@woosh/meep-engine 2.33.19 → 2.33.23

package/engine/asset/loaders/material/computeImageBitmapHash.js

@@ -1,47 +1,41 @@
 import { min2 } from "../../../../core/math/min2.js";
-import { computeIntegerArrayHash } from "../../../../core/primitives/array/computeIntegerArrayHash.js";
+import { sampler_from_bitmap } from "./computeImageBitmapEquality.js";
 
-let canvas = null;
-let canvasContext = null;
 
 /**
  *
- * @returns {CanvasRenderingContext2D}
+ * @param {ImageBitmap} bitmap
+ * @returns {number}
  */
-function getCanvasContext() {
+export function computeImageBitmapHash(bitmap) {
 
-    if (canvasContext === null) {
-        canvas = document.createElement('canvas');
+    const w = min2(bitmap.width, 8);
+    const h = min2(bitmap.height, 8);
 
-        canvas.height = 8;
-        canvas.width = 8;
+    const sampler = sampler_from_bitmap(bitmap);
 
-        canvasContext = canvas.getContext('2d');
+    const sampler_data = sampler.data;
+    const item_size = sampler.itemSize;
 
-    }
+    let hash = 0;
 
-    return canvasContext;
+    for (let y = 0; y < h; y++) {
 
-}
+        const row_size = y * sampler.width;
 
-/**
- *
- * @param {ImageBitmap} bitmap
- * @returns {number}
- */
-export function computeImageBitmapHash(bitmap) {
-    const ctx = getCanvasContext();
+        for (let x = 0; x < w; x++) {
 
-    const w = min2(bitmap.width, 8);
-    const h = min2(bitmap.height, 8);
+            const texel_index = x + row_size;
+            const address = texel_index * item_size;
 
-    ctx.clearRect(0, 0, w, h);
+            for (let i = 0; i < item_size; i++) {
 
-    ctx.drawImage(bitmap, 0, 0, w, h, 0, 0, w, h);
+                const v = sampler_data[address];
 
-    const imageData = ctx.getImageData(0, 0, w, h);
-
-    const data = imageData.data;
+                hash = (hash << 5) - hash + v;
+            }
+        }
+    }
 
-    return computeIntegerArrayHash(data, 0, data.length);
+    return hash;
 }

package/engine/asset/loaders/material/computeMaterialHash.js

@@ -59,8 +59,7 @@ export function computeMaterialHash(material) {
             computeTextureHash(material.alphaMap),
             computeHashFloat(material.envMapIntensity),
             computeTextureHash(material.envMap)
-        )
-        ;
+        );
     } else if (material.isShaderMaterial) {
         hash ^= material.lights ? 0 : 1;
     }

package/engine/asset/loaders/material/computeTextureEquality.js

@@ -51,6 +51,7 @@ export function computeTextureEquality(a, b) {
         const bMipmaps = b.mipmaps;
 
         const n = aMipmaps.length;
+
         if (n !== bMipmaps.length) {
             return false;
         }
@@ -72,8 +73,8 @@ export function computeTextureEquality(a, b) {
 
 /**
  *
- * @param {Image|[]} a
- * @param {Image|[]} b
+ * @param {Image|[]|{width:number, height:number}} a
+ * @param {Image|[]|{width:number, height:number}} b
  * @returns {boolean}
  */
 export function textureImagesEqual(a, b) {
@@ -89,6 +90,14 @@ export function textureImagesEqual(a, b) {
         }
     }
 
+    if (
+        (typeof a.width === "number" && a.width !== b.width)
+        || (typeof a.height === "number" && a.height !== b.height)
+    ) {
+        // dimensions are present, but are inconsistent
+        return false;
+    }
+
     if (a instanceof ImageBitmap && b instanceof ImageBitmap) {
         return computeImageBitmapEquality(a, b);
     }
@@ -148,11 +157,10 @@ export function textureImagesEqual(a, b) {
             }
         }
 
-        //array images are equivalent
-        return true;
     }
 
-    return false;
+    // assume equivalent
+    return true;
 }
 
 

package/engine/ecs/animation/OneBoneSurfaceAlignmentSolver.js

