@zephyr3d/scene 0.6.1 → 0.7.1

package/dist/animation/proptrack.js

@@ -0,0 +1,186 @@
+import { AnimationTrack } from './animationtrack.js';
+import { Interpolator } from '@zephyr3d/base';
+
+/**
+ * Property animation track
+ *
+ * Animates a single property (scalar, vector, or color) on a target object using
+ * time-based interpolation. Supports:
+ * - float, vec2, vec3/rgb, vec4, rgba property types
+ * - Separate interpolation for RGB and Alpha in RGBA mode
+ * - Linear and cubic spline (natural) interpolation presets
+ *
+ * The track reads a `PropertyAccessor` which encapsulates how to get/set the property
+ * on the target object. Internally, the current state is represented as a numeric array.
+ *
+ * Notes:
+ * - `calculateState` samples interpolators into an internal reusable state instance
+ *   for performance; consumers should treat returned states as ephemeral.
+ * - `mixState` performs component-wise linear interpolation for blending.
+ *
+ * @public
+ */ class PropertyTrack extends AnimationTrack {
+    _state;
+    _stateAlpha;
+    _prop;
+    _count;
+    _interpolator;
+    _interpolatorAlpha;
+    /**
+   * Construct a PropertyTrack for a specific property.
+   *
+   * Initializes interpolators and internal state based on the property type.
+   * If an initial `value` is provided, it seeds the starting state and default key values.
+   *
+   * @param prop - The property accessor describing what and how to animate.
+   * @param value - Optional initial numeric values (length must match the property type).
+   * @param embedded - Whether this track is embedded/owned inline. Default false.
+   *
+   * @throws Error if the property type is unsupported for animation.
+   */ constructor(prop, value, embedded){
+        super(embedded);
+        this._prop = prop;
+        this._state = [
+            0,
+            0,
+            0,
+            0
+        ];
+        this._stateAlpha = [
+            0
+        ];
+        this._interpolator = null;
+        this._interpolatorAlpha = null;
+        if (value) {
+            this._state = value.slice();
+        }
+        switch(this._prop.type){
+            case 'float':
+                this._count = 1;
+                this._interpolator = new Interpolator('cubicspline-natural', 'number', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    this._state[0],
+                    this._state[0]
+                ]));
+                break;
+            case 'vec2':
+                this._count = 2;
+                this._interpolator = new Interpolator('cubicspline-natural', 'vec2', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    ...this._state.slice(0, 2),
+                    ...this._state.slice(0, 2)
+                ]));
+                break;
+            case 'rgb':
+            case 'vec3':
+                this._count = 3;
+                this._interpolator = new Interpolator('cubicspline-natural', 'vec3', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    ...this._state.slice(0, 3),
+                    ...this._state.slice(0, 3)
+                ]));
+                break;
+            case 'vec4':
+                this._count = 4;
+                this._interpolator = new Interpolator('cubicspline-natural', 'vec4', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    ...this._state.slice(0, 4),
+                    ...this._state.slice(0, 4)
+                ]));
+                break;
+            case 'rgba':
+                this._count = 4;
+                this._interpolator = new Interpolator('linear', 'vec3', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    ...this._state.slice(0, 3),
+                    ...this._state.slice(0, 3)
+                ]));
+                this._interpolatorAlpha = new Interpolator('linear', 'number', new Float32Array([
+                    0,
+                    1
+                ]), new Float32Array([
+                    this._state[3],
+                    this._state[3]
+                ]));
+                this._stateAlpha = [
+                    this._state[3]
+                ];
+                break;
+            default:
+                throw new Error(`Property '${this._prop.name}' cannot be animated`);
+        }
+    }
+    /**
+   * The primary interpolator for the property components.
+   *
+   * - For float/vec2/vec3/vec4/rgb: handles all channels.
+   * - For rgba: handles RGB channels only; alpha is handled by `interpolatorAlpha`.
+   */ get interpolator() {
+        return this._interpolator;
+    }
+    set interpolator(interpolator) {
+        this._interpolator = interpolator;
+    }
+    /**
+   * The alpha-channel interpolator for RGBA properties.
+   *
+   * - Only used when the property type is `rgba`.
+   * - Setting a non-null interpolator ensures alpha state storage is allocated.
+   */ get interpolatorAlpha() {
+        return this._interpolatorAlpha;
+    }
+    set interpolatorAlpha(interpolator) {
+        this._interpolatorAlpha = interpolator ?? null;
+        if (!this._stateAlpha && this._interpolatorAlpha) {
+            this._stateAlpha = [
+                0
+            ];
+        }
+    }
+    /** {@inheritDoc AnimationTrack.calculateState} */ calculateState(target, currentTime) {
+        this._interpolator.interpolate(currentTime, this._state);
+        if (this._interpolatorAlpha) {
+            this._interpolatorAlpha.interpolate(currentTime, this._stateAlpha);
+            this._state[3] = this._stateAlpha[0];
+        }
+        return this._state;
+    }
+    /** {@inheritDoc AnimationTrack.applyState} */ applyState(target, state) {
+        this._prop.set.call(target, {
+            num: state
+        });
+    }
+    /** {@inheritDoc AnimationTrack.mixState} */ mixState(a, b, t) {
+        const v = [];
+        for(let i = 0; i < this._count; i++){
+            v[i] = a[i] + t * (b[i] - a[i]);
+        }
+        return v;
+    }
+    /** {@inheritDoc AnimationTrack.getBlendId} */ getBlendId() {
+        return this._prop;
+    }
+    /** {@inheritDoc AnimationTrack.getDuration} */ getDuration() {
+        return this._interpolator?.maxTime ?? 0;
+    }
+    /**
+   * Access the underlying property accessor.
+   *
+   * @returns The `PropertyAccessor` used by this track.
+   */ getProp() {
+        return this._prop;
+    }
+}
+
+export { PropertyTrack };
+//# sourceMappingURL=proptrack.js.map

