@woosh/meep-engine 2.46.29 → 2.46.31

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

@@ -0,0 +1,23 @@
+import Vector3 from "../../../../../src/core/geom/Vector3.js";
+import Quaternion from "../../../../../src/core/geom/Quaternion.js";
+import { ObjectEditor } from "../primitive/ObjectEditor.js";
+
+export class TransformEditor extends ObjectEditor {
+    get schema() {
+        return {
+            additionalProperties: false,
+
+            properties: {
+                position: {
+                    type: Vector3
+                },
+                rotation: {
+                    type: Quaternion
+                },
+                scale: {
+                    type: Vector3
+                }
+            }
+        };
+    }
+}

package/editor/ecs/component/editors/ecs/terrain/SplatMappingEditor.js

@@ -0,0 +1,21 @@
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+
+export class SplatMappingEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                depth: {
+                    transient: true,
+                },
+                materialTexture: {
+                    transient: true,
+                    deprecated: true
+                },
+                materialSampler: {
+                    transient: true,
+                    deprecated: true
+                }
+            }
+        };
+    }
+}

package/editor/ecs/component/editors/ecs/terrain/TerrainEditor.js

@@ -0,0 +1,95 @@
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+import { BitFlagsEditor } from "../../common/BitFlagsEditor.js";
+import { TerrainFlags } from "../../../../../../src/engine/ecs/terrain/ecs/TerrainFlags.js";
+import { ImagePathEditor } from "../../ImagePathEditor.js";
+import { EnumEditor } from "../../common/EnumEditor.js";
+import { GridTransformKind } from "../../../../../../src/engine/ecs/terrain/ecs/GridTransformKind.js";
+import { Texture } from "three";
+
+export class TerrainEditor extends ObjectEditor {
+    build(parent, field, registry) {
+        const view = super.build(parent, field, registry);
+
+        if (view) {
+
+            /**
+             * @type {Terrain}
+             */
+            const terrain = field.adapter.read(parent, field.name);
+
+            function updateLayers() {
+
+                terrain.layers.buildTexture();
+                terrain.layers.writeAllLayersDataIntoTexture();
+
+                terrain.updateMaterial();
+            }
+
+            // splats
+            view.bindSignal(terrain.layers.layers.on.added, () => {
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.addWeightLayer();
+                    updateLayers();
+                }
+            });
+            view.bindSignal(terrain.layers.layers.on.removed, (a, index) => {
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.removeWeightLayer(index);
+
+                    updateLayers();
+                }
+            });
+
+            // mapping sizes
+            view.bindSignal(terrain.splat.size.onChanged, (x, y) => {
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.resize(x, y, terrain.splat.depth);
+
+                    terrain.updateMaterial();
+                }
+            });
+        }
+
+        return view;
+    }
+
+    get schema() {
+        return {
+            properties: {
+                id: {
+                    transient: true
+                },
+                flags: {
+                    editor: new BitFlagsEditor(TerrainFlags),
+                    transient: true
+                },
+                gridTransformKind: {
+                    editor: new EnumEditor(GridTransformKind)
+                },
+                material: {
+                    transient: true
+                },
+                heightMapURL: {
+                    editor: new ImagePathEditor(),
+                    deprecated: true,
+                    type: String
+                },
+                heightRange: {
+                    deprecated: true
+                },
+                bvh: {
+                    transient: true,
+                },
+                heightTexture: {
+                    transient: true
+                },
+                buildLightMap: {
+                    type: Function
+                },
+                aoMap: {
+                    type: Texture
+                }
+            }
+        };
+    }
+}

package/editor/ecs/component/editors/ecs/terrain/TerrainLayerEditor.js

@@ -0,0 +1,18 @@
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+import { ImagePathEditor } from "../../ImagePathEditor.js";
+
+export class TerrainLayerEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                textureDiffuseURL: {
+                    type: String,
+                    editor: new ImagePathEditor()
+                },
+                diffuse: {
+                    transient: true
+                }
+            }
+        };
+    }
+}

package/editor/ecs/component/editors/ecs/terrain/TerrainLayersEditor.js

@@ -0,0 +1,22 @@
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+import List from "../../../../../../src/core/collection/list/List.js";
+import { TerrainLayer } from "../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js";
+import Vector2 from "../../../../../../src/core/geom/Vector2.js";
+
+export class TerrainLayersEditor extends ObjectEditor {
+    get schema() {
+        return {
+
+            additionalProperties: false,
+            properties: {
+                resolution: {
+                    type: Vector2
+                },
+                layers: {
+                    type: List,
+                    type_parameters: [TerrainLayer]
+                },
+            }
+        };
+    }
+}

