@woosh/meep-engine 2.68.0 → 2.70.0

package/src/core/geom/3d/aabb/aabb3_array_intersects_clipping_volume_array.js

@@ -0,0 +1,30 @@
+import { aabb3_intersects_clipping_volume_array } from "./aabb3_intersects_clipping_volume_array.js";
+
+/**
+ *
+ * @param {Float32Array|number[]} aabb
+ * @param {number} aabb_offset
+ * @param {Float32Array|number[]} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @return {boolean}
+ */
+export function aabb3_array_intersects_clipping_volume_array(
+    aabb, aabb_offset,
+    planes, planes_offset, plane_count
+) {
+
+    const x0 = aabb[aabb_offset + 0];
+    const y0 = aabb[aabb_offset + 1];
+    const z0 = aabb[aabb_offset + 2];
+    const x1 = aabb[aabb_offset + 3];
+    const y1 = aabb[aabb_offset + 4];
+    const z1 = aabb[aabb_offset + 5];
+
+    return aabb3_intersects_clipping_volume_array(
+        x0, y0, z0,
+        x1, y1, z1,
+        planes, planes_offset, plane_count
+    );
+}
+

package/src/core/geom/3d/aabb/aabb3_intersects_clipping_volume_array.js

@@ -0,0 +1,51 @@
+import { assert } from "../../../assert.js";
+import { aabb3_compute_distance_above_plane_max } from "./aabb3_compute_distance_above_plane_max.js";
+
+/**
+ * Tests whether AABB intersects a clipping volume defined by a set of planes
+ * Mainly useful for frustum checks
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @return {boolean}
+ */
+export function aabb3_intersects_clipping_volume_array(
+    x0, y0, z0,
+    x1, y1, z1,
+    planes, planes_offset, plane_count
+) {
+
+    assert.isNonNegativeInteger(planes_offset, 'frustum_offset');
+
+    const limit = plane_count * 4;
+
+    for (let i = 0; i < limit; i += 4) {
+
+        const offset = planes_offset + i;
+
+        const plane_x = planes[offset];
+        const plane_y = planes[offset + 1];
+        const plane_z = planes[offset + 2];
+        const plane_w = planes[offset + 3];
+
+        const plane_distance = aabb3_compute_distance_above_plane_max(
+            plane_x, plane_y, plane_z, plane_w,
+            x0, y0, z0,
+            x1, y1, z1
+        );
+
+        if (plane_distance < 0) {
+            return false;
+        }
+
+    }
+
+    return true;
+
+}

package/src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.js

@@ -1,9 +1,10 @@
 //
 
 
-import Vector3 from "../../Vector3.js";
-import Quaternion, { quat3_createFromAxisAngle } from "../../Quaternion.js";
 import { max2 } from "../../../math/max2.js";
+import Quaternion from "../../Quaternion.js";
+import Vector3 from "../../Vector3.js";
+import { quat3_createFromAxisAngle } from "../quaternion/quat3_createFromAxisAngle.js";
 
 const tangent = new Vector3();
 

package/src/core/geom/3d/frustum/{read_frustum_planes_to_array.js → read_three_planes_to_array.js}

@@ -5,10 +5,12 @@ import { assert } from "../../../assert.js";
  * @param {Plane[]} planes
  * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} array
  */
