@woosh/meep-engine 2.33.33 → 2.33.37

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

@@ -0,0 +1,5 @@
+import { compute_delaunay_tetrahedral_mesh } from "./compute_delaunay_tetrahedral_mesh.js";
+
+test('single point', () => {
+    compute_delaunay_tetrahedral_mesh([1, 2, 3], 1);
+});

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

@@ -0,0 +1,77 @@
+/**
+ * Approximate 3D insphere test.  Nonrobust.
+ *
+ * Return a positive value if the point pe lies inside the
+ * sphere passing through pa, pb, pc, and pd; a negative value
+ * if it lies outside; and zero if the five points are
+ * cospherical.  The points pa, pb, pc, and pd must be ordered
+ * so that they have a positive orientation (as defined by
+ * orient3d()), or the sign of the result will be reversed.
+ *
+ * @see "Adaptive Precision Floating-Point Arithmetic and Fast Robust Geometric Predicates." Technical Report CMU-CS-96-140, School of Computer Science, Carnegie Mellon University, Pittsburgh, Pennsylvania, May 1996
+ * @see http://www.cs.cmu.edu/~quake/robust.html
+ * @see https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/predicates/src/predicates.c
+ * @param {number[]} points
+ * @param {number} a tetrahedral point index
+ * @param {number} b tetrahedral point index
+ * @param {number} c tetrahedral point index
+ * @param {number} d tetrahedral point index
+ * @param {number} e reference point index
+ * @returns {number}
+ */
+export function point_in_tetrahedron_circumsphere(points, a, b, c, d, e) {
+    const ex = points[e * 3];
+    const ey = points[e * 3 + 1];
+    const ez = points[e * 3 + 2];
+
+    const aex = points[a * 3] - ex;
+    const bex = points[b * 3] - ex;
+    const cex = points[c * 3] - ex;
+    const dex = points[d * 3] - ex;
+
+    const aey = points[a * 3 + 1] - ey;
+    const bey = points[b * 3 + 1] - ey;
+    const cey = points[c * 3 + 1] - ey;
+    const dey = points[d * 3 + 1] - ey;
+
+    const aez = points[a * 3 + 2] - ez;
+    const bez = points[b * 3 + 2] - ez;
+    const cez = points[c * 3 + 2] - ez;
+    const dez = points[d * 3 + 1] - ez;
+
+    const aexbey = aex * bey;
+    const bexaey = bex * aey;
+    const ab = aexbey - bexaey;
+    const bexcey = bex * cey;
+    const cexbey = cex * bey;
+    const bc = bexcey - cexbey;
+    const cexdey = cex * dey;
+    const dexcey = dex * cey;
+    const cd = cexdey - dexcey;
+    const dexaey = dex * aey;
+    const aexdey = aex * dey;
+    const da = dexaey - aexdey;
+
+    const aexcey = aex * cey;
+    const cexaey = cex * aey;
+    const ac = aexcey - cexaey;
+    const bexdey = bex * dey;
+    const dexbey = dex * bey;
+    const bd = bexdey - dexbey;
+
+    const abc = aez * bc - bez * ac + cez * ab;
+    const bcd = bez * cd - cez * bd + dez * bc;
+    const cda = cez * da + dez * ac + aez * cd;
+    const dab = dez * ab + aez * bd + bez * da;
+
+    const alift = aex * aex + aey * aey + aez * aez;
+    const blift = bex * bex + bey * bey + bez * bez;
+    const clift = cex * cex + cey * cey + cez * cez;
+    const dlift = dex * dex + dey * dey + dez * dez;
+
+    const det = (dlift * abc - clift * dab) + (blift * cda - alift * bcd);
+
+    // TODO HXT uses 2 more methods to perform exact calculation (avoiding rounding errors), we could include that if necessary
+
+    return det;
+}

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/geom/Vector2.d.ts

@@ -20,6 +20,14 @@ export default class Vector2 {
 
     _sub(x: number, y: number): void
 
+    abs(): void
+
+    round(): void
+
+    floor(): void
+
+    ceil(): void
+
     copy(other: Vector2): void
 
     distanceTo(other: Vector2): number

package/core/geom/Vector3.d.ts

@@ -31,6 +31,14 @@ export default class Vector3 implements Vector3Like {
 
     _sub(x: number, y: number, z: number): void
 
+    abs(): void
+
+    round(): void
+
+    floor(): void
+
+    ceil(): void
+
     _multiply(x: number, y: number, z: number): void
 
     multiply(other: Vector3Like): void

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

@@ -95,6 +95,14 @@ export class ActionProcessor {
         return mark.description;
     }
 
+    /**
+     * Remove all of the history
+     */
+    clear() {
+        // drop all of the history
+        this.dropHistory(0);
+    }
+
     /**
      * Drop records beyond a given limit. records are dropped in batches between marks.
      *

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();

package/engine/graphics/GraphicsEngine.js

@@ -97,6 +97,9 @@ function GraphicsEngine(camera, entityManger) {
         preRender: new Signal(),
         postRender: new Signal(),
 
+        preOpaquePass: new Signal(),
+        postOpaquePass : new Signal(),
+
         /**
          * @deprecated
          */
@@ -558,6 +561,8 @@ GraphicsEngine.prototype.prepareRenderPass = function (passType) {
  * Renders opaque assets
  */
 GraphicsEngine.prototype.renderOpaque = function () {
+    this.on.preOpaquePass.send0();
+
     this.prepareRenderPass(RenderPassType.Opaque);
 
     const renderer = this.renderer;
@@ -570,6 +575,8 @@ GraphicsEngine.prototype.renderOpaque = function () {
     const frameBuffer = buffers.getById(StandardFrameBuffers.ColorAndDepth);
 
     renderTextureToScreenQuad(frameBuffer.renderTarget.texture, renderer);
+
+    this.on.postOpaquePass.send0();
 };
 
 /**

package/engine/graphics/ecs/mesh/Mesh.js

@@ -252,8 +252,8 @@ class Mesh {
 
     fromJSON({
                  url = null,
-                 castShadow = false,
-                 receiveShadow = false,
+                 castShadow = true,
+                 receiveShadow = true,
                  opacity = 1
              }) {
         this.url = url;

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -167,3 +167,16 @@ export class ShadedGeometry {
         this.updateTransform();
     }
 }
+
+/**
+ * @readonly
+ * @type {string}
+ */
+ShadedGeometry.typeName = 'ShadedGeometry';
+
+/**
+ * TODO add serialization support
+ * @readonly
+ * @type {boolean}
+ */
+ShadedGeometry.serializable = false;