@woosh/meep-engine 3.30.0 → 3.32.0

package/src/engine/graphics/particles/particular/engine/simulator/SimulationStepCurlNoiseVelocity.d.ts

@@ -1,5 +1,4 @@
 export class SimulationStepCurlNoiseVelocity extends AbstractSimulationStep {
-    time: number;
 }
 import { AbstractSimulationStep } from "./AbstractSimulationStep.js";
 //# sourceMappingURL=SimulationStepCurlNoiseVelocity.d.ts.map

package/src/engine/graphics/particles/particular/engine/simulator/SimulationStepCurlNoiseVelocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SimulationStepCurlNoiseVelocity.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/simulator/SimulationStepCurlNoiseVelocity.js"],"names":[],"mappings":"AAYA;IAEI,aAAS;CA4DZ;uCA1EsC,6BAA6B"}
+{"version":3,"file":"SimulationStepCurlNoiseVelocity.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/simulator/SimulationStepCurlNoiseVelocity.js"],"names":[],"mappings":"AAYA;CAmEC;uCA/EsC,6BAA6B"}

package/src/engine/graphics/particles/particular/engine/simulator/SimulationStepCurlNoiseVelocity.js

@@ -12,12 +12,17 @@ const noise = [];
 
 export class SimulationStepCurlNoiseVelocity extends AbstractSimulationStep {
 
-    time = 0;
-
     execute() {
-        this.time += this.timeDelta;
-
-        const time = this.time;
+        // The EMITTER's clock, not one of this step's own. `ParticularEngine`
+        // holds one instance of each step and reuses it for every emitter in
+        // the scene, so a clock here advanced once per emitter per frame: the
+        // noise field tracked wall time multiplied by however many emitters
+        // happened to be using this step, and the catch-up loop — up to ten
+        // calls for one waking emitter — jumped it for everyone else. Particle
+        // motion in one effect changed when an unrelated effect was spawned or
+        // despawned somewhere else in the scene, which is nothing the effect's
+        // own authoring can account for.
+        const time = this.emitter.simulated_time;
 
         const particles = this.particles;
 

package/src/engine/graphics/particles/particular/engine/simulator/update_parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update_parameters.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/simulator/update_parameters.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,kDALW,MAAM,iEAGN,MAAM,QA0BhB"}
+{"version":3,"file":"update_parameters.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/simulator/update_parameters.js"],"names":[],"mappings":"AAgBA;;;;;;GAMG;AACH,kDALW,MAAM,iEAGN,MAAM,QA0ChB"}

package/src/engine/graphics/particles/particular/engine/simulator/update_parameters.js

@@ -7,6 +7,13 @@ import {
 
 const v4 = new Float32Array(4);
 
+/**
+ * What a particle is coloured when its layer carries no Color track: opaque white, which is what the
+ * emitter parameter set defaults that track to.
+ * @type {number}
+ */
+const COLOR_DEFAULT = 255;
+
 /**
  *
  * @param {number} particle_index
@@ -23,6 +30,22 @@ export function update_parameters(particle_index, particles, layer, normalized_a
     if (param_color !== undefined) {
         param_color.track.sample(normalized_age, v4);
         particles.writeAttributeVector4(particle_index, PARTICLE_ATTRIBUTE_COLOR, v4[0] * 255, v4[1] * 255, v4[2] * 255, v4[3] * 255);
+    } else {
+        /*
+         The else the size branch below has always had.
+
+         This function is the only writer of the colour attribute for this pool, and without this a
+         layer authored with no Color track took whatever was already in the slot: on a fresh pool
+         the Uint8Array zeros, RGBA (0,0,0,0), so the layer rendered nothing at all, and on a
+         recycled slot the previous occupant colour — ParticlePool#create hands back the first
+         clear occupancy bit without clearing it — so the same layer flashed a different colour
+         depending on where it landed. Colour was the only one of the eleven attributes with no
+         unconditional writer.
+        */
+        particles.writeAttributeVector4(
+            particle_index, PARTICLE_ATTRIBUTE_COLOR,
+            COLOR_DEFAULT, COLOR_DEFAULT, COLOR_DEFAULT, COLOR_DEFAULT
+        );
     }
 
     // update size

package/src/engine/graphics/particles/particular/group/itemSizeFromAttributeType.d.ts

@@ -2,6 +2,6 @@
  *
  * @param {ParticleAttributeType} type
  */
-export function itemSizeFromAttributeType(type: ParticleAttributeType): 1 | 2 | 3 | 4;
+export function itemSizeFromAttributeType(type: ParticleAttributeType): 1 | 2 | 4 | 3;
 import { ParticleAttributeType } from "./ParticleAttributeType.js";
 //# sourceMappingURL=itemSizeFromAttributeType.d.ts.map

package/src/engine/graphics/sh3/path_tracer/texture/apply_texture_clamping_to_coordinate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply_texture_clamping_to_coordinate.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/texture/apply_texture_clamping_to_coordinate.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,+DAJW,eAAe,GAAC,MAAM,KACtB,MAAM,GACL,MAAM,CAcjB;gCA1B+B,gCAAgC"}
+{"version":3,"file":"apply_texture_clamping_to_coordinate.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/texture/apply_texture_clamping_to_coordinate.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,+DAJW,eAAe,GAAC,MAAM,KACtB,MAAM,GACL,MAAM,CAmBjB;gCA/B+B,gCAAgC"}

package/src/engine/graphics/sh3/path_tracer/texture/apply_texture_clamping_to_coordinate.js

@@ -17,7 +17,12 @@ export function apply_texture_clamping_to_coordinate(clamping, v) {
 
     switch (clamping) {
         case TextureWrapping.RepeatWrapping:
-            return v % 1;
+            // NOT `v % 1`: JavaScript's `%` is a remainder, which keeps the
+            // sign of the dividend, so every negative coordinate came out
+            // negative and `Sampler2D.sampleBilinearUV` clamped it to texel 0 —
+            // the whole negative half of a tiled surface collapsing onto the
+            // left/bottom edge texel instead of tiling.
+            return v - Math.floor(v);
         case TextureWrapping.ClampToEdgeWrapping:
             return clamp01(v);
         default:

package/src/engine/graphics/texture/atlas/ManagedTextureAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ManagedTextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/ManagedTextureAtlas.js"],"names":[],"mappings":"AAUA;IAoCI;;;;OAIG;IACH,wCAiCC;IAvBG,qCAAyD;IAEzD;;;OAGG;IACH,OAFU,YAAY,CAEJ;IA8DtB,cAIC;IAED;;;;OAIG;IACH,mBAFa,QAAQ,qBAAqB,CAAC,CAe1C;IAED;;;OAGG;IACH,aAFW,MAAM,QAIhB;;CACJ;oCA3JmC,0BAA0B;6BACjC,mBAAmB;0BAJtB,oCAAoC"}
+{"version":3,"file":"ManagedTextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/ManagedTextureAtlas.js"],"names":[],"mappings":"AAUA;IAoCI;;;;OAIG;IACH,wCAiCC;IAvBG,qCAAyD;IAEzD;;;OAGG;IACH,OAFU,YAAY,CAEJ;IAwEtB,cAcC;IAED;;;;OAIG;IACH,mBAFa,QAAQ,qBAAqB,CAAC,CAe1C;IAED;;;OAGG;IACH,aAFW,MAAM,QAIhB;;CACJ;oCA/KmC,0BAA0B;6BACjC,mBAAmB;0BAJtB,oCAAoC"}

package/src/engine/graphics/texture/atlas/ManagedTextureAtlas.js

@@ -91,11 +91,21 @@ export class ManagedAtlas {
     #remove_from_lookup(patch) {
         const urls = this.#patch_url_lookup.get(patch);
 
+        if (urls === undefined) {
+            return;
+        }
+
         for (let i = 0; i < urls.length; i++) {
             const url = urls[i];
 
             this.#url_patch_lookup.delete(url);
+
+            // and the memoized loader, which would otherwise hand this patch
+            // back for that url after the atlas has stopped holding it
+            this.#patch_loader.invalidate(url);
         }
+
+        this.#patch_url_lookup.delete(patch);
     }
 
     /**
@@ -131,6 +141,16 @@ export class ManagedAtlas {
         this.#references.clear();
         this.__caching_atlas.reset();
         this.#url_patch_lookup.clear();
+
+        // The loader is memoized with no time-to-live and no weigher, so
+        // nothing evicts it: a url loaded before the reset would miss the
+        // lookup cleared above, fall through to the loader and be handed back
+        // the SAME AtlasPatch — one the reset atlas no longer holds, still
+        // flagged Attached and Packed, with a uv rectangle pointing at the
+        // pre-reset packing, and never repainted. Everything drawn with it
+        // samples whatever now occupies that region.
+        this.#patch_loader.clear();
+        this.#patch_url_lookup.clear();
     }
 
     /**

package/src/engine/graphics/texture/atlas/TextureAtlas.d.ts

@@ -139,6 +139,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * Drops all the data
      */
     reset(): void;
+    #private;
 }
 import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
 import Vector2 from "../../../../core/geom/Vector2.js";

package/src/engine/graphics/texture/atlas/TextureAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IAcI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA6ChB;IA9DD;;;OAGG;IACH,gBAAa;IAEb;;;;OAIG;IACH,sBAAsB;IAgBlB;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAEhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAGL;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAqBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cAsCC;IAsDD;;OAEG;IACH,cASC;CACJ;qCArkBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}
+{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IAcI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA6ChB;IA9DD;;;OAGG;IACH,gBAAa;IAEb;;;;OAIG;IACH,sBAAsB;IAgBlB;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAEhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAGL;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAqBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cAsCC;IAyED;;OAEG;IACH,cASC;;CACJ;qCAxlBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}

