@esotericsoftware/spine-pixi-v8 4.2.71 → 4.2.73

package/dist/esm/spine-pixi-v8.mjs

@@ -7022,7 +7022,7 @@ var PhysicsConstraint = class {
             }
             if (a >= t) {
               d = Math.pow(this.damping, 60 * t);
-              const m = this.massInverse * t, e = this.strength, w = this.wind * f * skeleton.scaleX, g = (Skeleton.yDown ? -this.gravity : this.gravity) * f * skeleton.scaleY;
+              const m = this.massInverse * t, e = this.strength, w = this.wind * f * skeleton.scaleX, g = this.gravity * f * skeleton.scaleY;
               do {
                 if (x) {
                   this.xVelocity += (w - this.xOffset * e) * m;
@@ -7977,10 +7977,10 @@ var _Skeleton = class {
   }
   /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose as `{ x: number, y: number, width: number, height: number }`.
    * Note that this method will create temporary objects which can add to garbage collection pressure. Use `getBounds()` if garbage collection is a concern. */
-  getBoundsRect() {
+  getBoundsRect(clipper2) {
     let offset = new Vector2();
     let size = new Vector2();
-    this.getBounds(offset, size);
+    this.getBounds(offset, size, void 0, clipper2);
     return { x: offset.x, y: offset.y, width: size.x, height: size.y };
   }
   /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose.
@@ -12381,6 +12381,97 @@ import {
 var vectorAux = new Vector2();
 Skeleton.yDown = true;
 var clipper = new SkeletonClipping();
+var AABBRectangleBoundsProvider = class {
+  constructor(x, y, width, height) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+  }
+  calculateBounds() {
+    return { x: this.x, y: this.y, width: this.width, height: this.height };
+  }
+};
+var SetupPoseBoundsProvider = class {
+  /**
+   * @param clipping If true, clipping attachments are used to compute the bounds. False, by default.
+   */
+  constructor(clipping = false) {
+    this.clipping = clipping;
+  }
+  calculateBounds(gameObject) {
+    if (!gameObject.skeleton)
+      return { x: 0, y: 0, width: 0, height: 0 };
+    const skeleton = new Skeleton(gameObject.skeleton.data);
+    skeleton.setToSetupPose();
+    skeleton.updateWorldTransform(2 /* update */);
+    const bounds = skeleton.getBoundsRect(this.clipping ? new SkeletonClipping() : void 0);
+    return bounds.width == Number.NEGATIVE_INFINITY ? { x: 0, y: 0, width: 0, height: 0 } : bounds;
+  }
+};
+var SkinsAndAnimationBoundsProvider = class {
+  /**
+   * @param animation The animation to use for calculating the bounds. If null, the setup pose is used.
+   * @param skins The skins to use for calculating the bounds. If empty, the default skin is used.
+   * @param timeStep The time step to use for calculating the bounds. A smaller time step means more precision, but slower calculation.
+   * @param clipping If true, clipping attachments are used to compute the bounds. False, by default.
+   */
+  constructor(animation, skins = [], timeStep = 0.05, clipping = false) {
+    this.animation = animation;
+    this.skins = skins;
+    this.timeStep = timeStep;
+    this.clipping = clipping;
+  }
+  calculateBounds(gameObject) {
+    if (!gameObject.skeleton || !gameObject.state)
+      return { x: 0, y: 0, width: 0, height: 0 };
+    const animationState = new AnimationState(gameObject.state.data);
+    const skeleton = new Skeleton(gameObject.skeleton.data);
+    const clipper2 = this.clipping ? new SkeletonClipping() : void 0;
+    const data = skeleton.data;
+    if (this.skins.length > 0) {
+      let customSkin = new Skin("custom-skin");
+      for (const skinName of this.skins) {
+        const skin = data.findSkin(skinName);
+        if (skin == null)
+          continue;
+        customSkin.addSkin(skin);
+      }
+      skeleton.setSkin(customSkin);
+    }
+    skeleton.setToSetupPose();
+    const animation = this.animation != null ? data.findAnimation(this.animation) : null;
+    if (animation == null) {
+      skeleton.updateWorldTransform(2 /* update */);
+      const bounds = skeleton.getBoundsRect(clipper2);
+      return bounds.width == Number.NEGATIVE_INFINITY ? { x: 0, y: 0, width: 0, height: 0 } : bounds;
+    } else {
+      let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
+      animationState.clearTracks();
+      animationState.setAnimationWith(0, animation, false);
+      const steps = Math.max(animation.duration / this.timeStep, 1);
+      for (let i = 0; i < steps; i++) {
+        const delta = i > 0 ? this.timeStep : 0;
+        animationState.update(delta);
+        animationState.apply(skeleton);
+        skeleton.update(delta);
+        skeleton.updateWorldTransform(2 /* update */);
+        const bounds2 = skeleton.getBoundsRect(clipper2);
+        minX = Math.min(minX, bounds2.x);
+        minY = Math.min(minY, bounds2.y);
+        maxX = Math.max(maxX, bounds2.x + bounds2.width);
+        maxY = Math.max(maxY, bounds2.y + bounds2.height);
+      }
+      const bounds = {
+        x: minX,
+        y: minY,
+        width: maxX - minX,
+        height: maxY - minY
+      };
+      return bounds.width == Number.NEGATIVE_INFINITY ? { x: 0, y: 0, width: 0, height: 0 } : bounds;
+    }
+  }
+};
 var maskPool = new Pool(() => new Graphics());
 var Spine = class extends ViewContainer {
   // Pixi properties
@@ -12447,6 +12538,18 @@ var Spine = class extends ViewContainer {
     }
     this._autoUpdate = value;
   }
+  _boundsProvider;
+  /** The bounds provider to use. If undefined the bounds will be dynamic, calculated when requested and based on the current frame. */
+  get boundsProvider() {
+    return this._boundsProvider;
+  }
+  set boundsProvider(value) {
+    this._boundsProvider = value;
+    if (value) {
+      this._boundsDirty = false;
+    }
+    this.updateBounds();
+  }
   hasNeverUpdated = true;
   constructor(options) {
     if (options instanceof SkeletonData) {
@@ -12464,6 +12567,7 @@ var Spine = class extends ViewContainer {
     for (let i = 0; i < slots.length; i++) {
       this.attachmentCacheData[i] = /* @__PURE__ */ Object.create(null);
     }
+    this._boundsProvider = options.boundsProvider;
   }
   /** If {@link Spine.autoUpdate} is `false`, this method allows to update the AnimationState and the Skeleton with the given delta. */
   update(dt) {
@@ -12540,7 +12644,6 @@ var Spine = class extends ViewContainer {
     this.afterUpdateWorldTransforms(this);
     this.updateSlotObjects();
     this._stateChanged = true;
-    this._boundsDirty = true;
     this.onViewUpdate();
   }
   /**
@@ -12792,7 +12895,9 @@ var Spine = class extends ViewContainer {
   }
   onViewUpdate() {
     this._didViewChangeTick++;
-    this._boundsDirty = true;
+    if (!this._boundsProvider) {
+      this._boundsDirty = true;
+    }
     if (this.didViewUpdate)
       return;
     this.didViewUpdate = true;
@@ -12880,7 +12985,15 @@ var Spine = class extends ViewContainer {
     this.skeletonBounds ||= new SkeletonBounds();
     const skeletonBounds = this.skeletonBounds;
     skeletonBounds.update(this.skeleton, true);
-    if (skeletonBounds.minX === Infinity) {
+    if (this._boundsProvider) {
+      const boundsSpine = this._boundsProvider.calculateBounds(this);
+      const bounds = this._bounds;
+      bounds.clear();
+      bounds.x = boundsSpine.x;
+      bounds.y = boundsSpine.y;
+      bounds.width = boundsSpine.width;
+      bounds.height = boundsSpine.height;
+    } else if (skeletonBounds.minX === Infinity) {
       if (this.hasNeverUpdated) {
         this._updateAndApplyState(0);
         this._boundsDirty = false;
@@ -12957,10 +13070,15 @@ var Spine = class extends ViewContainer {
    * @param options - Options to configure the Spine game object. See {@link SpineFromOptions}
    * @returns {Spine} The Spine game object instantiated
    */
-  static from({ skeleton, atlas, scale = 1, darkTint, autoUpdate = true }) {
+  static from({ skeleton, atlas, scale = 1, darkTint, autoUpdate = true, boundsProvider }) {
     const cacheKey = `${skeleton}-${atlas}-${scale}`;
     if (Cache.has(cacheKey)) {
-      return new Spine(Cache.get(cacheKey));
+      return new Spine({
+        skeletonData: Cache.get(cacheKey),
+        darkTint,
+        autoUpdate,
+        boundsProvider
+      });
     }
     const skeletonAsset = Assets.get(skeleton);
     const atlasAsset = Assets.get(atlas);
@@ -12972,7 +13090,8 @@ var Spine = class extends ViewContainer {
     return new Spine({
       skeletonData,
       darkTint,
-      autoUpdate
+      autoUpdate,
+      boundsProvider
     });
   }
 };
@@ -13366,6 +13485,7 @@ var SpineDebugRenderer = class {
   }
 };
 export {
+  AABBRectangleBoundsProvider,
   AlphaTimeline,
   Animation,
   AnimationState,
@@ -13446,6 +13566,7 @@ export {
   ScaleXTimeline,
   ScaleYTimeline,
   SequenceTimeline,
+  SetupPoseBoundsProvider,
   ShearTimeline,
   ShearXTimeline,
   ShearYTimeline,
@@ -13457,6 +13578,7 @@ export {
   SkeletonJson,
   Skin,
   SkinEntry,
+  SkinsAndAnimationBoundsProvider,
   Slot,
   SlotData,
   SpacingMode,