A way to know spine bounds

KirillMu

Hi im using folowing code to get spine bounds, but it does not work as expected returned rects are smaller than a spine scene.
Google leads me to a similar code.
What is wrong, help plz
Spine bounding rect is not a case for me

private static getFrameRect(spine:PIXI.spine.Spine)
{
    let skeleton:PIXI.spine.core.Skeleton = spine.skeleton;
    var left   =  0xffff;
    var top    =  0xffff;
    var bottom = -0xffff;
    var right  = -0xffff;
    for (var i = 0, n = skeleton.slots.length; i < n; i++) {
        let slot:PIXI.spine.core.Slot = skeleton.slots[i];
        let attachment = slot.getAttachment();
        if (!attachment) continue;
        

    if (!(attachment instanceof PIXI.spine.core.RegionAttachment)) continue;
    let imageRegion:PIXI.spine.core.RegionAttachment = attachment as PIXI.spine.core.RegionAttachment;
    let vertices = new Array();
    imageRegion.computeWorldVertices(slot.bone, vertices, 0, 2);
                
    left   = Math.min(vertices[0], left);
    top    = Math.min(vertices[1], top);
    right  = Math.max(vertices[0], right);
    bottom = Math.max(vertices[1], bottom);

    left   = Math.min(vertices[2], left);
    top    = Math.min(vertices[3], top);
    right  = Math.max(vertices[2], right);
    bottom = Math.max(vertices[3], bottom);

    left   = Math.min(vertices[4], left);
    top    = Math.min(vertices[5], top);
    right  = Math.max(vertices[4], right);
    bottom = Math.max(vertices[5], bottom);

    left   = Math.min(vertices[6], left);
    top    = Math.min(vertices[7], top);
    right  = Math.max(vertices[6], right);
    bottom = Math.max(vertices[7], bottom);

}        
 var res = {
    "l":left,
    "t":top,
    "r":right,
    "b":bottom
 };
return res;
}

Nate

This code only looks at RegionAttachment. If your skeleton has one or more MeshAttachment, the mesh vertices are not considered for the bounds. Also your code does not handle ClippingAttachment.

You basically want to do what is involved for skeleton rendering: go through the slots, if the slot's attachment is a region or mesh then compute the world vertices, taking into account clipping (if that is important to you). You could look at skeleton renderers to see how to add meshes and clipping to your code. For example, here is computing mesh vertices:
https://github.com/EsotericSoftware/spine-runtimes/blob/3.8/spine-ts/webgl/src/SkeletonRenderer.ts#L112-L120
You'd then check the world vertices, similar to what you do for the 4 region vertices (renderable.vertices in that code).

Clipping is a little trickier. If you need that, I would probably take the whole draw function and rip out everything except region and mesh world vertex computation and the clipping.

Also note that you need to apply any animations, then call Skeleton updateWorldTransform so that the bones' world transforms are computed for the current pose. Only then can you apply the code you have shown, which uses the bone world transform. If you only care about region attachments, then that is probably all you need to do to make the code you have work.

The bounds will of course likely change when your skeleton is animating.

Edit: haha, I forgot we actually added a Skeleton getBounds method for calculating the bounds:
https://github.com/EsotericSoftware/spine-runtimes/blob/3.8/spine-ts/core/src/Skeleton.ts#L572
So you can just use that. You'd only need to do as I described above if you care about clipping.