@woosh/meep-engine 2.46.29 → 2.46.30

package/editor/view/ecs/components/GridObstacleController.js

@@ -0,0 +1,72 @@
+import ObservedValue from "../../../../src/core/model/ObservedValue.js";
+import View from "../../../../src/view/View.js";
+import { CanvasView } from "../../../../src/view/elements/CanvasView.js";
+import DatGuiController from "./DatGuiController.js";
+import convertSampler2D2Canvas from "../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { Sampler2D } from "../../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import { scaleSampler2D } from "../../../../src/engine/graphics/texture/sampler/scaleSampler2D.js";
+import Vector2 from "../../../../src/core/geom/Vector2.js";
+
+/**
+ *
+ * @param {GridObstacle} grid
+ * @param {HTMLCanvasElement} canvas
+ */
+export function buildGridObstaclePreview(grid, canvas) {
+    const source = new Sampler2D(grid.data, 1, grid.size.x, grid.size.y);
+
+    const target = Sampler2D.uint8(1, canvas.width, canvas.height);
+
+    scaleSampler2D(source, target);
+
+    convertSampler2D2Canvas(target, 255, 0, canvas);
+}
+
+export class GridObstacleController extends View {
+    constructor() {
+        super();
+
+        this.el = document.createElement('div');
+
+        this.model = new ObservedValue(null);
+
+        const self = this;
+
+        /**
+         *
+         * @param {GridObstacle} model
+         */
+        function setModel(model) {
+            self.removeAllChildren();
+
+            const vPreview = new CanvasView();
+
+            vPreview.size.set(200, 200);
+
+            buildGridObstaclePreview(model, vPreview.el);
+
+            self.addChild(vPreview);
+
+            const controller = new DatGuiController();
+
+            self.addChild(controller);
+
+            const proxy = {
+                size: new Vector2(model.size.x, model.size.y)
+            };
+
+            controller.add(proxy, 'size');
+            controller.addAction(() => {
+                buildGridObstaclePreview(model, vPreview.el);
+            }, 'update preview');
+
+            proxy.size.onChanged.add((x, y) => {
+                model.resize(x, y);
+
+                buildGridObstaclePreview(model, vPreview.el);
+            });
+        }
+
+        this.model.onChanged.add(setModel);
+    }
+}

package/editor/view/ecs/components/GridPositionController.js

@@ -0,0 +1,40 @@
+import GuiControl from "../../../../src/view/controller/controls/GuiControl.js";
+import Vector2Control from "../../../../src/view/controller/controls/Vector2Control.js";
+import LabelView from "../../../../src/view/common/LabelView.js";
+
+export class GridPositionController extends GuiControl {
+    constructor() {
+        super();
+
+        this.cPosition = new Vector2Control();
+
+
+        const self = this;
+
+        this.handlers = {
+            modelChanged: function (newModel, oldModel) {
+                if (newModel !== null) {
+                    self.cPosition.model.set(newModel);
+                }
+                if (oldModel !== null) {
+                    //do nothing really
+                }
+            }
+        };
+
+        const lPosition = new LabelView('Position');
+
+        this.addChild(lPosition);
+        this.addChild(this.cPosition);
+
+        this.bindSignal(this.model.onChanged, this.handlers.modelChanged);
+    }
+
+    link() {
+        super.link();
+
+        if (this.model.getValue() !== null) {
+            this.handlers.modelChanged(this.model.getValue(), null);
+        }
+    }
+}

package/editor/view/ecs/components/HeadsUpDisplayController.js

@@ -0,0 +1,30 @@
+import DatGuiController from "./DatGuiController.js";
+import { clear } from "../../../../src/view/controller/dat/DatGuiUtils.js";
+import { HeadsUpDisplayFlag } from "../../../../src/engine/ecs/gui/hud/HeadsUpDisplayFlag.js";
+
+export class HeadsUpDisplayController extends DatGuiController {
+    constructor() {
+        super();
+
+        const self = this;
+
+
+        /**
+         *
+         * @param {HeadsUpDisplay} model
+         */
+        function setModel(model) {
+            const gui = self.gui;
+
+            clear(gui);
+
+            if (model !== null) {
+                self.add(model, 'worldOffset');
+                self.addBitFlag(model, 'flags', HeadsUpDisplayFlag.TransformWorldOffset, 'transform offset');
+                self.addBitFlag(model, 'flags', HeadsUpDisplayFlag.PerspectiveRotation, 'perspective rotation');
+            }
+        }
+
+        this.model.onChanged.add(setModel);
+    }
+}

package/editor/view/ecs/components/HighlightController.js

