@configura/babylon-view 2.2.0-alpha.0 → 2.2.0-alpha.2

package/dist/animation/animator/AnimatorEasing.d.ts

@@ -1,17 +1,17 @@
-import { Animator, AnimatorConfig } from "./Animator.js";
-import { EasingFunction } from "./EasingFunctions.js";
-export declare type AnimatorEasingConfig<T> = AnimatorConfig & {
-    easing: EasingFunction;
-    duration: number;
-    startPosition: T;
-    endPosition: T;
-};
-export declare function getDefaultConfig<T>(empty: T): AnimatorEasingConfig<T>;
-export declare abstract class AnimatorEasing<T, Config extends AnimatorEasingConfig<T>> extends Animator<Config> {
-    run(): void;
-    tick(now: number, delta: number): void;
-    protected setDead(): void;
-    apply0(): void;
-    protected abstract apply(boundedEased: number): void;
-}
+import { Animator, AnimatorConfig } from "./Animator.js";
+import { EasingFunction } from "./EasingFunctions.js";
+export declare type AnimatorEasingConfig<T> = AnimatorConfig & {
+    easing: EasingFunction;
+    duration: number;
+    startPosition: T;
+    endPosition: T;
+};
+export declare function getDefaultConfig<T>(empty: T): AnimatorEasingConfig<T>;
+export declare abstract class AnimatorEasing<T, Config extends AnimatorEasingConfig<T>> extends Animator<Config> {
+    run(): void;
+    tick(now: number, delta: number): void;
+    protected setDead(): void;
+    apply0(): void;
+    protected abstract apply(boundedEased: number): void;
+}
 //# sourceMappingURL=AnimatorEasing.d.ts.map

package/dist/animation/animator/AnimatorEasing.js

@@ -1,31 +1,31 @@
-import { AnimationState, Animator, defaultConfig as baseDefaultConfig, } from "./Animator.js";
-import { EasingFunctions } from "./EasingFunctions.js";
-export function getDefaultConfig(empty) {
-    return Object.assign(Object.assign({}, baseDefaultConfig), { startPosition: empty, endPosition: empty, easing: EasingFunctions.linear, duration: 1000 });
-}
-export class AnimatorEasing extends Animator {
-    run() {
-        if (!this.isReadyToRun()) {
-            return;
-        }
-        this.state = AnimationState.Waiting;
-    }
-    tick(now, delta) {
-        if (!this.willTick(now, delta) || this.startTime === undefined) {
-            return;
-        }
-        const progressFraction = (now - this.startTime) / this._config.duration;
-        const boundedEased = this._config.easing(Math.max(0, Math.min(1, progressFraction)));
-        this.apply(boundedEased);
-        if (1 < progressFraction) {
-            this.setDead();
-        }
-    }
-    setDead() {
-        this.state = AnimationState.Dead;
-        this.isDoneObservable.notifyAll();
-    }
-    apply0() {
-        this.apply(0);
-    }
-}
+import { AnimationState, Animator, defaultConfig as baseDefaultConfig, } from "./Animator.js";
+import { EasingFunctions } from "./EasingFunctions.js";
+export function getDefaultConfig(empty) {
+    return Object.assign(Object.assign({}, baseDefaultConfig), { startPosition: empty, endPosition: empty, easing: EasingFunctions.linear, duration: 1000 });
+}
+export class AnimatorEasing extends Animator {
+    run() {
+        if (!this.isReadyToRun()) {
+            return;
+        }
+        this.state = AnimationState.Waiting;
+    }
+    tick(now, delta) {
+        if (!this.willTick(now, delta) || this.startTime === undefined) {
+            return;
+        }
+        const progressFraction = (now - this.startTime) / this._config.duration;
+        const boundedEased = this._config.easing(Math.max(0, Math.min(1, progressFraction)));
+        this.apply(boundedEased);
+        if (1 < progressFraction) {
+            this.setDead();
+        }
+    }
+    setDead() {
+        this.state = AnimationState.Dead;
+        this.isDoneObservable.notifyAll();
+    }
+    apply0() {
+        this.apply(0);
+    }
+}

