Sorting Layer with multiple skeleton textures - issue.

decoamorim

Hey guys, i am having trouble with this again. If the images are separated with multiple texture maps, i just can't use the meshes separators. If i do add them, the meshes do not even spawn in the hieararchy.

Multiple images packed.

Spawned Submeshes

The images are not even in the order they should be as they are in the Spine project.
For example, objects in the mouth of the character are in the same mesh of the front leg. I just did not get the way this is ordered.

Someone knows what we are missing here?

NOTE: we r using spine 2.1.27 because of our coding, but if this is fixed in 3.0 we ll have to update.

29 Jul 2016, 01:50

Well i did one thing, i dont know if its the best option. It seems to be running light also.
But set it the output size to 16384 x 16384 in the Texture Packeg Settings. It made a huge file with all images, and i was able to separate the meshes again as i wanted. Arms and torso.

But in the other method it did not worked.

Pharan

Wow. Okay, 16384x16384 may not be a good idea. I'm not sure if majority of GPUs support that.
But anyway, this functionality has since been replaced with SkeletonRenderSeparator: https://github.com/pharan/spine-unity-docs/blob/master/SkeletonRenderSeparator.md.

Firstly, I'm not sure what the screenshots are showing. I also don't know what "SubmeshOrganizer" is.
Secondly, can you share your old version of SkeletonRenderer.cs so we can see what exactly it's doing?

It's also possible that your Submesh # GameObjects are not set correctly. Check the sorting layer and order in layer of each and see if they are in the correct order.

decoamorim

Hello Pharan,

Thanks for the help here.

So about the 16384x16384 , i calculated the 4k resolution times four , thats why this size, so all the images could fit in one map. But the end result file size image is is 11708x11708, and in UNITY is converted to 4096x4096 or the selected size in the resolution settings.

Pharan ：
Wow. Okay, 16384x16384 may not be a good idea. I'm not sure if majority of GPUs support that.

About that, the things that matter arents the images rendered? Because, in that big image file, most of the images wont show, they are other characters clothes, itens, skins. So, from that big image file, just a few images are being renderer. For example: a pair of gloves, legs, arms, torsos, shorts. Only one each.

About game performance, really seems to be working as it was before. The difference is that, instead of exporting the image map to size 0.3 it is exported to size 1.0, in Spine.

In 4096x4096 the file size is 46mb
If 2048x2048 the file size is 16mb.

But anyway, this functionality has since been replaced with SkeletonRenderSeparator: https://github.com/pharan/spine-unity-docs/blob/master/SkeletonRenderSeparator.md.

This RendererSeparator is from the latest update? For spine 3.0? Because i tryied to update our game, but it does present a lot of bugs. And as we have a dead line here, i ll keep this version in Spine 2.1.27 . It is a really solid project, wouldnt be smart to update due to the deadline.

Pharan ：
Firstly, I'm not sure what the screenshots are showing. I also don't know what "SubmeshOrganizer" is.
Secondly, can you share your old version of SkeletonRenderer.cs so we can see what exactly it's doing?

SubmeshOrganizer, sorry that is there and it is confusing. Its a script i made. The scripts set all meshes (thats why there is an array there) to a sorting layer, depending if it is player one or player two it will send to one layer example Layer Body1 and Layer Body2, and to a sorting layer order.

It's also possible that your Submesh # GameObjects are not set correctly. Check the sorting layer and order in layer of each and see if they are in the correct order.

Yes they are, that was what that script SubmeshOrganizer was automatically doing. The issue is that it created more than 20 submeshes and the sepataror do not spawn any mesh when there is more than one image map.
Now that all images are in only one map, it is working again. I separated the back arm, from the torso and the front leg. But using that huge image mentioned earlier.

SkeletonRenderer

 * Spine Runtimes Software License
 * Version 2.3
 * 
 * Copyright (c) 2013-2015, Esoteric Software
 * All rights reserved.
 * 
 * You are granted a perpetual, non-exclusive, non-sublicensable and
 * non-transferable license to use, install, execute and perform the Spine
 * Runtimes Software (the "Software") and derivative works solely for personal
 * or internal use. Without the written permission of Esoteric Software (see
 * Section 2 of the Spine Software License Agreement), you may not (a) modify,
 * translate, adapt or otherwise create derivative works, improvements of the
 * Software or develop new applications using the Software or (b) remove,
 * delete, alter or obscure any trademarks or any copyright, trademark, patent
 * or other intellectual property or proprietary rights notices on or in the
 * Software, including any copy thereof. Redistributions in binary or source
 * form must include this license and terms.
 * 
 * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) 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 THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

using System;
using System.Collections.Generic;
using UnityEngine;
using Spine;

/// <summary>Renders a skeleton.</summary>
[ExecuteInEditMode, RequireComponent(typeof(MeshFilter), typeof(MeshRenderer)), DisallowMultipleComponent]
public class SkeletonRenderer : MonoBehaviour {

