[HELP] sharpdx drawn overlay after 10 sec execption

[djklesk]

hi community
my injected overlay is drawn then after 10 sec he throws a exception

PHP Code:

Debug: DXHookD3D11: PresentHook: Exeception: SharpDX.SharpDXException: SharpDX.SharpDXException: HRESULT: [0x80070057], Module: [Unknown], ApiCode: [Unknown/Unknown], Message: Falscher Parameter.

   bei SharpDX.Result.CheckError()
   bei SharpDX.Direct3D11.Device.CreateRenderTargetView(Resource resourceRef, Nullable`1 descRef, RenderTargetView rTViewOut)
   bei SharpDX.Direct3D11.RenderTargetView..ctor(Device device, Resource resource)
   bei Overlay.DX.DXOverlayEngine.Initialise(Device device, Texture2D renderTarget) in c:\Users\DJ\Documents\Visual Studio 2012\Projects\NewProject\Overlay\DX\DXOverlayEngine.cs:Zeile 69.
   bei Overlay.DX.DXOverlayEngine.Initialise(SwapChain swapChain) in c:\Users\DJ\Documents\Visual Studio 2012\Projects\NewProject\Overlay\DX\DXOverlayEngine.cs:Zeile 43.
   bei Overlay.DX.DXHookD3D11.PresentHook(IntPtr swapChainPtr, Int32 syncInterval, PresentFlags flags) in c:\Users\DJ\Documents\Visual Studio 2012\Projects\NewProject\Overlay\DX\DXHookD3D11.cs:Zeile 177. 


DXOverlayEngine.cs

 Spoiler

PHP Code:

namespace Overlay.DX
{
    using System;
    using System.Collections.Generic;
    using SharpDX.Direct3D11;
    using SharpDX;
    using System.Diagnostics;

    internal class DXOverlayEngine: DisposeBase
    {
        public List<Overlay.DX.Common.IOverlay> Overlays { get; set; }
        public bool DeferredContext
        {
            get
            {
                return _deviceContext.TypeInfo == DeviceContextType.Deferred; 
            }
        }

        bool _initialised = false;
        bool _initialising = false;

        Device _device;
        DeviceContext _deviceContext;
        Texture2D _renderTarget;
        RenderTargetView _renderTargetView;
        DXSprite _spriteEngine;
        Dictionary<string, DXFont> _fontCache = new Dictionary<string, DXFont>();

        public DXOverlayEngine()
        {
            Overlays = new List<Overlay.DX.Common.IOverlay>();
        }

        private void EnsureInitiliased()
        {
            Debug.Assert(_initialised);
        }

        public bool Initialise(SharpDX.DXGI.SwapChain swapChain)
        {
            return Initialise(swapChain.GetDevice<Device>(), swapChain.GetBackBuffer<Texture2D>(0));
        }

        public bool Initialise(Device device, Texture2D renderTarget)
        {
            Debug.Assert(!_initialised);
            if (_initialising)
                return false;

            _initialising = true;
            
            try
            {

                _device = device;
                _renderTarget = renderTarget;
                try
                {
                    // TODO: determine if any benefit to using deferred context here
                    _deviceContext = new DeviceContext(_device);
                }
                catch (SharpDXException)
                {
                    _deviceContext = _device.ImmediateContext;
                }

                _renderTargetView = new RenderTargetView(_device, _renderTarget);

                if (DeferredContext)
                {
                    ViewportF[] vp = new ViewportF[1];
                    vp = new ViewportF[] { new ViewportF(0, 0, _renderTarget.Description.Width, _renderTarget.Description.Height, 0, 1) };
                    _deviceContext.Rasterizer.SetViewports(vp);
                    _deviceContext.OutputMerger.SetTargets(_renderTargetView);
                }

                _spriteEngine = new DXSprite(_device, _deviceContext);
                if (!_spriteEngine.Initialize())
                    return false;

                // Initialise any resources required for overlay elements
                IntialiseElementResources();

                _initialised = true;
                return true;
            }
            finally
            {
                _initialising = false;
            }
        }

        private void IntialiseElementResources()
        {
            foreach (var overlay in Overlays)
            {
                foreach (var element in overlay.Elements)
                {
                    var textElement = element as Overlay.DX.Common.TextElement;
                    if (textElement != null)
                    {
                        GetFontForTextElement(textElement);
                    }
                }
            }
        }

        private void Begin()
        {
            if (!DeferredContext)
            {
                ViewportF[] vp = new ViewportF[1];
                vp = new ViewportF[] { new ViewportF(0, 0, _renderTarget.Description.Width, _renderTarget.Description.Height, 0, 1) };
                _deviceContext.Rasterizer.SetViewports(vp);
                _deviceContext.OutputMerger.SetTargets(_renderTargetView);
            }
        }

        /// <summary>
        /// Draw the overlay(s)
        /// </summary>
        public void Draw()
        {
            EnsureInitiliased();

            Begin();

            foreach (var overlay in Overlays)
            {
                foreach (var element in overlay.Elements)
                {
                    var textElement = element as Overlay.DX.Common.TextElement;
                    if (textElement != null)
                    {
                        DXFont font = GetFontForTextElement(textElement);
                        if (font != null && !String.IsNullOrEmpty(textElement.Text))
                            _spriteEngine.DrawString(textElement.Location.X, textElement.Location.Y, textElement.Text, textElement.Color.R, textElement.Color.G, textElement.Color.B, textElement.Color.A, font);
                    }
                }
            }

            End();
        }

        private void End()
        {
            if (DeferredContext)
            {
                var commandList = _deviceContext.FinishCommandList(true);
                _device.ImmediateContext.ExecuteCommandList(commandList, true);
                commandList.Dispose();
            }
        }

        DXFont GetFontForTextElement(Overlay.DX.Common.TextElement element)
        {
            DXFont result = null;

            string fontKey = String.Format("{0}{1}{2}", element.Font.Name, element.Font.Size, element.Font.Style, element.AntiAliased);

            if (!_fontCache.TryGetValue(fontKey, out result))
            {
                result = new DXFont(_device, _deviceContext);
                result.Initialize(element.Font.Name, element.Font.Size, element.Font.Style, element.AntiAliased);
                _fontCache[fontKey] = result;
            }
            return result;
        }

        /// <summary>
        /// Releases unmanaged and optionally managed resources
        /// </summary>
        /// <param name="disposing">true if disposing both unmanaged and managed</param>
        protected override void Dispose(bool disposing)
        {
            if (true)
            {
                SafeDispose(_device);
                _device = null;
            }
        }

        void SafeDispose(DisposeBase disposableObj)
        {
            if (disposableObj != null)
                disposableObj.Dispose();
        }
    }
} 


DXHookD3D11.cs

 Spoiler

PHP Code:


namespace Overlay.DX
{
    using System;
    using System.Collections.Generic;
    using SharpDX.Direct3D11;
    using SharpDX.DXGI;
    using System.Runtime.InteropServices;
    using EasyHook;
    using SharpDX.Direct3D;
    using Overlay.OverlayInterface;

    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,
    }

    internal class DXHookD3D11 : BaseDXHook
    {
        const int D3D11_DEVICE_METHOD_COUNT = 43;

        public DXHookD3D11(Interface ssInterface)
            : base(ssInterface)
        {
        }

        List<IntPtr> _d3d11VTblAddresses = null;
        List<IntPtr> _dxgiSwapChainVTblAddresses = null;
        LocalHook DXGISwapChain_PresentHook = null;
        DXOverlayEngine _overlayEngine;
        IntPtr _swapChainPointer = IntPtr.Zero;

        protected override string HookName
        {
            get
            {
                return "DXHookD3D11";
            }
        }

        public override void Hook()
        {
            this.DebugMessage("Hook: Begin");
            if (_d3d11VTblAddresses == null)
            {
                _d3d11VTblAddresses = new List<IntPtr>();
                _dxgiSwapChainVTblAddresses = new List<IntPtr>();

                #region Get Device and SwapChain method addresses
                // Create temporary device + swapchain and determine method addresses
                SharpDX.Direct3D11.Device device;
                SwapChain swapChain;
                using (SharpDX.Windows.RenderForm renderForm = new SharpDX.Windows.RenderForm())
                {
                    this.DebugMessage("Hook: Before device creation");
                    SharpDX.Direct3D11.Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, DXGI.CreateSwapChainDescription(renderForm.Handle), out device, out swapChain);
                    if (device != null && swapChain != null)
                    {
                        this.DebugMessage("Hook: Device created");
                        using (device)
                        {
                            _d3d11VTblAddresses.AddRange(GetVTblAddresses(device.NativePointer, D3D11_DEVICE_METHOD_COUNT));

                            using (swapChain)
                            {
                                _dxgiSwapChainVTblAddresses.AddRange(GetVTblAddresses(swapChain.NativePointer, DXGI.DXGI_SWAPCHAIN_METHOD_COUNT));
                            }
                        }
                    }
                    else
                    {
                        this.DebugMessage("Hook: Device creation failed");
                    }
                }
                #endregion
            }

            DXGISwapChain_PresentHook = LocalHook.Create(_dxgiSwapChainVTblAddresses[(int)DXGI.DXGISwapChainVTbl.Present], new DXGISwapChain_PresentDelegate(PresentHook), this);
            DXGISwapChain_PresentHook.ThreadACL.SetExclusiveACL(new Int32[1]);
            Hooks.Add(DXGISwapChain_PresentHook);
        }

        public override void Cleanup()
        {
            try
            {
                if (DXGISwapChain_PresentHook != null)
                {
                    DXGISwapChain_PresentHook.Dispose();
                    DXGISwapChain_PresentHook = null;
                }
                if (_overlayEngine != null)
                {
                    _overlayEngine.Dispose();
                    _overlayEngine = null;
                }

                //this.Request = null;
            }
            catch
            {
            }
        }

        [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode, SetLastError = true)]
        delegate int DXGISwapChain_PresentDelegate(IntPtr swapChainPtr, int syncInterval, /* int */ SharpDX.DXGI.PresentFlags flags);
        
        int PresentHook(IntPtr swapChainPtr, int syncInterval, SharpDX.DXGI.PresentFlags flags)
        {
            this.Frame();
            SwapChain swapChain = (SharpDX.DXGI.SwapChain)swapChainPtr;
            try
            {
                #region Draw overlay (after screenshot so we don't capture overlay as well)

                // Initialise Overlay Engine
                if (_swapChainPointer != swapChain.NativePointer || _overlayEngine == null)
                {
                    if (_overlayEngine != null)
                        _overlayEngine.Dispose();

                    _overlayEngine = new DXOverlayEngine();
                    _overlayEngine.Overlays.Add(new Common.Overlay
                    {
                        Elements =
                        {
                            //new ddl.Hook.Common.TextElement(new System.Drawing.Font("Times New Roman", 22)) { Text = "Test", Location = new System.Drawing.Point(200, 200), Color = System.Drawing.Color.Yellow, AntiAliased = false},
                            new Common.FramesPerSecond(new System.Drawing.Font("Arial", 16)) { Location = new System.Drawing.Point(5,5), Color = System.Drawing.Color.Red, AntiAliased = true }

                        }
                    });
                    _overlayEngine.Initialise(swapChain);
                    _swapChainPointer = swapChain.NativePointer;
                }
                // Draw Overlay(s)
                else if (_overlayEngine != null)
                {
                    foreach (var overlay in _overlayEngine.Overlays)
                        overlay.Frame();
                    _overlayEngine.Draw();
                }
                #endregion
            }
            catch (Exception e)
            {
                this.DebugMessage("PresentHook: Exeception: " + e.GetType().FullName + ": " + e.ToString());
            }
            swapChain.Present(syncInterval, flags);
            return SharpDX.Result.Ok.Code;
        }
    }
}