@woosh/meep-engine 2.46.28 → 2.46.30

package/editor/process/symbolic/make3DSymbolicDisplay.js

@@ -0,0 +1,91 @@
+import { assert } from "../../../src/core/assert.js";
+import EditorEntity from "../../ecs/EditorEntity.js";
+import { SignalBinding } from "../../../src/core/events/signal/SignalBinding.js";
+import { ComponentSymbolicDisplay } from "./ComponentSymbolicDisplay.js";
+import { SymbolicDisplayInternalAPI } from "./SymbolicDisplayInternalAPI.js";
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {function(components:[], api:{bind:function(Signal, function, thisArg:*), update: function, bindings:SignalBinding[]})} factory
+ * @param {Class[]} components
+ * @return {ComponentSymbolicDisplay}
+ */
+export function make3DSymbolicDisplay({
+                                          engine,
+                                          factory,
+                                          components
+                                      }) {
+
+    assert.defined(engine);
+    assert.defined(factory);
+    assert.defined(components);
+
+    assert.typeOf(factory, 'function', 'factory');
+
+    const entityManager = engine.entityManager;
+
+
+    /**
+     *
+     * @type {SymbolicDisplayInternalAPI[]}
+     */
+    const entities = [];
+
+
+    function added(...args) {
+        const entity = args[args.length - 1];
+
+        const entityDataset = entityManager.dataset;
+        const editorEntity = entityDataset.getComponent(entity, EditorEntity);
+
+        if (editorEntity !== undefined) {
+            //skip editor's own entities
+            return;
+        }
+
+
+        const api = new SymbolicDisplayInternalAPI();
+
+        api.__requestUpdate.add(() => {
+            removed(...args);
+            added(...args);
+        });
+
+        api.initialize({
+            ecd: entityDataset,
+            engine,
+            entity
+        });
+
+        try {
+            factory(args, api);
+        } catch (e) {
+            console.error(`Error while creating a helper:`, e, args);
+
+            api.finalize();
+
+            return;
+        }
+
+        entities[entity] = api;
+    }
+
+    function removed(...args) {
+        const entity = args[args.length - 1];
+
+        const api = entities[entity];
+
+        if (api === undefined) {
+            return;
+        }
+
+        delete entities[entity];
+
+        api.finalize();
+    }
+
+    const display = new ComponentSymbolicDisplay(components, added, removed);
+
+    return display;
+}

package/editor/process/symbolic/makeCameraSymbolicDisplay.js

@@ -0,0 +1,32 @@
+import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
+import { CameraHelper } from "three";
+import { buildThreeJSHelperEntity } from "./buildThreeJSHelperEntity.js";
+import Renderable from "../../../src/engine/ecs/components/Renderable.js";
+import { Camera } from "../../../src/engine/graphics/ecs/camera/Camera.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+
+/**
+ *
+ * @returns {ComponentSymbolicDisplay}
+ * @param {Engine} engine
+ */
+export function makeCameraSymbolicDisplay(engine) {
+
+    return make3DSymbolicDisplay({
+        engine,
+
+        factory([camera, transform, entity], api) {
+            const helper = new CameraHelper(camera.object);
+
+            const entityBuilder = buildThreeJSHelperEntity(helper);
+
+            const r = entityBuilder.getComponent(Renderable);
+
+            r.matrixAutoUpdate = false;
+
+            api.emit(entityBuilder);
+        },
+
+        components: [Camera, Transform]
+    });
+}

package/editor/process/symbolic/makeGridPositionSymbolDisplay.js

