@woosh/meep-engine 2.39.13 → 2.39.16

package/editor/tools/v2/prototypeTransformControls.js

@@ -0,0 +1,79 @@
+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
+    });
+
+
+    // create something to drag
+    const ecd = engine.entityManager.dataset;
+    const cube = new EntityBuilder()
+        .add(ShadedGeometry.from(new BoxBufferGeometry(1, 1, 1), new MeshStandardMaterial({
+            color: 0xFFAAAA
+        })))
+        .add(Transform.fromJSON({
+            position: {
+                x: 10,
+                y: 0,
+                z: 10
+            }
+        }));
+
+    const cube_entity = cube
+        .build(ecd);
+
+    const camera = ecd.getAnyComponent(Camera);
+
+    const controls = new TransformControls(camera.component.object, engine.gameView.el);
+
+    controls.build(ecd);
+    controls.attach(cube_entity);
+
+    // cube.getComponentSafe(Transform).position.onChanged.add(console.log);
+    // cube.getComponentSafe(Transform).scale.onChanged.add(console.warn);
+
+
+    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) {
@@ -928,39 +927,50 @@ class Terrain {
      * @param opt
      * @param {Engine} engine
      */
-    fromJSON(opt, engine) {
+    fromJSON({
+                 resolution = 4,
+                 preview,
+                 size = 1,
+                 scale = 1,
+                 material,
+                 heights,
+                 layers,
+                 splat,
+                 overlayTileImage
+             } = {}, engine) {
         // mark as needing rebuilding
         this.clearFlag(TerrainFlags.Built);
 
-        if (opt === undefined) {
-            opt = {};
+        if (preview !== undefined) {
+            this.preview.fromJSON(preview);
         }
 
-        if (opt.preview !== undefined) {
-            this.preview.fromJSON(opt.preview);
-        }
-
-        this.resolution = opt.resolution !== undefined ? opt.resolution : 4;
+        this.resolution = resolution;
 
-        const size = this.size;
-
-        if (opt.size !== undefined) {
-            size.fromJSON(opt.size);
-        }
+        this.size.fromJSON(size);
 
-        this.gridScale = opt.scale !== undefined ? opt.scale : 2;
+        this.gridScale = scale;
         //
 
-        this.materialDesc = opt.material;
+        this.materialDesc = material;
 
-        this.samplerHeight.fromJSON(opt.heights);
-        this.layers.fromJSON(opt.layers);
-        this.splat.fromJSON(opt.splat);
-
-        if (opt.overlayTileImage !== undefined) {
+        if (heights !== undefined) {
+            this.samplerHeight.fromJSON(heights);
+        } else {
+            this.samplerHeight.data = new Float32Array(1);
+            this.samplerHeight.width = 1;
+            this.samplerHeight.height = 1;
+            this.samplerHeight.itemSize = 1;
+            this.samplerHeight.version++;
+        }
 
-            this.overlay.baseTileImage(opt.overlayTileImage);
+        this.layers.fromJSON(layers);
+        this.splat.fromJSON(splat);
 
+        if (overlayTileImage !== undefined) {
+            this.overlay.baseTileImage = overlayTileImage;
+        } else {
+            this.overlay.baseTileImage = WHITE_PIXEL_DATA_URL;
         }
 
 

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

@@ -111,6 +111,8 @@ const scaled_texture_cache = new Cache({
     }
 });
 
+const DEFAULT_RESOLUTION = 512;
+
 export class TerrainLayers {
     constructor() {
 
@@ -124,7 +126,7 @@ export class TerrainLayers {
          *
          * @type {Vector2}
          */
-        this.resolution = new Vector2(512, 512);
+        this.resolution = new Vector2(DEFAULT_RESOLUTION, DEFAULT_RESOLUTION);
 
         /**
          *
@@ -166,7 +168,7 @@ export class TerrainLayers {
         };
     }
 
-    fromJSON({ resolution, layers }) {
+    fromJSON({ resolution = DEFAULT_RESOLUTION, layers = [] } = {}) {
         this.resolution.fromJSON(resolution);
         this.layers.fromJSON(layers, TerrainLayer);
     }
@@ -232,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/terrain/ecs/splat/SplatMapping.js

@@ -59,7 +59,11 @@ export class SplatMapping {
         };
     }
 
-    fromJSON({ size, depth, data }) {
+    fromJSON({
+                 size = { x: 1, y: 1 },
+                 depth = 0,
+                 data = []
+    } = {}) {
         this.resize(size.x, size.y, depth);
         array_copy(data, 0, this.weightData, 0, data.length);
 

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