@woosh/meep-engine 2.46.29 → 2.46.31

package/editor/SelectionVisualizer.js

@@ -0,0 +1,148 @@
+import { BoxHelper, Group } from 'three';
+import Mesh from "../src/engine/graphics/ecs/mesh/Mesh.js";
+import { SignalBinding } from "../src/core/events/signal/SignalBinding.js";
+import { MeshEvents } from "../src/engine/graphics/ecs/mesh/MeshEvents.js";
+
+
+/**
+ *
+ * @param entity
+ * @param {EntityManager} entityManager
+ * @constructor
+ */
+function SelectionContainer(entity, entityManager) {
+    this.entity = entity;
+    this.entityManager = entityManager;
+
+    this.isLinked = false;
+
+    const boxHelper = new BoxHelper();
+    boxHelper.material.depthTest = true;
+    boxHelper.material.transparent = true;
+
+    this.boxHelper = boxHelper;
+
+    const self = this;
+
+    function updateMesh() {
+        const mesh = entityManager.getComponent(entity, Mesh);
+
+        if (mesh !== null && mesh !== undefined && mesh.hasMesh()) {
+            boxHelper.setFromObject(mesh.mesh);
+            boxHelper.visible = true;
+        } else {
+            boxHelper.visible = false;
+        }
+    }
+
+    function updateBox() {
+        boxHelper.update();
+    }
+
+    function animationLoop() {
+        if (!self.isLinked) {
+            return;
+        }
+        updateBox();
+        requestAnimationFrame(animationLoop);
+    }
+
+    updateMesh();
+
+    this.handlers = {
+        updateMesh,
+        animationLoop
+    };
+}
+
+SelectionContainer.prototype.link = function () {
+    this.isLinked = true;
+    this.handlers.animationLoop();
+
+    this.entityManager.addEntityEventListener(this.entity, MeshEvents.DataSet, this.handlers.updateMesh);
+};
+
+SelectionContainer.prototype.unlink = function () {
+    this.isLinked = false;
+
+    this.entityManager.removeEntityEventListener(this.entity, MeshEvents.DataSet, this.handlers.updateMesh);
+};
+
+/**
+ *
+ * @param {Editor} editor
+ * @constructor
+ */
+function SelectionVisualizer(editor) {
+    this.editor = editor;
+
+    /**
+     *
+     * @returns {EntityManager}
+     */
+    function getEM() {
+        return editor.engine.entityManager;
+    }
+
+
+    const group = this.group = new Group();
+
+    const containers = [];
+
+    function addEntity(entity) {
+        //try to get a transform
+
+        const em = getEM();
+
+        const container = new SelectionContainer(entity, em);
+        container.link();
+        containers[entity] = container;
+
+        group.add(container.boxHelper);
+    }
+
+    function removeEntity(entity) {
+        const container = containers[entity];
+        if (container === undefined) {
+            console.error(`Failed to un-select entity ${entity}, it no container was registered.`);
+            return;
+        }
+        container.unlink();
+        delete containers[entity];
+
+        group.remove(container.boxHelper);
+    }
+
+    this.handlers = {
+        addEntity,
+        removeEntity
+    };
+
+    this.bindings = [
+        new SignalBinding(editor.selection.on.added, addEntity),
+        new SignalBinding(editor.selection.on.removed, removeEntity)
+    ]
+}
+
+SelectionVisualizer.prototype.startup = function () {
+    this.editor.engine.graphics.scene.add(this.group);
+
+    this.editor.selection.forEach(this.handlers.addEntity);
+
+    this.bindings.forEach(function (b) {
+        b.link();
+    });
+};
+
+SelectionVisualizer.prototype.shutdown = function () {
+    this.editor.engine.graphics.scene.remove(this.group);
+
+
+    this.editor.selection.forEach(this.handlers.removeEntity);
+
+    this.bindings.forEach(function (b) {
+        b.unlink();
+    });
+};
+
+export { SelectionVisualizer };

package/editor/actions/concrete/ActionUpdateTexture.js

@@ -0,0 +1,21 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+export class ActionUpdateTexture extends Action {
+    /**
+     *
+     * @param {THREE.Texture} texture
+     */
+    constructor(texture) {
+        super();
+
+        this.__texture = texture;
+    }
+
+    async apply(context) {
+        this.__texture.needsUpdate = true;
+    }
+
+    async revert(context) {
+        this.__texture.needsUpdate = true;
+    }
+}

package/editor/actions/concrete/ArrayCopyAction.js

