Spine.SkeletonMeshRenderer.Draw C# (CSharp) Method

		public void Draw (Skeleton skeleton) {
			float[] vertices = this.vertices;
			var drawOrder = skeleton.DrawOrder;
			var drawOrderItems = skeleton.DrawOrder.Items;
			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 = drawOrderItems[i];
				Attachment attachment = slot.Attachment;
				if (attachment is RegionAttachment) {
					RegionAttachment regionAttachment = (RegionAttachment)attachment;
					BlendState blend = slot.Data.BlendMode == BlendMode.additive ? 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.WorldVerticesLength;
					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];
					}
				}
			}
		}
	}

        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);

            state.Update(gameTime.ElapsedGameTime.Milliseconds / 1000f);
            state.Apply(skeleton);
            skeleton.UpdateWorldTransform();
            skeletonRenderer.Begin();
            skeletonRenderer.Draw(skeleton);
            skeletonRenderer.End();

            bounds.Update(skeleton, true);
            MouseState mouse = Mouse.GetState();

            if (headSlot != null)
            {
                headSlot.G = 1;
                headSlot.B = 1;
                if (bounds.AabbContainsPoint(mouse.X, mouse.Y))
                {
                    BoundingBoxAttachment hit = bounds.ContainsPoint(mouse.X, mouse.Y);
                    if (hit != null)
                    {
                        headSlot.G = 0;
                        headSlot.B = 0;
                    }
                }
            }

            base.Draw(gameTime);
        }