@woosh/meep-engine 2.92.6 → 2.92.8

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.92.6",
+  "version": "2.92.8",
   "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":"AAwRA;;;;GAIG;AACH,mGAaC;wCApSuC,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,10 +3,60 @@ 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";
 
+
+/**
+ *
+ * @param {EntityNode} node
+ * @returns {String}
+ */
+function get_node_name(node) {
+    /**
+     * @type {Name}
+     */
+    const name = node.entity.getComponentSafe(Name);
+
+    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
@@ -16,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 child_count = children.length;
-
+        const sub_node = find_node(node, part);
 
-        for (let j = 0; j < child_count; j++) {
-            /**
-             * @type {EntityNode}
-             */
-            const child = children[j];
+        if (sub_node === undefined) {
 
-            const name = child.entity.getComponentSafe(Name);
+            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)}]`);
 
-            if (name.getValue() === part) {
-                node = child;
-                continue main;
-            }
         }
 
-        throw new Error(`Child '${part}' not found, at index ${i} of [${path_parts.join(', ')}]`);
+        node = sub_node;
     }
 
     return node;
@@ -285,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,10 +37,8 @@ async function main(engine) {
         pitch: 0.030000000000008027,
         yaw: 3.123185307179593,
     });
-
-    const controller = new SGMeshAnimationController();
-
-    [
+    //
+    make_sample('data/models/samples/InterpolationTest.glb',[
         'Step Scale',
         'Linear Scale',
         'CubicSpline Scale',
@@ -50,23 +48,45 @@ async function main(engine) {
         'Step Translation',
         'CubicSpline Translation',
         'Linear Translation'
-    ].forEach(name => {
+    ],engine.entityManager.dataset);
+    //
+    // make_sample('data/models/samples/BoxAnimated.glb',[
+    //    'animation_01'
+    // ],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();
+
+    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));