@woosh/meep-engine 2.33.1 → 2.33.5

package/core/bvh2/aabb3/AABB3.js

@@ -8,6 +8,7 @@ import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.
 import computeMortonCode from "../../geom/3d/morton/Morton.js";
 import { _boxSurfaceArea2, intersectRay, intersectSegment } from "./AABB3Math.js";
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
+import { assert } from "../../assert.js";
 
 
 /**
@@ -718,6 +719,23 @@ AABB3.prototype.getCorners = function (result) {
     );
 };
 
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} offset
+ */
+AABB3.prototype.writeToArray = function (result, offset) {
+    assert.isNonNegativeInteger(offset, 'offset');
+
+    result[offset] = this.x0;
+    result[offset + 1] = this.y0;
+    result[offset + 2] = this.z0;
+
+    result[offset + 3] = this.x1;
+    result[offset + 4] = this.y1;
+    result[offset + 5] = this.z1;
+};
+
 /**
  * @param {THREE.Plane} plane
  * @returns {int} 2,0,or -2; 2: above, -2 : below, 0 : intersects plane

package/core/bvh2/aabb3/aabb3_intersects_frustum.js

@@ -0,0 +1,38 @@
+import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+
+/**
+ *
+ * @param {Float32Array|number[]} aabb
+ * @param {Float32Array|number[]} frustum
+ * @return {boolean}
+ */
+export function aabb3_intersects_frustum(aabb, frustum) {
+
+    const x0 = aabb[0];
+    const y0 = aabb[1];
+    const z0 = aabb[2];
+    const x1 = aabb[3];
+    const y1 = aabb[4];
+    const z1 = aabb[5];
+
+    for (let i = 0; i < 24; i += 4) {
+
+        const plane_n_x = frustum[i];
+        const plane_n_y = frustum[i + 1];
+        const plane_n_z = frustum[i + 2];
+        const plane_constant = frustum[i + 3];
+
+        const plane_distance = aabb3_computeDistanceAbovePlane(
+            plane_n_x, plane_n_y, plane_n_z, plane_constant,
+            x0, y0, z0,
+            x1, y1, z1
+        );
+
+        if (plane_distance < 0) {
+            return false;
+        }
+
+    }
+
+    return true;
+}

package/core/collection/array/copyArray.js

@@ -25,9 +25,9 @@ export function copyArray(source, target) {
  * Follows Java System.arraycopy interface
  * Copy data from one array to another
  * @template T
- * @param {T[]|ArrayLike<T>|TypedArray} source The source array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} source The source array
  * @param {number} source_position Starting position where to copy from inside the source array
- * @param {T[]|ArrayLike<T>|TypedArray} destination The destination array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} destination The destination array
  * @param {number} destination_position Starting position where to copy to inside the destination array
  * @param {number} length How many elements should be copied
  */

package/core/collection/table/RowFirstTableSpec.js

@@ -234,6 +234,14 @@ export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
     }
 }
 
+/**
+ *
+ * @return {number}
+ */
+RowFirstTableSpec.prototype.getColumnCount = function () {
+    return this.types.length;
+}
+
 /**
  *
  * @param {RowFirstTableSpec} other

package/core/geom/3d/aabb/aabb3_compute_projected_area.js

@@ -1,5 +1,3 @@
-const scratch_corners = new Float32Array(24);
-
 /*
 
     one option of Algorithm (problem-orthogonal only, rectangles under perspective projection do not behave this way):
@@ -12,13 +10,13 @@ const scratch_corners = new Float32Array(24);
 
 
 /**
+ * NOTE: Consider using an optimized aabb projection method based on Jim Arvo's Graphics Gems algorithm: https://stackoverflow.com/a/58630206/3973586
  * Almost everything is inlined for speed
- * @param {AABB2} result
- * @param {AABB3} bounds
+ * @param {number[]} aabb_corners
  * @param {number[]|mat4|Float32Array} projection_matrix
+ * @returns {number}
  */
