@woosh/meep-engine 2.31.1 → 2.31.5

package/core/graph/v2/Graph.js

@@ -122,11 +122,16 @@ export class Graph {
      * @returns {N|undefined}
      */
     findNode(filter, thisArg) {
-        for (const [node, container] of this.__nodes) {
+        const nodes = this.__nodes;
+
+        for (const [node, container] of nodes) {
+
             const pass = filter.call(thisArg, node);
+
             if (pass) {
                 return node;
             }
+
         }
 
         return undefined;
@@ -297,11 +302,6 @@ export class Graph {
             return false;
         }
 
-        if (!this.hasNode(b)) {
-            // check if B is part of the graph
-            return false;
-        }
-
         return context_a.edgeWithNodeExists(b);
     }
 

package/core/model/ObservedBoolean.js

@@ -1,7 +1,7 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 
-class ObservedBoolean extends Boolean{
+class ObservedBoolean extends Boolean {
     /**
      *
      * @param {boolean} value
@@ -44,7 +44,7 @@ class ObservedBoolean extends Boolean{
      * @returns {ObservedBoolean}
      */
     set(value) {
-        assert.equal(typeof value, "boolean", `Value must be of type "boolean", instead was "${typeof value}"`);
+        assert.isBoolean(value, 'value');
 
         const oldValue = this.__value;
         if (oldValue !== value) {
@@ -56,6 +56,14 @@ class ObservedBoolean extends Boolean{
         return this;
     }
 
+    setTrue() {
+        this.set(true);
+    }
+
+    setFalse() {
+        this.set(false);
+    }
+
     /**
      *
      * @param {ObservedBoolean} other
@@ -77,8 +85,8 @@ class ObservedBoolean extends Boolean{
      *
      * @return {number}
      */
-    hashCode(){
-        return this.__value?1:0;
+    hashCode() {
+        return this.__value ? 1 : 0;
     }
 
     /**

package/core/process/worker/WorkerBuilder.js

@@ -5,19 +5,19 @@
 
 import { convertPathToURL } from "../../../engine/network/convertPathToURL.js";
 import WorkerProxy from "./WorkerProxy.js";
-import { extractTransferables } from "./extractTransferables.js";
+import LineBuilder from "../../codegen/LineBuilder.js";
 
 const RxMatchFunctionName = /(function\s*)([a-zA-Z0-9_]+)?(\s*\([^\]]*\)\s*\{.*)/g;
 
-const builtin_functions = [{
-    f: extractTransferables,
-    name: 'extractTransferables'
-}];
-
 const WorkerBuilder = function () {
     this.imports = [];
     this.methods = {};
     this.functions = [];
+    this.preable = new LineBuilder();
+};
+
+WorkerBuilder.prototype.addCode = function (code) {
+    this.preable.add(code);
 };
 
 /**
@@ -30,7 +30,7 @@ WorkerBuilder.prototype.addMethod = function (name, method) {
 };
 
 /**
- *
+ * NOTE: take care when using minifiers as they may mangle function names
  * @param name
  * @param {function} f
  */
@@ -78,8 +78,10 @@ WorkerBuilder.prototype.build = function () {
         codeLines.push("globalScope.importScripts('" + url + "');");
     });
 
+    codeLines.push(this.preable.build());
+
     //handle functions
-    builtin_functions.concat(this.functions).forEach(function (spec) {
+    this.functions.forEach(function (spec) {
         const f = spec.f;
 
         const function_string = f.toString();
@@ -102,7 +104,23 @@ WorkerBuilder.prototype.build = function () {
 
     //api handler
     Array.prototype.push.apply(codeLines, [
-
+        `function extractTransferables(obj, result) {
+            if (typeof obj !== "object") {
+                return; //not an object, skip
+            } else if (obj instanceof ArrayBuffer) {
+                result.push(obj);
+            } else if (obj.buffer instanceof ArrayBuffer) {
+                result.push(obj.buffer);
+            } else if (obj instanceof ImageBitmap) {
+                result.push(obj);
+            } else {
+                for (var i in obj) {
+                    if (obj.hasOwnProperty(i)) {
+                        extractTransferables(obj[i], result);
+                    }
+                }
+            }
+        }`,
         'globalScope.onmessage = function(event){',
         '   var eventData = event.data;',
         '   var requestId = eventData.id',

package/core/process/worker/WorkerProxy.js

@@ -263,6 +263,12 @@ class WorkerProxy {
 
         this.__worker = new Worker(this.url);
         this.__worker.onmessage = this.__handleMessageBound;
+
+        // TODO attach proper error handler
+        this.__worker.onerror = (errorEvent) => {
+            console.error('Worker error:', errorEvent);
+        };
+
         this.__isRunning = true;
 
         this.sendPendingRequests();

package/editor/Editor.js

@@ -286,7 +286,16 @@ function activateEditorCamera(cameraEntity, dataset, editor) {
          */
         const cameraController = cameraEntity.getComponent(TopDownCameraController);
 
-        setCameraControllerFromTransform(cameraTransform, cameraController);
+        const active_camera_controller = dataset.getComponent(activeCameraEntity, TopDownCameraController);
+        if (active_camera_controller !== undefined) {
+            cameraController.target.copy(active_camera_controller.target);
+            cameraController.distance = active_camera_controller.distance;
+            cameraController.pitch = active_camera_controller.pitch;
+            cameraController.yaw = active_camera_controller.yaw;
+            cameraController.roll = active_camera_controller.roll;
+        } else {
+            setCameraControllerFromTransform(cameraTransform, cameraController);
+        }
     }
 
     camera.active.set(true);

package/editor/process/symbolic/makePositionedIconDisplaySymbol.js

@@ -6,6 +6,8 @@ import Renderable from "../../../engine/ecs/components/Renderable.js";
 import { Transform } from "../../../engine/ecs/transform/Transform.js";
 import { synchronizeTransform } from "./synchronizeTransform.js";
 
+const SPRITE_SIZE = 0.3;
+
 /**
  * @template C,T
  * @param {Engine} engine
@@ -57,7 +59,7 @@ export function makePositionedIconDisplaySymbol(engine, iconURL, ComponentClass)
 
 
             //sprite size
-            cT.scale.set(1, 1, 1);
+            cT.scale.set(SPRITE_SIZE, SPRITE_SIZE, SPRITE_SIZE);
             cR.boundingBox.setBounds(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
 
             synchronizeTransform(transform, cT, api.bindings, true, false, false);

package/engine/EngineHarness.js

@@ -150,7 +150,7 @@ export class EngineHarness {
             ecd = engine.entityManager.dataset,
             target = new Vector3(),
             distance = 10,
-            pitch = -1.4,
+            pitch = 1.4,
             yaw = 0,
             autoClip = true,
             distanceMin = 0,

package/engine/ecs/parent/ParentEntitySystem.js

@@ -75,7 +75,7 @@ class Context extends SystemEntityContext {
          */
         const cParent = this.components[0];
 
-        ecd.removeEntityEventListener(cParent.entity, EventType.EntityRemoved, this.die, this);
+        ecd.removeEntityEventListener(cParent.entity, EventType.EntityRemoved, this.handleParentEntityRemoval, this);
     }
 }
 

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

@@ -40,6 +40,7 @@ import { makeTerrainWorkerProxy } from "./makeTerrainWorkerProxy.js";
 import { MeepSettings } from "../../../MeepSettings.js";
 import { loadLegacyTerrainLayers } from "./layers/loadLegacyTerrainLayers.js";
 import { TerrainFlags } from "./TerrainFlags.js";
+import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
 
 /**
  *
@@ -464,6 +465,12 @@ class Terrain {
         this.clearFlag(TerrainFlags.Linked);
     }
 
+    dispose() {
+        if (this.getFlag(TerrainFlags.Linked)) {
+            throw new IllegalStateException('component is linked, must be unlinked first');
+        }
+    }
+
     initialize() {
         const overlay = this.overlay;
 
@@ -894,9 +901,11 @@ class Terrain {
 
     updateWorkerHeights() {
         const s = this.samplerHeight;
-        this.buildWorker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
+        const worker = this.buildWorker;
+
+        worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
-        this.buildWorker.computeHeightRange()
+        worker.computeHeightRange()
             .then(({ min, max }) => {
                 this.tiles.setHeightRange(min, max);
             });

package/engine/ecs/terrain/ecs/makeTerrainWorkerProxy.js

@@ -8,19 +8,19 @@ export function makeTerrainWorkerProxy() {
     const workerBuilder = new WorkerBuilder();
     workerBuilder.importScript('bundle-worker-terrain.js');
 
-    function useSampler(callback) {
-        if (globalScope.samplerHeight !== undefined) {
-            callback(globalScope.samplerHeight);
-        } else {
-            if (globalScope.useSampleCallbacks === undefined) {
-                globalScope.useSampleCallbacks = [callback];
+    workerBuilder.addCode(`
+        function useSampler(callback) {
+            if (globalScope.samplerHeight !== undefined) {
+                callback(globalScope.samplerHeight);
             } else {
-                globalScope.useSampleCallbacks.push(callback);
+                if (globalScope.useSampleCallbacks === undefined) {
+                    globalScope.useSampleCallbacks = [callback];
+                } else {
+                    globalScope.useSampleCallbacks.push(callback);
+                }
             }
         }
-    }
-
-    workerBuilder.importFunction('useSampler', useSampler);
+    `);
 
     workerBuilder.addMethod('computeHeightRange', function () {
         return new Promise(function (resolve, reject) {

package/engine/graphics/camera/makeOrbitalCameraController.js

@@ -3,6 +3,7 @@ import InputController from "../../input/ecs/components/InputController.js";
 import { decodeMouseEventButtons } from "../../input/devices/PointerDevice.js";
 import EntityBuilder from "../../ecs/EntityBuilder.js";
 import { Camera } from "../ecs/camera/Camera.js";
+import { clamp } from "../../../core/math/clamp.js";
 
 /**
  *
@@ -18,6 +19,10 @@ export function makeOrbitalCameraController({
                                                 dom_element,
                                                 sensitivity = 0.01
                                             }) {
+    /**
+     *
+     * @returns {TopDownCameraController}
+     */
     function getCameraController() {
         return ecd.getComponent(camera_entity, TopDownCameraController)
     }
@@ -55,7 +60,8 @@ export function makeOrbitalCameraController({
     function zoom(delta) {
         const cameraController = getCameraController();
 
-        cameraController.distance += delta;
+        const new_distance = cameraController.distance + delta;
+        cameraController.distance = clamp(new_distance, cameraController.distanceMin, cameraController.distanceMax);
     }
 
     const inputController = new InputController([

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

@@ -12,8 +12,6 @@ import { System } from '../../../../ecs/System.js';
 
 import TopDownCameraController from './TopDownCameraController.js';
 
-import { Euler as ThreeEuler } from 'three';
-
 
 const v3_scratch = new Vector3();
 
@@ -80,36 +78,11 @@ export function computeTopDownTransform(control, result) {
  * @param {number} distance
  */
 export function setCameraControllerFromTransform(transform, controller, distance = 20) {
-    //set camera controller
-    const euler = new ThreeEuler();
-
-    transform.rotation.__setThreeEuler(euler);
-
-    controller.yaw = euler.y;
-
-    const pitch = euler.x;
-
-    controller.pitch = pitch;
-
-    controller.roll = 0;
-
-    //compute direction
-    const direction = new Vector3();
-
-    direction.copy(Vector3.forward);
-    direction.applyQuaternion(transform.rotation);
-
-    direction.normalize();
-
-    controller.distance = distance;
-
-    const targetOffset = direction.clone();
-    targetOffset.multiplyScalar(controller.distance);
-
-    const target = transform.position.clone();
-    target.sub(targetOffset);
+    const v_f = Vector3.forward.clone();
+    v_f.multiplyScalar(distance);
+    v_f.applyQuaternion(transform.rotation);
 
-    controller.target.copy(target)
+    controller.setFromEyeAndTarget(transform.position,v_f);
 }
 
 export default TopDownCameraControllerSystem;

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

@@ -41,6 +41,12 @@ class Mesh {
          */
         this.mesh = null;
 
+        /**
+         * Mesh with micron data, if available
+         * @type {Object3D|null}
+         */
+        this.micron_mesh = null;
+
         /**
          * @transient
          * @type {Asset|null}
@@ -214,9 +220,9 @@ class Mesh {
      */
     equals(other) {
         return this.url === other.url
-               && this.opacity === other.opacity
-               && this.castShadow === other.castShadow
-               && this.receiveShadow === other.receiveShadow
+            && this.opacity === other.opacity
+            && this.castShadow === other.castShadow
+            && this.receiveShadow === other.receiveShadow
             ;
     }
 

package/engine/graphics/ecs/path/entity/EntityPath.js

@@ -6,7 +6,7 @@ import { EPSILON } from "../../../../../core/math/MathUtils.js";
 import { binarySearchHighIndex } from "../../../../../core/collection/ArrayUtils.js";
 import { assert } from "../../../../../core/assert.js";
 
-const v3 = new Vector3();
+const scratch_v3 = new Vector3();
 
 
 /**
@@ -117,19 +117,19 @@ export class EntityPath {
 
         if (def.align) {
             // get next point position to figure out orientation
-            if (path.sample(v3, offset + EPSILON)) {
-                v3.sub(transform.position);
+            if (path.sample(scratch_v3, offset + EPSILON)) {
+                scratch_v3.sub(transform.position);
 
             } else {
                 // sample behind
-                path.sample(v3, offset - EPSILON);
+                path.sample(scratch_v3, offset - EPSILON);
 
-                v3.subVectors(transform.position, v3);
+                scratch_v3.subVectors(transform.position, scratch_v3);
             }
 
-            v3.normalize();
+            scratch_v3.normalize();
 
-            transform.rotation.lookRotation(v3);
+            transform.rotation.lookRotation(scratch_v3);
         }
 
         transform.multiplyTransforms(transform, def.transform);

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

@@ -8,7 +8,7 @@ import { max2 } from "../../../../core/math/max2.js";
 import { System } from '../../../ecs/System.js';
 import { Transform } from '../../../ecs/transform/Transform.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
-import { computeHashFloat, computeHashIntegerArray} from '../../../../core/math/MathUtils.js';
+import { computeHashFloat, computeHashIntegerArray } from '../../../../core/math/MathUtils.js';
 
 import Trail2D, { Trail2DFlags } from './Trail2D.js';
 import { ClampToEdgeWrapping, DoubleSide, LinearFilter, TextureLoader } from 'three';
@@ -27,7 +27,9 @@ import {
 } from "../../trail/x/ribbon_attributes_spec.js";
 import { RibbonMaterialX } from "../../trail/x/RibbonMaterialX.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 
+const scratch_aabb3 = new AABB3();
 const v3Temp1 = new Vector3();
 
 const v3_array = [];
@@ -153,6 +155,7 @@ class Trail2DSystem extends System {
         this.entityManager = entityManager;
 
         this.renderLayer = this.graphics.layers.create('trail-2d-system');
+        // this.renderLayer.renderPass = RenderPassType.Transparent;
 
         this.renderLayer.extractRenderable = function (trail) {
             return trail.mesh;
@@ -220,12 +223,12 @@ class Trail2DSystem extends System {
         //instantiation
 
         //make a mesh
-        const numSegments = Math.ceil(clamp(trail.maxAge * segmentsPerSecond, 2, maxSegments));
+        const segment_count = Math.ceil(clamp(trail.maxAge * segmentsPerSecond, 2, maxSegments));
 
         const ribbon = new RibbonX();
 
         ribbon.buildGeometry();
-        ribbon.setCount(numSegments);
+        ribbon.setCount(segment_count);
 
 
         const geometry = ribbon.getGeometry();
@@ -242,24 +245,22 @@ class Trail2DSystem extends System {
         trail.mesh = mesh;
         trail.timeSinceLastUpdate = 0;
 
-        const leafNode = new LeafNode();
 
-        trail.bvhLeaf = leafNode;
-        trail.material = material;
-
-        leafNode.object = trail;
-        leafNode.setInfiniteBounds();
+        const trail_offset = trail.offset;
+        const transform_position = transform.position;
 
-        const position = trail.offset.clone().add(transform.position);
+        const position_x = trail_offset.x + transform_position.x;
+        const position_y = trail_offset.y + transform_position.y;
+        const position_z = trail_offset.z + transform_position.z;
 
         const color = trail.color;
 
         //initialize segments
-        for (let i = 0; i < numSegments; i++) {
-            const f = i / (numSegments - 1);
+        for (let i = 0; i < segment_count; i++) {
+            const f = i / (segment_count - 1);
 
             ribbon.setPointColor(i, color.x * 255, color.y * 255, color.z * 255);
-            ribbon.setPointPosition(i, position.x, position.y, position.z);
+            ribbon.setPointPosition(i, position_x, position_y, position_z);
             ribbon.setPointThickness(i, trail.width);
             ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET, f);
             ribbon.setPointAlpha(i, color.w);
@@ -267,9 +268,17 @@ class Trail2DSystem extends System {
 
         }
 
-        leafNode.setBounds(position.x, position.y, position.z);
+        const leafNode = new LeafNode(
+            trail,
+
+            position_x, position_y, position_z,
+            position_x, position_y, position_z
+        );
+
+        trail.bvhLeaf = leafNode;
+        trail.material = material;
 
-        this.bvh.insertNode(trail.bvhLeaf);
+        this.bvh.insertNode(leafNode);
     }
 
     unlink(component, transform, entity) {
@@ -328,8 +337,14 @@ class Trail2DSystem extends System {
             ribbon.setPointAttribute_Scalar(head_index, RIBBON_ATTRIBUTE_ADDRESS_AGE, ageOffset);
 
         }
+        const bvh = trail.bvhLeaf;
+
+        ribbon.computeBoundingBox(bvh);
+
+        if (bvh.parentNode !== null) {
+            bvh.parentNode.bubbleRefit();
+        }
 
-        ribbon.computeBoundingBox(trail.bvhLeaf);
 
         this.simulator.update(ribbon, trail.maxAge, timeDelta);
     }

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -174,6 +174,8 @@ export function compute_buffer_geometry_byte_size(g) {
     return result;
 }
 
+const PRINT_VERBOSE_STATS = false;
+
 /**
  *
  * @param {THREE.BufferGeometry} input
@@ -217,10 +219,12 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
         vertex_to_patch_map
     );
 
-    console.log(`build leaf patches: ${(performance.now() - t_build_leaf_patches_start)}ms`);
+    if (PRINT_VERBOSE_STATS) {
+        console.log(`build leaf patches: ${(performance.now() - t_build_leaf_patches_start)}ms`);
 
 
-    console.log(build_clustering_info(patches));
+        console.log(build_clustering_info(patches));
+    }
 
     // verify total poly count
 
@@ -233,8 +237,10 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
     const t_build_hierarchy_start = performance.now();
     const root = await buildAbstractPatchHierarchy(patches);
-    console.log(`build hierarchy: ${(performance.now() - t_build_hierarchy_start)}ms`);
 
+    if (PRINT_VERBOSE_STATS) {
+        console.log(`build hierarchy: ${(performance.now() - t_build_hierarchy_start)}ms`);
+    }
 
     // console.profile('simplification');
     // console.time('simplification');
@@ -248,14 +254,16 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
     // assign IDs to the patches
     assign_ids_to_hierarchy(root);
 
-    console.log(build_graph_info(root));
+    if (PRINT_VERBOSE_STATS) {
+        console.log(build_graph_info(root));
+    }
 
     const r = new MicronGeometry();
     r.source_triangle_count = index_attribute.count / 3;
     r.source_vertex_count = input.getAttribute('position').count;
     r.source_byte_size = compute_buffer_geometry_byte_size(input);
 
-    console.time('build geometry');
+    // console.time('build geometry');
 
     const vertex_attributes = attributes_from_buffer_geometry(input);
     const data_types = buildVertexDataTypeMap(vertex_attributes);
@@ -267,10 +275,11 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
     r.initialize();
 
-    console.timeEnd('build geometry');
-
+    // console.timeEnd('build geometry');
 
-    console.log(build_geometry_info(r));
+    if (PRINT_VERBOSE_STATS) {
+        console.log(build_geometry_info(r));
+    }
 
     // assign dependencies
 

package/engine/graphics/micron/build/graph/metis/metis.js

@@ -1,44 +1,11 @@
 import WorkerBuilder from "../../../../../../core/process/worker/WorkerBuilder.js";
 import { OnDemandWorkerManager } from "../../../../../../core/process/worker/OnDemandWorkerManager.js";
 
-/**
- *
- * @param {ArrayBuffer} data
- * @return {number}
- */
-function write_to_heap(data) {
-    const pointer = _create_buffer(data.byteLength);
-
-    Module.HEAP8.set(new Uint8Array(data), pointer); // write to heap
-
-    return pointer;
-}
-
-/**
- *
- * @param {Uint32Array} data
- * @return {number}
- */
-function write_to_heap_uint32(data) {
-    return write_to_heap(data.buffer);
-}
-
-/**
- *
- * @param {Float32Array} data
- * @return {number}
- */
-function write_to_heap_float32(data) {
-    return write_to_heap(data.buffer);
-}
 
 export class Metis {
     constructor() {
         const wb = new WorkerBuilder();
         wb.importScript('libs/metis/metis.js');
-        wb.importFunction("write_to_heap", write_to_heap);
-        wb.importFunction("write_to_heap_uint32", write_to_heap_uint32);
-        wb.importFunction("write_to_heap_float32", write_to_heap_float32);
         wb.addMethod('partition',
             /**
              *
@@ -74,6 +41,29 @@ export class Metis {
                     throw new Error(`Edge weight table size must be equal to and adjacency table size * n_constraints, instead #edge_weights=${edge_weights.length}, #adjacency=${adjacency.length}, n_constraints=${ncon}`);
                 }
 
+
+                /**
+                 *
+                 * @param {ArrayBuffer} data
+                 * @return {number}
+                 */
+                function write_to_heap(data) {
+                    const pointer = _create_buffer(data.byteLength);
+
+                    Module.HEAP8.set(new Uint8Array(data), pointer); // write to heap
+
+                    return pointer;
+                }
+
+                /**
+                 *
+                 * @param {Uint32Array} data
+                 * @return {number}
+                 */
+                function write_to_heap_uint32(data) {
+                    return write_to_heap(data.buffer);
+                }
+
                 /**
                  * Bind function to be called. Comes from the imported emscripten-compiled js file
                  * @type {function}