   public delegate void SkeletonRendererDelegate (SkeletonRenderer skeletonRenderer);
   public SkeletonRendererDelegate OnRebuild;

   public SkeletonDataAsset skeletonDataAsset;
   public String initialSkinName;

   #region Advanced
   public bool calculateNormals, calculateTangents;
   public float zSpacing;
   public bool renderMeshes = true, immutableTriangles;
   public bool frontFacing;
   public bool logErrors = false;

   // Submesh Separation
   [SpineSlot] public string[] submeshSeparators = new string[0];
   [HideInInspector] public List<Slot> submeshSeparatorSlots = new List<Slot>();

   // Custom Slot Material
   [System.NonSerialized] private readonly Dictionary<Slot, Material> customSlotMaterials = new Dictionary<Slot, Material>();
   public Dictionary<Slot, Material> CustomSlotMaterials { get { return customSlotMaterials; } }
   #endregion

   [System.NonSerialized] public bool valid;
   [System.NonSerialized] public Skeleton skeleton;

   private MeshRenderer meshRenderer;
   private MeshFilter meshFilter;

   private Mesh mesh1, mesh2;
   private bool useMesh1;

   private float[] tempVertices = new float[8];
   private Vector3[] vertices;
   private Color32[] colors;
   private Vector2[] uvs;
   private Material[] sharedMaterials = new Material[0];

   private MeshState meshState = new MeshState();
   private readonly ExposedList<Material> submeshMaterials = new ExposedList<Material>();
   private readonly ExposedList<Submesh> submeshes = new ExposedList<Submesh>();
   private SkeletonUtilitySubmeshRenderer[] submeshRenderers;

   #region Runtime Instantiation
   /// <summary>Add and prepare a Spine component that derives from SkeletonRenderer to a GameObject at runtime.</summary>
   /// <typeparam name="T">T should be SkeletonRenderer or any of its derived classes.</typeparam>
   public static T AddSpineComponent<T> (GameObject gameObject, SkeletonDataAsset skeletonDataAsset) where T : SkeletonRenderer {
      

  var c = gameObject.AddComponent<T>();

  if (skeletonDataAsset != null) {
     c.skeletonDataAsset = skeletonDataAsset;
     c.Initialize(false);
  }

  return c;
   }

   public static T NewSpineGameObject<T> (SkeletonDataAsset skeletonDataAsset) where T : SkeletonRenderer {
      return SkeletonRenderer.AddSpineComponent<T>(new GameObject("New Spine GameObject"), skeletonDataAsset);
   }
   #endregion

   public virtual void Awake () {
      Initialize(false);
   }

   public virtual void Initialize (bool overwrite) {
      if (valid && !overwrite)
         return;

  // Clear
  {
     if (meshFilter != null)
        meshFilter.sharedMesh = null;

     meshRenderer = GetComponent<MeshRenderer>();
     if (meshRenderer != null) meshRenderer.sharedMaterial = null;

     meshState = new MeshState();
     mesh1 = null;
     mesh2 = null;
     vertices = null;
     colors = null;
     uvs = null;
     sharedMaterials = new Material[0];
     submeshMaterials.Clear();
     submeshes.Clear();
     skeleton = null;

     valid = false;
  }

  if (!skeletonDataAsset) {
     if (logErrors)
        Debug.LogError("Missing SkeletonData asset.", this);

     return;
  }
  SkeletonData skeletonData = skeletonDataAsset.GetSkeletonData(false);
  if (skeletonData == null)
     return;
  valid = true;

  meshFilter = GetComponent<MeshFilter>();
  meshRenderer = GetComponent<MeshRenderer>();
  mesh1 = Spine.Unity.SpineMesh.NewMesh();
  mesh2 = Spine.Unity.SpineMesh.NewMesh();
  vertices = new Vector3[0];

  skeleton = new Skeleton(skeletonData);
  if (initialSkinName != null && initialSkinName.Length > 0 && initialSkinName != "default")
     skeleton.SetSkin(initialSkinName);

  submeshSeparatorSlots.Clear();
  for (int i = 0; i < submeshSeparators.Length; i++) {
     submeshSeparatorSlots.Add(skeleton.FindSlot(submeshSeparators[i]));
  }

  CollectSubmeshRenderers();

  LateUpdate();

  if (OnRebuild != null)
     OnRebuild(this);
   }

   public void CollectSubmeshRenderers () {
      submeshRenderers = GetComponentsInChildren<SkeletonUtilitySubmeshRenderer>();
   }