@@ -0,0 +1,47 @@
+import DatGuiController from "./DatGuiController.js";
+import { NativeListController } from "../../../../src/view/controller/controls/NativeListController.js";
+import { HighlightDefinition } from "../../../../src/engine/graphics/ecs/highlight/HighlightDefinition.js";
+
+class HighlightController extends DatGuiController {
+    /**
+     *
+     * @constructor
+     */
+    constructor() {
+        super();
+
+        const self = this;
+
+
+        /**
+         *
+         * @param {Highlight} model
+         */
+        function setModel(model) {
+            self.removeAllChildren();
+
+            self.addChild(new NativeListController({
+                model: model.elements,
+                elementFactory() {
+                    return new HighlightDefinition();
+                },
+                elementViewFactory(el) {
+                    const ctrl = new DatGuiController();
+
+
+                    ctrl.addControl(el.color, 'r').name('Red').min(0).max(1).step(0.01);
+                    ctrl.addControl(el.color, 'g').name('Green').min(0).max(1).step(0.01);
+                    ctrl.addControl(el.color, 'b').name('Blue').min(0).max(1).step(0.01);
+                    ctrl.addControl(el, 'opacity').name('Alpha').min(0).max(1).step(0.01);
+
+                    return ctrl;
+                }
+            }));
+        }
+
+        this.model.onChanged.add(setModel);
+    }
+}
+
+
+export default HighlightController;

package/editor/view/ecs/components/MeshController.js

@@ -0,0 +1,125 @@
+/**
+ * Created by Alex on 16/01/2017.
+ */
+import GuiControl from '../../../../src/view/controller/controls/GuiControl.js';
+
+import MeshPreview from '../../../../src/view/elements/MeshPreview.js';
+
+import { clear } from "../../../../src/view/controller/dat/DatGuiUtils.js";
+import DatGuiController from "./DatGuiController.js";
+import EmptyView from "../../../../src/view/elements/EmptyView.js";
+import { MeshSystem } from "../../../../src/engine/graphics/ecs/mesh/MeshSystem.js";
+
+class MeshController extends GuiControl {
+    /**
+     *
+     * @param {AssetManager} assetManager
+     * @constructor
+     */
+    constructor(assetManager) {
+        super();
+
+        this.addClass("ui-mesh-controller");
+
+        this.assetManager = assetManager;
+
+        this.vPreview = null;
+
+        const self = this;
+
+        this.vDat = new DatGuiController();
+
+        const gui = this.vDat.gui;
+
+        this.vPreviewContainer = new EmptyView();
+
+        this.addChild(this.vPreviewContainer);
+
+        this.addChild(this.vDat);
+
+        function modelSet(meshNew, meshOld) {
+            if (self.vPreview !== null) {
+                self.vPreview.size.set(200, 200);
+                self.removeChild(self.vPreview);
+                self.vPreview = null;
+            }
+
+            clear(gui);
+
+            if (meshNew !== null) {
+                self.createPreview();
+
+                const proxy = {
+                    url: typeof meshNew.url === "string" ? meshNew.url : ""
+                };
+
+                gui.add(proxy, 'url').onFinishChange(function (v) {
+                    meshNew.url = v;
+
+                    self.createPreview();
+                    /**
+                     * @type {EntityManager}
+                     */
+                    const entityManager = self.entityManager;
+
+                    /**
+                     *
+                     * @type {MeshSystem}
+                     */
+                    const meshSystem = entityManager.getSystem(MeshSystem);
+
+                    /**
+                     *
+                     * @type {Mesh}
+                     */
+                    const meshComponent = self.model.getValue();
+
+                    meshComponent.mesh = null;
+
+                    meshSystem.process(self.entity, meshComponent);
+                });
+                gui.add(meshNew, 'castShadow');
+                gui.add(meshNew, 'receiveShadow');
+                gui.add(meshNew, 'opacity').min(0).max(1).step(0.0001);
+            }
+        }
+
+        this.model.onChanged.add(modelSet);
+
+    }
+
+    destroyPreview() {
+        if (this.vPreview !== null) {
+            this.vPreviewContainer.removeChild(this.vPreview);
+            this.vPreview = null;
+        }
+    }
+
+    createPreview() {
+        this.destroyPreview();
+        const mesh = this.model.get();
+        if (mesh !== null) {
+
+            let meshPreview = null;
+
+            try {
+                meshPreview = new MeshPreview({
+                    url: mesh.url,
+                    assetManager: this.assetManager
+                });
+            } catch (e) {
+                console.error(e);
+            }
+
+            this.vPreview = meshPreview;
+
+            if (this.vPreview !== null) {
+                this.vPreview.size.set(200, 200);
+                this.vPreviewContainer.addChild(this.vPreview);
+            }
+        }
+    }
+}
+
+
+export default MeshController;

