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

package/dist/node_modules/@babylonjs/core/Bones/skeleton.esm.js

@@ -1,478 +0,0 @@
-import { Bone as d } from "./bone.esm.js";
-import { Observable as p } from "../Misc/observable.esm.js";
-import { Matrix as f, TmpVectors as _, Vector3 as A } from "../Maths/math.vector.esm.js";
-import { RawTexture as x } from "../Materials/Textures/rawTexture.esm.js";
-import { Animation as b } from "../Animations/animation.esm.js";
-import { AnimationRange as M } from "../Animations/animationRange.esm.js";
-import { EngineStore as y } from "../Engines/engineStore.esm.js";
-import { Logger as T } from "../Misc/logger.esm.js";
-import { DeepCopier as B } from "../Misc/deepCopier.esm.js";
-class g {
-  /**
-   * Gets or sets a boolean indicating that bone matrices should be stored as a texture instead of using shader uniforms (default is true).
-   * Please note that this option is not available if the hardware does not support it
-   */
-  get useTextureToStoreBoneMatrices() {
-    return this._useTextureToStoreBoneMatrices;
-  }
-  set useTextureToStoreBoneMatrices(e) {
-    this._useTextureToStoreBoneMatrices = e, this._markAsDirty();
-  }
-  /**
-   * Gets or sets the animation properties override
-   */
-  get animationPropertiesOverride() {
-    return this._animationPropertiesOverride ? this._animationPropertiesOverride : this._scene.animationPropertiesOverride;
-  }
-  set animationPropertiesOverride(e) {
-    this._animationPropertiesOverride = e;
-  }
-  /**
-   * Gets a boolean indicating that the skeleton effectively stores matrices into a texture
-   */
-  get isUsingTextureForMatrices() {
-    return this.useTextureToStoreBoneMatrices && this._canUseTextureForBones;
-  }
-  /**
-   * Gets the unique ID of this skeleton
-   */
-  get uniqueId() {
-    return this._uniqueId;
-  }
-  /**
-   * Creates a new skeleton
-   * @param name defines the skeleton name
-   * @param id defines the skeleton Id
-   * @param scene defines the hosting scene
-   */
-  constructor(e, i, n) {
-    this.name = e, this.id = i, this.bones = new Array(), this.needInitialSkinMatrix = !1, this._isDirty = !0, this._meshesWithPoseMatrix = new Array(), this._identity = f.Identity(), this._ranges = {}, this._absoluteTransformIsDirty = !0, this._canUseTextureForBones = !1, this._uniqueId = 0, this._numBonesWithLinkedTransformNode = 0, this._hasWaitingData = null, this._parentContainer = null, this.doNotSerialize = !1, this._useTextureToStoreBoneMatrices = !0, this._animationPropertiesOverride = null, this.onBeforeComputeObservable = new p(), this.bones = [], this._scene = n || y.LastCreatedScene, this._uniqueId = this._scene.getUniqueId(), this._scene.addSkeleton(this), this._isDirty = !0;
-    const t = this._scene.getEngine().getCaps();
-    this._canUseTextureForBones = t.textureFloat && t.maxVertexTextureImageUnits > 0;
-  }
-  /**
-   * Gets the current object class name.
-   * @returns the class name
-   */
-  getClassName() {
-    return "Skeleton";
-  }
-  /**
-   * Returns an array containing the root bones
-   * @returns an array containing the root bones
-   */
-  getChildren() {
-    return this.bones.filter((e) => !e.getParent());
-  }
-  // Members
-  /**
-   * Gets the list of transform matrices to send to shaders (one matrix per bone)
-   * @param mesh defines the mesh to use to get the root matrix (if needInitialSkinMatrix === true)
-   * @returns a Float32Array containing matrices data
-   */
-  getTransformMatrices(e) {
-    return this.needInitialSkinMatrix ? (e._bonesTransformMatrices || this.prepare(), e._bonesTransformMatrices) : ((!this._transformMatrices || this._isDirty) && this.prepare(), this._transformMatrices);
-  }
-  /**
-   * Gets the list of transform matrices to send to shaders inside a texture (one matrix per bone)
-   * @param mesh defines the mesh to use to get the root matrix (if needInitialSkinMatrix === true)
-   * @returns a raw texture containing the data
-   */
-  getTransformMatrixTexture(e) {
-    return this.needInitialSkinMatrix && e._transformMatrixTexture ? e._transformMatrixTexture : this._transformMatrixTexture;
-  }
-  /**
-   * Gets the current hosting scene
-   * @returns a scene object
-   */
-  getScene() {
-    return this._scene;
-  }
-  // Methods
-  /**
-   * Gets a string representing the current skeleton data
-   * @param fullDetails defines a boolean indicating if we want a verbose version
-   * @returns a string representing the current skeleton data
-   */
-  toString(e) {
-    let i = `Name: ${this.name}, nBones: ${this.bones.length}`;
-    if (i += `, nAnimationRanges: ${this._ranges ? Object.keys(this._ranges).length : "none"}`, e) {
-      i += ", Ranges: {";
-      let n = !0;
-      for (const t in this._ranges)
-        n && (i += ", ", n = !1), i += t;
-      i += "}";
-    }
-    return i;
-  }
-  /**
-   * Get bone's index searching by name
-   * @param name defines bone's name to search for
-   * @returns the indice of the bone. Returns -1 if not found
-   */
-  getBoneIndexByName(e) {
-    for (let i = 0, n = this.bones.length; i < n; i++)
-      if (this.bones[i].name === e)
-        return i;
-    return -1;
-  }
-  /**
-   * Create a new animation range
-   * @param name defines the name of the range
-   * @param from defines the start key
-   * @param to defines the end key
-   */
-  createAnimationRange(e, i, n) {
-    if (!this._ranges[e]) {
-      this._ranges[e] = new M(e, i, n);
-      for (let t = 0, s = this.bones.length; t < s; t++)
-        this.bones[t].animations[0] && this.bones[t].animations[0].createRange(e, i, n);
-    }
-  }
-  /**
-   * Delete a specific animation range
-   * @param name defines the name of the range
-   * @param deleteFrames defines if frames must be removed as well
-   */
-  deleteAnimationRange(e, i = !0) {
-    for (let n = 0, t = this.bones.length; n < t; n++)
-      this.bones[n].animations[0] && this.bones[n].animations[0].deleteRange(e, i);
-    this._ranges[e] = null;
-  }
-  /**
-   * Gets a specific animation range
-   * @param name defines the name of the range to look for
-   * @returns the requested animation range or null if not found
-   */
-  getAnimationRange(e) {
-    return this._ranges[e] || null;
-  }
-  /**
-   * Gets the list of all animation ranges defined on this skeleton
-   * @returns an array
-   */
-  getAnimationRanges() {
-    const e = [];
-    let i;
-    for (i in this._ranges)
-      e.push(this._ranges[i]);
-    return e;
-  }
-  /**
-   * Copy animation range from a source skeleton.
-   * This is not for a complete retargeting, only between very similar skeleton's with only possible bone length differences
-   * @param source defines the source skeleton
-   * @param name defines the name of the range to copy
-   * @param rescaleAsRequired defines if rescaling must be applied if required
-   * @returns true if operation was successful
-   */
-  copyAnimationRange(e, i, n = !1) {
-    if (this._ranges[i] || !e.getAnimationRange(i))
-      return !1;
-    let t = !0;
-    const s = this._getHighestAnimationFrame() + 1, a = {}, h = e.bones;
-    let o, r;
-    for (r = 0, o = h.length; r < o; r++)
-      a[h[r].name] = h[r];
-    this.bones.length !== h.length && (T.Warn(`copyAnimationRange: this rig has ${this.bones.length} bones, while source as ${h.length}`), t = !1);
-    const m = n && this.dimensionsAtRest && e.dimensionsAtRest ? this.dimensionsAtRest.divide(e.dimensionsAtRest) : null;
-    for (r = 0, o = this.bones.length; r < o; r++) {
-      const u = this.bones[r].name, c = a[u];
-      c ? t = t && this.bones[r].copyAnimationRange(c, i, s, n, m) : (T.Warn("copyAnimationRange: not same rig, missing source bone " + u), t = !1);
-    }
-    const l = e.getAnimationRange(i);
-    return l && (this._ranges[i] = new M(i, l.from + s, l.to + s)), t;
-  }
-  /**
-   * Forces the skeleton to go to rest pose
-   */
-  returnToRest() {
-    for (const e of this.bones)
-      e._index !== -1 && e.returnToRest();
-  }
-  _getHighestAnimationFrame() {
-    let e = 0;
-    for (let i = 0, n = this.bones.length; i < n; i++)
-      if (this.bones[i].animations[0]) {
-        const t = this.bones[i].animations[0].getHighestFrame();
-        e < t && (e = t);
-      }
-    return e;
-  }
-  /**
-   * Begin a specific animation range
-   * @param name defines the name of the range to start
-   * @param loop defines if looping must be turned on (false by default)
-   * @param speedRatio defines the speed ratio to apply (1 by default)
-   * @param onAnimationEnd defines a callback which will be called when animation will end
-   * @returns a new animatable
-   */
-  beginAnimation(e, i, n, t) {
-    const s = this.getAnimationRange(e);
-    return s ? this._scene.beginAnimation(this, s.from, s.to, i, n, t) : null;
-  }
-  /**
-   * Convert the keyframes for a range of animation on a skeleton to be relative to a given reference frame.
-   * @param skeleton defines the Skeleton containing the animation range 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 Skeleton to convert
-   * @returns the original skeleton
-   */
-  static MakeAnimationAdditive(e, i = 0, n) {
-    const t = e.getAnimationRange(n);
-    if (!t)
-      return null;
-    const s = e._scene.getAllAnimatablesByTarget(e);
-    let a = null;
-    for (let o = 0; o < s.length; o++) {
-      const r = s[o];
-      if (r.fromFrame === (t == null ? void 0 : t.from) && r.toFrame === (t == null ? void 0 : t.to)) {
-        a = r;
-        break;
-      }
-    }
-    const h = e.getAnimatables();
-    for (let o = 0; o < h.length; o++) {
-      const m = h[o].animations;
-      if (m)
-        for (let l = 0; l < m.length; l++)
-          b.MakeAnimationAdditive(m[l], i, n);
-    }
-    return a && (a.isAdditive = !0), e;
-  }
-  /** @internal */
-  _markAsDirty() {
-    this._isDirty = !0, this._absoluteTransformIsDirty = !0;
-  }
-  /**
-   * @internal
-   */
-  _registerMeshWithPoseMatrix(e) {
-    this._meshesWithPoseMatrix.push(e);
-  }
-  /**
-   * @internal
-   */
-  _unregisterMeshWithPoseMatrix(e) {
-    const i = this._meshesWithPoseMatrix.indexOf(e);
-    i > -1 && this._meshesWithPoseMatrix.splice(i, 1);
-  }
-  _computeTransformMatrices(e, i) {
-    this.onBeforeComputeObservable.notifyObservers(this);
-    for (let n = 0; n < this.bones.length; n++) {
-      const t = this.bones[n];
-      t._childUpdateId++;
-      const s = t.getParent();
-      if (s ? t.getLocalMatrix().multiplyToRef(s.getFinalMatrix(), t.getFinalMatrix()) : i ? t.getLocalMatrix().multiplyToRef(i, t.getFinalMatrix()) : t.getFinalMatrix().copyFrom(t.getLocalMatrix()), t._index !== -1) {
-        const a = t._index === null ? n : t._index;
-        t.getAbsoluteInverseBindMatrix().multiplyToArray(t.getFinalMatrix(), e, a * 16);
-      }
-    }
-    this._identity.copyToArray(e, this.bones.length * 16);
-  }
-  /**
-   * Build all resources required to render a skeleton
-   */
-  prepare() {
-    if (this._numBonesWithLinkedTransformNode > 0) {
-      for (const e of this.bones)
-        if (e._linkedTransformNode) {
-          const i = e._linkedTransformNode;
-          e.position = i.position, i.rotationQuaternion ? e.rotationQuaternion = i.rotationQuaternion : e.rotation = i.rotation, e.scaling = i.scaling;
-        }
-    }
-    if (this.needInitialSkinMatrix)
-      for (const e of this._meshesWithPoseMatrix) {
-        const i = e.getPoseMatrix();
-        let n = this._isDirty;
-        if ((!e._bonesTransformMatrices || e._bonesTransformMatrices.length !== 16 * (this.bones.length + 1)) && (e._bonesTransformMatrices = new Float32Array(16 * (this.bones.length + 1)), n = !0), !!n) {
-          if (this._synchronizedWithMesh !== e) {
-            this._synchronizedWithMesh = e;
-            for (const t of this.bones)
-              t.getParent() || (t.getBindMatrix().multiplyToRef(i, _.Matrix[1]), t._updateAbsoluteBindMatrices(_.Matrix[1]));
-            if (this.isUsingTextureForMatrices) {
-              const t = (this.bones.length + 1) * 4;
-              (!e._transformMatrixTexture || e._transformMatrixTexture.getSize().width !== t) && (e._transformMatrixTexture && e._transformMatrixTexture.dispose(), e._transformMatrixTexture = x.CreateRGBATexture(e._bonesTransformMatrices, (this.bones.length + 1) * 4, 1, this._scene, !1, !1, 1, 1));
-            }
-          }
-          this._computeTransformMatrices(e._bonesTransformMatrices, i), this.isUsingTextureForMatrices && e._transformMatrixTexture && e._transformMatrixTexture.update(e._bonesTransformMatrices);
-        }
-      }
-    else {
-      if (!this._isDirty)
-        return;
-      (!this._transformMatrices || this._transformMatrices.length !== 16 * (this.bones.length + 1)) && (this._transformMatrices = new Float32Array(16 * (this.bones.length + 1)), this.isUsingTextureForMatrices && (this._transformMatrixTexture && this._transformMatrixTexture.dispose(), this._transformMatrixTexture = x.CreateRGBATexture(this._transformMatrices, (this.bones.length + 1) * 4, 1, this._scene, !1, !1, 1, 1))), this._computeTransformMatrices(this._transformMatrices, null), this.isUsingTextureForMatrices && this._transformMatrixTexture && this._transformMatrixTexture.update(this._transformMatrices);
-    }
-    this._isDirty = !1;
-  }
-  /**
-   * Gets the list of animatables currently running for this skeleton
-   * @returns an array of animatables
-   */
-  getAnimatables() {
-    if (!this._animatables || this._animatables.length !== this.bones.length) {
-      this._animatables = [];
-      for (let e = 0; e < this.bones.length; e++)
-        this._animatables.push(this.bones[e]);
-    }
-    return this._animatables;
-  }
-  /**
-   * Clone the current skeleton
-   * @param name defines the name of the new skeleton
-   * @param id defines the id of the new skeleton
-   * @returns the new skeleton
-   */
-  clone(e, i) {
-    const n = new g(e, i || e, this._scene);
-    n.needInitialSkinMatrix = this.needInitialSkinMatrix;
-    for (let t = 0; t < this.bones.length; t++) {
-      const s = this.bones[t];
-      let a = null;
-      const h = s.getParent();
-      if (h) {
-        const r = this.bones.indexOf(h);
-        a = n.bones[r];
-      }
-      const o = new d(s.name, n, a, s.getBindMatrix().clone(), s.getRestMatrix().clone());
-      o._index = s._index, s._linkedTransformNode && o.linkTransformNode(s._linkedTransformNode), B.DeepCopy(s.animations, o.animations);
-    }
-    if (this._ranges) {
-      n._ranges = {};
-      for (const t in this._ranges) {
-        const s = this._ranges[t];
-        s && (n._ranges[t] = s.clone());
-      }
-    }
-    return this._isDirty = !0, n;
-  }
-  /**
-   * Enable animation blending for this skeleton
-   * @param blendingSpeed defines the blending speed to apply
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-blending
-   */
-  enableBlending(e = 0.01) {
-    this.bones.forEach((i) => {
-      i.animations.forEach((n) => {
-        n.enableBlending = !0, n.blendingSpeed = e;
-      });
-    });
-  }
-  /**
-   * Releases all resources associated with the current skeleton
-   */
-  dispose() {
-    if (this._meshesWithPoseMatrix.length = 0, this.getScene().stopAnimation(this), this.getScene().removeSkeleton(this), this._parentContainer) {
-      const e = this._parentContainer.skeletons.indexOf(this);
-      e > -1 && this._parentContainer.skeletons.splice(e, 1), this._parentContainer = null;
-    }
-    this._transformMatrixTexture && (this._transformMatrixTexture.dispose(), this._transformMatrixTexture = null);
-  }
-  /**
-   * Serialize the skeleton in a JSON object
-   * @returns a JSON object
-   */
-  serialize() {
-    var e;
-    const i = {};
-    i.name = this.name, i.id = this.id, this.dimensionsAtRest && (i.dimensionsAtRest = this.dimensionsAtRest.asArray()), i.bones = [], i.needInitialSkinMatrix = this.needInitialSkinMatrix;
-    for (let n = 0; n < this.bones.length; n++) {
-      const t = this.bones[n], s = t.getParent(), a = {
-        parentBoneIndex: s ? this.bones.indexOf(s) : -1,
-        index: t.getIndex(),
-        name: t.name,
-        id: t.id,
-        matrix: t.getBindMatrix().toArray(),
-        rest: t.getRestMatrix().toArray(),
-        linkedTransformNodeId: (e = t.getTransformNode()) === null || e === void 0 ? void 0 : e.id
-      };
-      i.bones.push(a), t.length && (a.length = t.length), t.metadata && (a.metadata = t.metadata), t.animations && t.animations.length > 0 && (a.animation = t.animations[0].serialize()), i.ranges = [];
-      for (const h in this._ranges) {
-        const o = this._ranges[h];
-        if (!o)
-          continue;
-        const r = {};
-        r.name = h, r.from = o.from, r.to = o.to, i.ranges.push(r);
-      }
-    }
-    return i;
-  }
-  /**
-   * Creates a new skeleton from serialized data
-   * @param parsedSkeleton defines the serialized data
-   * @param scene defines the hosting scene
-   * @returns a new skeleton
-   */
-  static Parse(e, i) {
-    const n = new g(e.name, e.id, i);
-    e.dimensionsAtRest && (n.dimensionsAtRest = A.FromArray(e.dimensionsAtRest)), n.needInitialSkinMatrix = e.needInitialSkinMatrix;
-    let t;
-    for (t = 0; t < e.bones.length; t++) {
-      const s = e.bones[t], a = e.bones[t].index;
-      let h = null;
-      s.parentBoneIndex > -1 && (h = n.bones[s.parentBoneIndex]);
-      const o = s.rest ? f.FromArray(s.rest) : null, r = new d(s.name, n, h, f.FromArray(s.matrix), o, null, a);
-      s.id !== void 0 && s.id !== null && (r.id = s.id), s.length && (r.length = s.length), s.metadata && (r.metadata = s.metadata), s.animation && r.animations.push(b.Parse(s.animation)), s.linkedTransformNodeId !== void 0 && s.linkedTransformNodeId !== null && (n._hasWaitingData = !0, r._waitingTransformNodeId = s.linkedTransformNodeId);
-    }
-    if (e.ranges)
-      for (t = 0; t < e.ranges.length; t++) {
-        const s = e.ranges[t];
-        n.createAnimationRange(s.name, s.from, s.to);
-      }
-    return n;
-  }
-  /**
-   * Compute all node absolute matrices
-   * @param forceUpdate defines if computation must be done even if cache is up to date
-   */
-  computeAbsoluteMatrices(e = !1) {
-    (this._absoluteTransformIsDirty || e) && (this.bones[0].computeAbsoluteMatrices(), this._absoluteTransformIsDirty = !1);
-  }
-  /**
-   * Compute all node absolute matrices
-   * @param forceUpdate defines if computation must be done even if cache is up to date
-   * @deprecated Please use computeAbsoluteMatrices instead
-   */
-  computeAbsoluteTransforms(e = !1) {
-    this.computeAbsoluteMatrices(e);
-  }
-  /**
-   * Gets the root pose matrix
-   * @returns a matrix
-   */
-  getPoseMatrix() {
-    let e = null;
-    return this._meshesWithPoseMatrix.length > 0 && (e = this._meshesWithPoseMatrix[0].getPoseMatrix()), e;
-  }
-  /**
-   * Sorts bones per internal index
-   */
-  sortBones() {
-    const e = new Array(), i = new Array(this.bones.length);
-    for (let n = 0; n < this.bones.length; n++)
-      this._sortBones(n, e, i);
-    this.bones = e;
-  }
-  _sortBones(e, i, n) {
-    if (n[e])
-      return;
-    n[e] = !0;
-    const t = this.bones[e];
-    if (!t)
-      return;
-    t._index === void 0 && (t._index = e);
-    const s = t.getParent();
-    s && this._sortBones(this.bones.indexOf(s), i, n), i.push(t);
-  }
-  /**
-   * Set the current local matrix as the restPose for all bones in the skeleton.
-   */
-  setCurrentPoseAsRest() {
-    this.bones.forEach((e) => {
-      e.setCurrentPoseAsRest();
-    });
-  }
-}
-export {
-  g as Skeleton
-};