@woosh/meep-engine 2.37.16 → 2.37.19

package/editor/ecs/component/editors/NumericIntervalEditor.js

@@ -0,0 +1,86 @@
+import { TypeEditor } from "../TypeEditor.js";
+import EmptyView from "../../../../view/elements/EmptyView.js";
+import { NumberController } from "../../../view/ecs/components/common/NumberController.js";
+import LabelView from "../../../../view/common/LabelView.js";
+
+export class NumericIntervalEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        /**
+         * @type {NumericInterval}
+         */
+        const interval = field.adapter?.read(parent, field.name);
+
+        const r = new EmptyView({
+            classList: ["inline-field-row-editor"]
+        });
+
+        const c_0 = new NumberController({ value: interval.min });
+        const c_1 = new NumberController({ value: interval.max });
+
+
+        r.addChild(new LabelView("min"))
+        r.addChild(c_0);
+        r.addChild(new LabelView("max"))
+        r.addChild(c_1);
+
+        let lock = false;
+
+        const sync_up = () => {
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            c_0.value.set(interval.min);
+            c_1.value.set(interval.max);
+
+            lock = false;
+        };
+
+        const sync_down = () => {
+
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            const v0 = c_0.value.getValue();
+            const v1 = c_1.value.getValue();
+
+            if (v0 <= v1) {
+
+                interval.set(
+                    v0,
+                    v1,
+                );
+            }
+
+            lock = false;
+        };
+
+        r.on.linked.add(sync_up);
+
+        r.bindSignal(interval.onChanged, sync_up);
+
+        r.bindSignal(c_0.value.onChanged, sync_down);
+        r.bindSignal(c_1.value.onChanged, sync_down);
+
+
+        const validate = () => {
+            // validation
+
+            if (c_0.value.getValue() > c_1.value.getValue()) {
+                // restore
+                sync_up();
+            }
+        };
+
+        c_0.el.addEventListener('blur', validate);
+        c_1.el.addEventListener('blur', validate);
+
+        return r;
+    }
+}

package/editor/ecs/component/editors/ObservedBooleanEditor.js

@@ -0,0 +1,13 @@
+import { TypeEditor } from "../TypeEditor.js";
+import { CheckboxView } from "../../../../view/elements/CheckboxView.js";
+
+export class ObservedBooleanEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        const ctrl = new CheckboxView({
+            value: field.adapter.read(parent, field.name)
+        });
+
+        return ctrl;
+    }
+}

package/editor/ecs/component/editors/ObservedEnumEditor.js

@@ -0,0 +1,32 @@
+import { TypeEditor } from "../TypeEditor.js";
+import DropDownSelectionView from "../../../../view/elements/DropDownSelectionView.js";
+import List from "../../../../core/collection/list/List.js";
+import { objectKeyByValue } from "../../../../core/model/object/objectKeyByValue.js";
+
+export class ObservedEnumEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        /**
+         * @type {ObservedEnum}
+         */
+        const value = field.adapter.read(parent, field.name);
+
+        const valueSet = value.getValidValueSet();
+
+        const ctrl = new DropDownSelectionView(
+            new List(Object.keys(valueSet)), {
+                changeListener(key) {
+                    const v = valueSet[key];
+
+                    value.set(v);
+                }
+            }
+        );
+
+        ctrl.on.linked.add(() => {
+            ctrl.setSelectedValue(objectKeyByValue(valueSet, value.getValue()));
+        })
+
+        return ctrl;
+    }
+}

package/editor/ecs/component/editors/ObservedIntegerEditor.js

@@ -0,0 +1,43 @@
+import { TypeEditor } from "../TypeEditor.js";
+import { NumberController } from "../../../view/ecs/components/common/NumberController.js";
+
+export class ObservedIntegerEditor extends TypeEditor {
+    build(parent, field, registry) {
+        const instance = field.adapter.read(parent, field.name);
+        const ctrl = new NumberController();
+
+        let lock = false;
+
+        function sync_down() {
+
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            instance.set(ctrl.value.getValue());
+
+            lock = false;
+        }
+
+        function sync_up() {
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            ctrl.value.set(instance.getValue());
+
+            lock = false;
+        }
+
+        ctrl.on.linked.add(sync_up);
+
+        ctrl.value.onChanged.add(sync_down);
+        ctrl.bindSignal(instance.onChanged, sync_up);
+
+        return ctrl;
+    }
+}

package/editor/ecs/component/editors/ObservedStringEditor.js

