/// <summary>Returns a pooled RegionItem.</summary>
        public RegionItem NextItem()
        {
            RegionItem item = freeItems.Count > 0 ? freeItems.Dequeue() : new RegionItem();

            items.Add(item);
            return(item);
        }
        public void Draw(GraphicsDevice device)
        {
            if (items.Count == 0)
            {
                return;
            }

            int itemIndex = 0;
            int itemCount = items.Count;

            while (itemCount > 0)
            {
                int itemsToProcess = Math.Min(itemCount, maxBatchSize);
                EnsureArrayCapacity(itemsToProcess);

                var       count   = 0;
                Texture2D texture = null;
                for (int i = 0; i < itemsToProcess; i++, itemIndex++)
                {
                    RegionItem item = items[itemIndex];
                    if (item.texture != texture)
                    {
                        FlushVertexArray(device, count);
                        texture            = item.texture;
                        count              = 0;
                        device.Textures[0] = texture;
                    }

                    vertexArray[count++] = item.vertexTL;
                    vertexArray[count++] = item.vertexTR;
                    vertexArray[count++] = item.vertexBL;
                    vertexArray[count++] = item.vertexBR;

                    item.texture = null;
                    freeItems.Enqueue(item);
                }
                FlushVertexArray(device, count);
                itemCount -= itemsToProcess;
            }
            items.Clear();
        }
示例#3
0
        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;

            for (int i = 0, n = drawOrder.Count; i < n; i++)
            {
                Slot             slot             = drawOrderItems[i];
                RegionAttachment regionAttachment = slot.Attachment as RegionAttachment;
                if (regionAttachment != null)
                {
                    BlendState blendState = new BlendState();
                    Blend      blendSrc;
                    Blend      blendDst;
                    if (premultipliedAlpha)
                    {
                        blendState.AlphaBlendFunction  = BlendState.AlphaBlend.AlphaBlendFunction;
                        blendState.BlendFactor         = BlendState.AlphaBlend.BlendFactor;
                        blendState.ColorBlendFunction  = BlendState.AlphaBlend.ColorBlendFunction;
                        blendState.ColorWriteChannels  = BlendState.AlphaBlend.ColorWriteChannels;
                        blendState.ColorWriteChannels1 = BlendState.AlphaBlend.ColorWriteChannels1;
                        blendState.ColorWriteChannels2 = BlendState.AlphaBlend.ColorWriteChannels2;
                        blendState.ColorWriteChannels3 = BlendState.AlphaBlend.ColorWriteChannels3;
                        blendState.MultiSampleMask     = BlendState.AlphaBlend.MultiSampleMask;
                    }
                    else
                    {
                        blendState.AlphaBlendFunction  = BlendState.NonPremultiplied.AlphaBlendFunction;
                        blendState.BlendFactor         = BlendState.NonPremultiplied.BlendFactor;
                        blendState.ColorBlendFunction  = BlendState.NonPremultiplied.ColorBlendFunction;
                        blendState.ColorWriteChannels  = BlendState.NonPremultiplied.ColorWriteChannels;
                        blendState.ColorWriteChannels1 = BlendState.NonPremultiplied.ColorWriteChannels1;
                        blendState.ColorWriteChannels2 = BlendState.NonPremultiplied.ColorWriteChannels2;
                        blendState.ColorWriteChannels3 = BlendState.NonPremultiplied.ColorWriteChannels3;
                        blendState.MultiSampleMask     = BlendState.NonPremultiplied.MultiSampleMask;
                    }
                    switch (slot.Data.BlendMode)
                    {
                    case BlendMode.additive:
                        blendState = BlendState.Additive;
                        break;

                    case BlendMode.multiply:
                        blendSrc = BlendXna.GetXNABlend(BlendXna.GL_DST_COLOR);
                        blendDst = BlendXna.GetXNABlend(BlendXna.GL_ONE_MINUS_SRC_ALPHA);
                        blendState.ColorSourceBlend      = blendSrc;
                        blendState.AlphaSourceBlend      = blendSrc;
                        blendState.ColorDestinationBlend = blendDst;
                        blendState.AlphaDestinationBlend = blendDst;
                        break;

                    case BlendMode.screen:
                        blendSrc = BlendXna.GetXNABlend(premultipliedAlpha ? BlendXna.GL_ONE : BlendXna.GL_SRC_ALPHA);
                        blendDst = BlendXna.GetXNABlend(BlendXna.GL_ONE_MINUS_SRC_COLOR);
                        blendState.ColorSourceBlend      = blendSrc;
                        blendState.AlphaSourceBlend      = blendSrc;
                        blendState.ColorDestinationBlend = blendDst;
                        blendState.AlphaDestinationBlend = blendDst;
                        break;

                    default:
                        blendState = defaultBlendState;
                        break;
                    }
                    if (device.BlendState != blendState)
                    {
                        End();
                        device.BlendState = blendState;
                    }


                    RegionItem item = batcher.NextItem();

                    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(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];
                }
            }
        }
        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;

            for (int i = 0, n = drawOrder.Count; i < n; i++)
            {
                Slot             slot             = drawOrderItems[i];
                RegionAttachment regionAttachment = slot.Attachment as RegionAttachment;
                if (regionAttachment != null)
                {
                    BlendState blend = slot.Data.BlendMode == BlendMode.additive ? BlendState.Additive : defaultBlendState;
                    if (device.BlendState != blend)
                    {
                        End();
                        device.BlendState = blend;
                    }

                    RegionItem item = batcher.NextItem();

                    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(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];
                }
            }
        }