   public virtual void LateUpdate () {
      if (!valid)
         return;

  // Exit early if there is nothing to render
  if (!meshRenderer.enabled && submeshRenderers.Length == 0)
     return;

  // This method caches several .Items arrays. Whenever it does, there should be no mutations done on the overlying ExposedList object.

  // Count vertices and submesh triangles.
  int vertexCount = 0;

  int submeshTriangleCount = 0, submeshFirstVertex = 0, submeshStartSlotIndex = 0;
  Material lastMaterial = null;
  ExposedList<Slot> drawOrder = skeleton.drawOrder;
  var drawOrderItems = drawOrder.Items;
  int drawOrderCount = drawOrder.Count;
  int submeshSeparatorSlotsCount = submeshSeparatorSlots.Count;
  bool renderMeshes = this.renderMeshes;

  // Clear last state of attachments and submeshes
  MeshState.SingleMeshState workingState = meshState.buffer;
  var workingAttachments = workingState.attachments;
  workingAttachments.Clear(true);
  workingState.UpdateAttachmentCount(drawOrderCount);
  var workingAttachmentsItems = workingAttachments.Items;

  var workingFlips = workingState.attachmentsFlipState;
  var workingFlipsItems = workingState.attachmentsFlipState.Items;

  var workingSubmeshArguments = workingState.addSubmeshArguments;   // Items array should not be cached. There is dynamic writing to this object.
  workingSubmeshArguments.Clear(false);

  MeshState.SingleMeshState storedState = useMesh1 ? meshState.stateMesh1 : meshState.stateMesh2;
  var storedAttachments = storedState.attachments;
  var storedAttachmentsItems = storedAttachments.Items;

  var storedFlips = storedState.attachmentsFlipState;
  var storedFlipsItems = storedFlips.Items;

  bool mustUpdateMeshStructure = storedState.requiresUpdate ||   // Force update if the mesh was cleared. (prevents flickering due to incorrect state)
     drawOrderCount != storedAttachments.Count ||            // Number of slots changed (when does this happen?)
     immutableTriangles != storedState.immutableTriangles;      // Immutable Triangles flag changed.

  bool isCustomMaterialsPopulated = customSlotMaterials.Count > 0;

  for (int i = 0; i < drawOrderCount; i++) {
     Slot slot = drawOrderItems[i];
     Bone bone = slot.bone;
     Attachment attachment = slot.attachment;

     object rendererObject; // An AtlasRegion in plain Spine-Unity. Spine-TK2D hooks into TK2D's system. eventual source of Material object.
     int attachmentVertexCount, attachmentTriangleCount;

     // Handle flipping for triangle winding (for lighting?).           
     bool flip = frontFacing && (bone.WorldSignX != bone.WorldSignY);

     workingFlipsItems[i] = flip;
     workingAttachmentsItems[i] = attachment;

     mustUpdateMeshStructure = mustUpdateMeshStructure ||   // Always prefer short circuited or. || and not |=.
        (attachment != storedAttachmentsItems[i]) ||       // Attachment order changed. // This relies on the drawOrder.Count != storedAttachments.Count check above as a bounds check.
        (flip != storedFlipsItems[i]);                  // Flip states changed.

     var regionAttachment = attachment as RegionAttachment;
     if (regionAttachment != null) {
        rendererObject = regionAttachment.RendererObject;
        attachmentVertexCount = 4;
        attachmentTriangleCount = 6;
     } else {
        if (!renderMeshes)
           continue;
        var meshAttachment = attachment as MeshAttachment;
        if (meshAttachment != null) {
           rendererObject = meshAttachment.RendererObject;
           attachmentVertexCount = meshAttachment.vertices.Length >> 1;
           attachmentTriangleCount = meshAttachment.triangles.Length;
        } else {
           var skinnedMeshAttachment = attachment as WeightedMeshAttachment;
           if (skinnedMeshAttachment != null) {
              rendererObject = skinnedMeshAttachment.RendererObject;
              attachmentVertexCount = skinnedMeshAttachment.uvs.Length >> 1;
              attachmentTriangleCount = skinnedMeshAttachment.triangles.Length;
           } else
              continue;
        }
     }

     #if !SPINE_TK2D
     // Material material = (Material)((AtlasRegion)rendererObject).page.rendererObject; // For no customSlotMaterials

     Material material;
     if (isCustomMaterialsPopulated) {
        if (!customSlotMaterials.TryGetValue(slot, out material)) {
           material = (Material)((AtlasRegion)rendererObject).page.rendererObject;
        }
     } else {
        material = (Material)((AtlasRegion)rendererObject).page.rendererObject;
     }
     #else
     Material material = (rendererObject.GetType() == typeof(Material)) ? (Material)rendererObject : (Material)((AtlasRegion)rendererObject).page.rendererObject;
     #endif

     // Populate submesh when material changes. (or when forced to separate by a submeshSeparator)
     if ((vertexCount > 0 && lastMaterial.GetInstanceID() != material.GetInstanceID()) ||
        (submeshSeparatorSlotsCount > 0 && submeshSeparatorSlots.Contains(slot))) {

        workingSubmeshArguments.Add(
           new MeshState.AddSubmeshArguments {
              material = lastMaterial,
              startSlot = submeshStartSlotIndex,
              endSlot = i,
              triangleCount = submeshTriangleCount,
              firstVertex = submeshFirstVertex,
              isLastSubmesh = false
           }
        );

        submeshTriangleCount = 0;
        submeshFirstVertex = vertexCount;
        submeshStartSlotIndex = i;
     }
     lastMaterial = material;

     submeshTriangleCount += attachmentTriangleCount;
     vertexCount += attachmentVertexCount;
  }


  workingSubmeshArguments.Add(
     new MeshState.AddSubmeshArguments {
        material = lastMaterial,
        startSlot = submeshStartSlotIndex,
        endSlot = drawOrderCount,
        triangleCount = submeshTriangleCount,
        firstVertex = submeshFirstVertex,
        isLastSubmesh = true
     }
  );

  mustUpdateMeshStructure = mustUpdateMeshStructure ||
     this.sharedMaterials.Length != workingSubmeshArguments.Count ||      // Material array changed in size
     CheckIfMustUpdateMeshStructure(workingSubmeshArguments);         // Submesh Argument Array changed.

  // CheckIfMustUpdateMaterialArray (workingMaterials, sharedMaterials)
  if (!mustUpdateMeshStructure) {
     // Narrow phase material array check.
     var workingMaterials = workingSubmeshArguments.Items;
     for (int i = 0, n = sharedMaterials.Length; i < n; i++) {
        if (this.sharedMaterials[i] != workingMaterials[i].material) {   // Bounds check is implied above.
           mustUpdateMeshStructure = true;
           break;
        }
     }
  }

  // NOT ELSE

  if (mustUpdateMeshStructure) {
     this.submeshMaterials.Clear();

     var workingSubmeshArgumentsItems = workingSubmeshArguments.Items;
     for (int i = 0, n = workingSubmeshArguments.Count; i < n; i++) {
        AddSubmesh(workingSubmeshArgumentsItems[i], workingFlips);
     }

     // Set materials.
     if (submeshMaterials.Count == sharedMaterials.Length)
        submeshMaterials.CopyTo(sharedMaterials);
     else
        sharedMaterials = submeshMaterials.ToArray();

     meshRenderer.sharedMaterials = sharedMaterials;
  }


  // Ensure mesh data is the right size.
  Vector3[] vertices = this.vertices;
  bool newTriangles = vertexCount > vertices.Length;
  if (newTriangles) {
     // Not enough vertices, increase size.
     this.vertices = vertices = new Vector3[vertexCount];
     this.colors = new Color32[vertexCount];
     this.uvs = new Vector2[vertexCount];

     mesh1.Clear();
     mesh2.Clear();
     meshState.stateMesh1.requiresUpdate = true;
     meshState.stateMesh2.requiresUpdate = true;

  } else {
     // Too many vertices, zero the extra.
     Vector3 zero = Vector3.zero;
     for (int i = vertexCount, n = meshState.vertexCount; i < n; i++)
        vertices[i] = zero;
  }
  meshState.vertexCount = vertexCount;

  // Setup mesh.
  float zSpacing = this.zSpacing;
  float[] tempVertices = this.tempVertices;
  Vector2[] uvs = this.uvs;
  Color32[] colors = this.colors;
  int vertexIndex = 0;
  Color32 color;
  float a = skeleton.a * 255, r = skeleton.r, g = skeleton.g, b = skeleton.b;

  Vector3 meshBoundsMin;
  Vector3 meshBoundsMax;
  if (vertexCount == 0) {
     meshBoundsMin = new Vector3(0, 0, 0);
     meshBoundsMax = new Vector3(0, 0, 0);
  } else {
     meshBoundsMin.x = int.MaxValue;
     meshBoundsMin.y = int.MaxValue;
     meshBoundsMax.x = int.MinValue;
     meshBoundsMax.y = int.MinValue;
     if (zSpacing > 0f) {
        meshBoundsMin.z = 0f;
        meshBoundsMax.z = zSpacing * (drawOrderCount - 1);
     } else {
        meshBoundsMin.z = zSpacing * (drawOrderCount - 1);
        meshBoundsMax.z = 0f;
     }
     int i = 0;
     do {
        Slot slot = drawOrderItems[i];
        Attachment attachment = slot.attachment;
        RegionAttachment regionAttachment = attachment as RegionAttachment;
        if (regionAttachment != null) {
           regionAttachment.ComputeWorldVertices(slot.bone, tempVertices);

           float z = i * zSpacing;
           float x1 = tempVertices[RegionAttachment.X1], y1 = tempVertices[RegionAttachment.Y1];
           float x2 = tempVertices[RegionAttachment.X2], y2 = tempVertices[RegionAttachment.Y2];
           float x3 = tempVertices[RegionAttachment.X3], y3 = tempVertices[RegionAttachment.Y3];
           float x4 = tempVertices[RegionAttachment.X4], y4 = tempVertices[RegionAttachment.Y4];
           vertices[vertexIndex].x = x1;
           vertices[vertexIndex].y = y1;
           vertices[vertexIndex].z = z;
           vertices[vertexIndex + 1].x = x4;
           vertices[vertexIndex + 1].y = y4;
           vertices[vertexIndex + 1].z = z;
           vertices[vertexIndex + 2].x = x2;
           vertices[vertexIndex + 2].y = y2;
           vertices[vertexIndex + 2].z = z;
           vertices[vertexIndex + 3].x = x3;
           vertices[vertexIndex + 3].y = y3;
           vertices[vertexIndex + 3].z = z;

           color.a = (byte)(a * slot.a * regionAttachment.a);
           color.r = (byte)(r * slot.r * regionAttachment.r * color.a);
           color.g = (byte)(g * slot.g * regionAttachment.g * color.a);
           color.b = (byte)(b * slot.b * regionAttachment.b * color.a);
           if (slot.data.blendMode == BlendMode.additive) color.a = 0;
           colors[vertexIndex] = color;
           colors[vertexIndex + 1] = color;
           colors[vertexIndex + 2] = color;
           colors[vertexIndex + 3] = color;

           float[] regionUVs = regionAttachment.uvs;
           uvs[vertexIndex].x = regionUVs[RegionAttachment.X1];
           uvs[vertexIndex].y = regionUVs[RegionAttachment.Y1];
           uvs[vertexIndex + 1].x = regionUVs[RegionAttachment.X4];
           uvs[vertexIndex + 1].y = regionUVs[RegionAttachment.Y4];
           uvs[vertexIndex + 2].x = regionUVs[RegionAttachment.X2];
           uvs[vertexIndex + 2].y = regionUVs[RegionAttachment.Y2];
           uvs[vertexIndex + 3].x = regionUVs[RegionAttachment.X3];
           uvs[vertexIndex + 3].y = regionUVs[RegionAttachment.Y3];

           // Calculate min/max X
           if (x1 < meshBoundsMin.x)
              meshBoundsMin.x = x1;
           else if (x1 > meshBoundsMax.x)
              meshBoundsMax.x = x1;
           if (x2 < meshBoundsMin.x)
              meshBoundsMin.x = x2;
           else if (x2 > meshBoundsMax.x)
              meshBoundsMax.x = x2;
           if (x3 < meshBoundsMin.x)
              meshBoundsMin.x = x3;
           else if (x3 > meshBoundsMax.x)
              meshBoundsMax.x = x3;
           if (x4 < meshBoundsMin.x)
              meshBoundsMin.x = x4;
           else if (x4 > meshBoundsMax.x)
              meshBoundsMax.x = x4;

           // Calculate min/max Y
           if (y1 < meshBoundsMin.y)
              meshBoundsMin.y = y1;
           else if (y1 > meshBoundsMax.y)
              meshBoundsMax.y = y1;
           if (y2 < meshBoundsMin.y)
              meshBoundsMin.y = y2;
           else if (y2 > meshBoundsMax.y)
              meshBoundsMax.y = y2;
           if (y3 < meshBoundsMin.y)
              meshBoundsMin.y = y3;
           else if (y3 > meshBoundsMax.y)
              meshBoundsMax.y = y3;
           if (y4 < meshBoundsMin.y)
              meshBoundsMin.y = y4;
           else if (y4 > meshBoundsMax.y)
              meshBoundsMax.y = y4;

           vertexIndex += 4;
        } else {
           if (!renderMeshes)
              continue;
           MeshAttachment meshAttachment = attachment as MeshAttachment;
           if (meshAttachment != null) {
              int meshVertexCount = meshAttachment.vertices.Length;
              if (tempVertices.Length < meshVertexCount)
                 this.tempVertices = tempVertices = new float[meshVertexCount];
              meshAttachment.ComputeWorldVertices(slot, tempVertices);

              color.a = (byte)(a * slot.a * meshAttachment.a);
              color.r = (byte)(r * slot.r * meshAttachment.r * color.a);
              color.g = (byte)(g * slot.g * meshAttachment.g * color.a);
              color.b = (byte)(b * slot.b * meshAttachment.b * color.a);
              if (slot.data.blendMode == BlendMode.additive) color.a = 0;

              float[] meshUVs = meshAttachment.uvs;
              float z = i * zSpacing;
              for (int ii = 0; ii < meshVertexCount; ii += 2, vertexIndex++) {
                 float x = tempVertices[ii], y = tempVertices[ii + 1];
                 vertices[vertexIndex].x = x;
                 vertices[vertexIndex].y = y;
                 vertices[vertexIndex].z = z;
                 colors[vertexIndex] = color;
                 uvs[vertexIndex].x = meshUVs[ii];
                 uvs[vertexIndex].y = meshUVs[ii + 1];

                 if (x < meshBoundsMin.x)
                    meshBoundsMin.x = x;
                 else if (x > meshBoundsMax.x)
                    meshBoundsMax.x = x;
                 if (y < meshBoundsMin.y)
                    meshBoundsMin.y = y;
                 else if (y > meshBoundsMax.y)
                    meshBoundsMax.y = y;
              }
           } else {
              WeightedMeshAttachment weightedMeshAttachment = attachment as WeightedMeshAttachment;
              if (weightedMeshAttachment != null) {
                 int meshVertexCount = weightedMeshAttachment.uvs.Length;
                 if (tempVertices.Length < meshVertexCount)
                    this.tempVertices = tempVertices = new float[meshVertexCount];
                 weightedMeshAttachment.ComputeWorldVertices(slot, tempVertices);

                 color.a = (byte)(a * slot.a * weightedMeshAttachment.a);
                 color.r = (byte)(r * slot.r * weightedMeshAttachment.r * color.a);
                 color.g = (byte)(g * slot.g * weightedMeshAttachment.g * color.a);
                 color.b = (byte)(b * slot.b * weightedMeshAttachment.b * color.a);
                 if (slot.data.blendMode == BlendMode.additive) color.a = 0;

                 float[] meshUVs = weightedMeshAttachment.uvs;
                 float z = i * zSpacing;
                 for (int ii = 0; ii < meshVertexCount; ii += 2, vertexIndex++) {
                    float x = tempVertices[ii], y = tempVertices[ii + 1];
                    vertices[vertexIndex].x = x;
                    vertices[vertexIndex].y = y;
                    vertices[vertexIndex].z = z;
                    colors[vertexIndex] = color;
                    uvs[vertexIndex].x = meshUVs[ii];
                    uvs[vertexIndex].y = meshUVs[ii + 1];

                    if (x < meshBoundsMin.x)
                       meshBoundsMin.x = x;
                    else if (x > meshBoundsMax.x)
                       meshBoundsMax.x = x;
                    if (y < meshBoundsMin.y)
                       meshBoundsMin.y = y;
                    else if (y > meshBoundsMax.y)
                       meshBoundsMax.y = y;
                 }
              }
           }
        }
     } while (++i < drawOrderCount);
  }

  // Double buffer mesh.
  Mesh mesh = useMesh1 ? mesh1 : mesh2;
  meshFilter.sharedMesh = mesh;

  mesh.vertices = vertices;
  mesh.colors32 = colors;
  mesh.uv = uvs;

  if (mustUpdateMeshStructure) {
     int submeshCount = submeshMaterials.Count;
     mesh.subMeshCount = submeshCount;
     for (int i = 0; i < submeshCount; ++i)
        mesh.SetTriangles(submeshes.Items[i].triangles, i);

     // Done updating mesh.
     storedState.requiresUpdate = false;
  }

  Vector3 meshBoundsExtents = meshBoundsMax - meshBoundsMin;
  Vector3 meshBoundsCenter = meshBoundsMin + meshBoundsExtents * 0.5f;
  mesh.bounds = new Bounds(meshBoundsCenter, meshBoundsExtents);

  if (newTriangles && calculateNormals) {
     Vector3[] normals = new Vector3[vertexCount];
     Vector3 normal = new Vector3(0, 0, -1);
     for (int i = 0; i < vertexCount; i++)
        normals[i] = normal;
     (useMesh1 ? mesh2 : mesh1).vertices = vertices; // Set other mesh vertices.
     mesh1.normals = normals;
     mesh2.normals = normals;

     if (calculateTangents) {
        Vector4[] tangents = new Vector4[vertexCount];
        Vector4 tangent = new Vector4(1, 0, 0, -1);
        for (int i = 0; i < vertexCount; i++)
           tangents[i] = tangent;
        mesh1.tangents = tangents;
        mesh2.tangents = tangents;
     }
  }
     
  // Update previous state
  storedState.immutableTriangles = immutableTriangles;

  storedAttachments.Clear(true);
  storedAttachments.GrowIfNeeded(workingAttachments.Capacity);
  storedAttachments.Count = workingAttachments.Count;
  workingAttachments.CopyTo(storedAttachments.Items);

  storedFlips.GrowIfNeeded(workingFlips.Capacity);
  storedFlips.Count = workingFlips.Count;
  workingFlips.CopyTo(storedFlips.Items);

  storedState.addSubmeshArguments.GrowIfNeeded(workingSubmeshArguments.Capacity);
  storedState.addSubmeshArguments.Count = workingSubmeshArguments.Count;
  workingSubmeshArguments.CopyTo(storedState.addSubmeshArguments.Items);


  // Submesh Renderers
  if (submeshRenderers.Length > 0) {
     for (int i = 0; i < submeshRenderers.Length; i++) {
        SkeletonUtilitySubmeshRenderer submeshRenderer = submeshRenderers[i];
        if (submeshRenderer.submeshIndex < sharedMaterials.Length) {
           submeshRenderer.SetMesh(meshRenderer, useMesh1 ? mesh1 : mesh2, sharedMaterials[submeshRenderer.submeshIndex]);
        } else {
           submeshRenderer.GetComponent<Renderer>().enabled = false;
        }
     }
  }

  useMesh1 = !useMesh1;
   }