-export function aabb3_project_to_2d(result, bounds, projection_matrix) {
-    bounds.getCorners(scratch_corners);
+export function aabb3_project_to_2d(aabb_corners, projection_matrix) {
 
     // read matrix into local variables for speed
     const a0 = projection_matrix[0];
@@ -48,9 +46,9 @@ export function aabb3_project_to_2d(result, bounds, projection_matrix) {
     for (let i = 0; i < 24; i += 3) {
 
         // read corner
-        const _x = scratch_corners[i];
-        const _y = scratch_corners[i + 1];
-        const _z = scratch_corners[i + 2];
+        const _x = aabb_corners[i];
+        const _y = aabb_corners[i + 1];
+        const _z = aabb_corners[i + 2];
 
         // apply transform
         const t_x = a0 * _x + b0 * _y + c0 * _z + d0;
@@ -80,5 +78,8 @@ export function aabb3_project_to_2d(result, bounds, projection_matrix) {
 
     }
 
-    result.set(x0, y0, x1, y1);
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+
+    return dx * dy;
 }

package/core/geom/3d/aabb/aabb3_estimate_projected_area2.js

@@ -0,0 +1,59 @@
+const scratch_aabb = new Float32Array(4);
+
+
+/**
+ * NOTE: tends to overestimate the area
+ * @param {number[]} aabb
+ * @param {number[]} matrix
+ * @return {number}
+ */
+export function aabb3_estimate_projected_area2(aabb, matrix) {
+    // extract translation from matrix
+    scratch_aabb[0] = scratch_aabb[2] = matrix[12];
+    scratch_aabb[1] = scratch_aabb[3] = matrix[13];
+
+    // apply 3x3 matrix transform
+    for (let i = 0; i < 2; i++) {
+        for (let j = 0; j < 3; j++) {
+
+            const m_a = i * 4 + j;
+            const m_v = matrix[m_a];
+
+            const a = m_v * aabb[j];
+            const b = m_v * aabb[j + 3];
+
+            if (a < b) {
+                scratch_aabb[i] += a;
+                scratch_aabb[i + 2] += b;
+            } else {
+                scratch_aabb[i] += b;
+                scratch_aabb[i + 2] += a;
+            }
+        }
+    }
+
+
+    const x1 = scratch_aabb[2];
+    const x0 = scratch_aabb[0];
+
+    const dx = x1 - x0;
+
+    const y1 = scratch_aabb[3];
+    const y0 = scratch_aabb[1];
+
+    const dy = y1 - y0;
+    const a = dx * dy;
+
+    const cx = (aabb[0] + aabb[3]) * 0.5;
+    const cy = (aabb[1] + aabb[4]) * 0.5;
+    const cz = (aabb[2] + aabb[5]) * 0.5;
+
+    /* compute W projection value, using conservative estimate
+       @see https://twitter.com/SebAaltonen/status/1332332808979832832
+       @see https://gist.github.com/slembcke/b2b2af4dede1d5702a635dc2d0e45d54
+    */
+    const w = matrix[3] * cx + matrix[7] * cy + matrix[11] * cz + matrix[15];
+    const d = 0.5 / Math.abs(w);
+
+    return a * d * d;
+}

package/core/geom/3d/aabb/aabb3_matrix4_project.js

@@ -0,0 +1,33 @@
+
+/**
+ * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
+ * @param {number[]} result
+ * @param {number[]} aabb
+ * @param {number[]} matrix 4x4 matrix
+ */
+export function aabb3_matrix4_project(result, aabb, matrix) {
+    // extract translation from matrix
+    result[0] = result[3] = matrix[12];
+    result[1] = result[4] = matrix[13];
+    result[2] = result[5] = matrix[14];
+
+    // apply 3x3 matrix transform
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+
+            const m_a = i * 4 + j;
+            const m_v = matrix[m_a];
+
+            const a = m_v * aabb[j];
+            const b = m_v * aabb[j + 3];
+
+            if (a < b) {
+                result[i] += a;
+                result[i + 3] += b;
+            } else {
+                result[i] += b;
+                result[i + 3] += a;
+            }
+        }
+    }
+}

package/core/geom/3d/aabb/aabb3_matrix4_project.spec.js

@@ -0,0 +1,41 @@
+import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+
+test('identity', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        0, 0, 0, 1
+    ]);
+
+    expect(r).toEqual([1, 2, 3, 5, 7, 9]);
+});
+
+test('translation case', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        13, -17, 23, 1
+    ]);
+
+    expect(r).toEqual([14, -15, 26, 18, -10, 32]);
+});
+
+
+test('scale case', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        -1, 0, 0, 0,
+        0, 2, 0, 0,
+        0, 0, -3, 0,
+        0, 0, 0, 1
+    ]);
+
+    expect(r).toEqual([-5, 4, -27, -1, 14, -9]);
+});

