@woosh/meep-engine 2.108.4 → 2.109.1

package/src/core/geom/3d/sphere/harmonics/sh3_vector_accumulate.spec.js

@@ -0,0 +1,27 @@
+import { sh3_vector_accumulate } from "./sh3_vector_accumulate.js";
+
+test("basics", () => {
+    const out = [
+        1, 2,
+        3,4, 5,6,7,8,
+        9,10, 11,12, 13,14, 15,16, 17,18
+    ];
+    const basis = [
+        2,
+        3, 5, 7,
+        11, 13, 17, 19, 23
+    ];
+
+    sh3_vector_accumulate(
+        out, 0,
+        basis, 0,
+        [-3, 5], 0,
+        2
+    );
+
+    expect(out).toEqual([
+        -5, 12,
+        -6, 19, -10, 31, -14, 43,
+        -24, 65, -28, 77, -38, 99, -42, 111, -52, 133
+    ]);
+});

package/src/core/geom/3d/sphere/harmonics/sh_compute_K.d.ts

@@ -1,9 +1,9 @@
 /**
- * computes K(m,l) normalization constant
+ * computes K(l,m) normalization constant
  * @see "Deringing Spherical Harmonics" by Peter-Pike Sloan
+ * @param {number} l band
  * @param {number} m
- * @param {number} l
  * @returns {number}
  */
-export function sh_compute_K(m: number, l: number): number;
+export function sh_compute_K(l: number, m: number): number;
 //# sourceMappingURL=sh_compute_K.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh_compute_K.js

@@ -1,13 +1,13 @@
 import { factorial } from "../../../../math/factorial.js";
 
 /**
- * computes K(m,l) normalization constant
+ * computes K(l,m) normalization constant
  * @see "Deringing Spherical Harmonics" by Peter-Pike Sloan
+ * @param {number} l band
  * @param {number} m
- * @param {number} l
  * @returns {number}
  */