   private bool CheckIfMustUpdateMeshStructure (ExposedList<MeshState.AddSubmeshArguments> workingAddSubmeshArguments) {
      #if UNITY_EDITOR
      if (!Application.isPlaying)
         return true;
      #endif

  // Check if any mesh settings were changed
  MeshState.SingleMeshState currentMeshState = useMesh1 ? meshState.stateMesh1 : meshState.stateMesh2;
  ExposedList<MeshState.AddSubmeshArguments> addSubmeshArgumentsCurrentMesh = currentMeshState.addSubmeshArguments;
  int submeshCount = workingAddSubmeshArguments.Count;
  if (addSubmeshArgumentsCurrentMesh.Count != submeshCount)
     return true;

  for (int i = 0; i < submeshCount; i++) {
     if (!addSubmeshArgumentsCurrentMesh.Items[i].Equals(ref workingAddSubmeshArguments.Items[i]))
        return true;
  }

  return false;
   }

   private void AddSubmesh (MeshState.AddSubmeshArguments submeshArguments, ExposedList<bool> flipStates) {
      int submeshIndex = submeshMaterials.Count;
      submeshMaterials.Add(submeshArguments.material);

  if (submeshes.Count <= submeshIndex)
     submeshes.Add(new Submesh());
  else if (immutableTriangles)
     return;

  Submesh currentSubmesh = submeshes.Items[submeshIndex];
  int[] triangles = currentSubmesh.triangles;

  int triangleCount = submeshArguments.triangleCount;
  int firstVertex = submeshArguments.firstVertex;

  int trianglesCapacity = triangles.Length;
  if (submeshArguments.isLastSubmesh && trianglesCapacity > triangleCount) {
     // Last submesh may have more triangles than required, so zero triangles to the end.
     for (int i = triangleCount; i < trianglesCapacity; i++) {
        triangles[i] = 0;
     }
     currentSubmesh.triangleCount = triangleCount;

  } else if (trianglesCapacity != triangleCount) {
     // Reallocate triangles when not the exact size needed.
     currentSubmesh.triangles = triangles = new int[triangleCount];
     currentSubmesh.triangleCount = 0;
  }

  if (!this.renderMeshes && !this.frontFacing) {
     // Use stored triangles if possible.
     if (currentSubmesh.firstVertex != firstVertex || currentSubmesh.triangleCount < triangleCount) { //|| currentSubmesh.triangleCount == 0
        currentSubmesh.triangleCount = triangleCount;
        currentSubmesh.firstVertex = firstVertex;

        for (int i = 0; i < triangleCount; i += 6, firstVertex += 4) {
           triangles[i] = firstVertex;
           triangles[i + 1] = firstVertex + 2;
           triangles[i + 2] = firstVertex + 1;
           triangles[i + 3] = firstVertex + 2;
           triangles[i + 4] = firstVertex + 3;
           triangles[i + 5] = firstVertex + 1;
        }

     }
     return;
  }

  // This method caches several .Items arrays. Whenever it does, there should be no mutations done on the overlying ExposedList object.
  // Iterate through all slots and store their triangles. 
  var drawOrderItems = skeleton.DrawOrder.Items;
  var flipStatesItems = flipStates.Items;

  int triangleIndex = 0; // Modified by loop
  for (int i = submeshArguments.startSlot, n = submeshArguments.endSlot; i < n; i++) {         
     Attachment attachment = drawOrderItems[i].attachment;

     bool flip = flipStatesItems[i];

     // Add RegionAttachment triangles
     if (attachment is RegionAttachment) {
        if (!flip) {
           triangles[triangleIndex] = firstVertex;
           triangles[triangleIndex + 1] = firstVertex + 2;
           triangles[triangleIndex + 2] = firstVertex + 1;
           triangles[triangleIndex + 3] = firstVertex + 2;
           triangles[triangleIndex + 4] = firstVertex + 3;
           triangles[triangleIndex + 5] = firstVertex + 1;
        } else {
           triangles[triangleIndex] = firstVertex + 1;
           triangles[triangleIndex + 1] = firstVertex + 2;
           triangles[triangleIndex + 2] = firstVertex;
           triangles[triangleIndex + 3] = firstVertex + 1;
           triangles[triangleIndex + 4] = firstVertex + 3;
           triangles[triangleIndex + 5] = firstVertex + 2;
        }

        triangleIndex += 6;
        firstVertex += 4;
        continue;
     }

     // Add (Weighted)MeshAttachment triangles
     int[] attachmentTriangles;
     int attachmentVertexCount;
     var meshAttachment = attachment as MeshAttachment;
     if (meshAttachment != null) {
        attachmentVertexCount = meshAttachment.vertices.Length >> 1; // length/2
        attachmentTriangles = meshAttachment.triangles;
     } else {
        var weightedMeshAttachment = attachment as WeightedMeshAttachment;
        if (weightedMeshAttachment != null) {
           attachmentVertexCount = weightedMeshAttachment.uvs.Length >> 1; // length/2
           attachmentTriangles = weightedMeshAttachment.triangles;
        } else
           continue;
     }

     if (flip) {
        for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii += 3, triangleIndex += 3) {
           triangles[triangleIndex + 2] = firstVertex + attachmentTriangles[ii];
           triangles[triangleIndex + 1] = firstVertex + attachmentTriangles[ii + 1];
           triangles[triangleIndex] = firstVertex + attachmentTriangles[ii + 2];
        }
     } else {
        for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii++, triangleIndex++) {
           triangles[triangleIndex] = firstVertex + attachmentTriangles[ii];
        }
        }

