@woosh/meep-engine 2.109.2 → 2.109.4

package/build/meep.cjs

@@ -60141,8 +60141,12 @@ class HashMap {
             return true;
         }
 
+        // assert.equal(record.hash, this.#build_key_hash(record.key), `Key hash has diverged for key ${record.key}, likely key was mutated or hash function is unstable`);
+
         const result = this.keyEqualityFunction(record.key, key);
 
+        // assert.isBoolean(result, `result(a=${record.key},b=${key})`);
+
         return result;
     }
 

package/build/meep.module.js

@@ -60139,8 +60139,12 @@ class HashMap {
             return true;
         }
 
+        // assert.equal(record.hash, this.#build_key_hash(record.key), `Key hash has diverged for key ${record.key}, likely key was mutated or hash function is unstable`);
+
         const result = this.keyEqualityFunction(record.key, key);
 
+        // assert.isBoolean(result, `result(a=${record.key},b=${key})`);
+
         return result;
     }
 

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.109.2",
+  "version": "2.109.4",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.d.ts

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @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} t_min
+ * @param {number} t_max
+ * @returns {number}
+ */
+export function bvh_query_leaves_ray_segment(bvh: BVH, root: number, result: number[], result_offset: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, t_min: number, t_max: number): number;
+//# sourceMappingURL=bvh_query_leaves_ray_segment.d.ts.map

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_query_leaves_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH,6DAbW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,MAAM,CAwElB"}

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.js

@@ -0,0 +1,94 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_intersects_ray_segment } from "../../../geom/3d/aabb/aabb3_intersects_ray_segment.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @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} t_min
+ * @param {number} t_max
+ * @returns {number}
+ */
+export function bvh_query_leaves_ray_segment(
+    bvh, root,
+    result, result_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    t_min, t_max
+) {
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let result_cursor = result_offset;
+
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
+        stack.pointer--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[stack.pointer];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        // test node against the ray
+        const intersects = aabb3_intersects_ray_segment(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z,
+            t_min, t_max
+        );
+
+        if (!intersects) {
+            continue;
+        }
+
+        // get fist child to check if this is a leaf node or not
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+
+            // this is not a leaf node, push children onto traversal stack
+            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
+            stack[stack.pointer++] = child_1;
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = node;
+        }
+    } while (stack.pointer > stack_top);
+
+    return result_cursor - result_offset;
+}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.d.ts

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @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} t_min
+ * @param {number} t_max
+ * @returns {number}
+ */
+export function bvh_query_user_data_ray_segment(bvh: BVH, root: number, result: number[], result_offset: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, t_min: number, t_max: number): number;
+//# sourceMappingURL=bvh_query_user_data_ray_segment.d.ts.map

package/src/core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_query_user_data_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,gEAbW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,MAAM,CA+ElB"}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js

@@ -0,0 +1,100 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_intersects_ray_segment } from "../../../geom/3d/aabb/aabb3_intersects_ray_segment.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, COLUMN_USER_DATA, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @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} t_min
+ * @param {number} t_max
+ * @returns {number}
+ */
+export function bvh_query_user_data_ray_segment(
+    bvh, root,
+    result, result_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    t_min, t_max
+) {
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    /**
+     * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+     * @type {number}
+     */
+    let pointer = stack.pointer;
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = pointer;
+
+    stack[pointer++] = root;
+
+    let result_cursor = result_offset;
+
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
+        --pointer;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[pointer];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        // test node against the ray
+        const intersects = aabb3_intersects_ray_segment(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z,
+            t_min, t_max
+        );
+
+        if (!intersects) {
+            continue;
+        }
+
+        // get fist child to check if this is a leaf node or not
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+
+            // this is not a leaf node, push children onto traversal stack
+            const child_2 = uint32[address + COLUMN_CHILD_2];
+
+            stack[pointer++] = child_2;
+            stack[pointer++] = child_1;
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = uint32[address + COLUMN_USER_DATA];
+        }
+    } while (pointer > stack_top);
+
+    return result_cursor - result_offset;
+}

