@woosh/meep-engine 2.169.1 → 2.169.2

package/src/engine/animation/curve/draw/position_curve_to_canvas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"position_curve_to_canvas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/position_curve_to_canvas.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,+CAPW,OAAO,wBAEP,OAAO,KACP,MAAM,KACN,MAAM,GACL,OAAO,CAelB;oBAxBmB,kCAAkC"}
+{"version":3,"file":"position_curve_to_canvas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/position_curve_to_canvas.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,+CAPW,OAAO,wBAEP,OAAO,KACP,MAAM,KACN,MAAM,GACL,OAAO,CAOlB;oBArBmB,kCAAkC"}

package/src/engine/animation/curve/draw/position_curve_to_canvas.js

@@ -1,25 +1,22 @@
-import Vector2 from "../../../../core/geom/Vector2.js";
-
-/**
- *
- * @param {Vector2} size
- * @param {AABB2} frame
- * @param {Vector2} margin
- * @param {number} x
- * @param {number} y
- * @return {Vector2}
- */
-export function position_curve_to_canvas(size, frame, margin, x, y) {
-    const width = size.x;
-    const height = size.y;
-
-    const curve_width = frame.width;
-    const curve_width_multiplier = curve_width > 0 ? 1 / curve_width : 0;
-    const u = (x - frame.x0) * curve_width_multiplier;
-
-    const curve_height = frame.height;
-    const curve_height_multiplier = curve_height > 0 ? 1 / curve_height : 0;
-    const v = 1 - (y - frame.y0) * curve_height_multiplier;
-
-    return new Vector2(margin.x + (u * (width - margin.x * 2)), margin.y + v * (height - margin.y * 2));
-}
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { curve_point_to_canvas } from "./curve_point_to_canvas.js";
+
+const scratch = new Float64Array(2);
+
+/**
+ * Allocating convenience wrapper around {@link curve_point_to_canvas}; use that directly on any
+ * path that runs per-pixel or per-frame.
+ *
+ * @param {Vector2} size
+ * @param {AABB2} frame
+ * @param {Vector2} margin
+ * @param {number} x
+ * @param {number} y
+ * @return {Vector2}
+ */
+export function position_curve_to_canvas(size, frame, margin, x, y) {
+
+    curve_point_to_canvas(scratch, 0, size, frame, margin, x, y);
+
+    return new Vector2(scratch[0], scratch[1]);
+}

package/src/engine/animation/curve/editor/canvas2dDrawWorldAxisLabels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvas2dDrawWorldAxisLabels.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/canvas2dDrawWorldAxisLabels.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,+IAVW,wBAAwB,QAwDlC"}
+{"version":3,"file":"canvas2dDrawWorldAxisLabels.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/canvas2dDrawWorldAxisLabels.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,+IAVW,wBAAwB,QAyDlC"}

package/src/engine/animation/curve/editor/canvas2dDrawWorldAxisLabels.js