package/editor/ecs/component/editors/ecs/terrain/TerrainOverlayEditor.js

@@ -0,0 +1,20 @@
+import { ObjectEditor } from "../../primitive/ObjectEditor.js";
+import { ImagePathEditor } from "../../ImagePathEditor.js";
+
+export class TerrainOverlayEditor extends ObjectEditor {
+    get schema() {
+        return {
+            properties: {
+                tileImage: {
+                    editor: new ImagePathEditor()
+                },
+                fillColor: {
+                    transient: true
+                },
+                texture: {
+                    transient: true
+                }
+            }
+        };
+    }
+}

package/editor/ecs/component/editors/geom/QuaternionEditor.js

@@ -0,0 +1,63 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import Vector3 from "../../../../../src/core/geom/Vector3.js";
+import { makeV3_editor } from "../common/makeV3_editor.js";
+import { DEG_TO_RAD } from "../../../../../src/core/math/DEG_TO_RAD.js";
+import { RAD_TO_DEG } from "../../../../../src/core/math/RAD_TO_DEG.js";
+
+export class QuaternionEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        /**
+         * @type {Quaternion}
+         */
+        const q = field.adapter.read(parent, field.name);
+
+        const euler = new Vector3();
+
+        let lock = false;
+        const sync_down = () => {
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            q.__setFromEuler(
+                euler.x * DEG_TO_RAD,
+                euler.y * DEG_TO_RAD,
+                euler.z * DEG_TO_RAD
+            );
+
+            lock = false;
+        };
+
+        const sync_up = () => {
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            const t = new Vector3();
+
+            q.toEulerAnglesXYZ(t);
+
+            euler.set(
+                t.x * RAD_TO_DEG,
+                t.y * RAD_TO_DEG,
+                t.z * RAD_TO_DEG,
+            );
+
+            lock = false;
+        }
+
+        const editor = makeV3_editor(euler);
+
+        editor.bindSignal(q.onChanged, sync_up);
+        editor.bindSignal(euler.onChanged, sync_down);
+
+        editor.on.linked.add(sync_up);
+
+        return editor;
+    }
+}

package/editor/ecs/component/editors/geom/Vector1Editor.js

@@ -0,0 +1,57 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { NumberController } from "../../../../view/ecs/components/common/NumberController.js";
+import Vector1 from "../../../../../src/core/geom/Vector1.js";
+import { isSubclassOf } from "../../../../../src/engine/plugin/isSubclassOf.js";
+
+export class Vector1Editor extends TypeEditor {
+    build(parent, field, registry) {
+        /**
+         * @type {Vector1}
+         */
+        const v1 = field.adapter.read(parent, field.name);
+
+        if (!((v1 instanceof Vector1) || isSubclassOf(v1, Vector1))) {
+            throw new Error(`Field ${field} is not Vector1`);
+        }
+
+        const view = new NumberController({ value: v1.getValue() });
+
+
+        let lock = false;
+
+        const sync_up = () => {
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            view.value.set(v1.x);
+
+            lock = false;
+        };
+
+        const sync_down = () => {
+
+            if (lock) {
+                return;
+            }
+
+            lock = true;
+
+            v1.set(
+                view.value.getValue(),
+            );
+
+            lock = false;
+        };
+
+        view.on.linked.add(sync_up);
+
+        view.bindSignal(view.value.onChanged, sync_down);
+        view.bindSignal(v1.onChanged, sync_up);
+
+
+        return view;
+    }
+}

package/editor/ecs/component/editors/geom/Vector2Editor.js

@@ -0,0 +1,11 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { make_row_editor } from "../common/makeV3_editor.js";
+
+export class Vector2Editor extends TypeEditor {
+
+    build(parent, field) {
+        const v2 = field.adapter.read(parent, field.name);
+
+        return make_row_editor(['x', 'y'], v2);
+    }
+}

package/editor/ecs/component/editors/geom/Vector3Editor.js

@@ -0,0 +1,13 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { makeV3_editor } from "../common/makeV3_editor.js";
+
+export class Vector3Editor extends TypeEditor {
+
+    build(parent, field) {
+
+        const v3 = field.adapter.read(parent, field.name);
+
+        return makeV3_editor(v3);
+    }
+}
+

package/editor/ecs/component/editors/geom/Vector4Editor.js