package/src/core/collection/map/HashMap.js

@@ -337,11 +337,11 @@ export class HashMap {
             return true;
         }
 
-        assert.equal(record.hash, this.#build_key_hash(record.key), `Key hash has diverged for key ${record.key}, likely key was mutated or hash function is unstable`);
+        // assert.equal(record.hash, this.#build_key_hash(record.key), `Key hash has diverged for key ${record.key}, likely key was mutated or hash function is unstable`);
 
         const result = this.keyEqualityFunction(record.key, key);
 
-        assert.isBoolean(result, `result(a=${record.key},b=${key})`);
+        // assert.isBoolean(result, `result(a=${record.key},b=${key})`);
 
         return result;
     }

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @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} min_distance
+ * @param {number} max_distance
+ * @returns {boolean}
+ * @returns {boolean}
+ */
+export function aabb3_intersects_ray_segment(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, min_distance: number, max_distance: number): boolean;
+//# sourceMappingURL=aabb3_intersects_ray_segment.d.ts.map

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_intersects_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,iDAjBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,OAAO,CA+CnB"}

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

@@ -0,0 +1,67 @@
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+
+/**
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @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} min_distance
+ * @param {number} max_distance
+ * @returns {boolean}
+ * @returns {boolean}
+ */
+export function aabb3_intersects_ray_segment(
+    x0, y0, z0,
+    x1, y1, z1,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    min_distance, max_distance
+) {
+
+    // move aabb into ray space
+    const _x0 = x0 - origin_x;
+    const _y0 = y0 - origin_y;
+    const _z0 = z0 - origin_z;
+
+    const _x1 = x1 - origin_x;
+    const _y1 = y1 - origin_y;
+    const _z1 = z1 - origin_z;
+
+    const inv_direction_x = 1 / direction_x;
+    const inv_direction_y = 1 / direction_y;
+    const inv_direction_z = 1 / direction_z;
+
+    // Absolute distances to lower and upper box coordinates
+    const t_lower_x = _x0 * inv_direction_x;
+    const t_lower_y = _y0 * inv_direction_y;
+    const t_lower_z = _z0 * inv_direction_z;
+
+    const t_upper_x = _x1 * inv_direction_x;
+    const t_upper_y = _y1 * inv_direction_y;
+    const t_upper_z = _z1 * inv_direction_z;
+
+    // The four t-intervals (for x-/y-/z-slabs, and ray p(t))
+    const t_min_x = min2(t_lower_x, t_upper_x);
+    const t_min_y = min2(t_lower_y, t_upper_y);
+    const t_min_z = min2(t_lower_z, t_upper_z);
+
+    const t_max_x = max2(t_lower_x, t_upper_x);
+    const t_max_y = max2(t_lower_y, t_upper_y);
+    const t_max_z = max2(t_lower_z, t_upper_z);
+
+    // Easy to remember: ``max of mins, and min of maxes''
+    const t_box_min = Math.max(t_min_x, t_min_y, t_min_z, min_distance);
+    const t_box_max = Math.min(t_max_x, t_max_y, t_max_z, max_distance);
+
+    return t_box_min <= t_box_max;
+}

package/src/core/geom/3d/ray/ray3_interval_array_apply_matrix4.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output 8 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, tMin, tMax]
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>|Float32Array} input 8 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, tMin, tMax]
+ * @param {number} input_offset
+ * @param {number[]|ArrayLike<number>|Float32Array} m4 4x4 matrix
+ * @returns {boolean} false if matrix transformation is impossible, such as when scale of the matrix is 0
+ */
+export function ray3_interval_array_apply_matrix4(output: number[] | ArrayLike<number> | Float32Array, output_offset: number, input: number[] | ArrayLike<number> | Float32Array, input_offset: number, m4: number[] | ArrayLike<number> | Float32Array): boolean;
+//# sourceMappingURL=ray3_interval_array_apply_matrix4.d.ts.map

package/src/core/geom/3d/ray/ray3_interval_array_apply_matrix4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ray3_interval_array_apply_matrix4.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_interval_array_apply_matrix4.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,0DAPW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,iBACvC,MAAM,SACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,MACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACrC,OAAO,CAqDnB"}

