d3d11hook + 2d

    internal class D3DHook
    {
        [StructLayout(LayoutKind.Sequential)]
        internal struct VertexPositionTexture
        {
            public Vector4 Position;
            public Vector2 TexCoord;

            public static readonly SharpDX.Direct3D11.InputElement[] inputElements = new[] {
            new SharpDX.Direct3D11.InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
            new SharpDX.Direct3D11.InputElement("TEXCOORD",0,Format.R32G32_Float, 16 ,0)
        };
            public static readonly int SizeInBytes = Marshal.SizeOf(typeof(VertexPositionTexture));
            public VertexPositionTexture(Vector4 position, Vector2 texCoord)
            {
                Position = position;
                TexCoord = texCoord;
            }
            public VertexPositionTexture(Vector3 position, Vector2 texCoord)
            {
                Position = new Vector4(position, 1);
                TexCoord = texCoord;
            }
        }

        private enum D3D11DeviceVTbl : short
        {
            // IUnknown
            QueryInterface = 0,
            AddRef = 1,
            Release = 2,

            // ID3D11Device
            CreateBuffer = 3,
            CreateTexture1D = 4,
            CreateTexture2D = 5,
            CreateTexture3D = 6,
            CreateShaderResourceView = 7,
            CreateUnorderedAccessView = 8,
            CreateRenderTargetView = 9,
            CreateDepthStencilView = 10,
            CreateInputLayout = 11,
            CreateVertexShader = 12,
            CreateGeometryShader = 13,
            CreateGeometryShaderWithStreamOutput = 14,
            CreatePixelShader = 15,
            CreateHullShader = 16,
            CreateDomainShader = 17,
            CreateComputeShader = 18,
            CreateClassLinkage = 19,
            CreateBlendState = 20,
            CreateDepthStencilState = 21,
            CreateRasterizerState = 22,
            CreateSamplerState = 23,
            CreateQuery = 24,
            CreatePredicate = 25,
            CreateCounter = 26,
            CreateDeferredContext = 27,
            OpenSharedResource = 28,
            CheckFormatSupport = 29,
            CheckMultisampleQualityLevels = 30,
            CheckCounterInfo = 31,
            CheckCounter = 32,
            CheckFeatureSupport = 33,
            GetPrivateData = 34,
            SetPrivateData = 35,
            SetPrivateDataInterface = 36,
            GetFeatureLevel = 37,
            GetCreationFlags = 38,
            GetDeviceRemovedReason = 39,
            GetImmediateContext = 40,
            SetExceptionMode = 41,
            GetExceptionMode = 42,
        }

        private const int D3D11_DEVICE_METHOD_COUNT = 43;

        private enum DXGISwapChainVTbl : 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,
        }

        string SpriteFX = @"Texture2D SpriteTex;