@@ -0,0 +1,176 @@
+import { max2 } from "../../../src/core/math/max2.js";
+import { min2 } from "../../../src/core/math/min2.js";
+import Task from "../../../src/core/process/task/Task.js";
+import { TaskSignal } from "../../../src/core/process/task/TaskSignal.js";
+import EntityBuilder from "../../../src/engine/ecs/EntityBuilder.js";
+import { BufferGeometry, Float32BufferAttribute, Line, LineBasicMaterial } from "three";
+import Renderable from "../../../src/engine/ecs/components/Renderable.js";
+import { SurfacePoint3 } from "../../../src/core/geom/3d/SurfacePoint3.js";
+import Vector3 from "../../../src/core/geom/Vector3.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import EditorEntity from "../../ecs/EditorEntity.js";
+import { EventType } from "../../../src/engine/ecs/EntityManager.js";
+import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
+import GridPosition from "../../../src/engine/grid/components/GridPosition.js";
+import { ProcessState } from "../../../src/core/process/ProcessState.js";
+import { obtainTerrain } from "../../../src/engine/ecs/terrain/util/obtainTerrain.js";
+
+/**
+ *
+ * @param {Engine} engine
+ */
+export function makeGridPositionSymbolDisplay(engine) {
+
+    /**
+     *
+     * @type {EntityManager}
+     */
+    const em = engine.entityManager;
+
+    const updateQueue = [];
+
+    const tTerrainWaiter = new Task({
+        name: 'terrain-waiter',
+        cycleFunction() {
+            if (updateQueue.length === 0) {
+                return TaskSignal.Yield;
+            }
+
+            const f = updateQueue.shift();
+
+            f();
+
+            return TaskSignal.Continue;
+        }
+    });
+
+    /**
+     *
+     * @param {GridPosition} gridPosition
+     * @param {Transform} transform
+     * @returns {EntityBuilder}
+     */
+    function makeHelper(gridPosition, transform) {
+        const builder = new EntityBuilder();
+
+        // TODO replace with {@link VisualSymbolLine}
+
+        const lineMaterial = new LineBasicMaterial({ color: 0xFFFFFF });
+        lineMaterial.depthTest = false;
+
+        const lineGeometry = new BufferGeometry();
+
+        const positionAttribute = new Float32BufferAttribute(new Float32Array(6), 3);
+        lineGeometry.setAttribute('position', positionAttribute);
+
+
+        //find terrain
+        const terrain = obtainTerrain(em.dataset);
+
+        const line = new Line(lineGeometry, lineMaterial);
+
+        line.updateMatrixWorld();
+        line.frustumCulled = false;
+
+        const renderable = new Renderable(line);
+        renderable.matrixAutoUpdate = false;
+
+        const contact = new SurfacePoint3();
+
+        const p0 = transform.position;
+        const p1 = new Vector3();
+
+        /**
+         *
+         * @returns {boolean}
+         */
+        function updateGridPosition() {
+
+            //get grid position in the world
+            terrain.mapPointGrid2World(gridPosition.x, gridPosition.y, p1);
+
+            return terrain.raycastFirstSync(contact, p1.x, -(terrain.heightRange + 1), p1.z, 0, 1, 0);
+
+        }
+
+        function updateGeometry() {
+            const c = contact.position;
+
+            positionAttribute.setXYZ(0, p0.x, p0.y, p0.z);
+            positionAttribute.setXYZ(1, c.x, c.y, c.z);
+
+            positionAttribute.needsUpdate = true;
+        }
+
+        function updateBounds() {
+            const c = contact.position;
+
+            const x0 = min2(p0.x, c.x),
+                y0 = min2(p0.y, c.y),
+                z0 = min2(p0.z, c.z),
+                x1 = max2(p0.x, c.x),
+                y1 = max2(p0.y, c.y),
+                z1 = max2(p0.z, c.z);
+
+            renderable.boundingBox.setBounds(x0, y0, z0, x1, y1, z1);
+
+            renderable.bvh.resize(x0, y0, z0, x1, y1, z1);
+        }
+
+        function attemptUpdate() {
+            if (updateGridPosition()) {
+                updateGeometry();
+                updateBounds();
+            } else if (updateQueue.indexOf(attemptUpdate) === -1) {
+                updateQueue.push(attemptUpdate);
+            }
+        }
+
+        attemptUpdate();
+
+        builder
+            .add(renderable)
+            .add(new Transform())
+            .add(new EditorEntity());
+
+        builder.addEventListener(EventType.EntityRemoved, () => {
+            p0.onChanged.remove(attemptUpdate);
+            gridPosition.onChanged.remove(attemptUpdate);
+        });
+
+        builder.on.built.add(() => {
+            p0.onChanged.add(attemptUpdate);
+            gridPosition.onChanged.add(attemptUpdate);
+
+            attemptUpdate();
+        });
+
+        return builder;
+    }
+
+    const display = make3DSymbolicDisplay({
+        engine,
+        components: [GridPosition, Transform],
+        factory([gridPosition, transform, entity], api) {
+
+            api.emit(makeHelper(gridPosition, transform));
+
+        }
+    });
+
+
+    display.__state.onChanged.add((s0, s1) => {
+        if (s0 === ProcessState.Running) {
+            //started
+            engine.executor.run(tTerrainWaiter);
+        } else if (s1 === ProcessState.Running) {
+            //stopepd
+            engine.executor.removeTask(tTerrainWaiter);
+
+            //purge update queue
+            updateQueue.splice(0, updateQueue.length);
+        }
+    });
+
+    return display;
+}

package/editor/process/symbolic/makeHelperBoxGeometry.js