package/src/core/geom/3d/ray/ray3_interval_array_apply_matrix4.js

@@ -0,0 +1,61 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output 8 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, tMin, tMax]
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>|Float32Array} input 8 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, tMin, tMax]
+ * @param {number} input_offset
+ * @param {number[]|ArrayLike<number>|Float32Array} m4 4x4 matrix
+ * @returns {boolean} false if matrix transformation is impossible, such as when scale of the matrix is 0
+ */
+export function ray3_interval_array_apply_matrix4(output, output_offset, input, input_offset, m4) {
+    const origin_x = input[input_offset + 0];
+    const origin_y = input[input_offset + 1];
+    const origin_z = input[input_offset + 2];
+
+    const direction_x = input[input_offset + 3];
+    const direction_y = input[input_offset + 4];
+    const direction_z = input[input_offset + 5];
+
+    // transform ray to local space (inlined for speed)
+    const det = m4[3] * origin_x + m4[7] * origin_y + m4[11] * origin_z + m4[15];
+
+    if (det === 0) {
+        return false;
+    }
+
+    const inv_w = 1 / det;
+
+    const out_origin_x = (m4[0] * origin_x + m4[4] * origin_y + m4[8] * origin_z + m4[12]) * inv_w;
+    const out_origin_y = (m4[1] * origin_x + m4[5] * origin_y + m4[9] * origin_z + m4[13]) * inv_w;
+    const out_origin_z = (m4[2] * origin_x + m4[6] * origin_y + m4[10] * origin_z + m4[14]) * inv_w;
+
+    const out_direction_x = m4[0] * direction_x + m4[4] * direction_y + m4[8] * direction_z;
+    const out_direction_y = m4[1] * direction_x + m4[5] * direction_y + m4[9] * direction_z;
+    const out_direction_z = m4[2] * direction_x + m4[6] * direction_y + m4[10] * direction_z;
+
+    // normalize direction
+    const out_direction_magnitude = Math.hypot(out_direction_x, out_direction_y, out_direction_z);
+
+    if (out_direction_magnitude === 0) {
+        return false;
+    }
+
+    const out_direction_magnitude_inverse = 1 / out_direction_magnitude;
+
+    const out_direction_normalized_x = out_direction_x * out_direction_magnitude_inverse;
+    const out_direction_normalized_y = out_direction_y * out_direction_magnitude_inverse;
+    const out_direction_normalized_z = out_direction_z * out_direction_magnitude_inverse;
+
+    output[output_offset + 0] = out_origin_x;
+    output[output_offset + 1] = out_origin_y;
+    output[output_offset + 2] = out_origin_z;
+
+    output[output_offset + 3] = out_direction_normalized_x;
+    output[output_offset + 4] = out_direction_normalized_y;
+    output[output_offset + 5] = out_direction_normalized_z;
+
+    // TODO implement
+    throw new Error("Not Implemented")
+
+    return true;
+}

package/src/core/math/max4.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {number}
+ */
+export function max4(a: number, b: number, c: number, d: number): number;
+//# sourceMappingURL=max4.d.ts.map

package/src/core/math/max4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max4.d.ts","sourceRoot":"","sources":["../../../../src/core/math/max4.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/math/max4.js

@@ -0,0 +1,24 @@
+/**
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {number}
+ */
+export function max4(a, b, c, d) {
+    let v = a;
+
+    if (b > v) {
+        v = b;
+    }
+    if (c > v) {
+        v = c;
+    }
+    if (d > v) {
+        v = d;
+    }
+
+    return v;
+}
+

package/src/core/math/min4.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {number}
+ */
+export function min4(a: number, b: number, c: number, d: number): number;
+//# sourceMappingURL=min4.d.ts.map