SamplerState samLinear {
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = WRAP;
    AddressV = WRAP;
};
struct VertexIn {
    float3 PosNdc : POSITION;
    float2 Tex    : TEXCOORD;
    float4 Color  : COLOR;
};
struct VertexOut {
    float4 PosNdc : SV_POSITION;
    float2 Tex    : TEXCOORD;
    float4 Color  : COLOR;
};
VertexOut VS(VertexIn vin) {
    VertexOut vout;
    vout.PosNdc = float4(vin.PosNdc, 1.0f);
    vout.Tex    = vin.Tex;
    vout.Color  = vin.Color;
    return vout;
};
float4 PS(VertexOut pin) : SV_Target {
    return pin.Color*SpriteTex.Sample(samLinear, pin.Tex);
};
technique11 SpriteTech {
    pass P0 {
        SetVertexShader( CompileShader( vs_5_0, VS() ) );
        SetHullShader( NULL );
        SetDomainShader( NULL );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_5_0, PS() ) );
    }
};";

        [StructLayout(LayoutKind.Sequential)]
        internal struct SpriteVertex
        {
            public Vector3 Pos;
            public Vector2 Tex;
            public Color4 Color;
        }


        private const int DXGI_SWAPCHAIN_METHOD_COUNT = 18;

        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
        private delegate int DXGISwapChain_PresentDelegate(IntPtr swapChainPtr, int syncInterval, /* int */ SharpDX.DXGI.PresentFlags flags);

        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
        delegate int DXGISwapChain_ResizeTargetDelegate(IntPtr swapChainPtr, ref ModeDescription newTargetParameters);

        private List<IntPtr> _d3d11VTblAddresses = null;
        private List<IntPtr> _dxgiSwapChainVTblAddresses = null;

        private Hook<DXGISwapChain_PresentDelegate> DXGISwapChain_PresentHook = null;
        private Hook<DXGISwapChain_ResizeTargetDelegate> DXGISwapChain_ResizeTargetHook = null;

        SharpDX.Direct3D11.Device _device;
        SharpDX.DXGI.SwapChain _swapChain;

        IntPtr _swapChainPointer = IntPtr.Zero;

        public const string fontFamily = "Calibri";
        public const float fontSize = 12.0f;
        public static SharpDX.DirectWrite.Factory fontFactory = new SharpDX.DirectWrite.Factory();
        public static SharpDX.DirectWrite.TextFormat font = new SharpDX.DirectWrite.TextFormat(fontFactory, fontFamily, fontSize);

        public SharpDX.Direct2D1.DeviceContext d2dContext;
        public Bitmap1 d2dTarget;

        KeyedMutex device10Mutex;
        KeyedMutex device11Mutex;
        RenderTarget renderTarget2D;
        RenderTargetView renderTargetView;
        Texture2D textureD3D11;
        SharpDX.Direct3D11.Effect effect;
        InputLayout layoutOverlay;
        SharpDX.Direct3D11.Buffer vertexBufferOverlay;
        Surface _surface;

        private static SharpDX.DXGI.SwapChainDescription CreateSwapChainDescription(IntPtr windowHandle)
        {
            return new SharpDX.DXGI.SwapChainDescription
            {
                BufferCount = 1,
                Flags = SharpDX.DXGI.SwapChainFlags.None,
                IsWindowed = true,
                ModeDescription = new SharpDX.DXGI.ModeDescription(100, 100, new Rational(60, 1), SharpDX.DXGI.Format.R8G8B8A8_UNorm),
                OutputHandle = windowHandle,
                SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
                SwapEffect = SharpDX.DXGI.SwapEffect.Discard,
                Usage = SharpDX.DXGI.Usage.RenderTargetOutput
            };
        }

        private static IntPtr[] GetVTblAddresses(IntPtr pointer, int numberOfMethods)
        {
            List<IntPtr> vtblAddresses = new List<IntPtr>();

            IntPtr vTable = Marshal.ReadIntPtr(pointer);
            for (int i = 0; i < numberOfMethods; i++)
                vtblAddresses.Add(Marshal.ReadIntPtr(vTable, i * IntPtr.Size));

            return vtblAddresses.ToArray();
        }

        public void Hook()
        {

            try
            {

            Console.WriteLine("Hooking D3D...");
            if (this._d3d11VTblAddresses == null)
            {
                this._d3d11VTblAddresses = new List<IntPtr>();
                this._dxgiSwapChainVTblAddresses = new List<IntPtr>();

                SharpDX.Windows.RenderForm _renderForm = new SharpDX.Windows.RenderForm();

                SharpDX.Direct3D11.Device.CreateWithSwapChain(
                        DriverType.Hardware,
                        DeviceCreationFlags.BgraSupport | DeviceCreationFlags.Debug,
                        CreateSwapChainDescription(_renderForm.Handle),
                        out this._device,
                        out this._swapChain);


                if (_device != null && _swapChain != null)
                {
                    Console.WriteLine("Hook: Device created.");
                    this._d3d11VTblAddresses.AddRange(GetVTblAddresses(this._device.NativePointer, D3D11_DEVICE_METHOD_COUNT));
                    this._dxgiSwapChainVTblAddresses.AddRange(GetVTblAddresses(this._swapChain.NativePointer, DXGI_SWAPCHAIN_METHOD_COUNT));


                        var factory1 = new SharpDX.DXGI.Factory1();
                        // The 1st graphics adapter
                        var adapter1 = factory1.GetAdapter1(0);

                        var resource = SharpDX.Direct3D11.Resource.FromSwapChain<Texture2D>(_swapChain, 0);
                        renderTargetView = new RenderTargetView(_device, resource);

                        var context = _device.ImmediateContext;
                        RawViewportF[] viewportf = { new ViewportF(0, 0, resource.Description.Width, resource.Description.Height, 0, 1) };

                        context.OutputMerger.SetTargets(renderTargetView);
                        context.Rasterizer.SetViewports(viewportf);

                        textureD3D11 = new Texture2D(_device, new Texture2DDescription
                        {
                            Width = _renderForm.ClientSize.Width,
                            Height = _renderForm.ClientSize.Height,
                            MipLevels = 1,
                            ArraySize = 1,
                            Format = Format.B8G8R8A8_UNorm,
                            SampleDescription = new SampleDescription(1, 0),
                            Usage = ResourceUsage.Default,
                            BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
                            CpuAccessFlags = CpuAccessFlags.None,
                            OptionFlags = ResourceOptionFlags.SharedKeyedmutex
                        });
                        var device10 = new Device10(adapter1, SharpDX.Direct3D10.DeviceCreationFlags.BgraSupport, SharpDX.Direct3D10.FeatureLevel.Level_10_0);
                        var factory2D = new SharpDX.Direct2D1.Factory(SharpDX.Direct2D1.FactoryType.SingleThreaded, DebugLevel.Information);

                        // Here we bind the texture we've created on our direct3d11 device through the direct3d10
                        // to the direct 2d render target....
                        var sharedResource = textureD3D11.QueryInterface<SharpDX.DXGI.Resource>();
                        var textureD3D10 = device10.OpenSharedResource<SharpDX.Direct3D10.Texture2D>(sharedResource.SharedHandle);

                        _surface = textureD3D10.AsSurface();
                        var rtp = new RenderTargetProperties
                        {
                            MinLevel = SharpDX.Direct2D1.FeatureLevel.Level_10,
                            Type = RenderTargetType.Hardware,
                            PixelFormat = new PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied)
                        };

                        renderTarget2D = new RenderTarget(factory2D, _surface, rtp);
                        var solidColorBrush = new SolidColorBrush(renderTarget2D, Color.Red);

                        device10Mutex = textureD3D10.QueryInterface<KeyedMutex>();
                        device11Mutex = textureD3D11.QueryInterface<KeyedMutex>();

                        ShaderBytecode shaderByteCode = ShaderBytecode.Compile(
                            SpriteFX,
                            "fx_5_0",
                            ShaderFlags.EnableStrictness);

                        effect = new SharpDX.Direct3D11.Effect(_device, shaderByteCode);

                        var verticesText = new DataStream(VertexPositionTexture.SizeInBytes * 4, true, true);
                        verticesText.Write(new VertexPositionTexture(new Vector3(-1, 1, 0), new Vector2(0, 0f)));
                        verticesText.Write(new VertexPositionTexture(new Vector3(1, 1, 0), new Vector2(1, 0)));
                        verticesText.Write(new VertexPositionTexture(new Vector3(-1, -1, 0), new Vector2(0, 1)));
                        verticesText.Write(new VertexPositionTexture(new Vector3(1, -1, 0), new Vector2(1, 1)));

                        verticesText.Position = 0;

                        // create the overlay vertex layout and buffer
                        SharpDX.Direct3D11.InputElement[] layoutDesc = {
                            new SharpDX.Direct3D11.InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0, InputClassification.PerVertexData, 0),
                            new SharpDX.Direct3D11.InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float, 12, 0, InputClassification.PerVertexData, 0),
                            new SharpDX.Direct3D11.InputElement("COLOR", 0, SharpDX.DXGI.Format.R32G32B32A32_Float, 20, 0, InputClassification.PerVertexData, 0)
                        };
                        layoutOverlay = new SharpDX.Direct3D11.InputLayout(_device, effect.GetTechniqueByName("SpriteTech").GetPassByIndex(0).Description.Signature, layoutDesc);
                        //layoutOverlay = new InputLayout(_device, effect.GetTechniqueByName("SpriteTech").GetPassByIndex(0).Description.Signature, VertexPositionTexture.inputElements);
                        vertexBufferOverlay = new SharpDX.Direct3D11.Buffer(_device, verticesText, (int)verticesText.Length, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
                        verticesText.Close();

                    }
                else
                {
                    Console.WriteLine("Hook: Device creation failed.");
                }

            }

            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.WriteLine(e.StackTrace);
            }

            this.DXGISwapChain_PresentHook = new Hook<DXGISwapChain_PresentDelegate>(
                this._dxgiSwapChainVTblAddresses[(int)DXGISwapChainVTbl.Present],
                new DXGISwapChain_PresentDelegate(this.PresentHook),
            this);

            this.DXGISwapChain_PresentHook.Enable();

            this.DXGISwapChain_ResizeTargetHook = new Hook<DXGISwapChain_ResizeTargetDelegate>(
                _dxgiSwapChainVTblAddresses[(int)DXGISwapChainVTbl.ResizeTarget],
                new DXGISwapChain_ResizeTargetDelegate(ResizeTargetHook),
                this);

            this.DXGISwapChain_ResizeTargetHook.Enable();

            Console.WriteLine("Hook: Hook is in place.");
        }

        public void UnHook()
        {
            this.DXGISwapChain_PresentHook.Disable();
            this.DXGISwapChain_ResizeTargetHook.Disable();
        }

        /** HOOKED METHODS **/
        public int ResizeTargetHook(IntPtr swapChainPtr, ref ModeDescription newTargetParameters)
        {
            Console.WriteLine("ResizeTargetHook");
            SharpDX.DXGI.SwapChain swapChain = (SharpDX.DXGI.SwapChain)swapChainPtr;

            swapChain.ResizeTarget(ref newTargetParameters);
            return this.DXGISwapChain_ResizeTargetHook.Original(swapChainPtr, ref newTargetParameters);
        }

        public int PresentHook(IntPtr swapChainPtr, int syncInterval, SharpDX.DXGI.PresentFlags flags)
        {
            Console.WriteLine("PresentHook");
            SharpDX.DXGI.SwapChain swapChain = (SharpDX.DXGI.SwapChain)swapChainPtr;

            _device.ImmediateContext.ClearRenderTargetView(renderTargetView, new Color4(0, 0, 0, 0));

            device10Mutex.Acquire(0, 100);

            renderTarget2D.BeginDraw();
            renderTarget2D.Clear(new Color4(0, 0, 0, 0));

            var x = 0;
            var y = 0;
            var textToDraw = "Test String should be drawn on screen...";
            var rectTest = new RectangleF(x, y, font.FontSize * textToDraw.Length+500, font.FontSize);
            var c = new SolidColorBrush(renderTarget2D, new Color4(255, 0, 0, 1));

            renderTarget2D.DrawText(textToDraw, font, rectTest, c);

            renderTarget2D.EndDraw();
            device10Mutex.Release(0);

            device11Mutex.Acquire(0, 100);
            //_device.ImmediateContext.CopyResource(SharpDX.Direct3D11.Resource.FromSwapChain<Texture2D>(_swapChain, 0), _surface);

            var srv = new ShaderResourceView(_device, textureD3D11);
            effect.GetVariableByName("SpriteTex").AsShaderResource().SetResource(srv);
            _device.ImmediateContext.InputAssembler.InputLayout = layoutOverlay;
            _device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBufferOverlay, VertexPositionTexture.SizeInBytes, 0));
            var currentTechnique = effect.GetTechniqueByName("SpriteTech");

            for (var pass = 0; pass < currentTechnique.Description.PassCount; ++pass)
            {
                using (var effectPass = currentTechnique.GetPassByIndex(pass))
                {
                    effectPass.Apply(_device.ImmediateContext);
                }
                _device.ImmediateContext.Draw(4, 0);
            }
            srv.Dispose();
            device11Mutex.Release(0);

            swapChain.Present(0, PresentFlags.None);

            return this.DXGISwapChain_PresentHook.Original(swapChainPtr, syncInterval, flags);
        }

    }