Esempio n. 1
0
        internal static SpriteData *Create(Vector position, Texture material)
        {
            SpriteData *result = (SpriteData *)Marshal.AllocHGlobal(sizeof(SpriteData));

            result->position = position;
            result->material = material;
            return(result);
        }
Esempio n. 2
0
        private unsafe void RenderBatch(Texture2D texture, SpriteData[] sprites, int offset, int count)
        {
            graphicsDevice.Textures[0] = texture;
            float num  = 1f / (float)texture.Width;
            float num2 = 1f / (float)texture.Height;

            while (count > 0)
            {
                SetDataOptions options = SetDataOptions.NoOverwrite;
                int            num3    = count;
                if (num3 > 2048 - vertexBufferPosition)
                {
                    num3 = 2048 - vertexBufferPosition;
                    if (num3 < 256)
                    {
                        vertexBufferPosition = 0;
                        options = SetDataOptions.Discard;
                        num3    = count;
                        if (num3 > 2048)
                        {
                            num3 = 2048;
                        }
                    }
                }

                fixed(SpriteData *ptr = &sprites[offset])
                {
                    fixed(VertexPositionColorTexture *ptr3 = &vertices[0])
                    {
                        SpriteData *ptr2 = ptr;
                        VertexPositionColorTexture *ptr4 = ptr3;

                        for (int i = 0; i < num3; i++)
                        {
                            float num4 = ptr2->Origin.X / ptr2->Source.Z;
                            float num5 = ptr2->Origin.Y / ptr2->Source.W;
                            ptr4->Color   = ptr2->Colors.TopLeftColor;
                            ptr4[1].Color = ptr2->Colors.TopRightColor;
                            ptr4[2].Color = ptr2->Colors.BottomRightColor;
                            ptr4[3].Color = ptr2->Colors.BottomLeftColor;
                            for (int j = 0; j < 4; j++)
                            {
                                float num6 = xCornerOffsets[j];
                                float num7 = yCornerOffsets[j];
                                float num8 = (num6 - num4) * ptr2->Destination.Z;
                                float num9 = (num7 - num5) * ptr2->Destination.W;
                                float x    = ptr2->Destination.X + num8;
                                float y    = ptr2->Destination.Y + num9;
                                if ((ptr2->Effects & SpriteEffects.FlipVertically) != 0)
                                {
                                    num6 = 1f - num6;
                                }
                                if ((ptr2->Effects & SpriteEffects.FlipHorizontally) != 0)
                                {
                                    num7 = 1f - num7;
                                }
                                ptr4->Position.X          = x;
                                ptr4->Position.Y          = y;
                                ptr4->Position.Z          = 0f;
                                ptr4->TextureCoordinate.X = (ptr2->Source.X + num6 * ptr2->Source.Z) * num;
                                ptr4->TextureCoordinate.Y = (ptr2->Source.Y + num7 * ptr2->Source.W) * num2;
                                ptr4++;
                            }
                            ptr2++;
                        }
                    }
                }

                int offsetInBytes = vertexBufferPosition * sizeof(VertexPositionColorTexture) * 4;
                vertexBuffer.SetData(offsetInBytes, vertices, 0, num3 * 4, sizeof(VertexPositionColorTexture), options);
                int minVertexIndex = vertexBufferPosition * 4;
                int numVertices    = num3 * 4;
                int startIndex     = vertexBufferPosition * 6;
                int primitiveCount = num3 * 2;
                graphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, minVertexIndex, numVertices, startIndex, primitiveCount);
                vertexBufferPosition += num3;
                offset += num3;
                count  -= num3;
            }
        }
        private unsafe void RenderBatch(Texture2D texture, SpriteData[] sprites, int offset, int count)
        {
            _graphicsDevice.Textures[0] = texture;
            float num  = 1f / (float)texture.Width;
            float num2 = 1f / (float)texture.Height;

            while (count > 0)
            {
                SetDataOptions options = SetDataOptions.NoOverwrite;
                int            num3    = count;
                if (num3 > 2048 - _vertexBufferPosition)
                {
                    num3 = 2048 - _vertexBufferPosition;
                    if (num3 < 256)
                    {
                        _vertexBufferPosition = 0;
                        options = SetDataOptions.Discard;
                        num3    = count;
                        if (num3 > 2048)
                        {
                            num3 = 2048;
                        }
                    }
                }

                fixed(SpriteData *ptr = &sprites[offset])
                {
                    fixed(VertexPositionColorTexture *ptr3 = &_vertices[0])
                    {
                        SpriteData *ptr2 = ptr;
                        VertexPositionColorTexture *ptr4 = ptr3;

                        for (int i = 0; i < num3; i++)
                        {
                            float num4;
                            float num5;
                            if (ptr2->Rotation != 0f)
                            {
                                num4 = (float)Math.Cos(ptr2->Rotation);
                                num5 = (float)Math.Sin(ptr2->Rotation);
                            }
                            else
                            {
                                num4 = 1f;
                                num5 = 0f;
                            }
                            float num6 = ptr2->Origin.X / ptr2->Source.Z;
                            float num7 = ptr2->Origin.Y / ptr2->Source.W;
                            ptr4->Color   = ptr2->Colors.TopLeftColor;
                            ptr4[1].Color = ptr2->Colors.TopRightColor;
                            ptr4[2].Color = ptr2->Colors.BottomRightColor;
                            ptr4[3].Color = ptr2->Colors.BottomLeftColor;
                            for (int j = 0; j < 4; j++)
                            {
                                float num8  = CORNER_OFFSET_X[j];
                                float num9  = CORNER_OFFSET_Y[j];
                                float num10 = (num8 - num6) * ptr2->Destination.Z;
                                float num11 = (num9 - num7) * ptr2->Destination.W;
                                float x     = ptr2->Destination.X + num10 * num4 - num11 * num5;
                                float y     = ptr2->Destination.Y + num10 * num5 + num11 * num4;
                                if ((ptr2->Effects & SpriteEffects.FlipVertically) != 0)
                                {
                                    num8 = 1f - num8;
                                }
                                if ((ptr2->Effects & SpriteEffects.FlipHorizontally) != 0)
                                {
                                    num9 = 1f - num9;
                                }
                                ptr4->Position.X          = x;
                                ptr4->Position.Y          = y;
                                ptr4->Position.Z          = 0f;
                                ptr4->TextureCoordinate.X = (ptr2->Source.X + num8 * ptr2->Source.Z) * num;
                                ptr4->TextureCoordinate.Y = (ptr2->Source.Y + num9 * ptr2->Source.W) * num2;
                                ptr4++;
                            }
                            ptr2++;
                        }
                    }
                }

                int offsetInBytes = _vertexBufferPosition * sizeof(VertexPositionColorTexture) * 4;
                _vertexBuffer.SetData(offsetInBytes, _vertices, 0, num3 * 4, sizeof(VertexPositionColorTexture), options);
                int minVertexIndex = _vertexBufferPosition * 4;
                int numVertices    = num3 * 4;
                int startIndex     = _vertexBufferPosition * 6;
                int primitiveCount = num3 * 2;
                _graphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, minVertexIndex, numVertices, startIndex, primitiveCount);
                _vertexBufferPosition += num3;
                offset += num3;
                count  -= num3;
            }
        }
Esempio n. 4
0
 public static void Delete(SpriteData *item)
 {
     Marshal.FreeHGlobal((IntPtr)item);
 }