@babylonjs/core 5.0.0-alpha.60 → 5.0.0-alpha.61

package/Animations/animationKey.js

@@ -3,6 +3,10 @@
  */
 export var AnimationKeyInterpolation;
 (function (AnimationKeyInterpolation) {
+    /**
+     * Use tangents to interpolate between start and end values.
+     */
+    AnimationKeyInterpolation[AnimationKeyInterpolation["NONE"] = 0] = "NONE";
     /**
      * Do not interpolate between keys and use the start key value only. Tangents are ignored
      */

package/Animations/animationKey.js.map

@@ -1 +1 @@
-{"version":3,"file":"animationKey.js","sourceRoot":"","sources":["../../../sourceES6/core/Animations/animationKey.ts"],"names":[],"mappings":"AA8BA;;GAEG;AACH,MAAM,CAAN,IAAY,yBAKX;AALD,WAAY,yBAAyB;IACjC;;OAEG;IACH,yEAAQ,CAAA;AACZ,CAAC,EALW,yBAAyB,KAAzB,yBAAyB,QAKpC","sourcesContent":["/**\r\n * Defines an interface which represents an animation key frame\r\n */\r\nexport interface IAnimationKey {\r\n    /**\r\n     * Frame of the key frame\r\n     */\r\n    frame: number;\r\n    /**\r\n     * Value at the specifies key frame\r\n     */\r\n    value: any;\r\n    /**\r\n     * The input tangent for the cubic hermite spline\r\n     */\r\n    inTangent?: any;\r\n    /**\r\n     * The output tangent for the cubic hermite spline\r\n     */\r\n    outTangent?: any;\r\n    /**\r\n     * The animation interpolation type\r\n     */\r\n    interpolation?: AnimationKeyInterpolation;\r\n    /**\r\n     * Property defined by UI tools to link (or not ) the tangents\r\n     */\r\n    lockedTangent?: boolean;\r\n}\r\n\r\n/**\r\n * Enum for the animation key frame interpolation type\r\n */\r\nexport enum AnimationKeyInterpolation {\r\n    /**\r\n     * Do not interpolate between keys and use the start key value only. Tangents are ignored\r\n     */\r\n    STEP = 1\r\n}"]}
+{"version":3,"file":"animationKey.js","sourceRoot":"","sources":["../../../sourceES6/core/Animations/animationKey.ts"],"names":[],"mappings":"AA8BA;;GAEG;AACH,MAAM,CAAN,IAAY,yBASX;AATD,WAAY,yBAAyB;IACjC;;OAEG;IACH,yEAAQ,CAAA;IACR;;OAEG;IACH,yEAAQ,CAAA;AACZ,CAAC,EATW,yBAAyB,KAAzB,yBAAyB,QASpC","sourcesContent":["/**\r\n * Defines an interface which represents an animation key frame\r\n */\r\nexport interface IAnimationKey {\r\n    /**\r\n     * Frame of the key frame\r\n     */\r\n    frame: number;\r\n    /**\r\n     * Value at the specifies key frame\r\n     */\r\n    value: any;\r\n    /**\r\n     * The input tangent for the cubic hermite spline\r\n     */\r\n    inTangent?: any;\r\n    /**\r\n     * The output tangent for the cubic hermite spline\r\n     */\r\n    outTangent?: any;\r\n    /**\r\n     * The animation interpolation type\r\n     */\r\n    interpolation?: AnimationKeyInterpolation;\r\n    /**\r\n     * Property defined by UI tools to link (or not ) the tangents\r\n     */\r\n    lockedTangent?: boolean;\r\n}\r\n\r\n/**\r\n * Enum for the animation key frame interpolation type\r\n */\r\nexport enum AnimationKeyInterpolation {\r\n    /**\r\n     * Use tangents to interpolate between start and end values.\r\n     */\r\n    NONE = 0,\r\n    /**\r\n     * Do not interpolate between keys and use the start key value only. Tangents are ignored\r\n     */\r\n    STEP = 1,\r\n}\r\n"]}

package/BakedVertexAnimation/bakedVertexAnimationManager.d.ts

@@ -0,0 +1,130 @@
+import { Nullable } from "../types";
+import { Scene } from "../scene";
+import { BaseTexture } from '../Materials/Textures/baseTexture';
+import { Vector4 } from "../Maths/math.vector";
+import { Effect } from "../Materials/effect";
+/**
+ * Interface for baked vertex animation texture, see BakedVertexAnimationManager
+ * @since 5.0
+ */
+export interface IBakedVertexAnimationManager {
+    /**
+     * The vertex animation texture
+     */
+    texture: Nullable<BaseTexture>;
+    /**
+     * Gets or sets a boolean indicating if the edgesRenderer is active
+     */
+    isEnabled: boolean;
+    /**
+     * The animation parameters for the mesh. See setAnimationParameters()
+     */
+    animationParameters: Vector4;
+    /**
+     * The time counter, to pick the correct animation frame.
+     */
+    time: number;
+    /**
+     * Binds to the effect.
+     * @param effect The effect to bind to.
+     * @param useInstances True when it's an instance.
+     */
+    bind(effect: Effect, useInstances: boolean): void;
+    /**
+     * Sets animation parameters.
+     * @param startFrame The first frame of the animation.
+     * @param endFrame The last frame of the animation.
+     * @param offset The offset when starting the animation.
+     * @param speedFramesPerSecond The frame rate.
+     */
+    setAnimationParameters(startFrame: number, endFrame: number, offset: number, speedFramesPerSecond: number): void;
+    /**
+     * Disposes the resources of the manager.
+     * @param forceDisposeTextures - Forces the disposal of all textures.
+     */
+    dispose(forceDisposeTextures?: boolean): void;
+    /**
+     * Get the current class name useful for serialization or dynamic coding.
+     * @returns "BakedVertexAnimationManager"
+     */
+    getClassName(): string;
+}
+/**
+ * This class is used to animate meshes using a baked vertex animation texture
+ * @see https://doc.babylonjs.com/divingDeeper/animation/baked_texture_animations
+ * @since 5.0
+ */
+export declare class BakedVertexAnimationManager implements IBakedVertexAnimationManager {
+    private _scene;
+    private _texture;
+    /**
+     * The vertex animation texture
+     */
+    texture: Nullable<BaseTexture>;
+    private _isEnabled;
+    /**
+     * Enable or disable the vertex animation manager
+     */
+    isEnabled: boolean;
+    /**
+     * The animation parameters for the mesh. See setAnimationParameters()
+     */
+    animationParameters: Vector4;
+    /**
+     * The time counter, to pick the correct animation frame.
+     */
+    time: number;
+    /**
+     * Creates a new BakedVertexAnimationManager
+     * @param scene defines the current scene
+     */
+    constructor(scene: Scene);
+    /** @hidden */
+    _markSubMeshesAsAttributesDirty(): void;
+    /**
+     * Binds to the effect.
+     * @param effect The effect to bind to.
+     * @param useInstances True when it's an instance.
+     */
+    bind(effect: Effect, useInstances?: boolean): void;
+    /**
+     * Clone the current manager
+     * @returns a new BakedVertexAnimationManager
+     */
+    clone(): BakedVertexAnimationManager;
+    /**
+     * Sets animation parameters.
+     * @param startFrame The first frame of the animation.
+     * @param endFrame The last frame of the animation.
+     * @param offset The offset when starting the animation.
+     * @param speedFramesPerSecond The frame rate.
+     */
+    setAnimationParameters(startFrame: number, endFrame: number, offset?: number, speedFramesPerSecond?: number): void;
+    /**
+     * Disposes the resources of the manager.
+     * @param forceDisposeTextures - Forces the disposal of all textures.
+     */
+    dispose(forceDisposeTextures?: boolean): void;
+    /**
+     * Get the current class name useful for serialization or dynamic coding.
+     * @returns "BakedVertexAnimationManager"
+     */
+    getClassName(): string;
+    /**
+     * Makes a duplicate of the current instance into another one.
+     * @param vatMap define the instance where to copy the info
+     */
+    copyTo(vatMap: BakedVertexAnimationManager): void;
+    /**
+     * Serializes this vertex animation instance
+     * @returns - An object with the serialized instance.
+     */
+    serialize(): any;
+    /**
+     * Parses a vertex animation setting from a serialized object.
+     * @param source - Serialized object.
+     * @param scene Defines the scene we are parsing for
+     * @param rootUrl Defines the rootUrl to load from
+     */
+    parse(source: any, scene: Scene, rootUrl: string): void;
+}

package/BakedVertexAnimation/bakedVertexAnimationManager.js

@@ -0,0 +1,134 @@
+import { __decorate } from "tslib";
+import { serialize, expandToProperty, serializeAsTexture, SerializationHelper } from "../Misc/decorators.js";
+import { Vector4 } from "../Maths/math.vector.js";
+/**
+ * This class is used to animate meshes using a baked vertex animation texture
+ * @see https://doc.babylonjs.com/divingDeeper/animation/baked_texture_animations
+ * @since 5.0
+ */
+var BakedVertexAnimationManager = /** @class */ (function () {
+    /**
+     * Creates a new BakedVertexAnimationManager
+     * @param scene defines the current scene
+     */
+    function BakedVertexAnimationManager(scene) {
+        this._texture = null;
+        this._isEnabled = true;
+        /**
+         * Enable or disable the vertex animation manager
+         */
+        this.isEnabled = true;
+        /**
+         * The time counter, to pick the correct animation frame.
+         */
+        this.time = 0;
+        this._scene = scene;
+        this.animationParameters = new Vector4(0, 0, 0, 30);
+    }
+    /** @hidden */
+    BakedVertexAnimationManager.prototype._markSubMeshesAsAttributesDirty = function () {
+        for (var _i = 0, _a = this._scene.meshes; _i < _a.length; _i++) {
+            var mesh = _a[_i];
+            if (mesh.bakedVertexAnimationManager === this) {
+                mesh._markSubMeshesAsAttributesDirty();
+            }
+        }
+    };
+    /**
+     * Binds to the effect.
+     * @param effect The effect to bind to.
+     * @param useInstances True when it's an instance.
+     */
+    BakedVertexAnimationManager.prototype.bind = function (effect, useInstances) {
+        if (useInstances === void 0) { useInstances = false; }
+        if (!this._texture || !this._isEnabled) {
+            return;
+        }
+        var size = this._texture.getSize();
+        effect.setFloat2("bakedVertexAnimationTextureSizeInverted", 1.0 / size.width, 1.0 / size.height);
+        effect.setFloat("bakedVertexAnimationTime", this.time);
+        if (!useInstances) {
+            effect.setVector4("bakedVertexAnimationSettings", this.animationParameters);
+        }
+        effect.setTexture("bakedVertexAnimationTexture", this._texture);
+    };
+    /**
+     * Clone the current manager
+     * @returns a new BakedVertexAnimationManager
+     */
+    BakedVertexAnimationManager.prototype.clone = function () {
+        var copy = new BakedVertexAnimationManager(this._scene);
+        this.copyTo(copy);
+        return copy;
+    };
+    /**
+     * Sets animation parameters.
+     * @param startFrame The first frame of the animation.
+     * @param endFrame The last frame of the animation.
+     * @param offset The offset when starting the animation.
+     * @param speedFramesPerSecond The frame rate.
+     */
+    BakedVertexAnimationManager.prototype.setAnimationParameters = function (startFrame, endFrame, offset, speedFramesPerSecond) {
+        if (offset === void 0) { offset = 0; }
+        if (speedFramesPerSecond === void 0) { speedFramesPerSecond = 30; }
+        this.animationParameters = new Vector4(startFrame, endFrame, offset, speedFramesPerSecond);
+    };
+    /**
+     * Disposes the resources of the manager.
+     * @param forceDisposeTextures - Forces the disposal of all textures.
+     */
+    BakedVertexAnimationManager.prototype.dispose = function (forceDisposeTextures) {
+        var _a;
+        if (forceDisposeTextures) {
+            (_a = this._texture) === null || _a === void 0 ? void 0 : _a.dispose();
+        }
+    };
+    /**
+     * Get the current class name useful for serialization or dynamic coding.
+     * @returns "BakedVertexAnimationManager"
+     */
+    BakedVertexAnimationManager.prototype.getClassName = function () {
+        return "BakedVertexAnimationManager";
+    };
+    /**
+     * Makes a duplicate of the current instance into another one.
+     * @param vatMap define the instance where to copy the info
+     */
+    BakedVertexAnimationManager.prototype.copyTo = function (vatMap) {
+        SerializationHelper.Clone(function () { return vatMap; }, this);
+    };
+    /**
+     * Serializes this vertex animation instance
+     * @returns - An object with the serialized instance.
+     */
+    BakedVertexAnimationManager.prototype.serialize = function () {
+        return SerializationHelper.Serialize(this);
+    };
+    /**
+     * Parses a vertex animation setting from a serialized object.
+     * @param source - Serialized object.
+     * @param scene Defines the scene we are parsing for
+     * @param rootUrl Defines the rootUrl to load from
+     */
+    BakedVertexAnimationManager.prototype.parse = function (source, scene, rootUrl) {
+        var _this = this;
+        SerializationHelper.Parse(function () { return _this; }, source, scene, rootUrl);
+    };
+    __decorate([
+        serializeAsTexture(),
+        expandToProperty("_markSubMeshesAsAttributesDirty")
+    ], BakedVertexAnimationManager.prototype, "texture", void 0);
+    __decorate([
+        serialize(),
+        expandToProperty("_markSubMeshesAsAttributesDirty")
+    ], BakedVertexAnimationManager.prototype, "isEnabled", void 0);
+    __decorate([
+        serialize()
+    ], BakedVertexAnimationManager.prototype, "animationParameters", void 0);
+    __decorate([
+        serialize()
+    ], BakedVertexAnimationManager.prototype, "time", void 0);
+    return BakedVertexAnimationManager;
+}());
+export { BakedVertexAnimationManager };
+//# sourceMappingURL=bakedVertexAnimationManager.js.map

package/BakedVertexAnimation/bakedVertexAnimationManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bakedVertexAnimationManager.js","sourceRoot":"","sources":["../../../sourceES6/core/BakedVertexAnimation/bakedVertexAnimationManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Nullable } from \"../types\";\r\nimport { Scene } from \"../scene\";\r\nimport { serialize, expandToProperty, serializeAsTexture, SerializationHelper } from \"../Misc/decorators\";\r\nimport { BaseTexture } from '../Materials/Textures/baseTexture';\r\nimport { Vector4 } from \"../Maths/math.vector\";\r\nimport { Effect } from \"../Materials/effect\";\r\n\r\n/**\r\n * Interface for baked vertex animation texture, see BakedVertexAnimationManager\r\n * @since 5.0\r\n */\r\nexport interface IBakedVertexAnimationManager {\r\n    /**\r\n     * The vertex animation texture\r\n     */\r\n    texture: Nullable<BaseTexture>;\r\n\r\n    /**\r\n     * Gets or sets a boolean indicating if the edgesRenderer is active\r\n     */\r\n    isEnabled: boolean;\r\n\r\n    /**\r\n     * The animation parameters for the mesh. See setAnimationParameters()\r\n     */\r\n    animationParameters: Vector4;\r\n\r\n    /**\r\n     * The time counter, to pick the correct animation frame.\r\n     */\r\n    time: number;\r\n\r\n    /**\r\n     * Binds to the effect.\r\n     * @param effect The effect to bind to.\r\n     * @param useInstances True when it's an instance.\r\n     */\r\n    bind(effect: Effect, useInstances: boolean): void;\r\n\r\n    /**\r\n     * Sets animation parameters.\r\n     * @param startFrame The first frame of the animation.\r\n     * @param endFrame The last frame of the animation.\r\n     * @param offset The offset when starting the animation.\r\n     * @param speedFramesPerSecond The frame rate.\r\n     */\r\n    setAnimationParameters(\r\n        startFrame: number,\r\n        endFrame: number,\r\n        offset: number,\r\n        speedFramesPerSecond: number\r\n    ): void;\r\n\r\n    /**\r\n     * Disposes the resources of the manager.\r\n     * @param forceDisposeTextures - Forces the disposal of all textures.\r\n     */\r\n    dispose(forceDisposeTextures?: boolean): void;\r\n\r\n    /**\r\n     * Get the current class name useful for serialization or dynamic coding.\r\n     * @returns \"BakedVertexAnimationManager\"\r\n     */\r\n    getClassName(): string;\r\n}\r\n\r\n/**\r\n * This class is used to animate meshes using a baked vertex animation texture\r\n * @see https://doc.babylonjs.com/divingDeeper/animation/baked_texture_animations\r\n * @since 5.0\r\n */\r\nexport class BakedVertexAnimationManager implements IBakedVertexAnimationManager {\r\n    private _scene: Scene;\r\n\r\n    private _texture: Nullable<BaseTexture> = null;\r\n    /**\r\n     * The vertex animation texture\r\n     */\r\n    @serializeAsTexture()\r\n    @expandToProperty(\"_markSubMeshesAsAttributesDirty\")\r\n    public texture: Nullable<BaseTexture>;\r\n\r\n    private _isEnabled = true;\r\n    /**\r\n     * Enable or disable the vertex animation manager\r\n     */\r\n    @serialize()\r\n    @expandToProperty(\"_markSubMeshesAsAttributesDirty\")\r\n    public isEnabled = true;\r\n\r\n    /**\r\n     * The animation parameters for the mesh. See setAnimationParameters()\r\n     */\r\n    @serialize()\r\n    public animationParameters: Vector4;\r\n\r\n    /**\r\n     * The time counter, to pick the correct animation frame.\r\n     */\r\n    @serialize()\r\n    public time = 0;\r\n\r\n    /**\r\n     * Creates a new BakedVertexAnimationManager\r\n     * @param scene defines the current scene\r\n     */\r\n    constructor(scene: Scene) {\r\n        this._scene = scene;\r\n        this.animationParameters = new Vector4(0, 0, 0, 30);\r\n    }\r\n\r\n    /** @hidden */\r\n    public _markSubMeshesAsAttributesDirty(): void {\r\n        for (const mesh of this._scene.meshes) {\r\n            if ((<any>mesh).bakedVertexAnimationManager === this) {\r\n                mesh._markSubMeshesAsAttributesDirty();\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Binds to the effect.\r\n     * @param effect The effect to bind to.\r\n     * @param useInstances True when it's an instance.\r\n     */\r\n    public bind(effect: Effect, useInstances = false): void {\r\n        if (!this._texture || !this._isEnabled) {\r\n            return;\r\n        }\r\n\r\n        const size = this._texture.getSize();\r\n        effect.setFloat2(\r\n            \"bakedVertexAnimationTextureSizeInverted\",\r\n            1.0 / size.width,\r\n            1.0 / size.height\r\n        );\r\n        effect.setFloat(\"bakedVertexAnimationTime\", this.time);\r\n\r\n        if (!useInstances) {\r\n            effect.setVector4(\"bakedVertexAnimationSettings\", this.animationParameters);\r\n        }\r\n\r\n        effect.setTexture(\"bakedVertexAnimationTexture\", this._texture);\r\n    }\r\n\r\n    /**\r\n     * Clone the current manager\r\n     * @returns a new BakedVertexAnimationManager\r\n     */\r\n     public clone(): BakedVertexAnimationManager {\r\n        let copy = new BakedVertexAnimationManager(this._scene);\r\n        this.copyTo(copy);\r\n        return copy;\r\n    }\r\n\r\n    /**\r\n     * Sets animation parameters.\r\n     * @param startFrame The first frame of the animation.\r\n     * @param endFrame The last frame of the animation.\r\n     * @param offset The offset when starting the animation.\r\n     * @param speedFramesPerSecond The frame rate.\r\n     */\r\n    public setAnimationParameters(\r\n        startFrame: number,\r\n        endFrame: number,\r\n        offset: number = 0,\r\n        speedFramesPerSecond: number = 30\r\n    ): void {\r\n        this.animationParameters = new Vector4(startFrame, endFrame, offset, speedFramesPerSecond);\r\n    }\r\n\r\n    /**\r\n     * Disposes the resources of the manager.\r\n     * @param forceDisposeTextures - Forces the disposal of all textures.\r\n     */\r\n    public dispose(forceDisposeTextures?: boolean): void {\r\n        if (forceDisposeTextures) {\r\n            this._texture?.dispose();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Get the current class name useful for serialization or dynamic coding.\r\n     * @returns \"BakedVertexAnimationManager\"\r\n     */\r\n    public getClassName(): string {\r\n        return \"BakedVertexAnimationManager\";\r\n    }\r\n\r\n    /**\r\n     * Makes a duplicate of the current instance into another one.\r\n     * @param vatMap define the instance where to copy the info\r\n     */\r\n    public copyTo(vatMap: BakedVertexAnimationManager): void {\r\n        SerializationHelper.Clone(() => vatMap, this);\r\n    }\r\n\r\n    /**\r\n     * Serializes this vertex animation instance\r\n     * @returns - An object with the serialized instance.\r\n     */\r\n    public serialize(): any {\r\n        return SerializationHelper.Serialize(this);\r\n    }\r\n\r\n    /**\r\n     * Parses a vertex animation setting from a serialized object.\r\n     * @param source - Serialized object.\r\n     * @param scene Defines the scene we are parsing for\r\n     * @param rootUrl Defines the rootUrl to load from\r\n     */\r\n    public parse(source: any, scene: Scene, rootUrl: string): void {\r\n        SerializationHelper.Parse(() => this, source, scene, rootUrl);\r\n    }\r\n}\r\n"]}