package/dist/animation/proptrack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proptrack.js","sources":["../../src/animation/proptrack.ts"],"sourcesContent":["import { AnimationTrack } from './animationtrack';\r\nimport type { PropertyAccessor } from '../utility';\r\nimport type { Nullable } from '@zephyr3d/base';\r\nimport { Interpolator } from '@zephyr3d/base';\r\n\r\n/**\r\n * Property animation track\r\n *\r\n * Animates a single property (scalar, vector, or color) on a target object using\r\n * time-based interpolation. Supports:\r\n * - float, vec2, vec3/rgb, vec4, rgba property types\r\n * - Separate interpolation for RGB and Alpha in RGBA mode\r\n * - Linear and cubic spline (natural) interpolation presets\r\n *\r\n * The track reads a `PropertyAccessor` which encapsulates how to get/set the property\r\n * on the target object. Internally, the current state is represented as a numeric array.\r\n *\r\n * Notes:\r\n * - `calculateState` samples interpolators into an internal reusable state instance\r\n *   for performance; consumers should treat returned states as ephemeral.\r\n * - `mixState` performs component-wise linear interpolation for blending.\r\n *\r\n * @public\r\n */\r\nexport class PropertyTrack extends AnimationTrack<number[]> {\r\n  private readonly _state: number[];\r\n  private _stateAlpha: number[];\r\n  private readonly _prop: PropertyAccessor;\r\n  private readonly _count: number;\r\n  private _interpolator: Nullable<Interpolator>;\r\n  private _interpolatorAlpha: Nullable<Interpolator>;\r\n  /**\r\n   * Construct a PropertyTrack for a specific property.\r\n   *\r\n   * Initializes interpolators and internal state based on the property type.\r\n   * If an initial `value` is provided, it seeds the starting state and default key values.\r\n   *\r\n   * @param prop - The property accessor describing what and how to animate.\r\n   * @param value - Optional initial numeric values (length must match the property type).\r\n   * @param embedded - Whether this track is embedded/owned inline. Default false.\r\n   *\r\n   * @throws Error if the property type is unsupported for animation.\r\n   */\r\n  constructor(prop: PropertyAccessor, value?: number[], embedded?: boolean) {\r\n    super(embedded);\r\n    this._prop = prop;\r\n    this._state = [0, 0, 0, 0];\r\n    this._stateAlpha = [0];\r\n    this._interpolator = null;\r\n    this._interpolatorAlpha = null;\r\n    if (value) {\r\n      this._state = value.slice();\r\n    }\r\n    switch (this._prop.type) {\r\n      case 'float':\r\n        this._count = 1;\r\n        this._interpolator = new Interpolator(\r\n          'cubicspline-natural',\r\n          'number',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([this._state[0], this._state[0]])\r\n        );\r\n        break;\r\n      case 'vec2':\r\n        this._count = 2;\r\n        this._interpolator = new Interpolator(\r\n          'cubicspline-natural',\r\n          'vec2',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([...this._state.slice(0, 2), ...this._state.slice(0, 2)])\r\n        );\r\n        break;\r\n      case 'rgb':\r\n      case 'vec3':\r\n        this._count = 3;\r\n        this._interpolator = new Interpolator(\r\n          'cubicspline-natural',\r\n          'vec3',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([...this._state.slice(0, 3), ...this._state.slice(0, 3)])\r\n        );\r\n        break;\r\n      case 'vec4':\r\n        this._count = 4;\r\n        this._interpolator = new Interpolator(\r\n          'cubicspline-natural',\r\n          'vec4',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([...this._state.slice(0, 4), ...this._state.slice(0, 4)])\r\n        );\r\n        break;\r\n      case 'rgba':\r\n        this._count = 4;\r\n        this._interpolator = new Interpolator(\r\n          'linear',\r\n          'vec3',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([...this._state.slice(0, 3), ...this._state.slice(0, 3)])\r\n        );\r\n        this._interpolatorAlpha = new Interpolator(\r\n          'linear',\r\n          'number',\r\n          new Float32Array([0, 1]),\r\n          new Float32Array([this._state[3], this._state[3]])\r\n        );\r\n        this._stateAlpha = [this._state[3]];\r\n        break;\r\n      default:\r\n        throw new Error(`Property '${this._prop.name}' cannot be animated`);\r\n    }\r\n  }\r\n  /**\r\n   * The primary interpolator for the property components.\r\n   *\r\n   * - For float/vec2/vec3/vec4/rgb: handles all channels.\r\n   * - For rgba: handles RGB channels only; alpha is handled by `interpolatorAlpha`.\r\n   */\r\n  get interpolator() {\r\n    return this._interpolator;\r\n  }\r\n  set interpolator(interpolator: Nullable<Interpolator>) {\r\n    this._interpolator = interpolator;\r\n  }\r\n  /**\r\n   * The alpha-channel interpolator for RGBA properties.\r\n   *\r\n   * - Only used when the property type is `rgba`.\r\n   * - Setting a non-null interpolator ensures alpha state storage is allocated.\r\n   */\r\n  get interpolatorAlpha() {\r\n    return this._interpolatorAlpha;\r\n  }\r\n  set interpolatorAlpha(interpolator: Nullable<Interpolator>) {\r\n    this._interpolatorAlpha = interpolator ?? null;\r\n    if (!this._stateAlpha && this._interpolatorAlpha) {\r\n      this._stateAlpha = [0];\r\n    }\r\n  }\r\n  /** {@inheritDoc AnimationTrack.calculateState} */\r\n  calculateState(target: unknown, currentTime: number) {\r\n    this._interpolator!.interpolate(currentTime, this._state);\r\n    if (this._interpolatorAlpha) {\r\n      this._interpolatorAlpha.interpolate(currentTime, this._stateAlpha);\r\n      this._state[3] = this._stateAlpha[0];\r\n    }\r\n    return this._state;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.applyState} */\r\n  applyState(target: object, state: number[]) {\r\n    this._prop.set!.call(target, { num: state } as any);\r\n  }\r\n  /** {@inheritDoc AnimationTrack.mixState} */\r\n  mixState(a: number[], b: number[], t: number) {\r\n    const v: number[] = [];\r\n    for (let i = 0; i < this._count; i++) {\r\n      v[i] = a[i] + t * (b[i] - a[i]);\r\n    }\r\n    return v;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getBlendId} */\r\n  getBlendId() {\r\n    return this._prop;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getDuration} */\r\n  getDuration() {\r\n    return this._interpolator?.maxTime ?? 0;\r\n  }\r\n  /**\r\n   * Access the underlying property accessor.\r\n   *\r\n   * @returns The `PropertyAccessor` used by this track.\r\n   */\r\n  getProp() {\r\n    return this._prop;\r\n  }\r\n}\r\n"],"names":["PropertyTrack","AnimationTrack","_state","_stateAlpha","_prop","_count","_interpolator","_interpolatorAlpha","prop","value","embedded","slice","type","Interpolator","Float32Array","Error","name","interpolator","interpolatorAlpha","calculateState","target","currentTime","interpolate","applyState","state","set","call","num","mixState","a","b","t","v","i","getBlendId","getDuration","maxTime","getProp"],"mappings":"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"}