@@ -3,9 +3,11 @@ import { inverseLerp } from "../../../core/math/inverseLerp.js";
 import { IKSolver } from "./IKSolver.js";
 import { findSkeletonBoneByType } from "../../graphics/ecs/mesh/SkeletonUtils.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
-import Vector3, { v3_dot, v3_length } from "../../../core/geom/Vector3.js";
+import Vector3 from "../../../core/geom/Vector3.js";
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import { v3_computeOffsetVector } from "./IKMath.js";
+import { v3_dot } from "../../../core/geom/v3_dot.js";
+import { v3_length } from "../../../core/geom/v3_length.js";
 
 const boneWorldPosition = new Vector3();
 const boneWorldRotation = new Quaternion();

package/engine/ecs/animation/TwoBoneInverseKinematicsSolver.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import Vector3, { v3_dot, v3_length } from "../../../core/geom/Vector3.js";
+import Vector3 from "../../../core/geom/Vector3.js";
 import { clamp } from "../../../core/math/clamp.js";
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
@@ -7,6 +7,8 @@ import { findSkeletonBoneByType } from "../../graphics/ecs/mesh/SkeletonUtils.js
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import { IKSolver } from "./IKSolver.js";
 import { v3_computeOffsetVector } from "./IKMath.js";
+import { v3_dot } from "../../../core/geom/v3_dot.js";
+import { v3_length } from "../../../core/geom/v3_length.js";
 
 const boneWorldPositionC = new Vector3();
 const boneWorldPositionB = new Vector3();

package/engine/ecs/fow/FogOfWar.js

@@ -5,7 +5,6 @@ import { Sampler2D } from "../../graphics/texture/sampler/Sampler2D.js";
 import { ClampToEdgeWrapping, DataTexture, LinearFilter, RedFormat, UnsignedByteType } from "three";
 import Vector1 from "../../../core/geom/Vector1.js";
 import Vector2 from "../../../core/geom/Vector2.js";
-import Vector3 from "../../../core/geom/Vector3.js";
 import { assert } from "../../../core/assert.js";
 import { computeUnsignedDistanceField } from "../../graphics/texture/sampler/distanceField.js";
 import Vector4 from "../../../core/geom/Vector4.js";
@@ -357,7 +356,7 @@ export class FogOfWar {
         }
 
 
-        this.on.textureChanged.dispatch();
+        this.on.textureChanged.send0();
 
         //clear flag
         this.textureNeedsUpdate = false;
