Refactor to decrease dependent implementation exposure and remove need for wrapper

.gitignore

···
 # Visual Studio 2017 auto generated files
 Generated\ Files/
 
+# vscode
+.vscode/
+
 # MSTest test Results
 [Tt]est[Rr]esult*/
 [Bb]uild[Ll]og.*

src/Peridot.Demo/Peridot.Demo.csproj

···
 
   <ItemGroup>
     <PackageReference Include="Ez.Numerics" Version="0.2.0-alpha" />
-    <PackageReference Include="StbImageSharp" Version="2.22.6" />
     <PackageReference Include="System.Resources.Extensions" Version="6.0.0" />
     <PackageReference Include="Veldrid.StartupUtilities" Version="4.8.0" />
   </ItemGroup>

src/Peridot.Demo/Program.cs

···
 // Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
 // This code is licensed under MIT license (see LICENSE for details)
-
-using Peridot.Veldrid;
 using System.Drawing;
 using Veldrid;
 using Veldrid.StartupUtilities;
 using System.Numerics;
 using Peridot.Demo;
 
-using Font = Peridot.Veldrid.Font;
 using StbImageSharp;
 using System.Diagnostics;
 using Rectangle = System.Drawing.Rectangle;
 using Peridot;
+using Peridot.Text;
 
 var title = "Peridot.Demo";
 var wci = new WindowCreateInfo(100, 100, 640, 480, WindowState.Normal, title);
 
 var window = VeldridStartup.CreateWindow(wci);
-var gd = VeldridStartup.CreateDefaultD3D11GraphicsDevice(
-    new(true,
-        Veldrid.PixelFormat.D32_Float_S8_UInt,
-        true,
-        ResourceBindingModel.Default,
-        true,
-        true),
-    window);
+var gd = VeldridStartup.CreateVulkanGraphicsDevice(
+	new(true,
+		Veldrid.PixelFormat.D32_Float_S8_UInt,
+		true,
+		ResourceBindingModel.Default,
+		true,
+		true),
+	window);
 
 window.Resized += () =>
 {
-    gd.MainSwapchain.Resize((uint)window.Width, (uint)window.Height);
+	gd.MainSwapchain.Resize((uint)window.Width, (uint)window.Height);
 };
 
-var shaders = VeldridSpriteBatch.LoadDefaultShaders(gd);
-var sb = new VeldridSpriteBatch(gd, gd.MainSwapchain.Framebuffer.OutputDescription, shaders);
-var tr = new TextRenderer(gd, sb);
+var peridot = new VPeridot(gd);
+
+var shaders = peridot.LoadDefaultShaders();
+var sbd = new SpriteBatchDescriptor(gd.MainSwapchain.Framebuffer.OutputDescription, shaders);
+var sb = peridot.CreateSpriteBatch(sbd);
+
+var tr = new TextRenderer(peridot, sb);
 var cl = gd.ResourceFactory.CreateCommandList();
 var fence = gd.ResourceFactory.CreateFence(false);
 var texture = LoadTexture(Resource._4_2_07);
···
 var ps = 0;
 while (window.Exists)
 {
-    count++;
+	count++;
 
-    var now = DateTime.Now;
-    var delta = now - time;
-    var deltaTime = delta.TotalSeconds;
-    time = now;
+	var now = DateTime.Now;
+	var delta = now - time;
+	var deltaTime = delta.TotalSeconds;
+	time = now;
 
-    if((count % 1000) == 0)
-    {
-        window.Title = title + " " + (1f / deltaTime);
-    }
+	if((count % 1000) == 0)
+	{
+		window.Title = title + " " + (1f / deltaTime);
+	}
 
-    window.PumpEvents();
+	window.PumpEvents();
 
-    sb.Begin();
-    sb.ViewMatrix = Matrix4x4.CreateOrthographic(window.Width, window.Height, 0.01f, -100f);
-    
-    var size = new Vector2(texture.Width, texture.Height);
-    var pos = size * -0.5f;
-    var source = new System.Drawing.Rectangle((int)texture.Width / 2, (int)texture.Height / 2, (int)texture.Width / 2, (int)texture.Height / 2);
+	sb.Begin();
+	sb.ViewMatrix = Matrix4x4.CreateOrthographic(window.Width, window.Height, 0.01f, -100f);
+	
+	var size = new Vector2(texture.Width, texture.Height);
+	var pos = size * -0.5f;
+	var source = new System.Drawing.Rectangle((int)texture.Width / 2, (int)texture.Height / 2, (int)texture.Width / 2, (int)texture.Height / 2);
 
-    ps += neg ? -1 : 1;
-    if (ps == 0 || ps == 100)
-        neg = !neg;
+	ps += neg ? -1 : 1;
+	if (ps == 0 || ps == 100)
+		neg = !neg;
 
-    var options = ps >= 0 && ps < 25 ? SpriteOptions.None :
-                  ps >= 25 && ps < 50 ? SpriteOptions.FlipVertically :
-                  ps >= 50 && ps < 75 ? SpriteOptions.FlipVertically | SpriteOptions.FlipHorizontally :
-                                        SpriteOptions.FlipHorizontally;
+	var options = ps >= 0 && ps < 25 ? SpriteOptions.None :
+				  ps >= 25 && ps < 50 ? SpriteOptions.FlipVertically :
+				  ps >= 50 && ps < 75 ? SpriteOptions.FlipVertically | SpriteOptions.FlipHorizontally :
+										SpriteOptions.FlipHorizontally;
 
-    sb.Draw(texture, default, source, Color.White, 0, new(-size.X / 6, 0), Vector2.One, options, 1f);
+	sb.Draw(texture, default, source, Color.White, 0, new(-size.X / 6, 0), Vector2.One, options, 1f);
 
-    var s = font.MeasureString("Hello World!", 32);
-    var strScissor = new Rectangle(0, 0, (int)s.X, (int)s.Y * ps / 100);
-    tr.DrawString(font, 32, "Hello World!", new Vector2(1, 1), Color.White, 0, new Vector2(0, 0), new Vector2(1), 2f, strScissor);
-    sb.End();
+	var s = font.MeasureString("Hello World!", 32);
+	var strScissor = new Rectangle(0, 0, (int)s.X, (int)s.Y * ps / 100);
+	tr.DrawString(font, 32, "Hello World!", new Vector2(1, 1), Color.White, 0, new Vector2(0, 0), new Vector2(1), 2f, strScissor);
+	sb.End();
 
-    cl.Begin();
-    cl.SetFramebuffer(gd.SwapchainFramebuffer);
-    cl.ClearColorTarget(0, RgbaFloat.CornflowerBlue);
-    cl.ClearDepthStencil(0f);
-    sb.DrawBatch(cl);
-    cl.End();
+	cl.Begin();
+	cl.SetFramebuffer(gd.SwapchainFramebuffer);
+	cl.ClearColorTarget(0, RgbaFloat.CornflowerBlue);
+	cl.ClearDepthStencil(0f);
+	cl.DrawBatch(sb);
+	cl.End();
 
-    fence.Reset();
-    gd.SubmitCommands(cl, fence);
-    gd.WaitForFence(fence);
-    gd.SwapBuffers();
+	fence.Reset();
+	gd.SubmitCommands(cl, fence);
+	gd.WaitForFence(fence);
+	gd.SwapBuffers();
 }
 
 Texture LoadTexture(byte[] data)
 {
-    ImageResult image;
-    {
-        image = ImageResult.FromMemory(data, ColorComponents.Default);
-        Debug.Assert(image != null);
-    }
+	ImageResult image;
+	{
+		image = ImageResult.FromMemory(data, ColorComponents.Default);
+		Debug.Assert(image != null);
+	}
 
-    var td = new TextureDescription(
-        (uint)image.Width, (uint)image.Height, 1,
-        1, 1,
-        PixelFormat.R8_G8_B8_A8_UNorm,
-        TextureUsage.Sampled,
-        TextureType.Texture2D);
+	var td = new TextureDescription(
+		(uint)image.Width, (uint)image.Height, 1,
+		1, 1,
+		Veldrid.PixelFormat.R8_G8_B8_A8_UNorm,
+		TextureUsage.Sampled,
+		TextureType.Texture2D);
 
-    var texture = gd.ResourceFactory.CreateTexture(td);
-    gd.UpdateTexture(texture, image.Data, 0, 0, 0, td.Width, td.Height, td.Depth, 0, 0);
+	var texture = gd.ResourceFactory.CreateTexture(td);
+	gd.UpdateTexture(texture, image.Data, 0, 0, 0, td.Width, td.Height, td.Depth, 0, 0);
 
-    return texture;
+	return texture;
 }
 
 Font LoadFont(byte[] data)
 {
-    using var stream = new MemoryStream();
-    stream.Write(data);
-    stream.Position = 0;
-    var font = new Font();
-    font.AddFont(data);
-    return font;
-}
+	using var stream = new MemoryStream();
+	stream.Write(data);
+	stream.Position = 0;
+	var font = new Font();
+	font.AddFont(data);
+	return font;
+}

src/Peridot.Veldrid/Font.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using FontStashSharp;
-using System.Numerics;
-
-namespace Peridot.Veldrid
-{
-    /// <summary>
-    /// Represents a font that can be rendered with <see cref="TextRenderer"/>.
-    /// </summary>
-    public class Font : IFont
-    {
-        /// <summary>
-        /// Creates a new instance of <see cref="Font"/>.
-        /// </summary>
-        public Font()
-        {
-            var settings = new FontSystemSettings
-            {
-                Effect = FontSystemEffect.None,
-                EffectAmount = 2,
-            };
-            FontSystem = new FontSystem(settings);
-        }
-
-        /// <summary>
-        /// Destroys a instance of <see cref="TextureWrapper"/>.
-        /// </summary>
-        ~Font()
-        {
-            Dispose(false);
-        }
-
-        internal FontSystem FontSystem { get; }
-
-        /// <inheritdoc/>
-        public bool IsDisposed { get; private set; }
-
-        /// <summary>
-        /// Add a character font to the font.
-        /// </summary>
-        /// <param name="stream">The stream that contains the font.</param>
-        public void AddFont(Stream stream)
-        {
-            FontSystem.AddFont(stream);
-        }
-
-        /// <summary>
-        /// Add a character font to the font.
-        /// </summary>
-        /// <param name="data">The data that contains the font.</param>
-        public void AddFont(byte[] data)
-        {
-            FontSystem.AddFont(data);
-        }
-
-        /// <inheritdoc/>
-        public Vector2 MeasureString(string text, int fontSize)
-        {
-            var font = FontSystem.GetFont(fontSize);
-            return font.MeasureString(text);
-        }
-
-        /// <inheritdoc/>
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        private void Dispose(bool disposing)
-        {
-            if (disposing)
-                FontSystem.Dispose();
-        }
-    }
-}

src/Peridot.Veldrid/FontStashRenderer.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using FontStashSharp.Interfaces;
-using System.Drawing;
-using System.Numerics;
-using Veldrid;
-
-namespace Peridot.Veldrid
-{
-    internal class FontStashRenderer : IFontStashRenderer, IDisposable
-    {
-        private bool _disposed;
-        private readonly VeldridSpriteBatch _sb;
-        private readonly Texture2DManager _texture2DManager;
-        public FontStashRenderer(GraphicsDevice gd, VeldridSpriteBatch sb)
-        {
-            _texture2DManager = new Texture2DManager(gd);
-            _sb = sb;
-            ResetScissor();
-        }
-
-        ~FontStashRenderer()
-        {
-            Dispose(false);
-        }
-
-        public Rectangle Scissor { get; set; }
-
-        public ITexture2DManager TextureManager => _texture2DManager;
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        private void Dispose(bool disposing)
-        {
-            if (_disposed)
-                return;
-            _disposed = true;
-            if (disposing)
-                _texture2DManager.Dispose();
-        }
-
-        public void ResetScissor()
-        {
-            const int v = 1 << 23;
-            const int s = -(1 << 22);
-            Scissor = new Rectangle(s, s, v, v);
-        }
-
-        public void Draw(object texture, Vector2 pos, Rectangle? src, Color color, float rotation, Vector2 origin, Vector2 scale, float depth)
-        {
-            if (texture is not Texture t)
-                throw new ArgumentException(nameof(texture));
-
-            var s = src ?? new(0, 0, (int)t.Width, (int)t.Height);
-
-            var oldScissor = _sb.Scissor;
-            _sb.Scissor = RectangleF.Intersect(_sb.Scissor, Scissor);
-            _sb.Draw(t, pos, s, color, rotation, origin, new Vector2(scale.X, scale.Y), depth);
-            _sb.Scissor = oldScissor;
-        }
-    }
-}

src/Peridot.Veldrid/Peridot.Veldrid.csproj

···
 		<TargetFramework>net6.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
 		<Description>Peridot implementation using Veldrid lib.</Description>
 	</PropertyGroup>
 
···
 
 	<ItemGroup>
 	  <PackageReference Include="Ez.Memory" Version="0.2.0-alpha" />
-	  <PackageReference Include="FontStashSharp" Version="1.0.4" />
 	  <PackageReference Include="Veldrid" Version="4.8.0" />
 	  <PackageReference Include="Veldrid.SPIRV" Version="1.0.14" />
 	</ItemGroup>

src/Peridot.Veldrid/PeridotCommandListExtensions.cs

···
+using Veldrid;
+
+namespace Peridot;
+
+/// <summary>
+/// Peridot command list extensions.
+/// </summary>
+public static class PeridotCommandListExtensions
+{
+	/// <summary>
+	/// Draw this branch into a <see cref="CommandList"/>.
+	/// Call this after calling <see cref="SpriteBatch{TTexture}.End"/>
+	/// </summary>
+	/// <param name="spriteBatch"></param>
+	/// <param name="commandList"></param>
+	public static void DrawBatch(this CommandList commandList, ISpriteBatch spriteBatch)
+	{
+		if (spriteBatch is not VSpriteBatch sb)
+			throw new NotSupportedException();
+
+		sb.DrawBatch(commandList);
+	}
+}

src/Peridot.Veldrid/Resource.Designer.cs

···
 // </auto-generated>
 //------------------------------------------------------------------------------
 