@@ -0,0 +1,51 @@
+import { TypeEditor } from "../TypeEditor.js";
+import EmptyView from "../../../../view/elements/EmptyView.js";
+
+export class ObservedStringEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        const ctrl = new EmptyView({
+            tag: 'input'
+        });
+
+        ctrl.attr({
+            type: 'text'
+        });
+
+        const value = field.adapter.read(parent, field.name);
+
+        let lock = false;
+
+        function sync_up() {
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            ctrl.el.value = value.getValue();
+
+            lock = false;
+        }
+
+        function sync_down() {
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+            const str = ctrl.el.value;
+
+            value.set(str);
+
+            lock = false;
+        }
+
+        ctrl.on.linked.add(sync_up);
+        ctrl.bindSignal(value.onChanged, sync_up);
+        ctrl.el.addEventListener('input', sync_down);
+
+
+        return ctrl;
+    }
+}

package/editor/ecs/component/editors/Sampler2DEditor.js

@@ -0,0 +1,60 @@
+import { TypeEditor } from "../TypeEditor.js";
+import { CanvasView } from "../../../../view/elements/CanvasView.js";
+import sampler2D2Canvas from "../../../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { scaleSampler2D } from "../../../../engine/graphics/texture/sampler/scaleSampler2D.js";
+import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
+import {
+    typedArrayConstructorByInstance
+} from "../../../../engine/graphics/texture/sampler/typedArrayConstructorByInstance.js";
+import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
+import { DataType } from "../../../../core/collection/table/DataType.js";
+import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../core/math/max2.js";
+import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
+
+export class Sampler2DEditor extends TypeEditor {
+    build(parent, field, context) {
+        /**
+         * @type {Sampler2D}
+         */
+        const sampler = field.adapter.read(parent, field.name);
+
+        let dataType;
+
+        if (isTypedArray(sampler.data)) {
+            dataType = typedArrayToDataType(sampler.data);
+        } else {
+            dataType = DataType.Float32;
+        }
+
+        const TypedArrayConstructor = typedArrayConstructorByInstance(sampler.data);
+
+        const res = 32;
+        const result_sampler = new Sampler2D(new TypedArrayConstructor(sampler.itemSize * res * res), sampler.itemSize, res, res);
+
+        scaleSampler2D(sampler, result_sampler);
+
+        const view = new CanvasView();
+
+        let min = 0, max = 0;
+        if (dataType === DataType.Float32) {
+            min = Infinity;
+            max = -Infinity;
+            for (let i = 0; i < result_sampler.itemSize; i++) {
+
+                min = min2(min, result_sampler.computeMin(i).value)
+                max = max2(min, result_sampler.computeMax(i).value)
+            }
+        } else if (dataType === DataType.Uint8) {
+            min = 0;
+            max = 255;
+        }
+
+        const scale = 255 / (max - min);
+        const offset = min;
+
+        sampler2D2Canvas(result_sampler, scale, offset, view.el);
+
+        return view;
+    }
+}

package/editor/ecs/component/editors/collection/ListEditor.js

@@ -0,0 +1,83 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { NativeListController } from "../../../../../view/controller/controls/NativeListController.js";
+import { buildObjectEditorFromRegistry } from "../../createObjectEditor.js";
+import LabelView from "../../../../../view/common/LabelView.js";
+import { FieldDescriptor } from "../../FieldDescriptor.js";
+import { FieldValueAdapter } from "../../FieldValueAdapter.js";
+
+export class ListEditor extends TypeEditor {
+    inline = false;
+
+    build(parent, field, registry) {
+
+
+        const list = field.adapter.read(parent, field.name);
+
+        if (list.length > 100) {
+            return new LabelView(`List is too big (length = ${list.length})`);
+        }
+
+        let ElementType;
+
+        const field_schema = field.schema;
+
+        if (field_schema !== undefined) {
+
+            const type_parameters = field_schema.type_parameters;
+
+
+            if (type_parameters === undefined || type_parameters.length < 1) {
+                // no type specified on schema
+
+            } else {
+
+                ElementType = type_parameters[0];
+
+            }
+        }
+
+        let inferred_type = false;
+
+        if (ElementType === undefined && list.length > 0) {
+            ElementType = list.get(0).constructor;
+            inferred_type = true;
+        }
+
+        if (ElementType === undefined) {
+            return undefined;
+        }
+
+        if (inferred_type && !registry.has(ElementType)) {
+            // only work with known types when type is inferred, too messy otherwise
+            return undefined;
+        }
+
+        return new NativeListController({
+            model: list,
+            elementFactory() {
+                return new ElementType();
+            },
+            elementViewFactory(el) {
+                const fd = new FieldDescriptor();
+
+                let last_known = el;
+
+                fd.type = ElementType;
+                fd.adapter = new FieldValueAdapter();
+                fd.adapter.read = (object, field_name) => {
+                    return last_known;
+                };
+                fd.adapter.write = (object, field_name, value) => {
+                    const i = list.indexOf(last_known);
+
+                    list.set(i, value);
+
+                    last_known = value;
+                };
+
+                return buildObjectEditorFromRegistry(el, registry, fd);
+            }
+        })
+
+    }
+}

