@woosh/meep-engine 2.108.4 → 2.109.0

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

@@ -0,0 +1,35 @@
+import { v3_shift_along_direction } from "../../vec3/v3_shift_along_direction.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} output 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number} output_offset
+ * @param {number[]|ArrayLike<number>|Float32Array} input 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+ * @param {number} input_offset
+ * @param {number} distance
+ */
+export function ray3_shift_origin_along_direction(
+    output, output_offset,
+    input, input_offset,
+    distance
+) {
+    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];
+
+    v3_shift_along_direction(
+        output, 0,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        distance
+    );
+
+    output[output_offset + 3] = direction_x;
+    output[output_offset + 4] = direction_y;
+    output[output_offset + 5] = direction_z;
+}
+

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

@@ -0,0 +1 @@
+//# sourceMappingURL=compute_legendre_polynomial.d.ts.map

package/src/core/geom/3d/sphere/harmonics/compute_legendre_polynomial.d.ts.map

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

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

@@ -0,0 +1,9 @@
+/**
+ * Performs convolution of 3-band spherical harmonic coefficients with a cosine kernel
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number[]} input
+ * @param {number} input_offset
+ */
+export function sh3_convolve_with_cosine_kernel(out: number[], out_offset: number, input: number[], input_offset: number): void;
+//# sourceMappingURL=sh3_convolve_with_cosine_kernel.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh3_convolve_with_cosine_kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh3_convolve_with_cosine_kernel.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_convolve_with_cosine_kernel.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,qDALW,MAAM,EAAE,cACR,MAAM,SACN,MAAM,EAAE,gBACR,MAAM,QAchB"}

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

@@ -0,0 +1,25 @@
+// Cosine kernel for SH
+const CosineA0 = Math.PI;
+const CosineA1 = (2.0 * Math.PI) / 3.0;
+const CosineA2 = Math.PI / 4.0;
+
+/**
+ * Performs convolution of 3-band spherical harmonic coefficients with a cosine kernel
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number[]} input
+ * @param {number} input_offset
+ */
+export function sh3_convolve_with_cosine_kernel(out, out_offset, input, input_offset) {
+    out[out_offset + 0] = input[input_offset + 0] * CosineA0;
+
+    out[out_offset + 1] = input[input_offset + 1] * CosineA1;
+    out[out_offset + 2] = input[input_offset + 2] * CosineA1;
+    out[out_offset + 3] = input[input_offset + 3] * CosineA1;
+
+    out[out_offset + 4] = input[input_offset + 4] * CosineA2;
+    out[out_offset + 5] = input[input_offset + 5] * CosineA2;
+    out[out_offset + 6] = input[input_offset + 6] * CosineA2;
+    out[out_offset + 7] = input[input_offset + 7] * CosineA2;
+    out[out_offset + 8] = input[input_offset + 8] * CosineA2;
+}

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sh3_dering_optimize_positive.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js"],"names":[],"mappings":"AAkSA;;;;;;;GAOG;AACH,qDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,oBAClC,MAAM,oBACN,MAAM,QAIhB"}
+{"version":3,"file":"sh3_dering_optimize_positive.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js"],"names":[],"mappings":"AAgSA;;;;;;;GAOG;AACH,qDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,oBAClC,MAAM,oBACN,MAAM,QAIhB"}

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

@@ -3,7 +3,7 @@ import { assert } from "../../../../assert.js";
 import { array_copy } from "../../../../collection/array/array_copy.js";
 import { min2 } from "../../../../math/min2.js";
 import { SH3_COEFFICIENTS } from "./SH3_COEFFICIENTS.js";
-import { sh3_rotate } from "./sh3_rotate.js";
+import { sh3_rotate_bl } from "./sh3_rotate_bl.js";
 import { sh_index } from "./sh_index.js";
 
 /*
@@ -74,11 +74,9 @@ function sh3_min(input_sh3) {
     array_copy(y_axis, 0, M, 3, 3);
     array_copy(dir, 0, M, 6, 3);
 
-    mat3.transpose(M, M);
-
     const f = new Float32Array(9);
 
-    sh3_rotate(f, input_sh3, M);
+    sh3_rotate_bl(f, input_sh3, M);
     // here we're guaranteed to have normalize(float3{ -f[3], -f[1], f[2] }) == { 0, 0, 1 }
 
 

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

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number[]|Float32Array} result sh3
+ * @param {number[]} sh input
+ * @param {number[]} rotation 3x3 rotation matrix
+ */
+export function sh3_rotate_bl(result: number[] | Float32Array, sh: number[], rotation: number[]): number[] | Float32Array;
+//# sourceMappingURL=sh3_rotate_bl.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh3_rotate_bl.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,sCAJW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,EAAE,YACR,MAAM,EAAE,2BAuFlB"}

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

