@woosh/meep-engine 2.92.24 → 2.93.2

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

@@ -145,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"}

package/src/engine/graphics/texture/virtual/VirtualTextureUsageUpdater.js

@@ -83,7 +83,7 @@ export class VirtualTextureUsageUpdater {
      */
     #frame_jitter_offsets = new Float32Array([0, 0]);
     #frame_jitter_samples = 1;
-    #frame_jitter_enabled = false;
+    #frame_jitter_enabled = true;
 
     get frame_jitter_enabled() {
         return this.#frame_jitter_enabled;
@@ -264,8 +264,10 @@ export class VirtualTextureUsageUpdater {
             // apply jitter to projection matrix
             const jitter_index = this.#frame_index % this.#frame_jitter_samples;
 
-            const jitter_offset_x = this.#frame_jitter_offsets[jitter_index * 2];
-            const jitter_offset_y = this.#frame_jitter_offsets[jitter_index * 2 + 1];
+            const jitter_index_2 = jitter_index * 2;
+
+            const jitter_offset_x = this.#frame_jitter_offsets[jitter_index_2];
+            const jitter_offset_y = this.#frame_jitter_offsets[jitter_index_2 + 1];
 
             camera_projection_matrix[8] = jitter_offset_x / usage_buffer.width;
             camera_projection_matrix[9] = jitter_offset_y / usage_buffer.height;

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"EntityNodeAnimationClip.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/EntityNodeAnimationClip.js"],"names":[],"mappings":"AAAA;IACI,aAAS;IACT;;;OAGG;IACH,QAFU,sBAAsB,CAErB;IACX,iBAAY;IAEZ;;;OAGG;IACH,cAFW,MAAM,QAWhB;CACJ"}

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

@@ -1,24 +0,0 @@
-export class EntityNodeAnimationClip {
-    name = ""
-    /**
-     *
-     * @type {AnimatedValueBinding[]}
-     */
-    tracks = []
-    duration = 0
-
-    /**
-     *
-     * @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/curve/ecd_bind_animation_curve.d.ts

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

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

@@ -1 +0,0 @@
-{"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/graphics/ecs/mesh-v2/aggregate/animation/AnimatedValueBinding.d.ts

@@ -1,27 +0,0 @@
-export class AnimatedValueBinding {
-    /**
-     *
-     * @param {BoundValueWriter} writer
-     * @param {AnimationCurve[]} curves
-     * @returns {AnimatedValueBinding}
-     */
-    static from(writer: BoundValueWriter, curves: AnimationCurve[]): AnimatedValueBinding;
-    constructor(itemSize: any);
-    /**
-     *
-     * @type {BoundValueWriter|null}
-     */
-    writer: BoundValueWriter | null;
-    /**
-     *
-     * @type {AnimationCurve[]}
-     */
-    curves: AnimationCurve[];
-    /**
-     *
-     * @param {number} time
-     */
-    writeAt(time: number): void;
-    #private;
-}
-//# sourceMappingURL=AnimatedValueBinding.d.ts.map

package/src/engine/graphics/ecs/mesh-v2/aggregate/animation/AnimatedValueBinding.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnimatedValueBinding.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/mesh-v2/aggregate/animation/AnimatedValueBinding.js"],"names":[],"mappings":"AAAA;IAoBI;;;;;OAKG;IACH,8CAHW,gBAAgB,GACd,oBAAoB,CAWhC;IArBD,2BAIC;IAjBD;;;OAGG;IACH,QAFU,mBAAiB,IAAI,CAElB;IAEb;;;OAGG;IACH,QAFU,gBAAgB,CAEf;IAkCX;;;OAGG;IACH,cAFW,MAAM,QAYhB;;CACJ"}

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

@@ -1,61 +0,0 @@
-export class AnimatedValueBinding {
-    /**
-     *
-     * @type {BoundValueWriter|null}
-     */
-    writer = null
-
-    /**
-     *
-     * @type {AnimationCurve[]}
-     */
-    curves = []
-
-
-    constructor(itemSize) {
-        this.#itemSize = itemSize;
-
-        this.#sample = new Float32Array(itemSize);
-    }
-
-    /**
-     *
-     * @param {BoundValueWriter} writer
-     * @param {AnimationCurve[]} curves
-     * @returns {AnimatedValueBinding}
-     */
-    static from(writer, curves) {
-
-        const r = new AnimatedValueBinding(curves.length);
-
-        r.writer = writer;
-        r.curves = curves;
-
-        return r;
-
-    }
-
-    #itemSize = 1;
-
-    /**
-     *
-     * @type {Float32Array|null}
-     */
-    #sample = null;
-
-    /**
-     *
-     * @param {number} time
-     */
-    writeAt(time) {
-
-        for (let i = 0; i < this.#itemSize; i++) {
-            const curve = this.curves[i];
-
-            this.#sample[i] = curve.evaluate(time)
-        }
-
-
-        this.writer.write(this.#sample);
-    }
-}

package/src/engine/graphics/ecs/mesh-v2/aggregate/animation/BoundQuaternionWriter.d.ts.map

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