SpriteBatch.cs

Go to the documentation of this file.

// Copyright (c) 2014 Silicon Studio Corp. (http://siliconstudio.co.jp)
// This file is distributed under GPL v3. See LICENSE.md for details.

using System;
using System.Runtime.InteropServices;
using System.Text;
using SiliconStudio.Core.Mathematics;
using SiliconStudio.Paradox.Effects.Modules;

namespace SiliconStudio.Paradox.Graphics
{
    /// <summary>
    /// Renders a group of sprites.
    /// </summary>
    public partial class SpriteBatch : BatchBase<SpriteBatch.SpriteDrawInfo>
    {
        private static readonly Vector2[] CornerOffsets = { Vector2.Zero, Vector2.UnitX, Vector2.One, Vector2.UnitY };
        private static Vector2 vector2Zero = Vector2.Zero;
        private static RectangleF? nullRectangle;
        
        private Matrix userViewMatrix;
        private Matrix userProjectionMatrix;

        private readonly Matrix defaultViewMatrix = Matrix.Identity;
        private Matrix defaultProjectionMatrix;
        
        /// <summary>
        /// Gets or sets the default depth value used by the <see cref="SpriteBatch"/> when the <see cref="VirtualResolution"/> is not set. 
        /// </summary>
        /// <remarks>More precisely, this value represents the length "farPlane-nearPlane" used by the default projection matrix.</remarks>
        public float DefaultDepth { get; set; }

