@woosh/meep-engine 2.34.47 → 2.35.0

package/engine/ecs/parent/EntityNode.js

@@ -4,7 +4,7 @@ import { array_remove_first } from "../../../core/collection/array/array_remove_
 import { assert } from "../../../core/assert.js";
 import { array_push_if_unique } from "../../../core/collection/array/array_push_if_unique.js";
 import { Transform } from "../transform/Transform.js";
-import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
+import { TransformAttachment, TransformAttachmentFlags } from "../transform-attachment/TransformAttachment.js";
 
 export class EntityNode {
     /**
@@ -18,12 +18,14 @@ export class EntityNode {
          * @private
          */
         this.__parent = null;
+
         /**
          *
          * @type {EntityBuilder}
          * @private
          */
         this.__entity = entity;
+
         /**
          *
          * @type {EntityNode[]}
@@ -32,7 +34,7 @@ export class EntityNode {
         this.__children = [];
 
         /**
-         *
+         * Local transform
          * @type {Transform}
          * @private
          */
@@ -45,13 +47,18 @@ export class EntityNode {
      */
     __transform_sync_down() {
 
+        const transform = this.__transform;
+
         if (this.__parent === null) {
-            const t = this.__entity.getComponent(Transform);
-            if (t !== null) {
-                t.copy(this.__transform);
+            // not attached to anything, world and local transforms match
+            const cTransform = this.__entity.getComponent(Transform);
+
+            if (cTransform !== null) {
+                cTransform.copy(transform);
             }
+
         } else {
-            this.__safe_get_attachment().transform.copy(this.__transform);
+            this.__safe_get_attachment().transform.copy(transform);
         }
 
     }
@@ -85,7 +92,7 @@ export class EntityNode {
 
         if (attachment === null) {
             attachment = new TransformAttachment();
-            attachment.immediate = true;
+            attachment.setFlag(TransformAttachmentFlags.Immediate);
 
             entity.add(attachment);
         }
@@ -115,13 +122,15 @@ export class EntityNode {
     set parent(node) {
         this.__parent = node;
 
+        const this_entity = this.__entity;
+
         // check if entity is built
-        if (!this.__entity.isBuilt) {
+        if (!this_entity.isBuilt) {
             return;
         }
 
-        let parent_entity = this.__entity.removeComponent(ParentEntity);
-        let attachment = this.__entity.removeComponent(TransformAttachment);
+        let parent_entity = this_entity.removeComponent(ParentEntity);
+        let attachment = this_entity.removeComponent(TransformAttachment);
 
         if (node !== null) {
 
@@ -141,7 +150,7 @@ export class EntityNode {
             parent_entity.entity = parent_entity_id;
 
             // add component back
-            this.__entity.add(parent_entity);
+            this_entity.add(parent_entity);
 
 
             // handle component Attachment
@@ -230,6 +239,8 @@ export class EntityNode {
         }
 
         this.__transform_sync_down();
+
+        // attach listeners
         this.__transform.position.onChanged.add(this.__transform_sync_down, this);
         this.__transform.scale.onChanged.add(this.__transform_sync_down, this);
         this.__transform.rotation.onChanged.add(this.__transform_sync_down, this);
@@ -247,6 +258,7 @@ export class EntityNode {
     }
 
     destroy() {
+        // remove listeners
         this.__transform.position.onChanged.remove(this.__transform_sync_down, this);
         this.__transform.scale.onChanged.remove(this.__transform_sync_down, this);
         this.__transform.rotation.onChanged.remove(this.__transform_sync_down, this);

package/engine/ecs/transform/Transform.js

@@ -4,14 +4,16 @@
 
 import Vector3 from "../../../core/geom/Vector3.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
-import { Matrix4 } from "../../../core/geom/Matrix4.js";
 import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
 import { decompose_matrix_4_array } from "../../graphics/util/decompose_matrix_4_array.js";
+import { mat4 } from "gl-matrix";
 
 const delta = new Vector3();
 
-const m4_0 = new Matrix4();
-const m4_1 = new Matrix4();
+const scratch_buffer = new ArrayBuffer(32 * 4);
+
+const m4_0 = new Float32Array(scratch_buffer, 0, 16);
+const m4_1 = new Float32Array(scratch_buffer, 64, 16)
 
 export class Transform {
     /**
@@ -152,12 +154,12 @@ export class Transform {
      * @param {Transform} b
      */
     multiplyTransforms(a, b) {
-        m4_0.compose(a.position, a.rotation, a.scale);
-        m4_1.compose(b.position, b.rotation, b.scale);
+        compose_matrix4_array(m4_0, a.position, a.rotation, a.scale);
+        compose_matrix4_array(m4_1, b.position, b.rotation, b.scale);
 
-        m4_0.multiplyMatrices(m4_0, m4_1);
+        mat4.multiply(m4_0, m4_0, m4_1);
 
-        m4_0.decompose(this.position, this.rotation, this.scale);
+        this.fromMatrix4(m4_0);
     }
 
     /**
@@ -170,18 +172,18 @@ export class Transform {
 
     /**
      *
-     * @param {mat4|number[]|Float32Array} m
+     * @param {Matrix4} matrix
      */
-    fromMatrix4(m) {
-        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
+    toThreeMatrix(matrix) {
+        this.toMatrix4(matrix.elements);
     }
 
     /**
      *
-     * @param {Matrix4} matrix
+     * @param {mat4|number[]|Float32Array} m
      */
-    toThreeMatrix(matrix) {
-        this.toMatrix4(matrix.elements);
+    fromMatrix4(m) {
+        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
     }
 
     /**

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -12,6 +12,42 @@ const DEFAULT_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
 ;
 
+/**
+ *
+ * @param {ShadedGeometry} sg
+ * @returns {THREE.Object3D}
+ */
+export function build_three_object(sg) {
+
+    /**
+     * @type {THREE.Object3D}
+     */
+    let object;
+
+    const mode = sg.mode;
+    const shader = sg.material;
+    const geo = sg.geometry;
+
+    if (mode === DrawMode.Triangles) {
+        object = new Mesh(geo, shader);
+    } else if (mode === DrawMode.Lines) {
+        object = new Line(geo, shader);
+    } else if (mode === DrawMode.LineSegments) {
+        object = new LineSegments(geo, shader);
+    } else {
+        throw new Error(`Unsupported draw mode '${mode}'`);
+    }
+
+    object.matrixAutoUpdate = false;
+    object.frustumCulled = false;
+    object.matrixWorldNeedsUpdate = false;
+
+    object.castShadow = sg.getFlag(ShadedGeometryFlags.CastShadow);
+    object.receiveShadow = sg.getFlag(ShadedGeometryFlags.ReceiveShadow);
+
+    return object;
+}
+
 export class ShadedGeometry {
     constructor() {
         /**
@@ -51,6 +87,7 @@ export class ShadedGeometry {
          * @private
          */
         this.__entity = -1;
+
         /**
          * Transform matrix
          * Transient, assigned in the system
@@ -59,6 +96,12 @@ export class ShadedGeometry {
          */
         this.__transform = null;
 
+        /**
+         * Transient property signifying how to render object
+         * @type {number}
+         */
+        this.draw_method = 0;
+
         /**
          *
          * @type {number}
@@ -106,6 +149,25 @@ export class ShadedGeometry {
         return (this.flags & flag) === flag;
     }
 
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return this.geometry.id ^ this.material.id;
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.geometry.id === other.geometry.id
+            && this.material.id === other.material.id
+            ;
+    }
+
     /**
      * Current cached entity that this component is attached to
      * @return {number}
@@ -130,32 +192,7 @@ export class ShadedGeometry {
     }
 
     __build_object() {
-        /**
-         * @type {THREE.Object3D}
-         */
-        let object;
-
-        const mode = this.mode;
-        const shader = this.material;
-        const geo = this.geometry;
-
-        if (mode === DrawMode.Triangles) {
-            object = new Mesh(geo, shader);
-        } else if (mode === DrawMode.Lines) {
-            object = new Line(geo, shader);
-        } else if (mode === DrawMode.LineSegments) {
-            object = new LineSegments(geo, shader);
-        } else {
-            throw new Error(`Unsupported draw mode '${mode}'`);
-        }
-
-        object.matrixAutoUpdate = false;
-        object.frustumCulled = false;
-
-        object.castShadow = this.getFlag(ShadedGeometryFlags.CastShadow);
-        object.receiveShadow = this.getFlag(ShadedGeometryFlags.ReceiveShadow);
-
-        this.__cached_object = object;
+        this.__cached_object = build_three_object(this);
     }
 
     get bvh() {

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -7,6 +7,8 @@ import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
 import { mat4 } from "gl-matrix";
 import { returnTrue } from "../../../../core/function/Functions.js";
 import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
+import { ShadedGeometryRendererContext } from "./render/ShadedGeometryRendererContext.js";
+import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
 
 /**
  *
@@ -54,14 +56,72 @@ export class ShadedGeometrySystem extends System {
          * @private
          */
         this.__render_layer = null;
+
+        /**
+         *
+         * @type {Map<CameraView, ShadedGeometryRendererContext>}
+         * @private
+         */
+        this.__view_contexts = new Map();
+
+        this.__bvh = new BinaryNode();
+        this.__bvh.setNegativelyInfiniteBounds();
+    }
+
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    __handle_view_added(view) {
+        this.__view_contexts.set(view, new ShadedGeometryRendererContext());
+    }
+
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    __handle_view_removed(view) {
+        const ctx = this.__view_contexts.get(view);
+
+        this.__view_contexts.delete(view);
+
+        ctx.dispose();
     }
 
     async startup(entityManager, readyCallback, errorCallback) {
 
         const engine = this.__engine;
+        const graphics = engine.graphics;
+
+        const view_list = graphics.views.elements;
+
+        view_list.forEach(this.__handle_view_added, this);
+        view_list.on.added.add(this.__handle_view_added, this);
+        view_list.on.removed.add(this.__handle_view_removed, this);
+
+        this.__render_layer = graphics.layers.create('shaded-geometry');
+
+        this.__render_layer.buildVisibleSet = ((destination, destination_offset, view) => {
+            const ctx = this.__view_contexts.get(view);
+
+            return ctx.collect(destination, destination_offset, view, this.__bvh);
+        });
+
+        readyCallback();
+    }
+
+    async shutdown(entityManager, readyCallback, errorCallback) {
+
+        const engine = this.__engine;
+        const graphics = engine.graphics;
+
+        const view_list = graphics.views.elements;
 
-        this.__render_layer = engine.graphics.layers.create('shaded-geometry');
-        this.__render_layer.extractRenderable = (sg) => sg.__cached_object;
+        view_list.forEach(this.__handle_view_removed, this);
+        view_list.on.added.remove(this.__handle_view_added, this);
+        view_list.on.removed.remove(this.__handle_view_removed, this);
 
         readyCallback();
     }
@@ -87,7 +147,7 @@ export class ShadedGeometrySystem extends System {
         // remember entity for lookups
         sg.__entity = entity;
 
-        this.__render_layer.bvh.insertNode(leaf_node);
+        this.__bvh.insertNode(leaf_node);
     }
 
     /**

package/engine/graphics/ecs/mesh-v2/render/AbstractRenderAdapter.js

@@ -0,0 +1,67 @@
+export class AbstractRenderAdapter {
+    constructor() {
+
+        /**
+         *
+         * @type {number}
+         * @protected
+         */
+        this.__object_count = 0;
+
+        /**
+         *
+         * @type {THREE.Object3D[]}
+         * @protected
+         */
+        this.__objects = [];
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     * @param {THREE.Material} material
+     * @returns {number}
+     */
+    score(geometry, material) {
+        return 0;
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} sg
+     * @returns {void}
+     */
+    add(sg) {
+        throw new Error('Not Implemented');
+    }
+
+    build_start() {
+
+    }
+
+    build_end() {
+
+    }
+
+    clear() {
+        this.__object_count = 0;
+    }
+
+    /**
+     * @returns {THREE.Object3D[]}
+     */
+    get objects() {
+        return this.__objects;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get object_count() {
+        return this.__object_count;
+    }
+
+    dispose() {
+
+    }
+}

package/engine/graphics/ecs/mesh-v2/render/GenericRendererAdapter.js

@@ -0,0 +1,48 @@
+import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
+import { build_three_object } from "../ShadedGeometry.js";
+import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+
+export class GenericRendererAdapter extends AbstractRenderAdapter {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {Cache<ShadedGeometry, THREE.Object3D>}
+         * @private
+         */
+        this.__cache = new WeakMap();
+    }
+
+
+    score(geometry, material) {
+        return 0;
+    }
+
+    build_start() {
+        this.clear();
+    }
+
+    add(sg) {
+        const cache = this.__cache;
+
+        /**
+         *
+         * @type {THREE.Object3D}
+         */
+        let object = cache.get(sg);
+
+        if (object === undefined) {
+
+            object = build_three_object(sg);
+
+            cache.set(sg, object);
+
+        }
+
+        array_copy(sg.__transform, 0, object.matrixWorld.elements, 0, 16);
+
+        this.__objects[this.__object_count++] = object;
+    }
+
+}

package/engine/graphics/ecs/mesh-v2/render/InstancedRendererAdapter.js

@@ -0,0 +1,110 @@
+import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
+import { HashMap } from "../../../../../core/collection/HashMap.js";
+import { InstancedMeshGroup } from "../../../geometry/instancing/InstancedMeshGroup.js";
+import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
+
+const INSTANCED_EQUALITY_FLAGS = ShadedGeometryFlags.CastShadow
+    | ShadedGeometryFlags.ReceiveShadow
+;
+
+export class InstancedRendererAdapter extends AbstractRenderAdapter {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {HashMap<ShadedGeometry, InstancedMeshGroup>}
+         * @private
+         */
+        this.__instanced_meshes = new HashMap({
+            keyHashFunction(sg) {
+                return sg.geometry.id ^ sg.material.id;
+            },
+            keyEqualityFunction(a, b) {
+                return a.material.id === b.material.id
+                    && a.geometry.id === b.geometry.id
+                    && (a.flags & INSTANCED_EQUALITY_FLAGS) === (b.flags & INSTANCED_EQUALITY_FLAGS)
+                    ;
+            }
+        });
+
+        /**
+         *
+         * @type {Set<InstancedMeshGroup>}
+         * @private
+         */
+        this.__active_meshes = new Set();
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} sg
+     * @returns {InstancedMeshGroup}
+     * @private
+     */
+    __get_instanced_mesh(sg) {
+        let im = this.__instanced_meshes.get(sg);
+
+        if (im === undefined) {
+            im = new InstancedMeshGroup();
+            im.shrinkFactor = 0; // prevent shrinking as we're essentially rebuilding this geometry frame
+
+            im.setMaterial(sg.material);
+            im.setGeometry(sg.geometry);
+
+            im.mesh.castShadow = sg.getFlag(ShadedGeometryFlags.CastShadow);
+            im.mesh.receiveShadow = sg.getFlag(ShadedGeometryFlags.ReceiveShadow);
+
+            this.__instanced_meshes.set(sg, im);
+        }
+
+        return im;
+    }
+
+    add(sg) {
+        const mesh = this.__get_instanced_mesh(sg);
+
+        const index = mesh.count;
+
+        mesh.ensureCapacity(index + 1);
+
+        mesh.setTransformAt(index, sg.transform);
+
+        mesh.count++;
+
+        this.__active_meshes.add(mesh);
+    }
+
+    build_start() {
+        this.clear();
+    }
+
+    build_end() {
+
+        for (const activeMesh of this.__active_meshes) {
+            // force underlying geometry to update
+            activeMesh.setCount(activeMesh.getCount());
+            activeMesh.requestAttributeUpdate();
+
+            this.__objects[this.__object_count++] = activeMesh.mesh;
+        }
+
+    }
+
+    clear() {
+        super.clear();
+
+        for (const activeMesh of this.__active_meshes) {
+            activeMesh.setCount(0);
+        }
+
+        this.__active_meshes.clear();
+    }
+
+    dispose() {
+        // release GPU memory
+        this.__instanced_meshes.forEach((value, key) => {
+            value.dispose();
+        });
+    }
+}

package/engine/graphics/ecs/mesh-v2/render/ShadedGeometryRendererContext.js

@@ -0,0 +1,98 @@
+import { queryBinaryNode_FrustumIntersections_Data } from "../../../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
+import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
+import { InstancedRendererAdapter } from "./InstancedRendererAdapter.js";
+import { GenericRendererAdapter } from "./GenericRendererAdapter.js";
+
+/**
+ * 1 - collect visible meshes
+ * 2 - figure out how to render a given mesh
+ */
+export class ShadedGeometryRendererContext {
+    constructor() {
+        /**
+         * @readonly
+         * @type {AbstractRenderAdapter[]}
+         */
+        this.adapters = [
+            new GenericRendererAdapter(),
+            new InstancedRendererAdapter()
+        ];
+    }
+
+    setAdapter(index, adapter) {
+        const existing = this.adapters[index];
+        if (existing !== undefined) {
+            // dispose of existing adapter
+            existing.dispose();
+        }
+
+        this.adapters[index] = adapter;
+    }
+
+    /**
+     *
+     * @param {THREE.Object3D[]} destination
+     * @param {number} destination_offset
+     * @param {CameraView} view
+     * @param {BinaryNode<ShadedGeometry>} bvh
+     */
+    collect(destination, destination_offset, view, bvh) {
+        const adapters = this.adapters;
+        const adapter_count = adapters.length;
+
+        let i = 0, j = 0;
+        for (; i < adapter_count; i++) {
+            const adapter = adapters[i];
+
+            adapter.build_start();
+        }
+
+
+        // get all meshes
+
+        const data = [];
+
+        const intersection_count = queryBinaryNode_FrustumIntersections_Data(data, 0, bvh, view.frustum);
+
+        for (i = 0; i < intersection_count; i++) {
+            /**
+             *
+             * @type {ShadedGeometry}
+             */
+            const sg = data[i];
+
+            const adapter = adapters[sg.draw_method];
+
+            adapter.add(sg);
+        }
+
+        let additions = 0;
+
+        for (i = 0; i < adapter_count; i++) {
+            const adapter = adapters[i];
+
+            adapter.build_end();
+
+            const adapter_object_count = adapter.object_count;
+
+            for (j = 0; j < adapter_object_count; j++) {
+                const object3D = adapter.objects[j];
+
+                destination[destination_offset + additions] = object3D;
+
+                additions++;
+            }
+
+        }
+
+        return additions;
+    }
+
+    dispose() {
+        for (const adapter of this.adapters) {
+            if (adapter !== undefined) {
+                adapter.dispose();
+            }
+        }
+    }
+}