@woosh/meep-engine 2.84.9 → 2.84.10

package/editor/view/prepareMeshLibrary.js

@@ -0,0 +1,178 @@
+import { SurfacePoint3 } from "../../src/core/geom/3d/SurfacePoint3.js";
+import Vector2 from "../../src/core/geom/Vector2.js";
+import Vector3 from "../../src/core/geom/Vector3.js";
+import { obtainTerrain } from "../../src/engine/ecs/terrain/util/obtainTerrain.js";
+import { Transform } from "../../src/engine/ecs/transform/Transform.js";
+import Mesh from "../../src/engine/graphics/ecs/mesh/Mesh.js";
+import { MeshEvents } from "../../src/engine/graphics/ecs/mesh/MeshEvents.js";
+import { make_ray_from_viewport_position } from "../../src/engine/graphics/make_ray_from_viewport_position.js";
+import BottomLeftResizeHandleView from "../../src/view/elements/BottomLeftResizeHandleView.js";
+import ComponentAddAction from "../actions/concrete/ComponentAddAction.js";
+import EntityCreateAction from "../actions/concrete/EntityCreateAction.js";
+import SelectionAddAction from "../actions/concrete/SelectionAddAction.js";
+import SelectionClearAction from "../actions/concrete/SelectionClearAction.js";
+import MeshLibraryView from "./library/MeshLibraryView.js";
+
+/**
+ *
+ * @param {Editor} editor
+ */
+export function prepareMeshLibrary(editor) {
+    let resolveEngine;
+
+    const pEngine = new Promise(function (resolve, reject) {
+        resolveEngine = resolve;
+
+    });
+
+    /**
+     *
+     * @type {Promise<GraphicsEngine>}
+     */
+    const pGraphicsEngine = pEngine.then(function (e) {
+        return e.graphics;
+    });
+
+    const pRenderer = pGraphicsEngine.then(function (graphicsEngine) {
+        return graphicsEngine.renderer;
+    });
+
+    const pAssetManager = pEngine.then(e => e.assetManager);
+
+    const meshLibraryView = new MeshLibraryView(
+        editor.meshLibrary,
+        pAssetManager,
+        pRenderer
+    );
+
+    function handleDropEvent(event) {
+        event.stopPropagation();
+        event.preventDefault();
+
+        const dataText = event.dataTransfer.getData('text/json');
+        if (dataText === "") {
+            //no data
+            return;
+        }
+
+        const data = JSON.parse(dataText);
+
+        const type = data.type;
+
+        if (type !== "Mesh") {
+            //wrong type
+            return;
+        }
+
+        const url = data.url;
+
+        const engine = editor.engine;
+        const graphics = engine.graphics;
+
+        const position = new Vector2(event.clientX, event.clientY);
+
+        graphics.viewport.positionGlobalToLocal(position, position);
+
+        const normalizedPosition = new Vector2();
+
+        //compute world position for drop
+        const ray = make_ray_from_viewport_position(engine, position);
+
+        const source = ray.origin;
+        const direction = ray.direction;
+
+
+        const entityManager = engine.entityManager;
+        const ecd = entityManager.dataset;
+
+        const terrain = obtainTerrain(ecd);
+
+        const worldPosition = new Vector3();
+
+        const mesh = new Mesh();
+
+        mesh.castShadow = true;
+        mesh.receiveShadow = true;
+
+        const transform = new Transform();
+
+        const actions = editor.actions;
+        actions.mark('New Mesh Placed from Library');
+        const entityCreateAction = new EntityCreateAction();
+        actions.do(entityCreateAction);
+
+        const sp3 = new SurfacePoint3();
+
+        const hit_found = terrain.raycastFirstSync(sp3, source.x, source.y, source.z, direction.x, direction.y, direction.z);
+
+        function handleMeshSetEvent() {
+            const bb = mesh.boundingBox;
+
+            const c0 = new Vector3(bb.x0, bb.y0, bb.z0);
+            const c1 = new Vector3(bb.x1, bb.y1, bb.z1);
+
+            const diagonal = c0.distanceTo(c1);
+
+            const offset = direction.clone().multiplyScalar(diagonal);
+
+            transform.position.add(offset);
+
+            //remove listener
+            ecd.removeEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
+        }
+
+        if (hit_found) {
+            //got a terrain ray hit, set world placement position to that point
+            worldPosition.copy(sp3.position);
+        } else {
+            //set position to the source of the ray pick if there's nothing else available
+            worldPosition.copy(source);
+
+
+            //wait for mesh to load
+            ecd.addEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
+        }
+
+        transform.position.copy(worldPosition);
+
+        mesh.url = url;
+
+
+        actions.doMany([
+            new ComponentAddAction(entityCreateAction.entity, transform),
+            new ComponentAddAction(entityCreateAction.entity, mesh),
+            //automatically select newly placed object
+            new SelectionClearAction(),
+            new SelectionAddAction([entityCreateAction.entity])
+        ]);
+
+    }
+
+    function handleDragOverEvent(event) {
+        event.preventDefault();
+    }
+
+
+    meshLibraryView.on.linked.add(function () {
+        resolveEngine(editor.engine);
+
+        const viewport = editor.engine.graphics.viewport;
+
+        viewport.el.addEventListener('drop', handleDropEvent);
+        viewport.el.addEventListener('dragover', handleDragOverEvent);
+    });
+
+    meshLibraryView.on.unlinked.add(function () {
+        const viewport = editor.engine.graphics.viewport;
+
+        viewport.el.removeEventListener('drop', handleDropEvent);
+        viewport.el.removeEventListener('dragover', handleDragOverEvent);
+    });
+
+    meshLibraryView.size.set(400, 400);
+
+    const resizeHandleView = new BottomLeftResizeHandleView(meshLibraryView);
+    meshLibraryView.addChild(resizeHandleView);
+
+    return meshLibraryView;
+}

