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

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

@@ -0,0 +1,478 @@
+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
+};