@@ -0,0 +1,12 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { make_row_editor } from "../common/makeV3_editor.js";
+
+export class Vector4Editor extends TypeEditor {
+
+    build(parent, field) {
+        const v4 = field.adapter.read(parent, field.name);
+
+        return make_row_editor(['x', 'y', 'z', 'w'], v4);
+    }
+}
+

package/editor/ecs/component/editors/primitive/ArrayEditor.js

@@ -0,0 +1,46 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import List from "../../../../../src/core/collection/list/List.js";
+import { FieldDescriptor } from "../../FieldDescriptor.js";
+import { FieldValueAdapter } from "../../FieldValueAdapter.js";
+import { ListEditor } from "../collection/ListEditor.js";
+import { noop } from "../../../../../src/core/function/Functions.js";
+
+export class ArrayEditor extends TypeEditor {
+    inline = false;
+
+    __list_editor = new ListEditor();
+
+    build(parent, field, registry) {
+
+        /**
+         * @type {Array}
+         */
+        const array = field.adapter.read(parent, field.name);
+
+
+        const list = new List();
+        list.data = array;
+        list.length = array.length;
+
+        // remap to list
+        const surrogate_field = new FieldDescriptor();
+        surrogate_field.type = List;
+
+        if (field.schema) {
+
+            surrogate_field.schema = Object.assign({}, field.schema, {
+                type: List
+            });
+        }
+
+        surrogate_field.name = field.name;
+        surrogate_field.adapter = new FieldValueAdapter();
+        surrogate_field.adapter.read = () => list;
+        surrogate_field.adapter.write = noop;
+        surrogate_field.adapter.writable = false;
+
+
+        return this.__list_editor.build(parent, surrogate_field, registry);
+
+    }
+}

package/editor/ecs/component/editors/primitive/BooleanEditor.js

@@ -0,0 +1,27 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import ObservedBoolean from "../../../../../src/core/model/ObservedBoolean.js";
+import { CheckboxView } from "../../../../../src/view/elements/CheckboxView.js";
+
+export class BooleanEditor extends TypeEditor {
+    build(parent, field,registry) {
+        const v = new ObservedBoolean(field.adapter.read(parent, field.name));
+
+        const ctrl = new CheckboxView({
+            value: v
+        });
+
+        function sync_up() {
+            v.set(field.adapter.read(parent, field.name));
+        }
+
+        function sync_down() {
+            field.adapter.write(parent, field.name, v.getValue());
+        }
+
+        ctrl.on.linked.add(sync_up);
+        v.onChanged.add(sync_down);
+
+
+        return ctrl;
+    }
+}

package/editor/ecs/component/editors/primitive/FunctionEditor.js

@@ -0,0 +1,29 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import ButtonView from "../../../../../src/view/elements/button/ButtonView.js";
+
+export class FunctionEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        if (field.schema === undefined) {
+            // no schema, function editors are only available for explicit schema
+            return undefined;
+        }
+
+        /**
+         * @type {Function}
+         */
+        const v = field.adapter.read(parent, field.name);
+
+        if (typeof v !== "function") {
+            // wrong type
+            return undefined;
+        }
+
+        return new ButtonView({
+            action: () => {
+                v.call(parent);
+            },
+            name: 'execute'
+        });
+    }
+}

package/editor/ecs/component/editors/primitive/NumberEditor.js

@@ -0,0 +1,60 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { NumberController } from "../../../../view/ecs/components/common/NumberController.js";
+import LabelView from "../../../../../src/view/common/LabelView.js";
+
+export class NumberEditor extends TypeEditor {
+    build(parent, field, registry) {
+        function read_value() {
+            return field.adapter.read(parent, field.name);
+        }
+
+        if (field.adapter.writable) {
+
+            const ctrl = new NumberController();
+
+            let lock = false;
+
+            function sync_up() {
+                if (lock) {
+                    return;
+                }
+
+                lock = true;
+
+                let v = read_value();
+
+                if (Number.isNaN(v)) {
+                    v = 0;
+                }
+
+                if (typeof v !== "number") {
+                    v = v.valueOf();
+                }
+
+                ctrl.value.set(v);
+
+                lock = false;
+            }
+
+            function sync_down() {
+                if (lock) {
+                    return;
+                }
+
+                lock = true;
+
+                field.adapter.write(parent, field.name, ctrl.value.getValue());
+
+                lock = false;
+            }
+
+            ctrl.on.linked.add(sync_up);
+            ctrl.value.onChanged.add(sync_down);
+
+
+            return ctrl;
+        } else {
+            return new LabelView(read_value());
+        }
+    }
+}