package/core/geom/3d/plane/plane3_lerp.js

@@ -1,5 +1,5 @@
 import { lerp } from "../../../math/lerp.js";
-import Vector3, { v3_dot, v3Length_i } from "../../Vector3.js";
+import Vector3, { v3_dot, v3_length } from "../../Vector3.js";
 import { plane3_intersect_plane } from "./plane3_intersect_plane.js";
 
 const v0 = new Vector3();
@@ -32,7 +32,7 @@ export function plane3_lerp(
     let normal_z = lerp(a_normal_z, b_normal_z, t);
 
     // normalize the normal vector
-    const normal_length = v3Length_i(normal_x, normal_y, normal_z);
+    const normal_length = v3_length(normal_x, normal_y, normal_z);
     const normal_length_inv = 1 / normal_length;
 
     normal_x *= normal_length_inv;

package/core/geom/3d/topology/TopoTriangle.js

@@ -1,4 +1,4 @@
-import { v3Length_i } from "../../Vector3.js";
+import { v3_length } from "../../Vector3.js";
 import { array_replace_all } from "../../../collection/array/array_replace_all.js";
 import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
 import { assert } from "../../../assert.js";
@@ -40,7 +40,7 @@ export function compute_triangle_normal(result, vA, vB, vC) {
     const crossY = vCBz * vABx - vCBx * vABz;
     const crossZ = vCBx * vABy - vCBy * vABx;
 
-    const l = v3Length_i(crossX, crossY, crossZ);
+    const l = v3_length(crossX, crossY, crossZ);
 
     if (l === 0) {
         // degenerate triangle, provide arbitrary invalid result

package/core/geom/AABB2.d.ts

@@ -20,5 +20,7 @@ export default class AABB2 {
 
     grow(size: number): void
 
+    shrink(size: number): void
+
     setNegativelyInfiniteBounds(): void
 }

package/core/geom/Matrix4.js

@@ -1,4 +1,4 @@
-import Vector3, { v3Length_i } from "./Vector3.js";
+import Vector3, { v3_length } from "./Vector3.js";
 
 const _z = new Vector3();
 const _x = new Vector3();
@@ -192,9 +192,9 @@ export class Matrix4 {
     decompose(position, rotation, scale) {
 
 
-        var sx = v3Length_i(this.a0, this.a1, this.a2);
-        var sy = v3Length_i(this.b0, this.b1, this.b2);
-        var sz = v3Length_i(this.c0, this.c1, this.c2);
+        var sx = v3_length(this.a0, this.a1, this.a2);
+        var sy = v3_length(this.b0, this.b1, this.b2);
+        var sz = v3_length(this.c0, this.c1, this.c2);
 
         // if determine is negative, we need to invert one scale
         var det = this.determinant();

package/core/geom/Vector3.js

@@ -883,7 +883,7 @@ class Vector3 {
      * @returns {number}
      */
     static distance(a, b) {
-        return v3Length_i(a.x - b.x, a.y - b.y, a.z - b.z);
+        return v3_length(a.x - b.x, a.y - b.y, a.z - b.z);
     }
 }
 
@@ -1008,10 +1008,10 @@ export function v3_distance_sqr(x0, y0, z0, x1, y1, z1) {
 
 
 function v3Length(v) {
-    return v3Length_i(v.x, v.y, v.z);
+    return v3_length(v.x, v.y, v.z);
 }
 
-export function v3Length_i(x, y, z) {
+export function v3_length(x, y, z) {
     return Math.sqrt(v3_length_sqr(x, y, z));
 }
 
@@ -1040,8 +1040,8 @@ export function v3_length_sqr(x, y, z) {
 export function v3_angleBetween(x0, y0, z0, x1, y1, z1) {
     const d = v3_dot(x0, y0, z0, x1, y1, z1);
 
-    const magnitude_0 = v3Length_i(x0, y0, z0);
-    const magnitude_1 = v3Length_i(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;
 

package/core/model/reactive/model/terminal/ReactiveReference.js

@@ -64,9 +64,15 @@ export class ReactiveReference extends ReactiveExpression {
         assert.notEqual(source, null, 'source is null');
         assert.notEqual(source, undefined, 'source is undefined');
         assert.typeOf(source.onChanged, 'object', 'source.onChanged');
-        assert.typeOf(source.onChanged.add, 'function', 'source.onChanged.add');
+        assert.isFunction(source.onChanged.add, 'source.onChanged.add');
 
         if (this.source !== null) {
+
+            if (this.source === source) {
+                // already connected to this source, do nothing
+                return;
+            }
+
             throw new Error('source is already set. Already connected');
         }
 

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -23,6 +23,7 @@ import { convert_three_object_to_micron } from "../../graphics/micron/convert_th
 import { HashSet } from "../../../core/collection/HashSet.js";
 import { computeGeometryHash } from "./geometry/geometry/computeGeometryHash.js";
 import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEquality.js";
+import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/traverseThreeObject.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
@@ -287,9 +288,7 @@ export class GLTFAssetLoader extends AssetLoader {
                 root = meshes[0];
             }
 
-            root.traverse(o => {
-                this.__prepareObjectMaterial(o);
-            });
+            traverseThreeObject(root, this.__prepareObjectMaterial, this);
 
             const root_transform = new Transform();
 
@@ -319,6 +318,7 @@ export class GLTFAssetLoader extends AssetLoader {
 
             await async_traverse(root, process_object);
 
+
             // compute object bounding sphere
             root.boundingSphere = computeObjectBoundingSphere(root);
 

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

@@ -2,6 +2,7 @@ import { TextureAttachment } from "./TextureAttachment.js";
 
 const taDiffuse = new TextureAttachment({
     name: 'diffuse',
+    uv_index: 0,
     read(m) {
         return m.map;
     },
@@ -12,6 +13,7 @@ const taDiffuse = new TextureAttachment({
 
 const taAlphaMap = new TextureAttachment({
     name: "alpha",
+    uv_index: 0,
     read(m) {
         return m.alphaMap;
     },
@@ -22,6 +24,7 @@ const taAlphaMap = new TextureAttachment({
 
 const taDisplacement = new TextureAttachment({
     name: "displacement",
+    uv_index: 0,
     read(m) {
         return m.displacementMap;
     },
@@ -45,6 +48,7 @@ export const TextureAttachmentsByMaterialType = {
         taAlphaMap,
         new TextureAttachment({
             name: "light",
+            uv_index: 1,
             read(m) {
                 return m.lightMap;
             },
@@ -54,6 +58,7 @@ export const TextureAttachmentsByMaterialType = {
         }),
         new TextureAttachment({
             name: "ao",
+            uv_index: 1,
             read(m) {
                 return m.aoMap;
             },
@@ -63,6 +68,7 @@ export const TextureAttachmentsByMaterialType = {
         }),
         new TextureAttachment({
             name: "emissive",
+            uv_index: 0,
             read(m) {
                 return m.emissiveMap;
             },
@@ -72,6 +78,7 @@ export const TextureAttachmentsByMaterialType = {
         }),
         new TextureAttachment({
             name: "bump",
+            uv_index: 0,
             read(m) {
                 return m.bumpMap;
             },
@@ -81,6 +88,7 @@ export const TextureAttachmentsByMaterialType = {
         }),
         new TextureAttachment({
             name: "normal",
+            uv_index: 0,
             read(m) {
                 return m.normalMap;
             },
@@ -91,6 +99,7 @@ export const TextureAttachmentsByMaterialType = {
         taDisplacement,
         new TextureAttachment({
             name: "roughness",
+            uv_index: 0,
             read(m) {
                 return m.roughnessMap;
             },
@@ -100,6 +109,7 @@ export const TextureAttachmentsByMaterialType = {
         }),
         new TextureAttachment({
             name: "metalness",
+            uv_index: 0,
             read(m) {
                 return m.metalnessMap;
             },
@@ -107,9 +117,9 @@ export const TextureAttachmentsByMaterialType = {
                 m.metalnessMap = t;
             }
         }),
-        taAlphaMap,
         new TextureAttachment({
             name: "environment",
+            uv_index: 0,
             read(m) {
                 return m.envMap;
             },

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

@@ -4,11 +4,22 @@ export class TextureAttachment {
      * @param {function(T):Texture} read
      * @param {function(T, Texture)} write
      * @param {string} [name]
+     * @param {number} [uv_index]
      */
-    constructor({ read, write, name }) {
+    constructor({ read, write, name, uv_index = 0 }) {
+        /**
+         *
+         * @type {string}
+         */
         this.name = name;
 
         this.read = read;
         this.write = write;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.uv_index = uv_index;
     }
 }

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

@@ -76,7 +76,7 @@ export function computeTextureEquality(a, b) {
  * @param {Image|[]} b
  * @returns {boolean}
  */
-function textureImagesEqual(a, b) {
+export function textureImagesEqual(a, b) {
     if (a === b) {
         return true;
     }

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

@@ -1,4 +1,4 @@
-import { computeHashFloat, computeHashIntegerArray} from "../../../../core/math/MathUtils.js";
+import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { computeImageBitmapHash } from "./computeImageBitmapHash.js";
 
@@ -19,7 +19,7 @@ function vector2Hash(v) {
  */
 const data_cache = new WeakMap();
 
-function computeImageDataHash(image) {
+export function computeImageDataHash(image) {
     const cached_value = data_cache.get(image);
 
     if (cached_value !== undefined) {
@@ -32,6 +32,19 @@ function computeImageDataHash(image) {
         result = computeImageBitmapHash(image);
     }
 
+    let width = 0;
+    let height = 0;
+
+    if (typeof image.width === "number") {
+        width = image.width;
+    }
+
+    if (typeof image.height === "number") {
+        height = image.height;
+    }
+
+    result = result ^ (((width & 0xFFFF) << 16) | (height & 0xFFFF));
+
     // cache value
     data_cache.set(image, result);
 
@@ -44,23 +57,12 @@ function computeImageDataHash(image) {
  * @return {number}
  */
 function computeSpecificHash(texture) {
-    let width = 0;
-    let height = 0;
-
     let dataHash = 0;
 
     if (texture.image !== null && texture.image !== undefined) {
 
         const image = texture.image;
 
-        if (typeof image.width === "number") {
-            width = image.width;
-        }
-
-        if (typeof image.height === "number") {
-            height = image.height;
-        }
-
         dataHash = computeImageDataHash(image);
 
     }
@@ -94,7 +96,7 @@ function computeSpecificHash(texture) {
 
     }
 
-    return computeHashIntegerArray(width, height, dataHash);
+    return dataHash;
 }
 
 /**

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

@@ -3,7 +3,7 @@ import { TextureAttachmentsByMaterialType } from "./TextureAttachmensByMaterialT
 /**
  *
  * @param {Material} material
- * @param {function(Texture)} callback
+ * @param {function(THREE.Texture, TextureAttachment)} callback
  * @param {*} [thisArg]
  */
 export function traverseMaterialTextures(material, callback, thisArg) {
@@ -30,7 +30,7 @@ export function traverseMaterialTextures(material, callback, thisArg) {
                 continue;
             }
 
-            callback.call(thisArg, texture);
+            callback.call(thisArg, texture, attachment);
 
         }
     }

package/engine/ecs/animation/OneBoneSurfaceAlignmentSolver.js

@@ -3,7 +3,7 @@ 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, v3Length_i } from "../../../core/geom/Vector3.js";
+import Vector3, { v3_dot, v3_length } from "../../../core/geom/Vector3.js";
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import { v3_computeOffsetVector } from "./IKMath.js";
 
@@ -127,7 +127,7 @@ export class OneBoneSurfaceAlignmentSolver extends IKSolver {
         //check if current effector position is above the contact point
         const dot_contact_side = v3_dot(directionX, directionY, directionZ, delta_contact_c_x, delta_contact_c_y, delta_contact_c_z);
 
-        const delta_contact_c_length = v3Length_i(delta_contact_c_x, delta_contact_c_y, delta_contact_c_z);
+        const delta_contact_c_length = v3_length(delta_contact_c_x, delta_contact_c_y, delta_contact_c_z);
 
         let influence;