package/dist/animation/animator/AnimatorEasingMatrix.d.ts

@@ -1,15 +1,15 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatableObject } from "../AnimatableObject.js";
-import { AnimatorEasing, AnimatorEasingConfig } from "./AnimatorEasing.js";
-export declare type AnimatorEasingMatrixConfig<T> = AnimatorEasingConfig<T> & {
-    translationVector: Vector3;
-};
-export declare function getDefaultConfig<T>(empty: T): AnimatorEasingMatrixConfig<T>;
-export declare abstract class AnimatorEasingMatrix<T, Config extends AnimatorEasingMatrixConfig<T>> extends AnimatorEasing<T, Config> {
-    private _translateMatrix;
-    private _translateInverseMatrix;
-    constructor(node: AnimatableObject, config: Config, type?: string | undefined);
-    protected abstract getTransformMatrix(boundedEased: number): Matrix;
-    protected apply(boundedEased: number): void;
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatableObject } from "../AnimatableObject.js";
+import { AnimatorEasing, AnimatorEasingConfig } from "./AnimatorEasing.js";
+export declare type AnimatorEasingMatrixConfig<T> = AnimatorEasingConfig<T> & {
+    translationVector: Vector3;
+};
+export declare function getDefaultConfig<T>(empty: T): AnimatorEasingMatrixConfig<T>;
+export declare abstract class AnimatorEasingMatrix<T, Config extends AnimatorEasingMatrixConfig<T>> extends AnimatorEasing<T, Config> {
+    private _translateMatrix;
+    private _translateInverseMatrix;
+    constructor(node: AnimatableObject, config: Config, type?: string | undefined);
+    protected abstract getTransformMatrix(boundedEased: number): Matrix;
+    protected apply(boundedEased: number): void;
+}
 //# sourceMappingURL=AnimatorEasingMatrix.d.ts.map

package/dist/animation/animator/AnimatorEasingMatrix.js

