@woosh/meep-engine 2.33.21 → 2.33.25

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

@@ -2,19 +2,21 @@ import { v3_dot } from "../../v3_dot.js";
 
 /**
  *
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  * @param {Plane} a
  * @param {Plane} b
  * @param {Plane} c
  * @returns {boolean}
  */
-export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
+export function plane_three_computeConvex3PlaneIntersection(result, result_offset, a, b, c) {
     const a_normal = a.normal;
     const b_normal = b.normal;
     const c_normal = c.normal;
 
     return plane_computeConvex3PlaneIntersection(
         result,
+        result_offset,
         a_normal.x, a_normal.y, a_normal.z, a.constant,
         b_normal.x, b_normal.y, b_normal.z, b.constant,
         c_normal.x, c_normal.y, c_normal.z, c.constant,
@@ -23,7 +25,8 @@ export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
 
 /**
  * NOTE: Based on Intersection of 3 planes, Graphics Gems 1 pg 305
- * @param {Vector3} result
+ * @param {Float32Array|number[]|vec3} result
+ * @param {number} result_offset
  * @param {number} a_normal_x
  * @param {number} a_normal_y
  * @param {number} a_normal_z
@@ -39,7 +42,7 @@ export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
  * @returns {boolean} true if planes intersect, false otherwise
  */
 export function plane_computeConvex3PlaneIntersection(
-    result,
+    result, result_offset,
     a_normal_x, a_normal_y, a_normal_z, a_constant,
     b_normal_x, b_normal_y, b_normal_z, b_constant,
     c_normal_x, c_normal_y, c_normal_z, c_constant
@@ -74,18 +77,14 @@ export function plane_computeConvex3PlaneIntersection(
     const d = 1 / determinant;
 
     const neg_a_constant = -a_constant;
-    const neg_b_constant = -b_constant;
-    const neg_c_constant = -c_constant;
 
-    const x = (bxc_x * neg_a_constant + cxa_x * neg_b_constant + axb_x * neg_c_constant) * d;
-    const y = (bxc_y * neg_a_constant + cxa_y * neg_b_constant + axb_y * neg_c_constant) * d;
-    const z = (bxc_z * neg_a_constant + cxa_z * neg_b_constant + axb_z * neg_c_constant) * d;
+    const x = (bxc_x * neg_a_constant - cxa_x * b_constant - axb_x * c_constant) * d;
+    const y = (bxc_y * neg_a_constant - cxa_y * b_constant - axb_y * c_constant) * d;
+    const z = (bxc_z * neg_a_constant - cxa_z * b_constant - axb_z * c_constant) * d;
 
-    result.set(
-        x,
-        y,
-        z
-    );
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 
     return true;
 }

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,38 @@
+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');
+    }
+
+    /**
+     * 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}
+     */
+    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,240 @@
+import { AbstractShape3D } from "./AbstractShape3D.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 = [];
+
+/**
+ *
+ * @param {AbstractShape3D} shape
+ * @return {number}
+ */
+function getVolume(shape) {
+    return shape.volume;
+}
+
+export class CompositeShape3D extends AbstractShape3D {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @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() {
+        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];
+
+            volume_sum += child.volume;
+        }
+
+        /**
+         * 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() {
+        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;
+    }
+
+    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 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;
+
+        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

@@ -0,0 +1,126 @@
+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 {Float32Array|mat4}
+         * @private
+         */
+        this.__inverse_matrix = new Float32Array(16);
+
+        /**
+         *
+         * @type {AbstractShape3D|null}
+         * @private
+         */
+        this.__subject = null;
+    }
+
+    /**
+     *
+     * @returns {AbstractShape3D|null}
+     */
+    get subject() {
+        return this.__subject;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array|mat4} m4
+     * @param {AbstractShape3D} subject
+     * @returns {TransformedShape3D}
+     */
+    static from_m4(subject, m4) {
+        const r = new TransformedShape3D();
+
+        r.__subject = subject;
+        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);
+
+        const scale_modifier = scratch_v3[0] * scratch_v3[1] * scratch_v3[2];
+
+        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);
+
+        // 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,24 @@
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { randomPointInBox } from "../../random/randomPointInBox.js";
+
+export class UnitCubeShape3D extends AbstractShape3D {
+
+    get volume() {
+        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

@@ -0,0 +1,24 @@
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { randomPointInSphere } from "../../random/randomPointInSphere.js";
+
+export class UnitSphereShape3D extends AbstractShape3D {
+    get volume() {
+        return 0.523598776;
+    }
+
+    get surface_area() {
+        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);
+    }
+}