-export function read_frustum_planes_to_array(planes, array) {
-    assert.greaterThanOrEqual(array.length, 24, 'target array is too small');
+export function read_three_planes_to_array(planes, array) {
+    const plane_count = planes.length;
 
-    for (let i = 0; i < 6; i++) {
+    assert.greaterThanOrEqual(array.length, plane_count * 4, 'target array is too small');
+
+    for (let i = 0; i < plane_count; i++) {
         const plane = planes[i];
 
         const offset = i * 4;

package/src/core/geom/3d/morton/v3_morton_encode_bounded.js

@@ -0,0 +1,34 @@
+import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
+
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]} bounds
+ * @returns {number}
+ */
+export function v3_morton_encode_bounded(x, y, z, bounds) {
+
+    const bounds_x0 = bounds[0];
+    const bounds_y0 = bounds[1];
+    const bounds_z0 = bounds[2];
+
+    const bounds_x1 = bounds[3];
+    const bounds_y1 = bounds[4];
+    const bounds_z1 = bounds[5];
+
+    const bounds_span_x = bounds_x1 - bounds_x0;
+    const bounds_span_y = bounds_y1 - bounds_y0;
+    const bounds_span_z = bounds_z1 - bounds_z0;
+
+    // scale to 10 bits
+    const ndc_x = 1023 * (x - bounds_x0) / bounds_span_x;
+    const ndc_y = 1023 * (y - bounds_y0) / bounds_span_y;
+    const ndc_z = 1023 * (z - bounds_z0) / bounds_span_z;
+
+    return mortonEncode_magicbits(
+        Math.round(ndc_x),
+        Math.round(ndc_y),
+        Math.round(ndc_z)
+    );
+}

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

@@ -1,5 +1,5 @@
-import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
 import { clamp } from "../../../math/clamp.js";
+import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
 
 /**
  * Assumes that coordinates will be mapped to -1..1 range after transform
@@ -35,3 +35,4 @@ export function v3_morton_encode_transformed(x, y, z, matrix) {
         Math.round(pz)
     );
 }
+

package/src/core/geom/3d/quaternion/quat3_createFromAxisAngle.js

@@ -0,0 +1,11 @@
+/**
+ * just in case you need that function also
+ * @param {Vector3} axis
+ * @param {number} angle
+ * @param {Quaternion} result
+ */
+export function quat3_createFromAxisAngle(axis, angle, result) {
+    const halfAngle = angle * .5;
+    const s = Math.sin(halfAngle);
+    result.set(axis.x * s, axis.y * s, axis.z * s, Math.cos(halfAngle));
+}

package/src/core/geom/3d/quaternion/quat_decode_from_uint32.js

@@ -0,0 +1,53 @@
+const K = Math.SQRT1_2 / 511;
+
+/**
+ * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} value
+ */
+export function quat_decode_from_uint32(output, output_offset, value) {
+    //read components
+    const max = value & 0x3;
+
+    const iv0 = (value >> 2) & 0x3FF;
+    const iv1 = (value >> 12) & 0x3FF;
+    const iv2 = (value >> 22) & 0x3FF;
+
+    //scale components back to quaternion range
+    const v0 = iv0 * K - Math.SQRT1_2;
+    const v1 = iv1 * K - Math.SQRT1_2;
+    const v2 = iv2 * K - Math.SQRT1_2;
+
+    //restore dropped component using quaternion identity: x^2 + y^2 + z^2 + w^2 = 1
+    const dropped_2 = 1 - v0 * v0 - v1 * v1 - v2 * v2;
+    const dropped = Math.sqrt(dropped_2);
+
+    let x, y, z, w;
+    if (max === 0) {
+        x = dropped
+        y = v0
+        z = v1
+        w = v2
+    } else if (max === 1) {
+        x = v0
+        y = dropped
+        z = v1
+        w = v2
+    } else if (max === 2) {
+        x = v0
+        y = v1
+        z = dropped
+        w = v2
+    } else {
+        x = v0
+        y = v1
+        z = v2
+        w = dropped
+    }
+
+    output[output_offset] = x;
+    output[output_offset + 1] = y;
+    output[output_offset + 2] = z;
+    output[output_offset + 3] = w;
+}

package/src/core/geom/3d/quaternion/quat_encode_to_uint32.js

@@ -0,0 +1,106 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ * @returns {number}
+ */
+export function quat_encode_to_uint32(x, y, z, w) {
+
+    const absX = Math.abs(x);
+    const absY = Math.abs(y);
+    const absZ = Math.abs(z);
+    const absW = Math.abs(w);
+
+    let max = 0;
+
+    //pick max component
+    if (absY > absX) {
+        if (absY > absZ) {
+            if (absY > absW) {
+                //absY is max
+                max = 1;
+            } else {
+                //absW is max
+                max = 3;
+            }
+        } else if (absZ > absW) {
+            //absZ is max
+            max = 2;
+        } else {
+            //absW is max
+            max = 3;
+        }
+    } else if (absX > absZ) {
+        if (absX > absW) {
+            max = 0;
+        } else {
+            max = 3;
+        }
+    } else if (absZ > absW) {
+        max = 2;
+    } else {
+        max = 3;
+    }
+
+    let v0, v1, v2, dropped;
+
+    //max will be dropped
+    if (max === 0) {
+        //dropping x
+        v0 = y;
+        v1 = z;
+        v2 = w;
+
+        dropped = x;
+    } else if (max === 1) {
+        //dropping y
+        v0 = x;
+        v1 = z;
+        v2 = w;
+
+        dropped = y;
+    } else if (max === 2) {
+        //dropping z
+        v0 = x;
+        v1 = y;
+        v2 = w;
+
+        dropped = z;
+    } else {
+        //dropping w
+        v0 = x;
+        v1 = y;
+        v2 = z;
+
+        dropped = w;
+    }
+
+    if (dropped < 0) {
+        //reconstructing dropped value is only possible if it is positive, so we invert the quaternion to make dropped value positive
+        v0 = -v0;
+        v1 = -v1;
+        v2 = -v2;
+    }
+
+    const l = Math.sqrt(x * x + y * y + z * z + w * w);
+    const m = 511 / (l * Math.SQRT1_2);
+
+    //re-normalize the remaining components to 10 bit UINT value
+    const oV0 = Math.round(v0 * m + 511);
+    const oV1 = Math.round(v1 * m + 511);
+    const oV2 = Math.round(v2 * m + 511);
+
+    assert.ok(oV0 <= 1023 && oV0 >= 0, `expected 0 <= ov0 <= 1023, instead was '${oV0}'`);
+    assert.ok(oV1 <= 1023 && oV1 >= 0, `expected 0 <= ov1 <= 1023, instead was '${oV1}'`);
+    assert.ok(oV2 <= 1023 && oV2 >= 0, `expected 0 <= ov2 <= 1023, instead was '${oV2}'`);
+
+
+    return (max & 0x3)
+        | ((oV0 & 0x3FF) << 2)
+        | ((oV1 & 0x3FF) << 12)
+        | ((oV2 & 0x3FF) << 22);
+}

package/src/core/geom/3d/triangle/triangle_intersects_clipping_volume.js

@@ -0,0 +1,51 @@
+import { computeTrianglePlaneSide } from "./computeTrianglePlaneSide.js";
+
+/**
+ * @param {number[]|Float32Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+export function triangle_intersects_clipping_volume(
+    planes, planes_offset, plane_count,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+
+    for (let j = 0; j < plane_count; j++) {
+
+        const plane_address = planes_offset + j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        const side = computeTrianglePlaneSide(
+            plane_normal_x,
+            plane_normal_y,
+            plane_normal_z,
+            plane_constant,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        );
+
+        if (side === -3) {
+            // fully outside
+            return false;
+        }
+    }
+
+    return true;
+}

package/src/core/geom/Quaternion.js

@@ -6,31 +6,21 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
+import { EPSILON } from "../math/EPSILON.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
 import { lerp } from "../math/lerp.js";
-import Vector3 from "./Vector3.js";
-import { v3_dot } from "./vec3/v3_dot.js";
 import { min2 } from "../math/min2.js";
 import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
-import { epsilonEquals } from "../math/epsilonEquals.js";
-import { EPSILON } from "../math/EPSILON.js";
+import { quat_decode_from_uint32 } from "./3d/quaternion/quat_decode_from_uint32.js";
+import { quat_encode_to_uint32 } from "./3d/quaternion/quat_encode_to_uint32.js";
+import { v3_dot } from "./vec3/v3_dot.js";
+import Vector3 from "./Vector3.js";
 
 
 const forward = new Vector3();
 const up = new Vector3();
 const right = new Vector3();
 
-/**
- * just in case you need that function also
- * @param {Vector3} axis
- * @param {number} angle
- * @param {Quaternion} result
- */
-export function quat3_createFromAxisAngle(axis, angle, result) {
-    const halfAngle = angle * .5;
-    const s = Math.sin(halfAngle);
-    result.set(axis.x * s, axis.y * s, axis.z * s, Math.cos(halfAngle));
-}
-
 class Quaternion {
     /**
      *
@@ -1453,31 +1443,7 @@ class Quaternion {
      * @param {number} value
      */
     decodeFromUint32(value) {
-        //read components
-        const max = value & 0x3;
-
-        const iv0 = (value >> 2) & 0x3FF;
-        const iv1 = (value >> 12) & 0x3FF;
-        const iv2 = (value >> 22) & 0x3FF;
-
-        //scale components back to quaternion range
-        const v0 = (iv0 / 511 - 1) * K_CONST;
-        const v1 = (iv1 / 511 - 1) * K_CONST;
-        const v2 = (iv2 / 511 - 1) * K_CONST;
-
-        //restore dropped component using quaternion identity: x^2 + y^2 + z^2 + w^2 = 1
-        const dropped_2 = 1 - v0 * v0 - v1 * v1 - v2 * v2;
-        const dropped = Math.sqrt(dropped_2);
-
-        if (max === 0) {
-            this.set(dropped, v0, v1, v2);
-        } else if (max === 1) {
-            this.set(v0, dropped, v1, v2);
-        } else if (max === 2) {
-            this.set(v0, v1, dropped, v2);
-        } else {
-            this.set(v0, v1, v2, dropped);
-        }
+        quat_decode_from_uint32(this, 0, value);
     }
 
     /**
@@ -1485,107 +1451,7 @@ class Quaternion {
      * @returns {number}
      */
     encodeToUint32() {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
-        const w = this.w;
-
-        const absX = Math.abs(x);
-        const absY = Math.abs(y);
-        const absZ = Math.abs(z);
-        const absW = Math.abs(w);
-
-        let max = 0;
-
-        //pick max component
-        if (absY > absX) {
-            if (absY > absZ) {
-                if (absY > absW) {
-                    //absY is max
-                    max = 1;
-                } else {
-                    //absW is max
-                    max = 3;
-                }
-            } else if (absZ > absW) {
-                //absZ is max
-                max = 2;
-            } else {
-                //absW is max
-                max = 3;
-            }
-        } else if (absX > absZ) {
-            if (absX > absW) {
-                max = 0;
-            } else {
-                max = 3;
-            }
-        } else if (absZ > absW) {
-            max = 2;
-        } else {
-            max = 3;
-        }
-
-        let v0, v1, v2, dropped;
-
-        //max will be dropped
-        if (max === 0) {
-            //dropping x
-            v0 = y;
-            v1 = z;
-            v2 = w;
-
-            dropped = x;
-        } else if (max === 1) {
-            //dropping y
-            v0 = x;
-            v1 = z;
-            v2 = w;
-
-            dropped = y;
-        } else if (max === 2) {
-            //dropping z
-            v0 = x;
-            v1 = y;
-            v2 = w;
-
-            dropped = z;
-        } else {
-            //dropping w
-            v0 = x;
-            v1 = y;
-            v2 = z;
-
-            dropped = w;
-        }
-
-        if (dropped < 0) {
-            //reconstructing dropped value is only possible if it is positive, so we invert the quaternion to make dropped value positive
-            v0 = -v0;
-            v1 = -v1;
-            v2 = -v2;
-        }
-
-        const l = Math.sqrt(x * x + y * y + z * z + w * w);
-        const m = 1 / (l * K_CONST);
-
-        //re-normalize the remaining components to 10 bit UINT value
-        const oV0 = Math.round((v0 * m + 1) * 511);
-        const oV1 = Math.round((v1 * m + 1) * 511);
-        const oV2 = Math.round((v2 * m + 1) * 511);
-
-        assert.ok(oV0 <= 1023 && oV0 >= 0, `expected 0 <= ov0 <= 1023, instead was '${oV0}'`);
-        assert.ok(oV1 <= 1023 && oV1 >= 0, `expected 0 <= ov1 <= 1023, instead was '${oV1}'`);
-        assert.ok(oV2 <= 1023 && oV2 >= 0, `expected 0 <= ov2 <= 1023, instead was '${oV2}'`);
-
-
-        const result = (max & 0x3)
-            | ((oV0 & 0x3FF) << 2)
-            | ((oV1 & 0x3FF) << 12)
-            | ((oV2 & 0x3FF) << 22)
-        ;
-
-        return result;
+        return quat_encode_to_uint32(this.x, this.y, this.z, this.w);
     }
 
     /**

package/src/core/geom/Vector2.js

@@ -546,11 +546,7 @@ class Vector2 {
         const x = computeHashFloat(this.x);
         const y = computeHashFloat(this.y);
 
-        let hash = ((x << 5) - x) + y;
-
-        hash |= 0; //convert to 32bit int
-
-        return hash;
+        return ((x << 5) - x) + y;
     }
 
     /**
@@ -561,8 +557,11 @@ class Vector2 {
         const sin = Math.sin(angle);
         const cos = Math.cos(angle);
 
-        const x = this.x * cos - this.y * sin
-        const y = this.x * sin + this.y * cos;
+        const _x = this.x;
+        const _y = this.y;
+
+        const x = _x * cos - _y * sin
+        const y = _x * sin + _y * cos;
 
         this.set(x, y);
     }