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

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

@@ -0,0 +1,478 @@
+import { Animation as w } from "./animation.esm.js";
+import { RuntimeAnimation as O } from "./runtimeAnimation.esm.js";
+import { Observable as x } from "../Misc/observable.esm.js";
+import { Scene as g } from "../scene.esm.js";
+import { TmpVectors as d, Quaternion as y, Vector3 as R, Matrix as D } from "../Maths/math.vector.esm.js";
+import { PrecisionDate as W } from "../Misc/precisionDate.esm.js";
+import { Bone as P } from "../Bones/bone.esm.js";
+class V {
+  /**
+   * Gets the root Animatable used to synchronize and normalize animations
+   */
+  get syncRoot() {
+    return this._syncRoot;
+  }
+  /**
+   * Gets the current frame of the first RuntimeAnimation
+   * Used to synchronize Animatables
+   */
+  get masterFrame() {
+    return this._runtimeAnimations.length === 0 ? 0 : this._runtimeAnimations[0].currentFrame;
+  }
+  /**
+   * Gets or sets the animatable weight (-1.0 by default meaning not weighted)
+   */
+  get weight() {
+    return this._weight;
+  }
+  set weight(n) {
+    if (n === -1) {
+      this._weight = -1;
+      return;
+    }
+    this._weight = Math.min(Math.max(n, 0), 1);
+  }
+  /**
+   * Gets or sets the speed ratio to apply to the animatable (1.0 by default)
+   */
+  get speedRatio() {
+    return this._speedRatio;
+  }
+  set speedRatio(n) {
+    for (let t = 0; t < this._runtimeAnimations.length; t++)
+      this._runtimeAnimations[t]._prepareForSpeedRatioChange(n);
+    this._speedRatio = n, this._goToFrame !== null && this.goToFrame(this._goToFrame);
+  }
+  /**
+   * Creates a new Animatable
+   * @param scene defines the hosting scene
+   * @param target defines the target object
+   * @param fromFrame defines the starting frame number (default is 0)
+   * @param toFrame defines the ending frame number (default is 100)
+   * @param loopAnimation defines if the animation must loop (default is false)
+   * @param speedRatio defines the factor to apply to animation speed (default is 1)
+   * @param onAnimationEnd defines a callback to call when animation ends if it is not looping
+   * @param animations defines a group of animation to add to the new Animatable
+   * @param onAnimationLoop defines a callback to call when animation loops
+   * @param isAdditive defines whether the animation should be evaluated additively
+   * @param playOrder defines the order in which this animatable should be processed in the list of active animatables (default: 0)
+   */
+  constructor(n, t, e = 0, a = 100, s = !1, o = 1, l, m, r, u = !1, h = 0) {
+    this.target = t, this.fromFrame = e, this.toFrame = a, this.loopAnimation = s, this.onAnimationEnd = l, this.onAnimationLoop = r, this.isAdditive = u, this.playOrder = h, this._localDelayOffset = null, this._pausedDelay = null, this._manualJumpDelay = null, this._runtimeAnimations = new Array(), this._paused = !1, this._speedRatio = 1, this._weight = -1, this._syncRoot = null, this._frameToSyncFromJump = null, this._goToFrame = null, this.disposeOnEnd = !0, this.animationStarted = !1, this.onAnimationEndObservable = new x(), this.onAnimationLoopObservable = new x(), this._scene = n, m && this.appendAnimations(t, m), this._speedRatio = o, n._activeAnimatables.push(this);
+  }
+  // Methods
+  /**
+   * Synchronize and normalize current Animatable with a source Animatable
+   * This is useful when using animation weights and when animations are not of the same length
+   * @param root defines the root Animatable to synchronize with (null to stop synchronizing)
+   * @returns the current Animatable
+   */
+  syncWith(n) {
+    if (this._syncRoot = n, n) {
+      const t = this._scene._activeAnimatables.indexOf(this);
+      t > -1 && (this._scene._activeAnimatables.splice(t, 1), this._scene._activeAnimatables.push(this));
+    }
+    return this;
+  }
+  /**
+   * Gets the list of runtime animations
+   * @returns an array of RuntimeAnimation
+   */
+  getAnimations() {
+    return this._runtimeAnimations;
+  }
+  /**
+   * Adds more animations to the current animatable
+   * @param target defines the target of the animations
+   * @param animations defines the new animations to add
+   */
+  appendAnimations(n, t) {
+    for (let e = 0; e < t.length; e++) {
+      const a = t[e], s = new O(n, a, this._scene, this);
+      s._onLoop = () => {
+        this.onAnimationLoopObservable.notifyObservers(this), this.onAnimationLoop && this.onAnimationLoop();
+      }, this._runtimeAnimations.push(s);
+    }
+  }
+  /**
+   * Gets the source animation for a specific property
+   * @param property defines the property to look for
+   * @returns null or the source animation for the given property
+   */
+  getAnimationByTargetProperty(n) {
+    const t = this._runtimeAnimations;
+    for (let e = 0; e < t.length; e++)
+      if (t[e].animation.targetProperty === n)
+        return t[e].animation;
+    return null;
+  }
+  /**
+   * Gets the runtime animation for a specific property
+   * @param property defines the property to look for
+   * @returns null or the runtime animation for the given property
+   */
+  getRuntimeAnimationByTargetProperty(n) {
+    const t = this._runtimeAnimations;
+    for (let e = 0; e < t.length; e++)
+      if (t[e].animation.targetProperty === n)
+        return t[e];
+    return null;
+  }
+  /**
+   * Resets the animatable to its original state
+   */
+  reset() {
+    const n = this._runtimeAnimations;
+    for (let t = 0; t < n.length; t++)
+      n[t].reset(!0);
+    this._localDelayOffset = null, this._pausedDelay = null;
+  }
+  /**
+   * Allows the animatable to blend with current running animations
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-blending
+   * @param blendingSpeed defines the blending speed to use
+   */
+  enableBlending(n) {
+    const t = this._runtimeAnimations;
+    for (let e = 0; e < t.length; e++)
+      t[e].animation.enableBlending = !0, t[e].animation.blendingSpeed = n;
+  }
+  /**
+   * Disable animation blending
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-blending
+   */
+  disableBlending() {
+    const n = this._runtimeAnimations;
+    for (let t = 0; t < n.length; t++)
+      n[t].animation.enableBlending = !1;
+  }
+  /**
+   * Jump directly to a given frame
+   * @param frame defines the frame to jump to
+   */
+  goToFrame(n) {
+    var t;
+    const e = this._runtimeAnimations;
+    if (e[0]) {
+      const a = e[0].animation.framePerSecond;
+      this._frameToSyncFromJump = (t = this._frameToSyncFromJump) !== null && t !== void 0 ? t : e[0].currentFrame;
+      const s = this.speedRatio === 0 ? 0 : (n - this._frameToSyncFromJump) / a * 1e3 / this.speedRatio;
+      this._manualJumpDelay = -s;
+    }
+    for (let a = 0; a < e.length; a++)
+      e[a].goToFrame(n);
+    this._goToFrame = n;
+  }
+  /**
+   * Pause the animation
+   */
+  pause() {
+    this._paused || (this._paused = !0);
+  }
+  /**
+   * Restart the animation
+   */
+  restart() {
+    this._paused = !1;
+  }
+  _raiseOnAnimationEnd() {
+    this.onAnimationEnd && this.onAnimationEnd(), this.onAnimationEndObservable.notifyObservers(this);
+  }
+  /**
+   * Stop and delete the current animation
+   * @param animationName defines a string used to only stop some of the runtime animations instead of all
+   * @param targetMask a function that determines if the animation should be stopped based on its target (all animations will be stopped if both this and animationName are empty)
+   * @param useGlobalSplice if true, the animatables will be removed by the caller of this function (false by default)
+   */
+  stop(n, t, e = !1) {
+    if (n || t) {
+      const a = this._scene._activeAnimatables.indexOf(this);
+      if (a > -1) {
+        const s = this._runtimeAnimations;
+        for (let o = s.length - 1; o >= 0; o--) {
+          const l = s[o];
+          n && l.animation.name != n || t && !t(l.target) || (l.dispose(), s.splice(o, 1));
+        }
+        s.length == 0 && (e || this._scene._activeAnimatables.splice(a, 1), this._raiseOnAnimationEnd());
+      }
+    } else {
+      const a = this._scene._activeAnimatables.indexOf(this);
+      if (a > -1) {
+        e || this._scene._activeAnimatables.splice(a, 1);
+        const s = this._runtimeAnimations;
+        for (let o = 0; o < s.length; o++)
+          s[o].dispose();
+        this._runtimeAnimations.length = 0, this._raiseOnAnimationEnd();
+      }
+    }
+  }
+  /**
+   * Wait asynchronously for the animation to end
+   * @returns a promise which will be fulfilled when the animation ends
+   */
+  waitAsync() {
+    return new Promise((n) => {
+      this.onAnimationEndObservable.add(() => {
+        n(this);
+      }, void 0, void 0, this, !0);
+    });
+  }
+  /**
+   * @internal
+   */
+  _animate(n) {
+    if (this._paused)
+      return this.animationStarted = !1, this._pausedDelay === null && (this._pausedDelay = n), !0;
+    if (this._localDelayOffset === null ? (this._localDelayOffset = n, this._pausedDelay = null) : this._pausedDelay !== null && (this._localDelayOffset += n - this._pausedDelay, this._pausedDelay = null), this._manualJumpDelay !== null && (this._localDelayOffset += this._manualJumpDelay, this._manualJumpDelay = null, this._frameToSyncFromJump = null), this._goToFrame = null, this._weight === 0)
+      return !0;
+    let t = !1;
+    const e = this._runtimeAnimations;
+    let a;
+    for (a = 0; a < e.length; a++) {
+      const o = e[a].animate(n - this._localDelayOffset, this.fromFrame, this.toFrame, this.loopAnimation, this._speedRatio, this._weight);
+      t = t || o;
+    }
+    if (this.animationStarted = t, !t) {
+      if (this.disposeOnEnd)
+        for (a = this._scene._activeAnimatables.indexOf(this), this._scene._activeAnimatables.splice(a, 1), a = 0; a < e.length; a++)
+          e[a].dispose();
+      this._raiseOnAnimationEnd(), this.disposeOnEnd && (this.onAnimationEnd = null, this.onAnimationLoop = null, this.onAnimationLoopObservable.clear(), this.onAnimationEndObservable.clear());
+    }
+    return t;
+  }
+}
+g.prototype._animate = function() {
+  if (!this.animationsEnabled)
+    return;
+  const i = W.Now;
+  if (!this._animationTimeLast) {
+    if (this._pendingData.length > 0)
+      return;
+    this._animationTimeLast = i;
+  }
+  this.deltaTime = this.useConstantAnimationDeltaTime ? 16 : (i - this._animationTimeLast) * this.animationTimeScale, this._animationTimeLast = i;
+  const n = this._activeAnimatables;
+  if (n.length === 0)
+    return;
+  this._animationTime += this.deltaTime;
+  const t = this._animationTime;
+  for (let e = 0; e < n.length; e++) {
+    const a = n[e];
+    !a._animate(t) && a.disposeOnEnd && e--;
+  }
+  this._processLateAnimationBindings();
+};
+g.prototype.sortActiveAnimatables = function() {
+  this._activeAnimatables.sort((i, n) => i.playOrder - n.playOrder);
+};
+g.prototype.beginWeightedAnimation = function(i, n, t, e = 1, a, s = 1, o, l, m, r, u = !1) {
+  const h = this.beginAnimation(i, n, t, a, s, o, l, !1, m, r, u);
+  return h.weight = e, h;
+};
+g.prototype.beginAnimation = function(i, n, t, e, a = 1, s, o, l = !0, m, r, u = !1) {
+  n > t && a > 0 && (a *= -1), l && this.stopAnimation(i, void 0, m), o || (o = new V(this, i, n, t, e, a, s, void 0, r, u));
+  const h = m ? m(i) : !0;
+  if (i.animations && h && o.appendAnimations(i, i.animations), i.getAnimatables) {
+    const c = i.getAnimatables();
+    for (let f = 0; f < c.length; f++)
+      this.beginAnimation(c[f], n, t, e, a, s, o, l, m, r);
+  }
+  return o.reset(), o;
+};
+g.prototype.beginHierarchyAnimation = function(i, n, t, e, a, s = 1, o, l, m = !0, r, u, h = !1) {
+  const c = i.getDescendants(n), f = [];
+  f.push(this.beginAnimation(i, t, e, a, s, o, l, m, r, void 0, h));
+  for (const A of c)
+    f.push(this.beginAnimation(A, t, e, a, s, o, l, m, r, void 0, h));
+  return f;
+};
+g.prototype.beginDirectAnimation = function(i, n, t, e, a, s, o, l, m = !1) {
+  if (s === void 0 && (s = 1), t > e && s > 0)
+    s *= -1;
+  else if (e > t && s < 0) {
+    const u = e;
+    e = t, t = u;
+  }
+  return new V(this, i, t, e, a, s, o, n, l, m);
+};
+g.prototype.beginDirectHierarchyAnimation = function(i, n, t, e, a, s, o, l, m, r = !1) {
+  const u = i.getDescendants(n), h = [];
+  h.push(this.beginDirectAnimation(i, t, e, a, s, o, l, m, r));
+  for (const c of u)
+    h.push(this.beginDirectAnimation(c, t, e, a, s, o, l, m, r));
+  return h;
+};
+g.prototype.getAnimatableByTarget = function(i) {
+  for (let n = 0; n < this._activeAnimatables.length; n++)
+    if (this._activeAnimatables[n].target === i)
+      return this._activeAnimatables[n];
+  return null;
+};
+g.prototype.getAllAnimatablesByTarget = function(i) {
+  const n = [];
+  for (let t = 0; t < this._activeAnimatables.length; t++)
+    this._activeAnimatables[t].target === i && n.push(this._activeAnimatables[t]);
+  return n;
+};
+g.prototype.stopAnimation = function(i, n, t) {
+  const e = this.getAllAnimatablesByTarget(i);
+  for (const a of e)
+    a.stop(n, t);
+};
+g.prototype.stopAllAnimations = function() {
+  if (this._activeAnimatables) {
+    for (let i = 0; i < this._activeAnimatables.length; i++)
+      this._activeAnimatables[i].stop(void 0, void 0, !0);
+    this._activeAnimatables.length = 0;
+  }
+  for (const i of this.animationGroups)
+    i.stop();
+};
+g.prototype._registerTargetForLateAnimationBinding = function(i, n) {
+  const t = i.target;
+  this._registeredForLateAnimationBindings.pushNoDuplicate(t), t._lateAnimationHolders || (t._lateAnimationHolders = {}), t._lateAnimationHolders[i.targetPath] || (t._lateAnimationHolders[i.targetPath] = {
+    totalWeight: 0,
+    totalAdditiveWeight: 0,
+    animations: [],
+    additiveAnimations: [],
+    originalValue: n
+  }), i.isAdditive ? (t._lateAnimationHolders[i.targetPath].additiveAnimations.push(i), t._lateAnimationHolders[i.targetPath].totalAdditiveWeight += i.weight) : (t._lateAnimationHolders[i.targetPath].animations.push(i), t._lateAnimationHolders[i.targetPath].totalWeight += i.weight);
+};
+g.prototype._processLateAnimationBindingsForMatrices = function(i) {
+  if (i.totalWeight === 0 && i.totalAdditiveWeight === 0)
+    return i.originalValue;
+  let n = 1;
+  const t = d.Vector3[0], e = d.Vector3[1], a = d.Quaternion[0];
+  let s = 0;
+  const o = i.animations[0], l = i.originalValue;
+  let m = 1, r = !1;
+  if (i.totalWeight < 1)
+    m = 1 - i.totalWeight, l.decompose(e, a, t);
+  else {
+    if (s = 1, n = i.totalWeight, m = o.weight / n, m == 1)
+      if (i.totalAdditiveWeight)
+        r = !0;
+      else
+        return o.currentValue;
+    o.currentValue.decompose(e, a, t);
+  }
+  if (!r) {
+    e.scaleInPlace(m), t.scaleInPlace(m), a.scaleInPlace(m);
+    for (let h = s; h < i.animations.length; h++) {
+      const c = i.animations[h];
+      if (c.weight === 0)
+        continue;
+      m = c.weight / n;
+      const f = d.Vector3[2], A = d.Vector3[3], p = d.Quaternion[1];
+      c.currentValue.decompose(A, p, f), A.scaleAndAddToRef(m, e), p.scaleAndAddToRef(y.Dot(a, p) > 0 ? m : -m, a), f.scaleAndAddToRef(m, t);
+    }
+    a.normalize();
+  }
+  for (let h = 0; h < i.additiveAnimations.length; h++) {
+    const c = i.additiveAnimations[h];
+    if (c.weight === 0)
+      continue;
+    const f = d.Vector3[2], A = d.Vector3[3], p = d.Quaternion[1];
+    c.currentValue.decompose(A, p, f), A.multiplyToRef(e, A), R.LerpToRef(e, A, c.weight, e), a.multiplyToRef(p, p), y.SlerpToRef(a, p, c.weight, a), f.scaleAndAddToRef(c.weight, t);
+  }
+  const u = o ? o._animationState.workValue : d.Matrix[0].clone();
+  return D.ComposeToRef(e, a, t, u), u;
+};
+g.prototype._processLateAnimationBindingsForQuaternions = function(i, n) {
+  if (i.totalWeight === 0 && i.totalAdditiveWeight === 0)
+    return n;
+  const t = i.animations[0], e = i.originalValue;
+  let a = n;
+  if (i.totalWeight === 0 && i.totalAdditiveWeight > 0)
+    a.copyFrom(e);
+  else if (i.animations.length === 1) {
+    if (y.SlerpToRef(e, t.currentValue, Math.min(1, i.totalWeight), a), i.totalAdditiveWeight === 0)
+      return a;
+  } else if (i.animations.length > 1) {
+    let s = 1, o, l;
+    if (i.totalWeight < 1) {
+      const r = 1 - i.totalWeight;
+      o = [], l = [], o.push(e), l.push(r);
+    } else {
+      if (i.animations.length === 2 && (y.SlerpToRef(i.animations[0].currentValue, i.animations[1].currentValue, i.animations[1].weight / i.totalWeight, n), i.totalAdditiveWeight === 0))
+        return n;
+      o = [], l = [], s = i.totalWeight;
+    }
+    for (let r = 0; r < i.animations.length; r++) {
+      const u = i.animations[r];
+      o.push(u.currentValue), l.push(u.weight / s);
+    }
+    let m = 0;
+    for (let r = 0; r < o.length; ) {
+      if (!r) {
+        y.SlerpToRef(o[r], o[r + 1], l[r + 1] / (l[r] + l[r + 1]), n), a = n, m = l[r] + l[r + 1], r += 2;
+        continue;
+      }
+      m += l[r], y.SlerpToRef(a, o[r], l[r] / m, a), r++;
+    }
+  }
+  for (let s = 0; s < i.additiveAnimations.length; s++) {
+    const o = i.additiveAnimations[s];
+    o.weight !== 0 && (a.multiplyToRef(o.currentValue, d.Quaternion[0]), y.SlerpToRef(a, d.Quaternion[0], o.weight, a));
+  }
+  return a;
+};
+g.prototype._processLateAnimationBindings = function() {
+  if (this._registeredForLateAnimationBindings.length) {
+    for (let i = 0; i < this._registeredForLateAnimationBindings.length; i++) {
+      const n = this._registeredForLateAnimationBindings.data[i];
+      for (const t in n._lateAnimationHolders) {
+        const e = n._lateAnimationHolders[t], a = e.animations[0], s = e.originalValue;
+        if (s == null)
+          continue;
+        const o = w.AllowMatrixDecomposeForInterpolation && s.m;
+        let l = n[t];
+        if (o)
+          l = this._processLateAnimationBindingsForMatrices(e);
+        else if (s.w !== void 0)
+          l = this._processLateAnimationBindingsForQuaternions(e, l || y.Identity());
+        else {
+          let r = 0, u = 1;
+          if (e.totalWeight < 1)
+            a && s.scale ? l = s.scale(1 - e.totalWeight) : a ? l = s * (1 - e.totalWeight) : s.clone ? l = s.clone() : l = s;
+          else if (a) {
+            u = e.totalWeight;
+            const h = a.weight / u;
+            h !== 1 ? a.currentValue.scale ? l = a.currentValue.scale(h) : l = a.currentValue * h : l = a.currentValue, r = 1;
+          }
+          for (let h = r; h < e.animations.length; h++) {
+            const c = e.animations[h], f = c.weight / u;
+            if (f)
+              c.currentValue.scaleAndAddToRef ? c.currentValue.scaleAndAddToRef(f, l) : l += c.currentValue * f;
+            else
+              continue;
+          }
+          for (let h = 0; h < e.additiveAnimations.length; h++) {
+            const c = e.additiveAnimations[h], f = c.weight;
+            if (f)
+              c.currentValue.scaleAndAddToRef ? c.currentValue.scaleAndAddToRef(f, l) : l += c.currentValue * f;
+            else
+              continue;
+          }
+        }
+        n[t] = l;
+      }
+      n._lateAnimationHolders = {};
+    }
+    this._registeredForLateAnimationBindings.reset();
+  }
+};
+P.prototype.copyAnimationRange = function(i, n, t, e = !1, a = null) {
+  this.animations.length === 0 && (this.animations.push(new w(this.name, "_matrix", i.animations[0].framePerSecond, w.ANIMATIONTYPE_MATRIX, 0)), this.animations[0].setKeys([]));
+  const s = i.animations[0].getRange(n);
+  if (!s)
+    return !1;
+  const o = s.from, l = s.to, m = i.animations[0].getKeys(), r = i.length, u = i.getParent(), h = this.getParent(), c = e && u && r && this.length && r !== this.length, f = c && h && u ? h.length / u.length : 1, A = e && !h && a && (a.x !== 1 || a.y !== 1 || a.z !== 1), p = this.animations[0].getKeys();
+  let b, T, _;
+  for (let v = 0, F = m.length; v < F; v++)
+    b = m[v], b.frame >= o && b.frame <= l && (e ? (_ = b.value.clone(), c ? (T = _.getTranslation(), _.setTranslation(T.scaleInPlace(f))) : A && a ? (T = _.getTranslation(), _.setTranslation(T.multiplyInPlace(a))) : _ = b.value) : _ = b.value, p.push({ frame: b.frame + t, value: _ }));
+  return this.animations[0].createRange(n, o + t, l + t), !0;
+};
+export {
+  V as Animatable
+};