@woosh/meep-engine 2.110.8 → 2.110.9

package/src/core/process/worker/WorkerProxy.js

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 /**
  *
  * @param {Worker} worker
@@ -35,7 +37,13 @@ function needsSerialization(value) {
 
 class WorkerProxy {
 
+    /**
+     *
+     * @type {{}}
+     * @private
+     */
     __pending = {};
+
     __isRunning = false;
 
     /**
@@ -63,11 +71,13 @@ class WorkerProxy {
     /**
      * Invoke a given method on the worker, as defined by the `WorkerBuilder`
      * @template T
-     * @param {number} name Method's name
+     * @param {string} name Method's name
      * @param {Array} args
      * @return {Promise<T>} eventual result of the invoked method
      */
     $submitRequest(name, args) {
+        assert.isString(name, "name");
+
         const pending = this.__pending[name];
 
         const argumentCount = args.length;
@@ -114,7 +124,14 @@ class WorkerProxy {
         });
     }
 
+    /**
+     *
+     * @param {string} name
+     * @private
+     */
     __makeMethod(name) {
+        assert.isString(name, 'name');
+
         if (this.__pending.hasOwnProperty(name)) {
             throw new Error(`Method '${name}' already defined`);
         }
@@ -199,15 +216,17 @@ class WorkerProxy {
     /**
      *
      * @param {number} id
-     * @param {string} methodName
+     * @param {string} method_name
      * @returns {boolean}
      */
-    cancelRequest(id, methodName) {
+    cancelRequest(id, method_name) {
+        assert.isString(method_name, 'method_name');
+
         //find request
-        const requestQueue = this.__pending[methodName];
+        const requestQueue = this.__pending[method_name];
 
         if (requestQueue === undefined) {
-            throw new Error(`No request queue for method name '${methodName}'`);
+            throw new Error(`No request queue for method name '${method_name}'`);
         }
 
         const n = requestQueue.length;

package/src/engine/EngineHarness.d.ts

@@ -1,4 +1,10 @@
 export class EngineHarness {
+    /**
+     * Quick initialization of the engine in a sensible default configuration
+     * @param {(config:EngineConfiguration,engine:Engine)=>*} [configuration]
+     * @return {Promise<Engine>}
+     */
+    static bootstrap({ configuration }?: (config: EngineConfiguration, engine: Engine) => any): Promise<Engine>;
     /**
      *
      * @param {Engine} engine
@@ -111,7 +117,7 @@ export class EngineHarness {
      */
     readonly p: Promise<any> | null;
     /**
-     * @param {(config:EngineConfiguration,engine:Engine)=>*} configuration
+     * @param {(config:EngineConfiguration,engine:Engine)=>*} [configuration]
      * @param {boolean} [enable_localization] Whether or not to load localization data
      * @returns {Promise<Engine>}
      */

package/src/engine/EngineHarness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EngineHarness.d.ts","sourceRoot":"","sources":["../../../src/engine/EngineHarness.js"],"names":[],"mappings":"AA6DA;IAmBI;;;OAGG;IACH,6BAFW,MAAM,QAYhB;IAkED;;;;;;;;;;;;;OAaG;IACH;QAZyB,MAAM,EAApB,MAAM;QACyB,GAAG;QAClB,MAAM,GAAtB,OAAO;QACQ,QAAQ,GAAvB,MAAM;QACS,KAAK,GAApB,MAAM;QACS,GAAG,GAAlB,MAAM;QACU,QAAQ,GAAxB,OAAO;QACQ,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACJ,MAAM,CA+DlB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oQAnBW,MAAM,iBAmFhB;IAGD;;;;;;;;;;OAUG;IACH;QATyB,MAAM,EAApB,MAAM;QACyB,GAAG;QACnB,mBAAmB,GAAlC,MAAM;QACU,UAAU,GAA1B,OAAO;QACO,GAAG,GAAjB,KAAK;QACU,YAAY,GAA3B,MAAM;QACQ,OAAO,GAArB,KAAK;QACU,gBAAgB,GAA/B,MAAM;sBAqDhB;IAED;;;;;;;OAOG;IACH;QAN0B,YAAY,GAA3B,MAAM;QACQ,MAAM,EAApB,MAAM;QACS,WAAW,GAA1B,MAAM;QACyB,GAAG;QAChC,MAAM,CA2ClB;IAGD;;;;;;;;;;;OAWG;IACH,mGAVW,MAAM,GAQJ,OAAO,CAuDnB;IA3bG;;;OAGG;IACH,QAFU,MAAM,CAEiC;IAMjD;;;OAGG;IACH,YAFU,eAAQ,IAAI,CAET;IAmBjB;;;;OAIG;IACH,8DAJmB,mBAAmB,UAAQ,MAAM,WAEvC,QAAQ,MAAM,CAAC,CA2D3B;CA6VJ;;IAID;;;OAGG;IACH,uCAMC;;mBA1fkB,aAAa;oCACI,0BAA0B;oBAX1C,yBAAyB;mBAK1B,iBAAiB;sBATd,wBAAwB;oBAW1B,8BAA8B"}
+{"version":3,"file":"EngineHarness.d.ts","sourceRoot":"","sources":["../../../src/engine/EngineHarness.js"],"names":[],"mappings":"AA6DA;IAmBI;;;;OAIG;IACH,8CAHmB,mBAAmB,UAAQ,MAAM,WACxC,QAAQ,MAAM,CAAC,CAM1B;IAED;;;OAGG;IACH,6BAFW,MAAM,QAYhB;IAkED;;;;;;;;;;;;;OAaG;IACH;QAZyB,MAAM,EAApB,MAAM;QACyB,GAAG;QAClB,MAAM,GAAtB,OAAO;QACQ,QAAQ,GAAvB,MAAM;QACS,KAAK,GAApB,MAAM;QACS,GAAG,GAAlB,MAAM;QACU,QAAQ,GAAxB,OAAO;QACQ,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACJ,MAAM,CA+DlB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oQAnBW,MAAM,iBAmFhB;IAGD;;;;;;;;;;OAUG;IACH;QATyB,MAAM,EAApB,MAAM;QACyB,GAAG;QACnB,mBAAmB,GAAlC,MAAM;QACU,UAAU,GAA1B,OAAO;QACO,GAAG,GAAjB,KAAK;QACU,YAAY,GAA3B,MAAM;QACQ,OAAO,GAArB,KAAK;QACU,gBAAgB,GAA/B,MAAM;sBAqDhB;IAED;;;;;;;OAOG;IACH;QAN0B,YAAY,GAA3B,MAAM;QACQ,MAAM,EAApB,MAAM;QACS,WAAW,GAA1B,MAAM;QACyB,GAAG;QAChC,MAAM,CA2ClB;IAGD;;;;;;;;;;;OAWG;IACH,mGAVW,MAAM,GAQJ,OAAO,CAuDnB;IAtcG;;;OAGG;IACH,QAFU,MAAM,CAEiC;IAMjD;;;OAGG;IACH,YAFU,eAAQ,IAAI,CAET;IA8BjB;;;;OAIG;IACH,8DAJmB,mBAAmB,UAAQ,MAAM,WAEvC,QAAQ,MAAM,CAAC,CA2D3B;CA6VJ;;IAID;;;OAGG;IACH,uCAMC;;mBArgBkB,aAAa;oCACI,0BAA0B;oBAX1C,yBAAyB;mBAK1B,iBAAiB;sBATd,wBAAwB;oBAW1B,8BAA8B"}

package/src/engine/EngineHarness.js

@@ -78,6 +78,17 @@ export class EngineHarness {
         this.p = null;
     }
 
+    /**
+     * Quick initialization of the engine in a sensible default configuration
+     * @param {(config:EngineConfiguration,engine:Engine)=>*} [configuration]
+     * @return {Promise<Engine>}
+     */
+    static async bootstrap({ configuration } = {}) {
+        const harness = new EngineHarness();
+
+        return harness.initialize({ configuration });
+    }
+
     /**
      *
      * @param {Engine} engine
@@ -95,7 +106,7 @@ export class EngineHarness {
     }
 
     /**
-     * @param {(config:EngineConfiguration,engine:Engine)=>*} configuration
+     * @param {(config:EngineConfiguration,engine:Engine)=>*} [configuration]
      * @param {boolean} [enable_localization] Whether or not to load localization data
      * @returns {Promise<Engine>}
      */

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

@@ -1 +1 @@
-{"version":3,"file":"AnimationTrack.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationTrack.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAwEI;;;;;OAKG;IACH,qBAJW,gBAAgB,SAChB,MAAM,GACL,cAAc,CAYzB;IAvFD;;;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;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,eAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QAahB;IAqBL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC"}
+{"version":3,"file":"AnimationTrack.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/AnimationTrack.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IA2EI;;;;;OAKG;IACH,qBAJW,gBAAgB,SAChB,MAAM,GACL,cAAc,CAYzB;IA1FD;;;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;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,eAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,QAgBhB;IAqBL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC"}

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

@@ -64,6 +64,9 @@ export class AnimationTrack {
      * @param {number} time
      */
     sample(output, output_offset, time) {
+        assert.isArrayLike(output, 'output');
+        assert.isNonNegativeInteger(output_offset, 'output_offset');
+
         const curves = this.curves;
         const curve_count = curves.length;
 

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

@@ -1,9 +1,9 @@
 /**
  *
  * @param {EntityNode} node
- * @param {string} path
+ * @param {string[]} path_parts
  * @returns {BoundValueWriter}
  */
-export function bind_property_writer(node: EntityNode, path: string): BoundValueWriter;
+export function bind_property_writer(node: EntityNode, path_parts: string[]): BoundValueWriter;
 import { BoundValueWriter } from "../curve/binding/BoundValueWriter.js";
 //# sourceMappingURL=bind_property_writer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bind_property_writer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/bind_property_writer.js"],"names":[],"mappings":"AAqFA;;;;;GAKG;AACH,6DAHW,MAAM,GACJ,gBAAgB,CA4B5B;iCAnHgC,sCAAsC"}
+{"version":3,"file":"bind_property_writer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/bind_property_writer.js"],"names":[],"mappings":"AA2FA;;;;;GAKG;AACH,mEAHW,MAAM,EAAE,GACN,gBAAgB,CA+B5B;iCA3HgC,sCAAsC"}

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

@@ -89,6 +89,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;IA2KD;;;;;;;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;IAzTD;;;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,uBAUC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACL,MAAM,CAiCjB;IAED;;;OAGG;IACH,qBAFW,MAAM,QAoBhB;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;yBA3UwB,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;
     }
 
@@ -171,17 +172,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);
             }
         }
 
@@ -236,6 +227,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;