package/editor/view/v2/SplitView.js

@@ -0,0 +1,104 @@
+import { clamp01 } from "../../../src/core/math/clamp01.js";
+import { CSS_ABSOLUTE_POSITIONING } from "../../../src/view/CSS_ABSOLUTE_POSITIONING.js";
+import EmptyView from "../../../src/view/elements/EmptyView.js";
+
+export class SplitView extends EmptyView {
+    #direction = 'x';
+    #child_a = new EmptyView();
+    #child_b = new EmptyView();
+    #fraction = 0.5;
+    #round_split_to_nearest_integer = true
+
+    static from({ a, b, type = 'x', fraction = 0.5 }) {
+        const r = new SplitView();
+
+        r.direction = type;
+        r.fraction = fraction;
+        r.childA = a;
+        r.childB = b;
+
+        return r;
+    }
+
+    constructor() {
+        super();
+
+        this.addChild(this.#child_a);
+        this.addChild(this.#child_b);
+
+        this.layout();
+
+        this.bindSignal(this.size.onChanged, this.layout, this);
+        this.on.linked.add(this.layout, this);
+    }
+
+    set fraction(v) {
+        this.#fraction = v;
+        this.layout();
+    }
+
+    set direction(v) {
+        if (!['x', 'y'].includes(v)) {
+            throw new Error(`Invalid direction '${v}', valid values are 'x' and 'y'`);
+        }
+
+        this.#direction = v;
+
+        this.layout();
+    }
+
+    set childA(v) {
+        this.removeChild(this.#child_a);
+
+        this.#child_a = v;
+        this.addChild(v);
+
+        this.layout();
+    }
+
+    set childB(v) {
+        this.removeChild(this.#child_b);
+
+        this.#child_b = v;
+        this.addChild(v);
+
+        this.layout();
+    }
+
+    layout() {
+        const size = this.size;
+        const f = clamp01(this.#fraction);
+
+        this.#child_a.css(CSS_ABSOLUTE_POSITIONING);
+        this.#child_b.css(CSS_ABSOLUTE_POSITIONING);
+
+        const width = size.x;
+        const height = size.y;
+        if (this.#direction === 'x') {
+            let first = width*f;
+            if(this.#round_split_to_nearest_integer){
+                first = Math.round(first);
+            }
+            const second = width - first;
+
+            this.#child_a.size.set(first, height);
+            this.#child_b.size.set(second, height);
+
+            this.#child_a.position.set(0, 0);
+            this.#child_b.position.set(first, 0);
+        } else {
+
+            let first = height*f;
+            if(this.#round_split_to_nearest_integer){
+                first = Math.round(first);
+            }
+            const second = width - first;
+
+            this.#child_a.size.set(width, first);
+            this.#child_b.size.set(width, second);
+
+            this.#child_a.position.set(0, 0);
+            this.#child_b.position.set(0, first);
+        }
+    }
+}

package/editor/view/v2/prototypeEditor.js

@@ -0,0 +1,127 @@
+import Name from "../../../../model/game/ecs/component/Name.js";
+import { initializeEditor } from "../../../../model/game/initializeEditor.js";
+import { randomFromArray } from "../../../src/core/math/random/randomFromArray.js";
+import { randomIntegerBetween } from "../../../src/core/math/random/randomIntegerBetween.js";
+import { seededRandom } from "../../../src/core/math/random/seededRandom.js";
+import { TextureAssetLoader } from "../../../src/engine/asset/loaders/texture/TextureAssetLoader.js";
+import { EntityNode } from "../../../src/engine/ecs/parent/EntityNode.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { EngineHarness } from "../../../src/engine/EngineHarness.js";
+import { enableEditor } from "../../enableEditor.js";
+
+
+/**
+ *
+ * @param {function} rng
+ */
+function randomNode(rng = Math.random) {
+    const node = new EntityNode();
+
+
+    node.entity.add(new Transform());
+    const ENGLISH_FIRST_NAMES = [
+        "Alex", "Anthony","Adam",
+        "Barbara", "Bartholomew","Benjamin",
+        "Charles", "Christian", "Cindy", "Catherine",
+        "Duncan", "David", "Donna", "Dylan",
+        "Ethan", "Edward", "Edgar", "Elizabeth",
+        "Fletcher", "Francis", "Fae",
+        "George", "Gavin", "Gabriel", "Gideon", "Griffin", "Grace", "Gordon",
+        "Hugh", "Harry", "Hilla",
+        "Ian", "Inge", "Ivy", "Isabella",
+        "John", "Jeff", "Joanna","Jack",
+        "Kevin", "Kelsey", "Kara", "Kade", "Kenneth", "Kylie", "Kaleb", "Khloe", "Keith", "Katie",
+        "Lewis", "Liam",
+        "Mathew", "Mark", "Mona",
+        "Nickolas", "Nigel", "Natasha",
+        "Otto", "Owen", "Olivia", "Oliver", "Odette", "Ophelia", "Orion",
+        "Peter", "Paola",
+        "Raphael", "Ralf", "Robert",
+        "Steward", "Simon", "Samantha",
+        "Trevor", "Tylor", "Terry",
+        "Uwe", "Uriel", "Uma", "Ulysses",
+        "Vladimir", "Vera",
+        "Wolfgang", "William", "Wyatt", "Willow", "Wesley", "Wren",
+        "Xylo", "Xavier", "Xander",
+    ];
+
+    const ENGLISH_SURNAMES = [
+        "Angel", "Aaron", "Abbott", "Abrams", "Ainsley","Anderson","Allen",
+        "Baker", "Bank", "Black", "Bale","Brown","Bennet","Bailey",
+        "Carter", "Chandler","Cooper","Clarke","Cook",
+        "Drake", "Dalton", "Davison", "Dawson", "Day","Davis",
+        "Ellis", "Eastwood", "Erickson", "Eaton", "Ellison","Evans","Edwards",
+        "Farley", "Fisc", "Fry", "Falcon","Farmer","Fletcher",
+        "Gabin", "Green", "Gray", "Gibson", "Grant", "Gordon", "Gill","Gold","Goldring","Golding",
+        "Hall", "Harris", "Hill", "Hughes", "Harrison", "Hunt", "Holmes",
+        "Ingram", "Irwin", "Irving", "Ives",
+        "Johnson","Jones","Jackson",
+        "Kelvin","King",
+        "Lewis", "Law","Lee",
+        "Morris","Mills","Martin","Moore","Morgan","Mitchel",
+        "Phillips","Parker","Price",
+        "Robinson","Roberts","Richardson",
+        "Smith","Scott",
+        "Tailor","Taylor","Thomas","Thompson","Turner",
+        "White","Wilson","Williams","Wright","Wood","Ward","Watson",
+        "Young",
+    ];
+
+    const first_name = randomFromArray(rng, ENGLISH_FIRST_NAMES);
+    const last_name = randomFromArray(rng, ENGLISH_SURNAMES);
+
+    node.entity.add(new Name(`${first_name} ${last_name}`))
+
+    return node;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {Promise<void>}
+ */
+async function main(engine) {
+
+    await EngineHarness.buildBasics({
+        engine,
+        showFps: false
+    });
+
+
+    const random = seededRandom();
+
+    const density = 0.2;
+
+    const nodes = [];
+
+    for (let i = 0; i < 50; i++) {
+        nodes.push(randomNode(random));
+    }
+
+    while (nodes.length > 4) {
+        const child_index = randomIntegerBetween(random, 0, nodes.length - 1);
+
+        const [child] = nodes.splice(child_index, 1);
+
+        const parent = randomFromArray(random, nodes);
+
+        parent.addChild(child);
+    }
+
+    for (let i = 0; i < nodes.length; i++) {
+
+        const node = nodes[i];
+
+        node.build(engine.entityManager.dataset);
+
+    }
+
+
+    enableEditor(engine, initializeEditor).enable();
+}
+
+new EngineHarness().initialize({
+    configuration(config, engine) {
+        config.addLoader('texture', new TextureAssetLoader())
+    }
+}).then(main)

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.84.9",
+  "version": "2.84.10",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/cache/Cache.d.ts

@@ -44,4 +44,6 @@ export class Cache<K, V> {
     getOrCompute(key: K, compute: (key: K) => V, compute_context?: any): V
 
     recomputeWeight(): void
+
+    updateElementWeight(key: K): boolean
 }

package/src/core/cache/Cache.js

@@ -174,14 +174,56 @@ export 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
@@ -189,7 +231,15 @@ export class Cache {
      * @returns {number}
      */
     computeElementWeight(key, value) {
-        return this.keyWeigher(key) + this.valueWeigher(value);
+        const key_weight = this.keyWeigher(key);
+
+        assert.notNaN(key_weight, 'key_weight');
+
+        const value_weight = this.valueWeigher(value);
+
+        assert.notNaN(value_weight, 'value_weight');
+
+        return key_weight + value_weight;
     }
 
     /**
@@ -264,6 +314,9 @@ export 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
@@ -374,14 +427,11 @@ export 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;
     }
 
     /**

package/src/core/cache/Cache.spec.js

@@ -179,6 +179,44 @@ test("recomputeWeight", () => {
     expect(cache.weight).toBe(4);
 });
 
+test("updateElementWeight", () => {
+    class Record {
+        weight = 0;
+
+        constructor(v) {
+            this.weight = v;
+        }
+    }
+
+    /**
+     *
+     * @type {Cache<string, Record>}
+     */
+    const cache = new Cache({
+        valueWeigher: (v) => v.weight,
+    });
+
+    const record_a = new Record(7);
+    const record_b = new Record(11);
+
+    cache.set("a", record_a);
+    cache.set("b", record_b);
+
+    expect(cache.weight).toBe(18);
+
+    record_a.weight = 3;
+
+    cache.updateElementWeight("a");
+
+    expect(cache.weight).toBe(14);
+
+    record_b.weight = 13;
+
+    cache.updateElementWeight("b");
+
+    expect(cache.weight).toBe(16);
+});
+
 test("silentRemove should not notify", () => {
 
     const cache = new Cache();

package/src/core/cache/CacheElement.js

@@ -21,6 +21,12 @@ export class CacheElement {
          */
         this.value = null;
 
+        /**
+         *
+         * @type {number}
+         */
+        this.weight = 0;
+
         /**
          * Link to next element (implements linked list)
          * @type {CacheElement<Key,Value>|null}

package/src/core/cache/LoadingCache.js

@@ -1,6 +1,7 @@
 //
 
 import { assert } from "../assert.js";
+import { returnZero } from "../function/returnZero.js";
 import { current_time_in_seconds } from "../time/current_time_in_seconds.js";
 import { Cache } from "./Cache.js";
 
@@ -17,6 +18,7 @@ class Record {
         this.value = value;
         this.time = time;
         this.failed = false;
+        this.weight = 0;
     }
 }
 
@@ -27,6 +29,15 @@ class Record {
  */
 const DEFAULT_TIME_TO_LIVE = Infinity;
 
+/**
+ * @template T
+ * @param {Record<T>} record
+ * @returns {number}
+ */
+function record_get_value_weight(record) {
+    return record.weight;
+}
+
 /**
  * Asynchronous cache capable of resolving its own values by keys
  * Modelled on Guava's LoadingCache concept
@@ -54,6 +65,11 @@ export class LoadingCache {
      * @type {boolean}
      */
     #policyRetryFailed = true;
+    /**
+     *
+     * @type {function(V): number}
+     */
+    #value_weigher;
 
     /**
      * @see {@link Cache} for more details on what each parameter means
@@ -71,7 +87,7 @@ export class LoadingCache {
     constructor({
                     maxWeight,
                     keyWeigher,
-                    valueWeigher,
+                    valueWeigher = returnZero,
                     keyHashFunction,
                     keyEqualityFunction,
                     capacity,
@@ -85,7 +101,7 @@ export class LoadingCache {
         this.#internal = new Cache({
             maxWeight,
             keyWeigher,
-            valueWeigher,
+            valueWeigher: record_get_value_weight,
             keyHashFunction,
             keyEqualityFunction,
             capacity,
@@ -94,6 +110,7 @@ export class LoadingCache {
         this.#timeToLive = timeToLive;
         this.#load = load;
         this.#policyRetryFailed = retryFailed;
+        this.#value_weigher = valueWeigher;
     }
 
     /**
@@ -132,6 +149,12 @@ export class LoadingCache {
 
         this.#internal.put(key, record);
 
+        promise.then((value) => {
+            // re-score value based on actual data
+            record.weight = this.#value_weigher(value);
+            this.#internal.updateElementWeight(key);
+        });
+
         promise.catch(() => {
             // mark as failure
             record.failed = true;