@@ -1,16 +1,16 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatorEasing, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasing.js";
-export function getDefaultConfig(empty) {
-    return Object.assign(Object.assign({}, baseGetDefaultConfig(empty)), { translationVector: new Vector3() });
-}
-export class AnimatorEasingMatrix extends AnimatorEasing {
-    constructor(node, config, type) {
-        super(node, config, type);
-        this._translateMatrix = Matrix.Translation(config.translationVector.x, config.translationVector.y, config.translationVector.z);
-        this._translateInverseMatrix = Matrix.Translation(-config.translationVector.x, -config.translationVector.y, -config.translationVector.z);
-    }
-    apply(boundedEased) {
-        const transformMatrix = this.getTransformMatrix(boundedEased);
-        this.node.setPreTransformMatrix(this.node.originalMatrix.multiply(this._translateInverseMatrix.multiply(transformMatrix.multiply(this._translateMatrix))));
-    }
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatorEasing, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasing.js";
+export function getDefaultConfig(empty) {
+    return Object.assign(Object.assign({}, baseGetDefaultConfig(empty)), { translationVector: new Vector3() });
+}
+export class AnimatorEasingMatrix extends AnimatorEasing {
+    constructor(node, config, type) {
+        super(node, config, type);
+        this._translateMatrix = Matrix.Translation(config.translationVector.x, config.translationVector.y, config.translationVector.z);
+        this._translateInverseMatrix = Matrix.Translation(-config.translationVector.x, -config.translationVector.y, -config.translationVector.z);
+    }
+    apply(boundedEased) {
+        const transformMatrix = this.getTransformMatrix(boundedEased);
+        this.node.setPreTransformMatrix(this.node.originalMatrix.multiply(this._translateInverseMatrix.multiply(transformMatrix.multiply(this._translateMatrix))));
+    }
+}

package/dist/animation/animator/AnimatorHighlight.d.ts

@@ -1,17 +1,17 @@
-import { Color3 } from "@babylonjs/core/Maths/math.color.js";
-import "@babylonjs/core/Rendering/outlineRenderer.js";
-import { AnimatableObject } from "../AnimatableObject.js";
-import { AnimatorEasing, AnimatorEasingConfig } from "./AnimatorEasing.js";
-export declare type AnimatorHighlightConfig = AnimatorEasingConfig<number> & {
-    color: Color3;
-    width: number;
-    alpha: number;
-};
-export declare const defaultConfig: AnimatorHighlightConfig;
-export declare class AnimatorHighlight extends AnimatorEasing<number, AnimatorHighlightConfig> {
-    constructor(node: AnimatableObject, config?: Partial<AnimatorHighlightConfig>, type?: string);
-    run(): void;
-    protected setDead(): void;
-    protected apply(boundedEased: number): void;
-}
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import "@babylonjs/core/Rendering/outlineRenderer.js";
+import { AnimatableObject } from "../AnimatableObject.js";
+import { AnimatorEasing, AnimatorEasingConfig } from "./AnimatorEasing.js";
+export declare type AnimatorHighlightConfig = AnimatorEasingConfig<number> & {
+    color: Color3;
+    width: number;
+    alpha: number;
+};
+export declare const defaultConfig: AnimatorHighlightConfig;
+export declare class AnimatorHighlight extends AnimatorEasing<number, AnimatorHighlightConfig> {
+    constructor(node: AnimatableObject, config?: Partial<AnimatorHighlightConfig>, type?: string);
+    run(): void;
+    protected setDead(): void;
+    protected apply(boundedEased: number): void;
+}
 //# sourceMappingURL=AnimatorHighlight.d.ts.map

package/dist/animation/animator/AnimatorHighlight.js

@@ -1,32 +1,32 @@
-import "@babylonjs/core/Rendering/outlineRenderer.js";
-import { toColor3 } from "../../utilities/utilitiesColor.js";
-import { AnimatorEasing, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasing.js";
-export const defaultConfig = Object.assign(Object.assign({}, baseGetDefaultConfig(0)), { color: toColor3(0xffff00).toLinearSpace(), width: 0.01, alpha: 0.5 });
-export class AnimatorHighlight extends AnimatorEasing {
-    constructor(node, config, type) {
-        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
-    }
-    run() {
-        for (const mesh of this.node.getChildMeshes()) {
-            mesh.renderOutline = true;
-            mesh.outlineColor = this._config.color;
-            mesh.renderOverlay = true;
-            mesh.overlayColor = this._config.color;
-        }
-        this.apply(0);
-        super.run();
-    }
-    setDead() {
-        super.setDead();
-        for (const mesh of this.node.getChildMeshes()) {
-            mesh.renderOutline = false;
-            mesh.renderOverlay = false;
-        }
-    }
-    apply(boundedEased) {
-        for (const mesh of this.node.getChildMeshes()) {
-            mesh.outlineWidth = this._config.width * boundedEased;
-            mesh.overlayAlpha = this._config.alpha * boundedEased;
-        }
-    }
-}
+import "@babylonjs/core/Rendering/outlineRenderer.js";
+import { toColor3 } from "../../utilities/utilitiesColor.js";
+import { AnimatorEasing, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasing.js";
+export const defaultConfig = Object.assign(Object.assign({}, baseGetDefaultConfig(0)), { color: toColor3(0xffff00).toLinearSpace(), width: 0.01, alpha: 0.5 });
+export class AnimatorHighlight extends AnimatorEasing {
+    constructor(node, config, type) {
+        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
+    }
+    run() {
+        for (const mesh of this.node.getChildMeshes()) {
+            mesh.renderOutline = true;
+            mesh.outlineColor = this._config.color;
+            mesh.renderOverlay = true;
+            mesh.overlayColor = this._config.color;
+        }
+        this.apply(0);
+        super.run();
+    }
+    setDead() {
+        super.setDead();
+        for (const mesh of this.node.getChildMeshes()) {
+            mesh.renderOutline = false;
+            mesh.renderOverlay = false;
+        }
+    }
+    apply(boundedEased) {
+        for (const mesh of this.node.getChildMeshes()) {
+            mesh.outlineWidth = this._config.width * boundedEased;
+            mesh.overlayAlpha = this._config.alpha * boundedEased;
+        }
+    }
+}

package/dist/animation/animator/AnimatorPointToPoint.d.ts

@@ -1,9 +1,9 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatableObject } from "../AnimatableObject.js";
-import { AnimatorEasingMatrix, AnimatorEasingMatrixConfig } from "./AnimatorEasingMatrix.js";
-export declare type AnimatorPointToPointConfig = AnimatorEasingMatrixConfig<Vector3>;
-export declare class AnimatorPointToPoint extends AnimatorEasingMatrix<Vector3, AnimatorPointToPointConfig> {
-    constructor(node: AnimatableObject, config: Partial<AnimatorPointToPointConfig>, type?: string);
-    protected getTransformMatrix(boundedEased: number): Matrix;
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatableObject } from "../AnimatableObject.js";
+import { AnimatorEasingMatrix, AnimatorEasingMatrixConfig } from "./AnimatorEasingMatrix.js";
+export declare type AnimatorPointToPointConfig = AnimatorEasingMatrixConfig<Vector3>;
+export declare class AnimatorPointToPoint extends AnimatorEasingMatrix<Vector3, AnimatorPointToPointConfig> {
+    constructor(node: AnimatableObject, config: Partial<AnimatorPointToPointConfig>, type?: string);
+    protected getTransformMatrix(boundedEased: number): Matrix;
+}
 //# sourceMappingURL=AnimatorPointToPoint.d.ts.map

package/dist/animation/animator/AnimatorPointToPoint.js

@@ -1,14 +1,14 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatorEasingMatrix, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasingMatrix.js";
-const defaultConfig = baseGetDefaultConfig(new Vector3());
-export class AnimatorPointToPoint extends AnimatorEasingMatrix {
-    constructor(node, config, type) {
-        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
-    }
-    getTransformMatrix(boundedEased) {
-        const move = this._config.startPosition.add(this._config.endPosition
-            .subtract(this._config.startPosition)
-            .multiplyByFloats(boundedEased, boundedEased, boundedEased));
-        return Matrix.Identity().setTranslation(move);
-    }
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatorEasingMatrix, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasingMatrix.js";
+const defaultConfig = baseGetDefaultConfig(new Vector3());
+export class AnimatorPointToPoint extends AnimatorEasingMatrix {
+    constructor(node, config, type) {
+        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
+    }
+    getTransformMatrix(boundedEased) {
+        const move = this._config.startPosition.add(this._config.endPosition
+            .subtract(this._config.startPosition)
+            .multiplyByFloats(boundedEased, boundedEased, boundedEased));
+        return Matrix.Identity().setTranslation(move);
+    }
+}

package/dist/animation/animator/AnimatorQueue.d.ts

@@ -1,14 +1,14 @@
-import { AnimatableObject } from "../AnimatableObject.js";
-import { Animator, AnimatorConfig } from "./Animator.js";
-export declare type AnimatorQueueConfig = AnimatorConfig;
-export declare class AnimatorQueue extends Animator<AnimatorQueueConfig> {
-    private animationsQueue;
-    constructor(node: AnimatableObject, config?: Partial<AnimatorQueueConfig>, type?: string);
-    add(animator: Animator): void;
-    peek(): Animator | undefined;
-    run(): void;
-    apply0(): void;
-    willTick(now: number, delta: number): boolean;
-    tick(now: number, delta: number): void;
-}
+import { AnimatableObject } from "../AnimatableObject.js";
+import { Animator, AnimatorConfig } from "./Animator.js";
+export declare type AnimatorQueueConfig = AnimatorConfig;
+export declare class AnimatorQueue extends Animator<AnimatorQueueConfig> {
+    private animationsQueue;
+    constructor(node: AnimatableObject, config?: Partial<AnimatorQueueConfig>, type?: string);
+    add(animator: Animator): void;
+    peek(): Animator | undefined;
+    run(): void;
+    apply0(): void;
+    willTick(now: number, delta: number): boolean;
+    tick(now: number, delta: number): void;
+}
 //# sourceMappingURL=AnimatorQueue.d.ts.map

package/dist/animation/animator/AnimatorQueue.js

@@ -1,57 +1,57 @@
-import { AnimationState, Animator, defaultConfig as baseDefaultConfig, } from "./Animator.js";
-const defaultConfig = baseDefaultConfig;
-export class AnimatorQueue extends Animator {
-    constructor(node, config, type) {
-        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
-        this.animationsQueue = [];
-    }
-    add(animator) {
-        const doneListener = () => {
-            animator.stopListenForDone(doneListener);
-            this.animationsQueue.shift();
-            if (this.animationsQueue.length === 0) {
-                this.state = AnimationState.Ready;
-                this.isDoneObservable.notifyAll();
-                return;
-            }
-            this.animationsQueue[0].run();
-        };
-        animator.listenForDone(doneListener);
-        this.animationsQueue.push(animator);
-    }
-    peek() {
-        return this.animationsQueue[0];
-    }
-    run() {
-        if (!this.isReadyToRun()) {
-            return;
-        }
-        const animation = this.peek();
-        if (animation === undefined) {
-            return;
-        }
-        this.state = AnimationState.Running;
-        animation.run();
-    }
-    apply0() {
-        const animation = this.peek();
-        if (animation === undefined) {
-            return;
-        }
-        animation.apply0();
-    }
-    willTick(now, delta) {
-        const animation = this.peek();
-        if (animation === undefined) {
-            return false;
-        }
-        return animation.willTick(now, delta);
-    }
-    tick(now, delta) {
-        const animation = this.peek();
-        if (animation === undefined) {
-            return;
-        }
-        animation.tick(now, delta);
-    }
-}
+import { AnimationState, Animator, defaultConfig as baseDefaultConfig, } from "./Animator.js";
+const defaultConfig = baseDefaultConfig;
+export class AnimatorQueue extends Animator {
+    constructor(node, config, type) {
+        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
+        this.animationsQueue = [];
+    }
+    add(animator) {
+        const doneListener = () => {
+            animator.stopListenForDone(doneListener);
+            this.animationsQueue.shift();
+            if (this.animationsQueue.length === 0) {
+                this.state = AnimationState.Ready;
+                this.isDoneObservable.notifyAll();
+                return;
+            }
+            this.animationsQueue[0].run();
+        };
+        animator.listenForDone(doneListener);
+        this.animationsQueue.push(animator);
+    }
+    peek() {
+        return this.animationsQueue[0];
+    }
+    run() {
+        if (!this.isReadyToRun()) {
+            return;
+        }
+        const animation = this.peek();
+        if (animation === undefined) {
+            return;
+        }
+        this.state = AnimationState.Running;
+        animation.run();
+    }
+    apply0() {
+        const animation = this.peek();
+        if (animation === undefined) {
+            return;
+        }
+        animation.apply0();
+    }
+    willTick(now, delta) {
+        const animation = this.peek();
+        if (animation === undefined) {
+            return false;
+        }
+        return animation.willTick(now, delta);
+    }
+    tick(now, delta) {
+        const animation = this.peek();
+        if (animation === undefined) {
+            return;
+        }
+        animation.tick(now, delta);
+    }
+}

package/dist/animation/animator/AnimatorScale.d.ts

@@ -1,9 +1,9 @@
-import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatableObject } from "../AnimatableObject.js";
-import { AnimatorEasingMatrix, AnimatorEasingMatrixConfig } from "./AnimatorEasingMatrix.js";
-export declare type AnimatorScaleConfig = AnimatorEasingMatrixConfig<number>;
-export declare class AnimatorScale extends AnimatorEasingMatrix<number, AnimatorScaleConfig> {
-    constructor(node: AnimatableObject, config: Partial<AnimatorScaleConfig>, type?: string);
-    protected getTransformMatrix(boundedEased: number): Matrix;
-}
+import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatableObject } from "../AnimatableObject.js";
+import { AnimatorEasingMatrix, AnimatorEasingMatrixConfig } from "./AnimatorEasingMatrix.js";
+export declare type AnimatorScaleConfig = AnimatorEasingMatrixConfig<number>;
+export declare class AnimatorScale extends AnimatorEasingMatrix<number, AnimatorScaleConfig> {
+    constructor(node: AnimatableObject, config: Partial<AnimatorScaleConfig>, type?: string);
+    protected getTransformMatrix(boundedEased: number): Matrix;
+}
 //# sourceMappingURL=AnimatorScale.d.ts.map

package/dist/animation/animator/AnimatorScale.js

@@ -1,13 +1,13 @@
-import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatorEasingMatrix, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasingMatrix.js";
-const defaultConfig = baseGetDefaultConfig(0);
-export class AnimatorScale extends AnimatorEasingMatrix {
-    constructor(node, config, type) {
-        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
-    }
-    getTransformMatrix(boundedEased) {
-        const scale = this._config.startPosition +
-            (this._config.endPosition - this._config.startPosition) * boundedEased;
-        return Matrix.Scaling(scale, scale, scale);
-    }
-}
+import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatorEasingMatrix, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasingMatrix.js";
+const defaultConfig = baseGetDefaultConfig(0);
+export class AnimatorScale extends AnimatorEasingMatrix {
+    constructor(node, config, type) {
+        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
+    }
+    getTransformMatrix(boundedEased) {
+        const scale = this._config.startPosition +
+            (this._config.endPosition - this._config.startPosition) * boundedEased;
+        return Matrix.Scaling(scale, scale, scale);
+    }
+}

package/dist/animation/animator/AnimatorSpin.d.ts

@@ -1,11 +1,11 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatableObject } from "../AnimatableObject.js";
-import { AnimatorEasingMatrix, AnimatorEasingMatrixConfig } from "./AnimatorEasingMatrix.js";
-export declare type AnimatorSpinConfig = AnimatorEasingMatrixConfig<number> & {
-    rotationAxis: Vector3;
-};
-export declare class AnimatorSpin extends AnimatorEasingMatrix<number, AnimatorSpinConfig> {
-    constructor(node: AnimatableObject, config: Partial<AnimatorSpinConfig>, type?: string);
-    protected getTransformMatrix(boundedEased: number): Matrix;
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatableObject } from "../AnimatableObject.js";
+import { AnimatorEasingMatrix, AnimatorEasingMatrixConfig } from "./AnimatorEasingMatrix.js";
+export declare type AnimatorSpinConfig = AnimatorEasingMatrixConfig<number> & {
+    rotationAxis: Vector3;
+};
+export declare class AnimatorSpin extends AnimatorEasingMatrix<number, AnimatorSpinConfig> {
+    constructor(node: AnimatableObject, config: Partial<AnimatorSpinConfig>, type?: string);
+    protected getTransformMatrix(boundedEased: number): Matrix;
+}
 //# sourceMappingURL=AnimatorSpin.d.ts.map

