Hi everyone,

I'm still new to Spine, and it's a very nice program, but I was a bit surprised to see that you can't strip whitespace in atlas export when using meshes. This means that atlases can become grossly inefficient unless you pre-trim pieces, which would then add much wasted effort, at least in my simple workflow.

The reasoning behind this seems to be that too much whitespace might get trimmed away so mesh regions might bleed into each other, and therefore it's not worth doing at all. But usually to remove the bleeding all you would have to do is add a few more pixels of padding in the atlas and/or keep your meshes reasonably tight around the image boundary. This is good practice anyway as it conserves fill-rate when the game is running.

Anyway, here's a fix I managed to hack together for the spine-csharp runtime. It looks nasty, but it's simple enough to add, and it works for all the cases that I was able to test in Unity.

In both the SkinnedMeshAttachment.cs and MeshAttachment.cs source files in the spine-csharp runtime, find the following lines of code:

if (RegionRotate) {
   for (int i = 0, n = uvs.Length; i < n; i += 2) {
      uvs[i] = u + regionUVs[i + 1] * width;
      uvs[i + 1] = v + height - regionUVs[i] * height;
   }
} else {
   for (int i = 0, n = uvs.Length; i < n; i += 2) {
      uvs[i] = u + regionUVs[i] * width;
      uvs[i + 1] = v + regionUVs[i + 1] * height;
   }
}

And replace the above with these new lines of code:

// NEW CODE: Handles whitespace-trimmed meshes inside an atlas.
// note: If the edges of the mesh textures bleed into each other at all,
//       try adding a little more padding in the atlas export settings,
//      and/or tighten up your meshes so that they hug the image closer.
if (RegionRotate) {
   float uScale = width * regionOriginalHeight / regionHeight;
   float vScale = height * regionOriginalWidth / regionWidth;
   float uOffs = u + width*(1.0f-regionOriginalHeight/regionHeight) + uScale * regionOffsetY/regionOriginalHeight;
   float vOffs = v + height + vScale * regionOffsetX/regionOriginalWidth;
   for (int i = 0, n = uvs.Length; i < n; i += 2) {
      uvs[i] = uOffs + regionUVs[i + 1] * uScale;
      uvs[i + 1] = vOffs - regionUVs[i] * vScale;
   }
} else {
   float uScale = width * regionOriginalWidth / regionWidth;
   float vScale = height * regionOriginalHeight / regionHeight;
   float uOffs = u - uScale * regionOffsetX/regionOriginalWidth;
   float vOffs = v + height*(1.0f-regionOriginalHeight/regionHeight) + vScale * regionOffsetY/regionOriginalHeight;
   for (int i = 0, n = uvs.Length; i < n; i += 2) {
      uvs[i] = uOffs + regionUVs[i] * uScale;
      uvs[i + 1] = vOffs + regionUVs[i + 1] * vScale;
   }
}

I imagine that the code fragment in other Spine runtimes would be very similar, and this patch could almost be dropped in there too without much modification.

Cheers,
Jules