private void ReadAnimation(string name, Stream input, SkeletonData skeletonData)
{
ExposedList <Timeline> exposedList = new ExposedList <Timeline>();
float scale = this.Scale;
float num = 0f;
int i = 0;
int num2 = SkeletonBinary.ReadVarint(input, true);
while (i < num2)
{
int slotIndex = SkeletonBinary.ReadVarint(input, true);
int j = 0;
int num3 = SkeletonBinary.ReadVarint(input, true);
while (j < num3)
{
int num4 = input.ReadByte();
int num5 = SkeletonBinary.ReadVarint(input, true);
if (num4 != 1)
{
if (num4 == 0)
{
AttachmentTimeline attachmentTimeline = new AttachmentTimeline(num5);
attachmentTimeline.slotIndex = slotIndex;
for (int k = 0; k < num5; k++)
{
attachmentTimeline.SetFrame(k, this.ReadFloat(input), this.ReadString(input));
}
exposedList.Add(attachmentTimeline);
num = Math.Max(num, attachmentTimeline.frames[num5 - 1]);
}
}
else
{
ColorTimeline colorTimeline = new ColorTimeline(num5);
colorTimeline.slotIndex = slotIndex;
for (int l = 0; l < num5; l++)
{
float time = this.ReadFloat(input);
int num6 = SkeletonBinary.ReadInt(input);
float r = (float)((num6 & 4278190080u) >> 24) / 255f;
float g = (float)((num6 & 16711680) >> 16) / 255f;
float b = (float)((num6 & 65280) >> 8) / 255f;
float a = (float)(num6 & 255) / 255f;
colorTimeline.SetFrame(l, time, r, g, b, a);
if (l < num5 - 1)
{
this.ReadCurve(input, l, colorTimeline);
}
}
exposedList.Add(colorTimeline);
num = Math.Max(num, colorTimeline.frames[(colorTimeline.FrameCount - 1) * 5]);
}
j++;
}
i++;
}
int m = 0;
int num7 = SkeletonBinary.ReadVarint(input, true);
while (m < num7)
{
int boneIndex = SkeletonBinary.ReadVarint(input, true);
int n = 0;
int num8 = SkeletonBinary.ReadVarint(input, true);
while (n < num8)
{
int num9 = input.ReadByte();
int num10 = SkeletonBinary.ReadVarint(input, true);
switch (num9)
{
case 0:
{
RotateTimeline rotateTimeline = new RotateTimeline(num10);
rotateTimeline.boneIndex = boneIndex;
for (int num11 = 0; num11 < num10; num11++)
{
rotateTimeline.SetFrame(num11, this.ReadFloat(input), this.ReadFloat(input));
if (num11 < num10 - 1)
{
this.ReadCurve(input, num11, rotateTimeline);
}
}
exposedList.Add(rotateTimeline);
num = Math.Max(num, rotateTimeline.frames[(num10 - 1) * 2]);
break;
}
case 1:
case 2:
case 3:
{
float num12 = 1f;
TranslateTimeline translateTimeline;
if (num9 == 2)
{
translateTimeline = new ScaleTimeline(num10);
}
else if (num9 == 3)
{
translateTimeline = new ShearTimeline(num10);
}
else
{
translateTimeline = new TranslateTimeline(num10);
num12 = scale;
}
translateTimeline.boneIndex = boneIndex;
for (int num13 = 0; num13 < num10; num13++)
{
translateTimeline.SetFrame(num13, this.ReadFloat(input), this.ReadFloat(input) * num12, this.ReadFloat(input) * num12);
if (num13 < num10 - 1)
{
this.ReadCurve(input, num13, translateTimeline);
}
}
exposedList.Add(translateTimeline);
num = Math.Max(num, translateTimeline.frames[(num10 - 1) * 3]);
break;
}
}
n++;
}
m++;
}
int num14 = 0;
int num15 = SkeletonBinary.ReadVarint(input, true);
while (num14 < num15)
{
int ikConstraintIndex = SkeletonBinary.ReadVarint(input, true);
int num16 = SkeletonBinary.ReadVarint(input, true);
IkConstraintTimeline ikConstraintTimeline = new IkConstraintTimeline(num16);
ikConstraintTimeline.ikConstraintIndex = ikConstraintIndex;
for (int num17 = 0; num17 < num16; num17++)
{
ikConstraintTimeline.SetFrame(num17, this.ReadFloat(input), this.ReadFloat(input), (int)SkeletonBinary.ReadSByte(input));
if (num17 < num16 - 1)
{
this.ReadCurve(input, num17, ikConstraintTimeline);
}
}
exposedList.Add(ikConstraintTimeline);
num = Math.Max(num, ikConstraintTimeline.frames[(num16 - 1) * 3]);
num14++;
}
int num18 = 0;
int num19 = SkeletonBinary.ReadVarint(input, true);
while (num18 < num19)
{
int transformConstraintIndex = SkeletonBinary.ReadVarint(input, true);
int num20 = SkeletonBinary.ReadVarint(input, true);
TransformConstraintTimeline transformConstraintTimeline = new TransformConstraintTimeline(num20);
transformConstraintTimeline.transformConstraintIndex = transformConstraintIndex;
for (int num21 = 0; num21 < num20; num21++)
{
transformConstraintTimeline.SetFrame(num21, this.ReadFloat(input), this.ReadFloat(input), this.ReadFloat(input), this.ReadFloat(input), this.ReadFloat(input));
if (num21 < num20 - 1)
{
this.ReadCurve(input, num21, transformConstraintTimeline);
}
}
exposedList.Add(transformConstraintTimeline);
num = Math.Max(num, transformConstraintTimeline.frames[(num20 - 1) * 5]);
num18++;
}
int num22 = 0;
int num23 = SkeletonBinary.ReadVarint(input, true);
while (num22 < num23)
{
int num24 = SkeletonBinary.ReadVarint(input, true);
PathConstraintData pathConstraintData = skeletonData.pathConstraints.Items[num24];
int num25 = 0;
int num26 = SkeletonBinary.ReadVarint(input, true);
while (num25 < num26)
{
int num27 = (int)SkeletonBinary.ReadSByte(input);
int num28 = SkeletonBinary.ReadVarint(input, true);
if (num27 != 0 && num27 != 1)
{
if (num27 == 2)
{
PathConstraintMixTimeline pathConstraintMixTimeline = new PathConstraintMixTimeline(num28);
pathConstraintMixTimeline.pathConstraintIndex = num24;
for (int num29 = 0; num29 < num28; num29++)
{
pathConstraintMixTimeline.SetFrame(num29, this.ReadFloat(input), this.ReadFloat(input), this.ReadFloat(input));
if (num29 < num28 - 1)
{
this.ReadCurve(input, num29, pathConstraintMixTimeline);
}
}
exposedList.Add(pathConstraintMixTimeline);
num = Math.Max(num, pathConstraintMixTimeline.frames[(num28 - 1) * 3]);
}
}
else
{
float num30 = 1f;
PathConstraintPositionTimeline pathConstraintPositionTimeline;
if (num27 == 1)
{
pathConstraintPositionTimeline = new PathConstraintSpacingTimeline(num28);
if (pathConstraintData.spacingMode == SpacingMode.Length || pathConstraintData.spacingMode == SpacingMode.Fixed)
{
num30 = scale;
}
}
else
{
pathConstraintPositionTimeline = new PathConstraintPositionTimeline(num28);
if (pathConstraintData.positionMode == PositionMode.Fixed)
{
num30 = scale;
}
}
pathConstraintPositionTimeline.pathConstraintIndex = num24;
for (int num31 = 0; num31 < num28; num31++)
{
pathConstraintPositionTimeline.SetFrame(num31, this.ReadFloat(input), this.ReadFloat(input) * num30);
if (num31 < num28 - 1)
{
this.ReadCurve(input, num31, pathConstraintPositionTimeline);
}
}
exposedList.Add(pathConstraintPositionTimeline);
num = Math.Max(num, pathConstraintPositionTimeline.frames[(num28 - 1) * 2]);
}
num25++;
}
num22++;
}
int num32 = 0;
int num33 = SkeletonBinary.ReadVarint(input, true);
while (num32 < num33)
{
Skin skin = skeletonData.skins.Items[SkeletonBinary.ReadVarint(input, true)];
int num34 = 0;
int num35 = SkeletonBinary.ReadVarint(input, true);
while (num34 < num35)
{
int slotIndex2 = SkeletonBinary.ReadVarint(input, true);
int num36 = 0;
int num37 = SkeletonBinary.ReadVarint(input, true);
while (num36 < num37)
{
VertexAttachment vertexAttachment = (VertexAttachment)skin.GetAttachment(slotIndex2, this.ReadString(input));
bool flag = vertexAttachment.bones != null;
float[] vertices = vertexAttachment.vertices;
int num38 = (!flag) ? vertices.Length : (vertices.Length / 3 * 2);
int num39 = SkeletonBinary.ReadVarint(input, true);
DeformTimeline deformTimeline = new DeformTimeline(num39);
deformTimeline.slotIndex = slotIndex2;
deformTimeline.attachment = vertexAttachment;
for (int num40 = 0; num40 < num39; num40++)
{
float time2 = this.ReadFloat(input);
int num41 = SkeletonBinary.ReadVarint(input, true);
float[] array;
if (num41 == 0)
{
array = ((!flag) ? vertices : new float[num38]);
}
else
{
array = new float[num38];
int num42 = SkeletonBinary.ReadVarint(input, true);
num41 += num42;
if (scale == 1f)
{
for (int num43 = num42; num43 < num41; num43++)
{
array[num43] = this.ReadFloat(input);
}
}
else
{
for (int num44 = num42; num44 < num41; num44++)
{
array[num44] = this.ReadFloat(input) * scale;
}
}
if (!flag)
{
int num45 = 0;
int num46 = array.Length;
while (num45 < num46)
{
array[num45] += vertices[num45];
num45++;
}
}
}
deformTimeline.SetFrame(num40, time2, array);
if (num40 < num39 - 1)
{
this.ReadCurve(input, num40, deformTimeline);
}
}
exposedList.Add(deformTimeline);
num = Math.Max(num, deformTimeline.frames[num39 - 1]);
num36++;
}
num34++;
}
num32++;
}
int num47 = SkeletonBinary.ReadVarint(input, true);
if (num47 > 0)
{
DrawOrderTimeline drawOrderTimeline = new DrawOrderTimeline(num47);
int count = skeletonData.slots.Count;
for (int num48 = 0; num48 < num47; num48++)
{
float time3 = this.ReadFloat(input);
int num49 = SkeletonBinary.ReadVarint(input, true);
int[] array2 = new int[count];
for (int num50 = count - 1; num50 >= 0; num50--)
{
array2[num50] = -1;
}
int[] array3 = new int[count - num49];
int num51 = 0;
int num52 = 0;
for (int num53 = 0; num53 < num49; num53++)
{
int num54 = SkeletonBinary.ReadVarint(input, true);
while (num51 != num54)
{
array3[num52++] = num51++;
}
array2[num51 + SkeletonBinary.ReadVarint(input, true)] = num51++;
}
while (num51 < count)
{
array3[num52++] = num51++;
}
for (int num55 = count - 1; num55 >= 0; num55--)
{
if (array2[num55] == -1)
{
array2[num55] = array3[--num52];
}
}
drawOrderTimeline.SetFrame(num48, time3, array2);
}
exposedList.Add(drawOrderTimeline);
num = Math.Max(num, drawOrderTimeline.frames[num47 - 1]);
}
int num56 = SkeletonBinary.ReadVarint(input, true);
if (num56 > 0)
{
EventTimeline eventTimeline = new EventTimeline(num56);
for (int num57 = 0; num57 < num56; num57++)
{
float time4 = this.ReadFloat(input);
EventData eventData = skeletonData.events.Items[SkeletonBinary.ReadVarint(input, true)];
eventTimeline.SetFrame(num57, new Event(time4, eventData)
{
Int = SkeletonBinary.ReadVarint(input, false),
Float = this.ReadFloat(input),
String = ((!SkeletonBinary.ReadBoolean(input)) ? eventData.String : this.ReadString(input))
});
}
exposedList.Add(eventTimeline);
num = Math.Max(num, eventTimeline.frames[num56 - 1]);
}
exposedList.TrimExcess();
skeletonData.animations.Add(new Animation(name, exposedList, num));
}