@woosh/meep-engine 2.33.34 → 2.33.38

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/geom/3d/tetrahedra/tetrahedron_contains_point.js

@@ -0,0 +1,25 @@
+import { orient3d_fast } from "../plane/orient3d_fast.js";
+
+/**
+ * Containment test, whether tetrahedron defined by A,B,C,D contains point E or not
+ * Implemented using planar tests on each of side of the tetrahedron
+ *
+ * NOTE:    similar to https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/tetMesh/src/HXTSPR.c
+ *          We skip identity checks and bounding box checks. Identity is a waste of time when building tetrahedral mesh,
+ *          since each inserted point will be new to the mesh, box checks are not relevant as we don't track those
+ *
+ * @param {number[]} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} e
+ * @returns {boolean}
+ */
+export function tetrahedron_contains_point(points, a, b, c, d, e) {
+    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/geom/Quaternion.js

@@ -1298,6 +1298,10 @@ class Quaternion {
         this.set(x, y, z, w);
     }
 
+    /**
+     * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+     * @param value
+     */
     decodeFromUint32(value) {
         //read components
         const max = value & 0x3;

package/core/math/hash/murmur3_32.js

@@ -0,0 +1,39 @@
+/**
+ * NOTE: based on https://github.com/garycourt/murmurhash-js/blob/master/murmurhash3_gc.js
+ * @param {Uint32Array} key
+ * @param {number} seed
+ * @returns {number}
+ */
+export function murmur3_32(key, seed) {
+    let h1 = seed;
+    let k1;
+    let i = 0;
+
+    const bytes = key.length;
+
+    while (i < bytes) {
+        k1 = key[i];
+        ++i;
+
+        k1 = ((((k1 & 0xffff) * 0xcc9e2d51) + ((((k1 >>> 16) * 0xcc9e2d51) & 0xffff) << 16)));
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = ((((k1 & 0xffff) * 0x1b873593) + ((((k1 >>> 16) * 0x1b873593) & 0xffff) << 16)));
+
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1 = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16)));
+        h1 = (((h1 & 0xffff) + 0x6b64) + ((((h1 >>> 16) + 0xe654) & 0xffff) << 16));
+    }
+
+    // mix in array length
+    h1 ^= bytes;
+
+    h1 ^= h1 >>> 16;
+    h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16));
+    h1 ^= h1 >>> 13;
+    h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16)));
+    h1 ^= h1 >>> 16;
+
+    // cast to uint32
+    return h1 >>> 0;
+}

package/core/process/undo/ActionProcessor.d.ts

@@ -22,4 +22,6 @@ export class ActionProcessor<CTX, MD> {
     doMany(actions: Action<CTX>[]): void
 
     do(action: Action<CTX>): this
+
+    clear(): void
 }

package/core/process/undo/ActionProcessor.js

@@ -96,16 +96,24 @@ export class ActionProcessor {
     }
 
     /**
-     * Drop records beyond a given limit. records are dropped in batches between marks.
+     * Remove all of the history
+     */
+    clear() {
+        // drop all of the history
+        this.dropHistory(Infinity);
+    }
+
+    /**
+     * 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;
         }
@@ -136,6 +144,9 @@ export class ActionProcessor {
 
         // dispatch signal
         dropped_marks.forEach(this.onMarkRemoved.send1, this.onMarkRemoved);
+
+        // update history
+
     }
 
     /**

package/editor/tools/FoliagePaintTool.js

@@ -2,11 +2,11 @@ import Tool from "./engine/Tool.js";
 import Vector1 from "../../core/geom/Vector1.js";
 import { obtainTerrain } from "../../../model/game/scenes/SceneUtils.js";
 import ObservedValue from "../../core/model/ObservedValue.js";
-import { parseHex } from "../../core/color/ColorUtils.js";
 import Vector4 from "../../core/geom/Vector4.js";
 import loadSampler2D from "../../engine/graphics/texture/sampler/loadSampler2D.js";
 import convertSampler2D2Canvas from "../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
 import { InstancedMeshComponent } from "../../engine/ecs/foliage/ecs/InstancedMeshComponent.js";
+import { parseHex } from "../../core/color/parseHex.js";
 
 class FoliagePaintTool extends Tool {
     constructor() {

package/editor/tools/GridPaintTool.js

@@ -3,7 +3,6 @@ import GridPosition from "../../engine/grid/components/GridPosition.js";
 import GridObstacle from "../../engine/grid/components/GridObstacle.js";
 import { pick } from "../../../model/game/util/ScreenGridPicker.js";
 import Vector4 from "../../core/geom/Vector4.js";
-import { parseHex } from "../../core/color/ColorUtils.js";
 import ObservedValue from "../../core/model/ObservedValue.js";
 import Vector1 from "../../core/geom/Vector1.js";
 import WriteGridValueAction from "../actions/concrete/WriteGridValueAction.js";
@@ -12,6 +11,7 @@ import PaintTerrainOverlayAction from "../actions/concrete/PaintTerrainOverlayAc
 import { decodeMouseEventButtons, PointerDevice } from "../../engine/input/devices/PointerDevice.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import TopDownCameraControllerSystem from "../../engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { parseHex } from "../../core/color/parseHex.js";
 
 class GridPaintTool extends Tool {
     constructor() {

package/engine/ecs/foliage/InstancedFoliage.js

@@ -61,12 +61,29 @@ export class InstancedFoliage {
          */
         this.instances = new InstancedMeshGroup();
 