package/src/core/math/min4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"min4.d.ts","sourceRoot":"","sources":["../../../../src/core/math/min4.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/math/min4.js

@@ -0,0 +1,23 @@
+/**
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {number}
+ */
+export function min4(a, b, c, d) {
+    let v = a;
+
+    if (b < v) {
+        v = b;
+    }
+    if (c < v) {
+        v = c;
+    }
+    if (d < v) {
+        v = d;
+    }
+
+    return v;
+}

package/src/core/model/node-graph/node/NodeDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeDescription.js"],"names":[],"mappings":"AAwCA;IACI;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAEL;IAEX;;;OAGG;IACH,YAFU,wBAAwB,EAAE,CAEpB;IAEhB;;OAEG;IACH;QACI;;;WAGG;4BADO,OAAO,IAAI,CAAC;QAGtB;;;WAGG;8BADO,OAAO,IAAI,CAAC;MAGxB;IAEF;;;;OAIG;IACH,4CAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,sBALW,MAAM,QACN,qBAAqB,iBACrB,MAAM,GAAC,OAAO,GAAC,MAAM,GACnB,MAAM,CA0ClB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,wBAAwB,CAiBpC;IAGD;;;;;;OAMG;IACH,oDAHW,aAAa,GACX,MAAM,CA2BlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAuBnB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAgBrB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,EAAE,CAwBjB;IAED;;;;OAIG;IACH,+BAHW,aAAa,GACZ,IAAI,EAAE,CAuBjB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,aACN,aAAa,GACZ,IAAI,GAAC,SAAS,CAmBzB;IAED;;;OAGG;IACH,YAFa,IAAI,EAAE,CAIlB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAYnB;IAED,mBAEC;IAED;;;;MAMC;IAED;;;;;;OAMG;IACH,8BALW,EAAE,gCAaZ;IAKL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAR1C;;;;qBAxYoB,WAAW;yCADS,yCAAyC;mBAH/D,kCAAkC;sCAEf,sCAAsC;8BAG9C,oBAAoB"}
+{"version":3,"file":"NodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeDescription.js"],"names":[],"mappings":"AAwCA;IACI;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,IAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,iBAFU,IAAI,EAAE,CAEL;IAEX;;;OAGG;IACH,YAFU,wBAAwB,EAAE,CAEpB;IAEhB;;OAEG;IACH;QACI;;;WAGG;4BADO,OAAO,IAAI,CAAC;QAGtB;;;WAGG;8BADO,OAAO,IAAI,CAAC;MAGxB;IAEF;;;;OAIG;IACH,4CAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,sBALW,MAAM,QACN,qBAAqB,iBACrB,MAAM,GAAC,OAAO,GAAC,MAAM,GACnB,MAAM,CA0ClB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,wBAAwB,CAiBpC;IAGD;;;;;;OAMG;IACH,oDAHW,aAAa,GACX,MAAM,CA2BlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAuBnB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAgBrB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,EAAE,CAwBjB;IAED;;;;;OAKG;IACH,+BAHW,aAAa,GACZ,OAAO,CAiBlB;IAED;;;;OAIG;IACH,+BAHW,aAAa,GACZ,IAAI,EAAE,CAuBjB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,aACN,aAAa,GACZ,IAAI,GAAC,SAAS,CAmBzB;IAED;;;OAGG;IACH,YAFa,IAAI,EAAE,CAIlB;IAED;;;;OAIG;IACH,cAHW,eAAe,GACb,OAAO,CAYnB;IAED,mBAEC;IAED;;;;MAMC;IAED;;;;;;OAMG;IACH,8BALW,EAAE,gCAaZ;IAKL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAR1C;;;;qBA/ZoB,WAAW;yCADS,yCAAyC;mBAH/D,kCAAkC;sCAEf,sCAAsC;8BAG9C,oBAAoB"}

package/src/core/model/node-graph/node/NodeDescription.js

@@ -291,6 +291,29 @@ export class NodeDescription {
         return result;
     }
 
