@woosh/meep-engine 2.46.29 → 2.46.31

package/editor/view/node-graph/NodeView.js

@@ -0,0 +1,135 @@
+import View from "../../../src/view/View.js";
+import { PortView } from "./PortView.js";
+import EmptyView from "../../../src/view/elements/EmptyView.js";
+import LabelView from "../../../src/view/common/LabelView.js";
+import { DraggableAspect } from "../../../src/engine/ui/DraggableAspect.js";
+import Vector2 from "../../../src/core/geom/Vector2.js";
+import { noop } from "../../../src/core/function/Functions.js";
+import { NodeParameterDataType } from "../../../src/core/model/node-graph/node/parameter/NodeParameterDataType.js";
+import DatGuiController from "../ecs/components/DatGuiController.js";
+import { PortDirection } from "../../../src/core/model/node-graph/node/PortDirection.js";
+
+export class NodeView extends View {
+    /**
+     *
+     * @param {NodeInstance} node
+     * @param {NodeVisualData} visual
+     * @param {NodeGraphVisualData} visualData
+     * @param {boolean} enableDrag
+     * @param {function(PortView, Port)} portCreationCallback
+     */
+    constructor({ node, visual, visualData, enableDrag = true, portCreationCallback = noop }) {
+        super();
+
+        /**
+         *
+         * @type {NodeInstance}
+         */
+        this.node = node;
+        /**
+         *
+         * @type {NodeVisualData}
+         */
+        this.visual = visual;
+
+        this.el = document.createElement('div');
+
+        this.addClass('ui-node-view');
+
+        const vPorts = new EmptyView({
+            classList: ['ports']
+        });
+
+        const nodeDescription = node.description;
+        const vName = new LabelView(nodeDescription.name, {
+            classList: ['name']
+        });
+
+        const v2_prev_position = new Vector2();
+
+        const self = this;
+
+        if (enableDrag) {
+            const draggableAspect = new DraggableAspect({
+                el: this.el,
+                dragStart(p) {
+                    v2_prev_position.copy(p);
+                },
+                drag(position, origin, delta) {
+                    const p = delta.clone();
+
+                    const scale = new Vector2(1, 1);
+
+                    self.computeGlobalScale(scale);
+
+                    p.divide(scale);
+
+                    // p.add(v2_origin);
+
+                    visual.dimensions.position.add(p);
+                }
+            });
+            this.on.linked.add(draggableAspect.start, draggableAspect);
+            this.on.unlinked.add(draggableAspect.stop, draggableAspect);
+        }
+
+        //create parameters
+
+        const vParamContainer = new EmptyView({ classList: ['parameters-container'] });
+
+        const vParams = new DatGuiController({ classList: ['parameters'] });
+        vParamContainer.addChild(vParams);
+
+        nodeDescription.parameters.forEach(param => {
+            const id = param.id;
+
+            const type = param.type;
+
+            let controller = null;
+
+            if (type === NodeParameterDataType.Number) {
+                controller = vParams.addControl({ v: node.getParameterValue(id) }, 'v');
+            } else if (type === NodeParameterDataType.String) {
+                controller = vParams.addControl({ v: node.getParameterValue(id) }, 'v');
+            } else if (type === NodeParameterDataType.Boolean) {
+                controller = vParams.addControl({ v: node.getParameterValue(id) }, 'v');
+            }
+
+            controller.name(param.name);
+            controller.onChange((v) => {
+                node.setParameterValue(id, v);
+            });
+        });
+
+
+        this.addChild(vParamContainer);
+
+        this.addChild(vName);
+
+        this.addChild(vPorts);
+
+        nodeDescription.getPorts().forEach(port => {
+
+            const portVisualData = visual.getPort(port.id);
+
+            const portView = new PortView({ port, visual: portVisualData, visualData });
+
+            portCreationCallback(portView, port);
+
+            vPorts.addChild(portView);
+
+        });
+
+        this.setClass('has-inputs', nodeDescription.getPorts().some(p => p.direction === PortDirection.In));
+        this.setClass('has-outputs', nodeDescription.getPorts().some(p => p.direction === PortDirection.Out));
+
+        this.on.linked.add(this.update, this);
+        this.bindSignal(visual.dimensions.position.onChanged, this.update, this);
+        this.bindSignal(visual.dimensions.size.onChanged, this.update, this);
+    }
+
+    update() {
+        this.position.copy(this.visual.dimensions.position);
+        this.size.copy(this.visual.dimensions.size);
+    }
+}

package/editor/view/node-graph/PortView.js