-export function sh_compute_K(m, l) {
+export function sh_compute_K(l, m) {
 
     const a = (2 * l + 1) * factorial(l - Math.abs(m))
 

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_build_from_grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_build_from_grid.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_build_from_grid.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,gFANW,MAAM,EAAE,gCAER,MAAM,iBACN,MAAM,iBACN,MAAM,QA6HhB"}
+{"version":3,"file":"tetrahedral_mesh_build_from_grid.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_build_from_grid.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,gFANW,MAAM,EAAE,gCAER,MAAM,iBACN,MAAM,iBACN,MAAM,QA4IhB"}

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_build_from_grid.js

@@ -87,29 +87,44 @@ export function tetrahedral_mesh_build_from_grid(
     for (let z = 1; z < resolution_z; z++) {
         for (let y = 1; y < resolution_y; y++) {
             for (let x = 1; x < resolution_x; x++) {
-                const p000 = vertex_position_to_index(x - 1, y - 1, z - 1);
-                const p001 = vertex_position_to_index(x - 1, y - 1, z);
-                const p010 = vertex_position_to_index(x - 1, y, z - 1);
-                const p011 = vertex_position_to_index(x - 1, y, z);
-                const p100 = vertex_position_to_index(x, y - 1, z - 1);
-                const p101 = vertex_position_to_index(x, y - 1, z);
-                const p110 = vertex_position_to_index(x, y, z - 1);
-                const p111 = vertex_position_to_index(x, y, z);
+                const A = vertex_position_to_index(x - 1, y - 1, z - 1);
+                const B = vertex_position_to_index(x - 1, y - 1, z);
+                const C = vertex_position_to_index(x - 1, y, z - 1);
+                const D = vertex_position_to_index(x - 1, y, z);
+                const E = vertex_position_to_index(x, y - 1, z - 1);
+                const F = vertex_position_to_index(x, y - 1, z);
+                const G = vertex_position_to_index(x, y, z - 1);
+                const H = vertex_position_to_index(x, y, z);
+
+                // const p000 = vertex_position_to_index(x - 1, y - 1, z - 1);
+                // const p001 = vertex_position_to_index(x - 1, y - 1, z);
+                // const p010 = vertex_position_to_index(x - 1, y, z - 1);
+                // const p011 = vertex_position_to_index(x - 1, y, z);
+                // const p100 = vertex_position_to_index(x, y - 1, z - 1);
+                // const p101 = vertex_position_to_index(x, y - 1, z);
+                // const p110 = vertex_position_to_index(x, y, z - 1);
+                // const p111 = vertex_position_to_index(x, y, z);
 
 
                 // Tessellate the grid volume into six tetrahedra per grid cell.
 
                 // prism 1
-                const tet_0 = make_cell(p111, p110, p010, p000);
-                const tet_1 = make_cell(p111, p101, p110, p000);
-                const tet_2 = make_cell(p110, p101, p100, p000);
+                const tet_0 = make_cell(E, F, G, A);
+                const tet_1 = make_cell(A, B, F, G);
+                const tet_2 = make_cell(A, C, B, G);
 
                 // prism 2
-                const tet_3 = make_cell(p111, p011, p010, p000);
-                const tet_4 = make_cell(p111, p101, p011, p000);
-                const tet_5 = make_cell(p011, p101, p001, p000);
+                const tet_3 = make_cell(E, G, H, A);
+                const tet_4 = make_cell(A, H, D, G);
+                const tet_5 = make_cell(A, D, C, G);
 
                 // link newly created tetrahedrons
+                mesh.setNeighbour(tet_0, 1, (tet_3 << 2) & 2);
+                mesh.setNeighbour(tet_3, 2, (tet_0 << 2) & 1);
+
+                mesh.setNeighbour(tet_0, 1, (tet_1 << 2) & 2);
+                mesh.setNeighbour(tet_1, 2, (tet_0 << 2) & 1);
+
                 // TODO implement
 
                 if (x > 1) {

package/src/core/geom/Quaternion.js

@@ -457,7 +457,7 @@ class Quaternion {
     /**
      *
      * @param {Quaternion} other
-     * @param {number} max_delta
+     * @param {number} max_delta in radians
      */
     rotateTowards(other, max_delta) {
         Quaternion.rotateTowards(this, this, other, max_delta);

package/src/core/geom/vec/vector_copy.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number[]} input
+ * @param {number} input_offset
+ * @param {number} length
+ */
+export function vector_copy(out: number[], out_offset: number, input: number[], input_offset: number, length: number): void;
+//# sourceMappingURL=vector_copy.d.ts.map

package/src/core/geom/vec/vector_copy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_copy.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_copy.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,iCANW,MAAM,EAAE,cACR,MAAM,SACN,MAAM,EAAE,gBACR,MAAM,UACN,MAAM,QAIhB"}

package/src/core/geom/vec/vector_copy.js

@@ -0,0 +1,13 @@
+import { array_copy } from "../../collection/array/array_copy.js";
+
+/**
+ *
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number[]} input
+ * @param {number} input_offset
+ * @param {number} length
+ */
+export function vector_copy(out, out_offset, input, input_offset, length) {
+    array_copy(input, input_offset, out, out_offset, length);
+}

package/src/core/{math/vector_nd_dot.d.ts → geom/vec/vector_dot.d.ts}

@@ -5,5 +5,5 @@
  * @param {number} n number of dimensions
  * @return {number}
  */
-export function vector_nd_dot(a: number[] | Float32Array | Float64Array, b: number[] | Float32Array | Float64Array, n: number): number;
-//# sourceMappingURL=vector_nd_dot.d.ts.map
+export function vector_dot(a: number[] | Float32Array | Float64Array, b: number[] | Float32Array | Float64Array, n: number): number;
+//# sourceMappingURL=vector_dot.d.ts.map

package/src/core/geom/vec/vector_dot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_dot.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_dot.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,8BALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,GACL,MAAM,CAUjB"}

package/src/core/{math/vector_nd_dot.js → geom/vec/vector_dot.js}

@@ -5,7 +5,7 @@
  * @param {number} n number of dimensions
  * @return {number}
  */
-export function vector_nd_dot(a, b, n) {
+export function vector_dot(a, b, n) {
     let result = 0;
 
     for (let i = 0; i < n; i++) {

package/src/core/{math/vector_nd_normalize.d.ts → geom/vec/vector_normalize.d.ts}

@@ -4,5 +4,5 @@
  * @param {number[]|Float32Array|Float64Array} data
  * @param {number} [length] number of dimensions
  */
-export function vector_nd_normalize(result: number[] | Float32Array | Float64Array, data: number[] | Float32Array | Float64Array, length?: number): void;
-//# sourceMappingURL=vector_nd_normalize.d.ts.map
+export function vector_normalize(result: number[] | Float32Array | Float64Array, data: number[] | Float32Array | Float64Array, length?: number): void;
+//# sourceMappingURL=vector_normalize.d.ts.map

package/src/core/geom/vec/vector_normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_normalize.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_normalize.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,yCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,WAClC,MAAM,QAoBhB"}

package/src/core/{math/vector_nd_normalize.js → geom/vec/vector_normalize.js}

@@ -4,7 +4,7 @@
  * @param {number[]|Float32Array|Float64Array} data
  * @param {number} [length] number of dimensions
  */
-export function vector_nd_normalize(result, data, length = data.length) {
+export function vector_normalize(result, data, length = data.length) {
 
     let magnitude2 = 0;
 

package/src/core/geom/vec/vector_normalize.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vector_normalize.spec.d.ts.map

package/src/core/geom/vec/vector_normalize.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_normalize.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_normalize.spec.js"],"names":[],"mappings":""}

package/src/core/{math/vector_nd_normalize.spec.js → geom/vec/vector_normalize.spec.js}

@@ -1,15 +1,15 @@
-import { vector_nd_normalize } from "./vector_nd_normalize.js";
+import { vector_normalize } from "./vector_normalize.js";
 
 test("1d vector normalization", () => {
     const v = [7];
 
-    vector_nd_normalize(v, v, 1);
+    vector_normalize(v, v, 1);
 
     expect(v[0]).toBeCloseTo(1);
 
     v[0] = -13;
 
-    vector_nd_normalize(v, v, 1);
+    vector_normalize(v, v, 1);
 
     expect(v[0]).toBeCloseTo(-1);
 });

package/src/core/geom/vec/vector_scale_array.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} input_offset
+ * @param {number} dimensions
+ * @param {number} scale
+ */
+export function vector_scale_array(out: number[] | Float32Array | Float64Array, out_offset: number, input: number[] | Float32Array | Float64Array, input_offset: number, dimensions: number, scale: number): void;
+//# sourceMappingURL=vector_scale_array.d.ts.map

package/src/core/geom/vec/vector_scale_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_scale_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_scale_array.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,cACN,MAAM,SACN,MAAM,QAqBhB"}

package/src/core/geom/vec/vector_scale_array.js

@@ -0,0 +1,31 @@
+import { assert } from "../../assert.js";
+
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} input_offset
+ * @param {number} dimensions
+ * @param {number} scale
+ */
+export function vector_scale_array(
+    out, out_offset,
+    input, input_offset,
+    dimensions,
+    scale) {
+
+    assert.isArrayLike(out, 'out');
+    assert.isNonNegativeInteger(out_offset, 'out_offset');
+
+    assert.isArrayLike(input, 'input');
+    assert.isNonNegativeInteger(input_offset, 'input_offset');
+
+    assert.isNonNegativeInteger(dimensions, 'dimensions');
+    assert.isNumber(scale, 'scale');
+
+    for (let i = 0; i < dimensions; i++) {
+        out[out_offset + i] = input[input_offset + i] * scale;
+    }
+
+}

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

@@ -18,3 +18,5 @@ export function v3_dot_array_array(a, a_offset, b, b_offset) {
 
     return a_x * b_x + a_y * b_y + a_z * b_z;
 }
+
+

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

@@ -0,0 +1,10 @@
+/**
+ * Perform matrix multiplication on a 3d vector
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_multiply(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number, m4: number[] | Float32Array): void;
+//# sourceMappingURL=v3_matrix4_multiply.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"v3_matrix4_multiply.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_multiply.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,4CANW,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_multiply.js

@@ -0,0 +1,27 @@
+/**
+ * Perform matrix multiplication on a 3d vector
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_multiply(
+    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 w = 1 / (m4[3] * x + m4[7] * y + m4[11] * z + m4[15]);
+
+    const _x = (m4[0] * x + m4[4] * y + m4[8] * z + m4[12]) * w;
+    const _y = (m4[1] * x + m4[5] * y + m4[9] * z + m4[13]) * w;
+    const _z = (m4[2] * x + m4[6] * y + m4[10] * z + m4[14]) * w;
+
+    output[output_offset] = _x;
+    output[output_offset + 1] = _y;
+    output[output_offset + 2] = _z;
+}

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

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_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} distance
+ */
+export function v3_shift_along_direction(output: number[] | Float32Array, output_offset: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, distance: number): void;
+//# sourceMappingURL=v3_shift_along_direction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"v3_shift_along_direction.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_shift_along_direction.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,iDAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,YACN,MAAM,QAYhB"}

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

@@ -0,0 +1,23 @@
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_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} distance
+ */
+export function v3_shift_along_direction(
+    output, output_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    distance
+) {
+
+    output[output_offset + 0] = origin_x + direction_x * distance;
+    output[output_offset + 1] = origin_y + direction_y * distance;
+    output[output_offset + 2] = origin_z + direction_z * distance;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Computes associated Legendre Polynomial P(l,m,x) at x
+ * Useful in Spherical Harmonics coefficient computation
+ * @param {number} l band
+ * @param {number} m
+ * @param {number} x
+ * @returns {number}
+ */
+export function compute_legendre_polynomial(l: number, m: number, x: number): number;
+//# sourceMappingURL=compute_legendre_polynomial.d.ts.map

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

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

package/src/core/math/compute_legendre_polynomial.js

@@ -0,0 +1,46 @@
+/**
+ * Computes associated Legendre Polynomial P(l,m,x) at x
+ * Useful in Spherical Harmonics coefficient computation
+ * @param {number} l band
+ * @param {number} m
+ * @param {number} x
+ * @returns {number}
+ */
+export function compute_legendre_polynomial(l, m, x) {
+    // based on code from https://github.com/jan-van-bergen/SphericalHarmonicLighting/blob/2b214b3451859ded07ea4e41fb2aa8d2a44ab579/SphericalHarmonicsLighting/SphericalHarmonics.cpp#L61
+
+    // Apply rule 2; P m m
+    let pmm = 1.0;
+    if (m > 0) {
+        const somx2 = Math.sqrt((1.0 - x) * (1.0 + x));
+        let fact = 1.0;
+
+        for (let i = 1; i <= m; i++) {
+            pmm *= (-fact) * somx2;
+            fact += 2.0;
+        }
+    }
+
+    // If l is equal to m then P m m is already the right answer
+    if (l === m) {
+        return pmm;
+    }
+
+    // Use rule 3 once
+    let pmmp1 = x * (2.0 * m + 1.0) * pmm;
+
+    if (l === m + 1) {
+        return pmmp1;
+    }
+
+    // Iterate rule 1 until the right answer is found
+    let pll = 0.0;
+
+    for (let ll = m + 2; ll <= l; ll++) {
+        pll = ((2.0 * ll - 1.0) * x * pmmp1 - (ll + m - 1.0) * pmm) / (ll - m);
+        pmm = pmmp1;
+        pmmp1 = pll;
+    }
+
+    return pll;
+}

package/src/core/math/statistics/softmax.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Normalized exponential function, converts vector of size K into probability distribution of K possible outcomes
+ * Useful in neural network implementations
+ * @see https://en.wikipedia.org/wiki/Softmax_function
+ * @param {number[]|Float32Array} z input vector
+ * @param {number} i Element in vector Z to compute softmax for
+ * @param {number} k Should be >= 1, typically dimension of Z
+ * @returns {number}
+ */
+export function softmax(z: number[] | Float32Array, i: number, k: number): number;
+//# sourceMappingURL=softmax.d.ts.map

package/src/core/math/statistics/softmax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"softmax.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/softmax.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,2BALW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/math/statistics/softmax.js

@@ -0,0 +1,24 @@
+/**
+ * Normalized exponential function, converts vector of size K into probability distribution of K possible outcomes
+ * Useful in neural network implementations
+ * @see https://en.wikipedia.org/wiki/Softmax_function
+ * @param {number[]|Float32Array} z input vector
+ * @param {number} i Element in vector Z to compute softmax for
+ * @param {number} k Should be >= 1, typically dimension of Z
+ * @returns {number}
+ */
+export function softmax(z, i, k) {
+
+    const ezi = Math.exp(z[i]);
+
+    // NOTE that if we want to compute softmax for an entire vector, it could be far more efficient
+    let sum = 0;
+
+    for (let j = 1; j < k; j++) {
+
+        sum += Math.exp(z[j]);
+
+    }
+
+    return ezi / sum;
+}

package/src/core/math/statistics/softmax.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=softmax.spec.d.ts.map

package/src/core/math/statistics/softmax.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"softmax.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/statistics/softmax.spec.js"],"names":[],"mappings":""}

package/src/core/math/statistics/softmax.spec.js

@@ -0,0 +1,9 @@
+import { softmax } from "./softmax.js";
+
+test("1,2,8",()=>{
+
+    expect(softmax([1,2,8],0,3)).toBeCloseTo(0.001);
+    expect(softmax([1,2,8],1,3)).toBeCloseTo(0.002);
+    expect(softmax([1,2,8],2,3)).toBeCloseTo(0.997);
+
+});

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

@@ -1 +1 @@
-{"version":3,"file":"NodeInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeInstance.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH;IAEI;;;;OAIG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,6BAAmB;IAEnB;;;OAGG;IACH,WAFU,yBAAyB,EAAE,CAEtB;IAEf;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,qBAAmB;IAEnB;;;OAGG;IACH,aAFU,gBAAgB,CAED;IAEzB;;;;;;OAMG;IACH,wBAFU,MAAM,CAEE;IAElB;;OAEG;IACH;QACI;;;WAGG;mCADO,OAAO,MAAM,WAAO;QAG9B;;;WAGG;iCADO,OAAO,MAAM,MAAI;QAG3B;;;WAGG;mCADO,OAAO,MAAM,MAAI;QAI3B;;;;WAIG;qCADO,yCAAyC,YAAY,CAAC;MAGlE;IAEF;;;;;;OAMG;IACH,yBALW,MAAM,aACN,aAAa,UACb,YAAY,GACV,MAAM,CAsBlB;IAED;;;OAGG;IACH,gDAEC;IAED;;;OAGG;IACH,+CAEC;IAGD;;;OAGG;IACH,mCAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,oBAKhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,OAKhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,KAOhB;IAED;;;;OAIG;IACH,2BAHW,MAAM,oBAmChB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAkBnB;IAED;;;OAGG;IACH,uCAQC;IAED,wBAIC;IAED;;;OAGG;IACH,mDA+BC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,yBAAyB,GAAC,SAAS,CAoB/C;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAQnB;IAED,mBAEC;IAIL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CAPpC;0CA1VyC,gCAAgC;iBAHzD,kCAAkC;mBAChC,kCAAkC;8BAGvB,oBAAoB"}
+{"version":3,"file":"NodeInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/core/model/node-graph/node/NodeInstance.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH;IAEI;;;;OAIG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,6BAAmB;IAEnB;;;OAGG;IACH,WAFU,yBAAyB,EAAE,CAEtB;IAEf;;;OAGG;IACH,gBAAgB;IAEhB;;;OAGG;IACH,qBAAmB;IAEnB;;;OAGG;IACH,aAFU,gBAAgB,CAED;IAEzB;;;;;;OAMG;IACH,wBAFU,MAAM,CAEE;IAElB;;OAEG;IACH;QACI;;;WAGG;mCADO,OAAO,MAAM,WAAO;QAG9B;;;WAGG;iCADO,OAAO,MAAM,MAAI;QAG3B;;;WAGG;mCADO,OAAO,MAAM,MAAI;QAI3B;;;;WAIG;qCADO,yCAAyC,YAAY,CAAC;MAGlE;IAEF;;;;;;OAMG;IACH,yBALW,MAAM,aACN,aAAa,UACb,YAAY,GACV,MAAM,CAsBlB;IAED;;;OAGG;IACH,gDAEC;IAED;;;OAGG;IACH,+CAEC;IAGD;;;OAGG;IACH,mCAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;;OAIG;IACH,mBAHW,MAAM,oBAKhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,OAKhB;IAED;;;;OAIG;IACH,yBAHW,MAAM,KAOhB;IAED;;;;OAIG;IACH,2BAHW,MAAM,oBAmChB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAkBnB;IAED;;;OAGG;IACH,uCAQC;IAED,wBAIC;IAED;;;OAGG;IACH,mDA+BC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,yBAAyB,GAAC,SAAS,CAoB/C;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,SAAS,GAAC,yBAAyB,CAa/C;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAQnB;IAED,mBAEC;IAIL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CAPpC;0CA5WyC,gCAAgC;iBAHzD,kCAAkC;mBAChC,kCAAkC;8BAGvB,oBAAoB"}

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

@@ -329,6 +329,24 @@ export class NodeInstance {
         return undefined;
     }
 
+    /**
+     *
+     * @param {string} name
+     * @returns {undefined|NodeInstancePortReference}
+     */
+    getFirstEndpointByName(name) {
+        assert.isString(name, 'name');
+
+        const ports = this.description.getPortsByName(name);
+
+        if (ports.length === 0) {
+            return undefined;
+        }
+
+        return this.getEndpoint(ports[0].id);
+
+    }
+
     hash() {
         return this.id;
     }

package/src/engine/ecs/transform/Transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transform.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/Transform.js"],"names":[],"mappings":"AAsBA;;;GAGG;AACH;IAwQI;;;;OAIG;IACH,4BAFa,SAAS,CAQrB;IAqDD;;;;;OAKG;IACH,wCAJW,UAAU,gBACV,OAAO,wBAajB;IAtVD;;;OAGG;IACH,mBAHU,OAAO,CAGe;IAEhC;;;OAGG;IACH,mBAHU,UAAU,CAGkB;IAEtC;;;OAGG;IACH,gBAHU,OAAO,CAGY;IAE7B;;;;OAIG;IACH,iBAFU,YAAY,CAEC;IAEvB;;;;OAIG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;OAIG;IACH,uBAMC;IAED;;;OAGG;IACH,kBAMC;IAED;;;OAGG;IACH,qBAMC;IAED;;;;OAIG;IACH,kDAIC;IAED;;;;OAIG;IACH,oDAIC;IAYD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;OAEG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,OAAO,OACP,OAAO,QAmBjB;IAED,0BAwBC;IAED;;;;MAMC;IAED;;;OAGG;IACH,YAFW,SAAS,QAenB;IAED;;;OAGG;IACH,SAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAMnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAKlB;IAeD;;;;OAIG;IACH,sBAHW,SAAS,KACT,SAAS,QAMnB;IAED;;;OAGG;IACH,eAFW,OAAK,MAAM,EAAE,GAAC,YAAY,QAcpC;IAED;;;OAGG;IACH,kBAFW,MAAM,EAAE,GAAC,YAAY,QAI/B;IAED;;;;;OAKG;IACH,qBAEC;IAED,mBAEC;IA2BL;;;OAGG;IACH,sBAFU,OAAO,CAEc;;CAZ9B;;kBAIS,MAAM;;oBAhXI,+BAA+B;uBAD5B,kCAAkC;+BAE1B,qBAAqB"}
+{"version":3,"file":"Transform.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/Transform.js"],"names":[],"mappings":"AAsBA;;;GAGG;AACH;IAwQI;;;;OAIG;IACH,4BAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,uBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,SAAS,CAQrB;IAuDD;;;;;OAKG;IACH,wCAJW,UAAU,gBACV,OAAO,wBAajB;IArWD;;;OAGG;IACH,mBAHU,OAAO,CAGe;IAEhC;;;OAGG;IACH,mBAHU,UAAU,CAGkB;IAEtC;;;OAGG;IACH,gBAHU,OAAO,CAGY;IAE7B;;;;OAIG;IACH,iBAFU,YAAY,CAEC;IAEvB;;;;OAIG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;OAIG;IACH,uBAMC;IAED;;;OAGG;IACH,kBAMC;IAED;;;OAGG;IACH,qBAMC;IAED;;;;OAIG;IACH,kDAIC;IAED;;;;OAIG;IACH,oDAIC;IAYD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;OAEG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,OAAO,OACP,OAAO,QAmBjB;IAED,0BAwBC;IAED;;;;MAMC;IAED;;;OAGG;IACH,YAFW,SAAS,QAenB;IAED;;;OAGG;IACH,SAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAMnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAKlB;IA4BD;;;;OAIG;IACH,sBAHW,SAAS,KACT,SAAS,QAMnB;IAED;;;OAGG;IACH,oBAFW,OAAK,MAAM,EAAE,GAAC,YAAY,QAgBpC;IAED;;;OAGG;IACH,kBAFW,MAAM,EAAE,GAAC,YAAY,QAI/B;IAED;;;;;OAKG;IACH,qBAEC;IAED,mBAEC;IA2BL;;;OAGG;IACH,sBAFU,OAAO,CAEc;;CAZ9B;;kBAIS,MAAM;;oBA/XI,+BAA+B;uBAD5B,kCAAkC;+BAE1B,qBAAqB"}

package/src/engine/ecs/transform/Transform.js

@@ -301,6 +301,19 @@ export class Transform {
         return result;
     }
 
+    /**
+     *
+     * @param {number[]|Float32Array} mat
+     * @returns {Transform}
+     */
+    static fromMatrix(mat) {
+        const result = new Transform();
+
+        result.fromMatrix4(mat);
+
+        return result;
+    }
+
     /**
      * Multiply two transforms, result it written into this one
      * @param {Transform} a
@@ -314,17 +327,19 @@ export class Transform {
 
     /**
      *
-     * @param {mat4|number[]|Float32Array} m
+     * @param {mat4|number[]|Float32Array} matrix
      */
-    fromMatrix4(m) {
+    fromMatrix4(matrix) {
+        assert.isArrayLike(matrix, 'matrix');
+
         // we know we are changing the matrix, so we're going to need to disable the flag that sets matrix from position/rotation/scale changes
         const ad = this.getFlag(TransformFlags.AutomaticChangeDetection);
 
         this.clearFlag(TransformFlags.AutomaticChangeDetection);
 
-        this.matrix.set(m);
+        this.matrix.set(matrix);
 
-        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
+        decompose_matrix_4_array(matrix, this.position, this.rotation, this.scale);
 
         // restore value of the flag
         this.writeFlag(TransformFlags.AutomaticChangeDetection, ad);

package/src/engine/graphics/ecs/camera/CameraSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CameraSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/camera/CameraSystem.js"],"names":[],"mappings":"AAeA;IA2OI;;;;OAIG;IACH,8EAOC;IAED;;;;OAIG;IACH,0DAFa;QAAC,SAAS,EAAC,CAAC,MAAM,GAAC,SAAS,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAc1D;IAED;;;;OAIG;IACH,uEAFoB,YAAY,EAAE,gBAqBjC;IAnSD;;;;OAIG;IACH,sCAmDC;IAhDG,WAA2B;IAE3B,mDAAuC;IAEvC,8DAEC;IAQD;;OAEG;IACH,yBAAwB;IAExB,kBAAoB;IAKpB;;;;;OAKG;IACH,+BAeC;IAED,sBAAwB;IAI5B;;;;;OAKG;IACH,aAHW,MAAM,aADN,SAAS,uBAqFnB;IAED;;;;;OAKG;IACH,eAHW,MAAM,aADN,SAAS,uBAiBnB;IAED,0EAqDC;IAED,2EAQC;CA4DJ;uBA/SsB,wBAAwB;0BACrB,qCAAqC;uBAGxC,aAAa;4CALQ,uDAAuD;wCAJ1D,OAAO"}
+{"version":3,"file":"CameraSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/camera/CameraSystem.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,4DAHW,YAAY,8BAmBtB;AAED;IA+NI;;;;OAIG;IACH,8EAOC;IAED;;;;OAIG;IACH,0DAFa;QAAC,SAAS,EAAC,CAAC,MAAM,GAAC,SAAS,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAc1D;IAED;;;;OAIG;IACH,uEAFoB,YAAY,EAAE,gBAqBjC;IAvRD;;;;OAIG;IACH,sCAmDC;IAhDG,WAA2B;IAE3B,mDAAuC;IAEvC,8DAEC;IAQD;;OAEG;IACH,yBAAwB;IAExB,kBAAoB;IAKpB;;;;;OAKG;IACH,+BAeC;IAED,sBAAwB;IAI5B;;;;;OAKG;IACH,aAHW,MAAM,aADN,SAAS,uBAyEnB;IAED;;;;;OAKG;IACH,eAHW,MAAM,aADN,SAAS,uBAiBnB;IAED,0EAqDC;IAED,2EAQC;CA4DJ;uBAtTsB,aAAa;uBALb,wBAAwB;0BACrB,qCAAqC;4CAFnB,uDAAuD;wCAJ1D,OAAO"}