package/src/engine/graphics/texture/atlas/TextureAtlas.js

@@ -532,11 +532,32 @@ export class TextureAtlas extends AbstractTextureAtlas {
      *
      */
     update() {
-        if (!this.__needsUpdate) {
-            //no update required
-            return;
+        if (this.__needsUpdate) {
+            this.#repack();
         }
 
+        /*
+         Painted unconditionally, because {@link paint} decides PER PATCH whether there is anything
+         to do: a patch that is not painted yet, or one whose source sampler moved on since it was
+         stencilled in.
+
+         That second test — last_painted_version against the sampler's version, the whole reason
+         {@link AtlasPatch} carries the field — was unreachable while this method returned early on
+         __needsUpdate, which is set only by add, erase and repack and never by a write to a source
+         sampler, since the atlas does not observe them. A live-updating patch kept its old pixels
+         until an unrelated add happened to set the flag, at which point every stale patch
+         repainted at once.
+
+         The cost when nothing has changed is a flag and two integers per patch, and paint moves
+         the atlas version only when it actually painted something.
+        */
+        this.paint();
+    }
+
+    /**
+     * Pack every patch, growing the canvas until they fit.
+     */
+    #repack() {
         // console.group("TextureAtlas.update");
         // console.time('TextureAtlas.update');
 
@@ -571,8 +592,6 @@ export class TextureAtlas extends AbstractTextureAtlas {
             }
         }
 
-        this.paint();
-
         this.__needsUpdate = false;
 
         // console.timeEnd('TextureAtlas.update');

package/src/engine/graphics/texture/sampler/Sampler2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/Sampler2D.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/Sampler2D.js"],"names":[],"mappings":"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"}

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -943,7 +943,20 @@ export class Sampler2D {
     }
 
     toJSON() {
-        const encoded = Base64.encode(this.data.buffer);
+        const data = this.data;
+
+        // This sampler's own bytes, not the whole buffer they sit in.
+        // `Sampler2DArray#layer` hands out a Sampler2D whose data is a
+        // `subarray` VIEW over a shared buffer, so for any layer past the first
+        // `byteOffset` is non-zero: encoding from byte zero wrote layer 0's
+        // pixels under layer 2's name, and encoded three layers' worth of them,
+        // which `fromJSON` then read back as a sampler three times the size its
+        // own dimensions describe. `hash()` already reads the view properly.
+        const encoded = Base64.encode(
+            isTypedArray(data)
+                ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+                : data.buffer
+        );
 
         return {
             height: this.height,

package/src/engine/graphics/texture/sampler/sampler2d_sub_copy_same_item_size.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_sub_copy_same_item_size.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_sub_copy_same_item_size.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,gNAoCC"}
+{"version":3,"file":"sampler2d_sub_copy_same_item_size.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_sub_copy_same_item_size.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,gNAiDC"}

package/src/engine/graphics/texture/sampler/sampler2d_sub_copy_same_item_size.js

@@ -1,5 +1,3 @@
-import { assert } from "../../../../core/assert.js";
-
 /**
  * Copy a patch from another sampler with the same itemSize
  * @param {Sampler2D} destination
@@ -15,14 +13,27 @@ export function sampler2d_sub_copy_same_item_size(destination, source, sourceX,
     const itemSize = destination.itemSize;
     const sItemSize = source.itemSize;
 
-    assert.equal(sItemSize, sItemSize, `source.itemSize(=${sItemSize}) != destination.itemSize(=${itemSize})`);
+    // An ordinary throw rather than an `assert`, because `assert.*` is stripped
+    // in a shipped build and the failure this guards is silent: nothing else
+    // checks it — the assert here compared `sItemSize` to itself, a tautology
+    // that could never fire, and `TextureAtlas.add` never looks at a sampler's
+    // itemSize either, while `paintPatch` is this function's only production
+    // caller. A 3-channel patch stencilled into the 4-channel atlas that is
+    // TextureAtlas's own default wrote texels shifted by a channel per column
+    // and read row 1 from the wrong offset, with no error anywhere.
+    if (sItemSize !== itemSize) {
+        throw new Error(`source.itemSize(=${sItemSize}) != destination.itemSize(=${itemSize})`);
+    }
 
     const _w = Math.min(width, source.width - sourceX, destination.width - destinationX);
     const _h = Math.min(height, source.height - sourceY, destination.height - destinationY);
 
 
     const dRowSize = itemSize * destination.width;
-    const sRowSize = itemSize * source.width;
+    // the SOURCE's own item size, which the guard above has just made equal —
+    // reading the source through the destination's was what made the mismatch
+    // corrupt rather than merely unsupported
+    const sRowSize = sItemSize * source.width;
 
     const sData = source.data;
     const dData = destination.data;
@@ -36,7 +47,7 @@ export function sampler2d_sub_copy_same_item_size(destination, source, sourceX,
         const sA = (y + sourceY) * sRowSize;
 
         const dOffset = dA + destinationX * itemSize;
-        const sOffset = sA + sourceX * itemSize;
+        const sOffset = sA + sourceX * sItemSize;
 
         for (i = 0; i < patchRowSize; i++) {
 

package/src/engine/graphics/texture/sampler/sampler2d_to_uint8_RGBA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_to_uint8_RGBA.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_uint8_RGBA.js"],"names":[],"mappings":"AAyCA;;;;GAIG;AACH,mFA6DC"}
+{"version":3,"file":"sampler2d_to_uint8_RGBA.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/sampler2d_to_uint8_RGBA.js"],"names":[],"mappings":"AA8DA;;;;GAIG;AACH,mFA6DC"}

package/src/engine/graphics/texture/sampler/sampler2d_to_uint8_RGBA.js

@@ -1,27 +1,48 @@
 import { sampler2d_channel_linear_transform } from "./sampler2d_channel_linear_transform.js";
 
+/** @type {number} */
+const UINT8_MAX = 255;
+
+/**
+ * The line that carries a source type's whole range onto `[0, 255]`:
+ * `gradient = 255 / (max - min)` and `intercept = -min * gradient`, so `min`
+ * lands on 0 and `max` on 255.
+ *
+ * The signed types used to carry `intercept = 127`, which is a half short on
+ * both sides: Int8's `[-128, 127]` mapped to `[-1, 254]`. The destination is a
+ * plain `Uint8Array`, not a clamped one, and the transform writes without a
+ * clamp, so that `-1` wrapped to 255 — the darkest representable value came
+ * out as the brightest byte and the extremes swapped.
+ *
+ * @param {number} min lowest representable source value
+ * @param {number} max highest
+ * @returns {{gradient: number, intercept: number}}
+ */
+function line_onto_uint8(min, max) {
+    const gradient = UINT8_MAX / (max - min);
+
+    return { gradient, intercept: -min * gradient };
+}
+
 function compute_gradient_and_intercept_uint8(ctor) {
     let gradient = 1;
     let intercept = 0;
 
     switch (ctor) {
         case Uint16Array:
-            gradient = 0.0038910505836575876;
+            ({ gradient, intercept } = line_onto_uint8(0, 65535));
             break;
         case Uint32Array:
-            gradient = 5.937181414556033e-8;
+            ({ gradient, intercept } = line_onto_uint8(0, 4294967295));
             break;
         case Int8Array:
-            gradient = 1;
-            intercept = 127;
+            ({ gradient, intercept } = line_onto_uint8(-128, 127));
             break
         case Int16Array:
-            gradient = 0.0038910505836575876;
-            intercept = 127;
+            ({ gradient, intercept } = line_onto_uint8(-32768, 32767));
             break;
         case Int32Array:
-            gradient = 5.937181414556033e-8;
-            intercept = 127;
+            ({ gradient, intercept } = line_onto_uint8(-2147483648, 2147483647));
             break
         case Float16Array:
         case Float32Array:

package/src/engine/graphics/texture/sampler/serialization/TextureBinaryBufferSerializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextureBinaryBufferSerializer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/serialization/TextureBinaryBufferSerializer.js"],"names":[],"mappings":"AAmFA;;;;GAIG;AACH,gEAFW,SAAS,QA4BnB;AAGD;;;;GAIG;AACH,0DAFa,SAAS,CAkBrB;0BApIyB,iBAAiB"}
+{"version":3,"file":"TextureBinaryBufferSerializer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/serialization/TextureBinaryBufferSerializer.js"],"names":[],"mappings":"AAmFA;;;;GAIG;AACH,gEAFW,SAAS,QAiCnB;AAGD;;;;GAIG;AACH,0DAFa,SAAS,CAkBrB;0BAzIyB,iBAAiB"}

package/src/engine/graphics/texture/sampler/serialization/TextureBinaryBufferSerializer.js

@@ -3,7 +3,7 @@ import { EndianType } from "../../../../../core/binary/EndianType.js";
 import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
 import { DataTypeByteSizes } from "../../../../../core/binary/type/DataTypeByteSizes.js";
 import { compute_binary_data_type_from_typed_array } from "../../../../../core/collection/array/typed/compute_binary_data_type_from_typed_array.js";
-import { DataTypeIndices } from "../../../../../core/binary/type/DataTypeIndices.js";
+import { dataTypeIndex, DataTypeIndices } from "../../../../../core/binary/type/DataTypeIndices.js";
 import { Sampler2D } from "../Sampler2D.js";
 
 
@@ -96,7 +96,7 @@ export function serializeTexture(buffer, texture) {
     buffer.writeUint8(itemSize); //number of channels
 
     const type = compute_binary_data_type_from_typed_array(texture.data);
-    buffer.writeUint8(DataTypeIndices[type]);
+    buffer.writeUint8(dataTypeIndex(type));
     const array = texture.data;
 
     const byteBuffer = array.buffer;
@@ -111,7 +111,12 @@ export function serializeTexture(buffer, texture) {
 
     const byteSize = width * height * itemSize * itemByteSize;
 
-    buffer.writeBytes(new Uint8Array(byteBuffer), 0, byteSize);
+    // From THIS texture's bytes, not from byte zero of the buffer they sit in.
+    // `Sampler2DArray#layer` hands out a Sampler2D whose data is a `subarray`
+    // view over a shared buffer, so for any layer past the first `byteOffset`
+    // is non-zero and this wrote layer 0's pixels under another layer's name.
+    // `Sampler2D.hash()` already reads the view properly.
+    buffer.writeBytes(new Uint8Array(byteBuffer, array.byteOffset, array.byteLength), 0, byteSize);
 }
 
 

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

@@ -1 +1 @@
-{"version":3,"file":"DebugDrawSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DebugDrawSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAkEI;;OAEG;IACH,sCAYC;IAhFD;;;;;;;;;OASG;IACH,YAFU,MAAM,CAED;IA8Cf;;;;OAIG;IACH,8BAEC;IAmBD,2CAMC;IAED,4CAYC;IAED;;OAEG;IACH,kCAwBC;;CACJ;AAED;;;;;;;;GAQG;AACH;IAYI;;OAEG;IACH,oBAFW,eAAe,EAMzB;IAED,yBAEC;;CACJ;uBApMsB,kBAAkB;iCADR,gDAAgD;gCAJjD,mDAAmD"}
+{"version":3,"file":"DebugDrawSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DebugDrawSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAkEI;;OAEG;IACH,sCAYC;IAhFD;;;;;;;;;OASG;IACH,YAFU,MAAM,CAED;IA8Cf;;;;OAIG;IACH,8BAEC;IAmBD,2CAMC;IAED,4CAYC;IAED;;OAEG;IACH,kCA4BC;;CACJ;AAED;;;;;;;;GAQG;AACH;IAYI;;OAEG;IACH,oBAFW,eAAe,EAMzB;IAED,yBAEC;;CACJ;uBAxMsB,kBAAkB;iCADR,gDAAgD;gCAJjD,mDAAmD"}

package/src/engine/graphics3/DebugDrawSystem.js

@@ -159,14 +159,18 @@ export class DebugDrawSystem extends System {
         }
 
         const scene = frame.get(SceneColor);
+        const view = frame.get(ViewTextures);
 
-        scene.color = this.#renderer.graph_draw({
+        const drawn = this.#renderer.graph_draw({
             graph: frame.graph,
             batch: this.#batch,
             color: scene.color,
-            depth: frame.get(ViewTextures).depth,
+            depth: view.depth,
             camera: frame.view.camera.buffer
         });
+
+        scene.color = drawn.color;
+        view.depth = drawn.depth;
     }
 }
 

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

@@ -68,10 +68,11 @@ export class DecalSystem extends System<any> {
     #private;
 }
 /**
- * **Late on the phase**, because a decal composites over surfaces that are already written — the
- * textured ground above all — rather than preceding them. That requirement used to be met by
- * putting a registration call above an `await` and writing a comment about it; here it is the
- * declaration below.
+ * **Late on the phase**, because a decal composites over surfaces that are already written rather
+ * than preceding them — anything another extension writes into the G-buffer at this phase. That
+ * requirement used to be met by putting a registration call above an `await` and writing a comment
+ * about it; here it is the declaration below. The textured ground no longer depends on it: terrain is
+ * shaded in the G-buffer pass itself, before any extension runs.
  */
 export class DecalExtension extends RenderExtension {
     /**

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":"AAyBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAwHI;;;OAGG;IACH,4DAeC;IA1ID,oDAAoC;IA8FpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAuBD,2CAUC;IAED,4CAYC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAmBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAiFD,6BAiDC;IAED;;OAEG;IACH,kCAkBC;;CACJ;AAED;;;;;GAKG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAxbsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD"}
+{"version":3,"file":"DecalSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DecalSystem.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAwHI;;;OAGG;IACH,4DAeC;IA1ID,oDAAoC;IA8FpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAuBD,2CAUC;IAED,4CAYC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAmBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAiFD,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"}

package/src/engine/graphics3/DecalSystem.js

@@ -417,10 +417,11 @@ export class DecalSystem extends System {
 }
 
 /**
- * **Late on the phase**, because a decal composites over surfaces that are already written — the
- * textured ground above all — rather than preceding them. That requirement used to be met by
- * putting a registration call above an `await` and writing a comment about it; here it is the
- * declaration below.
+ * **Late on the phase**, because a decal composites over surfaces that are already written rather
+ * than preceding them — anything another extension writes into the G-buffer at this phase. That
+ * requirement used to be met by putting a registration call above an `await` and writing a comment
+ * about it; here it is the declaration below. The textured ground no longer depends on it: terrain is
+ * shaded in the G-buffer pass itself, before any extension runs.
  */
 export class DecalExtension extends RenderExtension {
     name = "decals";

package/src/engine/graphics3/GraphicsEngine.d.ts

@@ -6,15 +6,17 @@
  * start(), stop(), render(), updateSize()}` — because that is what `Engine` needs in order to boot,
  * and because the facade is deliberately not allowed to grow past §4.2 (D14).
  *
- * **Three things have been let through since, each by name.** {@link add_extension} /
+ * **Four things have been let through since, each by name.** {@link add_extension} /
  * {@link remove_extension} (E9), because an extension has to survive the restart that replaces the
- * renderer holding it, and
- * {@link scene_context} (E13, D29), because the managers a system needs — animation above all —
- * hang off Shade's per-scene GPU state and there is no other door to them. Both take or return
- * something the caller already owns; neither hands out the renderer.
+ * renderer holding it; {@link add_transparency_channel} / {@link remove_transparency_channel}
+ * (2026-09-24, trails), the same door for the one thing an extension cannot do — draw inside the
+ * transparency pipeline rather than over it; and {@link scene_context} (E13, D29), because the
+ * managers a system needs — animation above all — hang off Shade's per-scene GPU state and there is
+ * no other door to them. All three take or return something the caller already owns; none hands out
+ * the renderer.
  *
- * {@link renderer} is the third, and much the widest: it hands the renderer straight out, so
- * everything the other two are shaped to avoid is reachable through it. It is an escape hatch for
+ * {@link renderer} is the fourth, and much the widest: it hands the renderer straight out, so
+ * everything the other three are shaped to avoid is reachable through it. It is an escape hatch for
  * callers that have no other route, not a migration target — the old engine's 44
  * `.renderer`/`getRenderer()` call sites are each still a migration item.
  *
@@ -210,6 +212,36 @@ export class GraphicsEngine {
      * @returns {boolean} whether it was registered
      */
     remove_extension(extension: RenderExtension): boolean;
+    /**
+     * Draw something inside the transparency pipeline rather than over it: an `AVBOITSideChannel`,
+     * whose fragments composite order-independently against the transparent meshes, the particles
+     * and every other channel. What {@link add_extension} cannot do — an extension at
+     * `AfterTransparency` records over transparency that is already resolved.
+     *
+     * **Registering does not require a device**, for the reason it does not for an extension: the
+     * channel is held here and handed to the renderer when one exists, and again after a restart.
+     * A channel that has nothing to add in a frame says so (`avboit_is_empty`) and costs that frame
+     * nothing. Under MBOIT, the legacy transparency mode, channels are not drawn.
+     *
+     * @param {AVBOITSideChannel} channel
+     * @returns {AVBOITSideChannel} `channel`, for handing back to {@link remove_transparency_channel}
+     */
+    add_transparency_channel(channel: AVBOITSideChannel): AVBOITSideChannel;
+    /**
+     * How many transparency channels are registered — for the leak gate a system states
+     * "start → stop → start leaves one" with, as {@link extension_count} is for extensions. Hands
+     * out nothing.
+     *
+     * @returns {number}
+     */
+    transparency_channel_count(): number;
+    /**
+     * Take a transparency channel back out. Identity is the object.
+     *
+     * @param {AVBOITSideChannel} channel
+     * @returns {boolean} whether it was registered
+     */
+    remove_transparency_channel(channel: AVBOITSideChannel): boolean;
     /**
      * Shade's GPU-side state for a scene the caller already owns — and with it the managers that
      * hang off it, of which the animation manager is the one Phase 4 needs.
@@ -364,6 +396,7 @@ export class GraphicsEngine {
 export type Vector3 = import("../../core/geom/Vector3.js").Vector3;
 export type FramePhase = import("../../shade/renderer/extension/FramePhase.js").FramePhase;
 export type RenderExtension = import("../../shade/renderer/extension/RenderExtension.js").RenderExtension;
+export type AVBOITSideChannel = import("../../shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js").AVBOITSideChannel;
 export type GPUSceneContext = import("../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext;
 export type ShadeTexture = import("../../shade/renderer/texture/ShadeTexture.js").ShadeTexture;
 export type Camera = import("../graphics/ecs/camera/Camera.js").Camera;

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

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IA0DG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAkDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CAoDnB;;CACJ;sBAjzBY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;8BAC3E,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAdrC,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}
+{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IAmEG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;OAaG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAqB7B;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAuDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CAoDnB;;CACJ;sBAt4BY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;gCAC3E,OAAO,mEAAmE,EAAE,iBAAiB;8BAC7F,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAfrC,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}