public Skeleton (SkeletonData data) {
if (data == null) throw new ArgumentNullException("data cannot be null.");
this.data = data;
bones = new ExposedList<Bone>(data.bones.Count);
foreach (BoneData boneData in data.bones) {
Bone parent = boneData.parent == null ? null : bones.Items[data.bones.IndexOf(boneData.parent)];
Bone bone = new Bone(boneData, this, parent);
if (parent != null) parent.children.Add(bone);
bones.Add(bone);
}
slots = new ExposedList<Slot>(data.slots.Count);
drawOrder = new ExposedList<Slot>(data.slots.Count);
foreach (SlotData slotData in data.slots) {
Bone bone = bones.Items[data.bones.IndexOf(slotData.boneData)];
Slot slot = new Slot(slotData, bone);
slots.Add(slot);
drawOrder.Add(slot);
}
ikConstraints = new ExposedList<IkConstraint>(data.ikConstraints.Count);
foreach (IkConstraintData ikConstraintData in data.ikConstraints)
ikConstraints.Add(new IkConstraint(ikConstraintData, this));
transformConstraints = new ExposedList<TransformConstraint>(data.transformConstraints.Count);
foreach (TransformConstraintData transformConstraintData in data.transformConstraints)
transformConstraints.Add(new TransformConstraint(transformConstraintData, this));
UpdateCache();
UpdateWorldTransform();
}
public IkConstraint (IkConstraintData data, Skeleton skeleton) {
if (data == null) throw new ArgumentNullException("data cannot be null.");
if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
this.data = data;
mix = data.mix;
bendDirection = data.bendDirection;
bones = new ExposedList<Bone>(data.bones.Count);
foreach (BoneData boneData in data.bones)
bones.Add(skeleton.FindBone(boneData.name));
target = skeleton.FindBone(data.target.name);
}
public PathConstraint (PathConstraintData data, Skeleton skeleton) {
if (data == null) throw new ArgumentNullException("data", "data cannot be null.");
if (skeleton == null) throw new ArgumentNullException("skeleton", "skeleton cannot be null.");
this.data = data;
bones = new ExposedList<Bone>(data.Bones.Count);
foreach (BoneData boneData in data.bones)
bones.Add(skeleton.FindBone(boneData.name));
target = skeleton.FindSlot(data.target.name);
position = data.position;
spacing = data.spacing;
rotateMix = data.rotateMix;
translateMix = data.translateMix;
}
public TransformConstraint (TransformConstraintData data, Skeleton skeleton) {
if (data == null) throw new ArgumentNullException("data", "data cannot be null.");
if (skeleton == null) throw new ArgumentNullException("skeleton", "skeleton cannot be null.");
this.data = data;
rotateMix = data.rotateMix;
translateMix = data.translateMix;
scaleMix = data.scaleMix;
shearMix = data.shearMix;
bones = new ExposedList<Bone>();
foreach (BoneData boneData in data.bones)
bones.Add (skeleton.FindBone (boneData.name));
target = skeleton.FindBone(data.target.name);
}
public void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha)
{
if (firedEvents == null)
{
return;
}
float[] array = this.frames;
int num = array.Length;
if (lastTime > time)
{
this.Apply(skeleton, lastTime, 2.14748365E+09f, firedEvents, alpha);
lastTime = -1f;
}
else if (lastTime >= array[num - 1])
{
return;
}
if (time < array[0])
{
return;
}
int i;
if (lastTime < array[0])
{
i = 0;
}
else
{
i = Animation.binarySearch(array, lastTime);
float num2 = array[i];
while (i > 0)
{
if (array[i - 1] != num2)
{
break;
}
i--;
}
}
while (i < num && time >= array[i])
{
firedEvents.Add(this.events[i]);
i++;
}
}
public void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha)
{
float[] array = this.frames;
if (time < array[0])
{
return;
}
int num;
if (time >= array[array.Length - 1])
{
num = array.Length - 1;
}
else
{
num = Animation.binarySearch(array, time) - 1;
}
ExposedList <Slot> drawOrder = skeleton.drawOrder;
ExposedList <Slot> slots = skeleton.slots;
int[] array2 = this.drawOrders[num];
if (array2 == null)
{
drawOrder.Clear(true);
int i = 0;
int count = slots.Count;
while (i < count)
{
drawOrder.Add(slots.Items[i]);
i++;
}
}
else
{
Slot[] items = drawOrder.Items;
Slot[] items2 = slots.Items;
int j = 0;
int num2 = array2.Length;
while (j < num2)
{
items[j] = items2[array2[j]];
j++;
}
}
}
public void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction)
{
if (firedEvents == null)
{
return;
}
float[] array = frames;
int num = array.Length;
if (lastTime > time)
{
Apply(skeleton, lastTime, 2.14748365E+09f, firedEvents, alpha, pose, direction);
lastTime = -1f;
}
else if (lastTime >= array[num - 1])
{
return;
}
if (time < array[0])
{
return;
}
int i;
if (lastTime < array[0])
{
i = 0;
}
else
{
i = Animation.BinarySearch(array, lastTime);
float num2 = array[i];
while (i > 0 && array[i - 1] == num2)
{
i--;
}
}
for (; i < num && time >= array[i]; i++)
{
firedEvents.Add(events[i]);
}
}
public static void SetColorTintObjects(SkeletonAnimation sa, Color c)
{
ExposedList <Slot> tintSlots = new ExposedList <Slot> ();
ExposedList <Slot> slots = sa.skeleton.Slots;
for (int i = 0; i < slots.Count; i++)
{
string tPrefix = slots.Items[i].Data.Name.Split('_')[0];
if (tPrefix.Equals("t"))
{
tintSlots.Add(slots.Items[i]);
}
}
for (int x = 0; x < tintSlots.Count; x++)
{
tintSlots.Items[x].SetColor(c);
}
Debug.LogError("Done");
}
private void OnLevelWasLoaded(int level)
{
UpdateCameraEvents();
// Remove empty mesh managers
ExposedList <ShadowMeshManager> emptyShadowMeshManagers = new ExposedList <ShadowMeshManager>();
ShadowMeshManagerMapEnumerator meshManagersEnumerator = new ShadowMeshManagerMapEnumerator(_meshManagers);
while (meshManagersEnumerator.MoveNext())
{
ShadowMeshManager meshManager = meshManagersEnumerator.CurrentValue;
if (meshManager.ShadowsCount == 0)
{
emptyShadowMeshManagers.Add(meshManager);
}
}
for (int i = 0; i < emptyShadowMeshManagers.Count; i++)
{
_meshManagers.Remove(emptyShadowMeshManagers.Items[i].GetInstanceHashCode());
}
}
/// <summary>Fires events for frames > lastTime and <= time.</summary>
public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha, bool setupPose, bool mixingOut) {
if (firedEvents == null) return;
float[] frames = this.frames;
int frameCount = frames.Length;
if (lastTime > time) { // Fire events after last time for looped animations.
Apply(skeleton, lastTime, int.MaxValue, firedEvents, alpha, setupPose, mixingOut);
lastTime = -1f;
} else if (lastTime >= frames[frameCount - 1]) // Last time is after last frame.
return;
if (time < frames[0]) return; // Time is before first frame.
int frame;
if (lastTime < frames[0])
frame = 0;
else {
frame = Animation.BinarySearch(frames, lastTime);
float frameTime = frames[frame];
while (frame > 0) { // Fire multiple events with the same frame.
if (frames[frame - 1] != frameTime) break;
frame--;
}
}
for (; frame < frameCount && time >= frames[frame]; frame++)
firedEvents.Add(events[frame]);
}
private void ReadAnimation (String name, Stream input, SkeletonData skeletonData) {
var timelines = new ExposedList<Timeline>();
float scale = Scale;
float duration = 0;
// Slot timelines.
for (int i = 0, n = ReadInt(input, true); i < n; i++) {
int slotIndex = ReadInt(input, true);
for (int ii = 0, nn = ReadInt(input, true); ii < nn; ii++) {
int timelineType = input.ReadByte();
int frameCount = ReadInt(input, true);
switch (timelineType) {
case TIMELINE_COLOR: {
ColorTimeline timeline = new ColorTimeline(frameCount);
timeline.slotIndex = slotIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
float time = ReadFloat(input);
int color = ReadInt(input);
float r = ((color & 0xff000000) >> 24) / 255f;
float g = ((color & 0x00ff0000) >> 16) / 255f;
float b = ((color & 0x0000ff00) >> 8) / 255f;
float a = ((color & 0x000000ff)) / 255f;
timeline.SetFrame(frameIndex, time, r, g, b, a);
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount * 5 - 5]);
break;
}
case TIMELINE_ATTACHMENT: {
AttachmentTimeline timeline = new AttachmentTimeline(frameCount);
timeline.slotIndex = slotIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++)
timeline.SetFrame(frameIndex, ReadFloat(input), ReadString(input));
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount - 1]);
break;
}
}
}
}
// Bone timelines.
for (int i = 0, n = ReadInt(input, true); i < n; i++) {
int boneIndex = ReadInt(input, true);
for (int ii = 0, nn = ReadInt(input, true); ii < nn; ii++) {
int timelineType = input.ReadByte();
int frameCount = ReadInt(input, true);
switch (timelineType) {
case TIMELINE_ROTATE: {
RotateTimeline timeline = new RotateTimeline(frameCount);
timeline.boneIndex = boneIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input));
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount * 2 - 2]);
break;
}
case TIMELINE_TRANSLATE:
case TIMELINE_SCALE: {
TranslateTimeline timeline;
float timelineScale = 1;
if (timelineType == TIMELINE_SCALE)
timeline = new ScaleTimeline(frameCount);
else {
timeline = new TranslateTimeline(frameCount);
timelineScale = scale;
}
timeline.boneIndex = boneIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input) * timelineScale, ReadFloat(input)
* timelineScale);
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount * 3 - 3]);
break;
}
case TIMELINE_FLIPX:
case TIMELINE_FLIPY: {
FlipXTimeline timeline = timelineType == TIMELINE_FLIPX ? new FlipXTimeline(frameCount) : new FlipYTimeline(
frameCount);
timeline.boneIndex = boneIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++)
timeline.SetFrame(frameIndex, ReadFloat(input), ReadBoolean(input));
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount * 2 - 2]);
break;
}
}
}
}
// IK timelines.
for (int i = 0, n = ReadInt(input, true); i < n; i++) {
IkConstraintData ikConstraint = skeletonData.ikConstraints.Items[ReadInt(input, true)];
int frameCount = ReadInt(input, true);
IkConstraintTimeline timeline = new IkConstraintTimeline(frameCount);
timeline.ikConstraintIndex = skeletonData.ikConstraints.IndexOf(ikConstraint);
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input), ReadSByte(input));
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount * 3 - 3]);
}
// FFD timelines.
for (int i = 0, n = ReadInt(input, true); i < n; i++) {
Skin skin = skeletonData.skins.Items[ReadInt(input, true)];
for (int ii = 0, nn = ReadInt(input, true); ii < nn; ii++) {
int slotIndex = ReadInt(input, true);
for (int iii = 0, nnn = ReadInt(input, true); iii < nnn; iii++) {
Attachment attachment = skin.GetAttachment(slotIndex, ReadString(input));
int frameCount = ReadInt(input, true);
FFDTimeline timeline = new FFDTimeline(frameCount);
timeline.slotIndex = slotIndex;
timeline.attachment = attachment;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
float time = ReadFloat(input);
float[] vertices;
int vertexCount;
if (attachment is MeshAttachment)
vertexCount = ((MeshAttachment)attachment).vertices.Length;
else
vertexCount = ((SkinnedMeshAttachment)attachment).weights.Length / 3 * 2;
int end = ReadInt(input, true);
if (end == 0) {
if (attachment is MeshAttachment)
vertices = ((MeshAttachment)attachment).vertices;
else
vertices = new float[vertexCount];
} else {
vertices = new float[vertexCount];
int start = ReadInt(input, true);
end += start;
if (scale == 1) {
for (int v = start; v < end; v++)
vertices[v] = ReadFloat(input);
} else {
for (int v = start; v < end; v++)
vertices[v] = ReadFloat(input) * scale;
}
if (attachment is MeshAttachment) {
float[] meshVertices = ((MeshAttachment)attachment).vertices;
for (int v = 0, vn = vertices.Length; v < vn; v++)
vertices[v] += meshVertices[v];
}
}
timeline.SetFrame(frameIndex, time, vertices);
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount - 1]);
}
}
}
// Draw order timeline.
int drawOrderCount = ReadInt(input, true);
if (drawOrderCount > 0) {
DrawOrderTimeline timeline = new DrawOrderTimeline(drawOrderCount);
int slotCount = skeletonData.slots.Count;
for (int i = 0; i < drawOrderCount; i++) {
int offsetCount = ReadInt(input, true);
int[] drawOrder = new int[slotCount];
for (int ii = slotCount - 1; ii >= 0; ii--)
drawOrder[ii] = -1;
int[] unchanged = new int[slotCount - offsetCount];
int originalIndex = 0, unchangedIndex = 0;
for (int ii = 0; ii < offsetCount; ii++) {
int slotIndex = ReadInt(input, true);
// Collect unchanged items.
while (originalIndex != slotIndex)
unchanged[unchangedIndex++] = originalIndex++;
// Set changed items.
drawOrder[originalIndex + ReadInt(input, true)] = originalIndex++;
}
// Collect remaining unchanged items.
while (originalIndex < slotCount)
unchanged[unchangedIndex++] = originalIndex++;
// Fill in unchanged items.
for (int ii = slotCount - 1; ii >= 0; ii--)
if (drawOrder[ii] == -1) drawOrder[ii] = unchanged[--unchangedIndex];
timeline.SetFrame(i, ReadFloat(input), drawOrder);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[drawOrderCount - 1]);
}
// Event timeline.
int eventCount = ReadInt(input, true);
if (eventCount > 0) {
EventTimeline timeline = new EventTimeline(eventCount);
for (int i = 0; i < eventCount; i++) {
float time = ReadFloat(input);
EventData eventData = skeletonData.events.Items[ReadInt(input, true)];
Event e = new Event(eventData);
e.Int = ReadInt(input, false);
e.Float = ReadFloat(input);
e.String = ReadBoolean(input) ? ReadString(input) : eventData.String;
timeline.SetFrame(i, time, e);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[eventCount - 1]);
}
timelines.TrimExcess();
skeletonData.animations.Add(new Animation(name, timelines, duration));
}
public SubmeshedMeshInstruction GenerateInstruction(Skeleton skeleton)
{
if (skeleton == null)
{
throw new ArgumentNullException("skeleton");
}
int num = 0;
int num2 = 0;
int firstVertexIndex = 0;
int num3 = 0;
int startSlot = 0;
Material material = null;
ExposedList <Slot> drawOrder = skeleton.drawOrder;
Slot[] items = drawOrder.Items;
int count = drawOrder.Count;
int count2 = this.separators.Count;
ExposedList <SubmeshInstruction> submeshInstructions = this.currentInstructions.submeshInstructions;
submeshInstructions.Clear(false);
this.currentInstructions.attachmentList.Clear(false);
int i = 0;
while (i < count)
{
Slot slot = items[i];
Attachment attachment = slot.attachment;
RegionAttachment regionAttachment = attachment as RegionAttachment;
object rendererObject;
int num4;
int num5;
if (regionAttachment != null)
{
rendererObject = regionAttachment.RendererObject;
num4 = 4;
num5 = 6;
goto IL_E1;
}
MeshAttachment meshAttachment = attachment as MeshAttachment;
if (meshAttachment != null)
{
rendererObject = meshAttachment.RendererObject;
num4 = meshAttachment.worldVerticesLength >> 1;
num5 = meshAttachment.triangles.Length;
goto IL_E1;
}
IL_1B8:
i++;
continue;
IL_E1:
Material material2 = (Material)((AtlasRegion)rendererObject).page.rendererObject;
bool flag = count2 > 0 && this.separators.Contains(slot);
if ((num > 0 && material.GetInstanceID() != material2.GetInstanceID()) || flag)
{
submeshInstructions.Add(new SubmeshInstruction
{
skeleton = skeleton,
material = material,
triangleCount = num2,
vertexCount = num3,
startSlot = startSlot,
endSlot = i,
firstVertexIndex = firstVertexIndex,
forceSeparate = flag
});
num2 = 0;
num3 = 0;
firstVertexIndex = num;
startSlot = i;
}
material = material2;
num2 += num5;
num3 += num4;
num += num4;
this.currentInstructions.attachmentList.Add(attachment);
goto IL_1B8;
}
submeshInstructions.Add(new SubmeshInstruction
{
skeleton = skeleton,
material = material,
triangleCount = num2,
vertexCount = num3,
startSlot = startSlot,
endSlot = count,
firstVertexIndex = firstVertexIndex,
forceSeparate = false
});
this.currentInstructions.vertexCount = num;
return(this.currentInstructions);
}
public virtual void LateUpdate()
{
if (!valid || (!meshRenderer.enabled && this.generateMeshOverride == null))
{
return;
}
ExposedList <Slot> drawOrder = skeleton.drawOrder;
Slot[] items = drawOrder.Items;
int count = drawOrder.Count;
bool flag = renderMeshes;
SmartMesh.Instruction instruction = currentInstructions;
ExposedList <Attachment> attachments = instruction.attachments;
attachments.Clear(clearArray: false);
attachments.GrowIfNeeded(count);
attachments.Count = count;
Attachment[] items2 = instruction.attachments.Items;
ExposedList <SubmeshInstruction> submeshInstructions = instruction.submeshInstructions;
submeshInstructions.Clear(clearArray: false);
bool flag2 = customSlotMaterials.Count > 0;
int num = 0;
int num2 = 0;
int num3 = 0;
int firstVertexIndex = 0;
int startSlot = 0;
Material material = null;
for (int i = 0; i < count; i++)
{
Slot slot = items[i];
Attachment attachment = items2[i] = slot.attachment;
RegionAttachment regionAttachment = attachment as RegionAttachment;
object rendererObject;
int num4;
int num5;
if (regionAttachment != null)
{
rendererObject = regionAttachment.RendererObject;
num4 = 4;
num5 = 6;
}
else
{
if (!flag)
{
continue;
}
MeshAttachment meshAttachment = attachment as MeshAttachment;
if (meshAttachment == null)
{
continue;
}
rendererObject = meshAttachment.RendererObject;
num4 = meshAttachment.worldVerticesLength >> 1;
num5 = meshAttachment.triangles.Length;
}
Material value;
if (flag2)
{
if (!customSlotMaterials.TryGetValue(slot, out value))
{
value = (Material)((AtlasRegion)rendererObject).page.rendererObject;
}
}
else
{
value = (Material)((AtlasRegion)rendererObject).page.rendererObject;
}
bool flag3 = separatorSlots.Count > 0 && separatorSlots.Contains(slot);
if (num > 0 && (material.GetInstanceID() != value.GetInstanceID() || flag3))
{
submeshInstructions.Add(new SubmeshInstruction
{
skeleton = skeleton,
material = material,
startSlot = startSlot,
endSlot = i,
triangleCount = num3,
firstVertexIndex = firstVertexIndex,
vertexCount = num2,
forceSeparate = flag3
});
num3 = 0;
num2 = 0;
firstVertexIndex = num;
startSlot = i;
}
material = value;
num3 += num5;
num += num4;
num2 += num4;
}
if (num2 != 0)
{
submeshInstructions.Add(new SubmeshInstruction
{
skeleton = skeleton,
material = material,
startSlot = startSlot,
endSlot = count,
triangleCount = num3,
firstVertexIndex = firstVertexIndex,
vertexCount = num2,
forceSeparate = false
});
}
instruction.vertexCount = num;
instruction.immutableTriangles = immutableTriangles;
if (customMaterialOverride.Count > 0)
{
SubmeshInstruction[] items3 = submeshInstructions.Items;
for (int j = 0; j < submeshInstructions.Count; j++)
{
Material material2 = items3[j].material;
Material value2;
if (customMaterialOverride.TryGetValue(material2, out value2))
{
items3[j].material = value2;
}
}
}
if (this.generateMeshOverride != null)
{
this.generateMeshOverride(instruction);
if (disableRenderingOnOverride)
{
return;
}
}
if (ArraysMeshGenerator.EnsureSize(num, ref vertices, ref uvs, ref colors) && calculateNormals)
{
Vector3[] array = normals = new Vector3[num];
Vector3 vector = new Vector3(0f, 0f, -1f);
for (int k = 0; k < num; k++)
{
array[k] = vector;
}
}
Vector3 boundsMin = default(Vector3);
Vector3 boundsMax = default(Vector3);
if (num <= 0)
{
boundsMin = new Vector3(0f, 0f, 0f);
boundsMax = new Vector3(0f, 0f, 0f);
}
else
{
boundsMin.x = 2.14748365E+09f;
boundsMin.y = 2.14748365E+09f;
boundsMax.x = -2.14748365E+09f;
boundsMax.y = -2.14748365E+09f;
if (zSpacing > 0f)
{
boundsMin.z = 0f;
boundsMax.z = zSpacing * (float)(count - 1);
}
else
{
boundsMin.z = zSpacing * (float)(count - 1);
boundsMax.z = 0f;
}
}
int vertexIndex = 0;
ArraysMeshGenerator.FillVerts(skeleton, 0, count, zSpacing, pmaVertexColors, vertices, uvs, colors, ref vertexIndex, ref tempVertices, ref boundsMin, ref boundsMax, flag);
SmartMesh next = doubleBufferedMesh.GetNext();
Mesh mesh = next.mesh;
mesh.vertices = vertices;
mesh.colors32 = colors;
mesh.uv = uvs;
mesh.bounds = ArraysMeshGenerator.ToBounds(boundsMin, boundsMax);
SmartMesh.Instruction instructionUsed = next.instructionUsed;
if (calculateNormals && instructionUsed.vertexCount < num)
{
mesh.normals = normals;
}
bool flag4 = CheckIfMustUpdateMeshStructure(instruction, instructionUsed);
int count2 = submeshInstructions.Count;
if (flag4)
{
ExposedList <Material> exposedList = submeshMaterials;
exposedList.Clear(clearArray: false);
int count3 = submeshes.Count;
if (submeshes.Capacity < count2)
{
submeshes.Capacity = count2;
}
for (int l = count3; l < count2; l++)
{
submeshes.Items[l] = new ArraysMeshGenerator.SubmeshTriangleBuffer(submeshInstructions.Items[l].triangleCount);
}
submeshes.Count = count2;
bool flag5 = !instruction.immutableTriangles;
int m = 0;
int num6 = count2 - 1;
for (; m < count2; m++)
{
SubmeshInstruction submeshInstruction = submeshInstructions.Items[m];
if (flag5 || m >= count3)
{
ArraysMeshGenerator.SubmeshTriangleBuffer submeshTriangleBuffer = submeshes.Items[m];
int triangleCount = submeshInstruction.triangleCount;
if (flag)
{
ArraysMeshGenerator.FillTriangles(ref submeshTriangleBuffer.triangles, skeleton, triangleCount, submeshInstruction.firstVertexIndex, submeshInstruction.startSlot, submeshInstruction.endSlot, m == num6);
submeshTriangleBuffer.triangleCount = triangleCount;
}
else
{
ArraysMeshGenerator.FillTrianglesQuads(ref submeshTriangleBuffer.triangles, ref submeshTriangleBuffer.triangleCount, ref submeshTriangleBuffer.firstVertex, submeshInstruction.firstVertexIndex, triangleCount, m == num6);
}
}
exposedList.Add(submeshInstruction.material);
}
mesh.subMeshCount = count2;
for (int n = 0; n < count2; n++)
{
mesh.SetTriangles(submeshes.Items[n].triangles, n);
}
}
if (calculateTangents)
{
ArraysMeshGenerator.SolveTangents2DEnsureSize(ref tangents, ref tempTanBuffer, vertices.Length);
for (int num7 = 0; num7 < count2; num7++)
{
ArraysMeshGenerator.SubmeshTriangleBuffer submeshTriangleBuffer2 = submeshes.Items[num7];
ArraysMeshGenerator.SolveTangents2DTriangles(tempTanBuffer, submeshTriangleBuffer2.triangles, submeshTriangleBuffer2.triangleCount, vertices, uvs, num);
}
ArraysMeshGenerator.SolveTangents2DBuffer(tangents, tempTanBuffer, num);
mesh.tangents = tangents;
}
Material[] array2 = sharedMaterials;
bool flag6 = flag4 || array2.Length != count2;
if (!flag6)
{
SubmeshInstruction[] items4 = submeshInstructions.Items;
int num8 = 0;
for (int num9 = array2.Length; num8 < num9; num8++)
{
if (array2[num8].GetInstanceID() != items4[num8].material.GetInstanceID())
{
flag6 = true;
break;
}
}
}
if (flag6)
{
if (submeshMaterials.Count == sharedMaterials.Length)
{
submeshMaterials.CopyTo(sharedMaterials);
}
else
{
sharedMaterials = submeshMaterials.ToArray();
}
meshRenderer.sharedMaterials = sharedMaterials;
}
meshFilter.sharedMesh = mesh;
next.instructionUsed.Set(instruction);
}
public MeshAndMaterials GenerateMesh(ExposedList <SubmeshInstruction> instructions, int startSubmesh, int endSubmesh)
{
SubmeshInstruction[] items = instructions.Items;
this.currentInstructions.Clear(false);
for (int i = startSubmesh; i < endSubmesh; i++)
{
this.currentInstructions.Add(items[i]);
}
SmartMesh next = this.doubleBufferedSmartMesh.GetNext();
Mesh mesh = next.mesh;
int count = this.currentInstructions.Count;
SubmeshInstruction[] items2 = this.currentInstructions.Items;
int num = 0;
for (int j = 0; j < count; j++)
{
items2[j].firstVertexIndex = num;
num += items2[j].vertexCount;
}
bool flag = ArraysMeshGenerator.EnsureSize(num, ref this.meshVertices, ref this.meshUVs, ref this.meshColors32);
bool flag2 = ArraysMeshGenerator.EnsureTriangleBuffersSize(this.submeshBuffers, count, items2);
float zspacing = this.ZSpacing;
Vector3 boundsMin;
Vector3 boundsMax;
if (num <= 0)
{
boundsMin = new Vector3(0f, 0f, 0f);
boundsMax = new Vector3(0f, 0f, 0f);
}
else
{
boundsMin.x = 2.14748365E+09f;
boundsMin.y = 2.14748365E+09f;
boundsMax.x = -2.14748365E+09f;
boundsMax.y = -2.14748365E+09f;
int endSlot = items2[count - 1].endSlot;
if (zspacing > 0f)
{
boundsMin.z = 0f;
boundsMax.z = zspacing * (float)endSlot;
}
else
{
boundsMin.z = zspacing * (float)endSlot;
boundsMax.z = 0f;
}
}
ExposedList <Attachment> exposedList = this.attachmentBuffer;
exposedList.Clear(false);
int num2 = 0;
for (int k = 0; k < count; k++)
{
SubmeshInstruction submeshInstruction = items2[k];
int startSlot = submeshInstruction.startSlot;
int endSlot2 = submeshInstruction.endSlot;
Skeleton skeleton = submeshInstruction.skeleton;
Slot[] items3 = skeleton.DrawOrder.Items;
for (int l = startSlot; l < endSlot2; l++)
{
Attachment attachment = items3[l].attachment;
if (attachment != null)
{
exposedList.Add(attachment);
}
}
ArraysMeshGenerator.FillVerts(skeleton, startSlot, endSlot2, zspacing, base.PremultiplyVertexColors, this.meshVertices, this.meshUVs, this.meshColors32, ref num2, ref this.attachmentVertexBuffer, ref boundsMin, ref boundsMax, true);
}
bool flag3 = flag || flag2 || next.StructureDoesntMatch(exposedList, this.currentInstructions);
for (int m = 0; m < count; m++)
{
SubmeshInstruction submeshInstruction2 = items2[m];
if (flag3)
{
SubmeshTriangleBuffer submeshTriangleBuffer = this.submeshBuffers.Items[m];
bool isLastSubmesh = m == count - 1;
ArraysMeshGenerator.FillTriangles(ref submeshTriangleBuffer.triangles, submeshInstruction2.skeleton, submeshInstruction2.triangleCount, submeshInstruction2.firstVertexIndex, submeshInstruction2.startSlot, submeshInstruction2.endSlot, isLastSubmesh);
submeshTriangleBuffer.triangleCount = submeshInstruction2.triangleCount;
submeshTriangleBuffer.firstVertex = submeshInstruction2.firstVertexIndex;
}
}
if (flag3)
{
mesh.Clear();
this.sharedMaterials = this.currentInstructions.GetUpdatedMaterialArray(this.sharedMaterials);
}
next.Set(this.meshVertices, this.meshUVs, this.meshColors32, exposedList, this.currentInstructions);
mesh.bounds = ArraysMeshGenerator.ToBounds(boundsMin, boundsMax);
if (flag3)
{
mesh.subMeshCount = count;
for (int n = 0; n < count; n++)
{
mesh.SetTriangles(this.submeshBuffers.Items[n].triangles, n);
}
base.TryAddNormalsTo(mesh, num);
}
if (this.addTangents)
{
ArraysMeshGenerator.SolveTangents2DEnsureSize(ref this.meshTangents, ref this.tempTanBuffer, num);
int num3 = 0;
int num4 = count;
while (num3 < num4)
{
SubmeshTriangleBuffer submeshTriangleBuffer2 = this.submeshBuffers.Items[num3];
ArraysMeshGenerator.SolveTangents2DTriangles(this.tempTanBuffer, submeshTriangleBuffer2.triangles, submeshTriangleBuffer2.triangleCount, this.meshVertices, this.meshUVs, num);
num3++;
}
ArraysMeshGenerator.SolveTangents2DBuffer(this.meshTangents, this.tempTanBuffer, num);
}
return(new MeshAndMaterials(next.mesh, this.sharedMaterials));
}
private void ReadAnimation (String name, Dictionary<String, Object> map, SkeletonData skeletonData) {
var timelines = new ExposedList<Timeline>();
float duration = 0;
float scale = Scale;
if (map.ContainsKey("slots")) {
foreach (KeyValuePair<String, Object> entry in (Dictionary<String, Object>)map["slots"]) {
String slotName = entry.Key;
int slotIndex = skeletonData.FindSlotIndex(slotName);
var timelineMap = (Dictionary<String, Object>)entry.Value;
foreach (KeyValuePair<String, Object> timelineEntry in timelineMap) {
var values = (List<Object>)timelineEntry.Value;
var timelineName = (String)timelineEntry.Key;
if (timelineName == "color") {
var timeline = new ColorTimeline(values.Count);
timeline.slotIndex = slotIndex;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
String c = (String)valueMap["color"];
timeline.SetFrame(frameIndex, time, ToColor(c, 0), ToColor(c, 1), ToColor(c, 2), ToColor(c, 3));
ReadCurve(timeline, frameIndex, valueMap);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 5 - 5]);
} else if (timelineName == "attachment") {
var timeline = new AttachmentTimeline(values.Count);
timeline.slotIndex = slotIndex;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
timeline.SetFrame(frameIndex++, time, (String)valueMap["name"]);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
} else
throw new Exception("Invalid timeline type for a slot: " + timelineName + " (" + slotName + ")");
}
}
}
if (map.ContainsKey("bones")) {
foreach (KeyValuePair<String, Object> entry in (Dictionary<String, Object>)map["bones"]) {
String boneName = entry.Key;
int boneIndex = skeletonData.FindBoneIndex(boneName);
if (boneIndex == -1)
throw new Exception("Bone not found: " + boneName);
var timelineMap = (Dictionary<String, Object>)entry.Value;
foreach (KeyValuePair<String, Object> timelineEntry in timelineMap) {
var values = (List<Object>)timelineEntry.Value;
var timelineName = (String)timelineEntry.Key;
if (timelineName == "rotate") {
var timeline = new RotateTimeline(values.Count);
timeline.boneIndex = boneIndex;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
timeline.SetFrame(frameIndex, time, (float)valueMap["angle"]);
ReadCurve(timeline, frameIndex, valueMap);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 2 - 2]);
} else if (timelineName == "translate" || timelineName == "scale") {
TranslateTimeline timeline;
float timelineScale = 1;
if (timelineName == "scale")
timeline = new ScaleTimeline(values.Count);
else {
timeline = new TranslateTimeline(values.Count);
timelineScale = scale;
}
timeline.boneIndex = boneIndex;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
float x = valueMap.ContainsKey("x") ? (float)valueMap["x"] : 0;
float y = valueMap.ContainsKey("y") ? (float)valueMap["y"] : 0;
timeline.SetFrame(frameIndex, time, (float)x * timelineScale, (float)y * timelineScale);
ReadCurve(timeline, frameIndex, valueMap);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 3 - 3]);
} else
throw new Exception("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")");
}
}
}
if (map.ContainsKey("ik")) {
foreach (KeyValuePair<String, Object> ikMap in (Dictionary<String, Object>)map["ik"]) {
IkConstraintData ikConstraint = skeletonData.FindIkConstraint(ikMap.Key);
var values = (List<Object>)ikMap.Value;
var timeline = new IkConstraintTimeline(values.Count);
timeline.ikConstraintIndex = skeletonData.ikConstraints.IndexOf(ikConstraint);
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
float mix = valueMap.ContainsKey("mix") ? (float)valueMap["mix"] : 1;
bool bendPositive = valueMap.ContainsKey("bendPositive") ? (bool)valueMap["bendPositive"] : true;
timeline.SetFrame(frameIndex, time, mix, bendPositive ? 1 : -1);
ReadCurve(timeline, frameIndex, valueMap);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 3 - 3]);
}
}
if (map.ContainsKey("ffd")) {
foreach (KeyValuePair<String, Object> ffdMap in (Dictionary<String, Object>)map["ffd"]) {
Skin skin = skeletonData.FindSkin(ffdMap.Key);
foreach (KeyValuePair<String, Object> slotMap in (Dictionary<String, Object>)ffdMap.Value) {
int slotIndex = skeletonData.FindSlotIndex(slotMap.Key);
foreach (KeyValuePair<String, Object> meshMap in (Dictionary<String, Object>)slotMap.Value) {
var values = (List<Object>)meshMap.Value;
var timeline = new FFDTimeline(values.Count);
Attachment attachment = skin.GetAttachment(slotIndex, meshMap.Key);
if (attachment == null) throw new Exception("FFD attachment not found: " + meshMap.Key);
timeline.slotIndex = slotIndex;
timeline.attachment = attachment;
int vertexCount;
if (attachment is MeshAttachment)
vertexCount = ((MeshAttachment)attachment).vertices.Length;
else
vertexCount = ((WeightedMeshAttachment)attachment).Weights.Length / 3 * 2;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float[] vertices;
if (!valueMap.ContainsKey("vertices")) {
if (attachment is MeshAttachment)
vertices = ((MeshAttachment)attachment).vertices;
else
vertices = new float[vertexCount];
} else {
var verticesValue = (List<Object>)valueMap["vertices"];
vertices = new float[vertexCount];
int start = GetInt(valueMap, "offset", 0);
if (scale == 1) {
for (int i = 0, n = verticesValue.Count; i < n; i++)
vertices[i + start] = (float)verticesValue[i];
} else {
for (int i = 0, n = verticesValue.Count; i < n; i++)
vertices[i + start] = (float)verticesValue[i] * scale;
}
if (attachment is MeshAttachment) {
float[] meshVertices = ((MeshAttachment)attachment).vertices;
for (int i = 0; i < vertexCount; i++)
vertices[i] += meshVertices[i];
}
}
timeline.SetFrame(frameIndex, (float)valueMap["time"], vertices);
ReadCurve(timeline, frameIndex, valueMap);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
}
}
}
}
if (map.ContainsKey("drawOrder") || map.ContainsKey("draworder")) {
var values = (List<Object>)map[map.ContainsKey("drawOrder") ? "drawOrder" : "draworder"];
var timeline = new DrawOrderTimeline(values.Count);
int slotCount = skeletonData.slots.Count;
int frameIndex = 0;
foreach (Dictionary<String, Object> drawOrderMap in values) {
int[] drawOrder = null;
if (drawOrderMap.ContainsKey("offsets")) {
drawOrder = new int[slotCount];
for (int i = slotCount - 1; i >= 0; i--)
drawOrder[i] = -1;
var offsets = (List<Object>)drawOrderMap["offsets"];
int[] unchanged = new int[slotCount - offsets.Count];
int originalIndex = 0, unchangedIndex = 0;
foreach (Dictionary<String, Object> offsetMap in offsets) {
int slotIndex = skeletonData.FindSlotIndex((String)offsetMap["slot"]);
if (slotIndex == -1) throw new Exception("Slot not found: " + offsetMap["slot"]);
// Collect unchanged items.
while (originalIndex != slotIndex)
unchanged[unchangedIndex++] = originalIndex++;
// Set changed items.
int index = originalIndex + (int)(float)offsetMap["offset"];
drawOrder[index] = originalIndex++;
}
// Collect remaining unchanged items.
while (originalIndex < slotCount)
unchanged[unchangedIndex++] = originalIndex++;
// Fill in unchanged items.
for (int i = slotCount - 1; i >= 0; i--)
if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex];
}
timeline.SetFrame(frameIndex++, (float)drawOrderMap["time"], drawOrder);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
}
if (map.ContainsKey("events")) {
var eventsMap = (List<Object>)map["events"];
var timeline = new EventTimeline(eventsMap.Count);
int frameIndex = 0;
foreach (Dictionary<String, Object> eventMap in eventsMap) {
EventData eventData = skeletonData.FindEvent((String)eventMap["name"]);
if (eventData == null) throw new Exception("Event not found: " + eventMap["name"]);
float time = (float)eventMap["time"];
var e = new Event(time, eventData);
e.Int = GetInt(eventMap, "int", eventData.Int);
e.Float = GetFloat(eventMap, "float", eventData.Float);
e.String = GetString(eventMap, "string", eventData.String);
timeline.SetFrame(frameIndex++, time, e);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
}
timelines.TrimExcess();
skeletonData.animations.Add(new Animation(name, timelines, duration));
}
private void ReadVertices (Dictionary<String, Object> map, VertexAttachment attachment, int verticesLength) {
attachment.WorldVerticesLength = verticesLength;
float[] vertices = GetFloatArray(map, "vertices", 1);
float scale = Scale;
if (verticesLength == vertices.Length) {
if (scale != 1) {
for (int i = 0; i < vertices.Length; i++) {
vertices[i] *= scale;
}
}
attachment.vertices = vertices;
return;
}
ExposedList<float> weights = new ExposedList<float>(verticesLength * 3 * 3);
ExposedList<int> bones = new ExposedList<int>(verticesLength * 3);
for (int i = 0, n = vertices.Length; i < n;) {
int boneCount = (int)vertices[i++];
bones.Add(boneCount);
for (int nn = i + boneCount * 4; i < nn; i += 4) {
bones.Add((int)vertices[i]);
weights.Add(vertices[i + 1] * this.Scale);
weights.Add(vertices[i + 2] * this.Scale);
weights.Add(vertices[i + 3]);
}
}
attachment.bones = bones.ToArray();
attachment.vertices = weights.ToArray();
}
internal bool Clip(float x1, float y1, float x2, float y2, float x3, float y3, ExposedList <float> clippingArea, ExposedList <float> output)
{
ExposedList <float> exposedList = output;
bool result = false;
ExposedList <float> exposedList2 = null;
if (clippingArea.Count % 4 >= 2)
{
exposedList2 = output;
output = scratch;
}
else
{
exposedList2 = scratch;
}
exposedList2.Clear();
exposedList2.Add(x1);
exposedList2.Add(y1);
exposedList2.Add(x2);
exposedList2.Add(y2);
exposedList2.Add(x3);
exposedList2.Add(y3);
exposedList2.Add(x1);
exposedList2.Add(y1);
output.Clear();
float[] items = clippingArea.Items;
int num = clippingArea.Count - 4;
int num2 = 0;
while (true)
{
float num3 = items[num2];
float num4 = items[num2 + 1];
float num5 = items[num2 + 2];
float num6 = items[num2 + 3];
float num7 = num3 - num5;
float num8 = num4 - num6;
float[] items2 = exposedList2.Items;
int num9 = exposedList2.Count - 2;
int count = output.Count;
for (int i = 0; i < num9; i += 2)
{
float num10 = items2[i];
float num11 = items2[i + 1];
float num12 = items2[i + 2];
float num13 = items2[i + 3];
bool flag = num7 * (num13 - num6) - num8 * (num12 - num5) > 0f;
if (num7 * (num11 - num6) - num8 * (num10 - num5) > 0f)
{
if (flag)
{
output.Add(num12);
output.Add(num13);
continue;
}
float num14 = num13 - num11;
float num15 = num12 - num10;
float num16 = (num15 * (num4 - num11) - num14 * (num3 - num10)) / (num14 * (num5 - num3) - num15 * (num6 - num4));
output.Add(num3 + (num5 - num3) * num16);
output.Add(num4 + (num6 - num4) * num16);
}
else if (flag)
{
float num17 = num13 - num11;
float num18 = num12 - num10;
float num19 = (num18 * (num4 - num11) - num17 * (num3 - num10)) / (num17 * (num5 - num3) - num18 * (num6 - num4));
output.Add(num3 + (num5 - num3) * num19);
output.Add(num4 + (num6 - num4) * num19);
output.Add(num12);
output.Add(num13);
}
result = true;
}
if (count == output.Count)
{
exposedList.Clear();
return(true);
}
output.Add(output.Items[0]);
output.Add(output.Items[1]);
if (num2 == num)
{
break;
}
ExposedList <float> exposedList3 = output;
output = exposedList2;
output.Clear();
exposedList2 = exposedList3;
num2 += 2;
}
if (exposedList != output)
{
exposedList.Clear();
int j = 0;
for (int num20 = output.Count - 2; j < num20; j++)
{
exposedList.Add(output.Items[j]);
}
}
else
{
exposedList.Resize(exposedList.Count - 2);
}
return(result);
}
public virtual void LateUpdate()
{
if (!valid)
{
return;
}
// Exit early if there is nothing to render
if (!meshRenderer.enabled && submeshRenderers.Length == 0)
{
return;
}
// Count vertices and submesh triangles.
int vertexCount = 0;
int submeshTriangleCount = 0, submeshFirstVertex = 0, submeshStartSlotIndex = 0;
Material lastMaterial = null;
ExposedList <Slot> drawOrder = skeleton.drawOrder;
int drawOrderCount = drawOrder.Count;
int submeshSeparatorSlotsCount = submeshSeparatorSlots.Count;
bool renderMeshes = this.renderMeshes;
// Clear last state of attachments and submeshes
ExposedList <int> attachmentsTriangleCountTemp = lastState.attachmentsTriangleCountTemp;
attachmentsTriangleCountTemp.GrowIfNeeded(drawOrderCount);
attachmentsTriangleCountTemp.Count = drawOrderCount;
ExposedList <bool> attachmentsFlipStateTemp = lastState.attachmentsFlipStateTemp;
attachmentsFlipStateTemp.GrowIfNeeded(drawOrderCount);
attachmentsFlipStateTemp.Count = drawOrderCount;
ExposedList <LastState.AddSubmeshArguments> addSubmeshArgumentsTemp = lastState.addSubmeshArgumentsTemp;
addSubmeshArgumentsTemp.Clear(false);
bool noRender = false;
for (int i = 0; i < drawOrderCount; i++)
{
Slot slot = drawOrder.Items[i];
Bone bone = slot.bone;
Attachment attachment = slot.attachment;
object rendererObject;
int attachmentVertexCount, attachmentTriangleCount;
bool worldScaleXIsPositive = bone.worldScaleX >= 0f;
bool worldScaleYIsPositive = bone.worldScaleY >= 0f;
bool worldScaleIsSameSigns = (worldScaleXIsPositive && worldScaleYIsPositive) ||
(!worldScaleXIsPositive && !worldScaleYIsPositive);
bool flip = frontFacing && ((bone.worldFlipX != bone.worldFlipY) == worldScaleIsSameSigns);
attachmentsFlipStateTemp.Items[i] = flip;
attachmentsTriangleCountTemp.Items[i] = -1;
RegionAttachment regionAttachment = attachment as RegionAttachment;
if (regionAttachment != null)
{
rendererObject = regionAttachment.RendererObject;
attachmentVertexCount = 4;
attachmentTriangleCount = 6;
}
else
{
if (!renderMeshes)
{
continue;
}
MeshAttachment meshAttachment = attachment as MeshAttachment;
if (meshAttachment != null)
{
rendererObject = meshAttachment.RendererObject;
attachmentVertexCount = meshAttachment.vertices.Length >> 1;
attachmentTriangleCount = meshAttachment.triangles.Length;
}
else
{
SkinnedMeshAttachment skinnedMeshAttachment = attachment as SkinnedMeshAttachment;
if (skinnedMeshAttachment != null)
{
rendererObject = skinnedMeshAttachment.RendererObject;
attachmentVertexCount = skinnedMeshAttachment.uvs.Length >> 1;
attachmentTriangleCount = skinnedMeshAttachment.triangles.Length;
}
else
{
continue;
}
}
}
// Populate submesh when material changes.
// tsteil - added support for mask material
Material material = null;
if (useMaskMaterial)
{
if (maskProvider != null)
{
if (maskMaterial == null)
{
var prefabMat = (Material)((AtlasRegion)rendererObject).page.rendererObjectMask;
material = new Material(prefabMat);
material.hideFlags = HideFlags.HideAndDontSave;
maskMaterial = material;
SetMaskId();
}
else
{
material = maskMaterial;
}
}
else
{
material = (Material)((AtlasRegion)rendererObject).page.rendererObjectMask;
}
}
else
{
#if !SPINE_TK2D
material = (Material)((AtlasRegion)rendererObject).page.rendererObject;
#else
material = (rendererObject.GetType() == typeof(Material)) ? (Material)rendererObject : (Material)((AtlasRegion)rendererObject).page.rendererObject;
#endif
}
if ((lastMaterial != null && lastMaterial.GetInstanceID() != material.GetInstanceID()) ||
(submeshSeparatorSlotsCount > 0 && submeshSeparatorSlots.Contains(slot)))
{
addSubmeshArgumentsTemp.Add(
new LastState.AddSubmeshArguments(lastMaterial, submeshStartSlotIndex, i, submeshTriangleCount, submeshFirstVertex, false)
);
submeshTriangleCount = 0;
submeshFirstVertex = vertexCount;
submeshStartSlotIndex = i;
}
lastMaterial = material;
submeshTriangleCount += attachmentTriangleCount;
vertexCount += attachmentVertexCount;
attachmentsTriangleCountTemp.Items[i] = attachmentTriangleCount;
}
// tsteil - we need to keep track if we're rendering or not
if (lastMaterial == null)
{
noRender = true;
}
addSubmeshArgumentsTemp.Add(
new LastState.AddSubmeshArguments(lastMaterial, submeshStartSlotIndex, drawOrderCount, submeshTriangleCount, submeshFirstVertex, true)
);
bool mustUpdateMeshStructure = CheckIfMustUpdateMeshStructure(attachmentsTriangleCountTemp, attachmentsFlipStateTemp, addSubmeshArgumentsTemp);
var submeshMatCount = 0;
if (mustUpdateMeshStructure)
{
submeshMaterials.Clear();
for (int i = 0, n = addSubmeshArgumentsTemp.Count; i < n; i++)
{
LastState.AddSubmeshArguments arguments = addSubmeshArgumentsTemp.Items[i];
AddSubmesh(
arguments.material,
arguments.startSlot,
arguments.endSlot,
arguments.triangleCount,
arguments.firstVertex,
arguments.lastSubmesh,
attachmentsFlipStateTemp
);
}
// Set materials.
submeshMatCount = submeshMaterials.Count;
if (submeshMatCount == 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];
if (setupUv2)
{
this.uvs2 = new Vector2[vertexCount];
}
mesh1.Clear();
mesh2.Clear();
}
else
{
// Too many vertices, zero the extra.
Vector3 zero = Vector3.zero;
for (int i = vertexCount, n = lastState.vertexCount; i < n; i++)
{
vertices[i] = zero;
}
}
lastState.vertexCount = vertexCount;
// Setup mesh.
float zSpacing = this.zSpacing;
float[] tempVertices = this.tempVertices;
Vector2[] uvs = this.uvs;
Vector2[] uvs2 = this.uvs2;
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;
meshBoundsMin.x = float.MaxValue;
meshBoundsMin.y = float.MaxValue;
meshBoundsMin.z = zSpacing > 0f ? 0f : zSpacing * (drawOrderCount - 1);
Vector3 meshBoundsMax;
meshBoundsMax.x = float.MinValue;
meshBoundsMax.y = float.MinValue;
meshBoundsMax.z = zSpacing < 0f ? 0f : zSpacing * (drawOrderCount - 1);
for (int i = 0; i < drawOrderCount; i++)
{
Slot slot = drawOrder.Items[i];
Attachment attachment = slot.attachment;
RegionAttachment regionAttachment = attachment as RegionAttachment;
if (regionAttachment != null)
{
regionAttachment.ComputeWorldVertices(slot.bone, tempVertices);
float z = i * zSpacing;
vertices[vertexIndex].x = tempVertices[RegionAttachment.X1];
vertices[vertexIndex].y = tempVertices[RegionAttachment.Y1];
vertices[vertexIndex].z = z;
vertices[vertexIndex + 1].x = tempVertices[RegionAttachment.X4];
vertices[vertexIndex + 1].y = tempVertices[RegionAttachment.Y4];
vertices[vertexIndex + 1].z = z;
vertices[vertexIndex + 2].x = tempVertices[RegionAttachment.X2];
vertices[vertexIndex + 2].y = tempVertices[RegionAttachment.Y2];
vertices[vertexIndex + 2].z = z;
vertices[vertexIndex + 3].x = tempVertices[RegionAttachment.X3];
vertices[vertexIndex + 3].y = tempVertices[RegionAttachment.Y3];
vertices[vertexIndex + 3].z = z;
// Eugene - added
if (overrideVertexColor)
{
color = vertexColor;
colors[vertexIndex] = color;
colors[vertexIndex + 1] = color;
colors[vertexIndex + 2] = color;
colors[vertexIndex + 3] = color;
}
else
{
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 (tempVertices[RegionAttachment.X1] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[RegionAttachment.X1];
}
else if (tempVertices[RegionAttachment.X1] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[RegionAttachment.X1];
}
if (tempVertices[RegionAttachment.X2] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[RegionAttachment.X2];
}
else if (tempVertices[RegionAttachment.X2] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[RegionAttachment.X2];
}
if (tempVertices[RegionAttachment.X3] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[RegionAttachment.X3];
}
else if (tempVertices[RegionAttachment.X3] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[RegionAttachment.X3];
}
if (tempVertices[RegionAttachment.X4] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[RegionAttachment.X4];
}
else if (tempVertices[RegionAttachment.X4] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[RegionAttachment.X4];
}
// Calculate min/max Y
if (tempVertices[RegionAttachment.Y1] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[RegionAttachment.Y1];
}
else if (tempVertices[RegionAttachment.Y1] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[RegionAttachment.Y1];
}
if (tempVertices[RegionAttachment.Y2] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[RegionAttachment.Y2];
}
else if (tempVertices[RegionAttachment.Y2] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[RegionAttachment.Y2];
}
if (tempVertices[RegionAttachment.Y3] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[RegionAttachment.Y3];
}
else if (tempVertices[RegionAttachment.Y3] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[RegionAttachment.Y3];
}
if (tempVertices[RegionAttachment.Y4] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[RegionAttachment.Y4];
}
else if (tempVertices[RegionAttachment.Y4] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[RegionAttachment.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);
// Eugene - added
if (overrideVertexColor)
{
color = vertexColor;
}
else
{
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++)
{
vertices[vertexIndex].x = tempVertices[ii];
vertices[vertexIndex].y = tempVertices[ii + 1];
vertices[vertexIndex].z = z;
colors[vertexIndex] = color;
uvs[vertexIndex].x = meshUVs[ii];
uvs[vertexIndex].y = meshUVs[ii + 1];
if (tempVertices[ii] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[ii];
}
else if (tempVertices[ii] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[ii];
}
if (tempVertices[ii + 1] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[ii + 1];
}
else if (tempVertices[ii + 1] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[ii + 1];
}
}
}
else
{
SkinnedMeshAttachment skinnedMeshAttachment = attachment as SkinnedMeshAttachment;
if (skinnedMeshAttachment != null)
{
int meshVertexCount = skinnedMeshAttachment.uvs.Length;
if (tempVertices.Length < meshVertexCount)
{
this.tempVertices = tempVertices = new float[meshVertexCount];
}
skinnedMeshAttachment.ComputeWorldVertices(slot, tempVertices);
// Eugene - added
if (overrideVertexColor)
{
color = vertexColor;
}
else
{
color.a = (byte)(a * slot.a * skinnedMeshAttachment.a);
color.r = (byte)(r * slot.r * skinnedMeshAttachment.r * color.a);
color.g = (byte)(g * slot.g * skinnedMeshAttachment.g * color.a);
color.b = (byte)(b * slot.b * skinnedMeshAttachment.b * color.a);
if (slot.data.blendMode == BlendMode.additive)
{
color.a = 0;
}
}
float[] meshUVs = skinnedMeshAttachment.uvs;
float z = i * zSpacing;
for (int ii = 0; ii < meshVertexCount; ii += 2, vertexIndex++)
{
vertices[vertexIndex].x = tempVertices[ii];
vertices[vertexIndex].y = tempVertices[ii + 1];
vertices[vertexIndex].z = z;
colors[vertexIndex] = color;
uvs[vertexIndex].x = meshUVs[ii];
uvs[vertexIndex].y = meshUVs[ii + 1];
if (tempVertices[ii] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[ii];
}
else if (tempVertices[ii] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[ii];
}
if (tempVertices[ii + 1] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[ii + 1];
}
else if (tempVertices[ii + 1] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[ii + 1];
}
}
}
}
}
}
// Double buffer mesh.
Mesh mesh = useMesh1 ? mesh1 : mesh2;
meshFilter.sharedMesh = mesh;
mesh.vertices = vertices;
mesh.colors32 = colors;
mesh.uv = uvs;
// tsteil - added UV2 stuff
if (setupUv2)
{
float minX = 1f;
float minY = 1f;
float maxX = 0f;
float maxY = 0f;
float sizeX = 0f;
float sizeY = 0f;
// go through our vertices and find the min and max so we can normalize the UVs against it
for (int i = 0; i < vertexCount; ++i)
{
var x = vertices[i].x;
var y = vertices[i].y;
if (x < minX)
{
minX = x;
}
else if (x > maxX)
{
maxX = x;
}
if (y < minY)
{
minY = y;
}
else if (y > maxY)
{
maxY = y;
}
}
sizeX = maxX - minX;
sizeY = maxY - minY;
// now set the uvs2
for (int i = 0; i < vertexCount; ++i)
{
uvs2[i].x = (vertices[i].x - minX) / sizeX;
uvs2[i].y = (vertices[i].y - minY) / sizeY;
}
mesh.uv2 = uvs2;
}
if (mustUpdateMeshStructure)
{
int submeshCount = submeshMatCount;
mesh.subMeshCount = submeshCount;
for (int i = 0; i < submeshCount; ++i)
{
mesh.SetTriangles(submeshes.Items[i].triangles, i);
}
}
// tsteil: if we're not rendering, we dont need to calculate the bounds (this fixes the crazy AABB math errors)
if (noRender == 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];
Vector3 tangent = new Vector3(0, 0, 1);
for (int i = 0; i < vertexCount; i++)
{
tangents[i] = tangent;
}
mesh1.tangents = tangents;
mesh2.tangents = tangents;
}
}
// Update previous state
ExposedList <int> attachmentsTriangleCountCurrentMesh;
ExposedList <bool> attachmentsFlipStateCurrentMesh;
ExposedList <LastState.AddSubmeshArguments> addSubmeshArgumentsCurrentMesh;
if (useMesh1)
{
attachmentsTriangleCountCurrentMesh = lastState.attachmentsTriangleCountMesh1;
addSubmeshArgumentsCurrentMesh = lastState.addSubmeshArgumentsMesh1;
attachmentsFlipStateCurrentMesh = lastState.attachmentsFlipStateMesh1;
lastState.immutableTrianglesMesh1 = immutableTriangles;
}
else
{
attachmentsTriangleCountCurrentMesh = lastState.attachmentsTriangleCountMesh2;
addSubmeshArgumentsCurrentMesh = lastState.addSubmeshArgumentsMesh2;
attachmentsFlipStateCurrentMesh = lastState.attachmentsFlipStateMesh2;
lastState.immutableTrianglesMesh2 = immutableTriangles;
}
attachmentsTriangleCountCurrentMesh.GrowIfNeeded(attachmentsTriangleCountTemp.Capacity);
attachmentsTriangleCountCurrentMesh.Count = attachmentsTriangleCountTemp.Count;
attachmentsTriangleCountTemp.CopyTo(attachmentsTriangleCountCurrentMesh.Items, 0);
attachmentsFlipStateCurrentMesh.GrowIfNeeded(attachmentsFlipStateTemp.Capacity);
attachmentsFlipStateCurrentMesh.Count = attachmentsFlipStateTemp.Count;
attachmentsFlipStateTemp.CopyTo(attachmentsFlipStateCurrentMesh.Items, 0);
addSubmeshArgumentsCurrentMesh.GrowIfNeeded(addSubmeshArgumentsTemp.Count);
addSubmeshArgumentsCurrentMesh.Count = addSubmeshArgumentsTemp.Count;
addSubmeshArgumentsTemp.CopyTo(addSubmeshArgumentsCurrentMesh.Items);
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 void ReadAnimation (Dictionary<String, Object> map, String name, SkeletonData skeletonData) {
var scale = this.Scale;
var timelines = new ExposedList<Timeline>();
float duration = 0;
// Slot timelines.
if (map.ContainsKey("slots")) {
foreach (KeyValuePair<String, Object> entry in (Dictionary<String, Object>)map["slots"]) {
String slotName = entry.Key;
int slotIndex = skeletonData.FindSlotIndex(slotName);
var timelineMap = (Dictionary<String, Object>)entry.Value;
foreach (KeyValuePair<String, Object> timelineEntry in timelineMap) {
var values = (List<Object>)timelineEntry.Value;
var timelineName = (String)timelineEntry.Key;
if (timelineName == "color") {
var timeline = new ColorTimeline(values.Count);
timeline.slotIndex = slotIndex;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
String c = (String)valueMap["color"];
timeline.SetFrame(frameIndex, time, ToColor(c, 0), ToColor(c, 1), ToColor(c, 2), ToColor(c, 3));
ReadCurve(valueMap, timeline, frameIndex);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(timeline.FrameCount - 1) * ColorTimeline.ENTRIES]);
} else if (timelineName == "attachment") {
var timeline = new AttachmentTimeline(values.Count);
timeline.slotIndex = slotIndex;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
timeline.SetFrame(frameIndex++, time, (String)valueMap["name"]);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
} else
throw new Exception("Invalid timeline type for a slot: " + timelineName + " (" + slotName + ")");
}
}
}
// Bone timelines.
if (map.ContainsKey("bones")) {
foreach (KeyValuePair<String, Object> entry in (Dictionary<String, Object>)map["bones"]) {
String boneName = entry.Key;
int boneIndex = skeletonData.FindBoneIndex(boneName);
if (boneIndex == -1) throw new Exception("Bone not found: " + boneName);
var timelineMap = (Dictionary<String, Object>)entry.Value;
foreach (KeyValuePair<String, Object> timelineEntry in timelineMap) {
var values = (List<Object>)timelineEntry.Value;
var timelineName = (String)timelineEntry.Key;
if (timelineName == "rotate") {
var timeline = new RotateTimeline(values.Count);
timeline.boneIndex = boneIndex;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
timeline.SetFrame(frameIndex, (float)valueMap["time"], (float)valueMap["angle"]);
ReadCurve(valueMap, timeline, frameIndex);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(timeline.FrameCount - 1) * RotateTimeline.ENTRIES]);
} else if (timelineName == "translate" || timelineName == "scale" || timelineName == "shear") {
TranslateTimeline timeline;
float timelineScale = 1;
if (timelineName == "scale")
timeline = new ScaleTimeline(values.Count);
else if (timelineName == "shear")
timeline = new ShearTimeline(values.Count);
else {
timeline = new TranslateTimeline(values.Count);
timelineScale = scale;
}
timeline.boneIndex = boneIndex;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
float x = GetFloat(valueMap, "x", 0);
float y = GetFloat(valueMap, "y", 0);
timeline.SetFrame(frameIndex, time, x * timelineScale, y * timelineScale);
ReadCurve(valueMap, timeline, frameIndex);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(timeline.FrameCount - 1) * TranslateTimeline.ENTRIES]);
} else
throw new Exception("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")");
}
}
}
// IK constraint timelines.
if (map.ContainsKey("ik")) {
foreach (KeyValuePair<String, Object> constraintMap in (Dictionary<String, Object>)map["ik"]) {
IkConstraintData constraint = skeletonData.FindIkConstraint(constraintMap.Key);
var values = (List<Object>)constraintMap.Value;
var timeline = new IkConstraintTimeline(values.Count);
timeline.ikConstraintIndex = skeletonData.ikConstraints.IndexOf(constraint);
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
float mix = GetFloat(valueMap, "mix", 1);
bool bendPositive = GetBoolean(valueMap, "bendPositive", true);
timeline.SetFrame(frameIndex, time, mix, bendPositive ? 1 : -1);
ReadCurve(valueMap, timeline, frameIndex);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(timeline.FrameCount - 1) * IkConstraintTimeline.ENTRIES]);
}
}
// Transform constraint timelines.
if (map.ContainsKey("transform")) {
foreach (KeyValuePair<String, Object> constraintMap in (Dictionary<String, Object>)map["transform"]) {
TransformConstraintData constraint = skeletonData.FindTransformConstraint(constraintMap.Key);
var values = (List<Object>)constraintMap.Value;
var timeline = new TransformConstraintTimeline(values.Count);
timeline.transformConstraintIndex = skeletonData.transformConstraints.IndexOf(constraint);
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float time = (float)valueMap["time"];
float rotateMix = GetFloat(valueMap, "rotateMix", 1);
float translateMix = GetFloat(valueMap, "translateMix", 1);
float scaleMix = GetFloat(valueMap, "scaleMix", 1);
float shearMix = GetFloat(valueMap, "shearMix", 1);
timeline.SetFrame(frameIndex, time, rotateMix, translateMix, scaleMix, shearMix);
ReadCurve(valueMap, timeline, frameIndex);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(timeline.FrameCount - 1) * TransformConstraintTimeline.ENTRIES]);
}
}
// Path constraint timelines.
if (map.ContainsKey("paths")) {
foreach (KeyValuePair<String, Object> constraintMap in (Dictionary<String, Object>)map["paths"]) {
int index = skeletonData.FindPathConstraintIndex(constraintMap.Key);
if (index == -1) throw new Exception("Path constraint not found: " + constraintMap.Key);
PathConstraintData data = skeletonData.pathConstraints.Items[index];
var timelineMap = (Dictionary<String, Object>)constraintMap.Value;
foreach (KeyValuePair<String, Object> timelineEntry in timelineMap) {
var values = (List<Object>)timelineEntry.Value;
var timelineName = (String)timelineEntry.Key;
if (timelineName == "position" || timelineName == "spacing") {
PathConstraintPositionTimeline timeline;
float timelineScale = 1;
if (timelineName == "spacing") {
timeline = new PathConstraintSpacingTimeline(values.Count);
if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed) timelineScale = scale;
}
else {
timeline = new PathConstraintPositionTimeline(values.Count);
if (data.positionMode == PositionMode.Fixed) timelineScale = scale;
}
timeline.pathConstraintIndex = index;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
timeline.SetFrame(frameIndex, (float)valueMap["time"], GetFloat(valueMap, timelineName, 0) * timelineScale);
ReadCurve(valueMap, timeline, frameIndex);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(timeline.FrameCount - 1) * PathConstraintPositionTimeline.ENTRIES]);
}
else if (timelineName == "mix") {
PathConstraintMixTimeline timeline = new PathConstraintMixTimeline(values.Count);
timeline.pathConstraintIndex = index;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
timeline.SetFrame(frameIndex, (float)valueMap["time"], GetFloat(valueMap, "rotateMix", 1), GetFloat(valueMap, "translateMix", 1));
ReadCurve(valueMap, timeline, frameIndex);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(timeline.FrameCount - 1) * PathConstraintMixTimeline.ENTRIES]);
}
}
}
}
// Deform timelines.
if (map.ContainsKey("deform")) {
foreach (KeyValuePair<String, Object> deformMap in (Dictionary<String, Object>)map["deform"]) {
Skin skin = skeletonData.FindSkin(deformMap.Key);
foreach (KeyValuePair<String, Object> slotMap in (Dictionary<String, Object>)deformMap.Value) {
int slotIndex = skeletonData.FindSlotIndex(slotMap.Key);
if (slotIndex == -1) throw new Exception("Slot not found: " + slotMap.Key);
foreach (KeyValuePair<String, Object> timelineMap in (Dictionary<String, Object>)slotMap.Value) {
var values = (List<Object>)timelineMap.Value;
VertexAttachment attachment = (VertexAttachment)skin.GetAttachment(slotIndex, timelineMap.Key);
if (attachment == null) throw new Exception("Deform attachment not found: " + timelineMap.Key);
bool weighted = attachment.bones != null;
float[] vertices = attachment.vertices;
int deformLength = weighted ? vertices.Length / 3 * 2 : vertices.Length;
var timeline = new DeformTimeline(values.Count);
timeline.slotIndex = slotIndex;
timeline.attachment = attachment;
int frameIndex = 0;
foreach (Dictionary<String, Object> valueMap in values) {
float[] deform;
if (!valueMap.ContainsKey("vertices")) {
deform = weighted ? new float[deformLength] : vertices;
} else {
deform = new float[deformLength];
int start = GetInt(valueMap, "offset", 0);
float[] verticesValue = GetFloatArray(valueMap, "vertices", 1);
Array.Copy(verticesValue, 0, deform, start, verticesValue.Length);
if (scale != 1) {
for (int i = start, n = i + verticesValue.Length; i < n; i++)
deform[i] *= scale;
}
if (!weighted) {
for (int i = 0; i < deformLength; i++)
deform[i] += vertices[i];
}
}
timeline.SetFrame(frameIndex, (float)valueMap["time"], deform);
ReadCurve(valueMap, timeline, frameIndex);
frameIndex++;
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
}
}
}
}
// Draw order timeline.
if (map.ContainsKey("drawOrder") || map.ContainsKey("draworder")) {
var values = (List<Object>)map[map.ContainsKey("drawOrder") ? "drawOrder" : "draworder"];
var timeline = new DrawOrderTimeline(values.Count);
int slotCount = skeletonData.slots.Count;
int frameIndex = 0;
foreach (Dictionary<String, Object> drawOrderMap in values) {
int[] drawOrder = null;
if (drawOrderMap.ContainsKey("offsets")) {
drawOrder = new int[slotCount];
for (int i = slotCount - 1; i >= 0; i--)
drawOrder[i] = -1;
var offsets = (List<Object>)drawOrderMap["offsets"];
int[] unchanged = new int[slotCount - offsets.Count];
int originalIndex = 0, unchangedIndex = 0;
foreach (Dictionary<String, Object> offsetMap in offsets) {
int slotIndex = skeletonData.FindSlotIndex((String)offsetMap["slot"]);
if (slotIndex == -1) throw new Exception("Slot not found: " + offsetMap["slot"]);
// Collect unchanged items.
while (originalIndex != slotIndex)
unchanged[unchangedIndex++] = originalIndex++;
// Set changed items.
int index = originalIndex + (int)(float)offsetMap["offset"];
drawOrder[index] = originalIndex++;
}
// Collect remaining unchanged items.
while (originalIndex < slotCount)
unchanged[unchangedIndex++] = originalIndex++;
// Fill in unchanged items.
for (int i = slotCount - 1; i >= 0; i--)
if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex];
}
timeline.SetFrame(frameIndex++, (float)drawOrderMap["time"], drawOrder);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
}
// Event timeline.
if (map.ContainsKey("events")) {
var eventsMap = (List<Object>)map["events"];
var timeline = new EventTimeline(eventsMap.Count);
int frameIndex = 0;
foreach (Dictionary<String, Object> eventMap in eventsMap) {
EventData eventData = skeletonData.FindEvent((String)eventMap["name"]);
if (eventData == null) throw new Exception("Event not found: " + eventMap["name"]);
var e = new Event((float)eventMap["time"], eventData);
e.Int = GetInt(eventMap, "int", eventData.Int);
e.Float = GetFloat(eventMap, "float", eventData.Float);
e.String = GetString(eventMap, "string", eventData.String);
timeline.SetFrame(frameIndex++, e);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
}
timelines.TrimExcess();
skeletonData.animations.Add(new Animation(name, timelines, duration));
}
private Vertices ReadVertices (Stream input, int vertexCount) {
float scale = Scale;
int verticesLength = vertexCount << 1;
Vertices vertices = new Vertices();
if(!ReadBoolean(input)) {
vertices.vertices = ReadFloatArray(input, verticesLength, scale);
return vertices;
}
var weights = new ExposedList<float>(verticesLength * 3 * 3);
var bonesArray = new ExposedList<int>(verticesLength * 3);
for (int i = 0; i < vertexCount; i++) {
int boneCount = ReadVarint(input, true);
bonesArray.Add(boneCount);
for (int ii = 0; ii < boneCount; ii++) {
bonesArray.Add(ReadVarint(input, true));
weights.Add(ReadFloat(input) * scale);
weights.Add(ReadFloat(input) * scale);
weights.Add(ReadFloat(input));
}
}
vertices.vertices = weights.ToArray();
vertices.bones = bonesArray.ToArray();
return vertices;
}
public static bool EnsureTriangleBuffersSize (ExposedList<SubmeshTriangleBuffer> submeshBuffers, int targetSubmeshCount, SubmeshInstruction[] instructionItems) {
bool submeshBuffersWasResized = submeshBuffers.Count < targetSubmeshCount;
if (submeshBuffersWasResized) {
submeshBuffers.GrowIfNeeded(targetSubmeshCount - submeshBuffers.Count);
for (int i = submeshBuffers.Count; submeshBuffers.Count < targetSubmeshCount; i++)
submeshBuffers.Add(new SubmeshTriangleBuffer(instructionItems[i].triangleCount));
}
return submeshBuffersWasResized;
}
private void ReadAnimation (String name, Stream input, SkeletonData skeletonData) {
var timelines = new ExposedList<Timeline>();
float scale = Scale;
float duration = 0;
// Slot timelines.
for (int i = 0, n = ReadVarint(input, true); i < n; i++) {
int slotIndex = ReadVarint(input, true);
for (int ii = 0, nn = ReadVarint(input, true); ii < nn; ii++) {
int timelineType = input.ReadByte();
int frameCount = ReadVarint(input, true);
switch (timelineType) {
case SLOT_COLOR: {
ColorTimeline timeline = new ColorTimeline(frameCount);
timeline.slotIndex = slotIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
float time = ReadFloat(input);
int color = ReadInt(input);
float r = ((color & 0xff000000) >> 24) / 255f;
float g = ((color & 0x00ff0000) >> 16) / 255f;
float b = ((color & 0x0000ff00) >> 8) / 255f;
float a = ((color & 0x000000ff)) / 255f;
timeline.SetFrame(frameIndex, time, r, g, b, a);
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(timeline.FrameCount - 1) * ColorTimeline.ENTRIES]);
break;
}
case SLOT_ATTACHMENT: {
AttachmentTimeline timeline = new AttachmentTimeline(frameCount);
timeline.slotIndex = slotIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++)
timeline.SetFrame(frameIndex, ReadFloat(input), ReadString(input));
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount - 1]);
break;
}
}
}
}
// Bone timelines.
for (int i = 0, n = ReadVarint(input, true); i < n; i++) {
int boneIndex = ReadVarint(input, true);
for (int ii = 0, nn = ReadVarint(input, true); ii < nn; ii++) {
int timelineType = input.ReadByte();
int frameCount = ReadVarint(input, true);
switch (timelineType) {
case BONE_ROTATE: {
RotateTimeline timeline = new RotateTimeline(frameCount);
timeline.boneIndex = boneIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input));
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(frameCount - 1) * RotateTimeline.ENTRIES]);
break;
}
case BONE_TRANSLATE:
case BONE_SCALE:
case BONE_SHEAR: {
TranslateTimeline timeline;
float timelineScale = 1;
if (timelineType == BONE_SCALE)
timeline = new ScaleTimeline(frameCount);
else if (timelineType == BONE_SHEAR)
timeline = new ShearTimeline(frameCount);
else {
timeline = new TranslateTimeline(frameCount);
timelineScale = scale;
}
timeline.boneIndex = boneIndex;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input) * timelineScale, ReadFloat(input)
* timelineScale);
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(frameCount - 1) * TranslateTimeline.ENTRIES]);
break;
}
}
}
}
// IK timelines.
for (int i = 0, n = ReadVarint(input, true); i < n; i++) {
int index = ReadVarint(input, true);
int frameCount = ReadVarint(input, true);
IkConstraintTimeline timeline = new IkConstraintTimeline(frameCount);
timeline.ikConstraintIndex = index;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input), ReadSByte(input));
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(frameCount - 1) * IkConstraintTimeline.ENTRIES]);
}
// Transform constraint timelines.
for (int i = 0, n = ReadVarint(input, true); i < n; i++) {
int index = ReadVarint(input, true);
int frameCount = ReadVarint(input, true);
TransformConstraintTimeline timeline = new TransformConstraintTimeline(frameCount);
timeline.transformConstraintIndex = index;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input), ReadFloat(input), ReadFloat(input), ReadFloat(input));
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(frameCount - 1) * TransformConstraintTimeline.ENTRIES]);
}
// Path constraint timelines.
for (int i = 0, n = ReadVarint(input, true); i < n; i++) {
int index = ReadVarint(input, true);
PathConstraintData data = skeletonData.pathConstraints.Items[index];
for (int ii = 0, nn = ReadVarint(input, true); ii < nn; ii++) {
int timelineType = ReadSByte(input);
int frameCount = ReadVarint(input, true);
switch(timelineType) {
case PATH_POSITION:
case PATH_SPACING: {
PathConstraintPositionTimeline timeline;
float timelineScale = 1;
if (timelineType == PATH_SPACING) {
timeline = new PathConstraintSpacingTimeline(frameCount);
if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed) timelineScale = scale;
} else {
timeline = new PathConstraintPositionTimeline(frameCount);
if (data.positionMode == PositionMode.Fixed) timelineScale = scale;
}
timeline.pathConstraintIndex = index;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input) * timelineScale);
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(frameCount - 1) * PathConstraintPositionTimeline.ENTRIES]);
break;
}
case PATH_MIX: {
PathConstraintMixTimeline timeline = new PathConstraintMixTimeline(frameCount);
timeline.pathConstraintIndex = index;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input), ReadFloat(input));
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[(frameCount - 1) * PathConstraintMixTimeline.ENTRIES]);
break;
}
}
}
}
// Deform timelines.
for (int i = 0, n = ReadVarint(input, true); i < n; i++) {
Skin skin = skeletonData.skins.Items[ReadVarint(input, true)];
for (int ii = 0, nn = ReadVarint(input, true); ii < nn; ii++) {
int slotIndex = ReadVarint(input, true);
for (int iii = 0, nnn = ReadVarint(input, true); iii < nnn; iii++) {
VertexAttachment attachment = (VertexAttachment)skin.GetAttachment(slotIndex, ReadString(input));
bool weighted = attachment.bones != null;
float[] vertices = attachment.vertices;
int deformLength = weighted ? vertices.Length / 3 * 2 : vertices.Length;
int frameCount = ReadVarint(input, true);
DeformTimeline timeline = new DeformTimeline(frameCount);
timeline.slotIndex = slotIndex;
timeline.attachment = attachment;
for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
float time = ReadFloat(input);
float[] deform;
int end = ReadVarint(input, true);
if (end == 0)
deform = weighted ? new float[deformLength] : vertices;
else {
deform = new float[deformLength];
int start = ReadVarint(input, true);
end += start;
if (scale == 1) {
for (int v = start; v < end; v++)
deform[v] = ReadFloat(input);
} else {
for (int v = start; v < end; v++)
deform[v] = ReadFloat(input) * scale;
}
if (!weighted) {
for (int v = 0, vn = deform.Length; v < vn; v++)
deform[v] += vertices[v];
}
}
timeline.SetFrame(frameIndex, time, deform);
if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[frameCount - 1]);
}
}
}
// Draw order timeline.
int drawOrderCount = ReadVarint(input, true);
if (drawOrderCount > 0) {
DrawOrderTimeline timeline = new DrawOrderTimeline(drawOrderCount);
int slotCount = skeletonData.slots.Count;
for (int i = 0; i < drawOrderCount; i++) {
float time = ReadFloat(input);
int offsetCount = ReadVarint(input, true);
int[] drawOrder = new int[slotCount];
for (int ii = slotCount - 1; ii >= 0; ii--)
drawOrder[ii] = -1;
int[] unchanged = new int[slotCount - offsetCount];
int originalIndex = 0, unchangedIndex = 0;
for (int ii = 0; ii < offsetCount; ii++) {
int slotIndex = ReadVarint(input, true);
// Collect unchanged items.
while (originalIndex != slotIndex)
unchanged[unchangedIndex++] = originalIndex++;
// Set changed items.
drawOrder[originalIndex + ReadVarint(input, true)] = originalIndex++;
}
// Collect remaining unchanged items.
while (originalIndex < slotCount)
unchanged[unchangedIndex++] = originalIndex++;
// Fill in unchanged items.
for (int ii = slotCount - 1; ii >= 0; ii--)
if (drawOrder[ii] == -1) drawOrder[ii] = unchanged[--unchangedIndex];
timeline.SetFrame(i, time, drawOrder);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[drawOrderCount - 1]);
}
// Event timeline.
int eventCount = ReadVarint(input, true);
if (eventCount > 0) {
EventTimeline timeline = new EventTimeline(eventCount);
for (int i = 0; i < eventCount; i++) {
float time = ReadFloat(input);
EventData eventData = skeletonData.events.Items[ReadVarint(input, true)];
Event e = new Event(time, eventData);
e.Int = ReadVarint(input, false);
e.Float = ReadFloat(input);
e.String = ReadBoolean(input) ? ReadString(input) : eventData.String;
timeline.SetFrame(i, e);
}
timelines.Add(timeline);
duration = Math.Max(duration, timeline.frames[eventCount - 1]);
}
timelines.TrimExcess();
skeletonData.animations.Add(new Animation(name, timelines, duration));
}
public virtual void LateUpdate()
{
if (!valid)
{
return;
}
// Exit early if there is nothing to render
if (!meshRenderer.enabled && submeshRenderers.Length == 0)
{
return;
}
// Count vertices and submesh triangles.
int vertexCount = 0;
int submeshTriangleCount = 0, submeshFirstVertex = 0, submeshStartSlotIndex = 0;
Material lastMaterial = null;
ExposedList <Slot> drawOrder = skeleton.drawOrder;
int drawOrderCount = drawOrder.Count;
int submeshSeparatorSlotsCount = submeshSeparatorSlots.Count;
bool renderMeshes = this.renderMeshes;
// Clear last state of attachments and submeshes
ExposedList <int> attachmentsTriangleCountTemp = lastState.attachmentsTriangleCountTemp;
attachmentsTriangleCountTemp.GrowIfNeeded(drawOrderCount);
attachmentsTriangleCountTemp.Count = drawOrderCount;
ExposedList <bool> attachmentsFlipStateTemp = lastState.attachmentsFlipStateTemp;
attachmentsFlipStateTemp.GrowIfNeeded(drawOrderCount);
attachmentsFlipStateTemp.Count = drawOrderCount;
ExposedList <LastState.AddSubmeshArguments> addSubmeshArgumentsTemp = lastState.addSubmeshArgumentsTemp;
addSubmeshArgumentsTemp.Clear(false);
for (int i = 0; i < drawOrderCount; i++)
{
Slot slot = drawOrder.Items[i];
Bone bone = slot.bone;
Attachment attachment = slot.attachment;
object rendererObject;
int attachmentVertexCount, attachmentTriangleCount;
bool worldScaleXIsPositive = bone.worldScaleX >= 0f;
bool worldScaleYIsPositive = bone.worldScaleY >= 0f;
bool worldScaleIsSameSigns = (worldScaleXIsPositive && worldScaleYIsPositive) ||
(!worldScaleXIsPositive && !worldScaleYIsPositive);
bool flip = frontFacing && ((bone.worldFlipX != bone.worldFlipY) == worldScaleIsSameSigns);
attachmentsFlipStateTemp.Items[i] = flip;
attachmentsTriangleCountTemp.Items[i] = -1;
RegionAttachment regionAttachment = attachment as RegionAttachment;
if (regionAttachment != null)
{
rendererObject = regionAttachment.RendererObject;
attachmentVertexCount = 4;
attachmentTriangleCount = 6;
}
else
{
if (!renderMeshes)
{
continue;
}
MeshAttachment meshAttachment = attachment as MeshAttachment;
if (meshAttachment != null)
{
rendererObject = meshAttachment.RendererObject;
attachmentVertexCount = meshAttachment.vertices.Length >> 1;
attachmentTriangleCount = meshAttachment.triangles.Length;
}
else
{
SkinnedMeshAttachment skinnedMeshAttachment = attachment as SkinnedMeshAttachment;
if (skinnedMeshAttachment != null)
{
rendererObject = skinnedMeshAttachment.RendererObject;
attachmentVertexCount = skinnedMeshAttachment.uvs.Length >> 1;
attachmentTriangleCount = skinnedMeshAttachment.triangles.Length;
}
else
{
continue;
}
}
}
// Populate submesh when material changes.
#if !SPINE_TK2D
Material material = (Material)((AtlasRegion)rendererObject).page.rendererObject;
#else
Material material = (rendererObject.GetType() == typeof(Material)) ? (Material)rendererObject : (Material)((AtlasRegion)rendererObject).page.rendererObject;
#endif
if ((lastMaterial != null && lastMaterial.GetInstanceID() != material.GetInstanceID()) ||
(submeshSeparatorSlotsCount > 0 && submeshSeparatorSlots.Contains(slot)))
{
addSubmeshArgumentsTemp.Add(
new LastState.AddSubmeshArguments(lastMaterial, submeshStartSlotIndex, i, submeshTriangleCount, submeshFirstVertex, false)
);
submeshTriangleCount = 0;
submeshFirstVertex = vertexCount;
submeshStartSlotIndex = i;
}
lastMaterial = material;
submeshTriangleCount += attachmentTriangleCount;
vertexCount += attachmentVertexCount;
attachmentsTriangleCountTemp.Items[i] = attachmentTriangleCount;
}
addSubmeshArgumentsTemp.Add(
new LastState.AddSubmeshArguments(lastMaterial, submeshStartSlotIndex, drawOrderCount, submeshTriangleCount, submeshFirstVertex, true)
);
bool mustUpdateMeshStructure = CheckIfMustUpdateMeshStructure(attachmentsTriangleCountTemp, attachmentsFlipStateTemp, addSubmeshArgumentsTemp);
if (mustUpdateMeshStructure)
{
submeshMaterials.Clear();
for (int i = 0, n = addSubmeshArgumentsTemp.Count; i < n; i++)
{
LastState.AddSubmeshArguments arguments = addSubmeshArgumentsTemp.Items[i];
AddSubmesh(
arguments.material,
arguments.startSlot,
arguments.endSlot,
arguments.triangleCount,
arguments.firstVertex,
arguments.lastSubmesh,
attachmentsFlipStateTemp
);
}
// 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();
}
else
{
// Too many vertices, zero the extra.
Vector3 zero = Vector3.zero;
for (int i = vertexCount, n = lastState.vertexCount; i < n; i++)
{
vertices[i] = zero;
}
}
lastState.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 = drawOrder.Items[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
{
SkinnedMeshAttachment skinnedMeshAttachment = attachment as SkinnedMeshAttachment;
if (skinnedMeshAttachment != null)
{
int meshVertexCount = skinnedMeshAttachment.uvs.Length;
if (tempVertices.Length < meshVertexCount)
{
this.tempVertices = tempVertices = new float[meshVertexCount];
}
skinnedMeshAttachment.ComputeWorldVertices(slot, tempVertices);
color.a = (byte)(a * slot.a * skinnedMeshAttachment.a);
color.r = (byte)(r * slot.r * skinnedMeshAttachment.r * color.a);
color.g = (byte)(g * slot.g * skinnedMeshAttachment.g * color.a);
color.b = (byte)(b * slot.b * skinnedMeshAttachment.b * color.a);
if (slot.data.blendMode == BlendMode.additive)
{
color.a = 0;
}
float[] meshUVs = skinnedMeshAttachment.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);
}
}
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];
Vector3 tangent = new Vector3(0, 0, 1);
for (int i = 0; i < vertexCount; i++)
{
tangents[i] = tangent;
}
mesh1.tangents = tangents;
mesh2.tangents = tangents;
}
}
// Update previous state
ExposedList <int> attachmentsTriangleCountCurrentMesh;
ExposedList <bool> attachmentsFlipStateCurrentMesh;
ExposedList <LastState.AddSubmeshArguments> addSubmeshArgumentsCurrentMesh;
if (useMesh1)
{
attachmentsTriangleCountCurrentMesh = lastState.attachmentsTriangleCountMesh1;
addSubmeshArgumentsCurrentMesh = lastState.addSubmeshArgumentsMesh1;
attachmentsFlipStateCurrentMesh = lastState.attachmentsFlipStateMesh1;
lastState.immutableTrianglesMesh1 = immutableTriangles;
}
else
{
attachmentsTriangleCountCurrentMesh = lastState.attachmentsTriangleCountMesh2;
addSubmeshArgumentsCurrentMesh = lastState.addSubmeshArgumentsMesh2;
attachmentsFlipStateCurrentMesh = lastState.attachmentsFlipStateMesh2;
lastState.immutableTrianglesMesh2 = immutableTriangles;
}
attachmentsTriangleCountCurrentMesh.GrowIfNeeded(attachmentsTriangleCountTemp.Capacity);
attachmentsTriangleCountCurrentMesh.Count = attachmentsTriangleCountTemp.Count;
attachmentsTriangleCountTemp.CopyTo(attachmentsTriangleCountCurrentMesh.Items, 0);
attachmentsFlipStateCurrentMesh.GrowIfNeeded(attachmentsFlipStateTemp.Capacity);
attachmentsFlipStateCurrentMesh.Count = attachmentsFlipStateTemp.Count;
attachmentsFlipStateTemp.CopyTo(attachmentsFlipStateCurrentMesh.Items, 0);
addSubmeshArgumentsCurrentMesh.GrowIfNeeded(addSubmeshArgumentsTemp.Count);
addSubmeshArgumentsCurrentMesh.Count = addSubmeshArgumentsTemp.Count;
addSubmeshArgumentsTemp.CopyTo(addSubmeshArgumentsCurrentMesh.Items);
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;
}
public void UpdateMesh()
{
//Debug.Log("UpdateMesh");
if (!valid)
{
return;
}
float scale = canvas.referencePixelsPerUnit;
// Count vertices and submesh triangles.
int vertexCount = 0;
int submeshTriangleCount = 0, submeshFirstVertex = 0, submeshStartSlotIndex = 0;
Material lastMaterial = null;
ExposedList <Slot> drawOrder = skeleton.drawOrder;
int drawOrderCount = drawOrder.Count;
bool renderMeshes = this.renderMeshes;
// Clear last state of attachments and submeshes
ExposedList <int> attachmentsTriangleCountTemp = lastState.attachmentsTriangleCountTemp;
attachmentsTriangleCountTemp.GrowIfNeeded(drawOrderCount);
attachmentsTriangleCountTemp.Count = drawOrderCount;
ExposedList <bool> attachmentsFlipStateTemp = lastState.attachmentsFlipStateTemp;
attachmentsFlipStateTemp.GrowIfNeeded(drawOrderCount);
attachmentsFlipStateTemp.Count = drawOrderCount;
ExposedList <LastState.AddSubmeshArguments> addSubmeshArgumentsTemp = lastState.addSubmeshArgumentsTemp;
addSubmeshArgumentsTemp.Clear(false);
for (int i = 0; i < drawOrderCount; i++)
{
Slot slot = drawOrder.Items[i];
Bone bone = slot.bone;
Attachment attachment = slot.attachment;
object rendererObject;
int attachmentVertexCount, attachmentTriangleCount;
bool worldScaleXIsPositive = bone.worldScaleX >= 0f;
bool worldScaleYIsPositive = bone.worldScaleY >= 0f;
bool worldScaleIsSameSigns = (worldScaleXIsPositive && worldScaleYIsPositive) ||
(!worldScaleXIsPositive && !worldScaleYIsPositive);
bool flip = frontFacing && ((bone.worldFlipX != bone.worldFlipY) == worldScaleIsSameSigns);
attachmentsFlipStateTemp.Items[i] = flip;
attachmentsTriangleCountTemp.Items[i] = -1;
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 SkinnedMeshAttachment;
if (skinnedMeshAttachment != null)
{
rendererObject = skinnedMeshAttachment.RendererObject;
attachmentVertexCount = skinnedMeshAttachment.uvs.Length >> 1;
attachmentTriangleCount = skinnedMeshAttachment.triangles.Length;
}
else
{
continue;
}
}
}
// Populate submesh when material changes.
#if !SPINE_TK2D
var currentMaterial = (Material)((AtlasRegion)rendererObject).page.rendererObject;
#else
var currentMaterial = (rendererObject.GetType() == typeof(Material)) ? (Material)rendererObject : (Material)((AtlasRegion)rendererObject).page.rendererObject;
#endif
if ((lastMaterial != null && lastMaterial.GetInstanceID() != currentMaterial.GetInstanceID()))
{
addSubmeshArgumentsTemp.Add(
new LastState.AddSubmeshArguments(lastMaterial, submeshStartSlotIndex, i, submeshTriangleCount, submeshFirstVertex, false)
);
submeshTriangleCount = 0;
submeshFirstVertex = vertexCount;
submeshStartSlotIndex = i;
}
lastMaterial = currentMaterial;
submeshTriangleCount += attachmentTriangleCount;
vertexCount += attachmentVertexCount;
attachmentsTriangleCountTemp.Items[i] = attachmentTriangleCount;
}
addSubmeshArgumentsTemp.Add(
new LastState.AddSubmeshArguments(lastMaterial, submeshStartSlotIndex, drawOrderCount, submeshTriangleCount, submeshFirstVertex, true)
);
bool mustUpdateMeshStructure = CheckIfMustUpdateMeshStructure(attachmentsTriangleCountTemp, attachmentsFlipStateTemp, addSubmeshArgumentsTemp);
if (mustUpdateMeshStructure)
{
submeshMaterials.Clear();
for (int i = 0, n = addSubmeshArgumentsTemp.Count; i < n; i++)
{
LastState.AddSubmeshArguments arguments = addSubmeshArgumentsTemp.Items[i];
AddSubmesh(
arguments.material,
arguments.startSlot,
arguments.endSlot,
arguments.triangleCount,
arguments.firstVertex,
arguments.lastSubmesh,
attachmentsFlipStateTemp
);
}
// Set materials.
if (submeshMaterials.Count == sharedMaterials.Length)
{
submeshMaterials.CopyTo(sharedMaterials);
}
else
{
sharedMaterials = submeshMaterials.ToArray();
}
//meshRenderer.sharedMaterials = sharedMaterials;
this.material = sharedMaterials[0];
canvasRenderer.SetMaterial(sharedMaterials[0], (Texture)null);
}
// 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();
}
else
{
// Too many vertices, zero the extra.
Vector3 zero = Vector3.zero;
for (int i = vertexCount, n = lastState.vertexCount; i < n; i++)
{
vertices[i] = zero;
}
}
lastState.vertexCount = vertexCount;
// Setup mesh.
float zSpacing = this.zSpacing;
float[] tempVertices = this.tempVertices;
Vector2[] uvs = this.uvs;
Color32[] colors = this.colors;
int vertexIndex = 0;
Color32 vertColor = new Color32();
Color graphicColor = base.color;
float a = skeleton.a * 255, r = skeleton.r, g = skeleton.g, b = skeleton.b;
// Mesh bounds
Vector3 meshBoundsMin;
meshBoundsMin.x = float.MaxValue;
meshBoundsMin.y = float.MaxValue;
meshBoundsMin.z = zSpacing > 0f ? 0f : zSpacing * (drawOrderCount - 1);
Vector3 meshBoundsMax;
meshBoundsMax.x = float.MinValue;
meshBoundsMax.y = float.MinValue;
meshBoundsMax.z = zSpacing < 0f ? 0f : zSpacing * (drawOrderCount - 1);
for (int i = 0; i < drawOrderCount; i++)
{
Slot slot = drawOrder.Items[i];
Attachment attachment = slot.attachment;
var regionAttachment = attachment as RegionAttachment;
if (regionAttachment != null)
{
regionAttachment.ComputeWorldVertices(slot.bone, tempVertices);
float z = i * zSpacing;
vertices[vertexIndex].x = tempVertices[RegionAttachment.X1] * scale;
vertices[vertexIndex].y = tempVertices[RegionAttachment.Y1] * scale;
vertices[vertexIndex].z = z;
vertices[vertexIndex + 1].x = tempVertices[RegionAttachment.X4] * scale;
vertices[vertexIndex + 1].y = tempVertices[RegionAttachment.Y4] * scale;
vertices[vertexIndex + 1].z = z;
vertices[vertexIndex + 2].x = tempVertices[RegionAttachment.X2] * scale;
vertices[vertexIndex + 2].y = tempVertices[RegionAttachment.Y2] * scale;
vertices[vertexIndex + 2].z = z;
vertices[vertexIndex + 3].x = tempVertices[RegionAttachment.X3] * scale;
vertices[vertexIndex + 3].y = tempVertices[RegionAttachment.Y3] * scale;
vertices[vertexIndex + 3].z = z;
vertColor.a = (byte)(a * slot.a * regionAttachment.a * graphicColor.a);
vertColor.r = (byte)(r * slot.r * regionAttachment.r * graphicColor.r * vertColor.a);
vertColor.g = (byte)(g * slot.g * regionAttachment.g * graphicColor.g * vertColor.a);
vertColor.b = (byte)(b * slot.b * regionAttachment.b * graphicColor.b * vertColor.a);
if (slot.data.blendMode == BlendMode.additive)
{
vertColor.a = 0;
}
colors[vertexIndex] = vertColor;
colors[vertexIndex + 1] = vertColor;
colors[vertexIndex + 2] = vertColor;
colors[vertexIndex + 3] = vertColor;
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 Bounds min/max X
if (tempVertices[RegionAttachment.X1] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[RegionAttachment.X1];
}
else if (tempVertices[RegionAttachment.X1] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[RegionAttachment.X1];
}
if (tempVertices[RegionAttachment.X2] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[RegionAttachment.X2];
}
else if (tempVertices[RegionAttachment.X2] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[RegionAttachment.X2];
}
if (tempVertices[RegionAttachment.X3] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[RegionAttachment.X3];
}
else if (tempVertices[RegionAttachment.X3] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[RegionAttachment.X3];
}
if (tempVertices[RegionAttachment.X4] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[RegionAttachment.X4];
}
else if (tempVertices[RegionAttachment.X4] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[RegionAttachment.X4];
}
// Calculate Bounds min/max Y
if (tempVertices[RegionAttachment.Y1] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[RegionAttachment.Y1];
}
else if (tempVertices[RegionAttachment.Y1] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[RegionAttachment.Y1];
}
if (tempVertices[RegionAttachment.Y2] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[RegionAttachment.Y2];
}
else if (tempVertices[RegionAttachment.Y2] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[RegionAttachment.Y2];
}
if (tempVertices[RegionAttachment.Y3] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[RegionAttachment.Y3];
}
else if (tempVertices[RegionAttachment.Y3] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[RegionAttachment.Y3];
}
if (tempVertices[RegionAttachment.Y4] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[RegionAttachment.Y4];
}
else if (tempVertices[RegionAttachment.Y4] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[RegionAttachment.Y4];
}
vertexIndex += 4;
}
else
{
if (!renderMeshes)
{
continue;
}
var 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);
vertColor.a = (byte)(a * slot.a * meshAttachment.a * graphicColor.a);
vertColor.r = (byte)(r * slot.r * meshAttachment.r * graphicColor.r * vertColor.a);
vertColor.g = (byte)(g * slot.g * meshAttachment.g * graphicColor.g * vertColor.a);
vertColor.b = (byte)(b * slot.b * meshAttachment.b * graphicColor.b * vertColor.a);
if (slot.data.blendMode == BlendMode.additive)
{
vertColor.a = 0;
}
float[] meshUVs = meshAttachment.uvs;
float z = i * zSpacing;
for (int ii = 0; ii < meshVertexCount; ii += 2, vertexIndex++)
{
vertices[vertexIndex].x = tempVertices[ii] * scale;
vertices[vertexIndex].y = tempVertices[ii + 1] * scale;
vertices[vertexIndex].z = z;
colors[vertexIndex] = vertColor;
uvs[vertexIndex].x = meshUVs[ii];
uvs[vertexIndex].y = meshUVs[ii + 1];
// Calculate Bounds
if (tempVertices[ii] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[ii];
}
else if (tempVertices[ii] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[ii];
}
if (tempVertices[ii + 1] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[ii + 1];
}
else if (tempVertices[ii + 1] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[ii + 1];
}
}
}
else
{
var skinnedMeshAttachment = attachment as SkinnedMeshAttachment;
if (skinnedMeshAttachment != null)
{
int meshVertexCount = skinnedMeshAttachment.uvs.Length;
if (tempVertices.Length < meshVertexCount)
{
this.tempVertices = tempVertices = new float[meshVertexCount];
}
skinnedMeshAttachment.ComputeWorldVertices(slot, tempVertices);
vertColor.a = (byte)(a * slot.a * skinnedMeshAttachment.a * graphicColor.a);
vertColor.r = (byte)(r * slot.r * skinnedMeshAttachment.r * graphicColor.r * vertColor.a);
vertColor.g = (byte)(g * slot.g * skinnedMeshAttachment.g * graphicColor.g * vertColor.a);
vertColor.b = (byte)(b * slot.b * skinnedMeshAttachment.b * graphicColor.b * vertColor.a);
if (slot.data.blendMode == BlendMode.additive)
{
vertColor.a = 0;
}
float[] meshUVs = skinnedMeshAttachment.uvs;
float z = i * zSpacing;
for (int ii = 0; ii < meshVertexCount; ii += 2, vertexIndex++)
{
vertices[vertexIndex].x = tempVertices[ii] * scale;
vertices[vertexIndex].y = tempVertices[ii + 1] * scale;
vertices[vertexIndex].z = z;
colors[vertexIndex] = vertColor;
uvs[vertexIndex].x = meshUVs[ii];
uvs[vertexIndex].y = meshUVs[ii + 1];
// Calculate Bounds
if (tempVertices[ii] < meshBoundsMin.x)
{
meshBoundsMin.x = tempVertices[ii];
}
else if (tempVertices[ii] > meshBoundsMax.x)
{
meshBoundsMax.x = tempVertices[ii];
}
if (tempVertices[ii + 1] < meshBoundsMin.y)
{
meshBoundsMin.y = tempVertices[ii + 1];
}
else if (tempVertices[ii + 1] > meshBoundsMax.y)
{
meshBoundsMax.y = tempVertices[ii + 1];
}
}
}
}
}
}
// Double buffer mesh.
Mesh mesh = useMesh1 ? mesh1 : mesh2;
// Push data from buffers.
mesh.vertices = vertices;
mesh.colors32 = colors;
mesh.uv = uvs;
// Set Mesh bounds.
Vector3 meshBoundsExtents = (meshBoundsMax - meshBoundsMin) * scale; // scaled
Vector3 meshBoundsCenter = meshBoundsMin + meshBoundsExtents * 0.5f;
mesh.bounds = new Bounds(meshBoundsCenter, meshBoundsExtents);
//mesh.RecalculateBounds();
canvasRenderer.SetMesh(mesh);
//this.SetVerticesDirty();
if (mustUpdateMeshStructure)
{
int submeshCount = submeshMaterials.Count;
mesh.subMeshCount = submeshCount;
for (int i = 0; i < submeshCount; ++i)
{
mesh.SetTriangles(submeshes.Items[i].triangles, i);
}
/*
* TODO: Check fix with a known repro case.
* if (useMesh1)
* lastState.forceUpdateMesh1 = false;
* else
* lastState.forceUpdateMesh2 = false;
*/
}
if (newTriangles && calculateNormals)
{
var normals = new Vector3[vertexCount];
var 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)
{
var tangents = new Vector4[vertexCount];
var tangent = new Vector3(0, 0, 1);
for (int i = 0; i < vertexCount; i++)
{
tangents[i] = tangent;
}
mesh1.tangents = tangents;
mesh2.tangents = tangents;
}
}
// Update previous state
ExposedList <int> attachmentsTriangleCountCurrentMesh;
ExposedList <bool> attachmentsFlipStateCurrentMesh;
ExposedList <LastState.AddSubmeshArguments> addSubmeshArgumentsCurrentMesh;
if (useMesh1)
{
attachmentsTriangleCountCurrentMesh = lastState.attachmentsTriangleCountMesh1;
addSubmeshArgumentsCurrentMesh = lastState.addSubmeshArgumentsMesh1;
attachmentsFlipStateCurrentMesh = lastState.attachmentsFlipStateMesh1;
lastState.immutableTrianglesMesh1 = immutableTriangles;
}
else
{
attachmentsTriangleCountCurrentMesh = lastState.attachmentsTriangleCountMesh2;
addSubmeshArgumentsCurrentMesh = lastState.addSubmeshArgumentsMesh2;
attachmentsFlipStateCurrentMesh = lastState.attachmentsFlipStateMesh2;
lastState.immutableTrianglesMesh2 = immutableTriangles;
}
attachmentsTriangleCountCurrentMesh.GrowIfNeeded(attachmentsTriangleCountTemp.Capacity);
attachmentsTriangleCountCurrentMesh.Count = attachmentsTriangleCountTemp.Count;
attachmentsTriangleCountTemp.CopyTo(attachmentsTriangleCountCurrentMesh.Items, 0);
attachmentsFlipStateCurrentMesh.GrowIfNeeded(attachmentsFlipStateTemp.Capacity);
attachmentsFlipStateCurrentMesh.Count = attachmentsFlipStateTemp.Count;
attachmentsFlipStateTemp.CopyTo(attachmentsFlipStateCurrentMesh.Items, 0);
addSubmeshArgumentsCurrentMesh.GrowIfNeeded(addSubmeshArgumentsTemp.Count);
addSubmeshArgumentsCurrentMesh.Count = addSubmeshArgumentsTemp.Count;
addSubmeshArgumentsTemp.CopyTo(addSubmeshArgumentsCurrentMesh.Items);
useMesh1 = !useMesh1;
}