@@ -534,7 +533,7 @@ export class FogOfWar {
         const sampleX = samplePosition[0];
         const sampleY = samplePosition[1];
 
-        return this.distanceSampler.readChannel(sampleX|0, sampleY|0, 0);
+        return this.distanceSampler.readChannel(sampleX | 0, sampleY | 0, 0);
     }
 
     rebuildDistanceField() {

package/engine/ecs/gui/hud/HeadsUpDisplaySystem.js

@@ -85,7 +85,6 @@ class HeadsUpDisplaySystem extends System {
      * @private
      */
     __apply_entity_transformation(hud, transform, vp, element) {
-        const position = transform.position;
         const worldOffset = hud.worldOffset;
 
         let worldOffsetX = worldOffset.x;
@@ -107,6 +106,7 @@ class HeadsUpDisplaySystem extends System {
             v4.applyQuaternion(transform.rotation);
         }
 
+        const position = transform.position;
 
         v4.add3(position);
 

package/engine/ecs/systems/SteeringSystem.js

@@ -11,8 +11,9 @@ import Motion from '../components/Motion.js';
 import { Transform } from '../transform/Transform.js';
 import Steering, { SteeringEvents, SteeringFlags } from '../components/Steering.js';
 import { solveQuadratic } from "../../../core/math/MathUtils.js";
-import Vector3, { v3_dot } from "../../../core/geom/Vector3.js";
+import Vector3 from "../../../core/geom/Vector3.js";
 import { alignToVector } from "../terrain/ecs/ClingToTerrainSystem.js";
+import { v3_dot } from "../../../core/geom/v3_dot.js";
 
 /**
  *

package/engine/ecs/terrain/ecs/Terrain.js

@@ -461,6 +461,10 @@ class Terrain {
         this.__material_reference.release();
 
         this.tiles.dispose();
+        this.splat.dispose();
+        this.layers.dispose();
+
+        this.heightTexture.dispose();
 
         this.clearFlag(TerrainFlags.Linked);
     }
@@ -1045,6 +1049,8 @@ class Terrain {
             return texture;
         });
 
+        // TODO ensure cleanup when terrain is unlinked
+
         return result;
     }
 

package/engine/ecs/terrain/ecs/layers/TerrainLayers.js

@@ -335,6 +335,11 @@ export class TerrainLayers {
         this.texture.needsUpdate = true;
     }
 
+    dispose() {
+        this.texture.dispose();
+        this.scalesTexture.dispose();
+    }
+
     clear() {
         this.layers.reset();
     }

package/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -359,6 +359,11 @@ export class SplatMapping {
 
     }
 
+    dispose() {
+        this.weightTexture.dispose();
+        this.materialTexture.dispose();
+    }
+
     /**
      * Cut a specified layer, depth will be reduced by 1
      * @param {number} index

package/engine/ecs/util/hideEntityGracefully.js

@@ -15,10 +15,23 @@ import { DelayBehavior } from "../../intelligence/behavior/util/DelayBehavior.js
 import { Light } from "../../graphics/ecs/light/Light.js";
 import { TransitionPropertyVectorXBehavior } from "../../../../model/game/story/behaviors/generic/TransitionPropertyVectorXBehavior.js";
 
+/**
+ * @readonly
+ * @type {number}
+ */
 const SHUTDOWN_GRACE_PERIOD = 60;
 
+/**
+ *
+ * @type {Map<Class|function, function(T,entity?:EntityBuilder,createEntity?:function,createEntityContext?:*):number>}
+ */
 const component_shutdown = new Map();
 
+/**
+ * @template T
+ * @param {Class<T>} type
+ * @param {function(T,entity?:EntityBuilder,createEntity?:function,createEntityContext?:*):number} method
+ */
 function addShutdown(type, method) {
     component_shutdown.set(type, method);
 }
@@ -152,6 +165,11 @@ addShutdown(SoundEmitter, (soundEmitter, builder, createEntity, createEntityThis
  * @return {number} duration in seconds until the entity is completely hidden
  */
 export function hideEntityGracefully(builder, createEntity, createEntityThisArg) {
+    if (!builder.isBuilt) {
+        // already destroyed
+        return 0;
+    }
+
     let delay = 0;
 
     const components = builder.element;

package/engine/graphics/GraphicsEngine.js

@@ -344,6 +344,7 @@ GraphicsEngine.prototype.start = function () {
     };
 
     const webGLRenderer = this.renderer = new WebGLRenderer(rendererParameters);
+
     //print GPU info
     const GPU_NAME = this.getGPUName();
 

package/engine/graphics/camera/testClippingPlaneComputation.js

@@ -95,11 +95,11 @@ function makeConfig(engine) {
         new TopDownCameraControllerSystem(graphics),
         new TopDownCameraLanderSystem(),
         new CameraSystem(graphics.scene, graphics),
-        new MeshSystem(graphics, assetManager),
+        new MeshSystem(engine),
         new ClingToTerrainSystem(),
         new TerrainSystem(graphics, assetManager),
         new WaterSystem(graphics),
-        new Trail2DSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
         new GridPosition2TransformSystem(),

package/engine/graphics/ecs/camera/CameraClippingPlaneComputer.js

@@ -1,7 +1,7 @@
 import { isValueBetweenInclusive } from "../../../../core/math/MathUtils.js";
 import { frustumFromCamera } from "./CameraSystem.js";
 import { Frustum as ThreeFrustum } from "three";
-import { v3_dot } from "../../../../core/geom/Vector3.js";
+import { v3_dot } from "../../../../core/geom/v3_dot.js";
 
 const CLIPPING_EPSILON = 0.001;
 

package/engine/graphics/ecs/highlight/renderer/OutlineRenderer.js

@@ -18,8 +18,6 @@ import {
     Vector2,
     WebGLRenderTarget
 } from "three";
-import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
-import convertSampler2D2Canvas from "../../../texture/sampler/Sampler2D2Canvas.js";
 import { makeHighlightDecodeShader } from "./HighlightDecodeShader.js";
 import { makeDilationShader } from "./makeDilationShader.js";
 import { ScreenSpaceQuadShader } from "../../../shaders/ScreenSpaceQuadShader.js";
@@ -500,57 +498,6 @@ export class OutlineRenderer {
         renderer.setRenderTarget(null);
     }
 
-    debugObjectIDs() {
-
-        const s = Sampler2D.uint8(4, this.__renderTargetObjectId_t0.width, this.__renderTargetObjectId_t0.height);
-
-        this.renderer.readRenderTargetPixels(this.__renderTargetObjectId_t0, 0, 0, this.__renderTargetObjectId_t0.width, this.__renderTargetObjectId_t0.height, s);
-
-
-        const htmlCanvasElement = convertSampler2D2Canvas(s, 1, 0);
-
-        htmlCanvasElement.style.zIndex = 10000;
-        htmlCanvasElement.style.position = "absolute";
-
-        document.body.appendChild(htmlCanvasElement);
-    }
-
-    /**
-     *
-     * @param {Object3D} object
-     */
-    renderObjectId(object) {
-        if (object.isMesh || object.isSkinnedMesh) {
-
-            const geometry = object.geometry;
-
-            if (geometry === undefined) {
-                return;
-            }
-
-            const renderer = this.renderer;
-
-            if (object.isSkinnedMesh) {
-
-                renderer.renderBufferDirect(this.camera, null, geometry, material_id_skinned, object, null);
-
-            } else {
-                renderer.renderBufferDirect(this.camera, null, geometry, material_id_unskinned, object, null);
-            }
-
-        }
-
-        const children = object.children;
-
-        const child_count = children.length;
-
-        for (let i = 0; i < child_count; i++) {
-            const child = children[i];
-
-            this.renderObjectId(child);
-        }
-    }
-
     /**
      *
      * @param {Material} material

package/engine/graphics/ecs/path/testPathDisplaySystem.js

@@ -106,11 +106,11 @@ function makeConfig(engine) {
         new TopDownCameraControllerSystem(graphics),
         new TopDownCameraLanderSystem(),
         new CameraSystem(graphics.scene, graphics),
-        new MeshSystem(graphics, assetManager),
+        new MeshSystem(engine),
         new ClingToTerrainSystem(),
         new TerrainSystem(graphics, assetManager),
         new WaterSystem(graphics),
-        new Trail2DSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
         new GridPosition2TransformSystem(),
@@ -179,11 +179,11 @@ function catmullRom(points) {
     cv.link();
 
     cv.css({
-               position: "absolute",
-               left: 0,
-               right: 0,
-               zIndex: 99999
-           });
+        position: "absolute",
+        left: 0,
+        right: 0,
+        zIndex: 99999
+    });
 
     const sample = [];
 
@@ -216,92 +216,92 @@ function sample_style_entity() {
     const style = new EntityPathStyle();
     style.spacing = 0.6;
     style.marker_start = EntityPathMarkerDefinition.from({
-                                                             blueprint: EntityBlueprint.from([
-                                                                                                 Transform.fromJSON({}),
-                                                                                                 Mesh.fromJSON({
-                                                                                                                   url: "data/models/arrow-symbols/arrow4/model-green.gltf",
-                                                                                                                   castShadow: true,
-                                                                                                                   receiveShadow: true
-                                                                                                               })
-                                                                                             ]),
-                                                             transform: Transform.fromJSON({
-                                                                                               scale: {
-                                                                                                   x: 0.3,
-                                                                                                   y: 0.3,
-                                                                                                   z: 0.3
-                                                                                               },
-                                                                                               rotation: {
-                                                                                                   x: 0.5,
-                                                                                                   y: -0.5,
-                                                                                                   z: 0.5,
-                                                                                                   w: 0.5
-                                                                                               },
-                                                                                               position: {
-                                                                                                   x: 0,
-                                                                                                   y: 1,
-                                                                                                   z: 0
-                                                                                               }
-                                                                                           })
-                                                         });
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/arrow-symbols/arrow4/model-green.gltf",
+                castShadow: true,
+                receiveShadow: true
+            })
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.3,
+                y: 0.3,
+                z: 0.3
+            },
+            rotation: {
+                x: 0.5,
+                y: -0.5,
+                z: 0.5,
+                w: 0.5
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
     style.marker_end = EntityPathMarkerDefinition.from({
-                                                           blueprint: EntityBlueprint.from([
-                                                                                               Transform.fromJSON({}),
-                                                                                               Mesh.fromJSON({
-                                                                                                                 url: "data/models/arrow-symbols/arrow4/model-red.gltf",
-                                                                                                                 castShadow: true,
-                                                                                                                 receiveShadow: true
-                                                                                                             })
-                                                                                           ]),
-                                                           transform: Transform.fromJSON({
-                                                                                             scale: {
-                                                                                                 x: 0.3,
-                                                                                                 y: 0.3,
-                                                                                                 z: 0.3
-                                                                                             },
-                                                                                             rotation: {
-                                                                                                 x: 0.5,
-                                                                                                 y: -0.5,
-                                                                                                 z: 0.5,
-                                                                                                 w: 0.5
-                                                                                             },
-                                                                                             position: {
-                                                                                                 x: 0,
-                                                                                                 y: 1,
-                                                                                                 z: 0
-                                                                                             }
-                                                                                         })
-                                                       });
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/arrow-symbols/arrow4/model-red.gltf",
+                castShadow: true,
+                receiveShadow: true
+            })
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.3,
+                y: 0.3,
+                z: 0.3
+            },
+            rotation: {
+                x: 0.5,
+                y: -0.5,
+                z: 0.5,
+                w: 0.5
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
     style.marker_main = EntityPathMarkerDefinition.from({
-                                                            blueprint: EntityBlueprint.from([
-                                                                                                Transform.fromJSON({}),
-                                                                                                Mesh.fromJSON({
-                                                                                                                  url: "data/models/Barel-Roll Droid/handpainted.gltf",
-                                                                                                                  castShadow: true,
-                                                                                                                  receiveShadow: true
-                                                                                                              }),
-                                                                                                Animation.fromJSON({
-                                                                                                                       clips: [
-                                                                                                                           {
-                                                                                                                               name: "fly",
-                                                                                                                               repeatCount: Infinity
-                                                                                                                           }
-                                                                                                                       ]
-                                                                                                                   }),
-                                                                                                Highlight.fromOne(1, 0, 0, 1)
-                                                                                            ]),
-                                                            transform: Transform.fromJSON({
-                                                                                              scale: {
-                                                                                                  x: 0.2,
-                                                                                                  y: 0.2,
-                                                                                                  z: 0.2
-                                                                                              },
-                                                                                              position: {
-                                                                                                  x: 0,
-                                                                                                  y: 1,
-                                                                                                  z: 0
-                                                                                              }
-                                                                                          })
-                                                        });
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/Barel-Roll Droid/handpainted.gltf",
+                castShadow: true,
+                receiveShadow: true
+            }),
+            Animation.fromJSON({
+                clips: [
+                    {
+                        name: "fly",
+                        repeatCount: Infinity
+                    }
+                ]
+            }),
+            Highlight.fromOne(1, 0, 0, 1)
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.2,
+                y: 0.2,
+                z: 0.2
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
 
     return style;
 }
@@ -337,13 +337,13 @@ function main(engine) {
     // ], 50));
 
     _p.setPositionsFromVectorArray([
-                                       new Vector3(3, 1, 1),
-                                       new Vector3(3, 1, 3),
-                                       new Vector3(7, 1, 3),
-                                       new Vector3(7, 1, 7),
-                                       new Vector3(3, 1, 7),
-                                       new Vector3(3, 1, 8),
-                                   ]);
+        new Vector3(3, 1, 1),
+        new Vector3(3, 1, 3),
+        new Vector3(7, 1, 3),
+        new Vector3(7, 1, 7),
+        new Vector3(3, 1, 7),
+        new Vector3(3, 1, 8),
+    ]);
 
 
     const trailPathStyle = new RibbonPathStyle();