@woosh/meep-engine 2.35.17 → 2.36.2

package/engine/ecs/EntityComponentDataset.js

@@ -56,13 +56,16 @@ function validateIndexValue(index, name) {
  * @param {BitSet} mask
  * @returns {boolean} true if mask matches completely, false otherwise
  */
-function matchComponentMask(componentOccupancy, entityIndex, componentTypeCount, mask) {
+function matchComponentMask(
+    componentOccupancy,
+    entityIndex,
+    componentTypeCount,
+    mask
+) {
     const offset = entityIndex * componentTypeCount;
 
-    let componentIndex;
-
     for (
-        componentIndex = mask.nextSetBit(0);
+        let componentIndex = mask.nextSetBit(0);
         componentIndex !== -1;
         componentIndex = mask.nextSetBit(componentIndex + 1)
     ) {

package/engine/ecs/foliage/InstancedFoliage.js

@@ -11,9 +11,9 @@ import { deserializeBinaryNodeFromBinaryBuffer } from "../../../core/bvh2/serial
 import { computeGeometryBoundingSphereMiniball } from "../../graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js";
 import { serializeRowFirstTable } from "../../../core/collection/table/serializeRowFirstTable.js";
 import { deserializeRowFirstTable } from "../../../core/collection/table/deserializeRowFirstTable.js";
-import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
 import { aabb3_from_v3_array_transformed } from "../../../core/bvh2/aabb3/aabb3_from_v3_array_transformed.js";
 import { ViewState } from "./ViewState.js";
+import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 
 /**
  * @readonly

package/engine/ecs/foliage/ViewState.js

@@ -2,8 +2,8 @@ import { BitSet } from "../../../core/binary/BitSet.js";
 import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
 import { queryBinaryNode_FrustumIntersections_Data } from "../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
-import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
 import Vector3 from "../../../core/geom/Vector3.js";
+import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 
 /**
  *

package/engine/ecs/parent/EntityNode.d.ts

@@ -5,15 +5,19 @@ import {Transform} from "../transform/Transform";
 export class EntityNode {
     constructor(entity?: EntityBuilder)
 
-    parent: EntityNode | null
-    entity: EntityBuilder
+    readonly parent: EntityNode | null
+    readonly entity: EntityBuilder
 
-    transform: Transform
+    readonly transform: Transform
+
+    readonly children: Readonly<EntityNode[]>
 
     addChild(node: EntityNode): boolean
 
     removeChild(node: EntityNode): boolean
 
+    traverseChildren(visitor: (EntityNode) => void, thisArg?: any): void
+
     build(ecd: EntityComponentDataset): void
 
     destroy(): void

package/engine/ecs/parent/EntityNode.js

@@ -41,6 +41,23 @@ export class EntityNode {
         this.__transform = new Transform();
     }
 
+    /**
+     *
+     * @param {(EntityNode) => *} visitor
+     * @param {*} [context]
+     */
+    traverseChildren(visitor, context) {
+        this.__children.forEach(visitor, context);
+    }
+
+    /**
+     *
+     * @return {Readonly<EntityNode[]>}
+     */
+    get children() {
+        return this.__children;
+    }
+
     /**
      *
      * @private
@@ -162,6 +179,10 @@ export class EntityNode {
         }
     }
 
+    /**
+     *
+     * @return {EntityBuilder}
+     */
     get entity() {
         return this.__entity;
     }

package/engine/ecs/parent/entity_node_compute_bounding_box.js

@@ -0,0 +1,41 @@
+import { ShadedGeometry } from "../../graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { AABB3 } from "../../../core/bvh2/aabb3/AABB3.js";
+
+const scratch_aabb3 = new AABB3();
+
+/**
+ *
+ * @param {AABB3} out
+ * @param {EntityNode} root
+ */
+export function entity_node_expand_bounding_box_to_fit(out, root) {
+    const sg = root.entity.getComponent(ShadedGeometry);
+
+    if (sg !== null) {
+        sg.getBoundingBox(scratch_aabb3);
+
+        out.expandToFit(scratch_aabb3);
+    }
+
+    const children = root.children;
+    const child_count = children.length;
+
+    for (let i = 0; i < child_count; i++) {
+        const child = children[i];
+
+        entity_node_expand_bounding_box_to_fit(out, child);
+    }
+}
+
+/**
+ *
+ * @param {AABB3} out
+ * @param {EntityNode} root
+ */
+export function entity_node_compute_bounding_box(out, root) {
+    // init bounds
+    out.setNegativelyInfiniteBounds();
+
+    // expand bounds to fit the tree
+    entity_node_expand_bounding_box_to_fit(out, root);
+}

package/engine/ecs/transform/Transform.js

@@ -4,9 +4,9 @@
 
 import Vector3 from "../../../core/geom/Vector3.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
-import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
-import { decompose_matrix_4_array } from "../../graphics/util/decompose_matrix_4_array.js";
+import { decompose_matrix_4_array } from "../../../core/geom/3d/decompose_matrix_4_array.js";
 import { mat4 } from "gl-matrix";
+import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 
 const delta = new Vector3();
 

package/engine/graphics/ecs/highlight/HighlightDefinition.d.ts

@@ -3,4 +3,14 @@ import {Color} from "../../../../core/color/Color";
 export class HighlightDefinition {
     color: Color
     opacity: number
+
+    static rgba(r: number, g: number, b: number, a?: number): HighlightDefinition
+
+    equals(other: HighlightDefinition): boolean
+
+    hash(): number
+
+    fromJSON(json: any): void
+
+    toJSON(): any
 }

package/engine/graphics/ecs/highlight/HighlightDefinition.js

@@ -1,6 +1,5 @@
 import { Color } from "../../../../core/color/Color.js";
 import { assert } from "../../../../core/assert.js";
-import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "../../../ecs/storage/COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
@@ -8,7 +7,7 @@ export class HighlightDefinition {
     constructor() {
 
         /**
-         *
+         * @readonly
          * @type {Color}
          */
         this.color = new Color();
@@ -18,12 +17,6 @@ export class HighlightDefinition {
          * @type {number}
          */
         this.opacity = 1;
-
-        /**
-         *
-         * @type {boolean}
-         */
-        this[COMPONENT_SERIALIZATION_TRANSIENT_FIELD] = false;
     }
 
     /**
@@ -73,4 +66,21 @@ export class HighlightDefinition {
 
         return r;
     }
+
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} [a]
+     * @return {HighlightDefinition}
+     */
+    static rgba(r, g, b, a = 1) {
+        const result = new HighlightDefinition();
+
+        result.color.setRGB(r, g, b);
+        result.opacity = a;
+
+        return result;
+    }
 }

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

@@ -5,8 +5,13 @@ export class ShadedGeometry {
     readonly geometry: BufferGeometry
     readonly material: Material
 
+    /**
+     * @deprecated
+     */
     readonly bvh: Readonly<AABB3>
 
+    getBoundingBox(destination: AABB3): void
+
     from(geometry: BufferGeometry, material: Material): void
 
     static from(geometry: BufferGeometry, material: Material): ShadedGeometry

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

@@ -1,11 +1,13 @@
-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 { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
+import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 
 const _aabb3 = new AABB3();
 
+const scratch_aabb3_array = new Float32Array(6);
+
 const DEFAULT_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
 ;
@@ -36,6 +38,15 @@ export class ShadedGeometry {
          */
         this.__bvh_leaf = new LeafNode(this, 0, 0, 0, 0, 0, 0);
 
+        this.__bvh_leaf_id = -1;
+        /**
+         *
+         * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
+         * @private
+         */
+        this.__bvh_tree = null;
+        this.__bvh_aabb = new Float32Array(6);
+
         /**
          * Transient, assigned in the system
          * @type {number}
@@ -75,7 +86,7 @@ export class ShadedGeometry {
      * @deprecated
      * @private
      */
-    get __cached_object(){
+    get __cached_object() {
         throw new Error('Deprecated');
     }
 
@@ -155,10 +166,22 @@ export class ShadedGeometry {
         return this.__transform;
     }
 
+    /**
+     * @deprecated
+     * @returns {LeafNode<ShadedGeometry>}
+     */
     get bvh() {
         return this.__bvh_leaf;
     }
 
+    /**
+     *
+     * @param {AABB3} destination
+     */
+    getBoundingBox(destination) {
+        destination.copy(this.__bvh_leaf);
+    }
+
     /**
      *
      * @param {THREE.BufferGeometry} geometry
@@ -195,22 +218,33 @@ export class ShadedGeometry {
         //
         this.__c_transform.toMatrix4(this.__transform);
 
+        this.update_bounds();
+
+        this.__bvh_tree.node_move_aabb(this.__bvh_leaf_id, this.__bvh_aabb);
+    }
+
+    update_bounds() {
         // update bounds
         const gbb = this.geometry.boundingBox;
 
         const min = gbb.min;
         const max = gbb.max;
 
-        _aabb3.setBounds(
-            min.x,
-            min.y,
-            min.z,
-            max.x,
-            max.y,
-            max.z
-        );
-
-        updateNodeByMatrix4AndBBB(this.__bvh_leaf, _aabb3, this.__transform);
+        const x0 = min.x;
+        const y0 = min.y;
+        const z0 = min.z;
+        const x1 = max.x;
+        const y1 = max.y;
+        const z1 = max.z;
+
+        scratch_aabb3_array[0] = x0;
+        scratch_aabb3_array[1] = y0;
+        scratch_aabb3_array[2] = z0;
+        scratch_aabb3_array[3] = x1;
+        scratch_aabb3_array[4] = y1;
+        scratch_aabb3_array[5] = z1;
+
+        aabb3_matrix4_project(this.__bvh_aabb, scratch_aabb3_array, this.__transform);
     }
 }
 

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

@@ -6,24 +6,14 @@ import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 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";
 import { assert } from "../../../../core/assert.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/bvh_query_leaves_generic.js";
+import { BVHQueryIntersectsRay } from "../../../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
 
-/**
- *
- * @type {BinaryNode|LeafNode[]}
- */
-const traversal_stack = [];
-
-/**
- *
- * @type {number}
- */
-let traversal_cursor = 0;
 
 /**
  *
@@ -38,7 +28,6 @@ const scratch_point = new SurfacePoint3();
 const scratch_m4 = new Float32Array(16);
 
 const scratch_ray_0 = new Float32Array(6);
-const scratch_ray_1 = new Float32Array(6);
 
 export class ShadedGeometrySystem extends System {
     /**
@@ -70,9 +59,6 @@ export class ShadedGeometrySystem extends System {
          */
         this.__view_contexts = new Map();
 
-        this.__bvh = new BinaryNode();
-        this.__bvh.setNegativelyInfiniteBounds();
-
         /**
          *
          * @type {Map<number, function():AbstractRenderAdapter>}
@@ -86,6 +72,13 @@ export class ShadedGeometrySystem extends System {
          * @private
          */
         this.__geometry_usage_counters = new Map();
+
+        /**
+         *
+         * @type {ExplicitBinaryBoundingVolumeHierarchy}
+         * @private
+         */
+        this.__bvh_binary = new ExplicitBinaryBoundingVolumeHierarchy();
     }
 
     /**
@@ -178,7 +171,13 @@ export class ShadedGeometrySystem extends System {
         this.__render_layer.buildVisibleSet = ((destination, destination_offset, view) => {
             const ctx = this.__view_contexts.get(view);
 
-            return ctx.collect(destination, destination_offset, graphics.renderer, view, this.__bvh);
+            const ecd = entityManager.dataset;
+
+            if (ecd === null) {
+                return 0;
+            }
+
+            return ctx.collect(destination, destination_offset, graphics.renderer, view, this.__bvh_binary, ecd);
         });
 
         readyCallback();
@@ -211,7 +210,8 @@ export class ShadedGeometrySystem extends System {
         t.rotation.onChanged.add(sg.updateTransform, sg);
         t.scale.onChanged.add(sg.updateTransform, sg);
 
-        sg.updateTransform();
+        t.toMatrix4(sg.__transform);
+        sg.update_bounds();
 
         const leaf_node = sg.bvh;
 
@@ -221,7 +221,15 @@ export class ShadedGeometrySystem extends System {
         // remember entity for lookups
         sg.__entity = entity;
 
-        this.__bvh.insertNode(leaf_node);
+        // insert BVH entry
+        const bvh_node_id = this.__bvh_binary.allocate_node();
+        this.__bvh_binary.node_set_aabb(bvh_node_id, sg.__bvh_aabb);
+        this.__bvh_binary.insert_leaf(bvh_node_id);
+        this.__bvh_binary.node_set_user_data(bvh_node_id, entity);
+
+        sg.__bvh_tree = this.__bvh_binary;
+        sg.__bvh_leaf_id = bvh_node_id;
+
 
         // update usage count
         const geometry_id = sg.geometry.id;
@@ -242,7 +250,10 @@ export class ShadedGeometrySystem extends System {
         t.rotation.onChanged.remove(sg.updateTransform, sg);
         t.scale.onChanged.remove(sg.updateTransform, sg);
 
-        sg.bvh.disconnect();
+        // disconnect BVH
+        const node_id = sg.__bvh_leaf_id;
+        this.__bvh_binary.remove_leaf(node_id);
+        this.__bvh_binary.release_node(node_id);
 
         const geometry_id = sg.geometry.id;
         const count_existing = this.__geometry_usage_counters.get(geometry_id);
@@ -279,107 +290,82 @@ export class ShadedGeometrySystem extends System {
         direction_x, direction_y, direction_z,
         filter_function = returnTrue, filter_function_context
     ) {
-        const root_bvh = this.__bvh;
-        const stack_frame_address = traversal_cursor;
-
-        traversal_stack[traversal_cursor++] = root_bvh;
 
         let best_distance = Infinity;
         let found_hit = false;
         let best_result = null;
 
-        while (traversal_cursor > stack_frame_address) {
-            traversal_cursor--;
+        const hits = [];
 
-            /**
-             *
-             * @type {BinaryNode|LeafNode<ShadedGeometry>}
-             */
-            const node = traversal_stack[traversal_cursor];
+        const hit_count = bvh_query_leaves_generic(hits, 0, this.__bvh_binary, BVHQueryIntersectsRay.from([origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]));
 
-            // test node against the ray
-            const intersects = aabb3_intersects_ray(
-                node.x0, node.y0, node.z0,
-                node.x1, node.y1, node.z1,
-                origin_x, origin_y, origin_z,
-                direction_x, direction_y, direction_z
-            );
+        const ecd = this.entityManager.dataset;
 
-            if (!intersects) {
-                continue;
-            }
+        if (ecd === null) {
+            return;
+        }
 
-            if (node.isBinaryNode) {
-                if (node.right !== null) {
-                    traversal_stack[traversal_cursor++] = node.right;
-                }
-                if (node.left !== null) {
-                    traversal_stack[traversal_cursor++] = node.left;
-                }
-            } else {
-                // leaf node
+        const sg_component_index = ecd.computeComponentTypeIndex(ShadedGeometry);
 
-                /**
-                 *
-                 * @type {ShadedGeometry}
-                 */
-                const sg = node.object;
+        for (let i = 0; i < hit_count; i++) {
+            const node_id = hits[i];
 
-                const entity = sg.__entity;
+            const entity = this.__bvh_binary.node_get_user_data(node_id);
 
-                if (!filter_function.call(filter_function_context, entity, sg)) {
-                    // filtered out
-                    continue;
-                }
+            /**
+             *
+             * @type {ShadedGeometry}
+             */
+            const sg = ecd.getComponentByIndex(entity, sg_component_index);
 
-                const m4 = sg.transform;
+            if (!filter_function.call(filter_function_context, entity, sg)) {
+                // filtered out
+                continue;
+            }
 
-                // get transform in local space
-                mat4.invert(scratch_m4, m4);
+            const m4 = sg.transform;
 
-                ray3_array_compose(
-                    scratch_ray_0,
-                    origin_x, origin_y, origin_z,
-                    direction_x, direction_y, direction_z
-                );
+            // get transform in local space
+            mat4.invert(scratch_m4, m4);
 
-                // transform ray to local space
-                ray3_array_apply_matrix4(scratch_ray_0, scratch_ray_0, scratch_m4);
+            ray3_array_compose(
+                scratch_ray_0,
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            );
 
-                const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_array(
-                    scratch_point,
-                    sg.geometry,
-                    scratch_ray_0
-                );
+            // transform ray to local space
+            ray3_array_apply_matrix4(scratch_ray_0, scratch_ray_0, scratch_m4);
 
-                if (!geometry_hit_found) {
-                    continue;
-                }
+            const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_array(
+                scratch_point,
+                sg.geometry,
+                scratch_ray_0
+            );
 
-                // transform hit contact into global space
-                scratch_point.applyMatrix4(m4);
+            if (!geometry_hit_found) {
+                continue;
+            }
 
-                found_hit = true;
+            // transform hit contact into global space
+            scratch_point.applyMatrix4(m4);
 
-                const hit_position = scratch_point.position;
+            found_hit = true;
 
-                const distance_sqr = v3_distance_sqr(
-                    hit_position.x, hit_position.y, hit_position.z,
-                    origin_x, origin_y, origin_z
-                );
+            const hit_position = scratch_point.position;
 
-                if (distance_sqr < best_distance) {
-                    contact.copy(scratch_point);
-                    best_result = sg;
-                    best_distance = distance_sqr;
-                }
+            const distance_sqr = v3_distance_sqr(
+                hit_position.x, hit_position.y, hit_position.z,
+                origin_x, origin_y, origin_z
+            );
 
+            if (distance_sqr < best_distance) {
+                contact.copy(scratch_point);
+                best_result = sg;
+                best_distance = distance_sqr;
             }
         }
 
-        // drop stack frame
-        traversal_cursor = stack_frame_address;
-
         if (found_hit) {
             return {
                 entity: best_result.__entity,

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

@@ -1,8 +1,10 @@
-import { queryBinaryNode_FrustumIntersections_Data } from "../../../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.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";
+import { bvh_query_leaves_generic } from "../../../../../core/bvh2/bvh3/bvh_query_leaves_generic.js";
+import { BVHQueryIntersectsFrustum } from "../../../../../core/bvh2/bvh3/query/BVHQueryIntersectsFrustum.js";
+import { ShadedGeometry } from "../ShadedGeometry.js";
 
 /**
  * 1 - collect visible meshes
@@ -66,9 +68,10 @@ export class ShadedGeometryRendererContext {
      * @param {number} destination_offset
      * @param {THREE.WebGLRenderer} renderer
      * @param {CameraView} view
-     * @param {BinaryNode<ShadedGeometry>} bvh
+     * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+     * @param {EntityComponentDataset} ecd
      */
-    collect(destination, destination_offset, renderer, view, bvh) {
+    collect(destination, destination_offset, renderer, view, bvh, ecd) {
         const adapters = this.adapters;
         const adapter_count = adapters.length;
 
@@ -84,14 +87,22 @@ export class ShadedGeometryRendererContext {
 
         const data = [];
 
-        const intersection_count = queryBinaryNode_FrustumIntersections_Data(data, 0, bvh, view.frustum);
+        const query = BVHQueryIntersectsFrustum.from(view.frustum);
+
+        const intersection_count = bvh_query_leaves_generic(data, 0, bvh, query);
+
+        const sg_component_index = ecd.computeComponentTypeIndex(ShadedGeometry);
 
         for (i = 0; i < intersection_count; i++) {
+            const node_index = data[i];
+
+            const entity = bvh.node_get_user_data(node_index);
+
             /**
              *
              * @type {ShadedGeometry}
              */
-            const sg = data[i];
+            const sg = ecd.getComponentByIndex(entity, sg_component_index);
 
             const adapter = adapters[sg.draw_method];
 

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

@@ -3,6 +3,7 @@ import { HashMap } from "../../../../../../core/collection/HashMap.js";
 import { InstancedMeshGroup } from "../../../../geometry/instancing/InstancedMeshGroup.js";
 import { ShadedGeometryFlags } from "../../ShadedGeometryFlags.js";
 import { DrawMode } from "../../DrawMode.js";
+import { StreamDrawUsage } from "three";
 
 const INSTANCED_EQUALITY_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
@@ -89,6 +90,7 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
             }
 
             im = new InstancedMeshGroup();
+            im.instance_usage = StreamDrawUsage;
             im.shrinkFactor = 0; // prevent shrinking as we're essentially rebuilding this geometry frame
 
             im.setMaterial(sg.material);