@woosh/meep-engine 3.60.9 → 3.61.1

package/CHANGELOG.md

@@ -2,6 +2,96 @@
 
 ## Unreleased
 
+### Network: a client ahead of the host repays its lead in seconds
+
+- **Fixed:** a client that found itself far ahead of the host — the host lost time: a hidden or hitched
+  host tab, a slow host — slowed down at the steering's 5% whatever the size of the lead, and so took
+  about twenty frames per frame of lead to get back: half a minute after a 90-frame host stall at 60 Hz,
+  longer than a session would wait after 180. All that time its input reached the host that much late,
+  host frames landed past its action log, and a Replay client abandoned its reconciliations. `TimeDilation`
+  still steers an error behind, and one up to `max_dilation × T` frames ahead (4.35 at the default
+  `frame_capacity`), at up to `max_dilation`, and still runs fast at no more than that; a larger lead is
+  now repaid in proportion to its size — the client runs at `1 / (1 + lead / T)` of its rate, never
+  reaching a standstill, with `T` e times the longest round trip it is built for, so that on any round
+  trip up to that one it overshoots no further than the steering does. At 60 Hz with the default
+  `frame_capacity` a 90-frame lead is gone in about 400 frames and a 180-frame one in about 550.
+- **Fixed:** `NetworkSession` ran a client at the host's latest factor however little that report still
+  held. A report names the newest frame of the client's the host has seen, a running maximum the host
+  never lowers, so after the client's clock went back — a `seek_to_frame` back, a re-sync from ahead — it
+  was about frames the client had left; the client now runs at its nominal rate until its clock passes
+  that frame again. With no report on the current binding, or none for longer than the longest round
+  trip, the latest one may still steer but repays nothing: held through a silent link, a repayment
+  would put the client behind the host and its input past the host's window.
+- **Breaking:** `TimeDilation` takes `max_round_trip_frames`, the longest round trip in frames its reports
+  can be, and it is required. `NetworkSession` and `ServerAuthoritativeClient` pass their `frame_capacity`.
+
+### Particles: a scene's pool holds 131,072 particles
+
+- **Changed:** `GPUParticleSystem`'s default capacity is 131,072 particles, up from 65,536. The
+  renderer creates every scene's particle system at the default, so this is every scene's pool: about
+  18 MB of GPU memory (the 128-byte record pool, the free and alive lists and the coherence scratch),
+  up from about 9 MB. Spawns past a full pool are dropped as before.
+
+### Network: an abandoned reconciliation leaves the world at the present
+
+- **Fixed:** a Replay client whose AUTH_STATE needed a frame its action log no longer holds — one
+  further ahead of the server's frame than `frame_capacity` covers, as after a host stall — undid its
+  frames from the present back to the missing one, up to `frame_capacity` of them, before it found the
+  gap. It then abandoned the reconciliation and predicted on from that past world: its own entities lost
+  those frames of input, and everything else the frames wrote went back as far. The client now checks
+  that the log holds every frame the rewind undoes before it undoes any, so an abandoned reconciliation
+  changes nothing; it is counted and announced as before. An error thrown during the rewind is no longer
+  counted as an abandoned reconciliation: it is thrown, as an error in the replay is.
+
+### Network: a client that comes back on a new connection applies each host frame once
+
+- **Fixed:** a client that lost its connection and came back applied host frames it had already
+  applied a second time, so a relative write to an entity it does not own (`x += 1`) ran twice and
+  nothing corrected it. For every step the host closed before it read the client's `RESUME_HELLO`, it
+  packed the new connection's action stream from the oldest frame its log held, and the client applied
+  that stream once the host answered: on top of its world when the host resumed it, and on top of the
+  host's snapshot when the host refused the claim and sent its world again. The host now sends a
+  returning connection none of its action stream until it has read the claim, and on a resume only the
+  frames after the one claimed.
+- **Fixed:** a client that lost its connection right after its join, before any frame after the
+  snapshot reached it, claimed frame 0, or the newest frame of the world it held before. While the
+  host's log still reached back to that frame, the frames up to the snapshot's were applied again; once
+  it did not, the host refused the claim and sent its whole world again. The client now claims the frame
+  its last join's snapshot was taken at, or the newest frame it has applied since.
+
+### Network: records for a frame the action log has moved past no longer erase a frame it holds
+
+- **Fixed:** a peer that received records for a frame `frame_capacity` or more behind its newest — a
+  client on a round trip of about `frame_capacity` ticks, after a host stall, or after a link that held
+  its packets and delivered them at once — logged them in that frame's ring slot, which held one of its
+  own recent frames, and erased it: its own input there, which its outbound stream then counted as
+  sent without sending it again, and the prior state a rewind across the frame needs, so a Replay
+  client abandoned every reconciliation that crossed it. Such records are now applied to the world as
+  they arrive and not logged, since no rewind reaches their frame, and the frame in the slot keeps its
+  records. `ActionLog.resume_frame` keeps nothing of a frame the log has moved past;
+  `Replicator.onFrameApplied` still fires for one, and the log does not hold it.
+
+### Network: a host record that arrives late lands in its frame on a Replay client
+
+- **Fixed:** a Replay client applied a host record that arrived for a frame it had already predicted
+  past to the world as it stood, frames later, and its later frames kept the prior state they had
+  captured before the record. A rewind for another entity's AUTH_STATE put that state back, undoing the
+  host's write until the entity's own next AUTH_STATE, or for good where none came (SW_316). When such a
+  record writes something a later record, or the server's correction of its own frame, holds prior
+  state of, the client now rewinds to the end of the record's frame, applies it there — before that
+  frame's corrections, as a replay writes a frame — and replays what it predicted since. A record about
+  nothing written since stays where it landed, with no rewind. The test is on what records write: one
+  that only reads predicted state keeps what it read at the present until a replay crosses its frame.
+- **Fixed:** a replay that meets an arrived record which throws no longer stops in that frame with the
+  world in the past: every frame is replayed, the record is left out of the one it threw in, that
+  frame's corrections are applied as ever, and the first error is thrown once the world is back at the
+  present.
+- **Added:** `ServerAuthoritativeClient` option `rebase_on_arrival` (default true; `NetworkSession`
+  passes it for `NetworkSessionReconcile.Replay` only, since Correct never rewinds) and counter
+  `rebase_count`; `RewindEngine.undo_frame_from(frame, from)`; `ActionLog.resume_frame_at(frame,
+  offset)`. `Replicator.onFrameApplied` passes a third argument, `records_start`: where in the action
+  log's frame the records it just applied begin.
+
 ### Probe clipmap GI: virtual geometry has cards, through a proxy
 
 - **Added:** `VirtualGeometry.get_proxy()`: an ordinary geometry standing in for a virtual one, cut from its

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.60.9",
+  "version": "3.61.1",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/ecs/EntityManager.d.ts