@@ -0,0 +1,69 @@
+import View from "../../../src/view/View.js";
+import { PortDirection } from "../../../src/core/model/node-graph/node/PortDirection.js";
+import { camelToKebab } from "../../../src/core/primitives/strings/StringUtils.js";
+import LabelView from "../../../src/view/common/LabelView.js";
+import EmptyView from "../../../src/view/elements/EmptyView.js";
+import { Color } from "../../../src/core/color/Color.js";
+import { objectKeyByValue } from "../../../src/core/model/object/objectKeyByValue.js";
+
+const DEFAULT_TYPE_COLOR = new Color(1, 1, 1);
+
+export class PortView extends View {
+    /**
+     *
+     * @param {Port} port
+     * @param {PortVisualData} visual
+     * @param {NodeGraphVisualData} visualData
+     */
+    constructor({ port, visual, visualData }) {
+        super();
+
+        /**
+         *
+         * @type {Port}
+         */
+        this.port = port;
+        /**
+         *
+         * @type {PortVisualData}
+         */
+        this.visual = visual;
+
+        this.el = document.createElement('div');
+
+        this.addClass('ui-port-view');
+
+        this.addClass(`direction-${objectKeyByValue(PortDirection, port.direction).toLocaleLowerCase()}`);
+
+        this.addClass(`data-type-${camelToKebab(port.dataType.name)}`);
+
+        //add port name label
+        const vName = new LabelView(port.name, {
+            classList: ['name']
+        });
+
+        this.addChild(vName);
+
+        let color = visualData.getDataColor(port.dataType.id);
+
+        if (color === undefined) {
+            console.warn(`No color for data type ${port.dataType}, using default`);
+
+            color = DEFAULT_TYPE_COLOR;
+        }
+
+        this.addChild(new EmptyView({
+            classList: ['marker'],
+            css: {
+                backgroundColor: `rgb(${color.r * 255}, ${color.g * 255}, ${color.b * 255})`
+            }
+        }));
+
+        this.on.linked.add(this.update, this);
+        this.bindSignal(visual.position.onChanged, this.update, this);
+    }
+
+    update() {
+        this.position.copy(this.visual.position);
+    }
+}

package/editor/view/process/ProcessView.js

@@ -0,0 +1,63 @@
+import View from "../../../src/view/View.js";
+import dom from "../../../src/view/DOM.js";
+
+import LabelView from '../../../src/view/common/LabelView.js';
+import { ProcessState } from "../../../src/core/process/ProcessState.js";
+
+/**
+ *
+ * @param {ProcessState} state
+ * @returns {string}
+ */
+function processState2ClassName(state) {
+    return `process-state-${state}`;
+}
+
+class ProcessView extends View {
+    /**
+     *
+     * @param {BaseProcess} process
+     * @constructor
+     */
+    constructor(process) {
+
+        super(process);
+
+        this.model = process;
+
+        const dRoot = dom('div');
+
+        dRoot.addClass('process-view');
+
+        dRoot.addClass(`editor-process-${process.name}`);
+
+        this.$el = dRoot;
+        this.el = dRoot.el;
+
+        //add process name
+        const lName = new LabelView(process.name);
+        this.addChild(lName);
+
+        this.bindSignal(process.getState().onChanged, function (newValue, oldValue) {
+            dRoot.removeClass(processState2ClassName(oldValue));
+            dRoot.addClass(processState2ClassName(newValue));
+        });
+    }
+
+    link() {
+        const $el = this.$el;
+
+        //clear status classes
+        Object.values(ProcessState).map(processState2ClassName).forEach(function (state) {
+            $el.removeClass(state);
+        });
+
+        //set active status class
+        $el.addClass(processState2ClassName(this.model.getState().getValue()));
+
+        super.link();
+    }
+}
+
+
+export default ProcessView;

package/editor/view/tools/ToolSettingsView.js

