@woosh/meep-engine 2.92.24 → 2.93.2

package/build/meep.module.js

@@ -60511,54 +60511,21 @@ class HashMap {
      *
      * @returns {Iterator<V>}
      */
-    values() {
-        const entryIterator = this[Symbol.iterator]();
-
-        return {
-            next() {
-                const n = entryIterator.next();
-
-                if (n.done) {
-                    return {
-                        done: true,
-                        value: undefined
-                    };
-                } else {
-                    return {
-                        done: false,
-                        value: n.value[1]
-                    };
-                }
+    * values() {
 
-            }
-        };
+        for (const [k, v] of this) {
+            yield v;
+        }
     }
 
     /**
      *
      * @returns {Iterator<K>}
      */
-    keys() {
-        const entryIterator = this[Symbol.iterator]();
-
-        return {
-            next() {
-                const n = entryIterator.next();
-
-                if (n.done) {
-                    return {
-                        done: true,
-                        value: undefined
-                    };
-                } else {
-                    return {
-                        done: false,
-                        value: n.value[0]
-                    };
-                }
-
-            }
-        };
+    * keys() {
+        for (const [k, v] of this) {
+            yield k;
+        }
     }
 }
 

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.92.24",
+  "version": "2.93.2",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {
@@ -37,9 +37,6 @@
     "package.json",
     "README.md"
   ],
-  "optionalDependencies": {
-    "three": "0.136.0"
-  },
   "dependencies": {
     "fastest-levenshtein": "1.0.16",
     "gl-matrix": "3.4.3",
@@ -51,6 +48,11 @@
   "peerDependencies": {
     "three": ">=0.135.0"
   },
+  "peerDependenciesMeta": {
+    "three": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@babel/core": "7.22.15",
     "@babel/preset-env": "7.22.15",

package/src/core/collection/map/HashMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AAsHD;;;;;;;GAOG;AACH;IA2DI;;;;;;OAMG;IACH,4FALuB,MAAM,EAsC5B;IAlBG;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2HD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QAoEX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAcZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAYZ;IAuBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,4CAFa,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBAkDC;IAmBD,2CAwBC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAuBvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAuBvB;IAjFD,yDA2BC;;CAuDJ"}
+{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/HashMap.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH,uFAIC;AAsHD;;;;;;;GAOG;AACH;IA2DI;;;;;;OAMG;IACH,4FALuB,MAAM,EAsC5B;IAlBG;;;;;OAKG;IACH,iCAAsC;IACtC;;;;;OAKG;IACH,qCAA8C;IAOlD,mBAEC;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA2HD;;;;OAIG;IACH,SAHW,CAAC,SACD,CAAC,QAoEX;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,CAAC,GAAC,SAAS,CA+BvB;IAED;;;;;;;;OAQG;IACH,kBALW,CAAC,kBACQ,CAAC,KAAE,CAAC,0BAEZ,CAAC,CAcZ;IAED;;;;;OAKG;IACH,cAJW,CAAC,SACD,CAAC,GACA,CAAC,CAYZ;IAuBD;;;;OAIG;IACH,YAHW,CAAC,GACC,OAAO,CA+CnB;IAED;;;;;OAKG;IACH,4CAFa,OAAO,CA+BnB;IAOD;;OAEG;IACH,gBAkDC;IAmBD,2CAwBC;IAED;;;;OAIG;IACH,SAHW,CAAC,GACC,OAAO,CAInB;IAED;;OAEG;IACH,cA6BC;IA+BD;;;OAGG;IACH,UAFa,SAAS,CAAC,CAAC,CAOvB;IAED;;;OAGG;IACH,QAFa,SAAS,CAAC,CAAC,CAMvB;IAhDD,yDA2BC;;CAsBJ"}

package/src/core/collection/map/HashMap.js

@@ -831,53 +831,20 @@ export class HashMap {
      *
      * @returns {Iterator<V>}
      */
-    values() {
-        const entryIterator = this[Symbol.iterator]();
-
-        return {
-            next() {
-                const n = entryIterator.next();
-
-                if (n.done) {
-                    return {
-                        done: true,
-                        value: undefined
-                    };
-                } else {
-                    return {
-                        done: false,
-                        value: n.value[1]
-                    };
-                }
+    * values() {
 
-            }
-        };
+        for (const [k, v] of this) {
+            yield v;
+        }
     }
 
     /**
      *
      * @returns {Iterator<K>}
      */
-    keys() {
-        const entryIterator = this[Symbol.iterator]();
-
-        return {
-            next() {
-                const n = entryIterator.next();
-
-                if (n.done) {
-                    return {
-                        done: true,
-                        value: undefined
-                    };
-                } else {
-                    return {
-                        done: false,
-                        value: n.value[0]
-                    };
-                }
-
-            }
-        };
+    * keys() {
+        for (const [k, v] of this) {
+            yield k;
+        }
     }
 }

package/src/core/collection/set/HashSet.spec.js

@@ -20,4 +20,20 @@ test("add same element twice", () => {
     set.add("a");
 
     expect(set.size).toBe(1);
+});
+
+test("iterator symbol",()=>{
+
+    const set = new HashSet({
+        keyHashFunction: computeStringHash,
+        keyEqualityFunction: strictEquals
+    });
+
+    set.add("a");
+
+    const iterator = set[Symbol.iterator]();
+    expect(iterator.next()).toEqual({
+        done:false,
+        value: "a"
+    });
 });

package/src/core/math/spline/spline_hermite3.d.ts

@@ -1,10 +1,11 @@
 /**
  * Perform cubic hermite interpolation
- * @param {number} t normalized interpolation position (0..1)
+ * @see https://en.wikipedia.org/wiki/Cubic_Hermite_spline
+ * @param {number} t normalized interpolation position in interval [0,1]
  * @param {number} p0 first value
  * @param {number} p1 second value
- * @param {number} m0 first tangent
- * @param {number} m1 second tangent
+ * @param {number} m0 first tangent (tangent existing from first value)
+ * @param {number} m1 second tangent (tangent entering into second value)
  * @return {number}
  */
 export function spline_hermite3(t: number, p0: number, p1: number, m0: number, m1: number): number;

package/src/core/math/spline/spline_hermite3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline_hermite3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_hermite3.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,mCAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAajB"}
+{"version":3,"file":"spline_hermite3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline_hermite3.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,mCAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAajB"}

package/src/core/math/spline/spline_hermite3.js

@@ -1,10 +1,11 @@
 /**
  * Perform cubic hermite interpolation
- * @param {number} t normalized interpolation position (0..1)
+ * @see https://en.wikipedia.org/wiki/Cubic_Hermite_spline
+ * @param {number} t normalized interpolation position in interval [0,1]
  * @param {number} p0 first value
  * @param {number} p1 second value
- * @param {number} m0 first tangent
- * @param {number} m1 second tangent
+ * @param {number} m0 first tangent (tangent existing from first value)
+ * @param {number} m1 second tangent (tangent entering into second value)
  * @return {number}
  */
 export function spline_hermite3(t, p0, p1, m0, m1) {

package/src/engine/animation/clip/AnimationClip.d.ts

@@ -0,0 +1,4 @@
+export class AnimationClip {
+    name: string
+    readonly duration: number
+}

package/src/engine/animation/clip/AnimationClip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationClip.js"],"names":[],"mappings":"AAEA;IACI,aAAS;IACT;;;OAGG;IACH,QAFU,gBAAgB,CAEf;IAEX,uBAWC;CACJ"}

package/src/engine/animation/clip/AnimationClip.js

@@ -0,0 +1,23 @@
+import { max2 } from "../../../core/math/max2.js";
+
+export class AnimationClip {
+    name = ""
+    /**
+     *
+     * @type {AnimationTrack[]}
+     */
+    tracks = []
+
+    get duration() {
+        let r = 0;
+
+        const tracks = this.tracks;
+        const track_count = tracks.length;
+        for (let i = 0; i < track_count; i++) {
+            const track = tracks[i];
+            r = max2(r, track.duration)
+        }
+
+        return r;
+    }
+}

package/src/engine/animation/clip/AnimationClipBinding.d.ts

@@ -0,0 +1,14 @@
+import {AnimationClip} from "./AnimationClip";
+
+export class AnimationClipBinding {
+    /**
+     * @deprecated
+     */
+    readonly name: string
+    /**
+     * @deprecated
+     */
+    readonly duration: number
+
+    clip: AnimationClip
+}

package/src/engine/animation/clip/AnimationClipBinding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationClipBinding.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationClipBinding.js"],"names":[],"mappings":"AAGA;IA8BI,+EAQC;IApCD;;OAEG;IACH,oBAAI;IAGJ;;;OAGG;IACH,QAFU,qBAAqB,EAAE,CAEtB;IAEX;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAYD;;;;OAIG;IACH,8CA6BC;IAED;;;OAGG;IACH,cAFW,MAAM,QAWhB;CACJ;sCA5FqC,4BAA4B"}

package/src/engine/animation/clip/AnimationClipBinding.js

@@ -0,0 +1,94 @@
+import { assert } from "../../../core/assert.js";
+import { AnimationTrackBinding } from "./AnimationTrackBinding.js";
+
+export class AnimationClipBinding {
+
+    /**
+     * @type {AnimationClip}
+     */
+    clip
+
+
+    /**
+     *
+     * @type {AnimationTrackBinding[]}
+     */
+    tracks = []
+
+    /**
+     * @deprecated use `clip.name` directly instead
+     * @return {string}
+     */
+    get name() {
+        return this.clip.name
+    }
+
+    /**
+     * @deprecated use `clip.duration` directly instead
+     * @return {number}
+     */
+    get duration() {
+        return this.clip.duration;
+    }
+
+    static from(clip, root, binding_registry) {
+        const r = new AnimationClipBinding();
+
+        r.clip = clip;
+
+        r.bind(root, binding_registry);
+
+        return r;
+    }
+
+    /**
+     * @template T
+     * @param {T} root
+     * @param {Object<Type<BoundValueWriter>>} binding_registry
+     */
+    bind(root, binding_registry) {
+        const bound_tracks = this.tracks;
+
+        if (bound_tracks.length > 0) {
+            // clear out existing
+            bound_tracks.splice(0, bound_tracks.length);
+        }
+
+        const clip = this.clip;
+
+        const tracks = clip.tracks;
+        const track_count = tracks.length;
+        for (let i = 0; i < track_count; i++) {
+            const track = tracks[i];
+
+            const WriterClass = binding_registry[track.type];
+
+            if (WriterClass === undefined) {
+                throw new Error(`No binding class in registry for track type '${track.type}'`);
+            }
+
+            assert.isFunction(WriterClass, 'WriterClass');
+
+            const writer = new WriterClass();
+
+            writer.bind(root, track.path);
+
+            bound_tracks[i] = AnimationTrackBinding.from(writer, track);
+        }
+    }
+
+    /**
+     *
+     * @param {number} time time in seconds
+     */
+    writeAt(time) {
+        const tracks = this.tracks;
+        const track_count = tracks.length;
+
+        for (let i = 0; i < track_count; i++) {
+            const track = tracks[i];
+
+            track.writeAt(time);
+        }
+    }
+}

package/src/engine/animation/clip/AnimationTrack.d.ts

@@ -0,0 +1,45 @@
+export class AnimationTrack {
+    /**
+     *
+     * @param {AnimationCurve[]} curves
+     * @param {string} [name]
+     * @return {AnimationTrack}
+     */
+    static from(curves?: AnimationCurve[], name?: string): AnimationTrack;
+    /**
+     * Human-readable label
+     * @type {string}
+     */
+    name: string;
+    /**
+     * What property are we animating?
+     * @type {string[]}
+     */
+    path: string[];
+    /**
+     *
+     * @type {AnimationCurve[]}
+     */
+    curves: AnimationCurve[];
+    /**
+     * Special designator to help with interpolation
+     * For example, quaternion tracks will require sampled value to be normalized
+     * Based on this value, different bindings will be used
+     * @type {string}
+     */
+    type: string;
+    /**
+     * Time duration of the longest curve, in seconds
+     * @return {number}
+     */
+    get duration(): number;
+    get curveCount(): number;
+    /**
+     *
+     * @param {number[]|Float32Array|Float64Array} output
+     * @param {number} output_offset
+     * @param {number} time
+     */
+    sample(output: number[] | Float32Array | Float64Array, output_offset: number, time: number): void;
+}
+//# sourceMappingURL=AnimationTrack.d.ts.map

package/src/engine/animation/clip/AnimationTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationTrack.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationTrack.js"],"names":[],"mappings":"AAEA;IAkEI;;;;;OAKG;IACH,qBAJW,gBAAgB,SAChB,MAAM,GACL,cAAc,CASzB;IA9ED;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,MAFU,MAAM,EAAE,CAET;IAET;;;OAGG;IACH,QAFU,gBAAgB,CAEf;IAEX;;;;;OAKG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,uBAYC;IAED,yBAEC;IAED;;;;;OAKG;IACH,eAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QAWhB;CAgBJ"}

package/src/engine/animation/clip/AnimationTrack.js

@@ -0,0 +1,83 @@
+import { max2 } from "../../../core/math/max2.js";
+
+export class AnimationTrack {
+    /**
+     * Human-readable label
+     * @type {string}
+     */
+    name = ""
+
+    /**
+     * What property are we animating?
+     * @type {string[]}
+     */
+    path = []
+
+    /**
+     *
+     * @type {AnimationCurve[]}
+     */
+    curves = []
+
+    /**
+     * Special designator to help with interpolation
+     * For example, quaternion tracks will require sampled value to be normalized
+     * Based on this value, different bindings will be used
+     * @type {string}
+     */
+    type = ""
+
+    /**
+     * Time duration of the longest curve, in seconds
+     * @return {number}
+     */
+    get duration() {
+        const curves = this.curves;
+        const curve_count = curves.length;
+
+        let r = 0;
+        for (let i = 0; i < curve_count; i++) {
+            const curve = curves[i];
+
+            r = max2(r, curve.duration);
+        }
+
+        return r;
+    }
+
+    get curveCount() {
+        return this.curves.length;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array|Float64Array} output
+     * @param {number} output_offset
+     * @param {number} time
+     */
+    sample(output, output_offset, time) {
+        const curves = this.curves;
+        const curve_count = curves.length;
+
+        for (let i = 0; i < curve_count; i++) {
+            const curve = curves[i];
+
+            output[output_offset + i] = curve.evaluate(time)
+        }
+    }
+
+    /**
+     *
+     * @param {AnimationCurve[]} curves
+     * @param {string} [name]
+     * @return {AnimationTrack}
+     */
+    static from(curves = [], name = "") {
+        const r = new AnimationTrack();
+
+        r.curves = curves;
+        r.name = name;
+
+        return r;
+    }
+}

package/src/engine/animation/clip/AnimationTrackBinding.d.ts

@@ -0,0 +1,25 @@
+export class AnimationTrackBinding {
+    /**
+     *
+     * @param {BoundValueWriter} writer
+     * @param {AnimationTrack} track
+     * @returns {AnimationTrackBinding}
+     */
+    static from(writer: BoundValueWriter, track: AnimationTrack): AnimationTrackBinding;
+    /**
+     *
+     * @type {BoundValueWriter|null}
+     */
+    writer: BoundValueWriter | null;
+    /**
+     *
+     * @type {AnimationTrack}
+     */
+    track: AnimationTrack;
+    /**
+     *
+     * @param {number} time
+     */
+    writeAt(time: number): void;
+}
+//# sourceMappingURL=AnimationTrackBinding.d.ts.map

package/src/engine/animation/clip/AnimationTrackBinding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationTrackBinding.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationTrackBinding.js"],"names":[],"mappings":"AAEA;IAaI;;;;;OAKG;IACH,8DAFa,qBAAqB,CAWjC;IA3BD;;;OAGG;IACH,QAFU,mBAAiB,IAAI,CAElB;IAEb;;;OAGG;IACH,sBAAY;IAmBZ;;;OAGG;IACH,cAFW,MAAM,QAMhB;CACJ"}

package/src/engine/animation/clip/AnimationTrackBinding.js

@@ -0,0 +1,42 @@
+const sample = new Float64Array(1024);
+
+export class AnimationTrackBinding {
+    /**
+     *
+     * @type {BoundValueWriter|null}
+     */
+    writer = null
+
+    /**
+     *
+     * @type {AnimationTrack}
+     */
+    track = null
+
+    /**
+     *
+     * @param {BoundValueWriter} writer
+     * @param {AnimationTrack} track
+     * @returns {AnimationTrackBinding}
+     */
+    static from(writer, track) {
+
+        const r = new AnimationTrackBinding();
+
+        r.writer = writer;
+        r.track = track;
+
+        return r;
+
+    }
+
+    /**
+     *
+     * @param {number} time
+     */
+    writeAt(time) {
+        this.track.sample(sample, 0, time);
+
+        this.writer.write(sample);
+    }
+}

package/src/engine/animation/clip/ecd_bind_animation_curve.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Three.js clip to internal representation
+ * @param {EntityNode} node
+ * @param {THREE.AnimationClip} clip
+ */
+export function convert_three_clip(node: EntityNode, clip: THREE.AnimationClip): AnimationClipBinding;
+import { AnimationClip } from "./AnimationClip.js";
+import { AnimationClipBinding } from "./AnimationClipBinding.js";
+//# sourceMappingURL=ecd_bind_animation_curve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ecd_bind_animation_curve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/ecd_bind_animation_curve.js"],"names":[],"mappings":"AAmUA;;;;GAIG;AACH,2DAFW,mBAAmB,wBA6B7B;8BA5V6B,oBAAoB;qCACb,2BAA2B"}

package/src/engine/animation/{curve → clip}/ecd_bind_animation_curve.js

@@ -1,12 +1,14 @@
 import Name from "../../ecs/name/Name.js";
-import { AnimatedValueBinding } from "../../graphics/ecs/mesh-v2/aggregate/animation/AnimatedValueBinding.js";
-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";
+import { AnimationCurve } from "../curve/AnimationCurve.js";
+import { BoundQuaternionWriter } from "../curve/binding/BoundQuaternionWriter.js";
+import { BoundValueWriter } from "../curve/binding/BoundValueWriter.js";
+import { BoundVector3Writer } from "../curve/binding/BoundVector3Writer.js";
+import { Keyframe } from "../curve/Keyframe.js";
+import { AnimationClip } from "./AnimationClip.js";
+import { AnimationClipBinding } from "./AnimationClipBinding.js";
+import { AnimationTrack } from "./AnimationTrack.js";
+import { AnimationTrackBinding } from "./AnimationTrackBinding.js";
 
 
 /**
@@ -305,44 +307,50 @@ function component_curve_from_track(curve, type, values, times, component_count,
  *
  * @param {THREE.KeyframeTrack} track
  * @param {EntityNode} node
+ * @returns {AnimationTrack}
  */
 function convert_three_track(track, node) {
 
 
     const track_name = track.name;
 
-    const writer = bind_property_writer(node, track_name);
     // last part is the property
     const curves = convert_three_track_to_curves(track);
 
-    return AnimatedValueBinding.from(writer, curves);
+    return AnimationTrack.from(curves, track_name);
+
 }
 
 /**
  * Three.js clip to internal representation
  * @param {EntityNode} node
- * @param {AnimationClip} clip
+ * @param {THREE.AnimationClip} clip
  */
 export function convert_three_clip(node, clip) {
     const three_tracks = clip.tracks;
     const track_count = three_tracks.length;
 
-    const tracks = [];
+
+    const clip_binding = new AnimationClipBinding();
+    const meep_clip = new AnimationClip();
+
+    meep_clip.name = clip.name;
+
+    clip_binding.clip = meep_clip;
 
     for (let i = 0; i < track_count; i++) {
         try {
-            const engine_track = convert_three_track(three_tracks[i], node);
-            tracks.push(engine_track);
+            const three_track = three_tracks[i];
+            const meep_track = convert_three_track(three_track, node);
+
+            const writer = bind_property_writer(node, three_track.name);
+
+            meep_clip.tracks.push(meep_track);
+            clip_binding.tracks.push(AnimationTrackBinding.from(writer, meep_track));
         } catch (e) {
             logger.error(`Failed to parse track[${i}]: ${e.message}`);
         }
     }
 
-    const r = new EntityNodeAnimationClip();
-
-    r.name = clip.name;
-    r.tracks = tracks;
-    r.duration = clip.duration;
-
-    return r;
+    return clip_binding;
 }