@woosh/meep-engine 2.46.29 → 2.46.30

package/editor/process/DisableGameUIProcess.js

@@ -0,0 +1,43 @@
+import { EditorProcess } from "./EditorProcess.js";
+import GUIElementSystem from "../../src/engine/ecs/gui/GUIElementSystem.js";
+
+class DisableGameUIProcess extends EditorProcess {
+
+    constructor() {
+        super();
+
+        this.name = DisableGameUIProcess.Id;
+    }
+
+    initialize(editor) {
+        super.initialize(editor);
+    }
+
+    startup() {
+        super.startup();
+
+        const em = this.editor.engine.entityManager;
+
+        const guiElementSystem = em.getSystem(GUIElementSystem);
+
+        if (guiElementSystem !== null) {
+            guiElementSystem.view.visible = false;
+        }
+    }
+
+    shutdown() {
+        super.shutdown();
+
+        const em = this.editor.engine.entityManager;
+
+        const guiElementSystem = em.getSystem(GUIElementSystem);
+
+        if (guiElementSystem !== null) {
+            guiElementSystem.view.visible = true;
+        }
+    }
+}
+
+DisableGameUIProcess.Id = 'disable-game-user-interface';
+
+export { DisableGameUIProcess };

package/editor/process/EditorProcess.js

@@ -0,0 +1,35 @@
+import { BaseProcess } from "../../src/core/process/BaseProcess.js";
+import { assert } from "../../src/core/assert.js";
+
+
+class EditorProcess extends BaseProcess {
+
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {string}
+         */
+        this.name = "unnamed";
+        /**
+         *
+         * @type {Editor|null}
+         */
+        this.editor = null;
+    }
+
+    /**
+     *
+     * @param {Editor} editor
+     */
+    initialize(editor) {
+        assert.defined(editor,'editor');
+
+        this.editor = editor;
+
+        super.initialize();
+    }
+}
+
+export { EditorProcess };

package/editor/process/ObstacleGridDisplayProcess.js

@@ -0,0 +1,120 @@
+import { EditorProcess } from "./EditorProcess.js";
+import GridObstacle from "../../src/engine/grid/components/GridObstacle.js";
+import GridPosition from "../../src/engine/grid/components/GridPosition.js";
+import { Sampler2D } from "../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import { obtainTerrain } from "../../src/engine/ecs/terrain/util/obtainTerrain.js";
+
+class ObstacleGridDisplayProcess extends EditorProcess {
+
+    constructor() {
+        super();
+        /**
+         *
+         * @type {TerrainOverlay|null}
+         */
+        this.overlay = null;
+        this.name = ObstacleGridDisplayProcess.Id;
+    }
+
+    startup() {
+        super.startup();
+
+        const engine = this.editor.engine;
+
+        const entityManager = engine.entityManager;
+
+        const terrain = obtainTerrain(entityManager.dataset);
+
+        if (terrain === null) {
+            this.overlay = null;
+            return;
+        }
+
+        const overlay = terrain.overlay;
+        this.overlay = overlay;
+
+        overlay.push();
+
+        overlay.borderWidth.set(0.05);
+
+        this.draw();
+    }
+
+    draw() {
+        /**
+         *
+         * @type {TerrainOverlay}
+         */
+        const overlay = this.overlay;
+        if (overlay === null) {
+            //no overlay, do nothing
+            return;
+        }
+
+        //
+        const drawBuffer = Sampler2D.uint8(4, overlay.size.x, overlay.size.y);
+
+        overlay.clear();
+
+        const em = this.editor.engine.entityManager;
+
+        const color = [];
+
+        /**
+         *
+         * @param {number} x
+         * @param {number} y
+         * @param {number} value
+         */
+        function paintPoint(x, y, value) {
+            drawBuffer.read(x, y, color);
+
+            if (value === 0) {
+                if (color[3] !== 0) {
+                    return;
+                }
+                color[0] = 2;
+                color[1] = 256;
+                color[2] = 0;
+                color[3] = 13;
+            } else {
+                if (color[3] !== 0) {
+                    drawBuffer.set(x, y, [0, 0, 0, 0]);
+                }
+
+                color[0] = 0;
+                color[1] = 0;
+                color[2] = 0;
+                color[3] = 54;
+            }
+
+
+            drawBuffer.set(x, y, color);
+        }
+
+        /**
+         *
+         * @param {GridObstacle} obstacle
+         * @param {GridPosition} position
+         */
+        function visitObstacle(obstacle, position) {
+            obstacle.traverseMask(position.x, position.y, paintPoint);
+        }
+
+        em.dataset.traverseEntities([GridObstacle, GridPosition], visitObstacle);
+
+        overlay.writeData(drawBuffer.data);
+    }
+
+    shutdown() {
+        super.shutdown();
+
+        if (this.overlay !== null) {
+            this.overlay.pop();
+        }
+    }
+}
+
+ObstacleGridDisplayProcess.Id = "obstacle-grid-display";
+
+export { ObstacleGridDisplayProcess };