@@ -0,0 +1,39 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+import { array_copy } from "../../../src/core/collection/array/copyArray.js";
+
+export class ArrayCopyAction extends Action {
+    /**
+     * @template T
+     * @param {ArrayLike<T>|T[]|Uint8Array|Float32Array} source
+     * @param {ArrayLike<T>|T[]|Uint8Array|Float32Array} destination
+     */
+    constructor(source, destination) {
+        super();
+
+        this.__source = source;
+        this.__destination = destination;
+
+        /**
+         *
+         * @type {ArrayLike<T>|null}
+         * @private
+         */
+        this.__restore_value = null;
+    }
+
+    async apply(context) {
+
+        const CTOR = Object.getPrototypeOf(this.__destination).constructor;
+        this.__restore_value = new CTOR(this.__destination.length);
+
+        // remember old value
+        array_copy(this.__destination, 0, this.__restore_value, 0, this.__destination.length);
+
+        // copy data across
+        array_copy(this.__source, 0, this.__destination, 0, this.__source.length);
+    }
+
+    async revert(context) {
+        array_copy(this.__restore_value, 0, this.__destination, 0, this.__restore_value.length);
+    }
+}

package/editor/actions/concrete/ComponentAddAction.js

@@ -0,0 +1,47 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+class ComponentAddAction extends Action {
+    /**
+     * Created by Alex on 16/01/2017.
+     */
+    constructor(entity, component) {
+        super();
+        this.entity = entity;
+        this.component = component;
+        /**
+         *
+         * @type {EntityComponentDataset}
+         */
+        this.dataset = null;
+    }
+
+    async apply(editor) {
+        /**
+         * @type {EntityManager}
+         */
+        const em = editor.engine.entityManager;
+
+        /**
+         *
+         * @type {EntityComponentDataset}
+         */
+        const dataset = em.dataset;
+
+        this.dataset = dataset;
+
+        const clazz = this.component.constructor;
+
+        if (dataset.getComponent(this.entity, clazz)) {
+            throw new Error(`entity ${this.entity} already has a '${clazz.typeName}' component`);
+        }
+
+        dataset.addComponentToEntity(this.entity, this.component);
+    }
+
+    async revert(editor) {
+        const clazz = this.component.constructor;
+        this.dataset.removeComponentFromEntity(this.entity, clazz);
+    }
+}
+
+export default ComponentAddAction;

package/editor/actions/concrete/ComponentRemoveAction.js

@@ -0,0 +1,38 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+/**
+ * Created by Alex on 16/01/2017.
+ * TODO update
+ */
+class ComponentRemoveAction extends Action {
+    constructor(entity, componentType) {
+        super();
+
+        this.entity = entity;
+        this.componentType = componentType;
+        this.component = null;
+    }
+
+    async apply(editor) {
+        /**
+         * @type {Engine}
+         */
+        const engine = editor.engine;
+
+        const em = engine.entityManager;
+
+        /**
+         * @type {EntityComponentDataset}
+         */
+        const ecd = em.dataset;
+
+        this.component = ecd.removeComponentFromEntity(this.entity, this.componentType);
+    }
+
+    async revert(editor) {
+        const em = editor.engine.entityManager;
+        em.addComponentToEntity(this.entity, this.component);
+    }
+}
+
+export default ComponentRemoveAction;

package/editor/actions/concrete/EntityCreateAction.js

@@ -0,0 +1,47 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+class EntityCreateAction extends Action {
+    /**
+     * Created by Alex on 16/01/2017.
+     */
+    constructor() {
+        super();
+        /**
+         *
+         * @type {number|null}
+         */
+        this.entity = null;
+
+        /**
+         *
+         * @type {EntityComponentDataset}
+         */
+        this.ecd = null;
+    }
+
+    async apply(editor) {
+        if (this.ecd === null) {
+            /**
+             * @type {EntityManager}
+             */
+            const em = editor.engine.entityManager;
+
+            const ecd = em.dataset;
+
+            this.ecd = ecd;
+        }
+
+
+        if (this.entity === null) {
+            this.entity = this.ecd.createEntity();
+        } else {
+            this.ecd.createEntitySpecific(this.entity);
+        }
+    }
+
+    async revert(editor) {
+        this.ecd.removeEntity(this.entity);
+    }
+}
+
+export default EntityCreateAction;

package/editor/actions/concrete/EntityRemoveAction.js

