@woosh/meep-engine 2.33.37 → 2.33.41

package/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -434,11 +434,11 @@ export class BinaryUint32BVH {
      * Assemble leaf nodes into hierarchy, set binary node bounds iteratively bottom up
      */
     build() {
-        const nodeCount = this.__node_count_binary;
+        const binary_node_count = this.__node_count_binary;
 
-        const leaf_node_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+        const leaf_node_block_address = binary_node_count * BVH_BINARY_NODE_SIZE;
 
-        let level = Math.floor(Math.log(nodeCount) / Math.log(2));
+        let level = Math.floor(Math.log(binary_node_count) / Math.log(2));
 
         let i, offset, level_node_count;
         //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node

package/core/collection/array/typed/typed_array_copy.js

@@ -3,8 +3,8 @@ import { array_copy } from "../copyArray.js";
 
 /**
  * Assumes arrays have the same type
- * @param {TypedArray|Float32Array} source
- * @param {TypedArray|Float32Array} destination
+ * @param {TypedArray|Float32Array|Uint8Array} source
+ * @param {TypedArray|Float32Array|Uint8Array} destination
  */
 export function typed_array_copy(source, destination) {
     const destination_size = destination.length;

package/core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js

@@ -4,7 +4,7 @@ import { assert } from "../../../assert.js";
  *
  * @param {number[]|Float32Array} result
  * @param {number[]|Float32Array|Float64Array} aabb_corners
- * @param {number[]|Float32Array} projection_matrix
+ * @param {number[]|Float32Array|mat4} projection_matrix
  */
 export function aabb3_matrix4_project_by_corners(result, aabb_corners, projection_matrix) {
     assert.greaterThanOrEqual(result.length, 6, 'result.length must >= 6');

package/core/geom/3d/morton/mortonEncode_magicbits.js

@@ -1,10 +1,12 @@
 /**
  * method to separate bits from a given integer 3 positions apart
  * we only look at the first 10 bits
+ *
+ * @example when input is ABC, output bits are A00B00C
  * @param {number} a
  * @returns {number}
  */
-function splitBy3(a) {
+function split_by_3(a) {
     let x = a;
     x = (x | x << 16) & 0x30000ff;
     x = (x | x << 8) & 0x0300f00f;
@@ -25,10 +27,9 @@ function splitBy3(a) {
  */
 export function mortonEncode_magicbits(x, y, z) {
 
-    const x_bits = splitBy3(x);
-    const y_bits = splitBy3(y) << 1;
-    const z_bit = splitBy3(z) << 2;
-
-    return x_bits | y_bits | z_bit;
+    const x_bits = split_by_3(x);
+    const y_bits = split_by_3(y) << 1;
+    const z_bits = split_by_3(z) << 2;
 
+    return x_bits | y_bits | z_bits;
 }

package/core/geom/3d/morton/v3_morton_encode_transformed.js

@@ -1,4 +1,5 @@
 import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
+import { clamp } from "../../../math/clamp.js";
 
 /**
  * Assumes that coordinates will be mapped to -1..1 range after transform
@@ -16,18 +17,21 @@ export function v3_morton_encode_transformed(x, y, z, matrix) {
     const _z = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14];
     const _w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
 
-    const d = 1 / _w;
+    const d = 511.5 / _w;
 
-    // apply perspective divide, values are now in Normalized Coordinate system (-1,1)
-    const px = _x * d;
-    const py = _y * d;
-    const pz = _z * d;
+    // apply perspective divide as well as scaling to 10 bits
+    const ndc_x = _x * d;
+    const ndc_y = _y * d;
+    const ndc_z = _z * d;
 
-    // scale each value up to 10 bits (for 10 bits, the multiplier = 1024. As we have -1,1 range, we do (v+1)/2. 1024/2 = 512)
+    // Normalize values (0,1023) and clamp to prevent wrapping
+    const px = clamp(ndc_x + 511.5, 0, 1023);
+    const py = clamp(ndc_y + 511.5, 0, 1023);
+    const pz = clamp(ndc_z + 511.5, 0, 1023);
 
-    const cx = ((px + 1) * 512) | 0;
-    const cy = ((py + 1) * 512) | 0;
-    const cz = ((pz + 1) * 512) | 0;
-
-    return mortonEncode_magicbits(cx, cy, cz);
+    return mortonEncode_magicbits(
+        Math.round(px),
+        Math.round(py),
+        Math.round(pz)
+    );
 }

package/core/geom/3d/plane/orient3d_fast.js

@@ -21,23 +21,29 @@ export function orient3d_fast(points, a, b, c, d) {
     const a3 = a * 3;
     const d3 = d * 3;
 
-    const adx = points[a3] - points[d3];
+    const d_x = points[d3];
+
+    const adx = points[a3] - d_x;
 
     const b3 = b * 3;
 
-    const bdx = points[b3] - points[d3];
+    const bdx = points[b3] - d_x;
 
     const c3 = c * 3;
 
-    const cdx = points[c3] - points[d3];
+    const cdx = points[c3] - d_x;
+
+    const d_y = points[d3 + 1];
+
+    const ady = points[a3 + 1] - d_y;
+    const bdy = points[b3 + 1] - d_y;
+    const cdy = points[c3 + 1] - d_y;
 
-    const ady = points[a3 + 1] - points[d3 + 1];
-    const bdy = points[b3 + 1] - points[d3 + 1];
-    const cdy = points[c3 + 1] - points[d3 + 1];
+    const d_z = points[d3 + 2];
 
-    const adz = points[a3 + 2] - points[d3 + 2];
-    const bdz = points[b3 + 2] - points[d3 + 2];
-    const cdz = points[c3 + 2] - points[d3 + 2];
+    const adz = points[a3 + 2] - d_z;
+    const bdz = points[b3 + 2] - d_z;
+    const cdz = points[c3 + 2] - d_z;
 
     return adx * (bdy * cdz - bdz * cdy)
         + bdx * (cdy * adz - cdz * ady)

package/core/geom/3d/tetrahedra/GetDepthForTetrahedronProbe.glsl

@@ -0,0 +1,43 @@
+// Sample triangular depth map
+// see CoD SIGGRAPH 2017 "Advances in Real-Time Graphics in Games" course
+float GetDepthForTetrahedronProbe(float2 bary, uint4 encodedDepth)
+{
+    float sampleY = floor(bary.y * 4.0f);
+    float sampleX = floor(bary.x * 4.0f);
+
+    int baseIndex = (int)(((11.0f - sampleY) * sampleY) * 0.5f + sampleX + 0.5f);
+    int lineLength = 5 - (int)sampleY;
+
+    float2 baseBary = float2(sampleX * 0.25f, sampleY * 0.25f);
+
+    int3 indices = int3(baseIndex + 1, baseIndex + lineLength, baseIndex);
+
+    float3 sampleBary;
+    sampleBary.x = (bary.x - baseBary.x) * 4.0f;
+    sampleBary.y = (bary.y - baseBary.y) * 4.0f;
+
+    if (sampleBary.x + sampleBary.y > 1.0f)
+    {
+        // above the diagonal
+        indices = int3(baseIndex + lineLength, baseIndex + 1, baseIndex + lineLength + 1);
+
+        float3 newSampleBary;
+        newSampleBary.x = -(sampleBary.y - 1.0f);
+        newSampleBary.y = -(sampleBary.x - 1.0f);
+        sampleBary = newSampleBary;
+    }
+
+    sampleBary.z = 1.0f - sampleBary.x - sampleBary.y;
+
+    float result = 0.0f;
+    for (int i=0; i<3; ++i)
+    {
+        uint currIndex = indices[i];
+        int intDepth = (encodedDepth[currIndex / 4] >> ((currIndex % 4) * 8)) & 0xFF;
+        float depth = (float)intDepth / 255.0f;
+
+        result += sampleBary[i] * depth;
+    }
+
+    return result;
+}

package/core/geom/3d/tetrahedra/compute_delaunay_tetrahedral_mesh.js

@@ -1,199 +1,50 @@
 //
 
 import { compute_bounding_simplex_3d } from "./compute_bounding_simplex_3d.js";
-import { point_in_tetrahedron_circumsphere } from "./point_in_tetrahedron_circumsphere.js";
-import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
-import { assert } from "../../../assert.js";
-
-/**
- * @readonly
- * @type {number}
- */
-const LAYOUT_TETRA_BYTE_SIZE = 9 * 4;
-const INVALID_NEIGHBOUR = 0xFFFFFFFF;
-
-/**
- *
- * Layout:
- *      vertex_id_a :: uint
- *      vertex_id_b :: uint
- *      vertex_id_c :: uint
- *      vertex_id_d :: uint
- *      neighbour_a :: uint         - neighbour tetrahedron, opposite to vertex A
- *      neighbour_b :: uint         - neighbour tetrahedron, opposite to vertex B
- *      neighbour_c :: uint         - neighbour tetrahedron, opposite to vertex C
- *      neighbour_d :: uint         - neighbour tetrahedron, opposite to vertex D
- *      sub_determinant :: float    - ?
- * Layout is similar to [1], but is interleaved for better cache locality
- */
-class TetrahedraCollection {
-    constructor(initial_size) {
-        this.__buffer = new ArrayBuffer(initial_size * 4 * 9);
-
-        this.__view = new DataView(this.__buffer);
-
-        this.__capacity = initial_size;
-        this.__length = 0;
-    }
-
-    /**
-     *
-     * @param {number} tetra_index
-     * @param {number} neighbour_index
-     * @returns {number}
-     */
-    getNeighbour(tetra_index, neighbour_index) {
-        const tetra_address = LAYOUT_TETRA_BYTE_SIZE * tetra_index;
-        return this.__view.getUint32(tetra_address + (4 + neighbour_index) * 4);
-    }
-
-    /**
-     *
-     * @param {number[]|Float32Array} points
-     * @param {number} a
-     * @param {number} b
-     * @param {number} c
-     * @param {number} d
-     */
-    append(points, a, b, c, d) {
-        const address = this.__length * LAYOUT_TETRA_BYTE_SIZE;
-
-        // TODO check if there's enough room
-
-        const view = this.__view;
-
-        view.setUint32(address, a);
-        view.setUint32(address + 4, b);
-        view.setUint32(address + 8, c);
-        view.setUint32(address + 12, d);
-
-        // set neighbours
-        view.setUint32(address + 16, INVALID_NEIGHBOUR);
-        view.setUint32(address + 20, INVALID_NEIGHBOUR);
-        view.setUint32(address + 24, INVALID_NEIGHBOUR);
-        view.setUint32(address + 28, INVALID_NEIGHBOUR);
-
-        this.__length++;
-    }
-
-    /**
-     *
-     * @param {number[]} points
-     * @param {number} index
-     * @returns {number} index of tetra or -1 if no containing tetra found
-     */
-    findTetraContainingPoint(points, index) {
-        const data_view = this.__view;
-
-        // TODO improve this
-        const n = this.__length;
-        for (let i = 0; i < n; i++) {
-
-            const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
-
-            const a = data_view.getUint32(tet_address);
-            const b = data_view.getUint32(tet_address + 4);
-            const c = data_view.getUint32(tet_address + 8);
-            const d = data_view.getUint32(tet_address + 12);
-
-            if (tetrahedron_contains_point(points, a, b, c, d, index)) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    /**
-     *
-     * @param {number[]|Float32Array} points
-     * @param {number} index
-     */
-    insertPoint(points, index) {
-
-        // 1. walk to tetrahedron that contains this point
-        const containing_tetra = this.findTetraContainingPoint(points, index);
-
-        assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
-
-        const cavity = [];
-        const open_set = [
-            containing_tetra
-        ];
-
-        const data_view = this.__view;
-
-        // 2. find the Delaunay "cavity", a set of tetrahedrons who's circumsphere overlarlaps the point
-        // perform breadth-first expansion on the containing tetra to identify the cavity
-        while (open_set.length > 0) {
-            const tetra = open_set.pop();
-            cavity.push(tetra);
-
-            // get neighbours
-            for (let i = 0; i < 4; i++) {
-                const neighbour = this.getNeighbour(tetra, i);
-
-                if (
-                    (neighbour === INVALID_NEIGHBOUR) // no neighbour
-                    || cavity.includes(neighbour)   // already visited
-                    || open_set.includes(neighbour) // already in open set
-                ) {
-
-                    continue;
-                }
-
-                const neighbour_address = neighbour * LAYOUT_TETRA_BYTE_SIZE;
-                const a = data_view.getUint32(neighbour_address);
-                const b = data_view.getUint32(neighbour_address + 4);
-                const c = data_view.getUint32(neighbour_address + 8);
-                const d = data_view.getUint32(neighbour_address + 12);
-
-                // check neighbour
-                const is_in_sphere = point_in_tetrahedron_circumsphere(points, a, b, c, d, index);
-
-                if (is_in_sphere) {
-                    open_set.push(neighbour);
-                }
-            }
-        }
-
-        // 3. remove the cavity tetrahedrons
-
-        // 4. fill the cavity by creating new tetrahedrons connecting the point to the faces of cavity boundary
-    }
-}
+import { TetrahedraCollection } from "./tetrahedra_collection.js";
 
 /**
  * @see https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm
  * @see [1] "One machine, one minute, three billion tetrahedra" by Célestin Marot et al
  * @param {number[]} input serialized set of 3d points (x,y,z)
- * @param {number} input_point_count
+ * @param {number} n number of points in the input
  */
-export function compute_delaunay_tetrahedral_mesh(input, input_point_count) {
+export function compute_delaunay_tetrahedral_mesh(input, n) {
+    if (n < 4) {
+        // no mesh can be created, too few points
+        return;
+    }
+
     /**
      * According to [1] number of tetrahedra is around 6 times greater than number of input vertices, we use that fact to pre-allocate memory
+     * From the book of Cheng et al. 'Delaunay Mesh Generation' A triangulation of n vertices in R^3 has at most `ntet=(n^2 − 3n − 2)/2` tetrahedra,
+     * at most nedg=(n^2 − n)/2` edges (this is simply the 2-combination of n)
+     * and at most `ntri=n^2 − 3n = 2*ntet+2` triangles
+     *
+     * The +7 is for the initial "super" tetrahedron and 6 tetras for intermediate triangulation
      */
-    const tetrahedrons = new TetrahedraCollection(input_point_count * 6.01);
+    const tetrahedron_count_upper_bound = Math.ceil((n * n - 3 * n - 2) / 2) + 7;
+    const tetrahedrons = new TetrahedraCollection(tetrahedron_count_upper_bound);
     // TODO apply spatial sort to point, to get better cache locality
 
     // compute bounds over the input
-    const points = new Float32Array((input_point_count + 4) * 3);
+    const points = new Float32Array((n + 4) * 3);
 
     points.set(input);
 
     /*
      create super bounding volume
      */
-    compute_bounding_simplex_3d(points, input_point_count * 3, points, input_point_count, 1);
+    compute_bounding_simplex_3d(points, n * 3, points, n, 1);
 
-    tetrahedrons.append(points, input_point_count, input_point_count + 1, input_point_count + 2, input_point_count + 3);
+    tetrahedrons.append(points, n, n + 1, n + 2, n + 3);
 
     // add all points to the mesh
-    for (let i = 0; i < input_point_count; i++) {
+    for (let i = 0; i < n; i++) {
         tetrahedrons.insertPoint(points, i);
     }
 
     // remove tetras formed by with the super bounding volume
-    // TODO implement
+    tetrahedrons.removeTetrasConnectedToPoints(points, n, n + 3);
 }
 

package/core/geom/3d/tetrahedra/compute_delaunay_tetrahedral_mesh.spec.js

@@ -3,3 +3,12 @@ import { compute_delaunay_tetrahedral_mesh } from "./compute_delaunay_tetrahedra
 test('single point', () => {
     compute_delaunay_tetrahedral_mesh([1, 2, 3], 1);
 });
+
+test('exactly 4 points', () => {
+    compute_delaunay_tetrahedral_mesh([
+        -1, 0, 0,
+        1, 0, 0,
+        0.5, 1, 0,
+        0.5, 0, 1
+    ], 4);
+});