@woosh/meep-engine 2.36.30 → 2.37.2

package/core/process/undo/Action.d.ts

@@ -1,9 +1,9 @@
 export class Action<CTX> {
     computeByteSize(): number
 
-    apply(context: CTX): void
+    apply(context: CTX): Promise<void>
 
-    revert(context: CTX): void
+    revert(context: CTX): Promise<void>
 
     get isAction(): boolean
 }

package/core/process/undo/Action.js

@@ -21,16 +21,16 @@ export class Action {
      * Apply action
      * @param {CTX} context
      */
-    apply(context) {
-
+    async apply(context) {
+        throw new Error('Not Implemented. Needs to be overridden in subclass');
     }
 
     /**
      * Revert action, restoring state to just before this action was applied
      * @param {CTX} context
      */
-    revert(context) {
-
+    async revert(context) {
+        throw new Error('Not Implemented. Needs to be overridden in subclass');
     }
 }
 

package/core/process/undo/ActionGroup.js

@@ -41,24 +41,24 @@ export class ActionGroup extends Action {
         return result;
     }
 
-    apply(context) {
+    async apply(context) {
         const members = this.members;
         const n = members.length;
         for (let i = 0; i < n; i++) {
             const action = members[i];
 
-            action.apply(context);
+            await action.apply(context);
         }
     }
 
-    revert(context) {
+    async revert(context) {
         const members = this.members;
         const n = members.length;
 
         for (let i = n - 1; i >= 0; i--) {
             const action = members[i];
 
-            action.revert(context);
+           await action.revert(context);
         }
     }
 }

package/core/process/undo/ActionProcessor.d.ts

@@ -8,20 +8,20 @@ export class ActionProcessor<CTX, MD> {
 
     getMarkCount(): number
 
-    getMarkDescription(index: number): MD
+    getMarkDescription(index: number): Readonly<MD>
 
     readonly onMarkAdded: Signal<MD>
     readonly onMarkRemoved: Signal<MD>
 
-    undo(): void
+    undo(): Promise<void>
 
-    redo(): void
+    redo(): Promise<void>
 
-    navigateTo(mark: MD): boolean
+    navigateTo(mark: MD): Promise<boolean>
 
-    doMany(actions: Action<CTX>[]): void
+    doMany(actions: Action<CTX>[]): Promise<void>
 
-    do(action: Action<CTX>): this
+    do(action: Action<CTX>): Promise<void>
 
     clear(): void
 }

package/core/process/undo/ActionProcessor.js

@@ -26,11 +26,13 @@ export class ActionProcessor {
          * @type {List<Action>}
          */
         this.history = new List();
+
         /**
          *
          * @type {C}
          */
         this.context = context;
+
         /**
          *
          * @type {Array<Mark<M>>}
@@ -53,6 +55,7 @@ export class ActionProcessor {
          * @type {number}
          */
         this.historyMarkLimit = 10000;
+
         /**
          * Maximum amount of memory allowed for the history
          * @type {number}
@@ -64,11 +67,19 @@ export class ActionProcessor {
          * @type {Signal<M> | Signal}
          */
         this.onMarkAdded = new Signal();
+
         /**
          *
          * @type {Signal<M> | Signal}
          */
         this.onMarkRemoved = new Signal();
+
+        /**
+         *
+         * @type {Promise<never>}
+         * @private
+         */
+        this.__last_promise = Promise.resolve();
     }
 
     /**
@@ -153,7 +164,9 @@ export class ActionProcessor {
      * Insert a mark into the timeline, all actions between marks are grouped logically for UNDO and REDO mechanism
      * @param {D} description
      */
-    mark(description) {
+    async mark(description) {
+        await this.__barrier();
+
         const marks = this.marks;
         const numMarks = marks.length;
 
@@ -241,7 +254,25 @@ export class ActionProcessor {
      * @returns {boolean} true on success, false otherwise (e.g. mark not found)
      * @throws {Error} when mark is non-unique
      */
-    navigateTo(mark_descriptor) {
+    async navigateTo(mark_descriptor) {
+        await this.__barrier();
+
+        const p = this.__unsafe_navigateTo(mark_descriptor);
+
+        this.__last_promise = p;
+
+        return await p;
+    }
+
+    /**
+     * Navigate to a specific mark back or forward
+     * @param {M} mark_descriptor specific mark description
+     * @returns {boolean} true on success, false otherwise (e.g. mark not found)
+     * @throws {Error} when mark is non-unique
+     * @private
+     */
+    async __unsafe_navigateTo(mark_descriptor) {
+
         // find all matching marks
         const matching_marks = this.__find_mark_indices_by_description(mark_descriptor);
 
@@ -270,7 +301,7 @@ export class ActionProcessor {
 
             while (target > this.cursor) {
                 // navigate forward
-                this.redo();
+                await this.__unsafe_redo();
 
                 if (temp_cursor === this.cursor) {
                     // no cursor change
@@ -284,7 +315,7 @@ export class ActionProcessor {
 
             while (target < this.cursor) {
                 // navigate backwards
-                this.undo();
+                await this.__unsafe_undo();
 
                 if (temp_cursor === this.cursor) {
                     // no cursor change
@@ -299,7 +330,22 @@ export class ActionProcessor {
         return true;
     }
 
-    undo() {
+    async undo() {
+        await this.__barrier();
+
+        const p = this.__unsafe_undo();
+
+        this.__last_promise = p;
+
+        await p;
+    }
+
+    /**
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    async __unsafe_undo() {
         let markAddress = 0;
         /**
          *
@@ -327,7 +373,8 @@ export class ActionProcessor {
         while (this.cursor > markAddress && this.cursor > 0) {
             this.cursor--;
             const action = this.history.get(this.cursor);
-            action.revert(this.context);
+
+            await action.revert(this.context);
         }
 
         if (mark !== null) {
@@ -338,9 +385,24 @@ export class ActionProcessor {
     /**
      * redo previous sequence of actions on the timeline, up to the next mark
      */
-    redo() {
+    async redo() {
+        await this.__barrier();
+
+        const p = this.__unsafe_redo();
 
+        this.__last_promise = p;
+
+        await p;
+    }
+
+    /**
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    async __unsafe_redo() {
         let mark = this.history.length;
+
         //find mark
         const marks = this.marks;
 
@@ -358,7 +420,7 @@ export class ActionProcessor {
         while (this.cursor < mark) {
             const action = this.history.get(this.cursor);
 
-            action.apply(this.context);
+            await action.apply(this.context);
 
             this.historyMemoryUsage += action.computeByteSize();
 
@@ -370,37 +432,77 @@ export class ActionProcessor {
      *
      * @param {Action[]} actions
      */
-    doMany(actions) {
-        const n = actions.length;
+    async doMany(actions) {
+        await this.__barrier();
 
-        for (let i = 0; i < n; i++) {
+        const p = new Promise(async (resolve, reject) => {
 
-            const action = actions[i];
+            const n = actions.length;
 
-            this.do(action);
+            for (let i = 0; i < n; i++) {
 
-        }
+                const action = actions[i];
+
+                await this.__unsafe_do(action);
+
+            }
+
+            resolve();
+        });
+
+        this.__last_promise = p;
+
+        await p;
     }
 
     /**
      * Execute a given action and add it to the timeline
      * @param {Action} action
-     * @returns {ActionProcessor} this instance, useful for call chaining
      */
-    do(action) {
-        action.apply(this.context);
+    async do(action) {
+        await this.__barrier();
+
+        const p = this.__unsafe_do(action);
+
+        this.__last_promise = p;
+
+        await p;
+    }
+
+    /**
+     *
+     * @param {Action} action
+     * @returns {Promise<void>}
+     * @private
+     */
+    async __unsafe_do(action) {
+        await action.apply(this.context);
 
         this.historyMemoryUsage += action.computeByteSize();
 
+        const history = this.history;
+
         //doing action invalidates "future" branch of history, we need to clear all actions beyond cursor
-        if (this.cursor < this.history.length) {
-            this.history.crop(0, this.cursor);
+        if (this.cursor < history.length) {
+            history.crop(0, this.cursor);
             // TODO clear future marks
         }
 
-        this.history.add(action);
+        history.add(action);
+
         this.cursor++;
+    }
 
-        return this;
+    /**
+     * Await for synchronization barrier
+     * @returns {Promise<void>}
+     * @private
+     */
+    async __barrier() {
+        try {
+            await this.__last_promise;
+        } catch (e) {
+            // ignore
+        }
     }
 }

package/core/process/undo/ActionProcessor.spec.js

@@ -8,52 +8,57 @@ class DummyContext {
 }
 
 class DummyAction extends Action {
-    apply(context) {
+    async apply(context) {
         // do nothing
         context.value++;
     }
 
-    revert(context) {
+    async revert(context) {
         context.value--;
     }
 }
 
-test('navigateTo backwards', () => {
+test('navigateTo backwards', async () => {
     const ctx = new DummyContext();
     const ap = new ActionProcessor(ctx);
 
     ap.mark('a');
-    ap.do(new DummyAction());
+    await ap.do(new DummyAction());
     ap.mark('b');
-    ap.do(new DummyAction());
+    await ap.do(new DummyAction());
 
-    expect(ap.navigateTo('a')).toBe(true);
+    const nav_result = await ap.navigateTo('a');
+
+    expect(nav_result).toBe(true);
 
     expect(ctx.value).toBe(1);
 });
 
-test('navigateTo forward', () => {
+test('navigateTo forward', async () => {
     const ctx = new DummyContext();
     const ap = new ActionProcessor(ctx);
 
     ap.mark('a');
-    ap.do(new DummyAction());
+    await ap.do(new DummyAction());
     ap.mark('b');
-    ap.do(new DummyAction());
+    await ap.do(new DummyAction());
     ap.mark('c');
 
-    ap.undo();
-    ap.undo();
-    ap.undo();
+    await ap.undo();
+    await ap.undo();
+    await ap.undo();
+
+    const nav_result = await ap.navigateTo('c');
 
-    expect(ap.navigateTo('c')).toBe(true);
+    expect(nav_result).toBe(true);
 
     expect(ctx.value).toBe(2);
 });
 
-test('navigateTo non-existent on empty', () => {
+test('navigateTo non-existent on empty', async () => {
     const ctx = new DummyContext();
     const ap = new ActionProcessor(ctx);
 
-    expect(ap.navigateTo('a')).toBe(false);
+    const nav_result = await ap.navigateTo('a');
+    expect(nav_result).toBe(false);
 });

package/editor/actions/concrete/ComponentAddAction.js

@@ -15,7 +15,7 @@ class ComponentAddAction extends Action {
         this.dataset = null;
     }
 
-    apply(editor) {
+    async apply(editor) {
         /**
          * @type {EntityManager}
          */
@@ -38,7 +38,7 @@ class ComponentAddAction extends Action {
         dataset.addComponentToEntity(this.entity, this.component);
     }
 
-    revert(editor) {
+    async revert(editor) {
         const clazz = this.component.constructor;
         this.dataset.removeComponentFromEntity(this.entity, clazz);
     }

package/editor/actions/concrete/ComponentRemoveAction.js

@@ -13,7 +13,7 @@ class ComponentRemoveAction extends Action {
         this.component = null;
     }
 
-    apply(editor) {
+    async apply(editor) {
         /**
          * @type {Engine}
          */
@@ -29,7 +29,7 @@ class ComponentRemoveAction extends Action {
         this.component = ecd.removeComponentFromEntity(this.entity, this.componentType);
     }
 
-    revert(editor) {
+    async revert(editor) {
         const em = editor.engine.entityManager;
         em.addComponentToEntity(this.entity, this.component);
     }

package/editor/actions/concrete/EntityCreateAction.js

@@ -19,7 +19,7 @@ class EntityCreateAction extends Action {
         this.ecd = null;
     }
 
-    apply(editor) {
+    async apply(editor) {
         if (this.ecd === null) {
             /**
              * @type {EntityManager}
@@ -39,7 +39,7 @@ class EntityCreateAction extends Action {
         }
     }
 
-    revert(editor) {
+    async revert(editor) {
         this.ecd.removeEntity(this.entity);
     }
 }

package/editor/actions/concrete/EntityRemoveAction.js

@@ -18,7 +18,7 @@ class EntityRemoveAction extends Action {
      *
      * @param {Editor} editor
      */
-    apply(editor) {
+    async apply(editor) {
         const em = editor.engine.entityManager;
 
         const ecd = em.dataset;
@@ -32,7 +32,7 @@ class EntityRemoveAction extends Action {
      *
      * @param {Editor} editor
      */
-    revert(editor) {
+    async revert(editor) {
         const em = editor.engine.entityManager;
 
         const ecd = em.dataset;

package/editor/actions/concrete/PaintTerrainOverlayAction.js

@@ -22,7 +22,7 @@ class PaintTerrainOverlayAction extends Action {
         this.oldColor = new Vector4();
     }
 
-    apply(editor) {
+    async apply(editor) {
         const terrain = obtainTerrain(editor.engine.entityManager.dataset);
         const overlay = this.overlay = terrain.overlay;
 
@@ -33,7 +33,7 @@ class PaintTerrainOverlayAction extends Action {
         overlay.paintPoint(this.x, this.y, this.color);
     }
 
-    revert(editor) {
+    async revert(editor) {
         const overlay = this.overlay;
 
         overlay.clearPoint(this.x, this.y);

package/editor/actions/concrete/PatchTerrainHeightAction.js

@@ -109,7 +109,7 @@ export class PatchTerrainHeightAction extends Action {
         terrain.heightTexture.needsUpdate = true;
     }
 
-    apply(context) {
+    async apply(context) {
 
         /**
          *
@@ -135,7 +135,7 @@ export class PatchTerrainHeightAction extends Action {
         this.updateTerrain();
     }
 
-    revert(context) {
+    async revert(context) {
 
         /**
          *

package/editor/actions/concrete/PatchTerrainTextureAction.js

@@ -99,7 +99,7 @@ export class PatchTerrainTextureAction extends Action {
 
     }
 
-    apply(context) {
+    async apply(context) {
         /**
          *
          * @type {Terrain}
@@ -126,7 +126,7 @@ export class PatchTerrainTextureAction extends Action {
         this.updateTerrain();
     }
 
-    revert(context) {
+    async revert(context) {
         /**
          *
          * @type {Terrain}

package/editor/actions/concrete/SelectionAddAction.js

@@ -20,7 +20,7 @@ class SelectionAddAction extends Action {
         this.entities = entities;
     }
 
-    apply(editor) {
+    async apply(editor) {
         this.oldState = editor.selection.clone();
 
         const selection = editor.selection;
@@ -28,7 +28,7 @@ class SelectionAddAction extends Action {
         selection.addAllUnique(this.entities);
     }
 
-    revert(editor) {
+    async revert(editor) {
         editor.selection.copy(this.oldState);
     }
 }

package/editor/actions/concrete/SelectionClearAction.js

@@ -9,12 +9,12 @@ class SelectionClearAction extends Action {
         this.oldState = null;
     }
 
-    apply(editor) {
+    async apply(editor) {
         this.oldState = editor.selection.clone();
         editor.selection.reset();
     }
 
-    revert(editor) {
+    async revert(editor) {
         editor.selection.copy(this.oldState);
     }
 }

package/editor/actions/concrete/SelectionRemoveAction.js

@@ -10,7 +10,7 @@ class SelectionRemoveAction extends Action {
         this.entities = entities;
     }
 
-    apply(editor) {
+    async apply(editor) {
         const selection = editor.selection;
         this.oldState = selection.clone();
         for (let i = 0; i < this.entities.length; i++) {
@@ -22,7 +22,7 @@ class SelectionRemoveAction extends Action {
         }
     }
 
-    revert(editor) {
+    async revert(editor) {
         editor.selection.copy(this.oldState);
     }
 }

package/editor/actions/concrete/TransformModifyAction.js

@@ -24,7 +24,7 @@ class TransformModifyAction extends Action {
      *
      * @param {Editor} editor
      */
-    apply(editor) {
+    async apply(editor) {
         const entityManager = editor.engine.entityManager;
 
         const component = entityManager.getComponent(this.entity, Transform);
@@ -34,7 +34,7 @@ class TransformModifyAction extends Action {
         component.copy(this.modified);
     }
 
-    revert(editor) {
+    async revert(editor) {
         const entityManager = editor.engine.entityManager;
 
         const component = entityManager.getComponent(this.entity, Transform);

package/editor/actions/concrete/WriteGridValueAction.js

@@ -15,7 +15,7 @@ class WriteGridValueAction extends Action {
         this.oldValue = null;
     }
 
-    apply(editor) {
+    async apply(editor) {
         const obstacle = editor.engine.entityManager.getComponent(this.entity, GridObstacle);
         this.obstacle = obstacle;
 
@@ -26,7 +26,7 @@ class WriteGridValueAction extends Action {
         gridField.pointSet(this.x, this.y, this.value);
     }
 
-    revert(editor) {
+    async revert(editor) {
         const gridField = obstacle2grid(this.obstacle);
 
         gridField.pointSet(this.x, this.y, this.oldValue);

package/editor/view/EditorView.js

@@ -199,9 +199,10 @@ function prepareMeshLibrary(editor) {
 
         const transform = new Transform();
 
-        editor.actions.mark('New Mesh Placed from Library');
+        const actions = editor.actions;
+        actions.mark('New Mesh Placed from Library');
         const entityCreateAction = new EntityCreateAction();
-        editor.actions.do(entityCreateAction);
+        actions.do(entityCreateAction);
 
         terrain.raycast(source, direction, function (hit, normal, geometry) {
             function handleMeshSetEvent() {
@@ -217,7 +218,7 @@ function prepareMeshLibrary(editor) {
                 transform.position.add(offset);
 
                 //remove listener
-                entityManager.removeEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
+                ecd.removeEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
             }
 
             if (hit !== null) {
@@ -229,7 +230,7 @@ function prepareMeshLibrary(editor) {
 
 
                 //wait for mesh to load
-                entityManager.addEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
+                ecd.addEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
             }
         }, noop);
 
@@ -238,12 +239,13 @@ function prepareMeshLibrary(editor) {
         mesh.url = url;
 
 
-        editor.actions
-            .do(new ComponentAddAction(entityCreateAction.entity, transform))
-            .do(new ComponentAddAction(entityCreateAction.entity, mesh))
+        actions.doMany([
+            new ComponentAddAction(entityCreateAction.entity, transform),
+            new ComponentAddAction(entityCreateAction.entity, mesh),
             //automatically select newly placed object
-            .do(new SelectionClearAction())
-            .do(new SelectionAddAction([entityCreateAction.entity]));
+            new SelectionClearAction(),
+            new SelectionAddAction([entityCreateAction.entity])
+        ]);
 
     }
 

package/engine/graphics/ecs/mesh-v2/three_object_to_entity_composition.js

@@ -15,7 +15,8 @@ export function three_object_to_entity_composition(root) {
     // copy object transform
     node_transform.position.copy(root.position);
     node_transform.scale.copy(root.scale);
-    node_transform.rotation.copy(root.quaternion);
+    const euler = root.rotation;
+    node_transform.rotation.fromEulerAngles(euler.x, euler.y, euler.z);
 
     const entity = node.entity;
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.36.30",
+  "version": "2.37.2",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",