@woosh/meep-engine 2.92.24 → 2.93.1

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.1",
   "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/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;
 }

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

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

@@ -1,8 +0,0 @@
-export class BoundValueWriter {
-    /**
-     *
-     * @param {number[]} data
-     */
-    write(data: number[]): void;
-}
-//# sourceMappingURL=BoundValueWriter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"BoundValueWriter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/ecs/mesh-v2/aggregate/animation/BoundValueWriter.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,YAFW,MAAM,EAAE,QAIlB;CACJ"}

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

@@ -1,10 +0,0 @@
-export class BoundValueWriter {
-
-    /**
-     *
-     * @param {number[]} data
-     */
-    write(data) {
-
-    }
-}

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

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