+        /**
+         *
+         * @type {THREE.BufferGeometry|null}
+         */
         this.geometry = null;
+
+        /**
+         *
+         * @type {Vector4|Vector4}
+         */
         this.instanceBoundingSphere = new Vector4(0, 0, 0, 0);
 
 
+        /**
+         *
+         * @type {ThreeFrustumsIntersectionBVHVisitor}
+         */
         this.bvhVisibilityVisitor = new ThreeFrustumsIntersectionBVHVisitor();
 
+        /**
+         *
+         * @type {FoliageVisibilitySetBuilder}
+         */
         this.visibilitySetBuilder = new FoliageVisibilitySetBuilder();
         this.bvhVisibilityVisitor.collector = this.visibilitySetBuilder;
 
@@ -84,6 +101,10 @@ export class InstancedFoliage {
         this.__garbagePointer = 0;
     }
 
+    /**
+     *
+     * @returns {number}
+     */
     hash() {
         return this.data.hash();
     }
@@ -95,6 +116,25 @@ export class InstancedFoliage {
 
     }
 
+    /**
+     *
+     * @param {SurfacePoint3} contact
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @returns {number} index of the contact instance, or -1 if no hit found
+     */
+    raypick(
+        contact,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z
+    ) {
+        throw new Error('Not implemented');
+    }
+
     dispose() {
         this.instances.dispose();
     }
@@ -212,6 +252,11 @@ export class InstancedFoliage {
         this.instanceBoundingSphere = computeGeometryBoundingSphereMiniball(this.geometry);
     }
 
