@babylonjs/core 8.3.0 → 8.4.0

package/Animations/animation.optimizations.d.ts

@@ -0,0 +1,31 @@
+import type { Scene } from "../scene.js";
+/**
+ * Interface used to define the optimization options for animations
+ */
+export type AnimationOptimization = {
+    /**
+     * Do not merge runtime animations
+     * @defaultValue true
+     */
+    mergeRuntimeAnimations: false;
+} | {
+    /**
+     * All runtime animations will be merged into the first animatable
+     * @defaultValue true
+     */
+    mergeRuntimeAnimations: true;
+    /**
+     * If true, all keyframes evaluation will be merged from the first runtime animation
+     * You need to turn on `mergeRuntimeAnimations` for this to work
+     * @defaultValue false
+     */
+    mergeKeyFrames: boolean;
+};
+/**
+ * This is a destructive optimization that merges all animatables into the first one.
+ * That animatable will also host all the runtime animations.
+ * We expect that all the animatables are on the same timeframe (same start, end, loop, etc..)
+ * @param scene defines the scene to optimize
+ * @param options defines the optimization options
+ */
+export declare function OptimizeAnimations(scene: Scene, options?: Partial<AnimationOptimization>): void;

package/Animations/animation.optimizations.js

@@ -0,0 +1,41 @@
+/**
+ * This is a destructive optimization that merges all animatables into the first one.
+ * That animatable will also host all the runtime animations.
+ * We expect that all the animatables are on the same timeframe (same start, end, loop, etc..)
+ * @param scene defines the scene to optimize
+ * @param options defines the optimization options
+ */
+export function OptimizeAnimations(scene, options = {}) {
+    const mergeRuntimeAnimations = options.mergeRuntimeAnimations ?? true;
+    const mergeKeyFrames = options.mergeRuntimeAnimations === true ? (options.mergeKeyFrames ?? false) : false;
+    // We will go through all the current animatables and merge them
+    const animatables = scene.animatables;
+    if (animatables.length === 0) {
+        return;
+    }
+    const mainAnimatable = animatables[0];
+    for (let i = 1; i < animatables.length; i++) {
+        const animatable = animatables[i];
+        // Merge the current animatable with the main one
+        mainAnimatable._runtimeAnimations.push(...animatable._runtimeAnimations);
+    }
+    if (mergeRuntimeAnimations && mainAnimatable._runtimeAnimations.length > 1) {
+        // Make sure only one runtime animation is driving the beat
+        const mainRuntimeAnimation = mainAnimatable._runtimeAnimations[0];
+        for (let i = 1; i < mainAnimatable._runtimeAnimations.length; i++) {
+            const runtimeAnimation = mainAnimatable._runtimeAnimations[i];
+            runtimeAnimation._coreRuntimeAnimation = mainRuntimeAnimation;
+        }
+    }
+    if (mergeKeyFrames && mainAnimatable._runtimeAnimations.length > 1) {
+        // Merge the keyframes from all the runtime animations into the first one
+        const mainAnimation = mainAnimatable._runtimeAnimations[0]._animation;
+        for (let i = 1; i < mainAnimatable._runtimeAnimations.length; i++) {
+            const runtimeAnimation = mainAnimatable._runtimeAnimations[i];
+            const animation = runtimeAnimation._animation;
+            animation._coreAnimation = mainAnimation;
+        }
+    }
+    scene._activeAnimatables = [mainAnimatable];
+}
+//# sourceMappingURL=animation.optimizations.js.map