package/editor/process/ProcessEngine.js

@@ -0,0 +1,123 @@
+import { EditorProcess } from "./EditorProcess.js";
+import List from "../../src/core/collection/list/List.js";
+import { ProcessState } from "../../src/core/process/ProcessState.js";
+
+/**
+ *
+ * @param {Editor} editor
+ * @param {EditorProcess} process
+ */
+function tryInitialize(editor, process) {
+    if (process.__state.getValue() !== ProcessState.New) {
+        //process already initialized, ignore
+        return;
+    }
+
+    try {
+        process.initialize(editor);
+    } catch (e) {
+        console.error(`Failed to initialize process (name='${process.name}'):`, e);
+    }
+}
+
+class ProcessEngine extends EditorProcess {
+    constructor() {
+        super();
+        /**
+         * @type {List.<EditorProcess>}
+         */
+        this.processes = new List();
+
+        this.__suspendedList = new List();
+    }
+
+    startup() {
+        super.startup();
+        const editor = this.editor;
+
+        this.processes.forEach(function (proc) {
+            tryInitialize(editor, proc);
+        });
+
+        //re-start suspended processes
+        this.__suspendedList.forEach(function (process) {
+            process.startup();
+        });
+
+        this.__suspendedList.reset();
+    }
+
+    /**
+     *
+     * @param {EditorProcess} process
+     */
+    add(process) {
+        this.processes.add(process);
+
+        if (this.__state.getValue() !== ProcessState.New && this.__state.getValue() !== ProcessState.Stopped) {
+            tryInitialize(this.editor, process);
+        }
+    }
+
+    shutdown() {
+        const self = this;
+        //shutdown any running processes
+        this.processes.forEach(function (process) {
+            if (process.__state.getValue() === ProcessState.Running) {
+                process.shutdown();
+                //record process as suspended
+                self.__suspendedList.add(process);
+            }
+        });
+        super.shutdown();
+    }
+
+    /**
+     * @private
+     * @param {EditorProcess} process
+     */
+    startProcess(process) {
+        if (process.__state.getValue() !== ProcessState.Running) {
+            if (this.__state.getValue() !== ProcessState.Running) {
+                //record as suspended
+                this.__suspendedList.add(process);
+            } else {
+                process.startup();
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {string} name
+     */
+    startByName(name) {
+        const process = this.processes.find(p => p.name === name);
+
+        if (process === undefined) {
+            console.error(`No process found by name '${name}'`);
+            return;
+        }
+
+        this.startProcess(process);
+    }
+
+    /**
+     *
+     * @param {string} name
+     */
+    stopByName(name) {
+        const process = this.processes.find(p => p.name === name);
+
+        if (process === undefined) {
+            console.error(`No process found by name '${name}'`);
+            return;
+        }
+
+        if (process.__state.getValue() === ProcessState.Running) {
+            process.shutdown();
+        }
+    }
+}
+
+export { ProcessEngine };

package/editor/process/SymbolicDisplayProcess.js

@@ -0,0 +1,132 @@
+import { EditorProcess } from "./EditorProcess.js";
+import { ParticleEmitter } from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+import RenderSystem from "../../src/engine/ecs/systems/RenderSystem.js";
+import { Camera } from "../../src/engine/graphics/ecs/camera/Camera.js";
+import { Light } from "../../src/engine/graphics/ecs/light/Light.js";
+import { ComponentSymbolicDisplay } from "./symbolic/ComponentSymbolicDisplay.js";
+import { makeSocketsSymbolicDisplay } from "./symbolic/makeSocketsSymbolicDisplay.js";
+import { makeParticleEmitterSymbolicDisplay } from "./symbolic/makeParticleEmitterSymbolicDisplay.js";
+import { assert } from "../../src/core/assert.js";
+import { makeSoundEmitterSymbolicDisplay } from "./symbolic/makeSoundEmitterSymbolicDisplay.js";
+import { SoundEmitter } from "../../src/engine/sound/ecs/emitter/SoundEmitter.js";
+import { makeCameraSymbolicDisplay } from "./symbolic/makeCameraSymbolicDisplay.js";
+import { makePathSymbolicDisplay } from "./symbolic/makePathSymbolicDisplay.js";
+import { makePositionedIconDisplaySymbol } from "./symbolic/makePositionedIconDisplaySymbol.js";
+import { makeLightSymbolicDisplay } from "./symbolic/makeLightSymbolicDisplay.js";
+import { makeGridPositionSymbolDisplay } from "./symbolic/makeGridPositionSymbolDisplay.js";
+
+
+class SymbolicDisplayProcess extends EditorProcess {
+    constructor() {
+        super();
+
+        this.name = SymbolicDisplayProcess.Id;
+
+        const self = this;
+        this.requiredSystems = [{
+            klass: RenderSystem,
+            factory: function () {
+                return new RenderSystem(self.editor.engine.graphics);
+            }
+        }];
+
+        /**
+         *
+         * @type {EditorProcess[]}
+         */
+        this.displays = [];
+
+        this.spawnedSystems = [];
+    }
+
+    initialize(editor) {
+        super.initialize(editor);
+
+        const engine = editor.engine;
+
+        assert.defined(engine, 'engine');
+
+        /**
+         *
+         * @type {ComponentSymbolicDisplay[]}
+         */
+        this.displays = [
+            makePositionedIconDisplaySymbol(engine, "data/textures/icons/editor/particles.png", ParticleEmitter),
+            makePositionedIconDisplaySymbol(engine, "data/textures/icons/editor/camera.png", Camera),
+            makePositionedIconDisplaySymbol(engine, "data/textures/icons/editor/light.png", Light),
+            makePositionedIconDisplaySymbol(engine, "data/textures/icons/editor/sound.png", SoundEmitter),
+
+            makeCameraSymbolicDisplay(engine),
+            makeLightSymbolicDisplay(engine),
+            makeGridPositionSymbolDisplay(engine),
+            makePathSymbolicDisplay(engine),
+            makeSocketsSymbolicDisplay(engine),
+            makeParticleEmitterSymbolicDisplay(engine),
+            makeSoundEmitterSymbolicDisplay(engine)
+        ];
+
+        this.displays.forEach(d => d.initialize(editor));
+    }
+
+    startup() {
+        super.startup();
+
+
+        const self = this;
+
+        const entityManager = this.editor.engine.entityManager;
+
+        /**
+         *
+         * @type {EntityComponentDataset}
+         */
+        const ecd = entityManager.dataset;
+
+        this.requiredSystems.forEach(systemDescriptor => {
+
+            const foundSystem = entityManager.systems.find(system => system instanceof systemDescriptor.klass);
+
+            if (foundSystem === undefined) {
+                const system = systemDescriptor.factory();
+
+                self.spawnedSystems.push(system);
+
+                entityManager.addSystem(system);
+            }
+        });
+
+        for (let i = 0; i < this.displays.length; i++) {
+            const d = this.displays[i];
+
+            // validate observer
+            if (d instanceof ComponentSymbolicDisplay) {
+                if (!ecd.areComponentTypesRegistered(d.observer.componentTypes)) {
+                    // not compatible
+                    continue;
+                }
+            }
+
+            d.startup();
+        }
+    }
+
+    shutdown() {
+        super.shutdown();
+
+        const entityManager = this.editor.engine.entityManager;
+
+
+        this.displays.forEach(d => d.shutdown());
+
+
+        this.spawnedSystems.forEach(s => {
+            entityManager.removeSystem(s);
+        });
+
+        this.spawnedSystems = [];
+    }
+}
+
+SymbolicDisplayProcess.Id = 'symbolic-display-process';
+
+export { SymbolicDisplayProcess };

package/editor/process/symbolic/ComponentSymbolicDisplay.js

@@ -0,0 +1,34 @@
+import { EditorProcess } from "../EditorProcess.js";
+import { EntityObserver } from "../../../src/engine/ecs/EntityObserver.js";
+
+export class ComponentSymbolicDisplay extends EditorProcess {
+    constructor(components, creator, destructor) {
+        super();
+
+        /**
+         *
+         * @type {EntityObserver}
+         */
+        this.observer = new EntityObserver(components, creator, destructor);
+    }
+
+    startup() {
+        super.startup();
+
+        /**
+         *
+         * @type {EntityComponentDataset}
+         */
+        const dataset = this.editor.engine.entityManager.dataset;
+
+        dataset.addObserver(this.observer, true);
+    }
+
+    shutdown() {
+        super.shutdown();
+
+        const dataset = this.editor.engine.entityManager.dataset;
+
+        dataset.removeObserver(this.observer, true);
+    }
+}

package/editor/process/symbolic/SymbolicDisplayInternalAPI.js

@@ -0,0 +1,159 @@
+import { SignalBinding } from "../../../src/core/events/signal/SignalBinding.js";
+import Signal from "../../../src/core/events/signal/Signal.js";
+import { assert } from "../../../src/core/assert.js";
+import { seededRandom } from "../../../src/core/math/random/seededRandom.js";
+import { ProcessState } from "../../../src/core/process/ProcessState.js";
+import EditorEntity from "../../ecs/EditorEntity.js";
+import List from "../../../src/core/collection/list/List.js";
+
+export class SymbolicDisplayInternalAPI {
+    constructor() {
+        /**
+         *
+         * @type {SignalBinding[]}
+         */
+        this.bindings = [];
+
+        /**
+         *
+         * @type {Engine}
+         * @private
+         */
+        this.__engine = null;
+
+        this.__requestUpdate = new Signal();
+
+        this.random = seededRandom(42);
+
+        /**
+         *
+         * @type {List<EntityBuilder>}
+         * @private
+         */
+        this.__managed_entities = new List();
+
+        /**
+         *
+         * @type {ProcessState}
+         * @private
+         */
+        this.__state = ProcessState.New;
+
+        /**
+         *
+         * @type {EntityComponentDataset}
+         * @private
+         */
+        this.__dataset = null;
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__source_entity = -1;
+    }
+
+    /**
+     *
+     * @param {EntityBuilder} entity
+     */
+    emit(entity) {
+        assert.defined(entity, 'entity');
+        assert.equal(entity.isEntityBuilder, true, 'entity.isEntityBuilder !== true');
+
+        if (entity.getComponent(EditorEntity) === null) {
+            entity.add(new EditorEntity({ referenceEntity: this.__source_entity }));
+        }
+
+        this.__managed_entities.add(entity);
+
+        if (this.__state === ProcessState.Running) {
+            entity.build(this.__dataset);
+        }
+    }
+
+    /**
+     *
+     * @param {number} entity
+     * @param {EntityComponentDataset} ecd
+     * @param {Engine} engine
+     */
+    initialize({
+                   entity,
+                   ecd,
+                   engine
+               }) {
+        this.__engine = engine;
+        this.__dataset = ecd;
+        this.__source_entity = entity;
+
+        this.__state = ProcessState.Running;
+    }
+
+    finalize() {
+        // remove all managed entities
+        this.__managed_entities.forEach(e => e.destroy());
+
+        // clear all bindings
+        this.bindings.forEach(b => b.unlink());
+
+        // clear dataset
+        this.__dataset = null;
+
+        this.__state = ProcessState.Finalized;
+    }
+
+    /**
+     *
+     * @param {Transform} source
+     * @param {Transform} target
+     */
+    bindTransform(source, target) {
+
+        // watch source transform
+        this.bind(source.position.onChanged, target.position.set, target.position);
+        this.bind(source.rotation.onChanged, target.rotation.set, target.rotation);
+        this.bind(source.scale.onChanged, target.scale.set, target.scale);
+
+        // copy source transform
+        target.position.copy(source.position);
+        target.rotation.copy(source.rotation);
+        target.scale.copy(source.scale);
+    }
+
+    bind(signal, action, context) {
+        const binding = new SignalBinding(signal, action, context);
+        this.bindings.push(binding);
+        binding.link();
+    }
+
+    onFrame(method, thisArg) {
+        const engine = this.__engine;
+        this.bind(engine.graphics.on.visibilityConstructionEnded, method, thisArg);
+    }
+
+    unbind(signal, action, context) {
+        const bindings = this.bindings;
+
+        for (let i = 0; i < bindings.length; i++) {
+
+            const b = bindings[i];
+
+            if (b.signal === signal && b.handler === action && b.context === context) {
+                b.unlink();
+
+                bindings.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+
+    }
+
+
+    update() {
+        this.__requestUpdate.send0();
+    }
+
+}

package/editor/process/symbolic/buildThreeJSHelperEntity.js

@@ -0,0 +1,36 @@
+import EntityBuilder from "../../../src/engine/ecs/EntityBuilder.js";
+import Renderable from "../../../src/engine/ecs/components/Renderable.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import EditorEntity from "../../ecs/EditorEntity.js";
+import Script from "../../../src/engine/ecs/components/Script.js";
+
+
+/**
+ *
+ * @param {Object3D} helper
+ * @param {number} sourceEntity
+ * @return {EntityBuilder}
+ */
+export function buildThreeJSHelperEntity(helper, sourceEntity = -1) {
+    helper.frustumCulled = false;
+
+    const entityBuilder = new EntityBuilder();
+
+    const renderable = new Renderable(helper);
+    // renderable.matrixAutoUpdate = false;
+
+    entityBuilder.add(new Transform());
+    entityBuilder.add(new EditorEntity(sourceEntity));
+    entityBuilder.add(renderable);
+
+
+    if (typeof helper.update === "function") {
+        entityBuilder.add(new Script(function () {
+            helper.update();
+        }));
+    }
+
+    renderable.computeBoundsFromObject();
+
+    return entityBuilder;
+}