@@ -0,0 +1,51 @@
+/**
+ * Created by Alex on 16/01/2017.
+ */
+
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+/**
+ * @extends {Action<Editor>}
+ */
+class EntityRemoveAction extends Action {
+    constructor(entity) {
+        super();
+        this.entity = entity;
+        this.components = [];
+    }
+
+    /**
+     *
+     * @param {Editor} editor
+     */
+    async apply(editor) {
+        const em = editor.engine.entityManager;
+
+        const ecd = em.dataset;
+
+        this.components = ecd.getAllComponents(this.entity);
+
+        ecd.removeEntity(this.entity);
+    }
+
+    /**
+     *
+     * @param {Editor} editor
+     */
+    async revert(editor) {
+        const em = editor.engine.entityManager;
+
+        const ecd = em.dataset;
+
+        ecd.createEntitySpecific(this.entity);
+
+        for (let i = 0; i < this.components.length; i++) {
+            const c = this.components[i];
+            if (c !== undefined) {
+                ecd.addComponentToEntityByIndex(this.entity, i, c);
+            }
+        }
+    }
+}
+
+export default EntityRemoveAction;

package/editor/actions/concrete/ModifyPatchSampler2DAction.js

@@ -0,0 +1,118 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+import { Sampler2D } from "../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+
+export class ModifyPatchSampler2DAction extends Action {
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @param {number[]} bounds
+     */
+    constructor(sampler, bounds) {
+        super();
+
+        /**
+         *
+         * @type {Sampler2D}
+         * @private
+         */
+        this.__sampler = sampler;
+
+        /**
+         *
+         * @type {number[]}
+         * @private
+         */
+        this.__bounds = bounds;
+
+        const width = this.__bounds[2] - this.__bounds[0];
+        const height = this.__bounds[3] - this.__bounds[1];
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        this.__patch_new = Sampler2D.float32(sampler.itemSize, width, height);
+
+        /**
+         *
+         * @type {Sampler2D}
+         * @private
+         */
+        this.__patch_old = Sampler2D.float32(sampler.itemSize, width, height);
+    }
+
+    get patch() {
+        return this.__patch_new;
+    }
+
+    get x() {
+        return this.__bounds[0];
+    }
+
+    get y() {
+        return this.__bounds[1];
+    }
+
+    /**
+     *
+     * @param {number} x coordinate in global space
+     * @param {number} y coordinate in global space
+     * @param {number} [channel]
+     * @returns {number} delta between original value and the new one after the change
+     */
+    computeDelta(x, y, channel = 0) {
+        const _x = x - this.x;
+
+        if (_x < 0 || _x > this.__patch_new.width - 1) {
+            return 0;
+        }
+
+        const _y = y - this.y;
+
+        if (_y < 0 || _y > this.__patch_new.height - 1) {
+            return 0;
+        }
+
+        const value_old = this.__patch_old.sampleChannelBilinear(_x, _y, channel);
+        const value_new = this.__patch_new.sampleChannelBilinear(_x, _y, channel);
+
+        return value_new - value_old;
+    }
+
+    computeByteSize() {
+        return this.__patch_new.computeByteSize() + this.__patch_old.computeByteSize() + 280;
+    }
+
+
+    async apply(context) {
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        const source = this.__sampler;
+
+        //store old data from the patch
+        const patch_old = this.__patch_old;
+
+        patch_old.copy_sameItemSize(source, this.x, this.y, 0, 0, patch_old.width, patch_old.height);
+
+        const patch_new = this.__patch_new;
+
+        //apply the patch
+        source.copy_sameItemSize(patch_new, 0, 0, this.x, this.y, patch_new.width, patch_new.height);
+    }
+
+    async revert(context) {
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        const source = this.__sampler;
+
+        const patch_old = this.__patch_old;
+
+        //apply the patch
+        source.copy_sameItemSize(patch_old, 0, 0, this.x, this.y, patch_old.width, patch_old.height);
+    }
+}

package/editor/actions/concrete/ModifyPatchSampler2DAction.spec.js

@@ -0,0 +1,30 @@
+import { ModifyPatchSampler2DAction } from "./ModifyPatchSampler2DAction.js";
+import { Sampler2D } from "../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+
+test("apply patch size 0", async () => {
+    const sampler = Sampler2D.uint8(1, 1, 1);
+    sampler.data[0] = 123;
+
+    const action = new ModifyPatchSampler2DAction(sampler, [0, 0, 0, 0]);
+
+    await action.apply();
+
+    expect([...sampler.data]).toEqual([123]);
+});
+
+test("apply patch size 1, fill entire", async () => {
+    const sampler = Sampler2D.uint8(1, 1, 1);
+    sampler.data[0] = 123;
+
+    const action = new ModifyPatchSampler2DAction(sampler, [0, 0, 1, 1]);
+
+    action.patch.data[0] = 42;
+
+    await action.apply();
+
+    expect([...sampler.data]).toEqual([42]);
+
+    await action.revert();
+
+    expect([...sampler.data]).toEqual([123]);
+});