package/dist/animation/rotationtrack.js

@@ -4,15 +4,20 @@ import { AnimationTrack } from './animationtrack.js';
 /**
  * Rotation animation track
  * @public
- */ class RotationTrack extends AnimationTrack {
+ */ class NodeRotationTrack extends AnimationTrack {
     _state;
-    constructor(modeOrInterpolator, keyFrames){
-        if (modeOrInterpolator instanceof Interpolator) {
+    _interpolator;
+    constructor(modeOrInterpolator, keyFramesOrEmbedded, embedded){
+        if (modeOrInterpolator === undefined) {
+            super(false);
+        } else if (modeOrInterpolator instanceof Interpolator) {
             if (modeOrInterpolator.target !== 'quat') {
                 throw new Error(`RotationTrack(): interpolator target must be 'quat'`);
             }
-            super(modeOrInterpolator);
+            super(keyFramesOrEmbedded ?? false);
+            this._interpolator = modeOrInterpolator;
         } else {
+            const keyFrames = keyFramesOrEmbedded;
             const inputs = new Float32Array(keyFrames.map((val)=>val.time));
             const outputs = new Float32Array(keyFrames.length * 4);
             for(let i = 0; i < keyFrames.length; i++){
@@ -21,25 +26,37 @@ import { AnimationTrack } from './animationtrack.js';
                 outputs[i * 4 + 2] = keyFrames[i].value.z;
                 outputs[i * 4 + 3] = keyFrames[i].value.w;
             }
-            const interpolator = new Interpolator(modeOrInterpolator, 'quat', inputs, outputs);
-            super(interpolator);
+            super(embedded ?? false);
+            this._interpolator = new Interpolator(modeOrInterpolator, 'quat', inputs, outputs);
         }
         this._state = new Quaternion();
     }
-    calculateState(currentTime) {
+    get interpolator() {
+        return this._interpolator;
+    }
+    set interpolator(interp) {
+        if (interp && interp.target !== 'quat') {
+            throw new Error(`RotationTrack(): interpolator target must be 'quat'`);
+        }
+        this._interpolator = interp ?? null;
+    }
+    /** {@inheritDoc AnimationTrack.calculateState} */ calculateState(target, currentTime) {
         this._interpolator.interpolate(currentTime, this._state);
         return this._state;
     }
-    applyState(node, state) {
+    /** {@inheritDoc AnimationTrack.applyState} */ applyState(node, state) {
         node.rotation.set(state);
     }
-    mixState(a, b, t) {
+    /** {@inheritDoc AnimationTrack.mixState} */ mixState(a, b, t) {
         return Quaternion.slerp(a, b, t);
     }
-    getBlendId() {
+    /** {@inheritDoc AnimationTrack.getBlendId} */ getBlendId() {
         return 'node-rotation';
     }
+    /** {@inheritDoc AnimationTrack.getDuration} */ getDuration() {
+        return this._interpolator.maxTime;
+    }
 }
 
-export { RotationTrack };
+export { NodeRotationTrack };
 //# sourceMappingURL=rotationtrack.js.map

package/dist/animation/rotationtrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"rotationtrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"rotationtrack.js","sources":["../../src/animation/rotationtrack.ts"],"sourcesContent":["import type { InterpolationMode } from '@zephyr3d/base';\r\nimport { Interpolator, Quaternion } from '@zephyr3d/base';\r\nimport { AnimationTrack } from './animationtrack';\r\nimport type { SceneNode } from '../scene';\r\n\r\n/**\r\n * Rotation animation track\r\n * @public\r\n */\r\nexport class NodeRotationTrack extends AnimationTrack<Quaternion> {\r\n  private readonly _state: Quaternion;\r\n  private _interpolator!: Interpolator;\r\n  /**\r\n   * Create an instance of RotationTrack\r\n   */\r\n  constructor();\r\n  /**\r\n   * Create an instance of RotationTrack from keyframe values\r\n   * @param interpolator - Interpolator object that contains keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(interpolator: Interpolator, embedded?: boolean);\r\n  /**\r\n   * Create an instance of RotationTrack from keyframe values\r\n   * @param mode - The interpolation mode of keyframes\r\n   * @param keyFrames - Keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(mode: InterpolationMode, keyFrames: { time: number; value: Quaternion }[], embedded?: boolean);\r\n  constructor(\r\n    modeOrInterpolator?: Interpolator | InterpolationMode,\r\n    keyFramesOrEmbedded?: { time: number; value: Quaternion }[] | boolean,\r\n    embedded?: boolean\r\n  ) {\r\n    if (modeOrInterpolator === undefined) {\r\n      super(false);\r\n    } else if (modeOrInterpolator instanceof Interpolator) {\r\n      if (modeOrInterpolator.target !== 'quat') {\r\n        throw new Error(`RotationTrack(): interpolator target must be 'quat'`);\r\n      }\r\n      super((keyFramesOrEmbedded as boolean) ?? false);\r\n      this._interpolator = modeOrInterpolator;\r\n    } else {\r\n      const keyFrames = keyFramesOrEmbedded as { time: number; value: Quaternion }[];\r\n      const inputs = new Float32Array(keyFrames.map((val) => val.time));\r\n      const outputs = new Float32Array(keyFrames.length * 4);\r\n      for (let i = 0; i < keyFrames.length; i++) {\r\n        outputs[i * 4 + 0] = keyFrames[i].value.x;\r\n        outputs[i * 4 + 1] = keyFrames[i].value.y;\r\n        outputs[i * 4 + 2] = keyFrames[i].value.z;\r\n        outputs[i * 4 + 3] = keyFrames[i].value.w;\r\n      }\r\n      super(embedded ?? false);\r\n      this._interpolator = new Interpolator(modeOrInterpolator, 'quat', inputs, outputs);\r\n    }\r\n    this._state = new Quaternion();\r\n  }\r\n  get interpolator() {\r\n    return this._interpolator;\r\n  }\r\n  set interpolator(interp: Interpolator) {\r\n    if (interp && interp.target !== 'quat') {\r\n      throw new Error(`RotationTrack(): interpolator target must be 'quat'`);\r\n    }\r\n    this._interpolator = interp ?? null;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.calculateState} */\r\n  calculateState(target: object, currentTime: number) {\r\n    this._interpolator.interpolate(currentTime, this._state);\r\n    return this._state;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.applyState} */\r\n  applyState(node: SceneNode, state: Quaternion) {\r\n    node.rotation.set(state);\r\n  }\r\n  /** {@inheritDoc AnimationTrack.mixState} */\r\n  mixState(a: Quaternion, b: Quaternion, t: number) {\r\n    return Quaternion.slerp(a, b, t);\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getBlendId} */\r\n  getBlendId() {\r\n    return 'node-rotation';\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getDuration} */\r\n  getDuration() {\r\n    return this._interpolator.maxTime;\r\n  }\r\n}\r\n"],"names":["NodeRotationTrack","AnimationTrack","_state","_interpolator","modeOrInterpolator","keyFramesOrEmbedded","embedded","undefined","Interpolator","target","Error","keyFrames","inputs","Float32Array","map","val","time","outputs","length","i","value","x","y","z","w","Quaternion","interpolator","interp","calculateState","currentTime","interpolate","applyState","node","state","rotation","set","mixState","a","b","t","slerp","getBlendId","getDuration","maxTime"],"mappings":"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"}

package/dist/animation/scaletrack.js

@@ -4,15 +4,20 @@ import { AnimationTrack } from './animationtrack.js';
 /**
  * Scale animation track
  * @public
- */ class ScaleTrack extends AnimationTrack {
+ */ class NodeScaleTrack extends AnimationTrack {
     _state;
-    constructor(modeOrInterpolator, keyFrames){
-        if (modeOrInterpolator instanceof Interpolator) {
+    _interpolator;
+    constructor(modeOrInterpolator, keyFramesOrEmbedded, embedded){
+        if (modeOrInterpolator === undefined) {
+            super(false);
+        } else if (modeOrInterpolator instanceof Interpolator) {
             if (modeOrInterpolator.target !== 'vec3') {
                 throw new Error(`ScaleTrack(): interpolator target must be 'vec3'`);
             }
-            super(modeOrInterpolator);
+            super(keyFramesOrEmbedded ?? false);
+            this._interpolator = modeOrInterpolator;
         } else {
+            const keyFrames = keyFramesOrEmbedded;
             const inputs = new Float32Array(keyFrames.map((val)=>val.time));
             const outputs = new Float32Array(keyFrames.length * 3);
             for(let i = 0; i < keyFrames.length; i++){
@@ -20,25 +25,37 @@ import { AnimationTrack } from './animationtrack.js';
                 outputs[i * 3 + 1] = keyFrames[i].value.y;
                 outputs[i * 3 + 2] = keyFrames[i].value.z;
             }
-            const interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
-            super(interpolator);
+            super(embedded ?? false);
+            this._interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);
         }
         this._state = new Vector3();
     }
-    calculateState(currentTime) {
+    get interpolator() {
+        return this._interpolator;
+    }
+    set interpolator(interp) {
+        if (interp && interp.target !== 'vec3') {
+            throw new Error(`ScaleTrack(): interpolator target must be 'vec3'`);
+        }
+        this._interpolator = interp ?? null;
+    }
+    /** {@inheritDoc AnimationTrack.calculateState} */ calculateState(target, currentTime) {
         this._interpolator.interpolate(currentTime, this._state);
         return this._state;
     }
-    applyState(node, state) {
+    /** {@inheritDoc AnimationTrack.applyState} */ applyState(node, state) {
         node.scale.set(state);
     }
-    mixState(a, b, t) {
+    /** {@inheritDoc AnimationTrack.mixState} */ mixState(a, b, t) {
         return new Vector3(a.x + t * (b.x - a.x), a.y + t * (b.y - a.y), a.z + t * (b.z - a.z));
     }
-    getBlendId() {
+    /** {@inheritDoc AnimationTrack.getBlendId} */ getBlendId() {
         return 'node-scale';
     }
+    /** {@inheritDoc AnimationTrack.getDuration} */ getDuration() {
+        return this._interpolator.maxTime;
+    }
 }
 
-export { ScaleTrack };
+export { NodeScaleTrack };
 //# sourceMappingURL=scaletrack.js.map

package/dist/animation/scaletrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"scaletrack.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"scaletrack.js","sources":["../../src/animation/scaletrack.ts"],"sourcesContent":["import type { InterpolationMode } from '@zephyr3d/base';\r\nimport { Interpolator, Vector3 } from '@zephyr3d/base';\r\nimport { AnimationTrack } from './animationtrack';\r\nimport type { SceneNode } from '../scene';\r\n\r\n/**\r\n * Scale animation track\r\n * @public\r\n */\r\nexport class NodeScaleTrack extends AnimationTrack<Vector3> {\r\n  private readonly _state: Vector3;\r\n  private _interpolator!: Interpolator;\r\n  /**\r\n   * Create an instance of ScaleTrack\r\n   */\r\n  constructor();\r\n  /**\r\n   * Create an instance of ScaleTrack from keyframe values\r\n   * @param interpolator - Interpolator object that contains keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(interpolator: Interpolator, embedded?: boolean);\r\n  /**\r\n   * Create an instance of ScaleTrack from keyframe values\r\n   * @param mode - The interpolation mode of keyframes\r\n   * @param keyFrames - Keyframe values\r\n   * @param embedded - Whether this track be an embedded track\r\n   */\r\n  constructor(mode: InterpolationMode, keyFrames: { time: number; value: Vector3 }[], embedded?: boolean);\r\n  constructor(\r\n    modeOrInterpolator?: Interpolator | InterpolationMode,\r\n    keyFramesOrEmbedded?: { time: number; value: Vector3 }[] | boolean,\r\n    embedded?: boolean\r\n  ) {\r\n    if (modeOrInterpolator === undefined) {\r\n      super(false);\r\n    } else if (modeOrInterpolator instanceof Interpolator) {\r\n      if (modeOrInterpolator.target !== 'vec3') {\r\n        throw new Error(`ScaleTrack(): interpolator target must be 'vec3'`);\r\n      }\r\n      super((keyFramesOrEmbedded as boolean) ?? false);\r\n      this._interpolator = modeOrInterpolator;\r\n    } else {\r\n      const keyFrames = keyFramesOrEmbedded as { time: number; value: Vector3 }[];\r\n      const inputs = new Float32Array(keyFrames.map((val) => val.time));\r\n      const outputs = new Float32Array(keyFrames.length * 3);\r\n      for (let i = 0; i < keyFrames.length; i++) {\r\n        outputs[i * 3 + 0] = keyFrames[i].value.x;\r\n        outputs[i * 3 + 1] = keyFrames[i].value.y;\r\n        outputs[i * 3 + 2] = keyFrames[i].value.z;\r\n      }\r\n      super(embedded ?? false);\r\n      this._interpolator = new Interpolator(modeOrInterpolator, 'vec3', inputs, outputs);\r\n    }\r\n    this._state = new Vector3();\r\n  }\r\n  get interpolator() {\r\n    return this._interpolator;\r\n  }\r\n  set interpolator(interp: Interpolator) {\r\n    if (interp && interp.target !== 'vec3') {\r\n      throw new Error(`ScaleTrack(): interpolator target must be 'vec3'`);\r\n    }\r\n    this._interpolator = interp ?? null;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.calculateState} */\r\n  calculateState(target: object, currentTime: number) {\r\n    this._interpolator.interpolate(currentTime, this._state);\r\n    return this._state;\r\n  }\r\n  /** {@inheritDoc AnimationTrack.applyState} */\r\n  applyState(node: SceneNode, state: Vector3) {\r\n    node.scale.set(state);\r\n  }\r\n  /** {@inheritDoc AnimationTrack.mixState} */\r\n  mixState(a: Vector3, b: Vector3, t: number) {\r\n    return new Vector3(a.x + t * (b.x - a.x), a.y + t * (b.y - a.y), a.z + t * (b.z - a.z));\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getBlendId} */\r\n  getBlendId() {\r\n    return 'node-scale';\r\n  }\r\n  /** {@inheritDoc AnimationTrack.getDuration} */\r\n  getDuration() {\r\n    return this._interpolator.maxTime;\r\n  }\r\n}\r\n"],"names":["NodeScaleTrack","AnimationTrack","_state","_interpolator","modeOrInterpolator","keyFramesOrEmbedded","embedded","undefined","Interpolator","target","Error","keyFrames","inputs","Float32Array","map","val","time","outputs","length","i","value","x","y","z","Vector3","interpolator","interp","calculateState","currentTime","interpolate","applyState","node","state","scale","set","mixState","a","b","t","getBlendId","getDuration","maxTime"],"mappings":"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"}