@spiffcommerce/preview 3.6.2-rc.4 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Animations/animation.esm.js

@@ -0,0 +1,866 @@
+import { Quaternion as g, Vector3 as y, Vector2 as C, TmpVectors as E, Matrix as P } from "../Maths/math.vector.esm.js";
+import { Color3 as v, Color4 as M } from "../Maths/math.color.esm.js";
+import { Scalar as Y } from "../Maths/math.scalar.esm.js";
+import { SerializationHelper as F } from "../Misc/decorators.esm.js";
+import { RegisterClass as b } from "../Misc/typeStore.esm.js";
+import { AnimationKeyInterpolation as D } from "./animationKey.esm.js";
+import { AnimationRange as R } from "./animationRange.esm.js";
+import { Node as w } from "../node.esm.js";
+import { Size as S } from "../Maths/math.size.esm.js";
+import { WebRequest as m } from "../Misc/webRequest.esm.js";
+class a {
+  /**
+   * @internal Internal use
+   */
+  static _PrepareAnimation(t, e, s, i, r, n, o, c) {
+    let u;
+    if (!isNaN(parseFloat(r)) && isFinite(r) ? u = a.ANIMATIONTYPE_FLOAT : r instanceof g ? u = a.ANIMATIONTYPE_QUATERNION : r instanceof y ? u = a.ANIMATIONTYPE_VECTOR3 : r instanceof C ? u = a.ANIMATIONTYPE_VECTOR2 : r instanceof v ? u = a.ANIMATIONTYPE_COLOR3 : r instanceof M ? u = a.ANIMATIONTYPE_COLOR4 : r instanceof S && (u = a.ANIMATIONTYPE_SIZE), u == null)
+      return null;
+    const f = new a(t, e, s, u, o), l = [
+      { frame: 0, value: r },
+      { frame: i, value: n }
+    ];
+    return f.setKeys(l), c !== void 0 && f.setEasingFunction(c), f;
+  }
+  /**
+   * Sets up an animation
+   * @param property The property to animate
+   * @param animationType The animation type to apply
+   * @param framePerSecond The frames per second of the animation
+   * @param easingFunction The easing function used in the animation
+   * @returns The created animation
+   */
+  static CreateAnimation(t, e, s, i) {
+    const r = new a(t + "Animation", t, s, e, a.ANIMATIONLOOPMODE_CONSTANT);
+    return r.setEasingFunction(i), r;
+  }
+  /**
+   * Create and start an animation on a node
+   * @param name defines the name of the global animation that will be run on all nodes
+   * @param target defines the target where the animation will take place
+   * @param targetProperty defines property to animate
+   * @param framePerSecond defines the number of frame per second yo use
+   * @param totalFrame defines the number of frames in total
+   * @param from defines the initial value
+   * @param to defines the final value
+   * @param loopMode defines which loop mode you want to use (off by default)
+   * @param easingFunction defines the easing function to use (linear by default)
+   * @param onAnimationEnd defines the callback to call when animation end
+   * @param scene defines the hosting scene
+   * @returns the animatable created for this animation
+   */
+  static CreateAndStartAnimation(t, e, s, i, r, n, o, c, u, f, l) {
+    const O = a._PrepareAnimation(t, s, i, r, n, o, c, u);
+    return !O || (e.getScene && (l = e.getScene()), !l) ? null : l.beginDirectAnimation(e, [O], 0, r, O.loopMode === 1, 1, f);
+  }
+  /**
+   * Create and start an animation on a node and its descendants
+   * @param name defines the name of the global animation that will be run on all nodes
+   * @param node defines the root node where the animation will take place
+   * @param directDescendantsOnly if true only direct descendants will be used, if false direct and also indirect (children of children, an so on in a recursive manner) descendants will be used
+   * @param targetProperty defines property to animate
+   * @param framePerSecond defines the number of frame per second to use
+   * @param totalFrame defines the number of frames in total
+   * @param from defines the initial value
+   * @param to defines the final value
+   * @param loopMode defines which loop mode you want to use (off by default)
+   * @param easingFunction defines the easing function to use (linear by default)
+   * @param onAnimationEnd defines the callback to call when an animation ends (will be called once per node)
+   * @returns the list of animatables created for all nodes
+   * @example https://www.babylonjs-playground.com/#MH0VLI
+   */
+  static CreateAndStartHierarchyAnimation(t, e, s, i, r, n, o, c, u, f, l) {
+    const O = a._PrepareAnimation(t, i, r, n, o, c, u, f);
+    return O ? e.getScene().beginDirectHierarchyAnimation(e, s, [O], 0, n, O.loopMode === 1, 1, l) : null;
+  }
+  /**
+   * Creates a new animation, merges it with the existing animations and starts it
+   * @param name Name of the animation
+   * @param node Node which contains the scene that begins the animations
+   * @param targetProperty Specifies which property to animate
+   * @param framePerSecond The frames per second of the animation
+   * @param totalFrame The total number of frames
+   * @param from The frame at the beginning of the animation
+   * @param to The frame at the end of the animation
+   * @param loopMode Specifies the loop mode of the animation
+   * @param easingFunction (Optional) The easing function of the animation, which allow custom mathematical formulas for animations
+   * @param onAnimationEnd Callback to run once the animation is complete
+   * @returns Nullable animation
+   */
+  static CreateMergeAndStartAnimation(t, e, s, i, r, n, o, c, u, f) {
+    const l = a._PrepareAnimation(t, s, i, r, n, o, c, u);
+    return l ? (e.animations.push(l), e.getScene().beginAnimation(e, 0, r, l.loopMode === 1, 1, f)) : null;
+  }
+  /**
+   * Convert the keyframes for all animations belonging to the group to be relative to a given reference frame.
+   * @param sourceAnimation defines the Animation containing keyframes to convert
+   * @param referenceFrame defines the frame that keyframes in the range will be relative to
+   * @param range defines the name of the AnimationRange belonging to the Animation to convert
+   * @param cloneOriginal defines whether or not to clone the animation and convert the clone or convert the original animation (default is false)
+   * @param clonedName defines the name of the resulting cloned Animation if cloneOriginal is true
+   * @returns a new Animation if cloneOriginal is true or the original Animation if cloneOriginal is false
+   */
+  static MakeAnimationAdditive(t, e = 0, s, i = !1, r) {
+    let n = t;
+    if (i && (n = t.clone(), n.name = r || n.name), !n._keys.length)
+      return n;
+    e = e >= 0 ? e : 0;
+    let o = 0;
+    const c = n._keys[0];
+    let u = n._keys.length - 1;
+    const f = n._keys[u], l = {
+      referenceValue: c.value,
+      referencePosition: E.Vector3[0],
+      referenceQuaternion: E.Quaternion[0],
+      referenceScaling: E.Vector3[1],
+      keyPosition: E.Vector3[2],
+      keyQuaternion: E.Quaternion[1],
+      keyScaling: E.Vector3[3]
+    };
+    let O = !1, p = c.frame, I = f.frame;
+    if (s) {
+      const T = n.getRange(s);
+      T && (p = T.from, I = T.to);
+    }
+    let L = c.frame === p, k = f.frame === I;
+    if (n._keys.length === 1) {
+      const T = n._getKeyValue(n._keys[0]);
+      l.referenceValue = T.clone ? T.clone() : T, O = !0;
+    } else if (e <= c.frame) {
+      const T = n._getKeyValue(c.value);
+      l.referenceValue = T.clone ? T.clone() : T, O = !0;
+    } else if (e >= f.frame) {
+      const T = n._getKeyValue(f.value);
+      l.referenceValue = T.clone ? T.clone() : T, O = !0;
+    }
+    let N = 0;
+    for (; !O || !L || !k && N < n._keys.length - 1; ) {
+      const T = n._keys[N], d = n._keys[N + 1];
+      if (!O && e >= T.frame && e <= d.frame) {
+        let h;
+        if (e === T.frame)
+          h = n._getKeyValue(T.value);
+        else if (e === d.frame)
+          h = n._getKeyValue(d.value);
+        else {
+          const A = {
+            key: N,
+            repeatCount: 0,
+            loopMode: this.ANIMATIONLOOPMODE_CONSTANT
+          };
+          h = n._interpolate(e, A);
+        }
+        l.referenceValue = h.clone ? h.clone() : h, O = !0;
+      }
+      if (!L && p >= T.frame && p <= d.frame) {
+        if (p === T.frame)
+          o = N;
+        else if (p === d.frame)
+          o = N + 1;
+        else {
+          const h = {
+            key: N,
+            repeatCount: 0,
+            loopMode: this.ANIMATIONLOOPMODE_CONSTANT
+          }, A = n._interpolate(p, h), _ = {
+            frame: p,
+            value: A.clone ? A.clone() : A
+          };
+          n._keys.splice(N + 1, 0, _), o = N + 1;
+        }
+        L = !0;
+      }
+      if (!k && I >= T.frame && I <= d.frame) {
+        if (I === T.frame)
+          u = N;
+        else if (I === d.frame)
+          u = N + 1;
+        else {
+          const h = {
+            key: N,
+            repeatCount: 0,
+            loopMode: this.ANIMATIONLOOPMODE_CONSTANT
+          }, A = n._interpolate(I, h), _ = {
+            frame: I,
+            value: A.clone ? A.clone() : A
+          };
+          n._keys.splice(N + 1, 0, _), u = N + 1;
+        }
+        k = !0;
+      }
+      N++;
+    }
+    for (n.dataType === a.ANIMATIONTYPE_QUATERNION ? l.referenceValue.normalize().conjugateInPlace() : n.dataType === a.ANIMATIONTYPE_MATRIX && (l.referenceValue.decompose(l.referenceScaling, l.referenceQuaternion, l.referencePosition), l.referenceQuaternion.normalize().conjugateInPlace()), N = o; N <= u; N++) {
+      const T = n._keys[N];
+      if (!(N && n.dataType !== a.ANIMATIONTYPE_FLOAT && T.value === c.value))
+        switch (n.dataType) {
+          case a.ANIMATIONTYPE_MATRIX:
+            T.value.decompose(l.keyScaling, l.keyQuaternion, l.keyPosition), l.keyPosition.subtractInPlace(l.referencePosition), l.keyScaling.divideInPlace(l.referenceScaling), l.referenceQuaternion.multiplyToRef(l.keyQuaternion, l.keyQuaternion), P.ComposeToRef(l.keyScaling, l.keyQuaternion, l.keyPosition, T.value);
+            break;
+          case a.ANIMATIONTYPE_QUATERNION:
+            l.referenceValue.multiplyToRef(T.value, T.value);
+            break;
+          case a.ANIMATIONTYPE_VECTOR2:
+          case a.ANIMATIONTYPE_VECTOR3:
+          case a.ANIMATIONTYPE_COLOR3:
+          case a.ANIMATIONTYPE_COLOR4:
+            T.value.subtractToRef(l.referenceValue, T.value);
+            break;
+          case a.ANIMATIONTYPE_SIZE:
+            T.value.width -= l.referenceValue.width, T.value.height -= l.referenceValue.height;
+            break;
+          default:
+            T.value -= l.referenceValue;
+        }
+    }
+    return n;
+  }
+  /**
+   * Transition property of an host to the target Value
+   * @param property The property to transition
+   * @param targetValue The target Value of the property
+   * @param host The object where the property to animate belongs
+   * @param scene Scene used to run the animation
+   * @param frameRate Framerate (in frame/s) to use
+   * @param transition The transition type we want to use
+   * @param duration The duration of the animation, in milliseconds
+   * @param onAnimationEnd Callback trigger at the end of the animation
+   * @returns Nullable animation
+   */
+  static TransitionTo(t, e, s, i, r, n, o, c = null) {
+    if (o <= 0)
+      return s[t] = e, c && c(), null;
+    const u = r * (o / 1e3);
+    n.setKeys([
+      {
+        frame: 0,
+        value: s[t].clone ? s[t].clone() : s[t]
+      },
+      {
+        frame: u,
+        value: e
+      }
+    ]), s.animations || (s.animations = []), s.animations.push(n);
+    const f = i.beginAnimation(s, 0, u, !1);
+    return f.onAnimationEnd = c, f;
+  }
+  /**
+   * Return the array of runtime animations currently using this animation
+   */
+  get runtimeAnimations() {
+    return this._runtimeAnimations;
+  }
+  /**
+   * Specifies if any of the runtime animations are currently running
+   */
+  get hasRunningRuntimeAnimations() {
+    for (const t of this._runtimeAnimations)
+      if (!t.isStopped())
+        return !0;
+    return !1;
+  }
+  /**
+   * Initializes the animation
+   * @param name Name of the animation
+   * @param targetProperty Property to animate
+   * @param framePerSecond The frames per second of the animation
+   * @param dataType The data type of the animation
+   * @param loopMode The loop mode of the animation
+   * @param enableBlending Specifies if blending should be enabled
+   */
+  constructor(t, e, s, i, r, n) {
+    this.name = t, this.targetProperty = e, this.framePerSecond = s, this.dataType = i, this.loopMode = r, this.enableBlending = n, this._easingFunction = null, this._runtimeAnimations = new Array(), this._events = new Array(), this.blendingSpeed = 0.01, this._ranges = {}, this.targetPropertyPath = e.split("."), this.dataType = i, this.loopMode = r === void 0 ? a.ANIMATIONLOOPMODE_CYCLE : r, this.uniqueId = a._UniqueIdGenerator++;
+  }
+  // Methods
+  /**
+   * Converts the animation to a string
+   * @param fullDetails support for multiple levels of logging within scene loading
+   * @returns String form of the animation
+   */
+  toString(t) {
+    let e = "Name: " + this.name + ", property: " + this.targetProperty;
+    if (e += ", datatype: " + ["Float", "Vector3", "Quaternion", "Matrix", "Color3", "Vector2"][this.dataType], e += ", nKeys: " + (this._keys ? this._keys.length : "none"), e += ", nRanges: " + (this._ranges ? Object.keys(this._ranges).length : "none"), t) {
+      e += ", Ranges: {";
+      let s = !0;
+      for (const i in this._ranges)
+        s && (e += ", ", s = !1), e += i;
+      e += "}";
+    }
+    return e;
+  }
+  /**
+   * Add an event to this animation
+   * @param event Event to add
+   */
+  addEvent(t) {
+    this._events.push(t), this._events.sort((e, s) => e.frame - s.frame);
+  }
+  /**
+   * Remove all events found at the given frame
+   * @param frame The frame to remove events from
+   */
+  removeEvents(t) {
+    for (let e = 0; e < this._events.length; e++)
+      this._events[e].frame === t && (this._events.splice(e, 1), e--);
+  }
+  /**
+   * Retrieves all the events from the animation
+   * @returns Events from the animation
+   */
+  getEvents() {
+    return this._events;
+  }
+  /**
+   * Creates an animation range
+   * @param name Name of the animation range
+   * @param from Starting frame of the animation range
+   * @param to Ending frame of the animation
+   */
+  createRange(t, e, s) {
+    this._ranges[t] || (this._ranges[t] = new R(t, e, s));
+  }
+  /**
+   * Deletes an animation range by name
+   * @param name Name of the animation range to delete
+   * @param deleteFrames Specifies if the key frames for the range should also be deleted (true) or not (false)
+   */
+  deleteRange(t, e = !0) {
+    const s = this._ranges[t];
+    if (s) {
+      if (e) {
+        const i = s.from, r = s.to;
+        for (let n = this._keys.length - 1; n >= 0; n--)
+          this._keys[n].frame >= i && this._keys[n].frame <= r && this._keys.splice(n, 1);
+      }
+      this._ranges[t] = null;
+    }
+  }
+  /**
+   * Gets the animation range by name, or null if not defined
+   * @param name Name of the animation range
+   * @returns Nullable animation range
+   */
+  getRange(t) {
+    return this._ranges[t];
+  }
+  /**
+   * Gets the key frames from the animation
+   * @returns The key frames of the animation
+   */
+  getKeys() {
+    return this._keys;
+  }
+  /**
+   * Gets the highest frame rate of the animation
+   * @returns Highest frame rate of the animation
+   */
+  getHighestFrame() {
+    let t = 0;
+    for (let e = 0, s = this._keys.length; e < s; e++)
+      t < this._keys[e].frame && (t = this._keys[e].frame);
+    return t;
+  }
+  /**
+   * Gets the easing function of the animation
+   * @returns Easing function of the animation
+   */
+  getEasingFunction() {
+    return this._easingFunction;
+  }
+  /**
+   * Sets the easing function of the animation
+   * @param easingFunction A custom mathematical formula for animation
+   */
+  setEasingFunction(t) {
+    this._easingFunction = t;
+  }
+  /**
+   * Interpolates a scalar linearly
+   * @param startValue Start value of the animation curve
+   * @param endValue End value of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns Interpolated scalar value
+   */
+  floatInterpolateFunction(t, e, s) {
+    return Y.Lerp(t, e, s);
+  }
+  /**
+   * Interpolates a scalar cubically
+   * @param startValue Start value of the animation curve
+   * @param outTangent End tangent of the animation
+   * @param endValue End value of the animation curve
+   * @param inTangent Start tangent of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns Interpolated scalar value
+   */
+  floatInterpolateFunctionWithTangents(t, e, s, i, r) {
+    return Y.Hermite(t, e, s, i, r);
+  }
+  /**
+   * Interpolates a quaternion using a spherical linear interpolation
+   * @param startValue Start value of the animation curve
+   * @param endValue End value of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns Interpolated quaternion value
+   */
+  quaternionInterpolateFunction(t, e, s) {
+    return g.Slerp(t, e, s);
+  }
+  /**
+   * Interpolates a quaternion cubically
+   * @param startValue Start value of the animation curve
+   * @param outTangent End tangent of the animation curve
+   * @param endValue End value of the animation curve
+   * @param inTangent Start tangent of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns Interpolated quaternion value
+   */
+  quaternionInterpolateFunctionWithTangents(t, e, s, i, r) {
+    return g.Hermite(t, e, s, i, r).normalize();
+  }
+  /**
+   * Interpolates a Vector3 linearly
+   * @param startValue Start value of the animation curve
+   * @param endValue End value of the animation curve
+   * @param gradient Scalar amount to interpolate (value between 0 and 1)
+   * @returns Interpolated scalar value
+   */
+  vector3InterpolateFunction(t, e, s) {
+    return y.Lerp(t, e, s);
+  }
+  /**
+   * Interpolates a Vector3 cubically
+   * @param startValue Start value of the animation curve
+   * @param outTangent End tangent of the animation
+   * @param endValue End value of the animation curve
+   * @param inTangent Start tangent of the animation curve
+   * @param gradient Scalar amount to interpolate (value between 0 and 1)
+   * @returns InterpolatedVector3 value
+   */
+  vector3InterpolateFunctionWithTangents(t, e, s, i, r) {
+    return y.Hermite(t, e, s, i, r);
+  }
+  /**
+   * Interpolates a Vector2 linearly
+   * @param startValue Start value of the animation curve
+   * @param endValue End value of the animation curve
+   * @param gradient Scalar amount to interpolate (value between 0 and 1)
+   * @returns Interpolated Vector2 value
+   */
+  vector2InterpolateFunction(t, e, s) {
+    return C.Lerp(t, e, s);
+  }
+  /**
+   * Interpolates a Vector2 cubically
+   * @param startValue Start value of the animation curve
+   * @param outTangent End tangent of the animation
+   * @param endValue End value of the animation curve
+   * @param inTangent Start tangent of the animation curve
+   * @param gradient Scalar amount to interpolate (value between 0 and 1)
+   * @returns Interpolated Vector2 value
+   */
+  vector2InterpolateFunctionWithTangents(t, e, s, i, r) {
+    return C.Hermite(t, e, s, i, r);
+  }
+  /**
+   * Interpolates a size linearly
+   * @param startValue Start value of the animation curve
+   * @param endValue End value of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns Interpolated Size value
+   */
+  sizeInterpolateFunction(t, e, s) {
+    return S.Lerp(t, e, s);
+  }
+  /**
+   * Interpolates a Color3 linearly
+   * @param startValue Start value of the animation curve
+   * @param endValue End value of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns Interpolated Color3 value
+   */
+  color3InterpolateFunction(t, e, s) {
+    return v.Lerp(t, e, s);
+  }
+  /**
+   * Interpolates a Color3 cubically
+   * @param startValue Start value of the animation curve
+   * @param outTangent End tangent of the animation
+   * @param endValue End value of the animation curve
+   * @param inTangent Start tangent of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns interpolated value
+   */
+  color3InterpolateFunctionWithTangents(t, e, s, i, r) {
+    return v.Hermite(t, e, s, i, r);
+  }
+  /**
+   * Interpolates a Color4 linearly
+   * @param startValue Start value of the animation curve
+   * @param endValue End value of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns Interpolated Color3 value
+   */
+  color4InterpolateFunction(t, e, s) {
+    return M.Lerp(t, e, s);
+  }
+  /**
+   * Interpolates a Color4 cubically
+   * @param startValue Start value of the animation curve
+   * @param outTangent End tangent of the animation
+   * @param endValue End value of the animation curve
+   * @param inTangent Start tangent of the animation curve
+   * @param gradient Scalar amount to interpolate
+   * @returns interpolated value
+   */
+  color4InterpolateFunctionWithTangents(t, e, s, i, r) {
+    return M.Hermite(t, e, s, i, r);
+  }
+  /**
+   * @internal Internal use only
+   */
+  _getKeyValue(t) {
+    return typeof t == "function" ? t() : t;
+  }
+  /**
+   * Evaluate the animation value at a given frame
+   * @param currentFrame defines the frame where we want to evaluate the animation
+   * @returns the animation value
+   */
+  evaluate(t) {
+    return this._interpolate(t, {
+      key: 0,
+      repeatCount: 0,
+      loopMode: a.ANIMATIONLOOPMODE_CONSTANT
+    });
+  }
+  /**
+   * @internal Internal use only
+   */
+  _interpolate(t, e) {
+    if (e.loopMode === a.ANIMATIONLOOPMODE_CONSTANT && e.repeatCount > 0)
+      return e.highLimitValue.clone ? e.highLimitValue.clone() : e.highLimitValue;
+    const s = this._keys, i = s.length;
+    let r = e.key;
+    for (; r >= 0 && t < s[r].frame; )
+      --r;
+    for (; r + 1 <= i - 1 && t >= s[r + 1].frame; )
+      ++r;
+    if (e.key = r, r < 0)
+      return this._getKeyValue(s[0].value);
+    if (r + 1 > i - 1)
+      return this._getKeyValue(s[i - 1].value);
+    const n = s[r], o = s[r + 1], c = this._getKeyValue(n.value), u = this._getKeyValue(o.value);
+    if (n.interpolation === D.STEP)
+      return o.frame > t ? c : u;
+    const f = n.outTangent !== void 0 && o.inTangent !== void 0, l = o.frame - n.frame;
+    let O = (t - n.frame) / l;
+    const p = this.getEasingFunction();
+    switch (p !== null && (O = p.ease(O)), this.dataType) {
+      case a.ANIMATIONTYPE_FLOAT: {
+        const I = f ? this.floatInterpolateFunctionWithTangents(c, n.outTangent * l, u, o.inTangent * l, O) : this.floatInterpolateFunction(c, u, O);
+        switch (e.loopMode) {
+          case a.ANIMATIONLOOPMODE_CYCLE:
+          case a.ANIMATIONLOOPMODE_CONSTANT:
+          case a.ANIMATIONLOOPMODE_YOYO:
+            return I;
+          case a.ANIMATIONLOOPMODE_RELATIVE:
+            return e.offsetValue * e.repeatCount + I;
+        }
+        break;
+      }
+      case a.ANIMATIONTYPE_QUATERNION: {
+        const I = f ? this.quaternionInterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.quaternionInterpolateFunction(c, u, O);
+        switch (e.loopMode) {
+          case a.ANIMATIONLOOPMODE_CYCLE:
+          case a.ANIMATIONLOOPMODE_CONSTANT:
+          case a.ANIMATIONLOOPMODE_YOYO:
+            return I;
+          case a.ANIMATIONLOOPMODE_RELATIVE:
+            return I.addInPlace(e.offsetValue.scale(e.repeatCount));
+        }
+        return I;
+      }
+      case a.ANIMATIONTYPE_VECTOR3: {
+        const I = f ? this.vector3InterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.vector3InterpolateFunction(c, u, O);
+        switch (e.loopMode) {
+          case a.ANIMATIONLOOPMODE_CYCLE:
+          case a.ANIMATIONLOOPMODE_CONSTANT:
+          case a.ANIMATIONLOOPMODE_YOYO:
+            return I;
+          case a.ANIMATIONLOOPMODE_RELATIVE:
+            return I.add(e.offsetValue.scale(e.repeatCount));
+        }
+        break;
+      }
+      case a.ANIMATIONTYPE_VECTOR2: {
+        const I = f ? this.vector2InterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.vector2InterpolateFunction(c, u, O);
+        switch (e.loopMode) {
+          case a.ANIMATIONLOOPMODE_CYCLE:
+          case a.ANIMATIONLOOPMODE_CONSTANT:
+          case a.ANIMATIONLOOPMODE_YOYO:
+            return I;
+          case a.ANIMATIONLOOPMODE_RELATIVE:
+            return I.add(e.offsetValue.scale(e.repeatCount));
+        }
+        break;
+      }
+      case a.ANIMATIONTYPE_SIZE: {
+        switch (e.loopMode) {
+          case a.ANIMATIONLOOPMODE_CYCLE:
+          case a.ANIMATIONLOOPMODE_CONSTANT:
+          case a.ANIMATIONLOOPMODE_YOYO:
+            return this.sizeInterpolateFunction(c, u, O);
+          case a.ANIMATIONLOOPMODE_RELATIVE:
+            return this.sizeInterpolateFunction(c, u, O).add(e.offsetValue.scale(e.repeatCount));
+        }
+        break;
+      }
+      case a.ANIMATIONTYPE_COLOR3: {
+        const I = f ? this.color3InterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.color3InterpolateFunction(c, u, O);
+        switch (e.loopMode) {
+          case a.ANIMATIONLOOPMODE_CYCLE:
+          case a.ANIMATIONLOOPMODE_CONSTANT:
+          case a.ANIMATIONLOOPMODE_YOYO:
+            return I;
+          case a.ANIMATIONLOOPMODE_RELATIVE:
+            return I.add(e.offsetValue.scale(e.repeatCount));
+        }
+        break;
+      }
+      case a.ANIMATIONTYPE_COLOR4: {
+        const I = f ? this.color4InterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.color4InterpolateFunction(c, u, O);
+        switch (e.loopMode) {
+          case a.ANIMATIONLOOPMODE_CYCLE:
+          case a.ANIMATIONLOOPMODE_CONSTANT:
+          case a.ANIMATIONLOOPMODE_YOYO:
+            return I;
+          case a.ANIMATIONLOOPMODE_RELATIVE:
+            return I.add(e.offsetValue.scale(e.repeatCount));
+        }
+        break;
+      }
+      case a.ANIMATIONTYPE_MATRIX: {
+        switch (e.loopMode) {
+          case a.ANIMATIONLOOPMODE_CYCLE:
+          case a.ANIMATIONLOOPMODE_CONSTANT:
+          case a.ANIMATIONLOOPMODE_YOYO:
+            return a.AllowMatricesInterpolation ? this.matrixInterpolateFunction(c, u, O, e.workValue) : c;
+          case a.ANIMATIONLOOPMODE_RELATIVE:
+            return c;
+        }
+        break;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Defines the function to use to interpolate matrices
+   * @param startValue defines the start matrix
+   * @param endValue defines the end matrix
+   * @param gradient defines the gradient between both matrices
+   * @param result defines an optional target matrix where to store the interpolation
+   * @returns the interpolated matrix
+   */
+  matrixInterpolateFunction(t, e, s, i) {
+    return a.AllowMatrixDecomposeForInterpolation ? i ? (P.DecomposeLerpToRef(t, e, s, i), i) : P.DecomposeLerp(t, e, s) : i ? (P.LerpToRef(t, e, s, i), i) : P.Lerp(t, e, s);
+  }
+  /**
+   * Makes a copy of the animation
+   * @returns Cloned animation
+   */
+  clone() {
+    const t = new a(this.name, this.targetPropertyPath.join("."), this.framePerSecond, this.dataType, this.loopMode);
+    if (t.enableBlending = this.enableBlending, t.blendingSpeed = this.blendingSpeed, this._keys && t.setKeys(this._keys), this._ranges) {
+      t._ranges = {};
+      for (const e in this._ranges) {
+        const s = this._ranges[e];
+        s && (t._ranges[e] = s.clone());
+      }
+    }
+    return t;
+  }
+  /**
+   * Sets the key frames of the animation
+   * @param values The animation key frames to set
+   */
+  setKeys(t) {
+    this._keys = t.slice(0);
+  }
+  /**
+   * Serializes the animation to an object
+   * @returns Serialized object
+   */
+  serialize() {
+    const t = {};
+    t.name = this.name, t.property = this.targetProperty, t.framePerSecond = this.framePerSecond, t.dataType = this.dataType, t.loopBehavior = this.loopMode, t.enableBlending = this.enableBlending, t.blendingSpeed = this.blendingSpeed;
+    const e = this.dataType;
+    t.keys = [];
+    const s = this.getKeys();
+    for (let i = 0; i < s.length; i++) {
+      const r = s[i], n = {};
+      switch (n.frame = r.frame, e) {
+        case a.ANIMATIONTYPE_FLOAT:
+          n.values = [r.value], r.inTangent !== void 0 && n.values.push(r.inTangent), r.outTangent !== void 0 && (r.inTangent === void 0 && n.values.push(void 0), n.values.push(r.outTangent)), r.interpolation !== void 0 && (r.inTangent === void 0 && n.values.push(void 0), r.outTangent === void 0 && n.values.push(void 0), n.values.push(r.interpolation));
+          break;
+        case a.ANIMATIONTYPE_QUATERNION:
+        case a.ANIMATIONTYPE_MATRIX:
+        case a.ANIMATIONTYPE_VECTOR3:
+        case a.ANIMATIONTYPE_COLOR3:
+        case a.ANIMATIONTYPE_COLOR4:
+          n.values = r.value.asArray(), r.inTangent != null && n.values.push(r.inTangent.asArray()), r.outTangent != null && (r.inTangent === void 0 && n.values.push(void 0), n.values.push(r.outTangent.asArray())), r.interpolation !== void 0 && (r.inTangent === void 0 && n.values.push(void 0), r.outTangent === void 0 && n.values.push(void 0), n.values.push(r.interpolation));
+          break;
+      }
+      t.keys.push(n);
+    }
+    t.ranges = [];
+    for (const i in this._ranges) {
+      const r = this._ranges[i];
+      if (!r)
+        continue;
+      const n = {};
+      n.name = i, n.from = r.from, n.to = r.to, t.ranges.push(n);
+    }
+    return t;
+  }
+  /**
+   * @internal
+   */
+  static _UniversalLerp(t, e, s) {
+    const i = t.constructor;
+    return i.Lerp ? i.Lerp(t, e, s) : i.Slerp ? i.Slerp(t, e, s) : t.toFixed ? t * (1 - s) + s * e : e;
+  }
+  /**
+   * Parses an animation object and creates an animation
+   * @param parsedAnimation Parsed animation object
+   * @returns Animation object
+   */
+  static Parse(t) {
+    const e = new a(t.name, t.property, t.framePerSecond, t.dataType, t.loopBehavior), s = t.dataType, i = [];
+    let r, n;
+    for (t.enableBlending && (e.enableBlending = t.enableBlending), t.blendingSpeed && (e.blendingSpeed = t.blendingSpeed), n = 0; n < t.keys.length; n++) {
+      const o = t.keys[n];
+      let c, u, f;
+      switch (s) {
+        case a.ANIMATIONTYPE_FLOAT:
+          r = o.values[0], o.values.length >= 2 && (c = o.values[1]), o.values.length >= 3 && (u = o.values[2]), o.values.length >= 4 && (f = o.values[3]);
+          break;
+        case a.ANIMATIONTYPE_QUATERNION:
+          if (r = g.FromArray(o.values), o.values.length >= 8) {
+            const O = g.FromArray(o.values.slice(4, 8));
+            O.equals(g.Zero()) || (c = O);
+          }
+          if (o.values.length >= 12) {
+            const O = g.FromArray(o.values.slice(8, 12));
+            O.equals(g.Zero()) || (u = O);
+          }
+          o.values.length >= 13 && (f = o.values[12]);
+          break;
+        case a.ANIMATIONTYPE_MATRIX:
+          r = P.FromArray(o.values), o.values.length >= 17 && (f = o.values[16]);
+          break;
+        case a.ANIMATIONTYPE_COLOR3:
+          r = v.FromArray(o.values), o.values[3] && (c = v.FromArray(o.values[3])), o.values[4] && (u = v.FromArray(o.values[4])), o.values[5] && (f = o.values[5]);
+          break;
+        case a.ANIMATIONTYPE_COLOR4:
+          r = M.FromArray(o.values), o.values[4] && (c = M.FromArray(o.values[4])), o.values[5] && (u = M.FromArray(o.values[5])), o.values[6] && (f = M.FromArray(o.values[6]));
+          break;
+        case a.ANIMATIONTYPE_VECTOR3:
+        default:
+          r = y.FromArray(o.values), o.values[3] && (c = y.FromArray(o.values[3])), o.values[4] && (u = y.FromArray(o.values[4])), o.values[5] && (f = o.values[5]);
+          break;
+      }
+      const l = {};
+      l.frame = o.frame, l.value = r, c != null && (l.inTangent = c), u != null && (l.outTangent = u), f != null && (l.interpolation = f), i.push(l);
+    }
+    if (e.setKeys(i), t.ranges)
+      for (n = 0; n < t.ranges.length; n++)
+        r = t.ranges[n], e.createRange(r.name, r.from, r.to);
+    return e;
+  }
+  /**
+   * Appends the serialized animations from the source animations
+   * @param source Source containing the animations
+   * @param destination Target to store the animations
+   */
+  static AppendSerializedAnimations(t, e) {
+    F.AppendSerializedAnimations(t, e);
+  }
+  /**
+   * Creates a new animation or an array of animations from a snippet saved in a remote file
+   * @param name defines the name of the animation to create (can be null or empty to use the one from the json data)
+   * @param url defines the url to load from
+   * @returns a promise that will resolve to the new animation or an array of animations
+   */
+  static ParseFromFileAsync(t, e) {
+    return new Promise((s, i) => {
+      const r = new m();
+      r.addEventListener("readystatechange", () => {
+        if (r.readyState == 4)
+          if (r.status == 200) {
+            let n = JSON.parse(r.responseText);
+            if (n.animations && (n = n.animations), n.length) {
+              const o = new Array();
+              for (const c of n)
+                o.push(this.Parse(c));
+              s(o);
+            } else {
+              const o = this.Parse(n);
+              t && (o.name = t), s(o);
+            }
+          } else
+            i("Unable to load the animation");
+      }), r.open("GET", e), r.send();
+    });
+  }
+  /**
+   * Creates an animation or an array of animations from a snippet saved by the Inspector
+   * @param snippetId defines the snippet to load
+   * @returns a promise that will resolve to the new animation or a new array of animations
+   */
+  static ParseFromSnippetAsync(t) {
+    return new Promise((e, s) => {
+      const i = new m();
+      i.addEventListener("readystatechange", () => {
+        if (i.readyState == 4)
+          if (i.status == 200) {
+            const r = JSON.parse(JSON.parse(i.responseText).jsonPayload);
+            if (r.animations) {
+              const n = JSON.parse(r.animations), o = new Array();
+              for (const c of n.animations) {
+                const u = this.Parse(c);
+                u.snippetId = t, o.push(u);
+              }
+              e(o);
+            } else {
+              const n = JSON.parse(r.animation), o = this.Parse(n);
+              o.snippetId = t, e(o);
+            }
+          } else
+            s("Unable to load the snippet " + t);
+      }), i.open("GET", this.SnippetUrl + "/" + t.replace(/#/g, "/")), i.send();
+    });
+  }
+}
+a._UniqueIdGenerator = 0;
+a.AllowMatricesInterpolation = !1;
+a.AllowMatrixDecomposeForInterpolation = !0;
+a.SnippetUrl = "https://snippet.babylonjs.com";
+a.ANIMATIONTYPE_FLOAT = 0;
+a.ANIMATIONTYPE_VECTOR3 = 1;
+a.ANIMATIONTYPE_QUATERNION = 2;
+a.ANIMATIONTYPE_MATRIX = 3;
+a.ANIMATIONTYPE_COLOR3 = 4;
+a.ANIMATIONTYPE_COLOR4 = 7;
+a.ANIMATIONTYPE_VECTOR2 = 5;
+a.ANIMATIONTYPE_SIZE = 6;
+a.ANIMATIONLOOPMODE_RELATIVE = 0;
+a.ANIMATIONLOOPMODE_CYCLE = 1;
+a.ANIMATIONLOOPMODE_CONSTANT = 2;
+a.ANIMATIONLOOPMODE_YOYO = 4;
+a.CreateFromSnippetAsync = a.ParseFromSnippetAsync;
+b("BABYLON.Animation", a);
+w._AnimationRangeFactory = (V, t, e) => new R(V, t, e);
+export {
+  a as Animation
+};