@woosh/meep-engine 2.35.1 → 2.35.2

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/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.js

@@ -133,11 +133,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 +159,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();
     }

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/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 { build_three_object } from "../build_three_object.js";
 
 export class GenericRendererAdapter extends AbstractRenderAdapter {
     constructor() {

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

@@ -2,11 +2,42 @@ 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 { 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);
 
@@ -80,13 +127,14 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
     }
 
     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/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/render/v1/VGThreeRenderer.js

@@ -189,12 +189,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/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.2",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",