@woosh/meep-engine 2.109.3 → 2.109.5

package/build/meep.module.js

@@ -67733,6 +67733,60 @@ function sampler2d_ensure_uint8_RGBA(input) {
 const DEFAULT_TEXTURE_WIDTH = 512;
 const DEFAULT_TEXTURE_HEIGHT = 512;
 
+/**
+ *
+ * @param {THREE.DataTexture} texture
+ * @param {number} channel_count
+ * @param {number} _width
+ * @param {number} _height
+ * @returns {Sampler2D}
+ */
+function data_texture_to_sampler(texture, channel_count, _width, _height) {
+    const source = new Sampler2D(texture.image.data, channel_count, texture.image.width, texture.image.height);
+
+    let converted = sampler2d_ensure_uint8_RGBA(source);
+
+    if (converted.width !== _width || converted.height !== _height) {
+        const target = Sampler2D.uint8(4, _width, _height);
+
+        sampler2d_scale(converted, target);
+
+        converted = target;
+    }
+    return converted;
+}
+
+/**
+ *
+ * @param {THREE.Texture} texture
+ * @param {number} channel_count
+ * @param {number} _width
+ * @param {number} _height
+ * @returns {Sampler2D}
+ */
+function html_image_texture_to_sampler(texture, channel_count, _width, _height) {
+    /**
+     *
+     * @type {Image}
+     */
+    const img = texture.image;
+
+    const canvas = document.createElement('canvas');
+
+    canvas.width = _width;
+    canvas.height = _height;
+
+    const ctx = canvas.getContext('2d');
+
+    ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, _width, _height);
+
+    const result = Sampler2D.uint8(4, _width, _height);
+
+    canvasDataToSampler(result, ctx);
+
+    return result;
+}
+
 /**
  *
  * @param {Texture} texture
@@ -67752,8 +67806,6 @@ function convertTexture2Sampler2D(
 
     const channel_count = formatToChannelCount(texture.format);
 
-    // TODO take channel count into account
-
     if (_width === undefined || _height === undefined) {
 
         //figure out texture size
@@ -67792,21 +67844,14 @@ function convertTexture2Sampler2D(
     if (texture.isDataTexture === true) {
 
         // special case
+        const converted = data_texture_to_sampler(texture, channel_count, _width, _height);
 
-        const source = new Sampler2D(texture.image.data, channel_count, texture.image.width, texture.image.height);
-
-        let converted = sampler2d_ensure_uint8_RGBA(source);
-
-        if (converted.width !== _width || converted.height !== _height) {
-            const target = Sampler2D.uint8(4, _width, _height);
-
-            sampler2d_scale(converted, target);
+        data = converted.data;
 
-            converted = target;
-        }
+    } else if (texture.image instanceof Image) {
+        const converted = html_image_texture_to_sampler(texture, channel_count, _width, _height);
 
         data = converted.data;
-
     } else {
         const built = WebGLRendererPool.global.use(renderer => {
 
@@ -84850,7 +84895,7 @@ class Deque {
      * @type {T[]}
      * @private
      */