package/editor/ecs/component/editors/common/BitFlagsEditor.js

@@ -0,0 +1,80 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { assert } from "../../../../../core/assert.js";
+import EmptyView from "../../../../../view/elements/EmptyView.js";
+import { CheckboxView } from "../../../../../view/elements/CheckboxView.js";
+import ObservedBoolean from "../../../../../core/model/ObservedBoolean.js";
+
+
+/**
+ *
+ * @param {Object} parent
+ * @param {FieldDescriptor} field
+ * @param {string} key
+ * @param {Object<number>} definition
+ */
+function make_flag_editor(parent, field, key, definition) {
+    const mask = definition[key];
+
+    function get_field_value() {
+        return field.adapter.read(parent, field.name);
+    }
+
+    function read() {
+        const flags = get_field_value();
+
+        return (flags & mask) !== 0;
+    }
+
+    const flag = new ObservedBoolean(read());
+
+    const r = new CheckboxView({ value: flag });
+
+    r.attr({
+        // Tooltip
+        title: key
+    })
+
+    flag.onChanged.add((v) => {
+        const flags = get_field_value();
+
+        let new_flags;
+
+        if (v) {
+            new_flags = flags | mask;
+        } else {
+            new_flags = flags & ~(mask);
+        }
+
+        field.adapter.write(parent, field.name, new_flags);
+    });
+
+    return r;
+}
+
+export class BitFlagsEditor extends TypeEditor {
+    /**
+     *
+     * @param {Object<number>} definition
+     */
+    constructor(definition) {
+        super();
+
+        assert.defined(definition, 'definition');
+
+        this.definition = definition;
+    }
+
+    build(parent, field, registry) {
+        const flag_names = Object.keys(this.definition);
+
+        const r = new EmptyView();
+
+        for (let i = 0; i < flag_names.length; i++) {
+            const flag_key = flag_names[i];
+
+            r.addChild(make_flag_editor(parent, field, flag_key, this.definition));
+        }
+
+        return r;
+    }
+}

package/editor/ecs/component/editors/common/EnumEditor.js

@@ -0,0 +1,41 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import DropDownSelectionView from "../../../../../view/elements/DropDownSelectionView.js";
+import List from "../../../../../core/collection/list/List.js";
+import { objectKeyByValue } from "../../../../../core/model/object/objectKeyByValue.js";
+
+export class EnumEditor extends TypeEditor {
+    constructor(type) {
+        super();
+
+        this.type = type;
+    }
+
+    build(parent, field, registry) {
+
+        const valueSet = this.type;
+
+        function read() {
+            return field.adapter.read(parent, field.name);
+        }
+
+        function write(v) {
+            field.adapter.write(parent, field.name, v);
+        }
+
+        const ctrl = new DropDownSelectionView(
+            new List(Object.keys(valueSet)), {
+                changeListener(key) {
+                    const v = valueSet[key];
+
+                    write(v);
+                }
+            }
+        );
+
+        ctrl.on.linked.add(() => {
+            ctrl.setSelectedValue(objectKeyByValue(valueSet, read()));
+        })
+
+        return ctrl;
+    }
+}

package/editor/ecs/component/editors/common/makeV3_editor.js

