@woosh/meep-engine 2.110.8 → 2.110.10

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

@@ -1,3 +1,4 @@
+import { assert } from "../../../core/assert.js";
 import Name from "../../ecs/name/Name.js";
 import { BoundQuaternionWriter } from "../curve/binding/BoundQuaternionWriter.js";
 import { BoundValueWriter } from "../curve/binding/BoundValueWriter.js";
@@ -24,14 +25,15 @@ function get_node_name(node) {
 /**
  * Following THREE.js PropertyBinding.findNode implementation
  * @param {EntityNode} root
- * @param {string} nodeName
+ * @param {string} node_name
  * @returns {EntityNode|undefined}
  */
-function find_node(root, nodeName) {
+function find_node(root, node_name) {
+    assert.isString(node_name, 'node_name');
 
     const root_name = get_node_name(root);
 
-    if (root_name === nodeName) {
+    if (root_name === node_name) {
         return root;
     }
 
@@ -40,14 +42,13 @@ function find_node(root, nodeName) {
 
     const child_count = children.length;
 
-
     for (let j = 0; j < child_count; j++) {
         /**
          * @type {EntityNode}
          */
         const child = children[j];
 
-        const subtree_result = find_node(child, nodeName);
+        const subtree_result = find_node(child, node_name);
 
         if (subtree_result !== undefined) {
             return subtree_result;
@@ -59,13 +60,18 @@ function find_node(root, nodeName) {
  *
  * @param {EntityNode} root
  * @param {string[]} path_parts
+ * @param {number} part_first
+ * @param {number} part_last
  */
-function entity_node_resolve_path(root, path_parts) {
+function entity_node_resolve_path(root, path_parts, part_first, part_last) {
+    assert.isNonNegativeInteger(part_first, 'part_first');
+    assert.isNonNegativeInteger(part_last, 'part_last');
+
+    assert.lessThan(part_last, path_parts.length, 'overflow');
 
     let node = root;
 
-    const part_count = path_parts.length;
-    for (let i = 0; i < part_count; i++) {
+    for (let i = part_first; i <= part_last; i++) {
 
         const part = path_parts[i];
 
@@ -86,15 +92,18 @@ function entity_node_resolve_path(root, path_parts) {
 /**
  *
  * @param {EntityNode} node
- * @param {string} path
+ * @param {string[]} path_parts
  * @returns {BoundValueWriter}
  */
-export function bind_property_writer(node, path) {
-    const path_parts = path.split('.');
+export function bind_property_writer(node, path_parts) {
+    assert.defined(path_parts, 'path_parts');
+    assert.isArray(path_parts, 'path_parts');
+
+    const part_count = path_parts.length;
 
-    const property_name = path_parts[path_parts.length - 1];
+    const property_name = path_parts[part_count - 1];
 
-    const parent = entity_node_resolve_path(node, path_parts.slice(0, path_parts.length - 1));
+    const parent = entity_node_resolve_path(node, path_parts, 0, part_count - 2);
 
     let writer;
 

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

@@ -1 +1 @@
-{"version":3,"file":"curve_from_track_data.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/curve_from_track_data.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,mEANW,0BAA0B,UAC1B,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,mBACN,MAAM,QAchB;2CA1B0C,iCAAiC"}
+{"version":3,"file":"curve_from_track_data.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/curve_from_track_data.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,mEANW,0BAA0B,UAC1B,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,mBACN,MAAM,QAsBhB;2CAlC0C,iCAAiC"}

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

@@ -12,7 +12,15 @@ import { curve_from_track_data_linear } from "./curve_from_track_data_linear.js"
  * @param {number} component_count
  * @param {number} component_index
  */
-export function curve_from_track_data(curve, type, values, times, component_count, component_index) {
+export function curve_from_track_data(
+    curve,
+    type,
+    values,
+    times,
+    component_count,
+    component_index
+) {
+
     switch (type) {
         case AnimationInterpolationKind.Discrete:
             return curve_from_track_data_discrete(curve, values, times, component_count, component_index);

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

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

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

@@ -85,11 +85,9 @@ function convert_three_track_to_curves(track) {
 /**
  *
  * @param {THREE.KeyframeTrack} track
- * @param {EntityNode} node
  * @returns {AnimationTrack}
  */
-function convert_three_track(track, node) {
-
+function convert_three_track(track) {
 
     const track_name = track.name;
 
@@ -120,9 +118,12 @@ export function convert_three_clip(node, clip) {
     for (let i = 0; i < track_count; i++) {
         try {
             const three_track = three_tracks[i];
-            const meep_track = convert_three_track(three_track, node);
 
-            const writer = bind_property_writer(node, three_track.name);
+            const meep_track = convert_three_track(three_track);
+
+            const property_path = three_track.name.split('.');
+
+            const writer = bind_property_writer(node, property_path);
 
             meep_clip.tracks.push(meep_track);
             clip_binding.tracks.push(AnimationTrackBinding.from(writer, meep_track));

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

@@ -66,10 +66,20 @@ export class AnimationCurve {
      * @returns {number}
      */
     get length(): number;
+    /**
+     * Time of the first keyframe, returns 0 if there are no keys
+     * @returns {number}
+     */
+    get start_time(): number;
     /**
      * Time of the last chronological key in the curve
      * @return {number}
      */
+    get end_time(): number;
+    /**
+     * Time difference between first and last frame
+     * @returns {number}
+     */
     get duration(): number;
     /**
      *
@@ -79,6 +89,7 @@ export class AnimationCurve {
     evaluate(time: number): number;
     /**
      * Set tangents of a key to match surrounding keys
+     * Produces a smoother looking curve
      * @param {number} index index of keyframe
      */
     alignTangents(index: number): void;
@@ -89,6 +100,27 @@ export class AnimationCurve {
      */
     smoothTangents(index: number, weight: number): void;
     smoothAllTangents(): void;
+    /**
+     *
+     * @param {AnimationCurve} other
+     * @return {boolean}
+     */
+    equals(other: AnimationCurve): boolean;
+    /**
+     * The copy is deep
+     * @param {AnimationCurve} other
+     */
+    copy(other: AnimationCurve): void;
+    /**
+     *
+     * @return {AnimationCurve}
+     */
+    clone(): AnimationCurve;
+    /**
+     *
+     * @return {number}
+     */
+    hash(): number;
     toJSON(): {
         keys: any[];
     };

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":"AAkBA;;;GAGG;AACH;IAkFI;;;;OAIG;IACH,kBAHW,QAAQ,EAAE,GACR,cAAc,CAU1B;IAgJD;;;;;;;OAOG;IACH,6BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAUzB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,YACN,MAAM,UACN,MAAM,GACL,cAAc,CAOzB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAYzB;IAhSD;;;OAGG;IACH,eAFU,QAAQ,EAAE,CAEV;IAEV;;;;OAIG;IACH,SAHW,QAAQ,GACN,MAAM,CAgClB;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,eAHW,MAAM,GACL,MAAM,CA2CjB;IAED;;;OAGG;IACH,qBAFW,MAAM,QAoBhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAWhB;IAED,0BAKC;IAED;;MAIC;IAED;;aAeC;CAqDJ;yBAlTwB,eAAe"}
+{"version":3,"file":"AnimationCurve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/AnimationCurve.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH;IAkFI;;;;OAIG;IACH,kBAHW,QAAQ,EAAE,GACR,cAAc,CAQ1B;IA0ND;;;;;;;OAOG;IACH,6BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAUzB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,YACN,MAAM,UACN,MAAM,GACL,cAAc,CAOzB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAYzB;IAxWD;;;OAGG;IACH,eAFU,QAAQ,EAAE,CAEV;IAEV;;;;OAIG;IACH,SAHW,QAAQ,GACN,MAAM,CAgClB;IAED;;;OAGG;IACH,cAFW,QAAQ,EAAE,QAUpB;IAED;;;;OAIG;IACH,YAHW,QAAQ,GACN,OAAO,CAYnB;IAED;;OAEG;IACH,cAEC;IAeD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,yBAUC;IAED;;;OAGG;IACH,uBAUC;IAED;;;OAGG;IACH,uBAaC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACL,MAAM,CAiCjB;IAED;;;;OAIG;IACH,qBAFW,MAAM,QA+BhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAWhB;IAED,0BAKC;IAED;;;;OAIG;IACH,cAHW,cAAc,GACb,OAAO,CAIlB;IAED;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;MAIC;IAED;;aAeC;CAqDJ;yBA1XwB,eAAe"}

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

@@ -1,9 +1,12 @@
 import { assert } from "../../../core/assert.js";
 import { binarySearchHighIndex } from "../../../core/collection/array/binarySearchHighIndex.js";
-import { inverseLerp } from "../../../core/math/inverseLerp.js";
+import { computeHashArray } from "../../../core/collection/array/computeHashArray.js";
+import { isArrayEqual } from "../../../core/collection/array/isArrayEqual.js";
 import { lerp } from "../../../core/math/lerp.js";
-import { spline_hermite3 } from "../../../core/math/spline/spline_hermite3.js";
+import { invokeObjectClone } from "../../../core/model/object/invokeObjectClone.js";
+import { invokeObjectHash } from "../../../core/model/object/invokeObjectHash.js";
 import { invokeObjectToJSON } from "../../../core/model/object/invokeObjectToJSON.js";
+import { evaluate_two_key_curve } from "./evaluate_two_key_curve.js";
 import { Keyframe } from "./Keyframe.js";
 
 /**
@@ -112,8 +115,6 @@ export class AnimationCurve {
 
         curve.addMany(keys);
 
-        curve.smoothAllTangents();
-
         return curve;
     }
 
@@ -125,11 +126,27 @@ export class AnimationCurve {
         return this.keys.length;
     }
 
+    /**
+     * Time of the first keyframe, returns 0 if there are no keys
+     * @returns {number}
+     */
+    get start_time() {
+        const keys = this.keys;
+
+        if (keys.length === 0) {
+            return 0;
+        }
+
+        const first = keys[0];
+
+        return first.time;
+    }
+
     /**
      * Time of the last chronological key in the curve
      * @return {number}
      */
-    get duration() {
+    get end_time() {
         const keys = this.keys;
         const key_count = keys.length;
 
@@ -141,6 +158,25 @@ export class AnimationCurve {
         return keys[key_count - 1].time;
     }
 
+    /**
+     * Time difference between first and last frame
+     * @returns {number}
+     */
+    get duration() {
+
+        const keys = this.keys;
+        const key_count = keys.length;
+
+        if (key_count < 2) {
+            return 0;
+        }
+
+        const first = keys[0];
+        const last = keys[key_count - 1];
+
+        return last.time - first.time;
+    }
+
     /**
      *
      * @param {number} time time in seconds
@@ -171,17 +207,7 @@ export class AnimationCurve {
             if (time < keyframe1.time) {
                 const keyframe0 = keys[i - 1];
 
-                // convert to 0..1 region
-                const normalized_time = inverseLerp(keyframe0.time, keyframe1.time, time);
-
-                const time_distance = keyframe1.time - keyframe0.time;
-
-                return spline_hermite3(
-                    normalized_time,
-                    keyframe0.value, keyframe1.value,
-                    keyframe0.outTangent * time_distance,
-                    keyframe1.inTangent * time_distance
-                );
+                return evaluate_two_key_curve(time, keyframe0, keyframe1);
             }
         }
 
@@ -191,10 +217,15 @@ export class AnimationCurve {
 
     /**
      * Set tangents of a key to match surrounding keys
+     * Produces a smoother looking curve
      * @param {number} index index of keyframe
      */
     alignTangents(index) {
         const keys = this.keys;
+        const last_index = keys.length - 1;
+
+        assert.isNonNegativeInteger(index, "index");
+        assert.lessThanOrEqual(index, last_index, "index overflow");
 
         const key_main = keys[index];
 
@@ -202,14 +233,21 @@ export class AnimationCurve {
         if (has_previous) {
             const key_previous = keys[index - 1];
 
-            key_main.inTangent = key_main.value - key_previous.value;
+            const time_span = key_main.time - key_previous.time;
+            const value_span = key_main.value - key_previous.value;
+
+            key_main.inTangent = value_span / time_span;
         }
 
-        const has_next = index < keys.length - 1;
+        const has_next = index < last_index;
+
         if (has_next) {
             const key_next = keys[index + 1];
 
-            key_main.outTangent = key_next.value - key_main.value;
+            const time_span = key_next.time - key_main.time;
+            const value_span = key_next.value - key_main.value;
+
+            key_main.outTangent = value_span / time_span;
         }
     }
 
@@ -236,6 +274,43 @@ export class AnimationCurve {
         }
     }
 
+    /**
+     *
+     * @param {AnimationCurve} other
+     * @return {boolean}
+     */
+    equals(other) {
+        return isArrayEqual(this.keys, other.keys);
+    }
+
+    /**
+     * The copy is deep
+     * @param {AnimationCurve} other
+     */
+    copy(other) {
+        this.keys = other.keys.map(invokeObjectClone);
+    }
+
+    /**
+     *
+     * @return {AnimationCurve}
+     */
+    clone() {
+        const curve = new AnimationCurve();
+
+        curve.copy(this);
+
+        return curve;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return computeHashArray(this.keys, invokeObjectHash);
+    }
+
     toJSON() {
         return {
             keys: this.keys.map(invokeObjectToJSON)

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

@@ -178,4 +178,71 @@ test("static constant constructor", () => {
     expect(curve.evaluate(4.9)).toBe(7);
 
     expect(curve.evaluate(3)).toBe(7);
+});
+
+test("equals method", () => {
+
+    expect(new AnimationCurve().equals(new AnimationCurve())).toBe(true);
+
+    // one frame
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 0)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
+    ).toBe(true);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 1)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
+    ).toBe(false);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(1, 0)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
+    ).toBe(false);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 0)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 1)]))
+    ).toBe(false);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 0)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 1)]))
+    ).toBe(false);
+
+    // different frame count
+
+    expect(
+        AnimationCurve.from([])
+            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
+    ).toBe(false);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 0)])
+            .equals(AnimationCurve.from([]))
+    ).toBe(false);
+
+});
+
+test("hash", () => {
+
+    expect(typeof AnimationCurve.from([Keyframe.from(0, 0)]).hash()).toBe("number")
+
+    expect(AnimationCurve.from([]).hash())
+        .toEqual(AnimationCurve.from([]).hash())
+
+});
+
+test("copy", () => {
+
+    const r = new AnimationCurve();
+
+    r.copy(AnimationCurve.from([Keyframe.from(1, -3, 5, -7)]))
+
+    expect(r.keys.length).toBe(1);
+    expect(r.keys[0].value).toBe(-3);
+    expect(r.keys[0].time).toBe(1);
+    expect(r.keys[0].inTangent).toBe(5);
+    expect(r.keys[0].outTangent).toBe(-7);
+
 });

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

@@ -14,17 +14,17 @@ export class Keyframe {
      */
     value: number;
     /**
-     *
+     * Timestamp
      * @type {number}
      */
     time: number;
     /**
-     *
+     * Incoming tangent
      * @type {number}
      */
     inTangent: number;
     /**
-     *
+     * Outgoing tangent
      * @type {number}
      */
     outTangent: number;
@@ -36,6 +36,27 @@ export class Keyframe {
      * @param {number} outTangent
      */
     set(time: number, value: number, inTangent: number, outTangent: number): void;
+    /**
+     *
+     * @param {Keyframe} other
+     * @returns {boolean}
+     */
+    equals(other: Keyframe): boolean;
+    /**
+     *
+     * @param {Keyframe} other
+     */
+    copy(other: Keyframe): void;
+    /**
+     *
+     * @return {Keyframe}
+     */
+    clone(): Keyframe;
+    /**
+     *
+     * @return {number}
+     */
+    hash(): number;
     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;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;IAIL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B"}
+{"version":3,"file":"Keyframe.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/Keyframe.js"],"names":[],"mappings":"AAGA;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;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAQnB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAOlB;IAED;;;OAGG;IACH,SAFY,QAAQ,CAQnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAKjB;IAED;;;;;MAOC;IAED;;;;;aAQC;IAIL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B"}

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

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 
 export class Keyframe {
     /**
@@ -8,19 +9,19 @@ export class Keyframe {
     value = 0;
 
     /**
-     *
+     * Timestamp
      * @type {number}
      */
     time = 0;
 
     /**
-     *
+     * Incoming tangent
      * @type {number}
      */
     inTangent = 0;
 
     /**
-     *
+     * Outgoing tangent
      * @type {number}
      */
     outTangent = 0;
@@ -67,6 +68,51 @@ export class Keyframe {
         this.outTangent = outTangent;
     }
 
+    /**
+     *
+     * @param {Keyframe} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.time === other.time
+            && this.value === other.value
+            && this.inTangent === other.inTangent
+            && this.outTangent === other.outTangent;
+
+    }
+
+    /**
+     *
+     * @param {Keyframe} other
+     */
+    copy(other) {
+        this.time = other.time;
+        this.value = other.value;
+        this.inTangent = other.inTangent;
+        this.outTangent = other.outTangent;
+    }
+
+    /**
+     *
+     * @return {Keyframe}
+     */
+    clone() {
+        const r = new Keyframe();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return computeHashFloat(this.time)
+            ^ computeHashFloat(this.value);
+    }
+
     toJSON() {
         return {
             value: this.value,

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

@@ -28,4 +28,15 @@ test("fromJSON", () => {
     expect(keyframe.inTangent).toEqual(5);
     expect(keyframe.outTangent).toEqual(7);
 
+});
+
+test("copy",()=>{
+    const keyframe = new Keyframe();
+
+    keyframe.copy(Keyframe.from(1, -3, 5, -7));
+
+    expect(keyframe.value).toBe(-3);
+    expect(keyframe.time).toBe(1);
+    expect(keyframe.inTangent).toBe(5);
+    expect(keyframe.outTangent).toBe(-7);
 });

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

@@ -0,0 +1,7 @@
+/**
+ * Compute bounding box for a given curve. X-axis is time, Y-axis is value.
+ * @param {AABB2} out
+ * @param {AnimationCurve} curve
+ */
+export function animation_curve_compute_aabb(out: AABB2, curve: AnimationCurve): void;
+//# sourceMappingURL=animation_curve_compute_aabb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation_curve_compute_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/animation_curve_compute_aabb.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,sFAsCC"}

package/src/engine/animation/curve/{compute_curve_aabb.js → animation_curve_compute_aabb.js}

@@ -9,7 +9,7 @@ const temp_bounds = new Float32Array(4);
  * @param {AABB2} out
  * @param {AnimationCurve} curve
  */
-export function compute_curve_aabb(out, curve) {
+export function animation_curve_compute_aabb(out, curve) {
     let x0 = Number.POSITIVE_INFINITY;
     let x1 = Number.NEGATIVE_INFINITY;
     let y0 = Number.POSITIVE_INFINITY;

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

@@ -0,0 +1,8 @@
+/**
+ * Will remove keyframes that do not affect shape of the curve significantly. The significance degree is determined by the error tolerance
+ * Intended to reduce complexity of a curve to improve performance and lower memory usage
+ * @param {AnimationCurve} curve
+ * @param {number} [error_tolerance] how much of a loss to accept, this is relative to normalized value bounds of the curve
+ */
+export function animation_curve_optimize(curve: AnimationCurve, error_tolerance?: number): void;
+//# sourceMappingURL=animation_curve_optimize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation_curve_optimize.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/animation_curve_optimize.js"],"names":[],"mappings":"AA0CA;;;;;GAKG;AACH,kFAFW,MAAM,QA0ChB"}