@woosh/meep-engine 2.46.29 → 2.46.30

package/editor/process/symbolic/makePathSymbolicDisplay.js

@@ -0,0 +1,105 @@
+import { BufferGeometry, Float32BufferAttribute, Group, Line, LineBasicMaterial } from "three";
+import Vector3 from "../../../src/core/geom/Vector3.js";
+import { min2 } from "../../../src/core/math/min2.js";
+import Renderable from "../../../src/engine/ecs/components/Renderable.js";
+import { buildThreeJSHelperEntity } from "./buildThreeJSHelperEntity.js";
+import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
+import Path from "../../../src/engine/navigation/ecs/components/Path.js";
+
+/**
+ *
+ * @return {ComponentSymbolicDisplay}
+ * @param {Engine} engine
+ */
+export function makePathSymbolicDisplay(engine) {
+
+    /**
+     *
+     * @param {Path} path
+     * @param {number} q
+     * @returns {BufferGeometry}
+     */
+    function buildPathGeometry(path, q) {
+        const geometry = new BufferGeometry();
+
+        const vertices = [];
+
+        const v3 = new Vector3();
+
+        const length = path.computeLength();
+        const minStep = (length / path.getPointCount()) / 10;
+        const step = min2(q, minStep);
+
+        const p = path;
+
+        let i = 0;
+
+        for (let c = 0; c < length; c += step) {
+            p.sample(v3, c);
+
+            vertices[i++] = v3.x;
+            vertices[i++] = v3.y;
+            vertices[i++] = v3.z;
+        }
+
+        geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3));
+
+        return geometry;
+    }
+
+    /**
+     *
+     * @param {Path} path
+     * @param entity
+     * @param {SymbolicDisplayInternalAPI} api
+     * @return {EntityBuilder}
+     */
+    function factory([path, entity], api) {
+        const pathObjectMaterial = new LineBasicMaterial({ color: 0xFF0000, opacity: 0.4 });
+        pathObjectMaterial.depthTest = false;
+
+        const q = 0.01;
+
+        const pathObject = new Line(buildPathGeometry(path, q), pathObjectMaterial);
+        pathObject.castShadow = true;
+
+
+        function update() {
+            pathObject.geometry = buildPathGeometry(path, q);
+
+            b.getComponent(Renderable).computeBoundsFromObject();
+        }
+
+        for (let i = 0; i < path.getPointCount(); i++) {
+            const p = new Vector3();
+
+            path.getPosition(i, p);
+
+
+            api.bind(p.onChanged, () => {
+                update();
+            });
+
+        }
+
+
+        const group = new Group();
+        group.frustumCulled = false;
+
+        group.add(pathObject);
+
+        const b = buildThreeJSHelperEntity(group);
+
+        const r = b.getComponent(Renderable);
+
+        r.matrixAutoUpdate = false;
+
+        api.emit(b);
+    }
+
+    return make3DSymbolicDisplay({
+        engine,
+        components: [Path],
+        factory
+    })
+}

package/editor/process/symbolic/makePositionedIconDisplaySymbol.js

@@ -0,0 +1,74 @@
+import { assert } from "../../../src/core/assert.js";
+import { Sprite, SpriteMaterial } from "three";
+import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
+import EntityBuilder from "../../../src/engine/ecs/EntityBuilder.js";
+import Renderable from "../../../src/engine/ecs/components/Renderable.js";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { synchronizeTransform } from "./synchronizeTransform.js";
+
+const SPRITE_SIZE = 0.3;
+
+/**
+ * @template C,T
+ * @param {Engine} engine
+ * @param {string} iconURL
+ * @param {C} ComponentClass
+ * @returns {ComponentSymbolicDisplay}
+ */
+export function makePositionedIconDisplaySymbol(engine, iconURL, ComponentClass) {
+    assert.defined(engine, 'engine');
+    assert.ok(engine.isEngine, 'engine.isEngine');
+
+    const entityManager = engine.entityManager;
+
+    const assetManager = engine.assetManager;
+
+    const spriteMaterial = new SpriteMaterial();
+    spriteMaterial.depthTest = false;
+    spriteMaterial.transparent = true;
+    spriteMaterial.depthWrite = true;
+
+    assetManager.promise(iconURL, 'texture').then(asset => {
+
+        spriteMaterial.map = asset.create();
+        spriteMaterial.needsUpdate = true;
+    });
+
+    return make3DSymbolicDisplay({
+        engine,
+        /**
+         *
+         * @param component
+         * @param transform
+         * @param entity
+         * @param {SymbolicDisplayInternalAPI} api
+         * @return {EntityBuilder}
+         */
+        factory([component, transform, entity], api) {
+
+            const b = new EntityBuilder();
+
+            const sprite = new Sprite(spriteMaterial);
+            sprite.frustumCulled = false;
+            sprite.matrixAutoUpdate = false;
+            //draw on top of everything else
+            sprite.renderOrder = 9999;
+
+            const cR = new Renderable(sprite);
+            const cT = new Transform();
+
+
+            //sprite size
+            cT.scale.set(SPRITE_SIZE, SPRITE_SIZE, SPRITE_SIZE);
+            cR.boundingBox.setBounds(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5);
+
+            synchronizeTransform(transform, cT, api.bindings, true, false, false);
+
+            b.add(cR);
+            b.add(cT);
+
+            api.emit(b);
+        },
+        components: [ComponentClass, Transform]
+    });
+}

