@woosh/meep-engine 2.35.1 → 2.35.4

package/core/bvh2/aabb3/aabb3_intersects_frustum_degree.js

@@ -19,18 +19,18 @@ export function aabb3_intersects_frustum_degree(
     frustum
 ) {
 
-    let i = 0;
     let result = 2;
+    let i = 0;
 
     for (; i < 24; i += 4) {
 
-        const p_nx = frustum[i];
-        const p_ny = frustum[i + 1];
-        const p_nz = frustum[i + 2];
-        const p_c = frustum[i + 3];
+        const p_x = frustum[i];
+        const p_y = frustum[i + 1];
+        const p_z = frustum[i + 2];
+        const p_w = frustum[i + 3];
 
         const plane_side = computeAABB3PlaneSide(
-            p_nx, p_ny, p_nz, p_c,
+            p_x, p_y, p_z, p_w,
             x0, y0, z0, x1, y1, z1
         );
 

package/core/bvh2/traversal/queryBinaryNode_CollectData.js

@@ -13,13 +13,12 @@ let stackPointer = 0;
  */
 export function queryBinaryNode_CollectData(destination, destinationOffset, root) {
     let n;
+    let i = 0;
 
     const stackOffset = stackPointer;
 
     stack[stackPointer++] = root;
 
-    let i = 0;
-
     while (stackPointer-- > stackOffset) {
 
         n = stack[stackPointer];

package/core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js

@@ -1,3 +1,6 @@
+import { aabb3_intersects_frustum_degree } from "../aabb3/aabb3_intersects_frustum_degree.js";
+import { queryBinaryNode_CollectData } from "./queryBinaryNode_CollectData.js";
+
 /**
  *
  * @type {(BinaryNode|LeafNode)[]}
@@ -30,32 +33,42 @@ export function queryBinaryNode_FrustumIntersections_Data(destination, destinati
 
         n = stack[stackPointer];
 
-        const node_intersects_frustum = n.intersectFrustum_array(frustum);
+        const intersection_degree = aabb3_intersects_frustum_degree(
+            n.x0, n.y0, n.z0,
+            n.x1, n.y1, n.z1,
+            frustum
+        );
 
-        if (!node_intersects_frustum) {
-            continue;
-        }
+        if (intersection_degree === 2) {
+            // fully inside
 
-        if (n.isBinaryNode === true) {
+            offset += queryBinaryNode_CollectData(destination, offset, n);
 
-            const right = n.right;
+        } else if (intersection_degree === 1) {
+            // partly inside
 
-            if (right !== null) {
-                stack[stackPointer++] = right;
-            }
+            if (n.isBinaryNode === true) {
 
-            const left = n.left;
+                const right = n.right;
 
-            if (left !== null) {
-                stack[stackPointer++] = left;
-            }
+                if (right !== null) {
+                    stack[stackPointer++] = right;
+                }
 
-        } else {
-            // leaf node
+                const left = n.left;
 
-            destination[offset] = n.object;
+                if (left !== null) {
+                    stack[stackPointer++] = left;
+                }
+
+            } else {
+                // leaf node
+
+                destination[offset] = n.object;
+
+                offset++;
+            }
 
-            offset++;
         }
 
     }

package/core/collection/HashMap.js

@@ -176,7 +176,7 @@ export class HashMap {
         const mixed_hash = (hash >>> 16) ^ hash;
 
         // ensure index is non-negative
-        const index = (2147483647) & mixed_hash;
+        const index = mixed_hash >>> 0;
 
         return index % this.__bucket_count;
     }

package/core/geom/3d/SurfacePoint3.js

@@ -1,9 +1,6 @@
-import Quaternion from "../Quaternion.js";
 import Vector3 from "../Vector3.js";
 import { v3_length } from "../v3_length.js";
 
-const q = new Quaternion();
-
 /**
  * Used for representing points on a 3D surface. Used for raycasting contacts
  */
@@ -25,9 +22,12 @@ export class SurfacePoint3 {
         const p_y = p.y;
         const p_z = p.z;
 
-        const result_p_x = m4[0] * p_x + m4[4] * p_y + m4[8] * p_z + m4[12];
-        const result_p_y = m4[1] * p_x + m4[5] * p_y + m4[9] * p_z + m4[13];
-        const result_p_z = m4[2] * p_x + m4[6] * p_y + m4[10] * p_z + m4[14];
+        // compute perspective projection
+        const w = 1 / (m4[3] * p_x + m4[7] * p_y + m4[11] * p_z + m4[15]);
+
+        const result_p_x = (m4[0] * p_x + m4[4] * p_y + m4[8] * p_z + m4[12]) * w;
+        const result_p_y = (m4[1] * p_x + m4[5] * p_y + m4[9] * p_z + m4[13]) * w;
+        const result_p_z = (m4[2] * p_x + m4[6] * p_y + m4[10] * p_z + m4[14]) * w;
 
         this.position.set(
             result_p_x,

package/engine/ecs/EntityManager.d.ts

@@ -1,6 +1,11 @@
 import {EntityComponentDataset} from "./EntityComponentDataset";
 import {System} from "./System";
 
+interface Type<T> extends Function {
+    new(...args: any[]): T;
+}
+
+
 export class EntityManager {
     dataset: EntityComponentDataset
 
@@ -10,6 +15,8 @@ export class EntityManager {
 
     removeSystem<T>(system: System<T>): Promise<void>
 
+    getSystem<T>(systemClass: Type<T>): T | null
+
     attachDataSet(dataset: EntityComponentDataset): void
 
     detachDataSet(): void

package/engine/graphics/ecs/highlight/system/ShadedGeometryHighlightSystem.js

@@ -3,6 +3,7 @@ import { HighlightRenderElementSource } from "../plugin/HighlightRenderElementSo
 import Highlight from "../Highlight.js";
 import { OutlineRenderPlugin } from "../plugin/OutlineRenderPlugin.js";
 import { ShadedGeometry } from "../../mesh-v2/ShadedGeometry.js";
+import { build_three_object } from "../../mesh-v2/build_three_object.js";
 
 class Supplier extends HighlightRenderElementSource {
     /**
@@ -31,6 +32,13 @@ class Supplier extends HighlightRenderElementSource {
          * @private
          */
         this.__group = null;
+
+        /**
+         *
+         * @type {WeakMap<ShadedGeometry, THREE.Object3D>}
+         * @private
+         */
+        this.__object_cache = new WeakMap();
     }
 
     collect(pool, group) {
@@ -77,13 +85,14 @@ class Supplier extends HighlightRenderElementSource {
             return;
         }
 
-        const object = sg.__cached_object;
+        let object = this.__object_cache.get(sg);
 
-        if (object === null) {
-            // no renderable primitive
-            return;
+        if(object === undefined){
+            object = build_three_object(sg);
         }
 
+        object.matrixWorld.elements = sg.transform;
+
         const renderElement = this.__pool.create();
 
         renderElement.definitions = elements.asArray();

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

@@ -1,9 +1,7 @@
-import { Line, LineSegments, Mesh } from "three";
 import { updateNodeByMatrix4AndBBB } from "../mesh/updateNodeByTransformAndBBB.js";
 import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { DrawMode } from "./DrawMode.js";
-import { applyTransformToThreeObject } from "../mesh/applyTransformToThreeObject.js";
 import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
 
 const _aabb3 = new AABB3();
@@ -12,42 +10,6 @@ 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() {
         /**
@@ -67,13 +29,6 @@ export class ShadedGeometry {
          */
         this.mode = DrawMode.Triangles;
 
-        /**
-         *
-         * @type {THREE.Object3D|null}
-         * @private
-         */
-        this.__cached_object = null;
-
         /**
          *
          * @type {LeafNode<ShadedGeometry>}
@@ -88,13 +43,20 @@ export class ShadedGeometry {
          */
         this.__entity = -1;
 
+        /**
+         *
+         * @type {Transform|null}
+         * @private
+         */
+        this.__c_transform = null;
+
         /**
          * Transform matrix
          * Transient, assigned in the system
          * @type {number[]|null}
          * @private
          */
-        this.__transform = null;
+        this.__transform = new Float32Array(16);
 
         /**
          * Transient property signifying how to render object
@@ -109,6 +71,14 @@ export class ShadedGeometry {
         this.flags = DEFAULT_FLAGS;
     }
 
+    /**
+     * @deprecated
+     * @private
+     */
+    get __cached_object(){
+        throw new Error('Deprecated');
+    }
+
     /**
      *
      * @param {number|ShadedGeometryFlags} flag
@@ -182,17 +152,7 @@ export class ShadedGeometry {
      * @return {null|number[]}
      */
     get transform() {
-        if (this.__transform !== null) {
-            return this.__transform;
-        } else if (this.__cached_object !== null) {
-            return this.__cached_object.matrix.elements;
-        } else {
-            return null;
-        }
-    }
-
-    __build_object() {
-        this.__cached_object = build_three_object(this);
+        return this.__transform;
     }
 
     get bvh() {
@@ -214,13 +174,6 @@ export class ShadedGeometry {
         if (geometry.boundingBox === null) {
             geometry.computeBoundingBox();
         }
-
-        if (this.__cached_object === null) {
-            this.__build_object();
-        } else {
-            this.__cached_object.material = material;
-            this.__cached_object.geometry = geometry;
-        }
     }
 
     /**
@@ -239,11 +192,8 @@ export class ShadedGeometry {
     }
 
     updateTransform() {
-        const object_3d = this.__cached_object;
-
-        // update matrix
-        object_3d.updateMatrix();
-        object_3d.updateMatrixWorld();
+        //
+        this.__c_transform.toMatrix4(this.__transform);
 
         // update bounds
         const gbb = this.geometry.boundingBox;
@@ -260,56 +210,7 @@ export class ShadedGeometry {
             max.z
         );
 
-        updateNodeByMatrix4AndBBB(this.__bvh_leaf, _aabb3, object_3d.matrix.elements);
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setPositionByComponents(x, y, z) {
-
-        this.__cached_object.position.set(x, y, z);
-
-        this.updateTransform();
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {number} w
-     */
-    setRotationByComponents(x, y, z, w) {
-
-        this.__cached_object.quaternion.set(x, y, z, w);
-
-        this.updateTransform();
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setScaleByComponents(x, y, z) {
-        this.__cached_object.scale.set(x, y, z);
-
-        this.updateTransform();
-    }
-
-    /**
-     *
-     * @param {Transform} t
-     */
-    applyTransform(t) {
-        applyTransformToThreeObject(this.__cached_object, t);
-
-        this.updateTransform();
+        updateNodeByMatrix4AndBBB(this.__bvh_leaf, _aabb3, this.__transform);
     }
 }
 

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.d.ts

@@ -1,6 +1,16 @@
 import {System} from "../../../ecs/System";
 import Engine from "../../../Engine";
+import {ShadedGeometry} from "./ShadedGeometry";
+import {SurfacePoint3} from "../../../../core/geom/3d/SurfacePoint3";
 
-export class ShadedGeometrySystem extends System {
+export class ShadedGeometrySystem extends System<ShadedGeometry> {
     constructor(engine: Engine)
+
+    raycastNearest(
+        contact: SurfacePoint3,
+        origin_x: number, origin_y: number, origin_z: number,
+        direction_x: number, direction_y: number, direction_z: number,
+        filter_function?: (entity: number, mesh: ShadedGeometry) => boolean,
+        filter_function_context?: any
+    ): { entity: number, mesh: ShadedGeometry } | undefined
 }

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

@@ -9,6 +9,7 @@ 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";
+import { assert } from "../../../../core/assert.js";
 
 /**
  *
@@ -66,6 +67,58 @@ export class ShadedGeometrySystem extends System {
 
         this.__bvh = new BinaryNode();
         this.__bvh.setNegativelyInfiniteBounds();
+
+        /**
+         *
+         * @type {Map<number, function():AbstractRenderAdapter>}
+         * @private
+         */
+        this.__adapter_suppliers = new Map();
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {function():AbstractRenderAdapter} supplier
+     */
+    register_render_adapter(index, supplier) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        if (this.__adapter_suppliers.has(index)) {
+            // slot is already taken
+            console.warn(`Render adapter slot '${index}' is already taken, removing old adapter`);
+            this.unregister_render_adapter(index);
+        }
+
+        this.__adapter_suppliers.set(index, supplier);
+
+        this.__view_contexts.forEach((value, key) => {
+            value.setAdapter(index, supplier());
+        });
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @return {boolean}
+     */
+    unregister_render_adapter(index) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        const supplier = this.__adapter_suppliers.get(index);
+
+        if (supplier === undefined) {
+            // not found
+            return false;
+        }
+
+        this.__adapter_suppliers.delete(index);
+
+        this.__view_contexts.forEach((value, key) => {
+            value.removeAdapter(index);
+        });
+
+        return true;
     }
 
     /**
@@ -74,7 +127,14 @@ export class ShadedGeometrySystem extends System {
      * @private
      */
     __handle_view_added(view) {
-        this.__view_contexts.set(view, new ShadedGeometryRendererContext());
+        const ctx = new ShadedGeometryRendererContext();
+
+        // attach adapters
+        this.__adapter_suppliers.forEach((value, key) => {
+            ctx.setAdapter(key, value());
+        });
+
+        this.__view_contexts.set(view, ctx);
     }
 
     /**
@@ -133,11 +193,13 @@ export class ShadedGeometrySystem extends System {
      * @param {number} entity
      */
     link(sg, t, entity) {
-        t.position.onChanged.add(sg.setPositionByComponents, sg);
-        t.rotation.onChanged.add(sg.setRotationByComponents, sg);
-        t.scale.onChanged.add(sg.setScaleByComponents, sg);
+        sg.__c_transform = t;
 
-        sg.applyTransform(t);
+        t.position.onChanged.add(sg.updateTransform, sg);
+        t.rotation.onChanged.add(sg.updateTransform, sg);
+        t.scale.onChanged.add(sg.updateTransform, sg);
+
+        sg.updateTransform();
 
         const leaf_node = sg.bvh;
 
@@ -157,9 +219,9 @@ export class ShadedGeometrySystem extends System {
      * @param {number} entity
      */
     unlink(sg, t, entity) {
-        t.position.onChanged.remove(sg.setPositionByComponents, sg);
-        t.rotation.onChanged.remove(sg.setRotationByComponents, sg);
-        t.scale.onChanged.remove(sg.setScaleByComponents, sg);
+        t.position.onChanged.remove(sg.updateTransform, sg);
+        t.rotation.onChanged.remove(sg.updateTransform, sg);
+        t.scale.onChanged.remove(sg.updateTransform, sg);
 
         sg.bvh.disconnect();
     }
@@ -173,7 +235,7 @@ export class ShadedGeometrySystem extends System {
      * @param {number} direction_x
      * @param {number} direction_y
      * @param {number} direction_z
-     * @param {function(entity:number, mesh:ShadedGeometry)} [filter_function]
+     * @param {function(entity:number, mesh:ShadedGeometry):boolean} [filter_function]
      * @param {*} [filter_function_context]
      * @returns {{entity:number, mesh:ShadedGeometry}|undefined}
      */
@@ -183,7 +245,7 @@ export class ShadedGeometrySystem extends System {
         direction_x, direction_y, direction_z,
         filter_function = returnTrue, filter_function_context
     ) {
-        const root_bvh = this.__render_layer.bvh;
+        const root_bvh = this.__bvh;
         const stack_frame_address = traversal_cursor;
 
         traversal_stack[traversal_cursor++] = root_bvh;
@@ -242,9 +304,11 @@ export class ShadedGeometrySystem extends System {
                 mat4.invert(scratch_m4, m4);
 
                 // transform ray to local space
-                const local_origin_x = scratch_m4[0] * origin_x + scratch_m4[4] * origin_y + scratch_m4[8] * origin_z + scratch_m4[12];
-                const local_origin_y = scratch_m4[1] * origin_x + scratch_m4[5] * origin_y + scratch_m4[9] * origin_z + scratch_m4[13];
-                const local_origin_z = scratch_m4[2] * origin_x + scratch_m4[6] * origin_y + scratch_m4[10] * origin_z + scratch_m4[14];
+                const inv_w = 1 / (scratch_m4[3] * origin_x + scratch_m4[7] * origin_y + scratch_m4[11] * origin_z + scratch_m4[15]);
+
+                const local_origin_x = (scratch_m4[0] * origin_x + scratch_m4[4] * origin_y + scratch_m4[8] * origin_z + scratch_m4[12]) * inv_w;
+                const local_origin_y = (scratch_m4[1] * origin_x + scratch_m4[5] * origin_y + scratch_m4[9] * origin_z + scratch_m4[13]) * inv_w;
+                const local_origin_z = (scratch_m4[2] * origin_x + scratch_m4[6] * origin_y + scratch_m4[10] * origin_z + scratch_m4[14]) * inv_w;
 
                 const local_direction_x = scratch_m4[0] * direction_x + scratch_m4[4] * direction_y + scratch_m4[8] * direction_z;
                 const local_direction_y = scratch_m4[1] * direction_x + scratch_m4[5] * direction_y + scratch_m4[9] * direction_z;

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

@@ -0,0 +1,39 @@
+import { DrawMode } from "./DrawMode.js";
+import { Line, LineSegments, Mesh } from "three";
+import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
+
+/**
+ *
+ * @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;
+}

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

@@ -1,7 +1,8 @@
 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";
+import { AbstractRenderAdapter } from "./adapters/AbstractRenderAdapter.js";
+import { InstancedRendererAdapter } from "./adapters/InstancedRendererAdapter.js";
+import { GenericRendererAdapter } from "./adapters/GenericRendererAdapter.js";
+import { assert } from "../../../../../core/assert.js";
 
 /**
  * 1 - collect visible meshes
@@ -19,7 +20,16 @@ export class ShadedGeometryRendererContext {
         ];
     }
 
+    /**
+     *
+     * @param {number} index
+     * @param {AbstractRenderAdapter} adapter
+     */
     setAdapter(index, adapter) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.defined(adapter, 'adapter');
+        assert.equal(adapter.isShadedGeometryRenderAdapter, true, 'adapter.isShadedGeometryRenderAdapter !== true');
+
         const existing = this.adapters[index];
         if (existing !== undefined) {
             // dispose of existing adapter
@@ -29,14 +39,36 @@ export class ShadedGeometryRendererContext {
         this.adapters[index] = adapter;
     }
 
+    /**
+     *
+     * @param {number} index
+     * @returns {boolean}
+     */
+    removeAdapter(index) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        const adapter = this.adapters[index];
+
+        if (adapter === undefined) {
+            return false;
+        }
+
+        delete this.adapters[index];
+
+        adapter.dispose();
+
+        return true;
+    }
+
     /**
      *
      * @param {THREE.Object3D[]} destination
      * @param {number} destination_offset
+     * @param {THREE.WebGLRenderer} renderer
      * @param {CameraView} view
      * @param {BinaryNode<ShadedGeometry>} bvh
      */
-    collect(destination, destination_offset, view, bvh) {
+    collect(destination, destination_offset, renderer, view, bvh) {
         const adapters = this.adapters;
         const adapter_count = adapters.length;
 
@@ -44,7 +76,7 @@ export class ShadedGeometryRendererContext {
         for (; i < adapter_count; i++) {
             const adapter = adapters[i];
 
-            adapter.build_start();
+            adapter.build_start(renderer);
         }
 
 

package/engine/graphics/ecs/mesh-v2/render/{AbstractRenderAdapter.js → adapters/AbstractRenderAdapter.js}

@@ -35,7 +35,13 @@ export class AbstractRenderAdapter {
         throw new Error('Not Implemented');
     }
 
-    build_start() {
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {CameraView} view
+     */
+    build_start(renderer, view) {
 
     }
 
@@ -65,3 +71,9 @@ export class AbstractRenderAdapter {
 
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AbstractRenderAdapter.prototype.isShadedGeometryRenderAdapter = true;

package/engine/graphics/ecs/mesh-v2/render/{GenericRendererAdapter.js → adapters/GenericRendererAdapter.js}

@@ -1,6 +1,6 @@
 import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
-import { build_three_object } from "../ShadedGeometry.js";
-import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../../../core/collection/array/copyArray.js";
+import { build_three_object } from "../../build_three_object.js";
 
 export class GenericRendererAdapter extends AbstractRenderAdapter {
     constructor() {
@@ -19,7 +19,12 @@ export class GenericRendererAdapter extends AbstractRenderAdapter {
         return 0;
     }
 
-    build_start() {
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {CameraView} view
+     */
+    build_start(renderer, view) {
         this.clear();
     }
 

package/engine/graphics/ecs/mesh-v2/render/{InstancedRendererAdapter.js → adapters/InstancedRendererAdapter.js}

@@ -1,12 +1,43 @@
 import { AbstractRenderAdapter } from "./AbstractRenderAdapter.js";
-import { HashMap } from "../../../../../core/collection/HashMap.js";
-import { InstancedMeshGroup } from "../../../geometry/instancing/InstancedMeshGroup.js";
-import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
+import { HashMap } from "../../../../../../core/collection/HashMap.js";
+import { InstancedMeshGroup } from "../../../../geometry/instancing/InstancedMeshGroup.js";
+import { ShadedGeometryFlags } from "../../ShadedGeometryFlags.js";
+import { DrawMode } from "../../DrawMode.js";
 
 const INSTANCED_EQUALITY_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
 ;
 
+/**
+ *
+ * @param {ShadedGeometry} a
+ * @param {ShadedGeometry} b
+ * @returns {number}
+ */
+function compare(a, b) {
+    const d_geometry = a.geometry.id - b.geometry.id;
+    if (d_geometry !== 0) {
+        return d_geometry;
+    }
+
+    const d_material = a.material.id - b.material.id;
+    if (d_material !== 0) {
+        return d_material;
+    }
+
+    const d_flags = (a.flags & INSTANCED_EQUALITY_FLAGS) - (b.flags & INSTANCED_EQUALITY_FLAGS);
+    if (d_flags !== 0) {
+        return d_flags;
+    }
+
+    const d_mode = a.mode - b.mode;
+    if (d_mode !== 0) {
+        return d_mode;
+    }
+
+    return 0;
+}
+
 export class InstancedRendererAdapter extends AbstractRenderAdapter {
     constructor() {
         super();
@@ -18,11 +49,12 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
          */
         this.__instanced_meshes = new HashMap({
             keyHashFunction(sg) {
-                return sg.geometry.id ^ sg.material.id;
+                return sg.geometry.id ^ sg.material.id ^ sg.mode;
             },
             keyEqualityFunction(a, b) {
                 return a.material.id === b.material.id
                     && a.geometry.id === b.geometry.id
+                    && a.mode === b.mode
                     && (a.flags & INSTANCED_EQUALITY_FLAGS) === (b.flags & INSTANCED_EQUALITY_FLAGS)
                     ;
             }
@@ -45,7 +77,17 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
     __get_instanced_mesh(sg) {
         let im = this.__instanced_meshes.get(sg);
 
-        if (im === undefined) {
+
+        if (im !== undefined) {
+
+            return im;
+
+        } else {
+
+            if (sg.mode !== DrawMode.Triangles) {
+                throw new Error(`Unsupported draw mode ${sg.mode}`);
+            }
+
             im = new InstancedMeshGroup();
             im.shrinkFactor = 0; // prevent shrinking as we're essentially rebuilding this geometry frame
 
@@ -56,9 +98,10 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
             im.mesh.receiveShadow = sg.getFlag(ShadedGeometryFlags.ReceiveShadow);
 
             this.__instanced_meshes.set(sg, im);
-        }
 
-        return im;
+            return im;
+
+        }
     }
 
     add(sg) {
@@ -66,7 +109,11 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
 
         const index = mesh.count;
 
-        mesh.ensureCapacity(index + 1);
+        const new_size = index + 1;
+
+        if (new_size > mesh.capacity) {
+            mesh.ensureCapacity(new_size);
+        }
 
         mesh.setTransformAt(index, sg.transform);
 
@@ -75,18 +122,24 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
         this.__active_meshes.add(mesh);
     }
 
-    build_start() {
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {CameraView} view
+     */
+    build_start(renderer, view) {
         this.clear();
     }
 
     build_end() {
+        const objects = this.__objects;
 
         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;
+            objects[this.__object_count++] = activeMesh.mesh;
         }
 
     }

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

@@ -16,6 +16,7 @@ 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";
+import { randomFromArray } from "../../../../../core/math/random/randomFromArray.js";
 
 const eh = new EngineHarness();
 
@@ -51,23 +52,31 @@ async function main(engine) {
 
     window.material = material;
 
-    const geometry = new BoxBufferGeometry();
-
     const random = seededRandom(0);
 
-    for (let i = 0; i < 100000; i++) {
+    const INSTANCE_COUNT = 20000;
+
+    const geometries = [];
+
+    for (let i = 0; i < 1000; i++) {
+        geometries.push(new BoxBufferGeometry());
+    }
 
+    for (let i = 0; i < INSTANCE_COUNT; i++) {
+        const geometry = randomFromArray(random, geometries);
         const sg = ShadedGeometry.from(geometry, material);
 
+        // sg.draw_method = DRAW_METHOD_PLAIN;
         sg.draw_method = DRAW_METHOD_INSTANCED;
+        // sg.draw_method = random() > 0.01 ? DRAW_METHOD_INSTANCED : DRAW_METHOD_PLAIN;
         sg.clearFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow);
 
         new EntityBuilder()
             .add(Transform.fromJSON({
                 position: {
-                    x: randomFloatBetween(random, -50, 50),
+                    x: randomFloatBetween(random, 0, 20),
                     y: randomFloatBetween(random, 0, 10),
-                    z: randomFloatBetween(random, -50, 50)
+                    z: randomFloatBetween(random, 0, 20)
                 },
                 rotation: Quaternion.random(random),
                 scale: 0.05

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

@@ -22,7 +22,6 @@ export function three_object_to_entity_composition(root) {
         }
 
         const sg = ShadedGeometry.from(root.geometry, root.material);
-        sg.draw_method = 1;
 
         entity.add(sg);
     }

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -11,6 +11,7 @@ import { StaticMaterialCache } from "../../../asset/loaders/material/StaticMater
 import { composeCompile } from "../../material/composeCompile.js";
 import { typed_array_copy } from "../../../../core/collection/array/typed/typed_array_copy.js";
 import { rewriteMaterial } from "./rewriteMaterial.js";
+import { max3 } from "../../../../core/math/max3.js";
 
 export class InstancedMeshGroup {
     /**
@@ -69,6 +70,13 @@ export class InstancedMeshGroup {
          */
         this.__attributeTransform = null;
 
+        /**
+         * Shortcut to buffer attribute data
+         * @type {Float32Array}
+         * @private
+         */
+        this.__attributeTransformArray = null;
+
         /**
          *
          * @type {Material}
@@ -167,7 +175,7 @@ export class InstancedMeshGroup {
         if (currentCapacity < size) {
             // grow
 
-            const newCapacityRaw = Math.max(
+            const newCapacityRaw = max3(
                 size,
                 currentCapacity * this.growFactor,
                 currentCapacity + this.growConstant
@@ -193,7 +201,7 @@ export class InstancedMeshGroup {
      * @param {number[]|ArrayLike<number>|Float32Array} transform 4x4 transform matrix of the instance
      */
     setTransformAt(index, transform) {
-        this.__attributeTransform.array.set(transform, index * 16);
+        this.__attributeTransformArray.set(transform, index * 16);
     }
 
     requestAttributeUpdate() {
@@ -357,6 +365,7 @@ export class InstancedMeshGroup {
         }
 
         //rewrite old attributes
+        this.__attributeTransformArray = newTransformArray;
         this.__attributeTransform = new InstancedBufferAttribute(newTransformArray, 16);
         this.__attributeTransform.setUsage(StreamDrawUsage);
 

package/engine/graphics/micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js

@@ -0,0 +1,150 @@
+import { AbstractRenderAdapter } from "../../../ecs/mesh-v2/render/adapters/AbstractRenderAdapter.js";
+import Vector2 from "../../../../../core/geom/Vector2.js";
+import { MaterialVertexSpec } from "../../render/v1/MaterialVertexSpec.js";
+
+/**
+ *
+ * @type {MaterialVertexSpec}
+ */
+const scratch_mvc = new MaterialVertexSpec();
+
+class MicronRenderContext {
+
+}
+
+export class MicronShadedGeometryRenderAdapter extends AbstractRenderAdapter {
+    constructor({
+                    vgtr
+                }) {
+        super();
+
+        /**
+         * @type {VGThreeRenderer}
+         * @private
+         */
+        this.__vgtr = vgtr;
+
+        /**
+         *
+         * @type {VirtualGeometry|null}
+         * @private
+         */
+        this.__vg = null;
+
+        /**
+         *
+         * @type {VirtualGeometryBuilder|null}
+         * @private
+         */
+        this.__vgb = null;
+
+        /**
+         *
+         * @type {Map<number, MicronGeometry>}
+         * @private
+         */
+        this.__geometry_map = new Map();
+
+        /**
+         *
+         * @type {Set<MaterialContext>}
+         * @private
+         */
+        this.__active_contexts = new Set();
+    }
+
+    add(sg) {
+
+        const micron_geometry = this.__geometry_map.get(sg.geometry.id);
+
+        // populate virtual geometry for this instance
+        this.__vgb.buildForMesh(sg.entity, micron_geometry, sg.transform);
+
+    }
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {CameraView} view
+     */
+    build_start(renderer, view) {
+        const resolution = new Vector2();
+        let pixelRatio = 1;
+
+        /**
+         *
+         * @type {THREE.RenderTarget}
+         */
+        const render_target = renderer.getRenderTarget();
+
+        if (render_target !== null) {
+            resolution.set(render_target.width, render_target.height);
+        } else {
+            renderer.getSize(resolution);
+            pixelRatio = renderer.getPixelRatio();
+        }
+
+        const vg_builder = this.__vgb;
+
+        vg_builder.resolution.set(resolution.x * pixelRatio, resolution.y * pixelRatio);
+        vg_builder.setMatricesFromCamera(view.camera);
+        vg_builder.setOutput(this.__vg);
+
+        vg_builder.build();
+    }
+
+    build_end() {
+        const contexts = this.__contexts_array;
+        const context_count = contexts.length;
+
+        /**
+         *
+         * @type {Map<number, MaterialContext>}
+         */
+        const instance_to_ctx = new Map();
+
+        for (let i = 0; i < context_count; i++) {
+            const ctx = contexts[i];
+            ctx.__patch_count = 0;
+
+            for (const instance of ctx.instances) {
+                instance_to_ctx.set(instance, ctx);
+            }
+        }
+
+        // sort patches into relevant contexts
+        const geometry = this.geometry;
+        const patch_count = geometry.patch_count;
+        const patches = geometry.patches;
+
+        for (let i = 0; i < patch_count; i++) {
+            const i3 = i * 3;
+
+            const instance_id = patches[i3];
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const ctx = instance_to_ctx.get(instance_id);
+
+            const target_address = ctx.__patch_count * 3;
+            ctx.__patch_count++;
+
+            const ctx_patches = ctx.__patches;
+
+            ctx_patches[target_address] = instance_id;
+            ctx_patches[target_address + 1] = geometry_id;
+            ctx_patches[target_address + 2] = patch_id;
+        }
+
+        // build each context
+        for (let i = 0; i < context_count; i++) {
+            const ctx = contexts[i];
+
+            ctx.build(this.geometry);
+        }
+    }
+
+    dispose() {
+
+    }
+}

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -141,13 +141,11 @@ export class VirtualGeometryBuilder {
      * @param {number} instance_id
      * @param {MicronGeometry} geometry
      * @param {number[]} transform world transform matrix of the instance
-     * @param {ActivePatchList} apl
      */
     buildForMesh(
         instance_id,
         geometry,
-        transform,
-        apl
+        transform
     ) {
         refinement_spec.build(transform, this.view_projection_matrix);
 

package/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -42,13 +42,6 @@ export class ThreeInstancedAdapter {
 
         this.__uniforms = Object.assign({}, this.__patch_data.genUniforms());
 
-        /**
-         *
-         * @type {WebGL2RenderingContext|null}
-         * @private
-         */
-        this.__gl_context = null;
-
         /**
          *
          * @type {Signal}

package/engine/graphics/micron/render/v1/MaterialContext.js

@@ -73,8 +73,7 @@ export class MaterialContext {
         return this.instances.has(occurrence.instance_id);
     }
 
-    init(gl) {
-        this.adapter.__gl_context = gl;
+    init() {
 
         const material = this.material.clone();
 

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -19,13 +19,6 @@ export class VGThreeRenderer {
 
         this.builder = new VirtualGeometryBuilder();
 
-        /**
-         *
-         * @type {WebGL2RenderingContext|null}
-         * @private
-         */
-        this.__gl_context = null;
-
         /**
          *
          * @type {Map<MaterialVertexSpec, MaterialContext>}
@@ -89,7 +82,7 @@ export class VGThreeRenderer {
 
         const ctx = new MaterialContext(spec, m);
 
-        ctx.init(this.__gl_context);
+        ctx.init();
 
         this.material_contexts.set(key, ctx);
         this.__contexts_array.push(ctx);
@@ -189,12 +182,13 @@ export class VGThreeRenderer {
             const ctx = instance_to_ctx.get(instance_id);
 
             const target_address = ctx.__patch_count * 3;
+            ctx.__patch_count++;
 
-            ctx.__patches[target_address] = instance_id;
-            ctx.__patches[target_address + 1] = geometry_id;
-            ctx.__patches[target_address + 2] = patch_id;
+            const ctx_patches = ctx.__patches;
 
-            ctx.__patch_count++;
+            ctx_patches[target_address] = instance_id;
+            ctx_patches[target_address + 1] = geometry_id;
+            ctx_patches[target_address + 2] = patch_id;
         }
 
         // build each context

package/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.js

@@ -1,6 +1,5 @@
 import { ParticleEmitterFlag } from "../../emitter/ParticleEmitterFlag.js";
 import { PARTICLE_ATTRIBUTE_DEATH_AGE, PARTICLE_ATTRIBUTE_POSITION } from "../../emitter/PARTICLE_ATTRIBUTES.js";
-import { EmissionShapeType } from "../../emitter/EmissionShapeType.js";
 import { Matrix4 } from "three";
 import { composeMatrix4 } from "../../../../../util/composeMatrix4.js";
 import Quaternion from "../../../../../../../core/geom/Quaternion.js";
@@ -14,55 +13,6 @@ import { SerializationMetadata } from "../../../../../../ecs/components/Serializ
 import { UnitCubeShape3D } from "../../../../../../../core/geom/3d/shape/UnitCubeShape3D.js";
 import { shape_from_json } from "../../../../../../../core/geom/3d/shape/json/shape_from_json.js";
 
-/**
- *
- * @param {ParticleLayer} layer
- * @returns {number}
- */
-function computeLayerVolume(layer) {
-    let base_volume = 0;
-
-    switch (layer.emissionShape) {
-        case EmissionShapeType.Box:
-            base_volume = 1;
-            break;
-        case EmissionShapeType.Sphere:
-            base_volume = 0.5236;
-            break;
-        case EmissionShapeType.Point:
-            base_volume = 0;
-            break;
-    }
-
-    const scale_volume = layer.scale.x * layer.scale.y * layer.scale.z;
-
-    return base_volume * scale_volume;
-}
-
-/**
- *
- * @param {ParticleEmitter} emitter
- * @param {Transform} transform
- * @returns {number}
- */
-function computeEmitterVolume(emitter, transform) {
-
-    const layers = emitter.layers;
-    const n = layers.length;
-
-    let layer_volume_sum = 0;
-
-    for (let i = 0; i < n; i++) {
-        const particleLayer = layers.get(i);
-
-        layer_volume_sum += computeLayerVolume(particleLayer);
-    }
-
-    const scale_volume = transform.scale.x * transform.scale.y * transform.scale.z;
-
-    return layer_volume_sum * scale_volume;
-}
-
 const DEFAULT_ATTRIBUTE_VALUES = {
     color: [1, 1, 1, 1],
     age: [0],

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.35.1",
+  "version": "2.35.4",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",