        /// <summary>
        /// Gets or sets the virtual resolution used for this <see cref="SpriteBatch"/>
        /// </summary>
        public Vector3? VirtualResolution { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="SpriteBatch" /> class.
        /// </summary>
        /// <param name="graphicsDevice">The graphics device.</param>
        /// <param name="bufferElementCount">The maximum number element that can be batched in one time.</param>
        /// <param name="batchCapacity">The batch capacity default to 64.</param>
        public SpriteBatch(GraphicsDevice graphicsDevice, int bufferElementCount = 1024, int batchCapacity = 64)
            : base(graphicsDevice, Bytecode, StaticQuadBufferInfo.CreateQuadBufferInfo("SpriteBatch.VertexIndexBuffer", bufferElementCount, batchCapacity), VertexPositionColorTextureSwizzle.Layout)
        {
            DefaultDepth = 200f;
        }

        /// <summary>
        /// Calculate the default projection matrix for the provided virtual resolution.
        /// </summary>
        /// <returns>The default projection matrix for the provided virtual resolution</returns>
        /// <remarks>The sprite batch default projection is an orthogonal matrix such as (0,0) is the Top/Left corner of the screen and 
        /// (VirtualResolution.X, VirtualResolution.Y) is the Bottom/Right corner of the screen.</remarks>
        public static Matrix CalculateDefaultProjection(Vector3 virtualResolution)
        {
            Matrix matrix;

            CalculateDefaultProjection(ref virtualResolution, out matrix);

            return matrix;
        }

        /// <summary>
        /// Calculate the default projection matrix for the provided virtual resolution.
        /// </summary>
        public static void CalculateDefaultProjection(ref Vector3 virtualResolution, out Matrix projection)
        {
            var xRatio = 1f / virtualResolution.X;
            var yRatio = -1f / virtualResolution.Y;
            var zRatio = -1f / virtualResolution.Z;

            projection = new Matrix { M11 = 2f * xRatio, M22 = 2f * yRatio, M33 = zRatio, M44 = 1f, M41 = -1f, M42 = 1f, M43 = 0.5f };
        }

        private Vector3 GetCurrentResolution()
        {
            return VirtualResolution.HasValue ? VirtualResolution.Value: new Vector3(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height, DefaultDepth);
        }

        private void UpdateDefaultProjectionMatrix()
        {
            var resolution = GetCurrentResolution();
            CalculateDefaultProjection(ref resolution, out defaultProjectionMatrix);
        }

        /// <summary>
        /// Begins a sprite batch operation using deferred sort and default state objects (BlendState.AlphaBlend, SamplerState.LinearClamp, DepthStencilState.None, RasterizerState.CullCounterClockwise).
        /// </summary>
        /// <param name="sortMode">The sprite drawing order to use for the batch session</param>
        /// <param name="effect">The effect to use for the batch session</param>
        public void Begin(SpriteSortMode sortMode, Effect effect)
        {
            UpdateDefaultProjectionMatrix();
            Begin(defaultViewMatrix, defaultProjectionMatrix, sortMode, null, null, null, null, effect);
        }

        /// <summary>
        /// Begins a sprite batch rendering using the specified sorting mode and blend state, sampler, depth stencil and rasterizer state objects, plus a custom effect. Passing null for any of the state objects selects the default default state objects (BlendState.AlphaBlend, DepthStencilState.None, RasterizerState.CullCounterClockwise, SamplerState.LinearClamp). Passing a null effect selects the default SpriteBatch Class shader.
        /// </summary>
        /// <param name="sortMode">The sprite drawing order to use for the batch session</param>
        /// <param name="effect">The effect to use for the batch session</param>
        /// <param name="blendState">The blending state to use for the batch session</param>
        /// <param name="samplerState">The sampling state to use for the batch session</param>
        /// <param name="depthStencilState">The depth stencil state to use for the batch session</param>
        /// <param name="rasterizerState">The rasterizer state to use for the batch session</param>
        /// <param name="stencilValue">The value of the stencil buffer to take as reference for the batch session</param>
        public void Begin(SpriteSortMode sortMode = SpriteSortMode.Deferred, BlendState blendState = null, SamplerState samplerState = null, DepthStencilState depthStencilState = null, RasterizerState rasterizerState = null, Effect effect = null, int stencilValue = 0)
        {
            UpdateDefaultProjectionMatrix();
            Begin(defaultViewMatrix, defaultProjectionMatrix, sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect, stencilValue);
        }

        /// <summary>
        /// Begins a sprite batch rendering using the specified sorting mode and blend state, sampler, depth stencil, rasterizer state objects, plus a custom effect and a 2D transformation matrix. Passing null for any of the state objects selects the default default state objects (BlendState.AlphaBlend, DepthStencilState.None, RasterizerState.CullCounterClockwise, SamplerState.LinearClamp). Passing a null effect selects the default SpriteBatch Class shader. 
        /// </summary>
        /// <param name="sortMode">The sprite drawing order to use for the batch session</param>
        /// <param name="effect">The effect to use for the batch session</param>
        /// <param name="blendState">The blending state to use for the batch session</param>
        /// <param name="samplerState">The sampling state to use for the batch session</param>
        /// <param name="depthStencilState">The depth stencil state to use for the batch session</param>
        /// <param name="rasterizerState">The rasterizer state to use for the batch session</param>
        /// <param name="stencilValue">The value of the stencil buffer to take as reference for the batch session</param>
        /// <param name="viewMatrix">The view matrix to use for the batch session</param>
        public void Begin(Matrix viewMatrix, SpriteSortMode sortMode = SpriteSortMode.Deferred, BlendState blendState = null, SamplerState samplerState = null, DepthStencilState depthStencilState = null, RasterizerState rasterizerState = null, Effect effect = null, int stencilValue = 0)
        {
            UpdateDefaultProjectionMatrix();
            Begin(viewMatrix, defaultProjectionMatrix, sortMode, blendState, samplerState, depthStencilState, rasterizerState, effect, stencilValue);
        }

        /// <summary>
        /// Begins a sprite batch rendering using the specified sorting mode and blend state, sampler, depth stencil, rasterizer state objects, plus a custom effect and a 2D transformation matrix. Passing null for any of the state objects selects the default default state objects (BlendState.AlphaBlend, DepthStencilState.None, RasterizerState.CullCounterClockwise, SamplerState.LinearClamp). Passing a null effect selects the default SpriteBatch Class shader. 
        /// </summary>
        /// <param name="sortMode">The sprite drawing order to use for the batch session</param>
        /// <param name="effect">The effect to use for the batch session</param>
        /// <param name="blendState">The blending state to use for the batch session</param>
        /// <param name="samplerState">The sampling state to use for the batch session</param>
        /// <param name="depthStencilState">The depth stencil state to use for the batch session</param>
        /// <param name="rasterizerState">The rasterizer state to use for the batch session</param>
        /// <param name="stencilValue">The value of the stencil buffer to take as reference for the batch session</param>
        /// <param name="viewMatrix">The view matrix to use for the batch session</param>
        /// <param name="projectionMatrix">The projection matrix to use for the batch session</param>
        public void Begin(Matrix viewMatrix, Matrix projectionMatrix, SpriteSortMode sortMode = SpriteSortMode.Deferred, BlendState blendState = null, SamplerState samplerState = null, DepthStencilState depthStencilState = null, RasterizerState rasterizerState = null, Effect effect = null, int stencilValue = 0)
        {
            CheckEndHasBeenCalled("begin");

            userViewMatrix = viewMatrix;
            userProjectionMatrix = projectionMatrix;

            Begin(effect, sortMode, blendState, samplerState, depthStencilState, rasterizerState, stencilValue);
        }

        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, destination rectangle, and color. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="destinationRectangle">A rectangle that specifies (in screen coordinates) the destination for drawing the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <remarks>
        /// Before making any calls to Draw, you must call Begin. Once all calls to Draw are complete, call End. 
        /// </remarks>
        public void Draw(Texture texture, RectangleF destinationRectangle, Color color)
        {
            DrawSprite(texture, ref destinationRectangle, false, ref nullRectangle, color, 0f, ref vector2Zero, SpriteEffects.None, ImageOrientation.AsIs, 0f);
        }

        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, position and color. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        public void Draw(Texture texture, Vector2 position)
        {
            Draw(texture, position, Color.White);
        }

        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, position and color. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        public void Draw(Texture texture, Vector2 position, Color color)
        {
            var destination = new RectangleF(position.X, position.Y, 1f, 1f);
            DrawSprite(texture, ref destination, true, ref nullRectangle, color, 0f, ref vector2Zero, SpriteEffects.None, ImageOrientation.AsIs, 0f);
        }

        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, destination rectangle, source rectangle, color, rotation, origin, effects and layer. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="orientation">The source image orientation</param>
        /// <param name="destinationRectangle">A rectangle that specifies (in screen coordinates) the destination for drawing the sprite. If this rectangle is not the same size as the source rectangle, the sprite will be scaled to fit.</param>
        /// <param name="sourceRectangle">A rectangle that specifies (in texels) the source texels from a texture. Use null to draw the entire texture. </param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in the texture in pixels (dependent of image orientation). Default value is (0,0) which represents the upper-left corner.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        public void Draw(Texture texture, RectangleF destinationRectangle, RectangleF? sourceRectangle, Color color, float rotation, Vector2 origin, 
            SpriteEffects effects = SpriteEffects.None, ImageOrientation orientation = ImageOrientation.AsIs, float layerDepth = 0f) 
        {
            DrawSprite(texture, ref destinationRectangle, false, ref sourceRectangle, color, rotation, ref origin, effects, orientation, layerDepth);
        }


        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, position, source rectangle, color, rotation, origin, scale, effects, and layer. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in the texture in pixels (dependent of image orientation). Default value is (0,0) which represents the upper-left corner.</param>
        /// <param name="scale">Scale factor.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="orientation">The source image orientation</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        public void Draw(Texture texture, Vector2 position, Color color, float rotation, Vector2 origin, float scale = 1.0f, 
            SpriteEffects effects = SpriteEffects.None, ImageOrientation orientation = ImageOrientation.AsIs, float layerDepth = 0)
        {
            Draw(texture, position, null, color, rotation, origin, scale, effects, orientation, layerDepth);
        }

        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, position, source rectangle, color, rotation, origin, scale, effects, and layer. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in the texture in pixels (dependent of image orientation). Default value is (0,0) which represents the upper-left corner.</param>
        /// <param name="scale">Scale factor.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="orientation">The source image orientation</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        public void Draw(Texture texture, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, 
            SpriteEffects effects = SpriteEffects.None, ImageOrientation orientation = ImageOrientation.AsIs, float layerDepth = 0)
        {
            Draw(texture, position, null, color, rotation, origin, scale, effects, orientation, layerDepth);
        }

        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, position, source rectangle, and color. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="sourceRectangle">A rectangle that specifies (in texels) the source texels from a texture. Use null to draw the entire texture. </param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        public void Draw(Texture texture, Vector2 position, RectangleF? sourceRectangle, Color color)
        {
            var destination = new RectangleF(position.X, position.Y, 1f, 1f);
            DrawSprite(texture, ref destination, true, ref sourceRectangle, color, 0f, ref vector2Zero, SpriteEffects.None, ImageOrientation.AsIs, 0f);
        }

        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, position, source rectangle, color, rotation, origin, scale, effects, and layer. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="sourceRectangle">A rectangle that specifies (in texels) the source texels from a texture. Use null to draw the entire texture. </param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in the texture in pixels (dependent of image orientation). Default value is (0,0) which represents the upper-left corner.</param>
        /// <param name="scale">Scale factor.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="orientation">The source image orientation</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        public void Draw(Texture texture, Vector2 position, RectangleF? sourceRectangle, Color color, float rotation, 
            Vector2 origin, float scale = 1f, SpriteEffects effects = SpriteEffects.None, ImageOrientation orientation = ImageOrientation.AsIs, float layerDepth = 0)
        {
            var destination = new RectangleF(position.X, position.Y, scale, scale);
            DrawSprite(texture, ref destination, true, ref sourceRectangle, color, rotation, ref origin, effects, orientation, layerDepth);
        }

        /// <summary>
        /// Adds a sprite to a batch of sprites for rendering using the specified texture, position, source rectangle, color, rotation, origin, scale, effects, and layer. 
        /// </summary>
        /// <param name="texture">A texture.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="sourceRectangle">A rectangle that specifies (in texels) the source texels from a texture. Use null to draw the entire texture. </param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in the texture in pixels (dependent of image orientation). Default value is (0,0) which represents the upper-left corner.</param>
        /// <param name="scale">Scale factor.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="orientation">The source image orientation</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        public void Draw(Texture texture, Vector2 position, RectangleF? sourceRectangle, Color color, float rotation, 
            Vector2 origin, Vector2 scale, SpriteEffects effects = SpriteEffects.None, ImageOrientation orientation = ImageOrientation.AsIs, float layerDepth = 0)
        {
            var destination = new RectangleF(position.X, position.Y, scale.X, scale.Y);
            DrawSprite(texture, ref destination, true, ref sourceRectangle, color, rotation, ref origin, effects, orientation, layerDepth);
        }

        /// <summary>
        /// Returns the size of the given text in virtual pixels.
        /// </summary>
        /// <param name="spriteFont">The font used to draw the text.</param>
        /// <param name="text">The text to measure.</param>
        /// <param name="targetSize">The size of the target to render in</param>
        /// <returns>The size of the text in virtual pixels.</returns>
        /// <exception cref="ArgumentNullException">The provided sprite font is null.</exception>
        public Vector2 MeasureString(SpriteFont spriteFont, string text, Vector2 targetSize)
        {
            if (spriteFont == null) throw new ArgumentNullException("spriteFont");

            return MeasureString(spriteFont, text, spriteFont.Size, targetSize);
        }

        /// <summary>
        /// Returns the size of the given text in virtual pixels.
        /// </summary>
        /// <param name="spriteFont">The font used to draw the text.</param>
        /// <param name="text">The text to measure.</param>
        /// <param name="targetSize">The size of the target to render in</param>
        /// <param name="fontSize">The font size (in pixels) used to draw the text.</param>
        /// <returns>The size of the text in virtual pixels.</returns>
        /// <exception cref="ArgumentNullException">The provided sprite font is null.</exception>
        public Vector2 MeasureString(SpriteFont spriteFont, string text, float fontSize, Vector2 targetSize)
        {
            if (spriteFont == null) throw new ArgumentNullException("spriteFont");

            if (string.IsNullOrEmpty(text))
                return Vector2.Zero;

            // calculate the size of the text that will be used to draw
            var virtualResolution = VirtualResolution.HasValue? VirtualResolution.Value: new Vector3(targetSize, DefaultDepth);
            var ratio = new Vector2(targetSize.X / virtualResolution.X, targetSize.Y / virtualResolution.Y);

            var realSize = spriteFont.MeasureString(text, fontSize * ratio);

            // convert pixel size into virtual pixel size (if needed) 
            var virtualSize = realSize;
            virtualSize.X /= ratio.X;
            virtualSize.Y /= ratio.Y;

            return virtualSize;
        }

        /// <summary>Adds a string to a batch of sprites for rendering using the specified font, text, position, and color.</summary>
        /// <param name="spriteFont">A font for displaying text.</param>
        /// <param name="text">A text string.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="alignment">Describes how to align the text to draw</param>
        public void DrawString(SpriteFont spriteFont, string text, Vector2 position, Color color, TextAlignment alignment = TextAlignment.Left)
        {
            var proxy = new SpriteFont.StringProxy(text);
            DrawString(spriteFont, ref proxy, -1, ref position, ref color, 0, Vector2.Zero, Vector2.One, SpriteEffects.None, 0f, alignment);
        }

        /// <summary>Adds a string to a batch of sprites for rendering using the specified font, text, position, and color.</summary>
        /// <param name="spriteFont">A font for displaying text.</param>
        /// <param name="text">Text string.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="alignment">Describes how to align the text to draw</param>
        public void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2 position, Color color, TextAlignment alignment = TextAlignment.Left)
        {
            var proxy = new SpriteFont.StringProxy(text);
            DrawString(spriteFont, ref proxy, -1, ref position, ref color, 0, Vector2.Zero, Vector2.One, SpriteEffects.None, 0f, alignment);
        }

        /// <summary>Adds a string to a batch of sprites for rendering using the specified font, text, position, and color.</summary>
        /// <param name="spriteFont">A font for displaying text.</param>
        /// <param name="text">A text string.</param>
        /// <param name="fontSize">The font size in pixels (ignored in the case of static fonts)</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="alignment">Describes how to align the text to draw</param>
        public void DrawString(SpriteFont spriteFont, string text, float fontSize, Vector2 position, Color color, TextAlignment alignment = TextAlignment.Left)
        {
            var proxy = new SpriteFont.StringProxy(text);
            DrawString(spriteFont, ref proxy, fontSize, ref position, ref color, 0, Vector2.Zero, Vector2.One, SpriteEffects.None, 0f, alignment);
        }

        /// <summary>Adds a string to a batch of sprites for rendering using the specified font, text, position, and color.</summary>
        /// <param name="spriteFont">A font for displaying text.</param>
        /// <param name="text">Text string.</param>
        /// <param name="fontSize">The font size in pixels (ignored in the case of static fonts)</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="alignment">Describes how to align the text to draw</param>
        public void DrawString(SpriteFont spriteFont, StringBuilder text, float fontSize, Vector2 position, Color color, TextAlignment alignment = TextAlignment.Left)
        {
            var proxy = new SpriteFont.StringProxy(text);
            DrawString(spriteFont, ref proxy, fontSize, ref position, ref color, 0, Vector2.Zero, Vector2.One, SpriteEffects.None, 0f, alignment);
        }

        /// <summary>Adds a string to a batch of sprites for rendering using the specified font, text, position, color, rotation, origin, scale, effects and layer.</summary>
        /// <param name="spriteFont">A font for displaying text.</param>
        /// <param name="text">A text string.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in virtual pixels; the default is (0,0) which represents the upper-left corner.</param>
        /// <param name="scale">Scale factor.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        /// <param name="alignment">Describes how to align the text to draw</param>
        public void DrawString(SpriteFont spriteFont, string text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth, TextAlignment alignment)
        {
            var proxy = new SpriteFont.StringProxy(text);
            DrawString(spriteFont, ref proxy, -1, ref position, ref color, rotation, ref origin, ref scale, effects, layerDepth, alignment);
        }

        /// <summary>Adds a string to a batch of sprites for rendering using the specified font, text, position, color, rotation, origin, scale, effects and layer.</summary>
        /// <param name="spriteFont">A font for displaying text.</param>
        /// <param name="text">Text string.</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in virtual pixels; the default is (0,0) which represents the upper-left corner.</param>
        /// <param name="scale">Scale factor.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        /// <param name="alignment">Describes how to align the text to draw</param>
        public void DrawString(SpriteFont spriteFont, StringBuilder text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth, TextAlignment alignment)
        {
            var proxy = new SpriteFont.StringProxy(text);
            DrawString(spriteFont, ref proxy, -1, ref position, ref color, rotation, ref origin, ref scale, effects, layerDepth, alignment);
        }

        /// <summary>Adds a string to a batch of sprites for rendering using the specified font, text, position, color, rotation, origin, scale, effects and layer.</summary>
        /// <param name="spriteFont">A font for displaying text.</param>
        /// <param name="text">A text string.</param>
        /// <param name="fontSize">The font size in pixels (ignored in the case of static fonts)</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in virtual pixels; the default is (0,0) which represents the upper-left corner.</param>
        /// <param name="scale">Scale factor.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        /// <param name="alignment">Describes how to align the text to draw</param>
        public void DrawString(SpriteFont spriteFont, string text, float fontSize, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth, TextAlignment alignment)
        {
            var proxy = new SpriteFont.StringProxy(text);
            DrawString(spriteFont, ref proxy, fontSize, ref position, ref color, rotation, ref origin, ref scale, effects, layerDepth, alignment);
        }

        /// <summary>Adds a string to a batch of sprites for rendering using the specified font, text, position, color, rotation, origin, scale, effects and layer.</summary>
        /// <param name="spriteFont">A font for displaying text.</param>
        /// <param name="text">Text string.</param>
        /// <param name="fontSize">The font size in pixels (ignored in the case of static fonts)</param>
        /// <param name="position">The location (in screen coordinates) to draw the sprite.</param>
        /// <param name="color">The color to tint a sprite. Use Color.White for full color with no tinting.</param>
        /// <param name="rotation">Specifies the angle (in radians) to rotate the sprite about its center.</param>
        /// <param name="origin">The sprite origin in virtual pixels; the default is (0,0) which represents the upper-left corner.</param>
        /// <param name="scale">Scale factor.</param>
        /// <param name="effects">Effects to apply.</param>
        /// <param name="layerDepth">The depth of a layer. By default, 0 represents the front layer and 1 represents a back layer. Use SpriteSortMode if you want sprites to be sorted during drawing.</param>
        /// <param name="alignment">Describes how to align the text to draw</param>
        public void DrawString(SpriteFont spriteFont, StringBuilder text, float fontSize, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth, TextAlignment alignment)
        {
            var proxy = new SpriteFont.StringProxy(text);
            DrawString(spriteFont, ref proxy, fontSize, ref position, ref color, rotation, ref origin, ref scale, effects, layerDepth, alignment);
        }

        private void DrawString(SpriteFont spriteFont, ref SpriteFont.StringProxy text, float fontSize, ref Vector2 position, ref Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth, TextAlignment alignment)
        {
            DrawString(spriteFont, ref text, fontSize, ref position, ref color, rotation, ref origin, ref scale, effects, layerDepth, alignment);
        }

        private void DrawString(SpriteFont spriteFont, ref SpriteFont.StringProxy text, float fontSize, ref Vector2 position, ref Color color, float rotation, ref Vector2 origin, ref Vector2 scale, SpriteEffects effects, float layerDepth, TextAlignment alignment)
        {
            if (spriteFont == null)
            {
                throw new ArgumentNullException("spriteFont");
            }
            if (text.IsNull)
            {
                throw new ArgumentNullException("text");
            }
            if (fontSize < 0)
                fontSize = spriteFont.Size;

            // calculate the resolution ratio between the screen real size and the virtual resolution
            var viewportSize = GraphicsDevice.Viewport;
            var virtualResolution = GetCurrentResolution();
            var resolutionRatio = new Vector2(viewportSize.Width / virtualResolution.X, viewportSize.Height / virtualResolution.Y);
            scale.X = scale.X / resolutionRatio.X;
            scale.Y = scale.Y / resolutionRatio.Y;

            var fontSize2 = fontSize * (spriteFont.IsDynamic ? resolutionRatio : Vector2.One);
            var drawCommand = new SpriteFont.InternalDrawCommand(this, ref fontSize2, ref position, ref color, rotation, ref origin, ref scale, effects, layerDepth);

            // snap the position the closest 'real' pixel
            Vector2.Modulate(ref drawCommand.Position, ref resolutionRatio, out drawCommand.Position);
            drawCommand.Position.X = (float)Math.Round(drawCommand.Position.X);
            drawCommand.Position.Y = (float)Math.Round(drawCommand.Position.Y);
            drawCommand.Position.X /= resolutionRatio.X;
            drawCommand.Position.Y /= resolutionRatio.Y;

            spriteFont.InternalDraw(ref text, ref drawCommand, alignment);
        }
        
        internal unsafe void DrawSprite(Texture texture, ref RectangleF destination, bool scaleDestination, ref RectangleF? sourceRectangle, Color color, 
            float rotation, ref Vector2 origin, SpriteEffects effects, ImageOrientation orientation, float depth, SwizzleMode swizzle = SwizzleMode.None, bool realSize = false)
        {
            // Check that texture is not null
            if (texture == null)
            {
                throw new ArgumentNullException("texture");
            }
            
            // Put values in next ElementInfo
            var elementInfo = new ElementInfo();
            var spriteInfo = &elementInfo.DrawInfo;

            float width;
            float height;

            // If the source rectangle has a value, then use it.
            if (sourceRectangle.HasValue)
            {
                var rectangle = sourceRectangle.Value;
                spriteInfo->Source.X = rectangle.X;
                spriteInfo->Source.Y = rectangle.Y;
                width = rectangle.Width;
                height = rectangle.Height;
            }
            else
            {
                // Else, use directly the size of the texture
                spriteInfo->Source.X = 0.0f;
                spriteInfo->Source.Y = 0.0f;
                width = texture.Width;
                height = texture.Height;
            }

            // Sets the width and height
            spriteInfo->Source.Width = width;
            spriteInfo->Source.Height = height;

            // Scale the destination box
            if (scaleDestination)
            {
                if (orientation == ImageOrientation.Rotated90)
                {
                    destination.Width *= height;
                    destination.Height *= width;
                }
                else
                {
                    destination.Width *= width;
                    destination.Height *= height;
                }
            }

            // Sets the destination
            spriteInfo->Destination = destination;

            // Copy all other values.
            spriteInfo->Origin.X = origin.X;
            spriteInfo->Origin.Y = origin.Y;
            spriteInfo->Rotation = rotation;
            spriteInfo->Depth = depth;
            spriteInfo->SpriteEffects = effects;
            spriteInfo->Color = color;
            spriteInfo->Swizzle = swizzle;
            spriteInfo->TextureSize.X = texture.Width;
            spriteInfo->TextureSize.Y = texture.Height;
            spriteInfo->Orientation = orientation;

            elementInfo.VertexCount = StaticQuadBufferInfo.VertexByElement;
            elementInfo.IndexCount = StaticQuadBufferInfo.IndicesByElement;
            elementInfo.Depth = depth;

            Draw(texture, null, ref elementInfo);
        }

        protected override unsafe void UpdateBufferValuesFromElementInfo(ref ElementInfo elementInfo, IntPtr vertexPtr, IntPtr indexPtr, int vertexOffset)
        {
            var vertex = (VertexPositionColorTextureSwizzle*)vertexPtr;
            fixed (SpriteDrawInfo* drawInfo = &elementInfo.DrawInfo)
            {
                var deltaX = 1f / drawInfo->TextureSize.X;
                var deltaY = 1f / drawInfo->TextureSize.Y;

                var rotation = Math.Abs(drawInfo->Rotation) > MathUtil.ZeroTolerance ? new Vector2((float)Math.Cos(drawInfo->Rotation), (float)Math.Sin(drawInfo->Rotation)) : Vector2.UnitX;

                // Center scale down to the size of the source texture 
                var origin = drawInfo->Origin;
                origin.X /= Math.Max(MathUtil.ZeroTolerance, drawInfo->Source.Width);
                origin.Y /= Math.Max(MathUtil.ZeroTolerance, drawInfo->Source.Height);

                for (int j = 0; j < 4; j++)
                {
                    // Gets the corner and take into account the Flip mode.
                    var corner = CornerOffsets[j];
                    // Calculate position on destination
                    var position = new Vector2((corner.X - origin.X) * drawInfo->Destination.Width, (corner.Y - origin.Y) * drawInfo->Destination.Height);

                    // Apply rotation and destination offset
                    vertex->Position.X = drawInfo->Destination.X + (position.X * rotation.X) - (position.Y * rotation.Y);
                    vertex->Position.Y = drawInfo->Destination.Y + (position.X * rotation.Y) + (position.Y * rotation.X);
                    vertex->Position.Z = drawInfo->Depth;
                    vertex->Position.W = 1f;
                    vertex->Color = drawInfo->Color;

                    corner = CornerOffsets[((j ^ (int)drawInfo->SpriteEffects) + (int)drawInfo->Orientation) % 4];
                    vertex->TextureCoordinate.X = (drawInfo->Source.X + corner.X * drawInfo->Source.Width) * deltaX;
                    vertex->TextureCoordinate.Y = (drawInfo->Source.Y + corner.Y * drawInfo->Source.Height) * deltaY;

                    vertex->Swizzle = (int)drawInfo->Swizzle;

                    vertex++;
                }
            }
        }

        protected override void PrepareForRendering()
        {
            Matrix viewProjection;
            Matrix.MultiplyTo(ref userViewMatrix, ref userProjectionMatrix, out viewProjection);

            // Setup effect states and parameters: SamplerState and MatrixTransform
            // Sets the sampler state
            Effect.Parameters.Set(SpriteBaseKeys.MatrixTransform, viewProjection);

            base.PrepareForRendering();
        }
        
        [StructLayout(LayoutKind.Sequential)]
        public struct SpriteDrawInfo
        {
            public RectangleF Source;
            public RectangleF Destination;
            public Vector2 Origin;
            public float Rotation;
            public float Depth;
            public SpriteEffects SpriteEffects;
            public Color Color;
            public SwizzleMode Swizzle;
            public Vector2 TextureSize;
            public ImageOrientation Orientation;
        }
    }
}