@woosh/meep-engine 2.33.56 → 2.33.60

package/engine/ecs/gui/hud/HeadsUpDisplaySystem.js

@@ -6,23 +6,15 @@
 import { System } from '../../System.js';
 import HeadsUpDisplay from './HeadsUpDisplay.js';
 import { Transform } from '../../transform/Transform.js';
-
-import { Matrix4 } from 'three';
 import { GraphicsEngine } from "../../../graphics/GraphicsEngine.js";
 import { FogOfWarVisibilityPredicate } from "../../fow/FogOfWarVisibilityPredicate.js";
-import Vector4 from "../../../../core/geom/Vector4.js";
 import ViewportPosition from "../position/ViewportPosition.js";
 import GUIElement from "../GUIElement.js";
 import { HeadsUpDisplayFlag } from "./HeadsUpDisplayFlag.js";
+import { mat4 } from "gl-matrix";
 
-/**
- *
- * @type {Vector4}
- */
-const v4 = new Vector4();
-const projectionMatrix = new Matrix4();
+const projection = new Float32Array(16);
 
-const up = new Vector4();
 
 /**
  *
@@ -77,7 +69,7 @@ class HeadsUpDisplaySystem extends System {
     }
 
     /**
-     *
+     * NOTE: for the sake of speed all of the matrix and vector multiplications have been inlined, readability of this method is pretty bad
      * @param {HeadsUpDisplay} hud
      * @param {Transform} transform
      * @param {ViewportPosition} vp
@@ -87,48 +79,69 @@ class HeadsUpDisplaySystem extends System {
     __apply_entity_transformation(hud, transform, vp, element) {
         const worldOffset = hud.worldOffset;
 
-        let worldOffsetX = worldOffset.x;
-        let worldOffsetY = worldOffset.y;
-        let worldOffsetZ = worldOffset.z;
-
-        v4.set(
-            worldOffsetX,
-            worldOffsetY,
-            worldOffsetZ,
-            1
-        );
+        let x = worldOffset.x;
+        let y = worldOffset.y;
+        let z = worldOffset.z;
 
         if (hud.getFlag(HeadsUpDisplayFlag.TransformWorldOffset)) {
             //apply scale and rotation
+            const transform_scale = transform.scale;
+
+            x *= transform_scale.x;
+            y *= transform_scale.y;
+            z *= transform_scale.y;
 
-            v4.multiplyVector3(transform.scale);
+            const q = transform.rotation;
+
+            const qx = q.x;
+            const qy = q.y;
+            const qz = q.z;
+            const qw = q.w;
+
+            // calculate quat * vec
+            const ix = qw * x + qy * z - qz * y;
+            const iy = qw * y + qz * x - qx * z;
+            const iz = qw * z + qx * y - qy * x;
+            const iw = -qx * x - qy * y - qz * z;
+
+            // calculate result * inverse quat
+            x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+            y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+            z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
 
-            v4.applyQuaternion(transform.rotation);
         }
 
+        // add transform position to get final world position
         const position = transform.position;
 
-        v4.add3(position);
-
-        const worldPositionX = v4.x;
-        const worldPositionY = v4.y;
-        const worldPositionZ = v4.z;
+        x += position.x;
+        y += position.y;
+        z += position.z;
 
+        const worldPositionX = x;
+        const worldPositionY = y;
+        const worldPositionZ = z;
 
         // Convert the [-1, 1] screen coordinate into a world coordinate on the near plane
-        v4.threeApplyMatrix4(projectionMatrix);
 
-        const d = 1 / Math.abs(v4.w);
-        v4.x *= d;
-        v4.y *= d;
-        v4.z *= d;
+        // apply projection matrix
+        const _x = projection[0] * x + projection[4] * y + projection[8] * z + projection[12];
+        const _y = projection[1] * x + projection[5] * y + projection[9] * z + projection[13];
+        const _z = projection[2] * x + projection[6] * y + projection[10] * z + projection[14];
+        const _w = projection[3] * x + projection[7] * y + projection[11] * z + projection[15];
+
+        // apply perspective transform
+        const d = 1 / Math.abs(_w);
+        x = _x * d;
+        y = _y * d;
+        z = _z * d;
 
-        const ndcX = (v4.x + 1) / 2;
-        const ndcY = (1 - v4.y) / 2;
+        const ndcX = (x + 1) / 2;
+        const ndcY = (1 - y) / 2;
 
         vp.position.set(ndcX, ndcY);
 
-        const trackedPositionOutOfBounds = v4.z > 1 || v4.z < -1;
+        const trackedPositionOutOfBounds = z > 1 || z < -1;
 
         const visible = (!trackedPositionOutOfBounds || vp.stickToScreenEdge) && this.__visibility_predicate.test(worldPositionX, worldPositionY, worldPositionZ);
 
@@ -141,18 +154,20 @@ class HeadsUpDisplaySystem extends System {
             if (hud.getFlag(HeadsUpDisplayFlag.PerspectiveRotation)) {
                 //compute rotation in screen-space
 
-                up.set(worldPositionX, worldPositionY + 1, worldPositionZ, 1);
-                up.threeApplyMatrix4(projectionMatrix);
+                const w_y_1 = worldPositionY + 1;
+
+                const _up_x = projection[0] * worldPositionX + projection[4] * w_y_1 + projection[8] * worldPositionZ + projection[12];
+                const _up_y = projection[1] * worldPositionX + projection[5] * w_y_1 + projection[9] * worldPositionZ + projection[13];
+                const _up_w = projection[3] * worldPositionX + projection[7] * w_y_1 + projection[11] * worldPositionZ + projection[15];
 
                 // compute perspective divide
-                const d = 1 / Math.abs(up.w);
+                const d = 1 / Math.abs(_up_w);
 
-                up.x *= d;
-                up.y *= d;
-                up.z *= d;
+                const up_x = _up_x * d;
+                const up_y = _up_y * d;
 
-                const up_ndcX = (up.x + 1) / 2;
-                const up_ndcY = (1 - up.y) / 2;
+                const up_ndcX = (up_x + 1) / 2;
+                const up_ndcY = (1 - up_y) / 2;
 
                 const angle = Math.atan2(up_ndcY - ndcY, up_ndcX - ndcX);
 
@@ -176,7 +191,7 @@ class HeadsUpDisplaySystem extends System {
          */
         const camera = this.graphics.camera;
 
