@woosh/meep-engine 2.33.19 → 2.33.23

package/core/geom/3d/topology/simplify/quadratic/Quadratic3.js

@@ -1,4 +1,4 @@
-import { v3_dot } from "../../../../Vector3.js";
+import { v3_dot } from "../../../../v3_dot.js";
 
 export class Quadratic3 {
     constructor() {

package/core/geom/3d/triangle/computeTrianglePlaneSide.js

@@ -1,4 +1,4 @@
-import { v3_dot } from "../../Vector3.js";
+import { v3_dot } from "../../v3_dot.js";
 
 /**
  * Produces a numeric result to indicate which side of the plane the triangle is on

package/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -1,4 +1,4 @@
-import { v3_dot } from "../../Vector3.js";
+import { v3_dot } from "../../v3_dot.js";
 
 /**
  * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h

package/core/geom/3d/voxel/DenseBitVolume3D.js

@@ -0,0 +1,87 @@
+import Vector3 from "../../Vector3.js";
+import { BitSet } from "../../../binary/BitSet.js";
+
+export class DenseBitVolume3D {
+    constructor() {
+        this.size = new Vector3(1, 1, 1);
+
+        this.__data = new BitSet();
+        this.__data.preventShrink();
+    }
+
+    clear() {
+        this.__data.reset();
+    }
+
+    resize(x, y, z) {
+        // TODO consider how we can resize while keeping the data
+        this.clear();
+
+        this.size.set(x, y, z);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {number}
+     * @private
+     */
+    __compute_address(x, y, z) {
+
+        const size = this.size;
+
+        const dx = size.x;
+        const dy = size.y;
+
+        return y * dx + z * dx * dy + x;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {boolean}
+     */
+    get(x, y, z) {
+        const address = this.__compute_address(x, y, z);
+
+        return this.__data.get(address)
+    }
+
+    /**
+     *
+     * @param {boolean} value
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    set(value, x, y, z) {
+        const address = this.__compute_address(x, y, z);
+
+        this.__data.set(address, value);
+    }
+
+    /**
+     *
+     * @param {number} u x-coordinate, normalized to [0,1] range
+     * @param {number} v y-coordinate, normalized to [0,1] range
+     * @param {number} w z-coordinate, normalized to [0,1] range
+     * @returns {boolean}
+     */
+    sampleNearest(u, v, w) {
+        const s = this.size;
+
+        const dx = s.x;
+        const dy = s.y;
+        const dz = s.z;
+
+        const x = Math.round(dx * u) % dx
+        const y = Math.round(dy * v) % dy
+        const z = Math.round(dz * w) % dz
+
+        return this.get(x, y, z);
+    }
+}

package/core/geom/3d/voxel/buildVolumeFromProjectedGeometry.js

@@ -0,0 +1,23 @@
+/**
+ * Build a world-space oriented volume
+ * @param {DenseBitVolume3D} volume
+ * @param {AABB3} bounds
+ * @param {{raycast:function(source_x:number, source_y:number, source_z:number, direction_x:number, direction_y:number, direction_z:number):number}} sampler
+ * @param {number[]} frustum 3d frustum, defined as series of 6 planes in order: normal_x, normal_y, normal_z, plane_offset
+ */
+export function buildVolumeFromProjectedGeometry({ volume, sampler, frustum }) {
+    // get frustum corners
+
+    // get first hits from "front" plane to seed the volume
+    for (let x = 0; x < 64; x++) {
+        for (let y = 0; y < 64; y++) {
+
+        }
+    }
+
+    // fit volume to the frustum
+
+    // create a connectivity graph to identify disconnected regions
+
+    // clear out disconnected regions starting from smallest until only one is left
+}

package/core/geom/LineSegment.js

@@ -2,7 +2,9 @@
  * Created by Alex on 18/03/14.
  */
 import { clamp } from "../math/clamp.js";
-import Vector3, { v3_distance_sqr, v3_dot } from "./Vector3.js";
+import Vector3 from "./Vector3.js";
+import { v3_dot } from "./v3_dot.js";
+import { v3_distance_sqr } from "./v3_distance_sqr.js";
 
 
 const SMALL_NUM = 1e-9;

package/core/geom/Matrix4.js

@@ -1,4 +1,5 @@
-import Vector3, { v3_length } from "./Vector3.js";
+import Vector3 from "./Vector3.js";
+import { v3_length } from "./v3_length.js";
 
 const _z = new Vector3();
 const _x = new Vector3();

package/core/geom/Plane.js

@@ -3,7 +3,7 @@
  */
 
 
-import { v3_dot } from "./Vector3.js";
+import { v3_dot } from "./v3_dot.js";
 
 function Plane() {
 
@@ -192,7 +192,8 @@ export function computePlaneLineIntersection(out, originX, originY, originZ, dir
 
 /**
  *
- * @param {Vector3} result
+ * @param {Float32Array|number[]|vec3} result
+ * @param {number} result_offset
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
@@ -205,30 +206,34 @@ export function computePlaneLineIntersection(out, originX, originY, originZ, dir
  * @param {number} dist
  * @returns {boolean}
  */
-export function plane3_computeLineSegmentIntersection(result, x0, y0, z0, x1, y1, z1, normalX, normalY, normalZ, dist) {
+export function plane3_computeLineSegmentIntersection(
+    result, result_offset,
+    x0, y0, z0,
+    x1, y1, z1,
+    normalX, normalY, normalZ, dist
+) {
+
     const directionX = x1 - x0;
     const directionY = y1 - y0;
     const directionZ = z1 - z0;
 
     const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
 
-    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
-
     if (denom === 0) {
         return false;
     }
 
+    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
+
     const t = -p / denom;
 
     if (t < 0 || t > 1) {
         return false;
     }
 
-    result.set(
-        directionX * t + x0,
-        directionY * t + y0,
-        directionZ * t + z0
-    );
+    result[result_offset] = directionX * t + x0;
+    result[result_offset + 1] = directionY * t + y0;
+    result[result_offset + 2] = directionZ * t + z0;
 
     return true;
 

package/core/geom/Quaternion.js

@@ -10,7 +10,8 @@ import { clamp } from "../math/clamp.js";
 import { copysign } from "../math/copysign.js";
 import { lerp } from "../math/lerp.js";
 import { EPSILON, epsilonEquals, PI2, PI_HALF } from "../math/MathUtils.js";
-import Vector3, { v3_dot } from "./Vector3.js";
+import Vector3 from "./Vector3.js";
+import { v3_dot } from "./v3_dot.js";
 
 const matrix = new ThreeMatrix4();
 

package/core/geom/Vector3.d.ts

@@ -65,6 +65,8 @@ export default class Vector3 implements Vector3Like {
 
     applyMatrix3_three(m4: Matrix3): void
 
+    transformDirection_three(m4: Matrix4): void
+
     angleTo(other: Vector3Like): number
 
     toJSON(): any

package/core/geom/Vector3.js

@@ -5,10 +5,15 @@
 
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
-import { clamp } from "../math/clamp.js";
 import { lerp } from "../math/lerp.js";
 import { computeHashFloat, EPSILON, epsilonEquals } from "../math/MathUtils.js";
 import { sign } from "../math/sign.js";
+import { v3_dot } from "./v3_dot.js";
+import { v3_length_sqr } from "./v3_length_sqr.js";
+import { v3_length } from "./v3_length.js";
+import { v3_angle_between } from "./v3_angle_between.js";
+import { v3_lerp } from "./v3_lerp.js";
+import { v3_slerp } from "./v3_slerp.js";
 
 class Vector3 {
     /**
@@ -442,7 +447,7 @@ class Vector3 {
      * @returns {number}
      */
     angleTo(other) {
-        return v3_angleBetween(this.x, this.y, this.z, other.x, other.y, other.z);
+        return v3_angle_between(this.x, this.y, this.z, other.x, other.y, other.z);
     }
 
     /**
@@ -534,6 +539,32 @@ class Vector3 {
         return this.set(_x, _y, _z);
     }
 
+    /**
+     * Assume current vector holds a direction, transform using a matrix to produce a new directional unit vector
+     * @param {THREE.Matrix4} m
+     */
+    transformDirection_three(m) {
+
+        // input: THREE.Matrix4 affine matrix
+        // vector interpreted as a direction
+
+        const x = this.x, y = this.y, z = this.z;
+        const e = m.elements;
+
+        const _x = e[0] * x + e[4] * y + e[8] * z;
+        const _y = e[1] * x + e[5] * y + e[9] * z;
+        const _z = e[2] * x + e[6] * y + e[10] * z;
+
+        // normalize the result
+        const _l = 1 / v3_length(_x, _y, _z);
+
+        this.set(
+            _x * _l,
+            _y * _l,
+            _z * _l
+        );
+    }
+
     /**
      *
      * @param {THREE.Matrix3} m
@@ -947,20 +978,6 @@ Vector3.back = Object.freeze(new Vector3(0, 0, -1));
 Vector3.typeName = "Vector3";
 
 
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-export function v3_dot(x0, y0, z0, x1, y1, z1) {
-    return (x0 * x1 + y0 * y1 + z0 * z1);
-}
-
 /**
  *
  * @param {number} x0
@@ -973,87 +990,11 @@ export function v3_dot(x0, y0, z0, x1, y1, z1) {
  */
 Vector3._dot = v3_dot;
 
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-export function v3_distance(x0, y0, z0, x1, y1, z1) {
-
-    return Math.sqrt(v3_distance_sqr(x0, y0, z0, x1, y1, z1));
-}
-
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-export function v3_distance_sqr(x0, y0, z0, x1, y1, z1) {
-    const x = x0 - x1;
-    const y = y0 - y1;
-    const z = z0 - z1;
-
-    return x * x + y * y + z * z;
-}
-
 
 function v3Length(v) {
     return v3_length(v.x, v.y, v.z);
 }
 
-export function v3_length(x, y, z) {
-    return Math.sqrt(v3_length_sqr(x, y, z));
-}
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @return {number}
- */
-export function v3_length_sqr(x, y, z) {
-    return x * x + y * y + z * z;
-}
-
-
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-export function v3_angleBetween(x0, y0, z0, x1, y1, z1) {
-    const d = v3_dot(x0, y0, z0, 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;
-
-    if (l === 0) {
-        // collective magnitude is 0, provide arbitrary angle
-        return 0;
-    }
-
-    const theta = clamp(d / l, -1, 1);
-
-    return Math.acos(theta);
-}
 
 /**
  *
@@ -1067,70 +1008,4 @@ function v3Lerp(result, a, b, fraction) {
     v3_lerp(result, a.x, a.y, a.z, b.x, b.y, b.z, fraction);
 }
 
-/**
- *
- * @param {Vector3} result
- * @param {number} a_x
- * @param {number} a_y
- * @param {number} a_z
- * @param {number} b_x
- * @param {number} b_y
- * @param {number} b_z
- * @param {number} fraction
- */
-function v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction) {
-
-    const x = lerp(a_x, b_x, fraction);
-    const y = lerp(a_y, b_y, fraction);
-    const z = lerp(a_z, b_z, fraction);
-
-    result.set(x, y, z);
-}
-
-/**
- * Spherical linear interpolation
- * @see https://en.wikipedia.org/wiki/Slerp
- * @param {Vector3} result
- * @param {number} a_x
- * @param {number} a_y
- * @param {number} a_z
- * @param {number} b_x
- * @param {number} b_y
- * @param {number} b_z
- * @param {number} fraction
- */
-export function v3_slerp(
-    result,
-    a_x, a_y, a_z,
-    b_x, b_y, b_z,
-    fraction
-) {
-    const dot = v3_dot(
-        a_x, a_y, a_z,
-        b_x, b_y, b_z
-    );
-
-    if (dot >= 1 || dot <= -1) {
-        // avoid division by 0, both vectors are pointing in the same direction, use lerp instead
-        v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction);
-        return;
-    }
-
-    // compute angle between two vectors
-    const theta = Math.acos(dot);
-
-    const sin_theta = Math.sin(theta);
-
-    const inv_sin_theta = 1 / sin_theta;
-
-    const scale_0 = Math.sin((1 - fraction) * theta) * inv_sin_theta;
-    const scale_1 = Math.sin((fraction) * theta) * inv_sin_theta;
-
-    const x = a_x * scale_0 + b_x * scale_1;
-    const y = a_y * scale_0 + b_y * scale_1;
-    const z = a_z * scale_0 + b_z * scale_1;
-
-    result.set(x, y, z);
-}
-
 export default Vector3;

package/core/geom/Vector3.spec.js

@@ -1,4 +1,5 @@
-import Vector3, { v3_slerp } from "./Vector3.js";
+import Vector3 from "./Vector3.js";
+import { v3_slerp } from "./v3_slerp.js";
 
 test('slerp', () => {
 

package/core/geom/v3_angle_between.js

@@ -0,0 +1,31 @@
+import { v3_dot } from "./v3_dot.js";
+import { v3_length } from "./v3_length.js";
+import { clamp } from "../math/clamp.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
+    const d = v3_dot(x0, y0, z0, 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;
+
+    if (l === 0) {
+        // collective magnitude is 0, provide arbitrary angle
+        return 0;
+    }
+
+    const theta = clamp(d / l, -1, 1);
+
+    return Math.acos(theta);
+}

package/core/geom/v3_distance.js

@@ -0,0 +1,16 @@
+import { v3_distance_sqr } from "./v3_distance_sqr.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_distance(x0, y0, z0, x1, y1, z1) {
+
+    return Math.sqrt(v3_distance_sqr(x0, y0, z0, x1, y1, z1));
+}

package/core/geom/v3_distance_sqr.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_distance_sqr(x0, y0, z0, x1, y1, z1) {
+    const x = x0 - x1;
+    const y = y0 - y1;
+    const z = z0 - z1;
+
+    return x * x + y * y + z * z;
+}

package/core/geom/v3_dot.js

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_dot(x0, y0, z0, x1, y1, z1) {
+    return (x0 * x1 + y0 * y1 + z0 * z1);
+}

package/core/geom/v3_length.js

@@ -0,0 +1,5 @@
+import { v3_length_sqr } from "./v3_length_sqr.js";
+
+export function v3_length(x, y, z) {
+    return Math.sqrt(v3_length_sqr(x, y, z));
+}

package/core/geom/v3_length_sqr.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+export function v3_length_sqr(x, y, z) {
+    return x * x + y * y + z * z;
+}

package/core/geom/v3_lerp.js

@@ -0,0 +1,21 @@
+import { lerp } from "../math/lerp.js";
+
+/**
+ *
+ * @param {Vector3} result
+ * @param {number} a_x
+ * @param {number} a_y
+ * @param {number} a_z
+ * @param {number} b_x
+ * @param {number} b_y
+ * @param {number} b_z
+ * @param {number} fraction
+ */
+export function v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction) {
+
+    const x = lerp(a_x, b_x, fraction);
+    const y = lerp(a_y, b_y, fraction);
+    const z = lerp(a_z, b_z, fraction);
+
+    result.set(x, y, z);
+}

package/core/geom/v3_slerp.js

@@ -0,0 +1,48 @@
+import { v3_dot } from "./v3_dot.js";
+import { v3_lerp } from "./v3_lerp.js";
+
+/**
+ * Spherical linear interpolation
+ * @see https://en.wikipedia.org/wiki/Slerp
+ * @param {Vector3} result
+ * @param {number} a_x
+ * @param {number} a_y
+ * @param {number} a_z
+ * @param {number} b_x
+ * @param {number} b_y
+ * @param {number} b_z
+ * @param {number} fraction
+ */
+export function v3_slerp(
+    result,
+    a_x, a_y, a_z,
+    b_x, b_y, b_z,
+    fraction
+) {
+    const dot = v3_dot(
+        a_x, a_y, a_z,
+        b_x, b_y, b_z
+    );
+
+    if (dot >= 1 || dot <= -1) {
+        // avoid division by 0, both vectors are pointing in the same direction, use lerp instead
+        v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction);
+        return;
+    }
+
+    // compute angle between two vectors
+    const theta = Math.acos(dot);
+
+    const sin_theta = Math.sin(theta);
+
+    const inv_sin_theta = 1 / sin_theta;
+
+    const scale_0 = Math.sin((1 - fraction) * theta) * inv_sin_theta;
+    const scale_1 = Math.sin((fraction) * theta) * inv_sin_theta;
+
+    const x = a_x * scale_0 + b_x * scale_1;
+    const y = a_y * scale_0 + b_y * scale_1;
+    const z = a_z * scale_0 + b_z * scale_1;
+
+    result.set(x, y, z);
+}

package/core/primitives/array/computeIntegerArrayHash.js

@@ -7,10 +7,15 @@
 export function computeIntegerArrayHash(data, offset, length) {
     const end = offset + length;
 
-    let hash = 0;
+    let hash = length;
 
     for (let i = offset; i < end; i++) {
         const singleValue = data[i];
+        /**
+         * Simple hashing scheme, multiplying existing hash by a prime and adding next value
+         * (h<<5) - h ===  h*31
+         * @type {number}
+         */
         hash = ((hash << 5) - hash) + singleValue;
         hash |= 0; // Convert to 32bit integer
     }

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

@@ -79,6 +79,17 @@ function obtainCanvasCtx(width, height) {
     return gl;
 }
 
+/**
+ *
+ * @param {ImageBitmap} bitmap
+ * @return {Sampler2D}
+ */
+export function sampler_from_bitmap(bitmap) {
+    const ctx = obtainCanvasCtx(bitmap.width, bitmap.height);
+
+    return obtainSampler(bitmap, ctx);
+}
+
 /**
  *
  * @param {ImageBitmap} a