@@ -0,0 +1,143 @@
+import View from "../../../src/view/View.js";
+import { clear } from "../../../src/view/controller/dat/DatGuiUtils.js";
+import dat from 'dat.gui'
+
+class ToolSettingsView extends View {
+    constructor(tool) {
+        super(tool);
+
+        this.model = tool;
+
+        const gui = new dat.GUI({
+            autoPlace: false,
+            closed: false,
+            resizable: false
+        });
+        this.gui = gui;
+
+        this.el = gui.domElement;
+
+        this.addClass('editor-tool-settings-view');
+
+        this.build();
+    }
+
+    setTool(tool) {
+        this.model = tool;
+        this.build();
+    }
+
+    build() {
+
+        let rowCount = 0;
+
+        function isObservedValue(v) {
+            return typeof v === "object" && typeof v.onChanged === "object" && typeof v.get === "function";
+        }
+
+        function isVector1(v) {
+            return typeof v === "object" && v.constructor !== undefined && v.constructor.typeName === "Vector1";
+        }
+
+        function addProperties(folder, object) {
+            for (let propertyName in object) {
+                const propertyValue = object[propertyName];
+                if (typeof propertyValue === object) {
+                    //check for observed values
+                    if (isObservedValue(propertyValue) || isVector1(propertyValue)) {
+                        makeProperty(folder, object, propertyName);
+                    } else {
+                        makeFolder(folder, propertyValue, propertyName);
+                    }
+                } else {
+                    makeProperty(folder, object, propertyName);
+                }
+            }
+        }
+
+        function makeFolder(parentFolder, object, name) {
+            rowCount++;
+
+            const folder = parentFolder.addFolder(name);
+
+            folder.closed = false;
+
+            addProperties(folder, object);
+
+            return folder;
+        }
+
+        function wrapObservedValue(value) {
+            const op = {
+                v: null
+            };
+
+            Object.defineProperty(op, "v", {
+                get: function () {
+                    return value.get();
+                },
+                set: function (v) {
+                    return value.set(v);
+                }
+            });
+
+            return op;
+        }
+
+        function wrapVector1(value) {
+            const op = {
+                v: null
+            };
+
+            Object.defineProperty(op, "v", {
+                get: function () {
+                    return value.getValue();
+                },
+                set: function (v) {
+                    return value.set(v);
+                }
+            });
+
+            return op;
+        }
+
+        function makeProperty(parentFolder, owner, name) {
+            rowCount++;
+
+            let control;
+
+            try {
+                const propertyValue = owner[name];
+                if (isObservedValue(propertyValue)) {
+                    control = parentFolder.add(wrapObservedValue(propertyValue), "v");
+                    control.name(name);
+                } else if (isVector1(propertyValue)) {
+                    control = parentFolder.add(wrapVector1(propertyValue), "v");
+                    control.name(name);
+                } else {
+                    control = parentFolder.add(owner, name);
+                }
+            } catch (e) {
+                console.error("Failed to add option controller", name, e);
+            }
+
+            return control;
+        }
+
+        const gui = this.gui;
+
+
+        clear(gui);
+
+        const tool = this.model;
+
+        if (tool !== undefined && typeof tool.settings === "object") {
+            addProperties(gui, tool.settings);
+        }
+
+        this.size.set(gui.width, rowCount * 30 + 20);
+    }
+}
+
+
+export default ToolSettingsView;

package/editor/view/tools/ToolView.js