-namespace Peridot.Veldrid 
+namespace Peridot 
 {
     using System;
     

src/Peridot.Veldrid/SpriteBatchDescriptor.cs

···
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Veldrid;
+
+namespace Peridot
+{
+	/// <summary>
+	/// Describes a sprite batch.
+	/// </summary>
+	public struct SpriteBatchDescriptor
+	{
+		/// <summary>
+		/// Creates a sprite batch descriptior.
+		/// </summary>
+		/// <param name="outputDescription">The output description of target framebuffer.</param>
+        /// <param name="shaders">The shaders to use to render. Uses <seealso cref="VPeridot.LoadDefaultShaders(GraphicsDevice)"/> for default.</param>
+        /// <param name="sampler">The samppler used to sample.</param>
+        /// <param name="cullMode">Controls which face will be culled. By default the sprite are rendered with forward normal, negatives scales can flips that normal.</param>
+        /// <param name="blendState">The blend state description for creating the pipeline.</param>
+        /// <param name="depthStencil">The depth stencil state description for creating the pipeline.</param>
+		public SpriteBatchDescriptor(
+			OutputDescription outputDescription,
+			Shader[] shaders,
+			Sampler? sampler = null,
+			FaceCullMode cullMode = FaceCullMode.None,
+			BlendStateDescription? blendState = null,
+			DepthStencilStateDescription? depthStencil = null)
+		{
+			OutputDescription = outputDescription;
+			Shaders = shaders;
+			Sampler = sampler;
+			CullMode = cullMode;
+			BlendState = blendState;
+			DepthStencil = depthStencil;
+		}
+		
+		/// <summary>
+		/// The output description of target framebuffer.
+		/// </summary>
+		public OutputDescription OutputDescription { init; get; }
+		
+		/// <summary>
+		/// The shaders to use to render.
+		/// Uses <seealso cref="VPeridot.LoadDefaultShaders(GraphicsDevice)"/> for default.
+		/// </summary>
+		public Shader[] Shaders { init; get; }
+		
+		/// <summary>
+		/// The samppler used to sample.
+		/// If null, will use LinearSampler.
+		/// </summary>
+		public Sampler? Sampler { init; get; }
+		
+		/// <summary>
+		/// Controls which face will be culled.
+		/// By default the sprite are rendered with forward normal, negatives scales can 
+		/// flips that normal.
+		/// </summary>
+		public FaceCullMode CullMode { init; get; }
+		
+		/// <summary>
+		/// The blend state description for creating the pipeline.
+		/// If null, will use SingleAlphaBlend.
+		/// </summary>
+		public BlendStateDescription? BlendState { init; get; }
+		
+		/// <summary>
+		/// The depth stencil state description for creating the pipeline.
+		/// If null, will use depth test, depth write enable and comparison kind GreaterEqual.
+		/// </summary>
+		public DepthStencilStateDescription? DepthStencil { init; get; }
+	}
+}

src/Peridot.Veldrid/TextRenderer.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using System.Drawing;
-using System.Numerics;
-using Veldrid;
-
-namespace Peridot.Veldrid
-{
-    /// <inheritdoc/>
-    public class TextRenderer : ITextRenderer<Font>
-    {
-        private readonly VeldridSpriteBatch _sb;
-        private readonly FontStashRenderer _textRenderer;
-
-        /// <summary>
-        /// Creates a new instance of <see cref="TextRenderer"/>.
-        /// </summary>
-        /// <param name="gd"></param>
-        /// <param name="spriteBatch"></param>
-        public TextRenderer(GraphicsDevice gd, VeldridSpriteBatch spriteBatch)
-        {
-            _sb = spriteBatch;
-            _textRenderer = new(gd, _sb);
-        }
-
-        /// <inheritdoc/>
-        ~TextRenderer()
-        {
-            Dispose(false);
-        }
-
-        /// <inheritdoc/>
-        public bool IsDisposed { get; private set; }
-
-        /// <inheritdoc/>
-        public void Dispose()
-        {
-            GC.SuppressFinalize(this);
-            Dispose(true);
-        }
-
-        private void Dispose(bool disposing)
-        {
-            if (IsDisposed)
-                return;
-            IsDisposed = true;
-
-            if (disposing)
-            {
-
-            }
-        }
-
-        /// <inheritdoc/>
-        public void DrawString(IFont font, int fontSize, string text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, float layerDepth)
-        {
-            DrawString(Cast(font), fontSize, text, position, color, rotation, origin, scale, layerDepth);
-        }
-
-        /// <inheritdoc/>
-        public void DrawString(IFont font, int fontSize, string text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, float layerDepth, Rectangle scissor)
-        {
-            DrawString(Cast(font), fontSize, text, position, color, rotation, origin, scale, layerDepth, scissor);
-        }
-
-        /// <inheritdoc/>
-        public void DrawString(Font font, int fontSize, string text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, float layerDepth)
-        {
-            var rf = font.FontSystem.GetFont(fontSize);
-            rf.DrawText(_textRenderer, text, position, color, scale, rotation, origin, layerDepth);
-        }
-
-        /// <inheritdoc/>
-        public void DrawString(Font font, int fontSize, string text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, float layerDepth, Rectangle scissor)
-        {
-            var rf = font.FontSystem.GetFont(fontSize);
-            _textRenderer.Scissor = scissor;
-            rf.DrawText(_textRenderer, text, position, color, scale, rotation, origin, layerDepth);
-            _textRenderer.ResetScissor();
-        }
-
-        private static Font Cast(IFont font)
-        {
-            if (font is not Font f)
-                throw new InvalidCastException($"The {font} is not supported by this implementation.");
-            return f;
-        }
-    }
-}

src/Peridot.Veldrid/Texture2DManager.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using FontStashSharp.Interfaces;
-using System.Drawing;
-using Veldrid;
-
-namespace Peridot.Veldrid
-{
-    internal class Texture2DManager : ITexture2DManager, IDisposable
-    {
-        private readonly GraphicsDevice _gd;
-        private readonly List<WeakReference<Texture>> _textures;
-        private bool _disposed;
-        public Texture2DManager(GraphicsDevice gd)
-        {
-            _gd = gd;
-            _textures = new();
-        }
-
-        ~Texture2DManager()
-        {
-            Dispose(false);
-        }
-
-        public object CreateTexture(int width, int height)
-        {
-            var texture = _gd.ResourceFactory.CreateTexture(
-                new(
-                    (uint)width, (uint)height, 1,
-                    1, 1,
-                    PixelFormat.B8_G8_R8_A8_UNorm,
-                    TextureUsage.Sampled,
-                    TextureType.Texture2D));
-
-            _textures.Add(new(texture));
-            return texture;
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
-        private void Dispose(bool disposing)
-        {
-            if (_disposed)
-                return;
-            _disposed = true;
-
-            if (disposing)
-            {
-                foreach (var wt in _textures)
-                    if (wt.TryGetTarget(out var texture))
-                        texture.Dispose();
-            }
-        }
-
-        public Point GetTextureSize(object texture)
-        {
-            var t = texture as Texture;
-            if (t is null)
-                return Point.Empty;
-
-            return new((int)t.Width, (int)t.Height);
-        }
-
-        public void SetTextureData(object texture, Rectangle bounds, byte[] data)
-        {
-            if (texture is not Texture t)
-                return;
-
-            _gd.UpdateTexture(t, data, (uint)bounds.X, (uint)bounds.Y, 0, (uint)bounds.Width, (uint)bounds.Height, 1, 0, 0);
-        }
-    }
-}

src/Peridot.Veldrid/TextureWrapper.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using System.Diagnostics.CodeAnalysis;
-using System.Drawing;
-using Veldrid;
-
-namespace Peridot.Veldrid;
-
-/// <summary>
-/// A wrapper with <see cref="ITexture2D"/> interface.
-/// </summary>
-public class TextureWrapper : ITexture2D, IEquatable<TextureWrapper>
-{
-    /// <summary>
-    /// Creates a new instance of <see cref="TextureWrapper"/>.
-    /// </summary>
-    /// <param name="texture">The texture.</param>
-    /// <exception cref="ArgumentNullException"></exception>
-    public TextureWrapper(Texture texture)
-    {
-        Texture = texture ?? throw new ArgumentNullException(nameof(texture));
-    }
-
-    /// <summary>
-    /// Texture
-    /// </summary>
-    public Texture Texture { get; }
-
-    /// <summary>
-    /// Size of texture
-    /// </summary>
-    public Size Size => new((int)Texture.Width, (int)Texture.Height);
-
-    /// <inheritdoc/>
-    public bool IsDisposed => Texture.IsDisposed;
-
-    /// <inheritdoc/>
-    public override int GetHashCode() => Texture.GetHashCode();
-
-    /// <inheritdoc/>
-    public bool Equals(TextureWrapper? other) => Texture == other?.Texture;
-
-    /// <inheritdoc/>
-    public override bool Equals([NotNullWhen(true)] object? obj) =>
-        obj is TextureWrapper tw && Equals(tw);
-
-    /// <inheritdoc/>
-    public override string? ToString() => Texture.ToString();
-
-    /// <inheritdoc/>
-    public void Dispose()
-    {
-        Texture.Dispose();
-        GC.SuppressFinalize(this);
-    }
-
-    public static implicit operator TextureWrapper(Texture t) => new(t);
-
-    public static implicit operator Texture(TextureWrapper t) => t.Texture;
-    
-    public static bool operator ==(TextureWrapper left, TextureWrapper right) => left.Equals(right);
-
-    public static bool operator !=(TextureWrapper left, TextureWrapper right) => !(left == right);
-}

src/Peridot.Veldrid/VImage.cs

···
+// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
+// This code is licensed under MIT license (see LICENSE for details)
+
+using System.Diagnostics.CodeAnalysis;
+using System.Drawing;
+using Veldrid;
+
+namespace Peridot;
+
+/// <summary>
+/// A wrapper with <see cref="VImage"/> interface.
+/// </summary>
+internal class VImage : Image, IEquatable<VImage>
+{
+	/// <summary>
+	/// Creates a new instance of <see cref="VImage"/>.
+	/// </summary>
+	/// <param name="texture">The texture.</param>
+	/// <exception cref="ArgumentNullException"></exception>
+	public VImage(Texture texture)
+	{
+		Texture = texture ?? throw new ArgumentNullException(nameof(texture));
+	}
+
+	/// <summary>
+	/// Texture
+	/// </summary>
+	public Texture Texture { get; }
+
+	/// <summary>
+	/// Size of texture
+	/// </summary>
+	public Size Size => new((int)Texture.Width, (int)Texture.Height);
+
+	/// <inheritdoc/>
+	public bool IsDisposed => Texture.IsDisposed;
+
+	/// <inheritdoc/>
+	public PixelFormat Format => Texture.Format switch 
+	{
+		Veldrid.PixelFormat.R8_UNorm => PixelFormat.R8,
+		Veldrid.PixelFormat.R16_UNorm => PixelFormat.R16,
+		Veldrid.PixelFormat.B8_G8_R8_A8_UNorm => PixelFormat.BGRA8,
+		Veldrid.PixelFormat.R32_G32_B32_A32_Float => PixelFormat.RGBAF32,
+		Veldrid.PixelFormat.R8_G8_UNorm => PixelFormat.RG8,
+		Veldrid.PixelFormat.R16_G16_UNorm => PixelFormat.RG16,
+		Veldrid.PixelFormat.R32_G32_B32_A32_SInt => PixelFormat.RGBAI32,
+		Veldrid.PixelFormat.R8_G8_B8_A8_UNorm => PixelFormat.RGBA8,
+		_ => PixelFormat.Undefined
+	};
+
+	/// <inheritdoc/>
+	public override int GetHashCode() => Texture.GetHashCode();
+
+	/// <inheritdoc/>
+	public bool Equals(VImage? other) => Texture == other?.Texture;
+
+	/// <inheritdoc/>
+	public override bool Equals([NotNullWhen(true)] object? obj) =>
+		obj is VImage tw && Equals(tw);
+
+	/// <inheritdoc/>
+	public override string? ToString() => Texture.ToString();
+
+	/// <inheritdoc/>
+	public void Dispose()
+	{
+		Texture.Dispose();
+		GC.SuppressFinalize(this);
+	}
+
+	public static implicit operator VImage(Texture t) => new(t);
+
+	public static implicit operator Texture(VImage t) => t.Texture;
+	
+	public static bool operator ==(VImage left, VImage right) => left.Equals(right);
+
+	public static bool operator !=(VImage left, VImage right) => !(left == right);
+}

src/Peridot.Veldrid/VPeridot.cs

···
+using System.Diagnostics;
+using System.Text;
+using Veldrid;
+using Veldrid.SPIRV;
+using VPF = Veldrid.PixelFormat;
+namespace Peridot;
+
+public class VPeridot : IPeridot<Texture, SpriteBatchDescriptor>
+{
+	private readonly GraphicsDevice m_gd;
+	private readonly Image m_whiteImage;
+	public VPeridot(GraphicsDevice gd)
+	{
+		m_gd = gd;
+		m_whiteImage = CreateImage(new ImageDescription()
+		{
+			Format = PixelFormat.BGRA8,
+			Width = 1,
+			Height = 1,
+		});
+
+		UpdateImage<byte>(m_whiteImage, new byte[] { 255, 255, 255, 255 }, 0, 0, 1, 1);
+	}
+
+	internal GraphicsDevice GraphicsDevice => m_gd;
+
+	/// <inheritdoc/>
+	public Image CreateImage(ImageDescription description)
+	{
+		var pf = description.Format switch
+		{
+			PixelFormat.R8 => VPF.R8_UNorm,
+			PixelFormat.R16 => VPF.R16_UNorm,
+			PixelFormat.BGRA8 => VPF.B8_G8_R8_A8_UNorm,
+			PixelFormat.RGBAF32 => VPF.R32_G32_B32_A32_Float,
+			PixelFormat.RG8 => VPF.R8_G8_UNorm,
+			PixelFormat.RG16 => VPF.R16_G16_UNorm,
+			PixelFormat.RGBAI32 => VPF.R8_G8_B8_A8_SInt,
+			PixelFormat.RGBA8 => VPF.R8_G8_B8_A8_UNorm,
+			_ => throw new ArgumentOutOfRangeException(nameof(description.Format))
+		};
+		TextureDescription desc = new(description.Width, description.Height, 1, 1, 1, pf, TextureUsage.Sampled, TextureType.Texture2D);
+		return new VImage(m_gd.ResourceFactory.CreateTexture(desc));
+	}
+
+	/// <inheritdoc/>
+	public void UpdateImage<T>(Image image, ReadOnlySpan<T> source, uint x, uint y, uint width, uint height) where T : unmanaged
+	{
+		Debug.Assert(image is VImage);
+		if (image is not VImage vimage)
+			throw new ArgumentOutOfRangeException(nameof(image));
+
+		unsafe
+		{
+			uint size = (uint)source.Length * (uint)sizeof(T);
+			fixed (T* ptr = source)
+			{
+				m_gd.UpdateTexture(vimage, (IntPtr)ptr, size, x, y, 0, width, height, 1, 0, 0);
+			}
+		}
+	}
+
+	/// <inheritdoc/>
+	public ISpriteBatch<Texture> CreateSpriteBatch(SpriteBatchDescriptor descriptor)
+	{
+		var s = descriptor.Sampler ?? GraphicsDevice.LinearSampler;
+		var bs = descriptor.BlendState ?? BlendStateDescription.SingleAlphaBlend;
+		var ds = descriptor.DepthStencil ?? new(
+			depthTestEnabled: true,
+			depthWriteEnabled: true,
+			comparisonKind: ComparisonKind.GreaterEqual);
+
+		return new VSpriteBatch(
+			this,
+			m_whiteImage,
+			descriptor.OutputDescription,
+			descriptor.Shaders,
+			s,
+			descriptor.CullMode,
+			bs,
+			ds);
+	}
+
+	/// <summary>
+	/// Loads default shaders for <see cref="ISpriteBatch"/>.
+	/// </summary>
+	/// <returns>Shaders for use in <see cref="ISpriteBatch"/>.</returns>
+	public Shader[] LoadDefaultShaders()
+	{
+
+		var vertexShaderDesc = new ShaderDescription(
+			ShaderStages.Vertex,
+			Encoding.UTF8.GetBytes(Resource.shader_vert),
+			"main");
+
+		var fragmentShaderDesc = new ShaderDescription(
+			ShaderStages.Fragment,
+			Encoding.UTF8.GetBytes(Resource.shader_frag),
+			"main");
+
+		return GraphicsDevice.ResourceFactory.CreateFromSpirv(vertexShaderDesc, fragmentShaderDesc);
+	}
+
+	ISpriteBatch IPeridot<SpriteBatchDescriptor>.CreateSpriteBatch(SpriteBatchDescriptor description)
+	{
+		return CreateSpriteBatch(description);
+	}
+}

src/Peridot.Veldrid/VSpriteBatch.cs

···
+// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
+// This code is licensed under MIT license (see LICENSE for details)
+
+using Ez.Memory;
+using System.Drawing;
+using System.Numerics;
+
+using Veldrid;
+
+namespace Peridot
+{
+	/// <inheritdoc/>
+	internal class VSpriteBatch : SpriteBatch<Texture>
+	{
+		private readonly GraphicsDevice m_device;
+		private readonly DeviceBuffer m_vertexBuffer;
+		private readonly Sampler m_sampler;
+		private Pipeline m_pipeline;
+		private readonly ResourceLayout[] m_resourceLayouts;
+		private Dictionary<Texture, (DeviceBuffer buffer, ResourceSet set, ResourceSet textureSet)> m_buffers;
+
+		internal VSpriteBatch(
+			VPeridot peridot,
+			Image whiteImage,
+			OutputDescription outputDescription,
+			Shader[] shaders,
+			Sampler sampler,
+			FaceCullMode cullMode,
+			BlendStateDescription blendState,
+			DepthStencilStateDescription depthStencil) : base(whiteImage)
+		{
+			m_device = peridot.GraphicsDevice;
+			m_sampler = sampler ?? m_device.LinearSampler;
+			m_vertexBuffer = CreateVertexBuffer(m_device);
+			m_resourceLayouts = CreateResourceLayouts(m_device);
+			m_buffers = new();
+
+			var bs = blendState;
+			var ds = depthStencil;
+			m_pipeline = CreatePipeline(m_device, outputDescription, cullMode, bs, ds, shaders, m_resourceLayouts);
+		}
+
+		/// <summary>
+		/// Draw this branch into a <see cref="CommandList"/>.
+		/// Call this after calling <see cref="SpriteBatch{TTexture}.End"/>
+		/// </summary>
+		/// <param name="commandList"></param>
+		public void DrawBatch(CommandList commandList)
+		{
+			var matrixSize = (int)MemUtil.SizeOf<Matrix4x4>();
+			commandList.SetPipeline(m_pipeline);
+			foreach (var item in m_batcher)
+			{
+				var texture = item.Key;
+				var group = item.Value;
+
+				var pair = GetBuffer(texture, group.Count + matrixSize);
+				var mapped = m_device.Map(pair.buffer, MapMode.Write);
+
+				MemUtil.Set(mapped.Data, ViewMatrix, 1);
+				MemUtil.Copy(mapped.Data + matrixSize, group.GetSpan());
+
+				m_device.Unmap(pair.buffer);
+
+				commandList.SetVertexBuffer(0, m_vertexBuffer);
+				commandList.SetGraphicsResourceSet(0, pair.set);
+				commandList.SetGraphicsResourceSet(1, pair.textureSet);
+				commandList.Draw(4, (uint)group.Count, 0, 0);
+			}
+		}
+
+		internal (DeviceBuffer buffer, ResourceSet set, ResourceSet textureSet) GetBuffer(Texture t, int count)
+		{
+			var texture = t as Texture;
+			var structSize = MemUtil.SizeOf<BatchItem>();
+			var size = ((count + 63) & (~63)) * structSize;
+			var bci = new BufferDescription((uint)size, BufferUsage.StructuredBufferReadOnly | BufferUsage.Dynamic, structSize);
+
+			if (!m_buffers.TryGetValue(texture, out var pair))
+			{
+				pair.buffer = m_device.ResourceFactory.CreateBuffer(bci);
+				pair.set = m_device.ResourceFactory.CreateResourceSet(new ResourceSetDescription(m_resourceLayouts[0], pair.buffer));
+				pair.textureSet = m_device.ResourceFactory.CreateResourceSet(new ResourceSetDescription(m_resourceLayouts[1], texture, m_sampler));
+				m_buffers[texture] = pair;
+			}
+			else if (size > pair.buffer.SizeInBytes)
+			{
+				pair.set.Dispose();
+				pair.buffer.Dispose();
+
+				pair.buffer = m_device.ResourceFactory.CreateBuffer(bci);
+				pair.set = m_device.ResourceFactory.CreateResourceSet(new ResourceSetDescription(m_resourceLayouts[0], pair.buffer));
+				pair.textureSet = m_device.ResourceFactory.CreateResourceSet(new ResourceSetDescription(m_resourceLayouts[1], texture, m_sampler));
+				m_buffers[texture] = pair;
+			}
+
+			return pair;
+		}
+
+		/// <inheritdoc/>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing)
+			{
+				m_vertexBuffer.Dispose();
+			}
+		}
+
+		private static DeviceBuffer CreateVertexBuffer(GraphicsDevice device)
+		{
+			var bd = new BufferDescription()
+			{
+				SizeInBytes = 4 * MemUtil.SizeOf<Vector2>(),
+				Usage = BufferUsage.VertexBuffer,
+			};
+
+			var buffer = device.ResourceFactory.CreateBuffer(bd);
+
+			var vertices = new Vector2[]
+			{
+				new( 0,  0),
+				new( 1,  0),
+				new( 0,  1),
+				new( 1,  1)
+			};
+
+			device.UpdateBuffer(buffer, 0, vertices);
+
+			return buffer;
+		}
+
+		private static ResourceLayout[] CreateResourceLayouts(GraphicsDevice device)
+		{
+			var layouts = new ResourceLayout[2];
+
+			var elements = new ResourceLayoutElementDescription[]
+			{
+				new("Items", ResourceKind.StructuredBufferReadOnly, ShaderStages.Vertex),
+			};
+			var rld = new ResourceLayoutDescription(elements);
+
+			layouts[0] = device.ResourceFactory.CreateResourceLayout(rld);
+
+			elements = new ResourceLayoutElementDescription[]
+			{
+				new("Tex", ResourceKind.TextureReadOnly, ShaderStages.Fragment),
+				new("Sampler", ResourceKind.Sampler, ShaderStages.Fragment)
+			};
+			rld = new ResourceLayoutDescription(elements);
+
+			layouts[1] = device.ResourceFactory.CreateResourceLayout(rld);
+			return layouts;
+		}
+
+		private static Pipeline CreatePipeline(GraphicsDevice device,
+			OutputDescription outputDescription,
+			FaceCullMode cullMode,
+			BlendStateDescription blendState,
+			DepthStencilStateDescription depthStencil,
+			Shader[] shaders,
+			params ResourceLayout[] layouts)
+		{
+			var vertexLayout = new VertexLayoutDescription(
+				new VertexElementDescription("Position", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float2));
+
+			var pipelineDescription = new GraphicsPipelineDescription
+			{
+				BlendState = blendState,
+				DepthStencilState = depthStencil,
+				RasterizerState = new(
+					cullMode: cullMode,
+					fillMode: PolygonFillMode.Solid,
+					frontFace: FrontFace.Clockwise,
+					depthClipEnabled: true,
+					scissorTestEnabled: false),
+				PrimitiveTopology = PrimitiveTopology.TriangleStrip,
+				ResourceLayouts = layouts,
+				ShaderSet = new(
+					vertexLayouts: new[] { vertexLayout },
+					shaders: shaders,
+					specializations: new[] { new SpecializationConstant(0, device.IsClipSpaceYInverted) }),
+				Outputs = outputDescription,
+			};
+
+			return device.ResourceFactory.CreateGraphicsPipeline(pipelineDescription);
+		}
+
+		protected override Size GetSize(Texture image)
+		{
+			return new((int)image.Width, (int)image.Height);
+		}
+		
+		protected override Texture GetHandle(Image image)
+		{
+			if (image is not VImage vimage)
+				throw new InvalidCastException($"The {image} is not supported by this implementation.");
+			return vimage.Texture;
+		}
+	}
+}

src/Peridot.Veldrid/VeldridSpriteBatch.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using Ez.Memory;
-
-using System.Numerics;
-using System.Text;
-
-using Veldrid;
-using Veldrid.SPIRV;
-
-namespace Peridot.Veldrid
-{
-    /// <inheritdoc/>
-    public class VeldridSpriteBatch : SpriteBatch<TextureWrapper>
-    {
-        private readonly GraphicsDevice _device;
-        private readonly DeviceBuffer _vertexBuffer;
-        private readonly Sampler _sampler;
-        private Pipeline _pipeline;
-        private readonly ResourceLayout[] _resourceLayouts;
-        private Dictionary<Texture, (DeviceBuffer buffer, ResourceSet set, ResourceSet textureSet)> _buffers;
-
-        /// <summary>
-        /// Creates a new instance of <see cref="VeldridSpriteBatch"/>.
-        /// </summary>
-        /// <param name="device">The graphics device to create resources.</param>
-        /// <param name="outputDescription">The output description of target framebuffer.</param>
-        /// <param name="shaders">The shaders to use to render. Uses <seealso cref="LoadDefaultShaders(GraphicsDevice)"/> for default.</param>
-        /// <param name="sampler">The samppler used to sample.</param>
-        /// <param name="cullMode">Controls which face will be culled. By default the sprite are rendered with forward normal, negatives scales can flips that normal.</param>
-        /// <param name="blendState">The blend state description for creating the pipeline.</param>
-        /// <param name="depthStencil">The depth stencil state description for creating the pipeline.</param>
-        public VeldridSpriteBatch(GraphicsDevice device,
-            OutputDescription outputDescription,
-            Shader[] shaders,
-            Sampler? sampler = null,
-            FaceCullMode cullMode = FaceCullMode.None,
-            BlendStateDescription? blendState = null,
-            DepthStencilStateDescription? depthStencil = null) : base()
-        {
-            _sampler = sampler ?? device.LinearSampler;
-            _device = device;
-            _vertexBuffer = CreateVertexBuffer(device);
-            _resourceLayouts = CreateResourceLayouts(device);
-            _buffers = new();
-
-            var bs = blendState ?? BlendStateDescription.SingleAlphaBlend;
-            var ds = depthStencil ?? new(
-                depthTestEnabled: true,
-                depthWriteEnabled: true,
-                comparisonKind: ComparisonKind.GreaterEqual);
-            _pipeline = CreatePipeline(device, outputDescription, cullMode, bs, ds, shaders, _resourceLayouts);
-        }
-
-        /// <summary>
-        /// Draw this branch into a <see cref="CommandList"/>.
-        /// Call this after calling <see cref="SpriteBatch{TTexture}.End"/>
-        /// </summary>
-        /// <param name="commandList"></param>
-        public void DrawBatch(CommandList commandList)
-        {
-            var matrixSize = (int)MemUtil.SizeOf<Matrix4x4>();
-            commandList.SetPipeline(_pipeline);
-            foreach (var item in _batcher)
-            {
-                var texture = item.Key;
-                var group = item.Value;
-
-                var pair = GetBuffer(texture, group.Count + matrixSize);
-                var mapped = _device.Map(pair.buffer, MapMode.Write);
-
-                MemUtil.Set(mapped.Data, ViewMatrix, 1);
-                MemUtil.Copy(mapped.Data + matrixSize, group.GetSpan());
-
-                _device.Unmap(pair.buffer);
-
-                commandList.SetVertexBuffer(0, _vertexBuffer);
-                commandList.SetGraphicsResourceSet(0, pair.set);
-                commandList.SetGraphicsResourceSet(1, pair.textureSet);
-                commandList.Draw(4, (uint)group.Count, 0, 0);
-            }
-        }
-
-        internal (DeviceBuffer buffer, ResourceSet set, ResourceSet textureSet) GetBuffer(Texture t, int count)
-        {
-            var texture = t as Texture;
-            var structSize = MemUtil.SizeOf<BatchItem>();
-            var size = ((count + 63) & (~63)) * structSize;
-            var bci = new BufferDescription((uint)size, BufferUsage.StructuredBufferReadOnly | BufferUsage.Dynamic, structSize);
-
-            if (!_buffers.TryGetValue(texture, out var pair))
-            {
-                pair.buffer = _device.ResourceFactory.CreateBuffer(bci);
-                pair.set = _device.ResourceFactory.CreateResourceSet(new ResourceSetDescription(_resourceLayouts[0], pair.buffer));
-                pair.textureSet = _device.ResourceFactory.CreateResourceSet(new ResourceSetDescription(_resourceLayouts[1], texture, _sampler));
-                _buffers[texture] = pair;
-            }
-            else if (size > pair.buffer.SizeInBytes)
-            {
-                pair.set.Dispose();
-                pair.buffer.Dispose();
-
-                pair.buffer = _device.ResourceFactory.CreateBuffer(bci);
-                pair.set = _device.ResourceFactory.CreateResourceSet(new ResourceSetDescription(_resourceLayouts[0], pair.buffer));
-                pair.textureSet = _device.ResourceFactory.CreateResourceSet(new ResourceSetDescription(_resourceLayouts[1], texture, _sampler));
-                _buffers[texture] = pair;
-            }
-
-            return pair;
-        }
-
-        /// <inheritdoc/>
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                _vertexBuffer.Dispose();
-            }
-        }
-
-        private static DeviceBuffer CreateVertexBuffer(GraphicsDevice device)
-        {
-            var bd = new BufferDescription()
-            {
-                SizeInBytes = 4 * MemUtil.SizeOf<Vector2>(),
-                Usage = BufferUsage.VertexBuffer,
-            };
-
-            var buffer = device.ResourceFactory.CreateBuffer(bd);
-
-            var vertices = new Vector2[]
-            {
-                new( 0,  0),
-                new( 1,  0),
-                new( 0,  1),
-                new( 1,  1)
-            };
-
-            device.UpdateBuffer(buffer, 0, vertices);
-
-            return buffer;
-        }
-
-        private static ResourceLayout[] CreateResourceLayouts(GraphicsDevice device)
-        {
-            var layouts = new ResourceLayout[2];
-
-            var elements = new ResourceLayoutElementDescription[]
-            {
-                new("Items", ResourceKind.StructuredBufferReadOnly, ShaderStages.Vertex),
-            };
-            var rld = new ResourceLayoutDescription(elements);
-
-            layouts[0] = device.ResourceFactory.CreateResourceLayout(rld);
-
-            elements = new ResourceLayoutElementDescription[]
-            {
-                new("Tex", ResourceKind.TextureReadOnly, ShaderStages.Fragment),
-                new("Sampler", ResourceKind.Sampler, ShaderStages.Fragment)
-            };
-            rld = new ResourceLayoutDescription(elements);
-
-            layouts[1] = device.ResourceFactory.CreateResourceLayout(rld);
-            return layouts;
-        }
-
-        private static Pipeline CreatePipeline(GraphicsDevice device,
-            OutputDescription outputDescription,
-            FaceCullMode cullMode,
-            BlendStateDescription blendState,
-            DepthStencilStateDescription depthStencil,
-            Shader[] shaders,
-            params ResourceLayout[] layouts)
-        {
-            var vertexLayout = new VertexLayoutDescription(
-                new VertexElementDescription("Position", VertexElementSemantic.TextureCoordinate, VertexElementFormat.Float2));
-
-            var pipelineDescription = new GraphicsPipelineDescription
-            {
-                BlendState = blendState,
-                DepthStencilState = depthStencil,
-                RasterizerState = new(
-                    cullMode: cullMode,
-                    fillMode: PolygonFillMode.Solid,
-                    frontFace: FrontFace.Clockwise,
-                    depthClipEnabled: true,
-                    scissorTestEnabled: false),
-                PrimitiveTopology = PrimitiveTopology.TriangleStrip,
-                ResourceLayouts = layouts,
-                ShaderSet = new(
-                    vertexLayouts: new[] { vertexLayout },
-                    shaders: shaders,
-                    specializations: new[] { new SpecializationConstant(0, device.IsClipSpaceYInverted) }),
-                Outputs = outputDescription,
-            };
-
-            return device.ResourceFactory.CreateGraphicsPipeline(pipelineDescription);
-        }
-
-        /// <summary>
-        /// Loads default shaders for <see cref="VeldridSpriteBatch"/>.
-        /// </summary>
-        /// <param name="graphicsDevice">The graphics device.</param>
-        /// <returns>Shaders for use in <see cref="VeldridSpriteBatch"/>.</returns>
-        public static Shader[] LoadDefaultShaders(GraphicsDevice graphicsDevice)
-        {
-
-            var vertexShaderDesc = new ShaderDescription(
-                ShaderStages.Vertex,
-                Encoding.UTF8.GetBytes(Resource.shader_vert),
-                "main");
-
-            var fragmentShaderDesc = new ShaderDescription(
-                ShaderStages.Fragment,
-                Encoding.UTF8.GetBytes(Resource.shader_frag),
-                "main");
-
-            return graphicsDevice.ResourceFactory.CreateFromSpirv(vertexShaderDesc, fragmentShaderDesc);
-        }
-    }
-}

