@woosh/meep-engine 2.92.7 → 2.92.9

package/build/meep.module.js

@@ -65751,7 +65751,7 @@ function bvh32_from_indexed_geometry(bvh, vertices, indices) {
  */
 function bvh32_from_unindexed_geometry(bvh, vertices) {
 
-    const triangle_count = indices.length / 3;
+    const triangle_count = vertices.length / 3;
 
     bvh.setLeafCount(triangle_count);
     bvh.initialize_structure();

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.92.7",
+  "version": "2.92.9",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/engine/animation/curve/ecd_bind_animation_curve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ecd_bind_animation_curve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/ecd_bind_animation_curve.js"],"names":[],"mappings":"AAuSA;;;;GAIG;AACH,mGAaC;wCAnTuC,8BAA8B"}
+{"version":3,"file":"ecd_bind_animation_curve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/ecd_bind_animation_curve.js"],"names":[],"mappings":"AAgUA;;;;GAIG;AACH,mGAsBC;wCApVuC,8BAA8B"}

package/src/engine/animation/curve/ecd_bind_animation_curve.js

@@ -3,6 +3,7 @@ import { AnimatedValueBinding } from "../../graphics/ecs/mesh-v2/aggregate/anima
 import { BoundQuaternionWriter } from "../../graphics/ecs/mesh-v2/aggregate/animation/BoundQuaternionWriter.js";
 import { BoundValueWriter } from "../../graphics/ecs/mesh-v2/aggregate/animation/BoundValueWriter.js";
 import { BoundVector3Writer } from "../../graphics/ecs/mesh-v2/aggregate/animation/BoundVector3Writer.js";
+import { logger } from "../../logging/GlobalLogger.js";
 import { AnimationCurve } from "./AnimationCurve.js";
 import { EntityNodeAnimationClip } from "./EntityNodeAnimationClip.js";
 import { Keyframe } from "./Keyframe.js";
@@ -22,6 +23,40 @@ function get_node_name(node) {
     return name.getValue();
 }
 
+/**
+ * Following THREE.js PropertyBinding.findNode implementation
+ * @param {EntityNode} root
+ * @param {string} nodeName
+ * @returns {EntityNode|undefined}
+ */
+function find_node(root, nodeName) {
+
+    const root_name = get_node_name(root);
+
+    if (root_name === nodeName) {
+        return root;
+    }
+
+    // search into node subtree.
+    const children = root.children;
+
+    const child_count = children.length;
+
+
+    for (let j = 0; j < child_count; j++) {
+        /**
+         * @type {EntityNode}
+         */
+        const child = children[j];
+
+        const subtree_result = find_node(child, nodeName);
+
+        if (subtree_result !== undefined) {
+            return subtree_result;
+        }
+    }
+}
+
 /**
  *
  * @param {EntityNode} root
@@ -31,30 +66,20 @@ function entity_node_resolve_path(root, path_parts) {
 
     let node = root;
 
-    main:for (let i = 0; i < path_parts.length; i++) {
+    const part_count = path_parts.length;
+    for (let i = 0; i < part_count; i++) {
 
         const part = path_parts[i];
 
-        const children = node.children;
+        const sub_node = find_node(node, part);
 
-        const child_count = children.length;
+        if (sub_node === undefined) {
 
+            throw new Error(`Child '${part}' not found, at index ${i} of [${path_parts.join(', ')}]. Valid names at this level: [${node.children.map(get_node_name)}]`);
 
-        for (let j = 0; j < child_count; j++) {
-            /**
-             * @type {EntityNode}
-             */
-            const child = children[j];
-
-            const name = get_node_name(child);
-
-            if (name === part) {
-                node = child;
-                continue main;
-            }
         }
 
-        throw new Error(`Child '${part}' not found, at index ${i} of [${path_parts.join(', ')}]. Valid names at this level: [${children.map(get_node_name)}]`);
+        node = sub_node;
     }
 
     return node;
