/// <summary>
/// Resets the slot Z order to pose order.
/// </summary>
public void ResetSlotZOrder()
{
if (slots == null || slots.Length == 0)
{
return;
}
if (isUGUI)
{
int count = slots.Length;
for (int i = 0; i < count; ++i)
{
Slot slot = slots[i];
if (slot)
{
slot.transform.SetSiblingIndex(slot.zOrder);
#if UNITY_EDITOR
if (!Application.isPlaying)
{
UnityEditor.EditorUtility.SetDirty(slot.transform);
}
#endif
}
}
}
else
{
float tempZ = m_FlipX || m_FlipY ? 1f : -1f;
if (m_FlipX && m_FlipY)
{
tempZ = -1f;
}
tempZ *= zSpace;
int len = slots.Length;
for (int i = 0; i < len; ++i)
{
Slot slot = slots[i];
if (slot && !slot.manualZ)
{
Vector3 v = slot.transform.localPosition;
v.z = tempZ * slot.zOrder + tempZ;
slot.transform.localPosition = v;
slot.z = 0;
if (sortType == SortType.ZOrder)
{
slot.UpdateZOrder(slot.zOrder);
}
#if UNITY_EDITOR
if (!Application.isPlaying)
{
UnityEditor.EditorUtility.SetDirty(slot.transform);
}
#endif
}
}
m_SortedSlots = null;
}
m_OrderSlots.Clear();
m_CanSortAllSlot = false;
}
void CalculatZOrder()
{
int orderCount = m_OrderSlots.Count;
int slotCount = slots.Length;
int[] unchanged = new int[slotCount - orderCount];
if (m_NewSlotOrders == null)
{
m_NewSlotOrders = new int[slotCount];
}
for (int i = 0; i < slotCount; ++i)
{
m_NewSlotOrders[i] = -1;
}
int originalIndex = 0;
int unchangedIndex = 0;
for (int i = 0; i < orderCount; ++i)
{
Slot slot = m_OrderSlots[i];
int slotIndex = slot.zOrder;
int offset = slot.z;
while (originalIndex != slotIndex)
{
unchanged[unchangedIndex++] = originalIndex++;
}
m_NewSlotOrders[originalIndex + offset] = originalIndex++;
}
while (originalIndex < slotCount)
{
unchanged[unchangedIndex++] = originalIndex++;
}
int iC = slotCount;
while (iC-- != 0)
{
if (m_NewSlotOrders[iC] == -1 && unchangedIndex > 0)
{
m_NewSlotOrders[iC] = unchanged[--unchangedIndex];
}
}
if (isUGUI)
{
for (int i = 0; i < slotCount; ++i)
{
Slot slot = slots[m_NewSlotOrders[i]];
if (slot)
{
slot.transform.SetSiblingIndex(i);
}
}
}
else
{
//set order
float zoff = m_FlipX || m_FlipY ? 1f : -1f;
if (m_FlipX && m_FlipY)
{
zoff = -1f;
}
zoff *= zSpace;
for (int i = 0; i < slotCount; ++i)
{
if (m_NewSlotOrders[i] < 0)
{
continue;
}
Slot slot = slots[m_NewSlotOrders[i]];
if (slot && !slot.manualZ)
{
Vector3 v = slot.transform.localPosition;
v.z = zoff * i;
slot.transform.localPosition = v;
}
}
m_SortedSlots = new List <Slot>(slots);
m_SortedSlots.Sort(delegate(Slot x, Slot y) {
if (x.transform.localPosition.z < y.transform.localPosition.z)
{
return(1);
}
else if (x.transform.localPosition.z > y.transform.localPosition.z)
{
return(-1);
}
return(0);
});
if (sortType == SortType.ZOrder)
{
sortingOrder = sortingOrder;
}
}
m_OrderSlots.Clear();
}
/// <summary>
/// Sets to pose.
/// </summary>
public void SetToPose()
{
if (poseData)
{
for (int i = 0; i < poseData.boneDatas.Length && i < bones.Length; ++i)
{
Transform bone = bones[i];
if (bone)
{
PoseData.TransformData transData = poseData.boneDatas[i];
bone.localPosition = new Vector3(transData.x, transData.y, bone.localPosition.z);
bone.localScale = new Vector3(transData.sx, transData.sy, bone.localScale.z);
bone.localEulerAngles = new Vector3(bone.localEulerAngles.x, bone.localEulerAngles.y, transData.rotation);
}
}
for (int i = 0; i < poseData.slotDatas.Length && i < slots.Length; ++i)
{
Slot slot = slots[i];
if (slot)
{
slot.color = poseData.slotDatas[i].color;
slot.displayIndex = poseData.slotDatas[i].displayIndex;
slot.z = poseData.slotDatas[i].zorder;
}
m_SortedSlots = null;
}
if (isUGUI)
{
for (int i = 0; i < poseData.displayDatas.Length && i < uiAttachments.Length; ++i)
{
MaskableGraphic mg = uiAttachments[i];
if (mg)
{
PoseData.DisplayData displayData = poseData.displayDatas[i];
switch (displayData.type)
{
case PoseData.AttachmentType.IMG:
UIFrame uf = mg.GetComponent <UIFrame>();
if (uf)
{
uf.color = displayData.color;
}
else
{
Image img = mg.GetComponent <Image>();
if (img)
{
img.color = displayData.color;
}
}
break;
case PoseData.AttachmentType.MESH:
UIMesh um = mg.GetComponent <UIMesh> ();
um.vertices = (Vector3[])displayData.vertex.Clone();
if (um.vertControlTrans != null && um.vertControlTrans.Length > 0)
{
for (int j = 0; j < um.vertControlTrans.Length && j < um.vertices.Length; ++j)
{
Transform vctr = um.vertControlTrans [j];
if (vctr)
{
vctr.localPosition = um.vertices [j];
}
}
}
break;
}
}
}
}
else
{
for (int i = 0; i < poseData.displayDatas.Length && i < attachments.Length; ++i)
{
Renderer r = attachments[i];
if (r)
{
PoseData.DisplayData displayData = poseData.displayDatas[i];
switch (displayData.type)
{
case PoseData.AttachmentType.IMG:
SpriteFrame sf = r.GetComponent <SpriteFrame>();
if (sf)
{
sf.color = displayData.color;
}
else
{
SpriteRenderer sr = r.GetComponent <SpriteRenderer>();
if (sr)
{
sr.color = displayData.color;
}
}
break;
case PoseData.AttachmentType.MESH:
SpriteMesh sm = r.GetComponent <SpriteMesh>();
sm.vertices = (Vector3[])displayData.vertex.Clone();
if (sm.vertControlTrans != null)
{
for (int j = 0; j < sm.vertControlTrans.Length && j < sm.vertices.Length; ++j)
{
Transform vctr = sm.vertControlTrans[j];
if (vctr)
{
vctr.localPosition = sm.vertices[j];
}
}
}
break;
}
}
}
}
}
ResetSlotZOrder();
}
/// <summary>
/// Lates the update. Sort slot
/// </summary>
void LateUpdate()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
if (animator != null)
{
UpdateArmature();
}
if (parentArmature)
{
sortType = parentArmature.sortType;
}
#if UNITY_5_6_OR_NEWER
if (!isUGUI)
{
_sortingGroup = gameObject.GetComponent <UnityEngine.Rendering.SortingGroup>();
if (parentArmature)
{
if (parentArmature.sortingGroup != null)
{
if (_sortingGroup == null)
{
_sortingGroup = gameObject.AddComponent <UnityEngine.Rendering.SortingGroup>();
_sortingGroup.sortingLayerName = sortingLayerName;
_sortingGroup.sortingOrder = sortingOrder;
}
}
else if (_sortingGroup)
{
DestroyImmediate(_sortingGroup);
}
}
}
#endif
}
SetAlphaTex();
#endif
//caculate sort
if (slots != null)
{
int len = slots.Length;
for (int i = 0; i < len; ++i)
{
Slot slot = slots[i];
if (slot && slot.isActiveAndEnabled)
{
slot.CheckZorderChange();
}
}
}
if (m_CanSortAllSlot)
{
ForceSortAll();
m_CanSortAllSlot = false;
int temp = (int)m_ZOrderValid;
if (Mathf.Abs(m_ZOrderValid - temp) > 0.0001f)
{
return;
}
if (temp != __ZOrderValid)
{
__ZOrderValid = temp;
}
}
else
{
int temp = (int)m_ZOrderValid;
if (Mathf.Abs(m_ZOrderValid - temp) > 0.0001f)
{
return;
}
if (temp != __ZOrderValid)
{
__ZOrderValid = temp;
ResetSlotZOrder();
}
}
}