package/dist/animation/animator/AnimatorSpin.js

@@ -1,13 +1,13 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatorEasingMatrix, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasingMatrix.js";
-const defaultConfig = Object.assign(Object.assign({}, baseGetDefaultConfig(0)), { rotationAxis: new Vector3(0, 0, 1) });
-export class AnimatorSpin extends AnimatorEasingMatrix {
-    constructor(node, config, type) {
-        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
-    }
-    getTransformMatrix(boundedEased) {
-        const spin = this._config.startPosition +
-            (this._config.endPosition - this._config.startPosition) * boundedEased;
-        return Matrix.RotationAxis(this._config.rotationAxis, spin);
-    }
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatorEasingMatrix, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasingMatrix.js";
+const defaultConfig = Object.assign(Object.assign({}, baseGetDefaultConfig(0)), { rotationAxis: new Vector3(0, 0, 1) });
+export class AnimatorSpin extends AnimatorEasingMatrix {
+    constructor(node, config, type) {
+        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
+    }
+    getTransformMatrix(boundedEased) {
+        const spin = this._config.startPosition +
+            (this._config.endPosition - this._config.startPosition) * boundedEased;
+        return Matrix.RotationAxis(this._config.rotationAxis, spin);
+    }
+}

package/dist/animation/animator/EasingFunctions.d.ts

@@ -1,36 +1,36 @@
-export declare type EasingFunction = (t: number) => number;
-export declare const EasingFunctions: {
-    linear: EasingFunction;
-    easeInQuad: EasingFunction;
-    easeOutQuad: EasingFunction;
-    easeInOutQuad: EasingFunction;
-    easeInCubic: EasingFunction;
-    easeOutCubic: EasingFunction;
-    easeInOutCubic: EasingFunction;
-    easeInQuart: EasingFunction;
-    easeOutQuart: EasingFunction;
-    easeInOutQuart: EasingFunction;
-    easeInQuint: EasingFunction;
-    easeOutQuint: EasingFunction;
-    easeInOutQuint: EasingFunction;
-    sinBounce: (oscillations: number) => EasingFunction;
-    easeInSine: EasingFunction;
-    easeOutSine: EasingFunction;
-    easeInOutSine: EasingFunction;
-    easeInExpo: EasingFunction;
-    easeOutExpo: EasingFunction;
-    easeInOutExpo: EasingFunction;
-    easeInCirc: EasingFunction;
-    easeOutCirc: EasingFunction;
-    easeInOutCirc: EasingFunction;
-    easeInElastic: EasingFunction;
-    easeOutElastic: EasingFunction;
-    easeInOutElastic: EasingFunction;
-    easeInBack: (s?: number) => EasingFunction;
-    easeOutBack: (s?: number) => EasingFunction;
-    easeInOutBack: (s?: number) => EasingFunction;
-    easeOutBounce: EasingFunction;
-    makeMirrored: (func: EasingFunction) => EasingFunction;
-    invert: (func: EasingFunction) => EasingFunction;
-};
+export declare type EasingFunction = (t: number) => number;
+export declare const EasingFunctions: {
+    linear: EasingFunction;
+    easeInQuad: EasingFunction;
+    easeOutQuad: EasingFunction;
+    easeInOutQuad: EasingFunction;
+    easeInCubic: EasingFunction;
+    easeOutCubic: EasingFunction;
+    easeInOutCubic: EasingFunction;
+    easeInQuart: EasingFunction;
+    easeOutQuart: EasingFunction;
+    easeInOutQuart: EasingFunction;
+    easeInQuint: EasingFunction;
+    easeOutQuint: EasingFunction;
+    easeInOutQuint: EasingFunction;
+    sinBounce: (oscillations: number) => EasingFunction;
+    easeInSine: EasingFunction;
+    easeOutSine: EasingFunction;
+    easeInOutSine: EasingFunction;
+    easeInExpo: EasingFunction;
+    easeOutExpo: EasingFunction;
+    easeInOutExpo: EasingFunction;
+    easeInCirc: EasingFunction;
+    easeOutCirc: EasingFunction;
+    easeInOutCirc: EasingFunction;
+    easeInElastic: EasingFunction;
+    easeOutElastic: EasingFunction;
+    easeInOutElastic: EasingFunction;
+    easeInBack: (s?: number) => EasingFunction;
+    easeOutBack: (s?: number) => EasingFunction;
+    easeInOutBack: (s?: number) => EasingFunction;
+    easeOutBounce: EasingFunction;
+    makeMirrored: (func: EasingFunction) => EasingFunction;
+    invert: (func: EasingFunction) => EasingFunction;
+};
 //# sourceMappingURL=EasingFunctions.d.ts.map