@woosh/meep-engine 2.111.1 → 2.111.3

package/package.json

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

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

@@ -2,9 +2,9 @@ import { assert } from "../../assert.js";
 import { array_copy } from "../../collection/array/array_copy.js";
 import { array_range_equal_strict } from "../../collection/array/array_range_equal_strict.js";
 import { computeHashFloatArray } from "../../math/hash/computeHashFloatArray.js";
+import { v3_array_normalize } from "../vec3/v3_array_normalize.js";
 import { v3_matrix4_multiply } from "../vec3/v3_matrix4_multiply.js";
 import { v3_matrix4_rotate } from "../vec3/v3_matrix4_rotate.js";
-import { v3_normalize_array } from "../vec3/v3_normalize_array.js";
 import { ray3_interval_array_apply_matrix4 } from "./ray/ray3_interval_array_apply_matrix4.js";
 
 /**
@@ -111,7 +111,7 @@ export class Ray3 extends Float32Array {
     }
 
     normalizeDirection() {
-        v3_normalize_array(this, 3, this, 3);
+        v3_array_normalize(this, 3, this, 3);
     }
 
     /**

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts

@@ -87,12 +87,9 @@ export class TetrahedralMesh {
      */
     private __free_pointer;
     /**
-     * Only valid when the mesh is compacted
-     * @return {number}
-     */
-    get count(): number;
-    /**
-     *
+     * Exposes internal state, when this is false there are hole in the allocated memory
+     * Useful mainly for serialization and debugging.
+     * When serializing, you would want to get rid of any holes first by calling {@link compact}
      * @return {boolean}
      */
     get isCompacted(): boolean;