@@ -145,9 +145,9 @@ export class EntityManager {
      *
      * So this changes how often a fixed step runs, never how long one is: at `1.05` the simulation
      * advances 5% more steps per wall second, each one the same size, and the interpolation alpha
-     * stays a true fraction of a step. That is what network time dilation needs — a client running a
-     * few percent fast or slow to keep the host's input buffer at depth — and what dropping or
-     * doubling whole steps could not give it: a skipped step reads as a hitch.
+     * stays a true fraction of a step. That is what network time dilation needs — a client running
+     * fast or slow to keep the host's input buffer at depth — and what dropping or doubling whole steps
+     * could not give it: a skipped step reads as a hitch.
      *
      * Must be finite and non-negative. `0` freezes the fixed-step simulation (the `update` pass keeps
      * running).

package/src/engine/ecs/EntityManager.js

@@ -193,9 +193,9 @@ export class EntityManager {
      *
      * So this changes how often a fixed step runs, never how long one is: at `1.05` the simulation
      * advances 5% more steps per wall second, each one the same size, and the interpolation alpha
-     * stays a true fraction of a step. That is what network time dilation needs — a client running a
-     * few percent fast or slow to keep the host's input buffer at depth — and what dropping or
-     * doubling whole steps could not give it: a skipped step reads as a hitch.
+     * stays a true fraction of a step. That is what network time dilation needs — a client running
+     * fast or slow to keep the host's input buffer at depth — and what dropping or doubling whole steps
+     * could not give it: a skipped step reads as a hitch.
      *
      * Must be finite and non-negative. `0` freezes the fixed-step simulation (the `update` pass keeps
      * running).

package/src/engine/ecs/storage/populateEngineSerializationRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AA0MA;;;;;;;;GAQG;AACH,iGA0HC"}
+{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AA6MA;;;;;;;;GAQG;AACH,iGA2HC"}

package/src/engine/ecs/storage/populateEngineSerializationRegistry.js

@@ -85,6 +85,9 @@ import { DecalSerializationAdapter } from "../../graphics/ecs/decal/v2/DecalSeri
 import {
     DecalSerializationUpgrader_0_1
 } from "../../graphics/ecs/decal/v2/DecalSerializationUpgrader_0_1.js";
+import {
+    DecalSerializationUpgrader_1_2
+} from "../../graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.js";
 import Highlight from "../../graphics/ecs/highlight/Highlight.js";
 import { HighlightSerializationAdapter } from "../../graphics/ecs/highlight/HighlightSerializationAdapter.js";
 import {
@@ -291,6 +294,7 @@ export function populateEngineSerializationRegistry(registry) {
     registry.registerUpgrader(Tag.typeName, new TagSerializationUpgrader_0_1());
     registry.registerUpgrader(ParticipatingMedia.typeName, new ParticipatingMediaSerializationUpgrader_0_1());
     registry.registerUpgrader(Decal.typeName, new DecalSerializationUpgrader_0_1());
+    registry.registerUpgrader(Decal.typeName, new DecalSerializationUpgrader_1_2());
 
     registry.registerUpgrader(FogOfWar.typeName, new FogOfWarSerializationUpdater_0_1());
 

package/src/engine/graphics/ecs/decal/v2/Decal.d.ts

@@ -36,7 +36,12 @@ export class Decal {
      */
     uri: string;
     /**
-     * Base colour and coverage. Its alpha is what the decal's coverage means.
+     * Base colour and the decal's mask. Its alpha is the coverage every channel blends by, scaled
+     * per channel by the `*_weight` fields — so a decal that writes only normals still takes its
+     * shape from this alpha, with {@link albedo_weight} at zero.
+     *
+     * Optional: with none, the mask is one across the whole projection volume and the colour is
+     * {@link color}.
      * @type {string}
      */
     uri_albedo: string;
@@ -87,6 +92,35 @@ export class Decal {
      * @type {number}
      */
     emissive_intensity: number;
+    /**
+     * How much of this decal's albedo is written, in [0, 1]. It scales the coverage this one channel
+     * blends by: zero leaves the surface's albedo exactly as it was, one writes it at the full
+     * coverage of the mask. Carried to the GPU as a 16-bit unorm.
+     * @type {number}
+     */
+    albedo_weight: number;
+    /**
+     * How much of this decal's normal is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    normal_weight: number;
+    /**
+     * How much of this decal's roughness is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    roughness_weight: number;
+    /**
+     * How much of this decal's metalness is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    metalness_weight: number;
+    /**
+     * How much of this decal's emission is written, in [0, 1]. As {@link albedo_weight} — and since a
+     * decal's emission replaces what is beneath it rather than adding to it, zero is also what keeps
+     * an emitting surface emitting under a decal.
+     * @type {number}
+     */
+    emissive_weight: number;
     /**
      * Internal transient reference to loaded asset
      * @type {Sampler2D|null}
@@ -119,8 +153,13 @@ export class Decal {
         metalness: number;
         emissive_color: string;
         emissive_intensity: number;
+        albedo_weight: number;
+        normal_weight: number;
+        roughness_weight: number;
+        metalness_weight: number;
+        emissive_weight: number;
     };
-    fromJSON({ uri, uri_albedo, uri_normal, uri_orm, uri_emissive, priority, color, roughness, metalness, emissive_color, emissive_intensity }: {
+    fromJSON({ uri, uri_albedo, uri_normal, uri_orm, uri_emissive, priority, color, roughness, metalness, emissive_color, emissive_intensity, albedo_weight, normal_weight, roughness_weight, metalness_weight, emissive_weight }: {
         uri?: string;
         uri_albedo?: string;
         uri_normal?: string;
@@ -132,6 +171,11 @@ export class Decal {
         metalness?: number;
         emissive_color?: string;
         emissive_intensity?: number;
+        albedo_weight?: number;
+        normal_weight?: number;
+        roughness_weight?: number;
+        metalness_weight?: number;
+        emissive_weight?: number;
     }): void;
     hash(): number;
     /**

package/src/engine/graphics/ecs/decal/v2/Decal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Decal.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/Decal.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAmGI,+BAMC;IAvGD;;;;;;;OAOG;IACH,KAFU,MAAM,CAEP;IAET;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,cAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,OAFU,KAAK,CAEe;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,gBAFU,KAAK,CAEwB;IAEvC;;;;OAIG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,yBAAwB;IAExB;;;;OAIG;IACH,qBAAoB;IAEpB;;;;;;OAMG;IACH,yBAEC;IAUD;;;;;;;;;;;;MAcC;IAED;;;;;;;;;;;;aA+CC;IAED,eAkBC;IAED;;;;OAIG;IACH,cAHW,KAAK,GACH,OAAO,CAenB;CACJ;;;;sBApPqB,oCAAoC"}
+{"version":3,"file":"Decal.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/Decal.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA0II,+BAMC;IA9ID;;;;;;;OAOG;IACH,KAFU,MAAM,CAEP;IAET;;;;;;;;OAQG;IACH,YAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,cAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,OAFU,KAAK,CAEe;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,gBAFU,KAAK,CAEwB;IAEvC;;;;OAIG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;;;OAKG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,yBAAwB;IAExB;;;;OAIG;IACH,qBAAoB;IAEpB;;;;;;OAMG;IACH,yBAEC;IAUD;;;;;;;;;;;;;;;;;MAmBC;IAED;;;;;;;;;;;;;;;;;aA+DC;IAED,eAsBC;IAED;;;;OAIG;IACH,cAHW,KAAK,GACH,OAAO,CAoBnB;CACJ;;;;sBAzTqB,oCAAoC"}

package/src/engine/graphics/ecs/decal/v2/Decal.js

@@ -44,7 +44,12 @@ export class Decal {
     uri = "";
 
     /**
-     * Base colour and coverage. Its alpha is what the decal's coverage means.
+     * Base colour and the decal's mask. Its alpha is the coverage every channel blends by, scaled
+     * per channel by the `*_weight` fields — so a decal that writes only normals still takes its
+     * shape from this alpha, with {@link albedo_weight} at zero.
+     *
+     * Optional: with none, the mask is one across the whole projection volume and the colour is
+     * {@link color}.
      * @type {string}
      */
     uri_albedo = "";
@@ -105,6 +110,40 @@ export class Decal {
      */
     emissive_intensity = 0;
 
+    /**
+     * How much of this decal's albedo is written, in [0, 1]. It scales the coverage this one channel
+     * blends by: zero leaves the surface's albedo exactly as it was, one writes it at the full
+     * coverage of the mask. Carried to the GPU as a 16-bit unorm.
+     * @type {number}
+     */
+    albedo_weight = 1;
+
+    /**
+     * How much of this decal's normal is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    normal_weight = 1;
+
+    /**
+     * How much of this decal's roughness is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    roughness_weight = 1;
+
+    /**
+     * How much of this decal's metalness is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    metalness_weight = 1;
+
+    /**
+     * How much of this decal's emission is written, in [0, 1]. As {@link albedo_weight} — and since a
+     * decal's emission replaces what is beneath it rather than adding to it, zero is also what keeps
+     * an emitting surface emitting under a decal.
+     * @type {number}
+     */
+    emissive_weight = 1;
+
     /**
      * Internal transient reference to loaded asset
      * @type {Sampler2D|null}
@@ -150,7 +189,12 @@ export class Decal {
             roughness: this.roughness,
             metalness: this.metalness,
             emissive_color: this.emissive_color.toCssRGBAString(),
-            emissive_intensity: this.emissive_intensity
+            emissive_intensity: this.emissive_intensity,
+            albedo_weight: this.albedo_weight,
+            normal_weight: this.normal_weight,
+            roughness_weight: this.roughness_weight,
+            metalness_weight: this.metalness_weight,
+            emissive_weight: this.emissive_weight
         };
     }
 
@@ -165,7 +209,12 @@ export class Decal {
                  roughness = 1,
                  metalness = 0,
                  emissive_color = '#FFFFFF',
-                 emissive_intensity = 0
+                 emissive_intensity = 0,
+                 albedo_weight = 1,
+                 normal_weight = 1,
+                 roughness_weight = 1,
+                 metalness_weight = 1,
+                 emissive_weight = 1
              }) {
 
         assert.isString(uri, 'uri');
@@ -178,6 +227,11 @@ export class Decal {
         assert.isNumber(roughness, 'roughness');
         assert.isNumber(metalness, 'metalness');
         assert.isNumber(emissive_intensity, 'emissive_intensity');
+        assert.isNumber(albedo_weight, 'albedo_weight');
+        assert.isNumber(normal_weight, 'normal_weight');
+        assert.isNumber(roughness_weight, 'roughness_weight');
+        assert.isNumber(metalness_weight, 'metalness_weight');
+        assert.isNumber(emissive_weight, 'emissive_weight');
 
         const albedo_before = this.albedo_uri;
 
@@ -199,12 +253,18 @@ export class Decal {
         this.metalness = metalness;
         this.emissive_intensity = emissive_intensity;
 
+        this.albedo_weight = albedo_weight;
+        this.normal_weight = normal_weight;
+        this.roughness_weight = roughness_weight;
+        this.metalness_weight = metalness_weight;
+        this.emissive_weight = emissive_weight;
+
         this.color.parse(color);
         this.emissive_color.parse(emissive_color);
     }
 
     hash() {
-        return hash_mix3(
+        return hash_mix2(hash_mix3(
             computeStringHash(this.uri) ^ this.color.hash(),
             hash_mix2(
                 hash_mix2(
@@ -220,7 +280,11 @@ export class Decal {
                 hash_mix2(computeHashFloat(this.roughness), computeHashFloat(this.metalness)),
                 hash_mix2(this.emissive_color.hash(), computeHashFloat(this.emissive_intensity))
             )
-        );
+        ), hash_mix3(
+            hash_mix2(computeHashFloat(this.albedo_weight), computeHashFloat(this.normal_weight)),
+            hash_mix2(computeHashFloat(this.roughness_weight), computeHashFloat(this.metalness_weight)),
+            computeHashFloat(this.emissive_weight)
+        ));
     }
 
     /**
@@ -240,6 +304,11 @@ export class Decal {
             && this.metalness === other.metalness
             && this.emissive_color.equals(other.emissive_color)
             && this.emissive_intensity === other.emissive_intensity
+            && this.albedo_weight === other.albedo_weight
+            && this.normal_weight === other.normal_weight
+            && this.roughness_weight === other.roughness_weight
+            && this.metalness_weight === other.metalness_weight
+            && this.emissive_weight === other.emissive_weight
             ;
     }
 }

package/src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DecalSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,oBAAc;IAGd;;;;OAIG;IACH,uCAFW,KAAK,QAmBf;IAED;;;;OAIG;IACH,yCAFW,KAAK,QAmBf;CACJ;gDAvD+C,mEAAmE;sBAC7F,YAAY"}
+{"version":3,"file":"DecalSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,oBAAc;IAGd;;;;OAIG;IACH,uCAFW,KAAK,QAyBf;IAED;;;;OAIG;IACH,yCAFW,KAAK,QAyBf;CACJ;gDAnE+C,mEAAmE;sBAC7F,YAAY"}

package/src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.js

@@ -4,7 +4,7 @@ import { Decal } from "./Decal.js";
 export class DecalSerializationAdapter extends BinaryClassSerializationAdapter {
 
     klass = Decal;
-    version = 1;
+    version = 2;
 
     /**
      *
@@ -28,6 +28,12 @@ export class DecalSerializationAdapter extends BinaryClassSerializationAdapter {
         buffer.writeFloat32Array(value.emissive_color, 0, 4);
         buffer.writeFloat32(value.emissive_intensity);
 
+        buffer.writeFloat32(value.albedo_weight);
+        buffer.writeFloat32(value.normal_weight);
+        buffer.writeFloat32(value.roughness_weight);
+        buffer.writeFloat32(value.metalness_weight);
+        buffer.writeFloat32(value.emissive_weight);
+
     }
 
     /**
@@ -52,5 +58,11 @@ export class DecalSerializationAdapter extends BinaryClassSerializationAdapter {
         buffer.readFloat32Array(value.emissive_color, 0, 4);
         value.emissive_intensity = buffer.readFloat32();
 
+        value.albedo_weight = buffer.readFloat32();
+        value.normal_weight = buffer.readFloat32();
+        value.roughness_weight = buffer.readFloat32();
+        value.metalness_weight = buffer.readFloat32();
+        value.emissive_weight = buffer.readFloat32();
+
     }
 }

package/src/engine/graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A v1 decal wrote every channel it carries. v2 adds a weight per channel, and a v1 decal comes
+ * back with all five at one — which is what writing every channel means.
+ */
+export class DecalSerializationUpgrader_1_2 extends BinaryClassUpgrader {
+    upgrade(source: any, target: any): void;
+}
+import { BinaryClassUpgrader } from "../../../../ecs/storage/binary/BinaryClassUpgrader.js";
+//# sourceMappingURL=DecalSerializationUpgrader_1_2.d.ts.map

package/src/engine/graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecalSerializationUpgrader_1_2.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAII,wCAyBC;CACJ;oCApCmC,uDAAuD"}

package/src/engine/graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.js

@@ -0,0 +1,37 @@
+import { BinaryClassUpgrader } from "../../../../ecs/storage/binary/BinaryClassUpgrader.js";
+
+/**
+ * A v1 decal wrote every channel it carries. v2 adds a weight per channel, and a v1 decal comes
+ * back with all five at one — which is what writing every channel means.
+ */
+export class DecalSerializationUpgrader_1_2 extends BinaryClassUpgrader {
+    __startVersion = 1;
+    __targetVersion = 2;
+
+    upgrade(source, target) {
+        // uri, uri_albedo, uri_normal, uri_orm, uri_emissive
+        for (let i = 0; i < 5; i++) {
+            target.writeUTF8String(source.readUTF8String());
+        }
+
+        const scratch = [0, 0, 0, 0];
+
+        target.writeFloat32(source.readFloat32()); // priority
+
+        source.readFloat32Array(scratch, 0, 4);
+        target.writeFloat32Array(scratch, 0, 4); // color
+
+        target.writeFloat32(source.readFloat32()); // roughness
+        target.writeFloat32(source.readFloat32()); // metalness
+
+        source.readFloat32Array(scratch, 0, 4);
+        target.writeFloat32Array(scratch, 0, 4); // emissive_color
+
+        target.writeFloat32(source.readFloat32()); // emissive_intensity
+
+        // albedo, normal, roughness, metalness, emissive weights
+        for (let i = 0; i < 5; i++) {
+            target.writeFloat32(1);
+        }
+    }
+}

package/src/engine/graphics3/DecalSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DecalSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DecalSystem.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAmHI;;;OAGG;IACH,4DAkCC;IAxJD,oDAAoC;IAyFpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAoDD,2CAUC;IAED,4CAgBC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAmBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAqDD,6BAiDC;IAED;;OAEG;IACH,kCAkBC;;CACJ;AAED;;;;;;GAMG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAzbsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD"}
+{"version":3,"file":"DecalSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DecalSystem.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;GAgBG;AACH;IA+HI;;;OAGG;IACH,4DAkCC;IApKD,oDAAoC;IAqGpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAoDD,2CAUC;IAED,4CAgBC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAoBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAoDD,6BAmDC;IAED;;OAEG;IACH,kCAkBC;;CACJ;AAED;;;;;;GAMG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAxcsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD"}