@woosh/meep-engine 2.33.20 → 2.33.21

package/core/geom/Vector3.js

@@ -5,10 +5,15 @@
 
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
-import { clamp } from "../math/clamp.js";
 import { lerp } from "../math/lerp.js";
 import { computeHashFloat, EPSILON, epsilonEquals } from "../math/MathUtils.js";
 import { sign } from "../math/sign.js";
+import { v3_dot } from "./v3_dot.js";
+import { v3_length_sqr } from "./v3_length_sqr.js";
+import { v3_length } from "./v3_length.js";
+import { v3_angle_between } from "./v3_angle_between.js";
+import { v3_lerp } from "./v3_lerp.js";
+import { v3_slerp } from "./v3_slerp.js";
 
 class Vector3 {
     /**
@@ -442,7 +447,7 @@ class Vector3 {
      * @returns {number}
      */
     angleTo(other) {
-        return v3_angleBetween(this.x, this.y, this.z, other.x, other.y, other.z);
+        return v3_angle_between(this.x, this.y, this.z, other.x, other.y, other.z);
     }
 
     /**
@@ -534,6 +539,32 @@ class Vector3 {
         return this.set(_x, _y, _z);
     }
 
+    /**
+     * Assume current vector holds a direction, transform using a matrix to produce a new directional unit vector
+     * @param {THREE.Matrix4} m
+     */
+    transformDirection_three(m) {
+
+        // input: THREE.Matrix4 affine matrix
+        // vector interpreted as a direction
+
+        const x = this.x, y = this.y, z = this.z;
+        const e = m.elements;
+
+        const _x = e[0] * x + e[4] * y + e[8] * z;
+        const _y = e[1] * x + e[5] * y + e[9] * z;
+        const _z = e[2] * x + e[6] * y + e[10] * z;
+
+        // normalize the result
+        const _l = 1 / v3_length(_x, _y, _z);
+
+        this.set(
+            _x * _l,
+            _y * _l,
+            _z * _l
+        );
+    }
+
     /**
      *
      * @param {THREE.Matrix3} m
@@ -947,20 +978,6 @@ Vector3.back = Object.freeze(new Vector3(0, 0, -1));
 Vector3.typeName = "Vector3";
 
 
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-export function v3_dot(x0, y0, z0, x1, y1, z1) {
-    return (x0 * x1 + y0 * y1 + z0 * z1);
-}
-
 /**
  *
  * @param {number} x0
@@ -973,87 +990,11 @@ export function v3_dot(x0, y0, z0, x1, y1, z1) {
  */
 Vector3._dot = v3_dot;
 
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-export function v3_distance(x0, y0, z0, x1, y1, z1) {
-
-    return Math.sqrt(v3_distance_sqr(x0, y0, z0, x1, y1, z1));
-}
-
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-export function v3_distance_sqr(x0, y0, z0, x1, y1, z1) {
-    const x = x0 - x1;
-    const y = y0 - y1;
-    const z = z0 - z1;
-
-    return x * x + y * y + z * z;
-}
-
 
 function v3Length(v) {
     return v3_length(v.x, v.y, v.z);
 }
 
-export function v3_length(x, y, z) {
-    return Math.sqrt(v3_length_sqr(x, y, z));
-}
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @return {number}
- */
-export function v3_length_sqr(x, y, z) {
-    return x * x + y * y + z * z;
-}
-
-
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-export function v3_angleBetween(x0, y0, z0, x1, y1, z1) {
-    const d = v3_dot(x0, y0, z0, x1, y1, z1);
-
-    const magnitude_0 = v3_length(x0, y0, z0);
-    const magnitude_1 = v3_length(x1, y1, z1);
-
-    const l = magnitude_0 * magnitude_1;
-
-    if (l === 0) {
-        // collective magnitude is 0, provide arbitrary angle
-        return 0;
-    }
-
-    const theta = clamp(d / l, -1, 1);
-
-    return Math.acos(theta);
-}
 
 /**
  *
@@ -1067,70 +1008,4 @@ function v3Lerp(result, a, b, fraction) {
     v3_lerp(result, a.x, a.y, a.z, b.x, b.y, b.z, fraction);
 }
 
-/**
- *
- * @param {Vector3} result
- * @param {number} a_x
- * @param {number} a_y
- * @param {number} a_z
- * @param {number} b_x
- * @param {number} b_y
- * @param {number} b_z
- * @param {number} fraction
- */
-function v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction) {
-
-    const x = lerp(a_x, b_x, fraction);
-    const y = lerp(a_y, b_y, fraction);
-    const z = lerp(a_z, b_z, fraction);
-
-    result.set(x, y, z);
-}
-
-/**
- * Spherical linear interpolation
- * @see https://en.wikipedia.org/wiki/Slerp
- * @param {Vector3} result
- * @param {number} a_x
- * @param {number} a_y
- * @param {number} a_z
- * @param {number} b_x
- * @param {number} b_y
- * @param {number} b_z
- * @param {number} fraction
- */
-export function v3_slerp(
-    result,
-    a_x, a_y, a_z,
-    b_x, b_y, b_z,
-    fraction
-) {
-    const dot = v3_dot(
-        a_x, a_y, a_z,
-        b_x, b_y, b_z
-    );
-
-    if (dot >= 1 || dot <= -1) {
-        // avoid division by 0, both vectors are pointing in the same direction, use lerp instead
-        v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction);
-        return;
-    }
-
-    // compute angle between two vectors
-    const theta = Math.acos(dot);
-
-    const sin_theta = Math.sin(theta);
-
-    const inv_sin_theta = 1 / sin_theta;
-
-    const scale_0 = Math.sin((1 - fraction) * theta) * inv_sin_theta;
-    const scale_1 = Math.sin((fraction) * theta) * inv_sin_theta;
-
-    const x = a_x * scale_0 + b_x * scale_1;
-    const y = a_y * scale_0 + b_y * scale_1;
-    const z = a_z * scale_0 + b_z * scale_1;
-
-    result.set(x, y, z);
-}
-
 export default Vector3;

