@woosh/meep-engine 2.33.24 → 2.33.28

package/core/binary/ValidatingBitSetWrapper.js

@@ -0,0 +1,81 @@
+//
+
+/**
+ * Debug tool to verify correct behavior of a BitSet
+ */
+export class ValidatingBitSetWrapper {
+    /**
+     *
+     * @param {BitSet} source
+     */
+    constructor(source) {
+        this.__source = source;
+    }
+
+    preventShrink() {
+        this.__source.preventShrink();
+    }
+
+    setShrinkFactor(x) {
+        this.__source.setShrinkFactor(x);
+    }
+
+    setCapacity(x) {
+        this.__source.setCapacity(x);
+    }
+
+    size() {
+        return this.__source.size();
+    }
+
+    capacity() {
+        return this.__source.capacity();
+    }
+
+    previousSetBit(i) {
+        const bit = this.__source.previousSetBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== true || bit > i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    nextSetBit(i) {
+        const bit = this.__source.nextSetBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== true || bit < i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    nextClearBit(i) {
+        const bit = this.__source.nextClearBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== false || bit < i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    set(x, y) {
+        this.__source.set(x, y);
+    }
+
+    clear(i) {
+        this.__source.clear(i);
+    }
+
+    get(i) {
+        return this.__source.get(i);
+    }
+
+
+    reset() {
+        this.__source.reset();
+    }
+}

package/core/bvh2/aabb3/AABB3.js

@@ -761,16 +761,9 @@ AABB3.prototype.computePlaneSide = function computePlaneSide(plane) {
     const normal = plane.normal;
 
     return computeAABB3PlaneSide(
-        normal.x,
-        normal.y,
-        normal.z,
-        plane.constant,
-        this.x0,
-        this.y0,
-        this.z0,
-        this.x1,
-        this.y1,
-        this.z1
+        normal.x, normal.y, normal.z, plane.constant,
+        this.x0, this.y0, this.z0,
+        this.x1, this.y1, this.z1
     );
 };
 

package/core/bvh2/binary/IndexedBinaryBVH.js

@@ -344,7 +344,7 @@ function writeBox(array, address, x0, y0, z0, x1, y1, z1) {
  * @param {Float32Array} array
  */
 function copyBox(from, to, array) {
-    array_copy(data, from, scratch_aabb_0, to, 6);
+    array_copy(array, from, array, to, 6);
 }
 
 /**

package/core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js

@@ -40,7 +40,11 @@ export class ThreeClippingPlaneComputingBVHVisitor extends BVHVisitor {
          */
         this.__nearPlaneConstant = 0;
 
-
+        /**
+         *
+         * @type {Float32Array}
+         * @private
+         */
         this.__planes_f32 = new Float32Array(24);
 
         this.near = 0;

package/core/bvh2/traversal/__detailed_box_volume_intersection.js

@@ -7,37 +7,54 @@ import { __process_point_if_within_planes } from "./__process_point_if_within_pl
 import { plane_computeConvex3PlaneIntersection } from "../../geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 import { EPSILON } from "../../math/MathUtils.js";
 
+/**
+ * Common piece of continuous memory for better cache coherence
+ * @type {ArrayBuffer}
+ * @private
+ */
+const __scratch_buffer = new ArrayBuffer(
+    24 * 4
+    + 24 * 4
+    + 8 * 4
+    + 3 * 4
+);
+
 /**
  *
  * @type {number[]}
  */
-const scratch_aabb_corners = new Float32Array(24);
+const scratch_aabb_corners = new Float32Array(__scratch_buffer, 0, 24);
 
 /**
  *
  * @type {number[]}
  */
-const scratch_aabb_planes = new Float32Array(24);
+const scratch_aabb_planes = new Float32Array(__scratch_buffer, 96, 24);
 
 /**
  *
  * @type {number[]}
  */
-const scratch_corner_out_bitfields = new Uint32Array(8);
+const scratch_corner_out_bitfields = new Uint32Array(__scratch_buffer, 192, 8);
 
 /**
  *
  * @type {number[]}
  */
-const scratch_v3_array = new Float32Array(3);
+const scratch_v3_array = new Float32Array(__scratch_buffer, 224, 3);
 
 /**
+ * Figures out intersection volume between an AABB and a frustum for much tighter bounds
+ *
+ * Especially beneficial when trying to intersect a large AABB against a small frustum,
+ * where where traditionally only AABB corners would be considered,
+ * we're instead able to compute minimum bounds of the overlap of the two
  *
  * @param {AABB3} box
  * @param {number[]} planes
  * @param {number} plane_count
  * @param {number} plane_mask
- * @param {function} callback
+ * @param {function(x:number,y:number,z:number)} callback
  * @param {*} [thisArg]
  * @private
  */

package/core/cache/Cache.d.ts

@@ -4,13 +4,15 @@ export class Cache<K, V> {
                     keyWeigher,
                     valueWeigher,
                     keyHashFunction,
-                    keyEqualityFunction
+                    keyEqualityFunction,
+                    capacity
                 }?: {
         maxWeight?: number,
         keyWeigher?: (key: K) => number,
         valueWeigher?: (value: V) => number,
         keyHashFunction?: (key: K) => number,
-        keyEqualityFunction?: (a: K, b: K) => boolean
+        keyEqualityFunction?: (a: K, b: K) => boolean,
+        capacity?: number
     })
 
     size(): number

package/core/cache/Cache.js

@@ -16,6 +16,7 @@ export class Cache {
      * @param {function(key:Key, value:Value)} [removeListener] will be notified when element is either explicitly removed or evicted
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
+     * @param {number} capacity initial capacity for the cache, helps prevent early resizing
      * @constructor
      * @template Key, Value
      */
@@ -25,7 +26,8 @@ export class Cache {
                     valueWeigher = returnOne,
                     removeListener = noop,
                     keyHashFunction = returnZero,
-                    keyEqualityFunction = strictEquals
+                    keyEqualityFunction = strictEquals,
+                    capacity
                 } = {}) {
 
         assert.isNumber(maxWeight, 'maxWeight');
@@ -95,7 +97,8 @@ export class Cache {
          */
         this.data = new HashMap({
             keyHashFunction,
-            keyEqualityFunction
+            keyEqualityFunction,
+            capacity
         });
 
         /**

package/core/collection/HashMap.d.ts

@@ -1,7 +1,14 @@
 export class HashMap<K, V> implements Iterable<[V, K]> {
-    constructor({keyHashFunction, keyEqualityFunction}: {
+    constructor({
+                    keyHashFunction,
+                    keyEqualityFunction,
+                    capacity,
+                    loadFactor
+                }: {
         keyHashFunction: (k: K) => number,
-        keyEqualityFunction: (a: K, b: K) => boolean
+        keyEqualityFunction: (a: K, b: K) => boolean,
+        capacity?: number,
+        loadFactor?: number
     })
 
     constructor()

package/core/collection/HashSet.d.ts

@@ -1,7 +1,12 @@
 export class HashSet<T> {
-    constructor({keyHashFunction, keyEqualityFunction}: {
+    constructor({
+                    keyHashFunction,
+                    keyEqualityFunction,
+                    capacity
+                }: {
         keyHashFunction: (k: T) => number,
-        keyEqualityFunction: (a: T, b: T) => boolean
+        keyEqualityFunction: (a: T, b: T) => boolean,
+        capacity?: number
     })
 
     constructor()

package/core/collection/HashSet.js

@@ -11,7 +11,11 @@ export class HashSet {
     /**
      * @template T
      */
-    constructor({ keyHashFunction = invokeObjectHash, keyEqualityFunction = invokeObjectEquals } = {}) {
+    constructor({
+                    keyHashFunction = invokeObjectHash,
+                    keyEqualityFunction = invokeObjectEquals,
+                    capacity
+                } = {}) {
 
         /**
          * Using HashMap as a backing, this is not the most efficient approach, but it works
@@ -20,7 +24,8 @@ export class HashSet {
          */
         this.__map = new HashMap({
             keyHashFunction,
-            keyEqualityFunction
+            keyEqualityFunction,
+            capacity
         });
     }
 

package/core/collection/array/binarySearchHighIndex.js

@@ -1,6 +1,6 @@
 /**
  * @template T,V
- * @param {T[]} array
+ * @param {T[]|ArrayLike<T>|Float32Array} array
  * @param {V} el
  * @param {function(V,T):number} compareFunction
  * @param {number} [minIndex]

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|Uint8ClampedArray|Uint8Array} source The source array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Float32Array|Float64Array} source The source array
  * @param {number} source_position Starting position where to copy from inside the source array
- * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} destination The destination array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Float32Array|Float64Array} 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/array/typed/typed_array_copy.js

@@ -2,7 +2,7 @@ import { array_copy } from "../copyArray.js";
 
 
 /**
- *
+ * Assumes arrays have the same type
  * @param {TypedArray|Float32Array} source
  * @param {TypedArray|Float32Array} destination
  */

package/core/geom/3d/frustum/array_setFromProjectionMatrix.js

@@ -1,5 +1,3 @@
-import { v3_length } from "../../v3_length.js";
-
 /**
  *
  * @param {number[]} destination
@@ -10,10 +8,12 @@ import { v3_length } from "../../v3_length.js";
  * @param {number} w
  */
 function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
-    const length = v3_length(x, y, z);
+    // compute vector length
+    const length = Math.hypot(x, y, z);
 
     const inverseNormalLength = 1.0 / length;
 
+    // apply normalization
     destination[destination_offset] = x * inverseNormalLength;
     destination[destination_offset + 1] = y * inverseNormalLength;
     destination[destination_offset + 2] = z * inverseNormalLength;

package/core/geom/3d/normal/hemioct/unit_hemioct.spec.js

@@ -1,5 +1,5 @@
 import { decode_hemioct_to_unit, encode_unit_to_hemioct } from "./encode_unit3_hemioct.js";
-import { v3_length } from "../../../Vector3.d.ts";
+import { v3_length } from "../../../v3_length.js";
 
 test('encode-decode', () => {
     const v0 = [];

package/core/geom/3d/shape/AbstractShape3D.js

@@ -1,5 +1,31 @@
 export class AbstractShape3D {
-    constructor() {
+    /**
+     * Signed distance to boundary of the shape from the given point
+     * @param {number[]} point
+     * @returns {number}
+     */
+    signed_distance_at_point(point) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * Samples both distances as well as the gradient
+     * @param {number[]} result resulting gradient is written here
+     * @param {number[]} point sampling point
+     * @returns {number}
+     */
+    signed_distance_gradient_at_point(result, point) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {number[]} result where the resulting point is stored
+     * @param {number[]} reference reference point from which to go
+     * @returns {void}
+     */
+    nearest_point_on_surface(result, reference) {
+        throw new Error('Not Implemented');
     }
 
     /**
@@ -7,11 +33,21 @@ export class AbstractShape3D {
      * @param {number[]} result
      * @param {number} result_offset
      * @param {function} random
+     * @returns {void}
      */
     sample_random_point_in_volume(result, result_offset, random) {
         throw new Error('Not Implemented');
     }
 
+    /**
+     * Whether or not given point is inside the shape
+     * @param {number[]} point
+     * @returns {boolean}
+     */
+    contains_point(point) {
+        throw new Error('Not Implemented');
+    }
+
     /**
      * Total volume of the shape
      * @returns {number}

package/core/geom/3d/shape/TransformedShape3D.js

@@ -1,11 +1,12 @@
 import { mat4, vec3 } from "gl-matrix";
 import { AbstractShape3D } from "./AbstractShape3D.js";
+import { sign } from "../../../math/sign.js";
 
 /**
  *
  * @type {number[]|Float32Array|vec3}
  */
-const scratch_v3 = [];
+const scratch_v3_0 = [];
 
 export class TransformedShape3D extends AbstractShape3D {
     constructor() {
@@ -17,6 +18,14 @@ export class TransformedShape3D extends AbstractShape3D {
          * @private
          */
         this.__matrix = new Float32Array(16);
+
+        /**
+         *
+         * @type {Float32Array|mat4}
+         * @private
+         */
+        this.__inverse_matrix = new Float32Array(16);
+
         /**
          *
          * @type {AbstractShape3D|null}
@@ -27,7 +36,15 @@ export class TransformedShape3D extends AbstractShape3D {
 
     /**
      *
-     * @param {number[]|Float32Array} m4
+     * @returns {AbstractShape3D|null}
+     */
+    get subject() {
+        return this.__subject;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array|mat4} m4
      * @param {AbstractShape3D} subject
      * @returns {TransformedShape3D}
      */
@@ -35,36 +52,130 @@ export class TransformedShape3D extends AbstractShape3D {
         const r = new TransformedShape3D();
 
         r.__subject = subject;
-        r.__matrix = m4;
+        r.transform = m4;
 
         return r;
     }
 
+    /**
+     *
+     * @param {AbstractShape3D} subject
+     * @param {number[]} translation
+     * @param {number[]} scale
+     */
+    static from_translation_scale(subject, translation, scale) {
+
+        const mat = mat4.create();
+        mat4.fromRotationTranslationScale(mat, [0, 0, 0, 1], translation, scale);
+
+        return TransformedShape3D.from_m4(subject, mat);
+    }
+
+    /**
+     *
+     * @returns {TransformedShape3D}
+     * @param {AbstractShape3D} subject
+     * @param {number[]|Float32Array|vec3} scale
+     */
+    static from_scale(subject, scale) {
+        const mat = mat4.create();
+        mat4.fromScaling(mat, scale);
+
+        return TransformedShape3D.from_m4(subject, mat);
+    }
+
     /**
      *
      * @param {number[]|Float32Array} m
      */
     set transform(m) {
         this.__matrix.set(m);
+
+        mat4.invert(this.__inverse_matrix, this.__matrix);
+    }
+
+    get transform() {
+        return this.__matrix;
     }
 
     get volume() {
-        mat4.getScaling(scratch_v3, this.__matrix);
+        mat4.getScaling(scratch_v3_0, this.__matrix);
 
-        const scale_modifier = scratch_v3[0] * scratch_v3[1] * scratch_v3[2];
+        const scale_modifier = scratch_v3_0[0] * scratch_v3_0[1] * scratch_v3_0[2];
 
         return this.__subject.volume * scale_modifier;
     }
 
+    signed_distance_gradient_at_point(result, point) {
+        // transform point to subject's local space
+        vec3.transformMat4(scratch_v3_0, point, this.__inverse_matrix);
+
+        const subject = this.__subject;
+
+        // sample gradient at the point
+        const distance = subject.signed_distance_gradient_at_point(scratch_v3_0, scratch_v3_0);
+
+        const m = this.__matrix;
+
+        const m11 = m[0];
+        const m12 = m[1];
+        const m13 = m[2];
+
+        const m21 = m[4];
+        const m22 = m[5];
+        const m23 = m[6];
+
+        const m31 = m[8];
+        const m32 = m[9];
+        const m33 = m[10];
+
+        const scale_x = Math.hypot(m11, m12, m13);
+        const scale_y = Math.hypot(m21, m22, m23);
+        const scale_z = Math.hypot(m31, m32, m33);
+
+        const scaled_gx = scratch_v3_0[0] * scale_x;
+        const scaled_gy = scratch_v3_0[1] * scale_y;
+        const scaled_gz = scratch_v3_0[2] * scale_z;
+
+        // normalize gradient
+        const gd = distance / Math.hypot(scratch_v3_0[0], scratch_v3_0[1], scratch_v3_0[2]);
+
+        const scaled_dx = scaled_gx * gd ;
+        const scaled_dy = scaled_gy * gd ;
+        const scaled_dz = scaled_gz * gd ;
+
+        // determine sign
+        const result_sign = sign(distance);
+
+        const scaled_distance = result_sign * Math.sqrt(scaled_dx * scaled_dx + scaled_dy * scaled_dy + scaled_dz * scaled_dz);
+
+        result[0] = scaled_gx;
+        result[1] = scaled_gy;
+        result[2] = scaled_gz;
+
+        return scaled_distance;
+    }
+
+    signed_distance_at_point(point) {
+        return this.signed_distance_gradient_at_point(scratch_v3_0, point);
+    }
+
+    contains_point(point) {
+        // transform point to subject's local space
+        vec3.transformMat4(scratch_v3_0, point, this.__inverse_matrix);
+
+        return this.__subject.contains_point(scratch_v3_0);
+    }
+
     sample_random_point_in_volume(result, result_offset, random) {
-        this.__subject.sample_random_point_in_volume(scratch_v3, 0, random);
+        this.__subject.sample_random_point_in_volume(scratch_v3_0, 0, random);
 
         // apply transform
-        vec3.transformMat4(scratch_v3, scratch_v3, this.__matrix);
+        vec3.transformMat4(scratch_v3_0, scratch_v3_0, this.__matrix);
 
         // write out
-        result[0] = scratch_v3[0];
-        result[1] = scratch_v3[1];
-        result[2] = scratch_v3[2];
+        result[0] = scratch_v3_0[0];
+        result[1] = scratch_v3_0[1];
+        result[2] = scratch_v3_0[2];
     }
 }

package/core/geom/3d/shape/TransformedShape3D.spec.js

@@ -0,0 +1,33 @@
+import { UnitCubeShape3D } from "./UnitCubeShape3D.js";
+import { TransformedShape3D } from "./TransformedShape3D.js";
+
+test('signed distance identity transform', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [1, 1, 1]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(-0.5);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(0.5);
+});
+
+test('signed distance translation', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [1, 0, 0], [1, 1, 1]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(0.5);
+
+    expect(s.signed_distance_at_point([-1, 0, 0])).toBeCloseTo(1.5);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(-0.5);
+});
+
+test('signed distance scale', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 2, 2]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(-1);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([2, 0, 0])).toBeCloseTo(1);
+});