@woosh/meep-engine 2.39.15 → 2.39.18

package/editor/tools/v2/prototypeTransformControls.js

@@ -0,0 +1,80 @@
+import { EngineHarness } from "../../../engine/EngineHarness.js";
+import EntityBuilder from "../../../engine/ecs/EntityBuilder.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { BoxBufferGeometry, MeshStandardMaterial } from "three";
+import { Transform } from "../../../engine/ecs/transform/Transform.js";
+import { ShadedGeometrySystem } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import { TransformControls } from "./TransformControls.js";
+import { Camera } from "../../../engine/graphics/ecs/camera/Camera.js";
+import { TransformAttachmentSystem } from "../../../engine/ecs/transform-attachment/TransformAttachmentSystem.js";
+import InputController from "../../../engine/input/ecs/components/InputController.js";
+import InputControllerSystem from "../../../engine/input/ecs/systems/InputControllerSystem.js";
+
+const harness = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+    EngineHarness.buildBasics({
+        engine,
+        cameraController: false
+    });
+
+
+    const ecd = engine.entityManager.dataset;
+
+    // create something to drag
+    const cube_entity = new EntityBuilder()
+        .add(ShadedGeometry.from(
+            new BoxBufferGeometry(1, 1, 1),
+            new MeshStandardMaterial({
+                color: 0xFFAAAA
+            })
+        ))
+        .add(Transform.fromJSON({
+            position: {
+                x: 10,
+                y: 0,
+                z: 10
+            }
+        }))
+        .build(ecd);
+
+    const camera = ecd.getAnyComponent(Camera);
+
+    const controls = new TransformControls(camera.component.object, engine.gameView.el);
+
+
+    controls.build(ecd); // add controls to the scene
+    controls.attach(cube_entity); // make controls target the cube
+
+    new EntityBuilder()
+        .add(new InputController([{
+            path: 'keyboard/keys/w/down',
+            listener() {
+                controls.mode = "translate"
+            }
+        }, {
+            path: 'keyboard/keys/e/down',
+            listener() {
+                controls.mode = "scale"
+            }
+        }, {
+            path: 'keyboard/keys/r/down',
+            listener() {
+                controls.mode = "rotate"
+            }
+        }]))
+        .build(ecd);
+
+}
+
+harness.initialize({
+    configuration(config, engine) {
+        config.addSystem(new ShadedGeometrySystem(engine));
+        config.addSystem(new TransformAttachmentSystem(engine));
+        config.addSystem(new InputControllerSystem(engine.devices));
+    }
+}).then(main);

package/engine/asset/AssetManager.js

@@ -14,29 +14,58 @@ import { array_remove_element } from "../../core/collection/array/array_remove_e
 import { AssetDescription } from "./AssetDescription.js";
 import { noop } from "../../core/function/Functions.js";
 