@@ -0,0 +1,58 @@
+/**
+ * Created by Alex on 16/01/2017.
+ */
+
+
+import View from "../../../src/view/View.js";
+import dom from "../../../src/view/DOM.js";
+
+import LabelView from '../../../src/view/common/LabelView.js';
+import ImageView from "../../../src/view/elements/image/ImageView.js";
+
+class ToolView extends View {
+    /**
+     *
+     * @param {Tool} tool
+     * @param {Editor} editor
+     * @constructor
+     */
+    constructor({ tool, editor }) {
+
+        super(tool);
+
+        const dRoot = dom('div');
+
+        dRoot.addClass('tool-view');
+
+        dRoot.addClass(`editor-tool-${tool.name}`);
+
+        this.el = dRoot.el;
+
+        //add tool name
+        const lName = new LabelView(tool.name);
+
+        const icon = new ImageView(tool.icon, { classList: ['icon'] });
+
+        icon.size.set(32, 32);
+        icon.position.set(2, 2);
+
+        this.addChild(icon);
+
+        this.addChild(lName);
+
+
+        this.on.linked.add(() => {
+            tool.updateIcon(editor);
+        });
+
+        function updateIconVisibility() {
+            icon.visible = (tool.icon.getValue() !== "");
+        }
+
+        tool.icon.onChanged.add(updateIconVisibility);
+        this.on.linked.add(updateIconVisibility);
+    }
+}
+
+
+export default ToolView;

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.46.29",
+  "version": "2.46.31",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {
@@ -27,6 +27,7 @@
   "files": [
     "build",
     "src",
+    "editor",
     "samples",
     "package.json",
     "README.md"

package/src/engine/intelligence/behavior/composite/CompositeBehavior.js

@@ -1,6 +1,9 @@
 import { Behavior } from "../Behavior.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * Abstract class
+ */
 export class CompositeBehavior extends Behavior {
     constructor() {
         super();
@@ -18,12 +21,25 @@ export class CompositeBehavior extends Behavior {
      * @param {Behavior} child
      */
     addChild(child) {
-        assert.defined(child);
-        assert.ok(child.isBehavior, 'child is not a Behavior');
+        assert.defined(child, 'child');
+        assert.notNull(child, 'child');
+        assert.equal(child.isBehavior, true, 'child is not a Behavior');
 
         this.__children.push(child);
     }
 
+    /**
+     *
+     * @param {Behavior[]} many
+     */
+    addChildren(many) {
+        const n = many.length;
+        for (let i = 0; i < n; i++) {
+            const e = many[i];
+            r.addChild(e);
+        }
+    }
+
     /**
      * NOTE: do not modify obtained value
      * @return {Behavior[]}

package/src/engine/intelligence/behavior/composite/ParallelBehavior.js

@@ -1,6 +1,7 @@
 import { CompositeBehavior } from "./CompositeBehavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { BitSet } from "../../../../core/binary/BitSet.js";
+import { assert } from "../../../../core/assert.js";
 
 /**
  *
@@ -11,6 +12,9 @@ export const ParallelBehaviorPolicy = {
     RequireAll: 1
 };
 
+/**
+ * Executes all contained behaviors in parallel
+ */
 export class ParallelBehavior extends CompositeBehavior {
     /**
      *
@@ -20,6 +24,9 @@ export class ParallelBehavior extends CompositeBehavior {
     constructor(successPolicy, failurePolicy) {
         super();
 
+        assert.enum(successPolicy, ParallelBehaviorPolicy, 'successPolicy');
+        assert.enum(failurePolicy, ParallelBehaviorPolicy, 'failurePolicy');
+
         /**
          * @private
          * @type {ParallelBehaviorPolicy}
@@ -33,6 +40,7 @@ export class ParallelBehavior extends CompositeBehavior {
         this.failurePolicy = failurePolicy;
 
         /**
+         * @readonly
          * @private
          * @type {BitSet}
          */
@@ -60,10 +68,11 @@ export class ParallelBehavior extends CompositeBehavior {
 
     /**
      *
-     * @param {ParallelBehaviorPolicy|number} v
+     * @param {ParallelBehaviorPolicy|number} policy
      */
-    setSuccessPolicy(v) {
-        this.successPolicy = v;
+    setSuccessPolicy(policy) {
+        assert.enum(policy, ParallelBehaviorPolicy, 'policy');
+        this.successPolicy = policy;
     }
 
     /**
@@ -76,10 +85,11 @@ export class ParallelBehavior extends CompositeBehavior {
 
     /**
      *
-     * @param {ParallelBehaviorPolicy|number} v
+     * @param {ParallelBehaviorPolicy|number} policy
      */
-    setFailurePolicy(v) {
-        this.failurePolicy = v;
+    setFailurePolicy(policy) {
+        assert.enum(policy, ParallelBehaviorPolicy, 'policy');
+        this.failurePolicy = policy;
     }
 
     /**
@@ -213,14 +223,16 @@ export class ParallelBehavior extends CompositeBehavior {
     /**
      *
      * @param {Behavior[]} elements
-     * @param {ParallelBehaviorPolicy} success
-     * @param {ParallelBehaviorPolicy} failure
+     * @param {ParallelBehaviorPolicy} success how should successful completion be determined?
+     * @param {ParallelBehaviorPolicy} failure how should failing completion be determined
      * @returns {ParallelBehavior}
      */
     static from(elements, success = ParallelBehaviorPolicy.RequireAll, failure = ParallelBehaviorPolicy.RequireOne) {
+        assert.isArray(elements, 'elements');
+
         const r = new ParallelBehavior(success, failure);
 
-        elements.forEach(e => r.addChild(e));
+        r.addChildren(elements);
 
         return r;
     }

package/src/engine/intelligence/behavior/composite/SequenceBehavior.js

@@ -3,6 +3,10 @@ import { CompositeBehavior } from "./CompositeBehavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * Executes all contained behaviors one after another in a sequence, next behaviour in the sequence will not be started until the previous one signal success
+ * If any of the contained behaviours fail - the whole sequence fails
+ */
 export class SequenceBehavior extends CompositeBehavior {
     constructor() {
         super();
@@ -106,7 +110,7 @@ export class SequenceBehavior extends CompositeBehavior {
     static from(list) {
         const r = new SequenceBehavior();
 
-        list.forEach(b => r.addChild(b));
+        r.addChildren(list);
 
         return r;
     }

package/src/engine/intelligence/behavior/util/DelayBehavior.js

@@ -2,12 +2,15 @@ import { Behavior } from "../Behavior.js";
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * Wait for a certain amount of time
+ */
 export class DelayBehavior extends Behavior {
     constructor() {
         super();
 
         /**
-         * Delay value
+         * Delay value in seconds
          * @type {number}
          */
         this.value = 0;
@@ -38,11 +41,13 @@ export class DelayBehavior extends Behavior {
 
     /**
      *
-     * @param {number} value
+     * @param {number} value in seconds
      * @return {DelayBehavior}
      */
     static from(value) {
-        assert.typeOf(value, 'number', 'value');
+        assert.isNumber(value,  'value');
+        assert.notNaN(value,'value');
+        assert.isFiniteNumber(value,'value');
 
         const r = new DelayBehavior();