@woosh/meep-engine 2.33.37 → 2.33.38

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);
+});

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

@@ -0,0 +1,279 @@
+import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
+import { assert } from "../../../assert.js";
+import { point_in_tetrahedron_circumsphere } from "./point_in_tetrahedron_circumsphere.js";
+import { BitSet } from "../../../binary/BitSet.js";
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const LAYOUT_TETRA_BYTE_SIZE = 9 * 4;
+const INVALID_NEIGHBOUR = 0xFFFFFFFF;
+
+class Cavity {
+    constructor() {
+        this.indices = [];
+        this.__size = 0;
+    }
+
+    /**
+     *
+     * @param {number} i
+     */
+    push(i) {
+        this.indices[this.__size++] = i;
+    }
+
+    /**
+     *
+     * @param {number} i
+     * @returns {boolean}
+     */
+    includes(i) {
+        const n = this.__size;
+        for (let j = 0; j < n; j++) {
+            if (this.indices[j] === i) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    reset() {
+        this.__size = 0;
+    }
+}
+
+const SCRATCH_CAVITY = new Cavity();
+
+/**
+ *
+ * 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
+ */
+export 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;
+
+
+        /**
+         * Marks which indices are in use
+         * @type {BitSet}
+         * @private
+         */
+        this.__occupancy = new BitSet();
+    }
+
+    /**
+     *
+     * @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 tetra_index = this.__length;
+        const address = tetra_index * 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.__occupancy.set(tetra_index, true);
+
+        this.__length++;
+    }
+
+    /**
+     * Remove tetrahedron
+     * @param {number} tera_index
+     */
+    remove(tera_index) {
+        this.__occupancy.clear(tera_index);
+    }
+
+    /**
+     * Remove tetrahedrons who's points touch the "super-tetrahedron's" points that was inserted originally
+     * These points are identified by an offset + count parameters
+     * @param {number[]|Float32Array} points
+     * @param {number} range_start
+     * @param {number} range_end
+     */
+    removeTetrasConnectedToPoints(points, range_start, range_end) {
+        const data_view = this.__view;
+
+        const n = this.__length;
+
+        let i = 0;
+        let j = 0;
+
+        for (; i < n; i++) {
+
+            const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
+
+            for (j = 0; j < 4; j++) {
+                const point_index = data_view.getUint32(tet_address + 4 * i);
+
+                if (point_index >= range_start && point_index <= range_end) {
+                    // point index is in range, tetra should be removed
+                    this.remove(i);
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @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 {Cavity} cavity
+     * @param {number[]|Float32Array} points
+     * @param {number} index
+     */
+    computeCavity(cavity, points, index) {
+
+        // 1.identify tetrahedron that contains this point
+        const containing_tetra = this.findTetraContainingPoint(points, index);
+
+        assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
+
+        cavity.reset();
+
+        /**
+         *
+         * @type {number[]}
+         */
+        const open_set = [
+            containing_tetra
+        ];
+
+        /**
+         *
+         * @type {number[]}
+         */
+        const closed_set = [];
+
+        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);
+            closed_set.push(tetra);
+
+            // get neighbours
+            for (let i = 0; i < 4; i++) {
+                const neighbour = this.getNeighbour(tetra, i);
+
+                if (
+                    (neighbour === INVALID_NEIGHBOUR) // no neighbour
+                    || closed_set.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);
+                } else {
+                    // move directly to closed set
+                    closed_set.push(neighbour);
+                }
+
+
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} points
+     * @param {number} index
+     */
+    insertPoint(points, index) {
+        // Compute the cavity, that is the set of tetrahedra that need to be removed and rebuilt
+        this.computeCavity(SCRATCH_CAVITY, points, index);
+
+        // identify cavity "edge" - the set of tetras that are neighbours of the tetras that form the cavity
+
+        // 3. remove the cavity tetrahedrons
+
+        // 4. fill the cavity by creating new tetrahedrons connecting the point to the faces of cavity boundary
+    }
+}

package/core/process/undo/ActionProcessor.js

@@ -100,20 +100,20 @@ export class ActionProcessor {
      */
     clear() {
         // drop all of the history
-        this.dropHistory(0);
+        this.dropHistory(Infinity);
     }
 
     /**
-     * Drop records beyond a given limit. records are dropped in batches between marks.
+     * Drop number of records from the history
      *
      * NOTE valid use-cases for this method from the outside are: 1) memory management and 1) removing access to a set of previous actions
      * NOTE this method is used internally by {@link #mark} method
      *
      * @example if there are 2 marks A at record 9 and B at record 11, and requested limit is 10 - 9 records will be kept as records 10 and 11 belong to the same batch and will be removed together.
-     * @param {number} limit maximum number of records to keep
+     * @param {number} drop_count maximum number of records to drop
      */
-    dropHistory(limit) {
-        const recordsToDrop = Math.min(limit, this.history.length);
+    dropHistory(drop_count) {
+        const recordsToDrop = Math.min(drop_count, this.history.length);
         if (recordsToDrop <= 0) {
             return;
         }
@@ -144,6 +144,9 @@ export class ActionProcessor {
 
         // dispatch signal
         dropped_marks.forEach(this.onMarkRemoved.send1, this.onMarkRemoved);
+
+        // update history
+
     }
 
     /**

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -456,7 +456,7 @@ function init() {
 
     // sample_gltf_sponza();
     // sample_gltf_rts_factory();
-    sample_lucy();
+    // sample_lucy();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
     // sample_gltf_broken_isiflow();
@@ -465,6 +465,9 @@ function init() {
     // gltf_sample('data/models/moicon/08-clickable-assets/model.gltf');
     // gltf_sample('data/models/moicon/05-ground-floor/model.gltf');
     // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');
+    // gltf_sample('moicon/29_Dec_2021_Nammo/1/model.gltf');
+    // gltf_sample('moicon/29_Dec_2021_Nammo/1-onematerial/model.gltf');
+    gltf_sample('moicon/29_Dec_2021_Nammo/2/model.gltf');
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.37",
+  "version": "2.33.38",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",