|
public ComputeWorldVertices ( |
||
| bone | ||
| worldVertices | float | |
| return | void | |
/*
* Actual draw. Pipeline is 'deferred' list of GDI calls
*/
public static void Draw(Skeleton skeleton, Pipeline pipeline)
{
skeleton.UpdateWorldTransform();
foreach (Slot slot in skeleton.Slots)
{
if (slot.Attachment == null)
{
continue;
}
if (slot.Attachment.GetType() == typeof(RegionAttachment))
{
RegionAttachment attach = (RegionAttachment)slot.Attachment;
AtlasRegion region = (AtlasRegion)attach.RendererObject;
float[] worldVertices = new float[2 * 4];
attach.ComputeWorldVertices(slot.Bone, worldVertices);
var color = Color.FromArgb((int)(slot.A * 255), (int)(slot.R * 255), (int)(slot.G * 255), (int)(slot.B * 255));
DrawRegionAttachmnent(pipeline, region, worldVertices, color, slot.Data.BlendMode);
}
else if (slot.Attachment.GetType() == typeof(MeshAttachment))
{
MeshAttachment attach = (MeshAttachment)slot.Attachment;
AtlasRegion region = (AtlasRegion)attach.RendererObject;
float[] worldVertices = new float[attach.WorldVerticesLength];
attach.ComputeWorldVertices(slot, worldVertices);
int[] triangles = attach.Triangles;
var color = Color.FromArgb((int)(slot.A * 255), (int)(slot.R * 255), (int)(slot.G * 255), (int)(slot.B * 255));
DrawMeshAttachmnent(pipeline, region, attach.RegionUVs, worldVertices, triangles, color, slot.Data.BlendMode);
}
else
{
}
}
}
void spRegionAttachment_updateQuad(ref RegionAttachment self, ref Slot slot, CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha)
{
float[] vertices = new float[8];
self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);
float r = (slot.Skeleton.R * slot.R * 255);
float g = (slot.Skeleton.G * slot.G * 255);
float b = (slot.Skeleton.B * slot.B * 255);
float normalizedAlpha = slot.Skeleton.A * slot.A;
if (premultipliedAlpha)
{
r *= normalizedAlpha;
g *= normalizedAlpha;
b *= normalizedAlpha;
}
float a = normalizedAlpha * 255;
quad.BottomLeft.Colors.R = Convert.ToByte(r);
quad.BottomLeft.Colors.G = Convert.ToByte(g);
quad.BottomLeft.Colors.B = Convert.ToByte(b);
quad.BottomLeft.Colors.A = Convert.ToByte(a);
quad.TopLeft.Colors.R = Convert.ToByte(r);
quad.TopLeft.Colors.G = Convert.ToByte(g);
quad.TopLeft.Colors.B = Convert.ToByte(b);
quad.TopLeft.Colors.A = Convert.ToByte(a);
quad.TopRight.Colors.R = Convert.ToByte(r);
quad.TopRight.Colors.G = Convert.ToByte(g);
quad.TopRight.Colors.B = Convert.ToByte(b);
quad.TopRight.Colors.A = Convert.ToByte(a);
quad.BottomRight.Colors.R = Convert.ToByte(r);
quad.BottomRight.Colors.G = Convert.ToByte(g);
quad.BottomRight.Colors.B = Convert.ToByte(b);
quad.BottomRight.Colors.A = Convert.ToByte(a);
quad.BottomLeft.Vertices.X = vertices[RegionAttachment.X1];
quad.BottomLeft.Vertices.Y = vertices[RegionAttachment.Y1];
quad.TopLeft.Vertices.X = vertices[RegionAttachment.X2];
quad.TopLeft.Vertices.Y = vertices[RegionAttachment.Y2];
quad.TopRight.Vertices.X = vertices[RegionAttachment.X3];
quad.TopRight.Vertices.Y = vertices[RegionAttachment.Y3];
quad.BottomRight.Vertices.X = vertices[RegionAttachment.X4];
quad.BottomRight.Vertices.Y = vertices[RegionAttachment.Y4];
quad.BottomLeft.TexCoords.U = self.UVs[RegionAttachment.X1];
quad.BottomLeft.TexCoords.V = self.UVs[RegionAttachment.Y1];
quad.TopLeft.TexCoords.U = self.UVs[RegionAttachment.X2];
quad.TopLeft.TexCoords.V = self.UVs[RegionAttachment.Y2];
quad.TopRight.TexCoords.U = self.UVs[RegionAttachment.X3];
quad.TopRight.TexCoords.V = self.UVs[RegionAttachment.Y3];
quad.BottomRight.TexCoords.U = self.UVs[RegionAttachment.X4];
quad.BottomRight.TexCoords.V = self.UVs[RegionAttachment.Y4];
}
void spRegionAttachment_updateQuad(RegionAttachment self, Slot slot, CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha = false)
{
float[] vertices = new float[8];
self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);
byte r = Convert.ToByte(slot.Skeleton.R * slot.R * 255);
byte g =Convert.ToByte( slot.Skeleton.G * slot.G * 255);
byte b = Convert.ToByte(slot.Skeleton.B * slot.B * 255);
byte normalizedAlpha = Convert.ToByte( slot.Skeleton.A * slot.A);
if (premultipliedAlpha)
{
r *= normalizedAlpha;
g *= normalizedAlpha;
b *= normalizedAlpha;
}
byte a = Convert.ToByte(normalizedAlpha * 255);
quad.BottomLeft.Colors.R = r;
quad.BottomLeft.Colors.G = g;
quad.BottomLeft.Colors.B = b;
quad.BottomLeft.Colors.A = a;
quad.TopLeft.Colors.R = r;
quad.TopLeft.Colors.G = g;
quad.TopLeft.Colors.B = b;
quad.TopLeft.Colors.A = a;
quad.TopRight.Colors.R = r;
quad.TopRight.Colors.G = g;
quad.TopRight.Colors.B = b;
quad.TopRight.Colors.A = a;
quad.BottomRight.Colors.R = r;
quad.BottomRight.Colors.G = g;
quad.BottomRight.Colors.B = b;
quad.BottomRight.Colors.A = a;
quad.BottomLeft.Vertices.X = vertices[VERTEX_X1];
quad.BottomLeft.Vertices.Y = vertices[VERTEX_Y1];
quad.TopLeft.Vertices.X = vertices[VERTEX_X2];
quad.TopLeft.Vertices.Y = vertices[VERTEX_Y2];
quad.TopRight.Vertices.X = vertices[VERTEX_X3];
quad.TopRight.Vertices.Y = vertices[VERTEX_Y3];
quad.BottomRight.Vertices.X = vertices[VERTEX_X4];
quad.BottomRight.Vertices.Y = vertices[VERTEX_Y4];
quad.BottomLeft.TexCoords.U = self.UVs[VERTEX_X1];
quad.BottomLeft.TexCoords.V = self.UVs[VERTEX_Y1];
quad.TopLeft.TexCoords.U = self.UVs[VERTEX_X2];
quad.TopLeft.TexCoords.V = self.UVs[VERTEX_Y2];
quad.TopRight.TexCoords.U = self.UVs[VERTEX_X3];
quad.TopRight.TexCoords.V = self.UVs[VERTEX_Y3];
quad.BottomRight.TexCoords.U = self.UVs[VERTEX_X4];
quad.BottomRight.TexCoords.V = self.UVs[VERTEX_Y4];
}
private void DrawSlot(Skeleton skeleton, RegionAttachment attachment, Slot slot)
{
var region = (AtlasRegion)attachment.RendererObject;
var thisMaterial = (Material)region.page.rendererObject;
var thisBlendMode = slot.Data.AdditiveBlending ? BlendMode.Additive : BlendMode.Normal;
var thisBatch = (Batch2D)renderer.FindOrCreateBatch(thisMaterial, thisBlendMode);
if (currentBatch != null && currentBatch != thisBatch)
renderer.FlushDrawBuffer(currentBatch);
currentBatch = thisBatch;
attachment.ComputeWorldVertices(skeleton.X, skeleton.Y, slot.Bone, vertices);
currentColor = new Color(color.RedValue * slot.R, color.GreenValue * slot.G,
color.BlueValue * slot.B, color.AlphaValue * slot.A);
AddSlotIndicesAndVertices(attachment.UVs);
}
// update the attachment with the current slot data
public void Update(Slot slot)
{
_attachment = slot.Attachment as RegionAttachment;
//_attachment.UpdateOffset();
//_attachment.UpdateVertices(slot.Bone);
_attachment.ComputeWorldVertices(slot.Bone, vertices);
element = _attachment.RendererObject as FAtlasElement;
element = null;
base.color = _slotCustomColor * new Color(slot.R, slot.G, slot.B, slot.A);
UpdateLocalVertices();
}
static Mesh ExtractRegionAttachment (string name, RegionAttachment attachment, Mesh mesh = null) {
var bone = GetExtractionBone();
bone.X = -attachment.X;
bone.Y = -attachment.Y;
bone.UpdateWorldTransform();
Vector2[] uvs = ExtractUV(attachment.UVs);
float[] floatVerts = new float[8];
attachment.ComputeWorldVertices(bone, floatVerts);
Vector3[] verts = ExtractVerts(floatVerts);
//unrotate verts now that they're centered
for (int i = 0; i < verts.Length; i++) {
verts[i] = Quaternion.Euler(0, 0, -attachment.Rotation) * verts[i];
}
int[] triangles = new int[6] { 1, 3, 0, 2, 3, 1 };
Color color = new Color(attachment.R, attachment.G, attachment.B, attachment.A);
if (mesh == null)
mesh = new Mesh();
mesh.triangles = new int[0];
mesh.vertices = verts;
mesh.uv = uvs;
mesh.triangles = triangles;
mesh.colors = new Color[] { color, color, color, color };
mesh.RecalculateBounds();
mesh.RecalculateNormals();
mesh.name = name;
return mesh;
}
public void Draw(Skeleton skeleton)
{
List <Slot> drawOrder = skeleton.DrawOrder;
float x = skeleton.X, y = skeleton.Y;
float skeletonR = skeleton.R, skeletonG = skeleton.G, skeletonB = skeleton.B, skeletonA = skeleton.A;
for (int i = 0, n = drawOrder.Count; i < n; i++)
{
Slot slot = drawOrder[i];
RegionAttachment regionAttachment = slot.Attachment as RegionAttachment;
if (regionAttachment != null)
{
BlendState blend = slot.Data.AdditiveBlending ? BlendState.Additive : defaultBlendState;
if (device.BlendState != blend)
{
End();
device.BlendState = blend;
}
SpriteBatchItem item = batcher.CreateBatchItem();
AtlasRegion region = (AtlasRegion)regionAttachment.RendererObject;
item.Texture = (Texture2D)region.page.rendererObject;
Color color;
float a = skeletonA * slot.A;
if (premultipliedAlpha)
{
color = new Color(skeletonR * slot.R * a, skeletonG * slot.G * a, skeletonB * slot.B * a, a);
}
else
{
color = new Color(skeletonR * slot.R, skeletonG * slot.G, skeletonB * slot.B, a);
}
item.vertexTL.Color = color;
item.vertexBL.Color = color;
item.vertexBR.Color = color;
item.vertexTR.Color = color;
float[] vertices = this.vertices;
regionAttachment.ComputeWorldVertices(x, y, slot.Bone, vertices);
item.vertexTL.Position.X = vertices[RegionAttachment.X1];
item.vertexTL.Position.Y = vertices[RegionAttachment.Y1];
item.vertexTL.Position.Z = 0;
item.vertexBL.Position.X = vertices[RegionAttachment.X2];
item.vertexBL.Position.Y = vertices[RegionAttachment.Y2];
item.vertexBL.Position.Z = 0;
item.vertexBR.Position.X = vertices[RegionAttachment.X3];
item.vertexBR.Position.Y = vertices[RegionAttachment.Y3];
item.vertexBR.Position.Z = 0;
item.vertexTR.Position.X = vertices[RegionAttachment.X4];
item.vertexTR.Position.Y = vertices[RegionAttachment.Y4];
item.vertexTR.Position.Z = 0;
float[] uvs = regionAttachment.UVs;
item.vertexTL.TextureCoordinate.X = uvs[RegionAttachment.X1];
item.vertexTL.TextureCoordinate.Y = uvs[RegionAttachment.Y1];
item.vertexBL.TextureCoordinate.X = uvs[RegionAttachment.X2];
item.vertexBL.TextureCoordinate.Y = uvs[RegionAttachment.Y2];
item.vertexBR.TextureCoordinate.X = uvs[RegionAttachment.X3];
item.vertexBR.TextureCoordinate.Y = uvs[RegionAttachment.Y3];
item.vertexTR.TextureCoordinate.X = uvs[RegionAttachment.X4];
item.vertexTR.TextureCoordinate.Y = uvs[RegionAttachment.Y4];
}
}
}
//virtual cocos2d::CCTextureAtlas* getTextureAtlas (RegionAttachment regionAttachment);
#region SpinesCocos2d
void UpdateRegionAttachmentQuad(RegionAttachment self, Slot slot, ref CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha = false)
{
float[] vertices = new float[8];
self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);
float r = slot.Skeleton.R * slot.R * 255;
float g = slot.Skeleton.G * slot.G * 255;
float b = slot.Skeleton.B * slot.B * 255;
float normalizedAlpha = slot.Skeleton.A * slot.A;
if (premultipliedAlpha)
{
r *= normalizedAlpha;
g *= normalizedAlpha;
b *= normalizedAlpha;
}
float a = normalizedAlpha * 255;
quad.BottomLeft.Colors.R = (byte)r;
quad.BottomLeft.Colors.G = (byte)g;
quad.BottomLeft.Colors.B = (byte)b;
quad.BottomLeft.Colors.A = (byte)a;
quad.TopLeft.Colors.R = (byte)r;
quad.TopLeft.Colors.G = (byte)g;
quad.TopLeft.Colors.B = (byte)b;
quad.TopLeft.Colors.A = (byte)a;
quad.TopRight.Colors.R = (byte)r;
quad.TopRight.Colors.G = (byte)g;
quad.TopRight.Colors.B = (byte)b;
quad.TopRight.Colors.A = (byte)a;
quad.BottomRight.Colors.R = (byte)r;
quad.BottomRight.Colors.G = (byte)g;
quad.BottomRight.Colors.B = (byte)b;
quad.BottomRight.Colors.A = (byte)a;
quad.BottomLeft.Vertices.X = vertices[RegionAttachment.X1];
quad.BottomLeft.Vertices.Y = vertices[RegionAttachment.Y1];
quad.TopLeft.Vertices.X = vertices[RegionAttachment.X2];
quad.TopLeft.Vertices.Y = vertices[RegionAttachment.Y2];
quad.TopRight.Vertices.X = vertices[RegionAttachment.X3];
quad.TopRight.Vertices.Y = vertices[RegionAttachment.Y3];
quad.BottomRight.Vertices.X = vertices[RegionAttachment.X4];
quad.BottomRight.Vertices.Y = vertices[RegionAttachment.Y4];
quad.BottomLeft.TexCoords.U = self.UVs[RegionAttachment.X1];
quad.BottomLeft.TexCoords.V = self.UVs[RegionAttachment.Y1];
quad.TopLeft.TexCoords.U = self.UVs[RegionAttachment.X2];
quad.TopLeft.TexCoords.V = self.UVs[RegionAttachment.Y2];
quad.TopRight.TexCoords.U = self.UVs[RegionAttachment.X3];
quad.TopRight.TexCoords.V = self.UVs[RegionAttachment.Y3];
quad.BottomRight.TexCoords.U = self.UVs[RegionAttachment.X4];
quad.BottomRight.TexCoords.V = self.UVs[RegionAttachment.Y4];
}
public void Draw(Skeleton skeleton)
{
float[] vertices = this.vertices;
List <Slot> drawOrder = skeleton.DrawOrder;
float skeletonR = skeleton.R, skeletonG = skeleton.G, skeletonB = skeleton.B, skeletonA = skeleton.A;
for (int i = 0, n = drawOrder.Count; i < n; i++)
{
Slot slot = drawOrder[i];
Attachment attachment = slot.Attachment;
if (attachment is RegionAttachment)
{
RegionAttachment regionAttachment = (RegionAttachment)attachment;
BlendState blend = slot.Data.AdditiveBlending ? BlendState.Additive : defaultBlendState;
if (device.BlendState != blend)
{
End();
device.BlendState = blend;
}
MeshItem item = batcher.NextItem(4, 6);
item.triangles = quadTriangles;
VertexPositionColorTexture[] itemVertices = item.vertices;
AtlasRegion region = (AtlasRegion)regionAttachment.RendererObject;
item.texture = (Texture2D)region.page.rendererObject;
Color color;
float a = skeletonA * slot.A * regionAttachment.A;
if (premultipliedAlpha)
{
color = new Color(
skeletonR * slot.R * regionAttachment.R * a,
skeletonG * slot.G * regionAttachment.G * a,
skeletonB * slot.B * regionAttachment.B * a, a);
}
else
{
color = new Color(
skeletonR * slot.R * regionAttachment.R,
skeletonG * slot.G * regionAttachment.G,
skeletonB * slot.B * regionAttachment.B, a);
}
itemVertices[TL].Color = color;
itemVertices[BL].Color = color;
itemVertices[BR].Color = color;
itemVertices[TR].Color = color;
regionAttachment.ComputeWorldVertices(slot.Bone, vertices);
itemVertices[TL].Position.X = vertices[RegionAttachment.X1];
itemVertices[TL].Position.Y = vertices[RegionAttachment.Y1];
itemVertices[TL].Position.Z = 0;
itemVertices[BL].Position.X = vertices[RegionAttachment.X2];
itemVertices[BL].Position.Y = vertices[RegionAttachment.Y2];
itemVertices[BL].Position.Z = 0;
itemVertices[BR].Position.X = vertices[RegionAttachment.X3];
itemVertices[BR].Position.Y = vertices[RegionAttachment.Y3];
itemVertices[BR].Position.Z = 0;
itemVertices[TR].Position.X = vertices[RegionAttachment.X4];
itemVertices[TR].Position.Y = vertices[RegionAttachment.Y4];
itemVertices[TR].Position.Z = 0;
float[] uvs = regionAttachment.UVs;
itemVertices[TL].TextureCoordinate.X = uvs[RegionAttachment.X1];
itemVertices[TL].TextureCoordinate.Y = uvs[RegionAttachment.Y1];
itemVertices[BL].TextureCoordinate.X = uvs[RegionAttachment.X2];
itemVertices[BL].TextureCoordinate.Y = uvs[RegionAttachment.Y2];
itemVertices[BR].TextureCoordinate.X = uvs[RegionAttachment.X3];
itemVertices[BR].TextureCoordinate.Y = uvs[RegionAttachment.Y3];
itemVertices[TR].TextureCoordinate.X = uvs[RegionAttachment.X4];
itemVertices[TR].TextureCoordinate.Y = uvs[RegionAttachment.Y4];
}
else if (attachment is MeshAttachment)
{
MeshAttachment mesh = (MeshAttachment)attachment;
int vertexCount = mesh.Vertices.Length;
if (vertices.Length < vertexCount)
{
vertices = new float[vertexCount];
}
mesh.ComputeWorldVertices(slot, vertices);
int[] triangles = mesh.Triangles;
MeshItem item = batcher.NextItem(vertexCount, triangles.Length);
item.triangles = triangles;
AtlasRegion region = (AtlasRegion)mesh.RendererObject;
item.texture = (Texture2D)region.page.rendererObject;
Color color;
float a = skeletonA * slot.A * mesh.A;
if (premultipliedAlpha)
{
color = new Color(
skeletonR * slot.R * mesh.R * a,
skeletonG * slot.G * mesh.G * a,
skeletonB * slot.B * mesh.B * a, a);
}
else
{
color = new Color(
skeletonR * slot.R * mesh.R,
skeletonG * slot.G * mesh.G,
skeletonB * slot.B * mesh.B, a);
}
float[] uvs = mesh.UVs;
VertexPositionColorTexture[] itemVertices = item.vertices;
for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2)
{
itemVertices[ii].Color = color;
itemVertices[ii].Position.X = vertices[v];
itemVertices[ii].Position.Y = vertices[v + 1];
itemVertices[ii].Position.Z = 0;
itemVertices[ii].TextureCoordinate.X = uvs[v];
itemVertices[ii].TextureCoordinate.Y = uvs[v + 1];
}
}
else if (attachment is SkinnedMeshAttachment)
{
SkinnedMeshAttachment mesh = (SkinnedMeshAttachment)attachment;
int vertexCount = mesh.UVs.Length;
if (vertices.Length < vertexCount)
{
vertices = new float[vertexCount];
}
mesh.ComputeWorldVertices(slot, vertices);
int[] triangles = mesh.Triangles;
MeshItem item = batcher.NextItem(vertexCount, triangles.Length);
item.triangles = triangles;
AtlasRegion region = (AtlasRegion)mesh.RendererObject;
item.texture = (Texture2D)region.page.rendererObject;
Color color;
float a = skeletonA * slot.A * mesh.A;
if (premultipliedAlpha)
{
color = new Color(
skeletonR * slot.R * mesh.R * a,
skeletonG * slot.G * mesh.G * a,
skeletonB * slot.B * mesh.B * a, a);
}
else
{
color = new Color(
skeletonR * slot.R * mesh.R,
skeletonG * slot.G * mesh.G,
skeletonB * slot.B * mesh.B, a);
}
float[] uvs = mesh.UVs;
VertexPositionColorTexture[] itemVertices = item.vertices;
for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2)
{
itemVertices[ii].Color = color;
itemVertices[ii].Position.X = vertices[v];
itemVertices[ii].Position.Y = vertices[v + 1];
itemVertices[ii].Position.Z = 0;
itemVertices[ii].TextureCoordinate.X = uvs[v];
itemVertices[ii].TextureCoordinate.Y = uvs[v + 1];
}
}
}
}
public void GetBounds(out float x, out float y, out float width, out float height, ref float[] vertexBuffer)
{
float[] worldVertices = vertexBuffer;
if (worldVertices != null)
{
worldVertices = worldVertices;
}
else
{
worldVertices = new float[8];
}
Slot[] items = this.drawOrder.Items;
float num = 2.147484E+09f;
float num2 = 2.147484E+09f;
float num3 = -2.147484E+09f;
float num4 = -2.147484E+09f;
int index = 0;
int count = this.drawOrder.Count;
while (index < count)
{
Slot slot = items[index];
int worldVerticesLength = 0;
float[] numArray2 = null;
Attachment attachment = slot.attachment;
RegionAttachment attachment2 = attachment as RegionAttachment;
if (attachment2 != null)
{
worldVerticesLength = 8;
numArray2 = worldVertices;
if (numArray2.Length < 8)
{
numArray2 = worldVertices = new float[8];
}
attachment2.ComputeWorldVertices(slot.bone, worldVertices, 0, 2);
}
else
{
MeshAttachment attachment3 = attachment as MeshAttachment;
if (attachment3 != null)
{
MeshAttachment attachment4 = attachment3;
worldVerticesLength = attachment4.WorldVerticesLength;
numArray2 = worldVertices;
if (numArray2.Length < worldVerticesLength)
{
numArray2 = worldVertices = new float[worldVerticesLength];
}
attachment4.ComputeWorldVertices(slot, 0, worldVerticesLength, worldVertices, 0, 2);
}
}
if (numArray2 != null)
{
for (int i = 0; i < worldVerticesLength; i += 2)
{
float num9 = numArray2[i];
float num10 = numArray2[i + 1];
num = Math.Min(num, num9);
num2 = Math.Min(num2, num10);
num3 = Math.Max(num3, num9);
num4 = Math.Max(num4, num10);
}
}
index++;
}
x = num;
y = num2;
width = num3 - num;
height = num4 - num2;
vertexBuffer = worldVertices;
}
public void Draw(Skeleton skeleton)
{
var drawOrder = skeleton.DrawOrder;
var drawOrderItems = skeleton.DrawOrder.Items;
float skeletonR = skeleton.R, skeletonG = skeleton.G, skeletonB = skeleton.B, skeletonA = skeleton.A;
Color color = new Color();
if (VertexEffect != null)
{
VertexEffect.Begin(skeleton);
}
for (int i = 0, n = drawOrder.Count; i < n; i++)
{
Slot slot = drawOrderItems[i];
Attachment attachment = slot.Attachment;
float attachmentColorR, attachmentColorG, attachmentColorB, attachmentColorA;
Texture2D texture = null;
int verticesCount = 0;
float[] vertices = this.vertices;
int indicesCount = 0;
int[] indices = null;
float[] uvs = null;
if (attachment is RegionAttachment)
{
RegionAttachment regionAttachment = (RegionAttachment)attachment;
attachmentColorR = regionAttachment.R; attachmentColorG = regionAttachment.G; attachmentColorB = regionAttachment.B; attachmentColorA = regionAttachment.A;
AtlasRegion region = (AtlasRegion)regionAttachment.RendererObject;
texture = (Texture2D)region.page.rendererObject;
verticesCount = 4;
regionAttachment.ComputeWorldVertices(slot.Bone, vertices, 0, 2);
indicesCount = 6;
indices = quadTriangles;
uvs = regionAttachment.UVs;
}
else if (attachment is MeshAttachment)
{
MeshAttachment mesh = (MeshAttachment)attachment;
attachmentColorR = mesh.R; attachmentColorG = mesh.G; attachmentColorB = mesh.B; attachmentColorA = mesh.A;
AtlasRegion region = (AtlasRegion)mesh.RendererObject;
texture = (Texture2D)region.page.rendererObject;
int vertexCount = mesh.WorldVerticesLength;
if (vertices.Length < vertexCount)
{
vertices = new float[vertexCount];
}
verticesCount = vertexCount >> 1;
mesh.ComputeWorldVertices(slot, vertices);
indicesCount = mesh.Triangles.Length;
indices = mesh.Triangles;
uvs = mesh.UVs;
}
else if (attachment is ClippingAttachment)
{
ClippingAttachment clip = (ClippingAttachment)attachment;
clipper.ClipStart(slot, clip);
continue;
}
else
{
continue;
}
// set blend state
BlendState blend = slot.Data.BlendMode == BlendMode.Additive ? BlendState.Additive : defaultBlendState;
if (device.BlendState != blend)
{
//End();
//device.BlendState = blend;
}
// calculate color
float a = skeletonA * slot.A * attachmentColorA;
if (premultipliedAlpha)
{
color = new Color(
skeletonR * slot.R * attachmentColorR * a,
skeletonG * slot.G * attachmentColorG * a,
skeletonB * slot.B * attachmentColorB * a, a);
}
else
{
color = new Color(
skeletonR * slot.R * attachmentColorR,
skeletonG * slot.G * attachmentColorG,
skeletonB * slot.B * attachmentColorB, a);
}
Color darkColor = new Color();
if (slot.HasSecondColor)
{
if (premultipliedAlpha)
{
darkColor = new Color(slot.R2 * a, slot.G2 * a, slot.B2 * a);
}
else
{
darkColor = new Color(slot.R2 * a, slot.G2 * a, slot.B2 * a);
}
}
darkColor.A = premultipliedAlpha ? (byte)255 : (byte)0;
// clip
if (clipper.IsClipping)
{
clipper.ClipTriangles(vertices, verticesCount << 1, indices, indicesCount, uvs);
vertices = clipper.ClippedVertices.Items;
verticesCount = clipper.ClippedVertices.Count >> 1;
indices = clipper.ClippedTriangles.Items;
indicesCount = clipper.ClippedTriangles.Count;
uvs = clipper.ClippedUVs.Items;
}
if (verticesCount == 0 || indicesCount == 0)
{
continue;
}
// submit to batch
MeshItem item = batcher.NextItem(verticesCount, indicesCount);
item.texture = texture;
for (int ii = 0, nn = indicesCount; ii < nn; ii++)
{
item.triangles[ii] = indices[ii];
}
VertexPositionColorTextureColor[] itemVertices = item.vertices;
for (int ii = 0, v = 0, nn = verticesCount << 1; v < nn; ii++, v += 2)
{
itemVertices[ii].Color = color;
itemVertices[ii].Color2 = darkColor;
itemVertices[ii].Position.X = vertices[v];
itemVertices[ii].Position.Y = vertices[v + 1];
itemVertices[ii].Position.Z = 0;
itemVertices[ii].TextureCoordinate.X = uvs[v];
itemVertices[ii].TextureCoordinate.Y = uvs[v + 1];
if (VertexEffect != null)
{
VertexEffect.Transform(ref itemVertices[ii]);
}
}
clipper.ClipEnd(slot);
}
clipper.ClipEnd();
if (VertexEffect != null)
{
VertexEffect.End();
}
}
public void GetBounds(out float x, out float y, out float width, out float height, ref float[] vertexBuffer)
{
float[] array = vertexBuffer;
array = (array ?? new float[8]);
Slot[] items = drawOrder.Items;
float num = 2.14748365E+09f;
float num2 = 2.14748365E+09f;
float num3 = -2.14748365E+09f;
float num4 = -2.14748365E+09f;
int i = 0;
for (int count = drawOrder.Count; i < count; i++)
{
Slot slot = items[i];
int num5 = 0;
float[] array2 = null;
Attachment attachment = slot.attachment;
RegionAttachment regionAttachment = attachment as RegionAttachment;
if (regionAttachment != null)
{
num5 = 8;
array2 = array;
if (array2.Length < 8)
{
array2 = (array = new float[8]);
}
regionAttachment.ComputeWorldVertices(slot.bone, array, 0);
}
else
{
MeshAttachment meshAttachment = attachment as MeshAttachment;
if (meshAttachment != null)
{
MeshAttachment meshAttachment2 = meshAttachment;
num5 = meshAttachment2.WorldVerticesLength;
array2 = array;
if (array2.Length < num5)
{
array2 = (array = new float[num5]);
}
meshAttachment2.ComputeWorldVertices(slot, 0, num5, array, 0);
}
}
if (array2 != null)
{
for (int j = 0; j < num5; j += 2)
{
float val = array2[j];
float val2 = array2[j + 1];
num = Math.Min(num, val);
num2 = Math.Min(num2, val2);
num3 = Math.Max(num3, val);
num4 = Math.Max(num4, val2);
}
}
}
x = num;
y = num2;
width = num3 - num;
height = num4 - num2;
vertexBuffer = array;
}
