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

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

@@ -1,281 +0,0 @@
-import { Quaternion as T, Vector3 as P, Vector2 as y, Matrix as d } from "../Maths/math.vector.esm.js";
-import { Color3 as F } from "../Maths/math.color.esm.js";
-import { Animation as r } from "./animation.esm.js";
-import { Size as b } from "../Maths/math.size.esm.js";
-const v = Object.freeze(new T(0, 0, 0, 0)), I = Object.freeze(P.Zero()), N = Object.freeze(y.Zero()), M = Object.freeze(b.Zero()), C = Object.freeze(F.Black());
-class Y {
-  /**
-   * Gets the current frame of the runtime animation
-   */
-  get currentFrame() {
-    return this._currentFrame;
-  }
-  /**
-   * Gets the weight of the runtime animation
-   */
-  get weight() {
-    return this._weight;
-  }
-  /**
-   * Gets the current value of the runtime animation
-   */
-  get currentValue() {
-    return this._currentValue;
-  }
-  /**
-   * Gets or sets the target path of the runtime animation
-   */
-  get targetPath() {
-    return this._targetPath;
-  }
-  /**
-   * Gets the actual target of the runtime animation
-   */
-  get target() {
-    return this._currentActiveTarget;
-  }
-  /**
-   * Gets the additive state of the runtime animation
-   */
-  get isAdditive() {
-    return this._host && this._host.isAdditive;
-  }
-  /**
-   * Create a new RuntimeAnimation object
-   * @param target defines the target of the animation
-   * @param animation defines the source animation object
-   * @param scene defines the hosting scene
-   * @param host defines the initiating Animatable
-   */
-  constructor(i, t, e, n) {
-    if (this._events = new Array(), this._currentFrame = 0, this._originalValue = new Array(), this._originalBlendValue = null, this._offsetsCache = {}, this._highLimitsCache = {}, this._stopped = !1, this._blendingFactor = 0, this._currentValue = null, this._currentActiveTarget = null, this._directTarget = null, this._targetPath = "", this._weight = 1, this._absoluteFrameOffset = 0, this._previousElapsedTime = 0, this._previousAbsoluteFrame = 0, this._targetIsArray = !1, this._animation = t, this._target = i, this._scene = e, this._host = n, this._activeTargets = [], t._runtimeAnimations.push(this), this._animationState = {
-      key: 0,
-      repeatCount: 0,
-      loopMode: this._getCorrectLoopMode()
-    }, this._animation.dataType === r.ANIMATIONTYPE_MATRIX && (this._animationState.workValue = d.Zero()), this._keys = this._animation.getKeys(), this._minFrame = this._keys[0].frame, this._maxFrame = this._keys[this._keys.length - 1].frame, this._minValue = this._keys[0].value, this._maxValue = this._keys[this._keys.length - 1].value, this._minFrame !== 0) {
-      const l = { frame: 0, value: this._minValue };
-      this._keys.splice(0, 0, l);
-    }
-    if (this._target instanceof Array) {
-      let l = 0;
-      for (const h of this._target)
-        this._preparePath(h, l), this._getOriginalValues(l), l++;
-      this._targetIsArray = !0;
-    } else
-      this._preparePath(this._target), this._getOriginalValues(), this._targetIsArray = !1, this._directTarget = this._activeTargets[0];
-    const a = t.getEvents();
-    a && a.length > 0 && a.forEach((l) => {
-      this._events.push(l._clone());
-    }), this._enableBlending = i && i.animationPropertiesOverride ? i.animationPropertiesOverride.enableBlending : this._animation.enableBlending;
-  }
-  _preparePath(i, t = 0) {
-    const e = this._animation.targetPropertyPath;
-    if (e.length > 1) {
-      let n = i[e[0]];
-      for (let a = 1; a < e.length - 1; a++)
-        n = n[e[a]];
-      this._targetPath = e[e.length - 1], this._activeTargets[t] = n;
-    } else
-      this._targetPath = e[0], this._activeTargets[t] = i;
-  }
-  /**
-   * Gets the animation from the runtime animation
-   */
-  get animation() {
-    return this._animation;
-  }
-  /**
-   * Resets the runtime animation to the beginning
-   * @param restoreOriginal defines whether to restore the target property to the original value
-   */
-  reset(i = !1) {
-    if (i)
-      if (this._target instanceof Array) {
-        let t = 0;
-        for (const e of this._target)
-          this._originalValue[t] !== void 0 && this._setValue(e, this._activeTargets[t], this._originalValue[t], -1, t), t++;
-      } else
-        this._originalValue[0] !== void 0 && this._setValue(this._target, this._directTarget, this._originalValue[0], -1, 0);
-    this._offsetsCache = {}, this._highLimitsCache = {}, this._currentFrame = 0, this._blendingFactor = 0;
-    for (let t = 0; t < this._events.length; t++)
-      this._events[t].isDone = !1;
-  }
-  /**
-   * Specifies if the runtime animation is stopped
-   * @returns Boolean specifying if the runtime animation is stopped
-   */
-  isStopped() {
-    return this._stopped;
-  }
-  /**
-   * Disposes of the runtime animation
-   */
-  dispose() {
-    const i = this._animation.runtimeAnimations.indexOf(this);
-    i > -1 && this._animation.runtimeAnimations.splice(i, 1);
-  }
-  /**
-   * Apply the interpolated value to the target
-   * @param currentValue defines the value computed by the animation
-   * @param weight defines the weight to apply to this value (Defaults to 1.0)
-   */
-  setValue(i, t) {
-    if (this._targetIsArray) {
-      for (let e = 0; e < this._target.length; e++) {
-        const n = this._target[e];
-        this._setValue(n, this._activeTargets[e], i, t, e);
-      }
-      return;
-    }
-    this._setValue(this._target, this._directTarget, i, t, 0);
-  }
-  _getOriginalValues(i = 0) {
-    let t;
-    const e = this._activeTargets[i];
-    e.getRestPose && this._targetPath === "_matrix" ? t = e.getRestPose() : t = e[this._targetPath], t && t.clone ? this._originalValue[i] = t.clone() : this._originalValue[i] = t;
-  }
-  _setValue(i, t, e, n, a) {
-    if (this._currentActiveTarget = t, this._weight = n, this._enableBlending && this._blendingFactor <= 1) {
-      if (!this._originalBlendValue) {
-        const h = t[this._targetPath];
-        h.clone ? this._originalBlendValue = h.clone() : this._originalBlendValue = h;
-      }
-      this._originalBlendValue.m ? r.AllowMatrixDecomposeForInterpolation ? this._currentValue ? d.DecomposeLerpToRef(this._originalBlendValue, e, this._blendingFactor, this._currentValue) : this._currentValue = d.DecomposeLerp(this._originalBlendValue, e, this._blendingFactor) : this._currentValue ? d.LerpToRef(this._originalBlendValue, e, this._blendingFactor, this._currentValue) : this._currentValue = d.Lerp(this._originalBlendValue, e, this._blendingFactor) : this._currentValue = r._UniversalLerp(this._originalBlendValue, e, this._blendingFactor);
-      const l = i && i.animationPropertiesOverride ? i.animationPropertiesOverride.blendingSpeed : this._animation.blendingSpeed;
-      this._blendingFactor += l;
-    } else
-      this._currentValue ? this._currentValue.copyFrom ? this._currentValue.copyFrom(e) : this._currentValue = e : e != null && e.clone ? this._currentValue = e.clone() : this._currentValue = e;
-    n !== -1 ? this._scene._registerTargetForLateAnimationBinding(this, this._originalValue[a]) : t[this._targetPath] = this._currentValue, i.markAsDirty && i.markAsDirty(this._animation.targetProperty);
-  }
-  /**
-   * Gets the loop pmode of the runtime animation
-   * @returns Loop Mode
-   */
-  _getCorrectLoopMode() {
-    return this._target && this._target.animationPropertiesOverride ? this._target.animationPropertiesOverride.loopMode : this._animation.loopMode;
-  }
-  /**
-   * Move the current animation to a given frame
-   * @param frame defines the frame to move to
-   */
-  goToFrame(i) {
-    const t = this._animation.getKeys();
-    i < t[0].frame ? i = t[0].frame : i > t[t.length - 1].frame && (i = t[t.length - 1].frame);
-    const e = this._events;
-    if (e.length)
-      for (let a = 0; a < e.length; a++)
-        e[a].onlyOnce || (e[a].isDone = e[a].frame < i);
-    this._currentFrame = i;
-    const n = this._animation._interpolate(i, this._animationState);
-    this.setValue(n, -1);
-  }
-  /**
-   * @internal Internal use only
-   */
-  _prepareForSpeedRatioChange(i) {
-    const t = this._previousElapsedTime * (this._animation.framePerSecond * i) / 1e3;
-    this._absoluteFrameOffset = this._previousAbsoluteFrame - t;
-  }
-  /**
-   * Execute the current animation
-   * @param elapsedTimeSinceAnimationStart defines the elapsed time (in milliseconds) since the animation was started
-   * @param from defines the lower frame of the animation range
-   * @param to defines the upper frame of the animation range
-   * @param loop defines if the current animation must loop
-   * @param speedRatio defines the current speed ratio
-   * @param weight defines the weight of the animation (default is -1 so no weight)
-   * @returns a boolean indicating if the animation is running
-   */
-  animate(i, t, e, n, a, l = -1) {
-    const h = this._animation, V = h.targetPropertyPath;
-    if (!V || V.length < 1)
-      return this._stopped = !0, !1;
-    let p = !0;
-    (t < this._minFrame || t > this._maxFrame) && (t = this._minFrame), (e < this._minFrame || e > this._maxFrame) && (e = this._maxFrame);
-    const _ = e - t;
-    let f, u = i * (h.framePerSecond * a) / 1e3 + this._absoluteFrameOffset, O = 0;
-    if (n && this._animationState.loopMode === r.ANIMATIONLOOPMODE_YOYO) {
-      const s = (u - t) / _;
-      u = Math.abs(Math.sin(s * Math.PI)) * _ + t;
-    }
-    if (this._previousElapsedTime = i, this._previousAbsoluteFrame = u, !n && e >= t && u >= _)
-      p = !1, O = h._getKeyValue(this._maxValue);
-    else if (!n && t >= e && u <= _)
-      p = !1, O = h._getKeyValue(this._minValue);
-    else if (this._animationState.loopMode !== r.ANIMATIONLOOPMODE_CYCLE) {
-      const s = e.toString() + t.toString();
-      if (!this._offsetsCache[s]) {
-        this._animationState.repeatCount = 0, this._animationState.loopMode = r.ANIMATIONLOOPMODE_CYCLE;
-        const o = h._interpolate(t, this._animationState), m = h._interpolate(e, this._animationState);
-        switch (this._animationState.loopMode = this._getCorrectLoopMode(), h.dataType) {
-          case r.ANIMATIONTYPE_FLOAT:
-            this._offsetsCache[s] = m - o;
-            break;
-          case r.ANIMATIONTYPE_QUATERNION:
-            this._offsetsCache[s] = m.subtract(o);
-            break;
-          case r.ANIMATIONTYPE_VECTOR3:
-            this._offsetsCache[s] = m.subtract(o);
-            break;
-          case r.ANIMATIONTYPE_VECTOR2:
-            this._offsetsCache[s] = m.subtract(o);
-            break;
-          case r.ANIMATIONTYPE_SIZE:
-            this._offsetsCache[s] = m.subtract(o);
-            break;
-          case r.ANIMATIONTYPE_COLOR3:
-            this._offsetsCache[s] = m.subtract(o);
-            break;
-        }
-        this._highLimitsCache[s] = m;
-      }
-      O = this._highLimitsCache[s], f = this._offsetsCache[s];
-    }
-    if (f === void 0)
-      switch (h.dataType) {
-        case r.ANIMATIONTYPE_FLOAT:
-          f = 0;
-          break;
-        case r.ANIMATIONTYPE_QUATERNION:
-          f = v;
-          break;
-        case r.ANIMATIONTYPE_VECTOR3:
-          f = I;
-          break;
-        case r.ANIMATIONTYPE_VECTOR2:
-          f = N;
-          break;
-        case r.ANIMATIONTYPE_SIZE:
-          f = M;
-          break;
-        case r.ANIMATIONTYPE_COLOR3:
-          f = C;
-      }
-    let g;
-    if (this._host && this._host.syncRoot) {
-      const s = this._host.syncRoot, o = (s.masterFrame - s.fromFrame) / (s.toFrame - s.fromFrame);
-      g = t + _ * o;
-    } else
-      u > 0 && t > e || u < 0 && t < e ? g = p && _ !== 0 ? e + u % _ : t : g = p && _ !== 0 ? t + u % _ : e;
-    const c = this._events;
-    if (a > 0 && this.currentFrame > g || a < 0 && this.currentFrame < g) {
-      this._onLoop();
-      for (let s = 0; s < c.length; s++)
-        c[s].onlyOnce || (c[s].isDone = !1);
-      this._animationState.key = a > 0 ? 0 : h.getKeys().length - 1;
-    }
-    this._currentFrame = g, this._animationState.repeatCount = _ === 0 ? 0 : u / _ >> 0, this._animationState.highLimitValue = O, this._animationState.offsetValue = f;
-    const A = h._interpolate(g, this._animationState);
-    if (this.setValue(A, l), c.length) {
-      for (let s = 0; s < c.length; s++)
-        if (_ > 0 && g >= c[s].frame && c[s].frame >= t || _ < 0 && g <= c[s].frame && c[s].frame <= t) {
-          const o = c[s];
-          o.isDone || (o.onlyOnce && (c.splice(s, 1), s--), o.isDone = !0, o.action(g));
-        }
-    }
-    return p || (this._stopped = !0), p;
-  }
-}
-export {
-  Y as RuntimeAnimation
-};