@@ -110,6 +107,7 @@ export class TetrahedralMesh {
     getLive(): number[];
     /**
      * Clears all data from the mesh, making it contain 0 tetrahedrons
+     * Ensures that consequent allocation requests will be sequential
      */
     clear(): void;
     /**
@@ -124,9 +122,16 @@ export class TetrahedralMesh {
     getCapacity(): number;
     /**
      * How many tetrahedrons are contained in the mesh, includes any unallocated tetrahedrons
+     * @deprecated use {@link count} instead
      * @return {number}
      */
     size(): number;
+    /**
+     * Number of currently live tetrahedrons.
+     * Excludes unallocated tetrahedrons.
+     * @return {number}
+     */
+    get count(): number;
     /**
      * Grow capacity to at least the specified size
      * @private
@@ -202,7 +207,7 @@ export class TetrahedralMesh {
      */
     disconnect(tetra_index: number): void;
     /**
-     * Remove tetrahedron
+     * Remove tetrahedron, de-allocating memory
      * Please note that if there are any dangling references in the mesh neighbourhood - you will need to take care of that separately
      * @param {number} tetra_index
      */

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAG3B;;;OAGG;IACH,oBAIC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAUC;IAED;;;;OAIG;IACH,WAFY,MAAM,EAAE,CAYnB;IAED;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,qBAYC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;;OAQG;IACH,eAPW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CA8DlB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA6BhB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAUjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAQhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BAvvB4B,iCAAiC"}
+{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAG3B;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAUC;IAED;;;;OAIG;IACH,WAFY,MAAM,EAAE,CAYnB;IAED;;;OAGG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,QAFY,MAAM,CAMjB;IAED;;;;OAIG;IACH,oBAEC;IAGD;;;;OAIG;IACH,qBAYC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;;OAQG;IACH,eAPW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CA8DlB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAUjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAQhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA1wB4B,iCAAiC"}

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.js

@@ -134,17 +134,9 @@ export class TetrahedralMesh {
     }
 
     /**
-     * Only valid when the mesh is compacted
-     * @return {number}
-     */
-    get count() {
-        assert.equal(this.isCompacted, true, 'must be compacted');
-
-        return this.__used_end;
-    }
-
-    /**
-     *
+     * Exposes internal state, when this is false there are hole in the allocated memory
+     * Useful mainly for serialization and debugging.
+     * When serializing, you would want to get rid of any holes first by calling {@link compact}
      * @return {boolean}
      */
     get isCompacted() {
@@ -187,6 +179,7 @@ export class TetrahedralMesh {
 
     /**
      * Clears all data from the mesh, making it contain 0 tetrahedrons
+     * Ensures that consequent allocation requests will be sequential
      */
     clear() {
 
@@ -245,12 +238,25 @@ export class TetrahedralMesh {
 
     /**
      * How many tetrahedrons are contained in the mesh, includes any unallocated tetrahedrons
+     * @deprecated use {@link count} instead
      * @return {number}
      */
     size() {
+        console.warn('Deprecated, use .count instead');
+
         return this.__used_end;
     }
 
+    /**
+     * Number of currently live tetrahedrons.
+     * Excludes unallocated tetrahedrons.
+     * @return {number}
+     */
+    get count() {
+        return this.__used_end - this.__free_pointer;
+    }
+
+
     /**
      * Grow capacity to at least the specified size
      * @private
@@ -492,7 +498,7 @@ export class TetrahedralMesh {
     }
 
     /**
-     * Remove tetrahedron
+     * Remove tetrahedron, de-allocating memory
      * Please note that if there are any dangling references in the mesh neighbourhood - you will need to take care of that separately
      * @param {number} tetra_index
      */
@@ -624,6 +630,14 @@ export class TetrahedralMesh {
      * @param {number} destination_index new index, where the source tetrahedron is to be moved
      */
     relocate(source_index, destination_index) {
+        assert.isNonNegativeInteger(source_index, 'source_index');
+        assert.isNonNegativeInteger(destination_index, 'destination_index');
+
+        if (source_index === destination_index) {
+            // avoid unnecessary work
+            return;
+        }
+
         // validate_tetrahedron_neighbourhood(this, source_index, console.error);
 
         // patch neighbours
@@ -647,7 +661,12 @@ export class TetrahedralMesh {
 
 
         const layout_word_size = LAYOUT_TETRA_BYTE_SIZE >> 2;
-        array_copy(this.__data_uint32, source_index * layout_word_size, this.__data_uint32, destination_index * layout_word_size, layout_word_size);
+
+        array_copy(
+            this.__data_uint32, source_index * layout_word_size,
+            this.__data_uint32, destination_index * layout_word_size,
+            layout_word_size
+        );
 
         // validate_tetrahedron_neighbourhood(this, destination_index, console.error);
     }

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

@@ -8,6 +8,7 @@
  * @param {number} resolution_x how many points to generate on the grid in X axis
  * @param {number} resolution_y how many points to generate on the grid in Y axis
  * @param {number} resolution_z how many points to generate on the grid in Y axis
+ * @returns {number} number of added points
  */
-export function tetrahedral_mesh_build_from_grid(mesh: TetrahedralMesh, points: number[], bounds: AABB3, resolution_x?: number, resolution_y?: number, resolution_z?: number): void;
+export function tetrahedral_mesh_build_from_grid(mesh: TetrahedralMesh, points: number[], bounds: AABB3, resolution_x?: number, resolution_y?: number, resolution_z?: number): number;
 //# sourceMappingURL=tetrahedral_mesh_build_from_grid.d.ts.map

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,QA4IhB"}
+{"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":"AAEA;;;;;;;;;;;GAWG;AACH,gFAPW,MAAM,EAAE,gCAER,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,MAAM,CA+LlB"}

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

@@ -1,3 +1,5 @@
+import { assert } from "../../../../assert.js";
+
 /**
  * Special case of tetrahedral mesh generation using a regular 3d grid, useful for generating light probe volumes
  * This is a special case of tetrahedral tessellation, we can handle it much easier due to regular nature of the point distribution
@@ -8,6 +10,7 @@
  * @param {number} resolution_x how many points to generate on the grid in X axis
  * @param {number} resolution_y how many points to generate on the grid in Y axis
  * @param {number} resolution_z how many points to generate on the grid in Y axis
+ * @returns {number} number of added points
  */
 export function tetrahedral_mesh_build_from_grid(
     mesh, points,
@@ -15,7 +18,9 @@ export function tetrahedral_mesh_build_from_grid(
     resolution_x = 2, resolution_y = 2, resolution_z = 2,
 ) {
 
-    console.error("Implementation is incomplete"); // FIXME
+    assert.isNonNegativeInteger(resolution_x, 'resolution_x');
+    assert.isNonNegativeInteger(resolution_y, 'resolution_y');
+    assert.isNonNegativeInteger(resolution_z, 'resolution_z');
 
     mesh.clear();
 
@@ -40,6 +45,11 @@ export function tetrahedral_mesh_build_from_grid(
         return z * resolution_y * resolution_x + y * resolution_x + x;
     }
 
+    function voxel_position_to_tetrahedral(x, y, z, index) {
+
+        return (z * (resolution_y - 1) * (resolution_x - 1) + y * (resolution_x - 1) + x) * 6 + index;
+    }
+
     // generate points
     for (let z = 0; z < resolution_z; z++) {
         for (let y = 0; y < resolution_y; y++) {
@@ -83,63 +93,104 @@ export function tetrahedral_mesh_build_from_grid(
 
     // NOTE: it's possible to tessellate each box into 5 tetrahedrons instead of 6, but orientation becomes inconsistent if we do that
     // reference http://www.iue.tuwien.ac.at/phd/wessner/node32.html
-
     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 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);
-
+                const C = vertex_position_to_index(x, y - 1, z);
+                const D = vertex_position_to_index(x, y - 1, z - 1);
+                const E = vertex_position_to_index(x - 1, y, z - 1);
+                const F = vertex_position_to_index(x - 1, y, z);
+                const G = vertex_position_to_index(x, y, z);
+                const H = vertex_position_to_index(x, y, z - 1);
 
                 // Tessellate the grid volume into six tetrahedra per grid cell.
 
                 // prism 1
-                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);
+                const tet_0 = make_cell(B, A, D, H); // purple
+                const tet_1 = make_cell(B, A, H, E); // blue
+                const tet_2 = make_cell(H, B, E, F); // red
 
                 // prism 2
-                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);
+                const tet_3 = make_cell(C, B, D, H); // orange
+                const tet_4 = make_cell(C, B, H, G); // yellow
+                const tet_5 = make_cell(B, H, G, F); // green
 
                 // 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);
+                // purple
+                mesh.setNeighbour(tet_0, 1, (tet_3 << 2) | 0); // A - orange C
+                mesh.setNeighbour(tet_0, 2, (tet_1 << 2) | 3); // D - blue E
 
-                // TODO implement
+                // blue
+                mesh.setNeighbour(tet_1, 1, (tet_2 << 2) | 3); // A - red F
+                mesh.setNeighbour(tet_1, 3, (tet_0 << 2) | 2); // E - purple D
 
+                // red
+                mesh.setNeighbour(tet_2, 2, (tet_5 << 2) | 2); // E - green G
+                mesh.setNeighbour(tet_2, 3, (tet_1 << 2) | 1); // F - blue A
+
+                // orange
+                mesh.setNeighbour(tet_3, 0, (tet_0 << 2) | 1); // C - purple A
+                mesh.setNeighbour(tet_3, 2, (tet_4 << 2) | 3); // D - yellow G
+
+                // yellow
+                mesh.setNeighbour(tet_4, 0, (tet_5 << 2) | 3); // C - green F
+                mesh.setNeighbour(tet_4, 3, (tet_3 << 2) | 2); // G - orange D
+
+                // green
+                mesh.setNeighbour(tet_5, 2, (tet_2 << 2) | 2); // G - red E
+                mesh.setNeighbour(tet_5, 3, (tet_4 << 2) | 0); // F - yellow C
+
+                // links to previous voxel
+
+                // prev x
                 if (x > 1) {
-                    // link to previous voxel
-                    // TODO implement
+                    const tet_3_prev_x = voxel_position_to_tetrahedral(x - 2, y - 1, z - 1, 3);// prev x orange
+                    const tet_4_prev_x = voxel_position_to_tetrahedral(x - 2, y - 1, z - 1, 4); // prev x yellow
+
+                    // blue
+                    mesh.setNeighbour(tet_1, 2, (tet_3_prev_x << 2) | 1); // H - prev x orange B
+                    // orange prev x
+                    mesh.setNeighbour(tet_3_prev_x, 1, (tet_1 << 2) | 2); // B - blue H
+
+                    // red
+                    mesh.setNeighbour(tet_2, 0, (tet_4_prev_x << 2) | 1); // H - prev x yellow B
+                    // yellow prev x
+                    mesh.setNeighbour(tet_4_prev_x, 1, (tet_2 << 2) | 0); // B - red H
                 }
 
+                // prev y
                 if (y > 1) {
-                    // link to previous voxel
-                    // TODO implement
+                    const tet_2_prev_y = voxel_position_to_tetrahedral(x - 1, y - 2, z - 1, 2); // prev y red
+                    const tet_5_prev_y = voxel_position_to_tetrahedral(x - 1, y - 2, z - 1, 5); // prev y green
+
+                    // purple
+                    mesh.setNeighbour(tet_0, 3, (tet_2_prev_y << 2) | 1); // H - prev y red B
+                    // prev y red
+                    mesh.setNeighbour(tet_2_prev_y, 1, (tet_0 << 2) | 3); // B - blue H
+
+                    // orange
+                    mesh.setNeighbour(tet_3, 3, (tet_5_prev_y << 2) | 0); // H - prev y green B
+                    // prev y green
+                    mesh.setNeighbour(tet_5_prev_y, 0, (tet_3 << 2) | 3); // B - orange H
                 }
 
                 if (z > 1) {
-                    // link to previous voxel
-                    // TODO implement
+                    const tet_4_prev_z = voxel_position_to_tetrahedral(x - 1, y - 1, z - 2, 4); // prev z yellow
+                    const tet_5_prev_z = voxel_position_to_tetrahedral(x - 1, y - 1, z - 2, 5); // prev z green
+
+                    // purple
+                    mesh.setNeighbour(tet_0, 0, (tet_4_prev_z << 2) | 2); // B - prev z yellow H
+                    // prev z yellow
+                    mesh.setNeighbour(tet_4_prev_z, 2, (tet_0 << 2) | 0); // H - purple B
+
+                    // blue
+                    mesh.setNeighbour(tet_1, 0, (tet_5_prev_z << 2) | 1); // B - prev z green H
+                    // prev z green
+                    mesh.setNeighbour(tet_5_prev_z, 1, (tet_1 << 2) | 0); // H - blue B
                 }
 
             }
@@ -147,4 +198,7 @@ export function tetrahedral_mesh_build_from_grid(
         }
 
     }
+
+    // number of points added
+    return resolution_x * resolution_y * resolution_z;
 }

package/src/core/geom/3d/tetrahedra/prototypeTetrahedraBuilder.js

@@ -76,7 +76,7 @@ async function main(engine) {
         tetrahedra,
         points,
         new AABB3(-10, 0, -10, 10, 10, 10),
-        8, 4, 8
+        4, 4, 4
     )
     console.timeEnd('mesh build');
     console.log(`Mesh build for ${number_pretty_print(points.length / 3)} points`)

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"v3_array_immediate_add.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_array_immediate_add.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,4CALW,MAAM,EAAE,cACR,MAAM,SACN,MAAM,EAAE,gBACR,MAAM,QAYhB"}

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

@@ -0,0 +1,19 @@
+/**
+ * Adds input to output
+ * `out += input`
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {number[]} input
+ * @param {number} input_offset
+ */
+export function v3_array_immediate_add(out, out_offset, input, input_offset) {
+
+    const x = input[input_offset];
+    const y = input[input_offset + 1];
+    const z = input[input_offset + 2];
+
+    out[out_offset] += x;
+    out[out_offset + 1] += y;
+    out[out_offset + 2] += z;
+
+}

package/src/core/geom/vec3/{v3_normalize_array.d.ts → v3_array_normalize.d.ts}

@@ -5,5 +5,5 @@
  * @param {number[]|Float32Array} input
  * @param {number} input_offset
  */
-export function v3_normalize_array(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number): void;
-//# sourceMappingURL=v3_normalize_array.d.ts.map
+export function v3_array_normalize(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number): void;
+//# sourceMappingURL=v3_array_normalize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"v3_array_normalize.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_array_normalize.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAqBhB"}

package/src/core/geom/vec3/{v3_normalize_array.js → v3_array_normalize.js}

@@ -7,7 +7,7 @@ import { v3_length } from "./v3_length.js";
  * @param {number[]|Float32Array} input
  * @param {number} input_offset
  */
-export function v3_normalize_array(
+export function v3_array_normalize(
     output, output_offset,
     input, input_offset,
 ) {

package/src/engine/ecs/terrain/BufferedGeometryArraysBuilder.js

@@ -1,4 +1,4 @@
-import { computeVertexNormals } from '../../graphics/geometry/buffered/ComputeNormals.js';
+import { geometry_compute_vertex_normals } from '../../graphics/geometry/buffered/geometry_compute_vertex_normals.js';
 
 /**
  *
@@ -103,7 +103,7 @@ function buildBufferGeometry(samplerHeight, position, size, scale, totalSize, re
         }
     }
 
-    computeVertexNormals(vertices, normals, indices);
+    geometry_compute_vertex_normals(vertices, normals, indices);
 
     //CleanupGeometry(geometry);
     return {

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals.d.ts

@@ -0,0 +1,9 @@
+/**
+ * based on code from THREE.js
+ * Prior to calling this function, normals need to be set to 0
+ * @param {Array.<number>|Float32Array} positions
+ * @param {Array.<number>|Float32Array} normals
+ * @param {Array.<number>|Uint32Array} indices
+ */
+export function geometry_compute_vertex_normals(positions: Array<number> | Float32Array, normals: Array<number> | Float32Array, indices: Array<number> | Uint32Array): void;
+//# sourceMappingURL=geometry_compute_vertex_normals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry_compute_vertex_normals.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,2DAJW,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,WAAW,QAsEpC"}

package/src/engine/graphics/geometry/buffered/{ComputeNormals.js → geometry_compute_vertex_normals.js}

@@ -1,4 +1,4 @@
-import { v3_normalize_array } from "../../../../core/geom/vec3/v3_normalize_array.js";
+import { v3_array_normalize } from "../../../../core/geom/vec3/v3_array_normalize.js";
 
 /**
  *
@@ -8,19 +8,23 @@ function normalizeVectors(normals) {
     const count = normals.length;
     for (let i = 0; i < count; i += 3) {
 
-        v3_normalize_array(normals, i, normals, i);
+        v3_array_normalize(normals, i, normals, i);
 
     }
 }
 
 /**
  * based on code from THREE.js
- * normals need to be set to 0
- * @param {Array.<number>|Float32Array} vertices
+ * Prior to calling this function, normals need to be set to 0
+ * @param {Array.<number>|Float32Array} positions
  * @param {Array.<number>|Float32Array} normals
  * @param {Array.<number>|Uint32Array} indices
  */
-export function computeVertexNormals(vertices, normals, indices) {
+export function geometry_compute_vertex_normals(
+    positions,
+    normals,
+    indices
+) {
     let vA, vB, vC;
 
     let vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz;
@@ -29,26 +33,28 @@ export function computeVertexNormals(vertices, normals, indices) {
 
     let crossX, crossY, crossZ;
     // indexed elements
+
     let i = 0;
-    const il = indices.length;
-    for (; i < il; i += 3) {
+
+    const index_length = indices.length;
+    for (; i < index_length; i += 3) {
 
         vA = indices[i] * 3;
         vB = indices[i + 1] * 3;
         vC = indices[i + 2] * 3;
 
         //obtain vertex coordinates
-        vAx = vertices[vA];
-        vAy = vertices[vA + 1];
-        vAz = vertices[vA + 2];
+        vAx = positions[vA];
+        vAy = positions[vA + 1];
+        vAz = positions[vA + 2];
 
-        vBx = vertices[vB];
-        vBy = vertices[vB + 1];
-        vBz = vertices[vB + 2];
+        vBx = positions[vB];
+        vBy = positions[vB + 1];
+        vBz = positions[vB + 2];
 
-        vCx = vertices[vC];
-        vCy = vertices[vC + 1];
-        vCz = vertices[vC + 2];
+        vCx = positions[vC];
+        vCy = positions[vC + 1];
+        vCz = positions[vC + 2];
 
         //compute CB and AB vectors
         vCBx = vCx - vBx;
@@ -64,6 +70,8 @@ export function computeVertexNormals(vertices, normals, indices) {
         crossY = vCBz * vABx - vCBx * vABz;
         crossZ = vCBx * vABy - vCBy * vABx;
 
+        // accumulate normal values
+
         normals[vA] += crossX;
         normals[vA + 1] += crossY;
         normals[vA + 2] += crossZ;
@@ -77,5 +85,7 @@ export function computeVertexNormals(vertices, normals, indices) {
         normals[vC + 2] += crossZ;
     }
 
+    // restore unit magnitude
+
     normalizeVectors(normals);
 }

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts

@@ -28,6 +28,16 @@ export class LightProbeVolume {
      * @param {number} z
      */
     add_point(x: number, y: number, z: number): void;
+    /**
+     *
+     * @param {AABB3} bounds
+     * @param {Vector3|{x:number, y:number, z:number}} resolution
+     */
+    build_grid(bounds: AABB3, resolution: Vector3 | {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
     /**
      * Build tetrahedral mesh
      */

package/src/engine/graphics/sh3/lpv/LightProbeVolume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAMD;;;OAGG;IACH,sCAIC;IAZD,mCAEC;IAYD,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAvL+B,wDAAwD;2BAC7D,mCAAmC"}
+{"version":3,"file":"LightProbeVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/LightProbeVolume.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH;IAiCI,sBAEC;IAED,cAkBC;IAED;;;OAGG;IACH,4BAEC;IAED,uBAEC;IAED,0BAEC;IAMD;;;OAGG;IACH,sCAIC;IAZD,mCAEC;IAYD,sBAEC;IAMD,uBAEC;IAND,oBAEC;IAMD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAgBhB;IAED;;;;OAIG;IACH,sCAFW,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAA;KAAC,QAOhD;IAED;;OAEG;IACH,mBAaC;IAGD;;;;;OAKG;IACH,mCAJW,MAAM,GAEJ,UAAU,CAsBtB;IAGD,yBAEC;;CAEJ;gCAnM+B,wDAAwD;2BAC7D,mCAAmC"}

package/src/engine/graphics/sh3/lpv/LightProbeVolume.js

@@ -2,6 +2,9 @@ import { assert } from "../../../../core/assert.js";
 import {
     compute_delaunay_tetrahedral_mesh
 } from "../../../../core/geom/3d/tetrahedra/delaunay/compute_delaunay_tetrahedral_mesh.js";
+import {
+    tetrahedral_mesh_build_from_grid
+} from "../../../../core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_build_from_grid.js";
 import { TetrahedralMesh } from "../../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
 import { EntityNode } from "../../../ecs/parent/EntityNode.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
@@ -35,7 +38,7 @@ export class LightProbeVolume {
      * Depth map is stored as a 2d texture of size RESOLUTION x RESOLUTION
      * @type {number}
      */
-    #probe_depth_resolution = 16;
+    #probe_depth_resolution = 12;
 
     /**
      * Octahedral-encoded depth map for each probe, 2 channels for mean and mean squared for variance recovery in the shader
@@ -133,6 +136,18 @@ export class LightProbeVolume {
         this.#probe_count++;
     }
 
+    /**
+     *
+     * @param {AABB3} bounds
+     * @param {Vector3|{x:number, y:number, z:number}} resolution
+     */
+    build_grid(bounds, resolution) {
+        this.#probe_count = tetrahedral_mesh_build_from_grid(
+            this.#mesh, this.#probe_positions,
+            bounds, resolution.x, resolution.y, resolution.z
+        );
+    }
+
     /**
      * Build tetrahedral mesh
      */
@@ -148,7 +163,7 @@ export class LightProbeVolume {
 
         const t2 = performance.now();
 
-        console.log(`Tetrahedral mesh (${this.#probe_count} points, ${this.#mesh.size()} tets) build took ${t2 - t0}ms`);
+        console.log(`Tetrahedral mesh (${this.#probe_count} points, ${this.#mesh.count} tets) build took ${t2 - t0}ms`);
     }
 
 

package/src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js

@@ -24,7 +24,7 @@ const sampled_irradiance = new Float32Array(3);
 export class PathTracerProbeRenderer extends ProbeRenderer {
     tracer = new PathTracer();
     max_bounce_count = 5;
-    sample_count = 190;
+    sample_count = 256;
     // sample_count = 40960;
     random = seededRandom(0);
 

package/src/engine/graphics/sh3/lpv/build_probes_for_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_probes_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/build_probes_for_scene.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,iFAPW,gBAAgB,GAKd,QAAQ,gBAAgB,CAAC,CAoFrC;iCA9FgC,uBAAuB"}
+{"version":3,"file":"build_probes_for_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/build_probes_for_scene.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,iFAPW,gBAAgB,GAKd,QAAQ,gBAAgB,CAAC,CA8FrC;iCAxGgC,uBAAuB"}

package/src/engine/graphics/sh3/lpv/build_probes_for_scene.js

@@ -1,6 +1,6 @@
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
-import { make_justified_point_grid } from "../../../../core/geom/3d/util/make_justified_point_grid.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { delay } from "../../../../core/process/delay.js";
 import Entity from "../../../ecs/Entity.js";
@@ -60,18 +60,28 @@ export async function build_probes_for_scene(
     //     );
     // }
 
-    make_justified_point_grid(model_bounds, probe_grid_spacing, (x, y, z) => {
-        volume.add_point(x, y, z);
-    });
+    // make_justified_point_grid(model_bounds, probe_grid_spacing, (x, y, z) => {
+    //     volume.add_point(x, y, z);
+    // });
 
     // lpv.add_point(10, 1, -10);
 
     await delay(1);
 
+
     //
     // console.profile('lpv build');
     //
-    volume.build_mesh();
+    // volume.build_mesh();
+    console.time('Grid Build')
+    volume.build_grid(model_bounds, new Vector3(
+        Math.ceil(model_bounds.width / probe_grid_spacing),
+        Math.ceil(model_bounds.height / probe_grid_spacing),
+        Math.ceil(model_bounds.depth / probe_grid_spacing)
+    ));
+
+    console.timeEnd('Grid Build');
+
     const lpv_baker = new LightProbeVolumeBaker();
     const task = lpv_baker.bake(volume, ecd);
     // console.profileEnd('lpv build');

package/src/engine/graphics/sh3/prototypeSH3Probe.js

@@ -388,8 +388,8 @@ async function main(engine) {
     // const path = 'data/models/samples/teapot.gltf';
     // const path = 'data/models/samples/salle_de_bain/model.glb';
     // const path = 'data/models/samples/conference/model-no-curtains.glb';
-    // const path = 'data/models/pica_pica/pica_pica.gltf';
-    const path = 'data/models/samples/gi_box_01/model.glb';
+    const path = 'data/models/pica_pica/pica_pica.gltf';
+    // const path = 'data/models/samples/gi_box_01/model.glb';
     // const path = 'data/models/samples/low_poly_classroom/no-glass/model.gltf';
 
     const mesh_asset = await engine.assetManager.promise(path, 'model/gltf+json');

package/src/engine/physics/inverse_kinematics/fabrik/fabrik3d_solve_primitive.js

@@ -1,8 +1,8 @@
+import { v3_array_normalize } from "../../../../core/geom/vec3/v3_array_normalize.js";
 import { v3_displace_in_direction_array } from "../../../../core/geom/vec3/v3_displace_in_direction_array.js";
 import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
 import { v3_distance_sqr } from "../../../../core/geom/vec3/v3_distance_sqr.js";
 import { v3_length_sqr } from "../../../../core/geom/vec3/v3_length_sqr.js";
-import { v3_normalize_array } from "../../../../core/geom/vec3/v3_normalize_array.js";
 
 const scratch_direction = new Float32Array(3);
 
@@ -103,7 +103,7 @@ function reach_out(
     scratch_direction[1] = target_y - origin_y;
     scratch_direction[2] = target_z - origin_z;
 
-    v3_normalize_array(scratch_direction, 0, scratch_direction, 0);
+    v3_array_normalize(scratch_direction, 0, scratch_direction, 0);
 
     for (let i = 1; i < size; i++) {
         const current_offset = i * 3;

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

@@ -1 +0,0 @@
-{"version":3,"file":"v3_normalize_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_normalize_array.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAqBhB"}

package/src/engine/graphics/geometry/buffered/ComputeNormals.d.ts

@@ -1,9 +0,0 @@
-/**
- * based on code from THREE.js
- * normals need to be set to 0
- * @param {Array.<number>|Float32Array} vertices
- * @param {Array.<number>|Float32Array} normals
- * @param {Array.<number>|Uint32Array} indices
- */
-export function computeVertexNormals(vertices: Array<number> | Float32Array, normals: Array<number> | Float32Array, indices: Array<number> | Uint32Array): void;
-//# sourceMappingURL=ComputeNormals.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ComputeNormals.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/ComputeNormals.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,+CAJW,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,WAAW,QA4DpC"}