src/Peridot/BatchGroup.cs

···
 // Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
 // This code is licensed under MIT license (see LICENSE for details)
 
-namespace Peridot
+namespace Peridot;
+
+public class BatchGroup
 {
-    public class BatchGroup
-    {
-        private BatchItem[] _items;
+	private BatchItem[] _items;
 
-        public BatchGroup()
-        {
-            _items = new BatchItem[64];
-        }
-        public int Count { get; private set; }
+	public BatchGroup()
+	{
+		_items = new BatchItem[64];
+	}
+	public int Count { get; private set; }
 
-        public ref BatchItem Add()
-        {
-            if (Count >= _items.Length)
-            {
-                var lastSize = _items.Length;
-                var newSize = (lastSize + lastSize / 2 + 63) & (~63);
-                Array.Resize(ref _items, newSize);
-            }
+	public ref BatchItem Add()
+	{
+		if (Count >= _items.Length)
+		{
+			var lastSize = _items.Length;
+			var newSize = (lastSize + lastSize / 2 + 63) & (~63);
+			Array.Resize(ref _items, newSize);
+		}
 
-            return ref _items[Count++];
-        }
+		return ref _items[Count++];
+	}
 
-        public void Clear()
-        {
-            Count = 0;
-        }
+	public void Clear()
+	{
+		Count = 0;
+	}
 
-        public ReadOnlySpan<BatchItem> GetSpan() => new ReadOnlySpan<BatchItem>(_items, 0, Count);
+	public ReadOnlySpan<BatchItem> GetSpan() => new ReadOnlySpan<BatchItem>(_items, 0, Count);
 
-        public Enumerator GetEnumerator() => new(_items, Count);
+	public Enumerator GetEnumerator() => new(_items, Count);
 
-        public struct Enumerator
-        {
-            private readonly BatchItem[] _items;
-            private readonly int _count;
-            private int _index;
+	public struct Enumerator
+	{
+		private readonly BatchItem[] _items;
+		private readonly int _count;
+		private int _index;
 
-            internal Enumerator(BatchItem[] items, int count)
-            {
-                _items = items;
-                _count = count;
-                _index = -1;
-            }
+		internal Enumerator(BatchItem[] items, int count)
+		{
+			_items = items;
+			_count = count;
+			_index = -1;
+		}
 
-            public BatchItem Current => _items[_index];
+		public BatchItem Current => _items[_index];
 
-            public bool MoveNext()
-            {
-                if (_index >= _count)
-                    return false;
-                _index++;
-                return true;
-            }
+		public bool MoveNext()
+		{
+			if (_index >= _count)
+				return false;
+			_index++;
+			return true;
+		}
 
-            public void Reset()
-            {
-                _index = -1;
-            }
-        }
-    }
+		public void Reset()
+		{
+			_index = -1;
+		}
+	}
 }

src/Peridot/BatchItem.cs

···
 using System.Drawing;
 using System.Numerics;
 
-namespace Peridot
+namespace Peridot;
+
+public struct BatchItem
 {
-    public struct BatchItem
+    public BatchItem(Vector2 textureSize, RectangleF destinationRectangle, RectangleF sourceRectangle, Color color,
+                     float rotation, Vector2 origin, float layerDepth, RectangleF scissor, SpriteOptions options)
     {
-        public BatchItem(Vector2 textureSize, RectangleF destinationRectangle, RectangleF sourceRectangle, Color color,
-                         float rotation, Vector2 origin, float layerDepth, RectangleF scissor, SpriteOptions options)
-        {
-            var sourceSize = new Vector2(sourceRectangle.Width, sourceRectangle.Height) / textureSize;
-            var pos = new Vector2(sourceRectangle.X, sourceRectangle.Y) / textureSize;
+        var sourceSize = new Vector2(sourceRectangle.Width, sourceRectangle.Height) / textureSize;
+        var pos = new Vector2(sourceRectangle.X, sourceRectangle.Y) / textureSize;
 
-            UV = CreateUV(options, sourceSize, pos);
-            Color = ToVector(color);
-            Scale = destinationRectangle.Size.ToVector2();
-            Origin = origin;
-            Location = new(destinationRectangle.Location.ToVector2(), layerDepth);
-            Rotation = rotation;
-            Scissor = scissor;
-        }
+        UV = CreateUV(options, sourceSize, pos);
+        Color = ToVector(color);
+        Scale = destinationRectangle.Size.ToVector2();
+        Origin = origin;
+        Location = new(destinationRectangle.Location.ToVector2(), layerDepth);
+        Rotation = rotation;
+        Scissor = scissor;
+    }
 
-        public BatchItem(Vector2 textureSize, Vector2 position, RectangleF sourceRectangle, Color color, float rotation,
-                         Vector2 origin, Vector2 scale, float layerDepth, RectangleF scissor, SpriteOptions options) 
-            : this(textureSize, new RectangleF(position.X, position.Y, sourceRectangle.Width * scale.X, sourceRectangle.Height * scale.Y), 
-                    sourceRectangle, 
-                    color, 
-                    rotation,
-                    origin, 
-                    layerDepth,
-                    scissor, 
-                    options)
-        {
-        }
+    public BatchItem(Vector2 textureSize, Vector2 position, RectangleF sourceRectangle, Color color, float rotation,
+                     Vector2 origin, Vector2 scale, float layerDepth, RectangleF scissor, SpriteOptions options)
+        : this(textureSize, new RectangleF(position.X, position.Y, sourceRectangle.Width * scale.X, sourceRectangle.Height * scale.Y),
+                sourceRectangle,
+                color,
+                rotation,
+                origin,
+                layerDepth,
+                scissor,
+                options)
+    {
+    }
 
-        public Vector4 UV { get; set; }
-        public Vector4 Color { get; set; }
-        public Vector2 Scale { get; set; }
-        public Vector2 Origin { get; set; }
-        public Vector3 Location { get; set; }
-        public float Rotation { get; set; }
-        public RectangleF Scissor { get; set; }
+    public Vector4 UV { get; set; }
+    public Vector4 Color { get; set; }
+    public Vector2 Scale { get; set; }
+    public Vector2 Origin { get; set; }
+    public Vector3 Location { get; set; }
+    public float Rotation { get; set; }
+    public RectangleF Scissor { get; set; }
 
-        private static Vector4 CreateUV(SpriteOptions options, Vector2 sourceSize, Vector2 sourceLocation)
+    private static Vector4 CreateUV(SpriteOptions options, Vector2 sourceSize, Vector2 sourceLocation)
+    {
+        if (options != SpriteOptions.None)
         {
-            if (options != SpriteOptions.None)
+            // flipX
+            if (options.HasFlag(SpriteOptions.FlipHorizontally))
             {
-                // flipX
-                if (options.HasFlag(SpriteOptions.FlipHorizontally))
-                {
-                    sourceLocation.X += sourceSize.X;
-                    sourceSize.X *= -1;
-                }
-
-                // flipY
-                if (options.HasFlag(SpriteOptions.FlipVertically))
-                {
-                    sourceLocation.Y += sourceSize.Y;
-                    sourceSize.Y *= -1;
-                }
+                sourceLocation.X += sourceSize.X;
+                sourceSize.X *= -1;
             }
 
-            return new(sourceLocation.X, sourceLocation.Y, sourceSize.X, sourceSize.Y);
+            // flipY
+            if (options.HasFlag(SpriteOptions.FlipVertically))
+            {
+                sourceLocation.Y += sourceSize.Y;
+                sourceSize.Y *= -1;
+            }
         }
 
-        private static Vector4 ToVector(Color color) => new Vector4(color.R, color.G, color.B, color.A) * (1f / 255f);
+        return new(sourceLocation.X, sourceLocation.Y, sourceSize.X, sourceSize.Y);
+    }
+
+    private static Vector4 ToVector(Color color) => new Vector4(color.R, color.G, color.B, color.A) * (1f / 255f);
 
-        public override string ToString()
-        {
-            return $"uv: {UV}, color: {Color}, scale: {Scale}, origin: {Origin}, location: {new Vector4(Location, Rotation)}, scissor: {Scissor}";
-        }
+    public override string ToString()
+    {
+        return $"uv: {UV}, color: {Color}, scale: {Scale}, origin: {Origin}, location: {new Vector4(Location, Rotation)}, scissor: {Scissor}";
     }
 }

