Merge pull request #84 from AleBello7276/main

2026-01-31 00:55:17 +01:00 · 2025-01-04 01:47:51 -06:00
parent dab643dc89 181a44a103
commit 87bd5eb082
9 changed files with 761 additions and 40 deletions
--- a/dlls/d3d11_x/IDXGI.h
+++ b/dlls/d3d11_x/IDXGI.h
@@ -0,0 +1,176 @@
+#pragma once
+#include "pch.h"
+#include "d3d_x/d3d11_x_device.h"
+#include "d3d_x/d3d_x.hpp"
+#include <typeinfo>
+
+
+namespace d3d11x
+{
+
+    /*struct IGraphicsUnknownn
+    {
+    public:
+
+
+
+        virtual HRESULT QueryInterface(REFIID riid, void** ppvObject) PURE;
+        virtual ULONG AddRef( ) = 0;
+        virtual ULONG Release( ) = 0;
+    };*/
+
+    //MIDL_INTERFACE("aec22fb8-76f3-4639-9be0-28eb43a67a2e")
+    struct IDXGIObject_X : public IGraphicsUnknown
+    {
+        /* 0x0000: fields for IGraphicsUnknown */
+    /* 0x0010 */ public: void* m_pPrivateData;
+
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetPrivateData(_In_  REFGUID Name, UINT DataSize, _In_reads_bytes_(DataSize)  const void* pData) PURE;
+        virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_  REFGUID Name, _In_opt_  const IUnknown* pUnknown) PURE;
+        /*virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterfaceGraphics(_In_ REFGUID Name, const IGraphicsUnknown* data)
+        {
+            return this->SetPrivateDataInterface(Name, reinterpret_cast<IUnknown const*>(data));
+        }*/
+        virtual HRESULT STDMETHODCALLTYPE GetPrivateData(_In_  REFGUID Name, _Inout_  UINT* pDataSize, _Out_writes_bytes_(*pDataSize)  void* pData) PURE;
+        virtual HRESULT STDMETHODCALLTYPE GetParent(_In_  REFIID riid, _COM_Outptr_  void** ppParent) PURE;
+    };
+
+
+
+
+    // Adapted to Xbox one (look at pdb)
+    //MIDL_INTERFACE("7b7166ec-21c7-44ae-b21a-c9ae321ae369")
+    struct IDXGIFactory_X : public IDXGIObject_X
+    {
+    public:
+
+        /* 0x0000: fields for IDXGIObject */
+    /* 0x0018 */ public: IDXGIAdapter2* m_pAdapter;
+
+                       virtual HRESULT STDMETHODCALLTYPE EnumAdapters(
+                           UINT Adapter,
+
+                           IDXGIAdapter** ppAdapter) PURE;
+
+                       virtual HRESULT STDMETHODCALLTYPE MakeWindowAssociation(
+                           HWND WindowHandle,
+                           UINT Flags) PURE;
+
+                       virtual HRESULT STDMETHODCALLTYPE GetWindowAssociation(
+                           HWND* pWindowHandle) PURE;
+
+                       virtual HRESULT STDMETHODCALLTYPE CreateSwapChain(
+                           IGraphicsUnknown* pDevice,
+                           DXGI_SWAP_CHAIN_DESC* pDesc,
+                           IDXGISwapChain** ppSwapChain) PURE;
+
+                       virtual HRESULT STDMETHODCALLTYPE CreateSoftwareAdapter(
+                           HMODULE Module,
+                           IDXGIAdapter** ppAdapter) PURE;
+
+    };
+
+
+    // Adapted to Xbox one (look at pdb)
+    //MIDL_INTERFACE("770aae78-f26f-4dba-a829-253c83d1b387")
+    struct IDXGIFactory1_X : public IDXGIFactory_X
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE EnumAdapters1(UINT Adapter, IDXGIAdapter1** ppAdapter) PURE;
+
+        virtual BOOL STDMETHODCALLTYPE IsCurrent(void) PURE;
+    };
+
+
+    // Adapted to Xbox one (look at pdb)
+    //MIDL_INTERFACE("50c83a1c-e072-4c48-87b0-3630fa36a6d0")
+    struct IDXGIFactory2_X : public IDXGIFactory1_X
+    {
+    public:
+        virtual BOOL STDMETHODCALLTYPE IsWindowedStereoEnabled(void) PURE;
+
+
+
+        virtual HRESULT STDMETHODCALLTYPE CreateSwapChainForHwnd(IGraphicsUnknown* pDevice,
+            HWND hWnd, const DXGI_SWAP_CHAIN_DESC1* pDesc,
+            const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc,
+            IDXGIOutput* pRestrictToOutput,
+            IDXGISwapChain1** ppSwapChain) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE CreateSwapChainForCoreWindow(
+            IGraphicsUnknown* pDevice,
+            IUnknown* pWindow,
+            const DXGI_SWAP_CHAIN_DESC1* pDesc,
+            IDXGIOutput* pRestrictToOutput,
+            IDXGISwapChain1** ppSwapChain) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE GetSharedResourceAdapterLuid(
+            HANDLE hResource,
+            LUID* pLuid) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE RegisterStereoStatusWindow(
+            HWND WindowHandle,
+            UINT wMsg,
+            DWORD* pdwCookie) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE RegisterStereoStatusEvent(
+            HANDLE hEvent,
+            DWORD* pdwCookie) PURE;
+
+        virtual void STDMETHODCALLTYPE UnregisterStereoStatus(
+            DWORD dwCookie) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE RegisterOcclusionStatusWindow(
+            HWND WindowHandle,
+            UINT wMsg,
+            DWORD* pdwCookie) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE RegisterOcclusionStatusEvent(
+            HANDLE hEvent,
+            DWORD* pdwCookie) PURE;
+
+        virtual void STDMETHODCALLTYPE UnregisterOcclusionStatus(
+            DWORD dwCookie) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE CreateSwapChainForComposition(
+            IGraphicsUnknown* pDevice,
+            const DXGI_SWAP_CHAIN_DESC1* pDesc,
+            IDXGIOutput* pRestrictToOutput,
+            IDXGISwapChain1** ppSwapChain) PURE;
+
+    };
+
+
+    struct IDXGIAdapter_X : IDXGIObject_X
+    {
+        virtual HRESULT STDMETHODCALLTYPE EnumOutputs(UINT Output, IDXGIOutput** ppOutput) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE GetDesc(DXGI_ADAPTER_DESC* pDesc) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE CheckInterfaceSupport(REFGUID InterfaceName, LARGE_INTEGER* pUMDVersion) PURE;
+
+    };
+
+    struct IDXGIDevice_X : d3d11x::IDXGIObject_X
+    {
+        virtual HRESULT STDMETHODCALLTYPE GetAdapter(IDXGIAdapter_X** pAdapter) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE CreateSurface(const DXGI_SURFACE_DESC* pDesc, UINT NumSurfaces, DXGI_USAGE Usage,
+            const DXGI_SHARED_RESOURCE* pSharedResource,
+            _Out_writes_(NumSurfaces)  IDXGISurface** ppSurface) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE QueryResourceResidency(
+            _In_reads_(NumResources)  IGraphicsUnknown** ppResources,
+            _Out_writes_(NumResources)  DXGI_RESIDENCY* pResidencyStatus,
+            /* [in] */ UINT NumResources) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE SetGPUThreadPriority(
+            /* [in] */ INT Priority) PURE;
+
+        virtual HRESULT STDMETHODCALLTYPE GetGPUThreadPriority(
+            _Out_  INT* pPriority) PURE;
+
+    };
+
+}
--- a/dlls/d3d11_x/IDXGIAdapterWrapper.cpp
+++ b/dlls/d3d11_x/IDXGIAdapterWrapper.cpp
@@ -0,0 +1,72 @@
+#include "pch.h"
+#include "IDXGIWrappers.h"
+
+namespace d3d11x
+{
+
+
+
+
+    HRESULT IDXGIAdapterWrapper::QueryInterface(REFIID riid, void** ppvObject)
+    {
+        return E_NOTIMPL;
+    }
+
+    ULONG IDXGIAdapterWrapper::AddRef( )
+    {
+        return InterlockedIncrement(&m_refCount);
+    }
+
+    ULONG IDXGIAdapterWrapper::Release( )
+    {
+        ULONG refCount = InterlockedDecrement(&m_refCount);
+        if (refCount == 0)
+            delete this;
+        return refCount;
+    }
+
+    HRESULT __stdcall IDXGIAdapterWrapper::SetPrivateData(REFGUID Name, UINT DataSize, const void* pData)
+    {
+        return m_realAdapter->SetPrivateData(Name, DataSize, pData);
+    }
+
+    HRESULT __stdcall IDXGIAdapterWrapper::SetPrivateDataInterface(REFGUID Name, const IUnknown* pUnknown)
+    {
+        return m_realAdapter->SetPrivateDataInterface(Name, pUnknown);
+    }
+
+    HRESULT __stdcall IDXGIAdapterWrapper::GetPrivateData(REFGUID Name, UINT* pDataSize, void* pData)
+    {
+        return m_realAdapter->GetPrivateData(Name, pDataSize, pData);
+    }
+
+    HRESULT __stdcall IDXGIAdapterWrapper::GetParent(REFIID riid, void** ppParent)
+    {
+        HRESULT hr = m_realAdapter->GetParent(riid, ppParent);
+        if (riid == __uuidof(IDXGIFactory) ||
+           riid == __uuidof(IDXGIFactory1) ||
+           riid == __uuidof(IDXGIFactory2))
+        {
+            *ppParent = new IDXGIFactoryWrapper(static_cast<IDXGIFactory2*>(*ppParent));
+        }
+
+
+        return hr;
+    }
+
+    HRESULT __stdcall IDXGIAdapterWrapper::EnumOutputs(UINT Output, IDXGIOutput** ppOutput)
+    {
+        return m_realAdapter->EnumOutputs(Output, ppOutput);
+    }
+
+    HRESULT __stdcall IDXGIAdapterWrapper::GetDesc(DXGI_ADAPTER_DESC* pDesc)
+    {
+        return m_realAdapter->GetDesc(pDesc);
+    }
+
+    HRESULT __stdcall IDXGIAdapterWrapper::CheckInterfaceSupport(REFGUID InterfaceName, LARGE_INTEGER* pUMDVersion)
+    {
+        return m_realAdapter->CheckInterfaceSupport(InterfaceName, pUMDVersion);
+    }
+
+}
--- a/dlls/d3d11_x/IDXGIDeviceWrapper.cpp
+++ b/dlls/d3d11_x/IDXGIDeviceWrapper.cpp
@@ -0,0 +1,93 @@
+#include "pch.h"
+#include "IDXGIWrappers.h"
+
+namespace d3d11x
+{
+
+    HRESULT IDXGIDeviceWrapper::QueryInterface(REFIID riid, void** ppvObject)
+    {
+        if (riid == __uuidof(IDXGIDevice))
+        {
+            *ppvObject = this;
+            AddRef( );
+            return S_OK;
+        }
+        else
+        {
+            // DEBUG
+            char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
+            OLECHAR iidwstr[ sizeof(iidstr) ];
+            StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
+            WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
+            printf("[IDXGIDeviceWrapper] QueryInterface: %s\n", iidstr);
+        }
+
+        return m_realDevice->QueryInterface(riid, ppvObject);
+    }
+
+
+
+  
+    ULONG IDXGIDeviceWrapper::AddRef( )
+    {
+        return InterlockedIncrement(&m_refCount);
+    }
+
+    ULONG IDXGIDeviceWrapper::Release( )
+    {
+        ULONG refCount = InterlockedDecrement(&m_refCount);
+        if (refCount == 0)
+            delete this;
+        return refCount;
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::SetPrivateData(REFGUID Name, UINT DataSize, const void* pData)
+    {
+        return m_realDevice->SetPrivateData(Name, DataSize, pData);
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::SetPrivateDataInterface(REFGUID Name, const IUnknown* pUnknown)
+    {
+        return m_realDevice->SetPrivateDataInterface(Name, pUnknown);
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::GetPrivateData(REFGUID Name, UINT* pDataSize, void* pData)
+    {
+        return m_realDevice->GetPrivateData(Name, pDataSize, pData);
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::GetParent(REFIID riid, void** ppParent)
+    {
+        return m_realDevice->GetParent(riid, ppParent);
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::GetAdapter(IDXGIAdapter_X** pAdapter)
+    {
+        IDXGIAdapter* adapter;
+        HRESULT hr = m_realDevice->GetAdapter(&adapter);
+
+        *pAdapter = new IDXGIAdapterWrapper(adapter);
+        return hr;
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::CreateSurface(const DXGI_SURFACE_DESC* pDesc, UINT NumSurfaces, DXGI_USAGE Usage, const DXGI_SHARED_RESOURCE* pSharedResource, IDXGISurface** ppSurface)
+    {
+        return m_realDevice->CreateSurface(pDesc, NumSurfaces, Usage, pSharedResource, ppSurface);
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::QueryResourceResidency(IGraphicsUnknown** ppResources, DXGI_RESIDENCY* pResidencyStatus, UINT NumResources)
+    {
+        return m_realDevice->QueryResourceResidency(reinterpret_cast<IUnknown**>(ppResources), pResidencyStatus, NumResources);
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::SetGPUThreadPriority(INT Priority)
+    {
+        return m_realDevice->SetGPUThreadPriority(Priority);
+    }
+
+    HRESULT __stdcall IDXGIDeviceWrapper::GetGPUThreadPriority(INT* pPriority)
+    {
+        return m_realDevice->GetGPUThreadPriority(pPriority);
+    }
+
+}
--- a/dlls/d3d11_x/IDXGIFactoryWrapper.cpp
+++ b/dlls/d3d11_x/IDXGIFactoryWrapper.cpp
@@ -0,0 +1,163 @@
+#include "pch.h"
+#include "IDXGIWrappers.h"
+#include <windows.ui.core.h>
+#include "../kernelx/CoreWindowWrapperX.h"
+
+namespace d3d11x
+{
+
+	HRESULT d3d11x::IDXGIFactoryWrapper::QueryInterface(REFIID riid, void** ppvObject)
+		{
+			if (riid == __uuidof(IDXGIFactory) ||
+				riid == __uuidof(IDXGIFactory1) ||
+				riid == __uuidof(IDXGIFactory2))
+			{
+				*ppvObject = this;
+				AddRef( );
+				return S_OK;
+			}
+			else
+			{
+				// DEBUG
+				char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
+				OLECHAR iidwstr[ sizeof(iidstr) ];
+				StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
+				WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
+				printf("[IDXGIFactoryWrapper] QueryInterface: %s\n", iidstr);
+			}
+
+			
+			return m_realFactory->QueryInterface(riid, ppvObject);
+		}
+
+	
+
+	ULONG IDXGIFactoryWrapper::AddRef( )
+	{
+		return InterlockedIncrement(&m_refCount);
+	}
+
+	ULONG IDXGIFactoryWrapper::Release( )
+	{
+		ULONG refCount = InterlockedDecrement(&m_refCount);
+		if (refCount == 0)
+			delete this;
+		return refCount;
+	}
+
+
+
+	HRESULT __stdcall IDXGIFactoryWrapper::SetPrivateData(REFGUID Name, UINT DataSize, const void* pData)
+	{
+		return m_realFactory->SetPrivateData(Name, DataSize, pData);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::SetPrivateDataInterface(REFGUID Name, const IUnknown* pUnknown)
+	{
+		return m_realFactory->SetPrivateDataInterface(Name, pUnknown);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::GetPrivateData(REFGUID Name, UINT* pDataSize, void* pData)
+	{
+		return m_realFactory->GetPrivateData(Name, pDataSize, pData);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::GetParent(REFIID riid, void** ppParent)
+	{
+		return m_realFactory->GetParent(riid, ppParent);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::EnumAdapters(UINT Adapter, IDXGIAdapter** ppAdapter)
+	{
+		return m_realFactory->EnumAdapters(Adapter, ppAdapter);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::MakeWindowAssociation(HWND WindowHandle, UINT Flags)
+	{
+		return m_realFactory->MakeWindowAssociation(WindowHandle, Flags);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::GetWindowAssociation(HWND* pWindowHandle)
+	{
+		return m_realFactory->GetWindowAssociation(pWindowHandle);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::CreateSwapChain(IGraphicsUnknown* pDevice, DXGI_SWAP_CHAIN_DESC* pDesc, IDXGISwapChain** ppSwapChain)
+	{
+		return m_realFactory->CreateSwapChain(reinterpret_cast<IUnknown*>(pDevice), pDesc, ppSwapChain);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::CreateSoftwareAdapter(HMODULE Module, IDXGIAdapter** ppAdapter)
+	{
+		return m_realFactory->CreateSoftwareAdapter(Module, ppAdapter);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::EnumAdapters1(UINT Adapter, IDXGIAdapter1** ppAdapter)
+	{
+		return m_realFactory->EnumAdapters1(Adapter, ppAdapter);
+	}
+
+	BOOL __stdcall IDXGIFactoryWrapper::IsCurrent(void)
+	{
+		return m_realFactory->IsCurrent( );
+	}
+
+	BOOL __stdcall IDXGIFactoryWrapper::IsWindowedStereoEnabled(void)
+	{
+		return m_realFactory->IsWindowedStereoEnabled( );
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::CreateSwapChainForHwnd(IGraphicsUnknown* pDevice, HWND hWnd, const DXGI_SWAP_CHAIN_DESC1* pDesc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc, IDXGIOutput* pRestrictToOutput, IDXGISwapChain1** ppSwapChain)
+	{
+		return m_realFactory->CreateSwapChainForHwnd(reinterpret_cast<IUnknown*>(pDevice), hWnd, pDesc, pFullscreenDesc, pRestrictToOutput, ppSwapChain);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::CreateSwapChainForCoreWindow(IGraphicsUnknown* pDevice, IUnknown* pWindow, const DXGI_SWAP_CHAIN_DESC1* pDesc, IDXGIOutput* pRestrictToOutput, IDXGISwapChain1** ppSwapChain)
+	{
+
+
+
+		return m_realFactory->CreateSwapChainForCoreWindow(reinterpret_cast<IUnknown*>(pDevice), reinterpret_cast<CoreWindowWrapperX*>(pWindow)->m_realWindow, pDesc, pRestrictToOutput, ppSwapChain);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::GetSharedResourceAdapterLuid(HANDLE hResource, LUID* pLuid)
+	{
+		return m_realFactory->GetSharedResourceAdapterLuid(hResource, pLuid);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::RegisterStereoStatusWindow(HWND WindowHandle, UINT wMsg, DWORD* pdwCookie)
+	{
+		return m_realFactory->RegisterStereoStatusWindow(WindowHandle, wMsg, pdwCookie);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::RegisterStereoStatusEvent(HANDLE hEvent, DWORD* pdwCookie)
+	{
+		return m_realFactory->RegisterStereoStatusEvent(hEvent, pdwCookie);
+	}
+
+	void __stdcall IDXGIFactoryWrapper::UnregisterStereoStatus(DWORD dwCookie)
+	{
+		return m_realFactory->UnregisterStereoStatus(dwCookie);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::RegisterOcclusionStatusWindow(HWND WindowHandle, UINT wMsg, DWORD* pdwCookie)
+	{
+		return m_realFactory->RegisterOcclusionStatusWindow(WindowHandle, wMsg, pdwCookie);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::RegisterOcclusionStatusEvent(HANDLE hEvent, DWORD* pdwCookie)
+	{
+		return m_realFactory->RegisterOcclusionStatusEvent(hEvent, pdwCookie);
+	}
+
+	void __stdcall IDXGIFactoryWrapper::UnregisterOcclusionStatus(DWORD dwCookie)
+	{
+		return m_realFactory->UnregisterOcclusionStatus(dwCookie);
+	}
+
+	HRESULT __stdcall IDXGIFactoryWrapper::CreateSwapChainForComposition(IGraphicsUnknown* pDevice, const DXGI_SWAP_CHAIN_DESC1* pDesc, IDXGIOutput* pRestrictToOutput, IDXGISwapChain1** ppSwapChain)
+	{
+		return m_realFactory->CreateSwapChainForComposition(reinterpret_cast<IUnknown*>(pDevice), pDesc, pRestrictToOutput, ppSwapChain);
+	}
+
+}
--- a/dlls/d3d11_x/IDXGIWrappers.h
+++ b/dlls/d3d11_x/IDXGIWrappers.h
@@ -0,0 +1,188 @@
+#pragma once
+#include "IDXGI.h"
+
+
+namespace d3d11x
+{
+    class IDXGIFactoryWrapper : public d3d11x::IDXGIFactory2_X
+    {
+    public:
+
+        IDXGIFactoryWrapper(IDXGIFactory2* factory) : m_realFactory(factory)
+        {
+
+        }
+
+
+        // IGraphicsUnknown
+        HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
+
+        
+
+
+        ULONG AddRef( ) override;
+        ULONG Release( ) override;
+
+        // IDXGIObject
+        HRESULT STDMETHODCALLTYPE SetPrivateData(_In_  REFGUID Name, UINT DataSize, _In_reads_bytes_(DataSize)  const void* pData) override;
+        HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_  REFGUID Name, _In_opt_  const IUnknown* pUnknown) override;
+        HRESULT STDMETHODCALLTYPE GetPrivateData(_In_  REFGUID Name, _Inout_  UINT* pDataSize, _Out_writes_bytes_(*pDataSize)  void* pData) override;
+        HRESULT STDMETHODCALLTYPE GetParent(_In_  REFIID riid, _COM_Outptr_  void** ppParent) override;
+
+        // IDXGIFactory
+        HRESULT STDMETHODCALLTYPE EnumAdapters(
+            UINT Adapter,
+            IDXGIAdapter** ppAdapter) override;
+        HRESULT STDMETHODCALLTYPE MakeWindowAssociation(
+            HWND WindowHandle,
+            UINT Flags) override;
+        HRESULT STDMETHODCALLTYPE GetWindowAssociation(
+            HWND* pWindowHandle) override;
+        HRESULT STDMETHODCALLTYPE CreateSwapChain(
+            IGraphicsUnknown* pDevice,
+            DXGI_SWAP_CHAIN_DESC* pDesc,
+            IDXGISwapChain** ppSwapChain) override;
+        HRESULT STDMETHODCALLTYPE CreateSoftwareAdapter(
+            HMODULE Module,
+            IDXGIAdapter** ppAdapter) override;
+
+
+        // IDXGIFactory1
+        HRESULT STDMETHODCALLTYPE EnumAdapters1(UINT Adapter, IDXGIAdapter1** ppAdapter) override;
+        BOOL STDMETHODCALLTYPE IsCurrent(void) override;
+
+
+        // IDXGIFactory2
+        BOOL STDMETHODCALLTYPE IsWindowedStereoEnabled(void) override;
+
+        HRESULT STDMETHODCALLTYPE CreateSwapChainForHwnd(IGraphicsUnknown* pDevice,
+            HWND hWnd, const DXGI_SWAP_CHAIN_DESC1* pDesc,
+            const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc,
+            IDXGIOutput* pRestrictToOutput,
+            IDXGISwapChain1** ppSwapChain) override;
+
+        HRESULT STDMETHODCALLTYPE CreateSwapChainForCoreWindow(
+            IGraphicsUnknown* pDevice,
+            IUnknown* pWindow,
+            const DXGI_SWAP_CHAIN_DESC1* pDesc,
+            IDXGIOutput* pRestrictToOutput,
+            IDXGISwapChain1** ppSwapChain) override;
+
+
+        HRESULT STDMETHODCALLTYPE GetSharedResourceAdapterLuid(
+            HANDLE hResource,
+            LUID* pLuid) override;
+        HRESULT STDMETHODCALLTYPE RegisterStereoStatusWindow(
+            HWND WindowHandle,
+            UINT wMsg,
+            DWORD* pdwCookie) override;
+        HRESULT STDMETHODCALLTYPE RegisterStereoStatusEvent(
+            HANDLE hEvent,
+            DWORD* pdwCookie) override;
+        void STDMETHODCALLTYPE UnregisterStereoStatus(
+            DWORD dwCookie) override;
+        HRESULT STDMETHODCALLTYPE RegisterOcclusionStatusWindow(
+            HWND WindowHandle,
+            UINT wMsg,
+            DWORD* pdwCookie) override;
+        HRESULT STDMETHODCALLTYPE RegisterOcclusionStatusEvent(
+            HANDLE hEvent,
+            DWORD* pdwCookie) override;
+        void STDMETHODCALLTYPE UnregisterOcclusionStatus(
+            DWORD dwCookie) override;
+        HRESULT STDMETHODCALLTYPE CreateSwapChainForComposition(
+            IGraphicsUnknown* pDevice,
+            const DXGI_SWAP_CHAIN_DESC1* pDesc,
+            IDXGIOutput* pRestrictToOutput,
+            IDXGISwapChain1** ppSwapChain) override;
+
+    private:
+        long m_refCount = 1;
+        IDXGIFactory2* m_realFactory;
+    };
+
+    
+
+    class IDXGIAdapterWrapper : public IDXGIAdapter_X
+    {
+    public:
+
+        IDXGIAdapterWrapper(IDXGIAdapter* adapter) : m_realAdapter(adapter)
+        {
+        }
+
+
+
+        // IGraphicsUnknown
+        HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
+        ULONG AddRef( ) override;
+        ULONG Release( ) override;
+
+        // IDXGIObject
+        HRESULT STDMETHODCALLTYPE SetPrivateData(_In_  REFGUID Name, UINT DataSize, _In_reads_bytes_(DataSize)  const void* pData) override;
+        HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_  REFGUID Name, _In_opt_  const IUnknown* pUnknown) override;
+        HRESULT STDMETHODCALLTYPE GetPrivateData(_In_  REFGUID Name, _Inout_  UINT* pDataSize, _Out_writes_bytes_(*pDataSize)  void* pData) override;
+        HRESULT STDMETHODCALLTYPE GetParent(_In_  REFIID riid, _COM_Outptr_  void** ppParent) override;
+
+        HRESULT STDMETHODCALLTYPE EnumOutputs(
+             UINT Output,
+             IDXGIOutput** ppOutput) override;
+
+        HRESULT STDMETHODCALLTYPE GetDesc(
+            DXGI_ADAPTER_DESC* pDesc) override;
+
+        HRESULT STDMETHODCALLTYPE CheckInterfaceSupport(
+            REFGUID InterfaceName,
+            LARGE_INTEGER* pUMDVersion) override;
+
+    private:
+        long m_refCount = 1;
+        IDXGIAdapter* m_realAdapter;
+    };
+
+    class IDXGIDeviceWrapper : public IDXGIDevice_X
+    {
+    public:
+
+        IDXGIDeviceWrapper(IDXGIDevice1* device) : m_realDevice(device)
+        {
+
+        }
+
+        // IGraphicsUnknown
+        HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
+        ULONG AddRef( ) override;
+        ULONG Release( ) override;
+
+        // IDXGIObject
+        HRESULT STDMETHODCALLTYPE SetPrivateData(_In_  REFGUID Name, UINT DataSize, _In_reads_bytes_(DataSize)  const void* pData) override;
+        HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_  REFGUID Name, _In_opt_  const IUnknown* pUnknown) override;
+        HRESULT STDMETHODCALLTYPE GetPrivateData(_In_  REFGUID Name, _Inout_  UINT* pDataSize, _Out_writes_bytes_(*pDataSize)  void* pData) override;
+        HRESULT STDMETHODCALLTYPE GetParent(_In_  REFIID riid, _COM_Outptr_  void** ppParent) override;
+
+        HRESULT STDMETHODCALLTYPE GetAdapter(
+            _COM_Outptr_  IDXGIAdapter_X** pAdapter) override;
+
+        HRESULT STDMETHODCALLTYPE CreateSurface(
+            _In_  const DXGI_SURFACE_DESC* pDesc,
+            UINT NumSurfaces,
+            DXGI_USAGE Usage,
+            _In_opt_  const DXGI_SHARED_RESOURCE* pSharedResource,
+            _Out_writes_(NumSurfaces)  IDXGISurface** ppSurface) override;
+
+        HRESULT STDMETHODCALLTYPE QueryResourceResidency(
+            _In_reads_(NumResources)  IGraphicsUnknown** ppResources,
+            _Out_writes_(NumResources)  DXGI_RESIDENCY* pResidencyStatus,
+             UINT NumResources) override;
+
+        HRESULT STDMETHODCALLTYPE SetGPUThreadPriority(
+            INT Priority) override;
+
+        HRESULT STDMETHODCALLTYPE GetGPUThreadPriority(
+            _Out_  INT* pPriority) override;
+
+    private:
+        long m_refCount = 1;
+        IDXGIDevice* m_realDevice;
+    };
+}
--- a/dlls/d3d11_x/d3d11_x.vcxproj
+++ b/dlls/d3d11_x/d3d11_x.vcxproj
@@ -93,12 +93,17 @@
    <ClInclude Include="d3d_x\d3d_x.hpp" />
    <ClInclude Include="Exports.def" />
    <ClInclude Include="framework.h" />
+    <ClInclude Include="IDXGIWrappers.h" />
    <ClInclude Include="pch.h" />
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="d3d11_x.cpp" />
    <ClCompile Include="d3d_x\d3d11_x_device.cpp" />
    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="IDXGI.h" />
+    <ClCompile Include="IDXGIAdapterWrapper.cpp" />
+    <ClCompile Include="IDXGIDeviceWrapper.cpp" />
+    <ClCompile Include="IDXGIFactoryWrapper.cpp" />
    <ClCompile Include="pch.cpp">
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
--- a/dlls/d3d11_x/d3d11_x.vcxproj.filters
+++ b/dlls/d3d11_x/d3d11_x.vcxproj.filters
@@ -13,6 +13,12 @@
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
+    <Filter Include="Header Files\dxgi">
+      <UniqueIdentifier>{93367b01-f957-4ef5-82c7-4aab1139fc9c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Dxgi">
+      <UniqueIdentifier>{cc2a8930-4142-49f7-9b17-f71e472520ed}</UniqueIdentifier>
+    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="framework.h">
@@ -33,6 +39,9 @@
    <ClInclude Include="d3d_x\d3d11_x_device.h">
      <Filter>Header Files</Filter>
    </ClInclude>
+    <ClInclude Include="IDXGIWrappers.h">
+      <Filter>Header Files\dxgi</Filter>
+    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="d3d11_x.cpp">
@@ -47,6 +56,18 @@
    <ClCompile Include="d3d_x\d3d11_x_device.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
+    <ClCompile Include="IDXGI.h">
+      <Filter>Header Files\dxgi</Filter>
+    </ClCompile>
+    <ClCompile Include="IDXGIFactoryWrapper.cpp">
+      <Filter>Source Files\Dxgi</Filter>
+    </ClCompile>
+    <ClCompile Include="IDXGIDeviceWrapper.cpp">
+      <Filter>Source Files\Dxgi</Filter>
+    </ClCompile>
+    <ClCompile Include="IDXGIAdapterWrapper.cpp">
+      <Filter>Source Files\Dxgi</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <None Include="Exports.def.bak" />
--- a/dlls/d3d11_x/d3d_x/d3d11_x_device.cpp
+++ b/dlls/d3d11_x/d3d_x/d3d11_x_device.cpp
@@ -1,8 +1,41 @@
 #include "pch.h"
 #include "d3d11_x_device.h"
 #include "d3d_x.hpp"
+#include "../IDXGIWrappers.h"

 #pragma region ID3D11DeviceX
+
+// QueryInterface need to be in the cpp file because of circular dependency for IDXGIDeviceWrapper :}
+
+HRESULT d3d11x::D3D11DeviceXWrapperX::QueryInterface(REFIID riid, void** ppvObject) 
+{
+    // note from unixian: for debugging purposes
+    char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
+    OLECHAR iidwstr[ sizeof(iidstr) ];
+    StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
+    WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
+    printf("[D3D11DeviceXWrapperX] QueryInterface: %s\n", iidstr);
+
+    if (riid == __uuidof(ID3D11DeviceX) || riid == __uuidof(ID3D11Device2) ||
+        riid == __uuidof(ID3D11Device1) || riid == __uuidof(ID3D11Device))
+    {
+        *ppvObject = static_cast<ID3D11DeviceX*>(this);
+        AddRef( );
+        return S_OK;
+    }
+
+    if (riid == __uuidof(IDXGIDevice) ||
+        riid == __uuidof(IDXGIDevice1))
+    {
+        void** giDevice = nullptr;
+        HRESULT hr = m_realDevice->QueryInterface(riid, ppvObject);
+        *ppvObject = new IDXGIDeviceWrapper(static_cast<IDXGIDevice1*>(*ppvObject));
+        return S_OK;
+    }
+
+    return m_realDevice->QueryInterface(riid, ppvObject);
+}
+
 void d3d11x::D3D11DeviceXWrapperX::GetImmediateContextX(
    _Out_ ID3D11DeviceContextX** ppImmediateContextX)
 {
--- a/dlls/d3d11_x/d3d_x/d3d11_x_device.h
+++ b/dlls/d3d11_x/d3d_x/d3d11_x_device.h
@@ -94,6 +94,7 @@ namespace d3d11x
 		IUnknown* m_pUnknown;
 	};

+	class IDXGIDeviceWrapper;
 	class IGraphicsUnknown;
 	class ID3D11DeviceContextX;
 	class ID3D11CounterSetX;
@@ -125,38 +126,31 @@ namespace d3d11x
 	public:
 		UINT m_CreationFlags;

-		virtual HRESULT CreateBuffer(_Inout_ ID3D11Device* pDevice,
-			_In_ const D3D11_BUFFER_DESC* pDesc,
+		virtual HRESULT CreateBuffer(_In_ const D3D11_BUFFER_DESC* pDesc,
 			_In_opt_ const D3D11_SUBRESOURCE_DATA* pInitialData,
 			_Out_opt_ ID3D11Buffer** ppBuffer) = 0;

-		virtual HRESULT CreateTexture1D(_Inout_ ID3D11Device* pDevice,
-			_In_ const D3D11_TEXTURE1D_DESC* pDesc,
+		virtual HRESULT CreateTexture1D(_In_ const D3D11_TEXTURE1D_DESC* pDesc,
 			_In_reads_opt_(_Inexpressible_(pDesc->MipLevels* pDesc->ArraySize)) const D3D11_SUBRESOURCE_DATA* pInitialData,
 			_Out_opt_ ID3D11Texture1D** ppTexture1D) = 0;

-		virtual HRESULT CreateTexture2D(_Inout_ ID3D11Device* pDevice,
-			_In_ const D3D11_TEXTURE2D_DESC* pDesc,
+		virtual HRESULT CreateTexture2D(_In_ const D3D11_TEXTURE2D_DESC* pDesc,
 			_In_reads_opt_(_Inexpressible_(pDesc->MipLevels* pDesc->ArraySize)) const D3D11_SUBRESOURCE_DATA* pInitialData,
 			_Out_opt_ ID3D11Texture2D** ppTexture2D) = 0;

-		virtual HRESULT CreateTexture3D(_Inout_ ID3D11Device* pDevice,
-			_In_ const D3D11_TEXTURE3D_DESC* pDesc,
+		virtual HRESULT CreateTexture3D(_In_ const D3D11_TEXTURE3D_DESC* pDesc,
 			_In_reads_opt_(_Inexpressible_(pDesc->MipLevels)) const D3D11_SUBRESOURCE_DATA* pInitialData,
 			_Out_opt_ ID3D11Texture3D** ppTexture3D) = 0;

-		virtual HRESULT CreateShaderResourceView(_Inout_ ID3D11Device* pDevice,
-			_In_ ID3D11Resource* pResource,
+		virtual HRESULT CreateShaderResourceView(_In_ ID3D11Resource* pResource,
 			_In_opt_ const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
 			_Out_opt_ ID3D11ShaderResourceView** ppSRView) = 0;

-		virtual HRESULT CreateUnorderedAccessView(_Inout_ ID3D11Device* pDevice,
-			_In_ ID3D11Resource* pResource,
+		virtual HRESULT CreateUnorderedAccessView(_In_ ID3D11Resource* pResource,
 			_In_opt_ const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
 			_Out_opt_ ID3D11UnorderedAccessView** ppUAView) = 0;

-		virtual HRESULT CreateRenderTargetView(_Inout_ ID3D11Device* pDevice,
-			_In_ ID3D11Resource* pResource,
+		virtual HRESULT CreateRenderTargetView(_In_ ID3D11Resource* pResource,
 			_In_opt_ const D3D11_RENDER_TARGET_VIEW_DESC* pDesc,
 			_Out_opt_ ID3D11RenderTargetView** ppRTView) = 0;

@@ -415,25 +409,8 @@ namespace d3d11x
 			m_RefCount = 1;
 		}

-		HRESULT QueryInterface(REFIID riid, void** ppvObject) override
-		{
-			// note from unixian: for debugging purposes
-			char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
-			OLECHAR iidwstr[ sizeof(iidstr) ];
-			StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
-			WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
-			printf("[D3D11DeviceXWrapperX] QueryInterface: %s\n", iidstr);
-
-			if (riid == __uuidof(ID3D11DeviceX) || riid == __uuidof(ID3D11Device2) ||
-				riid == __uuidof(ID3D11Device1) || riid == __uuidof(ID3D11Device))
-			{
-				*ppvObject = static_cast<ID3D11DeviceX*>(this);
-				AddRef( );
-				return S_OK;
-			}
-
-			return m_realDevice->QueryInterface(riid, ppvObject);
-		}
+		HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
+		

 		ULONG AddRef( ) override
 		{
@@ -463,7 +440,6 @@ namespace d3d11x
 		}

 		HRESULT CreateBuffer(
-			   ID3D11Device* pDevice,
 			   const D3D11_BUFFER_DESC* pDesc,
 			   const D3D11_SUBRESOURCE_DATA* pInitialData,
 			   ID3D11Buffer** ppBuffer) override {
@@ -471,7 +447,6 @@ namespace d3d11x
 		}

 		HRESULT CreateTexture1D(
-			ID3D11Device* pDevice,
 			const D3D11_TEXTURE1D_DESC* pDesc,
 			const D3D11_SUBRESOURCE_DATA* pInitialData,
 			ID3D11Texture1D** ppTexture1D) override {
@@ -479,7 +454,6 @@ namespace d3d11x
 		}

 		HRESULT CreateTexture2D(
-			ID3D11Device* pDevice,
 			const D3D11_TEXTURE2D_DESC* pDesc,
 			const D3D11_SUBRESOURCE_DATA* pInitialData,
 			ID3D11Texture2D** ppTexture2D) override {
@@ -487,7 +461,6 @@ namespace d3d11x
 		}

 		HRESULT CreateTexture3D(
-			ID3D11Device* pDevice,
 			const D3D11_TEXTURE3D_DESC* pDesc,
 			const D3D11_SUBRESOURCE_DATA* pInitialData,
 			ID3D11Texture3D** ppTexture3D) override {
@@ -495,7 +468,6 @@ namespace d3d11x
 		}

 		HRESULT CreateShaderResourceView(
-			ID3D11Device* pDevice,
 			ID3D11Resource* pResource,
 			const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
 			ID3D11ShaderResourceView** ppSRView) override {
@@ -503,7 +475,6 @@ namespace d3d11x
 		}

 		HRESULT CreateUnorderedAccessView(
-			ID3D11Device* pDevice,
 			ID3D11Resource* pResource,
 			const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
 			ID3D11UnorderedAccessView** ppUAView) override {
@@ -511,7 +482,6 @@ namespace d3d11x
 		}

 		HRESULT CreateRenderTargetView(
-			ID3D11Device* pDevice,
 			ID3D11Resource* pResource,
 			const D3D11_RENDER_TARGET_VIEW_DESC* pDesc,
 			ID3D11RenderTargetView** ppRTView) override {