package/core/geom/Vector3.spec.js

@@ -1,4 +1,5 @@
-import Vector3, { v3_slerp } from "./Vector3.js";
+import Vector3 from "./Vector3.js";
+import { v3_slerp } from "./v3_slerp.js";
 
 test('slerp', () => {
 

package/core/geom/v3_angle_between.js

@@ -0,0 +1,31 @@
+import { v3_dot } from "./v3_dot.js";
+import { v3_length } from "./v3_length.js";
+import { clamp } from "../math/clamp.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
+    const d = v3_dot(x0, y0, z0, x1, y1, z1);
+
+    const magnitude_0 = v3_length(x0, y0, z0);
+    const magnitude_1 = v3_length(x1, y1, z1);
+
+    const l = magnitude_0 * magnitude_1;
+
+    if (l === 0) {
+        // collective magnitude is 0, provide arbitrary angle
+        return 0;
+    }
+
+    const theta = clamp(d / l, -1, 1);
+
+    return Math.acos(theta);
+}

package/core/geom/v3_distance.js

@@ -0,0 +1,16 @@
+import { v3_distance_sqr } from "./v3_distance_sqr.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_distance(x0, y0, z0, x1, y1, z1) {
+
+    return Math.sqrt(v3_distance_sqr(x0, y0, z0, x1, y1, z1));
+}

package/core/geom/v3_distance_sqr.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_distance_sqr(x0, y0, z0, x1, y1, z1) {
+    const x = x0 - x1;
+    const y = y0 - y1;
+    const z = z0 - z1;
+
+    return x * x + y * y + z * z;
+}

package/core/geom/v3_dot.js

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_dot(x0, y0, z0, x1, y1, z1) {
+    return (x0 * x1 + y0 * y1 + z0 * z1);
+}

package/core/geom/v3_length.js

@@ -0,0 +1,5 @@
+import { v3_length_sqr } from "./v3_length_sqr.js";
+
+export function v3_length(x, y, z) {
+    return Math.sqrt(v3_length_sqr(x, y, z));
+}

package/core/geom/v3_length_sqr.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+export function v3_length_sqr(x, y, z) {
+    return x * x + y * y + z * z;
+}

package/core/geom/v3_lerp.js

@@ -0,0 +1,21 @@
+import { lerp } from "../math/lerp.js";
+
+/**
+ *
+ * @param {Vector3} result
+ * @param {number} a_x
+ * @param {number} a_y
+ * @param {number} a_z
+ * @param {number} b_x
+ * @param {number} b_y
+ * @param {number} b_z
+ * @param {number} fraction
+ */
+export function v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction) {
+
+    const x = lerp(a_x, b_x, fraction);
+    const y = lerp(a_y, b_y, fraction);
+    const z = lerp(a_z, b_z, fraction);
+
+    result.set(x, y, z);
+}

package/core/geom/v3_slerp.js

@@ -0,0 +1,48 @@
+import { v3_dot } from "./v3_dot.js";
+import { v3_lerp } from "./v3_lerp.js";
+
+/**
+ * Spherical linear interpolation
+ * @see https://en.wikipedia.org/wiki/Slerp
+ * @param {Vector3} result
+ * @param {number} a_x
+ * @param {number} a_y
+ * @param {number} a_z
+ * @param {number} b_x
+ * @param {number} b_y
+ * @param {number} b_z
+ * @param {number} fraction
+ */
+export function v3_slerp(
+    result,
+    a_x, a_y, a_z,
+    b_x, b_y, b_z,
+    fraction
+) {
+    const dot = v3_dot(
+        a_x, a_y, a_z,
+        b_x, b_y, b_z
+    );
+
+    if (dot >= 1 || dot <= -1) {
+        // avoid division by 0, both vectors are pointing in the same direction, use lerp instead
+        v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction);
+        return;
+    }
+
+    // compute angle between two vectors
+    const theta = Math.acos(dot);
+
+    const sin_theta = Math.sin(theta);
+
+    const inv_sin_theta = 1 / sin_theta;
+
+    const scale_0 = Math.sin((1 - fraction) * theta) * inv_sin_theta;
+    const scale_1 = Math.sin((fraction) * theta) * inv_sin_theta;
+
+    const x = a_x * scale_0 + b_x * scale_1;
+    const y = a_y * scale_0 + b_y * scale_1;
+    const z = a_z * scale_0 + b_z * scale_1;
+
+    result.set(x, y, z);
+}

package/core/primitives/array/computeIntegerArrayHash.js

@@ -11,6 +11,11 @@ export function computeIntegerArrayHash(data, offset, length) {
 
     for (let i = offset; i < end; i++) {
         const singleValue = data[i];
+        /**
+         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
+         * (h<<5) - h ===  h*31
+         * @type {number}
+         */
         hash = ((hash << 5) - hash) + singleValue;
         hash |= 0; // Convert to 32bit integer
     }

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/graphics/GraphicsEngine.js

@@ -344,6 +344,24 @@ GraphicsEngine.prototype.start = function () {
     };
 
     const webGLRenderer = this.renderer = new WebGLRenderer(rendererParameters);
+
+    let g = 0;
+    let t = 0;
+    webGLRenderer.info.memory = {
+        get geometries() {
+            return g;
+        },
+        set geometries(v) {
+            g = v;
+        },
+        get textures() {
+            return t;
+        },
+        set textures(v) {
+            t = v;
+        }
+    };
+
     //print GPU info
     const GPU_NAME = this.getGPUName();
 

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;