@woosh/meep-engine 2.46.29 → 2.46.31

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

@@ -0,0 +1,112 @@
+import { TypeEditor } from "../../TypeEditor.js";
+import {
+    convertTexture2Sampler2D
+} from "../../../../../src/engine/graphics/texture/sampler/convertTexture2Sampler2D.js";
+import { Sampler2D } from "../../../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
+import sampler2D2Canvas from "../../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { MouseEvents } from "../../../../../src/engine/input/devices/events/MouseEvents.js";
+import { downloadSampler2DAsPNG } from "../../../../../src/engine/graphics/texture/sampler/downloadSamplerAsPNG.js";
+import EmptyView from "../../../../../src/view/elements/EmptyView.js";
+import { FrameRunner } from "../../../../../src/engine/graphics/FrameRunner.js";
+
+const UPDATE_DELAY = 200;
+
+export class TextureEditor extends TypeEditor {
+    inline = true;
+
+    build(parent, field, registry) {
+        const size = 32;
+
+        let texture = field.adapter.read(parent, field.name);
+        let sampler;
+        if (texture) {
+
+            sampler = convertTexture2Sampler2D(texture, size, size)
+
+        } else {
+            sampler = Sampler2D.uint8(4, size, size);
+            sampler.fill_channel(3, 255);
+        }
+
+        const vContainer = new EmptyView({
+            css: {
+                width: "min-content",
+                height: "min-content"
+            }
+        });
+
+        const canvasView = new CanvasView();
+        canvasView.css({
+            position: "relative",
+            background: 'black'
+        });
+        vContainer.addChild(canvasView);
+
+        canvasView.size.set(sampler.width, sampler.height);
+
+
+        let last_version = -1;
+        let last_update_time = 0;
+        let last_update_duration = 0;
+
+        function draw() {
+            const draw_start_time = performance.now();
+
+            sampler = convertTexture2Sampler2D(texture, size, size);
+            sampler2D2Canvas(sampler, 1, 0, canvasView.el);
+
+            last_version = texture.version;
+
+            const draw_end_time = performance.now();
+            last_update_duration = draw_end_time - draw_start_time;
+
+            last_update_time = draw_end_time;
+        }
+
+
+        function try_update() {
+            const time_now = performance.now();
+
+            if ((time_now - last_update_time) < UPDATE_DELAY) {
+                return;
+            }
+
+            texture = field.adapter.read(parent, field.name);
+
+            if (texture === undefined || texture === null) {
+                sampler.fill(0);
+                return;
+            }
+
+            if (texture.version !== last_version) {
+                draw();
+            }
+        }
+
+        const frameRunner = new FrameRunner(try_update);
+
+        canvasView.on.linked.add(frameRunner.startup, frameRunner);
+        canvasView.on.unlinked.add(frameRunner.shutdown, frameRunner);
+
+
+        const allow_download = true;
+        if (allow_download) {
+            vContainer.el.addEventListener(MouseEvents.Click, () => {
+                const texture = field.adapter.read(parent, field.name);
+                if (texture === undefined || texture == null) {
+                    return;
+                }
+
+                const sampler = convertTexture2Sampler2D(texture);
+
+                downloadSampler2DAsPNG(sampler, field.name);
+            });
+            // add download marker
+            vContainer.addClass('downloadable');
+        }
+
+
+        return vContainer;
+    }
+}

package/editor/ecs/component/findNearestRegisteredType.js

@@ -0,0 +1,59 @@
+/**
+ *
+ * @param {Map<*, TypeEditor>} registry
+ * @param {*} value
+ * @returns {TypeEditor|void}
+ */
+export function findNearestRegisteredType(registry, value) {
+    const path = [];
+
+    let editor;
+    let t = value;
+    do {
+
+        if (t === undefined || t === null) {
+            return;
+        }
+
+
+        editor = registry.get(t);
+
+        if (editor !== undefined) {
+            return editor;
+        }
+
+        if (typeof t === "function" && t !== Function) {
+            // t is a class, classes have Function prototype, this is confusing, but we want to skip going to function class in this case
+            t = t.prototype;
+            continue;
+        }
+
+        if (t.constructor !== undefined) {
+
+            editor = registry.get(t.constructor);
+
+            if (editor !== undefined) {
+                return editor;
+            }
+        }
+
+        const proto = Object.getPrototypeOf(t);
+
+        if (proto === undefined || proto === null) {
+            return;
+        }
+
+
+        const ctor = proto;
+
+        t = ctor;
+
+        if (path.includes(t)) {
+            // circular dependency detected
+            return;
+        }
+
+        path.push(t);
+
+    } while (true);
+}