+    /**
+     * Useful for checking if a node has inputs/outputs
+     * Does not allocate and terminates early, so performance characteristics are very good
+     * @param {PortDirection} direction
+     * @return {boolean}
+     */
+    hasPortsByDirection(direction) {
+        assert.enum(direction, PortDirection, 'direction');
+
+        const ports = this.ports;
+        const port_count = ports.length;
+
+        for (let i = 0; i < port_count; i++) {
+            const port = ports[i];
+
+            if (port.direction === direction) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      *
      * @param {PortDirection} direction

package/src/engine/graphics/geometry/buffered/computeBufferAttributeHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeBufferAttributeHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sDAHW,MAAM,eAAe,GACnB,MAAM,CAmBlB"}
+{"version":3,"file":"computeBufferAttributeHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,sDAHW,MAAM,eAAe,GACnB,MAAM,CAsBlB"}

package/src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js

@@ -1,3 +1,4 @@
+import { min2 } from "../../../../core/math/min2.js";
 import { computeStridedIntegerArrayHash } from "../../../../core/primitives/array/computeStridedIntegerArrayHash.js";
 
 /**
@@ -9,15 +10,18 @@ export function computeBufferAttributeHash(attribute) {
     let result = 0;
 
     if (attribute !== null) {
-        const index_data = attribute.array;
-        const index_data_size = index_data.length;
+        const data = attribute.array;
+        const data_size = data.length;
 
-        result += index_data_size;
+        result += data_size;
+
+        // limit hash evaluation to first 1k of the data to random memory access and keep CPU cache usage more coherent
+        const hash_evaluation_length = min2(data_size, 1024);
 
         // compute stride so that we don't have to iterate over the entire buffer, instead picking at most X(509) values to consider
-        const stride = Math.max(1, Math.ceil(index_data_size / 509));
+        const stride = Math.max(1, Math.ceil(hash_evaluation_length / 31));
 
-        result ^= computeStridedIntegerArrayHash(index_data, 0, index_data_size, stride);
+        result ^= computeStridedIntegerArrayHash(data, 0, hash_evaluation_length, stride);
 
     }
 

package/src/engine/graphics/impostors/octahedral/prototypeBaker.js

@@ -37,7 +37,8 @@ async function main(engine) {
     await EngineHarness.buildBasics({
         engine,
         enableWater: false,
-        cameraFieldOfView: 45
+        cameraFieldOfView: 45,
+        showFps: false
     });
 
     const ecd = engine.entityManager.dataset;
@@ -47,12 +48,12 @@ async function main(engine) {
     baker.renderer = renderer;
 
 
-    const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
+    // const path = 'data/models/LowPolyTownshipSet/Small_house/Small_house.gltf';
     // const path = 'data/models/road_bike/road_bike.gltf'; //large CAD-type model
     // const path = 'data/models/LowPolyTownshipSet/Barrel/model.gltf';
     // const path = 'data/models/LowPolyTownshipSet/Town_Hall/model.gltf';
     // const path = 'data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf';
-    // const path = 'data/models/MOBA and Tower Defense/Tree_01.gltf';
+    const path = 'data/models/MOBA and Tower Defense/Tree_01.gltf';
     // const path = 'data/models/samples/transform-hierarchy.glb';
     // const path = 'data/models/sponza-pbr/gltf/sponza.glb';
     // const path = 'data/models/snaps/cube_blue.gltf';
@@ -67,7 +68,7 @@ async function main(engine) {
         objects,
         frames: 12,
         resolution: 1024,
-        type: ImpostorCaptureType.FullSphere
+        type: ImpostorCaptureType.Hemisphere
     });
     // console.profileEnd('bake');
 
@@ -76,7 +77,7 @@ async function main(engine) {
     const ctrl = makeImpostorAtlasPreview({
         impostor: id,
         renderer,
-        mode: 'normal'
+        mode: 'diffuse'
     });
 
     ctrl.scale.setScalar(0.5);

package/src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AA2BA;IAkBI;;;OAGG;IACH,eAFW,KAAK,GAAC,MAAM,EAAE,QAIxB;IAIG;;;;OAIG;IACH,mBAAsB;IAEtB;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,6BAAgC;IAGhC;;;;OAIG;IACH,yBAAyB;IAG7B;;;OAGG;IACH,gBAFW,MAAM,cAAc,QAsC9B;IAGD;;;;;;;OAOG;IACH,gBANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CA+FlB;;CACJ;sBAlOqB,wCAAwC"}
+{"version":3,"file":"BufferedGeometryBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js"],"names":[],"mappings":"AAwBA;IAkBI;;;OAGG;IACH,eAFW,KAAK,GAAC,MAAM,EAAE,QAIxB;IAIG;;;;OAIG;IACH,mBAAsB;IAEtB;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,6BAAgC;IAGhC;;;;OAIG;IACH,yBAAyB;IAG7B;;;OAGG;IACH,gBAFW,MAAM,cAAc,QAsC9B;IAGD;;;;;;;OAOG;IACH,gBANW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,MAAM,CAyElB;;CACJ;sBAzMqB,wCAAwC"}

package/src/engine/graphics/sh3/path_tracer/BufferedGeometryBVH.js

@@ -1,11 +1,8 @@
-import { BVH, ELEMENT_WORD_COUNT } from "../../../../core/bvh2/bvh3/BVH.js";
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { ebvh_build_for_geometry_morton } from "../../../../core/bvh2/bvh3/ebvh_build_for_geometry_morton.js";
-import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
+import { bvh_query_user_data_ray_segment } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
-import {
-    aabb3_unsigned_distance_sqr_to_point
-} from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
 
 import {
     computeTriangleRayIntersectionBarycentricGeometry
@@ -136,7 +133,6 @@ export class BufferedGeometryBVH {
      */
     raycast(output, ray, min_distance, max_distance) {
 
-
         const indices = this.__geometry_index;
         const positions = this.__geometry_positions;
 
@@ -150,11 +146,12 @@ export class BufferedGeometryBVH {
 
         const bvh = this.#bvh;
 
-        const count = bvh_query_leaves_ray(
+        const count = bvh_query_user_data_ray_segment(
             bvh, bvh.root,
             scratch_uint32_array, 0,
             origin_x, origin_y, origin_z,
-            direction_x, direction_y, direction_z
+            direction_x, direction_y, direction_z,
+            min_distance, max_distance
         );
 
         if (count === 0) {
@@ -168,31 +165,10 @@ export class BufferedGeometryBVH {
         let best_index = -1;
         let best_u = 0;
         let best_v = 0;
-        let best_node = -1;
-
-
-        /*
-         For performance, we bind data directly to avoid extra copies required to read out AABB
-         */
-        const float32 = bvh.__data_float32;
 
         // check triangles found via BVH
         for (let i = 0; i < count; i++) {
-            const node = scratch_uint32_array[i];
-
-            const node_address = node * ELEMENT_WORD_COUNT;
-
-            if (aabb3_unsigned_distance_sqr_to_point(
-                float32[node_address], float32[node_address + 1], float32[node_address + 2],
-                float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
-
-                origin_x, origin_y, origin_z
-            ) > nearest_hit_distance * nearest_hit_distance) {
-                // bounds of the mesh are too far
-                continue;
-            }
-
-            const triangle_index = bvh.node_get_user_data(node);
+            const triangle_index = scratch_uint32_array[i];
 
             const intersection_found = computeTriangleRayIntersectionBarycentricGeometry(
                 v3_scratch_0,
@@ -215,7 +191,6 @@ export class BufferedGeometryBVH {
                 best_u = v3_scratch_0[1];
                 best_v = v3_scratch_0[2];
 
-                best_node = node;
             }
         }
 

package/src/engine/graphics/sh3/path_tracer/PathTracedMesh.js

@@ -121,7 +121,7 @@ export class PathTracedMesh {
                 scratch_v3, 0,
                 ray[0], ray[1], ray[2],
                 ray[3], ray[4], ray[5],
-                max_distance
+                max_distance-min_distance
             );
 
             // move far point into local coordinate space

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAgDA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAiF7C,iBAOC;IAED,uBAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QAavB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAyBlB;IAED;;;;;;;OAOG;IACH,WANW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,gBACb,MAAM,gBACN,MAAM,GACL,MAAM,CAkEjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,eACR,MAAM,GACJ,OAAO,CAmEnB;;CACJ;oBArfkD,mCAAmC;+BAoBvD,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B"}
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AA6CA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,IAAI,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,IAAI,MAAM,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAiF7C,iBAOC;IAED,uBAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,cAAc,YACpB,MAAM,QAAQ,aACd,OAAK,MAAM,EAAE,QAavB;IAED;;;;OAIG;IACH,qBAHW,MAAM,EAAE,OACR,MAAM,EAAE,QAyBlB;IAED;;;;;;;OAOG;IACH,WANW,MAAM,EAAE,OACR,MAAM,EAAE,OAAK,gBACb,MAAM,gBACN,MAAM,GACL,MAAM,CA8CjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,eACR,MAAM,GACJ,OAAO,CAmEnB;;CACJ;oBA9d8B,mCAAmC;+BAiBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B"}

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.js

@@ -1,15 +1,12 @@
 import { assert } from "../../../../core/assert.js";
-import { BVH, ELEMENT_WORD_COUNT, NULL_NODE } from "../../../../core/bvh2/bvh3/BVH.js";
+import { BVH, NULL_NODE } from "../../../../core/bvh2/bvh3/BVH.js";
 import { ebvh_build_hierarchy } from "../../../../core/bvh2/bvh3/ebvh_build_hierarchy.js";
-import { bvh_query_leaves_ray } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_ray.js";
+import { bvh_query_user_data_ray_segment } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js";
 import { Cache } from "../../../../core/cache/Cache.js";
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { array_quick_sort_by_lookup_map } from "../../../../core/collection/array/array_quick_sort_by_lookup_map.js";
 import { strictEquals } from "../../../../core/function/strictEquals.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
-import {
-    aabb3_unsigned_distance_sqr_to_point
-} from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
 import { v3_morton_encode_bounded } from "../../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
@@ -362,38 +359,19 @@ export class PathTracedScene {
         const ray_direction_z = ray[5];
 
 
-        const hit_count = bvh_query_leaves_ray(
+        const hit_count = bvh_query_user_data_ray_segment(
             bvh, bvh.root,
             scratch_uint32_array, 0,
             ray_origin_x, ray_origin_y, ray_origin_z,
-            ray_direction_x, ray_direction_y, ray_direction_z
+            ray_direction_x, ray_direction_y, ray_direction_z,
+            min_distance, max_distance
         );
 
         let nearest_hit_distance = max_distance;
 
-        /*
-         For performance, we bind data directly to avoid extra copies required to read out AABB
-         */
-        const float32 = bvh.__data_float32;
-        let best_node;
-
         for (let i = 0; i < hit_count; i++) {
 
-            const node = scratch_uint32_array[i];
-
-            const node_address = node * ELEMENT_WORD_COUNT;
-
-            if (aabb3_unsigned_distance_sqr_to_point(
-                float32[node_address], float32[node_address + 1], float32[node_address + 2],
-                float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
-
-                ray_origin_x, ray_origin_y, ray_origin_z
-            ) > nearest_hit_distance * nearest_hit_distance ) {
-                // bounds of the mesh are too far
-                continue;
-            }
-
-            const node_user_data = bvh.node_get_user_data(node);
+            const node_user_data = scratch_uint32_array[i];
 
             const mesh = this.meshes.get(node_user_data);
 
@@ -402,7 +380,6 @@ export class PathTracedScene {
             if (distance_to_hit >= 0) {
                 // since raycast in leaf nodes is already bound by maximum distance, any hit we get is necessarily a closer hit than before
                 nearest_hit_distance = distance_to_hit;
-                best_node = node;
             }
         }
 

package/src/engine/graphics/sh3/path_tracer/prototypePathTracer.js

@@ -76,7 +76,7 @@ vCanvas.css({
  * How many rays to use per-pixel
  * @type {number}
  */
-const PIXEL_SAMPLE_COUNT = 32;
+const PIXEL_SAMPLE_COUNT = 1;
 
 const scene = new PathTracedScene();
 const pt = new PathTracer();
@@ -558,7 +558,7 @@ function* render(target, pt, camera, scene, progress = { current: 0, total: 0 })
                     pixel_accummulation[1] /= pixel_sample_count
                     pixel_accummulation[2] /= pixel_sample_count
 
-                    linear_to_sRGB(pixel_accummulation, 0, pixel_accummulation, 0);
+                    // linear_to_sRGB(pixel_accummulation, 0, pixel_accummulation, 0);
 
                     output_data[pixel_address] = float_to_uint8(pixel_accummulation[0]);
                     output_data[pixel_address + 1] = float_to_uint8(pixel_accummulation[1]);
@@ -605,15 +605,15 @@ async function start_renderer(camera) {
     // await prepare_scene_lucy(scene, camera);
     // await prepare_scene_rtiow(pt, camera);
     // await prepare_scene_sphere_01(pt, camera);
-    await prepare_gi_box_scene(scene, camera);
-    // await prepare_sponza(scene, camera);
-    // await prepare_scene_gltf(scene, camera, path);
+    // await prepare_gi_box_scene(scene, camera);
+    await prepare_sponza(scene, camera);
+    // await prepare_scene_gltf({scene, camera, path, url: path});
 
 
     await scene.build();
     // pt.optimize();
 
-    const pixelRatio = 1;
+    const pixelRatio = 0.5;
 
     const rt = Sampler2D.uint8(4, vCanvas.size.x, vCanvas.size.y);
 

package/src/core/geom/3d/aabb/aabb3_overlaps_ray_segment.d.ts

@@ -1,11 +0,0 @@
-/**
- *
- * @param {number[]} aabb
- * @param {number} aabb_offset
- * @param {number[]} ray
- * @param {number} min_distance
- * @param {number} max_distance
- * @returns {boolean}
- */
-export function aabb3_overlaps_ray_segment(aabb: number[], aabb_offset: number, ray: number[], min_distance: number, max_distance: number): boolean;
-//# sourceMappingURL=aabb3_overlaps_ray_segment.d.ts.map

package/src/core/geom/3d/aabb/aabb3_overlaps_ray_segment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aabb3_overlaps_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_overlaps_ray_segment.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,iDAPW,MAAM,EAAE,eACR,MAAM,OACN,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,OAAO,CAmDnB"}

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

@@ -1,61 +0,0 @@
-import { v3_dot } from "../../vec3/v3_dot.js";
-
-/**
- *
- * @param {number[]} aabb
- * @param {number} aabb_offset
- * @param {number[]} ray
- * @param {number} min_distance
- * @param {number} max_distance
- * @returns {boolean}
- */
-export function aabb3_overlaps_ray_segment(
-    aabb, aabb_offset, ray,
-    min_distance, max_distance
-) {
-
-    const dir_x = ray[3];
-    const dir_y = ray[4];
-    const dir_z = ray[5];
-
-    const plane_offset = v3_dot(
-        ray[0], ray[1], ray[2],
-        dir_x, dir_y, dir_z
-    );
-
-    let x0, y0, z0, x1, y1, z1;
-
-    if (dir_x > 0) {
-        x0 = aabb[0];
-        x1 = aabb[3];
-    } else {
-        x1 = aabb[0];
-        x0 = aabb[3];
-    }
-
-    if (dir_y > 0) {
-        y0 = aabb[1];
-        y1 = aabb[4];
-    } else {
-        y1 = aabb[1];
-        y0 = aabb[4];
-    }
-
-    if (dir_z > 0) {
-        z0 = aabb[2];
-        z1 = aabb[5];
-    } else {
-        z1 = aabb[2];
-        z0 = aabb[5];
-    }
-
-    const min = plane_offset + dir_x * x0 + dir_y * y0 + dir_z * z0;
-
-    if (min >= max_distance) {
-        return false;
-    }
-
-    const max = plane_offset + dir_x * x1 + dir_y * y1 + dir_z * z1;
-
-    return max > min_distance;
-}