src/Peridot/Batcher.cs

···
 // Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
 // This code is licensed under MIT license (see LICENSE for details)
 
-namespace Peridot
+namespace Peridot;
+
+public class Batcher<TTexture> where TTexture : notnull
 {
-    public class Batcher<TTexture> where TTexture : notnull
+    private Stack<BatchGroup> _batchGroups;
+    private Dictionary<TTexture, BatchGroup> _batchItems;
+
+    public Batcher()
     {
-        private Stack<BatchGroup> _batchGroups;
-        private Dictionary<TTexture, BatchGroup> _batchItems;
+        _batchItems = new();
+        _batchGroups = new();
+    }
 
-        public Batcher()
+    public ref BatchItem Add(TTexture texture)
+    {
+        if (!_batchItems.TryGetValue(texture, out var group))
         {
-            _batchItems = new();
-            _batchGroups = new();
+            group = GetBatchGroup();
+            group.Clear();
+            _batchItems[texture] = group;
         }
 
-        public ref BatchItem Add(TTexture texture)
-        {
-            if(!_batchItems.TryGetValue(texture, out var group))
-            {
-                group = GetBatchGroup();
-                group.Clear();
-                _batchItems[texture] = group;
-            }
+        return ref group.Add();
+    }
 
-            return ref group.Add();
-        }
+    public void Clear()
+    {
+        foreach (var group in this)
+            ReturnBatchGroup(group.Value);
+        _batchItems.Clear();
+    }
 
-        public void Clear()
-        {
-            foreach (var group in this)
-                ReturnBatchGroup(group.Value);
-            _batchItems.Clear();
-        }
+    public Dictionary<TTexture, BatchGroup>.Enumerator GetEnumerator() =>
+        _batchItems.GetEnumerator();
 
-        public Dictionary<TTexture, BatchGroup>.Enumerator GetEnumerator() =>
-            _batchItems.GetEnumerator();
-
-        private BatchGroup GetBatchGroup()
-        {
-            if (!_batchGroups.TryPop(out var group))
-                group = new();
-            return group;
-        }
-
-        private void ReturnBatchGroup(BatchGroup group) => _batchGroups.Push(group);
+    private BatchGroup GetBatchGroup()
+    {
+        if (!_batchGroups.TryPop(out var group))
+            group = new();
+        return group;
     }
+
+    private void ReturnBatchGroup(BatchGroup group) => _batchGroups.Push(group);
 }

src/Peridot/ColorB.Static.cs

···
+using System.Runtime.CompilerServices;
+
+namespace Peridot;
+
+/// <summary>
+/// Provides static methods to <see cref="ColorB"/> manipulation.
+/// </summary>
+public partial struct ColorB
+{
+    #region Math
+    /// <summary>
+    /// Negates the specified color.
+    /// </summary>
+    /// <param name="color">The color to negate.</param>
+    /// <returns>The negated vector.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Negate(ColorB color)
+    {
+        var r = -color.R;
+        var g = -color.G;
+        var b = -color.B;
+        var a = -color.A;
+
+        return new((byte)r, (byte)g, (byte)b, (byte)a);
+    }
+
+    /// <summary>
+    /// Adds two colors together.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The summed color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Add(ColorB left, ColorB right)
+    {
+        var r = left.R + right.R;
+        var g = left.G + right.G;
+        var b = left.B + right.B;
+        var a = left.A + right.A;
+
+        return new((byte)r, (byte)g, (byte)b, (byte)a);
+    }
+
+    /// <summary>
+    /// Subtracts the second color from the first.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The color that results from subracting <paramref name="right"/> from <paramref name="left"/>.</returns>
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Subtract(ColorB left, ColorB right)
+    {
+        var r = left.R - right.R;
+        var g = left.G - right.G;
+        var b = left.B - right.B;
+        var a = left.A - right.A;
+
+        return new((byte)r, (byte)g, (byte)b, (byte)a);
+    }
+
+    /// <summary>
+    /// Multiplies two colors together.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The product color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Multiply(ColorB left, ColorB right)
+    {
+        var r = left.R * right.R;
+        var g = left.G * right.G;
+        var b = left.B * right.B;
+        var a = left.A * right.A;
+
+        return new((byte)r, (byte)g, (byte)b, (byte)a);
+    }
+
+    /// <summary>
+    /// Divides the first color by the second.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The color that results from dividing <paramref name="left"/> by <paramref name="right"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Divide(ColorB left, ColorB right)
+    {
+        var r = left.R / right.R;
+        var g = left.G / right.G;
+        var b = left.B / right.B;
+        var a = left.A / right.A;
+
+        return new((byte)r, (byte)g, (byte)b, (byte)a);
+    }
+
+    /// <summary>
+    /// Multiples the specified color by the specified scalar value.
+    /// </summary>
+    /// <param name="left">The color.</param>
+    /// <param name="right">The scalar value.</param>
+    /// <returns>The scaled color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Multiply(ColorB left, float right)
+    {
+        var r = left.R * right;
+        var g = left.G * right;
+        var b = left.B * right;
+        var a = left.A * right;
+
+        return new((byte)r, (byte)g, (byte)b, (byte)a);
+    }
+
+    /// <summary>
+    /// Divides the specified color by a specified scalar value.
+    /// </summary>
+    /// <param name="left">The color.</param>
+    /// <param name="right">The scalar value.</param>
+    /// <returns>The result of the division.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Divide(ColorB left, float right)
+    {
+        var r = left.R / right;
+        var g = left.G / right;
+        var b = left.B / right;
+        var a = left.A / right;
+
+        return new((byte)r, (byte)g, (byte)b, (byte)a);
+    }
+
+    /// <summary>
+    /// Multiples the specified color by the specified scalar value.
+    /// </summary>
+    /// <param name="left">The scalar value.</param>
+    /// <param name="right">The color.</param>
+    /// <returns>The scaled color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Multiply(float left, ColorB right) => Multiply(right, left);
+
+    /// <summary>
+    /// Linearly interpolates between two colors.
+    /// </summary>
+    /// <param name="a">The first color.</param>
+    /// <param name="b">The second color.</param>
+    /// <param name="t">Influence of the second color on the final result.</param>
+    /// <returns><paramref name="a"/> * (255 - <paramref name="t"/>) + <paramref name="b"/> * <paramref name="t"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorB Lerp(in ColorB a, in ColorB b, float t) =>
+        a + (b - a) * t;
+
+    #endregion
+    #region Operators
+    /// <summary>
+    /// Element-wise equality.
+    /// </summary>
+    /// <param name="left">The first value.</param>
+    /// <param name="right">The second value.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator ==(ColorB left, ColorB right) =>
+        left.Equals(right);
+
+    /// <summary>
+    /// Element-wise inequality.
+    /// </summary>
+    /// <param name="left">The first value.</param>
+    /// <param name="right">The second value.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator !=(ColorB left, ColorB right) =>
+        !left.Equals(right);
+
+    /// <summary>
+    /// Negates the specified color.
+    /// </summary>
+    /// <param name="color">The color to negate.</param>
+    /// <returns>The negated vector.</returns>
+    public static ColorB operator -(ColorB color) => Negate(color);
+
+    /// <summary>
+    /// Adds two colors together.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The summed color.</returns>
+    public static ColorB operator +(ColorB left, ColorB right) => Add(left, right);
+
+    /// <summary>
+    /// Subtracts the second color from the first.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The color that results from subracting <paramref name="right"/> from <paramref name="left"/>.</returns>
+    public static ColorB operator -(ColorB left, ColorB right) => Subtract(left, right);
+
+    /// <summary>
+    /// Multiplies two colors together.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The product color.</returns>
+    public static ColorB operator *(ColorB left, ColorB right) => Multiply(left, right);
+
+    /// <summary>
+    /// Divides the first color by the second.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The color that results from dividing <paramref name="left"/> by <paramref name="right"/>.</returns>
+    public static ColorB operator /(ColorB left, ColorB right) => Divide(left, right);
+
+    /// <summary>
+    /// Multiples the specified color by the specified scalar value.
+    /// </summary>
+    /// <param name="left">The color.</param>
+    /// <param name="right">The scalar value.</param>
+    /// <returns>The scaled color.</returns>
+    public static ColorB operator *(ColorB left, float right) => Multiply(left, right);
+
+    /// <summary>
+    /// Divides the specified color by a specified scalar value.
+    /// </summary>
+    /// <param name="left">The color.</param>
+    /// <param name="right">The scalar value.</param>
+    /// <returns>The result of the division.</returns>
+    public static ColorB operator /(ColorB left, float right) => Divide(left, right);
+
+    /// <summary>
+    /// Multiples the specified color by the specified scalar value.
+    /// </summary>
+    /// <param name="left">The scalar value.</param>
+    /// <param name="right">The color.</param>
+    /// <returns>The scaled color.</returns>
+    public static ColorB operator *(float left, ColorB right) => Multiply(left, right);
+    #endregion
+    #region Colors
+    /// <summary>
+    /// Red (1, 0, 0, 1)
+    /// </summary>
+    public static readonly ColorB Red = new(255, 0, 0, 255);
+    public static readonly ColorB Transparent = new(0, 0, 0, 0);
+
+    /// <summary>
+    /// Dark Red (139, 0, 0, 255)
+    /// </summary>
+    public static readonly ColorB DarkRed = new(139, 0, 0, 255);
+
+    /// <summary>
+    /// Green (0, 255, 0, 255)
+    /// </summary>
+    public static readonly ColorB Green = new(0, 255, 0, 255);
+
+    /// <summary>
+    /// Blue (0, 0, 255, 255)
+    /// </summary>
+    public static readonly ColorB Blue = new(0, 0, 255, 255);
+
+    /// <summary>
+    /// Yellow (255, 255, 0, 255)
+    /// </summary>
+    public static readonly ColorB Yellow = new(255, 255, 0, 255);
+
+    /// <summary>
+    /// Grey (128, 128, 128 / 255f, 255)
+    /// </summary>
+    public static readonly ColorB Grey = new(128, 128, 128, 255);
+
+    /// <summary>
+    /// Light Grey (211, 211, 211, 255)
+    /// </summary>
+    public static readonly ColorB LightGrey = new(211, 211, 211, 255);
+
+    /// <summary>
+    /// Cyan (0, 255, 255, 255)
+    /// </summary>
+    public static readonly ColorB Cyan = new(0, 255, 255, 255);
+
+    /// <summary>
+    /// White (255, 255, 255, 255)
+    /// </summary>
+    public static readonly ColorB White = new(255, 255, 255, 255);
+
+    /// <summary>
+    /// Cornflower Blue (100, 149, 237, 255)
+    /// </summary>
+    public static readonly ColorB CornflowerBlue = new(100, 149, 237, 255);
+
+    /// <summary>
+    /// Clear (0, 0, 0, 0)
+    /// </summary>
+    public static readonly ColorB Clear = new(0, 0, 0, 0);
+
+    /// <summary>
+    /// Black (0, 0, 0, 255)
+    /// </summary>
+    public static readonly ColorB Black = new(0, 0, 0, 255);
+
+    /// <summary>
+    /// Pink (255, 192, 203, 255)
+    /// </summary>
+    public static readonly ColorB Pink = new(255, 192, 203, 255);
+
+    /// <summary>
+    /// Orange (255, 165, 0, 255)
+    /// </summary>
+    public static readonly ColorB Orange = new(255, 165, 0, 255);
+    #endregion
+}

src/Peridot/ColorB.cs

···
+using System.Drawing;
+
+namespace Peridot;
+
+/// <summary>
+/// Represetns a RGBA color with floating point values.
+/// All components must be between 0.0 and 1.0.
+/// </summary>
+public partial struct ColorB : IEquatable<ColorB>
+{
+    /// <summary>
+    /// Constructs a new ColorB from components.
+    /// </summary>
+    /// <param name="r">Red component.</param>
+    /// <param name="g">Green component.</param>
+    /// <param name="b">Blue component.</param>
+    /// <param name="a">Alpha component.</param>
+    public ColorB(byte r, byte g, byte b, byte a)
+    {
+        (R, G, B, A) = (r, g, b, a);
+    }
+
+    /// <summary>
+    /// Constructs a new ColorB from a Color.
+    /// </summary>
+    /// <param name="color">Color.</param>
+    public ColorB(Color color)
+    {
+        (R, G, B, A) = (color.R, color.G, color.B, color.A);
+    }
+
+    /// <summary>
+    /// Constructs a new ColorB from a Vector4.
+    /// </summary>
+    /// <param name="color">Color.</param>
+    public ColorB(ColorF color)
+    {
+        color *= 255f;
+        (R, G, B, A) = ((byte)color.R, (byte)color.G, (byte)color.B, (byte)color.A);
+    }
+
+    /// <summary>
+    /// The red color component.
+    /// </summary>
+    public byte R;
+
+    /// <summary>
+    /// The green color component.
+    /// </summary>
+    public byte G;
+
+    /// <summary>
+    /// The blue color component.
+    /// </summary>
+    public byte B;
+
+    /// <summary>
+    /// The alpha color component.
+    /// </summary>
+    public byte A;
+
+    public bool Equals(ColorB other)
+    {
+        return (R, G, B, A) == (other.R, other.G, other.B, other.A);
+    }
+
+    /// <inheritdoc/>
+    public override bool Equals(object obj)
+    {
+        return obj is ColorB other && Equals(other);
+    }
+
+    /// <inheritdoc/>
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(R, G, B, A);
+    }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return $"{{R: {R}, G: {G}, B: {B}, A: {A}}}";
+    }
+}

src/Peridot/ColorF.Static.cs