package/editor/ecs/component/prototypeObjectEditor.js

@@ -0,0 +1,379 @@
+import { buildObjectEditorFromRegistry } from "./createObjectEditor.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import Vector3 from "../../../src/core/geom/Vector3.js";
+import Signal from "../../../src/core/events/signal/Signal.js";
+import Quaternion from "../../../src/core/geom/Quaternion.js";
+import { seededRandom } from "../../../src/core/math/random/seededRandom.js";
+import Clock from "../../../src/engine/Clock.js";
+import { TypeEditor } from "./TypeEditor.js";
+import { Vector3Editor } from "./editors/geom/Vector3Editor.js";
+import { QuaternionEditor } from "./editors/geom/QuaternionEditor.js";
+import { noEditor } from "./editors/common/noEditor.js";
+import { TransformEditor } from "./editors/ecs/TransformEditor.js";
+import { Sampler2D } from "../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+import { Light } from "../../../src/engine/graphics/ecs/light/Light.js";
+import { Sampler2DEditor } from "./editors/Sampler2DEditor.js";
+import Vector1 from "../../../src/core/geom/Vector1.js";
+import { Color } from "../../../src/core/color/Color.js";
+import { ColorEditor } from "./editors/ColorEditor.js";
+import { Vector1Editor } from "./editors/geom/Vector1Editor.js";
+import ObservedBoolean from "../../../src/core/model/ObservedBoolean.js";
+import ObservedEnum from "../../../src/core/model/ObservedEnum.js";
+import { LightType } from "../../../src/engine/graphics/ecs/light/LightType.js";
+import { ShadedGeometry } from "../../../src/engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { BoxBufferGeometry, BufferGeometry, Material, MeshStandardMaterial, Texture } from "three";
+import { SGMesh } from "../../../src/engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js";
+import { ParticleEmitter } from "../../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+import { BufferGeometryEditor } from "./editors/three/BufferGeometryEditor.js";
+import { MaterialEditor } from "./editors/three/MaterialEditor.js";
+import { ObservedEnumEditor } from "./editors/ObservedEnumEditor.js";
+import { ObservedBooleanEditor } from "./editors/ObservedBooleanEditor.js";
+import { StringEditor } from "./editors/primitive/StringEditor.js";
+import { BooleanEditor } from "./editors/primitive/BooleanEditor.js";
+import { NumberEditor } from "./editors/primitive/NumberEditor.js";
+import {
+    ParameterLookupTable
+} from "../../../src/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js";
+import { ParameterLookupTableEditor } from "./editors/ecs/ParameterLookupTableEditor.js";
+import List from "../../../src/core/collection/list/List.js";
+import { ParticleLayer } from "../../../src/engine/graphics/particles/particular/engine/emitter/ParticleLayer.js";
+import { NumericInterval } from "../../../src/core/math/interval/NumericInterval.js";
+import { NumericIntervalEditor } from "./editors/NumericIntervalEditor.js";
+import { ObjectEditor } from "./editors/primitive/ObjectEditor.js";
+import { ListEditor } from "./editors/collection/ListEditor.js";
+import Trail2D from "../../../src/engine/graphics/ecs/trail2d/Trail2D.js";
+import { ParticleEmitterLayerEditor } from "./editors/ecs/ParticleEmitterLayerEditor.js";
+import { ParticleEmitterEditor } from "./editors/ecs/ParticleEmitterEditor.js";
+import Vector4 from "../../../src/core/geom/Vector4.js";
+import { Vector4Editor } from "./editors/geom/Vector4Editor.js";
+import { Trail2DEditor } from "./editors/ecs/Trail2DEditor.js";
+import GridObstacle from "../../../src/engine/grid/components/GridObstacle.js";
+import { Vector2Editor } from "./editors/geom/Vector2Editor.js";
+import Vector2 from "../../../src/core/geom/Vector2.js";
+import { randomIntegerBetween } from "../../../src/core/math/random/randomIntegerBetween.js";
+import { GridObstacleEditor } from "./editors/ecs/GridObstacleEditor.js";
+import { EngineHarness } from "../../../src/engine/EngineHarness.js";
+import Terrain from "../../../src/engine/ecs/terrain/ecs/Terrain.js";
+import WorkerProxy from "../../../src/core/process/worker/WorkerProxy.js";
+import { TextureEditor } from "./editors/three/TextureEditor.js";
+import { HTMLElementEditor } from "./editors/HTMLElementEditor.js";
+import { TerrainLayerEditor } from "./editors/ecs/terrain/TerrainLayerEditor.js";
+import { TerrainLayer } from "../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js";
+import ObservedString from "../../../src/core/model/ObservedString.js";
+import { ObservedStringEditor } from "./editors/ObservedStringEditor.js";
+import { TerrainOverlay } from "../../../src/engine/ecs/terrain/overlay/TerrainOverlay.js";
+import { TerrainOverlayEditor } from "./editors/ecs/terrain/TerrainOverlayEditor.js";
+import { TerrainEditor } from "./editors/ecs/terrain/TerrainEditor.js";
+import { SplatMapping } from "../../../src/engine/ecs/terrain/ecs/splat/SplatMapping.js";
+import { SplatMappingEditor } from "./editors/ecs/terrain/SplatMappingEditor.js";
+import { TerrainLayersEditor } from "./editors/ecs/terrain/TerrainLayersEditor.js";
+import { TerrainLayers } from "../../../src/engine/ecs/terrain/ecs/layers/TerrainLayers.js";
+import {
+    SimulationStepDefinition
+} from "../../../src/engine/graphics/particles/particular/engine/simulator/SimulationStepDefinition.js";
+import { SimulationStepDefinitionEditor } from "./editors/ecs/SimulationStepDefinitionEditor.js";
+import { ArrayEditor } from "./editors/primitive/ArrayEditor.js";
+import { ParameterTrackEditor } from "./editors/ecs/ParameterTrackEditor.js";
+import { ParameterTrack } from "../../../src/engine/graphics/particles/particular/engine/parameter/ParameterTrack.js";
+
+/**
+ *
+ * @type {Map<any, TypeEditor>}
+ */
+const registry = new Map();
+
+registry.set(Terrain, new TerrainEditor());
+registry.set(TerrainLayer, new TerrainLayerEditor());
+registry.set(SplatMapping, new SplatMappingEditor());
+registry.set(TerrainOverlay, new TerrainOverlayEditor());
+registry.set(TerrainLayers, new TerrainLayersEditor());
+
+registry.set(GridObstacle, new GridObstacleEditor());
+
+registry.set(ParticleLayer, new ParticleEmitterLayerEditor());
+registry.set(ParticleEmitter, new ParticleEmitterEditor());
+registry.set(ParameterTrack, new ParameterTrackEditor());
+registry.set(SimulationStepDefinition, new SimulationStepDefinitionEditor());
+
+registry.set(Trail2D, new Trail2DEditor());
+
+registry.set(Number, new NumberEditor());
+registry.set(Boolean, new BooleanEditor());
+registry.set(String, new StringEditor());
+registry.set(Array, new ArrayEditor());
+registry.set(Object, new ObjectEditor());
+
+registry.set(NumericInterval, new NumericIntervalEditor());
+registry.set(List, new ListEditor());
+registry.set(ObservedBoolean, new ObservedBooleanEditor());
+registry.set(ObservedEnum, new ObservedEnumEditor());
+registry.set(Material, new MaterialEditor());
+registry.set(BufferGeometry, new BufferGeometryEditor());
+registry.set(Texture, new TextureEditor());
+registry.set(Color, new ColorEditor());
+registry.set(Vector4, new Vector4Editor());
+registry.set(Vector3, new Vector3Editor());
+registry.set(Vector2, new Vector2Editor());
+registry.set(Vector1, new Vector1Editor());
+registry.set(ObservedString, new ObservedStringEditor());
+
+registry.set(Quaternion, new QuaternionEditor());
+registry.set(Transform, new TransformEditor());
+registry.set(ParameterLookupTable, new ParameterLookupTableEditor());
+registry.set(Sampler2D, new Sampler2DEditor());
+
+registry.set(HTMLElement, new HTMLElementEditor());
+registry.set(HTMLCanvasElement, new HTMLElementEditor());
+
+registry.set(WorkerProxy, noEditor());
+registry.set(Signal, noEditor());
+
+registry.set(Uint8Array, noEditor());
+registry.set(Uint16Array, noEditor());
+registry.set(Uint32Array, noEditor());
+
+registry.set(Int8Array, noEditor());
+registry.set(Int16Array, noEditor());
+registry.set(Int32Array, noEditor());
+
+registry.set(Float32Array, noEditor());
+registry.set(Float64Array, noEditor());
+
+registry.set(CanvasRenderingContext2D, noEditor());
+
+
+const random = seededRandom(7);
+
+const transform = new Transform();
+
+const light = new Light();
+light.type.set(LightType.SPOT);
+light.color.parse('rgb(255,145,0)');
+
+const sg = ShadedGeometry.from(new BoxBufferGeometry(), new MeshStandardMaterial({
+    color: 0xFFFF00
+}));
+const sgMesh = SGMesh.fromURL('bla-bla');
+const particleEmitter = ParticleEmitter.fromJSON({
+    "position": {
+        "x": 22,
+        "y": 0,
+        "z": 18
+    },
+    "scale": {
+        "x": 0.25,
+        "y": 0.25,
+        "z": 0.25
+    },
+    "rotation": {
+        "x": 0,
+        "y": -0.4073445409440101,
+        "z": 0,
+        "w": 0.9132745616533474
+    },
+    "parameters": [
+        {
+            "name": "scale",
+            "itemSize": 1,
+            "defaultTrackValue": {
+                "itemSize": 1,
+                "data": [
+                    1
+                ],
+                "positions": [
+                    0
+                ]
+            }
+        },
+        {
+            "name": "color",
+            "itemSize": 4,
+            "defaultTrackValue": {
+                "itemSize": 4,
+                "data": [
+                    1,
+                    1,
+                    1,
+                    1
+                ],
+                "positions": [
+                    0
+                ]
+            }
+        }
+    ],
+    "preWarm": true,
+    "readDepth": true,
+    "softDepth": true,
+    "velocityAlign": false,
+    "receiveLight": true,
+    "blendingMode": 0,
+    "layers": [
+        {
+            "imageURL": "data/textures/particle/UETools/x64/Smoke_14.png",
+            "particleLife": {
+                "min": 6,
+                "max": 8
+            },
+            "particleSize": {
+                "min": 0.4,
+                "max": 0.4
+            },
+            "particleRotation": {
+                "min": 0,
+                "max": 0
+            },
+            "particleRotationSpeed": {
+                "min": 0,
+                "max": 0
+            },
+            "emissionShape": 3,
+            "emissionFrom": 1,
+            "emissionRate": 2,
+            "emissionImmediate": 0,
+            "parameterTracks": [
+                {
+                    "name": "color",
+                    "track": {
+                        "itemSize": 4,
+                        "data": [
+                            0.45,
+                            0.45,
+                            0.45,
+                            0,
+
+                            0.6,
+                            0.6,
+                            0.6,
+                            0.3,
+
+                            0.6,
+                            0.6,
+                            0.6,
+                            0.2,
+
+                            0.6,
+                            0.6,
+                            0.6,
+                            0
+                        ],
+                        "positions": [
+                            0,
+                            0.2,
+                            0.7,
+                            1
+                        ]
+                    }
+                },
+                {
+                    "name": "scale",
+                    "track": {
+                        "itemSize": 1,
+                        "data": [
+                            0.2493331876981993,
+                            0.6134230340328317,
+                            1.0759788492641973,
+                            1.261059004570864
+                        ],
+                        "positions": [
+                            0,
+                            0.4176470588235294,
+                            0.7588235294117648,
+                            1
+                        ]
+                    }
+                }
+            ],
+            "position": {
+                "x": 2.7,
+                "y": 2.3,
+                "z": 1.5
+            },
+            "scale": {
+                "x": 1,
+                "y": 1,
+                "z": 1
+            },
+            "particleVelocityDirection": {
+                "direction": {
+                    "x": 0,
+                    "y": 1,
+                    "z": 0
+                },
+                "angle": 0.1
+            },
+            "particleSpeed": {
+                "min": 0.2,
+                "max": 0.22
+            },
+            "steps": [
+                {
+                    "type": "FixedPhysics",
+                    "parameters": []
+                }
+            ]
+        },
+
+    ]
+});
+
+const trail2D = new Trail2D();
+
+const gridObstacle = new GridObstacle();
+gridObstacle.resize(10, 10);
+gridObstacle.traverseMask(0, 0, (x, y) => {
+    gridObstacle.writePoint(x, y, randomIntegerBetween(random, 0, 1))
+});
+
+
+async function makeTerrain() {
+    const harness = new EngineHarness();
+
+    await harness.initialize()
+
+    const engine = harness.engine;
+
+    engine.viewStack.el.parentElement.removeChild(engine.viewStack.el);
+
+    return await EngineHarness.buildTerrain({ engine: engine })
+}
+
+async function exec() {
+
+    // const terrain = await makeTerrain();
+
+    const object = particleEmitter;
+
+
+// transform.rotation.random(random);
+
+    const view = buildObjectEditorFromRegistry(object, registry);
+
+    console.warn(object);
+
+    document.body.append(view.el);
+
+    document.body.style.background = 'rgb(37,73,0)';
+
+    view.link();
+
+    view.css({
+        background: 'grey'
+    });
+}
+
+exec();
+
+const clock = new Clock();
+clock.start();
+
+function animate() {
+    requestAnimationFrame(animate);
+
+    const delta = clock.getDelta();
+    const time = clock.getElapsedTime();
+
+    // transform.rotation.lookAt(Vector3.zero, new Vector3(Math.cos(time), Math.sin(time), time % 10))
+}
+
+animate();