package/BakedVertexAnimation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./bakedVertexAnimationManager";
+export * from "./vertexAnimationBaker";

package/BakedVertexAnimation/index.js

@@ -0,0 +1,3 @@
+export * from "./bakedVertexAnimationManager.js";
+export * from "./vertexAnimationBaker.js";
+//# sourceMappingURL=index.js.map

package/BakedVertexAnimation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../sourceES6/core/BakedVertexAnimation/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC","sourcesContent":["export * from \"./bakedVertexAnimationManager\";\r\nexport * from \"./vertexAnimationBaker\";\r\n"]}

package/BakedVertexAnimation/vertexAnimationBaker.d.ts

@@ -0,0 +1,65 @@
+import { AnimationRange } from "../Animations/animationRange";
+import { RawTexture } from "../Materials/Textures/rawTexture";
+import { Mesh } from "../Meshes/mesh";
+import { Scene } from "../scene";
+/**
+ * Class to bake vertex animation textures.
+ * @since 5.0
+ */
+export declare class VertexAnimationBaker {
+    private _scene;
+    private _mesh;
+    /**
+     * Create a new VertexAnimationBaker object which can help baking animations into a texture.
+     * @param scene Defines the scene the VAT belongs to
+     * @param mesh Defines the mesh the VAT belongs to
+     * @param skeleton Defines the skeleton the VAT belongs to
+     */
+    constructor(scene: Scene, mesh: Mesh);
+    /**
+     * Bakes the animation into the texture. This should be called once, when the
+     * scene starts, so the VAT is generated and associated to the mesh.
+     * @param ranges Defines the ranges in the animation that will be baked.
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    bakeVertexData(ranges: AnimationRange[]): Promise<Float32Array>;
+    /**
+     * Runs an animation frame and stores its vertex data
+     *
+     * @param vertexData The array to save data to.
+     * @param frameIndex Current frame in the skeleton animation to render.
+     * @param textureIndex Current index of the texture data.
+     */
+    private _executeAnimationFrame;
+    /**
+     * Builds a vertex animation texture given the vertexData in an array.
+     * @param vertexData The vertex animation data. You can generate it with bakeVertexData().
+     * @returns The vertex animation texture to be used with BakedVertexAnimationManager.
+     */
+    textureFromBakedVertexData(vertexData: Float32Array): RawTexture;
+    /**
+     * Serializes our vertexData to an object, with a nice string for the vertexData.
+     * @param vertexData The vertex array data.
+     * @returns This object serialized to a JS dict.
+     */
+    serializeBakedVertexDataToObject(vertexData: Float32Array): Record<string, any>;
+    /**
+     * Loads previously baked data.
+     * @param data The object as serialized by serializeBakedVertexDataToObject()
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    loadBakedVertexDataFromObject(data: Record<string, any>): Float32Array;
+    /**
+     * Serializes our vertexData to a JSON string, with a nice string for the vertexData.
+     * Should be called right after bakeVertexData().
+     * @param vertexData The vertex array data.
+     * @returns This object serialized to a safe string.
+     */
+    serializeBakedVertexDataToJSON(vertexData: Float32Array): string;
+    /**
+     * Loads previously baked data in string format.
+     * @param json The json string as serialized by serializeBakedVertexDataToJSON().
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    loadBakedVertexDataFromJSON(json: string): Float32Array;
+}

package/BakedVertexAnimation/vertexAnimationBaker.js

@@ -0,0 +1,155 @@
+import { __awaiter, __generator } from "tslib";
+import { RawTexture } from "../Materials/Textures/rawTexture.js";
+import { Texture } from "../Materials/Textures/texture.js";
+import { EncodeArrayBufferToBase64, DecodeBase64ToBinary } from "../Misc/stringTools.js";
+/**
+ * Class to bake vertex animation textures.
+ * @since 5.0
+ */
+var VertexAnimationBaker = /** @class */ (function () {
+    /**
+     * Create a new VertexAnimationBaker object which can help baking animations into a texture.
+     * @param scene Defines the scene the VAT belongs to
+     * @param mesh Defines the mesh the VAT belongs to
+     * @param skeleton Defines the skeleton the VAT belongs to
+     */
+    function VertexAnimationBaker(scene, mesh) {
+        this._scene = scene;
+        this._mesh = mesh;
+    }
+    /**
+     * Bakes the animation into the texture. This should be called once, when the
+     * scene starts, so the VAT is generated and associated to the mesh.
+     * @param ranges Defines the ranges in the animation that will be baked.
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    VertexAnimationBaker.prototype.bakeVertexData = function (ranges) {
+        return __awaiter(this, void 0, void 0, function () {
+            var boneCount, frameCount, textureIndex, textureSize, vertexData, _i, ranges_1, range, frameIndex;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._mesh.skeleton) {
+                            throw new Error("No skeleton in this mesh.");
+                        }
+                        boneCount = this._mesh.skeleton.bones.length;
+                        frameCount = ranges.reduce(function (previous, current) { return previous + current.to - current.from + 1; }, 0);
+                        if (isNaN(frameCount)) {
+                            throw new Error("Invalid animation ranges.");
+                        }
+                        textureIndex = 0;
+                        textureSize = (boneCount + 1) * 4 * 4 * frameCount;
+                        vertexData = new Float32Array(textureSize);
+                        this._scene.stopAnimation(this._mesh);
+                        this._mesh.skeleton.returnToRest();
+                        _i = 0, ranges_1 = ranges;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < ranges_1.length)) return [3 /*break*/, 6];
+                        range = ranges_1[_i];
+                        frameIndex = range.from;
+                        _a.label = 2;
+                    case 2:
+                        if (!(frameIndex <= range.to)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this._executeAnimationFrame(vertexData, frameIndex, textureIndex++)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        frameIndex++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/, vertexData];
+                }
+            });
+        });
+    };
+    /**
+     * Runs an animation frame and stores its vertex data
+     *
+     * @param vertexData The array to save data to.
+     * @param frameIndex Current frame in the skeleton animation to render.
+     * @param textureIndex Current index of the texture data.
+     */
+    VertexAnimationBaker.prototype._executeAnimationFrame = function (vertexData, frameIndex, textureIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, _reject) {
+                        _this._scene.beginAnimation(_this._mesh.skeleton, frameIndex, frameIndex, false, 1.0, function () {
+                            _this._mesh.skeleton.prepare();
+                            // generate matrices
+                            var skeletonMatrices = _this._mesh.skeleton.getTransformMatrices(_this._mesh);
+                            vertexData.set(skeletonMatrices, textureIndex * skeletonMatrices.length);
+                            resolve();
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     * Builds a vertex animation texture given the vertexData in an array.
+     * @param vertexData The vertex animation data. You can generate it with bakeVertexData().
+     * @returns The vertex animation texture to be used with BakedVertexAnimationManager.
+     */
+    VertexAnimationBaker.prototype.textureFromBakedVertexData = function (vertexData) {
+        if (!this._mesh.skeleton) {
+            throw new Error("No skeleton in this mesh.");
+        }
+        var boneCount = this._mesh.skeleton.bones.length;
+        var texture = RawTexture.CreateRGBATexture(vertexData, (boneCount + 1) * 4, vertexData.length / ((boneCount + 1) * 4 * 4), this._scene, false, false, Texture.NEAREST_NEAREST, 1);
+        texture.name = "VAT" + this._mesh.skeleton.name;
+        return texture;
+    };
+    /**
+     * Serializes our vertexData to an object, with a nice string for the vertexData.
+     * @param vertexData The vertex array data.
+     * @returns This object serialized to a JS dict.
+     */
+    VertexAnimationBaker.prototype.serializeBakedVertexDataToObject = function (vertexData) {
+        if (!this._mesh.skeleton) {
+            throw new Error("No skeleton in this mesh.");
+        }
+        // this converts the float array to a serialized base64 string, ~1.3x larger
+        // than the original.
+        var boneCount = this._mesh.skeleton.bones.length;
+        var width = (boneCount + 1) * 4;
+        var height = vertexData.length / ((boneCount + 1) * 4 * 4);
+        var data = {
+            vertexData: EncodeArrayBufferToBase64(vertexData),
+            width: width,
+            height: height
+        };
+        return data;
+    };
+    /**
+     * Loads previously baked data.
+     * @param data The object as serialized by serializeBakedVertexDataToObject()
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    VertexAnimationBaker.prototype.loadBakedVertexDataFromObject = function (data) {
+        return new Float32Array(DecodeBase64ToBinary(data.vertexData));
+    };
+    /**
+     * Serializes our vertexData to a JSON string, with a nice string for the vertexData.
+     * Should be called right after bakeVertexData().
+     * @param vertexData The vertex array data.
+     * @returns This object serialized to a safe string.
+     */
+    VertexAnimationBaker.prototype.serializeBakedVertexDataToJSON = function (vertexData) {
+        return JSON.stringify(this.serializeBakedVertexDataToObject(vertexData));
+    };
+    /**
+     * Loads previously baked data in string format.
+     * @param json The json string as serialized by serializeBakedVertexDataToJSON().
+     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.
+     */
+    VertexAnimationBaker.prototype.loadBakedVertexDataFromJSON = function (json) {
+        return this.loadBakedVertexDataFromObject(JSON.parse(json));
+    };
+    return VertexAnimationBaker;
+}());
+export { VertexAnimationBaker };
+//# sourceMappingURL=vertexAnimationBaker.js.map

package/BakedVertexAnimation/vertexAnimationBaker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertexAnimationBaker.js","sourceRoot":"","sources":["../../../sourceES6/core/BakedVertexAnimation/vertexAnimationBaker.ts"],"names":[],"mappings":"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","sourcesContent":["import { AnimationRange } from \"../Animations/animationRange\";\r\nimport { RawTexture } from \"../Materials/Textures/rawTexture\";\r\nimport { Texture } from \"../Materials/Textures/texture\";\r\nimport { Mesh } from \"../Meshes/mesh\";\r\nimport { EncodeArrayBufferToBase64, DecodeBase64ToBinary } from \"../Misc/stringTools\";\r\nimport { Scene } from \"../scene\";\r\n\r\n\r\n/**\r\n * Class to bake vertex animation textures.\r\n * @since 5.0\r\n */\r\nexport class VertexAnimationBaker {\r\n    private _scene: Scene;\r\n    private _mesh: Mesh;\r\n\r\n    /**\r\n     * Create a new VertexAnimationBaker object which can help baking animations into a texture.\r\n     * @param scene Defines the scene the VAT belongs to\r\n     * @param mesh Defines the mesh the VAT belongs to\r\n     * @param skeleton Defines the skeleton the VAT belongs to\r\n     */\r\n    constructor(scene: Scene, mesh: Mesh) {\r\n        this._scene = scene;\r\n        this._mesh = mesh;\r\n    }\r\n\r\n    /**\r\n     * Bakes the animation into the texture. This should be called once, when the\r\n     * scene starts, so the VAT is generated and associated to the mesh.\r\n     * @param ranges Defines the ranges in the animation that will be baked.\r\n     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.\r\n     */\r\n    public async bakeVertexData(ranges: AnimationRange[]): Promise<Float32Array> {\r\n        if (!this._mesh.skeleton) {\r\n            throw new Error(\"No skeleton in this mesh.\");\r\n        }\r\n        const boneCount = this._mesh.skeleton.bones.length;\r\n\r\n        /** total number of frames in our animations */\r\n        const frameCount = ranges.reduce(\r\n            (previous: number, current: AnimationRange) => previous + current.to - current.from + 1,\r\n            0\r\n        );\r\n\r\n        if (isNaN(frameCount)) {\r\n            throw new Error(\"Invalid animation ranges.\");\r\n        }\r\n\r\n        // reset our loop data\r\n        let textureIndex = 0;\r\n        const textureSize = (boneCount + 1) * 4 * 4 * frameCount;\r\n        const vertexData = new Float32Array(textureSize);\r\n        this._scene.stopAnimation(this._mesh);\r\n        this._mesh.skeleton.returnToRest();\r\n\r\n        // render all frames from our slices\r\n        for (const range of ranges) {\r\n            for (let frameIndex = range.from; frameIndex <= range.to; frameIndex++) {\r\n                await this._executeAnimationFrame(vertexData, frameIndex, textureIndex++);\r\n            }\r\n        }\r\n\r\n        return vertexData;\r\n    }\r\n\r\n    /**\r\n     * Runs an animation frame and stores its vertex data\r\n     *\r\n     * @param vertexData The array to save data to.\r\n     * @param frameIndex Current frame in the skeleton animation to render.\r\n     * @param textureIndex Current index of the texture data.\r\n     */\r\n    private async _executeAnimationFrame(vertexData: Float32Array, frameIndex: number, textureIndex: number): Promise<void> {\r\n        return new Promise<void>((resolve, _reject) => {\r\n            this._scene.beginAnimation(this._mesh.skeleton, frameIndex, frameIndex, false, 1.0, () => {\r\n                this._mesh.skeleton!.prepare();\r\n\r\n                // generate matrices\r\n                const skeletonMatrices = this._mesh.skeleton!.getTransformMatrices(this._mesh);\r\n                vertexData.set(skeletonMatrices, textureIndex * skeletonMatrices.length);\r\n\r\n                resolve();\r\n            });\r\n        });\r\n    }\r\n    /**\r\n     * Builds a vertex animation texture given the vertexData in an array.\r\n     * @param vertexData The vertex animation data. You can generate it with bakeVertexData().\r\n     * @returns The vertex animation texture to be used with BakedVertexAnimationManager.\r\n     */\r\n    public textureFromBakedVertexData(vertexData: Float32Array): RawTexture {\r\n        if (!this._mesh.skeleton) {\r\n            throw new Error(\"No skeleton in this mesh.\");\r\n        }\r\n        const boneCount = this._mesh.skeleton.bones.length;\r\n\r\n        const texture = RawTexture.CreateRGBATexture(\r\n            vertexData,\r\n            (boneCount + 1) * 4,\r\n            vertexData.length / ((boneCount + 1) * 4 * 4),\r\n            this._scene,\r\n            false,\r\n            false,\r\n            Texture.NEAREST_NEAREST,\r\n            1\r\n        );\r\n        texture.name = \"VAT\" + this._mesh.skeleton.name;\r\n        return texture;\r\n    }\r\n    /**\r\n     * Serializes our vertexData to an object, with a nice string for the vertexData.\r\n     * @param vertexData The vertex array data.\r\n     * @returns This object serialized to a JS dict.\r\n     */\r\n    public serializeBakedVertexDataToObject(vertexData: Float32Array): Record<string, any> {\r\n        if (!this._mesh.skeleton) {\r\n            throw new Error(\"No skeleton in this mesh.\");\r\n        }\r\n\r\n        // this converts the float array to a serialized base64 string, ~1.3x larger\r\n        // than the original.\r\n        const boneCount = this._mesh.skeleton.bones.length;\r\n        const width = (boneCount + 1) * 4;\r\n        const height = vertexData.length / ((boneCount + 1) * 4 * 4);\r\n        const data = {\r\n            vertexData: EncodeArrayBufferToBase64(vertexData),\r\n            width,\r\n            height\r\n        };\r\n        return data;\r\n    }\r\n    /**\r\n     * Loads previously baked data.\r\n     * @param data The object as serialized by serializeBakedVertexDataToObject()\r\n     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.\r\n     */\r\n    public loadBakedVertexDataFromObject(data: Record<string, any>): Float32Array {\r\n        return new Float32Array(DecodeBase64ToBinary(data.vertexData));\r\n    }\r\n    /**\r\n     * Serializes our vertexData to a JSON string, with a nice string for the vertexData.\r\n     * Should be called right after bakeVertexData().\r\n     * @param vertexData The vertex array data.\r\n     * @returns This object serialized to a safe string.\r\n     */\r\n    public serializeBakedVertexDataToJSON(vertexData: Float32Array): string {\r\n        return JSON.stringify(this.serializeBakedVertexDataToObject(vertexData));\r\n    }\r\n    /**\r\n     * Loads previously baked data in string format.\r\n     * @param json The json string as serialized by serializeBakedVertexDataToJSON().\r\n     * @returns The array of matrix transforms for each vertex (columns) and frame (rows), as a Float32Array.\r\n     */\r\n    public loadBakedVertexDataFromJSON(json: string): Float32Array {\r\n        return this.loadBakedVertexDataFromObject(JSON.parse(json));\r\n    }\r\n}\r\n"]}