     firstVertex += attachmentVertexCount;
  }
   }

   #if UNITY_EDITOR
   void OnDrawGizmos () {
      // Make scene view selection easier by drawing a clear gizmo over the skeleton.
      meshFilter = GetComponent<MeshFilter>();
      if (meshFilter == null) return;

  Mesh mesh = meshFilter.sharedMesh;
  if (mesh == null) return;

  Bounds meshBounds = mesh.bounds;
  Gizmos.color = Color.clear;
  Gizmos.matrix = transform.localToWorldMatrix;
  Gizmos.DrawCube(meshBounds.center, meshBounds.size);
   }
   #endif

   private class MeshState {
      public int vertexCount;
      public readonly SingleMeshState buffer = new SingleMeshState();
      public readonly SingleMeshState stateMesh1 = new SingleMeshState();
      public readonly SingleMeshState stateMesh2 = new SingleMeshState();

  public class SingleMeshState {
     public bool immutableTriangles;
     public bool requiresUpdate;
     public readonly ExposedList<Attachment> attachments = new ExposedList<Attachment>();
     public readonly ExposedList<bool> attachmentsFlipState = new ExposedList<bool>();
     public readonly ExposedList<AddSubmeshArguments> addSubmeshArguments = new ExposedList<AddSubmeshArguments>();

     public void UpdateAttachmentCount (int attachmentCount) {
        attachmentsFlipState.GrowIfNeeded(attachmentCount);
        attachmentsFlipState.Count = attachmentCount;

        attachments.GrowIfNeeded(attachmentCount);
        attachments.Count = attachmentCount;
     }
  }

  public struct AddSubmeshArguments {
     public Material material;
     public int startSlot;
     public int endSlot;
     public int triangleCount;
     public int firstVertex;
     public bool isLastSubmesh;

     public bool Equals (ref AddSubmeshArguments other) {
        return
           //!ReferenceEquals(material, null) &&
           //!ReferenceEquals(other.material, null) &&
           //material.GetInstanceID() == other.material.GetInstanceID() &&
           startSlot == other.startSlot &&
           endSlot == other.endSlot &&
           triangleCount == other.triangleCount &&
           firstVertex == other.firstVertex;
     }
  }
   }
}