@@ -40,8 +40,9 @@ export function canvas2dDrawWorldAxisLabels({
     const direction_x = delta_x / distance;
     const direction_y = delta_y / distance;
 
-    // number of marks
-    const mark_count = Math.ceil(distance / spacing);
+    // largest multiple of `spacing` that still lands on or before the axis end;
+    // using ceil would place a final tick past position_1 with an extrapolated value
+    const mark_count = Math.floor(distance / spacing);
 
     for (let i = 0; i <= mark_count; i++) {
         const offset = spacing * i;

package/src/engine/animation/curve/editor/canvas2dPlotCurvePoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvas2dPlotCurvePoints.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/canvas2dPlotCurvePoints.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2FAPW,wBAAwB,QAgElC"}
+{"version":3,"file":"canvas2dPlotCurvePoints.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/canvas2dPlotCurvePoints.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,2FAPW,wBAAwB,QA4DlC"}

package/src/engine/animation/curve/editor/canvas2dPlotCurvePoints.js

@@ -1,4 +1,8 @@
-import {Vector2} from "three";
+import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
+import { curve_point_to_canvas } from "../draw/curve_point_to_canvas.js";
+
+const scratch_frame = new AABB2();
+const scratch_point = new Float64Array(2);
 
 /**
  *
@@ -28,18 +32,15 @@ export function canvas2dPlotCurvePoints({
     const firstKeyTime = keyframes[0].time;
     const lastKeyTime = keyframes[keyframes.length - 1].time;
 
-    const axisSize = new Vector2(
-        dimension.x - offset.x * 2,
-        dimension.y - offset.y * 2
-    );
+    // curve->canvas mapping is shared with the editor's hit-testing and marker placement,
+    // see `draw/curve_point_to_canvas.js`
+    scratch_frame.set(minX, minY, maxX, maxY);
 
-    const timeRange = maxX - minX
-    const valueRange = maxY - minY
+    const axisSizeX = dimension.x - offset.x * 2;
 
-    const inverseTimeRange = timeRange !== 0 ? 1 / timeRange : 0;
-    const inverseValueRange = valueRange !== 0 ? 1 / valueRange : 0;
+    const timeRange = maxX - minX
 
-    const pixelCountX = Math.max(axisSize.x - 1 , 1);
+    const pixelCountX = Math.max(axisSizeX - 1, 1);
     const timeStep = timeRange * (1 / pixelCountX)
 
     ctx.beginPath();
@@ -52,11 +53,10 @@ export function canvas2dPlotCurvePoints({
 
         const value = curve.evaluate(t);
 
-        const normY = (value - minY) * inverseValueRange
-        const normX = (t - minX) * inverseTimeRange
+        curve_point_to_canvas(scratch_point, 0, dimension, scratch_frame, offset, t, value);
 
-        const y = (1 - normY) * axisSize.y + offset.y
-        const x = normX * axisSize.x + offset.x
+        const x = scratch_point[0];
+        const y = scratch_point[1];
 
         if (x >= -offScreenMargin && !started) {
             ctx.moveTo(x, y);

package/src/engine/animation/removeEntityWithMeshParticlesEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeEntityWithMeshParticlesEffect.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/removeEntityWithMeshParticlesEffect.js"],"names":[],"mappings":"AA6IA;;;;;;;GAOG;AACH,+GAFa,QAAQ,GAAG,CAAC,CAuDxB"}
+{"version":3,"file":"removeEntityWithMeshParticlesEffect.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/removeEntityWithMeshParticlesEffect.js"],"names":[],"mappings":"AA8IA;;;;;;;GAOG;AACH,+GAFa,QAAQ,GAAG,CAAC,CA2DxB"}

package/src/engine/animation/removeEntityWithMeshParticlesEffect.js

@@ -2,6 +2,7 @@ import Mesh from "../graphics/ecs/mesh/Mesh.js";
 import {
     distributeParticlesOnObject3D
 } from "../graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js";
+import { SerializationMetadata } from "../ecs/components/SerializationMetadata.js";
 import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
 import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
 import Trail2D from "../graphics/ecs/trail2d/Trail2D.js";
@@ -173,6 +174,10 @@ export function removeEntityWithMeshParticlesEffect(
     //prevent further interactions
     removeComponentsExcept(ecd, entity, [Mesh, ParticleEmitter, Trail2D, Transform]);
 
+    //make entity volatile so it does not end up in game saves. The entity is mid-death here;
+    //without this a save taken during the effect would restore a corpse that never finishes dying.
+    ecd.addComponentToEntity(entity, SerializationMetadata.Transient);
+
     /**
      *
      * @type {Transform}

package/src/engine/asset/loaders/GLTFAssetLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GLTFAssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/GLTFAssetLoader.js"],"names":[],"mappings":"AAuIA;IAEI,cAyDC;IArDG,2BAAsC;IAatC,mBAAoB;IAEpB;;;;;OAKG;IACH,gCAAoC;IAEpC;;;;;OAKG;IACH,+BAAmC;IAEnC;;;;OAIG;IACH,yBAIE;IAGF;;;;OAIG;IACH,wBAIE;IAGN;;;OAGG;IACH,uBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oCAEC;IAED;;;OAGG;IACH,iCAEC;IAED,oDAOC;IAED;;;;OAIG;IACH,gCAsCC;IAGD;;;;OAIG;IACH,sBAiCC;IAED;;;;;OAKG;IACH,uBAgHC;IAED,6EAWC;CACJ;4BA1a2B,kBAAkB;4BAnBlB,2CAA2C;2BAC5C,0CAA0C"}
+{"version":3,"file":"GLTFAssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/GLTFAssetLoader.js"],"names":[],"mappings":"AA6GA;IAEI,cAyDC;IArDG,2BAAsC;IAatC,mBAAoB;IAEpB;;;;;OAKG;IACH,gCAAoC;IAEpC;;;;;OAKG;IACH,+BAAmC;IAEnC;;;;OAIG;IACH,yBAIE;IAGF;;;;OAIG;IACH,wBAIE;IAGN;;;OAGG;IACH,uBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oCAEC;IAED;;;OAGG;IACH,iCAEC;IAED,oDAOC;IAED;;;;OAIG;IACH,gCAsCC;IAGD;;;;OAIG;IACH,sBAiCC;IAED;;;;;OAKG;IACH,uBAgHC;IAED,6EAWC;CACJ;4BAhZ2B,kBAAkB;4BAnBlB,2CAA2C;2BAC5C,0CAA0C"}

package/src/engine/asset/loaders/GLTFAssetLoader.js

@@ -27,39 +27,33 @@ import { isMesh } from "./gltf/isMesh.js";
 import { computeTextureEquality } from "./material/computeTextureEquality.js";
 import { computeTextureHash } from "./material/computeTextureHash.js";
 import { StaticMaterialCache } from "./material/StaticMaterialCache.js";
-import { TextureAttachmentsByMaterialType } from "./material/TextureAttachmensByMaterialType.js";
+import { traverseMaterialTextures } from "./material/traverseMaterialTextures.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
 
 /**
- *
+ * @this {HashSet<Texture>}
+ * @param {Texture} texture
+ * @param {TextureAttachment} attachment
  * @param {THREE.Material} material
- * @param {HashSet<Texture>} texture_cache
  */
-function replace_material_textures_from_cache(material, texture_cache) {
-    const attachments = TextureAttachmentsByMaterialType[material.type];
+function replace_texture_attachment_from_cache(texture, attachment, material) {
+    const cached = this.ensure(texture);
 
-    if (attachments === undefined) {
-        // unsupported material
-        return;
+    if (cached !== texture) {
+        // got an existing cached texture, write that instead
+        attachment.write(material, cached);
     }
+}
 
-    const attachment_count = attachments.length;
-
-    for (let i = 0; i < attachment_count; i++) {
-        const attachment = attachments[i];
-
-        const texture = attachment.read(material);
-        if (texture !== undefined && texture !== null) {
-            const cached = texture_cache.ensure(texture);
-
-            if (cached !== texture) {
-                // got an existing cached texture, write that instead
-                attachment.write(material, cached);
-            }
-        }
-    }
+/**
+ *
+ * @param {THREE.Material} material
+ * @param {HashSet<Texture>} texture_cache
+ */
+function replace_material_textures_from_cache(material, texture_cache) {
+    traverseMaterialTextures(material, replace_texture_attachment_from_cache, texture_cache);
 }
 
 /**
@@ -85,39 +79,19 @@ function transferRootTransform(root, result) {
     return true;
 }
 
+/**
+ * @param {Texture} texture
+ */
+function enable_anisotropic_filtering(texture) {
+    texture.anisotropy = 8;
+}
+
 /**
  *
  * @param {Material} material
  */
 function configureTextures(material) {
-
-    //patch textures
-    const materialType = material.type;
-
-    /**
-     *
-     * @type {TextureAttachment[]}
-     */
-    const attachments = TextureAttachmentsByMaterialType[materialType];
-
-
-    if (attachments !== undefined) {
-        const n = attachments.length;
-
-        for (let i = 0; i < n; i++) {
-            const attachment = attachments[i];
-
-            const texture = attachment.read(material);
-
-            if (texture === null || texture === undefined) {
-                continue;
-            }
-
-            //enable anisotropic filtering
-            texture.anisotropy = 8;
-        }
-
-    }
+    traverseMaterialTextures(material, enable_anisotropic_filtering);
 }
 
 /**

package/src/engine/asset/loaders/material/StaticMaterialCache.d.ts

@@ -6,9 +6,9 @@ export class StaticMaterialCache {
     materialCache: Cache<Material, Material>;
     /**
      *
-     * @type {Cache<Texture, Texture>}
+     * @returns {Cache<Texture, Texture>}
      */
-    textureCache: Cache<Texture, Texture>;
+    get textureCache(): Cache<Texture, Texture>;
     /**
      *
      * @param {Material} material
@@ -22,6 +22,7 @@ export class StaticMaterialCache {
      * @returns {boolean}
      */
     validate(error_consumer: (arg0: string) => any, thisArg?: any): boolean;
+    #private;
 }
 export namespace StaticMaterialCache {
     let Global: StaticMaterialCache;

package/src/engine/asset/loaders/material/StaticMaterialCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticMaterialCache.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/StaticMaterialCache.js"],"names":[],"mappings":"AASA;IAGQ;;;OAGG;IACH,eAFU,yBAAyB,CAMjC;IAEF;;;OAGG;IACH,cAFU,uBAAuB,CAM/B;IAGN;;;;OAIG;IACH,sCA2DC;IAED;;;;;OAKG;IACH,gCAJoB,MAAM,0BAEb,OAAO,CAYnB;CACJ;;gBAKS,mBAAmB;;sBAzHP,iCAAiC"}
+{"version":3,"file":"StaticMaterialCache.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/StaticMaterialCache.js"],"names":[],"mappings":"AAMA;IAUQ;;;OAGG;IACH,eAFU,yBAAyB,CAMjC;IAGN;;;OAGG;IACH,4CAEC;IAED;;;;OAIG;IACH,sCAkBC;IAED;;;;;OAKG;IACH,gCAJoB,MAAM,0BAEb,OAAO,CAYnB;;CACJ;;gBAKS,mBAAmB;;sBAlFP,iCAAiC"}

package/src/engine/asset/loaders/material/StaticMaterialCache.js

@@ -1,13 +1,17 @@
 import { Cache } from "../../../../core/cache/Cache.js";
-import { TextureAttachment } from "./TextureAttachment.js";
-import { TextureAttachmentsByMaterialType } from "./TextureAttachmensByMaterialType.js";
-import { computeTextureHash } from "./computeTextureHash.js";
-import { computeTextureEquality } from "./computeTextureEquality.js";
 import { computeMaterialHash } from "./computeMaterialHash.js";
 import { computeMaterialEquality } from "./computeMaterialEquality.js";
+import { TextureCoalescer } from "./TextureCoalescer.js";
 
 
 export class StaticMaterialCache {
+
+    /**
+     *
+     * @type {TextureCoalescer}
+     */
+    #textures = new TextureCoalescer();
+
     constructor() {
 
         /**
@@ -19,16 +23,14 @@ export class StaticMaterialCache {
             keyHashFunction: computeMaterialHash,
             keyEqualityFunction: computeMaterialEquality
         });
+    }
 
-        /**
-         *
-         * @type {Cache<Texture, Texture>}
-         */
-        this.textureCache = new Cache({
-            maxWeight: 1000,
-            keyHashFunction: computeTextureHash,
-            keyEqualityFunction: computeTextureEquality
-        });
+    /**
+     *
+     * @returns {Cache<Texture, Texture>}
+     */
+    get textureCache() {
+        return this.#textures.cache;
     }
 
     /**
@@ -45,48 +47,7 @@ export class StaticMaterialCache {
             return existingMaterial;
         }
 
-        const textureCache = this.textureCache;
-
-        //patch textures
-        const materialType = material.type;
-
-        /**
-         *
-         * @type {TextureAttachment[]}
-         */
-        const attachments = TextureAttachmentsByMaterialType[materialType];
-
-
-        if (attachments !== undefined) {
-            const attachment_count = attachments.length;
-
-            for (let i = 0; i < attachment_count; i++) {
-                const attachment = attachments[i];
-
-                const texture = attachment.read(material);
-
-                if (texture === null || texture === undefined) {
-                    continue;
-                }
-
-                //check cache
-                const existingTexture = textureCache.get(texture);
-
-                if (existingTexture !== null) {
-
-                    //console.log('Re-using texture', existingTexture);
-
-                    attachment.write(material, existingTexture);
-
-                } else {
-
-                    //texture was not in cache, cache it
-                    textureCache.put(texture, texture);
-
-                }
-
-            }
-        }
+        this.#textures.coalesce(material);
 
         //doesn't exist, add
         this.materialCache.put(material, material);

package/src/engine/asset/loaders/material/TextureCoalescer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * De-duplicates the textures attached to a material against a cache of textures seen so far.
+ *
+ * Textures that are structurally equal (same source, same sampler settings - see
+ * {@link computeTextureEquality}) are collapsed onto a single instance, so a scene loaded from
+ * many files ends up with one GPU upload per distinct image instead of one per material.
+ *
+ * It exists because both {@link StaticMaterialCache} and the {@link CoalesceTextures} material
+ * transformer carried their own byte-identical copy of this loop *and* of the `Cache`
+ * configuration that backs it - comment for comment, down to a commented-out `console.log`.
+ * A change to the caching policy (weight, hash, equality) or to the write-back convention had to
+ * be made in both.
+ */
+export class TextureCoalescer {
+    /**
+     * Cache of retained textures, exposed for diagnostics (see {@link Cache#validate})
+     * @returns {Cache<Texture, Texture>}
+     */
+    get cache(): Cache<Texture, Texture>;
+    /**
+     * Replaces every texture of the material that has a structurally equal counterpart already in
+     * the cache with that counterpart. Textures with no counterpart are retained for future calls.
+     *
+     * The material is mutated in place.
+     *
+     * @param {Material} material
+     */
+    coalesce(material: Material): void;
+    #private;
+}
+import { Cache } from "../../../../core/cache/Cache.js";
+//# sourceMappingURL=TextureCoalescer.d.ts.map

package/src/engine/asset/loaders/material/TextureCoalescer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureCoalescer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/TextureCoalescer.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH;IAYI;;;OAGG;IACH,qCAEC;IAED;;;;;;;OAOG;IACH,mCAoBC;;CACJ;sBAnEqB,iCAAiC"}

package/src/engine/asset/loaders/material/TextureCoalescer.js

@@ -0,0 +1,68 @@
+import { Cache } from "../../../../core/cache/Cache.js";
+import { computeTextureEquality } from "./computeTextureEquality.js";
+import { computeTextureHash } from "./computeTextureHash.js";
+import { traverseMaterialTextures } from "./traverseMaterialTextures.js";
+
+/**
+ * De-duplicates the textures attached to a material against a cache of textures seen so far.
+ *
+ * Textures that are structurally equal (same source, same sampler settings - see
+ * {@link computeTextureEquality}) are collapsed onto a single instance, so a scene loaded from
+ * many files ends up with one GPU upload per distinct image instead of one per material.
+ *
+ * It exists because both {@link StaticMaterialCache} and the {@link CoalesceTextures} material
+ * transformer carried their own byte-identical copy of this loop *and* of the `Cache`
+ * configuration that backs it - comment for comment, down to a commented-out `console.log`.
+ * A change to the caching policy (weight, hash, equality) or to the write-back convention had to
+ * be made in both.
+ */
+export class TextureCoalescer {
+
+    /**
+     *
+     * @type {Cache<Texture, Texture>}
+     */
+    #cache = new Cache({
+        maxWeight: 1000,
+        keyHashFunction: computeTextureHash,
+        keyEqualityFunction: computeTextureEquality
+    });
+
+    /**
+     * Cache of retained textures, exposed for diagnostics (see {@link Cache#validate})
+     * @returns {Cache<Texture, Texture>}
+     */
+    get cache() {
+        return this.#cache;
+    }
+
+    /**
+     * Replaces every texture of the material that has a structurally equal counterpart already in
+     * the cache with that counterpart. Textures with no counterpart are retained for future calls.
+     *
+     * The material is mutated in place.
+     *
+     * @param {Material} material
+     */
+    coalesce(material) {
+        const cache = this.#cache;
+
+        traverseMaterialTextures(material, (texture, attachment) => {
+
+            //check cache
+            const existing_texture = cache.get(texture);
+
+            if (existing_texture !== null) {
+
+                attachment.write(material, existing_texture);
+
+            } else {
+
+                //texture was not in cache, cache it
+                cache.put(texture, texture);
+
+            }
+
+        });
+    }
+}

package/src/engine/asset/loaders/material/traverseMaterialTextures.d.ts

@@ -1,8 +1,16 @@
 /**
+ * Visit every non-null texture attached to a material, along with the {@link TextureAttachment}
+ * that reads/writes it. This is THE place that knows how to walk
+ * {@link TextureAttachmentsByMaterialType} and what "no texture here" means; anything that needs to
+ * inspect or replace a material's textures should go through it rather than re-deriving the walk.
+ *
+ * `material` is handed to the callback as well so write-back consumers
+ * (`attachment.write(material, replacement)`) need no closure, and `thisArg` can carry whatever
+ * cache the traversal is feeding.
  *
  * @param {Material} material
- * @param {function(THREE.Texture, TextureAttachment)} callback
+ * @param {function(THREE.Texture, TextureAttachment, Material)} callback
  * @param {*} [thisArg]
  */
-export function traverseMaterialTextures(material: Material, callback: (arg0: THREE.Texture, arg1: TextureAttachment) => any, thisArg?: any): void;
+export function traverseMaterialTextures(material: Material, callback: (arg0: THREE.Texture, arg1: TextureAttachment, arg2: Material) => any, thisArg?: any): void;
 //# sourceMappingURL=traverseMaterialTextures.d.ts.map

package/src/engine/asset/loaders/material/traverseMaterialTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traverseMaterialTextures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/traverseMaterialTextures.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,8EAHoB,MAAM,OAAO,wDA+BhC"}
+{"version":3,"file":"traverseMaterialTextures.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/traverseMaterialTextures.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,8EAHoB,MAAM,OAAO,wEA+BhC"}

package/src/engine/asset/loaders/material/traverseMaterialTextures.js

@@ -1,9 +1,17 @@
 import { TextureAttachmentsByMaterialType } from "./TextureAttachmensByMaterialType.js";
 
 /**
+ * Visit every non-null texture attached to a material, along with the {@link TextureAttachment}
+ * that reads/writes it. This is THE place that knows how to walk
+ * {@link TextureAttachmentsByMaterialType} and what "no texture here" means; anything that needs to
+ * inspect or replace a material's textures should go through it rather than re-deriving the walk.
+ *
+ * `material` is handed to the callback as well so write-back consumers
+ * (`attachment.write(material, replacement)`) need no closure, and `thisArg` can carry whatever
+ * cache the traversal is feeding.
  *
  * @param {Material} material
- * @param {function(THREE.Texture, TextureAttachment)} callback
+ * @param {function(THREE.Texture, TextureAttachment, Material)} callback
  * @param {*} [thisArg]
  */
 export function traverseMaterialTextures(material, callback, thisArg) {
@@ -30,7 +38,7 @@ export function traverseMaterialTextures(material, callback, thisArg) {
                 continue;
             }
 
-            callback.call(thisArg, texture, attachment);
+            callback.call(thisArg, texture, attachment, material);
 
         }
     }

package/src/engine/control/first-person/abilities/Mantle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Mantle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Mantle.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAOQ,6CAA6C;IAC7C,WAAW;IACX,uCAAuC;IACvC,kBAAoB;IACpB,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB;IAChB,cAAc;IACd,cAAc;IACd,cAAc;IACd;;0EAEsE;IACtE,cAAqB;IACrB,8CAA8C;IAC9C,eAAe;IAGnB,kEAgCC;IAED,gDAiEC;IAED,wBAGC;IAED,wFA0DC;IAED,oDAEC;CACJ;wBA3PuB,cAAc"}
+{"version":3,"file":"Mantle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Mantle.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAOQ,6CAA6C;IAC7C,WAAW;IACX,uCAAuC;IACvC,kBAAoB;IACpB,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB;IAChB,cAAc;IACd,cAAc;IACd,cAAc;IACd;;0EAEsE;IACtE,cAAqB;IACrB,8CAA8C;IAC9C,eAAe;IAGnB,kEAgCC;IAED,gDAiEC;IAED,wBAGC;IAED,wFA0DC;IAED,oDAEC;CACJ;wBA1OuB,cAAc"}

package/src/engine/control/first-person/abilities/Mantle.js

@@ -1,35 +1,19 @@
 import { assert } from "../../../../core/assert.js";
+import TransitionFunctions from "../../../animation/TransitionFunctions.js";
 import { FirstPersonPosture } from "../pose/FirstPersonPosture.js";
 import { Ability } from "./Ability.js";
 
-/**
- * Smoothstep-style horizontal interpolation: slow-fast-slow.
- * @param {number} t  [0..1]
- */
-function easeInOutCubic(t) {
-    return t < 0.5
-        ? 4 * t * t * t
-        : 1 - Math.pow(-2 * t + 2, 3) / 2;
-}
+// Smoothstep-style horizontal interpolation: slow-fast-slow.
+const easeInOutCubic = TransitionFunctions.EaseInOutCubic;
 
-/**
- * Front-loaded ease — fast rise then gentle settle. Used for the vertical
- * curve so the body lifts off the ground quickly (matching the hand-grip
- * pull-up dynamic) and decelerates as it approaches the surface top.
- * @param {number} t  [0..1]
- */
-function easeOutCubic(t) {
-    return 1 - Math.pow(1 - t, 3);
-}
+// Front-loaded ease — fast rise then gentle settle. Used for the vertical
+// curve so the body lifts off the ground quickly (matching the hand-grip
+// pull-up dynamic) and decelerates as it approaches the surface top.
+const easeOutCubic = TransitionFunctions.EaseOutCubic;
 
-/**
- * Back-loaded ease — gentle start, accelerating finish. Used for the
- * DESCENDING half of a vault hump (you crest the edge then drop over).
- * @param {number} t  [0..1]
- */
-function easeInCubic(t) {
-    return t * t * t;
-}
+// Back-loaded ease — gentle start, accelerating finish. Used for the
+// DESCENDING half of a vault hump (you crest the edge then drop over).
+const easeInCubic = TransitionFunctions.EaseInCubic;
 
 /**
  * Mantle ability — auto-triggers when the player walks/runs into a

package/src/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WeightedRandomActionDescription.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,UAFU,gBAAgB,yBAAyB,CAAC,EAAE,CAExC;IAEd,qFAsBC;IAED;;;;OAIG;IACH,mBAHW,yBAAyB,UACzB,MAAM,QAQhB;CACJ;0CA9CyC,gCAAgC;gCAF1C,+DAA+D;uCACxD,sEAAsE"}
+{"version":3,"file":"WeightedRandomActionDescription.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,UAFU,gBAAgB,yBAAyB,CAAC,EAAE,CAExC;IAEd,qFA2BC;IAED;;;;OAIG;IACH,mBAHW,yBAAyB,UACzB,MAAM,QAQhB;CACJ;0CAnDyC,gCAAgC;gCAF1C,+DAA+D;uCACxD,sEAAsE"}

package/src/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js

@@ -28,6 +28,11 @@ export class WeightedRandomActionDescription extends AbstractActionDescription {
         // remix actor entity index to produce large difference for small entity ID differences
         const actor_seed = (actor >> 16) | (actor << 16);
 
+        // DETERMINISM HOLE: this Math.random() seeds an AI behaviour tree, so the same world state can
+        // produce different AI decisions across runs -- defeating replay, rewind and action-log
+        // replication. It cannot be removed on its own: without it every invocation for a given actor
+        // would return an identical sequence. The fix is to draw from a run-level seeded stream, which
+        // has to be threaded down to here first (see MarkerNodeActionSelectWeighted for the pattern).
         const seed = actor_seed ^ computeHashFloat(Math.random());
 
         b.setRandomSeed(seed);