-/**
- *
- * @param {function(asset:Asset)} successCallback
- * @param {function(error:*)} failureCallback
- * @param {function(loaded:number, total:number):void} progressCallback
- * @constructor
- */
-function AssetRequest(successCallback, failureCallback, progressCallback) {
-    this.successCallback = successCallback;
-    this.failureCallback = failureCallback;
-    this.pogressCallback = progressCallback;
+class AssetRequest {
+    /**
+     *
+     * @param {function(asset:Asset)} successCallback
+     * @param {function(error:*)} failureCallback
+     * @param {function(loaded:number, total:number):void} progressCallback
+     * @constructor
+     */
+    constructor(successCallback, failureCallback, progressCallback) {
+        this.successCallback = successCallback;
+        this.failureCallback = failureCallback;
+        this.pogressCallback = progressCallback;
+    }
 }
 
-
 /**
- *
- * @param {AssetDescription} description
- * @constructor
+ * @enum {number}
  */
-function PendingAsset(description) {
-    this.description = description;
-    this.requests = [];
-    this.progress = new BoundedValue(0, 0);
+const AssetLoadState = {
+    Initial: 0,
+    Queued: 1,
+    Loading: 2,
+    Succeeded: 3,
+    Failed: 4
+};
+
+
+class PendingAsset {
+    /**
+     *
+     * @param {AssetDescription} description
+     * @constructor
+     */
+    constructor(description) {
+        this.description = description;
+        /**
+         *
+         * @type {AssetRequest[]}
+         */
+        this.requests = [];
+        /**
+         *
+         * @type {BoundedValue}
+         */
+        this.progress = new BoundedValue(0, 0);
+
+        /**
+         *
+         * @type {AssetLoadState|number}
+         */
+        this.state = AssetLoadState.Initial;
+    }
 }
 
 
@@ -232,6 +261,19 @@ export class AssetManager {
          * @param {Asset} loaded_asset
          */
         const success = async (loaded_asset) => {
+            if (pendingAsset.state === AssetLoadState.Succeeded) {
+                // incorrect state
+                console.warn(`Asset already resolved, duplicate success invocation. Ignored. AD:${assetDescription}`);
+                return;
+            }
+
+            if (pendingAsset.state === AssetLoadState.Failed) {
+                // incorrect state
+                console.error(`Asset already failed. Unexpected resolution signal. AD:${assetDescription}`);
+            }
+
+            pendingAsset.state = AssetLoadState.Succeeded;
+
             let asset = loaded_asset;
 
             // apply transform chain
@@ -256,25 +298,42 @@ export class AssetManager {
 
             //register asset
             assets.set(assetDescription, asset);
-            requests.forEach(function (request) {
+
+            // process callbacks
+            for (let i = 0; i < requests.length; i++) {
+                const request = requests[i];
                 try {
                     request.successCallback(asset);
                 } catch (e) {
                     console.error("Failed to execute asset success callback", e);
                 }
-            });
+            }
+
             //clear callbacks
             requestMap.delete(assetDescription);
         }
 
         function failure(error) {
-            requests.forEach(function (request) {
+            if (pendingAsset.state === AssetLoadState.Failed) {
+                console.warn(`Asset already failed, this is a redundant invocation. AD: ${assetDescription}`);
+                return;
+            }
+
+            if (pendingAsset.state === AssetLoadState.Succeeded) {
+                // incorrect state
+                console.error(`Asset already resolved. Unexpected failure signal. AD:${assetDescription}`);
+            }
+
+            pendingAsset.state = AssetLoadState.Failed;
+
+            for (let i = 0; i < requests.length; i++) {
+                const request = requests[i];
                 try {
                     request.failureCallback(error);
                 } catch (e) {
                     console.error("Failed to execute asset failure callback", e);
                 }
-            });
+            }
             //clear callbacks
             requestMap.delete(assetDescription);
 

package/engine/ecs/parent/EntityNode.js

@@ -219,16 +219,24 @@ export class EntityNode {
     addChild(node) {
         const added = array_push_if_unique(this.__children, node);
 
-        if (added) {
-            if (node.parent !== null) {
-                // has a parent already, detach
-                node.parent.removeChild(node);
-            }
+        if (!added) {
+            // already contain this child
+            return false;
+        }
+
+        if (node.parent !== null) {
+            // has a parent already, detach
+            node.parent.removeChild(node);
+        }
 
-            node.parent = this;
+        node.parent = this;
+
+        // live mode
+        if (this.__entity.isBuilt) {
+            // TODO attach node live
         }
 
-        return added;
+        return true;
     }
 
     /**
@@ -239,13 +247,21 @@ export class EntityNode {
     removeChild(node) {
         const removed = array_remove_first(this.__children, node);
 
-        if (removed) {
-            assert.equal(node.parent, this, 'node is a child, but parent property points to something else instead of this node');
-
-            node.parent = null;
+        if (!removed) {
+            // not present
+            return false;
         }
 
-        return removed;
+        assert.equal(node.parent, this, 'node is a child, but parent property points to something else instead of this node');
+
+        node.parent = null;
+
+
+        return true;
+    }
+
+    get isBuilt() {
+        return this.__entity.isBuilt;
     }
 
     /**
@@ -278,6 +294,7 @@ export class EntityNode {
             const parent_entity_id = parent_entity_builder.entity;
             parent_entity.entity = parent_entity_id;
 
+            assert.ok(parent.entity.hasComponent(Transform), "parent node must have a transform but doesn't. Transform is required for attachment transform hierarchy to work correctly");
 
             const attachment = this.__safe_get_attachment();
 
@@ -306,7 +323,12 @@ export class EntityNode {
     }
 
     destroy() {
-        assert.ok(this.__entity.isBuilt, 'Not built');
+        if (!this.__entity.isBuilt) {
+            // not built
+
+            //TODO check for dangling listeners
+            return;
+        }
 
         // remove listeners
         this.__transform.position.onChanged.remove(this.__transform_sync_down, this);
@@ -328,3 +350,9 @@ export class EntityNode {
         this.on.destroyed.send0();
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+EntityNode.prototype.isEntityNode = true;

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

@@ -36,6 +36,7 @@ import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalSt
 import { buildLightTexture } from "./BuildLightTexture.js";
 import { promiseSamplerHeight } from "./PromiseSamplerHeight.js";
 import { loadLegacyTerrainSplats } from "./splat/loadLegacyTerrainSplats.js";
+import { WHITE_PIXEL_DATA_URL } from "../../../graphics/WHITE_PIXEL_DATA_URL.js";
 
 let idCounter = 0;
 
@@ -350,7 +351,7 @@ class Terrain {
         overlay.tileImage.onChanged.add(this.updateTileImage, this);
     }
 
-    updateTileImage() {
+    async updateTileImage() {
         const tileImageURL = this.overlay.tileImage.getValue();
 
         const assetManager = this.__assetManager;
@@ -359,27 +360,25 @@ class Terrain {
             return;
         }
 
-        assetManager.promise(tileImageURL, GameAssetType.Texture)
-            .then((asset) => {
+        const asset = await assetManager.promise(tileImageURL, GameAssetType.Texture);
 
-                if (tileImageURL !== this.overlay.tileImage.getValue()) {
-                    //url has changed, abort
-                    return;
-                }
+        if (tileImageURL !== this.overlay.tileImage.getValue()) {
+            //url has changed, abort
+            return;
+        }
 
-                /**
-                 *
-                 * @type {Texture}
-                 */
-                const texture = asset.create();
+        /**
+         *
+         * @type {Texture}
+         */
+        const texture = asset.create();
 
-                texture.minFilter = LinearFilter;
-                texture.magFilter = LinearFilter;
+        texture.minFilter = LinearFilter;
+        texture.magFilter = LinearFilter;
 
-                texture.generateMipmaps = false;
+        texture.generateMipmaps = false;
 
-                this.material.uniforms.diffuseGridOverlaySprite.value = texture;
-            });
+        this.material.uniforms.diffuseGridOverlaySprite.value = texture;
     }
 
     update(timeDelta) {
@@ -710,7 +709,7 @@ class Terrain {
     }
 
     /**
-     *
+     * @deprecated
      * @param {AssetManager} assetManager
      */
     buildFromLegacy(assetManager) {
@@ -969,9 +968,9 @@ class Terrain {
         this.splat.fromJSON(splat);
 
         if (overlayTileImage !== undefined) {
-
-            this.overlay.baseTileImage(overlayTileImage);
-
+            this.overlay.baseTileImage = overlayTileImage;
+        } else {
+            this.overlay.baseTileImage = WHITE_PIXEL_DATA_URL;
         }
 
 

package/engine/ecs/terrain/ecs/layers/TerrainLayers.js

@@ -234,9 +234,14 @@ export class TerrainLayers {
 
             const layerIndex = i;
 
-            promise.then(() => {
-                this.writeLayerDataIntoTexture(layerIndex);
-            });
+            promise.then(
+                () => {
+                    this.writeLayerDataIntoTexture(layerIndex);
+                },
+                (reason) => {
+                    console.error(`Failed to load layer [${layerIndex}]"${layer.textureDiffuseURL}". Reason: ${reason}`);
+                }
+            );
 
             promises.push(promise);
         }

package/engine/ecs/transform/Transform.d.ts

@@ -31,4 +31,6 @@ export class Transform {
     fromMatrix4(matrix: ArrayLike<number>): void
 
     multiplyTransforms(a: Transform, b: Transform): void
+
+    makeIdentity():void
 }

package/engine/ecs/transform/Transform.js

@@ -285,6 +285,12 @@ export class Transform {
     toMatrix4(result) {
         compose_matrix4_array(result, this.position, this.rotation, this.scale);
     }
+
+    makeIdentity() {
+        this.position.copy(Vector3.zero);
+        this.rotation.copy(Quaternion.identity);
+        this.scale.copy(Vector3.one);
+    }
 }
 
 /**

package/engine/ecs/transform-attachment/TransformAttachment.js

@@ -1,4 +1,5 @@
 import { Transform } from "../transform/Transform.js";
+import { int32_to_binary_string } from "../../../core/binary/int32_to_binary_string.js";
 
 export const TransformAttachmentFlags = {
     /**
@@ -31,6 +32,18 @@ export class TransformAttachment {
         this.flags = DEFAULT_FLAGS;
     }
 
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+
+    toJSON() {
+        return {
+            transform: this.transform.toJSON(),
+            parent: this.parent,
+            flags: int32_to_binary_string(this.flags)
+        };
+    }
+
     get immediate() {
         return this.getFlag(TransformAttachmentFlags.Immediate);
     }

package/engine/ecs/transform-attachment/TransformAttachmentSystem.js

@@ -1,6 +1,13 @@
 import { System } from "../System.js";
 import { TransformAttachment, TransformAttachmentFlags } from "./TransformAttachment.js";
 import { Transform } from "../transform/Transform.js";
+import { min2 } from "../../../core/math/min2.js";
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const QUEUE_ITERATION_COUNT = 32;
 
 class UpdateContext {
     constructor() {
@@ -27,22 +34,63 @@ class UpdateContext {
          * @type {Transform|null}
          */
         this.parent_transform = null;
+
+        /**
+         *
+         * @type {EntityComponentDataset|null}
+         */
+        this.ecd = null;
+    }
+
+    toString() {
+        return `UpdateContext{ attachment:${this.attachment}, entity:${this.entity} }`;
     }
 
     update() {
         this.transform.multiplyTransforms(this.parent_transform, this.attachment.transform);
     }
 
+    /**
+     *
+     * @returns {boolean}
+     */
+    bind_parent() {
+
+        const parent_transform = this.ecd.getComponent(this.attachment.parent, Transform);
+
+        if (parent_transform === undefined) {
+            return false;
+        }
+
+        this.parent_transform = parent_transform;
+
+        return true;
+    }
+
     link() {
-        this.parent_transform.position.onChanged.add(this.update, this);
-        this.parent_transform.rotation.onChanged.add(this.update, this);
-        this.parent_transform.scale.onChanged.add(this.update, this);
+        const t_parent = this.parent_transform;
+
+        t_parent.position.onChanged.add(this.update, this);
+        t_parent.rotation.onChanged.add(this.update, this);
+        t_parent.scale.onChanged.add(this.update, this);
+
+        const t_attachment = this.attachment.transform;
+        t_attachment.position.onChanged.add(this.update,this);
+        t_attachment.rotation.onChanged.add(this.update,this);
+        t_attachment.scale.onChanged.add(this.update,this);
     }
 
     unlink() {
-        this.parent_transform.position.onChanged.remove(this.update, this);
-        this.parent_transform.rotation.onChanged.remove(this.update, this);
-        this.parent_transform.scale.onChanged.remove(this.update, this);
+        const transform = this.parent_transform;
+
+        transform.position.onChanged.remove(this.update, this);
+        transform.rotation.onChanged.remove(this.update, this);
+        transform.scale.onChanged.remove(this.update, this);
+
+        const t_attachment = this.attachment.transform;
+        t_attachment.position.onChanged.remove(this.update,this);
+        t_attachment.rotation.onChanged.remove(this.update,this);
+        t_attachment.scale.onChanged.remove(this.update,this);
     }
 }
 
@@ -58,6 +106,54 @@ export class TransformAttachmentSystem extends System {
          * @private
          */
         this.__contexts = [];
+
+        /**
+         *
+         * @type {UpdateContext[]}
+         * @private
+         */
+        this.__queue = [];
+        this.__queue_size = 0;
+        this.__queue_cursor = 0;
+    }
+
+    /**
+     *
+     * @param {UpdateContext} ctx
+     * @private
+     */
+    __finalize_link(ctx) {
+
+        ctx.link();
+
+        this.__contexts[ctx.entity] = ctx;
+
+        if ((ctx.attachment.flags & TransformAttachmentFlags.Immediate) !== 0) {
+            ctx.update();
+        }
+    }
+
+    /**
+     *
+     * @param {UpdateContext} ctx
+     * @private
+     */
+    __enqueue(ctx) {
+        this.__queue[this.__queue_size++] = ctx;
+    }
+
+    __dequeue_entity(entity) {
+        for (let i = 0; i < this.__queue_size; i++) {
+            const ctx = this.__queue[i];
+
+            if (ctx.entity === entity) {
+                this.__queue.splice(i, 1);
+                this.__queue_size--;
+                return true;
+            }
+        }
+
+        return false;
     }
 
     /**
@@ -68,22 +164,23 @@ export class TransformAttachmentSystem extends System {
      */
     link(attachment, transform, entity) {
         const ctx = new UpdateContext();
-        ctx.system = this;
 
         ctx.attachment = attachment;
         ctx.transform = transform;
         ctx.entity = entity;
 
 
-        ctx.parent_transform = this.entityManager.dataset.getComponent(attachment.parent, Transform);
+        const ecd = this.entityManager.dataset;
 
-        ctx.link();
-
-        this.__contexts[entity] = ctx;
+        ctx.ecd = ecd;
 
-        if ((attachment.flags & TransformAttachmentFlags.Immediate) !== 0) {
-            ctx.update();
+        if (ctx.bind_parent()) {
+            this.__finalize_link(ctx);
+        } else {
+            // failed to bind parent, queue up instead
+            this.__enqueue(ctx);
         }
+
     }
 
     /**
@@ -93,12 +190,37 @@ export class TransformAttachmentSystem extends System {
      * @param {number} entity
      */
     unlink(attachment, transform, entity) {
+        const ctx = this.__contexts[entity];
 
+        if (ctx !== undefined) {
 
-        const ctx = this.__contexts[entity];
+            delete this.__contexts[entity];
 
-        delete this.__contexts[entity];
+            ctx.unlink();
+
+        } else {
+            // no context found, check the queue
+            this.__dequeue_entity(entity);
+        }
 
-        ctx.unlink();
+    }
+
+    update(timeDelta) {
+        const step_count = min2(this.__queue_size, QUEUE_ITERATION_COUNT);
+        for (let i = 0; i < step_count; i++) {
+            const index = this.__queue_cursor % this.__queue_size;
+
+            const ctx = this.__queue[index];
+
+            if (ctx.bind_parent()) {
+                this.__finalize_link(ctx);
+
+                this.__queue.splice(index, 1);
+                this.__queue_size--;
+
+            } else {
+                this.__queue_cursor++;
+            }
+        }
     }
 }