@@ -0,0 +1,94 @@
+const scratch_mat_5x5 = new Float64Array(25);
+
+/**
+ *
+ * @param {number[]|Float32Array} result sh3
+ * @param {number[]} sh input
+ * @param {number[]} rotation 3x3 rotation matrix
+ */
+export function sh3_rotate_bl(result, sh, rotation) {
+    // Implementation adapted from BakerLab by https://github.com/TheRealMJP
+
+    const r00 = rotation[0];
+    const r10 = rotation[1];
+    const r20 = rotation[2];
+
+    const r01 = rotation[3];
+    const r11 = rotation[4];
+    const r21 = rotation[5];
+
+    const r02 = rotation[6];
+    const r12 = rotation[7];
+    const r22 = rotation[8];
+
+
+    // Constant
+    result[0] = sh[0];
+
+    // Linear
+    result[1] = r11 * sh[1] - r12 * sh[2] + r10 * sh[3];
+    result[2] = -r21 * sh[1] + r22 * sh[2] - r20 * sh[3];
+    result[3] = r01 * sh[1] - r02 * sh[2] + r00 * sh[3];
+
+    // Quadratic
+    const t41 = r01 * r00;
+    const t43 = r11 * r10;
+    const t48 = r11 * r12;
+    const t50 = r01 * r02;
+    const t55 = r02 * r02;
+    const t57 = r22 * r22;
+    const t58 = r12 * r12;
+    const t61 = r00 * r02;
+    const t63 = r10 * r12;
+    const t68 = r10 * r10;
+    const t70 = r01 * r01;
+    const t72 = r11 * r11;
+    const t74 = r00 * r00;
+    const t76 = r21 * r21;
+    const t78 = r20 * r20;
+
+    const v173 = 0.1732050808e1;
+    const v577 = 0.5773502693e0;
+    const v115 = 0.1154700539e1;
+    const v288 = 0.2886751347e0;
+    const v866 = 0.8660254040e0;
+
+    scratch_mat_5x5[0] = r11 * r00 + r01 * r10;
+    scratch_mat_5x5[1] = -r01 * r12 - r11 * r02;
+    scratch_mat_5x5[2] = v173 * r02 * r12;
+    scratch_mat_5x5[3] = -r10 * r02 - r00 * r12;
+    scratch_mat_5x5[4] = r00 * r10 - r01 * r11;
+    scratch_mat_5x5[5] = -r11 * r20 - r21 * r10;
+    scratch_mat_5x5[6] = r11 * r22 + r21 * r12;
+    scratch_mat_5x5[7] = -v173 * r22 * r12;
+    scratch_mat_5x5[8] = r20 * r12 + r10 * r22;
+    scratch_mat_5x5[9] = -r10 * r20 + r11 * r21;
+    scratch_mat_5x5[10] = -v577 * (t41 + t43) + v115 * r21 * r20;
+    scratch_mat_5x5[11] = v577 * (t48 + t50) - v115 * r21 * r22;
+    scratch_mat_5x5[12] = -0.5 * (t55 + t58) + t57;
+    scratch_mat_5x5[13] = v577 * (t61 + t63) - v115 * r20 * r22;
+    scratch_mat_5x5[14] = v288 * (t70 - t68 + t72 - t74) - v577 * (t76 - t78);
+    scratch_mat_5x5[15] = -r01 * r20 - r21 * r00;
+    scratch_mat_5x5[16] = r01 * r22 + r21 * r02;
+    scratch_mat_5x5[17] = -v173 * r22 * r02;
+    scratch_mat_5x5[18] = r00 * r22 + r20 * r02;
+    scratch_mat_5x5[19] = -r00 * r20 + r01 * r21;
+    scratch_mat_5x5[20] = t41 - t43;
+    scratch_mat_5x5[21] = -t50 + t48;
+    scratch_mat_5x5[22] = v866 * (t55 - t58);
+    scratch_mat_5x5[23] = t63 - t61;
+    scratch_mat_5x5[24] = 0.5 * (t74 - t68 - t70 + t72);
+
+    for (let i = 0; i < 5; ++i) {
+        const base = i * 5;
+
+        result[4 + i] = scratch_mat_5x5[base + 0] * sh[4]
+            + scratch_mat_5x5[base + 1] * sh[5]
+            + scratch_mat_5x5[base + 2] * sh[6]
+            + scratch_mat_5x5[base + 3] * sh[7]
+            + scratch_mat_5x5[base + 4] * sh[8]
+        ;
+    }
+
+    return result;
+}

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

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number[]|Float32Array} result sh3
+ * @param {number[]} sh input
+ * @param {number[]} rotation 3x3 rotation matrix
+ */
+export function sh3_rotate_filament(result: number[] | Float32Array, sh: number[], rotation: number[]): void;
+//# sourceMappingURL=sh3_rotate_filament.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh3_rotate_filament.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh3_rotate_filament.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_rotate_filament.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,4CAJW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,EAAE,YACR,MAAM,EAAE,QAuBlB"}

package/src/core/geom/3d/sphere/harmonics/{sh3_rotate.js → sh3_rotate_filament.js}

@@ -7,7 +7,9 @@ import { sh_rotate_band2 } from "./sh_rotate_band2.js";
  * @param {number[]} sh input
  * @param {number[]} rotation 3x3 rotation matrix
  */
-export function sh3_rotate(result, sh, rotation) {
+export function sh3_rotate_filament(result, sh, rotation) {
+
+    // Adapted from filament https://github.com/google/filament/blob/e2da13f81734ccd6d6f9935061b771801682619e/libs/ibl/src/CubemapSH.cpp
 
     const b0 = sh[0];
     const band1 = [sh[1], sh[2], sh[3]];
@@ -26,4 +28,5 @@ export function sh3_rotate(result, sh, rotation) {
     result[6] = b2[2];
     result[7] = b2[3];
     result[8] = b2[4];
-}
+}
+

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