@woosh/meep-engine 2.107.0 → 2.108.2

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { sh_rotate_band1 } from "./sh_rotate_band1.js";
+import { sh_rotate_band2 } from "./sh_rotate_band2.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} result sh3
+ * @param {number[]} sh input
+ * @param {number[]} rotation 3x3 rotation matrix
+ */
+export function sh3_rotate(result, sh, rotation) {
+
+    const b0 = sh[0];
+    const band1 = [sh[1], sh[2], sh[3]];
+    const b1 = sh_rotate_band1(band1, rotation);
+    const band2 = [sh[4], sh[5], sh[6], sh[7], sh[8]];
+    const b2 = sh_rotate_band2(band2, rotation);
+
+    result[0] = b0;
+
+    result[1] = b1[0];
+    result[2] = b1[1];
+    result[3] = b1[2];
+
+    result[4] = b2[0];
+    result[5] = b2[1];
+    result[6] = b2[2];
+    result[7] = b2[3];
+    result[8] = b2[4];
+}

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

@@ -1,4 +1,4 @@
-//
+import { SH3_COEFFICIENTS } from "./SH3_COEFFICIENTS.js";
 
 /**
  * Sample value from a 3-band spherical harmonic defined by 9 coefficients
@@ -30,19 +30,19 @@ export function sh3_sample_by_direction(
         const offset = harmonics_offset + dimension_count * i;
 
         // band 0
-        channel_value = harmonics[offset] * 0.282095;
+        channel_value = harmonics[offset] * SH3_COEFFICIENTS[0];
 
         // band 1
-        channel_value += harmonics[offset + 1] * 0.488603 * y;
-        channel_value += harmonics[offset + 2] * 0.488603 * z;
-        channel_value += harmonics[offset + 3] * 0.488603 * x;
+        channel_value += harmonics[offset + 1] * SH3_COEFFICIENTS[1] * y;
+        channel_value += harmonics[offset + 2] * SH3_COEFFICIENTS[2] * z;
+        channel_value += harmonics[offset + 3] * SH3_COEFFICIENTS[3] * x;
 
         // band 2
-        channel_value += harmonics[offset + 4] * 1.092548 * (x * y);
-        channel_value += harmonics[offset + 5] * 1.092548 * (y * z);
-        channel_value += harmonics[offset + 6] * 0.315392 * (3.0 * z * z - 1.0);
-        channel_value += harmonics[offset + 7] * 1.092548 * (x * z);
-        channel_value += harmonics[offset + 8] * 0.546274 * (x * x - y * y);
+        channel_value += harmonics[offset + 4] * SH3_COEFFICIENTS[4] * (x * y);
+        channel_value += harmonics[offset + 5] * SH3_COEFFICIENTS[5] * (y * z);
+        channel_value += harmonics[offset + 6] * SH3_COEFFICIENTS[6] * (3.0 * z * z - 1.0);
+        channel_value += harmonics[offset + 7] * SH3_COEFFICIENTS[7] * (x * z);
+        channel_value += harmonics[offset + 8] * SH3_COEFFICIENTS[8] * (x * x - y * y);
 
         // write out
         result[result_offset + i] = channel_value;

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

@@ -0,0 +1,8 @@
+/**
+ * compute index of spherical harmonics coefficient
+ * @param {number} m signed offset from zonal harmonic
+ * @param {number} l band
+ * @return {number}
+ */
+export function sh_index(m: number, l: number): number;
+//# sourceMappingURL=sh_index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sh_index.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh_index.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,4BAJW,MAAM,KACN,MAAM,GACL,MAAM,CAIjB"}

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

@@ -0,0 +1,9 @@
+/**
+ * compute index of spherical harmonics coefficient
+ * @param {number} m signed offset from zonal harmonic
+ * @param {number} l band
+ * @return {number}
+ */
+export function sh_index(m, l) {
+    return l * (l + 1) + m;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * utilities to rotate very low order spherical harmonics (up to 3rd band)
+ * @param {number[]} band1 vec3
+ * @param {number[]} M 3x3 matrix
+ * @returns {number[]}
+ */
+export function sh_rotate_band1(band1: number[], M: number[]): number[];
+//# sourceMappingURL=sh_rotate_band1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sh_rotate_band1.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh_rotate_band1.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,uCAJW,MAAM,EAAE,KACR,MAAM,EAAE,GACN,MAAM,EAAE,CAoCpB"}

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

@@ -0,0 +1,44 @@
+import { mat3 } from "gl-matrix";
+import { m3_multiply_vec3 } from "../../../mat3/m3_multiply_vec3.js";
+
+/**
+ * utilities to rotate very low order spherical harmonics (up to 3rd band)
+ * @param {number[]} band1 vec3
+ * @param {number[]} M 3x3 matrix
+ * @returns {number[]}
+ */
+export function sh_rotate_band1(band1, M) {
+
+    // inverse() is not constexpr -- so we pre-calculate it in mathematica
+    //
+    //    constexpr float3 N0{ 1, 0, 0 };
+    //    constexpr float3 N1{ 0, 1, 0 };
+    //    constexpr float3 N2{ 0, 0, 1 };
+    //
+    //    constexpr mat3f A1 = { // this is the projection of N0, N1, N2 to SH space
+    //            float3{ -N0.y, N0.z, -N0.x },
+    //            float3{ -N1.y, N1.z, -N1.x },
+    //            float3{ -N2.y, N2.z, -N2.x }
+    //    };
+    //
+    //    const mat3f invA1 = inverse(A1);
+
+    const invA1TimesK = [
+        0, -1, 0,
+        0, 0, 1,
+        -1, 0, 0
+    ];
+
+    const R1OverK = [
+        -M[1], M[2], -M[0],
+        -M[4], M[5], -M[3],
+        -M[7], M[8], -M[6]
+    ];
+
+
+    m3_multiply_vec3(invA1TimesK, invA1TimesK, band1);
+
+    mat3.multiply(R1OverK, R1OverK, invA1TimesK);
+
+    return R1OverK;
+}

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

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number[]} band2 vec5
+ * @param {number[]} M mat3
+ * @return {number[]} vec5
+ */
+export function sh_rotate_band2(band2: number[], M: number[]): number[];
+//# sourceMappingURL=sh_rotate_band2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sh_rotate_band2.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh_rotate_band2.js"],"names":[],"mappings":"AAuCA;;;;;GAKG;AACH,uCAJW,MAAM,EAAE,KACR,MAAM,EAAE,GACP,MAAM,EAAE,CA0CnB"}

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