babylonjs-addons 8.24.0 → 8.24.2

package/babylonjs.addons.d.ts

@@ -388,973 +388,6 @@ declare module ADDONS {
     };
 
 
-
-
-    /**
-     * Configuration options for the Lottie animation player.
-     */
-    export type AnimationConfiguration = {
-        /**
-         * Whether the animation should play on a loop or not
-         */
-        loopAnimation: boolean;
-        /**
-         * Size of the sprite atlas texture.
-         * Default is 2048.
-         */
-        spriteAtlasSize: number;
-        /**
-         * Gap size around sprites in the atlas.
-         * Default is 5.
-         */
-        gapSize: number;
-        /**
-         * Maximum number of sprites the renderer can handle at once.
-         * Default is 64.
-         */
-        spritesCapacity: number;
-        /**
-         * Background color for the animation canvas.
-         * Default is white with full opacity.
-         */
-        backgroundColor: {
-            r: number;
-            g: number;
-            b: number;
-            a: number;
-        };
-        /**
-         * Minimum scale factor to prevent too small sprites.
-         * Default is 5.
-         */
-        scaleMultiplier: number;
-        /**
-         * Scale factor for the rendering.
-         * Default is 1.
-         */
-        devicePixelRatio: number;
-        /**
-         * Number of steps to sample cubic bezier easing functions for animations.
-         * Default is 4.
-         */
-        easingSteps: number;
-        /**
-         * Whether to ignore opacity animations for performance.
-         * Default is true.
-         */
-        ignoreOpacityAnimations: boolean;
-        /**
-         * Whether to support device lost events for WebGL contexts.
-         * Default is false.
-         */
-        supportDeviceLost: boolean;
-    };
-    /**
-     * LottiePlayer is a class that allows you to play Lottie animations using Babylon.js.
-     * It plays the animations in a worker thread using OffscreenCanvas.
-     * Once instance of this class can only be used to play a single animation. If you want to play multiple animations, create a new instance for each animation.
-     */
-    export class LottiePlayer {
-        private _playing;
-        private _disposed;
-        private _worker;
-        private _canvas;
-        private _resizeObserver;
-        private readonly _container;
-        private readonly _animationFile;
-        private readonly _configuration;
-        /**
-         * Creates a new instance of the LottiePlayer.
-         * @param container The HTMLDivElement to create the canvas in and render the animation on.
-         * @param animationFile The URL of the Lottie animation file to be played.
-         * @param configuration Optional configuration object to customize the animation playback.
-         */
-        constructor(container: HTMLDivElement, animationFile: string, configuration?: Partial<AnimationConfiguration>);
-        /**
-         * Loads and plays a lottie animation.
-         * @returns True if the animation is successfully set up to play, false if the animation couldn't play.
-         */
-        playAnimation(): boolean;
-        /**
-         * Disposes the LottiePlayer instance, cleaning up resources and event listeners.
-         */
-        dispose(): void;
-        private _onWindowResize;
-        private _onBeforeUnload;
-    }
-
-
-
-
-    /**
-     * Information about a sprite in the sprite atlas.
-     */
-    export type SpriteAtlasInfo = {
-        /**
-         * Offset in the x axis of the sprite in the atlas.
-         * Normalized between 0 and 1, left to right.
-         */
-        uOffset: number;
-        /**
-         * Offset in the y axis of the sprite in the atlas.
-         * Normalized between 0 and 1, top to bottom.
-         */
-        vOffset: number;
-        /**
-         * Width of the sprite in the atlas.
-         * In pixels.
-         */
-        cellWidth: number;
-        /**
-         * Height of the sprite in the atlas.
-         * In pixels.
-         */
-        cellHeight: number;
-        /**
-         * Width of the sprite in the screen.
-         * In pixels.
-         */
-        widthPx: number;
-        /**
-         * Height of the sprite in the screen.
-         * In pixels.
-         */
-        heightPx: number;
-        /**
-         * X coordinate of the center of the sprite bounding box, used for final positioning in the screen
-         */
-        centerX: number;
-        /**
-         * Y coordinate of the center of the sprite bounding box, used for final positioning in the screen
-         */
-        centerY: number;
-    };
-    /**
-     * SpritePacker is a class that handles the packing of sprites into a texture atlas.
-     */
-    export class SpritePacker {
-        private readonly _engine;
-        private readonly _configuration;
-        private _spritesCanvas;
-        private _spritesCanvasContext;
-        private readonly _spritesInternalTexture;
-        private readonly _spritesTexture;
-        private _isDirty;
-        private _currentX;
-        private _currentY;
-        private _maxRowHeight;
-        private _spriteAtlasInfo;
-        /**
-         * Gets the texture atlas that contains all the sprites packed by this SpritePacker.
-         * @returns The texture atlas containing the sprites.
-         */
-        get texture(): BABYLON.ThinTexture;
-        /**
-         * Creates a new instance of SpritePacker.
-         * @param engine Engine that will render the sprites.
-         * @param configuration Configuration options for the sprite packer.
-         */
-        constructor(engine: BABYLON.ThinEngine, configuration: AnimationConfiguration);
-        /**
-         * Adds a vector shape that comes from lottie data to the sprite atlas.
-         * @param rawGroup The raw group shape to add to the atlas.
-         * @param scalingFactor The scaling factor to apply to the shape.
-         * @returns The information on how to find the sprite in the atlas.
-         */
-        addLottieShape(rawGroup: RawGroupShape, scalingFactor: BABYLON.IVector2Like): SpriteAtlasInfo;
-        /**
-         * Updates the internal atlas texture with the information that has been added to the SpritePacker.
-         */
-        updateAtlasTexture(): void;
-        /**
-         * Releases the canvas and its context to allow garbage collection.
-         */
-        releaseCanvas(): void;
-        private _drawVectorShape;
-        private _drawRectangle;
-        private _drawPath;
-        private _drawFill;
-        private _drawGradientFill;
-        private _drawLinearGradientFill;
-        private _drawRadialGradientFill;
-        private _addColorStops;
-        private _gradientColorsToCssColor;
-        private _lottieColorToCSSColor;
-    }
-
-
-    /**
-     * Represents a sprite in the scene graph.
-     */
-    export class SpriteNode extends Node {
-        private _sprite;
-        private _originalWidth;
-        private _originalHeight;
-        private _firstTime;
-        /**
-         * Creates a new SpriteNode instance.
-         * @param id Unique identifier for the sprite node.
-         * @param ignoreOpacityAnimations If there are no animations on opacity, mark this as true to ignore and optimize CPU usage.
-         * @param sprite The sprite associated with this node.
-         * @param position The position of the sprite in the scene.
-         * @param rotation The rotation of the sprite in degrees.
-         * @param scale The scale of the sprite in the scene.
-         * @param opacity The opacity of the sprite.
-         * @param parent The parent node in the scene graph.
-         */
-        constructor(id: string, ignoreOpacityAnimations: boolean, sprite: BABYLON.ThinSprite, position?: Vector2Property, rotation?: ScalarProperty, scale?: Vector2Property, opacity?: ScalarProperty, parent?: Node);
-        /**
-         * Updates the node's properties based on the current frame of the animation.
-         * @param frame Frame number we are playing in the animation.
-         * @param isParentUpdated Whether the parent node has been updated.
-         * @param isReset Whether the node is being reset.
-         * @returns True if the node was updated, false otherwise.
-         */
-        update(frame: number, isParentUpdated?: boolean, isReset?: boolean): boolean;
-    }
-
-
-    /**
-     * Represents all the sprites from the animation and manages their rendering.
-     */
-    export class RenderingManager {
-        private readonly _engine;
-        private readonly _spritesRenderer;
-        private readonly _spritesTexture;
-        private _sprites;
-        private readonly _configuration;
-        /**
-         * Creates a new instance of the RenderingManager.
-         * @param engine BABYLON.ThinEngine instance used for rendering.
-         * @param spriteTexture The texture atlas containing the sprites.
-         * @param configuration Configuration options for the rendering manager.
-         */
-        constructor(engine: BABYLON.ThinEngine, spriteTexture: BABYLON.ThinTexture, configuration: AnimationConfiguration);
-        /**
-         * Adds a sprite to the rendering manager.
-         * @param sprite Sprite to add to the rendering manager.
-         */
-        addSprite(sprite: BABYLON.ThinSprite): void;
-        /**
-         * Prepares the rendering manager for rendering.
-         */
-        ready(): void;
-        /**
-         * Renders all the sprites in the rendering manager.
-         * @param worldMatrix World matrix to apply to the sprites.
-         * @param projectionMatrix Projection matrix to apply to the sprites.
-         */
-        render(worldMatrix: ThinMatrix, projectionMatrix: ThinMatrix): void;
-        /**
-         * Disposes the rendering manager and its resources.
-         */
-        dispose(): void;
-        private _customSpriteUpdate;
-    }
-
-
-    /**
-     * Represents a node in the scenegraph that contains the animation information from a lottie animation layer or group.
-     */
-    export class Node {
-        private readonly _id;
-        private readonly _ignoreOpacityAnimations;
-        private readonly _position;
-        private readonly _rotation;
-        private readonly _scale;
-        private _worldMatrix;
-        private _localMatrix;
-        private _globalMatrix;
-        private readonly _opacity;
-        private readonly _parent;
-        private readonly _children;
-        private _isVisible;
-        private _isAnimated;
-        private _animationsFunctions;
-        protected _isControl: boolean;
-        protected _isShape: boolean;
-        /**
-         * Gets the id of this node.
-         * @returns The unique identifier of this node.
-         */
-        get id(): string;
-        /**
-         * Gets the childer of this node.
-         * @returns An array of child nodes.
-         */
-        get children(): Node[];
-        /**
-         * Gets whether this node is a shape.
-         * @returns True if this node is a shape, false otherwise.
-         */
-        get isShape(): boolean;
-        /**
-         * Gets the world matrix of this node.
-         * @returns The world matrix.
-         */
-        get worldMatrix(): ThinMatrix;
-        /**
-         * Gets whether this node is animated.
-         * @returns True if this node has animations, false otherwise.
-         */
-        get isAnimated(): boolean;
-        /**
-         * Gets the opacity of this node.
-         * If the node is not visible, the opacity will be 0.
-         * @returns The opacity of the node, from 0 to 1.
-         */
-        get opacity(): number;
-        /**
-         * Gets the initial scale of this node.
-         * @returns The initial scale.
-         */
-        get startScale(): BABYLON.IVector2Like;
-        /**
-         * Gets the parent node of this node.
-         * @returns The parent node, or undefined if this is a root node.
-         */
-        get parent(): Node | undefined;
-        /**
-         * Sets the node visibility.
-         * @param value The new visibility value.
-         */
-        set isVisible(value: boolean);
-        /**
-         * Constructs a new node.
-         * @param id Unique identifier for the node.
-         * @param ignoreOpacityAnimations If there are no animations on opacity, mark this as true to ignore and optimize CPU usage.
-         * @param position Position of the node in the scene.
-         * @param rotation Rotation of the node in degrees.
-         * @param scale Scale of the node in the scene.
-         * @param opacity Opacity of the node, from 0 to 1.
-         * @param parent Parent node in the scenegraph.
-         */
-        constructor(id: string, ignoreOpacityAnimations: boolean, position?: Vector2Property, rotation?: ScalarProperty, scale?: Vector2Property, opacity?: ScalarProperty, parent?: Node);
-        /**
-         * Resets the node's properties to their initial values.
-         */
-        reset(): void;
-        /**
-         * Updates the node's properties based on the current frame of the animation.
-         * @param frame Frame number we are playing in the animation.
-         * @param isParentUpdated Whether the parent node has been updated.
-         * @param isReset Whether the node is being reset.
-         * @returns True if the node was updated, false otherwise.
-         */
-        update(frame: number, isParentUpdated?: boolean, isReset?: boolean): boolean;
-        private _updatePosition;
-        private _updateRotation;
-        private _updateScale;
-        private _updateOpacity;
-    }
-
-
-    /**
-     * This represents a top node of the scenegraph in a Lottie animation.
-     * Each top level layer in Lottie is represented by a control node node.
-     */
-    export class ControlNode extends Node {
-        private _inFrame;
-        private _outFrame;
-        /**
-         * Constructs a new control node.
-         * @param id Unique identifier for the node.
-         * @param ignoreOpacityAnimations If there are no animations on opacity, mark this as true to ignore and optimize CPU usage.
-         * @param inFrame Frame at which the node becomes active.
-         * @param outFrame Frame at which the node becomes inactive.
-         * @param position Position of the node in the scene.
-         * @param rotation Rotation of the node in degrees.
-         * @param scale Scale of the node in the scene.
-         * @param opacity Opacity of the node, from 0 to 1.
-         * @param parent Parent node in the scenegraph.
-         */
-        constructor(id: string, ignoreOpacityAnimations: boolean, inFrame: number, outFrame: number, position?: Vector2Property, rotation?: ScalarProperty, scale?: Vector2Property, opacity?: ScalarProperty, parent?: Node);
-        /**
-         * Updates the node's properties based on the current frame of the animation.
-         * This node will only be updated if the current frame is within the in and out range.
-         * @param frame Frame number we are playing in the animation.
-         * @param isParentUpdated Whether the parent node has been updated.
-         * @param isReset Whether the node is being reset.
-         * @returns True if the node was updated, false otherwise.
-         */
-        update(frame: number, isParentUpdated?: boolean, isReset?: boolean): boolean;
-    }
-
-
-    /**
-     * Class that controls the playing of lottie animations using Babylon.js
-     */
-    export class AnimationController {
-        private _isReady;
-        private readonly _canvas;
-        private readonly _configuration;
-        private readonly _engine;
-        private readonly _spritePacker;
-        private _animation?;
-        private readonly _viewport;
-        private readonly _projectionMatrix;
-        private readonly _worldMatrix;
-        private _frameDuration;
-        private _currentFrame;
-        private _isPlaying;
-        private _animationFrameId;
-        private _lastFrameTime;
-        private _deltaTime;
-        private _loop;
-        private _accumulatedTime;
-        private _framesToAdvance;
-        private readonly _renderingManager;
-        /**
-         * Gets the canvas used for rendering the animation.
-         * @returns The canvas element used for rendering.
-         */
-        get view(): HTMLCanvasElement;
-        /**
-         * Gets the height of the animation in pixels.
-         * @returns The height of the animation in pixels.
-         */
-        get animationHeight(): number;
-        /**
-         * Gets the width of the animation in pixels.
-         * @returns The width of the animation in pixels.
-         */
-        get animationWidth(): number;
-        /**
-         * Creates a new instance of the Player.
-         * @param canvas The canvas element to render the animation on.
-         * @param animationJson The JSON string of the Lottie animation to be played.
-         * @param configuration The configuration for the animation player.
-         */
-        constructor(canvas: HTMLCanvasElement, animationJson: string, configuration: AnimationConfiguration);
-        /**
-         * Plays the animation.
-         * @param loop If true, the animation will loop when it reaches the end.
-         */
-        playAnimation(loop?: boolean): void;
-        /**
-         * Stops the animation playback.
-         */
-        stopAnimation(): void;
-        /**
-         * Sets the rendering size for the engine
-         * @param width Width of the rendering canvas
-         * @param height Height of the rendering canvas
-         */
-        setSize(width: number, height: number): void;
-        /**
-         * Disposes the player and releases all resources.
-         */
-        dispose(): void;
-        private _cleanTree;
-        private _startRenderLoop;
-        private _render;
-    }
-
-
-    /**
-     * Represents a Babylon.js thin version of a Matrix
-     * We are only exposing what we truly need in the scope of
-     * the Lottie Renderer project preventing the dependency on the full
-     * Babylon.js math system.
-     */
-    export class ThinMatrix implements BABYLON.IMatrixLike {
-        /**
-         * Prevents global conflicts on update as shader programs are shared.
-         */
-        private static _UPDATE_FLAG_SEED;
-        /**
-         * Current update flag used to know whether a Matrix has changed since previous render or not.
-         * This helps identifying if a Matrix needs to be
-         * uploaded to a shader program.
-         */
-        updateFlag: number;
-        private readonly _data;
-        /**
-         * Creates a new ThinMatrix instance.
-         */
-        constructor();
-        /**
-         * Set the matrix values.
-         * @param m11 Value for row 1, column 1
-         * @param m12 Value for row 1, column 2
-         * @param m13 Value for row 1, column 3
-         * @param m14 Value for row 1, column 4
-         * @param m21 Value for row 2, column 1
-         * @param m22 Value for row 2, column 2
-         * @param m23 Value for row 2, column 3
-         * @param m24 Value for row 2, column 4
-         * @param m31 Value for row 3, column 1
-         * @param m32 Value for row 3, column 2
-         * @param m33 Value for row 3, column 3
-         * @param m34 Value for row 3, column 4
-         * @param m41 Value for row 4, column 1
-         * @param m42 Value for row 4, column 2
-         * @param m43 Value for row 4, column 3
-         * @param m44 Value for row 4, column 4
-         * @returns The updated ThinMatrix instance
-         */
-        setValues(m11: number, m12: number, m13: number, m14: number, m21: number, m22: number, m23: number, m24: number, m31: number, m32: number, m33: number, m34: number, m41: number, m42: number, m43: number, m44: number): ThinMatrix;
-        /**
-         * Set the matrix to an identity matrix.
-         * @returns The updated ThinMatrix instance
-         */
-        identity(): ThinMatrix;
-        /**
-         * Stores a left-handed orthographic projection into a given matrix
-         * @param left defines the viewport left coordinate
-         * @param right defines the viewport right coordinate
-         * @param bottom defines the viewport bottom coordinate
-         * @param top defines the viewport top coordinate
-         * @param znear defines the near clip plane
-         * @param zfar defines the far clip plane
-         * @returns The updated ThinMatrix instance
-         */
-        orthoOffCenterLeftHanded(left: number, right: number, bottom: number, top: number, znear: number, zfar: number): ThinMatrix;
-        /**
-         * Sets a matrix to a value composed by merging scale (vector2), rotation (roll around z) and translation (vector2)
-         * This only updates the parts of the matrix that are used for 2D transformations.
-         * @param scale defines the scale vector
-         * @param roll defines the rotation around z
-         * @param translation defines the translation vector
-         * @returns the updated ThinMatrix instance
-         */
-        compose(scale: BABYLON.IVector2Like, roll: number, translation: BABYLON.IVector2Like): ThinMatrix;
-        /**
-         * Sets the current matrix with the multiplication result of the current Matrix and the given one
-         * This only updates the parts of the matrix that are used for 2D transformations.
-         * @param other defines the second operand
-         * @param output the matrix to store the result in
-         * @returns the current matrix
-         */
-        multiplyToRef(other: ThinMatrix, output: ThinMatrix): ThinMatrix;
-        /**
-         * Returns the matrix data array.
-         * @returns The matrix data
-         */
-        asArray(): BABYLON.Tuple<number, 16>;
-        /**
-         * Decomposes the matrix into scale, rotation, and translation.
-         * @param scale Scale vector to store the scale values
-         * @param translation Translation vector to store the translation values
-         * @returns The rotation in radians
-         */
-        decompose(scale: BABYLON.IVector2Like, translation: BABYLON.IVector2Like): number;
-    }
-
-
-    /**
-     * Represents a bounding box for a shape in the animation.
-     */
-    export type BoundingBox = {
-        /**
-         * Height of the bounding box
-         */
-        height: number;
-        /**
-         * Width of the bounding box
-         */
-        width: number;
-        /**
-         * X coordinate of the center of the bounding box
-         */
-        centerX: number;
-        /**
-         * Y coordinate of the center of the bounding box
-         */
-        centerY: number;
-    };
-    /**
-     * Calculates the bounding box for a group shape in a Lottie animation.
-     * @param rawGroup The raw group shape to calculate the bounding box for
-     * @returns The bounding box for the group shape
-     */
-    export function GetBoundingBox(rawGroup: RawGroupShape): BoundingBox;
-
-
-    /**
-     * Represents a Babylon.js thin version of a cubic bezier curve
-     * We are only exposing what we truly need in the scope of
-     * the Lottie Renderer project preventing the dependency on the full
-     * Babylon.js animation system.
-     */
-    export class BezierCurve {
-        /**
-         * X of the first control point
-         */
-        readonly x1: number;
-        /**
-         * Y of the first control point
-         */
-        readonly y1: number;
-        /**
-         * X of the second control point
-         */
-        readonly x2: number;
-        /**
-         * Y of the second control point
-         */
-        readonly y2: number;
-        private readonly _easingSteps;
-        private readonly _f0;
-        private readonly _f1;
-        private readonly _f2;
-        /**
-         * Instantiates a bezier function
-         * @see http://cubic-bezier.com/#.17,.67,.83,.67
-         * @param x1 Defines the x component of the start tangent in the bezier curve
-         * @param y1 Defines the y component of the start tangent in the bezier curve
-         * @param x2 Defines the x component of the end tangent in the bezier curve
-         * @param y2 Defines the y component of the end tangent in the bezier curve
-         * @param easingSteps Number of steps to sample the bezier curve for easing
-         */
-        constructor(x1: number | undefined, y1: number | undefined, x2: number | undefined, y2: number | undefined, easingSteps: number);
-        /**
-         * Interpolates the bezier curve at a given time
-         * @param t Defines the time to evaluate the bezier curve at, between 0 and 1
-         * @returns The interpolated value at time t
-         */
-        interpolate(t: number): number;
-    }
-
-
-    export type RawLottieAnimation = {
-        v: string;
-        fr: number;
-        ip: number;
-        op: number;
-        w: number;
-        h: number;
-        nm?: string;
-        layers: RawLottieLayer[];
-    };
-    export type RawLottieLayer = {
-        ind?: number;
-        ty: RawLayerType;
-        nm?: string;
-        parent?: number;
-        hd?: boolean;
-        sr?: number;
-        ao?: number;
-        ip?: number;
-        op?: number;
-        st?: number;
-        ct?: number;
-        ks: RawTransform;
-        shapes?: RawGraphicElement[];
-    };
-    export type RawGraphicElement = {
-        nm?: string;
-        hd?: boolean;
-        ty: RawShapeType;
-        bm?: number;
-        ix?: number;
-    };
-    export type RawGroupShape = RawGraphicElement & {
-        it?: RawGraphicElement[];
-    };
-    export type RawRectangleShape = RawGraphicElement & {
-        d: RawShapeDirection;
-        p: RawPositionProperty;
-        s: RawVectorProperty;
-        r: RawScalarProperty;
-    };
-    export type RawPathShape = RawGraphicElement & {
-        d: RawShapeDirection;
-        ks: RawBezierShapeProperty;
-    };
-    export type RawFillShape = RawGraphicElement & {
-        o: RawScalarProperty;
-        c: RawColorProperty;
-        r: RawFillRule;
-    };
-    export type RawGradientFillShape = RawGraphicElement & {
-        o: RawScalarProperty;
-        g: RawGradientsProperty;
-        s: RawPositionProperty;
-        e: RawPositionProperty;
-        t: RawGradientType;
-        h: RawScalarProperty;
-        a?: RawScalarProperty;
-        r: RawFillRule;
-    };
-    export type RawTransformShape = RawGraphicElement & {
-        a: RawPositionProperty;
-        p: RawPositionProperty;
-        r: RawScalarProperty;
-        s: RawVectorProperty;
-        o: RawScalarProperty;
-        sk: RawScalarProperty;
-        sa: RawScalarProperty;
-    };
-    export type RawTransform = {
-        a?: RawPositionProperty;
-        p?: RawPositionProperty;
-        r?: RawScalarProperty;
-        s?: RawVectorProperty;
-        o?: RawScalarProperty;
-    };
-    export type RawScalarProperty = {
-        a: RawNumberBoolean;
-        k: number | RawVectorKeyframe[];
-    };
-    export type RawVectorProperty = {
-        a: RawNumberBoolean;
-        k: number[] | RawVectorKeyframe[];
-        l: number;
-    };
-    export type RawVectorKeyframe = {
-        t: number;
-        s: number[];
-        h?: RawNumberBoolean;
-        i?: RawKeyFrameEasing;
-        o?: RawKeyFrameEasing;
-    };
-    export type RawPositionProperty = {
-        a: RawNumberBoolean;
-        k: number[] | RawPositionKeyframe[];
-        l: number;
-    };
-    export type RawPositionKeyframe = {
-        t: number;
-        h?: RawNumberBoolean;
-        i?: RawKeyFrameEasing;
-        o?: RawKeyFrameEasing;
-        s: number[];
-        ti: number[];
-        to: number[];
-    };
-    export type RawBezierShapeProperty = {
-        a: RawNumberBoolean;
-        k: RawBezier | RawBezierShapeKeyframe[];
-    };
-    export type RawBezierShapeKeyframe = {
-        t: number;
-        h?: RawNumberBoolean;
-        i?: RawKeyFrameEasing;
-        o?: RawKeyFrameEasing;
-        s: RawBezier[];
-    };
-    export type RawColorProperty = {
-        a: RawNumberBoolean;
-        k: number[] | RawColorKeyframe[];
-    };
-    export type RawColorKeyframe = {
-        t: number;
-        h?: RawNumberBoolean;
-        i?: RawKeyFrameEasing;
-        o?: RawKeyFrameEasing;
-        s: number[];
-    };
-    export type RawGradientsProperty = {
-        p: number;
-        k: RawGradientProperty;
-    };
-    export type RawGradientProperty = {
-        a: RawNumberBoolean;
-        k: number[];
-    };
-    export type RawKeyFrameEasing = {
-        x: number | number[];
-        y: number | number[];
-    };
-    export type RawBezier = {
-        c: boolean;
-        i: number[][];
-        o: number[][];
-        v: number[][];
-    };
-    export type RawNumberBoolean = 0 | 1;
-    export type RawLayerType = 0 | 1 | 2 | 3 | 4 | 5 | 6;
-    export type RawShapeType = "fl" | "gf" | "gr" | "tr" | "sh" | "rc";
-    export type RawShapeDirection = 1 | 3;
-    export type RawFillRule = 1 | 2;
-    export type RawGradientType = 1 | 2;
-
-
-    /**
-     * Represents a Babylon.js thin version of a Lottie animation.
-     */
-    export type AnimationInfo = {
-        /**
-         * Frame number where the animation starts.
-         */
-        startFrame: number;
-        /**
-         * Frame number where the animation ends.
-         */
-        endFrame: number;
-        /**
-         * Frame rate of the animation.
-         */
-        frameRate: number;
-        /**
-         * Width of the animation in pixels
-         */
-        widthPx: number;
-        /**
-         * Height of the animation in pixels
-         */
-        heightPx: number;
-        /**
-         * Nodes representing the animation
-         */
-        nodes: Node[];
-    };
-    /**
-     * Transform properties for a Lottie animation.
-     * Any of these properties may be animated.
-     */
-    export type Transform = {
-        /**
-         * The anchor point of the layer, which is the point around which transformations are applied.
-         */
-        anchorPoint: Vector2Property;
-        /**
-         * The position of the layer in the animation.
-         */
-        position: Vector2Property;
-        /**
-         * The rotation of the layer in degrees.
-         */
-        rotation: ScalarProperty;
-        /**
-         * The scale of the layer in the X and Y axis.
-         */
-        scale: Vector2Property;
-        /**
-         * The opacity of the layer, represented as a scalar value.
-         */
-        opacity: ScalarProperty;
-    };
-    /**
-     * Represents a scalar that can be animated.
-     */
-    export type ScalarProperty = {
-        /**
-         * The initial value of the property at the start of the animation.
-         */
-        startValue: number;
-        /**
-         * The current value of the property during the animation.
-         */
-        currentValue: number;
-        /**
-         * An array of keyframes for the property.
-         */
-        keyframes?: ScalarKeyframe[];
-        /**
-         * The index of the current keyframe being processed in the animation.
-         */
-        currentKeyframeIndex: number;
-    };
-    /**
-     * Represents a keyframe for a scalar property.
-     */
-    export type ScalarKeyframe = {
-        /**
-         * The value at this keyframe.
-         */
-        value: number;
-        /**
-         * The time at which this keyframe occurs in the animation, in frames.
-         */
-        time: number;
-        /**
-         * The easing function applied to the transition from this keyframe to the next one.
-         */
-        easeFunction: BezierCurve;
-    };
-    /**
-     * Represents a 2D vector that can be animated.
-     */
-    export type Vector2Property = {
-        /**
-         * The initial value at the start of the animation.
-         */
-        startValue: BABYLON.IVector2Like;
-        /**
-         * The current value during the animation.
-         */
-        currentValue: BABYLON.IVector2Like;
-        /**
-         * An array of keyframes for the property.
-         */
-        keyframes?: Vector2Keyframe[];
-        /**
-         * The index of the current keyframe being processed in the animation.
-         */
-        currentKeyframeIndex: number;
-    };
-    /**
-     * Represents a keyframe for a 2D vector property.
-     */
-    export type Vector2Keyframe = {
-        /**
-         * The value at this keyframe.
-         */
-        value: BABYLON.IVector2Like;
-        /**
-         * The time at which this keyframe occurs in the animation, in frames.
-         */
-        time: number;
-        /**
-         * The easing function applied to the transition from this keyframe to the next one.
-         * This is used for the first dimension of the vector.
-         */
-        easeFunction1: BezierCurve;
-        /**
-         * The easing function applied to the transition from this keyframe to the next one.
-         * This is used for the second dimension of the vector.
-         */
-        easeFunction2: BezierCurve;
-    };
-
-
-    /**
-     * Parses a lottie animation file and converts it into a format that can be rendered by Babylon.js
-     * Important: not all lottie features are supported, you can call .debug() after parsing an animation to see what features were not supported.
-     */
-    export class AnimationParser {
-        private _packer;
-        private readonly _renderingManager;
-        private readonly _configuration;
-        private readonly _animationInfo;
-        private _unsupportedFeatures;
-        private _parentNodes;
-        private _rootNodes;
-        private _shape;
-        /**
-         * Get the animation information parsed from the Lottie file.
-         */
-        get animationInfo(): AnimationInfo;
-        /**
-         * Creates a new instance of the Lottie animations parser.
-         * @param packer Object that packs the sprites from the animation into a texture atlas.
-         * @param fileContentAsJsonString The content of the lottie file as a JSON string.
-         * @param configuration Configuration options for the animation parser.
-         * @param renderingManager Object that manages the rendering of the sprites in the animation.
-         */
-        constructor(packer: SpritePacker, fileContentAsJsonString: string, configuration: AnimationConfiguration, renderingManager: RenderingManager);
-        /**
-         * Logs to the console all issues that were encountered during parsing the file.
-         */
-        debug(): void;
-        private _loadFromData;
-        private _parseLayer;
-        private _parseShapes;
-        private _parseGroupShape;
-        private _parseTransform;
-        private _fromLottieScalarToBabylonScalar;
-        private _fromLottieVector2ToBabylonVector2;
-        private _calculateFinalVector;
-        private _getScaleFactor;
-        private _validatePathShape;
-        private _validateRectangleShape;
-        private _validateFillShape;
-        private _validateGradientFillShape;
-    }
-
-
     /**
      * BABYLON.Behavior for any content that can capture pointer events, i.e. bypass the Babylon pointer event handling
      * and receive pointer events directly.  It will register the capture triggers and negotiate the capture and
@@ -1459,6 +492,20 @@ declare module ADDONS {
      * created before.
      */
     export class HtmlMeshRenderer {
+        /**
+         * Global scale factor applied to the homogeneous `w` component (m[15]) of the
+         * transformation matrix when projecting 3D objects into pixel space.
+         *
+         * This value is used to balance Babylon units against screen pixels, ensuring
+         * that HTML-mapped or screen-space objects appear with the correct relative
+         * size. Adjust with care, as changing it affects the projection scale of all
+         * transformed objects.
+         *
+         *  The default value is `0.00001`, which works well when 1 Babylon unit
+         *  corresponds to 1 meter, and the typical screen resolution is around
+         * 100 pixels per meter (i.e., 1 pixel per centimeter).
+         */
+        static PROJECTION_SCALE_FACTOR: number;
         private _containerId?;
         private _inSceneElements?;
         private _overlayElements?;