+    /**
+     *
+     * @param {BufferGeometry} geometry
+     * @param {Material} material
+     */
     setInstance(geometry, material) {
         if (material === undefined) {
             throw new Error(`Material is undefined`);

package/engine/ecs/foliage/ecs/InstancedMeshLayer.js

@@ -40,6 +40,10 @@ export class InstancedMeshLayer {
         this.data.dispose();
     }
 
+    /**
+     *
+     * @returns {number}
+     */
     hash() {
 
         return computeHashIntegerArray(

package/engine/ecs/storage/BinaryBufferSerializer.js

@@ -5,6 +5,48 @@ import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "./COMPONENT_SERIALIZATI
 import { currentTimeInSeconds } from "../../Clock.js";
 import { BinaryObjectSerializationAdapter } from "./binary/object/BinaryObjectSerializationAdapter.js";
 
+/**
+ * @template T
+ * @param {Class<T>|constructor|function|{serializable?:boolean}} componentClass
+ * @returns {boolean}
+ */
+function isComponentClassSerializable(componentClass) {
+    return componentClass.serializable !== false;
+}
+
+/**
+ * Whether or not an entity should be serialized at all
+ * @param {number} entity
+ * @param {EntityComponentDataset} dataset
+ * @param {number} smComponentIndex
+ * @param {Object} componentInstance
+ * @returns {boolean}
+ */
+function isEntityTransient(entity, dataset, smComponentIndex, componentInstance) {
+    if (smComponentIndex === -1) {
+        return false;
+    }
+
+    //check component instance flag
+    if (componentInstance[COMPONENT_SERIALIZATION_TRANSIENT_FIELD] === true) {
+        return true;
+    }
+
+
+    /**
+     *
+     * @type {SerializationMetadata}
+     */
+    const serializationMetadata = dataset.getComponentByIndex(entity, smComponentIndex);
+
+    if (serializationMetadata === undefined) {
+        return false;
+    }
+
+    const isTransient = serializationMetadata.getFlag(SerializationFlags.Transient);
+
+    return isTransient;
+}
 
 class BinaryBufferSerialization {
     constructor() {
@@ -27,9 +69,8 @@ class BinaryBufferSerialization {
 
         const smComponentIndex = dataset.computeComponentTypeIndex(SerializationMetadata);
 
-        const serializableComponentTypes = dataset.getComponentTypeMap().filter(function (componentClass) {
-            return componentClass.serializable !== false;
-        });
+        // get a list of serializable component classes
+        const serializableComponentTypes = dataset.getComponentTypeMap().filter(isComponentClassSerializable);
 
         const numSerializableTypes = serializableComponentTypes.length;
 
@@ -59,6 +100,9 @@ class BinaryBufferSerialization {
 
             const className = componentType.typeName;
 
+            if (className === undefined) {
+                throw new Error(`Component type has no .typeName property`);
+            }
 
             collectionSerializer.setClass(className);
             collectionSerializer.initialize({
@@ -83,7 +127,7 @@ class BinaryBufferSerialization {
                     return;
                 }
 
-                assert.ok(entity >= lastEntity, `entity(=${entity}) < lastEntity(=${lastEntity})`)
+                assert.ok(entity >= lastEntity, `entity[=${entity}] < lastEntity[=${lastEntity}]`);
 
                 //write only the entity step
                 const step = entity - lastEntity;
@@ -127,38 +171,4 @@ class BinaryBufferSerialization {
     }
 }
 
-/**
- * Whether or not an entity should be serialized at all
- * @param {number} entity
- * @param {EntityComponentDataset} dataset
- * @param {number} smComponentIndex
- * @param {Object} componentInstance
- * @returns {boolean}
- */
-function isEntityTransient(entity, dataset, smComponentIndex, componentInstance) {
-    if (smComponentIndex === -1) {
-        return false;
-    }
-
-    //check component instance flag
-    if (componentInstance[COMPONENT_SERIALIZATION_TRANSIENT_FIELD] === true) {
-        return true;
-    }
-
-
-    /**
-     *
-     * @type {SerializationMetadata}
-     */
-    const serializationMetadata = dataset.getComponentByIndex(entity, smComponentIndex);
-
-    if (serializationMetadata === undefined) {
-        return false;
-    }
-
-    const isTransient = serializationMetadata.getFlag(SerializationFlags.Transient);
-
-    return isTransient;
-}
-
 export default BinaryBufferSerialization;

package/engine/ecs/storage/binary/collection/BinaryCollectionSerializer.js

@@ -88,7 +88,7 @@ export class BinaryCollectionSerializer {
      * @param {string} className
      */
     setClass(className) {
-        assert.typeOf(className, 'string', 'className');
+        assert.isString(className, 'className');
 
         this.className = className;
     }

package/engine/ecs/terrain/ecs/splat/SplatMapOptimizerDebugger.js

@@ -10,8 +10,8 @@ import SVG from "../../../../../view/SVG.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import Vector4 from "../../../../../core/geom/Vector4.js";
 import { MersenneTwister } from "../../../../../core/math/random/MersenneTwister.js";
-import { hsv2rgb } from "../../../../../core/color/ColorUtils.js";
 import { arrayPickBestElement } from "../../../../../core/collection/array/arrayPickBestElement.js";
+import { hsv2rgb } from "../../../../../core/color/hsv2rgb.js";
 
 function removeAllChildren(node) {
     const children = node.children;

package/engine/ecs/terrain/tiles/TerrainTile.js

@@ -581,7 +581,7 @@ class TerrainTile {
         mesh.geometry = g;
 
         mesh.receiveShadow = true;
-        mesh.castShadow = false;
+        mesh.castShadow = true;
 
         // console.timeEnd('total');
         // console.groupEnd();