@woosh/meep-engine 2.33.20 → 2.33.24

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_computeConvex3PlaneIntersection.js";
+import { plane_three_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
+import { ray_computeNearestPointToPoint } from "../ray/ray_computeNearestPointToPoint.js";
 
 /**
  *
@@ -14,6 +14,12 @@ const scratch_v3_0 = new Vector3();
 
 const scratch_v3_1 = new Vector3();
 
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_v3_array = [];
+
 /**
  *
  * @param {Vector3} result
@@ -94,7 +100,9 @@ export function frustum3_computeNearestPointToPoint(result, planes, target_x, ta
         const plane_1 = planes[plane_1_index];
         const plane_2 = planes[plane_2_index];
 
-        plane_three_computeConvex3PlaneIntersection(result, plane_0, plane_1, plane_2);
+        plane_three_computeConvex3PlaneIntersection(scratch_v3_array, 0, plane_0, plane_1, plane_2);
+
+        result.readFromArray(scratch_v3_array, 0)
     }
 
     return false;

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/{unit_hemioct.spec.js → 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 "../../../Vector3.d.ts";
 
 test('encode-decode', () => {
     const v0 = [];

package/core/geom/3d/normal/lamber_azimuth/transform.js

@@ -0,0 +1,61 @@
+import { v2_dot } from "../../../Vector2.js";
+
+/*
+@source https://aras-p.info/texts/CompactNormalStorage.html
+@source https://en.wikipedia.org/wiki/Lambert_azimuthal_equal-area_projection
+
+half2 encode (half3 n, float3 view)
+{
+    half f = sqrt(8*n.z+8);
+    return n.xy / f + 0.5;
+}
+half3 decode (half4 enc, float3 view)
+{
+    half2 fenc = enc*4-2;
+    half f = dot(fenc,fenc);
+    half g = sqrt(1-f/4);
+    half3 n;
+    n.xy = fenc*g;
+    n.z = 1-f/2;
+    return n;
+}
+ */
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function encode_unit_to_azimuth(output, output_offset, x, y, z) {
+    const f = Math.sqrt(8 * z + 8);
+
+    output[output_offset] = x / f + 0.5;
+    output[output_offset + 1] = y / f + 0.5;
+}
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x range [-1,1]
+ * @param {number} y range [-1,1]
+ */
+export function decode_azimuth_to_unit(output, output_offset, x, y) {
+    const fenc_x = x * 4 - 2;
+    const fenc_y = y * 4 - 2;
+
+    const f = v2_dot(fenc_x, fenc_y, fenc_x, fenc_y);
+
+    const g = Math.sqrt(1 - f / 4);
+
+    const n_x = fenc_x * g;
+    const n_y = fenc_y * g;
+    const n_z = 1 - f / 2;
+
+    output[output_offset] = n_x;
+    output[output_offset + 1] = n_y;
+    output[output_offset + 2] = n_z;
+}

package/core/geom/3d/normal/spherical/sphere_map_transform.js

@@ -0,0 +1,77 @@
+import { v2_magnitude } from "../../../Vector2.js";
+import { v3_dot } from "../../../v3_dot.js";
+
+/*
+@source https://aras-p.info/texts/CompactNormalStorage.html#method04spheremap
+@source Siggraph 99
+@source Cry Engine 3, presented by Martin Mittring in "A bit more Deferred"
+
+half2 encode (half3 n, float3 view)
+{
+    half2 enc = normalize(n.xy) * (sqrt(-n.z*0.5+0.5));
+    enc = enc*0.5+0.5;
+    return enc;
+}
+half3 decode (half4 enc, float3 view)
+{
+    half4 nn = enc*half4(2,2,0,0) + half4(-1,-1,1,-1);
+    half l = dot(nn.xyz,-nn.xyw);
+    nn.z = l;
+    nn.xy *= sqrt(l);
+    return nn.xyz * 2 + half3(0,0,-1);
+}
+ */
+
+
+/**
+ * Encode v3 to v2
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function encode_unit_to_spheremap(output, output_offset, x, y, z) {
+    const length_xy = v2_magnitude(x, y);
+
+    const norm_xy_x = x / length_xy;
+    const norm_xy_y = y / length_xy;
+
+    const z_factor = Math.sqrt(-z * 0.5 - 0.5) * 0.5;
+
+    const enc_x = norm_xy_x * z_factor + 0.5;
+    const enc_y = norm_xy_y * z_factor + 0.5;
+
+    output[output_offset] = enc_x;
+    output[output_offset + 1] = enc_y;
+}
+
+/**
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x range [-1,1]
+ * @param {number} y range [-1,1]
+ */
+function decode_spheremap_to_unit(output, output_offset, x, y) {
+    const nn4_x = x * 2 - 1;
+    const nn4_y = y * 2 - 1;
+    const nn4_z = 1;
+    const nn4_w = -1;
+
+    const l = v3_dot(nn4_x, nn4_y, nn4_z, -nn4_x, -nn4_y, -nn4_w);
+
+    const nn_z = l;
+
+    const l_sqrt = Math.sqrt(l);
+
+    const nn_x = nn4_x * l_sqrt;
+    const nn_y = nn4_y * l_sqrt;
+
+    const _x = nn_x * 2;
+    const _y = nn_y * 2;
+    const _z = nn_z * 2 - 1;
+
+    output[output_offset] = _x;
+    output[output_offset + 1] = _y;
+    output[output_offset + 2] = _z;
+}

package/core/geom/3d/{lerp_planes_to_array.js → plane/lerp_planes_to_array.js}

@@ -1,6 +1,4 @@
-import Vector3, { v3_dot } from "../Vector3.js";
-
-const t_v3 = new Vector3();
+import { v3_dot } from "../../v3_dot.js";
 
 /**
  * Calculate a plane that is a linear interpolation between two other planes A and B with interpolation factor between 0 and 1

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

@@ -1,6 +1,8 @@
 import { lerp } from "../../../math/lerp.js";
-import Vector3, { v3_dot, v3_length } from "../../Vector3.js";
+import Vector3 from "../../Vector3.js";
 import { plane3_intersect_plane } from "./plane3_intersect_plane.js";
+import { v3_dot } from "../../v3_dot.js";
+import { v3_length } from "../../v3_length.js";
 
 const v0 = new Vector3();
 const v1 = new Vector3();

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

@@ -1,6 +1,9 @@
 import { lerp } from "../../../math/lerp.js";
 import { EPSILON } from "../../../math/MathUtils.js";
-import Vector3, { v3_dot, v3_length_sqr, v3_slerp } from "../../Vector3.js";
+import Vector3 from "../../Vector3.js";
+import { v3_dot } from "../../v3_dot.js";
+import { v3_length_sqr } from "../../v3_length_sqr.js";
+import { v3_slerp } from "../../v3_slerp.js";
 
 const e = new Vector3();
 

package/core/geom/3d/{plane_computeConvex3PlaneIntersection.js → plane/plane_computeConvex3PlaneIntersection.js}

@@ -1,21 +1,22 @@
-import { v3_dot } from "../Vector3.js";
-
+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,
@@ -24,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
@@ -40,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
@@ -75,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,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);
+    }
+}

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

@@ -0,0 +1,16 @@
+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;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        randomPointInSphere(random, result, result_offset);
+    }
+}

package/core/geom/3d/topology/TopoTriangle.js

@@ -1,9 +1,9 @@
-import { v3_length } from "../../Vector3.js";
 import { array_replace_all } from "../../../collection/array/array_replace_all.js";
 import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
 import { assert } from "../../../assert.js";
 import { array_remove_first } from "../../../collection/array/array_remove_first.js";
 import { vec3 } from "gl-matrix";
+import { v3_length } from "../../v3_length.js";
 
 /**
  *

package/core/geom/3d/topology/TopoVertex.js

@@ -1,7 +1,7 @@
-import { v3_distance } from "../../Vector3.js";
 import { assert } from "../../../assert.js";
 import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
 import { array_remove_first } from "../../../collection/array/array_remove_first.js";
+import { v3_distance } from "../../v3_distance.js";
 
 export class TopoVertex {
     constructor() {

package/core/geom/3d/topology/bounds/computeTraingleClusterNormalBoundingCone.js

@@ -1,9 +1,9 @@
 import { Miniball } from "../../../packing/miniball/Miniball.js";
 import { PointSet } from "../../../packing/miniball/PointSet.js";
 import { ConicRay } from "../../../ConicRay.js";
-import { v3_angleBetween } from "../../../Vector3.js";
 import { array_copy } from "../../../../collection/array/copyArray.js";
 import { min2 } from "../../../../math/min2.js";
+import { v3_angle_between } from "../../../v3_angle_between.js";
 
 /**
  * Using Shirman and Abi-Ezzi method, compute bounding sphere of points, then build a cone from that
@@ -66,7 +66,7 @@ export function computeTraingleClusterNormalBoundingCone(result, faces) {
         const normal_y = normal_data[i3];
         const normal_z = normal_data[i3];
 
-        const angle = v3_angleBetween(
+        const angle = v3_angle_between(
             normal_x, normal_y, normal_z,
             result_direction.x, result_direction.y, result_direction.z
         );

package/core/geom/3d/topology/simplify/compute_face_normal_change_dot_product.js

@@ -1,4 +1,4 @@
-import { v3_dot } from "../../../Vector3.js";
+import { v3_dot } from "../../../v3_dot.js";
 
 /**
  * Used to detect face normal flips for mesh optimization.

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() {