···
+using System.Drawing;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace Peridot;
+
+/// <summary>
+/// Provides static methods to <see cref="ColorF"/> manipulation.
+/// </summary>
+public partial struct ColorF
+{
+    #region Cast operators
+    /// <summary>
+    /// Cast a <see cref="ColorF"/> to <see cref="Vector4"/>.
+    /// </summary>
+    /// <param name="color">The color to cast.</param>
+    public static implicit operator Vector4(ColorF color) => color.m_rgba;
+
+    /// <summary>
+    /// Cast a <see cref="Vector4"/> to <see cref="ColorF"/>.
+    /// </summary>
+    /// <param name="color"></param>
+    public static implicit operator ColorF(Vector4 color) => new(color);
+
+    /// <summary>
+    /// Cast a <see cref="Vector4"/> to <see cref="ColorF"/>.
+    /// </summary>
+    /// <param name="color"></param>
+    public static implicit operator Color(ColorF color)
+    {
+        color = Vector4.Clamp(color, Vector4.Zero, Vector4.One) * 255f;
+        return Color.FromArgb((byte)color.A, (byte)color.R, (byte)color.G, (byte)color.B);
+    }
+    #endregion
+    #region Math
+    /// <summary>
+    /// Negates the specified color.
+    /// </summary>
+    /// <param name="color">The color to negate.</param>
+    /// <returns>The negated vector.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Negate(ColorF color) => -color.m_rgba;
+
+    /// <summary>
+    /// Adds two colors together.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The summed color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Add(ColorF left, ColorF right) => left.m_rgba + right.m_rgba;
+
+    /// <summary>
+    /// Subtracts the second color from the first.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The color that results from subracting <paramref name="right"/> from <paramref name="left"/>.</returns>
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Subtract(ColorF left, ColorF right) => left.m_rgba - right.m_rgba;
+
+    /// <summary>
+    /// Multiplies two colors together.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The product color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Multiply(ColorF left, ColorF right) => left.m_rgba * right.m_rgba;
+
+    /// <summary>
+    /// Divides the first color by the second.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The color that results from dividing <paramref name="left"/> by <paramref name="right"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Divide(ColorF left, ColorF right) => left.m_rgba / right.m_rgba;
+
+    /// <summary>
+    /// Multiples the specified color by the specified scalar value.
+    /// </summary>
+    /// <param name="left">The color.</param>
+    /// <param name="right">The scalar value.</param>
+    /// <returns>The scaled color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Multiply(ColorF left, float right) => left.m_rgba * right;
+
+    /// <summary>
+    /// Divides the specified color by a specified scalar value.
+    /// </summary>
+    /// <param name="left">The color.</param>
+    /// <param name="right">The scalar value.</param>
+    /// <returns>The result of the division.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Divide(ColorF left, float right) => left.m_rgba / right;
+
+    /// <summary>
+    /// Multiples the specified color by the specified scalar value.
+    /// </summary>
+    /// <param name="left">The scalar value.</param>
+    /// <param name="right">The color.</param>
+    /// <returns>The scaled color.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Multiply(float left, ColorF right) => left * right.m_rgba;
+
+    /// <summary>
+    /// Linearly interpolates between two colors.
+    /// </summary>
+    /// <param name="a">The first color.</param>
+    /// <param name="b">The second color.</param>
+    /// <param name="t">Influence of the second color on the final result.</param>
+    /// <returns><paramref name="a"/> * (1f - <paramref name="t"/>) + <paramref name="b"/> * <paramref name="t"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ColorF Lerp(in ColorF a, in ColorF b, float t) =>
+        a + (b - a) * t;
+    #endregion
+    #region Operators
+    /// <summary>
+    /// Element-wise equality.
+    /// </summary>
+    /// <param name="left">The first value.</param>
+    /// <param name="right">The second value.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator ==(ColorF left, ColorF right) =>
+        left.Equals(right);
+
+    /// <summary>
+    /// Element-wise inequality.
+    /// </summary>
+    /// <param name="left">The first value.</param>
+    /// <param name="right">The second value.</param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static bool operator !=(ColorF left, ColorF right) =>
+        !left.Equals(right);
+
+    /// <summary>
+    /// Negates the specified color.
+    /// </summary>
+    /// <param name="color">The color to negate.</param>
+    /// <returns>The negated vector.</returns>
+    public static ColorF operator -(ColorF color) => Negate(color);
+
+    /// <summary>
+    /// Adds two colors together.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The summed color.</returns>
+    public static ColorF operator +(ColorF left, ColorF right) => Add(left, right);
+
+    /// <summary>
+    /// Subtracts the second color from the first.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The color that results from subracting <paramref name="right"/> from <paramref name="left"/>.</returns>
+    public static ColorF operator -(ColorF left, ColorF right) => Subtract(left, right);
+
+    /// <summary>
+    /// Multiplies two colors together.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The product color.</returns>
+    public static ColorF operator *(ColorF left, ColorF right) => Multiply(left, right);
+
+    /// <summary>
+    /// Divides the first color by the second.
+    /// </summary>
+    /// <param name="left">The first color.</param>
+    /// <param name="right">The second color.</param>
+    /// <returns>The color that results from dividing <paramref name="left"/> by <paramref name="right"/>.</returns>
+    public static ColorF operator /(ColorF left, ColorF right) => Divide(left, right);
+
+    /// <summary>
+    /// Multiples the specified color by the specified scalar value.
+    /// </summary>
+    /// <param name="left">The color.</param>
+    /// <param name="right">The scalar value.</param>
+    /// <returns>The scaled color.</returns>
+    public static ColorF operator *(ColorF left, float right) => Multiply(left, right);
+
+    /// <summary>
+    /// Divides the specified color by a specified scalar value.
+    /// </summary>
+    /// <param name="left">The color.</param>
+    /// <param name="right">The scalar value.</param>
+    /// <returns>The result of the division.</returns>
+    public static ColorF operator /(ColorF left, float right) => Divide(left, right);
+
+    /// <summary>
+    /// Multiples the specified color by the specified scalar value.
+    /// </summary>
+    /// <param name="left">The scalar value.</param>
+    /// <param name="right">The color.</param>
+    /// <returns>The scaled color.</returns>
+    public static ColorF operator *(float left, ColorF right) => Multiply(left, right);
+    #endregion
+    #region Colors
+    /// <summary>
+    /// Red (1, 0, 0, 1)
+    /// </summary>
+    public static readonly ColorF Red = new(1f, 0f, 0f, 1f);
+
+    /// <summary>
+    /// Dark Red (139f / 255f, 0f, 0f, 1f)
+    /// </summary>
+    public static readonly ColorF DarkRed = new(139f / 255f, 0f, 0f, 1f);
+
+    /// <summary>
+    /// Green (0f, 1f, 0f, 1f)
+    /// </summary>
+    public static readonly ColorF Green = new(0f, 1f, 0f, 1f);
+
+    /// <summary>
+    /// Blue (0f, 0f, 1f, 1f)
+    /// </summary>
+    public static readonly ColorF Blue = new(0f, 0f, 1f, 1f);
+
+    /// <summary>
+    /// Yellow (1f, 1f, 0f, 1f)
+    /// </summary>
+    public static readonly ColorF Yellow = new(1f, 1f, 0f, 1f);
+
+    /// <summary>
+    /// Grey (128f / 255f, 128f / 255f, 128 / 255f, 1f)
+    /// </summary>
+    public static readonly ColorF Grey = new(128f / 255f, 128f / 255f, 128f / 255f, 1f);
+
+    /// <summary>
+    /// Light Grey (211f / 255f, 211f / 255f, 211f / 255f, 1f)
+    /// </summary>
+    public static readonly ColorF LightGrey = new(211f / 255f, 211f / 255f, 211f / 255f, 1f);
+
+    /// <summary>
+    /// Cyan (0f, 1f, 1f, 1f)
+    /// </summary>
+    public static readonly ColorF Cyan = new(0f, 1f, 1f, 1f);
+
+    /// <summary>
+    /// White (1f, 1f, 1f, 1f)
+    /// </summary>
+    public static readonly ColorF White = new(1f, 1f, 1f, 1f);
+
+    /// <summary>
+    /// Cornflower Blue (100f / 255f, 149f / 255f, 237f / 255f, 1f)
+    /// </summary>
+    public static readonly ColorF CornflowerBlue = new(100f / 255f, 149f / 255f, 237f / 255f, 1f);
+
+    /// <summary>
+    /// Clear (0f, 0f, 0f, 0f)
+    /// </summary>
+    public static readonly ColorF Clear = new(0f, 0f, 0f, 0f);
+
+    /// <summary>
+    /// Black (0f, 0f, 0f, 1f)
+    /// </summary>
+    public static readonly ColorF Black = new(0f, 0f, 0f, 1f);
+
+    /// <summary>
+    /// Pink (1f, 192f / 255f, 203f / 255f, 1f)
+    /// </summary>
+    public static readonly ColorF Pink = new(1f, 192f / 255f, 203f / 255f, 1f);
+
+    /// <summary>
+    /// Orange (1f, 165f / 255f, 0f, 1f)
+    /// </summary>
+    public static readonly ColorF Orange = new(1f, 165f / 255f, 0f, 1f);
+    #endregion
+}

src/Peridot/ColorF.cs

···
+using System.Drawing;
+using System.Numerics;
+
+namespace Peridot;
+
+/// <summary>
+/// Represetns a RGBA color with floating point values.
+/// All components must be between 0.0 and 1.0.
+/// </summary>
+public partial struct ColorF : IEquatable<ColorF>
+{
+    private Vector4 m_rgba;
+
+    /// <summary>
+    /// Constructs a new ColorF from components.
+    /// </summary>
+    /// <param name="r">Red component.</param>
+    /// <param name="g">Green component.</param>
+    /// <param name="b">Blue component.</param>
+    /// <param name="a">Alpha component.</param>
+    public ColorF(float r, float g, float b, float a)
+    {
+        m_rgba = new(r, g, b, a);
+    }
+
+    /// <summary>
+    /// Constructs a new ColorF from a Color.
+    /// </summary>
+    /// <param name="color">Color.</param>
+    public ColorF(Color color)
+    {
+        m_rgba = new Vector4(color.R, color.G, color.B, color.A) * (1f / 255f);
+    }
+
+    /// <summary>
+    /// Constructs a new ColorF from a Vector4.
+    /// </summary>
+    /// <param name="color">Color.</param>
+    public ColorF(Vector4 color)
+    {
+        m_rgba = color;
+    }
+
+    /// <summary>
+    /// The red color component.
+    /// </summary>
+    public float R { get => m_rgba.X; set => m_rgba.X = value; }
+
+    /// <summary>
+    /// The green color component.
+    /// </summary>
+    public float G { get => m_rgba.Y; set => m_rgba.Y = value; }
+
+    /// <summary>
+    /// The blue color component.
+    /// </summary>
+    public float B { get => m_rgba.Z; set => m_rgba.Z = value; }
+
+    /// <summary>
+    /// The alpha color component.
+    /// </summary>
+    public float A { get => m_rgba.W; set => m_rgba.W = value; }
+
+    public Vector4 AsVector { get => m_rgba; set => m_rgba = value; }
+
+    public bool Equals(ColorF other)
+    {
+        return m_rgba.Equals(other.m_rgba);
+    }
+
+    /// <inheritdoc/>
+    public override bool Equals(object obj)
+    {
+        return obj is ColorF other && Equals(other);
+    }
+
+    /// <inheritdoc/>
+    public override int GetHashCode()
+    {
+        return m_rgba.GetHashCode();
+    }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return $"{{R: {R}, G: {G}, B: {B}, A: {A}}}";
+    }
+}

src/Peridot/IFont.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using System.Numerics;
-
-namespace Peridot
-{
-    /// <summary>
-    /// Represents a font to use in <see cref="SpriteBatch{TTexture}"/>.
-    /// </summary>
-    public interface IFont : IDisposable
-    {
-        /// <summary>
-        /// A bool indicating whether this instance has been disposed.
-        /// </summary>
-        public bool IsDisposed { get; }
-
-        /// <summary>
-        /// Gets the size of a string when rendered in this font.
-        /// </summary>
-        /// <param name="text">The text to measure.</param>
-        /// <param name="fontSize">The font size to measure.</param>
-        /// <returns>The size of <paramref name="text"/> rendered with a <see cref="ITextRenderer"/> 
-        /// with <paramref name="fontSize"/> font size.</returns>
-        public Vector2 MeasureString(string text, int fontSize);
-    }
-}

src/Peridot/IPeridot.cs

···
+namespace Peridot;
+
+/// <summary>
+/// Represents a interface for implementation of Peridot.
+/// </summary>
+public interface IPeridot
+{
+	/// <summary>
+	/// Creates a new image.
+	/// </summary>
+	/// <param name="description">The description of image.</param>
+	/// <returns>A new image.</returns>
+	public Image CreateImage(ImageDescription description);
+
+	/// <summary>
+	/// Updates a portion of Image with new data.
+	/// </summary>
+	/// <param name="image">The image to update.</param>
+	/// <param name="source">An span with data to upload.</param>
+	/// <param name="x">The minimum X value of the updated region.</param>
+	/// <param name="y">The minimum Y value of the updated region.</param>
+	/// <param name="width">The width of the updated region.</param>
+	/// <param name="height">The height of the updated region.</param>
+	/// <typeparam name="T">Type of data updated.</typeparam>
+	public void UpdateImage<T>(Image image, ReadOnlySpan<T> source, uint x, uint y, uint width, uint height) where T : unmanaged;
+}
+
+/// <summary>
+/// Represents a interface for implementation of Peridot.
+/// </summary>
+public interface IPeridot<TSpriteBatchDescripton> : IPeridot
+{
+	/// <summary>
+	/// Creates a new sprite batch.
+	/// </summary>
+	/// <param name="description">The description of sprite batch.</param>
+	/// <returns>A new sprite batch.</returns>
+	public ISpriteBatch CreateSpriteBatch(TSpriteBatchDescripton description);
+}
+
+/// <summary>
+/// Represents a interface for implementation of Peridot.
+/// </summary>
+public interface IPeridot<TImage, TSpriteBatchDescripton> : IPeridot<TSpriteBatchDescripton>
+{
+	/// <summary>
+	/// Creates a new sprite batch.
+	/// </summary>
+	/// <param name="description">The description of sprite batch.</param>
+	/// <returns>A new sprite batch.</returns>
+	public new ISpriteBatch<TImage> CreateSpriteBatch(TSpriteBatchDescripton description);
+}

src/Peridot/ISpriteBatch.cs

···
 using System.Drawing;
 using System.Numerics;
 
-namespace Peridot
+namespace Peridot;
+
+/// <summary>
+/// Represents a interface for drawing sprites in one or more optimized batches.
+/// </summary>
+public interface ISpriteBatch : IDisposable
 {
     /// <summary>
-    /// Represents a interface for drawing sprites in one or more optimized batches.
+    /// A bool indicating whether this instance has been disposed.
     /// </summary>
-    public interface ISpriteBatch : IDisposable
-    {
-        /// <summary>
-        /// A bool indicating whether this instance has been disposed.
-        /// </summary>
-        public bool IsDisposed { get; }
+    public bool IsDisposed { get; }
 
-        /// <summary>
-        /// The view matrix to use to renderer.
-        /// </summary>
-        public Matrix4x4 ViewMatrix { get; set; }
+    /// <summary>
+    /// The view matrix to use to renderer.
+    /// </summary>
+    public Matrix4x4 ViewMatrix { get; set; }
 
-        /// <summary>
-        /// The scissor rectangle.
-        /// </summary>
-        public RectangleF Scissor { get; set; }
+    /// <summary>
+    /// The scissor rectangle.
+    /// </summary>
+    public RectangleF Scissor { get; set; }
 
-        /// <summary>
-        /// Resets the <see cref="Scissor"/> to default value.
-        /// </summary>
-        public void ResetScissor();
+    /// <summary>
+    /// Resets the <see cref="Scissor"/> to default value.
+    /// </summary>
+    public void ResetScissor();
 
-        /// <summary>
-        /// Replaces the <see cref="Scissor"/> with the intersection of itself 
-        /// and the <paramref name="clip"/> rectangle.
-        /// </summary>
-        /// <param name="clip">The rectangle to intersects.</param>
-        public void IntersectScissor(RectangleF clip);
+    /// <summary>
+    /// Replaces the <see cref="Scissor"/> with the intersection of itself 
+    /// and the <paramref name="clip"/> rectangle.
+    /// </summary>
+    /// <param name="clip">The rectangle to intersects.</param>
+    public void IntersectScissor(RectangleF clip);
 
-        /// <summary>
-        /// Begins the sprite branch.
-        /// </summary>
-        /// <exception cref="InvalidOperationException">Thrown if <see cref="Begin"/> is called next time without previous <see cref="End"/>.</exception>
-        public void Begin();
+    /// <summary>
+    /// Begins the sprite branch.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if <see cref="Begin"/> is called next time without previous <see cref="End"/>.</exception>
+    public void Begin();
 
-        /// <summary>
-        /// Flushes all batched text and sprites to the screen.
-        /// </summary>
-        /// <exception cref="InvalidOperationException">This command should be called after <see cref="Begin"/> and drawing commands.</exception>
-        public void End();
+    /// <summary>
+    /// Flushes all batched text and sprites to the screen.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">This command should be called after <see cref="Begin"/> and drawing commands.</exception>
+    public void End();
 
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">A rotation of this sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                SpriteOptions options,
-                float layerDepth);
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            RectangleF destinationRectangle,
+            RectangleF sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            SpriteOptions options,
+            float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">A rotation of this sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float layerDepth);
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            Vector2 position,
+            RectangleF sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            Vector2 scale,
+            SpriteOptions options,
+            float layerDepth);
 
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                SpriteOptions options,
-                float layerDepth);
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            RectangleF destinationRectangle,
+            RectangleF sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            float layerDepth);
 
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">A rotation of this sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float scale,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">A rotation of this sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(ITexture2D texture,
-                    Vector2 position,
-                    RectangleF? sourceRectangle,
-                    Color color,
-                    float rotation,
-                    Vector2 origin,
-                    float scale,
-                    float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                RectangleF? sourceRectangle,
-                Color color,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                RectangleF? sourceRectangle,
-                Color color,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                Vector2 position,
-                Color color,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                Vector2 position,
-                Color color,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                Color color,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                Color color,
-                float layerDepth);
-    }
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            Vector2 position,
+            RectangleF sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            Vector2 scale,
+            float layerDepth);
 
     /// <summary>
-    /// Represents a interface for drawing sprites in one or more optimized batches.
+    /// Submit a sprite for drawing in the current batch.
     /// </summary>
-    public interface ISpriteBatch<TTexture> : ISpriteBatch where TTexture : notnull, ITexture2D
-    {
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
-                RectangleF destinationRectangle,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                SpriteOptions options,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
-                RectangleF destinationRectangle,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                float layerDepth);
-
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">A rotation of this sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(TTexture texture,
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">A rotation of this sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
             RectangleF destinationRectangle,
             RectangleF? sourceRectangle,
             Color color,
···
             SpriteOptions options,
             float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">A rotation of this sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">A rotation of this sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
             RectangleF destinationRectangle,
             RectangleF? sourceRectangle,
             Color color,
···
             Vector2 origin,
             float layerDepth);
 
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                SpriteOptions options,
-                float layerDepth);
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            Vector2 position,
+            RectangleF? sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            Vector2 scale,
+            SpriteOptions options,
+            float layerDepth);
 
-        /// <summary>
-        /// Submit sprite draw in the batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">The rotation of the sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                float layerDepth);
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            Vector2 position,
+            RectangleF? sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            Vector2 scale,
+            float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">A rotation of this sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float scale,
-                SpriteOptions options,
-                float layerDepth);
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">A rotation of this sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            Vector2 position,
+            RectangleF? sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            float scale,
+            SpriteOptions options,
+            float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="rotation">A rotation of this sprite.</param>
-        /// <param name="origin">Sprite center.</param>
-        /// <param name="scale">A scaling of this sprite.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-		public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">A rotation of this sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
                 Vector2 position,
                 RectangleF? sourceRectangle,
                 Color color,
···
                 float scale,
                 float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
             Vector2 position,
             RectangleF? sourceRectangle,
             Color color,
             SpriteOptions options,
             float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
             Vector2 position,
             RectangleF? sourceRectangle,
             Color color,
             float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">			The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
             RectangleF destinationRectangle,
             RectangleF? sourceRectangle,
             Color color,
             SpriteOptions options,
             float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
             RectangleF destinationRectangle,
             RectangleF? sourceRectangle,
             Color color,
             float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
             Vector2 position,
             Color color,
             SpriteOptions options,
             float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            Vector2 position,
+            Color color,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            RectangleF destinationRectangle,
+            Color color,
+            SpriteOptions options,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(Image image,
+            RectangleF destinationRectangle,
+            Color color,
+            float layerDepth);
+
+    #region Draw without image
+    /// <summary>
+    /// Submit a rectangle for drawing in the current batch.
+    /// </summary>
+    /// <param name="rectangle">The drawing bounds on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void DrawRect(
+            RectangleF rectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit a rectangle for drawing in the current batch.
+    /// </summary>
+    /// <param name="rectangle">The drawing bounds on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void DrawRect(
+            RectangleF rectangle,
+            Color color,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit a square for drawing in the current batch.Vector2.Zero
+    /// </summary>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="size">The size of quad</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void DrawDot(
             Vector2 position,