class Submesh {
   public int[] triangles = new int[0];
   public int triangleCount;
   public int firstVertex = -1;
}

29 Jul 2016, 17:12

Latest version, with submesh separators.

Images map file settings

Pharan

I don't think it's a good idea to update from 2.1.27 either if you are almost going to ship, especially if you rely on old-style scaling, etc.

What's "latest version"? Is something still wrong?
It looks like the SkeletonRenderer code isn't doing anything special. Just passing its mesh along to all the submesh renderers.

decoamorim

Pharan ：
What's "latest version"? Is something still wrong?
It looks like the SkeletonRenderer code isn't doing anything special. Just passing its mesh along to all the submesh renderers.

I called latest version because it was a printscreen from the last version of the project (the game not Spine). Well no, its working fine, but is running with that big file with all images packed.

But as i said/questioned, the things rendered in the screen are'nt the ones that matters? By that i mean it doesn't make any difference, or a relevent one? I am not 100% sure but i belive that is correct, since it is acctually working the same so far. We added a new game mode with four characters in the screen and its fine too, i do not own a boosted computer to run games its fullest so....but of course this will be tested in other machine configurations before releasing.
One thing i have learned is that the developer computer doesn't count for testing 😃 😃 😃

But if the export method come back to the previous method described in this topic, the one which will create many atlas, the issue will return.