package/Behaviors/Cameras/framingBehavior.d.ts

@@ -1,6 +1,7 @@
 import { Behavior } from "../../Behaviors/behavior";
 import { ArcRotateCamera } from "../../Cameras/arcRotateCamera";
 import { ExponentialEase } from "../../Animations/easing";
+import { Observable } from "../../Misc/observable";
 import { Nullable } from "../../types";
 import { AbstractMesh } from "../../Meshes/abstractMesh";
 import { Vector3 } from "../../Maths/math.vector";
@@ -13,6 +14,10 @@ export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
      * Gets the name of the behavior.
      */
     get name(): string;
+    /**
+     * An event triggered when the animation to zoom on target mesh has ended
+     */
+    onTargetFramingAnimationEndObservable: Observable<void>;
     private _mode;
     private _radiusScale;
     private _positionScale;

package/Behaviors/Cameras/framingBehavior.js

@@ -1,4 +1,5 @@
 import { ExponentialEase, EasingFunction } from "../../Animations/easing.js";
+import { Observable } from "../../Misc/observable.js";
 import { PointerEventTypes } from "../../Events/pointerEvents.js";
 import { PrecisionDate } from "../../Misc/precisionDate.js";
 import { Vector3, Vector2 } from "../../Maths/math.vector.js";
@@ -9,6 +10,10 @@ import { Animation } from "../../Animations/animation.js";
  */
 var FramingBehavior = /** @class */ (function () {
     function FramingBehavior() {
+        /**
+         * An event triggered when the animation to zoom on target mesh has ended
+         */
+        this.onTargetFramingAnimationEndObservable = new Observable();
         this._mode = FramingBehavior.FitFrustumSidesMode;
         this._radiusScale = 1.0;
         this._positionScale = 0.5;
@@ -196,7 +201,9 @@ var FramingBehavior = /** @class */ (function () {
         });
         this._onMeshTargetChangedObserver = camera.onMeshTargetChangedObservable.add(function (mesh) {
             if (mesh) {
-                _this.zoomOnMesh(mesh);
+                _this.zoomOnMesh(mesh, undefined, function () {
+                    _this.onTargetFramingAnimationEndObservable.notifyObservers();
+                });
             }
         });
         this._onAfterCheckInputsObserver = camera.onAfterCheckInputsObservable.add(function () {