@woosh/meep-engine 2.36.11 → 2.36.12

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.spec.js

@@ -111,6 +111,7 @@ test("add and remove 5 nodes", () => {
 
     for (let i = 0; i < 5; i++) {
         const a = bvh.allocate_node();
+        bvh.node_set_user_data(a, a);
         bvh.insert_leaf(a);
 
         leaves.push(a);
@@ -127,6 +128,8 @@ test("add and remove 5 nodes", () => {
 
         const leaf = leaves.shift();
 
+        expect(bvh.node_get_user_data(leaf)).toBe(leaf);
+
         bvh.remove_leaf(leaf);
 
         removed_leaves.push(leaf);

package/core/bvh2/bvh3/bvh_collect_user_data.js

@@ -0,0 +1,60 @@
+//
+
+import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+
+const traversal_stack = [];
+/**
+ *
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number} node
+ */
+export function bvh_collect_user_data(destination, destination_offset, bvh, node) {
+
+    if (node === NULL_NODE) {
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    let traversal_cursor = 0;
+
+    traversal_stack[traversal_cursor++] = node;
+
+    let result_cursor = destination_offset;
+
+    while (traversal_cursor > 0) {
+        traversal_cursor--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = traversal_stack[traversal_cursor];
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            traversal_stack[traversal_cursor++] = child1;
+            traversal_stack[traversal_cursor++] = child2;
+
+        } else {
+            // leaf node
+
+            destination[result_cursor++] = bvh.node_get_user_data(node);
+        }
+    }
+
+    // drop stack frame
+
+    return result_cursor - destination_offset;
+}

package/core/bvh2/bvh3/bvh_query_user_data_by_frustum.js

@@ -0,0 +1,85 @@
+//
+import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { aabb3_array_intersects_frustum_degree } from "../aabb3/aabb3_array_intersects_frustum_degree.js";
+import { bvh_collect_user_data } from "./bvh_collect_user_data.js";
+
+const traversal_stack = [];
+
+const scratch_aabb = [];
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]|Float32Array} frustum
+ */
+export function bvh_query_user_data_by_frustum(
+    result,
+    result_offset,
+    bvh,
+    frustum
+) {
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    let traversal_cursor = 0;
+
+    traversal_stack[traversal_cursor++] = root;
+
+    let result_cursor = result_offset;
+
+    while (traversal_cursor > 0) {
+        traversal_cursor--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = traversal_stack[traversal_cursor];
+
+        // test node against the ray
+        bvh.node_get_aabb(node, scratch_aabb);
+        const intersection = aabb3_array_intersects_frustum_degree(scratch_aabb, frustum);
+
+        if (intersection === 0) {
+            // fully outside
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            if (intersection === 2) {
+                // fully inside
+                result_cursor += bvh_collect_user_data(result, result_cursor, bvh, node);
+                continue;
+            }
+
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            traversal_stack[traversal_cursor++] = child1;
+            traversal_stack[traversal_cursor++] = child2;
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = bvh.node_get_user_data(node);
+        }
+    }
+
+    // drop stack frame
+
+    return result_cursor - result_offset;
+}

package/core/bvh2/bvh3/bvh_query_user_data_generic.js

@@ -0,0 +1,79 @@
+import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const traversal_stack = [];
+
+/**
+ *
+ * @type {number}
+ */
+let traversal_cursor = 0;
+
+
+/**
+ *
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BVHQuery} query
+ * @returns {number}
+ */
+export function bvh_query_user_data_generic(
+    result, result_offset,
+    bvh, query
+) {
+    const stack_frame_address = traversal_cursor;
+
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    traversal_stack[traversal_cursor++] = root;
+
+    let result_cursor = result_offset;
+
+    while (traversal_cursor > stack_frame_address) {
+        traversal_cursor--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = traversal_stack[traversal_cursor];
+
+        // test node against the ray
+        const pass = query.evaluate(node, bvh);
+
+        if (!pass) {
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            traversal_stack[traversal_cursor++] = child1;
+            traversal_stack[traversal_cursor++] = child2;
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = bvh.node_get_user_data(node);
+        }
+    }
+
+    // drop stack frame
+    traversal_cursor = stack_frame_address;
+
+    return result_cursor - result_offset;
+}

package/engine/graphics/ecs/mesh/Mesh.js

@@ -332,6 +332,21 @@ class Mesh {
         return result;
     }
 
+    /**
+     *
+     * @param {string} url
+     * @returns {Mesh}
+     */
+    static fromURL(url) {
+        const r = new Mesh();
+
+        r.url = url;
+        r.castShadow = true;
+        r.receiveShadow = true;
+
+        return r;
+    }
+
     /**
      *
      * @param {string} name

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

@@ -228,8 +228,8 @@ export class ShadedGeometrySystem extends System {
         // 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);
+        this.__bvh_binary.insert_leaf(bvh_node_id);
 
         sg.__bvh_tree = this.__bvh_binary;
         sg.__bvh_leaf_id = bvh_node_id;

package/engine/graphics/ecs/mesh-v2/aggregate/prototypeSGMesh.js

@@ -8,9 +8,10 @@ import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
-import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
-import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
 import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { SGMeshEvents } from "./SGMeshEvents.js";
+import { ShadedGeometry } from "../ShadedGeometry.js";
+import { MeshSystem } from "../../mesh/MeshSystem.js";
 
 new EngineHarness().initialize({
     configuration(config, engine) {
@@ -18,6 +19,7 @@ new EngineHarness().initialize({
             new ShadedGeometrySystem(engine),
             new SGMeshSystem(engine),
             new BehaviorSystem(engine),
+            new MeshSystem(engine),
             new TransformAttachmentSystem()
         );
 
@@ -36,18 +38,32 @@ function main(engine) {
 
     const ecd = engine.entityManager.dataset;
 
-    const mesh = SGMesh.fromURL("data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf");
+    // const mesh = SGMesh.fromURL("data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf");
+    const mesh = SGMesh.fromURL("moicon/ztest_object_many_pieces/model.gltf");
+    // const mesh = Mesh.fromURL("moicon/ztest_object_many_pieces/model.gltf");
 
     new EntityBuilder()
         .add(Transform.fromJSON({
             position: new Vector3(10, 0, 10)
         }))
-        // .add(SGMesh.fromURL("data/models/snaps/cube_blue.gltf"))
         .add(mesh)
-        .add(BehaviorComponent.fromOne(OrbitingBehavior.from({
+     /*   .add(BehaviorComponent.fromOne(OrbitingBehavior.from({
             center: new Vector3(10, 0, 10),
             radius: 5,
             rate: 2
-        })))
+        })))*/
+        .addEventListener(SGMeshEvents.AssetLoaded, () => {
+            mesh.__node.traverse(n => {
+                /**
+                 *
+                 * @type {ShadedGeometry}
+                 */
+                const sg = n.entity.getComponent(ShadedGeometry);
+
+                if (sg !== null) {
+                    sg.draw_method = 1;
+                }
+            });
+        })
         .build(ecd);
 }

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

@@ -2,9 +2,14 @@ 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";
+import { bvh_query_user_data_by_frustum } from "../../../../../core/bvh2/bvh3/bvh_query_user_data_by_frustum.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const collection_array = [];
 
 /**
  * 1 - collect visible meshes
@@ -84,19 +89,12 @@ export class ShadedGeometryRendererContext {
 
 
         // get all meshes
-
-        const data = [];
-
-        const query = BVHQueryIntersectsFrustum.from(view.frustum);
-
-        const intersection_count = bvh_query_leaves_generic(data, 0, bvh, query);
+        const intersection_count = bvh_query_user_data_by_frustum(collection_array, 0, bvh, view.frustum);
 
         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);
+            const entity = collection_array[i];
 
             /**
              *

package/engine/graphics/micron/plugin/MicronRenderPlugin.js

@@ -8,11 +8,15 @@ import { computeGeometryEquality } from "../../../asset/loaders/geometry/geometr
 import { CachedAsyncMap } from "../../../../core/collection/map/CachedAsyncMap.js";
 import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteHashMap.js";
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
-import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
+import {
+    MicronGeometryBinarySerializationAdapter
+} from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
 import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { ArrayBufferLoader } from "../../../asset/loaders/ArrayBufferLoader.js";
 import { ASSET_TYPE_ARRAY_BUFFER, GLTFAssetTransformer } from "./GLTFAssetTransformer.js";
+import { ShadedGeometrySystem } from "../../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { MicronShadedGeometryRenderAdapter } from "./shaded_geometry/MicronShadedGeometryRenderAdapter.js";
 
 /**
  *
@@ -85,6 +89,12 @@ export class MicronRenderPlugin extends EnginePlugin {
          */
         this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
 
+        /**
+         *
+         * @type {ShadedGeometrySystem|null}
+         * @private
+         */
+        this.__sg_system = null;
     }
 
     /**
@@ -135,6 +145,58 @@ export class MicronRenderPlugin extends EnginePlugin {
         view.on.preRender.remove(observer);
     }
 
+    /**
+     *
+     * @param {System} system
+     * @private
+     */
+    __handle_system_added(system) {
+        if (this.__sg_system !== null) {
+            return;
+        }
+
+        if (!(system instanceof ShadedGeometrySystem)) {
+            return;
+        }
+
+        /**
+         *
+         * @type {ShadedGeometrySystem|null}
+         */
+        const sg_system = system;
+
+        sg_system.register_render_adapter(2, () => {
+            const adapter = new MicronShadedGeometryRenderAdapter();
+
+            adapter.ctx = this.__vgtr.ctx;
+
+            return adapter;
+        });
+
+        this.__sg_system = sg_system;
+    }
+
+    /**
+     *
+     * @param {System} system
+     * @private
+     */
+    __handle_system_removed(system) {
+        if (this.__sg_system === null) {
+            return;
+        }
+
+        if (!(system instanceof ShadedGeometrySystem)) {
+            return;
+        }
+
+        if (this.__sg_system !== system) {
+            return;
+        }
+
+        this.__sg_system.unregister_render_adapter(2);
+    }
+
     async startup() {
 
         const engine = this.engine;
@@ -167,6 +229,11 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         this.__persisted_geometry.attach_storage(engine.storage);
 
+        engine.entityManager.on.systemAdded.add(this.__handle_system_added, this);
+        engine.entityManager.on.systemRemoved.add(this.__handle_system_removed, this);
+
+        engine.entityManager.systems.forEach(this.__handle_system_added, this);
+
         await super.startup();
     }
 
@@ -192,6 +259,11 @@ export class MicronRenderPlugin extends EnginePlugin {
         // clear all observer
         ge.views.elements.forEach(this.__handle_view_removed, this);
 
+        engine.entityManager.on.systemAdded.remove(this.__handle_system_added, this);
+        engine.entityManager.on.systemRemoved.remove(this.__handle_system_removed, this);
+
+        engine.entityManager.systems.forEach(this.__handle_system_removed, this);
+
         await super.shutdown();
     }
 }

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.36.11",
+  "version": "2.36.12",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",