-        projectionMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+        mat4.multiply(projection, camera.projectionMatrix.elements, camera.matrixWorldInverse.elements);
 
         const visibilityPredicate = this.__visibility_predicate;
 

package/engine/ecs/storage/binary/BinaryClassUpgrader.js

@@ -82,6 +82,7 @@ export class BinaryClassUpgrader {
      *
      * @param {BinaryBuffer} source
      * @param {BinaryBuffer} target
+     * @returns {void}
      */
     upgrade(source, target) {
         throw new Error('Not Implemented');

package/engine/ecs/util/removeComponentsExcept.js

@@ -10,7 +10,7 @@ export function removeComponentsExcept(ecd, entity, whitelist) {
     const components = ecd.getAllComponents(entity);
     const component_count = components.length;
 
-    for (let i = 0; i < component_count; i++) {
+    l0:for (let i = 0; i < component_count; i++) {
         const component = components[i];
 
         if (component === undefined) {
@@ -21,7 +21,7 @@ export function removeComponentsExcept(ecd, entity, whitelist) {
         for (let i = 0; i < exception_count; i++) {
             if (component instanceof whitelist[i]) {
                 //keep
-                continue;
+                continue l0;
             }
         }
 
@@ -29,4 +29,4 @@ export function removeComponentsExcept(ecd, entity, whitelist) {
         ecd.removeComponentFromEntityByIndex(entity, i);
     }
 
-}
+}

package/engine/graphics/GraphicsEngine.js

@@ -35,7 +35,6 @@ import { MetricsCategory } from "../metrics/MetricsCategory.js";
 import Vector1 from "../../core/geom/Vector1.js";
 import { NormalFrameBuffer } from "./render/buffer/buffers/NormalFrameBuffer.js";
 import { MaterialManager } from "./material/manager/MaterialManager.js";
-import { CoalesceTextures } from "./material/manager/compilers/CoalesceTextures.js";
 import { ShadowMapRenderer } from "./shadows/ShadowMapRenderer.js";
 import { CameraViewManager } from "./render/view/CameraViewManager.js";
 import { StandardFrameBuffers } from "./StandardFrameBuffers.js";
@@ -91,14 +90,15 @@ function GraphicsEngine(camera, entityManger) {
      */
     this.__material_manager = new MaterialManager();
 
-    this.__material_manager.addCompileStep(new CoalesceTextures());
+    // The line below would de-dupe textures, it is a rather slow process however
+    // this.__material_manager.addCompileStep(new CoalesceTextures());
 
     this.on = {
         preRender: new Signal(),
         postRender: new Signal(),
 
         preOpaquePass: new Signal(),
-        postOpaquePass : new Signal(),
+        postOpaquePass: new Signal(),
 
         /**
          * @deprecated

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -11,7 +11,6 @@ import { PI2 } from "../../../../../core/math/MathUtils.js";
 
 const m4 = new Matrix4();
 const euler = new Euler();
-const scratch_vector3 = new Vector3();
 
 const panOffset = new Vector3();
 

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.spec.js

@@ -3,6 +3,14 @@ import Vector3 from "../../../../../core/geom/Vector3.js";
 import { computeTopDownTransform } from "./TopDownCameraControllerSystem.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 
+test('setFromEyeAndTarget does not introduce roll when UP is aligned with +Y', () => {
+    const ut = new TopDownCameraController();
+
+    ut.setFromEyeAndTarget(new Vector3(0, 1, -1), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
+
+    expect(ut.roll).toBe(0);
+});
+
 test('setFromEyeAndTarget results in roll respecting UP vector', () => {
     const eye = new Vector3();
     const target = new Vector3();

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

@@ -52,10 +52,10 @@ class Mesh {
         this.mesh = null;
 
         /**
-         * Mesh with micron data, if available
+         * Override Mesh data, if available. Typically set via plugins
          * @type {Object3D|null}
          */
-        this.micron_mesh = null;
+        this.override_mesh = null;
 
         /**
          * @transient
@@ -128,9 +128,9 @@ class Mesh {
         //set bvh
         updateNodeByTransformAndBBB(this.bvh, this.boundingBox, _t);
 
-        // micron
-        if (this.micron_mesh !== null) {
-            applyTransformToThreeObject(this.micron_mesh, _t);
+        // override
+        if (this.override_mesh !== null) {
+            applyTransformToThreeObject(this.override_mesh, _t);
         }
     }
 

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

@@ -18,7 +18,6 @@ import Mesh, { MeshFlags } from "./Mesh.js";
 import { applyComponentPropertiesToThreeObject, setMesh } from "./setMesh.js";
 import { GLTFAssetLoader } from "../../../asset/loaders/GLTFAssetLoader.js";
 import { MeshEvents } from "./MeshEvents.js";
-import { MicronRenderPlugin } from "../../micron/plugin/MicronRenderPlugin.js";
 import { assert } from "../../../../core/assert.js";
 
 const placeholderGeometry = new BoxBufferGeometry(1, 1, 1);
@@ -86,13 +85,6 @@ export class MeshSystem extends System {
          * @type {BinaryNode}
          */
         this.bvh = null;
-
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__use_micron = false;
     }
 
     /**
@@ -126,11 +118,11 @@ export class MeshSystem extends System {
 
         component.setFlag(MeshFlags.Loaded);
 
-        // micron
-        if (asset.micron !== undefined && this.__use_micron) {
-            component.micron_mesh = asset.micron.clone();
+        // override
+        if (asset.override_mesh !== undefined ) {
+            component.override_mesh = asset.override_mesh.clone();
 
-            applyComponentPropertiesToThreeObject(component, component.micron_mesh, entity);
+            applyComponentPropertiesToThreeObject(component, component.override_mesh, entity);
         }
 
         setMesh(dataset, entity, component, mesh);
@@ -141,11 +133,6 @@ export class MeshSystem extends System {
     }
 
     async startup(entityManager, readyCallback, errorCallback) {
-        const engine = this.__engine;
-
-        // is micron supported here?
-        this.__use_micron = engine.plugins.getPlugin(MicronRenderPlugin) !== undefined;
-
         const am = this.assetManager;
 
         this.entityManager = entityManager;
@@ -158,10 +145,15 @@ export class MeshSystem extends System {
         const graphics = this.graphics;
         this.renderLayer = graphics.layers.create("mesh-system");
 
+        /**
+         *
+         * @param {Mesh} component
+         * @return {Object3D}
+         */
         const extractRenderable = (component) => {
-            if (this.__use_micron && component.micron_mesh !== null) {
-                // use micron mesh
-                return component.micron_mesh;
+            if (component.override_mesh !== null) {
+                // use override mesh
+                return component.override_mesh;
             } else {
                 // use standard mesh
                 return component.mesh;

package/engine/graphics/ecs/path/PathDisplaySystem.d.ts

@@ -1,5 +1,7 @@
 import Engine from "../../../Engine";
+import {System} from "../../../ecs/System";
+import {PathDisplay} from "./PathDisplay";
 
-export class PathDisplaySystem {
+export class PathDisplaySystem extends System<PathDisplay> {
     constructor(engine: Engine)
 }

package/engine/graphics/ecs/trail2d/Trail2D.js

@@ -6,6 +6,10 @@
 import Vector3 from "../../../../core/geom/Vector3.js";
 import Vector4 from "../../../../core/geom/Vector4.js";
 import { RibbonXMaterialSpec } from "../../trail/x/RibbonXMaterialSpec.js";
+import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
+import { makeGradientTrail } from "./makeGradientTrail.js";
+import { RibbonX } from "../../trail/x/RibbonX.js";
+import ThreeFactory from "../../three/ThreeFactory.js";
 
 /**
  * @readonly
@@ -14,6 +18,7 @@ import { RibbonXMaterialSpec } from "../../trail/x/RibbonXMaterialSpec.js";
 export const Trail2DFlags = {
     Spawning: 1,
     Aging: 2,
+    Built: 4,
 };
 
 class Trail2D {
@@ -37,6 +42,12 @@ class Trail2D {
          */
         this.time = 0;
 
+        /**
+         *
+         * @type {number}
+         */
+        this.trailingIndex = 0;
+
         /**
          * Time elapsed since last update
          * @type {number}
@@ -72,7 +83,11 @@ class Trail2D {
          * transient
          * @type {LeafNode|null}
          */
-        this.bvhLeaf = null;
+        this.bvhLeaf = new LeafNode(
+            this,
+            0, 0, 0,
+            0, 0, 0
+        );
 
         /**
          * @private
@@ -165,6 +180,21 @@ class Trail2D {
         }
     }
 
+    build(segment_count) {
+
+        const ribbon = new RibbonX();
+
+        ribbon.buildGeometry();
+        ribbon.setCount(segment_count);
+
+        const geometry = ribbon.getGeometry();
+
+        const mesh = ThreeFactory.createMesh(geometry, null);
+
+        this.ribbon = ribbon;
+        this.mesh = mesh;
+    }
+
     toJSON() {
         return {
             maxAge: this.maxAge,
@@ -187,10 +217,14 @@ class Trail2D {
             && this.offset.equals(other.offset)
             ;
     }
+
+
 }
 
 Trail2D.typeName = "Trail2D";
 
 Trail2D.serializable = false;
 
+Trail2D.makeGradientTrail = makeGradientTrail;
+
 export default Trail2D;

package/engine/graphics/ecs/trail2d/Trail2DSystem.js

@@ -10,9 +10,6 @@ import { Transform } from '../../../ecs/transform/Transform.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
 
 import Trail2D, { Trail2DFlags } from './Trail2D.js';
-
-import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
-import ThreeFactory from '../../three/ThreeFactory.js';
 import { GraphicsEngine } from "../../GraphicsEngine.js";
 import { RibbonXFixedPhysicsSimulator } from "../../trail/x/simulator/RibbonXFixedPhysicsSimulator.js";
 import { RibbonX } from "../../trail/x/RibbonX.js";
@@ -118,11 +115,11 @@ class Trail2DSystem extends System {
 
     /**
      *
-     * @param {Transform} transform
      * @param {Trail2D} trail
-     * @param {number} entityId
+     * @param {Transform} transform
+     * @private
      */
-    link(trail, transform, entityId) {
+    __build_trail(trail, transform) {
         const segmentsPerSecond = 60;
         const maxSegments = 1000;
         //instantiation
@@ -130,24 +127,19 @@ class Trail2DSystem extends System {
         //make a mesh
         const segment_count = Math.ceil(clamp(trail.maxAge * segmentsPerSecond, 2, maxSegments));
 
-        const ribbon = new RibbonX();
-
-        ribbon.buildGeometry();
-        ribbon.setCount(segment_count);
+        trail.build(segment_count);
 
-
-        const geometry = ribbon.getGeometry();
+        const ribbon = trail.ribbon;
 
         const ribbons = this.__ribbon_plugin.getValue();
 
         const material = ribbons.obtain_material_x(trail.material);
 
-        const mesh = ThreeFactory.createMesh(geometry, material);
+        trail.mesh.material = material;
 
         trail.time = 0;
         trail.trailingIndex = 0;
         trail.ribbon = ribbon;
-        trail.mesh = mesh;
         trail.timeSinceLastUpdate = 0;
 
 
@@ -173,16 +165,31 @@ class Trail2DSystem extends System {
 
         }
 
-        const leafNode = new LeafNode(
-            trail,
-
+        trail.bvhLeaf.resize(
             position_x, position_y, position_z,
             position_x, position_y, position_z
         );
 
-        trail.bvhLeaf = leafNode;
+        trail.setFlag(Trail2DFlags.Built);
+    }
+
+    /**
+     *
+     * @param {Transform} transform
+     * @param {Trail2D} trail
+     * @param {number} entityId
+     */
+    link(trail, transform, entityId) {
+        if (!trail.getFlag(Trail2DFlags.Built)) {
+            this.__build_trail(trail, transform);
+        } else {
+
+            const material = this.__ribbon_plugin.getValue().obtain_material_x(trail.material);
+            trail.mesh.material = material;
+        }
+
 
-        this.bvh.insertNode(leafNode);
+        this.bvh.insertNode(trail.bvhLeaf);
     }
 
     /**

package/engine/graphics/ecs/trail2d/makeGradientTrail.js

@@ -0,0 +1,68 @@
+import Trail2D, { Trail2DFlags } from "./Trail2D.js";
+import {
+    RIBBON_ATTRIBUTE_ADDRESS_AGE,
+    RIBBON_ATTRIBUTE_ADDRESS_COLOR,
+    RIBBON_ATTRIBUTE_ADDRESS_THICKNESS,
+    RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET
+} from "../../trail/x/ribbon_attributes_spec.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]} color
+ * @param {number[]} thickness
+ * @param {number} [duration]
+ * @param {number} [scale]
+ * @param {number[]} position
+ * @param {number[]} ages
+ * @param {string} texture
+ * @returns {Trail2D}
+ */
+export function makeGradientTrail({
+                                      color,
+                                      thickness,
+                                      position,
+                                      duration = 1,
+                                      scale = 1,
+                                      ages,
+                                      texture
+                                  }) {
+
+    const trail2D = new Trail2D();
+    trail2D.maxAge = duration;
+    trail2D.width = 1;
+    trail2D.textureURL = texture;
+
+    const point_count = thickness.length;
+
+    trail2D.build(point_count);
+
+    const ribbon = trail2D.ribbon;
+
+    for (let i = 0; i < point_count; i++) {
+
+        const f = i / (point_count - 1);
+        const i3 = i * 3;
+
+        ribbon.setPointAlpha(i, 0);
+        ribbon.setPointPosition(i, position[i3], position[i3 + 1], position[i3 + 2]);
+
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_AGE, ages[i] * duration);
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET, f);
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_THICKNESS, thickness[i]);
+
+        const c_0 = color[i];
+
+        assert.isNumber(c_0, `color[i]`);
+
+        ribbon.setPointAttribute_Vector3(i, RIBBON_ATTRIBUTE_ADDRESS_COLOR, c_0 >> 16, c_0 >> 8, c_0);
+    }
+
+    // don't spawn more trail segments
+    trail2D.clearFlag(Trail2DFlags.Spawning);
+    trail2D.setFlag(Trail2DFlags.Built);
+
+    ribbon.computeBoundingBox(trail2D.bvhLeaf);
+
+    return trail2D;
+}

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -3,12 +3,18 @@ import { computeGeometryHash } from "../../asset/loaders/geometry/geometry/compu
 import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
 import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
 import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
+import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";
 
 /**
  *
  * @type {HashMap<THREE.BufferGeometry, MicronGeometry>}
  */
-const micron_cache = new HashMap({
+const default_micron_cache = new AsyncMapWrapper(new HashMap({
+    keyHashFunction: computeGeometryHash,
+    keyEqualityFunction: computeGeometryEquality
+}));
+
+const pending_cache = new HashMap({
     keyHashFunction: computeGeometryHash,
     keyEqualityFunction: computeGeometryEquality
 });
@@ -17,9 +23,10 @@ const micron_cache = new HashMap({
 /**
  *
  * @param {THREE.Object3D} object
+ * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} micron_cache
  * @returns {THREE.Object3D}
  */
-export async function convert_three_object_to_micron(object) {
+export async function convert_three_object_to_micron(object, micron_cache = default_micron_cache) {
 
     const promises = [];
 
@@ -29,19 +36,29 @@ export async function convert_three_object_to_micron(object) {
      * @returns {MicronGeometry}
      */
     async function obtain_geometry(g) {
-        const existing = micron_cache.get(g);
+        const existing = await micron_cache.get(g);
+
+        if (existing !== undefined && existing !== null) {
+            return existing;
+        }
+
+        const pending = pending_cache.get(g);
 
-        if (existing !== undefined) {
-            return await existing;
+        if (pending !== undefined) {
+            return await pending;
         }
 
         const micron_geometry_promise = buildMicronGeometryFromBufferGeometry(g);
 
-        micron_cache.set(g, micron_geometry_promise);
+        pending_cache.set(g, micron_geometry_promise);
 
         promises.push(micron_geometry_promise);
 
-        return await micron_geometry_promise;
+        const micron_geometry = await micron_geometry_promise;
+
+        await micron_cache.set(g, micron_geometry);
+
+        return micron_geometry;
     }