package/editor/ecs/component/editors/primitive/ObjectEditor.js

@@ -0,0 +1,12 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { createObjectEditor } from "../../createObjectEditor.js";
+
+export class ObjectEditor extends TypeEditor {
+    inline = false;
+
+    build(parent, field, registry) {
+        const result = createObjectEditor(field.adapter.read(parent, field.name), registry);
+
+        return result;
+    }
+}

package/editor/ecs/component/editors/primitive/StringEditor.js

@@ -0,0 +1,31 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import EmptyView from "../../../../../src/view/elements/EmptyView.js";
+
+export class StringEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        const ctrl = new EmptyView({
+            tag: 'input'
+        });
+
+        ctrl.attr({
+            type: 'text'
+        });
+
+        function sync_up() {
+            ctrl.el.value = field.adapter.read(parent, field.name);
+        }
+
+        function sync_down() {
+            const str = ctrl.el.value;
+
+            field.adapter.write(parent, field.name, str);
+        }
+
+        ctrl.on.linked.add(sync_up);
+        ctrl.el.addEventListener('input', sync_down);
+
+
+        return ctrl;
+    }
+}

package/editor/ecs/component/editors/three/BufferGeometryEditor.js

@@ -0,0 +1,28 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { Sampler2D } from "../../../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import { renderObjectToSampler2D } from "../../../../../src/engine/graphics/util/renderObjectToSampler2D.js";
+import { Mesh, MeshPhongMaterial } from "three";
+import AABB2 from "../../../../../src/core/geom/AABB2.js";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+import sampler2D2Canvas from "../../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+
+export class BufferGeometryEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        const geo = field.adapter.read(parent, field.name);
+
+        const sampler = Sampler2D.uint8(4, 64, 64);
+
+        const preview = renderObjectToSampler2D(sampler, new Mesh(geo, new MeshPhongMaterial()), undefined, new AABB2(-0.05, -0.05, 1.05, 1.05));
+
+        preview.render();
+
+        const view = new CanvasView();
+
+        sampler2D2Canvas(sampler, 1, 0, view.el);
+
+        preview.dispose();
+
+        return view;
+    }
+}

package/editor/ecs/component/editors/three/MaterialEditor.js

@@ -0,0 +1,27 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { Sampler2D } from "../../../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import { renderObjectToSampler2D } from "../../../../../src/engine/graphics/util/renderObjectToSampler2D.js";
+import { Mesh, SphereBufferGeometry } from "three";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+import sampler2D2Canvas from "../../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+
+export class MaterialEditor extends TypeEditor {
+    build(parent, field, registry) {
+
+        const mat = field.adapter.read(parent, field.name);
+
+        const sampler = Sampler2D.uint8(4, 64, 64);
+
+        const preview = renderObjectToSampler2D(sampler, new Mesh(new SphereBufferGeometry(1), mat));
+
+        preview.render();
+
+        const view = new CanvasView();
+
+        sampler2D2Canvas(sampler, 1, 0, view.el);
+
+        preview.dispose();
+
+        return view;
+    }
+}

package/editor/ecs/component/editors/three/MeshEditor.js

@@ -0,0 +1,35 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import { Sampler2D } from "../../../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import { renderObjectToSampler2D } from "../../../../../src/engine/graphics/util/renderObjectToSampler2D.js";
+import AABB2 from "../../../../../src/core/geom/AABB2.js";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+import sampler2D2Canvas from "../../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { threeUpdateTransform } from "../../../../../src/engine/graphics/util/threeUpdateTransform.js";
+
+export class MeshEditor extends TypeEditor {
+    build(parent, field, registry) {
+        const mesh = field.adapter.read(parent, field.name);
+
+        const sampler = Sampler2D.uint8(4, 128, 128);
+
+        const m = mesh.clone();
+
+        m.position.set(0, 0, 0);
+        m.rotation.set(0, 0, 0);
+        m.scale.set(1, 1, 1);
+
+        threeUpdateTransform(m);
+
+        const preview = renderObjectToSampler2D(sampler, m, undefined, new AABB2(-0.05, -0.05, 1.05, 1.05));
+
+        preview.render();
+
+        const view = new CanvasView();
+
+        sampler2D2Canvas(sampler, 1, 0, view.el);
+
+        preview.dispose();
+
+        return view;
+    }
+}