package/Animations/animation.optimizations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation.optimizations.js","sourceRoot":"","sources":["../../../../dev/core/src/Animations/animation.optimizations.ts"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAY,EAAE,UAA0C,EAAE;IACzF,MAAM,sBAAsB,GAAG,OAAO,CAAC,sBAAsB,IAAI,IAAI,CAAC;IACtE,MAAM,cAAc,GAAG,OAAO,CAAC,sBAAsB,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,cAAc,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAE3G,gEAAgE;IAChE,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;IAEtC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO;IACX,CAAC;IAED,MAAM,cAAc,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;IAEtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;QAElC,iDAAiD;QACjD,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAAC;IAC7E,CAAC;IAED,IAAI,sBAAsB,IAAI,cAAc,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzE,2DAA2D;QAC3D,MAAM,oBAAoB,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;QAClE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAChE,MAAM,gBAAgB,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;YAC9D,gBAAgB,CAAC,qBAAqB,GAAG,oBAAoB,CAAC;QAClE,CAAC;IACL,CAAC;IAED,IAAI,cAAc,IAAI,cAAc,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjE,yEAAyE;QACzE,MAAM,aAAa,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QACtE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAChE,MAAM,gBAAgB,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;YAC9D,MAAM,SAAS,GAAG,gBAAgB,CAAC,UAAU,CAAC;YAC9C,SAAS,CAAC,cAAc,GAAG,aAAa,CAAC;QAC7C,CAAC;IACL,CAAC;IAED,KAAK,CAAC,kBAAkB,GAAG,CAAC,cAAc,CAAC,CAAC;AAChD,CAAC","sourcesContent":["import type { Scene } from \"core/scene\";\r\n\r\n/**\r\n * Interface used to define the optimization options for animations\r\n */\r\nexport type AnimationOptimization =\r\n    | {\r\n          /**\r\n           * Do not merge runtime animations\r\n           * @defaultValue true\r\n           */\r\n          mergeRuntimeAnimations: false;\r\n      }\r\n    | {\r\n          /**\r\n           * All runtime animations will be merged into the first animatable\r\n           * @defaultValue true\r\n           */\r\n          mergeRuntimeAnimations: true;\r\n          /**\r\n           * If true, all keyframes evaluation will be merged from the first runtime animation\r\n           * You need to turn on `mergeRuntimeAnimations` for this to work\r\n           * @defaultValue false\r\n           */\r\n          mergeKeyFrames: boolean;\r\n      };\r\n\r\n/**\r\n * This is a destructive optimization that merges all animatables into the first one.\r\n * That animatable will also host all the runtime animations.\r\n * We expect that all the animatables are on the same timeframe (same start, end, loop, etc..)\r\n * @param scene defines the scene to optimize\r\n * @param options defines the optimization options\r\n */\r\nexport function OptimizeAnimations(scene: Scene, options: Partial<AnimationOptimization> = {}) {\r\n    const mergeRuntimeAnimations = options.mergeRuntimeAnimations ?? true;\r\n    const mergeKeyFrames = options.mergeRuntimeAnimations === true ? (options.mergeKeyFrames ?? false) : false;\r\n\r\n    // We will go through all the current animatables and merge them\r\n    const animatables = scene.animatables;\r\n\r\n    if (animatables.length === 0) {\r\n        return;\r\n    }\r\n\r\n    const mainAnimatable = animatables[0];\r\n\r\n    for (let i = 1; i < animatables.length; i++) {\r\n        const animatable = animatables[i];\r\n\r\n        // Merge the current animatable with the main one\r\n        mainAnimatable._runtimeAnimations.push(...animatable._runtimeAnimations);\r\n    }\r\n\r\n    if (mergeRuntimeAnimations && mainAnimatable._runtimeAnimations.length > 1) {\r\n        // Make sure only one runtime animation is driving the beat\r\n        const mainRuntimeAnimation = mainAnimatable._runtimeAnimations[0];\r\n        for (let i = 1; i < mainAnimatable._runtimeAnimations.length; i++) {\r\n            const runtimeAnimation = mainAnimatable._runtimeAnimations[i];\r\n            runtimeAnimation._coreRuntimeAnimation = mainRuntimeAnimation;\r\n        }\r\n    }\r\n\r\n    if (mergeKeyFrames && mainAnimatable._runtimeAnimations.length > 1) {\r\n        // Merge the keyframes from all the runtime animations into the first one\r\n        const mainAnimation = mainAnimatable._runtimeAnimations[0]._animation;\r\n        for (let i = 1; i < mainAnimatable._runtimeAnimations.length; i++) {\r\n            const runtimeAnimation = mainAnimatable._runtimeAnimations[i];\r\n            const animation = runtimeAnimation._animation;\r\n            animation._coreAnimation = mainAnimation;\r\n        }\r\n    }\r\n\r\n    scene._activeAnimatables = [mainAnimatable];\r\n}\r\n"]}

package/Animations/index.d.ts

