@woosh/meep-engine 2.37.18 → 2.38.0

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,107 @@
+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";
+import { FrameRunner } from "../../../../engine/graphics/FrameRunner.js";
+
+const UPDATE_DELAY = 200;
+
+export class Sampler2DEditor extends TypeEditor {
+    build(parent, field, context) {
+
+        /**
+         * @type {Sampler2D}
+         */
+        const sampler = field.adapter.read(parent, field.name);
+
+        let last_version = -1;
+        let last_update_time = 0;
+        let last_update_duration = 0;
+
+        const view = new CanvasView();
+        view.css({
+            background: 'black'
+        });
+
+        function draw() {
+            const draw_start_time = performance.now();
+
+            let dataType;
+
+            if (isTypedArray(sampler.data)) {
+                dataType = typedArrayToDataType(sampler.data);
+            } else {
+                dataType = DataType.Float32;
+            }
+
+            let TypedArrayConstructor = typedArrayConstructorByInstance(sampler.data);
+
+            if (TypedArrayConstructor === Uint8Array) {
+                // use clamped array to avoid filtering artifacts
+                TypedArrayConstructor = Uint8ClampedArray;
+            }
+
+            const res = 32;
+            const result_sampler = new Sampler2D(new TypedArrayConstructor(sampler.itemSize * res * res), sampler.itemSize, res, res);
+
+            scaleSampler2D(sampler, result_sampler);
+
+
+            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);
+
+            last_version = sampler.version;
+
+            const draw_end_time = performance.now();
+            last_update_duration = draw_end_time - draw_start_time;
+
+            last_update_time = draw_end_time;
+        }
+
+
+        view.on.linked.add(try_update);
+
+        function try_update() {
+            if (sampler.version !== last_version) {
+
+                const time_now = performance.now();
+
+                if ((time_now - last_update_time) >= UPDATE_DELAY) {
+                    draw();
+                }
+            }
+        }
+
+        const frameRunner = new FrameRunner(try_update);
+
+        view.on.linked.add(frameRunner.startup, frameRunner);
+        view.on.unlinked.add(frameRunner.shutdown, frameRunner);
+
+        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"
+                    })
+                }
+            }
+        };
+    }
+}

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

@@ -0,0 +1,58 @@
+import List from "../../../../../core/collection/list/List.js";
+import { ParticleLayer } from "../../../../../engine/graphics/particles/particular/engine/emitter/ParticleLayer.js";
+import { BitFlagsEditor } from "../common/BitFlagsEditor.js";
+import {
+    ParticleEmitterFlag
+} from "../../../../../engine/graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import { EnumEditor } from "../common/EnumEditor.js";
+import { BlendingType } from "../../../../../engine/graphics/texture/sampler/BlendingType.js";
+
+export class ParticleEmitterEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                parameters: {
+                    transient: true
+                },
+                layers: {
+                    type: List,
+                    type_parameters: [ParticleLayer]
+                },
+                particles: {
+                    transient: true
+                },
+                mesh: {
+                    transient: true
+                },
+                bvhLeaf: {
+                    transient: true
+                },
+                particleBounds: {
+                    transient: true
+                },
+                emisionBounds: {
+                    transient: true
+                },
+                flags: {
+                    editor: new BitFlagsEditor(ParticleEmitterFlag)
+                },
+                blendingMode: {
+                    editor: new EnumEditor(BlendingType)
+                },
+                sleepTime: {
+                    transient: true,
+                },
+                position: {
+                    transient: true
+                },
+                rotation: {
+                    transient: true
+                },
+                scale: {
+                    transient: true
+                }
+            }
+        };
+    }
+}

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

@@ -0,0 +1,54 @@
+import List from "../../../../../core/collection/list/List.js";
+import {
+    SimulationStepDefinition
+} from "../../../../../engine/graphics/particles/particular/engine/simulator/SimulationStepDefinition.js";
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import { ImagePathEditor } from "../ImagePathEditor.js";
+import { EnumEditor } from "../common/EnumEditor.js";
+import {
+    EmissionShapeType
+} from "../../../../../engine/graphics/particles/particular/engine/emitter/EmissionShapeType.js";
+import {
+    EmissionFromType
+} from "../../../../../engine/graphics/particles/particular/engine/emitter/EmissionFromType.js";
+import { DataType } from "../../../../../core/collection/table/DataType.js";
+
+export class ParticleEmitterLayerEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                imageURL: {
+                    type: String,
+                    editor: new ImagePathEditor()
+                },
+                emissionShape: {
+                    editor: new EnumEditor(EmissionShapeType)
+                },
+                emissionFrom: {
+                    editor: new EnumEditor(EmissionFromType)
+                },
+                emissionRate: {
+                    type: Number,
+                    numeric_type: DataType.Uint32
+                },
+                emissionImmediate: {
+                    type: Number,
+                    numeric_type: DataType.Uint32
+                },
+                scaledSpriteHalfSize: {
+                    transient: true
+                },
+                baseBoundingBox: {
+                    transient: true
+                },
+                steps: {
+                    type: List,
+                    type_parameters: [SimulationStepDefinition]
+                },
+                timeSinceLastEmission: {
+                    transient: true
+                }
+            }
+        };
+    }
+}

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

@@ -0,0 +1,21 @@
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+import { EnumEditor } from "../common/EnumEditor.js";
+import {
+    SimulationStepType
+} from "../../../../../engine/graphics/particles/particular/engine/simulator/SimulationStepType.js";
+
+export class SimulationStepDefinitionEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                type: {
+                    editor: new EnumEditor(SimulationStepType)
+                },
+                parameters: {
+                    type: Array,
+                    type_parameters: [Number]
+                }
+            }
+        };
+    }
+}