@@ -300,9 +325,18 @@ function convert_three_track(track, node) {
  */
 export function convert_three_clip(node, clip) {
     const three_tracks = clip.tracks;
+    const track_count = three_tracks.length;
 
-    const tracks = three_tracks.map(t => convert_three_track(t, node));
+    const tracks = [];
 
+    for (let i = 0; i < track_count; i++) {
+        try {
+            const engine_track = convert_three_track(three_tracks[i], node);
+            tracks.push(engine_track);
+        } catch (e) {
+            logger.error(`Failed to parse track[${i}]: ${e.message}`);
+        }
+    }
 
     const r = new EntityNodeAnimationClip();
 

package/src/engine/animation/curve/prototypeGLTF.js

@@ -37,36 +37,56 @@ async function main(engine) {
         pitch: 0.030000000000008027,
         yaw: 3.123185307179593,
     });
+    //
+    // make_sample('data/models/samples/InterpolationTest.glb',[
+    //     'Step Scale',
+    //     'Linear Scale',
+    //     'CubicSpline Scale',
+    //     'Step Rotation',
+    //     'CubicSpline Rotation',
+    //     'Linear Rotation',
+    //     'Step Translation',
+    //     'CubicSpline Translation',
+    //     'Linear Translation'
+    // ],engine.entityManager.dataset);
+    //
+    make_sample('data/models/samples/BoxAnimated.glb',[
+       'animation_0'
+    ],engine.entityManager.dataset);
+
+    // make_sample('data/models/samples/animatedbox1.gltf', [
+    //     'All Animations'
+    // ], engine.entityManager.dataset);
+}
+
+/**
+ *
+ * @param {string} path
+ * @param {string[]} animations
+ * @param {EntityComponentDataset} ecd
+ */
+function make_sample(path, animations, ecd) {
 
     const controller = new SGMeshAnimationController();
 
-    [
-        'Step Scale',
-        'Linear Scale',
-        'CubicSpline Scale',
-        'Step Rotation',
-        'CubicSpline Rotation',
-        'Linear Rotation',
-        'Step Translation',
-        'CubicSpline Translation',
-        'Linear Translation'
-    ].forEach(name => {
+    animations.forEach(name => {
 
-        controller.start(name,true);
+        controller.start(name, true);
 
     })
 
     new Entity()
-        .add(SGMesh.fromURL('data/models/samples/InterpolationTest.glb'))
+        .add(SGMesh.fromURL(path))
         .add(controller)
         .add(new Transform())
-        .build(engine.entityManager.dataset);
-
+        .build(ecd);
 }
 
 harness.initialize({
     configuration(config, engine) {
-        config.addLoader(GameAssetType.ModelGLTF, new GLTFAssetLoader());
+        const gltfAssetLoader = new GLTFAssetLoader();
+        config.addLoader(GameAssetType.ModelGLTF, gltfAssetLoader);
+        config.addLoader(GameAssetType.ModelGLTF_JSON, gltfAssetLoader);
         config.addSystem(new SGMeshAnimationControllerSystem(engine));
         config.addSystem(new SGMeshSystem(engine));
         config.addSystem(new ShadedGeometrySystem(engine));

package/src/engine/graphics/geometry/bvh/buffered/bvh32_from_unindexed_geometry.js

@@ -7,7 +7,7 @@ import { bvh32_set_leaf_from_triangle } from "./bvh32_set_leaf_from_triangle.js"
  */
 export function bvh32_from_unindexed_geometry(bvh, vertices) {
 
-    const triangle_count = indices.length / 3;
+    const triangle_count = vertices.length / 3;
 
     bvh.setLeafCount(triangle_count);
     bvh.initialize_structure();

package/src/engine/graphics/geometry/bvh/buffered/bvh32_from_unindexed_geometry.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bvh32_from_unindexed_geometry.spec.d.ts.map

package/src/engine/graphics/geometry/bvh/buffered/bvh32_from_unindexed_geometry.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh32_from_unindexed_geometry.spec.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/bvh/buffered/bvh32_from_unindexed_geometry.spec.js"],"names":[],"mappings":""}

package/src/engine/graphics/geometry/bvh/buffered/bvh32_from_unindexed_geometry.spec.js

@@ -0,0 +1,16 @@
+import { BinaryUint32BVH } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+import { bvh32_from_unindexed_geometry } from "./bvh32_from_unindexed_geometry.js";
+
+test("1 triangle geometry", () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh32_from_unindexed_geometry(bvh, new Float32Array([1, 2, 3]));
+
+    const address = bvh.getNodeAddress(0);
+
+    const bounds = [];
+
+    bvh.readBounds(address, bounds, 0);
+
+    expect(bounds).toEqual([1, 2, 3, 1, 2, 3]);
+});