@@ -10,3 +10,4 @@ export * from "./animationRange.js";
 export * from "./animatable.interface.js";
 export * from "./pathCursor.js";
 export * from "./animationGroupMask.js";
+export * from "./animation.optimizations.js";

package/Animations/index.js

@@ -10,4 +10,5 @@ export * from "./animationRange.js";
 export * from "./animatable.interface.js";
 export * from "./pathCursor.js";
 export * from "./animationGroupMask.js";
+export * from "./animation.optimizations.js";
 //# sourceMappingURL=index.js.map

package/Animations/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../dev/core/src/Animations/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC","sourcesContent":["export * from \"./animatable\";\r\nexport * from \"./animation\";\r\nexport * from \"./animationPropertiesOverride\";\r\nexport * from \"./easing\";\r\nexport * from \"./runtimeAnimation\";\r\nexport * from \"./animationEvent\";\r\nexport * from \"./animationGroup\";\r\nexport * from \"./animationKey\";\r\nexport * from \"./animationRange\";\r\nexport * from \"./animatable.interface\";\r\nexport * from \"./pathCursor\";\r\nexport * from \"./animationGroupMask\";\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../dev/core/src/Animations/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,UAAU,CAAC;AACzB,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC","sourcesContent":["export * from \"./animatable\";\r\nexport * from \"./animation\";\r\nexport * from \"./animationPropertiesOverride\";\r\nexport * from \"./easing\";\r\nexport * from \"./runtimeAnimation\";\r\nexport * from \"./animationEvent\";\r\nexport * from \"./animationGroup\";\r\nexport * from \"./animationKey\";\r\nexport * from \"./animationRange\";\r\nexport * from \"./animatable.interface\";\r\nexport * from \"./pathCursor\";\r\nexport * from \"./animationGroupMask\";\r\nexport * from \"./animation.optimizations\";\r\n"]}

package/Animations/pathCursor.js

