@woosh/meep-engine 2.33.37 → 2.33.41

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

@@ -0,0 +1,454 @@
+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";
+import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
+import { max3 } from "../../../math/max3.js";
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const LAYOUT_TETRA_BYTE_SIZE = 9 * 4;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const INVALID_NEIGHBOUR = 0xFFFFFFFF;
+
+class Cavity {
+    constructor() {
+        this.indices = [];
+
+        /**
+         *
+         * @type {number}
+         */
+        this.size = 0;
+    }
+
+    update() {
+        // compute in/out state for each side of each tetra
+    }
+
+    /**
+     *
+     * @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 * LAYOUT_TETRA_BYTE_SIZE);
+
+        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} n
+     */
+    setCapacity(n) {
+        if (n === this.__capacity) {
+            // do nothing
+            return;
+        }
+
+        if (n < this.__length) {
+            throw new Error('Dropping information, not supported');
+        }
+
+        // allocate new buffer
+        const new_buffer = new ArrayBuffer(n * LAYOUT_TETRA_BYTE_SIZE);
+
+        // move data across from old buffer to the new one
+        const destination_uint8 = new Uint8Array(new_buffer);
+        const source_uint8 = new Uint8Array(this.__buffer);
+
+        typed_array_copy(source_uint8, destination_uint8);
+
+        // set new buffer
+        this.__buffer = new_buffer;
+        this.__view = new DataView(new_buffer);
+    }
+
+    /**
+     *
+     * @param {number} n
+     */
+    ensureCapacity(n) {
+
+        const new_capacity = max3(
+            n,
+            this.__capacity * 1.2,
+            this.__capacity + 32
+        );
+
+        this.setCapacity(new_capacity);
+    }
+
+    /**
+     *
+     * @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} tetra_index
+     * @param {number} neighbour_index which neighbour to set (0..11)
+     * @param {number} neighbour index of the neighbour
+     */
+    setNeighbour(tetra_index, neighbour_index, neighbour) {
+        const tetra_address = LAYOUT_TETRA_BYTE_SIZE * tetra_index;
+        return this.__view.setUint32(tetra_address + (4 + neighbour_index) * 4, neighbour);
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} points
+     * @param {number} a
+     * @param {number} b
+     * @param {number} c
+     * @param {number} d
+     * @returns {number} index of the new tetra
+     */
+    append(points, a, b, c, d) {
+        const tetra_index = this.__occupancy.nextClearBit(0);
+        const address = tetra_index * LAYOUT_TETRA_BYTE_SIZE;
+
+        if (tetra_index >= this.__capacity) {
+            // needs to be increased in size
+            this.ensureCapacity(tetra_index);
+        }
+
+        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++;
+
+        return tetra_index;
+    }
+
+    /**
+     * Remove tetrahedron
+     * @param {number} tera_index
+     */
+    remove(tera_index) {
+
+        // find neighbours and remove reference to self
+        for (let i = 0; i < 4; i++) {
+            const neighbour_encoded = this.getNeighbour(tera_index, i);
+
+            if (neighbour_encoded === INVALID_NEIGHBOUR) {
+                // no neighbour
+                continue;
+            }
+
+            // get tetrahedra index and point index
+            const neighbour_index = neighbour_encoded >> 2;
+            const neighbour_point = neighbour_encoded & 4;
+
+            // clear reference to self
+            this.setNeighbour(neighbour_index, neighbour_point, INVALID_NEIGHBOUR);
+        }
+
+        // mark as dead
+        this.__occupancy.clear(tera_index);
+        this.__length--;
+    }
+
+    /**
+     * 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;
+
+        let i = 0;
+        let j = 0;
+
+        const occupancy = this.__occupancy;
+        for (i = occupancy.nextSetBit(0); i !== -1; i = occupancy.nextSetBit(i + 1)) {
+
+            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);
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @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_encoded = this.getNeighbour(tetra, i);
+                const neighbour_tetra_index = neighbour_encoded >> 2;
+
+                if (
+                    (neighbour_encoded === INVALID_NEIGHBOUR) // no neighbour
+                    || closed_set.includes(neighbour_tetra_index)   // already visited
+                    || open_set.includes(neighbour_tetra_index) // already in open set
+                ) {
+
+                    continue;
+                }
+
+                const neighbour_address = neighbour_tetra_index * 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_tetra_index);
+                } else {
+                    // move directly to closed set
+                    closed_set.push(neighbour_tetra_index);
+                }
+
+
+            }
+        }
+    }
+
+    /**
+     *
+     * @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
+        const cavity_size = SCRATCH_CAVITY.size;
+        const cavity_indices = SCRATCH_CAVITY.indices;
+        const data = this.__view;
+
+        for (let i = 0; i < cavity_size; i++) {
+            const cavity_index = cavity_indices[i];
+
+            // take each side of the tetra
+            const tetra_address = cavity_index * LAYOUT_TETRA_BYTE_SIZE;
+
+            const a = data.getUint32(tetra_address);
+            const b = data.getUint32(tetra_address + 4);
+            const c = data.getUint32(tetra_address + 8);
+            const d = data.getUint32(tetra_address + 12);
+
+            // attempt to form 4 tetras using the sides of the cavity
+            const a_neighbour = data.getUint32(tetra_address + 16);
+            const a_neighbour_index = a_neighbour >> 2;
+
+            const b_neighbour = data.getUint32(tetra_address + 20);
+            const b_neighbour_index = b_neighbour >> 2;
+
+            const c_neighbour = data.getUint32(tetra_address + 24);
+            const c_neighbour_index = c_neighbour >> 2;
+
+            const d_neighbour = data.getUint32(tetra_address + 28);
+            const d_neighbour_index = d_neighbour >> 2;
+
+
+            if (a_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(a_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, b, d, c, index);
+                // patch in neighbours
+                if (a_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, a_neighbour);
+                    this.setNeighbour(a_neighbour_index, a_neighbour & 3, tet);
+                }
+            }
+            if (b_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(b_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, c, d, a, index);
+                if (b_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, b_neighbour);
+                    this.setNeighbour(b_neighbour_index, b_neighbour & 3, tet);
+                }
+            }
+            if (c_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(c_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, d, b, a, index);
+                if (c_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, c_neighbour);
+                    this.setNeighbour(c_neighbour_index, c_neighbour & 3, tet);
+                }
+            }
+            if (d_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(d_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, a, b, c, index);
+                if (d_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, d_neighbour);
+                    this.setNeighbour(d_neighbour_index, d_neighbour & 3, tet);
+                }
+            }
+        }
+
+
+        // 3. remove the cavity tetrahedrons
+        for (let i = 0; i < cavity_size; i++) {
+            const cavity_index = cavity_indices[i];
+
+            // clear out cavity, connectivity was already patched in the previous step
+            this.__occupancy.set(cavity_index, false);
+        }
+    }
+
+    /**
+     * optimize tetrahedrons to reduce number of thin and long tetras
+     * @see https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/tetMesh/src/HXTSPR.c
+     */
+    optimize() {
+
+        throw new Error('Not Implemented');
+    }
+}

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