package/editor/process/symbolic/makeSocketsSymbolicDisplay.js

@@ -0,0 +1,153 @@
+import { AxesHelper, Group, Mesh as ThreeMesh, MeshBasicMaterial, SphereBufferGeometry } from "three";
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { Attachment } from "../../../src/engine/ecs/attachment/Attachment.js";
+import { BoneAttachmentSocket } from "../../../src/engine/ecs/sockets/BoneAttachmentSocket.js";
+import { BoneAttachmentBinding } from "../../../src/engine/ecs/attachment/BoneAttachmentBinding.js";
+import Mesh from "../../../src/engine/graphics/ecs/mesh/Mesh.js";
+import { TransformAttachmentBinding } from "../../../src/engine/ecs/attachment/TransformAttachmentBinding.js";
+import { make3DSymbolicDisplay } from "./make3DSymbolicDisplay.js";
+import { AttachmentSockets } from "../../../src/engine/ecs/sockets/AttachmentSockets.js";
+import { buildThreeJSHelperEntity } from "./buildThreeJSHelperEntity.js";
+import ViewportPosition from "../../../src/engine/ecs/gui/position/ViewportPosition.js";
+import LabelView from "../../../src/view/common/LabelView.js";
+import HeadsUpDisplay from "../../../src/engine/ecs/gui/hud/HeadsUpDisplay.js";
+import GUIElement from "../../../src/engine/ecs/gui/GUIElement.js";
+import { MeshEvents } from "../../../src/engine/graphics/ecs/mesh/MeshEvents.js";
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {ComponentSymbolicDisplay}
+ */
+export function makeSocketsSymbolicDisplay(engine) {
+
+    const centerMaterial = new MeshBasicMaterial({
+        color: 0x00FFFF,
+        transparent: true,
+        opacity: 0.2
+    });
+
+    const centerGeometry = new SphereBufferGeometry(0.05, 10, 10);
+
+    /**
+     *
+     * @param {AttachmentSockets} sockets
+     * @param {Transform} transform
+     * @param {number} entity
+     * @param {SymbolicDisplayInternalAPI} api
+     */
+    function factory([sockets, transform, entity], api) {
+
+        const ecd = engine.entityManager.dataset;
+
+        const rebuild = () => {
+
+            ecd.removeEntityEventListener(entity, MeshEvents.DataSet, rebuild);
+
+            api.update();
+
+        };
+
+        ecd.addEntityEventListener(entity, MeshEvents.DataSet, rebuild);
+
+        /**
+         *
+         * @param {AttachmentSocket} socket
+         */
+        function buildGizmo(socket) {
+            /**
+             *
+             * @type {AttachmentBinding}
+             */
+            let binding = null;
+            let t = new Transform();
+
+            const attachment = new Attachment();
+
+            if (socket instanceof BoneAttachmentSocket) {
+                binding = new BoneAttachmentBinding();
+
+                /**
+                 *
+                 * @type {Mesh}
+                 */
+                const mesh = engine.entityManager.dataset.getComponent(entity, Mesh);
+
+                const bone = mesh.getDescendantObjectByName(socket.boneName);
+
+                binding.bone = bone;
+            } else {
+                binding = new TransformAttachmentBinding();
+            }
+
+            binding.attachment = attachment;
+
+            binding.parentEntity = entity;
+            binding.parentTransform = transform;
+            binding.socket = socket;
+
+            binding.attachedTransform = t;
+
+            const socket_group = new Group();
+            socket_group.frustumCulled = false;
+
+            const helper = new AxesHelper(2 * transform.scale.x);
+            helper.frustumCulled = false;
+
+            const mesh = new ThreeMesh(centerGeometry, centerMaterial);
+            mesh.frustumCulled = false;
+
+            socket_group.add(mesh);
+            socket_group.add(helper);
+
+
+            const builder = buildThreeJSHelperEntity(socket_group, entity);
+
+            const v = new LabelView(socket.id, { classList: ['__debug-plaque'] });
+            v.css({
+                position: 'absolute',
+                whiteSpace: 'pre',
+                left: 0,
+                top: 0
+            })
+
+            builder.add(new HeadsUpDisplay())
+                .add(new ViewportPosition())
+                .add(GUIElement.fromView(v))
+
+            function update_transform() {
+                binding.update();
+
+                /**
+                 *
+                 * @type {Transform}
+                 */
+                const transform = builder.getComponent(Transform);
+
+                transform.copy(t);
+            }
+
+            api.onFrame(update_transform);
+
+            api.bind(sockets.elements.on.removed, (s) => {
+                if (s === socket) {
+                    builder.destroy();
+                }
+            });
+
+            api.emit(builder);
+        }
+
+        sockets.elements.forEach(buildGizmo);
+
+        api.bind(sockets.elements.on.added, buildGizmo);
+
+    }
+
+    return make3DSymbolicDisplay({
+        engine,
+        components: [AttachmentSockets, Transform],
+        factory
+    });
+}
+