package/editor/view/ecs/components/PathFollowerController.js

@@ -0,0 +1,87 @@
+import LabelView from "../../../../src/view/common/LabelView.js";
+import Vector1Control from "../../../../src/view/controller/controls/Vector1Control.js";
+import ObservedValue from "../../../../src/core/model/ObservedValue.js";
+import { LineView } from "./common/LineView.js";
+import View from "../../../../src/view/View.js";
+import { BooleanVector3Control } from "../../../../src/view/controller/controls/BooleanVector3Control.js";
+import DatGuiController from "./DatGuiController.js";
+import { PathFollowerFlags } from "../../../../src/engine/navigation/ecs/path_following/PathFollowerFlags.js";
+
+export class PathFollowerController extends View {
+    constructor() {
+        super();
+
+        const self = this;
+
+        this.el = document.createElement('div');
+        this.addClass('ui-path-follower-controller');
+
+        this.model = new ObservedValue(null);
+
+        const cRotationSpeed = new Vector1Control();
+
+        this.addChild(new LineView({
+            elements: [
+                new LabelView('rotation speed'),
+                cRotationSpeed
+            ]
+        }));
+
+        const cSpeed = new Vector1Control();
+        this.addChild(new LineView({
+            elements: [
+                new LabelView('speed'),
+                cSpeed
+            ]
+        }));
+
+        const cRotationAlignment = new BooleanVector3Control();
+
+        this.addChild(new LineView({
+            elements: [
+                new LabelView('rotation alignment'),
+                cRotationAlignment
+            ]
+        }));
+
+        const cPositionAlignment = new BooleanVector3Control();
+
+        this.addChild(new LineView({
+            elements: [
+                new LabelView('position writing'),
+                cPositionAlignment
+            ]
+        }));
+
+        let d = new DatGuiController();
+
+        this.addChild(d);
+
+
+        /**
+         *
+         * @param {PathFollower} model
+         */
+        function setModel(model) {
+
+            self.removeChild(d);
+
+            d = new DatGuiController();
+
+            self.addChild(d);
+
+            if (model !== null) {
+                cRotationSpeed.model.set(model.rotationSpeed);
+                cSpeed.model.set(model.speed);
+                cRotationAlignment.model.set(model.rotationAlignment);
+                cPositionAlignment.model.set(model.positionWriting);
+
+                d.addBitFlag(model, 'flags', PathFollowerFlags.Active, 'active');
+                d.addBitFlag(model, 'flags', PathFollowerFlags.Loop, 'loop');
+                d.addBitFlag(model, 'flags', PathFollowerFlags.Locked, 'locked');
+            }
+        }
+
+        this.model.onChanged.add(setModel);
+    }
+}

package/editor/view/ecs/components/TagController.js

@@ -0,0 +1,80 @@
+import EmptyView from "../../../../src/view/elements/EmptyView.js";
+import ButtonView from "../../../../src/view/elements/button/ButtonView.js";
+import ObservedValue from "../../../../src/core/model/ObservedValue.js";
+import View from "../../../../src/view/View.js";
+
+function makeTag({ index, values, update }) {
+    const vValue = new EmptyView({ classList: ['value'], tag: 'input' });
+    const elValue = vValue.el;
+
+    elValue.setAttribute('type', 'text');
+    elValue.value = values[index];
+
+
+    elValue.addEventListener('input', () => {
+        const v = elValue.value;
+
+        values[index] = v;
+    });
+
+    const vRemove = new ButtonView({
+        action() {
+            values.splice(index, 1);
+
+            update();
+        },
+        classList: ['remove']
+    });
+
+
+    const vTag = new EmptyView({ classList: ['tag'] });
+
+    vTag.addChild(vValue);
+    vTag.addChild(vRemove);
+
+    return vTag;
+}
+
+export class TagController extends View {
+    constructor() {
+        super();
+
+        this.el = document.createElement('div');
+        this.addClass('controller');
+        this.addClass('tag-controller');
+
+        const self = this;
+
+        function update() {
+            /**
+             *
+             * @type {Tag}
+             */
+            const model = self.model.getValue();
+
+
+            self.removeAllChildren();
+
+            if (model !== null) {
+                const values = model.values;
+
+                values.forEach((v, i) => {
+                    const vTag = makeTag({ index: i, values, update });
+                    self.addChild(vTag);
+                });
+
+                self.addChild(new ButtonView({
+                    action() {
+                        values.push("");
+                        update();
+                    },
+                    name: 'Create'
+                }));
+            }
+        }
+
+        this.model = new ObservedValue(null);
+
+        this.model.onChanged.add(update);
+    }
+}