@@ -17,7 +17,8 @@ import { orient3d_fast } from "../plane/orient3d_fast.js";
  * @returns {boolean}
  */
 export function tetrahedron_contains_point(points, a, b, c, d, e) {
-    return !(orient3d_fast(points, b, d, c, e) > 0
+    return !(
+        orient3d_fast(points, b, d, c, e) > 0
         || orient3d_fast(points, c, d, a, e) > 0
         || orient3d_fast(points, d, b, a, e) > 0
         || orient3d_fast(points, a, b, c, e) > 0

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/asset/loaders/GLTFAssetLoader.js

@@ -337,16 +337,12 @@ export class GLTFAssetLoader extends AssetLoader {
                 return;
             }
 
-            //find a child that is a mesh
-            const meshes = scene.children.filter(isMesh);
 
-            let root;
+            let root = scene;
 
-            if (meshes.length !== 1) {
-                //use the whole scene
-                root = scene;
-            } else {
-                root = meshes[0];
+            if (children.length === 1 && isMesh(children[0])) {
+                // scene only contains a single mesh, use that directly
+                root = children[0];
             }
 
             traverseThreeObject(root, this.__prepareObjectMaterial, this);

package/engine/ecs/System.d.ts

@@ -1,3 +1,26 @@
-export class System {
+import {EntityManager} from "./EntityManager";
 
+interface Type<T> extends Function {
+    new(...args: any[]): T;
+}
+
+export class System<A, B = undefined, C = undefined, D = undefined, E = undefined> {
+    dependencies: Type<any>[]
+
+    startup(em: EntityManager, ready_callback: () => void, error_callback: () => void): void
+
+    shutdown(em: EntityManager, ready_callback: () => void, error_callback: () => void): void
+
+    link(a: A, entity: number): void
+    link(a: A, b: B, entity: number): void
+    link(a: A, b: B, c: C, entity: number): void
+    link(a: A, b: B, c: C, d: D, entity: number): void
+    link(a: A, b: B, c: C, d: D, e: E, entity: number): void
+
+    unlink(a: A, entity: number): void
+    unlink(a: A, b: B, entity: number): void
+    unlink(a: A, b: B, c: C, d: D, entity: number): void
+    unlink(a: A, b: B, c: C, d: D, e: E, entity: number): void
+
+    update(time_delta: number): void
 }

package/engine/graphics/ecs/light/binding/fp/FPLightBinding.js

@@ -1,5 +1,5 @@
 import { LightBinding } from "../LightBinding.js";
-import { PointLight } from "../../../../render/forward_plus/PointLight.js";
+import { PointLight } from "../../../../render/forward_plus/model/PointLight.js";
 
 export class FPLightBinding extends LightBinding {
     constructor() {

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/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -2,7 +2,6 @@ import { inverseLerp } from "../../../../../../core/math/inverseLerp.js";
 import { assert } from "../../../../../../core/assert.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
-import { mix } from "../../../../../../core/math/mix.js";
 import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
 import { ParameterLookupTableSerializationAdapter } from "../emitter/serde/ParameterLookupTableSerializationAdapter.js";
 import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
@@ -125,7 +124,7 @@ export class ParameterLookupTable {
      */
     sample(position, result) {
         assert.isNumber(position, 'position');
-        assert.greaterThanOrEqual(position, 0, 'position');
+        // assert.greaterThanOrEqual(position, 0, 'position');
         // assert.ok(position >= 0 && position <= 1, `position must be between 0 and 1, instead was ${position}`);
 
         const itemSize = this.itemSize;
@@ -140,32 +139,28 @@ export class ParameterLookupTable {
         let highIndex = lowIndex;
         let fraction = 0;
 
-        //find position index
-        for (i = 0; i < numValues; i++) {
-            //NOTE: no complex search is used, since for small data sizes linear scan is typically faster
-            const p = positions[i];
+        if (position <= positions[0]) {
 
-            if (p === position) {
+            // special case, seek position is at or before the start of the table
+            lowIndex = 0;
+            highIndex = 0;
 
-                // found the exact match
-                lowIndex = i;
-                highIndex = i;
-                fraction = 0;
-                break;
+        } else {
+
+            //find position index
+            for (i = 1; i < numValues; i++) {
+                //NOTE: no complex search is used, since for small data sizes linear scan is typically faster
+                const p = positions[i];
 
-            } else if (p > position) {
-                // next position if over the seek position
-                highIndex = i;
-                if (i === 0) {
-                    lowIndex = i;
-                    fraction = 0;
-                } else {
+                if (p >= position) {
+                    // next position if over the seek position
+                    highIndex = i;
                     lowIndex = i - 1;
-                    const prevPosition = positions[lowIndex];
-                    fraction = inverseLerp(prevPosition, p, position);
-                }
 
-                break;
+                    fraction = inverseLerp(positions[lowIndex], p, position);
+
+                    break;
+                }
             }
         }
 
@@ -177,7 +172,8 @@ export class ParameterLookupTable {
             const lowValue = data[low_offset + i];
             const highValue = data[high_offset + i];
 
-            const value = mix(lowValue, highValue, fraction);
+            // inlined for speed: mix(low, high, fraction)
+            const value = lowValue * (1 - fraction) + highValue * fraction;
 
             result[i] = value;
         }

package/engine/graphics/particles/particular/engine/shader/ShaderManager.js

@@ -117,7 +117,7 @@ export class ShaderManager {
             generateMipmaps: true,
             minFilter: LinearMipMapLinearFilter,
             magFilter: LinearFilter,
-            anisotropy: 0
+            anisotropy: 0 // sprites are always facing the screen, anisotropic filtering would be pointless
         });
 
         this.spriteTexture.name = 'Sprite sheet';

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -609,8 +609,8 @@ async function main(engine) {
 
     engine.graphics.renderer.setClearColor('rgba(99,99,99,1)');
 
-    // await sample_scene_nam(engine);
-    await sample_scene_0(engine);
+    await sample_scene_nam(engine);
+    // await sample_scene_0(engine);
 }
 
 /**