@woosh/meep-engine 2.33.57 → 2.33.61

package/engine/ecs/terrain/ecs/Terrain.js

@@ -909,7 +909,7 @@ class Terrain {
 
         worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
-        worker.computeHeightRange()
+       return worker.computeHeightRange()
             .then(({ min, max }) => {
                 this.tiles.setHeightRange(min, max);
             });
@@ -1038,13 +1038,22 @@ class Terrain {
             heightSampler: this.samplerHeight
         });
 
+
         const result = promise.then(() => {
 
-            this.material.aoMap = true;
-            this.material.needsUpdate = true;
+            const ref = this.__material_reference;
+
+            let mat = this.material;
+
+            if (ref !== null && ref.getValue() !== null) {
+                mat = ref.getValue();
+            }
+
+            mat.aoMap = true;
+            mat.needsUpdate = true;
 
-            this.material.uniforms.aoMap.value = texture;
-            this.material.uniforms.aoMapIntensity.value = 0.7;
+            mat.uniforms.aoMap.value = texture;
+            mat.uniforms.aoMapIntensity.value = 0.7;
 
             return texture;
         });

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
@@ -585,6 +585,7 @@ GraphicsEngine.prototype.renderOpaque = function () {
 GraphicsEngine.prototype.renderTransparent = function () {
     const scene = this.scene;
 
+    // clear background, as transparent pass is drawn on top, the background should already be composited
     const _background = scene.background;
     scene.background = null;
 
@@ -596,8 +597,6 @@ GraphicsEngine.prototype.renderTransparent = function () {
 
     // restore background
     scene.background = _background;
-
-    // TODO render transparent objects into a buffer, to be able to apply post-fx
 };
 
 /**

package/engine/graphics/camera/testClippingPlaneComputation.js

@@ -8,8 +8,6 @@ import PathFollowingSystem from "../../navigation/ecs/path_following/PathFollowi
 import SteeringSystem from "../../ecs/systems/SteeringSystem.js";
 import MotionSystem from "../../ecs/systems/MotionSystem.js";
 import TagSystem from "../../ecs/systems/TagSystem.js";
-import { AttachmentSocketsSystem } from "../../ecs/sockets/AttachmentSocketsSystem.js";
-import { AttachmentSystem } from "../../ecs/attachment/AttachmentSystem.js";
 import { SoundEmitterSystem } from "../../sound/ecs/emitter/SoundEmitterSystem.js";
 import SoundControllerSystem from "../../sound/ecs/SoundControllerSystem.js";
 import SoundListenerSystem from "../../sound/ecs/SoundListenerSystem.js";
@@ -84,8 +82,6 @@ function makeConfig(engine) {
         new SteeringSystem(),
         new MotionSystem(),
         new TagSystem(),
-        new AttachmentSocketsSystem(),
-        new AttachmentSystem(),
         new SoundEmitterSystem(assetManager, sound.destination, sound.context),
         new SoundControllerSystem(),
         new SoundListenerSystem(sound.context),

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/light/LightSystem.js

@@ -26,7 +26,7 @@ class LightSystem extends AbstractContextSystem {
      * @param settings
      * @constructor
      */
-    constructor(engine, settings) {
+    constructor(engine, settings = {}) {
         super(LightContext);
 
         /**

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/mesh-v2/ShadedGeometry.js

@@ -39,6 +39,35 @@ export class ShadedGeometry {
          * @private
          */
         this.__bvh_leaf = new LeafNode(this, 0, 0, 0, 0, 0, 0);
+
+        /**
+         * Transient, assigned in the system
+         * @type {number}
+         * @private
+         */
+        this.__entity = -1;
+        /**
+         * Transform matrix
+         * Transient, assigned in the system
+         * @type {number[]|null}
+         * @private
+         */
+        this.__transform = null;
+    }
+
+    /**
+     * Global transform matrix
+     * 4x4 matrix
+     * @return {null|number[]}
+     */
+    get transform() {
+        if (this.__transform !== null) {
+            return this.__transform;
+        } else if (this.__cached_object !== null) {
+            return this.__cached_object.matrix.elements;
+        } else {
+            return null;
+        }
     }
 
     __build_object() {

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

@@ -1,6 +1,27 @@
 import { ShadedGeometry } from "./ShadedGeometry.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { System } from "../../../ecs/System.js";
+import { intersectRay } from "../../../../core/bvh2/aabb3/AABB3Math.js";
+import { GeometrySpatialQueryAccelerator } from "../../geometry/buffered/query/GeometrySpatialQueryAccelerator.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
+import { mat4 } from "gl-matrix";
+import { returnTrue } from "../../../../core/function/Functions.js";
+
+const traversal_stack = [];
+let traversal_cursor = 0;
+
+/**
+ *
+ * @type {SurfacePoint3}
+ */
+const scratch_point = new SurfacePoint3();
+
+/**
+ *
+ * @type {Float32Array|mat4}
+ */
+const scratch_m4 = new Float32Array(16);
 
 export class ShadedGeometrySystem extends System {
     /**
@@ -49,7 +70,12 @@ export class ShadedGeometrySystem extends System {
 
         sg.applyTransform(t);
 
-        this.__render_layer.bvh.insertNode(sg.bvh);
+        const leaf_node = sg.bvh;
+
+        // remember entity for lookups
+        sg.__entity = entity;
+
+        this.__render_layer.bvh.insertNode(leaf_node);
     }
 
     /**
@@ -65,4 +91,135 @@ export class ShadedGeometrySystem extends System {
 
         sg.bvh.disconnect();
     }
+
+    /**
+     *
+     * @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
+     * @param {function(entity:number, mesh:ShadedGeometry)} [filter_function]
+     * @param {*} [filter_function_context]
+     * @returns {{entity:number, mesh:ShadedGeometry}|undefined}
+     */
+    raycastNearest(
+        contact,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        filter_function = returnTrue, filter_function_context
+    ) {
+        const root_bvh = this.__render_layer.bvh;
+        const stack_frame_address = traversal_cursor;
+
+        traversal_stack[traversal_cursor++] = root_bvh;
+
+        let best_distance = Infinity;
+        let found_hit = false;
+        let best_result = null;
+
+        while (traversal_cursor > stack_frame_address) {
+            traversal_cursor--;
+
+            /**
+             *
+             * @type {BinaryNode|LeafNode<ShadedGeometry>}
+             */
+            const node = traversal_stack[traversal_cursor];
+
+            // test node against the ray
+            const intersects = intersectRay(
+                node.x0, node.y0, node.z0,
+                node.x1, node.y1, node.z1,
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            );
+
+            if (!intersects) {
+                continue;
+            }
+
+            if (node.isBinaryNode) {
+                if (node.right !== null) {
+                    traversal_stack[traversal_cursor++] = node.right;
+                }
+                if (node.left !== null) {
+                    traversal_stack[traversal_cursor++] = node.left;
+                }
+            } else {
+                // leaf node
+
+                /**
+                 *
+                 * @type {ShadedGeometry}
+                 */
+                const sg = node.object;
+
+                const entity = sg.__entity;
+
+                if (!filter_function.call(filter_function_context, entity, sg)) {
+                    // filtered out
+                    continue;
+                }
+
+                const m4 = sg.transform;
+
+                // get transform in local space
+                mat4.invert(scratch_m4, m4);
+
+                // transform ray to local space
+                const local_origin_x = scratch_m4[0] * origin_x + scratch_m4[4] * origin_y + scratch_m4[8] * origin_z + scratch_m4[12];
+                const local_origin_y = scratch_m4[1] * origin_x + scratch_m4[5] * origin_y + scratch_m4[9] * origin_z + scratch_m4[13];
+                const local_origin_z = scratch_m4[2] * origin_x + scratch_m4[6] * origin_y + scratch_m4[10] * origin_z + scratch_m4[14];
+
+                const local_direction_x = scratch_m4[0] * direction_x + scratch_m4[4] * direction_y + scratch_m4[8] * direction_z;
+                const local_direction_y = scratch_m4[1] * direction_x + scratch_m4[5] * direction_y + scratch_m4[9] * direction_z;
+                const local_direction_z = scratch_m4[2] * direction_x + scratch_m4[6] * direction_y + scratch_m4[10] * direction_z;
+                // NOTE: direction is not normalized
+
+                const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_primitive(
+                    scratch_point,
+                    sg.geometry,
+                    local_origin_x, local_origin_y, local_origin_z,
+                    local_direction_x, local_direction_y, local_direction_z
+                );
+
+                if (!geometry_hit_found) {
+                    continue;
+                }
+
+                // transform hit contact into global space
+                scratch_point.applyMatrix4(m4);
+
+                found_hit = true;
+
+                const hit_position = scratch_point.position;
+
+                const distance_sqr = v3_distance_sqr(
+                    hit_position.x, hit_position.y, hit_position.z,
+                    origin_x, origin_y, origin_z
+                );
+
+                if (distance_sqr >= best_distance) {
+                    // further than best found
+                    continue;
+                }
+
+                contact.copy(scratch_point);
+                best_result = sg;
+            }
+        }
+
+        // drop stack frame
+        traversal_cursor = stack_frame_address;
+
+        if (found_hit) {
+            return {
+                entity: best_result.__entity,
+                mesh: best_result
+            };
+        }
+    }
 }

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/path/testPathDisplaySystem.js

@@ -19,7 +19,6 @@ import PathFollowingSystem from "../../../navigation/ecs/path_following/PathFoll
 import SteeringSystem from "../../../ecs/systems/SteeringSystem.js";
 import MotionSystem from "../../../ecs/systems/MotionSystem.js";
 import TagSystem from "../../../ecs/systems/TagSystem.js";
-import { AttachmentSocketsSystem } from "../../../ecs/sockets/AttachmentSocketsSystem.js";
 import { AttachmentSystem } from "../../../ecs/attachment/AttachmentSystem.js";
 import { SoundEmitterSystem } from "../../../sound/ecs/emitter/SoundEmitterSystem.js";
 import SoundControllerSystem from "../../../sound/ecs/SoundControllerSystem.js";
@@ -95,7 +94,6 @@ function makeConfig(engine) {
         new SteeringSystem(),
         new MotionSystem(),
         new TagSystem(),
-        new AttachmentSocketsSystem(),
         new AttachmentSystem(),
         new SoundEmitterSystem(assetManager, sound.destination, sound.context),
         new SoundControllerSystem(),

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);
     }
 
     /**