@@ -0,0 +1,44 @@
+import { BufferAttribute, BufferGeometry, Float32BufferAttribute } from "three";
+
+export function makeHelperBoxGeometry(sx = 1, sy = 1, sz = 1) {
+
+    const geometry = new BufferGeometry();
+
+    const dx = sx / 2;
+    const dy = sy / 2;
+    const dz = sz / 2;
+
+    const vertices = new Float32Array([
+        -dx, -dy, -dz,
+        dx, -dy, -dz,
+        dx, dy, -dz,
+        -dx, dy, -dz,
+
+        -dx, dy, dz,
+        dx, dy, dz,
+        dx, -dy, dz,
+        -dx, -dy, dz
+    ]);
+
+    geometry.setAttribute("position", new Float32BufferAttribute(vertices, 3));
+
+    geometry.setIndex(new BufferAttribute(new Uint8Array([
+        0, 1,
+        1, 2,
+        2, 3,
+        3, 0,
+
+        4, 5,
+        5, 6,
+        6, 7,
+        7, 4,
+
+
+        0, 7,
+        1, 6,
+        2, 5,
+        3, 4
+    ]), 1, false));
+
+    return geometry;
+}

package/editor/process/symbolic/makeHelperSphereGeometry.js

@@ -0,0 +1,73 @@
+import { BufferGeometry, Float32BufferAttribute } from "three";
+import { max2 } from "../../../src/core/math/max2.js";
+
+
+/**
+ *
+ * @param {number[]} vertices
+ * @param {number} radius
+ * @param {number} angle0
+ * @param {number} angle1
+ * @param {number} component0
+ * @param {number} component1
+ * @param {number} offset
+ * @param {number} count
+ */
+function addArc(vertices, radius, angle0, angle1, component0, component1, offset, count) {
+
+    /**
+     *
+     * @type {number}
+     */
+    const angleSpan = angle1 - angle0;
+
+    const offset3 = offset * 3;
+
+    for (var i = 0; i < count; ++i) {
+
+        const address = i * 3 + offset3;
+
+        const f = i / (count - 1);
+
+        const angle = angle0 + angleSpan * f;
+
+        vertices[address + component0] = Math.cos(angle) * radius;
+        vertices[address + component1] = Math.sin(angle) * radius;
+
+    }
+}
+
+/**
+ *
+ * @param {number} [radius]
+ * @param {number} [resolution]
+ * @returns {BufferGeometry}
+ */
+export function makeHelperSphereGeometry(radius = 1, resolution = 64) {
+    const geometry = new BufferGeometry();
+
+    const r_4 = max2(2, Math.floor(resolution / 4));
+
+    const pointCount = r_4 * 4 * 3;
+
+    const vertices = new Float32Array(pointCount * 3);
+
+
+    let offset = 0;
+
+    addArc(vertices, radius, 0, Math.PI * 2, 0, 1, offset, r_4 * 4);
+    offset += r_4 * 4;
+
+    addArc(vertices, radius, 0, Math.PI * 1.5, 0, 2, offset, r_4 * 3);
+    offset += r_4 * 3;
+
+    addArc(vertices, radius, -Math.PI * 0.5, Math.PI * 1.5, 1, 2, offset, r_4 * 4);
+    offset += r_4 * 4;
+
+    addArc(vertices, radius, Math.PI * 1.5, Math.PI * 2, 0, 2, offset, r_4);
+
+    geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+
+
+    return geometry;
+}

package/editor/process/symbolic/makeLightSymbolicDisplay.js

@@ -0,0 +1,77 @@
+import { Light } from "../../../src/engine/graphics/ecs/light/Light.js";
+import { DirectionalLightHelper, PointLightHelper, SpotLightHelper } from "three";
+import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
+import { buildThreeJSHelperEntity } from "./buildThreeJSHelperEntity.js";
+import Renderable from "../../../src/engine/ecs/components/Renderable.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {ComponentSymbolicDisplay}
+ */
+export function makeLightSymbolicDisplay(engine) {
+
+    /**
+     *
+     * @param {Light} light
+     */
+    function makeHelper(light) {
+        const threeObject = light.__threeObject;
+
+        if (threeObject === null) {
+            console.warn('Light object is not initialized', light);
+            return null;
+        }
+        if (threeObject === undefined) {
+            console.error('Light object is undefined', light);
+            return null;
+        }
+
+        switch (light.type.getValue()) {
+            case Light.Type.SPOT:
+                return new SpotLightHelper(threeObject);
+            case  Light.Type.POINT:
+                return new PointLightHelper(threeObject);
+            case Light.Type.DIRECTION:
+                return new DirectionalLightHelper(threeObject);
+
+            default:
+                return null;
+        }
+    }
+
+    return make3DSymbolicDisplay({
+        engine,
+
+        /**
+         *
+         * @param light
+         * @param transform
+         * @param entity
+         * @param {SymbolicDisplayInternalAPI} api
+         */
+        factory([light, transform, entity], api) {
+
+            const helper = makeHelper(light);
+
+            if (helper === null) {
+                //no helper for this light type
+                return;
+            }
+
+            const entityBuilder = buildThreeJSHelperEntity(helper);
+
+            const r = entityBuilder.getComponent(Renderable);
+
+            r.matrixAutoUpdate = false;
+
+            api.bind(light.type.onChanged, api.update, api);
+
+
+            api.emit(entityBuilder);
+        },
+
+        components: [Light, Transform]
+    });
+}