+            float size,
             Color color,
             float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="options">Options that modify the drawing.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit a line segment for drawing in the current batch.
+    /// </summary>
+    /// <param name="a">Endpoint A.</param>
+    /// <param name="b">Endpoint B</param>
+    /// <param name="color">Color.</param>
+    /// <param name="thickness">Line segment thickness.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void DrawSegment(
+        Vector2 a,
+        Vector2 b,
+        Color color,
+        float thickness,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a line segment for drawing in the current batch.
+    /// </summary>
+    /// <param name="start">The reference endpoint.</param>
+    /// <param name="length">The segment length.</param>
+    /// <param name="angle">The segment angle.</param>
+    /// <param name="color">The angle at start.</param>
+    /// <param name="thickness">Line segment thickness.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void DrawSegment(
+        Vector2 start,
+        float length,
+        Color color,
+        float angle,
+        float thickness,
+        float layerDepth);
+    #endregion
+}
+
+/// <summary>
+/// Represents a interface for drawing sprites in one or more optimized batches.
+/// </summary>
+public interface ISpriteBatch<TTexture> : ISpriteBatch
+{
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
             RectangleF destinationRectangle,
+            RectangleF sourceRectangle,
             Color color,
+            float rotation,
+            Vector2 origin,
             SpriteOptions options,
             float layerDepth);
 
-        /// <summary>
-        /// Submit a sprite for drawing in the current batch.
-        /// </summary>
-        /// <param name="texture">The source texture.</param>
-        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
-        /// <param name="color">Color multiplier.</param>
-        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
-        public void Draw(TTexture texture,
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+            Vector2 position,
+            RectangleF sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            Vector2 scale,
+            SpriteOptions options,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
             RectangleF destinationRectangle,
+            RectangleF sourceRectangle,
             Color color,
+            float rotation,
+            Vector2 origin,
             float layerDepth);
-    }
+
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+            Vector2 position,
+            RectangleF sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            Vector2 scale,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">A rotation of this sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        RectangleF destinationRectangle,
+        RectangleF? sourceRectangle,
+        Color color,
+        float rotation,
+        Vector2 origin,
+        SpriteOptions options,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">A rotation of this sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        RectangleF destinationRectangle,
+        RectangleF? sourceRectangle,
+        Color color,
+        float rotation,
+        Vector2 origin,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+            Vector2 position,
+            RectangleF? sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            Vector2 scale,
+            SpriteOptions options,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit sprite draw in the batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">The rotation of the sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+            Vector2 position,
+            RectangleF? sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            Vector2 scale,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">A rotation of this sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+            Vector2 position,
+            RectangleF? sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            float scale,
+            SpriteOptions options,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="rotation">A rotation of this sprite.</param>
+    /// <param name="origin">Sprite center.</param>
+    /// <param name="scale">A scaling of this sprite.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+            Vector2 position,
+            RectangleF? sourceRectangle,
+            Color color,
+            float rotation,
+            Vector2 origin,
+            float scale,
+            float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        Vector2 position,
+        RectangleF? sourceRectangle,
+        Color color,
+        SpriteOptions options,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        Vector2 position,
+        RectangleF? sourceRectangle,
+        Color color,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        RectangleF destinationRectangle,
+        RectangleF? sourceRectangle,
+        Color color,
+        SpriteOptions options,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="sourceRectangle">An optional region on the image which will be rendered. If null - draws full image.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        RectangleF destinationRectangle,
+        RectangleF? sourceRectangle,
+        Color color,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        Vector2 position,
+        Color color,
+        SpriteOptions options,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="position">The drawing location on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        Vector2 position,
+        Color color,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="options">Options that modify the drawing.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        RectangleF destinationRectangle,
+        Color color,
+        SpriteOptions options,
+        float layerDepth);
+
+    /// <summary>
+    /// Submit a sprite for drawing in the current batch.
+    /// </summary>
+    /// <param name="image">The source image.</param>
+    /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+    /// <param name="color">Color multiplier.</param>
+    /// <param name="layerDepth">A layer depth of this drawing.</param>
+    public void Draw(TTexture image,
+        RectangleF destinationRectangle,
+        Color color,
+        float layerDepth);
 }

src/Peridot/ITextRenderer.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using System.Drawing;
-using System.Numerics;
-
-namespace Peridot
-{
-    /// <summary>
-    /// Represents an interface to a text renderer.
-    /// </summary>
-    public interface ITextRenderer : IDisposable
-    {
-        /// <summary>
-        /// A bool indicating whether this instance has been disposed.
-        /// </summary>
-        public bool IsDisposed { get; }
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="color">The text color.</param>
-        /// <param name="rotation">The rotation of the drawing.</param>
-        /// <param name="origin">The center of the rotation. (0, 0) for default.</param>
-        /// <param name="scale">The scaling of this drawing.</param>
-        /// <param name="layerDepth">The layer depth of this drawing.</param>
-        public void DrawString(
-            IFont font,
-            int fontSize,
-            string text,
-            Vector2 position,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            Vector2 scale,
-            float layerDepth);
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="color">The text color.</param>
-        /// <param name="rotation">The rotation of the drawing.</param>
-        /// <param name="origin">The center of the rotation. (0, 0) for default.</param>
-        /// <param name="scale">The scaling of this drawing.</param>
-        /// <param name="layerDepth">The layer depth of this drawing.</param>
-        /// <param name="scissor">The scissor rectangle.</param>
-        public void DrawString(
-            IFont font,
-            int fontSize,
-            string text,
-            Vector2 position,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            Vector2 scale,
-            float layerDepth,
-            Rectangle scissor);
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen</param>
-        /// <param name="color">The text color.</param>
-        public void DrawString(
-            IFont font,
-            int fontSize,
-            string text,
-            Vector2 position,
-            Color color)
-        {
-            DrawString(font, fontSize, text, position, color, 0, Vector2.Zero, Vector2.One, 0);
-        }
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen</param>
-        /// <param name="color">The text color.</param>
-        /// <param name="scissor">The scissor rectangle.</param>
-        public void DrawString(
-            IFont font,
-            int fontSize,
-            string text,
-            Vector2 position,
-            Color color,
-            Rectangle scissor)
-        {
-            DrawString(font, fontSize, text, position, color, 0, Vector2.Zero, Vector2.One, 0, scissor);
-        }
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen</param>
-        /// <param name="color">The text color.</param>
-        /// <param name="rotation">The rotation of the drawing.</param>
-        /// <param name="origin">The center of the rotation. (0, 0) for default.</param>
-        /// <param name="scale">The scaling of this drawing.</param>
-        /// <param name="layerDepth">The layer depth of this drawing.</param>
-        public void DrawString(
-            IFont font, 
-            int fontSize, 
-            string text, 
-            Vector2 position, 
-            Color color,
-            float rotation, 
-            Vector2 origin, 
-            float scale, 
-            float layerDepth)
-        {
-            DrawString(font, fontSize, text, position, color, rotation, origin, new Vector2(scale), layerDepth);
-        }
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen</param>
-        /// <param name="color">The text color.</param>
-        /// <param name="rotation">The rotation of the drawing.</param>
-        /// <param name="origin">The center of the rotation. (0, 0) for default.</param>
-        /// <param name="scale">The scaling of this drawing.</param>
-        /// <param name="layerDepth">The layer depth of this drawing.</param>
-        /// <param name="scissor">The scissor rectangle.</param>
-        public void DrawString(
-            IFont font,
-            int fontSize,
-            string text,
-            Vector2 position,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            float scale,
-            float layerDepth,
-            Rectangle scissor)
-        {
-            DrawString(font, fontSize, text, position, color, rotation, origin, new Vector2(scale), layerDepth, scissor);
-        }
-    }
-
-    /// <summary>
-    /// Represents an interface to a text renderer.
-    /// </summary>
-    public interface ITextRenderer<TFont> : ITextRenderer where TFont : notnull, IFont
-    {
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="color">The text color.</param>
-        /// <param name="rotation">The rotation of the drawing.</param>
-        /// <param name="origin">The center of the rotation. (0, 0) for default.</param>
-        /// <param name="scale">The scaling of this drawing.</param>
-        /// <param name="layerDepth">The layer depth of this drawing.</param>
-        public abstract void DrawString(
-            TFont font,
-            int fontSize,
-            string text,
-            Vector2 position,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            Vector2 scale,
-            float layerDepth);
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen.</param>
-        /// <param name="color">The text color.</param>
-        /// <param name="rotation">The rotation of the drawing.</param>
-        /// <param name="origin">The center of the rotation. (0, 0) for default.</param>
-        /// <param name="scale">The scaling of this drawing.</param>
-        /// <param name="layerDepth">The layer depth of this drawing.</param>
-        /// <param name="scissor">The scissor rectangle.</param>
-        public abstract void DrawString(
-            TFont font,
-            int fontSize,
-            string text,
-            Vector2 position,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            Vector2 scale,
-            float layerDepth, 
-            Rectangle scissor);
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen</param>
-        /// <param name="color">The text color.</param>
-        public void DrawString(TFont font, int fontSize, string text, Vector2 position, Color color)
-        {
-            DrawString(font, fontSize, text, position, color, 0, new Vector2(), new Vector2(1), 0);
-        }
-
-        /// <summary>
-        /// Submit a text string for drawing.
-        /// </summary>
-        /// <param name="font">The font to draw.</param>
-        /// <param name="fontSize">The font size.</param>
-        /// <param name="text">The text which will be drawn.</param>
-        /// <param name="position">The drawing location on screen</param>
-        /// <param name="color">The text color.</param>
-        /// <param name="rotation">The rotation of the drawing.</param>
-        /// <param name="origin">The center of the rotation. (0, 0) for default.</param>
-        /// <param name="scale">The scaling of this drawing.</param>
-        /// <param name="layerDepth">The layer depth of this drawing.</param>
-        public void DrawString(TFont font, int fontSize, string text, Vector2 position, Color color, float rotation, Vector2 origin, float scale, float layerDepth)
-        {
-            DrawString(font, fontSize, text, position, color, rotation, origin, new Vector2(scale), layerDepth);
-        }
-    }
-}

src/Peridot/ITexture2D.cs

···
-// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
-// This code is licensed under MIT license (see LICENSE for details)
-
-using System.Drawing;
-
-namespace Peridot
-{
-    /// <summary>
-    /// Represents a 2D texture to use in <see cref="SpriteBatch{TTexture}"/>.
-    /// </summary>
-    public interface ITexture2D : IDisposable
-    {
-        /// <summary>
-        /// A bool indicating whether this instance has been disposed.
-        /// </summary>
-        public bool IsDisposed { get; }
-
-        /// <summary>
-        /// The total size of the texture.
-        /// </summary>
-        public Size Size { get; }
-    }
-}

src/Peridot/Image.cs

···
+// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
+// This code is licensed under MIT license (see LICENSE for details)
+
+using System.Drawing;
+
+namespace Peridot;
+
+/// <summary>
+/// Represents a 2D texture to use in <see cref="SpriteBatch{TTexture}"/>.
+/// </summary>
+public interface Image : IDisposable
+{
+    /// <summary>
+    /// A bool indicating whether this instance has been disposed.
+    /// </summary>
+    public bool IsDisposed { get; }
+
+    /// <summary>
+    /// The total size of the texture.
+    /// </summary>
+    public Size Size { get; }
+    public PixelFormat Format { get; }
+
+    public int Width => Size.Width;
+    public int Height => Size.Height;
+}

src/Peridot/ImageDescription.cs

···
+namespace Peridot;
+
+/// <summary>
+/// Describes a image in Peridot.
+/// </summary>
+public struct ImageDescription
+{
+    /// <summary>
+    /// Format of the image data.
+    /// </summary>
+    /// <value>Internal pixel format of image data.</value>
+    public PixelFormat Format { get; set; }
+
+    /// <summary>
+    /// The width of image.
+    /// </summary>
+    /// <value>Image width.</value>
+    public uint Width { get; set; }
+
+    /// <summary>
+    /// The height of image.
+    /// </summary>
+    /// <value>Image height.</value>
+    public uint Height { get; set; }
+}

src/Peridot/Peridot.csproj

···
 Peridot.Veldrid implements this with the Veldrid.</Description>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="FontStashSharp" Version="1.2.6" />
+  </ItemGroup>
+
+
   <Import Project="..\build\common.props.csproj" />
 
 </Project>

src/Peridot/PixelFormat.cs

···
+namespace Peridot;
+
+/// <summary>
+/// Specifies the pixel format.
+/// </summary>
+public enum PixelFormat
+{
+    Undefined,
+    /// <summary>
+    /// One-channel, byte storage.
+    /// </summary>
+    R8,
+    /// <summary>
+    /// One-channel, short storage.
+    /// </summary>
+    R16,
+    /// <summary>
+    /// Four channels, byte storage.
+    /// </summary>
+    BGRA8,
+    /// <summary>
+    /// Four channels, float storage.
+    /// </summary>
+    RGBAF32,
+    /// <summary>
+    /// Two-channels, byte storage.
+    /// </summary>
+    RG8,
+    /// <summary>
+    /// Two-channels, short storage.
+    /// </summary>
+    RG16,
+    /// <summary>
+    /// Four channels, signed integer storage.
+    /// </summary>
+    RGBAI32,
+    /// <summary>
+    /// Four channels, byte storage.
+    /// </summary>
+    RGBA8,
+}

src/Peridot/SpriteBatch.cs

···
 using System.Drawing;
 using System.Numerics;
 
-namespace Peridot
+namespace Peridot;
+
+/// <summary>
+/// A class for drawing sprites in one or more optimized batches.
+/// </summary>
+/// <typeparam name="TImage">The image type to renderer.</typeparam>
+public abstract class SpriteBatch<TImage> : ISpriteBatch<TImage>
 {
-    /// <summary>
-    /// A class for drawing sprites in one or more optimized batches.
-    /// </summary>
-    /// <typeparam name="TTexture">The texture type to renderer.</typeparam>
-    public abstract class SpriteBatch<TTexture> : ISpriteBatch<TTexture> where TTexture : notnull, ITexture2D
-    {
-        /// <summary>
-        /// The batcher with all entities to renderer.
-        /// </summary>
-        protected readonly Batcher<TTexture> _batcher;
+	/// <summary>
+	/// The batcher with all entities to renderer.
+	/// </summary>
+	protected readonly Batcher<TImage> m_batcher;
 
-        private bool _beginCalled;
+	protected readonly Image m_whiteImage;
 
-        /// <summary>
-        /// Creates a new <see cref="SpriteBatch{TTexture}"/>.
-        /// </summary>
-        public SpriteBatch()
-        {
-            _batcher = new();
-            _beginCalled = false;
-            IsDisposed = false;
-            ResetScissor();
-        }
+	private bool m_beginCalled;
 
-        /// <summary>
-        /// Deconstructor of <see cref="SpriteBatch{TTexture}"/>.
-        /// </summary>
-        ~SpriteBatch()
-        {
-            CoreDispose(false);
-        }
+	/// <summary>
+	/// Creates a new <see cref="SpriteBatch{TImage}"/>.
+	/// </summary>
+	public SpriteBatch(Image whiteImage)
+	{
+		m_batcher = new();
+		m_whiteImage = whiteImage;
+		m_beginCalled = false;
+		IsDisposed = false;
+		ResetScissor();
+	}
 
-        /// <summary>
-        /// The view matrix to use to renderer.
-        /// </summary>
-        public Matrix4x4 ViewMatrix { get; set; }
+	/// <summary>
+	/// Deconstructor of <see cref="SpriteBatch{TImage}"/>.
+	/// </summary>
+	~SpriteBatch()
+	{
+		CoreDispose(false);
+	}
 
-        /// <inheritdoc/>
-        public bool IsDisposed { get; protected set; }
+	/// <summary>
+	/// The view matrix to use to renderer.
+	/// </summary>
+	public Matrix4x4 ViewMatrix { get; set; }
 
-        /// <inheritdoc/>
-        public RectangleF Scissor { get; set; }
+	/// <inheritdoc/>
+	public bool IsDisposed { get; protected set; }
 
-        /// <summary>
-        /// Begins the sprite branch.
-        /// </summary>
-        /// <exception cref="InvalidOperationException">Thrown if <see cref="Begin"/> is called next time without previous <see cref="End"/>.</exception>
-        public void Begin()
-        {
-            if (_beginCalled)
-                throw new InvalidOperationException("Begin cannot be called again until End has been successfully called.");
+	/// <inheritdoc/>
+	public RectangleF Scissor { get; set; }
 
-            ViewMatrix = Matrix4x4.Identity;
-            _beginCalled = true;
-            _batcher.Clear();
-        }
+	/// <summary>
+	/// Begins the sprite branch.
+	/// </summary>
+	/// <exception cref="InvalidOperationException">Thrown if <see cref="Begin"/> is called next time without previous <see cref="End"/>.</exception>
+	public void Begin()
+	{
+		if (m_beginCalled)
+			throw new InvalidOperationException("Begin cannot be called again until End has been successfully called.");
 
-        /// <summary>
-        /// Flushes all batched text and sprites to the screen.
-        /// </summary>
-        /// <exception cref="InvalidOperationException">This command should be called after <see cref="Begin"/> and drawing commands.</exception>
-        public void End()
-        {
-            if (!_beginCalled)
-                throw new InvalidOperationException("Begin must be called before calling End.");
+		ViewMatrix = Matrix4x4.Identity;
+		m_beginCalled = true;
+		m_batcher.Clear();
+	}
 
-            _beginCalled = false;
-        }
+	/// <summary>
+	/// Flushes all batched text and sprites to the screen.
+	/// </summary>
+	/// <exception cref="InvalidOperationException">This command should be called after <see cref="Begin"/> and drawing commands.</exception>
+	public void End()
+	{
+		if (!m_beginCalled)
+			throw new InvalidOperationException("Begin must be called before calling End.");
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture, RectangleF destinationRectangle, RectangleF sourceRectangle, Color color, float rotation, Vector2 origin, SpriteOptions options, float layerDepth) =>
-            Draw(SpriteBatch<TTexture>.Cast(texture), destinationRectangle, sourceRectangle, color, rotation, origin, options, layerDepth);
+		m_beginCalled = false;
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture, Vector2 position, RectangleF sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteOptions options, float layerDepth) =>
-            Draw(SpriteBatch<TTexture>.Cast(texture), position, sourceRectangle, color, rotation, origin, scale, options, layerDepth);
+	/// <inheritdoc/>
+	public void Draw(Image image, RectangleF destinationRectangle, RectangleF sourceRectangle, Color color, float rotation, Vector2 origin, SpriteOptions options, float layerDepth) =>
+		Draw(GetHandle(image), destinationRectangle, sourceRectangle, color, rotation, origin, options, layerDepth);
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture, RectangleF destinationRectangle, RectangleF sourceRectangle, Color color, float rotation, Vector2 origin, SpriteOptions options, float layerDepth)
-        {
-            CheckValid(texture);
-            ref var item = ref _batcher.Add(texture);
+	/// <inheritdoc/>
+	public void Draw(Image image, Vector2 position, RectangleF sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteOptions options, float layerDepth) =>
+		Draw(GetHandle(image), position, sourceRectangle, color, rotation, origin, scale, options, layerDepth);
 
-            var size = new Vector2(texture.Size.Width, texture.Size.Height);
-            item = new(size, destinationRectangle, sourceRectangle, color, rotation, origin, layerDepth, Transform(Scissor, ViewMatrix), options);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image, RectangleF destinationRectangle, RectangleF sourceRectangle, Color color, float rotation, Vector2 origin, SpriteOptions options, float layerDepth)
+	{
+		CheckValid(image);
+		ref var item = ref m_batcher.Add(image);
+		var size = GetSize(image);
+		var vsize = new Vector2(size.Width, size.Height);
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture, Vector2 position, RectangleF sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteOptions options, float layerDepth)
-        {
-            CheckValid(texture);
-            ref var item = ref _batcher.Add(texture);
+		item = new(vsize, destinationRectangle, sourceRectangle, color, rotation, origin, layerDepth, Transform(Scissor, ViewMatrix), options);
+	}
 
