@woosh/meep-engine 2.34.49 → 2.35.0

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();
+            }
+        }
+    }
+}

package/engine/graphics/ecs/mesh-v2/sample/load_gltf.js

@@ -6,6 +6,7 @@ import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import { three_object_to_entity_composition } from "../three_object_to_entity_composition.js";
 import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
 import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { Camera } from "../../camera/Camera.js";
 
 const eh = new EngineHarness();
 
@@ -70,6 +71,10 @@ async function main(engine) {
         enableTerrain: false
     });
 
+    const camera = engine.entityManager.dataset.getAnyComponent(Camera);
+    camera.component.autoClip = false;
+    camera.component.object.far = 300;
+
     // a small delay to let background tasks finish, so we can get better performance reading later on
     timeout(20);
 

package/engine/graphics/ecs/mesh-v2/sample/prototypeShadedGeometry.js

@@ -3,7 +3,7 @@ import { ShadedGeometrySystem } from "../ShadedGeometrySystem.js";
 import EntityBuilder from "../../../../ecs/EntityBuilder.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "../ShadedGeometry.js";
-import { BoxBufferGeometry, MeshBasicMaterial } from "three";
+import { BoxBufferGeometry, MeshStandardMaterial } from "three";
 import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
@@ -13,9 +13,15 @@ import { downloadAsFile } from "../../../../../core/binary/ByteArrayTools.js";
 import { convert_bvh_to_dot_format_string } from "../../../../../core/bvh2/visual/convert_bvh_to_dot_format_string.js";
 import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
 import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import Quaternion from "../../../../../core/geom/Quaternion.js";
+import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
 
 const eh = new EngineHarness();
 
+const DRAW_METHOD_PLAIN = 0;
+const DRAW_METHOD_INSTANCED = 1;
+
 /**
  *
  * @param {Engine} engine
@@ -26,12 +32,18 @@ async function main(engine) {
 
     await em.addSystem(new ShadedGeometrySystem(engine));
 
-    EngineHarness.buildBasics({ engine })
+    EngineHarness.buildBasics({
+        engine,
+        yaw: -0.8,
+        pitch: 1,
+        distance: 46,
+        focus: new Vector3(10, 0, 10)
+    });
 
 
     const ecd = em.dataset;
 
-    const material = new MeshBasicMaterial({
+    const material = new MeshStandardMaterial({
         color: 0xFFFFFF
     });
 
@@ -45,6 +57,11 @@ async function main(engine) {
 
     for (let i = 0; i < 100000; i++) {
 
+        const sg = ShadedGeometry.from(geometry, material);
+
+        sg.draw_method = DRAW_METHOD_INSTANCED;
+        sg.clearFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow);
+
         new EntityBuilder()
             .add(Transform.fromJSON({
                 position: {
@@ -52,9 +69,10 @@ async function main(engine) {
                     y: randomFloatBetween(random, 0, 10),
                     z: randomFloatBetween(random, -50, 50)
                 },
-                scale: 0.01
+                rotation: Quaternion.random(random),
+                scale: 0.05
             }))
-            .add(ShadedGeometry.from(geometry, material))
+            .add(sg)
             .build(ecd);
     }
 

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

@@ -12,24 +12,29 @@ export function three_object_to_entity_composition(root) {
 
     node.transform.fromMatrix4(root.matrix.elements);
 
-    node.entity.add(new Transform());
+    const entity = node.entity;
+
+    entity.add(new Transform());
 
     if (root.isMesh) {
         if (root.isSkinnedMesh) {
             throw new Error(`Skinned meshes are not supported`);
         }
 
-        node.entity.add(ShadedGeometry.from(root.geometry, root.material));
+        const sg = ShadedGeometry.from(root.geometry, root.material);
+        sg.draw_method = 1;
+
+        entity.add(sg);
     }
 
     const children = root.children;
     const child_count = children.length;
+
     for (let i = 0; i < child_count; i++) {
         const child = children[i];
 
         const child_node = three_object_to_entity_composition(child);
 
-
         node.addChild(child_node);
     }