package/editor/process/symbolic/makeParticleEmitterSymbolicDisplay.js

@@ -0,0 +1,146 @@
+import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { BoxBufferGeometry, Group, Line, LineBasicMaterial, Mesh, MeshBasicMaterial } from "three";
+import { buildThreeJSHelperEntity } from "./buildThreeJSHelperEntity.js";
+import { ParticleEmitter } from "../../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+import { makeHelperSphereGeometry } from "./makeHelperSphereGeometry.js";
+import {
+    EmissionShapeType
+} from "../../../src/engine/graphics/particles/particular/engine/emitter/EmissionShapeType.js";
+
+/**
+ *
+ * @param {Engine} engine
+ */
+export function makeParticleEmitterSymbolicDisplay(engine) {
+
+    const wireframeMaterial = new MeshBasicMaterial({ wireframe: true, depthTest: true });
+
+    const lineMaterial = new LineBasicMaterial({
+        depthTest: true,
+        depthWrite: false,
+        transparent: true,
+        linewidth: 1,
+        fog: false,
+        color: '#FFFFFF',
+        opacity: 0.5
+    });
+
+    const centerMaterial = new MeshBasicMaterial({ color: 0xFF0000, transparent: true, opacity: 0.2 });
+
+    const sphereBufferGeometry = makeHelperSphereGeometry(0.5, 64);
+
+    const boxGeometry = new BoxBufferGeometry(1, 1, 1, 1, 1, 1,);
+
+    const centerGeometry = new BoxBufferGeometry(0.03, 0.03, 0.03, 1, 1, 1,);
+
+    /**
+     *
+     * @param {ParticleEmitter} emitter
+     * @param {Transform} transform
+     * @param {number} entity
+     * @param {SymbolicDisplayInternalAPI} api
+     * @returns {EntityBuilder}
+     */
+    function factory([emitter, transform, entity], api) {
+
+        const group = new Group();
+        group.name = 'Particle Emitter Gizmo';
+
+        /**
+         *
+         * @param {ParticleLayer} layer
+         */
+        function addLayer(layer) {
+            const emissionShape = layer.emissionShape;
+
+            const center = new Mesh(centerGeometry, centerMaterial);
+            center.name = "Center Marker";
+            center.frustumCulled = false;
+
+            center.position.copy(layer.position);
+
+            group.add(center);
+
+            let geometry;
+            let mesh;
+
+            if (emissionShape === EmissionShapeType.Box) {
+
+                geometry = boxGeometry;
+                mesh = new Mesh(geometry, wireframeMaterial);
+
+            } else if (emissionShape === EmissionShapeType.Sphere) {
+
+                geometry = sphereBufferGeometry;
+                mesh = new Line(geometry, lineMaterial);
+
+            }
+
+            function updateScale() {
+                center.scale.set(
+                    1 / transform.scale.x,
+                    1 / transform.scale.y,
+                    1 / transform.scale.z
+                );
+
+                mesh.scale.set(
+                    layer.scale.x,
+                    layer.scale.y,
+                    layer.scale.z
+                );
+            }
+
+            function updatePosition() {
+                mesh.position.copy(layer.position);
+            }
+
+            if (mesh !== undefined) {
+
+                mesh.frustumCulled = false;
+
+                updateScale();
+                updatePosition();
+
+                group.add(mesh);
+
+                api.bind(layer.position.onChanged, updatePosition);
+
+                api.bind(layer.scale.onChanged, updateScale);
+                api.bind(transform.scale.onChanged, updateScale);
+            }
+        }
+
+        /**
+         *
+         * @param {ParticleLayer} layer
+         */
+        function removeLayer(layer) {
+            // TODO implement
+        }
+
+        emitter.traverseLayers(addLayer);
+
+        const builder = buildThreeJSHelperEntity(group, entity);
+
+        /**
+         *
+         * @type {Transform}
+         */
+        const t = builder.getComponent(Transform);
+
+        api.bindTransform(transform, t);
+
+        api.bind(emitter.layers.on.added, addLayer, {});
+        api.bind(emitter.layers.on.removed, removeLayer, {});
+
+        api.emit(builder);
+
+    }
+
+    return make3DSymbolicDisplay({
+        engine,
+        components: [ParticleEmitter, Transform],
+        factory
+    });
+}