-            var size = new Vector2(texture.Size.Width, texture.Size.Height);
-            item = new(size, position, sourceRectangle, color, rotation, origin, scale, layerDepth, Transform(Scissor, ViewMatrix), options);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image, Vector2 position, RectangleF sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteOptions options, float layerDepth)
+	{
+		CheckValid(image);
+		ref var item = ref m_batcher.Add(image);
+		var size = GetSize(image);
+		var vsize = new Vector2(size.Width, size.Height);
 
-        /// <inheritdoc/>
-        public void Dispose() 
-        {
-            CoreDispose(true);
-            GC.SuppressFinalize(this);
-        }
+		item = new(vsize, position, sourceRectangle, color, rotation, origin, scale, layerDepth, Transform(Scissor, ViewMatrix), options);
+	}
 
-        private void CoreDispose(bool disposing)
-        {
-            if (IsDisposed)
-                return;
-            IsDisposed = true;
+	/// <inheritdoc/>
+	public void Dispose()
+	{
+		CoreDispose(true);
+		GC.SuppressFinalize(this);
+	}
 
-            Dispose(disposing);
-        }
+	private void CoreDispose(bool disposing)
+	{
+		if (IsDisposed)
+			return;
+		IsDisposed = true;
 
-        /// <summary>
-        /// Disposes resources.
-        /// </summary>
-        /// <param name="disposing">If called by <see cref="Dispose()"/></param>
-        protected abstract void Dispose(bool disposing);
+		Dispose(disposing);
+	}
 
-        private void CheckValid(ITexture2D texture)
-        {
-            if (texture == null)
-                throw new ArgumentNullException(nameof(texture));
-            if (!_beginCalled)
-                throw new InvalidOperationException("Draw was called, but Begin has not yet been called. Begin must be called successfully before you can call Draw.");
-        }
+	/// <summary>
+	/// Disposes resources.
+	/// </summary>
+	/// <param name="disposing">If called by <see cref="Dispose()"/></param>
+	protected abstract void Dispose(bool disposing);
 
-        private static TTexture Cast(ITexture2D texture)
-        {
-            if (texture is not TTexture tt)
-                throw new InvalidCastException($"The {texture} is not supported by this implementation.");
-            return tt;
-        }
+	private void CheckValid(TImage image)
+	{
+		if (image == null)
+			throw new ArgumentNullException(nameof(image));
+		if (!m_beginCalled)
+			throw new InvalidOperationException("Draw was called, but Begin has not yet been called. Begin must be called successfully before you can call Draw.");
+	}
 
-        /// <inheritdoc/>
-        public void ResetScissor()
-        {
-            const float v = 1 << 23;
-            const float s = -(1 << 22);
-            Scissor = new RectangleF(s, s, v, v);
-        }
+	/// <inheritdoc/>
+	public void ResetScissor()
+	{
+		const float v = 1 << 23;
+		const float s = -(1 << 22);
+		Scissor = new RectangleF(s, s, v, v);
+	}
 
-        /// <inheritdoc/>
-        public void IntersectScissor(RectangleF clip)
-        {
-            var scissor = Scissor;
-            scissor.Intersect(clip);
-            Scissor = scissor;
-        }
+	/// <inheritdoc/>
+	public void IntersectScissor(RectangleF clip)
+	{
+		var scissor = Scissor;
+		scissor.Intersect(clip);
+		Scissor = scissor;
+	}
 
-        private static RectangleF Transform(RectangleF rect, Matrix4x4 matrix)
-        {
-            var pos = Vector4.Transform(new Vector4(rect.X, rect.Y, 0, 1), matrix);
-            var size = Vector4.Transform(new Vector4(rect.X + rect.Width, rect.Y + rect.Height, 0, 1), matrix);
-            return new(pos.X, pos.Y, size.X - pos.X, size.Y - pos.Y);
-        }
+	private static RectangleF Transform(RectangleF rect, Matrix4x4 matrix)
+	{
+		var pos = Vector4.Transform(new Vector4(rect.X, rect.Y, 0, 1), matrix);
+		var size = Vector4.Transform(new Vector4(rect.X + rect.Width, rect.Y + rect.Height, 0, 1), matrix);
+		return new(pos.X, pos.Y, size.X - pos.X, size.Y - pos.Y);
+	}
 
