@woosh/meep-engine 2.107.0 → 2.108.0

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

@@ -0,0 +1,86 @@
+/**
+ * Math.sqrt(3)
+ * @type {number}
+ */
+const SQRT_3 = 1.7320508075688772;
+
+/**
+ *
+ * @param {number[]|Float32Array} M 5x5 matrix
+ * @param {number[]} x vec5
+ * @return {number[]} vec5
+ */
+function multiply_5d(M, x) {
+    return [
+        M[0] * x[0] + M[5] * x[1] + M[10] * x[2] + M[15] * x[3] + M[20] * x[4],
+        M[1] * x[0] + M[6] * x[1] + M[11] * x[2] + M[16] * x[3] + M[21] * x[4],
+        M[2] * x[0] + M[7] * x[1] + M[12] * x[2] + M[17] * x[3] + M[22] * x[4],
+        M[3] * x[0] + M[8] * x[1] + M[13] * x[2] + M[18] * x[3] + M[23] * x[4],
+        M[4] * x[0] + M[9] * x[1] + M[14] * x[2] + M[19] * x[3] + M[24] * x[4]
+    ];
+}
+
+/**
+ * This projects a vec3 to SH2/k space (i.e. we premultiply by 1/k)
+ * these are second band SH factors, multiplied by 1/K ( K = Math.sqrt(15) / (2*Math.sqrt(Math.PI)) )
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+function project_v3_to_sh2k(output, output_offset, x, y, z) {
+    output[output_offset] = (y * x)
+    output[output_offset + 1] = -(y * z)
+    output[output_offset + 2] = 0.28867513459481287 * (3 * z * z - 1)
+    output[output_offset + 3] = -(z * x)
+    output[output_offset + 4] = 0.5 * (x * x - y * y)
+}
+
+/**
+ *
+ * @param {number[]} band2 vec5
+ * @param {number[]} M mat3
+ * @return {number[]} vec5
+ */
+export function sh_rotate_band2(band2, M) {
+    const n = Math.SQRT1_2;
+
+    //  Below we precompute (with help of Mathematica):
+    //    constexpr float3 N0{ 1, 0, 0 };
+    //    constexpr float3 N1{ 0, 0, 1 };
+    //    constexpr float3 N2{ n, n, 0 };
+    //    constexpr float3 N3{ n, 0, n };
+    //    constexpr float3 N4{ 0, n, n };
+    //    constexpr float M_SQRT_PI = 1.7724538509f;
+    //    constexpr float M_SQRT_15 = 3.8729833462f;
+    //    constexpr float k = M_SQRT_15 / (2.0f * M_SQRT_PI);
+    //    --> k * inverse(mat5{project(N0), project(N1), project(N2), project(N3), project(N4)})
+    const invATimesK = [
+        0, 1, 2, 0, 0,
+        -1, 0, 0, 0, -2,
+        0, SQRT_3, 0, 0, 0,
+        1, 1, 0, -2, 0,
+        2, 1, 0, 0, 0
+    ];
+
+    // this is: invA * k * band2
+    // 5x5 matrix by vec5 (this a lot of zeroes and constants, which the compiler should eliminate)
+    const invATimesKTimesBand2 = multiply_5d(invATimesK, band2);
+
+    // this is: mat5{project(N0), project(N1), project(N2), project(N3), project(N4)} / k
+    // (the 1/k comes from project(), see above)
+    const ROverK = new Float32Array(25);
+
+    project_v3_to_sh2k(ROverK, 0, M[0], M[1], M[2])                  // M * N0
+    project_v3_to_sh2k(ROverK, 5, M[6], M[7], M[8])                  // M * N1
+    project_v3_to_sh2k(ROverK, 10, n * (M[0] + M[3]), n * (M[1] + M[4]), n * (M[2] + M[5]))     // M * N2
+    project_v3_to_sh2k(ROverK, 15, n * (M[0] + M[6]), n * (M[1] + M[7]), n * (M[2] + M[8]))     // M * N3
+    project_v3_to_sh2k(ROverK, 20, n * (M[3] + M[6]), n * (M[4] + M[7]), n * (M[5] + M[8]))      // M * N4;
+
+    // notice how "k" disappears
+    // this is: (R / k) * (invA * k) * band2 == R * invA * band2
+    const result = multiply_5d(ROverK, invATimesKTimesBand2);
+
+    return result;
+}