@@ -0,0 +1,85 @@
+import EmptyView from "../../../../../view/elements/EmptyView.js";
+import { NumberController } from "../../../../view/ecs/components/common/NumberController.js";
+import LabelView from "../../../../../view/common/LabelView.js";
+
+/**
+ *
+ * @param {string[]} props
+ * @param {} value
+ * @param {Signal} change_signal
+ */
+export function make_row_editor(props, value, change_signal = value.onChanged) {
+
+    const r = new EmptyView({
+        classList: ['inline-field-row-editor']
+    });
+
+    const ctrls = [];
+
+    for (let i = 0; i < props.length; i++) {
+        const prop_name = props[i];
+
+        const ctrl = new NumberController({
+            value: value[prop_name]
+        });
+
+        r.addChild(new LabelView(prop_name));
+        r.addChild(ctrl);
+
+        ctrls[i] = ctrl;
+    }
+
+    let lock = false;
+
+    const sync_up = () => {
+        if (lock) {
+            return;
+        }
+
+        lock = true;
+
+        for (let i = 0; i < props.length; i++) {
+            const prop_name = props[i];
+
+            ctrls[i].value.set(value[prop_name]);
+        }
+
+
+        lock = false;
+    };
+
+    const sync_down = () => {
+
+        if (lock) {
+            return;
+        }
+
+        lock = true;
+
+        const params = ctrls.map(c => c.value.getValue());
+
+        value.set.apply(value, params);
+
+        lock = false;
+    };
+
+    r.on.linked.add(sync_up);
+
+    r.bindSignal(change_signal, sync_up);
+
+    for (let i = 0; i < props.length; i++) {
+
+        ctrls[i].value.onChanged.add(sync_down);
+    }
+
+    return r;
+}
+
+/**
+ *
+ * @param {Vector3} v3
+ * @returns {EmptyView}
+ */
+export function makeV3_editor(v3) {
+    return make_row_editor(['x', 'y', 'z'], v3);
+}

package/editor/ecs/component/editors/common/noEditor.js

@@ -0,0 +1,9 @@
+import { TypeEditor } from "../../TypeEditor.js";
+
+export function noEditor() {
+    const editor = new TypeEditor();
+
+    Object.defineProperty(editor, "hidden", { value: true });
+
+    return editor;
+}

package/editor/ecs/component/editors/ecs/GridObstacleEditor.js

@@ -0,0 +1,17 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { CanvasView } from "../../../../../view/elements/CanvasView.js";
+import { buildGridObstaclePreview } from "../../../../view/ecs/components/GridObstacleController.js";
+
+export class GridObstacleEditor extends TypeEditor {
+    inline = false
+
+    build(parent, field, registry) {
+        const v = new CanvasView();
+
+        v.size.set(100, 100);
+
+        buildGridObstaclePreview(field.adapter.read(parent, field.name), v.el);
+
+        return v;
+    }
+}

package/editor/ecs/component/editors/ecs/MinimapMarkerEditor.js

@@ -0,0 +1,16 @@
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import ObservedString from "../../../../../core/model/ObservedString.js";
+import { ImagePathEditor } from "../ImagePathEditor.js";
+
+export class MinimapMarkerEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                iconURL: {
+                    type: ObservedString,
+                    editor: new ImagePathEditor()
+                }
+            }
+        };
+    }
+}

package/editor/ecs/component/editors/ecs/ParameterLookupTableEditor.js

@@ -0,0 +1,44 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { CanvasView } from "../../../../../view/elements/CanvasView.js";
+import { plot_data } from "../../../../../engine/animation/curve/draw/plot_data.js";
+import Vector2 from "../../../../../core/geom/Vector2.js";
+
+export class ParameterLookupTableEditor extends TypeEditor {
+    get schema() {
+        return {
+            properties: {
+                on: {
+                    transient: true
+                }
+            }
+        };
+    }
+
+    build(parent, field,registry) {
+
+        const canvasView = new CanvasView();
+        canvasView.size.set(200, 100);
+        const ctx = canvasView.context2d;
+
+        const data = [];
+
+        /**
+         * @type {ParameterLookupTable}
+         */
+        const lut = field.adapter.read(parent, field.name);
+
+        const sample = [];
+
+        for (let i = 0; i < canvasView.size.x; i++) {
+            const f = i / (canvasView.size.x - 1);
+
+            lut.sample(f, sample);
+
+            data[i] = sample[0];
+        }
+
+        plot_data({ ctx, data, width: canvasView.size.x, height: canvasView.size.y, margin: new Vector2(4, 4) });
+
+        return canvasView;
+    }
+}

package/editor/ecs/component/editors/ecs/ParameterTrackEditor.js

@@ -0,0 +1,17 @@
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import { EnumEditor } from "../common/EnumEditor.js";
+
+export class ParameterTrackEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                name: {
+                    editor: new EnumEditor({
+                        Color: "color",
+                        Scale: "scale"
+                    })
+                }
+            }
+        };
+    }
+}