@woosh/meep-engine 2.35.15 → 2.36.0

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

@@ -53,6 +53,7 @@ async function load_gltf(path, engine) {
     composition.build(ecd);
     // console.profileEnd('composition build');
     console.timeEnd('composition build');
+
 }
 
 async function timeout(t = 1) {

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

@@ -22,7 +22,6 @@ import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/Orb
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
 import { MicronShadedGeometryRenderAdapter } from "../../../micron/plugin/shaded_geometry/MicronShadedGeometryRenderAdapter.js";
 import { MicronRenderContext } from "../../../micron/render/v1/MicronRenderContext.js";
-import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
 
 const eh = new EngineHarness();
 
@@ -100,10 +99,10 @@ async function main(engine) {
         const sg = ShadedGeometry.from(geometry, material);
 
         // sg.draw_method = DRAW_METHOD_PLAIN;
-        // sg.draw_method = DRAW_METHOD_INSTANCED;
+        sg.draw_method = DRAW_METHOD_INSTANCED;
         // sg.draw_method = 2;
-        sg.draw_method = randomIntegerBetween(random, 0, 2);
-        // sg.draw_method = random() > 0.01 ? DRAW_METHOD_INSTANCED : DRAW_METHOD_PLAIN;
+        // sg.draw_method = DRAW_METHOD_INSTANCED;
+        // sg.draw_method = random() > 0.5 ? DRAW_METHOD_INSTANCED : 2;
         sg.clearFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow);
 
         new EntityBuilder()

package/engine/graphics/ecs/path/PathDisplaySystem.js

@@ -125,7 +125,8 @@ class PathDisplayContext extends SystemEntityContext {
             try {
                 builder(spec.style, path, this.system, ownedEntities);
             } catch (e) {
-                console.error(`Failed to build path of type '${spec.type}': ${e}`);
+                console.error(`Failed to build path of type '${spec.type}'`);
+                console.error(e);
             }
         }
 

package/engine/graphics/ecs/path/testPathDisplaySystem.js

@@ -359,14 +359,14 @@ function main(engine) {
 
     const pathDisplay = new PathDisplay();
     pathDisplay.specs.push(
-        PathDisplaySpec.from(
-            PathDisplayType.Ribbon,
-            trailPathStyle
-        ),
-        PathDisplaySpec.from(
-            PathDisplayType.Entity,
-            sample_style_entity()
-        ),
+        // PathDisplaySpec.from(
+        //     PathDisplayType.Ribbon,
+        //     trailPathStyle
+        // ),
+        // PathDisplaySpec.from(
+        //     PathDisplayType.Entity,
+        //     sample_style_entity()
+        // ),
         PathDisplaySpec.from(
             PathDisplayType.Tube,
             sample_style_tube()

package/engine/graphics/ecs/path/tube/CapType.d.ts

@@ -0,0 +1,5 @@
+export enum CapType {
+    None,
+    Flat,
+    Round
+}

package/engine/graphics/ecs/path/tube/CapType.js

@@ -0,0 +1,9 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const CapType = {
+    None: 0,
+    Flat: 1,
+    Round: 2
+};

package/engine/graphics/ecs/path/tube/TubePathStyle.d.ts

@@ -2,6 +2,7 @@ import {Color} from "../../../../../core/color/Color";
 import {TubeMaterialType} from "./TubeMaterialType";
 import {StandardMaterialDefinition} from "./StandardMaterialDefinition";
 import {MatcapMaterialDefinition} from "./MatcapMaterialDefinition";
+import {CapType} from "./CapType";
 
 export class TubePathStyle {
     public color: Color
@@ -14,4 +15,5 @@ export class TubePathStyle {
     public cast_shadow: boolean
     public receive_shadow: boolean
     public path_mask: number[]
+    public cap_type: CapType
 }

package/engine/graphics/ecs/path/tube/TubePathStyle.js

@@ -2,6 +2,7 @@ import { Color } from "../../../../../core/color/Color.js";
 import { TubeMaterialType } from "./TubeMaterialType.js";
 import { assert } from "../../../../../core/assert.js";
 import { MatcapMaterialDefinition } from "./MatcapMaterialDefinition.js";
+import { CapType } from "./CapType.js";
 
 const DEFAULT_COLOR = Object.freeze({ r: 1, g: 1, b: 1 });
 
@@ -71,6 +72,11 @@ export class TubePathStyle {
          * @type {number[]}
          */
         this.path_mask = [0, 1];
+
+        /**
+         * @type {CapType}
+         */
+        this.cap_type = CapType.Flat;
     }
 
     static fromJSON(j) {
@@ -91,7 +97,8 @@ export class TubePathStyle {
                  radial_resolution = 16,
                  cast_shadow = false,
                  receive_shadow = false,
-                 path_mask = [0, 1]
+                 path_mask = [0, 1],
+                 cap_type = CapType.None
              }) {
         assert.enum(material_type, TubeMaterialType, 'material_type');
         assert.isNumber(opacity, 'opacity');
@@ -106,6 +113,7 @@ export class TubePathStyle {
 
         assert.greaterThanOrEqual(path_mask.length, 2, 'path_mask length bust be at least 2');
         assert.ok(path_mask.length % 2 === 0, 'path_mask length bust be multiple of 2');
+        assert.enum(cap_type, CapType, 'cap_type');
 
         if (typeof color === 'string') {
             this.color.parse(color);
@@ -123,6 +131,7 @@ export class TubePathStyle {
         this.receive_shadow = receive_shadow;
 
         this.path_mask = path_mask;
+        this.cap_type = cap_type;
 
         switch (material_type) {
             case TubeMaterialType.Matcap: