@woosh/meep-engine 2.33.24 → 2.33.25

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/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/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

@@ -12,6 +12,15 @@ export class AbstractShape3D {
         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/CompositeShape.js

@@ -1,6 +1,20 @@
 import { AbstractShape3D } from "./AbstractShape3D.js";
-import { weightedRandomFromArray } from "../../../collection/array/weightedRandomFromArray.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { binarySearchHighIndex } from "../../../collection/array/binarySearchHighIndex.js";
+import { compareNumbers } from "../../../primitives/numbers/compareNumbers.js";
 
+/**
+ * To avoid severe performance overhead, we limit number of possible rejections
+ * @type {number}
+ */
+const SAMPLE_REJECTION_ATTEMPT_MAX = 4;
+
+/**
+ * Number of samples taken to estimate overlap level
+ * @type {number}
+ */
+const VOLUME_OVERLAP_ESTIMATION_TAPS = 1024;
+const VOLUME_OVERLAP_ESTIMATION_SUB_TAPS = 4;
 
 const scratch_array = [];
 
@@ -13,7 +27,7 @@ function getVolume(shape) {
     return shape.volume;
 }
 
-export class CompositeShape extends AbstractShape3D {
+export class CompositeShape3D extends AbstractShape3D {
     constructor() {
         super();
 
@@ -22,23 +36,126 @@ export class CompositeShape extends AbstractShape3D {
          * @type {AbstractShape3D[]}
          */
         this.children = [];
+
+        /**
+         * Estimator of how much volume is in overlap,
+         * expressed as fraction of volume occupied by overlapping region of 2 shapes over the sum of volume occupied by each child
+         * @type {number}
+         * @private
+         */
+        this.__volume_overlap_fraction = -1;
+
+        this.__volume_sum = -1;
+        this.__volume_sums = [];
+        this.__child_volumes = [];
+    }
+
+    __compute_volume_variables() {
+        this.__volume_sum = 0;
+
+        const children = this.children;
+        const child_count = children.length;
+
+        const child_volumes = this.__child_volumes = new Float32Array(child_count);
+        const child_volume_sums = this.__volume_sums = new Float32Array(child_count);
+
+        for (let i = 0; i < child_count; i++) {
+            const child_volume = children[i].volume;
+
+            child_volumes[i] = child_volume;
+            this.__volume_sum += child_volume;
+
+            child_volume_sums[i] = this.__volume_sum;
+        }
+
+    }
+
+    /**
+     * Monte-carlo-style volume overlap estimation
+     * @private
+     */
+    __estimate_volume_overlap_fraction() {
+
+        if (this.__volume_sum === -1) {
+            this.__compute_volume_variables();
+        }
+
+        const children = this.children;
+        const child_count = children.length;
+
+        const random = seededRandom(1);
+
+        const child_volume_sums = this.__volume_sums;
+        const child_volume_sum = this.__volume_sum;
+
+        let i = 0, j = 0, k = 0, tap_overlaps = 0;
+
+        for (i = 0; i < VOLUME_OVERLAP_ESTIMATION_TAPS; i++) {
+
+            const target_weight = random() * child_volume_sum;
+
+            // weighted search for a sample candidate, preferring larger volumes, resulting in more uniform sample distribution
+            const target_child_index = binarySearchHighIndex(child_volume_sums, target_weight, compareNumbers, 0, child_count - 1);
+
+            const child_0 = children[target_child_index];
+
+            for (j = 0; j < VOLUME_OVERLAP_ESTIMATION_SUB_TAPS; j++, i++) {
+
+                child_0.sample_random_point_in_volume(scratch_array, 0, random);
+
+                for (k = 0; k < child_count; k++) {
+                    if (target_child_index === k) {
+                        // skip self
+                        continue;
+                    }
+
+                    const child_1 = children[k];
+
+                    if (child_1.contains_point(scratch_array)) {
+                        tap_overlaps++;
+                    }
+                }
+
+            }
+        }
+
+        this.__volume_overlap_fraction = tap_overlaps / (VOLUME_OVERLAP_ESTIMATION_TAPS);
+    }
+
+    static from(children) {
+        const r = new CompositeShape3D();
+
+        r.children = children;
+
+        return r;
     }
 
     get volume() {
-        let r = 0;
+        if (this.__volume_overlap_fraction < 0) {
+            this.__estimate_volume_overlap_fraction();
+        }
+
+        let volume_sum = 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;
+            volume_sum += child.volume;
         }
 
-        return r;
+        /**
+         * Unbias the volume by taking overlap into account
+         * @type {number}
+         */
+        const unbiased_volume = volume_sum / (this.__volume_overlap_fraction + 1);
+
+        return unbiased_volume;
     }
 
-    get surface_area(){
+    get surface_area() {
         let r = 0;
 
         const children = this.children;
@@ -52,9 +169,72 @@ export class CompositeShape extends AbstractShape3D {
         return r;
     }
 
+    contains_point(point) {
+        const children = this.children;
+        const n = children.length;
+        for (let i = 0; i < n; i++) {
+            const child = children[i];
+
+            if (child.contains_point(point)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
     sample_random_point_in_volume(result, result_offset, random) {
-        const child = weightedRandomFromArray(this.children, random, getVolume);
+        const children = this.children;
+        const child_count = children.length;
+
+
+        const target_weight = random() * this.__volume_sum;
+
+        // weighted search for a sample candidate, preferring larger volumes, resulting in more uniform sample distribution
+        const target_child_index = binarySearchHighIndex(this.__volume_sums, target_weight, compareNumbers, 0, child_count - 1);
+
+        const child = children[target_child_index];
+
+        let collision_count, i, j;
 
-        return child.sample_random_point_in_volume(result, result_offset, random);
+        for (i = 0; i < SAMPLE_REJECTION_ATTEMPT_MAX; i++) {
+
+            // sample shape
+            child.sample_random_point_in_volume(result, result_offset, random);
+
+            /*
+            because underlying shapes can overlap and we wish to offer a union, just returning the sample would result in over-sampling in areas where shapes overlap
+            to avoid this oversampling, we reject samples in such areas with probability proportional to number of overlapping shapes at the sampled point
+             */
+            collision_count = 0;
+
+            for (j = 0; j < child_count; j++) {
+                const child_1 = children[j];
+
+                if (child_1 === child) {
+                    // exclude sampled child itself
+                    continue;
+                }
+
+                if (child_1.contains_point(result)) {
+                    collision_count++;
+                }
+            }
+
+            if (collision_count > 0) {
+                const rejection_chance = collision_count / (collision_count + 1);
+
+                const rejection_roll = random();
+
+                if (rejection_roll < rejection_chance) {
+                    //reject
+                    continue;
+                }
+            }
+
+            // no collisions, or survived rejection
+            break;
+        }
     }
 }

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

@@ -17,6 +17,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 +35,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,17 +51,50 @@ 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() {
@@ -56,6 +105,13 @@ export class TransformedShape3D extends AbstractShape3D {
         return this.__subject.volume * scale_modifier;
     }
 
+    contains_point(point) {
+        // transform point to subject's local space
+        vec3.transformMat4(scratch_v3, point, this.__inverse_matrix);
+
+        return this.__subject.contains_point(scratch_v3);
+    }
+
     sample_random_point_in_volume(result, result_offset, random) {
         this.__subject.sample_random_point_in_volume(scratch_v3, 0, random);
 

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

@@ -7,6 +7,17 @@ export class UnitCubeShape3D extends AbstractShape3D {
         return 1;
     }
 
+    contains_point(point) {
+        const x = point[0];
+        const y = point[1];
+        const z = point[2];
+
+        return x > -0.5 && x < 0.5
+            && y > -0.5 && y < 0.5
+            && z > -0.5 && z < 0.5
+            ;
+    }
+
     sample_random_point_in_volume(result, result_offset, random) {
         randomPointInBox(random, result, result_offset);
     }

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

@@ -10,6 +10,14 @@ export class UnitSphereShape3D extends AbstractShape3D {
         return 3.14159265;
     }
 
+    contains_point(point) {
+        const x = point[0];
+        const y = point[1];
+        const z = point[2];
+
+        return (x * x + y * y + z * z) < 1;
+    }
+
     sample_random_point_in_volume(result, result_offset, random) {
         randomPointInSphere(random, result, result_offset);
     }

package/core/geom/3d/shape/util/shape_to_visual_entity.js

@@ -0,0 +1,159 @@
+import { CompositeShape3D } from "../CompositeShape.js";
+import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
+import { UnitSphereShape3D } from "../UnitSphereShape3D.js";
+import { TransformedShape3D } from "../TransformedShape3D.js";
+import EntityBuilder from "../../../../../engine/ecs/EntityBuilder.js";
+import { Transform } from "../../../../../engine/ecs/transform/Transform.js";
+import { AttachmentSockets } from "../../../../../engine/ecs/sockets/AttachmentSockets.js";
+import { Attachment } from "../../../../../engine/ecs/attachment/Attachment.js";
+import { ShadedGeometry } from "../../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { LineBasicMaterial } from "three";
+import { makeHelperSphereGeometry } from "../../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
+import { DrawMode } from "../../../../../engine/graphics/ecs/mesh-v2/DrawMode.js";
+import { makeHelperBoxGeometry } from "../../../../../editor/process/symbolic/makeHelperBoxGeometry.js";
+import Tag from "../../../../../engine/ecs/components/Tag.js";
+
+const g_unit_sphere = makeHelperSphereGeometry(0.5, 32);
+const g_unit_cube = makeHelperBoxGeometry(1, 1, 1);
+
+const lineMaterial = new LineBasicMaterial({
+    depthTest: true,
+    depthWrite: false,
+    transparent: true,
+    linewidth: 1,
+    fog: false,
+    color: '#FFFFFF',
+    opacity: 1
+});
+
+export const SHAPE_VISUAL_ENTITY_TAG = 'util/vis/Shape3D';
+
+/**
+ *
+ * @param {CompositeShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+function composite_shape_to_entity(shape, ecd) {
+
+    const parent = new EntityBuilder();
+    parent
+        .add(new Transform())
+        .add(AttachmentSockets.fromJSON({
+            elements: [
+                {
+                    type: 0,
+                    id: 0
+                }
+            ]
+        }))
+        .build(ecd);
+
+    shape.children.forEach(c => {
+
+        const child_entity = shape_to_visual_entity(c, ecd);
+
+        child_entity.add(Attachment.fromJSON({
+            socket: 0,
+            parent: parent.entity,
+            immediate: true
+        }));
+
+    })
+
+    return parent;
+}
+
+
+/**
+ *
+ * @param {UnitCubeShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+function cube_shape_to_entity(shape, ecd) {
+    const eb = new EntityBuilder();
+
+    eb.add(new Transform());
+    eb.add(Tag.fromOne(SHAPE_VISUAL_ENTITY_TAG));
+    eb.add(ShadedGeometry.from(g_unit_cube, lineMaterial, DrawMode.LineSegments));
+
+    eb.build(ecd);
+
+    return eb;
+}
+
+
+/**
+ *
+ * @param {UnitSphereShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+function sphere_shape_to_entity(shape, ecd) {
+    const eb = new EntityBuilder();
+
+    eb.add(new Transform());
+    eb.add(Tag.fromOne(SHAPE_VISUAL_ENTITY_TAG));
+    eb.add(ShadedGeometry.from(g_unit_sphere, lineMaterial, DrawMode.Lines));
+
+    eb.build(ecd);
+
+    return eb;
+
+}
+
+/**
+ *
+ * @param {TransformedShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+function transformed_shape_to_entity(shape, ecd) {
+    const subject = shape_to_visual_entity(shape.subject, ecd);
+
+    const parent = new EntityBuilder();
+    parent
+        .add(new Transform())
+        .add(AttachmentSockets.fromJSON({
+            elements: [
+                {
+                    type: 0,
+                    id: 0
+                }
+            ]
+        }))
+        .build(ecd);
+
+    const attachment = Attachment.fromJSON({
+        socket: 0,
+        parent: parent.entity,
+        immediate: true
+    });
+
+    attachment.transform.fromMatrix4(shape.transform);
+
+    subject.add(attachment);
+
+    return parent;
+}
+
+/**
+ *
+ * @param {AbstractShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+export function shape_to_visual_entity(shape, ecd) {
+    if (shape instanceof CompositeShape3D) {
+        return composite_shape_to_entity(shape, ecd);
+    } else if (shape instanceof UnitCubeShape3D) {
+        return cube_shape_to_entity(shape, ecd);
+    } else if (shape instanceof UnitSphereShape3D) {
+        return sphere_shape_to_entity(shape, ecd);
+    } else if (shape instanceof TransformedShape3D) {
+        return transformed_shape_to_entity(shape, ecd);
+    } else {
+        throw new Error('Unsupported shape type');
+    }
+}

package/core/geom/random/randomPointInSphere.js

@@ -12,11 +12,12 @@ export function randomPointInSphere(random, result, result_offset) {
 
     const cosTheta = random() * 2 - 1;
 
-    const u = random() * 0.5;
+    const u = random();
 
     const theta = Math.acos(cosTheta);
 
-    const r = Math.cbrt(u);
+    // compute radius
+    const r = Math.cbrt(u) * 0.5;
 
     const sinTheta = Math.sin(theta);
 

package/core/json/resolvePathByArray.js

@@ -44,10 +44,10 @@ export function resolvePathByArray(object, parts, missingPropertyHandler) {
             } else {
                 const options = buildErrorSuggestions(current);
 
-                throw new Error(`failed to resolve path '${path}' at part ${i} [${part}]. Existing keys: ${options.join(", ")}`);
+                throw new Error(`failed to resolve path [${parts.join(',')}] at part ${i} [${part}]. Existing keys: ${options.join(", ")}`);
             }
         }
         current = current[part];
     }
     return current;
-}
+}