@woosh/meep-engine 2.33.23 → 2.33.24

package/core/bvh2/binary/IndexedBinaryBVH.js

@@ -6,8 +6,13 @@ import { min2 } from "../../math/min2.js";
 import { IndexedBinaryBVHVisitor } from "./IndexedBinaryBVHVisitor.js";
 import { NodeType } from "./NodeType.js";
 import { RayLeafIntersectionVisitor } from "./RayLeafIntersectionVisitor.js";
+import { array_copy } from "../../collection/array/copyArray.js";
 
 
+/**
+ *
+ * @type {Float32Array|number[]}
+ */
 const scratch_aabb_0 = new Float32Array(6);
 
 
@@ -30,16 +35,16 @@ export default class IndexedBinaryBVH {
         this.binaryNodeCount = 0;
 
         /**
-         *
+         * Total number of boxes contained in the tree, some might be unused
          * @type {number}
          */
         this.boxCount = 0;
 
         /**
          *
-         * @type {null|Float32Array}
+         * @type {Float32Array|number[]}
          */
-        this.data = null;
+        this.data = new Float32Array(16);
     }
 
     /**
@@ -59,7 +64,14 @@ export default class IndexedBinaryBVH {
 
         this.boxCount = this.leafNodeCount + this.binaryNodeCount;
 
-        this.data = new Float32Array(this.boxCount * 6);
+        // possibly resize the storage
+        const storage_size = this.boxCount * 6;
+
+        if (this.data.length < storage_size) {
+            this.data = new Float32Array(storage_size);
+        } else {
+            this.data.fill(0);
+        }
     }
 
     unsortedBuiltIntermediate() {
@@ -117,7 +129,7 @@ export default class IndexedBinaryBVH {
         }
 
         //set bounds of the bvh
-        copy_box_array(0, data, scratch_aabb_0, 0);
+        array_copy(data, 0, scratch_aabb_0, 0, 6);
 
         this.x0 = scratch_aabb_0[0];
         this.y0 = scratch_aabb_0[1];
@@ -238,7 +250,7 @@ export default class IndexedBinaryBVH {
     }
 
     /**
-     *
+     * @deprecated use a visitor object instead
      * @param {number} startX
      * @param {number} startY
      * @param {number} startZ
@@ -265,22 +277,6 @@ export default class IndexedBinaryBVH {
     }
 }
 
-/**
- *
- * @param {number} source_offset
- * @param {number[]|Float32Array} source
- * @param {number[]|Float32Array} destination
- * @param {number} destination_offset
- */
-function copy_box_array(source_offset, source, destination, destination_offset) {
-    destination[destination_offset] = source[source_offset];
-    destination[destination_offset + 1] = source[source_offset + 1];
-    destination[destination_offset + 2] = source[source_offset + 2];
-    destination[destination_offset + 3] = source[source_offset + 3];
-    destination[destination_offset + 4] = source[source_offset + 4];
-    destination[destination_offset + 5] = source[source_offset + 5];
-}
-
 /**
  *
  * @param {number[]|Float32Array} source
@@ -348,23 +344,23 @@ function writeBox(array, address, x0, y0, z0, x1, y1, z1) {
  * @param {Float32Array} array
  */
 function copyBox(from, to, array) {
-    copy_box_array(from, array, array, to);
+    array_copy(data, from, scratch_aabb_0, to, 6);
 }
 
 /**
  *
  * @param {number} from
  * @param {number} to
- * @param {Float32Array} array
+ * @param {Float32Array|number[]} array
  */
 function copyBoxZeroSize(from, to, array) {
-    copy_box_array(from, array, scratch_aabb_0, 0);
+    array_copy(array, from, scratch_aabb_0, 0, 3);
 
     scratch_aabb_0[3] = scratch_aabb_0[0];
     scratch_aabb_0[4] = scratch_aabb_0[1];
     scratch_aabb_0[5] = scratch_aabb_0[2];
 
-    copy_box_array(0, scratch_aabb_0, array, to);
+    array_copy(scratch_aabb_0, 0, array, to, 6);
 }
 
 /**

package/core/collection/ArrayUtils.js

@@ -6,9 +6,9 @@
  */
 import { assert } from "../assert.js";
 import { returnZero } from "../function/Functions.js";
-import { randomIntegerBetween } from "../math/MathUtils.js";
 import { min2 } from "../math/min2.js";
 import { HashMap } from "./HashMap.js";
+import { randomIntegerBetween } from "../math/random/randomIntegerBetween.js";
 
 
 /**

package/core/collection/array/arrayQuickSort.js

@@ -5,11 +5,14 @@ const stack = [];
 /**
  * @template T
  * @param {T[]} data
- * @param {function(T):number} keyExtractor
+ * @param {function(T):number} score_function
+ * @param {*} score_function_context
  * @param {number} start
  * @param {number} end
+ * @param {function(T[],number, number):*} [swap_operator]
+ * @param {*} [swap_context]
  */
