@safe-engine/pixi 8.9.4 → 8.9.6

package/dist/spine/lib/Spine.js

@@ -1,16 +1,16 @@
-/** ****************************************************************************
+/******************************************************************************
  * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
+ * Last updated April 5, 2025. Replaces all prior versions.
  *
- * Copyright (c) 2013-2023, Esoteric Software LLC
+ * Copyright (c) 2013-2025, Esoteric Software LLC
  *
  * Integration of the Spine Runtimes into software or otherwise creating
  * derivative works of the Spine Runtimes is permitted under the terms and
  * conditions of Section 2 of the Spine Editor License Agreement:
  * http://esotericsoftware.com/spine-editor-license
  *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
  * "Products"), provided that each user of the Products must obtain their own
  * Spine Editor license and redistribution of the Products in any form must
  * include this license and copyright notice.
@@ -23,14 +23,115 @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
  * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-import { AnimationState, AnimationStateData, AtlasAttachmentLoader, ClippingAttachment, Color, MeshAttachment, Physics, Pool, RegionAttachment, Skeleton, SkeletonBinary, SkeletonBounds, SkeletonClipping, SkeletonData, SkeletonJson, Vector2, } from '@esotericsoftware/spine-core';
-import { Assets, Cache, Container, DEG_TO_RAD, fastCopy, Graphics, Texture, Ticker, ViewContainer, } from 'pixi.js';
+import { AnimationState, AnimationStateData, AtlasAttachmentLoader, ClippingAttachment, Color, MeshAttachment, Physics, Pool, RegionAttachment, Skeleton, SkeletonBinary, SkeletonBounds, SkeletonClipping, SkeletonData, SkeletonJson, Skin, Vector2, } from '@esotericsoftware/spine-core';
+import { Assets, Cache, Container, fastCopy, Graphics, Texture, Ticker, ViewContainer, } from 'pixi.js';
 const vectorAux = new Vector2();
 Skeleton.yDown = true;
 const clipper = new SkeletonClipping();
+/** A bounds provider that provides a fixed size given by the user. */
+export class AABBRectangleBoundsProvider {
+    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 };
+    }
+}
+/** A bounds provider that calculates the bounding box from the setup pose. */
+export class SetupPoseBoundsProvider {
+    /**
+     * @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 };
+        // Make a copy of animation state and skeleton as this might be called while
+        // the skeleton in the GameObject has already been heavily modified. We can not
+        // reconstruct that state.
+        const skeleton = new Skeleton(gameObject.skeleton.data);
+        skeleton.setToSetupPose();
+        skeleton.updateWorldTransform(Physics.update);
+        const bounds = skeleton.getBoundsRect(this.clipping ? new SkeletonClipping() : undefined);
+        return bounds.width == Number.NEGATIVE_INFINITY ? { x: 0, y: 0, width: 0, height: 0 } : bounds;
+    }
+}
+/** A bounds provider that calculates the bounding box by taking the maximumg bounding box for a combination of skins and specific animation. */
+export class SkinsAndAnimationBoundsProvider {
+    /**
+     * @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 };
+        // Make a copy of animation state and skeleton as this might be called while
+        // the skeleton in the GameObject has already been heavily modified. We can not
+        // reconstruct that state.
+        const animationState = new AnimationState(gameObject.state.data);
+        const skeleton = new Skeleton(gameObject.skeleton.data);
+        const clipper = this.clipping ? new SkeletonClipping() : undefined;
+        const data = skeleton.data;
+        if (this.skins.length > 0) {
+            const 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(Physics.update);
+            const bounds = skeleton.getBoundsRect(clipper);
+            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.0);
+            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(Physics.update);
+                const bounds = skeleton.getBoundsRect(clipper);
+                minX = Math.min(minX, bounds.x);
+                minY = Math.min(minY, bounds.y);
+                maxX = Math.max(maxX, bounds.x + bounds.width);
+                maxY = Math.max(maxY, bounds.y + bounds.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;
+        }
+    }
+}
 const maskPool = new Pool(() => new Graphics());
 /**
  * The class to instantiate a {@link Spine} game object in Pixi.
@@ -69,14 +170,25 @@ export class Spine extends ViewContainer {
     }
     /** When `true`, the Spine AnimationState and the Skeleton will be automatically updated using the {@link Ticker.shared} instance. */
     set autoUpdate(value) {
-        if (value) {
+        if (value && !this._autoUpdate) {
             Ticker.shared.add(this.internalUpdate, this);
         }
-        else {
+        else if (!value && this._autoUpdate) {
             Ticker.shared.remove(this.internalUpdate, this);
         }
         this._autoUpdate = value;
     }
+    /** 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();
+    }
     constructor(options) {
         var _a;
         if (options instanceof SkeletonData) {
@@ -84,7 +196,7 @@ export class Spine extends ViewContainer {
                 skeletonData: options,
             };
         }
-        super(options);
+        super({});
         // Pixi properties
         this.batched = true;
         this.buildId = 0;
@@ -105,8 +217,9 @@ export class Spine extends ViewContainer {
         this._lastAttachments = [];
         this._stateChanged = true;
         this.attachmentCacheData = [];
-        this._autoUpdate = true;
+        this._autoUpdate = false;
         this.hasNeverUpdated = true;
+        this.allowChildren = true;
         const skeletonData = options instanceof SkeletonData ? options : options.skeletonData;
         this.skeleton = new Skeleton(skeletonData);
         this.state = new AnimationState(new AnimationStateData(skeletonData));
@@ -117,6 +230,7 @@ export class Spine extends ViewContainer {
         for (let i = 0; i < slots.length; i++) {
             this.attachmentCacheData[i] = 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) {
@@ -196,7 +310,6 @@ export class Spine extends ViewContainer {
         this.afterUpdateWorldTransforms(this);
         this.updateSlotObjects();
         this._stateChanged = true;
-        this._boundsDirty = true;
         this.onViewUpdate();
     }
     /**
@@ -240,15 +353,13 @@ export class Spine extends ViewContainer {
         if (attachment && attachment instanceof ClippingAttachment) {
             const clip = ((_a = this.clippingSlotToPixiMasks)[_b = slot.data.name] || (_a[_b] = { slot, vertices: new Array() }));
             clip.maskComputed = false;
-            this.currentClippingSlot = this.clippingSlotToPixiMasks[slot.data.name];
+            this.currentClippingSlot = clip;
             return;
         }
         // assign the currentClippingSlot mask to the slot object
         const currentClippingSlot = this.currentClippingSlot;
         const slotObject = this._slotsObject[slot.data.name];
         if (currentClippingSlot && slotObject) {
-            const slotClipping = currentClippingSlot.slot;
-            const clippingAttachment = slotClipping.attachment;
             // create the pixi mask, only the first time and if the clipped slot is the first one clipped by this currentClippingSlot
             let mask = currentClippingSlot.mask;
             if (!mask) {
@@ -258,6 +369,8 @@ export class Spine extends ViewContainer {
             }
             // compute the pixi mask polygon, if the clipped slot is the first one clipped by this currentClippingSlot
             if (!currentClippingSlot.maskComputed) {
+                const slotClipping = currentClippingSlot.slot;
+                const clippingAttachment = slotClipping.attachment;
                 currentClippingSlot.maskComputed = true;
                 const worldVerticesLength = clippingAttachment.worldVerticesLength;
                 const vertices = currentClippingSlot.vertices;
@@ -285,6 +398,7 @@ export class Spine extends ViewContainer {
                     clippingSlotToPixiMask.mask = undefined;
                 }
             }
+            this.currentClippingSlot = undefined;
         }
     }
     transformAttachments() {
@@ -313,18 +427,28 @@ export class Spine extends ViewContainer {
                     const skeletonColor = skeleton.color;
                     const slotColor = slot.color;
                     const attachmentColor = attachment.color;
-                    cacheData.color.set(skeletonColor.r * slotColor.r * attachmentColor.r, skeletonColor.g * slotColor.g * attachmentColor.g, skeletonColor.b * slotColor.b * attachmentColor.b, skeletonColor.a * slotColor.a * attachmentColor.a);
-                    if (slot.darkColor) {
-                        cacheData.darkColor.setFromColor(slot.darkColor);
-                    }
-                    cacheData.skipRender = cacheData.clipped = false;
-                    const texture = ((_a = attachment.region) === null || _a === void 0 ? void 0 : _a.texture.texture) || Texture.EMPTY;
-                    if (cacheData.texture !== texture) {
-                        cacheData.texture = texture;
-                        this.spineTexturesDirty = true;
+                    const alpha = skeletonColor.a * slotColor.a * attachmentColor.a;
+                    cacheData.color.set(skeletonColor.r * slotColor.r * attachmentColor.r, skeletonColor.g * slotColor.g * attachmentColor.g, skeletonColor.b * slotColor.b * attachmentColor.b, alpha);
+                    if (this.alpha === 0 || alpha === 0) {
+                        if (!cacheData.skipRender)
+                            this.spineAttachmentsDirty = true;
+                        cacheData.skipRender = true;
                     }
-                    if (clipper.isClipping()) {
-                        this.updateClippingData(cacheData);
+                    else {
+                        if (cacheData.skipRender)
+                            this.spineAttachmentsDirty = true;
+                        cacheData.skipRender = cacheData.clipped = false;
+                        if (slot.darkColor) {
+                            cacheData.darkColor.setFromColor(slot.darkColor);
+                        }
+                        const texture = ((_a = attachment.region) === null || _a === void 0 ? void 0 : _a.texture.texture) || Texture.EMPTY;
+                        if (cacheData.texture !== texture) {
+                            cacheData.texture = texture;
+                            this.spineTexturesDirty = true;
+                        }
+                        if (clipper.isClipping()) {
+                            this.updateClippingData(cacheData);
+                        }
                     }
                 }
                 else if (attachment instanceof ClippingAttachment) {
@@ -396,13 +520,22 @@ export class Spine extends ViewContainer {
     }
     updateSlotObject(slotAttachment) {
         const { slot, container } = slotAttachment;
-        container.visible = this.skeleton.drawOrder.includes(slot);
+        const followAttachmentValue = slotAttachment.followAttachmentTimeline ? Boolean(slot.attachment) : true;
+        container.visible = this.skeleton.drawOrder.includes(slot) && followAttachmentValue;
         if (container.visible) {
-            const bone = slot.bone;
+            let bone = slot.bone;
             container.position.set(bone.worldX, bone.worldY);
-            container.scale.x = bone.getWorldScaleX();
-            container.scale.y = bone.getWorldScaleY();
-            container.rotation = bone.getWorldRotationX() * DEG_TO_RAD;
+            container.angle = bone.getWorldRotationX();
+            let cumulativeScaleX = 1;
+            let cumulativeScaleY = 1;
+            while (bone) {
+                cumulativeScaleX *= bone.scaleX;
+                cumulativeScaleY *= bone.scaleY;
+                bone = bone.parent;
+            }
+            if (cumulativeScaleX < 0)
+                container.angle -= 180;
+            container.scale.set(slot.bone.getWorldScaleX() * Math.sign(cumulativeScaleX), slot.bone.getWorldScaleY() * Math.sign(cumulativeScaleY));
             container.alpha = this.skeleton.color.a * slot.color.a;
         }
     }
@@ -449,7 +582,9 @@ export class Spine extends ViewContainer {
         var _a;
         // increment from the 12th bit!
         this._didViewChangeTick++;
-        this._boundsDirty = true;
+        if (!this._boundsProvider) {
+            this._boundsDirty = true;
+        }
         if (this.didViewUpdate)
             return;
         this.didViewUpdate = true;
@@ -465,8 +600,10 @@ export class Spine extends ViewContainer {
      *
      * @param container - The container to attach to the slot
      * @param slotRef - The slot id or  slot to attach to
+     * @param options - Optional settings for the attachment.
+     * @param options.followAttachmentTimeline - If true, the attachment will follow the slot's attachment timeline.
      */
-    addSlotObject(slot, container) {
+    addSlotObject(slot, container, options) {
         var _a;
         slot = this.getSlotFromRef(slot);
         // need to check in on the container too...
@@ -477,9 +614,12 @@ export class Spine extends ViewContainer {
         }
         this.removeSlotObject(slot);
         container.includeInBuild = false;
-        // TODO only add once??
         this.addChild(container);
-        const slotObject = { container, slot };
+        const slotObject = {
+            container,
+            slot,
+            followAttachmentTimeline: (options === null || options === void 0 ? void 0 : options.followAttachmentTimeline) || false,
+        };
         this._slotsObject[slot.data.name] = slotObject;
         this.updateSlotObject(slotObject);
     }
@@ -511,6 +651,16 @@ export class Spine extends ViewContainer {
             containerToRemove.includeInBuild = true;
         }
     }
+    /**
+     * Removes all PixiJS containers attached to any slot.
+     */
+    removeSlotObjects() {
+        Object.entries(this._slotsObject).forEach(([slotName, slotObject]) => {
+            if (slotObject)
+                slotObject.container.removeFromParent();
+            delete this._slotsObject[slotName];
+        });
+    }
     /**
      * Returns a container attached to a slot, or undefined if no container is attached.
      *
@@ -527,7 +677,16 @@ export class Spine extends ViewContainer {
         this.skeletonBounds || (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;
@@ -596,8 +755,8 @@ export class Spine extends ViewContainer {
      * Use this method to instantiate a Spine game object.
      * Before instantiating a Spine game object, the skeleton (`.skel` or `.json`) and the atlas text files must be loaded into the Assets. For example:
      * ```
-     * PIXI.Assets.add("sackData", "./assets/sack-pro.skel");
-     * PIXI.Assets.add("sackAtlas", "./assets/sack-pma.atlas");
+     * PIXI.Assets.add("sackData", "/assets/sack-pro.skel");
+     * PIXI.Assets.add("sackAtlas", "/assets/sack-pma.atlas");
      * await PIXI.Assets.load(["sackData", "sackAtlas"]);
      * ```
      * Once a Spine game object is created, its skeleton data is cached into {@link Cache} using the key:
@@ -606,10 +765,15 @@ export class Spine 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);
@@ -622,6 +786,7 @@ export class Spine extends ViewContainer {
             skeletonData,
             darkTint,
             autoUpdate,
+            boundsProvider,
         });
     }
 }

package/dist/spine/lib/SpineDebugRenderer.d.ts

@@ -1,16 +1,16 @@
-/** ****************************************************************************
+/******************************************************************************
  * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
+ * Last updated April 5, 2025. Replaces all prior versions.
  *
- * Copyright (c) 2013-2023, Esoteric Software LLC
+ * Copyright (c) 2013-2025, Esoteric Software LLC
  *
  * Integration of the Spine Runtimes into software or otherwise creating
  * derivative works of the Spine Runtimes is permitted under the terms and
  * conditions of Section 2 of the Spine Editor License Agreement:
  * http://esotericsoftware.com/spine-editor-license
  *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
  * "Products"), provided that each user of the Products must obtain their own
  * Spine Editor license and redistribution of the Products in any form must
  * include this license and copyright notice.
@@ -23,8 +23,8 @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
  * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
 import { Container, Graphics } from 'pixi.js';
 import { Spine } from './Spine.js';

package/dist/spine/lib/SpineDebugRenderer.js

@@ -1,16 +1,16 @@
-/** ****************************************************************************
+/******************************************************************************
  * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
+ * Last updated April 5, 2025. Replaces all prior versions.
  *
- * Copyright (c) 2013-2023, Esoteric Software LLC
+ * Copyright (c) 2013-2025, Esoteric Software LLC
  *
  * Integration of the Spine Runtimes into software or otherwise creating
  * derivative works of the Spine Runtimes is permitted under the terms and
  * conditions of Section 2 of the Spine Editor License Agreement:
  * http://esotericsoftware.com/spine-editor-license
  *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
  * "Products"), provided that each user of the Products must obtain their own
  * Spine Editor license and redistribution of the Products in any form must
  * include this license and copyright notice.
@@ -23,8 +23,8 @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
  * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
 import { Container, Graphics, Text } from 'pixi.js';
 import { ClippingAttachment, MeshAttachment, PathAttachment, RegionAttachment, SkeletonBounds } from '@esotericsoftware/spine-core';

package/dist/spine/lib/SpinePipe.d.ts

@@ -1,16 +1,16 @@
-/** ****************************************************************************
+/******************************************************************************
  * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
+ * Last updated April 5, 2025. Replaces all prior versions.
  *
- * Copyright (c) 2013-2023, Esoteric Software LLC
+ * Copyright (c) 2013-2025, Esoteric Software LLC
  *
  * Integration of the Spine Runtimes into software or otherwise creating
  * derivative works of the Spine Runtimes is permitted under the terms and
  * conditions of Section 2 of the Spine Editor License Agreement:
  * http://esotericsoftware.com/spine-editor-license
  *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
  * "Products"), provided that each user of the Products must obtain their own
  * Spine Editor license and redistribution of the Products in any form must
  * include this license and copyright notice.
@@ -23,11 +23,11 @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
  * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-import { ExtensionType, InstructionSet, type Renderer, type RenderPipe } from 'pixi.js';
-import { Spine } from './Spine.js';
+import { ExtensionType, type InstructionSet, type Renderer, type RenderPipe } from 'pixi.js';
+import type { Spine } from './Spine.js';
 export declare class SpinePipe implements RenderPipe<Spine> {
     /** @ignore */
     static extension: {

package/dist/spine/lib/SpinePipe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpinePipe.d.ts","sourceRoot":"","sources":["../../../src/spine/lib/SpinePipe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAE/E,OAAO,EAEM,aAAa,EACzB,cAAc,EAGd,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAanC,qBAAa,SAAU,YAAW,UAAU,CAAC,KAAK,CAAC;IAClD,cAAc;IACd,MAAM,CAAC,SAAS;;;MAOL;IAEX,QAAQ,EAAE,QAAQ,CAAC;IAEnB,OAAO,CAAC,YAAY,CAA2C;IAC/D,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAwE;gBAEnG,QAAQ,EAAE,QAAQ;IAI/B,kBAAkB,CAAE,KAAK,EAAE,KAAK,GAAG,OAAO;IAoC1C,aAAa,CAAE,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,cAAc;IA+C3D,gBAAgB,CAAE,KAAK,EAAE,KAAK;IA0B9B,iBAAiB,CAAE,KAAK,EAAE,KAAK;IAK/B,OAAO;IAKP,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,aAAa;CAKrB"}
+{"version":3,"file":"SpinePipe.d.ts","sourceRoot":"","sources":["../../../src/spine/lib/SpinePipe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAG/E,OAAO,EAEU,aAAa,EAE7B,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAYxC,qBAAa,SAAU,YAAW,UAAU,CAAC,KAAK,CAAC;IAClD,cAAc;IACd,MAAM,CAAC,SAAS;;;MAOL;IAEX,QAAQ,EAAE,QAAQ,CAAC;IAEnB,OAAO,CAAC,YAAY,CAA2C;IAC/D,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAwE;gBAEnG,QAAQ,EAAE,QAAQ;IAI/B,kBAAkB,CAAE,KAAK,EAAE,KAAK,GAAG,OAAO;IAoC1C,aAAa,CAAE,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,cAAc;IAqD3D,gBAAgB,CAAE,KAAK,EAAE,KAAK;IA0B9B,iBAAiB,CAAE,KAAK,EAAE,KAAK;IAK/B,OAAO;IAKP,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,aAAa;CAKrB"}

package/dist/spine/lib/SpinePipe.js

@@ -1,16 +1,16 @@
-/** ****************************************************************************
+/******************************************************************************
  * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
+ * Last updated April 5, 2025. Replaces all prior versions.
  *
- * Copyright (c) 2013-2023, Esoteric Software LLC
+ * Copyright (c) 2013-2025, Esoteric Software LLC
  *
  * Integration of the Spine Runtimes into software or otherwise creating
  * derivative works of the Spine Runtimes is permitted under the terms and
  * conditions of Section 2 of the Spine Editor License Agreement:
  * http://esotericsoftware.com/spine-editor-license
  *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
  * "Products"), provided that each user of the Products must obtain their own
  * Spine Editor license and redistribution of the Products in any form must
  * include this license and copyright notice.
@@ -23,12 +23,12 @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
  * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
-import { collectAllRenderables, extensions, ExtensionType, } from 'pixi.js';
-import { BatchableSpineSlot } from './BatchableSpineSlot.js';
 import { MeshAttachment, RegionAttachment } from '@esotericsoftware/spine-core';
+import { ExtensionType, extensions, } from 'pixi.js';
+import { BatchableSpineSlot } from './BatchableSpineSlot.js';
 const spineBlendModeMap = {
     0: 'normal',
     1: 'add',
@@ -83,19 +83,24 @@ export class SpinePipe {
             const slot = drawOrder[i];
             const attachment = slot.getAttachment();
             const blendMode = spineBlendModeMap[slot.data.blendMode];
+            let skipRender = false;
             if (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment) {
                 const cacheData = spine._getCachedData(slot, attachment);
                 const batchableSpineSlot = (_a = gpuSpine.slotBatches)[_b = cacheData.id] || (_a[_b] = new BatchableSpineSlot());
                 batchableSpineSlot.setData(spine, cacheData, blendMode, roundPixels);
-                if (!cacheData.skipRender) {
+                skipRender = cacheData.skipRender;
+                if (!skipRender) {
                     batcher.addToBatch(batchableSpineSlot, instructionSet);
                 }
             }
             const containerAttachment = spine._slotsObject[slot.data.name];
             if (containerAttachment) {
                 const container = containerAttachment.container;
-                container.includeInBuild = true;
-                collectAllRenderables(container, instructionSet, this.renderer);
+                if (!skipRender) {
+                    container.includeInBuild = true;
+                    // See https://github.com/pixijs/pixijs/blob/b4c050a791fe65e979e467c9cba2bda0c01a1c35/src/scene/container/utils/collectAllRenderables.ts#L28
+                    container.collectRenderables(instructionSet, this.renderer, null);
+                }
                 container.includeInBuild = false;
             }
         }

package/dist/spine/lib/SpineTexture.d.ts

@@ -1,16 +1,16 @@
-/** ****************************************************************************
+/******************************************************************************
  * Spine Runtimes License Agreement
- * Last updated July 28, 2023. Replaces all prior versions.
+ * Last updated April 5, 2025. Replaces all prior versions.
  *
- * Copyright (c) 2013-2023, Esoteric Software LLC
+ * Copyright (c) 2013-2025, Esoteric Software LLC
  *
  * Integration of the Spine Runtimes into software or otherwise creating
  * derivative works of the Spine Runtimes is permitted under the terms and
  * conditions of Section 2 of the Spine Editor License Agreement:
  * http://esotericsoftware.com/spine-editor-license
  *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software or
- * otherwise create derivative works of the Spine Runtimes (collectively,
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
  * "Products"), provided that each user of the Products must obtain their own
  * Spine Editor license and redistribution of the Products in any form must
  * include this license and copyright notice.
@@ -23,8 +23,8 @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
  * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
- * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
 import { Texture as PixiTexture } from 'pixi.js';
 import { BlendMode, Texture, TextureFilter, TextureWrap } from '@esotericsoftware/spine-core';