Merge pull request #1 from unknownv2/feature/direct3d9-overlay-engine

Add Direct3D9 and Direct3D11 Overlay Engines

Author: unknownv2

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "deps/SharpDX.Desktop"]
+	path = deps/SharpDX.Desktop
+	url = git://github.com/unknownv2/SharpDX.Desktop.git

GraphicsHook.sln

@@ -11,9 +11,15 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{2FDEAA0B-9
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Direct3DCapture.Tests", "test\Direct3DCapture.Tests\Direct3DCapture.Tests.csproj", "{39FCDDD4-78AF-4F6F-BA40-724A5D1AE620}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DirectX.Direct3D9.Overlay", "src\DirectX.Direct3D9.Overlay\DirectX.Direct3D9.Overlay.csproj", "{A86B01F8-1FEA-485B-85D7-3941694EC0A4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DirectX.Direct3D9.Overlay", "src\DirectX.Direct3D9.Overlay\DirectX.Direct3D9.Overlay.csproj", "{A86B01F8-1FEA-485B-85D7-3941694EC0A4}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DirectX.Direct3D11.Overlay", "src\DirectX.Direct3D11.Overlay\DirectX.Direct3D11.Overlay.csproj", "{96BC579E-FAFD-4152-8AFC-81905D7BF210}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DirectX.Direct3D11.Overlay", "src\DirectX.Direct3D11.Overlay\DirectX.Direct3D11.Overlay.csproj", "{96BC579E-FAFD-4152-8AFC-81905D7BF210}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DirectX.Direct3D.Core", "src\DirectX.Direct3D.Core\DirectX.Direct3D.Core.csproj", "{224F9343-46F6-4654-9381-E35239D179F1}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DirectX.Direct3D10.Overlay", "src\DirectX.Direct3D10.Overlay\DirectX.Direct3D10.Overlay.csproj", "{409B3409-61FE-4614-B755-843689E50EF6}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpDX.Desktop", "deps\SharpDX.Desktop\SharpDX.Desktop\SharpDX.Desktop.csproj", "{4062A245-60C4-415C-84A2-FA3E5D6B9D3F}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -37,6 +43,18 @@ Global
 		{96BC579E-FAFD-4152-8AFC-81905D7BF210}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{96BC579E-FAFD-4152-8AFC-81905D7BF210}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{96BC579E-FAFD-4152-8AFC-81905D7BF210}.Release|Any CPU.Build.0 = Release|Any CPU
+		{224F9343-46F6-4654-9381-E35239D179F1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{224F9343-46F6-4654-9381-E35239D179F1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{224F9343-46F6-4654-9381-E35239D179F1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{224F9343-46F6-4654-9381-E35239D179F1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{409B3409-61FE-4614-B755-843689E50EF6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{409B3409-61FE-4614-B755-843689E50EF6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{409B3409-61FE-4614-B755-843689E50EF6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{409B3409-61FE-4614-B755-843689E50EF6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4062A245-60C4-415C-84A2-FA3E5D6B9D3F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4062A245-60C4-415C-84A2-FA3E5D6B9D3F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4062A245-60C4-415C-84A2-FA3E5D6B9D3F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4062A245-60C4-415C-84A2-FA3E5D6B9D3F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -46,6 +64,9 @@ Global
 		{39FCDDD4-78AF-4F6F-BA40-724A5D1AE620} = {2FDEAA0B-9F04-4CB1-89CF-EF668584453A}
 		{A86B01F8-1FEA-485B-85D7-3941694EC0A4} = {E9D61240-9E2C-4BD5-BEF1-607D3422EAAF}
 		{96BC579E-FAFD-4152-8AFC-81905D7BF210} = {E9D61240-9E2C-4BD5-BEF1-607D3422EAAF}
+		{224F9343-46F6-4654-9381-E35239D179F1} = {E9D61240-9E2C-4BD5-BEF1-607D3422EAAF}
+		{409B3409-61FE-4614-B755-843689E50EF6} = {E9D61240-9E2C-4BD5-BEF1-607D3422EAAF}
+		{4062A245-60C4-415C-84A2-FA3E5D6B9D3F} = {E9D61240-9E2C-4BD5-BEF1-607D3422EAAF}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {15C4F934-433D-4655-9D2C-5E30E7A936C3}

README.md

@@ -5,6 +5,23 @@ Example tool for hooking graphics APIs using [CoreHook](https://github.com/unkno
 
 Based on [Justin Stenning's Direct3DHook](https://github.com/spazzarama/Direct3DHook).
 
+## Requirements
+
+**[Building the sample requires the .NET Core 3.0 SDK, which can be downloaded here.](https://dotnet.microsoft.com/download/dotnet-core/3.0)**
+
+The Direct3D10 and Direct3D11 modules require the .NET Windows Form libraries, which are only available with .NET Core 3.0 and above.
+
+The `deps` folder contains the [`SharpDX.Desktop`](https://github.com/unknownv2/SharpDX.Desktop) library targeting .NET Core 3.0, which is used by the Direct3D10 and Direct3D11 sample modules.
+
+## Building
+
+Clone and build the sample with:
+
+```
+git clone --recursive git://github.com/unknownv2/graphics-hook.git
+cd graphics-hook
+dotnet build
+```
 
 ## References
 

deps/SharpDX.Desktop

@@ -4,4 +4,20 @@
     <TargetFramework>netstandard2.0</TargetFramework>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <OutputPath>$(OutputDir)</OutputPath>    
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <OutputPath>$(OutputDir)</OutputPath>    
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CoreHook" Version="1.0.3" />
+    <PackageReference Include="SharpDX.Direct3D9" Version="4.2.0" />
+    <PackageReference Include="SharpDX.Mathematics" Version="4.2.0" />
+  </ItemGroup>
+
 </Project>

src/Direct3DCapture/Direct3DCapture.csproj

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using DirectX.Direct3D.Core.Drawing;
+using DirectX.Direct3D.Core.Memory;
+
+namespace DirectX.Direct3D.Core
+{
+    public abstract class Direct3DHook : DisposableComponent, IDirect3DHook
+    {
+        protected List<IOverlay> Overlays { get; set; }
+
+        protected bool PendingUpdate;
+
+        public abstract void CreateHooks();
+    }
+}

src/DirectX.Direct3D.Core/Direct3DHook.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace DirectX.Direct3D.Core
+{
+    public enum Direct3DVersion
+    {
+        Auto,
+        Direct3D9,
+        Direct3D10,
+        Direct3D10_1,
+        Direct3D11,
+        Direct3D11_1,
+        Direct3D12
+    }
+}

src/DirectX.Direct3D.Core/Direct3DVersion.cs

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <OutputPath>$(OutputDir)</OutputPath>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <OutputPath>$(OutputDir)</OutputPath>    
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SharpDX" Version="4.2.0" />
+    <PackageReference Include="System.Drawing.Common" Version="4.6.0-preview.18571.3" />
+  </ItemGroup>
+
+</Project>

src/DirectX.Direct3D.Core/DirectX.Direct3D.Core.csproj

@@ -0,0 +1,40 @@
+using System;
+using System.Drawing;
+
+namespace DirectX.Direct3D.Core.Drawing
+{
+    public class FramesPerSecondOverlay : TextOverlay
+    {
+        private string _fpsText = "{0:N0} FPS";
+
+        private int _frameCount;
+        private int _lastTickCount;
+        private float _lastFrameRate;
+        public override string Text
+        {
+            get => string.Format(_fpsText, GetFramesPerSecond());
+            set => _fpsText = value;
+        }
+        public FramesPerSecondOverlay(Font font) : base(font)
+        {
+
+        }
+
+        public override void OnFrame()
+        {
+            _frameCount++;
+            var tickCount = Environment.TickCount;
+            if (Math.Abs(tickCount - _lastTickCount) > 1000)
+            {
+                _lastFrameRate = (float)_frameCount * 1000 / Math.Abs(tickCount - _lastTickCount);
+                _frameCount = 0;
+                _lastTickCount = tickCount;
+            }
+        }
+
+        public float GetFramesPerSecond()
+        {
+            return _lastFrameRate;
+        }
+    }
+}

src/DirectX.Direct3D.Core/Drawing/FramesPerSecondOverlay.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace DirectX.Direct3D.Core.Drawing
+{
+    public interface IOverlay : IOverlayElement
+    {
+        List<IOverlayElement> Elements { get; }
+    }
+}

src/DirectX.Direct3D.Core/Drawing/IOverlay.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace DirectX.Direct3D.Core.Drawing
+{
+    public interface IOverlayElement : ICloneable
+    {
+        bool Hidden { get; }
+
+        void OnFrame();
+    }
+}

src/DirectX.Direct3D.Core/Drawing/IOverlayElement.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DirectX.Direct3D.Core.Drawing
+{
+    public class ImageOverlay : OverlayElement
+    {
+    }
+}

src/DirectX.Direct3D.Core/Drawing/ImageOverlay.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+
+namespace DirectX.Direct3D.Core.Drawing
+{
+    [Serializable]
+    public class Overlay : IOverlay
+    {
+        public List<IOverlayElement> Elements { get; } = new List<IOverlayElement>();
+
+        public bool Hidden { get; set; }
+
+        public object Clone() => MemberwiseClone();
+
+        public void OnFrame()
+        {
+            foreach (var overlayElement in Elements)
+            {
+                overlayElement.OnFrame();
+            }
+        }
+    }
+}

src/DirectX.Direct3D.Core/Drawing/Overlay.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace DirectX.Direct3D.Core.Drawing
+{
+    public class OverlayElement : IOverlayElement, IDisposable
+    {
+        public virtual bool Hidden { get; set; }
+
+        public object Clone() => MemberwiseClone();
+
+        public virtual void OnFrame()
+        {
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected void SafeDispose(IDisposable disposableObject) => disposableObject?.Dispose();
+    }
+}

src/DirectX.Direct3D.Core/Drawing/OverlayElement.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DirectX.Direct3D.Core.Drawing
+{
+    public class TextOverlay : OverlayElement
+    {
+        public virtual string Text { get; set; }
+
+        public virtual System.Drawing.Font Font { get; set; } = System.Drawing.SystemFonts.DefaultFont;
+
+        public virtual System.Drawing.Color Color { get; set; } = System.Drawing.Color.Black;
+
+        public virtual System.Drawing.Point Location { get; set; }
+
+        public virtual bool AntiAliased { get; set; } = false;
+
+        public TextOverlay()
+        {
+        }
+
+        public TextOverlay(System.Drawing.Font font)
+        {
+            Font = font;
+        }
+    }
+}

src/DirectX.Direct3D.Core/Drawing/TextOverlay.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DirectX.Direct3D.Core
+{
+    public interface IDirect3DHook : IDisposable
+    {
+        void CreateHooks();
+    }
+}

src/DirectX.Direct3D.Core/IDirect3DHook.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DirectX.Direct3D.Core.Memory
+{
+    public abstract class DisposableBase : IDisposable
+    {
+        public bool IsDisposed { get; private set; }
+
+        public void Dispose()
+        {
+            CheckAndDispose(true);
+        }
+
+        private void CheckAndDispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                IsDisposed = true;
+            }
+        }
+
+        protected abstract void Dispose(bool disposing);
+    }
+}

src/DirectX.Direct3D.Core/Memory/DisposableBase.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using SharpDX;
+
+namespace DirectX.Direct3D.Core.Memory
+{
+    public class DisposableComponent : DisposableBase
+    {
+        protected DisposeCollector DisposeCollector { get; set; }
+
+        protected override void Dispose(bool disposeManagedResources)
+        {
+
+        }
+
+        protected internal T ToDispose<T>(T disposable)
+        {
+            if (!ReferenceEquals(disposable, null))
+            {
+                if (DisposeCollector == null)
+                {
+                    DisposeCollector = new DisposeCollector();
+                }
+
+                return DisposeCollector.Collect(disposable);
+            }
+
+            return default(T);
+        }
+
+        protected internal void RemoveAndDispose<T>(ref T disposable)
+        {
+            if (!ReferenceEquals(disposable, null))
+            {
+                DisposeCollector?.RemoveAndDispose(ref disposable);
+            }
+        }
+    }
+}

src/DirectX.Direct3D.Core/Memory/DisposableComponent.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace DirectX.Direct3D.Core.Memory
+{
+    public class DisposableEventArgs : EventArgs
+    {
+        public static readonly DisposableEventArgs DisposingEventArgs = new DisposableEventArgs(true);
+
+        public static readonly DisposableEventArgs NotDisposingEventArgs = new DisposableEventArgs(false);
+
+        public readonly bool Disposing;
+
+        private DisposableEventArgs(bool disposing)
+        {
+            Disposing = disposing;
+        }
+
+        public static DisposableEventArgs Get(bool disposing)
+        {
+            return disposing ? DisposingEventArgs : NotDisposingEventArgs;
+        }
+    }
+}

src/DirectX.Direct3D.Core/Memory/DisposableEventArgs.cs

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.0</TargetFramework>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <OutputPath>$(OutputDir)</OutputPath>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <OutputPath>$(OutputDir)</OutputPath>    
+  </PropertyGroup>
+  
+  <ItemGroup>
+    <PackageReference Include="CoreHook" Version="1.0.3" />
+    <PackageReference Include="Microsoft.WindowsDesktop.App" Version="3.0.0-alpha-27128-4" />
+    <PackageReference Include="SharpDX.Direct3D10" Version="4.2.0" />
+    <PackageReference Include="SharpDX.Mathematics" Version="4.2.0" />
+  </ItemGroup>
+
+</Project>

src/DirectX.Direct3D10.Overlay/DirectX.Direct3D10.Overlay.csproj

@@ -0,0 +1,129 @@
+using System;
+using SharpDX;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DirectX.Direct3D11.Overlay
+{
+    public abstract class Component : ComponentBase, IDisposable
+    {
+        /// <summary>
+        /// Gets or sets the disposables.
+        /// </summary>
+        /// <value>The disposables.</value>
+        protected DisposeCollector DisposeCollector { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Component"/> class.
+        /// </summary>
+        protected internal Component()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Component" /> class with an immutable name.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        protected Component(string name) : base(name)
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is attached to a collector.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this instance is attached to a collector; otherwise, <c>false</c>.
+        /// </value>
+        internal bool IsAttached { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is disposed.
+        /// </summary>
+        /// <value>
+        /// 	<c>true</c> if this instance is disposed; otherwise, <c>false</c>.
+        /// </value>
+        protected internal bool IsDisposed { get; private set; }
+
+        protected internal bool IsDisposing { get; private set; }
+
+        /// <summary>
+        /// Occurs when when Dispose is called.
+        /// </summary>
+        public event EventHandler<EventArgs> Disposing;
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources
+        /// </summary>
+        public void Dispose()
+        {
+            if (!IsDisposed)
+            {
+                IsDisposing = true;
+
+                // Call the disposing event.
+                var handler = Disposing;
+                if (handler != null)
+                {
+                    handler(this, EventArgs.Empty);
+                }
+
+                Dispose(true);
+                IsDisposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Disposes of object resources.
+        /// </summary>
+        /// <param name="disposeManagedResources">If true, managed resources should be
+        /// disposed of in addition to unmanaged resources.</param>
+        protected virtual void Dispose(bool disposeManagedResources)
+        {
+            if (disposeManagedResources)
+            {
+                // Dispose all ComObjects
+                if (DisposeCollector != null)
+                    DisposeCollector.Dispose();
+                DisposeCollector = null;
+            }
+        }
+
+        /// <summary>
+        /// Adds a disposable object to the list of the objects to dispose.
+        /// </summary>
+        /// <param name="toDisposeArg">To dispose.</param>
+        protected internal T ToDispose<T>(T toDisposeArg)
+        {
+            if (!ReferenceEquals(toDisposeArg, null))
+            {
+                if (DisposeCollector == null)
+                    DisposeCollector = new DisposeCollector();
+                return DisposeCollector.Collect(toDisposeArg);
+            }
+            return default(T);
+        }
+
+        /// <summary>
+        /// Dispose a disposable object and set the reference to null. Removes this object from the ToDispose list.
+        /// </summary>
+        /// <param name="objectToDispose">Object to dispose.</param>
+        protected internal void RemoveAndDispose<T>(ref T objectToDispose)
+        {
+            if (!ReferenceEquals(objectToDispose, null) && DisposeCollector != null)
+                DisposeCollector.RemoveAndDispose(ref objectToDispose);
+        }
+
+        /// <summary>
+        /// Removes a disposable object to the list of the objects to dispose.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="toDisposeArg">To dispose.</param>
+        protected internal void RemoveToDispose<T>(T toDisposeArg)
+        {
+            if (!ReferenceEquals(toDisposeArg, null) && DisposeCollector != null)
+                DisposeCollector.Remove(toDisposeArg);
+        }
+    }
+}

src/DirectX.Direct3D11.Overlay/Component.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+namespace DirectX.Direct3D11.Overlay
+{
+    public abstract class ComponentBase : IComponent, INotifyPropertyChanged
+    {
+        /// <summary>
+        /// Occurs while this component is disposing and before it is disposed.
+        /// </summary>
+        //internal event EventHandler<EventArgs> Disposing;
+        private string name;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the name of this instance is immutable.
+        /// </summary>
+        /// <value><c>true</c> if this instance is name immutable; otherwise, <c>false</c>.</value>
+        private readonly bool isNameImmutable;
+
+        private object tag;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ComponentBase" /> class with a mutable name.
+        /// </summary>
+        protected ComponentBase()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ComponentBase" /> class with an immutable name.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        protected ComponentBase(string name)
+        {
+            if (name != null)
+            {
+                this.name = name;
+                this.isNameImmutable = true;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of this component.
+        /// </summary>
+        /// <value>The name.</value>
+        [DefaultValue(null)]
+        public string Name
+        {
+            get { return name; }
+            set
+            {
+                if (isNameImmutable)
+                    throw new ArgumentException("Name property is immutable for this instance", "value");
+                if (name == value) return;
+                name = value;
+                OnPropertyChanged("Name");
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the tag associated to this object.
+        /// </summary>
+        /// <value>The tag.</value>
+#if !W8CORE
+        [Browsable(false)]
+#endif
+        [DefaultValue(null)]
+        public object Tag
+        {
+            get
+            {
+                return tag;
+            }
+            set
+            {
+                if (ReferenceEquals(tag, value)) return;
+                tag = value;
+                OnPropertyChanged("Tag");
+            }
+        }
+
+        /// <summary>
+        /// Occurs when a property value changes.
+        /// </summary>
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        protected virtual void OnPropertyChanged(string propertyName)
+        {
+            PropertyChangedEventHandler handler = PropertyChanged;
+            if (handler != null)
+            {
+                handler(this, new PropertyChangedEventArgs(propertyName));
+            }
+        }
+    }
+}

src/DirectX.Direct3D11.Overlay/ComponentBase.cs

@@ -0,0 +1,265 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using SharpDX.Direct3D11;
+using SharpDX;
+using System.Diagnostics;
+
+namespace DirectX.Direct3D11.Overlay
+{
+    public class DXFont : IDisposable
+    {
+        Device _device;
+        DeviceContext _deviceContext;
+
+        public DXFont(Device device, DeviceContext deviceContext)
+        {
+            _device = device;
+            _deviceContext = deviceContext;
+            _initialized = false;
+            _fontSheetTex = null;
+            _fontSheetSRV = null;
+            _texWidth = 1024;
+            _texHeight = 0;
+            _spaceWidth = 0;
+            _charHeight = 0;
+        }
+
+        public void Dispose()
+        {
+            if (_fontSheetTex != null)
+                _fontSheetTex.Dispose();
+            if (_fontSheetSRV != null)
+                _fontSheetSRV.Dispose();
+
+            _fontSheetTex = null;
+            _fontSheetSRV = null;
+            _device = null;
+            _deviceContext = null;
+        }
+
+        enum STYLE
+        {
+            STYLE_NORMAL = 0,
+            STYLE_BOLD = 1,
+            STYLE_ITALIC = 2,
+            STYLE_BOLD_ITALIC = 3,
+            STYLE_UNDERLINE = 4,
+            STYLE_STRIKEOUT = 8
+        };
+
+        bool _initialized;
+        const char StartChar = (char)33;
+        const char EndChar = (char)127;
+        const uint NumChars = EndChar - StartChar;
+        ShaderResourceView _fontSheetSRV;
+        Texture2D _fontSheetTex;
+        int _texWidth, _texHeight;
+        Rectangle[] _charRects = new Rectangle[NumChars];
+        int _spaceWidth, _charHeight;
+
+        public bool Initialize(string FontName, float FontSize, System.Drawing.FontStyle FontStyle, bool AntiAliased)
+        {
+            Debug.Assert(!_initialized);
+            System.Drawing.Font font = new System.Drawing.Font(FontName, FontSize, FontStyle, System.Drawing.GraphicsUnit.Pixel);
+
+            System.Drawing.Text.TextRenderingHint hint = AntiAliased ? System.Drawing.Text.TextRenderingHint.AntiAlias : System.Drawing.Text.TextRenderingHint.SystemDefault;
+
+            int tempSize = (int)(FontSize * 2);
+            using (System.Drawing.Bitmap charBitmap = new System.Drawing.Bitmap(tempSize, tempSize, System.Drawing.Imaging.PixelFormat.Format32bppArgb))
+            {
+                using (System.Drawing.Graphics charGraphics = System.Drawing.Graphics.FromImage(charBitmap))
+                {
+                    charGraphics.PageUnit = System.Drawing.GraphicsUnit.Pixel;
+                    charGraphics.TextRenderingHint = hint;
+
+                    MeasureChars(font, charGraphics);
+
+                    using (var fontSheetBitmap = new System.Drawing.Bitmap(_texWidth, _texHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb))
+                    {
+                        using (var fontSheetGraphics = System.Drawing.Graphics.FromImage(fontSheetBitmap))
+                        {
+                            fontSheetGraphics.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
+                            fontSheetGraphics.Clear(System.Drawing.Color.FromArgb(0, System.Drawing.Color.Black));
+
+                            BuildFontSheetBitmap(font, charGraphics, charBitmap, fontSheetGraphics);
+
+                            if (!BuildFontSheetTexture(fontSheetBitmap))
+                            {
+                                return false;
+                            }
+                        }
+                    }
+                }
+            }
+
+            _initialized = true;
+
+            return true;
+        }
+
+        private bool BuildFontSheetTexture(System.Drawing.Bitmap fontSheetBitmap)
+        {
+            System.Drawing.Imaging.BitmapData bmData;
+
+            bmData = fontSheetBitmap.LockBits(new System.Drawing.Rectangle(0, 0, _texWidth, _texHeight), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+            Texture2DDescription texDesc = new Texture2DDescription();
+            texDesc.Width = _texWidth;
+            texDesc.Height = _texHeight;
+            texDesc.MipLevels = 1;
+            texDesc.ArraySize = 1;
+            texDesc.Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm;
+            texDesc.SampleDescription.Count = 1;
+            texDesc.SampleDescription.Quality = 0;
+            texDesc.Usage = ResourceUsage.Immutable;
+            texDesc.BindFlags = BindFlags.ShaderResource;
+            texDesc.CpuAccessFlags = CpuAccessFlags.None;
+            texDesc.OptionFlags = ResourceOptionFlags.None;
+
+
+            SharpDX.DataBox data;
+            data.DataPointer = bmData.Scan0;
+            data.RowPitch = _texWidth * 4;
+            data.SlicePitch = 0;
+
+            _fontSheetTex = new Texture2D(_device, texDesc, new[] { data });
+            if (_fontSheetTex == null)
+                return false;
+
+            ShaderResourceViewDescription srvDesc = new ShaderResourceViewDescription();
+            srvDesc.Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm;
+            srvDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D;
+            srvDesc.Texture2D.MipLevels = 1;
+            srvDesc.Texture2D.MostDetailedMip = 0;
+
+            _fontSheetSRV = new ShaderResourceView(_device, _fontSheetTex, srvDesc);
+            if (_fontSheetSRV == null)
+                return false;
+
+            fontSheetBitmap.UnlockBits(bmData);
+
+            return true;
+        }
+
+        void MeasureChars(System.Drawing.Font font, System.Drawing.Graphics charGraphics)
+        {
+            char[] allChars = new char[NumChars];
+
+            for (char i = (char)0; i < NumChars; ++i)
+                allChars[i] = (char)(StartChar + i);
+
+            System.Drawing.SizeF size;
+            size = charGraphics.MeasureString(new String(allChars), font, new System.Drawing.PointF(0, 0), System.Drawing.StringFormat.GenericDefault);
+
+            _charHeight = (int)(size.Height + 0.5f);
+
+            int numRows = (int)(size.Width / _texWidth) + 1;
+            _texHeight = (numRows * _charHeight) + 1;
+
+            System.Drawing.StringFormat sf = System.Drawing.StringFormat.GenericDefault;
+            sf.FormatFlags |= System.Drawing.StringFormatFlags.MeasureTrailingSpaces;
+            size = charGraphics.MeasureString(" ", font, 0, sf);
+            _spaceWidth = (int)(size.Width + 0.5f);
+        }
+
+        void BuildFontSheetBitmap(System.Drawing.Font font, System.Drawing.Graphics charGraphics, System.Drawing.Bitmap charBitmap, System.Drawing.Graphics fontSheetGraphics)
+        {
+            System.Drawing.Brush whiteBrush = System.Drawing.Brushes.White;
+            int fontSheetX = 0;
+            int fontSheetY = 0;
+
+
+            for (int i = 0; i < NumChars; ++i)
+            {
+                charGraphics.Clear(System.Drawing.Color.FromArgb(0, System.Drawing.Color.Black));
+                charGraphics.DrawString(((char)(StartChar + i)).ToString(), font, whiteBrush, new System.Drawing.PointF(0.0f, 0.0f));
+
+                int minX = GetCharMinX(charBitmap);
+                int maxX = GetCharMaxX(charBitmap);
+                int charWidth = maxX - minX + 1;
+
+                if (fontSheetX + charWidth >= _texWidth)
+                {
+                    fontSheetX = 0;
+                    fontSheetY += (int)(_charHeight) + 1;
+                }
+
+                _charRects[i] = new Rectangle(fontSheetX, fontSheetY, charWidth, _charHeight);
+
+                fontSheetGraphics.DrawImage(charBitmap, fontSheetX, fontSheetY, new System.Drawing.Rectangle(minX, 0, charWidth, _charHeight), System.Drawing.GraphicsUnit.Pixel);
+
+                fontSheetX += charWidth + 1;
+            }
+        }
+
+        private int GetCharMaxX(System.Drawing.Bitmap charBitmap)
+        {
+            int width = charBitmap.Width;
+            int height = charBitmap.Height;
+
+            for (int x = width - 1; x >= 0; --x)
+            {
+                for (int y = 0; y < height; ++y)
+                {
+                    System.Drawing.Color color;
+
+                    color = charBitmap.GetPixel(x, y);
+                    if (color.A > 0)
+                        return x;
+                }
+            }
+
+            return width - 1;
+        }
+
+        private int GetCharMinX(System.Drawing.Bitmap charBitmap)
+        {
+            int width = charBitmap.Width;
+            int height = charBitmap.Height;
+
+            for (int x = 0; x < width; ++x)
+            {
+                for (int y = 0; y < height; ++y)
+                {
+                    System.Drawing.Color color;
+
+                    color = charBitmap.GetPixel(x, y);
+                    if (color.A > 0)
+                        return x;
+                }
+            }
+
+            return 0;
+        }
+
+        public ShaderResourceView GetFontSheetSRV()
+        {
+            Debug.Assert(_initialized);
+
+            return _fontSheetSRV;
+        }
+
+        public Rectangle GetCharRect(char c)
+        {
+            Debug.Assert(_initialized);
+
+            return _charRects[c - StartChar];
+        }
+
+        public int GetSpaceWidth()
+        {
+            Debug.Assert(_initialized);
+
+            return _spaceWidth;
+        }
+
+        public int GetCharHeight()
+        {
+            Debug.Assert(_initialized);
+
+            return _charHeight;
+        }
+
+    }
+}

src/DirectX.Direct3D11.Overlay/DXFont.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using SharpDX.Direct3D11;
+using SharpDX;
+using System.Diagnostics;
+
+namespace DirectX.Direct3D11.Overlay
+{
+    public class DXImage : Component
+    {
+        Device _device;
+        DeviceContext _deviceContext;
+        Texture2D _tex;
+        ShaderResourceView _texSRV;
+        int _texWidth, _texHeight;
+        bool _initialised = false;
+
+        public int Width
+        {
+            get
+            {
+                return _texWidth;
+            }
+        }
+
+        public int Height
+        {
+            get
+            {
+                return _texHeight;
+            }
+        }
+
+        public Device Device
+        {
+            get { return _device; }
+        }
+
+        public DXImage(Device device, DeviceContext deviceContext) : base("DXImage")
+        {
+            _device = device;
+            _deviceContext = deviceContext;
+            _tex = null;
+            _texSRV = null;
+            _texWidth = 0;
+            _texHeight = 0;
+        }
+
+        public bool Initialise(System.Drawing.Bitmap bitmap)
+        {
+            RemoveAndDispose(ref _tex);
+            RemoveAndDispose(ref _texSRV);
+
+            //Debug.Assert(bitmap.PixelFormat == System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+            System.Drawing.Imaging.BitmapData bmData;
+
+            _texWidth = bitmap.Width;
+            _texHeight = bitmap.Height;
+
+            bmData = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, _texWidth, _texHeight), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+            try
+            {
+                Texture2DDescription texDesc = new Texture2DDescription();
+                texDesc.Width = _texWidth;
+                texDesc.Height = _texHeight;
+                texDesc.MipLevels = 1;
+                texDesc.ArraySize = 1;
+                texDesc.Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm;
+                texDesc.SampleDescription.Count = 1;
+                texDesc.SampleDescription.Quality = 0;
+                texDesc.Usage = ResourceUsage.Immutable;
+                texDesc.BindFlags = BindFlags.ShaderResource;
+                texDesc.CpuAccessFlags = CpuAccessFlags.None;
+                texDesc.OptionFlags = ResourceOptionFlags.None;
+
+                SharpDX.DataBox data;
+                data.DataPointer = bmData.Scan0;
+                data.RowPitch = bmData.Stride;// _texWidth * 4;
+                data.SlicePitch = 0;
+
+                _tex = ToDispose(new Texture2D(_device, texDesc, new[] { data }));
+                if (_tex == null)
+                    return false;
+
+                ShaderResourceViewDescription srvDesc = new ShaderResourceViewDescription();
+                srvDesc.Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm;
+                srvDesc.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D;
+                srvDesc.Texture2D.MipLevels = 1;
+                srvDesc.Texture2D.MostDetailedMip = 0;
+
+                _texSRV = ToDispose(new ShaderResourceView(_device, _tex, srvDesc));
+                if (_texSRV == null)
+                    return false;
+            }
+            finally
+            {
+                bitmap.UnlockBits(bmData);
+            }
+
+            _initialised = true;
+
+            return true;
+        }
+
+        public ShaderResourceView GetSRV()
+        {
+            Debug.Assert(_initialised);
+            return _texSRV;
+        }
+    }
+}

src/DirectX.Direct3D11.Overlay/DXImage.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Drawing;
+using CoreHook;
+using DirectX.Direct3D.Core.Drawing;
+using DirectX.Direct3D.Core;
+using SharpDX.Direct3D;
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using Device = SharpDX.Direct3D11.Device;
+
+namespace DirectX.Direct3D11.Overlay
+{
+    internal class Direct3DHookModule : Direct3DHook
+    {
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
+        delegate int DXGISwapChain_PresentDelegate(IntPtr swapChain, int syncInterval, PresentFlags flags);
+
+        private IHook<DXGISwapChain_PresentDelegate> _d3DPresentHook;
+        private List<IntPtr> _d3DDeviceFunctions = new List<IntPtr>();
+        private OverlayRenderer _overlayRenderer;
+
+        public const int DXGI_SWAPCHAIN_METHOD_COUNT = 18;
+        Device _device;
+        SwapChain _swapChain;
+
+        private IntPtr _swapChainPtr;
+
+        private static SwapChainDescription CreateSwapChainDescription(IntPtr windowHandle)
+        {
+            return new SwapChainDescription
+            {
+                BufferCount = 1,
+                Flags = SwapChainFlags.None,
+                IsWindowed = true,
+                ModeDescription = new ModeDescription(100, 100, new Rational(60, 1), Format.R8G8B8A8_UNorm),
+                OutputHandle = windowHandle,
+                SampleDescription = new SampleDescription(1, 0),
+                SwapEffect = SwapEffect.Discard,
+                Usage = Usage.RenderTargetOutput
+            };
+        }
+
+        public override void CreateHooks()
+        {
+            var renderForm = new SharpDX.Windows.RenderForm();
+            Device.CreateWithSwapChain(
+                DriverType.Hardware,
+                DeviceCreationFlags.BgraSupport,
+                CreateSwapChainDescription(renderForm.Handle),
+                out _device,
+                out _swapChain);
+
+            if (_swapChain != null)
+            {
+                _d3DDeviceFunctions.AddRange(ReadVTableAddresses(_swapChain.NativePointer, DXGI_SWAPCHAIN_METHOD_COUNT));
+            }
+
+            _d3DPresentHook = HookFactory.CreateHook<DXGISwapChain_PresentDelegate>(
+                _d3DDeviceFunctions[(int)FunctionOrdinals.Present],
+                Detour_Present,
+                this);
+
+            Overlays = new List<IOverlay>
+            {
+                // Add the Frames Per Second overlay
+                new Direct3D.Core.Drawing.Overlay
+                {
+                    Elements =
+                    {
+                        new FramesPerSecondOverlay(new Font("Arial", 16, FontStyle.Bold))
+                        {
+                            Location = new Point(25, 25),
+                            Color = Color.Red,
+                            AntiAliased = true,
+                            Text = "{0:N0} FPS"
+                        }
+                    },
+                    Hidden = false
+                }
+            };
+
+            _d3DPresentHook.Enabled = true;
+        }
+
+        private static IEnumerable<IntPtr> ReadVTableAddresses(IntPtr vTableAddress, int vTableFunctionCount)
+        {
+            IntPtr[] addresses = new IntPtr[vTableFunctionCount];
+            IntPtr vTable = Marshal.ReadIntPtr(vTableAddress);
+            for (var i = 0; i < vTableFunctionCount; ++i)
+            {
+                addresses[i] = Marshal.ReadIntPtr(vTable, i * IntPtr.Size);
+            }
+            return addresses;
+        }
+
+        private int Detour_Present(IntPtr swapChainPtr, int syncInterval, SharpDX.DXGI.PresentFlags flags)
+        {
+            SwapChain swapChain = (SwapChain)swapChainPtr;
+
+            DrawFramesPerSecond(swapChain);
+
+            return _d3DPresentHook.Original(swapChainPtr, syncInterval, flags);
+        }
+
+        private void DrawFramesPerSecond(SwapChain swapChain)
+        {
+            Capture(swapChain);
+        }
+
+        private void Capture(SwapChain swapChain)
+        {
+           
+            try
+            {
+                // Draw any overlays
+                var displayOverlays = Overlays;
+                
+                if (_overlayRenderer == null ||
+                    _swapChainPtr != swapChain.NativePointer ||
+                    PendingUpdate)
+                {
+                    if (_overlayRenderer != null)
+                    {
+                        _overlayRenderer.Dispose();
+                    }
+
+                    _swapChainPtr = swapChain.NativePointer;
+
+                    _overlayRenderer = ToDispose((new OverlayRenderer()));
+                    _overlayRenderer.Overlays.AddRange(displayOverlays);
+                    _overlayRenderer.Initialize(swapChain);
+                    PendingUpdate = false;
+                }
+                
+                if (_overlayRenderer != null)
+                {
+                    foreach (var overlay in _overlayRenderer.Overlays)
+                    {
+                        overlay.OnFrame();
+                    }
+
+                    _overlayRenderer.DrawFrame();
+                }
+            }
+            catch (Exception e)
+            {
+                System.Diagnostics.Debug.WriteLine(e.ToString());
+            }
+        }
+    }
+}

src/DirectX.Direct3D11.Overlay/DXSprite.cs

@@ -1,13 +1,36 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netcoreapp3.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <OutputPath>$(OutputDir)</OutputPath>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <OutputPath>$(OutputDir)</OutputPath>    
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Debug|netcoreapp3.0|AnyCPU'">
+    <Optimize>false</Optimize>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="CoreHook" Version="1.0.3" />
+    <PackageReference Include="Microsoft.WindowsDesktop.App" Version="3.0.0-alpha-27128-4" />
+    <PackageReference Include="SharpDX.D3DCompiler" Version="4.2.0" />
     <PackageReference Include="SharpDX.Direct3D11" Version="4.2.0" />
+    <PackageReference Include="SharpDX.Direct3D11.Effects" Version="4.2.0" />
     <PackageReference Include="SharpDX.Mathematics" Version="4.2.0" />
+    <PackageReference Include="System.Drawing.Common" Version="4.6.0-preview.18571.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\deps\SharpDX.Desktop\SharpDX.Desktop\SharpDX.Desktop.csproj" />
+    <ProjectReference Include="..\DirectX.Direct3D.Core\DirectX.Direct3D.Core.csproj" />
   </ItemGroup>
 
 </Project>

src/DirectX.Direct3D11.Overlay/Direct3DHookModule.cs

@@ -1,17 +1,27 @@
-using System;
-using CoreHook;
-using SharpDX;
-using SharpDX.Direct3D11;
+using CoreHook;
+using DirectX.Direct3D.Core;
 
 namespace DirectX.Direct3D11.Overlay
 {
     public class EntryPoint : IEntryPoint
     {
+        private Direct3DHook _direct3DHook;
+
         public EntryPoint(IContext context) { }
 
         public void Run(IContext context)
         {
+            InitializeDeviceHook();
+            while (true)
+            {
+                System.Threading.Thread.Sleep(30000);
+            }
+        }
 
+        private void InitializeDeviceHook()
+        {
+            _direct3DHook = new Direct3DHookModule();
+            _direct3DHook.CreateHooks();
         }
     }
 }

src/DirectX.Direct3D11.Overlay/DirectX.Direct3D11.Overlay.csproj

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DirectX.Direct3D11.Overlay
+{
+    public enum FunctionOrdinals : short
+    {
+        // IUnknown
+        QueryInterface = 0,
+        AddRef = 1,
+        Release = 2,
+
+        // IDXGIObject
+        SetPrivateData = 3,
+        SetPrivateDataInterface = 4,
+        GetPrivateData = 5,
+        GetParent = 6,
+
+        // IDXGIDeviceSubObject
+        GetDevice = 7,
+
+        // IDXGISwapChain
+        Present = 8,
+        GetBuffer = 9,
+        SetFullscreenState = 10,
+        GetFullscreenState = 11,
+        GetDesc = 12,
+        ResizeBuffers = 13,
+        ResizeTarget = 14,
+        GetContainingOutput = 15,
+        GetFrameStatistics = 16,
+        GetLastPresentCount = 17,
+    }
+}

src/DirectX.Direct3D11.Overlay/EntryPoint.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DirectX.Direct3D11.Overlay
+{
+
+    public interface IComponent
+    {
+        /// <summary>
+        /// Gets the name of this component.
+        /// </summary>
+        /// <value>The name.</value>
+        string Name { get; set; }
+    }
+}

src/DirectX.Direct3D11.Overlay/FunctionOrdinals.cs

@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using DirectX.Direct3D.Core.Drawing;
+using DirectX.Direct3D.Core.Memory;
+using SharpDX;
+using SharpDX.Direct3D11;
+
+namespace DirectX.Direct3D11.Overlay
+{
+    internal class OverlayRenderer : DisposableComponent
+    {
+        public List<IOverlay> Overlays { get; set; } = new List<IOverlay>();
+        private Device _device;
+        private Texture2D _renderTarget;
+        private RenderTargetView _renderTargetView;
+        private DXSprite _spriteEngine;
+        Dictionary<string, DXFont> _fontCache = new Dictionary<string, DXFont>();
+        private DeviceContext _deviceContext;
+        //private readonly Dictionary<string, Font> _fontCache = new Dictionary<string, Font>();
+        public bool DeferredContext
+        {
+            get => _deviceContext.TypeInfo == DeviceContextType.Deferred;
+        }
+
+
+
+        public Device Device => _device;
+ 
+        private bool _isInitialized;
+        private bool _isInitializing;
+
+        internal OverlayRenderer()
+        {
+        }
+
+        private void EnsureInitialized()
+        {
+            System.Diagnostics.Debug.Assert(_isInitialized);
+        }
+
+        internal bool Initialize(SharpDX.DXGI.SwapChain swapChain)
+        {
+            return Initialize(swapChain.GetDevice<Device>(), swapChain.GetBackBuffer<Texture2D>(0));
+        }
+
+        internal bool Initialize(Device device, Texture2D renderTarget)
+        {
+            if (_isInitializing)
+            {
+                return false;
+            }
+
+            _isInitializing = true;
+
+            try
+            {
+                _device = device;
+                _renderTarget = renderTarget;
+                try
+                {
+                    _deviceContext = ToDispose(new DeviceContext(_device));
+                }
+                catch(SharpDXException)
+                {
+                    _deviceContext = _device.ImmediateContext;
+                }
+
+                _renderTargetView = ToDispose(new RenderTargetView(_device, _renderTarget));
+                _spriteEngine = new DXSprite(_device, _deviceContext);
+                if(!_spriteEngine.Initialize())
+                {
+                    return false;
+                }
+
+                InitializeResources();
+
+                _isInitialized = true;
+            }
+            finally
+            {
+                _isInitializing = true;
+            }
+            return true;
+        }
+
+        private void InitializeResources()
+        {
+            foreach (var overlay in Overlays)
+            {
+                foreach (var overlayElement in overlay.Elements)
+                {
+                    if (overlayElement is TextOverlay textOverlay)
+                    {
+                        GetOverlayFont(textOverlay);
+                    }
+                }
+            }
+        }
+
+        private DXFont GetOverlayFont(TextOverlay textOverlay)
+        {
+            string fontKey =
+              $"{textOverlay.Font.Name}{textOverlay.Font.Size}{textOverlay.Font.Style}{textOverlay.AntiAliased}";
+
+            if (!_fontCache.TryGetValue(fontKey, out DXFont overlayFont))
+            {
+                overlayFont = ToDispose(new DXFont(_device, _deviceContext));
+                overlayFont.Initialize(textOverlay.Font.Name, textOverlay.Font.Size, textOverlay.Font.Style, textOverlay.AntiAliased);
+                _fontCache[fontKey] = overlayFont;
+            }
+            return overlayFont;
+        }
+
+        public void DrawFrame()
+        {
+            EnsureInitialized();
+
+            BeginFrame();
+
+            foreach (var overlay in Overlays)
+            {
+                foreach (var overlayElement in overlay.Elements)
+                {
+                    if (overlayElement.Hidden)
+                    {
+                        continue;
+                    }
+
+                    if (overlayElement is TextOverlay textOverlay)
+                    {
+                        var font = GetOverlayFont(textOverlay);
+                        if (font != null && !string.IsNullOrEmpty(textOverlay.Text))
+                        {
+                            _spriteEngine.DrawString(textOverlay.Location.X, textOverlay.Location.Y, textOverlay.Text,
+                                textOverlay.Color, font);
+                        }
+                    }
+                }
+            }
+
+            EndFrame();
+        }
+
+        private void BeginFrame()
+        {
+            SharpDX.Mathematics.Interop.RawViewportF[] viewport =
+            {
+                new ViewportF(0, 0, _renderTarget.Description.Width, _renderTarget.Description.Height, 0, 1)
+            };
+            _deviceContext.Rasterizer.SetViewports(viewport);
+            _deviceContext.OutputMerger.SetTargets(_renderTargetView);
+        }
+
+        private void EndFrame()
+        {
+            if(DeferredContext)
+            {
+                var commands = _deviceContext.FinishCommandList(true);
+                _device.ImmediateContext.ExecuteCommandList(commands, true);
+                commands.Dispose();
+            }
+        }
+        protected override void Dispose(bool disposing)
+        {
+            _device = null;
+        }
+    }
+}

src/DirectX.Direct3D11.Overlay/IComponent.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace DirectX.Direct3D11.Overlay
+{
+    /// <summary>
+    /// Provides a safe handle around a block of unmanaged memory.
+    /// </summary>
+    public class SafeHGlobal : SafeHandle
+    {
+        /// <summary>
+        /// When overridden in a derived class, gets a value indicating whether the handle value is invalid.
+        /// </summary>
+        /// <returns>true if the handle value is invalid; otherwise, false.</returns>
+        public override bool IsInvalid
+        {
+            get { return handle == IntPtr.Zero; }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SafeHGlobal"/> class.
+        /// </summary>
+        /// <param name="sizeInBytes">The size of the block of memory to allocate, in bytes.</param>
+        public SafeHGlobal(int sizeInBytes)
+            : base(Marshal.AllocHGlobal(sizeInBytes), true)
+        {
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, executes the code required to free the handle.
+        /// </summary>
+        /// <returns>
+        /// true if the handle is released successfully; otherwise, in the event of a catastrophic failure, false. In this case, it generates a releaseHandleFailed MDA Managed Debugging Assistant.
+        /// </returns>
+        protected override bool ReleaseHandle()
+        {
+            Marshal.FreeHGlobal(handle);
+            return true;
+        }
+    }
+}

src/DirectX.Direct3D11.Overlay/OverlayRenderer.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using DirectX.Direct3D.Core;
+using CoreHook;
+using DirectX.Direct3D.Core.Drawing;
+using SharpDX;
+using SharpDX.Direct3D9;
+using Color = System.Drawing.Color;
+using Font = SharpDX.Direct3D9.Font;
+using Rectangle = SharpDX.Rectangle;
+
+namespace DirectX.Direct3D9.Overlay
+{
+    internal class Direct3DHookModule : Direct3DHook
+    {
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
+        unsafe delegate int IDirect3DDevice9_PresentDelegate(IntPtr device, Rectangle* sourceRectangle,
+            Rectangle* destRectangle, IntPtr destWindowOverride, IntPtr dirtyRegion);
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
+        private delegate int IDirect3DDevice9_EndSceneDelegate(IntPtr device);
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
+        private delegate int IDirect3DDevice9_ResetDelegate(IntPtr device, ref PresentParameters parameters);
+
+        private IHook<IDirect3DDevice9_PresentDelegate> _d3DPresentHook;
+        private IHook<IDirect3DDevice9_EndSceneDelegate> _d3DEndSceneHook;
+        private IHook<IDirect3DDevice9_ResetDelegate> _d3DResetHook;
+
+        private OverlayRenderer _overlayRenderer;
+        private List<IntPtr> _d3DDeviceFunctions = new List<IntPtr>();
+        private const int D3DDevice9FunctionCount = 119;
+        private bool _isUsingPresentHook = false;
+
+        public override unsafe void CreateHooks()
+        {
+            _d3DDeviceFunctions = new List<IntPtr>();
+
+            using (var direct3D = new SharpDX.Direct3D9.Direct3D())
+            {
+                using (var device = new Device(direct3D, 0, DeviceType.NullReference, IntPtr.Zero,
+                    CreateFlags.HardwareVertexProcessing,
+                    new PresentParameters { BackBufferWidth = 1, BackBufferHeight = 1, DeviceWindowHandle = IntPtr.Zero }))
+                {
+                    _d3DDeviceFunctions.AddRange(ReadVTableAddresses(device.NativePointer, D3DDevice9FunctionCount));
+                }
+            }
+
+            // Create the hooks for our target Direct3D Device functions.
+            _d3DEndSceneHook = HookFactory.CreateHook<IDirect3DDevice9_EndSceneDelegate>(
+                _d3DDeviceFunctions[(int)FunctionOrdinals.EndScene],
+                Detour_EndScene,
+                this);
+
+            _d3DPresentHook = HookFactory.CreateHook<IDirect3DDevice9_PresentDelegate>(
+                    _d3DDeviceFunctions[(int) FunctionOrdinals.Present],
+                    Detour_Present,
+                    this);
+
+            _d3DResetHook = HookFactory.CreateHook<IDirect3DDevice9_ResetDelegate>(
+                _d3DDeviceFunctions[(int)FunctionOrdinals.Reset],
+                Detour_Reset,
+                this);
+
+            // Add the Frames Per Second overlay.
+            Overlays = new List<IOverlay>
+            {
+                new Direct3D.Core.Drawing.Overlay
+                {
+                    Elements =
+                    {
+                        new FramesPerSecondOverlay(new System.Drawing.Font("Arial", 16, FontStyle.Bold))
+                        {
+                            Location = new System.Drawing.Point(25, 25),
+                            Color = Color.Red,
+                            AntiAliased = true,
+                            Text = "{0:N0} FPS"
+                        }
+                    },
+                    Hidden = false
+                }
+            };
+
+            // Enable the hooks for all threads except the current thread.
+            _d3DEndSceneHook.ThreadACL.SetExclusiveACL(new int[1]);
+            _d3DPresentHook.ThreadACL.SetExclusiveACL(new int[1]);
+            _d3DResetHook.ThreadACL.SetExclusiveACL(new int[1]);
+        }
+
+        private static IEnumerable<IntPtr> ReadVTableAddresses(IntPtr vTableAddress, int vTableFunctionCount)
+        {
+            IntPtr[] addresses = new IntPtr[vTableFunctionCount];
+            IntPtr vTable = Marshal.ReadIntPtr(vTableAddress);
+            for (var i = 0; i < vTableFunctionCount; ++i)
+            {
+                addresses[i] = Marshal.ReadIntPtr(vTable, i * IntPtr.Size);
+            }
+            return addresses;
+        }
+
+        private unsafe int Detour_Present(
+            IntPtr device,
+            Rectangle* sourceRectangle,
+            Rectangle* destRectangle,
+            IntPtr destWindowOverride,
+            IntPtr dirtyRegion)
+        {
+            _isUsingPresentHook = true;
+
+            Device d3Device = (Device)device;
+            DrawFramesPerSecond(d3Device);
+
+            return _d3DPresentHook.Original(device, sourceRectangle, destRectangle, destWindowOverride, dirtyRegion);
+        }
+
+        private int Detour_EndScene(IntPtr direct3DDevice)
+        {
+            Device device = (Device)direct3DDevice;
+
+            if (!_isUsingPresentHook)
+            {
+                DrawFramesPerSecond(device);
+            }
+
+            device.EndScene();
+
+            return Result.Ok.Code;
+        }
+
+        private int Detour_Reset(IntPtr direct3DDevice, ref PresentParameters parameters)
+        {
+            _overlayRenderer?.ResetDeviceResources();
+
+            return _d3DResetHook.Original(direct3DDevice, ref parameters);
+        }
+
+        private void DrawFramesPerSecond(Device device)
+        {
+            Capture(device);
+        }
+
+        private void Capture(Device device)
+        {
+            try
+            {
+                // Draw any overlays that have been added to the global list.
+                var displayOverlays = Overlays;
+                if (_overlayRenderer == null ||
+                    _overlayRenderer.Device.NativePointer != device.NativePointer ||
+                    PendingUpdate)
+                {
+                    if (_overlayRenderer != null)
+                    {
+                        RemoveAndDispose(ref _overlayRenderer);
+                    }
+
+                    _overlayRenderer = ToDispose((new OverlayRenderer()));
+                    _overlayRenderer.Overlays.AddRange(displayOverlays);
+                    _overlayRenderer.Initialize(device);
+                    PendingUpdate = false;
+                }
+
+                if (_overlayRenderer != null)
+                {
+                    foreach (var overlay in _overlayRenderer.Overlays)
+                    {
+                        overlay.OnFrame();
+                    }
+
+                    _overlayRenderer.DrawFrame();
+                }
+            }
+            catch (Exception e)
+            {
+                System.Diagnostics.Debug.WriteLine($"{e}");
+            }
+        }
+
+    }
+}

src/DirectX.Direct3D11.Overlay/SafeHGlobal.cs

@@ -20,4 +20,8 @@
     <PackageReference Include="SharpDX.Mathematics" Version="4.2.0" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\DirectX.Direct3D.Core\DirectX.Direct3D.Core.csproj" />
+  </ItemGroup>
+
 </Project>

src/DirectX.Direct3D9.Overlay/Direct3DHookModule.cs

@@ -1,22 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using CoreHook;
-using SharpDX;
-using SharpDX.Direct3D9;
+using CoreHook;
+using DirectX.Direct3D.Core;
 
 namespace DirectX.Direct3D9.Overlay
 {
     public class EntryPoint : IEntryPoint
     {
-        private List<IntPtr> _d3DDeviceFunctions = new List<IntPtr>();
-        private const int D3DDevice9FunctionCount = 119;
-
-        private Font _framesPerSecondFont;
-
-        private int _frameCount;
-        private int _lastTickCount;
-        private float _lastFrameRate;
+        private Direct3DHook _direct3DHook;
 
         public EntryPoint(IContext context) { }
 
@@ -29,111 +18,10 @@ public void Run(IContext context)
             }
         }
 
-        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
-        unsafe delegate int IDirect3DDevice9_PresentDelegate(IntPtr device, Rectangle* sourceRectangle,
-            Rectangle* destRectangle, IntPtr destWindowOverride, IntPtr dirtyRegion);
-
-        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
-        private delegate int IDirect3DDevice9_EndSceneDelegate(IntPtr device);
-
-        private IHook<IDirect3DDevice9_PresentDelegate> _d3DPresentHook;
-        private IHook<IDirect3DDevice9_EndSceneDelegate> _d3DEndSceneHook;
-
-        public unsafe void InitializeDeviceHook()
-        {
-            _d3DDeviceFunctions = new List<IntPtr>();
-
-            using (var direct3D = new Direct3D())
-            {
-                using (var device = new Device(direct3D, 0, DeviceType.NullReference, IntPtr.Zero, 
-                    CreateFlags.HardwareVertexProcessing,
-                    new PresentParameters { BackBufferWidth = 1, BackBufferHeight = 1, DeviceWindowHandle = IntPtr.Zero }))
-                {
-                    _d3DDeviceFunctions.AddRange(ReadVTableAddresses(device.NativePointer, D3DDevice9FunctionCount));
-                }
-            }
-
-            _d3DEndSceneHook = HookFactory.CreateHook<IDirect3DDevice9_EndSceneDelegate>(
-                _d3DDeviceFunctions[(int)FunctionOrdinals.EndScene],
-                Detour_EndScene,
-                this);
-
-            _d3DPresentHook = HookFactory.CreateHook<IDirect3DDevice9_PresentDelegate>(
-                _d3DDeviceFunctions[(int)FunctionOrdinals.Present],
-                Detour_Present,
-                this);
-
-            _d3DEndSceneHook.ThreadACL.SetExclusiveACL(new int[1]);
-            _d3DPresentHook.ThreadACL.SetExclusiveACL(new int[1]);
-        }
-
-        private static IEnumerable<IntPtr> ReadVTableAddresses(IntPtr vTableAddress, int vTableFunctionCount)
-        {
-            IntPtr[] addresses = new IntPtr[vTableFunctionCount];
-            IntPtr vTable = Marshal.ReadIntPtr(vTableAddress);
-            for (var i = 0; i < vTableFunctionCount; ++i)
-            {
-                addresses[i] = Marshal.ReadIntPtr(vTable, i * IntPtr.Size);
-            }
-            return addresses;
-        }
-
-        private unsafe int Detour_Present(
-            IntPtr device,
-            Rectangle* sourceRectangle,
-            Rectangle* destRectangle,
-            IntPtr destWindowOverride,
-            IntPtr dirtyRegion)
+        public void InitializeDeviceHook()
         {
-            _frameCount++;
-
-            return _d3DPresentHook.Original(device, sourceRectangle, destRectangle, destWindowOverride, dirtyRegion);
-        }
-
-        private int Detour_EndScene(IntPtr direct3DDevice)
-        {
-            Device device = (Device)direct3DDevice;
-
-            DrawFramesPerSecond(device);
-
-            device.EndScene();
-
-            return Result.Ok.Code;
-        }
-
-        private void DrawFramesPerSecond(Device device)
-        {
-            try
-            {
-                var tickCount = Environment.TickCount;
-                if (Math.Abs(tickCount - _lastTickCount) > 1000)
-                {
-                    _lastFrameRate = (float)_frameCount * 1000 / Math.Abs(tickCount - _lastTickCount);
-                    _frameCount = 0;
-                    _lastTickCount = tickCount;
-                }
-                if (_framesPerSecondFont == null)
-                {
-                    _framesPerSecondFont = new Font(device, new FontDescription
-                    {
-                        Height = 20,
-                        FaceName = "Arial",
-                        Italic = false,
-                        Width = 0,
-                        MipLevels = 1,
-                        CharacterSet = FontCharacterSet.Default,
-                        OutputPrecision = FontPrecision.Default,
-                        Quality = FontQuality.ClearTypeNatural,
-                        PitchAndFamily = FontPitchAndFamily.Default | FontPitchAndFamily.DontCare,
-                        Weight = FontWeight.Bold
-                    });
-                }
-
-                _framesPerSecondFont.DrawText(null, $"{_lastFrameRate:N0} FPS", 0, 0, new ColorBGRA(244, 66, 86, 255));
-            }
-            catch (Exception)
-            {
-            }
+            _direct3DHook = new Direct3DHookModule();
+            _direct3DHook.CreateHooks();
         }
     }
 }

src/DirectX.Direct3D9.Overlay/DirectX.Direct3D9.Overlay.csproj

@@ -0,0 +1,146 @@
+using System.Collections.Generic;
+using DirectX.Direct3D.Core.Drawing;
+using DirectX.Direct3D.Core.Memory;
+using SharpDX;
+using SharpDX.Direct3D9;
+
+namespace DirectX.Direct3D9.Overlay
+{
+    internal class OverlayRenderer : DisposableComponent
+    {
+        public List<IOverlay> Overlays { get; set; } = new List<IOverlay>();
+        private readonly Dictionary<string, Font> _fontCache = new Dictionary<string, Font>();
+
+        private Device _device;
+        private Sprite _sprite;
+
+        public Device Device => _device;
+
+        private bool _isInitialized;
+        private bool _isInitializing;
+
+        internal OverlayRenderer()
+        {
+        }
+
+        private void EnsureInitialized()
+        {
+            System.Diagnostics.Debug.Assert(_isInitialized);
+        }
+
+        internal bool Initialize(Device device)
+        {
+            if (_isInitializing)
+            {
+                return false;
+            }
+
+            _isInitializing = true;
+
+            try
+            {
+                _device = device;
+
+                _sprite = ToDispose(new Sprite(device));
+
+                InitializeResources();
+
+                _isInitialized = true;
+            }
+            finally
+            {
+                _isInitializing = true;
+            }
+            return true;
+        }
+
+        private void InitializeResources()
+        {
+            foreach (var overlay in Overlays)
+            {
+                foreach (var overlayElement in overlay.Elements)
+                {
+                    if(overlayElement is TextOverlay textOverlay)
+                    {
+                        GetOverlayFont(textOverlay);
+                    }
+                }
+            }
+        }
+
+        public void DrawFrame()
+        {
+            EnsureInitialized();
+
+            BeginFrame();
+
+            foreach (var overlay in Overlays)
+            {
+                foreach (var overlayElement in overlay.Elements)
+                {
+                    if (overlayElement is TextOverlay textOverlay)
+                    {
+                        var font = GetOverlayFont(textOverlay);
+                        if (font != null && !string.IsNullOrEmpty(textOverlay.Text))
+                        {
+                            font.DrawText(_sprite, textOverlay.Text, textOverlay.Location.X, textOverlay.Location.Y,
+                                new ColorBGRA(textOverlay.Color.R, textOverlay.Color.G, textOverlay.Color.B,
+                                    textOverlay.Color.A));
+                        }
+                    }
+                }
+            }
+
+            EndFrame();
+        }
+
+        private void BeginFrame()
+        {
+            _sprite.Begin(SpriteFlags.AlphaBlend);
+        }
+
+        private void EndFrame()
+        {
+            _sprite.End();
+        }
+
+        private Font GetOverlayFont(TextOverlay textOverlay)
+        {
+            string fontKey =
+                $"{textOverlay.Font.Name}{textOverlay.Font.Size}{textOverlay.Font.Style}{textOverlay.AntiAliased}";
+
+            if (!_fontCache.TryGetValue(fontKey, out Font overlayFont))
+            {
+                overlayFont = ToDispose(new Font(_device, new FontDescription()
+                {
+                    FaceName = textOverlay.Font.Name,
+                    Italic = (textOverlay.Font.Style & System.Drawing.FontStyle.Italic) == System.Drawing.FontStyle.Italic,
+                    Quality = (textOverlay.AntiAliased ? FontQuality.Antialiased : FontQuality.Default),
+                    Weight = ((textOverlay.Font.Style & System.Drawing.FontStyle.Bold) == System.Drawing.FontStyle.Bold) ? FontWeight.Bold : FontWeight.Normal,
+                    Height = (int)textOverlay.Font.SizeInPoints
+                }));
+                _fontCache[fontKey] = overlayFont;
+            }
+            return overlayFont;
+        }
+
+        public void ResetDeviceResources()
+        {
+            try
+            {
+                foreach (var font in _fontCache)
+                {
+                    font.Value.OnLostDevice();
+                }
+
+                _sprite?.OnLostDevice();
+            }
+            catch { }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            _device = null;
+        }
+    }
+}