@@ -82,7 +82,9 @@ export class PathCursor {
      * @returns This path cursor
      */
     _raiseOnChange() {
-        this._onchange.forEach((f) => f(this));
+        for (const f of this._onchange) {
+            f(this);
+        }
         return this;
     }
     /**

package/Animations/pathCursor.js.map

@@ -1 +1 @@
-{"version":3,"file":"pathCursor.js","sourceRoot":"","sources":["../../../../dev/core/src/Animations/pathCursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAG/C;;GAEG;AACH,MAAM,OAAO,UAAU;IAgBnB;;;OAGG;IACH,YAAoB,KAAY;QAAZ,UAAK,GAAL,KAAK,CAAO;QAnBhC;;WAEG;QACK,cAAS,GAAG,IAAI,KAAK,EAAgC,CAAC;QAE9D;;WAEG;QACH,UAAK,GAAW,CAAC,CAAC;QAElB;;WAEG;QACH,eAAU,GAAG,EAAiB,CAAC;IAMI,CAAC;IAEpC;;;OAGG;IACI,QAAQ;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9D,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACI,SAAS,CAAC,OAAe,KAAK;QACjC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEhB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,OAAe,KAAK;QAChC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;QAEjB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACI,IAAI,CAAC,IAAY;QACpB,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACrB,4CAA4C;YAC5C,MAAM,kCAAkC,CAAC;QAC7C,CAAC;QAED,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC;QACnB,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,aAAa;QACjB,OAAO,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QACpB,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QACpB,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,cAAc;QAClB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAEvC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,CAA+B;QAC3C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAEvB,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ","sourcesContent":["import { Vector3 } from \"../Maths/math.vector\";\r\nimport type { Path2 } from \"../Maths/math.path\";\r\n\r\n/**\r\n * A cursor which tracks a point on a path\r\n */\r\nexport class PathCursor {\r\n    /**\r\n     * Stores path cursor callbacks for when an onchange event is triggered\r\n     */\r\n    private _onchange = new Array<(cursor: PathCursor) => void>();\r\n\r\n    /**\r\n     * The value of the path cursor\r\n     */\r\n    value: number = 0;\r\n\r\n    /**\r\n     * The animation array of the path cursor\r\n     */\r\n    animations = [] as Animation[];\r\n\r\n    /**\r\n     * Initializes the path cursor\r\n     * @param _path The path to track\r\n     */\r\n    constructor(private _path: Path2) {}\r\n\r\n    /**\r\n     * Gets the cursor point on the path\r\n     * @returns A point on the path cursor at the cursor location\r\n     */\r\n    public getPoint(): Vector3 {\r\n        const point = this._path.getPointAtLengthPosition(this.value);\r\n        return new Vector3(point.x, 0, point.y);\r\n    }\r\n\r\n    /**\r\n     * Moves the cursor ahead by the step amount\r\n     * @param step The amount to move the cursor forward\r\n     * @returns This path cursor\r\n     */\r\n    public moveAhead(step: number = 0.002): PathCursor {\r\n        this.move(step);\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Moves the cursor behind by the step amount\r\n     * @param step The amount to move the cursor back\r\n     * @returns This path cursor\r\n     */\r\n    public moveBack(step: number = 0.002): PathCursor {\r\n        this.move(-step);\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Moves the cursor by the step amount\r\n     * If the step amount is greater than one, an exception is thrown\r\n     * @param step The amount to move the cursor\r\n     * @returns This path cursor\r\n     */\r\n    public move(step: number): PathCursor {\r\n        if (Math.abs(step) > 1) {\r\n            // eslint-disable-next-line no-throw-literal\r\n            throw \"step size should be less than 1.\";\r\n        }\r\n\r\n        this.value += step;\r\n        this._ensureLimits();\r\n        this._raiseOnChange();\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Ensures that the value is limited between zero and one\r\n     * @returns This path cursor\r\n     */\r\n    private _ensureLimits(): PathCursor {\r\n        while (this.value > 1) {\r\n            this.value -= 1;\r\n        }\r\n        while (this.value < 0) {\r\n            this.value += 1;\r\n        }\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Runs onchange callbacks on change (used by the animation engine)\r\n     * @returns This path cursor\r\n     */\r\n    private _raiseOnChange(): PathCursor {\r\n        this._onchange.forEach((f) => f(this));\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Executes a function on change\r\n     * @param f A path cursor onchange callback\r\n     * @returns This path cursor\r\n     */\r\n    public onchange(f: (cursor: PathCursor) => void): PathCursor {\r\n        this._onchange.push(f);\r\n\r\n        return this;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"pathCursor.js","sourceRoot":"","sources":["../../../../dev/core/src/Animations/pathCursor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAG/C;;GAEG;AACH,MAAM,OAAO,UAAU;IAgBnB;;;OAGG;IACH,YAAoB,KAAY;QAAZ,UAAK,GAAL,KAAK,CAAO;QAnBhC;;WAEG;QACK,cAAS,GAAG,IAAI,KAAK,EAAgC,CAAC;QAE9D;;WAEG;QACH,UAAK,GAAW,CAAC,CAAC;QAElB;;WAEG;QACH,eAAU,GAAG,EAAiB,CAAC;IAMI,CAAC;IAEpC;;;OAGG;IACI,QAAQ;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC9D,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACI,SAAS,CAAC,OAAe,KAAK;QACjC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEhB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,OAAe,KAAK;QAChC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;QAEjB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACI,IAAI,CAAC,IAAY;QACpB,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACrB,4CAA4C;YAC5C,MAAM,kCAAkC,CAAC;QAC7C,CAAC;QAED,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC;QACnB,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,aAAa;QACjB,OAAO,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QACpB,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QACpB,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACK,cAAc;QAClB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC7B,CAAC,CAAC,IAAI,CAAC,CAAC;QACZ,CAAC;QAED,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,CAA+B;QAC3C,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAEvB,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ","sourcesContent":["import { Vector3 } from \"../Maths/math.vector\";\r\nimport type { Path2 } from \"../Maths/math.path\";\r\n\r\n/**\r\n * A cursor which tracks a point on a path\r\n */\r\nexport class PathCursor {\r\n    /**\r\n     * Stores path cursor callbacks for when an onchange event is triggered\r\n     */\r\n    private _onchange = new Array<(cursor: PathCursor) => void>();\r\n\r\n    /**\r\n     * The value of the path cursor\r\n     */\r\n    value: number = 0;\r\n\r\n    /**\r\n     * The animation array of the path cursor\r\n     */\r\n    animations = [] as Animation[];\r\n\r\n    /**\r\n     * Initializes the path cursor\r\n     * @param _path The path to track\r\n     */\r\n    constructor(private _path: Path2) {}\r\n\r\n    /**\r\n     * Gets the cursor point on the path\r\n     * @returns A point on the path cursor at the cursor location\r\n     */\r\n    public getPoint(): Vector3 {\r\n        const point = this._path.getPointAtLengthPosition(this.value);\r\n        return new Vector3(point.x, 0, point.y);\r\n    }\r\n\r\n    /**\r\n     * Moves the cursor ahead by the step amount\r\n     * @param step The amount to move the cursor forward\r\n     * @returns This path cursor\r\n     */\r\n    public moveAhead(step: number = 0.002): PathCursor {\r\n        this.move(step);\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Moves the cursor behind by the step amount\r\n     * @param step The amount to move the cursor back\r\n     * @returns This path cursor\r\n     */\r\n    public moveBack(step: number = 0.002): PathCursor {\r\n        this.move(-step);\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Moves the cursor by the step amount\r\n     * If the step amount is greater than one, an exception is thrown\r\n     * @param step The amount to move the cursor\r\n     * @returns This path cursor\r\n     */\r\n    public move(step: number): PathCursor {\r\n        if (Math.abs(step) > 1) {\r\n            // eslint-disable-next-line no-throw-literal\r\n            throw \"step size should be less than 1.\";\r\n        }\r\n\r\n        this.value += step;\r\n        this._ensureLimits();\r\n        this._raiseOnChange();\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Ensures that the value is limited between zero and one\r\n     * @returns This path cursor\r\n     */\r\n    private _ensureLimits(): PathCursor {\r\n        while (this.value > 1) {\r\n            this.value -= 1;\r\n        }\r\n        while (this.value < 0) {\r\n            this.value += 1;\r\n        }\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Runs onchange callbacks on change (used by the animation engine)\r\n     * @returns This path cursor\r\n     */\r\n    private _raiseOnChange(): PathCursor {\r\n        for (const f of this._onchange) {\r\n            f(this);\r\n        }\r\n\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Executes a function on change\r\n     * @param f A path cursor onchange callback\r\n     * @returns This path cursor\r\n     */\r\n    public onchange(f: (cursor: PathCursor) => void): PathCursor {\r\n        this._onchange.push(f);\r\n\r\n        return this;\r\n    }\r\n}\r\n"]}

package/Animations/runtimeAnimation.d.ts

@@ -14,7 +14,7 @@ export declare class RuntimeAnimation {
     /**
      * The animation used by the runtime animation
      */
-    private _animation;
+    _animation: Animation;
     /**
      * The target of the runtime animation
      */
@@ -91,6 +91,8 @@ export declare class RuntimeAnimation {
     private _minValue;
     private _maxValue;
     private _targetIsArray;
+    /** @internal */
+    _coreRuntimeAnimation: RuntimeAnimation | null;
     /**
      * Gets the current frame of the runtime animation
      */

package/Animations/runtimeAnimation.js

@@ -105,6 +105,8 @@ export class RuntimeAnimation {
          */
         this._previousAbsoluteFrame = 0;
         this._targetIsArray = false;
+        /** @internal */
+        this._coreRuntimeAnimation = null;
         this._animation = animation;
         this._target = target;
         this._scene = scene;
@@ -150,9 +152,9 @@ export class RuntimeAnimation {
         // Cloning events locally
         const events = animation.getEvents();
         if (events && events.length > 0) {
-            events.forEach((e) => {
+            for (const e of events) {
                 this._events.push(e._clone());
-            });
+            }
         }
         this._enableBlending = target && target.animationPropertiesOverride ? target.animationPropertiesOverride.enableBlending : this._animation.enableBlending;
     }
@@ -423,150 +425,159 @@ export class RuntimeAnimation {
             return false;
         }
         let returnValue = true;
-        // Check limits
-        if (from < this._minFrame || from > this._maxFrame) {
-            from = this._minFrame;
-        }
-        if (to < this._minFrame || to > this._maxFrame) {
-            to = this._maxFrame;
-        }
+        let currentFrame;
+        const events = this._events;
         const frameRange = to - from;
-        let offsetValue;
-        // Compute the frame according to the elapsed time and the fps of the animation ("from" and "to" are not factored in!)
-        let absoluteFrame = (elapsedTimeSinceAnimationStart * (animation.framePerSecond * speedRatio)) / 1000.0 + this._absoluteFrameOffset;
-        let highLimitValue = 0;
-        // Apply the yoyo function if required
-        let yoyoLoop = false;
-        const yoyoMode = loop && this._animationState.loopMode === Animation.ANIMATIONLOOPMODE_YOYO;
-        if (yoyoMode) {
-            const position = (absoluteFrame - from) / frameRange;
-            // Apply the yoyo curve
-            const sin = Math.sin(position * Math.PI);
-            const yoyoPosition = Math.abs(sin);
-            // Map the yoyo position back to the range
-            absoluteFrame = yoyoPosition * frameRange + from;
-            const direction = sin >= 0 ? 1 : -1;
-            if (this._yoyoDirection !== direction) {
-                yoyoLoop = true;
+        if (!this._coreRuntimeAnimation) {
+            // Check limits
+            if (from < this._minFrame || from > this._maxFrame) {
+                from = this._minFrame;
+            }
+            if (to < this._minFrame || to > this._maxFrame) {
+                to = this._maxFrame;
+            }
+            let offsetValue;
+            // Compute the frame according to the elapsed time and the fps of the animation ("from" and "to" are not factored in!)
+            let absoluteFrame = (elapsedTimeSinceAnimationStart * (animation.framePerSecond * speedRatio)) / 1000.0 + this._absoluteFrameOffset;
+            let highLimitValue = 0;
+            // Apply the yoyo function if required
+            let yoyoLoop = false;
+            const yoyoMode = loop && this._animationState.loopMode === Animation.ANIMATIONLOOPMODE_YOYO;
+            if (yoyoMode) {
+                const position = (absoluteFrame - from) / frameRange;
+                // Apply the yoyo curve
+                const sin = Math.sin(position * Math.PI);
+                const yoyoPosition = Math.abs(sin);
+                // Map the yoyo position back to the range
+                absoluteFrame = yoyoPosition * frameRange + from;
+                const direction = sin >= 0 ? 1 : -1;
+                if (this._yoyoDirection !== direction) {
+                    yoyoLoop = true;
+                }
+                this._yoyoDirection = direction;
+            }
+            this._previousElapsedTime = elapsedTimeSinceAnimationStart;
+            this._previousAbsoluteFrame = absoluteFrame;
+            if (!loop && to >= from && ((absoluteFrame >= frameRange && speedRatio > 0) || (absoluteFrame <= 0 && speedRatio < 0))) {
+                // If we are out of range and not looping get back to caller
+                returnValue = false;
+                highLimitValue = animation._getKeyValue(this._maxValue);
             }
-            this._yoyoDirection = direction;
-        }
-        this._previousElapsedTime = elapsedTimeSinceAnimationStart;
-        this._previousAbsoluteFrame = absoluteFrame;
-        if (!loop && to >= from && ((absoluteFrame >= frameRange && speedRatio > 0) || (absoluteFrame <= 0 && speedRatio < 0))) {
-            // If we are out of range and not looping get back to caller
-            returnValue = false;
-            highLimitValue = animation._getKeyValue(this._maxValue);
-        }
-        else if (!loop && from >= to && ((absoluteFrame <= frameRange && speedRatio < 0) || (absoluteFrame >= 0 && speedRatio > 0))) {
-            returnValue = false;
-            highLimitValue = animation._getKeyValue(this._minValue);
-        }
-        else if (this._animationState.loopMode !== Animation.ANIMATIONLOOPMODE_CYCLE) {
-            const keyOffset = to.toString() + from.toString();
-            if (!this._offsetsCache[keyOffset]) {
-                this._animationState.repeatCount = 0;
-                this._animationState.loopMode = Animation.ANIMATIONLOOPMODE_CYCLE; // force a specific codepath in animation._interpolate()!
-                const fromValue = animation._interpolate(from, this._animationState);
-                const toValue = animation._interpolate(to, this._animationState);
-                this._animationState.loopMode = this._getCorrectLoopMode();
+            else if (!loop && from >= to && ((absoluteFrame <= frameRange && speedRatio < 0) || (absoluteFrame >= 0 && speedRatio > 0))) {
+                returnValue = false;
+                highLimitValue = animation._getKeyValue(this._minValue);
+            }
+            else if (this._animationState.loopMode !== Animation.ANIMATIONLOOPMODE_CYCLE) {
+                const keyOffset = to.toString() + from.toString();
+                if (!this._offsetsCache[keyOffset]) {
+                    this._animationState.repeatCount = 0;
+                    this._animationState.loopMode = Animation.ANIMATIONLOOPMODE_CYCLE; // force a specific codepath in animation._interpolate()!
+                    const fromValue = animation._interpolate(from, this._animationState);
+                    const toValue = animation._interpolate(to, this._animationState);
+                    this._animationState.loopMode = this._getCorrectLoopMode();
+                    switch (animation.dataType) {
+                        // Float
+                        case Animation.ANIMATIONTYPE_FLOAT:
+                            this._offsetsCache[keyOffset] = toValue - fromValue;
+                            break;
+                        // Quaternion
+                        case Animation.ANIMATIONTYPE_QUATERNION:
+                            this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                            break;
+                        // Vector3
+                        case Animation.ANIMATIONTYPE_VECTOR3:
+                            this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                            break;
+                        // Vector2
+                        case Animation.ANIMATIONTYPE_VECTOR2:
+                            this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                            break;
+                        // Size
+                        case Animation.ANIMATIONTYPE_SIZE:
+                            this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                            break;
+                        // Color3
+                        case Animation.ANIMATIONTYPE_COLOR3:
+                            this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                            break;
+                        default:
+                            break;
+                    }
+                    this._highLimitsCache[keyOffset] = toValue;
+                }
+                highLimitValue = this._highLimitsCache[keyOffset];
+                offsetValue = this._offsetsCache[keyOffset];
+            }
+            if (offsetValue === undefined) {
                 switch (animation.dataType) {
                     // Float
                     case Animation.ANIMATIONTYPE_FLOAT:
-                        this._offsetsCache[keyOffset] = toValue - fromValue;
+                        offsetValue = 0;
                         break;
                     // Quaternion
                     case Animation.ANIMATIONTYPE_QUATERNION:
-                        this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                        offsetValue = _staticOffsetValueQuaternion;
                         break;
                     // Vector3
                     case Animation.ANIMATIONTYPE_VECTOR3:
-                        this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                        offsetValue = _staticOffsetValueVector3;
                         break;
                     // Vector2
                     case Animation.ANIMATIONTYPE_VECTOR2:
-                        this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                        offsetValue = _staticOffsetValueVector2;
                         break;
                     // Size
                     case Animation.ANIMATIONTYPE_SIZE:
-                        this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                        offsetValue = _staticOffsetValueSize;
                         break;
                     // Color3
                     case Animation.ANIMATIONTYPE_COLOR3:
-                        this._offsetsCache[keyOffset] = toValue.subtract(fromValue);
+                        offsetValue = _staticOffsetValueColor3;
                         break;
-                    default:
+                    case Animation.ANIMATIONTYPE_COLOR4:
+                        offsetValue = _staticOffsetValueColor4;
                         break;
                 }
-                this._highLimitsCache[keyOffset] = toValue;
-            }
-            highLimitValue = this._highLimitsCache[keyOffset];
-            offsetValue = this._offsetsCache[keyOffset];
-        }
-        if (offsetValue === undefined) {
-            switch (animation.dataType) {
-                // Float
-                case Animation.ANIMATIONTYPE_FLOAT:
-                    offsetValue = 0;
-                    break;
-                // Quaternion
-                case Animation.ANIMATIONTYPE_QUATERNION:
-                    offsetValue = _staticOffsetValueQuaternion;
-                    break;
-                // Vector3
-                case Animation.ANIMATIONTYPE_VECTOR3:
-                    offsetValue = _staticOffsetValueVector3;
-                    break;
-                // Vector2
-                case Animation.ANIMATIONTYPE_VECTOR2:
-                    offsetValue = _staticOffsetValueVector2;
-                    break;
-                // Size
-                case Animation.ANIMATIONTYPE_SIZE:
-                    offsetValue = _staticOffsetValueSize;
-                    break;
-                // Color3
-                case Animation.ANIMATIONTYPE_COLOR3:
-                    offsetValue = _staticOffsetValueColor3;
-                    break;
-                case Animation.ANIMATIONTYPE_COLOR4:
-                    offsetValue = _staticOffsetValueColor4;
-                    break;
             }
-        }
-        // Compute value
-        let currentFrame;
-        if (this._host && this._host.syncRoot) {
-            // If we must sync with an animatable, calculate the current frame based on the frame of the root animatable
-            const syncRoot = this._host.syncRoot;
-            const hostNormalizedFrame = (syncRoot.masterFrame - syncRoot.fromFrame) / (syncRoot.toFrame - syncRoot.fromFrame);
-            currentFrame = from + frameRange * hostNormalizedFrame;
-        }
-        else {
-            if ((absoluteFrame > 0 && from > to) || (absoluteFrame < 0 && from < to)) {
-                currentFrame = returnValue && frameRange !== 0 ? to + (absoluteFrame % frameRange) : from;
+            // Compute value
+            if (this._host && this._host.syncRoot) {
+                // If we must sync with an animatable, calculate the current frame based on the frame of the root animatable
+                const syncRoot = this._host.syncRoot;
+                const hostNormalizedFrame = (syncRoot.masterFrame - syncRoot.fromFrame) / (syncRoot.toFrame - syncRoot.fromFrame);
+                currentFrame = from + frameRange * hostNormalizedFrame;
             }
             else {
-                currentFrame = returnValue && frameRange !== 0 ? from + (absoluteFrame % frameRange) : to;
+                if ((absoluteFrame > 0 && from > to) || (absoluteFrame < 0 && from < to)) {
+                    currentFrame = returnValue && frameRange !== 0 ? to + (absoluteFrame % frameRange) : from;
+                }
+                else {
+                    currentFrame = returnValue && frameRange !== 0 ? from + (absoluteFrame % frameRange) : to;
+                }
             }
-        }
-        const events = this._events;
-        // Reset event/state if looping
-        if ((!yoyoMode && ((speedRatio > 0 && this.currentFrame > currentFrame) || (speedRatio < 0 && this.currentFrame < currentFrame))) || (yoyoMode && yoyoLoop)) {
-            this._onLoop();
-            // Need to reset animation events
-            for (let index = 0; index < events.length; index++) {
-                if (!events[index].onlyOnce) {
-                    // reset event, the animation is looping
-                    events[index].isDone = false;
+            // Reset event/state if looping
+            if ((!yoyoMode && ((speedRatio > 0 && this.currentFrame > currentFrame) || (speedRatio < 0 && this.currentFrame < currentFrame))) || (yoyoMode && yoyoLoop)) {
+                this._onLoop();
+                // Need to reset animation events
+                for (let index = 0; index < events.length; index++) {
+                    if (!events[index].onlyOnce) {
+                        // reset event, the animation is looping
+                        events[index].isDone = false;
+                    }
                 }
+                this._animationState.key = speedRatio > 0 ? 0 : animation.getKeys().length - 1;
             }
-            this._animationState.key = speedRatio > 0 ? 0 : animation.getKeys().length - 1;
+            this._currentFrame = currentFrame;
+            this._animationState.repeatCount = frameRange === 0 ? 0 : (absoluteFrame / frameRange) >> 0;
+            this._animationState.highLimitValue = highLimitValue;
+            this._animationState.offsetValue = offsetValue;
+        }
+        else {
+            currentFrame = this._coreRuntimeAnimation.currentFrame;
+            this._currentFrame = currentFrame;
+            this._animationState.repeatCount = this._coreRuntimeAnimation._animationState.repeatCount;
+            this._animationState.highLimitValue = this._coreRuntimeAnimation._animationState.highLimitValue;
+            this._animationState.offsetValue = this._coreRuntimeAnimation._animationState.offsetValue;
         }
-        this._currentFrame = currentFrame;
-        this._animationState.repeatCount = frameRange === 0 ? 0 : (absoluteFrame / frameRange) >> 0;
-        this._animationState.highLimitValue = highLimitValue;
-        this._animationState.offsetValue = offsetValue;
         const currentValue = animation._interpolate(currentFrame, this._animationState);
         // Set value
         this.setValue(currentValue, weight);