-        #region ISpriteBatch
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-                RectangleF destinationRectangle,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float layerDepth)
-        {
-            Draw(texture, destinationRectangle, sourceRectangle, color, rotation, origin, SpriteOptions.None, layerDepth);
-        }
+	#region ISpriteBatch
+	/// <inheritdoc/>
+	public void Draw(Image image,
+			RectangleF destinationRectangle,
+			RectangleF sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			float layerDepth)
+	{
+		Draw(image, destinationRectangle, sourceRectangle, color, rotation, origin, SpriteOptions.None, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                float layerDepth)
-        {
-            Draw(texture, position, sourceRectangle, color, rotation, origin, scale, SpriteOptions.None, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+			Vector2 position,
+			RectangleF sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			Vector2 scale,
+			float layerDepth)
+	{
+		Draw(image, position, sourceRectangle, color, rotation, origin, scale, SpriteOptions.None, layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(ITexture2D texture,
-            RectangleF destinationRectangle,
-            RectangleF? sourceRectangle,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            var srcRect = sourceRectangle ?? new(0, 0, texture.Size.Width, texture.Size.Height);
-            Draw(texture, destinationRectangle, srcRect, color, rotation, origin, options, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		RectangleF destinationRectangle,
+		RectangleF? sourceRectangle,
+		Color color,
+		float rotation,
+		Vector2 origin,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		var srcRect = sourceRectangle ?? new(0, 0, image.Width, image.Height);
+		Draw(image, destinationRectangle, srcRect, color, rotation, origin, options, layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(ITexture2D texture,
-            RectangleF destinationRectangle,
-            RectangleF? sourceRectangle,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            float layerDepth)
-        {
-            Draw(texture, destinationRectangle, sourceRectangle, color, rotation, origin, SpriteOptions.None, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		RectangleF destinationRectangle,
+		RectangleF? sourceRectangle,
+		Color color,
+		float rotation,
+		Vector2 origin,
+		float layerDepth)
+	{
+		Draw(image, destinationRectangle, sourceRectangle, color, rotation, origin, SpriteOptions.None, layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                SpriteOptions options,
-                float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle ?? new()
-                {
-                    X = 0,
-                    Y = 0,
-                    Width = texture.Size.Width,
-                    Height = texture.Size.Height,
-                },
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                scale: scale,
-                options: options,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+			Vector2 position,
+			RectangleF? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			Vector2 scale,
+			SpriteOptions options,
+			float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle ?? new()
+			{
+				X = 0,
+				Y = 0,
+				Width = image.Width,
+				Height = image.Height,
+			},
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			scale: scale,
+			options: options,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                scale: scale,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+			Vector2 position,
+			RectangleF? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			Vector2 scale,
+			float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			scale: scale,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float scale,
-                SpriteOptions options,
-                float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                scale: new Vector2(scale),
-                options: options,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+			Vector2 position,
+			RectangleF? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			float scale,
+			SpriteOptions options,
+			float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			scale: new Vector2(scale),
+			options: options,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(ITexture2D texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float scale,
-                float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                scale: scale,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+			Vector2 position,
+			RectangleF? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			float scale,
+			float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			scale: scale,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-            Vector2 position,
-            RectangleF? sourceRectangle,
-            Color color,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                rotation: 0f,
-                origin: default,
-                scale: 0f,
-                options: options,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		Vector2 position,
+		RectangleF? sourceRectangle,
+		Color color,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			rotation: 0f,
+			origin: default,
+			scale: 0f,
+			options: options,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-            Vector2 position,
-            RectangleF? sourceRectangle,
-            Color color,
-            float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		Vector2 position,
+		RectangleF? sourceRectangle,
+		Color color,
+		float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-            RectangleF destinationRectangle,
-            RectangleF? sourceRectangle,
-            Color color,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            Draw(texture: texture,
-                destinationRectangle: destinationRectangle,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                rotation: 0,
-                origin: default,
-                options: options,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		RectangleF destinationRectangle,
+		RectangleF? sourceRectangle,
+		Color color,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		Draw(image: image,
+			destinationRectangle: destinationRectangle,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			rotation: 0,
+			origin: default,
+			options: options,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-            RectangleF destinationRectangle,
-            RectangleF? sourceRectangle,
-            Color color,
-            float layerDepth)
-        {
-            Draw(texture: texture,
-                destinationRectangle:
-                destinationRectangle,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		RectangleF destinationRectangle,
+		RectangleF? sourceRectangle,
+		Color color,
+		float layerDepth)
+	{
+		Draw(image: image,
+			destinationRectangle:
+			destinationRectangle,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
+
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		Vector2 position,
+		Color color,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: new Rectangle(default, image.Size),
+			color: color,
+			rotation: 0,
+			origin: default,
+			scale: default,
+			options: options,
+			layerDepth: layerDepth);
+	}
+
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		Vector2 position,
+		Color color,
+		float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			color: color,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
+
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		RectangleF destinationRectangle,
+		Color color,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		Draw(image: image,
+			destinationRectangle: destinationRectangle,
+			sourceRectangle: new Rectangle(default, image.Size),
+			color: color,
+			rotation: 0,
+			origin: default,
+			options: options,
+			layerDepth: layerDepth);
+	}
+
+	/// <inheritdoc/>
+	public void Draw(Image image,
+		RectangleF destinationRectangle,
+		Color color,
+		float layerDepth)
+	{
+		Draw(image: image,
+			destinationRectangle: destinationRectangle,
+			color: color,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
+	#endregion
+
+	#region ISpriteBatch<TImage>
+
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+			RectangleF destinationRectangle,
+			RectangleF sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			float layerDepth)
+	{
+		Draw(image: image,
+			destinationRectangle: destinationRectangle,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
+
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+			Vector2 position,
+			RectangleF sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			Vector2 scale,
+			float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			scale: scale,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
+
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		RectangleF destinationRectangle,
+		RectangleF? sourceRectangle,
+		Color color,
+		float rotation,
+		Vector2 origin,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		var size = GetSize(image);
+		Draw(image: image,
+			destinationRectangle: destinationRectangle,
+			sourceRectangle: sourceRectangle ?? new()
+			{
+				X = 0,
+				Y = 0,
+				Width = size.Width,
+				Height = size.Height,
+			},
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			options: options,
+			layerDepth: layerDepth);
+	}
+
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		RectangleF destinationRectangle,
+		RectangleF? sourceRectangle,
+		Color color,
+		float rotation,
+		Vector2 origin,
+		float layerDepth)
+	{
+		Draw(image, destinationRectangle, sourceRectangle, color, rotation, origin, SpriteOptions.None, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-            Vector2 position,
-            Color color,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: new Rectangle(default, texture.Size),
-                color: color,
-                rotation: 0,
-                origin: default,
-                scale: default,
-                options: options,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+			Vector2 position,
+			RectangleF? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			Vector2 scale,
+			SpriteOptions options,
+			float layerDepth)
+	{
+		var size = GetSize(image);
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle ?? new()
+			{
+				X = 0,
+				Y = 0,
+				Width = size.Width,
+				Height = size.Height,
+			},
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			scale: scale,
+			options: options,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-            Vector2 position,
-            Color color,
-            float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                color: color,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+			Vector2 position,
+			RectangleF? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			Vector2 scale,
+			float layerDepth)
+	{
+		Draw(image: image,
+			position: position,
+			sourceRectangle: sourceRectangle,
+			color: color,
+			rotation: rotation,
+			origin: origin,
+			scale: scale,
+			options: SpriteOptions.None,
+			layerDepth: layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-            RectangleF destinationRectangle,
-            Color color,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            Draw(texture: texture,
-                destinationRectangle: destinationRectangle,
-                sourceRectangle: new Rectangle(default, texture.Size),
-                color: color,
-                rotation: 0,
-                origin: default,
-                options: options,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+			Vector2 position,
+			RectangleF? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			float scale,
+			SpriteOptions options,
+			float layerDepth)
+	{
+		Draw(image, position, sourceRectangle, color, rotation, origin, new Vector2(scale), options, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(ITexture2D texture,
-            RectangleF destinationRectangle,
-            Color color,
-            float layerDepth)
-        {
-            Draw(texture: texture,
-                destinationRectangle: destinationRectangle,
-                color: color,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
-        #endregion
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+			Vector2 position,
+			RectangleF? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			float scale,
+			float layerDepth)
+	{
+		Draw(image, position, sourceRectangle, color, rotation, origin, scale, SpriteOptions.None, layerDepth);
+	}
 
-        #region ISpriteBatch<TTexture>
-        
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-                RectangleF destinationRectangle,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float layerDepth)
-        {
-            Draw(texture: texture,
-                destinationRectangle: destinationRectangle,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		Vector2 position,
+		RectangleF? sourceRectangle,
+		Color color,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		Draw(image, position, sourceRectangle, color, 0f, default, 0f, options, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                scale: scale,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		Vector2 position,
+		RectangleF? sourceRectangle,
+		Color color,
+		float layerDepth)
+	{
+		Draw(image, position, sourceRectangle, color, SpriteOptions.None, layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(TTexture texture,
-            RectangleF destinationRectangle,
-            RectangleF? sourceRectangle,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            //var srcRect = sourceRectangleF ?? new(0, 0, texture.Size.Width, texture.Size.Height);
-            Draw(texture: texture,
-                destinationRectangle: destinationRectangle,
-                sourceRectangle: sourceRectangle ?? new()
-                {
-                    X = 0,
-                    Y = 0,
-                    Width = texture.Size.Width,
-                    Height = texture.Size.Height,
-                },
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                options: options,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		RectangleF destinationRectangle,
+		RectangleF? sourceRectangle,
+		Color color,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		Draw(image, destinationRectangle, sourceRectangle, color, 0, default, options, layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(TTexture texture,
-            RectangleF destinationRectangle,
-            RectangleF? sourceRectangle,
-            Color color,
-            float rotation,
-            Vector2 origin,
-            float layerDepth)
-        {
-            Draw(texture, destinationRectangle, sourceRectangle, color, rotation, origin, SpriteOptions.None, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		RectangleF destinationRectangle,
+		RectangleF? sourceRectangle,
+		Color color,
+		float layerDepth)
+	{
+		Draw(image, destinationRectangle, sourceRectangle, color, SpriteOptions.None, layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                SpriteOptions options,
-                float layerDepth)
-        {
-            //var srcRect = sourceRectangleF ?? new(0, 0, texture.Size.Width, texture.Size.Height);
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle ?? new()
-                {
-                    X = 0,
-                    Y = 0,
-                    Width = texture.Size.Width,
-                    Height = texture.Size.Height,
-                },
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                scale: scale,
-                options: options,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		Vector2 position,
+		Color color,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		Draw(image, position, new Rectangle(default, GetSize(image)), color, 0, default, default, options, layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                Vector2 scale,
-                float layerDepth)
-        {
-            Draw(texture: texture,
-                position: position,
-                sourceRectangle: sourceRectangle,
-                color: color,
-                rotation: rotation,
-                origin: origin,
-                scale: scale,
-                options: SpriteOptions.None,
-                layerDepth: layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		Vector2 position,
+		Color color,
+		float layerDepth)
+	{
+		Draw(image, position, new Rectangle(default, GetSize(image)), color, 0, default, default, SpriteOptions.None, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float scale,
-                SpriteOptions options,
-                float layerDepth)
-        {
-            Draw(texture, position, sourceRectangle, color, rotation, origin, new Vector2(scale), options, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		RectangleF destinationRectangle,
+		Color color,
+		SpriteOptions options,
+		float layerDepth)
+	{
+		Draw(image, destinationRectangle, new Rectangle(default, GetSize(image)), color, 0, default, options, layerDepth);
+	}
 
-        /// <inheritdoc/>
-		public void Draw(TTexture texture,
-                Vector2 position,
-                RectangleF? sourceRectangle,
-                Color color,
-                float rotation,
-                Vector2 origin,
-                float scale,
-                float layerDepth)
-        {
-            Draw(texture, position, sourceRectangle, color, rotation, origin, scale, SpriteOptions.None, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void Draw(TImage image,
+		RectangleF destinationRectangle,
+		Color color,
+		float layerDepth)
+	{
+		Draw(image, destinationRectangle, color, SpriteOptions.None, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-            Vector2 position,
-            RectangleF? sourceRectangle,
-            Color color,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            Draw(texture, position, sourceRectangle, color, 0f, default, 0f, options, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void DrawRect(RectangleF rectangle, Color color, float rotation, Vector2 origin, float layerDepth)
+	{
+		Draw(m_whiteImage, rectangle, new RectangleF(0, 0, 1, 1), color, rotation, origin, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-            Vector2 position,
-            RectangleF? sourceRectangle,
-            Color color,
-            float layerDepth)
-        {
-            Draw(texture, position, sourceRectangle, color, SpriteOptions.None, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void DrawRect(RectangleF rectangle, Color color, float layerDepth)
+	{
+		Draw(m_whiteImage, rectangle, new RectangleF(0, 0, 1, 1), color, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-            RectangleF destinationRectangle,
-            RectangleF? sourceRectangle,
-            Color color,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            Draw(texture, destinationRectangle, sourceRectangle, color, 0, default, options, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void DrawDot(Vector2 position, float size, Color color, float layerDepth)
+	{
+		Draw(m_whiteImage, new RectangleF(0, 0, size, size), new RectangleF(0, 0, 1, 1), color, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-            RectangleF destinationRectangle,
-            RectangleF? sourceRectangle,
-            Color color,
-            float layerDepth)
-        {
-            Draw(texture, destinationRectangle, sourceRectangle, color, SpriteOptions.None, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void DrawSegment(Vector2 a, Vector2 b, Color color, float thickness, float layerDepth)
+	{
+		var diff = b - a;
+		var length = MathF.Sqrt(Vector2.Dot(diff, diff));
+		var angle = MathF.Atan2(diff.Y, diff.X);
+		DrawSegment(a, length, color, angle, thickness, layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-            Vector2 position,
-            Color color,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            Draw(texture, position, new Rectangle(default, texture.Size), color, 0, default, default, options, layerDepth);
-        }
+	/// <inheritdoc/>
+	public void DrawSegment(Vector2 start, float length, Color color, float angle, float thickness, float layerDepth)
+	{
+		var rect = new RectangleF(start.X, start.Y, length, thickness);
+		DrawRect(rect, color, angle, new Vector2(0, 0.5f), layerDepth);
+	}
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-            Vector2 position,
-            Color color,
-            float layerDepth)
-        {
-            Draw(texture, position, new Rectangle(default, texture.Size), color, 0, default, default, SpriteOptions.None, layerDepth);
-        }
+	#endregion
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-            RectangleF destinationRectangle,
-            Color color,
-            SpriteOptions options,
-            float layerDepth)
-        {
-            Draw(texture, destinationRectangle, new Rectangle(default, texture.Size), color, 0, default, options, layerDepth);
-        }
+	/// <summary>
+	/// Gets size of a image.
+	/// </summary>
+	/// <param name="image">Image.</param>
+	/// <returns>Image Size.</returns>
+	protected abstract Size GetSize(TImage image);
 
-        /// <inheritdoc/>
-        public void Draw(TTexture texture,
-            RectangleF destinationRectangle,
-            Color color,
-            float layerDepth)
-        {
-            Draw(texture, destinationRectangle, color, SpriteOptions.None, layerDepth);
-        }
-        #endregion
-    }
+	/// <summary>
+	/// Gets TImage.
+	/// </summary>
+	/// <param name="image"></param>
+	/// <returns></returns>
+	protected abstract TImage GetHandle(Image image);
 }

src/Peridot/SpriteOptions.cs

···
-namespace Peridot
+namespace Peridot;
+
+/// <summary>
+/// Defines sprite options.
+/// </summary>
+[Flags]
+public enum SpriteOptions
 {
     /// <summary>
-    /// Defines sprite options.
+    /// Nothing is applied in sprite rendering.
+    /// </summary>
+    None,
+    /// <summary>
+    /// Horizontal flip is applied in sprite rendering.
+    /// </summary>
+    FlipHorizontally,
+    /// <summary>
+    /// Vertical flip is applied in sprite rendering.
     /// </summary>
-    [Flags]
-    public enum SpriteOptions
-    {
-        /// <summary>
-        /// Nothing is applied in sprite rendering.
-        /// </summary>
-        None,
-        /// <summary>
-        /// Horizontal flip is applied in sprite rendering.
-        /// </summary>
-        FlipHorizontally,
-        /// <summary>
-        /// Vertical flip is applied in sprite rendering.
-        /// </summary>
-        FlipVertically,
-    }
+    FlipVertically,
 }

src/Peridot/Text/Font.cs

···
+using System.Numerics;
+using FontStashSharp;
+
+namespace Peridot.Text
+{
+	/// <summary>
+	/// Represents a font that can be rendered with <see cref="TextRenderer"/>.
+	/// </summary>
+	public class Font
+	{
+		/// <summary>
+		/// Creates a new instance of <see cref="Font"/>.
+		/// </summary>
+		public Font()
+		{
+			var settings = new FontSystemSettings
+			{
+				Effect = FontSystemEffect.None,
+				EffectAmount = 2,
+			};
+			FontSystem = new FontSystem(settings);
+		}
+		
+		/// <summary>
+		/// Destroys font.
+		/// </summary>
+		~Font()
+		{
+			Dispose(false);
+		}
+
+		internal FontSystem FontSystem { get; }
+
+		/// <summary>
+		/// A bool indicating whether this instance has been disposed.
+		/// </summary>
+		public bool IsDisposed { get; private set; }
+
+		/// <summary>
+		/// Add a character font to the font.
+		/// </summary>
+		/// <param name="stream">The stream that contains the font.</param>
+		public void AddFont(Stream stream)
+		{
+			FontSystem.AddFont(stream);
+		}
+
+		/// <summary>
+		/// Add a character font to the font.
+		/// </summary>
+		/// <param name="data">The data that contains the font.</param>
+		public void AddFont(byte[] data)
+		{
+			FontSystem.AddFont(data);
+		}
+
+		/// <summary>
+		/// Gets the size of a string when rendered in this font.
+		/// </summary>
+		/// <param name="text">The text to measure.</param>
+		/// <param name="fontSize">The font size to measure.</param>
+		/// <returns>The size of <paramref name="text"/> rendered with <paramref name="fontSize"/> font size.</returns>
+		public Vector2 MeasureString(string text, int fontSize)
+		{
+			var font = FontSystem.GetFont(fontSize);
+			return font.MeasureString(text);
+		}
+
+		/// <inheritdoc/>
+		public void Dispose()
+		{
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		private void Dispose(bool disposing)
+		{
+			if (disposing)
+				FontSystem.Dispose();
+		}
+	}
+}

src/Peridot/Text/FontRenderer.cs

···
+// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
+// This code is licensed under MIT license (see LICENSE for details)
+
+using FontStashSharp;
+using FontStashSharp.Interfaces;
+using System.Diagnostics;
+using System.Drawing;
+using System.Numerics;
+
+namespace Peridot
+{
+	internal class FontStashRenderer : IFontStashRenderer, IDisposable
+	{
+		private bool m_disposed;
+		private readonly ISpriteBatch m_spriteBatch;
+		private readonly Texture2DManager m_textureManager;
+		public FontStashRenderer(IPeridot peridot, ISpriteBatch spriteBatch)
+		{
+			m_spriteBatch = spriteBatch;
+			m_textureManager = new Texture2DManager(peridot);
+			ResetScissor();
+		}
+
+		~FontStashRenderer()
+		{
+			Dispose(false);
+		}
+
+		public Rectangle Scissor { get; set; }
+
+		public ITexture2DManager TextureManager => m_textureManager;
+		
+		private void Dispose(bool disposing)
+		{
+			if (m_disposed)
+				return;
+			m_disposed = true;
+			if (disposing)
+				m_textureManager.Dispose();
+		}
+		
+		public void Dispose()
+		{
+			Dispose(true);
+		}
+
+		public void ResetScissor()
+		{
+			const int v = 1 << 23;
+			const int s = -(1 << 22);
+			Scissor = new Rectangle(s, s, v, v);
+		}
+
+		public void Draw(object texture, Vector2 pos, Rectangle? src, FSColor color, float rotation, Vector2 scale, float depth)
+		{
+			Debug.Assert(texture is Image, "The texture object must be a Image.");
+			if (texture is not Image t)
+				throw new ArgumentException(nameof(texture));
+
+			var s = src ?? new(0, 0, (int)t.Width, (int)t.Height);
+
+			var oldScissor = m_spriteBatch.Scissor;
+			m_spriteBatch.Scissor = RectangleF.Intersect(m_spriteBatch.Scissor, Scissor);
+			m_spriteBatch.Draw(t, pos, s, ToColor(color), rotation, Vector2.Zero, new Vector2(scale.X, scale.Y), depth);
+			m_spriteBatch.Scissor = oldScissor;
+		}
+		
+		private static Color ToColor(in FSColor color)
+		{
+			return Color.FromArgb(color.A, color.R, color.G, color.B);
+		}
+
+		private class Texture2DManager : ITexture2DManager, IDisposable
+		{
+			private readonly List<WeakReference<Image>> m_images;
+			private readonly IPeridot m_peridot;
+			private bool m_disposed;
+			public Texture2DManager(IPeridot peridot)
+			{
+				m_images = new();
+				m_peridot = peridot;
+				m_disposed = false;
+			}
+			
+			~Texture2DManager()
+			{
+				Dispose(false);
+			}
+			
+			public object CreateTexture(int width, int height)
+			{
+				var image = m_peridot.CreateImage(new ImageDescription()
+				{
+					Format = PixelFormat.BGRA8,
+					Width = (uint)width,
+					Height = (uint)height,
+				});
+				m_images.Add(new WeakReference<Image>(image));
+				return image;
+			}
+
+			public Point GetTextureSize(object texture)
+			{
+				Debug.Assert(texture is Image);
+				Image image = (texture as Image)!;
+				return new Point(image.Width, image.Height);
+			}
+
+			public void SetTextureData(object texture, Rectangle bounds, byte[] data)
+			{
+				Debug.Assert(texture is Image);
+				
+				if (texture is not Image)
+					throw new NotImplementedException();
+				
+				m_peridot.UpdateImage<byte>(
+					(texture as Image)!,
+					data, 
+					(uint)bounds.X,
+					(uint)bounds.Y,
+					(uint)bounds.Width,
+					(uint)bounds.Height);
+			}
+			
+			public void Dispose()
+			{
+				Dispose(true);
+			}
+
+			private void Dispose(bool disposing)
+			{
+				if (m_disposed)
+					return;
+				m_disposed = true;
+
+				if (disposing)
+				{
+					foreach (var wt in m_images)
+						if (wt.TryGetTarget(out var texture))
+							texture.Dispose();
+				}
+			}
+		}
+	}
+}

src/Peridot/Text/TextRenderer.cs

···
+// Copyright (c) 2021 ezequias2d <[e-mail]> and the Peridot contributors
+// This code is licensed under MIT license (see LICENSE for details)
+
+using System.Drawing;
+using System.Numerics;
+
+namespace Peridot.Text
+{
+	/// <summary>
+	/// Represents an interface to a text renderer.
+	/// </summary>
+	public class TextRenderer : IDisposable
+	{
+		private readonly ISpriteBatch m_spriteBatch;
+		private readonly FontStashRenderer _textRenderer;
+
+		/// <summary>
+		/// Creates a new instance of <see cref="TextRenderer"/>.
+		/// </summary>
+		/// <param name="peridot">Peridot implementation.</param>
+		/// <param name="spriteBatch">SpriteBatch to use to render.</param>
+		public TextRenderer(IPeridot peridot, ISpriteBatch spriteBatch)
+		{
+			m_spriteBatch = spriteBatch;
+			_textRenderer = new(peridot, spriteBatch);
+		}
+
+		/// <inheritdoc/>
+		~TextRenderer()
+		{
+			Dispose(false);
+		}
+		
+		/// <summary>
+		/// A bool indicating whether this instance has been disposed.
+		/// </summary>
+		public bool IsDisposed { get; private set; }
+
+		/// <summary>
+		/// Submit a text string for drawing.
+		/// </summary>
+		/// <param name="font">The font to draw.</param>
+		/// <param name="fontSize">The font size.</param>
+		/// <param name="text">The text which will be drawn.</param>
+		/// <param name="position">The drawing location on screen.</param>
+		/// <param name="color">The text color.</param>
+		/// <param name="rotation">The rotation of the drawing.</param>
+		/// <param name="origin">The center of the rotation. (0, 0) for default.</param>
+		/// <param name="scale">The scaling of this drawing.</param>
+		/// <param name="layerDepth">The layer depth of this drawing.</param>
+		public void DrawString(
+			Font font,
+			int fontSize,
+			string text,
+			Vector2 position,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			Vector2 scale,
+			float layerDepth)
+		{
+			var rf = font.FontSystem.GetFont(fontSize);
+			var fcolor = new FontStashSharp.FSColor(color.R, color.G, color.B, color.A);
+			
+			rf.DrawText(_textRenderer, text, position, fcolor, scale, rotation, origin, layerDepth);
+		}
+
+		/// <summary>
+		/// Submit a text string for drawing.
+		/// </summary>
+		/// <param name="font">The font to draw.</param>
+		/// <param name="fontSize">The font size.</param>
+		/// <param name="text">The text which will be drawn.</param>
+		/// <param name="position">The drawing location on screen.</param>
+		/// <param name="color">The text color.</param>
+		/// <param name="rotation">The rotation of the drawing.</param>
+		/// <param name="origin">The center of the rotation. (0, 0) for default.</param>
+		/// <param name="scale">The scaling of this drawing.</param>
+		/// <param name="layerDepth">The layer depth of this drawing.</param>
+		/// <param name="scissor">The scissor rectangle.</param>
+		public void DrawString(
+			Font font,
+			int fontSize,
+			string text,
+			Vector2 position,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			Vector2 scale,
+			float layerDepth,
+			Rectangle scissor)
+		{
+			var rf = font.FontSystem.GetFont(fontSize);
+			var fcolor = new FontStashSharp.FSColor(color.R, color.G, color.B, color.A);
+			
+			_textRenderer.Scissor = scissor;
+			rf.DrawText(_textRenderer, text, position, fcolor, scale, rotation, origin, layerDepth);
+			_textRenderer.ResetScissor();
+		}
+
+		/// <summary>
+		/// Submit a text string for drawing.
+		/// </summary>
+		/// <param name="font">The font to draw.</param>
+		/// <param name="fontSize">The font size.</param>
+		/// <param name="text">The text which will be drawn.</param>
+		/// <param name="position">The drawing location on screen</param>
+		/// <param name="color">The text color.</param>
+		public void DrawString(
+			Font font,
+			int fontSize,
+			string text,
+			Vector2 position,
+			Color color)
+		{
+			DrawString(font, fontSize, text, position, color, 0, Vector2.Zero, Vector2.One, 0);
+		}
+
+		/// <summary>
+		/// Submit a text string for drawing.
+		/// </summary>
+		/// <param name="font">The font to draw.</param>
+		/// <param name="fontSize">The font size.</param>
+		/// <param name="text">The text which will be drawn.</param>
+		/// <param name="position">The drawing location on screen</param>
+		/// <param name="color">The text color.</param>
+		/// <param name="scissor">The scissor rectangle.</param>
+		public void DrawString(
+			Font font,
+			int fontSize,
+			string text,
+			Vector2 position,
+			Color color,
+			Rectangle scissor)
+		{
+			DrawString(font, fontSize, text, position, color, 0, Vector2.Zero, Vector2.One, 0, scissor);
+		}
+
+		/// <summary>
+		/// Submit a text string for drawing.
+		/// </summary>
+		/// <param name="font">The font to draw.</param>
+		/// <param name="fontSize">The font size.</param>
+		/// <param name="text">The text which will be drawn.</param>
+		/// <param name="position">The drawing location on screen</param>
+		/// <param name="color">The text color.</param>
+		/// <param name="rotation">The rotation of the drawing.</param>
+		/// <param name="origin">The center of the rotation. (0, 0) for default.</param>
+		/// <param name="scale">The scaling of this drawing.</param>
+		/// <param name="layerDepth">The layer depth of this drawing.</param>
+		public void DrawString(
+			Font font, 
+			int fontSize, 
+			string text, 
+			Vector2 position, 
+			Color color,
+			float rotation, 
+			Vector2 origin, 
+			float scale, 
+			float layerDepth)
+		{
+			DrawString(font, fontSize, text, position, color, rotation, origin, new Vector2(scale), layerDepth);
+		}
+
+		/// <summary>
+		/// Submit a text string for drawing.
+		/// </summary>
+		/// <param name="font">The font to draw.</param>
+		/// <param name="fontSize">The font size.</param>
+		/// <param name="text">The text which will be drawn.</param>
+		/// <param name="position">The drawing location on screen</param>
+		/// <param name="color">The text color.</param>
+		/// <param name="rotation">The rotation of the drawing.</param>
+		/// <param name="origin">The center of the rotation. (0, 0) for default.</param>
+		/// <param name="scale">The scaling of this drawing.</param>
+		/// <param name="layerDepth">The layer depth of this drawing.</param>
+		/// <param name="scissor">The scissor rectangle.</param>
+		public void DrawString(
+			Font font,
+			int fontSize,
+			string text,
+			Vector2 position,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			float scale,
+			float layerDepth,
+			Rectangle scissor)
+        {
+            DrawString(font, fontSize, text, position, color, rotation, origin, new Vector2(scale), layerDepth, scissor);
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+            Dispose(true);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (IsDisposed)
+                return;
+            IsDisposed = true;
+
+            if (disposing)
+            {
+
+            }
+        }
+    }
+}