-export function arrayQuickSort(data, keyExtractor, start, end) {
+export function arrayQuickSort(data, score_function, score_function_context, start, end, swap_operator = arraySwapElements, swap_context = undefined) {
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;
@@ -32,15 +35,15 @@ export function arrayQuickSort(data, keyExtractor, start, end) {
 
         const pivotIndex = (left + right) >> 1;
 
-        const pivot = keyExtractor(data[pivotIndex]);
+        const pivot = score_function.call(score_function_context,data[pivotIndex]);
 
         /* partition */
         while (i <= j) {
-            while (keyExtractor(data[i]) < pivot) {
+            while (score_function.call(score_function_context,data[i]) < pivot) {
                 i++;
             }
 
-            while (keyExtractor(data[j]) > pivot) {
+            while (score_function.call(score_function_context,data[j]) > pivot) {
                 j--;
             }
 
@@ -48,7 +51,7 @@ export function arrayQuickSort(data, keyExtractor, start, end) {
 
                 if (i !== j) {
                     //do swap
-                    arraySwapElements(data, i, j);
+                    swap_operator.call(swap_context, data, i, j);
                 }
 
                 i++;

package/core/collection/array/array_swap.js

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} a
+ * @param {number} a_offset
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} b
+ * @param {number} b_offset
+ * @param {number} length How many elements should be moved
+ */
+export function array_swap(a, a_offset, b, b_offset, length) {
+
+    let i, j, k;
+
+    for (k = 0; k < length; k++) {
+        i = a_offset + k;
+        j = b_offset + k;
+
+        const t = b[j];
+
+        b[j] = a[i];
+        a[i] = t;
+    }
+}

package/core/collection/array/computeHashArray.js

@@ -0,0 +1,22 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {function(T):number} elementHashFunction
+ */
+export function computeHashArray(array, elementHashFunction) {
+
+    const numArguments = array.length;
+    let hash = numArguments;
+
+    for (let i = 0; i < numArguments; i++) {
+
+        const singleValue = array[i];
+
+        const elementHash = elementHashFunction(singleValue);
+
+        hash = ((hash << 5) - hash) + elementHash;
+        hash |= 0; // Convert to 32bit integer
+    }
+
+    return hash;
+}

package/core/collection/array/computeHashIntegerArray.js

@@ -0,0 +1,15 @@
+/**
+ * Computes hash on integer values
+ * @param {...number} value
+ * @returns {number}
+ */
+export function computeHashIntegerArray(value) {
+    let hash = 0;
+    const numArguments = arguments.length;
+    for (let i = 0; i < numArguments; i++) {
+        const singleValue = arguments[i];
+        hash = ((hash << 5) - hash) + singleValue;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}

package/core/collection/table/DataType2TypedArrayConstructorMapping.js

@@ -16,4 +16,19 @@ export const DataType2TypedArrayConstructorMapping = {
     [DataType.Float16]: Uint16Array,
     [DataType.Float32]: Float32Array,
     [DataType.Float64]: Float64Array,
+};
+
+/**
+ *
+ * @param {DataType} dt
+ * @returns {constructor|function}
+ */
+export function compute_typed_array_constructor_from_data_type(dt) {
+    const r = DataType2TypedArrayConstructorMapping[dt];
+
+    if (r === undefined) {
+        throw new Error(`Unsupported data type '${dt}'`);
+    }
+
+    return r;
 }

package/core/color/Color.js

@@ -1,11 +1,12 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
-import { computeHashFloat, computeHashIntegerArray } from "../math/MathUtils.js";
 import { parseColor, rgb2hsv } from "./ColorUtils.js";
 import { clamp } from "../math/clamp.js";
 import { min2 } from "../math/min2.js";
 import { max2 } from "../math/max2.js";
 import { min3 } from "../math/min3.js";
+import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 class Color {
     /**

package/core/function/FunctionCompiler.js

@@ -1,11 +1,12 @@
 import { assert } from "../assert.js";
 import { Cache } from "../cache/Cache.js";
 import { isArrayEqualStrict } from "../collection/array/isArrayEqualStrict.js";
-import { computeHashArray, computeHashIntegerArray } from "../math/MathUtils.js";
 import { invokeObjectEquals } from "../model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../model/object/invokeObjectHash.js";
 import { computeStringHash } from "../primitives/strings/computeStringHash.js";
 import { computeUTF8StringByteSize } from "../primitives/strings/StringUtils.js";
+import { computeHashArray } from "../collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
 
 /**
  * Hash is an integer value, so this is an invalid value for a computed hash

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

@@ -1,5 +1,3 @@
-import { computePointDistanceToPlane } from "../../Plane.js";
-
 /**
  * @param {number} plane_normal_x
  * @param {number} plane_normal_y
@@ -14,38 +12,16 @@ import { computePointDistanceToPlane } from "../../Plane.js";
  * @returns {number}
  */
 export function aabb3_computeDistanceAbovePlane(
-    plane_normal_x,
-    plane_normal_y,
-    plane_normal_z,
-    plane_constant,
-    _x0,
-    _y0,
-    _z0,
-    _x1,
-    _y1,
-    _z1
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+    _x0, _y0, _z0,
+    _x1, _y1, _z1
 ) {
 
-    let px, py, pz;
-
-    // pick a corner point furthest along the normal
-    if (plane_normal_x > 0) {
-        px = _x1;
-    } else {
-        px = _x0;
-    }
-
-    if (plane_normal_y > 0) {
-        py = _y1;
-    } else {
-        py = _y0;
-    }
-
-    if (plane_normal_z > 0) {
-        pz = _z1;
-    } else {
-        pz = _z0;
-    }
+    // pick a corner point furthest along the plane normal
+    const px = plane_normal_x > 0 ? _x1 : _x0;
+    const py = plane_normal_y > 0 ? _y1 : _y0;
+    const pz = plane_normal_z > 0 ? _z1 : _z0;
 
-    return computePointDistanceToPlane(px, py, pz, plane_normal_x, plane_normal_y, plane_normal_z, plane_constant);
+    // dot(v4,v4) inlined for speed
+    return (plane_normal_x * px + plane_normal_y * py + plane_normal_z * pz) + plane_constant;
 }

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

@@ -1,8 +1,8 @@
-import { ray_computeNearestPointToPoint } from "../../LineSegment.js";
 import { computePlanePlaneIntersection, computePointDistanceToPlane } from "../../Plane.js";
 import Vector3 from "../../Vector3.js";
 import { plane3_projectPoint } from "../plane/plane3_projectPoint.js";
 import { plane_three_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
+import { ray_computeNearestPointToPoint } from "../ray/ray_computeNearestPointToPoint.js";
 
 /**
  *

package/core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js

@@ -0,0 +1,41 @@
+import { clamp } from "../../../math/clamp.js";
+import { v3_distance_sqr } from "../../v3_distance_sqr.js";
+
+/**
+ * Computes shortest distance between a line segment(defined by 2 points) and a point
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ */
+export function line3_computeSegmentPointDistance_sqr(x0, y0, z0, x1, y1, z1, px, py, pz) {
+    // get line delta
+    const line_delta_x = x1 - x0;
+    const line_delta_y = y1 - y0;
+    const line_delta_z = z1 - z0;
+
+    // find closest point
+    const sp0_x = px - x0;
+    const sp0_y = py - y0;
+    const sp0_z = pz - z0;
+
+    //
+    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y + line_delta_z * line_delta_z;
+
+    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
+
+    const t = clamp(d3 / d2, 0, 1);
+
+    // compute point on the line
+    const lp_x = line_delta_x * t + x0;
+    const lp_y = line_delta_y * t + y0;
+    const lp_z = line_delta_z * t + z0;
+
+    // compute distance from the point in question to the point on the line
+    return v3_distance_sqr(px, py, pz, lp_x, lp_y, lp_z);
+}

package/core/geom/3d/morton/mortonEncode_magicbits.js

@@ -1,10 +1,11 @@
 /**
  * method to separate bits from a given integer 3 positions apart
+ * we only look at the first 10 bits
  * @param {number} a
  * @returns {number}
  */
 function splitBy3(a) {
-    let x = a & 0x000003ff; // we only look at the first 10 bits
+    let x = a;
     x = (x | x << 16) & 0x30000ff;
     x = (x | x << 8) & 0x0300f00f;
     x = (x | x << 4) & 0x30c30c3;

package/core/geom/3d/morton/reinterpret_float32_as_int32.js

@@ -0,0 +1,13 @@
+const b = new ArrayBuffer(4);
+const b_f32 = new Float32Array(b);
+const b_i32 = new Int32Array(b);
+
+/**
+ *
+ * @param {number} value
+ * @returns {number}
+ */
+export function reinterpret_float32_as_int32(value) {
+    b_f32[0] = value;
+    return b_i32[0];
+}

package/core/geom/3d/morton/v3_morton_encode_transformed.js

@@ -0,0 +1,33 @@
+import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
+
+/**
+ * Assumes that coordinates will be mapped to -1..1 range after transform
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]} matrix matrix to transform supplied coordinates to Normalized Device Coordinates
+ * @returns {number}
+ */
+export function v3_morton_encode_transformed(x, y, z, matrix) {
+
+    // apply matrix transform
+    const _x = matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12];
+    const _y = matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13];
+    const _z = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14];
+    const _w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+
+    const d = 1 / _w;
+
+    // apply perspective divide, values are now in Normalized Coordinate system (-1,1)
+    const px = _x * d;
+    const py = _y * d;
+    const pz = _z * d;
+
+    // scale each value up to 10 bits (for 10 bits, the multiplier = 1024. As we have -1,1 range, we do (v+1)/2. 1024/2 = 512)
+
+    const cx = ((px + 1) * 512) | 0;
+    const cy = ((py + 1) * 512) | 0;
+    const cz = ((pz + 1) * 512) | 0;
+
+    return mortonEncode_magicbits(cx, cy, cz);
+}

package/core/geom/3d/ray/ray_computeNearestPointToPoint.js

@@ -0,0 +1,37 @@
+import { v3_dot } from "../../v3_dot.js";
+
+/**
+ *
+ * @param {Vector3} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number} distance from origin, negative means that the point lies behind the origin in the direction opposite to the ray's own
+ */
+export function ray_computeNearestPointToPoint(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, px, py, pz) {
+    // find closest point
+    const sp0_x = px - origin_x;
+    const sp0_y = py - origin_y;
+    const sp0_z = pz - origin_z;
+
+    //
+    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
+    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
+
+    const t = d3 / d2;
+
+    // compute point on the ray
+    const lp_x = direction_x * t + origin_x;
+    const lp_y = direction_y * t + origin_y;
+    const lp_z = direction_z * t + origin_z;
+
+    result.set(lp_x, lp_y, lp_z);
+
+    return t;
+}

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

@@ -0,0 +1,29 @@
+export class AbstractShape3D {
+    constructor() {
+    }
+
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {function} random
+     */
+    sample_random_point_in_volume(result, result_offset, random) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * Total volume of the shape
+     * @returns {number}
+     */
+    get volume() {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * @returns {number}
+     */
+    get surface_area() {
+        throw new Error('Not Implemented');
+    }
+}

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

@@ -0,0 +1,60 @@
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { weightedRandomFromArray } from "../../../collection/array/weightedRandomFromArray.js";
+
+
+const scratch_array = [];
+
+/**
+ *
+ * @param {AbstractShape3D} shape
+ * @return {number}
+ */
+function getVolume(shape) {
+    return shape.volume;
+}
+
+export class CompositeShape extends AbstractShape3D {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {AbstractShape3D[]}
+         */
+        this.children = [];
+    }
+
+    get volume() {
+        let r = 0;
+
+        const children = this.children;
+        const child_count = children.length;
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            r += child.volume;
+        }
+
+        return r;
+    }
+
+    get surface_area(){
+        let r = 0;
+
+        const children = this.children;
+        const child_count = children.length;
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            r += child.surface_area;
+        }
+
+        return r;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        const child = weightedRandomFromArray(this.children, random, getVolume);
+
+        return child.sample_random_point_in_volume(result, result_offset, random);
+    }
+}

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

@@ -0,0 +1,70 @@
+import { mat4, vec3 } from "gl-matrix";
+import { AbstractShape3D } from "./AbstractShape3D.js";
+
+/**
+ *
+ * @type {number[]|Float32Array|vec3}
+ */
+const scratch_v3 = [];
+
+export class TransformedShape3D extends AbstractShape3D {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {number[]|Float32Array|mat4}
+         * @private
+         */
+        this.__matrix = new Float32Array(16);
+        /**
+         *
+         * @type {AbstractShape3D|null}
+         * @private
+         */
+        this.__subject = null;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} m4
+     * @param {AbstractShape3D} subject
+     * @returns {TransformedShape3D}
+     */
+    static from_m4(subject, m4) {
+        const r = new TransformedShape3D();
+
+        r.__subject = subject;
+        r.__matrix = m4;
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} m
+     */
+    set transform(m) {
+        this.__matrix.set(m);
+    }
+
+    get volume() {
+        mat4.getScaling(scratch_v3, this.__matrix);
+
+        const scale_modifier = scratch_v3[0] * scratch_v3[1] * scratch_v3[2];
+
+        return this.__subject.volume * scale_modifier;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        this.__subject.sample_random_point_in_volume(scratch_v3, 0, random);
+
+        // apply transform
+        vec3.transformMat4(scratch_v3, scratch_v3, this.__matrix);
+
+        // write out
+        result[0] = scratch_v3[0];
+        result[1] = scratch_v3[1];
+        result[2] = scratch_v3[2];
+    }
+}

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

@@ -0,0 +1,13 @@
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { randomPointInBox } from "../../random/randomPointInBox.js";
+
+export class UnitCubeShape3D extends AbstractShape3D {
+
+    get volume() {
+        return 1;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        randomPointInBox(random, result, result_offset);
+    }
+}