package/src/core/geom/3d/sphere/in_sphere3d_robust.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in_sphere3d_robust.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/in_sphere3d_robust.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,2CARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAwClB"}
+{"version":3,"file":"in_sphere3d_robust.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/in_sphere3d_robust.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,2CARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAyClB"}

package/src/core/geom/3d/sphere/in_sphere3d_robust.js

@@ -14,7 +14,8 @@ import { insphere } from "robust-predicates";
  */
 export function in_sphere3d_robust(
     points,
-    a, b, c, d, e
+    a, b, c, d,
+    e
 ) {
 
     const a3 = a * 3;

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

@@ -86,12 +86,26 @@ export class TetrahedralMesh {
      * @private
      */
     private __free_pointer;
+    /**
+     * Only valid when the mesh is compacted
+     * @return {number}
+     */
+    get count(): number;
+    /**
+     *
+     * @return {boolean}
+     */
+    get isCompacted(): boolean;
     /**
      * Traverse tetrahedrons
      * @param {function(tet:number,mesh:TetrahedralMesh):*} visitor
      * @param {*} [thisArg]
      */
     forEach(visitor: any, thisArg?: any): void;
+    /**
+     * Clears all data from the mesh, making it contain 0 tetrahedrons
+     */
+    clear(): void;
     /**
      *
      * @param {number} capacity
@@ -112,6 +126,11 @@ export class TetrahedralMesh {
      * @param {number} capacity
      */
     growCapacity(capacity: number): void;
+    /**
+     *
+     * @param {number} capacity
+     */
+    ensureCapacity(capacity: number): void;
     /**
      * NOTE: this method can be quite slow in cases of sparse allocation, please prefer not to use it
      * @param {number} tet
@@ -128,7 +147,7 @@ export class TetrahedralMesh {
     /**
      * NOTE: the neighbour value must be encoded, see format specification for details
      * @param {number} tetra_index
-     * @param {number} neighbour_index which neighbour to set (0..11)
+     * @param {number} neighbour_index which neighbour to set (00..11)
      * @param {number} neighbour index of the neighbour encoded with the opposite corner
      */
     setNeighbour(tetra_index: number, neighbour_index: number, neighbour: number): void;

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;;;;OAIG;IACH,2CAQC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAahB;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;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,SACR,MAAM,GACJ,MAAM,CAsBlB;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;6BAnoB4B,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;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAQC;IAED;;OAEG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAShB;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;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,SACR,MAAM,GACJ,MAAM,CAsBlB;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;6BArrB4B,iCAAiC"}

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

@@ -1,12 +1,12 @@
-import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
-import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
-import { max3 } from "../../../math/max3.js";
 import { assert } from "../../../assert.js";
+import { Base64 } from "../../../binary/Base64.js";
+import { BinaryBuffer } from "../../../binary/BinaryBuffer.js";
 import { array_copy } from "../../../collection/array/array_copy.js";
 import { array_quick_sort_by_comparator } from "../../../collection/array/arrayQuickSort.js";
-import { BinaryBuffer } from "../../../binary/BinaryBuffer.js";
-import { Base64 } from "../../../binary/Base64.js";
+import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
+import { max3 } from "../../../math/max3.js";
 import { number_compare_descending } from "../../../primitives/numbers/number_compare_descending.js";
+import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
 
 /**
  * @readonly
@@ -133,6 +133,22 @@ export class TetrahedralMesh {
         this.__free_pointer = 0;
     }
 
+    /**
+     * Only valid when the mesh is compacted
+     * @return {number}
+     */
+    get count() {
+        return this.__used_end;
+    }
+
+    /**
+     *
+     * @return {boolean}
+     */
+    get isCompacted() {
+        return this.__free_pointer === 0;
+    }
+
     /**
      * Traverse tetrahedrons
      * @param {function(tet:number,mesh:TetrahedralMesh):*} visitor
@@ -148,6 +164,22 @@ export class TetrahedralMesh {
         }
     }
 
+    /**
+     * Clears all data from the mesh, making it contain 0 tetrahedrons
+     */
+    clear() {
+
+        // clear data
+        this.__data_uint32.fill(0, 0, this.__used_end);
+
+        // reset metadata
+        this.__used_end = 0;
+        this.__free_pointer = 0;
+        this.__free.splice(0, this.__free.length);
+
+
+    }
+
     /**
      *
      * @param {number} capacity
@@ -203,6 +235,7 @@ export class TetrahedralMesh {
      * @param {number} capacity
      */
     growCapacity(capacity) {
+        assert.isNonNegativeInteger(capacity, 'capacity');
 
         const existing_capacity = this.__capacity;
 
@@ -215,6 +248,19 @@ export class TetrahedralMesh {
         this.setCapacity(new_capacity);
     }
 
+    /**
+     *
+     * @param {number} capacity
+     */
+    ensureCapacity(capacity) {
+        assert.isNonNegativeInteger(capacity, 'capacity');
+        if (this.__capacity >= capacity) {
+            return;
+        }
+
+        this.growCapacity(capacity);
+    }
+
     /**
      * NOTE: this method can be quite slow in cases of sparse allocation, please prefer not to use it
      * @param {number} tet
@@ -258,7 +304,7 @@ export class TetrahedralMesh {
     /**
      * NOTE: the neighbour value must be encoded, see format specification for details
      * @param {number} tetra_index
-     * @param {number} neighbour_index which neighbour to set (0..11)
+     * @param {number} neighbour_index which neighbour to set (00..11)
      * @param {number} neighbour index of the neighbour encoded with the opposite corner
      */
     setNeighbour(tetra_index, neighbour_index, neighbour) {
@@ -617,7 +663,7 @@ export class TetrahedralMesh {
 
         this.growCapacity(this.__used_end);
 
-        buffer.readUint32Array(this.__data_uint32, 0, this.__used_end);
+        buffer.readUint32Array(this.__data_uint32, 0, this.__used_end * LAYOUT_TETRA_WORD_COUNT);
 
         buffer.readUint32Array(this.__free, 0, this.__free_pointer);
     }

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

@@ -1,5 +1,5 @@
-import { TetrahedralMesh } from "./TetrahedralMesh.js";
 import { jest } from "@jest/globals";
+import { TetrahedralMesh } from "./TetrahedralMesh.js";
 
 test("constructor does not throw", () => {
     expect(() => new TetrahedralMesh(1)).not.toThrow();
@@ -219,7 +219,7 @@ test('Compaction is non-destructive when moving resident data from the very end
     const b = mesh.allocate();
 
     // force move "a" to free set
-    mesh.__free[mesh.__free_pointer++] = a;
+    mesh.delete(a);
 
     expect(mesh.exists(b)).toBe(true);
     expect(mesh.exists(a)).toBe(false);

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

@@ -1,5 +1,5 @@
 /**
- *
+ * Useful as a visualisation tool, to display tetrahedral mesh
  * @param {TetrahedralMesh} tetrahedra
  * @param {Float32Array|number[]} points
  * @return {BufferGeometry}

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

@@ -1 +1 @@
-{"version":3,"file":"build_tetrahedral_mesh_buffer_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/build_tetrahedral_mesh_buffer_geometry.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,4FAHW,YAAY,GAAC,MAAM,EAAE,GACpB,cAAc,CAkEzB;+BA1E6E,OAAO"}
+{"version":3,"file":"build_tetrahedral_mesh_buffer_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/build_tetrahedral_mesh_buffer_geometry.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,4FAHW,YAAY,GAAC,MAAM,EAAE,GACpB,cAAc,CAwEzB;+BA/E6E,OAAO"}

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

@@ -1,20 +1,23 @@
 import { BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute } from "three";
-import { BitSet } from "../../../binary/BitSet.js";
 import { assert } from "../../../assert.js";
 
 /**
- *
+ * Useful as a visualisation tool, to display tetrahedral mesh
  * @param {TetrahedralMesh} tetrahedra
  * @param {Float32Array|number[]} points
  * @return {BufferGeometry}
  */
-export function build_tetrahedral_mesh_buffer_geometry(tetrahedra, points) {
-    const lines = [];
+export function build_tetrahedral_mesh_buffer_geometry(
+    tetrahedra,
+    points
+) {
 
-    const occupancy = new BitSet();
+    const lines = [];
 
     const point_count = points.length / 3;
 
+    const occupancy = {};
+
     assert.isNonNegativeInteger(point_count, 'point_count');
 
     /**
@@ -39,13 +42,15 @@ export function build_tetrahedral_mesh_buffer_geometry(tetrahedra, points) {
             v1 = a;
         }
 
-        const index = v0 * point_count + v1;
+        const key = `${v0}_${v1}`;
 
-        if (occupancy.getAndSet(index)) {
+        if (occupancy.hasOwnProperty(key)) {
             // already recorded
             return;
         }
 
+        occupancy[key] = true;
+
         // no line record yet, create it
         lines.push(v0, v1);
     }

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

@@ -0,0 +1,13 @@
+/**
+ * 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
+ * Note that if resolution in every dimension should be >= 2
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} points point data is written here
+ * @param {AABB3} bounds
+ * @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
+ */
+export function tetrahedral_mesh_build_from_grid(mesh: TetrahedralMesh, points: number[], bounds: AABB3, resolution_x?: number, resolution_y?: number, resolution_z?: number): void;
+//# sourceMappingURL=tetrahedral_mesh_build_from_grid.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,135 @@
+/**
+ * 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
+ * Note that if resolution in every dimension should be >= 2
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} points point data is written here
+ * @param {AABB3} bounds
+ * @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
+ */
+export function tetrahedral_mesh_build_from_grid(
+    mesh, points,
+    bounds,
+    resolution_x = 2, resolution_y = 2, resolution_z = 2,
+) {
+
+    console.error("Implementation is incomplete"); // FIXME
+
+    mesh.clear();
+
+    const tetrahedron_count = (resolution_x - 1) * (resolution_y - 1) * (resolution_z - 1) * 6;
+
+    // we know how many tetrahedrons will be created, so we can avoid some re-allocations by ensuring there's enough capacity
+    mesh.ensureCapacity(tetrahedron_count);
+
+    const bounds_extents_x = bounds.getExtentsX();
+    const bounds_extents_y = bounds.getExtentsY();
+    const bounds_extents_z = bounds.getExtentsZ();
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {number}
+     */
+    function vertex_position_to_index(x, y, z) {
+
+        return z * resolution_y * resolution_x + y * resolution_x + x;
+    }
+
+    // generate points
+    for (let z = 0; z < resolution_z; z++) {
+        for (let y = 0; y < resolution_y; y++) {
+            for (let x = 0; x < resolution_x; x++) {
+
+                const index = vertex_position_to_index(x, y, z);
+
+                const index3 = index * 3;
+
+                const x_norm = x / (resolution_x - 1);
+                const y_norm = y / (resolution_y - 1);
+                const z_norm = z / (resolution_z - 1);
+
+                points[index3] = bounds.x0 + x_norm * bounds_extents_x;
+                points[index3 + 1] = bounds.y0 + y_norm * bounds_extents_y;
+                points[index3 + 2] = bounds.z0 + z_norm * bounds_extents_z;
+
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number} v0
+     * @param {number} v1
+     * @param {number} v2
+     * @param {number} v3
+     * @return {number}
+     */
+    function make_cell(v0, v1, v2, v3) {
+
+        const tet_0 = mesh.allocate();
+
+        mesh.setVertexIndex(tet_0, 0, v0);
+        mesh.setVertexIndex(tet_0, 1, v1);
+        mesh.setVertexIndex(tet_0, 2, v2);
+        mesh.setVertexIndex(tet_0, 3, v3);
+
+        return tet_0;
+    }
+
+    // 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 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);
+
+                // 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);
+
+                // link newly created tetrahedrons
+                // TODO implement
+
+                if (x > 1) {
+                    // link to previous voxel
+                    // TODO implement
+                }
+
+                if (y > 1) {
+                    // link to previous voxel
+                    // TODO implement
+                }
+
+                if (z > 1) {
+                    // link to previous voxel
+                    // TODO implement
+                }
+
+            }
+
+        }
+
+    }
+}

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

@@ -1,17 +1,19 @@
-import { EngineHarness } from "../../../../engine/EngineHarness.js";
-import { compute_delaunay_tetrahedral_mesh } from "./delaunay/compute_delaunay_tetrahedral_mesh.js";
 import { LineBasicMaterial } from "three";
-import { ShadedGeometry } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
-import { DrawMode } from "../../../../engine/graphics/ecs/mesh-v2/DrawMode.js";
 import Entity from "../../../../engine/ecs/Entity.js";
 import { Transform } from "../../../../engine/ecs/transform/Transform.js";
+import { EngineHarness } from "../../../../engine/EngineHarness.js";
+import { DrawMode } from "../../../../engine/graphics/ecs/mesh-v2/DrawMode.js";
+import { ShadedGeometry } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { ShadedGeometrySystem } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
-import { GizmoRenderingPlugin } from "../../../../engine/graphics/render/gizmo/GizmoRenderingPlugin.js";
 import { Gizmo } from "../../../../engine/graphics/render/gizmo/Gizmo.js";
-import { build_tetrahedral_mesh_buffer_geometry } from "./build_tetrahedral_mesh_buffer_geometry.js";
+import { GizmoRenderingPlugin } from "../../../../engine/graphics/render/gizmo/GizmoRenderingPlugin.js";
 import { seededRandom } from "../../../math/random/seededRandom.js";
-import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { number_pretty_print } from "../../../primitives/numbers/number_pretty_print.js";
 import { delay } from "../../../process/delay.js";
+import { AABB3 } from "../aabb/AABB3.js";
+import { make_justified_point_grid } from "../util/make_justified_point_grid.js";
+import { build_tetrahedral_mesh_buffer_geometry } from "./build_tetrahedral_mesh_buffer_geometry.js";
+import { compute_delaunay_tetrahedral_mesh } from "./delaunay/compute_delaunay_tetrahedral_mesh.js";
 import { TetrahedralMesh } from "./TetrahedralMesh.js";
 
 /**
@@ -44,26 +46,37 @@ async function main(engine) {
 
     const random = seededRandom();
 
-    for (let i = 0; i < 600; i++) {
-        points.push(
-            randomFloatBetween(random, -100, 100),
-            randomFloatBetween(random, 0, 150),
-            randomFloatBetween(random, -100, 100),
-        );
-    }
-
-    // make_justified_point_grid(new AABB3(-100, 0, -100, 100, 150, 100), 40, (x, y, z) => {
-    //     points.push(x, y, z);
-    // });
+    // for (let i = 0; i < 600; i++) {
+    //     points.push(
+    //         randomFloatBetween(random, -100, 100),
+    //         randomFloatBetween(random, 0, 150),
+    //         randomFloatBetween(random, -100, 100),
+    //     );
+    // }
+
+    make_justified_point_grid(
+        new AABB3(-100, 0, -100, 100, 150, 100),
+        20,
+        (x, y, z) => {
+            points.push(x, y, z);
+        }
+    );
 
     await delay(1000);
 
     const tetrahedra = new TetrahedralMesh();
-    // console.time('mesh build');
-    console.profile('mesh build');
+    console.time('mesh build');
+    // console.profile('mesh build');
     compute_delaunay_tetrahedral_mesh(tetrahedra, points, points.length / 3);
-    console.profileEnd('mesh build');
-    // console.timeEnd('mesh build');
+    // tetrahedral_mesh_build_from_grid(
+    //     tetrahedra,
+    //     points,
+    //     new AABB3(-100, 0, -100, 100, 100, 100),
+    //     64, 32, 64
+    // )
+    // console.profileEnd('mesh build');
+    console.timeEnd('mesh build');
+    console.log(`Mesh build for ${number_pretty_print(points.length / 3)} points`)
 
     console.log(tetrahedra);
 
@@ -75,7 +88,6 @@ async function main(engine) {
     const geometry = build_tetrahedral_mesh_buffer_geometry(tetrahedra, points);
 
 
-
     new Entity()
         .add(ShadedGeometry.from(geometry, new LineBasicMaterial({ color: 0xFF0000 }), DrawMode.LineSegments))
         .add(Transform.fromJSON({
@@ -88,7 +100,9 @@ async function main(engine) {
 
         Gizmo.color = [1, 1, 1, 1];
 
-        for (let i = 0; i < points.length; i += 3) {
+        const point_count = points.length;
+
+        for (let i = 0; i < point_count; i += 3) {
 
             Gizmo.draw_solid_sphere([
                 points[i] * scale[0] + offset[0],

package/src/core/geom/3d/tetrahedra/{compute_circumsphere.d.ts → tetrahedron_compute_circumsphere.d.ts}

@@ -1,7 +1,5 @@
 /**
- * Compute the circumcenter (center[3]) and radius squared (method
- * return value) of a tetrahedron defined by the four points x1, x2,
- * x3, and x4.
+ * Compute the circumcenter (center[3]) and radius squared (method return value) of a tetrahedron defined by the four points x1, x2, x3, and x4.
  *
  * @see https://github.com/Kitware/VTK/blob/ac3fd8005bce7b3da4423c305f61ffd9df9695ef/Common/DataModel/vtkTetra.cxx
  * @param {number[]} result [center_x, center_y, center_z, radius_squared]
@@ -11,5 +9,5 @@
  * @param {number} c
  * @param {number} d
  */
-export function compute_circumsphere(result: number[], points: number[], a: number, b: number, c: number, d: number): void;
-//# sourceMappingURL=compute_circumsphere.d.ts.map
+export function tetrahedron_compute_circumsphere(result: number[], points: number[], a: number, b: number, c: number, d: number): void;
+//# sourceMappingURL=tetrahedron_compute_circumsphere.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedron_compute_circumsphere.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_compute_circumsphere.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,yDAPW,MAAM,EAAE,UACR,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QA+EhB"}

package/src/core/geom/3d/tetrahedra/{compute_circumsphere.js → tetrahedron_compute_circumsphere.js}

@@ -6,9 +6,7 @@ const SMALL_NUMBER = 1e-12;
 const VTK_MAX_WARNS = 3;
 
 /**
- * Compute the circumcenter (center[3]) and radius squared (method
- * return value) of a tetrahedron defined by the four points x1, x2,
- * x3, and x4.
+ * Compute the circumcenter (center[3]) and radius squared (method return value) of a tetrahedron defined by the four points x1, x2, x3, and x4.
  *
  * @see https://github.com/Kitware/VTK/blob/ac3fd8005bce7b3da4423c305f61ffd9df9695ef/Common/DataModel/vtkTetra.cxx
  * @param {number[]} result [center_x, center_y, center_z, radius_squared]
@@ -18,7 +16,7 @@ const VTK_MAX_WARNS = 3;
  * @param {number} c
  * @param {number} d
  */
-export function compute_circumsphere(
+export function tetrahedron_compute_circumsphere(
     result,
     points,
     a, b, c, d

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

@@ -1 +1 @@
-{"version":3,"file":"tetrahedron_compute_signed_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_compute_signed_volume.js"],"names":[],"mappings":"AAgCA;;;;;;;;;GASG;AACH,0DAPW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,KACvC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA0ClB"}
+{"version":3,"file":"tetrahedron_compute_signed_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_compute_signed_volume.js"],"names":[],"mappings":"AAkCA;;;;;;;;;GASG;AACH,0DAPW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,KACvC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA0ClB"}

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

@@ -1,3 +1,5 @@
+const ONE_OVER_SIX = 1.0 / 6.0;
+
 /**
  * Compute signed volume of a tetrahedron with the last point at the origin
  * @see "EFFICIENT FEATURE EXTRACTION FOR 2D/3D OBJECTS IN MESH REPRESENTATION" by Cha Zhang and Tsuhan Chen
@@ -25,7 +27,7 @@ function triangle_compute_signed_volume(
     const v213 = bx * ay * cz;
     const v123 = ax * by * cz;
 
-    return (1.0 / 6.0) * (-v321 + v231 + v312 - v132 - v213 + v123);
+    return ONE_OVER_SIX * (-v321 + v231 + v312 - v132 - v213 + v123);
 
 }