package/editor/enableEditor.js

@@ -0,0 +1,85 @@
+import Editor from "./Editor.js";
+import { noop } from "../src/core/function/Functions.js";
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {function(Editor):*} [initialization]
+ * @returns {{enable:function, disable: function, toggle: function, editor: Editor}}
+ */
+export function enableEditor(engine, initialization = noop) {
+    let editor = null;
+
+    let enabled = false;
+
+    function ensureEditor() {
+        if (editor === null) {
+            editor = new Editor();
+            editor.engine = engine;
+
+            editor.initialize();
+
+            initialization(editor);
+        }
+
+        return editor;
+    }
+
+    function attachEditor() {
+        if (enabled) {
+            return;
+        }
+
+        console.log('Enabling editor');
+
+        ensureEditor();
+
+        editor.attach(engine);
+        enabled = true;
+    }
+
+    function detachEditor() {
+        if (!enabled) {
+            return;
+        }
+
+        console.log('Disabling editor');
+        if (editor !== null) {
+            editor.detach();
+        }
+        enabled = false;
+    }
+
+    function toggleEditor() {
+        if (!enabled) {
+            attachEditor();
+        } else {
+            detachEditor();
+        }
+
+        return editor;
+    }
+
+    //bind key for toggling editor
+    engine.inputEngine.mapKey(144, {
+        on: function () {
+            toggleEditor();
+        },
+        off: function () {
+
+        }
+    });
+
+    console.warn('Editor mode enabled, use NumLock key to toggle editor mode');
+
+    return {
+        toggle: toggleEditor,
+        enable: attachEditor,
+        disable: detachEditor,
+        get editor() {
+            ensureEditor();
+
+            return editor;
+        }
+    }
+}

package/editor/library/MeshLibrary.js

@@ -0,0 +1,33 @@
+import List from "../../src/core/collection/list/List.js";
+
+
+class MeshLibrary {
+
+    constructor() {
+
+        /**
+         * @type {List.<string>}
+         */
+        this.assets = new List();
+    }
+
+    /**
+     *
+     * @param {string} url
+     */
+    add(url) {
+        const existingAsset = this.assets.find(function (_url) {
+            return _url === url;
+        });
+
+        if (existingAsset !== undefined) {
+            //already exists
+            return;
+        }
+
+        this.assets.add(url);
+    }
+}
+
+
+export { MeshLibrary };