@woosh/meep-engine 2.84.9 → 2.84.11

package/build/meep.module.js

@@ -60578,6 +60578,12 @@ class CacheElement {
          */
         this.value = null;
 
+        /**
+         *
+         * @type {number}
+         */
+        this.weight = 0;
+
         /**
          * Link to next element (implements linked list)
          * @type {CacheElement<Key,Value>|null}
@@ -60766,14 +60772,56 @@ class Cache {
     recomputeWeight() {
         let result = 0;
 
-        for (let [key, value] of this.data) {
-            result += this.keyWeigher(key);
-            result += this.valueWeigher(value);
+        for (let [key, record] of this.data) {
+
+            const weight = this.computeElementWeight(key, record.value);
+            record.weight = weight;
+
+            result += weight;
         }
 
         this.weight = result;
     }
 
+    /**
+     * Useful when working with wrapped value types, where contents can change and affect overall weight
+     * Instead of re-inserting element, we can just update weights
+     * NOTE: this method may trigger eviction
+     * @param {Key} key
+     * @returns {boolean} true when weight successfully updated, false if element was not found in cache
+     */
+    updateElementWeight(key) {
+        const record = this.data.get(key);
+
+        if (record === undefined) {
+            return false;
+        }
+
+        const old_weight = record.weight;
+
+        const new_weight = this.computeElementWeight(key, record.value);
+
+        if (new_weight === old_weight) {
+            // we're done, no change
+            return true;
+        }
+
+        record.weight = new_weight;
+
+        const delta_weight = new_weight - old_weight;
+
+        this.weight += delta_weight;
+
+        if (
+            this.weight > this.maxWeight
+            && new_weight <= this.maxWeight //make it less likely to drop entire cache
+        ) {
+            this.evictUntilWeight(this.maxWeight);
+        }
+
+        return true;
+    }
+
     /**
      * @private
      * @param {Key} key
@@ -60781,7 +60829,11 @@ class Cache {
      * @returns {number}
      */
     computeElementWeight(key, value) {
-        return this.keyWeigher(key) + this.valueWeigher(value);
+        const key_weight = this.keyWeigher(key);
+
+        const value_weight = this.valueWeigher(value);
+
+        return key_weight + value_weight;
     }
 
     /**
@@ -60854,6 +60906,9 @@ class Cache {
             //compute weight
             const elementWeight = this.computeElementWeight(key, value);
 
+            element.weight = elementWeight;
+
+
             /**
              * It's possible that element being added is larger than cache's capacity,
              * in which case entire cache will be evicted, but there still won't be enough space
@@ -60947,7 +61002,7 @@ class Cache {
      * @private
      */
     __removeElement(element) {
-        const value = element.value;
+        element.value;
 
         // remove from the queue
         if (element === this.__first) {
@@ -60962,14 +61017,11 @@ class Cache {
 
         const key = element.key;
 
-        //compute weight
-        const elementWeight = this.computeElementWeight(key, value);
-
         //remove from cache
         this.data.delete(key);
 
         //update weight
-        this.weight -= elementWeight;
+        this.weight -= element.weight;
     }
 
     /**
@@ -66275,7 +66327,14 @@ const ShadedGeometryFlags = {
     /**
      * If set to false will not render
      */
-    Visible:16
+    Visible: 16,
+
+    /**
+     * Bounds are updated whenever transforms change, we can defer this until next frame render request
+     * This lets us back updated and do less work overall
+     * TODO implement, currently it's ignored
+     */
+    DeferredBoundsUpdate: 32,
 };
 
 /**
@@ -68367,6 +68426,7 @@ function plane3_compute_ray_intersection(
         const t = -p / denom;
 
         if (t < 0) {
+            // ray starts and points behind the plane
             return false;
         }
 
@@ -68379,9 +68439,10 @@ function plane3_compute_ray_intersection(
         return true;
 
     } else {
+        // ray direction is perpendicular to the plane normal. In other words ray runs parallel to the plane
 
         if (p === 0) {
-
+            // ray origin lies on the plane
             out.set(originX, originY, originZ);
 
             return true;
@@ -73584,6 +73645,39 @@ function assetTypeByPath(url) {
     }
 }
 
+class Name extends ObservedString {
+    constructor(value = "") {
+        super(value);
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    getLocalizationKey() {
+        return `component.name.${this.getValue()}`;
+    }
+
+    /**
+     *
+     * @param {Localization} localization
+     * @returns {string}
+     */
+    getLocalizedValue(localization) {
+        return localization.getString(this.getLocalizationKey());
+    }
+
+    clone() {
+        const clone = new Name();
+
+        clone.copy(this);
+
+        return clone;
+    }
+}
+
+Name.typeName = "Name";
+
 /**
  *
  * @param {Transform} transform
@@ -73620,6 +73714,7 @@ function three_object_to_entity_composition(root) {
     transform.fromMatrix4(root.matrixWorld.elements);
 
     entity.add(transform);
+    entity.add(new Name(root.name));
 
     if (root.isMesh) {
         if (root.isSkinnedMesh) ;
@@ -79743,6 +79838,22 @@ function m3_cm_compose_transform(
  */
 const FLT_EPSILON_32 = 1.192092896E-7;
 
+/**
+ *
+ * @param {HTMLElement} domElement
+ * @param {boolean} visibility
+ */
+function setElementVisibility(domElement, visibility) {
+    const style = domElement.style;
+
+    if (!visibility) {
+        style.display = 'none';
+    } else {
+        // remove display property, this allows style re-flow whereby previous display type is assumed
+        style.removeProperty('display');
+    }
+}
+
 /**
  *
  * @param {Float32Array} m3
@@ -79776,21 +79887,6 @@ function writeCssTransformMatrix(m3, domElement) {
  */
 
 
-/**
- *
- * @param {HTMLElement} domElement
- * @param {boolean} visibility
- */
-function setElementVisibility(domElement, visibility) {
-    const style = domElement.style;
-
-    if (!visibility) {
-        style.display = 'none';
-    } else {
-        // remove display property, this allows style re-flow whereby previous display type is assumed
-        style.removeProperty('display');
-    }
-}
 
 /**
  *
@@ -79813,84 +79909,86 @@ const INITIAL_FLAGS = ViewFlags.Visible;
  * @class
  */
 class View {
-    #transform_written = new Float32Array(9);
-    #transform_current = new Float32Array(9);
 
     /**
-     * @constructor
+     * Signal bindings, these will be linked and unlinked along with the view
+     * @private
+     * @type {SignalBinding[]}
      */
-    constructor() {
-        /**
-         *
-         * @type {Element|NodeDescription|null}
-         */
-        this.el = null;
+    bindings = [];
 
-        /**
-         * Signal bindings, these will be linked and unlinked along with the view
-         * @private
-         * @type {SignalBinding[]}
-         */
-        this.bindings = [];
+    /**
+     *
+     * @type {ViewFlags|number}
+     */
+    flags = INITIAL_FLAGS;
 
-        /**
-         *
-         * @type {ViewFlags|number}
-         */
-        this.flags = INITIAL_FLAGS;
+    /**
+     * @readonly
+     * @type {Vector2}
+     */
+    position = new Vector2(0, 0);
 
-        /**
-         * @readonly
-         * @type {Vector2}
-         */
-        const position = this.position = new Vector2(0, 0);
+    /**
+     * @readonly
+     * @type {Vector1}
+     */
+    rotation = new Vector1(0);
 
-        /**
-         * @readonly
-         * @type {Vector1}
-         */
-        const rotation = this.rotation = new Vector1(0);
+    /**
+     * @readonly
+     * @type {Vector2}
+     */
+    scale = new Vector2(1, 1);
 
-        /**
-         * @readonly
-         * @type {Vector2}
-         */
-        const scale = this.scale = new Vector2(1, 1);
+    /**
+     * @readonly
+     * @type {Vector2}
+     */
+    size = new Vector2(0, 0);
 
-        /**
-         * @readonly
-         * @type {Vector2}
-         */
-        const size = this.size = new Vector2(0, 0);
+    /**
+     * Origin from which rotation and scaling is applied
+     * @readonly
+     * @type {Vector2}
+     */
+    transformOrigin = new Vector2(0.5, 0.5);
 
-        /**
-         * Origin from which rotation and scaling is applied
-         * @readonly
-         * @type {Vector2}
-         */
-        this.transformOrigin = new Vector2(0.5, 0.5);
+    on = {
+        linked: new Signal(),
+        unlinked: new Signal()
+    };
 
-        this.on = {
-            linked: new Signal(),
-            unlinked: new Signal()
-        };
+    /**
+     *
+     * @type {View[]}
+     */
+    children = [];
 
-        /**
-         *
-         * @type {View[]}
-         */
-        this.children = [];
+    /**
+     *
+     * @type {View|null}
+     */
+    parent = null;
 
+
+    #transform_written = new Float32Array(9);
+    #transform_current = new Float32Array(9);
+
+    /**
+     * @constructor
+     */
+    constructor() {
         /**
          *
-         * @type {View|null}
+         * @type {Element|NodeDescription|null}
          */
-        this.parent = null;
+        this.el = null;
 
-        position.onChanged.add(this.__updateTransform, this);
-        scale.onChanged.add(this.__updateTransform, this);
-        rotation.onChanged.add(this.__updateTransform, this);
-        size.onChanged.add(this.__setDimensions, this);
+        this.position.onChanged.add(this.__updateTransform, this);
+        this.scale.onChanged.add(this.__updateTransform, this);
+        this.rotation.onChanged.add(this.__updateTransform, this);
+        this.size.onChanged.add(this.__setDimensions, this);
 
         this.transformOrigin.onChanged.add(this.__setTransformOrigin, this);
     }

package/editor/process/symbolic/makePositionedIconDisplaySymbol.js

@@ -1,9 +1,9 @@
-import { assert } from "../../../src/core/assert.js";
 import { Sprite, SpriteMaterial } from "three";
-import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
+import { assert } from "../../../src/core/assert.js";
 import Entity from "../../../src/engine/ecs/Entity.js";
 import Renderable from "../../../src/engine/ecs/renderable/Renderable.js";
 import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
 import { synchronizeTransform } from "./synchronizeTransform.js";
 
 const SPRITE_SIZE = 0.3;
@@ -19,8 +19,6 @@ export function makePositionedIconDisplaySymbol(engine, iconURL, ComponentClass)
     assert.defined(engine, 'engine');
     assert.ok(engine.isEngine, 'engine.isEngine');
 
-    const entityManager = engine.entityManager;
-
     const assetManager = engine.assetManager;
 
     const spriteMaterial = new SpriteMaterial();