@woosh/meep-engine 2.92.23 → 2.93.1

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;
 }

package/src/engine/animation/curve/AnimationCurve.d.ts

@@ -9,6 +9,32 @@ export class AnimationCurve {
      * @returns {AnimationCurve}
      */
     static from(keys: Keyframe[]): AnimationCurve;
+    /**
+     *
+     * @param {number} timeStart
+     * @param {number} valueStart
+     * @param {number} timeEnd
+     * @param {number} valueEnd
+     * @return {AnimationCurve}
+     */
+    static easeInOut(timeStart: number, valueStart: number, timeEnd: number, valueEnd: number): AnimationCurve;
+    /**
+     *
+     * @param {number} timeStart
+     * @param {number} timeEnd
+     * @param {number} value
+     * @return {AnimationCurve}
+     */
+    static constant(timeStart: number, timeEnd: number, value: number): AnimationCurve;
+    /**
+     *
+     * @param {number} timeStart
+     * @param {number} valueStart
+     * @param {number} timeEnd
+     * @param {number} valueEnd
+     * @return {AnimationCurve}
+     */
+    static linear(timeStart: number, valueStart: number, timeEnd: number, valueEnd: number): AnimationCurve;
     /**
      * @readonly
      * @type {Keyframe[]}
@@ -40,6 +66,11 @@ export class AnimationCurve {
      * @returns {number}
      */
     get length(): number;
+    /**
+     * Time of the last chronological key in the curve
+     * @return {number}
+     */
+    get duration(): number;
     /**
      *
      * @param {number} t time in seconds

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

@@ -1 +1 @@
-{"version":3,"file":"AnimationCurve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/AnimationCurve.js"],"names":[],"mappings":"AAmCA;;;GAGG;AACH;IA4EI;;;;OAIG;IACH,kBAHW,QAAQ,EAAE,GACR,cAAc,CAU1B;IAxFD;;;OAGG;IACH,eAFU,QAAQ,EAAE,CAEV;IAEV;;;;OAIG;IACH,SAHW,QAAQ,GACN,MAAM,CA4BlB;IAED;;;OAGG;IACH,cAFW,QAAQ,EAAE,QAQpB;IAED;;;;OAIG;IACH,YAHW,QAAQ,GACN,OAAO,CAYnB;IAED;;OAEG;IACH,cAEC;IAiBD;;;OAGG;IACH,qBAEC;IAGD;;;;OAIG;IACH,YAHW,MAAM,GACL,MAAM,CA+BjB;IAED;;;OAGG;IACH,qBAFW,MAAM,QAoBhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAWhB;IAED,0BAKC;IAED;;MAIC;IAED;;aAeC;CACJ;yBA/OwB,eAAe"}
+{"version":3,"file":"AnimationCurve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/AnimationCurve.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH;IAiFI;;;;OAIG;IACH,kBAHW,QAAQ,EAAE,GACR,cAAc,CAU1B;IA6ID;;;;;;;OAOG;IACH,4BANW,MAAM,cACN,MAAM,WACN,MAAM,YACN,MAAM,GACL,cAAc,CAOzB;IAED;;;;;;OAMG;IACH,2BALW,MAAM,WACN,MAAM,SACN,MAAM,GACL,cAAc,CAOzB;IAED;;;;;;;OAOG;IACH,yBANW,MAAM,cACN,MAAM,WACN,MAAM,YACN,MAAM,GACL,cAAc,CASzB;IAtRD;;;OAGG;IACH,eAFU,QAAQ,EAAE,CAEV;IAEV;;;;OAIG;IACH,SAHW,QAAQ,GACN,MAAM,CA+BlB;IAED;;;OAGG;IACH,cAFW,QAAQ,EAAE,QAUpB;IAED;;;;OAIG;IACH,YAHW,QAAQ,GACN,OAAO,CAYnB;IAED;;OAEG;IACH,cAEC;IAiBD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,uBAUC;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,MAAM,CAwCjB;IAED;;;OAGG;IACH,qBAFW,MAAM,QAoBhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAWhB;IAED,0BAKC;IAED;;MAIC;IAED;;aAeC;CA+CJ;yBAxSwB,eAAe"}

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

@@ -1,3 +1,4 @@
+import { assert } from "../../../core/assert.js";
 import { binarySearchHighIndex } from "../../../core/collection/array/binarySearchHighIndex.js";
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
 import { lerp } from "../../../core/math/lerp.js";
@@ -5,24 +6,6 @@ import { spline_hermite3 } from "../../../core/math/spline/spline_hermite3.js";
 import { invokeObjectToJSON } from "../../../core/model/object/invokeObjectToJSON.js";
 import { Keyframe } from "./Keyframe.js";
 
-/**
- *
- * @param {number} t interpolation value, between 0 and 1
- * @param {Keyframe} keyframe0
- * @param {Keyframe} keyframe1
- * @return {number}
- */
-function evaluate(t, keyframe0, keyframe1) {
-    const time_distance = keyframe1.time - keyframe0.time;
-
-    return spline_hermite3(
-        t,
-        keyframe0.value, keyframe1.value,
-        keyframe0.outTangent * time_distance,
-        keyframe1.inTangent * time_distance
-    );
-}
-
 /**
  *
  * @param {number} time
@@ -50,6 +33,9 @@ export class AnimationCurve {
      * @returns {number} key index
      */
     add(key) {
+        assert.defined(key, 'key');
+        assert.notNull(key, 'key');
+
         const keys = this.keys;
 
         const key_count = keys.length;
@@ -82,6 +68,8 @@ export class AnimationCurve {
      * @param {Keyframe[]} keys
      */
     addMany(keys) {
+        assert.isArray(keys, 'keys');
+
         const key_count = keys.length;
 
         for (let i = 0; i < key_count; i++) {
@@ -136,6 +124,21 @@ export class AnimationCurve {
         return this.keys.length;
     }
 
+    /**
+     * Time of the last chronological key in the curve
+     * @return {number}
+     */
+    get duration() {
+        const keys = this.keys;
+        const key_count = keys.length;
+
+        if (key_count === 0) {
+            return 0
+        }
+
+        // keys are sorted, so we can rely on the last key's time
+        return keys[key_count - 1].time;
+    }
 
     /**
      *
@@ -159,13 +162,22 @@ export class AnimationCurve {
         }
 
         for (let i = 1; i < key_count; i++) {
-            const f1 = keys[i];
+            const keyframe1 = keys[i];
 
-            if (t < f1.time) {
-                const f0 = keys[i - 1];
-                const kt = inverseLerp(f0.time, f1.time, t);
+            if (t < keyframe1.time) {
+                const keyframe0 = keys[i - 1];
 
-                return evaluate(kt, f0, f1);
+                // convert to 0..1 region
+                const normalized_time = inverseLerp(keyframe0.time, keyframe1.time, t);
+
+                const time_distance = keyframe1.time - keyframe0.time;
+
+                return spline_hermite3(
+                    normalized_time,
+                    keyframe0.value, keyframe1.value,
+                    keyframe0.outTangent * time_distance,
+                    keyframe1.inTangent * time_distance
+                );
             }
         }
 
@@ -242,4 +254,50 @@ export class AnimationCurve {
         }
 
     }
+
+    /**
+     *
+     * @param {number} timeStart
+     * @param {number} valueStart
+     * @param {number} timeEnd
+     * @param {number} valueEnd
+     * @return {AnimationCurve}
+     */
+    static easeInOut(timeStart, valueStart, timeEnd, valueEnd) {
+        return AnimationCurve.from([
+            Keyframe.from(timeStart, valueStart, 0, 0),
+            Keyframe.from(timeEnd, valueEnd, 0, 0)
+        ]);
+    }
+
+    /**
+     *
+     * @param {number} timeStart
+     * @param {number} timeEnd
+     * @param {number} value
+     * @return {AnimationCurve}
+     */
+    static constant(timeStart, timeEnd, value) {
+        return AnimationCurve.from([
+            Keyframe.from(timeStart, value, 0, 0),
+            Keyframe.from(timeEnd, value, 0, 0)
+        ]);
+    }
+
+    /**
+     *
+     * @param {number} timeStart
+     * @param {number} valueStart
+     * @param {number} timeEnd
+     * @param {number} valueEnd
+     * @return {AnimationCurve}
+     */
+    static linear(timeStart, valueStart, timeEnd, valueEnd) {
+        const tangent = valueEnd - valueStart;
+
+        return AnimationCurve.from([
+            Keyframe.from(timeStart, valueStart, 0, tangent),
+            Keyframe.from(timeEnd, valueEnd, tangent, 0)
+        ]);
+    }
 }

package/src/engine/animation/curve/AnimationCurve.spec.js

@@ -119,9 +119,10 @@ test("extreme tangent interpolation", () => {
     const curve = new AnimationCurve();
 
     curve.add(Keyframe.from(0, 1, 0, -1));
-    curve.add(Keyframe.from(1, 2, 1, 0));
+    curve.add(Keyframe.from(1, 2, -1, 0));
 
-    expect(curve.evaluate(0.5)).toBe(0.5);
+    expect(curve.evaluate(0.1)).toBeLessThan(1);
+    expect(curve.evaluate(0.9)).toBeGreaterThan(2);
 
 });
 
@@ -144,3 +145,37 @@ test("to/from JSON consistency", () => {
     expect(first_key.inTangent).toBe(13);
     expect(first_key.outTangent).toBe(-17);
 });
+
+
+test("static easeInOut constructor", () => {
+
+    const curve = AnimationCurve.easeInOut(1, 3, 5, 7);
+
+
+    expect(curve.evaluate(1.1)).toBeCloseTo(3, 0.1);
+    expect(curve.evaluate(4.9)).toBeCloseTo(7, 0.1);
+
+    expect(curve.evaluate(3)).toBeCloseTo(5, 0.01);
+});
+
+test("static linear constructor", () => {
+
+    const curve = AnimationCurve.linear(1, 3, 5, 7);
+
+
+    expect(curve.evaluate(1.1)).toBeCloseTo(3.1, 0.01);
+    expect(curve.evaluate(4.9)).toBeCloseTo(6.9, 0.01);
+
+    expect(curve.evaluate(3)).toBeCloseTo(5, 0.01);
+});
+
+test("static constant constructor", () => {
+
+    const curve = AnimationCurve.constant(1, 5, 7);
+
+
+    expect(curve.evaluate(1.1)).toBe(7);
+    expect(curve.evaluate(4.9)).toBe(7);
+
+    expect(curve.evaluate(3)).toBe(7);
+});

package/src/engine/animation/curve/Keyframe.d.ts

@@ -28,6 +28,14 @@ export class Keyframe {
      * @type {number}
      */
     outTangent: number;
+    /**
+     *
+     * @param {number} time
+     * @param {number} value
+     * @param {number} inTangent
+     * @param {number} outTangent
+     */
+    set(time: number, value: number, inTangent: number, outTangent: number): void;
     toJSON(): {
         value: number;
         time: number;

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

@@ -1 +1 @@
-{"version":3,"file":"Keyframe.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/Keyframe.js"],"names":[],"mappings":"AAEA;IA2BI;;;;;;;OAOG;IACH,kBANW,MAAM,SACN,MAAM,cACN,MAAM,eACN,MAAM,GACL,QAAQ,CAuBnB;IAtDG;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,MAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,WAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAkCvB;;;;;MAOC;IAED;;;;;aAQC;CAEJ"}
+{"version":3,"file":"Keyframe.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/Keyframe.js"],"names":[],"mappings":"AAEA;IAyBI;;;;;;;OAOG;IACH,kBANW,MAAM,SACN,MAAM,cACN,MAAM,eACN,MAAM,GACL,QAAQ,CAQnB;IAtCD;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,YAFU,MAAM,CAED;IAkBf;;;;;;OAMG;IACH,UALW,MAAM,SACN,MAAM,aACN,MAAM,cACN,MAAM,QAmBhB;IAED;;;;;MAOC;IAED;;;;;aAQC;CAEJ"}

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

@@ -1,31 +1,29 @@
 import { assert } from "../../../core/assert.js";
 
 export class Keyframe {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.value = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.time = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.inTangent = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.outTangent = 0;
-    }
+    /**
+     *
+     * @type {number}
+     */
+    value = 0;
+
+    /**
+     *
+     * @type {number}
+     */
+    time = 0;
+
+    /**
+     *
+     * @type {number}
+     */
+    inTangent = 0;
+
+    /**
+     *
+     * @type {number}
+     */
+    outTangent = 0;
 
     /**
      *
@@ -36,26 +34,37 @@ export class Keyframe {
      * @return {Keyframe}
      */
     static from(time, value, inTangent = 0, outTangent = 0) {
-        assert.isNumber(time,'time');
-        assert.notNaN(time,'time');
+        const r = new Keyframe();
 
-        assert.isNumber(value,'value');
-        assert.notNaN(value,'value');
+        r.set(time, value, inTangent, outTangent);
 
-        assert.isNumber(inTangent,'inTangent');
-        assert.notNaN(inTangent,'inTangent');
+        return r;
+    }
 
-        assert.isNumber(outTangent,'outTangent');
-        assert.notNaN(outTangent,'outTangent');
+    /**
+     *
+     * @param {number} time
+     * @param {number} value
+     * @param {number} inTangent
+     * @param {number} outTangent
+     */
+    set(time, value, inTangent, outTangent) {
+        assert.isNumber(time, 'time');
+        assert.notNaN(time, 'time');
 
-        const r = new Keyframe();
+        assert.isNumber(value, 'value');
+        assert.notNaN(value, 'value');
 
-        r.time = time;
-        r.value = value;
-        r.inTangent = inTangent;
-        r.outTangent = outTangent;
+        assert.isNumber(inTangent, 'inTangent');
+        assert.notNaN(inTangent, 'inTangent');
 
-        return r;
+        assert.isNumber(outTangent, 'outTangent');
+        assert.notNaN(outTangent, 'outTangent');
+
+        this.time = time;
+        this.value = value;
+        this.inTangent = inTangent;
+        this.outTangent = outTangent;
     }
 
     toJSON() {
@@ -68,13 +77,13 @@ export class Keyframe {
     };
 
     fromJSON({
-                 value, time, inTangent, outTangent
+                 value,
+                 time,
+                 inTangent,
+                 outTangent
              }) {
 
-        this.value = value;
-        this.time = time;
-        this.inTangent = inTangent;
-        this.outTangent = outTangent;
+        this.set(time, value, inTangent, outTangent);
     }
 
 }

package/src/engine/animation/curve/Keyframe.spec.d.ts

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

package/src/engine/animation/curve/Keyframe.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Keyframe.spec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/Keyframe.spec.js"],"names":[],"mappings":""}

package/src/engine/animation/curve/Keyframe.spec.js

@@ -0,0 +1,31 @@
+import { Keyframe } from "./Keyframe.js";
+
+test("toJSON", () => {
+
+    const k = Keyframe.from(1, 3, 5, 7);
+
+    expect(k.toJSON()).toEqual({
+        time: 1,
+        value: 3,
+        inTangent: 5,
+        outTangent: 7
+    });
+});
+
+test("fromJSON", () => {
+
+    const keyframe = new Keyframe();
+
+    keyframe.fromJSON({
+        time: 1,
+        value: 3,
+        inTangent: 5,
+        outTangent: 7
+    });
+
+    expect(keyframe.time).toEqual(1);
+    expect(keyframe.value).toEqual(3);
+    expect(keyframe.inTangent).toEqual(5);
+    expect(keyframe.outTangent).toEqual(7);
+
+});

package/src/engine/animation/curve/binding/BoundQuaternionWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundQuaternionWriter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/binding/BoundQuaternionWriter.js"],"names":[],"mappings":"AAEA;IAOI,6BAIC;IAED,uBAGC;;CACJ;iCAnBgC,uBAAuB"}

package/src/engine/animation/curve/binding/BoundValueWriter.d.ts

@@ -0,0 +1,14 @@
+export class BoundValueWriter {
+    /**
+     *
+     * @param {number[]|ArrayLike<number>|Float32Array|Float64Array} data
+     */
+    write(data: number[] | ArrayLike<number> | Float32Array | Float64Array): void;
+    /**
+     * @template T
+     * @param {T} root
+     * @param {string[]} path
+     */
+    bind<T>(root: T, path: string[]): void;
+}
+//# sourceMappingURL=BoundValueWriter.d.ts.map

package/src/engine/animation/curve/binding/BoundValueWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundValueWriter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/binding/BoundValueWriter.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,YAFW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,QAI9D;IAED;;;;OAIG;IACH,uBAFW,MAAM,EAAE,QAIlB;CACJ"}

package/src/engine/animation/curve/binding/BoundValueWriter.js

@@ -0,0 +1,19 @@
+export class BoundValueWriter {
+
+    /**
+     *
+     * @param {number[]|ArrayLike<number>|Float32Array|Float64Array} data
+     */
+    write(data) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * @template T
+     * @param {T} root
+     * @param {string[]} path
+     */
+    bind(root, path) {
+        throw new Error('Not Implemented');
+    }
+}

package/src/engine/animation/curve/binding/BoundVector3Writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundVector3Writer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/binding/BoundVector3Writer.js"],"names":[],"mappings":"AAEA;IAOI,yBAIC;IAED,uBAEC;;CACJ;iCAlBgC,uBAAuB"}

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshAnimationController.d.ts

@@ -1,8 +1,8 @@
-import {EntityNodeAnimationClip} from "../../../../animation/curve/EntityNodeAnimationClip";
+import {AnimationClipBinding} from "../../../../animation/clip/AnimationClipBinding";
 import {SGAnimationPlayback} from "./SGAnimationPlayback";
 
 export class SGMeshAnimationController {
-    readonly bound: EntityNodeAnimationClip[]
+    readonly bound: AnimationClipBinding[]
 
     start(name: string, loop?: boolean, time_offset?: number): SGAnimationPlayback
 

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshAnimationControllerSystem.js

@@ -1,7 +1,7 @@
 import Signal from "../../../../../core/events/signal/Signal.js";
 import { ResourceAccessKind } from "../../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../../core/model/ResourceAccessSpecification.js";
-import { convert_three_clip } from "../../../../animation/curve/ecd_bind_animation_curve.js";
+import { convert_three_clip } from "../../../../animation/clip/ecd_bind_animation_curve.js";
 import { System } from "../../../../ecs/System.js";
 import { assetTypeByPath } from "../../mesh/assetTypeByPath.js";
 import { SGMesh } from "./SGMesh.js";

package/src/engine/graphics/texture/virtual/VirtualTextureUsageUpdater.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualTextureUsageUpdater.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureUsageUpdater.js"],"names":[],"mappings":"AA2EA;IAgBI;;;OAGG;IACH,uCAEC;IAVD,oCAEC;IA8CD,iCAEC;IAED,8BAEC;IAED,4BAEC;IASD;;;;;OAKG;IACH,iCAJW,MAAM,aACN,MAAM,cACN,MAAM,QAqBhB;IAED,0CAEC;IAED,4BAEC;IAiCD;;;;OAIG;IACH,yBAHW,MAAM,KACN,MAAM,QA+BhB;IAwBD;;;;;OAKG;IACH,yEAoDC;IAED,gBAEC;;CACJ;oCAhUmC,0BAA0B;0BADpC,yBAAyB"}
+{"version":3,"file":"VirtualTextureUsageUpdater.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/virtual/VirtualTextureUsageUpdater.js"],"names":[],"mappings":"AA2EA;IAgBI;;;OAGG;IACH,uCAEC;IAVD,oCAEC;IA8CD,iCAEC;IAED,8BAEC;IAED,4BAEC;IASD;;;;;OAKG;IACH,iCAJW,MAAM,aACN,MAAM,cACN,MAAM,QAqBhB;IAED,0CAEC;IAED,4BAEC;IAiCD;;;;OAIG;IACH,yBAHW,MAAM,KACN,MAAM,QA+BhB;IA0BD;;;;;OAKG;IACH,yEAoDC;IAED,gBAEC;;CACJ;oCAlUmC,0BAA0B;0BADpC,yBAAyB"}