@woosh/meep-engine 2.111.0 → 2.111.2

package/build/meep.cjs

@@ -1015,7 +1015,8 @@ SignalHandler.prototype.isSignalHandler = true;
 
 /**
  * Signal is a type of event bus. You can subscribe to events using {@link add} method and dispatch using sendN method where N is the number of arguments you wish to pass
- * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference. Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
+ * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference.
+ * Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
  * @example `const mouseDown = new Signal<MouseEvent>(); mouseDown.send1(myMouseEvent);`
  */
 class Signal {

package/build/meep.module.js

@@ -1013,7 +1013,8 @@ SignalHandler.prototype.isSignalHandler = true;
 
 /**
  * Signal is a type of event bus. You can subscribe to events using {@link add} method and dispatch using sendN method where N is the number of arguments you wish to pass
- * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference. Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
+ * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference.
+ * Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
  * @example `const mouseDown = new Signal<MouseEvent>(); mouseDown.send1(myMouseEvent);`
  */
 class Signal {

package/package.json

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

package/src/core/events/signal/Signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Signal.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/signal/Signal.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH;IACI;;;;OAIG;IACH,iBAAqB;IAErB;;;;OAIG;IACH,cAAU;IAWV;;;OAGG;IACH,yBAEC;IAfD;;;OAGG;IACH,sBAEC;IAYD;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,SAClB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,OAAO,CAInB;IAGD;;;;;OAKG;IACH,4CAFa,OAAO,CAcnB;IAED,aAEC;IAED,eAEC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,yCAQC;IAED;;;;OAIG;IACH,sCAOC;IA4BD;;;;;OAKG;IACH,oCAFa,OAAO,CA2CnB;IAED;;;;;;OAMG;IACH,kBAEC;IAqDD;;;OAGG;IACH,+BAoCC;IAGD;;;OAGG;IACH,cAoCC;IAED;;;;OAIG;IACH,sBAoCC;IAED;;;;OAIG;IACH,4BAmCC;IAED;;;;;OAKG;IACH,oCAoCC;IAED;;;;;;OAMG;IACH,4CAoCC;IAED;;;;;;;;OAQG;IACH,4DAoCC;IAED;;;;;;;;;;OAUG;IACH,4EAmCC;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAalB;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB"}
+{"version":3,"file":"Signal.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/signal/Signal.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IACI;;;;OAIG;IACH,iBAAqB;IAErB;;;;OAIG;IACH,cAAU;IAWV;;;OAGG;IACH,yBAEC;IAfD;;;OAGG;IACH,sBAEC;IAYD;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,SAClB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,OAAO,CAInB;IAGD;;;;;OAKG;IACH,4CAFa,OAAO,CAcnB;IAED,aAEC;IAED,eAEC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,yCAQC;IAED;;;;OAIG;IACH,sCAOC;IA4BD;;;;;OAKG;IACH,oCAFa,OAAO,CA2CnB;IAED;;;;;;OAMG;IACH,kBAEC;IAqDD;;;OAGG;IACH,+BAoCC;IAGD;;;OAGG;IACH,cAoCC;IAED;;;;OAIG;IACH,sBAoCC;IAED;;;;OAIG;IACH,4BAmCC;IAED;;;;;OAKG;IACH,oCAoCC;IAED;;;;;;OAMG;IACH,4CAoCC;IAED;;;;;;;;OAQG;IACH,4DAoCC;IAED;;;;;;;;;;OAUG;IACH,4EAmCC;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAalB;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB"}

package/src/core/events/signal/Signal.js

@@ -6,7 +6,8 @@ import { SignalHandler, SignalHandlerFlags } from "./SignalHandler.js";
 
 /**
  * Signal is a type of event bus. You can subscribe to events using {@link add} method and dispatch using sendN method where N is the number of arguments you wish to pass
- * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference. Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
+ * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference.
+ * Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
  * @example `const mouseDown = new Signal<MouseEvent>(); mouseDown.send1(myMouseEvent);`
  */
 export class Signal {

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[]} 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/model/node-graph/NodeGraph.d.ts

@@ -33,12 +33,12 @@ export class NodeGraph {
          * @readonly
          * @type {Signal<NodeInstance,number>}
          */
-        readonly nodeAdded: Signal<NodeInstance, number>;
+        readonly nodeAdded: Signal<NodeInstance<import("./node/NodeDescription.js").NodeDescription>, number>;
         /**
          * @readonly
          * @type {Signal<NodeInstance,number>}
          */
-        readonly nodeRemoved: Signal<NodeInstance, number>;
+        readonly nodeRemoved: Signal<NodeInstance<import("./node/NodeDescription.js").NodeDescription>, number>;
         /**
          * @readonly
          * @type {Signal<Connection,number>}

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

@@ -1,18 +1,18 @@
-import {NodeDescription} from "./NodeDescription";
-import {NodeInstancePortReference} from "./NodeInstancePortReference";
 import List from "../../../collection/list/List";
 import {Connection} from "../Connection";
+import {NodeDescription} from "./NodeDescription";
+import {NodeInstancePortReference} from "./NodeInstancePortReference";
 
-export class NodeInstance {
+export class NodeInstance<N extends NodeDescription = NodeDescription> {
     readonly id: number
 
-    readonly description: NodeDescription
+    readonly description: N
 
     readonly endpoints: NodeInstancePortReference[]
 
     readonly connections: List<Connection>
 
-    setDescription(d: NodeDescription): void
+    setDescription(d: N): void
 
     setParameters(hash: { [key: string]: any }): void
 }

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');