-    #data=EMPTY_ARRAY;
+    #data = EMPTY_ARRAY;
     /**
      *
      * @type {number}
@@ -85167,6 +85212,56 @@ class Deque {
         const last = this.#circular_previous_position(this.#tail);
         return this.#data[last];
     }
+
+    /**
+     * Retrieved element by position from head. Where element at the head is position 0
+     * @param {number} index
+     * @returns {T|undefined} undefined if indexing element that is past the end, otherwise returns element at the position given
+     */
+    getElementByIndex(index) {
+
+        if (index >= this.size()) {
+            // overflow
+            return undefined;
+        }
+
+        /**
+         *
+         * @type {number}
+         */
+        const position = (this.#head + index) % this.#data.length;
+
+        return this.#data[position];
+    }
+
+    /**
+     * Returns a copy of this queue represented as an array without gaps, with the head of the queue (first element) being at position 0
+     * @param {T[]} [result]
+     * @param {number} [result_offset]
+     * @returns {T[]}
+     */
+    toArray(result = [], result_offset = 0) {
+        const size = this.size();
+
+        for (let i = 0; i < size; i++) {
+            result[i] = this.getElementByIndex(i);
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @returns {Generator<T,void>}
+     */
+    * [Symbol.iterator]() {
+
+        const size = this.size();
+
+        for (let i = 0; i < size; i++) {
+            yield this.getElementByIndex(i);
+        }
+    }
 }
 
 /*

package/package.json

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

package/src/core/collection/queue/Deque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Deque.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IA8BI;;;OAGG;IACH,uBAFW,MAAM,EAUhB;IAqFD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cAeC;IAED;;OAEG;IACH,QAFa,MAAM,CAalB;IA+CD;;;;OAIG;IACH,UAHW,CAAC,GACC,OAAO,CAYnB;IA2BD;;;;OAIG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,YAFW,CAAC,QAOX;IAED;;;OAGG;IACH,eAFa,CAAC,GAAC,SAAS,CAQvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;OAGG;IACH,WAFW,CAAC,QAOX;IAED;;;OAGG;IACH,cAFa,CAAC,CASb;IAGD;;;OAGG;IACH,WAFa,CAAC,GAAC,SAAS,CAKvB;IAOL,gBAAoB;IACpB,uBAAoB;IACpB,eAAmB;IAEnB;;OAEG;IACH,sBAAmB;;CAblB"}
+{"version":3,"file":"Deque.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/queue/Deque.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IA8BI;;;OAGG;IACH,uBAFW,MAAM,EAUhB;IAqFD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cAeC;IAED;;OAEG;IACH,QAFa,MAAM,CAalB;IA+CD;;;;OAIG;IACH,UAHW,CAAC,GACC,OAAO,CAYnB;IA2BD;;;;OAIG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,YAFW,CAAC,QAOX;IAED;;;OAGG;IACH,eAFa,CAAC,GAAC,SAAS,CAQvB;IAED;;;OAGG;IACH,YAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;OAGG;IACH,WAFW,CAAC,QAOX;IAED;;;OAGG;IACH,cAFa,CAAC,CASb;IAGD;;;OAGG;IACH,WAFa,CAAC,GAAC,SAAS,CAKvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,CAAC,GAAC,SAAS,CAiBvB;IAED;;;;;OAKG;IACH,iBAJW,CAAC,EAAE,kBACH,MAAM,GACJ,CAAC,EAAE,CAUf;IAoBL,gBAAoB;IACpB,uBAAoB;IACpB,eAAmB;IAEnB;;OAEG;IACH,sBAAmB;IAzBf;;;OAGG;IACH,qBAFa,UAAU,CAAC,EAAC,IAAI,CAAC,CAS7B;;CACJ"}

package/src/core/collection/queue/Deque.js

@@ -25,7 +25,7 @@ export class Deque {
      * @type {T[]}
      * @private
      */
-    #data=EMPTY_ARRAY;
+    #data = EMPTY_ARRAY;
     /**
      *
      * @type {number}
@@ -344,6 +344,57 @@ export class Deque {
         const last = this.#circular_previous_position(this.#tail);
         return this.#data[last];
     }
+
+    /**
+     * Retrieved element by position from head. Where element at the head is position 0
+     * @param {number} index
+     * @returns {T|undefined} undefined if indexing element that is past the end, otherwise returns element at the position given
+     */
+    getElementByIndex(index) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        if (index >= this.size()) {
+            // overflow
+            return undefined;
+        }
+
+        /**
+         *
+         * @type {number}
+         */
+        const position = (this.#head + index) % this.#data.length;
+
+        return this.#data[position];
+    }
+
+    /**
+     * Returns a copy of this queue represented as an array without gaps, with the head of the queue (first element) being at position 0
+     * @param {T[]} [result]
+     * @param {number} [result_offset]
+     * @returns {T[]}
+     */
+    toArray(result = [], result_offset = 0) {
+        const size = this.size();
+
+        for (let i = 0; i < size; i++) {
+            result[i] = this.getElementByIndex(i);
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @returns {Generator<T,void>}
+     */
+    * [Symbol.iterator]() {
+
+        const size = this.size();
+
+        for (let i = 0; i < size; i++) {
+            yield this.getElementByIndex(i);
+        }
+    }
 }
 
 /*

package/src/core/collection/queue/Deque.spec.js

@@ -245,3 +245,32 @@ test("fill queue beyond default size and then drain it", () => {
     expect(queue.pop()).toBe(3);
     expect(queue.size()).toBe(0);
 });
+
+
+test("toArray", () => {
+
+    const q = new Deque(2);
+
+    expect(q.toArray()).toEqual([]);
+
+    q.addLast(1);
+
+    expect(q.toArray()).toEqual([1]);
+
+    q.addLast(7);
+
+    expect(q.toArray()).toEqual([1, 7]);
+
+    q.removeFirst();
+
+    expect(q.toArray()).toEqual([7]);
+});
+
+test("Symbol.iterator",()=>{
+    const q = new Deque();
+
+    q.addLast(1);
+    q.addLast(7);
+
+    expect(Array.from(q)).toEqual([1,7]);
+});

package/src/core/geom/3d/Ray3.d.ts

@@ -1,25 +1,38 @@
 /**
  * 3D ray
  */
-export class Ray3 {
-    origin: Vector3;
-    direction: Vector3;
-    get 0(): number;
-    get 1(): number;
-    get 2(): number;
-    get 3(): number;
-    get 4(): number;
-    get 5(): number;
+export class Ray3 extends Float32Array {
+    constructor();
+    set tMax(arg: any);
+    get tMax(): any;
+    6: any;
+    get direction(): Float32Array;
+    get origin(): Float32Array;
+    /**
+     *
+     * @param {number} distance
+     */
+    shiftForward(distance: number): void;
     /**
      *
      * @param {number[]|mat4|Float32Array} m4
      */
     applyMatrix4(m4: number[] | mat4 | Float32Array): void;
+    /**
+     *
+     * @returns {Ray3}
+     */
+    clone(): Ray3;
     /**
      *
      * @param {Ray3} other
      */
     copy(other: Ray3): void;
+    /**
+     *
+     * @param {Ray3} other
+     * @returns {boolean}
+     */
+    equals(other: Ray3): boolean;
 }
-import Vector3 from "../Vector3.js";
 //# sourceMappingURL=Ray3.d.ts.map

package/src/core/geom/3d/Ray3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/Ray3.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI,gBAAsB;IACtB,mBAAyB;IAEzB,gBAEC;IAED,gBAEC;IAED,gBAEC;IAED,gBAEC;IAED,gBAEC;IAED,gBAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAKpC;IAED;;;OAGG;IACH,YAFW,IAAI,QAKd;CACJ;oBAlDmB,eAAe"}
+{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/Ray3.js"],"names":[],"mappings":"AAKA;;GAEG;AACH;IACI,cAKC;IAMD,mBAEC;IAND,gBAEC;IAGG,OAAW;IAGf,8BAEC;IAED,2BAEC;IAED;;;OAGG;IACH,uBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAepC;IAED;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAInB;CACJ"}

package/src/core/geom/3d/Ray3.js

@@ -1,34 +1,43 @@
-import Vector3 from "../Vector3.js";
+import { array_range_equal_strict } from "../../collection/array/array_range_equal_strict.js";
+import { v3_matrix4_multiply } from "../vec3/v3_matrix4_multiply.js";
+import { v3_matrix4_rotate } from "../vec3/v3_matrix4_rotate.js";
+import { ray3_interval_array_apply_matrix4 } from "./ray/ray3_interval_array_apply_matrix4.js";
 
 /**
  * 3D ray
  */
-export class Ray3 {
-    origin = new Vector3()
-    direction = new Vector3()
+export class Ray3 extends Float32Array {
+    constructor() {
+        super(7);
 
-    get 0() {
-        return this.origin.x
+        // make ray unbounded
+        this.tMax = Infinity;
     }
 
-    get 1() {
-        return this.origin.y
+    get tMax() {
+        return this[6];
     }
 
-    get 2() {
-        return this.origin.z
+    set tMax(v) {
+        this[6] = v;
     }
 
-    get 3() {
-        return this.direction.x
+    get direction() {
+        return new Float32Array(this.buffer, this.byteOffset + 3, 3);
     }
 
-    get 4() {
-        return this.direction.y
+    get origin() {
+        return new Float32Array(this.buffer, this.byteOffset, 3);
     }
 
-    get 5() {
-        return this.direction.z
+    /**
+     *
+     * @param {number} distance
+     */
+    shiftForward(distance) {
+        this[0] += this[3] * distance;
+        this[1] += this[4] * distance;
+        this[2] += this[5] * distance;
     }
 
     /**
@@ -36,8 +45,30 @@ export class Ray3 {
      * @param {number[]|mat4|Float32Array} m4
      */
     applyMatrix4(m4) {
-        this.origin.applyMatrix4(m4);
-        this.direction.applyDirectionMatrix4(m4);
+
+        if (this[6] !== Infinity) {
+
+            ray3_interval_array_apply_matrix4(this, 0, this, 0, m4);
+
+        } else {
+
+            // special case
+            v3_matrix4_multiply(this, 0, this, 0, m4);
+            v3_matrix4_rotate(this, 3, this, 3, m4);
+
+        }
+    }
+
+    /**
+     *
+     * @returns {Ray3}
+     */
+    clone() {
+        const r = new Ray3();
+
+        r.copy(this);
+
+        return r;
     }
 
     /**
@@ -45,7 +76,15 @@ export class Ray3 {
      * @param {Ray3} other
      */
     copy(other) {
-        this.origin.copy(other.origin);
-        this.direction.copy(other.direction);
+        this.set(other);
+    }
+
+    /**
+     *
+     * @param {Ray3} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return array_range_equal_strict(this, 0, other, 0, 7);
     }
 }

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

@@ -1,8 +1,8 @@
 /**
  *
- * @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[]|ArrayLike<number>|Float32Array} output 7 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, 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[]|ArrayLike<number>|Float32Array} input 7 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, 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

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

@@ -1 +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"}
+{"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,CAoEnB"}

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

@@ -1,13 +1,17 @@
 /**
  *
- * @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[]|ArrayLike<number>|Float32Array} output 7 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, 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[]|ArrayLike<number>|Float32Array} input 7 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, 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) {
+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];
@@ -16,46 +20,57 @@ export function ray3_interval_array_apply_matrix4(output, output_offset, input,
     const direction_y = input[input_offset + 4];
     const direction_z = input[input_offset + 5];
 
+    const t_max = input[input_offset + 6];
+
+
+    const in_min_x = origin_x ;
+    const in_min_y = origin_y ;
+    const in_min_z = origin_z ;
+
+    const in_max_x = origin_x + direction_x * t_max;
+    const in_max_y = origin_y + direction_y * t_max;
+    const in_max_z = origin_z + direction_z * t_max;
+
     // transform ray to local space (inlined for speed)
-    const det = m4[3] * origin_x + m4[7] * origin_y + m4[11] * origin_z + m4[15];
+    const w0 = m4[3] * in_min_x + m4[7] * in_min_y + m4[11] * in_min_z + m4[15];
 
-    if (det === 0) {
-        return false;
-    }
+    const inv_w0 = 1 / w0;
 
-    const inv_w = 1 / det;
+    const out_min_x = (m4[0] * in_min_x + m4[4] * in_min_y + m4[8] * in_min_z + m4[12]) * inv_w0;
+    const out_min_y = (m4[1] * in_min_x + m4[5] * in_min_y + m4[9] * in_min_z + m4[13]) * inv_w0;
+    const out_min_z = (m4[2] * in_min_x + m4[6] * in_min_y + m4[10] * in_min_z + m4[14]) * inv_w0;
 
-    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;
+    // transform ray to local space (inlined for speed)
+    const w1 = m4[3] * in_max_x + m4[7] * in_max_y + m4[11] * in_max_z + m4[15];
 
-    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;
+    const inv_w1 = 1 / w1;
 
-    // normalize direction
-    const out_direction_magnitude = Math.hypot(out_direction_x, out_direction_y, out_direction_z);
+    const out_max_x = (m4[0] * in_max_x + m4[4] * in_max_y + m4[8] * in_max_z + m4[12]) * inv_w1;
+    const out_max_y = (m4[1] * in_max_x + m4[5] * in_max_y + m4[9] * in_max_z + m4[13]) * inv_w1;
+    const out_max_z = (m4[2] * in_max_x + m4[6] * in_max_y + m4[10] * in_max_z + m4[14]) * inv_w1;
 
-    if (out_direction_magnitude === 0) {
-        return false;
-    }
+    const delta_x = out_max_x - out_min_x;
+    const delta_y = out_max_y - out_min_y;
+    const delta_z = out_max_z - out_min_z;
+
+    // normalize direction
+    const out_direction_magnitude = Math.hypot(delta_x, delta_y, delta_z);
 
     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;
+    const out_direction_normalized_x = delta_x * out_direction_magnitude_inverse;
+    const out_direction_normalized_y = delta_y * out_direction_magnitude_inverse;
+    const out_direction_normalized_z = delta_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 + 0] = out_min_x;
+    output[output_offset + 1] = out_min_y;
+    output[output_offset + 2] = out_min_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")
+    output[output_offset + 6] = out_direction_magnitude;
 
     return true;
 }

package/src/core/geom/3d/tetrahedra/triangle/prototype.js

@@ -60,8 +60,6 @@ async function main() {
         transform.matrix
     );
 
-    await scene.build();
-
     const depth_map = new Uint32Array(4);
 
     trace_triangular_depth_map(depth_map, 0,

package/src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace_triangular_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,mDATW,WAAW,iBACX,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,gCAyGhB"}
+{"version":3,"file":"trace_triangular_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,mDATW,WAAW,iBACX,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,gCA2GhB"}

package/src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.js

@@ -1,8 +1,9 @@
 import { v3_length } from "../../../vec3/v3_length.js";
 import { ray3_array_compose } from "../../ray/ray3_array_compose.js";
+import { Ray3 } from "../../Ray3.js";
 
 const scratch = [];
-const ray = [];
+const ray = new Ray3();
 
 /**
  *
@@ -92,7 +93,9 @@ export function trace_triangular_depth_map(
                 ray_direction_x, ray_direction_y, ray_direction_z
             );
 
-            const distance = scene.trace(scratch, ray, 0, distance_to_target);
+            ray.tMax = distance_to_target;
+
+            const distance = scene.trace(scratch, ray);
 
             let depth;
             if (distance < 0) {

package/src/core/geom/vec3/v3_matrix4_rotate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_rotate(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number, m4: number[] | Float32Array): void;
+//# sourceMappingURL=v3_matrix4_rotate.d.ts.map

package/src/core/geom/vec3/v3_matrix4_rotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_matrix4_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,0CANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAoB/B"}

package/src/core/geom/vec3/v3_matrix4_rotate.js

@@ -0,0 +1,27 @@
+/**
+ * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_rotate(
+    output, output_offset,
+    input, input_offset,
+    m4
+) {
+    const x = input[input_offset];
+    const y = input[input_offset + 1];
+    const z = input[input_offset + 2];
+
+    const _x = m4[0] * x + m4[4] * y + m4[8] * z;
+    const _y = m4[1] * x + m4[5] * y + m4[9] * z;
+    const _z = m4[2] * x + m4[6] * y + m4[10] * z;
+
+    const norm = 1 / Math.hypot(_x, _y, _z);
+
+    output[output_offset] = _x * norm;
+    output[output_offset + 1] = _y * norm;
+    output[output_offset + 2] = _z * norm;
+}

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"}