From 331c3a927e88b9ee2f13db701a2c6a6fd85e6caf Mon Sep 17 00:00:00 2001 From: cdozdil Date: Wed, 13 Dec 2023 13:37:38 +0300 Subject: [PATCH] wrapped device changes --- CyberXeSS/CyberXeSS.vcxproj | 4 + CyberXeSS/CyberXeSS.vcxproj.filters | 12 + CyberXeSS/CyberXess.h | 4 +- CyberXeSS/CyberXessDx12.cpp | 79 +++ CyberXeSS/WrappedD3D12Device.cpp | 702 ++++++++++++++++++++++ CyberXeSS/WrappedD3D12Device.h | 245 ++++++++ CyberXeSS/WrappedDXGIObjects.cpp | 542 +++++++++++++++++ CyberXeSS/WrappedDXGIObjects.h | 882 ++++++++++++++++++++++++++++ CyberXeSS/pch.h | 41 +- 9 files changed, 2507 insertions(+), 4 deletions(-) create mode 100644 CyberXeSS/WrappedD3D12Device.cpp create mode 100644 CyberXeSS/WrappedD3D12Device.h create mode 100644 CyberXeSS/WrappedDXGIObjects.cpp create mode 100644 CyberXeSS/WrappedDXGIObjects.h diff --git a/CyberXeSS/CyberXeSS.vcxproj b/CyberXeSS/CyberXeSS.vcxproj index da53ba3b..cef6e912 100644 --- a/CyberXeSS/CyberXeSS.vcxproj +++ b/CyberXeSS/CyberXeSS.vcxproj @@ -174,6 +174,8 @@ + + @@ -190,6 +192,8 @@ Create + + diff --git a/CyberXeSS/CyberXeSS.vcxproj.filters b/CyberXeSS/CyberXeSS.vcxproj.filters index 2228d042..35e23bc2 100644 --- a/CyberXeSS/CyberXeSS.vcxproj.filters +++ b/CyberXeSS/CyberXeSS.vcxproj.filters @@ -33,6 +33,12 @@ Header Files + + Header Files + + + Header Files + Header Files @@ -65,5 +71,11 @@ Source Files + + Source Files + + + Source Files + \ No newline at end of file diff --git a/CyberXeSS/CyberXess.h b/CyberXeSS/CyberXess.h index 577da5fb..9e18b072 100644 --- a/CyberXeSS/CyberXess.h +++ b/CyberXeSS/CyberXess.h @@ -3,6 +3,7 @@ #include "NvParameter.h" #include "xess_d3d12.h" #include "xess_debug.h" +#include "WrappedD3D12Device.h" #include "d3d11on12.h" #include "d3dx12.h" @@ -19,12 +20,13 @@ public: bool init = false; const NvParameter* CreateFeatureParams; ID3D12Device* Dx12Device = nullptr; + WrappedD3D12Device* Dx12ProxyDevice = nullptr; ID3D11Device* Dx11Device = nullptr; ID3D11DeviceContext* Dx11DeviceContext = nullptr; VkDevice VulkanDevice = nullptr; VkInstance VulkanInstance = nullptr; VkPhysicalDevice VulkanPhysicalDevice = nullptr; - + // D3D11on12 stuff ID3D11On12Device2* Dx11on12Device = nullptr; ID3D12CommandAllocator* Dx12CommandAllocator = nullptr; diff --git a/CyberXeSS/CyberXessDx12.cpp b/CyberXeSS/CyberXessDx12.cpp index 3d2af502..09bb6545 100644 --- a/CyberXeSS/CyberXessDx12.cpp +++ b/CyberXeSS/CyberXessDx12.cpp @@ -90,12 +90,37 @@ static bool CreateFeature(ID3D12GraphicsCommandList* InCmdList, const NVSDK_NGX_ else { LOG("NVSDK_NGX_D3D12_CreateFeature CyberXessContext::instance()->Dx12Device received from InCmdList!", LEVEL_WARNING); + + CyberXessContext::instance()->Dx12Device->QueryInterface(__uuidof(ID3D12ProxyDevice), (void**)&CyberXessContext::instance()->Dx12ProxyDevice); + + if (CyberXessContext::instance()->Dx12ProxyDevice != nullptr) + LOG("NVSDK_NGX_D3D12_CreateFeature Dx12ProxyDevice assigned...", LEVEL_DEBUG); + else + LOG("NVSDK_NGX_D3D12_CreateFeature Dx12ProxyDevice not assigned...", LEVEL_DEBUG); + } } else LOG("NVSDK_NGX_D3D12_CreateFeature CyberXessContext::instance()->Dx12Device is OK!", LEVEL_DEBUG); #pragma endregion +#pragma region Check for Dx12ProxyDevice Device + //if (CyberXessContext::instance()->Dx12ProxyDevice != nullptr) + //{ + // LOG("NVSDK_NGX_D3D12_CreateFeature Dx12ProxyDevice proxy adapter disabling spoofing...", LEVEL_DEBUG); + // IDXGIProxyAdapter* pAdapter = nullptr; + + // if (SUCCEEDED(CyberXessContext::instance()->Dx12ProxyDevice->GetProxyAdapter(&pAdapter)) && pAdapter != nullptr) + // { + // LOG("NVSDK_NGX_D3D12_CreateFeature Dx12ProxyDevice proxy adapter accuired...", LEVEL_DEBUG); + // pAdapter->Spoofing(false); + // LOG("NVSDK_NGX_D3D12_CreateFeature Dx12ProxyDevice proxy adapter spoofing disabled...", LEVEL_DEBUG); + // } + // else + // LOG("NVSDK_NGX_D3D12_CreateFeature Dx12ProxyDevice proxy adapter is null!!!", LEVEL_DEBUG); + //} +#pragma endregion + auto inParams = CyberXessContext::instance()->CreateFeatureParams; auto deviceContext = CyberXessContext::instance()->Contexts[handle->Id].get(); @@ -275,12 +300,30 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Init_Ext(unsigned long long InApp CyberXessContext::instance()->init = false; CyberXessContext::instance()->Dx12Device = nullptr; + CyberXessContext::instance()->Dx12ProxyDevice = nullptr; if (InDevice) { + WrappedD3D12Device* proxyDevice = nullptr; + if (InDevice->QueryInterface(__uuidof(ID3D12ProxyDevice), (void**)&proxyDevice) == S_OK && proxyDevice != nullptr) + { + CyberXessContext::instance()->Dx12Device = proxyDevice->m_device; + LOG("NVSDK_NGX_D3D12_Init_Ext Proxy Dx12Device assigned...", LEVEL_DEBUG); + } + else + { CyberXessContext::instance()->Dx12Device = InDevice; LOG("NVSDK_NGX_D3D12_Init_Ext Dx12Device assigned...", LEVEL_DEBUG); } + + + InDevice->QueryInterface(__uuidof(ID3D12ProxyDevice), (void**)&CyberXessContext::instance()->Dx12ProxyDevice); + + if (CyberXessContext::instance()->Dx12ProxyDevice != nullptr) + LOG("NVSDK_NGX_D3D12_Init_Ext Dx12ProxyDevice assigned...", LEVEL_DEBUG); + else + LOG("NVSDK_NGX_D3D12_Init_Ext Dx12ProxyDevice not assigned...", LEVEL_DEBUG); + } else LOG("NVSDK_NGX_D3D12_Init_Ext Dx12Device is already assigned or InDevice is null!!!!", LEVEL_ERROR); @@ -324,7 +367,24 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Shutdown(void) { LOG("NVSDK_NGX_D3D12_Shutdown", LEVEL_DEBUG); + //if (CyberXessContext::instance()->Dx12ProxyDevice != nullptr) + //{ + // LOG("NVSDK_NGX_D3D12_Shutdown Dx12ProxyDevice proxy adapter spoofing enabling...", LEVEL_DEBUG); + // IDXGIProxyAdapter* pAdapter = nullptr; + // CyberXessContext::instance()->Dx12ProxyDevice->GetProxyAdapter(&pAdapter); + // LOG("NVSDK_NGX_D3D12_Shutdown Dx12ProxyDevice proxy adapter accuired...", LEVEL_DEBUG); + + // if (pAdapter != nullptr) + // { + // pAdapter->Spoofing(true); + // LOG("NVSDK_NGX_D3D12_Shutdown Dx12ProxyDevice proxy adapter spoofing enabled...", LEVEL_DEBUG); + // } + // else + // LOG("NVSDK_NGX_D3D12_Shutdown Dx12ProxyDevice proxy adapter is null!!!", LEVEL_DEBUG); + //} + CyberXessContext::instance()->Dx12Device = nullptr; + CyberXessContext::instance()->Dx12ProxyDevice = nullptr; CyberXessContext::instance()->NvParameterInstance->Params.clear(); CyberXessContext::instance()->Contexts.clear(); @@ -335,7 +395,25 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_Shutdown1(ID3D12Device* InDevice) { LOG("NVSDK_NGX_D3D12_Shutdown1", LEVEL_DEBUG); + //if (CyberXessContext::instance()->Dx12ProxyDevice != nullptr) + //{ + // LOG("NVSDK_NGX_D3D12_Shutdown1 Dx12ProxyDevice proxy adapter spoofing enabling...", LEVEL_DEBUG); + + // IDXGIProxyAdapter* pAdapter = nullptr; + // CyberXessContext::instance()->Dx12ProxyDevice->GetProxyAdapter(&pAdapter); + // LOG("NVSDK_NGX_D3D12_Shutdown1 Dx12ProxyDevice proxy adapter accuired...", LEVEL_DEBUG); + + // if (pAdapter != nullptr) + // { + // pAdapter->Spoofing(true); + // LOG("NVSDK_NGX_D3D12_Shutdown1 Dx12ProxyDevice proxy adapter spoofing enabled...", LEVEL_DEBUG); + // } + // else + // LOG("NVSDK_NGX_D3D12_Shutdown1 Dx12ProxyDevice proxy adapter is null!!!", LEVEL_DEBUG); + //} + CyberXessContext::instance()->Dx12Device = nullptr; + CyberXessContext::instance()->Dx12ProxyDevice = nullptr; CyberXessContext::instance()->NvParameterInstance->Params.clear(); CyberXessContext::instance()->Contexts.clear(); @@ -466,6 +544,7 @@ NVSDK_NGX_API NVSDK_NGX_Result NVSDK_NGX_D3D12_EvaluateFeature(ID3D12GraphicsCom //xessStartDump(deviceContext->XessContext, &dumpParams); // creatimg params for XeSS + xess_result_t xessResult; xess_d3d12_execute_params_t params{}; params.jitterOffsetX = inParams->JitterOffsetX; diff --git a/CyberXeSS/WrappedD3D12Device.cpp b/CyberXeSS/WrappedD3D12Device.cpp new file mode 100644 index 00000000..142dd840 --- /dev/null +++ b/CyberXeSS/WrappedD3D12Device.cpp @@ -0,0 +1,702 @@ +#include "pch.h" +#include "WrappedD3D12Device.h" + +bool RefCountD3D12Object::HandleWrap(const char* ifaceName, REFIID riid, void** ppvObject) +{ + LOG("RefCountD3D12Object.HandleWrap"); + + if (ppvObject == NULL || *ppvObject == NULL) + { + std::string str(ifaceName); + LOG("RefCountD3D12Object.HandleWrap called with NULL ppvObject querying " + str); + return false; + } + + // unknown GUID that we only want to print once to avoid log spam + // {79D2046C-22EF-451B-9E74-2245D9C760EA} + static const GUID Unknown_uuid = { + 0x79d2046c, 0x22ef, 0x451b, {0x9e, 0x74, 0x22, 0x45, 0xd9, 0xc7, 0x60, 0xea} }; + + // unknown/undocumented internal interface + // {7abb6563-02bc-47c4-8ef9-acc4795edbcf} + static const GUID ID3D12DeviceInternal2_uuid = { + 0x7abb6563, 0x02bc, 0x47c4, {0x8e, 0xf9, 0xac, 0xc4, 0x79, 0x5e, 0xdb, 0xcf} }; + + if (riid == __uuidof(ID3D12Device)) + { + ID3D12Device* real = (ID3D12Device*)(*ppvObject); + *ppvObject = (ID3D12Device*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device1)) + { + ID3D12Device1* real = (ID3D12Device1*)(*ppvObject); + *ppvObject = (ID3D12Device1*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device2)) + { + ID3D12Device2* real = (ID3D12Device2*)(*ppvObject); + *ppvObject = (ID3D12Device2*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device3)) + { + ID3D12Device3* real = (ID3D12Device3*)(*ppvObject); + *ppvObject = (ID3D12Device3*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device4)) + { + ID3D12Device4* real = (ID3D12Device4*)(*ppvObject); + *ppvObject = (ID3D12Device4*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device5)) + { + ID3D12Device5* real = (ID3D12Device5*)(*ppvObject); + *ppvObject = (ID3D12Device5*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device6)) + { + ID3D12Device6* real = (ID3D12Device6*)(*ppvObject); + *ppvObject = (ID3D12Device6*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device7)) + { + ID3D12Device7* real = (ID3D12Device7*)(*ppvObject); + *ppvObject = (ID3D12Device7*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device8)) + { + ID3D12Device8* real = (ID3D12Device8*)(*ppvObject); + *ppvObject = (ID3D12Device8*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device9)) + { + ID3D12Device9* real = (ID3D12Device9*)(*ppvObject); + *ppvObject = (ID3D12Device9*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == __uuidof(ID3D12Device10)) + { + ID3D12Device10* real = (ID3D12Device10*)(*ppvObject); + *ppvObject = (ID3D12Device10*)(new WrappedD3D12Device(real)); + return true; + } + else if (riid == Unknown_uuid) + { + LOG("RefCountDXGIObject.HandleWrap Querying Unknown_uuid, returning false"); + } + else if (riid == ID3D12DeviceInternal2_uuid) + { + LOG("RefCountDXGIObject.HandleWrap Querying ID3D12DeviceInternal2_uuid, returning false"); + } + else + { + std::string str(ifaceName); + LOG("RefCountDXGIObject.HandleWrap Querying " + str + " for unrecognized GUID: " + ToString(riid)); + } + + return false; +} + +HRESULT RefCountD3D12Object::WrapQueryInterface(IUnknown* real, const char* ifaceName, REFIID riid, void** ppvObject) +{ + LOG("RefCountD3D12Object.WrapQueryInterface"); + + HRESULT ret = real->QueryInterface(riid, ppvObject); + + if (ret == S_OK && HandleWrap(ifaceName, riid, ppvObject)) + return ret; + + *ppvObject = NULL; + return E_NOINTERFACE; +} + +WrappedD3D12Device::WrappedD3D12Device(ID3D12Device* device) : RefCountD3D12Object(device), m_device(device) +{ + m_device1 = NULL; + device->QueryInterface(__uuidof(ID3D12Device1), (void**)&m_device1); + m_device2 = NULL; + device->QueryInterface(__uuidof(ID3D12Device2), (void**)&m_device2); + m_device3 = NULL; + device->QueryInterface(__uuidof(ID3D12Device3), (void**)&m_device3); + m_device4 = NULL; + device->QueryInterface(__uuidof(ID3D12Device4), (void**)&m_device4); + m_device5 = NULL; + device->QueryInterface(__uuidof(ID3D12Device5), (void**)&m_device5); + m_device6 = NULL; + device->QueryInterface(__uuidof(ID3D12Device6), (void**)&m_device6); + m_device7 = NULL; + device->QueryInterface(__uuidof(ID3D12Device7), (void**)&m_device7); + m_device8 = NULL; + device->QueryInterface(__uuidof(ID3D12Device8), (void**)&m_device8); + m_device9 = NULL; + device->QueryInterface(__uuidof(ID3D12Device9), (void**)&m_device9); + m_device10 = NULL; + device->QueryInterface(__uuidof(ID3D12Device10), (void**)&m_device10); +} + +WrappedD3D12Device::~WrappedD3D12Device() +{ + SAFE_RELEASE(m_device); + SAFE_RELEASE(m_device1); + SAFE_RELEASE(m_device2); + SAFE_RELEASE(m_device3); + SAFE_RELEASE(m_device4); + SAFE_RELEASE(m_device5); + SAFE_RELEASE(m_device6); + SAFE_RELEASE(m_device7); + SAFE_RELEASE(m_device8); + SAFE_RELEASE(m_device9); + SAFE_RELEASE(m_device10); +} + + +HRESULT __stdcall WrappedD3D12Device::QueryInterface(REFIID riid, void** ppvObject) +{ + LOG("D3D12Device.QueryInterface: " + ToString(riid)); + + if (ppvObject == nullptr) + return E_POINTER; + + if (riid == __uuidof(ID3D12Device)) + { + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + if (riid == __uuidof(ID3D12ProxyDevice)) + { + LOG("D3D12Device.QueryInterface: Looking for ID3D12ProxyDevice, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device1)) + { + if (m_device1 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device1 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device1, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device2)) + { + if (m_device2 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device2 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device2, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device3)) + { + if (m_device == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device3 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device3, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device4)) + { + if (m_device4 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device4 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device4, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device5)) + { + if (m_device5 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device5 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device5, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device6)) + { + if (m_device6 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device6 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device6, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device7)) + { + if (m_device7 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device7 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device7, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device8)) + { + if (m_device8 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device8 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device8, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device9)) + { + if (m_device9 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device9 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device9, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Device10)) + { + if (m_device10 == nullptr) + { + LOG("D3D12Device.QueryInterface: m_device10 is not available, returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + + LOG("D3D12Device.QueryInterface: Looking for ID3D12Device10, returning this"); + AddRef(); + *ppvObject = this; + return S_OK; + } + else if (riid == __uuidof(ID3D12DeviceRemovedExtendedData) || + riid == __uuidof(ID3D12DeviceRemovedExtendedData1) || + riid == __uuidof(ID3D12DeviceRemovedExtendedData2)) + { + LOG("D3D12Device.QueryInterface: Looking for ID3D12DeviceRemovedExtendedData"); + auto ret = m_device->QueryInterface(riid, ppvObject); + LOG("D3D12Device.QueryInterface: Looking for ID3D12DeviceRemovedExtendedData result: " + int_to_hex(ret)); + return ret; + } + + auto hr = m_device->QueryInterface(riid, ppvObject); + + if (hr == S_OK && *ppvObject != nullptr) + { + auto wrapResult = RefCountD3D12Object::HandleWrap("ID3DDevice", riid, ppvObject); + + if (!wrapResult) + { + LOG("D3D12Device.QueryInterface: returning E_NOINTERFACE"); + return E_NOINTERFACE; + } + } + + LOG("D3D12Device.QueryInterface Unknown interface result: " + int_to_hex(hr)); + return hr; +} + +HRESULT STDMETHODCALLTYPE RefCountD3D12Object::SetName(_In_z_ LPCWSTR Name) +{ + return m_pReal->SetName(Name); +} + +UINT __stdcall WrappedD3D12Device::GetNodeCount(void) +{ + return m_device->GetNodeCount(); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommandQueue(const D3D12_COMMAND_QUEUE_DESC* pDesc, REFIID riid, void** ppCommandQueue) +{ + return m_device->CreateCommandQueue(pDesc, riid, ppCommandQueue); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE type, REFIID riid, void** ppCommandAllocator) +{ + return m_device->CreateCommandAllocator(type, riid, ppCommandAllocator); +} + +HRESULT __stdcall WrappedD3D12Device::CreateGraphicsPipelineState(const D3D12_GRAPHICS_PIPELINE_STATE_DESC* pDesc, REFIID riid, void** ppPipelineState) +{ + return m_device->CreateGraphicsPipelineState(pDesc, riid, ppPipelineState); +} + +HRESULT __stdcall WrappedD3D12Device::CreateComputePipelineState(const D3D12_COMPUTE_PIPELINE_STATE_DESC* pDesc, REFIID riid, void** ppPipelineState) +{ + return m_device->CreateComputePipelineState(pDesc, riid, ppPipelineState); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommandList(UINT nodeMask, D3D12_COMMAND_LIST_TYPE type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, REFIID riid, void** ppCommandList) +{ + return m_device->CreateCommandList(nodeMask, type, pCommandAllocator, pInitialState, riid, ppCommandList); +} + +HRESULT __stdcall WrappedD3D12Device::CheckFeatureSupport(D3D12_FEATURE Feature, void* pFeatureSupportData, UINT FeatureSupportDataSize) +{ + return m_device->CheckFeatureSupport(Feature, pFeatureSupportData, FeatureSupportDataSize); +} + +HRESULT __stdcall WrappedD3D12Device::CreateDescriptorHeap(const D3D12_DESCRIPTOR_HEAP_DESC* pDescriptorHeapDesc, REFIID riid, void** ppvHeap) +{ + return m_device->CreateDescriptorHeap(pDescriptorHeapDesc, riid, ppvHeap); +} + +UINT __stdcall WrappedD3D12Device::GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType) +{ + return m_device->GetDescriptorHandleIncrementSize(DescriptorHeapType); +} + +HRESULT __stdcall WrappedD3D12Device::CreateRootSignature(UINT nodeMask, const void* pBlobWithRootSignature, SIZE_T blobLengthInBytes, REFIID riid, void** ppvRootSignature) +{ + return m_device->CreateRootSignature(nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid, ppvRootSignature); +} + +void __stdcall WrappedD3D12Device::CreateConstantBufferView(const D3D12_CONSTANT_BUFFER_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) +{ + return m_device->CreateConstantBufferView(pDesc, DestDescriptor); +} + +void __stdcall WrappedD3D12Device::CreateShaderResourceView(ID3D12Resource* pResource, const D3D12_SHADER_RESOURCE_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) +{ + return m_device->CreateShaderResourceView(pResource, pDesc, DestDescriptor); +} + +void __stdcall WrappedD3D12Device::CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, const D3D12_UNORDERED_ACCESS_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) +{ + return m_device->CreateUnorderedAccessView(pResource, pCounterResource, pDesc, DestDescriptor); +} + +void __stdcall WrappedD3D12Device::CreateRenderTargetView(ID3D12Resource* pResource, const D3D12_RENDER_TARGET_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) +{ + return m_device->CreateRenderTargetView(pResource, pDesc, DestDescriptor); +} + +void __stdcall WrappedD3D12Device::CreateDepthStencilView(ID3D12Resource* pResource, const D3D12_DEPTH_STENCIL_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) +{ + return m_device->CreateDepthStencilView(pResource, pDesc, DestDescriptor); +} + +void __stdcall WrappedD3D12Device::CreateSampler(const D3D12_SAMPLER_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) +{ + return m_device->CreateSampler(pDesc, DestDescriptor); +} + +void __stdcall WrappedD3D12Device::CopyDescriptors(UINT NumDestDescriptorRanges, const D3D12_CPU_DESCRIPTOR_HANDLE* pDestDescriptorRangeStarts, const UINT* pDestDescriptorRangeSizes, UINT NumSrcDescriptorRanges, const D3D12_CPU_DESCRIPTOR_HANDLE* pSrcDescriptorRangeStarts, const UINT* pSrcDescriptorRangeSizes, D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) +{ + return m_device->CopyDescriptors(NumDestDescriptorRanges, pDestDescriptorRangeStarts, pDestDescriptorRangeSizes, NumSrcDescriptorRanges, pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes, DescriptorHeapsType); +} + +void __stdcall WrappedD3D12Device::CopyDescriptorsSimple(UINT NumDescriptors, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) +{ + return m_device->CopyDescriptorsSimple(NumDescriptors, DestDescriptorRangeStart, SrcDescriptorRangeStart, DescriptorHeapsType); +} + +D3D12_RESOURCE_ALLOCATION_INFO __stdcall WrappedD3D12Device::GetResourceAllocationInfo(UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC* pResourceDescs) +{ + return m_device->GetResourceAllocationInfo(visibleMask, numResourceDescs, pResourceDescs); +} + +D3D12_HEAP_PROPERTIES __stdcall WrappedD3D12Device::GetCustomHeapProperties(UINT nodeMask, D3D12_HEAP_TYPE heapType) +{ + return m_device->GetCustomHeapProperties(nodeMask, heapType); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommittedResource(const D3D12_HEAP_PROPERTIES* pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialResourceState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, REFIID riidResource, void** ppvResource) +{ + return m_device->CreateCommittedResource(pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, riidResource, ppvResource); +} + +HRESULT __stdcall WrappedD3D12Device::CreateHeap(const D3D12_HEAP_DESC* pDesc, REFIID riid, void** ppvHeap) +{ + return m_device->CreateHeap(pDesc, riid, ppvHeap); +} + +HRESULT __stdcall WrappedD3D12Device::CreatePlacedResource(ID3D12Heap* pHeap, UINT64 HeapOffset, const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, REFIID riid, void** ppvResource) +{ + return m_device->CreatePlacedResource(pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +} + +HRESULT __stdcall WrappedD3D12Device::CreateReservedResource(const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, REFIID riid, void** ppvResource) +{ + return m_device->CreateReservedResource(pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +} + +HRESULT __stdcall WrappedD3D12Device::CreateSharedHandle(ID3D12DeviceChild* pObject, const SECURITY_ATTRIBUTES* pAttributes, DWORD Access, LPCWSTR Name, HANDLE* pHandle) +{ + return m_device->CreateSharedHandle(pObject, pAttributes, Access, Name, pHandle); +} + +HRESULT __stdcall WrappedD3D12Device::OpenSharedHandle(HANDLE NTHandle, REFIID riid, void** ppvObj) +{ + return m_device->OpenSharedHandle(NTHandle, riid, ppvObj); +} + +HRESULT __stdcall WrappedD3D12Device::OpenSharedHandleByName(LPCWSTR Name, DWORD Access, HANDLE* pNTHandle) +{ + return m_device->OpenSharedHandleByName(Name, Access, pNTHandle); +} + +HRESULT __stdcall WrappedD3D12Device::MakeResident(UINT NumObjects, ID3D12Pageable* const* ppObjects) +{ + return m_device->MakeResident(NumObjects, ppObjects); +} + +HRESULT __stdcall WrappedD3D12Device::Evict(UINT NumObjects, ID3D12Pageable* const* ppObjects) +{ + return m_device->Evict(NumObjects, ppObjects); +} + +HRESULT __stdcall WrappedD3D12Device::CreateFence(UINT64 InitialValue, D3D12_FENCE_FLAGS Flags, REFIID riid, void** ppFence) +{ + return m_device->CreateFence(InitialValue, Flags, riid, ppFence); +} + +HRESULT __stdcall WrappedD3D12Device::GetDeviceRemovedReason(void) +{ + return m_device->GetDeviceRemovedReason(); +} + +void __stdcall WrappedD3D12Device::GetCopyableFootprints(const D3D12_RESOURCE_DESC* pResourceDesc, UINT FirstSubresource, UINT NumSubresources, UINT64 BaseOffset, D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts, UINT* pNumRows, UINT64* pRowSizeInBytes, UINT64* pTotalBytes) +{ + return m_device->GetCopyableFootprints(pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +} + +HRESULT __stdcall WrappedD3D12Device::CreateQueryHeap(const D3D12_QUERY_HEAP_DESC* pDesc, REFIID riid, void** ppvHeap) +{ + return m_device->CreateQueryHeap(pDesc, riid, ppvHeap); +} + +HRESULT __stdcall WrappedD3D12Device::SetStablePowerState(BOOL Enable) +{ + return m_device->SetStablePowerState(Enable); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommandSignature(const D3D12_COMMAND_SIGNATURE_DESC* pDesc, ID3D12RootSignature* pRootSignature, REFIID riid, void** ppvCommandSignature) +{ + return m_device->CreateCommandSignature(pDesc, pRootSignature, riid, ppvCommandSignature); +} + +void __stdcall WrappedD3D12Device::GetResourceTiling(ID3D12Resource* pTiledResource, UINT* pNumTilesForEntireResource, D3D12_PACKED_MIP_INFO* pPackedMipDesc, D3D12_TILE_SHAPE* pStandardTileShapeForNonPackedMips, UINT* pNumSubresourceTilings, UINT FirstSubresourceTilingToGet, D3D12_SUBRESOURCE_TILING* pSubresourceTilingsForNonPackedMips) +{ + return m_device->GetResourceTiling(pTiledResource, pNumTilesForEntireResource, pPackedMipDesc, pStandardTileShapeForNonPackedMips, pNumSubresourceTilings, FirstSubresourceTilingToGet, pSubresourceTilingsForNonPackedMips); +} + +LUID __stdcall WrappedD3D12Device::GetAdapterLuid(void) +{ + return LUID{ 0, 56090 }; +} + +HRESULT __stdcall WrappedD3D12Device::CreatePipelineLibrary(const void* pLibraryBlob, SIZE_T BlobLength, REFIID riid, void** ppPipelineLibrary) +{ + return m_device1->CreatePipelineLibrary(pLibraryBlob, BlobLength, riid, ppPipelineLibrary); +} + +HRESULT __stdcall WrappedD3D12Device::SetEventOnMultipleFenceCompletion(ID3D12Fence* const* ppFences, const UINT64* pFenceValues, UINT NumFences, D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, HANDLE hEvent) +{ + return m_device1->SetEventOnMultipleFenceCompletion(ppFences, pFenceValues, NumFences, Flags, hEvent); +} + +HRESULT __stdcall WrappedD3D12Device::SetResidencyPriority(UINT NumObjects, ID3D12Pageable* const* ppObjects, const D3D12_RESIDENCY_PRIORITY* pPriorities) +{ + return m_device1->SetResidencyPriority(NumObjects, ppObjects, pPriorities); +} + +HRESULT __stdcall WrappedD3D12Device::CreatePipelineState(const D3D12_PIPELINE_STATE_STREAM_DESC* pDesc, REFIID riid, void** ppPipelineState) +{ + return m_device2->CreatePipelineState(pDesc, riid, ppPipelineState); +} + +HRESULT __stdcall WrappedD3D12Device::OpenExistingHeapFromAddress(const void* pAddress, REFIID riid, void** ppvHeap) +{ + return m_device3->OpenExistingHeapFromAddress(pAddress, riid, ppvHeap); +} + +HRESULT __stdcall WrappedD3D12Device::OpenExistingHeapFromFileMapping(HANDLE hFileMapping, REFIID riid, void** ppvHeap) +{ + return m_device3->OpenExistingHeapFromFileMapping(hFileMapping, riid, ppvHeap); +} + +HRESULT __stdcall WrappedD3D12Device::EnqueueMakeResident(D3D12_RESIDENCY_FLAGS Flags, UINT NumObjects, ID3D12Pageable* const* ppObjects, ID3D12Fence* pFenceToSignal, UINT64 FenceValueToSignal) +{ + return m_device3->EnqueueMakeResident(Flags, NumObjects, ppObjects, pFenceToSignal, FenceValueToSignal); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommandList1(UINT nodeMask, D3D12_COMMAND_LIST_TYPE type, D3D12_COMMAND_LIST_FLAGS flags, REFIID riid, void** ppCommandList) +{ + return m_device4->CreateCommandList1(nodeMask, type, flags, riid, ppCommandList); +} + +HRESULT __stdcall WrappedD3D12Device::CreateProtectedResourceSession(const D3D12_PROTECTED_RESOURCE_SESSION_DESC* pDesc, REFIID riid, void** ppSession) +{ + return m_device4->CreateProtectedResourceSession(pDesc, riid, ppSession); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommittedResource1(const D3D12_HEAP_PROPERTIES* pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialResourceState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, REFIID riidResource, void** ppvResource) +{ + return m_device4->CreateCommittedResource1(pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +} + +HRESULT __stdcall WrappedD3D12Device::CreateHeap1(const D3D12_HEAP_DESC* pDesc, ID3D12ProtectedResourceSession* pProtectedSession, REFIID riid, void** ppvHeap) +{ + return m_device4->CreateHeap1(pDesc, pProtectedSession, riid, ppvHeap); +} + +HRESULT __stdcall WrappedD3D12Device::CreateReservedResource1(const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, REFIID riid, void** ppvResource) +{ + return m_device4->CreateReservedResource1(pDesc, InitialState, pOptimizedClearValue, pProtectedSession, riid, ppvResource); +} + +D3D12_RESOURCE_ALLOCATION_INFO __stdcall WrappedD3D12Device::GetResourceAllocationInfo1(UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC* pResourceDescs, D3D12_RESOURCE_ALLOCATION_INFO1* pResourceAllocationInfo1) +{ + return m_device4->GetResourceAllocationInfo1(visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +} + +HRESULT __stdcall WrappedD3D12Device::CreateLifetimeTracker(ID3D12LifetimeOwner* pOwner, REFIID riid, void** ppvTracker) +{ + return m_device5->CreateLifetimeTracker(pOwner, riid, ppvTracker); +} + +void __stdcall WrappedD3D12Device::RemoveDevice(void) +{ + return m_device5->RemoveDevice(); +} + +HRESULT __stdcall WrappedD3D12Device::EnumerateMetaCommands(UINT* pNumMetaCommands, D3D12_META_COMMAND_DESC* pDescs) +{ + return m_device5->EnumerateMetaCommands(pNumMetaCommands, pDescs); +} + +HRESULT __stdcall WrappedD3D12Device::EnumerateMetaCommandParameters(REFGUID CommandId, D3D12_META_COMMAND_PARAMETER_STAGE Stage, UINT* pTotalStructureSizeInBytes, UINT* pParameterCount, D3D12_META_COMMAND_PARAMETER_DESC* pParameterDescs) +{ + return m_device5->EnumerateMetaCommandParameters(CommandId, Stage, pTotalStructureSizeInBytes, pParameterCount, pParameterDescs); +} + +HRESULT __stdcall WrappedD3D12Device::CreateMetaCommand(REFGUID CommandId, UINT NodeMask, const void* pCreationParametersData, SIZE_T CreationParametersDataSizeInBytes, REFIID riid, void** ppMetaCommand) +{ + return m_device5->CreateMetaCommand(CommandId, NodeMask, pCreationParametersData, CreationParametersDataSizeInBytes, riid, ppMetaCommand); +} + +HRESULT __stdcall WrappedD3D12Device::CreateStateObject(const D3D12_STATE_OBJECT_DESC* pDesc, REFIID riid, void** ppStateObject) +{ + return m_device5->CreateStateObject(pDesc, riid, ppStateObject); +} + +void __stdcall WrappedD3D12Device::GetRaytracingAccelerationStructurePrebuildInfo(const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS* pDesc, D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO* pInfo) +{ + return m_device5->GetRaytracingAccelerationStructurePrebuildInfo(pDesc, pInfo); +} + +D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS __stdcall WrappedD3D12Device::CheckDriverMatchingIdentifier(D3D12_SERIALIZED_DATA_TYPE SerializedDataType, const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER* pIdentifierToCheck) +{ + return m_device5->CheckDriverMatchingIdentifier(SerializedDataType, pIdentifierToCheck); +} + +HRESULT __stdcall WrappedD3D12Device::SetBackgroundProcessingMode(D3D12_BACKGROUND_PROCESSING_MODE Mode, D3D12_MEASUREMENTS_ACTION MeasurementsAction, HANDLE hEventToSignalUponCompletion, BOOL* pbFurtherMeasurementsDesired) +{ + return m_device6->SetBackgroundProcessingMode(Mode, MeasurementsAction, hEventToSignalUponCompletion, pbFurtherMeasurementsDesired); +} + +HRESULT __stdcall WrappedD3D12Device::AddToStateObject(const D3D12_STATE_OBJECT_DESC* pAddition, ID3D12StateObject* pStateObjectToGrowFrom, REFIID riid, void** ppNewStateObject) +{ + return m_device7->AddToStateObject(pAddition, pStateObjectToGrowFrom, riid, ppNewStateObject); +} + +HRESULT __stdcall WrappedD3D12Device::CreateProtectedResourceSession1(const D3D12_PROTECTED_RESOURCE_SESSION_DESC1* pDesc, REFIID riid, void** ppSession) +{ + return m_device7->CreateProtectedResourceSession1(pDesc, riid, ppSession); +} + +D3D12_RESOURCE_ALLOCATION_INFO __stdcall WrappedD3D12Device::GetResourceAllocationInfo2(UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC1* pResourceDescs, D3D12_RESOURCE_ALLOCATION_INFO1* pResourceAllocationInfo1) +{ + return m_device8->GetResourceAllocationInfo2(visibleMask, numResourceDescs, pResourceDescs, pResourceAllocationInfo1); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommittedResource2(const D3D12_HEAP_PROPERTIES* pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC1* pDesc, D3D12_RESOURCE_STATES InitialResourceState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, REFIID riidResource, void** ppvResource) +{ + return m_device8->CreateCommittedResource2(pHeapProperties, HeapFlags, pDesc, InitialResourceState, pOptimizedClearValue, pProtectedSession, riidResource, ppvResource); +} + +HRESULT __stdcall WrappedD3D12Device::CreatePlacedResource1(ID3D12Heap* pHeap, UINT64 HeapOffset, const D3D12_RESOURCE_DESC1* pDesc, D3D12_RESOURCE_STATES InitialState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, REFIID riid, void** ppvResource) +{ + return m_device8->CreatePlacedResource1(pHeap, HeapOffset, pDesc, InitialState, pOptimizedClearValue, riid, ppvResource); +} + +void __stdcall WrappedD3D12Device::CreateSamplerFeedbackUnorderedAccessView(ID3D12Resource* pTargetedResource, ID3D12Resource* pFeedbackResource, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) +{ + return m_device8->CreateSamplerFeedbackUnorderedAccessView(pTargetedResource, pFeedbackResource, DestDescriptor); +} + +void __stdcall WrappedD3D12Device::GetCopyableFootprints1(const D3D12_RESOURCE_DESC1* pResourceDesc, UINT FirstSubresource, UINT NumSubresources, UINT64 BaseOffset, D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts, UINT* pNumRows, UINT64* pRowSizeInBytes, UINT64* pTotalBytes) +{ + return m_device8->GetCopyableFootprints1(pResourceDesc, FirstSubresource, NumSubresources, BaseOffset, pLayouts, pNumRows, pRowSizeInBytes, pTotalBytes); +} + +HRESULT __stdcall WrappedD3D12Device::CreateShaderCacheSession(const D3D12_SHADER_CACHE_SESSION_DESC* pDesc, REFIID riid, void** ppvSession) +{ + return m_device9->CreateShaderCacheSession(pDesc, riid, ppvSession); +} + +HRESULT __stdcall WrappedD3D12Device::ShaderCacheControl(D3D12_SHADER_CACHE_KIND_FLAGS Kinds, D3D12_SHADER_CACHE_CONTROL_FLAGS Control) +{ + return m_device9->ShaderCacheControl(Kinds, Control); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommandQueue1(const D3D12_COMMAND_QUEUE_DESC* pDesc, REFIID CreatorID, REFIID riid, void** ppCommandQueue) +{ + return m_device9->CreateCommandQueue1(pDesc, CreatorID, riid, ppCommandQueue); +} + +HRESULT __stdcall WrappedD3D12Device::CreateCommittedResource3(const D3D12_HEAP_PROPERTIES* pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC1* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, UINT32 NumCastableFormats, DXGI_FORMAT* pCastableFormats, REFIID riidResource, void** ppvResource) +{ + return m_device10->CreateCommittedResource3(pHeapProperties, HeapFlags, pDesc, InitialLayout, pOptimizedClearValue, pProtectedSession, NumCastableFormats, pCastableFormats, riidResource, ppvResource); +} + +HRESULT __stdcall WrappedD3D12Device::CreatePlacedResource2(ID3D12Heap* pHeap, UINT64 HeapOffset, const D3D12_RESOURCE_DESC1* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, UINT32 NumCastableFormats, DXGI_FORMAT* pCastableFormats, REFIID riid, void** ppvResource) +{ + return m_device10->CreatePlacedResource2(pHeap, HeapOffset, pDesc, InitialLayout, pOptimizedClearValue, NumCastableFormats, pCastableFormats, riid, ppvResource); +} + +HRESULT __stdcall WrappedD3D12Device::CreateReservedResource2(const D3D12_RESOURCE_DESC* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, UINT32 NumCastableFormats, DXGI_FORMAT* pCastableFormats, REFIID riid, void** ppvResource) +{ + return m_device10->CreateReservedResource2(pDesc, InitialLayout, pOptimizedClearValue, pProtectedSession, NumCastableFormats, pCastableFormats, riid, ppvResource); +} diff --git a/CyberXeSS/WrappedD3D12Device.h b/CyberXeSS/WrappedD3D12Device.h new file mode 100644 index 00000000..f27ecf32 --- /dev/null +++ b/CyberXeSS/WrappedD3D12Device.h @@ -0,0 +1,245 @@ +#pragma once + +#include "WrappedDXGIObjects.h" + +class RefCountD3D12Object : public ID3D12Object +{ + ID3D12Object* m_pReal; + unsigned int m_iRefcount; + +public: + RefCountD3D12Object(ID3D12Object* real) : m_pReal(real), m_iRefcount(1) {} + virtual ~RefCountD3D12Object() {} + static bool HandleWrap(const char* ifaceName, REFIID riid, void** ppvObject); + static HRESULT WrapQueryInterface(IUnknown* real, const char* ifaceName, REFIID riid, void** ppvObject); + + ////////////////////////////// + // implement IUnknown + HRESULT STDMETHODCALLTYPE QueryInterface( /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ __RPC__deref_out void** ppvObject) + { + LOG("RefCountD3D12Object.QueryInterface"); + auto result = QueryInterface("IUnknown", riid, ppvObject); + LOG("RefCountD3D12Object.QueryInterface result: " + int_to_hex(result)); + + return result; + } + + // optional overload that's useful for passing down the name of the current interface to put in + // any 'unknown interface' query logs. + HRESULT STDMETHODCALLTYPE QueryInterface(const char* ifaceName, REFIID riid, void** ppvObject) + { + if (riid == __uuidof(IUnknown)) + { + AddRef(); + *ppvObject = (IUnknown*)(ID3D12Object*)this; + return S_OK; + } + else if (riid == __uuidof(ID3D12Object)) + { + AddRef(); + *ppvObject = (ID3D12Object*)this; + return S_OK; + } + + return WrapQueryInterface(m_pReal, ifaceName, riid, ppvObject); + } + + ULONG STDMETHODCALLTYPE AddRef() + { + LOG("RefCountD3D12Object.AddRef"); + InterlockedIncrement(&m_iRefcount); + LOG("RefCountD3D12Object.AddRef result: " + int_to_hex(m_iRefcount)); + return m_iRefcount; + } + ULONG STDMETHODCALLTYPE Release() + { + LOG("RefCountD3D12Object.Release"); + + unsigned int ret = InterlockedDecrement(&m_iRefcount); + + LOG("RefCountD3D12Object.Release result: " + int_to_hex(m_iRefcount)); + + if (ret == 0) + { + LOG("RefCountD3D12Object.Release deleting object"); + delete this; + } + + return ret; + } + + ////////////////////////////// + // implement ID3D12Object + + virtual HRESULT STDMETHODCALLTYPE SetPrivateData( /* [in] */ REFGUID Name, /* [in] */ UINT DataSize, /* [in] */ const void* pData) + { + LOG("RefCountDXGIObject.SetPrivateData"); + auto result = m_pReal->SetPrivateData(Name, DataSize, pData); + LOG("RefCountDXGIObject.SetPrivateData result: " + int_to_hex(result)); + return result; + } + + virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface( /* [in] */ REFGUID Name, /* [in] */ const IUnknown* pUnknown) + { + LOG("RefCountDXGIObject.SetPrivateDataInterface"); + auto result = m_pReal->SetPrivateDataInterface(Name, pUnknown); + LOG("RefCountDXGIObject.SetPrivateDataInterface result: " + int_to_hex(result)); + return result; + } + + virtual HRESULT STDMETHODCALLTYPE GetPrivateData( /* [in] */ REFGUID Name, /* [out][in] */ UINT* pDataSize, /* [out] */ void* pData) + { + LOG("RefCountDXGIObject.GetPrivateData"); + auto result = m_pReal->GetPrivateData(Name, pDataSize, pData); + LOG("RefCountDXGIObject.GetPrivateData result: " + int_to_hex(result)); + return result; + } + + virtual HRESULT STDMETHODCALLTYPE SetName(_In_z_ LPCWSTR Name); +}; + +#define IMPLEMENT_ID3D12OBJECT_WITH_REFCOUNTDXGIOBJECT_CUSTOMQUERY \ + ULONG STDMETHODCALLTYPE AddRef() \ + { \ + return RefCountD3D12Object::AddRef(); \ + } \ + ULONG STDMETHODCALLTYPE Release() \ + { \ + return RefCountD3D12Object::Release(); \ + } \ + HRESULT STDMETHODCALLTYPE SetPrivateData(REFIID Name, UINT DataSize, const void *pData) \ + { \ + return RefCountD3D12Object::SetPrivateData(Name, DataSize, pData); \ + } \ + HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(REFIID Name, const IUnknown *pUnknown) \ + { \ + return RefCountD3D12Object::SetPrivateDataInterface(Name, pUnknown); \ + } \ + HRESULT STDMETHODCALLTYPE GetPrivateData(REFIID Name, UINT *pDataSize, void *pData) \ + { \ + return RefCountD3D12Object::GetPrivateData(Name, pDataSize, pData); \ + } \ + HRESULT STDMETHODCALLTYPE SetName(_In_z_ LPCWSTR Name) \ + { \ + return RefCountD3D12Object::SetName(Name); \ + } + +MIDL_INTERFACE("fa4994ad-dbe4-44b9-8c5c-bb5cf7188b6e") +ID3D12ProxyDevice : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE GetProxyAdapter(IDXGIProxyAdapter** adapter); + virtual HRESULT STDMETHODCALLTYPE SetProxyAdapter(IDXGIProxyAdapter* adapter); +}; + +class WrappedD3D12Device : public ID3D12Device10, public RefCountD3D12Object, public ID3D12ProxyDevice +{ + ID3D12Device1* m_device1; + ID3D12Device2* m_device2; + ID3D12Device3* m_device3; + ID3D12Device4* m_device4; + ID3D12Device5* m_device5; + ID3D12Device6* m_device6; + ID3D12Device7* m_device7; + ID3D12Device8* m_device8; + ID3D12Device9* m_device9; + ID3D12Device10* m_device10; + IDXGIProxyAdapter* m_adapter; + +public: + ID3D12Device* m_device; + WrappedD3D12Device(ID3D12Device* device); + + virtual ~WrappedD3D12Device(); + + IMPLEMENT_ID3D12OBJECT_WITH_REFCOUNTDXGIOBJECT_CUSTOMQUERY; + + // Inherited via ID3D12Device10 + + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObject) override; + UINT __stdcall GetNodeCount(void) override; + HRESULT __stdcall CreateCommandQueue(const D3D12_COMMAND_QUEUE_DESC* pDesc, REFIID riid, void** ppCommandQueue) override; + HRESULT __stdcall CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE type, REFIID riid, void** ppCommandAllocator) override; + HRESULT __stdcall CreateGraphicsPipelineState(const D3D12_GRAPHICS_PIPELINE_STATE_DESC* pDesc, REFIID riid, void** ppPipelineState) override; + HRESULT __stdcall CreateComputePipelineState(const D3D12_COMPUTE_PIPELINE_STATE_DESC* pDesc, REFIID riid, void** ppPipelineState) override; + HRESULT __stdcall CreateCommandList(UINT nodeMask, D3D12_COMMAND_LIST_TYPE type, ID3D12CommandAllocator* pCommandAllocator, ID3D12PipelineState* pInitialState, REFIID riid, void** ppCommandList) override; + HRESULT __stdcall CheckFeatureSupport(D3D12_FEATURE Feature, void* pFeatureSupportData, UINT FeatureSupportDataSize) override; + HRESULT __stdcall CreateDescriptorHeap(const D3D12_DESCRIPTOR_HEAP_DESC* pDescriptorHeapDesc, REFIID riid, void** ppvHeap) override; + UINT __stdcall GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType) override; + HRESULT __stdcall CreateRootSignature(UINT nodeMask, const void* pBlobWithRootSignature, SIZE_T blobLengthInBytes, REFIID riid, void** ppvRootSignature) override; + void __stdcall CreateConstantBufferView(const D3D12_CONSTANT_BUFFER_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override; + void __stdcall CreateShaderResourceView(ID3D12Resource* pResource, const D3D12_SHADER_RESOURCE_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override; + void __stdcall CreateUnorderedAccessView(ID3D12Resource* pResource, ID3D12Resource* pCounterResource, const D3D12_UNORDERED_ACCESS_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override; + void __stdcall CreateRenderTargetView(ID3D12Resource* pResource, const D3D12_RENDER_TARGET_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override; + void __stdcall CreateDepthStencilView(ID3D12Resource* pResource, const D3D12_DEPTH_STENCIL_VIEW_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override; + void __stdcall CreateSampler(const D3D12_SAMPLER_DESC* pDesc, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override; + void __stdcall CopyDescriptors(UINT NumDestDescriptorRanges, const D3D12_CPU_DESCRIPTOR_HANDLE* pDestDescriptorRangeStarts, const UINT* pDestDescriptorRangeSizes, UINT NumSrcDescriptorRanges, const D3D12_CPU_DESCRIPTOR_HANDLE* pSrcDescriptorRangeStarts, const UINT* pSrcDescriptorRangeSizes, D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) override; + void __stdcall CopyDescriptorsSimple(UINT NumDescriptors, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart, D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart, D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) override; + D3D12_RESOURCE_ALLOCATION_INFO __stdcall GetResourceAllocationInfo(UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC* pResourceDescs) override; + D3D12_HEAP_PROPERTIES __stdcall GetCustomHeapProperties(UINT nodeMask, D3D12_HEAP_TYPE heapType) override; + HRESULT __stdcall CreateCommittedResource(const D3D12_HEAP_PROPERTIES* pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialResourceState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, REFIID riidResource, void** ppvResource) override; + HRESULT __stdcall CreateHeap(const D3D12_HEAP_DESC* pDesc, REFIID riid, void** ppvHeap) override; + HRESULT __stdcall CreatePlacedResource(ID3D12Heap* pHeap, UINT64 HeapOffset, const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, REFIID riid, void** ppvResource) override; + HRESULT __stdcall CreateReservedResource(const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, REFIID riid, void** ppvResource) override; + HRESULT __stdcall CreateSharedHandle(ID3D12DeviceChild* pObject, const SECURITY_ATTRIBUTES* pAttributes, DWORD Access, LPCWSTR Name, HANDLE* pHandle) override; + HRESULT __stdcall OpenSharedHandle(HANDLE NTHandle, REFIID riid, void** ppvObj) override; + HRESULT __stdcall OpenSharedHandleByName(LPCWSTR Name, DWORD Access, HANDLE* pNTHandle) override; + HRESULT __stdcall MakeResident(UINT NumObjects, ID3D12Pageable* const* ppObjects) override; + HRESULT __stdcall Evict(UINT NumObjects, ID3D12Pageable* const* ppObjects) override; + HRESULT __stdcall CreateFence(UINT64 InitialValue, D3D12_FENCE_FLAGS Flags, REFIID riid, void** ppFence) override; + HRESULT __stdcall GetDeviceRemovedReason(void) override; + void __stdcall GetCopyableFootprints(const D3D12_RESOURCE_DESC* pResourceDesc, UINT FirstSubresource, UINT NumSubresources, UINT64 BaseOffset, D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts, UINT* pNumRows, UINT64* pRowSizeInBytes, UINT64* pTotalBytes) override; + HRESULT __stdcall CreateQueryHeap(const D3D12_QUERY_HEAP_DESC* pDesc, REFIID riid, void** ppvHeap) override; + HRESULT __stdcall SetStablePowerState(BOOL Enable) override; + HRESULT __stdcall CreateCommandSignature(const D3D12_COMMAND_SIGNATURE_DESC* pDesc, ID3D12RootSignature* pRootSignature, REFIID riid, void** ppvCommandSignature) override; + void __stdcall GetResourceTiling(ID3D12Resource* pTiledResource, UINT* pNumTilesForEntireResource, D3D12_PACKED_MIP_INFO* pPackedMipDesc, D3D12_TILE_SHAPE* pStandardTileShapeForNonPackedMips, UINT* pNumSubresourceTilings, UINT FirstSubresourceTilingToGet, D3D12_SUBRESOURCE_TILING* pSubresourceTilingsForNonPackedMips) override; + LUID __stdcall GetAdapterLuid(void) override; + HRESULT __stdcall CreatePipelineLibrary(const void* pLibraryBlob, SIZE_T BlobLength, REFIID riid, void** ppPipelineLibrary) override; + HRESULT __stdcall SetEventOnMultipleFenceCompletion(ID3D12Fence* const* ppFences, const UINT64* pFenceValues, UINT NumFences, D3D12_MULTIPLE_FENCE_WAIT_FLAGS Flags, HANDLE hEvent) override; + HRESULT __stdcall SetResidencyPriority(UINT NumObjects, ID3D12Pageable* const* ppObjects, const D3D12_RESIDENCY_PRIORITY* pPriorities) override; + HRESULT __stdcall CreatePipelineState(const D3D12_PIPELINE_STATE_STREAM_DESC* pDesc, REFIID riid, void** ppPipelineState) override; + HRESULT __stdcall OpenExistingHeapFromAddress(const void* pAddress, REFIID riid, void** ppvHeap) override; + HRESULT __stdcall OpenExistingHeapFromFileMapping(HANDLE hFileMapping, REFIID riid, void** ppvHeap) override; + HRESULT __stdcall EnqueueMakeResident(D3D12_RESIDENCY_FLAGS Flags, UINT NumObjects, ID3D12Pageable* const* ppObjects, ID3D12Fence* pFenceToSignal, UINT64 FenceValueToSignal) override; + HRESULT __stdcall CreateCommandList1(UINT nodeMask, D3D12_COMMAND_LIST_TYPE type, D3D12_COMMAND_LIST_FLAGS flags, REFIID riid, void** ppCommandList) override; + HRESULT __stdcall CreateProtectedResourceSession(const D3D12_PROTECTED_RESOURCE_SESSION_DESC* pDesc, REFIID riid, void** ppSession) override; + HRESULT __stdcall CreateCommittedResource1(const D3D12_HEAP_PROPERTIES* pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialResourceState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, REFIID riidResource, void** ppvResource) override; + HRESULT __stdcall CreateHeap1(const D3D12_HEAP_DESC* pDesc, ID3D12ProtectedResourceSession* pProtectedSession, REFIID riid, void** ppvHeap) override; + HRESULT __stdcall CreateReservedResource1(const D3D12_RESOURCE_DESC* pDesc, D3D12_RESOURCE_STATES InitialState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, REFIID riid, void** ppvResource) override; + D3D12_RESOURCE_ALLOCATION_INFO __stdcall GetResourceAllocationInfo1(UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC* pResourceDescs, D3D12_RESOURCE_ALLOCATION_INFO1* pResourceAllocationInfo1) override; + HRESULT __stdcall CreateLifetimeTracker(ID3D12LifetimeOwner* pOwner, REFIID riid, void** ppvTracker) override; + void __stdcall RemoveDevice(void) override; + HRESULT __stdcall EnumerateMetaCommands(UINT* pNumMetaCommands, D3D12_META_COMMAND_DESC* pDescs) override; + HRESULT __stdcall EnumerateMetaCommandParameters(REFGUID CommandId, D3D12_META_COMMAND_PARAMETER_STAGE Stage, UINT* pTotalStructureSizeInBytes, UINT* pParameterCount, D3D12_META_COMMAND_PARAMETER_DESC* pParameterDescs) override; + HRESULT __stdcall CreateMetaCommand(REFGUID CommandId, UINT NodeMask, const void* pCreationParametersData, SIZE_T CreationParametersDataSizeInBytes, REFIID riid, void** ppMetaCommand) override; + HRESULT __stdcall CreateStateObject(const D3D12_STATE_OBJECT_DESC* pDesc, REFIID riid, void** ppStateObject) override; + void __stdcall GetRaytracingAccelerationStructurePrebuildInfo(const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS* pDesc, D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO* pInfo) override; + D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS __stdcall CheckDriverMatchingIdentifier(D3D12_SERIALIZED_DATA_TYPE SerializedDataType, const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER* pIdentifierToCheck) override; + HRESULT __stdcall SetBackgroundProcessingMode(D3D12_BACKGROUND_PROCESSING_MODE Mode, D3D12_MEASUREMENTS_ACTION MeasurementsAction, HANDLE hEventToSignalUponCompletion, BOOL* pbFurtherMeasurementsDesired) override; + HRESULT __stdcall AddToStateObject(const D3D12_STATE_OBJECT_DESC* pAddition, ID3D12StateObject* pStateObjectToGrowFrom, REFIID riid, void** ppNewStateObject) override; + HRESULT __stdcall CreateProtectedResourceSession1(const D3D12_PROTECTED_RESOURCE_SESSION_DESC1* pDesc, REFIID riid, void** ppSession) override; + D3D12_RESOURCE_ALLOCATION_INFO __stdcall GetResourceAllocationInfo2(UINT visibleMask, UINT numResourceDescs, const D3D12_RESOURCE_DESC1* pResourceDescs, D3D12_RESOURCE_ALLOCATION_INFO1* pResourceAllocationInfo1) override; + HRESULT __stdcall CreateCommittedResource2(const D3D12_HEAP_PROPERTIES* pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC1* pDesc, D3D12_RESOURCE_STATES InitialResourceState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, REFIID riidResource, void** ppvResource) override; + HRESULT __stdcall CreatePlacedResource1(ID3D12Heap* pHeap, UINT64 HeapOffset, const D3D12_RESOURCE_DESC1* pDesc, D3D12_RESOURCE_STATES InitialState, const D3D12_CLEAR_VALUE* pOptimizedClearValue, REFIID riid, void** ppvResource) override; + void __stdcall CreateSamplerFeedbackUnorderedAccessView(ID3D12Resource* pTargetedResource, ID3D12Resource* pFeedbackResource, D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override; + void __stdcall GetCopyableFootprints1(const D3D12_RESOURCE_DESC1* pResourceDesc, UINT FirstSubresource, UINT NumSubresources, UINT64 BaseOffset, D3D12_PLACED_SUBRESOURCE_FOOTPRINT* pLayouts, UINT* pNumRows, UINT64* pRowSizeInBytes, UINT64* pTotalBytes) override; + HRESULT __stdcall CreateShaderCacheSession(const D3D12_SHADER_CACHE_SESSION_DESC* pDesc, REFIID riid, void** ppvSession) override; + HRESULT __stdcall ShaderCacheControl(D3D12_SHADER_CACHE_KIND_FLAGS Kinds, D3D12_SHADER_CACHE_CONTROL_FLAGS Control) override; + HRESULT __stdcall CreateCommandQueue1(const D3D12_COMMAND_QUEUE_DESC* pDesc, REFIID CreatorID, REFIID riid, void** ppCommandQueue) override; + HRESULT __stdcall CreateCommittedResource3(const D3D12_HEAP_PROPERTIES* pHeapProperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC1* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, UINT32 NumCastableFormats, DXGI_FORMAT* pCastableFormats, REFIID riidResource, void** ppvResource) override; + HRESULT __stdcall CreatePlacedResource2(ID3D12Heap* pHeap, UINT64 HeapOffset, const D3D12_RESOURCE_DESC1* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, UINT32 NumCastableFormats, DXGI_FORMAT* pCastableFormats, REFIID riid, void** ppvResource) override; + HRESULT __stdcall CreateReservedResource2(const D3D12_RESOURCE_DESC* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, UINT32 NumCastableFormats, DXGI_FORMAT* pCastableFormats, REFIID riid, void** ppvResource) override; + + virtual HRESULT STDMETHODCALLTYPE GetProxyAdapter(IDXGIProxyAdapter** adapter) + { + *adapter = m_adapter; + return S_OK; + } + + virtual HRESULT STDMETHODCALLTYPE SetProxyAdapter(IDXGIProxyAdapter* adapter) + { + m_adapter = adapter; + return S_OK; + } +}; + diff --git a/CyberXeSS/WrappedDXGIObjects.cpp b/CyberXeSS/WrappedDXGIObjects.cpp new file mode 100644 index 00000000..4e44a561 --- /dev/null +++ b/CyberXeSS/WrappedDXGIObjects.cpp @@ -0,0 +1,542 @@ +#include "pch.h" +#include "dxgi1_6.h" +#include "WrappedDXGIObjects.h" + +bool RefCountDXGIObject::HandleWrap(const char* ifaceName, REFIID riid, void** ppvObject) +{ + LOG("RefCountDXGIObject.HandleWrap"); + + if (ppvObject == NULL || *ppvObject == NULL) + { + std::string str(ifaceName); + LOG("RefCountDXGIObject.HandleWrap called with NULL ppvObject querying " + str); + return false; + } + + // unknown GUID that we only want to print once to avoid log spam + // {79D2046C-22EF-451B-9E74-2245D9C760EA} + static const GUID Unknown_uuid = { 0x79d2046c, 0x22ef, 0x451b, {0x9e, 0x74, 0x22, 0x45, 0xd9, 0xc7, 0x60, 0xea} }; + + // ditto + // {9B7E4C04-342C-4106-A19F-4F2704F689F0} + static const GUID ID3D10Texture2D_uuid = { 0x9b7e4c04, 0x342c, 0x4106, {0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0} }; + +#ifdef BLOCK_IDXGIAdapterInternal2 + // unknown/undocumented internal interface + // {7abb6563-02bc-47c4-8ef9-acc4795edbcf} + static const GUID IDXGIAdapterInternal2_uuid = { 0x7abb6563, 0x02bc, 0x47c4, {0x8e, 0xf9, 0xac, 0xc4, 0x79, 0x5e, 0xdb, 0xcf} }; +#endif + + + if (riid == __uuidof(IDXGIDevice) || + riid == __uuidof(IDXGIDevice1)) + { + // should have been handled elsewhere, so we can properly create this device + std::string str(ifaceName); + LOG("Unexpected uuid in RefCountDXGIObject::HandleWrap querying : " + str); + return false; + } + else if (riid == __uuidof(IDXGIAdapter)) + { + if (b_wrappingEnabled) + { + IDXGIAdapter* real = (IDXGIAdapter*)(*ppvObject); + *ppvObject = (IDXGIAdapter*)(new WrappedIDXGIAdapter4(real)); + } + } + else if (riid == __uuidof(IDXGIAdapter1)) + { + if (b_wrappingEnabled) + { + IDXGIAdapter1* real = (IDXGIAdapter1*)(*ppvObject); + *ppvObject = (IDXGIAdapter1*)(new WrappedIDXGIAdapter4(real)); + } + } + else if (riid == __uuidof(IDXGIAdapter2)) + { + if (b_wrappingEnabled) + { + IDXGIAdapter2* real = (IDXGIAdapter2*)(*ppvObject); + *ppvObject = (IDXGIAdapter2*)(new WrappedIDXGIAdapter4(real)); + } + } + else if (riid == __uuidof(IDXGIAdapter3)) + { + if (b_wrappingEnabled) + { + IDXGIAdapter3* real = (IDXGIAdapter3*)(*ppvObject); + *ppvObject = (IDXGIAdapter3*)(new WrappedIDXGIAdapter4(real)); + } + } + else if (riid == __uuidof(IDXGIAdapter4)) + { + if (b_spoofEnabled) + { + IDXGIAdapter4* real = (IDXGIAdapter4*)(*ppvObject); + *ppvObject = (IDXGIAdapter4*)(new WrappedIDXGIAdapter4(real)); + } + } + else if (riid == __uuidof(IDXGIFactory)) + { + // yes I know PRECISELY how fucked up this is. Speak to microsoft - after KB2670838 the internal + // D3D11 device creation function will pass in __uuidof(IDXGIFactory) then attempt to call + // EnumDevices1 (which is in the IDXGIFactory1 vtable). Doing this *should* be safe as using a + // IDXGIFactory1 like a IDXGIFactory should all just work by definition, but there's no way to + // know now if someone trying to create a IDXGIFactory really means it or not. + IDXGIFactory* real = (IDXGIFactory*)(*ppvObject); + *ppvObject = (IDXGIFactory*)(new WrappedIDXGIFactory(real)); + } + else if (riid == __uuidof(IDXGIFactory1)) + { + IDXGIFactory1* real = (IDXGIFactory1*)(*ppvObject); + *ppvObject = (IDXGIFactory1*)(new WrappedIDXGIFactory(real)); + } + else if (riid == __uuidof(IDXGIFactory2)) + { + IDXGIFactory2* real = (IDXGIFactory2*)(*ppvObject); + *ppvObject = (IDXGIFactory2*)(new WrappedIDXGIFactory(real)); + } + else if (riid == __uuidof(IDXGIFactory3)) + { + IDXGIFactory3* real = (IDXGIFactory3*)(*ppvObject); + *ppvObject = (IDXGIFactory3*)(new WrappedIDXGIFactory(real)); + } + else if (riid == __uuidof(IDXGIFactory4)) + { + IDXGIFactory4* real = (IDXGIFactory4*)(*ppvObject); + *ppvObject = (IDXGIFactory4*)(new WrappedIDXGIFactory(real)); + } + else if (riid == __uuidof(IDXGIFactory5)) + { + IDXGIFactory5* real = (IDXGIFactory5*)(*ppvObject); + *ppvObject = (IDXGIFactory5*)(new WrappedIDXGIFactory(real)); + } + else if (riid == __uuidof(IDXGIFactory6)) + { + IDXGIFactory6* real = (IDXGIFactory6*)(*ppvObject); + *ppvObject = (IDXGIFactory6*)(new WrappedIDXGIFactory(real)); + } + else if (riid == __uuidof(IDXGIFactory7)) + { + IDXGIFactory7* real = (IDXGIFactory7*)(*ppvObject); + *ppvObject = (IDXGIFactory7*)(new WrappedIDXGIFactory(real)); + } + else if (riid == ID3D10Texture2D_uuid) + { + static bool printed = false; + + if (!printed) + { + printed = true; + std::string str(ifaceName); + LOG("RefCountDXGIObject.HandleWrap Querying " + str + " for unsupported ID3D10Texture2D_uuid interface: " + ToString(riid)); + } + + return false; + } + else if (riid == Unknown_uuid) + { + static bool printed = false; + if (!printed) + { + printed = true; + std::string str(ifaceName); + LOG("RefCountDXGIObject.HandleWrap Querying " + str + " for unknown GUID: " + ToString(riid)); + } + + return false; + } +#ifdef BLOCK_IDXGIAdapterInternal2 + else if (riid == IDXGIAdapterInternal2_uuid) + { + static bool printed = false; + if (!printed) + { + printed = true; + std::string str(ifaceName); + LOG("RefCountDXGIObject.HandleWrap Querying " + str + " for unsupported/undocumented interface: IDXGIAdapterInternal2"); + } + + return false; + } +#endif + else + { + std::string str(ifaceName); + LOG("RefCountDXGIObject.HandleWrap Querying " + str + " for unrecognized GUID: " + ToString(riid)); + } + + return true; +} + +HRESULT STDMETHODCALLTYPE RefCountDXGIObject::GetParent( + /* [in] */ REFIID riid, + /* [retval][out] */ void** ppParent) +{ + LOG("RefCountDXGIObject.GetParent"); + + HRESULT ret = m_pReal->GetParent(riid, ppParent); + + if (ret == S_OK) + HandleWrap("GetParent", riid, ppParent); + + return ret; +} + +HRESULT RefCountDXGIObject::WrapQueryInterface(IUnknown* real, const char* ifaceName, REFIID riid, void** ppvObject) +{ + LOG("RefCountDXGIObject.WrapQueryInterface riid: " + ToString(riid)); + +#ifdef BLOCK_IDXGIAdapterInternal2 + // unknown/undocumented internal interface + // {7abb6563-02bc-47c4-8ef9-acc4795edbcf} + static const GUID IDXGIAdapterInternal2_uuid = { 0x7abb6563, 0x02bc, 0x47c4, {0x8e, 0xf9, 0xac, 0xc4, 0x79, 0x5e, 0xdb, 0xcf} }; + + if (riid == IDXGIAdapterInternal2_uuid) + { + LOG("RefCountDXGIObject.WrapQueryInterface IDXGIAdapterInternal2 result: " + int_to_hex(E_NOINTERFACE)); + return E_NOINTERFACE; + } +#endif + + HRESULT ret = real->QueryInterface(riid, ppvObject); + LOG("RefCountDXGIObject.WrapQueryInterface real->QueryInterface result: " + int_to_hex(ret)); + + if (ret == S_OK && HandleWrap(ifaceName, riid, ppvObject)) + { + LOG("RefCountDXGIObject.WrapQueryInterface HandleWrap result: " + int_to_hex(ret)); + return ret; + } + + LOG("RefCountDXGIObject.WrapQueryInterface result: E_NOINTERFACE"); + return E_NOINTERFACE; +} + + +WrappedIDXGIAdapter4::WrappedIDXGIAdapter4(IDXGIAdapter* real) + : RefCountDXGIObject(real), m_pReal(real) +{ + LOG("WrappedIDXGIAdapter4.ctor"); + + m_pReal1 = NULL; + real->QueryInterface(__uuidof(IDXGIAdapter1), (void**)&m_pReal1); + m_pReal2 = NULL; + real->QueryInterface(__uuidof(IDXGIAdapter2), (void**)&m_pReal2); + m_pReal3 = NULL; + real->QueryInterface(__uuidof(IDXGIAdapter3), (void**)&m_pReal3); + m_pReal4 = NULL; + real->QueryInterface(__uuidof(IDXGIAdapter4), (void**)&m_pReal4); + + b_spoofEnabled = true; +} + +WrappedIDXGIAdapter4::~WrappedIDXGIAdapter4() +{ + LOG("WrappedIDXGIAdapter4.dtor"); + + SAFE_RELEASE(m_pReal1); + SAFE_RELEASE(m_pReal2); + SAFE_RELEASE(m_pReal3); + SAFE_RELEASE(m_pReal4); + SAFE_RELEASE(m_pReal); +} + +HRESULT STDMETHODCALLTYPE WrappedIDXGIAdapter4::QueryInterface(REFIID riid, void** ppvObject) +{ + LOG("WrappedIDXGIAdapter4.QueryInterface riid: " + ToString(riid)); + +#ifndef BLOCK_IDXGIAdapterInternal2 + // unknown/undocumented internal interface + // {7abb6563-02bc-47c4-8ef9-acc4795edbcf} + static const GUID IDXGIAdapterInternal2_uuid = { 0x7abb6563, 0x02bc, 0x47c4, {0x8e, 0xf9, 0xac, 0xc4, 0x79, 0x5e, 0xdb, 0xcf} }; +#endif + + + if (riid == __uuidof(IDXGIAdapter)) + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter"); + AddRef(); + *ppvObject = (IDXGIAdapter*)this; + return S_OK; + } + else if (riid == __uuidof(IDXGIProxyAdapter)) + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIProxyAdapter"); + AddRef(); + *ppvObject = (IDXGIProxyAdapter*)this; + return S_OK; + } + else if (riid == __uuidof(IDXGIAdapter1)) + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter1"); + + if (m_pReal1) + { + AddRef(); + *ppvObject = (IDXGIAdapter1*)this; + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter1 result: OK"); + return S_OK; + } + else + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter1 result: E_NOINTERFACE"); + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIAdapter2)) + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter2"); + + if (m_pReal2) + { + AddRef(); + *ppvObject = (IDXGIAdapter2*)this; + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter2 result: OK"); + return S_OK; + } + else + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter2 result: E_NOINTERFACE"); + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIAdapter3)) + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter3"); + + if (m_pReal3) + { + AddRef(); + *ppvObject = (IDXGIAdapter3*)this; + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter3 result: OK"); + return S_OK; + } + else + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter3 result: E_NOINTERFACE"); + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIAdapter4)) + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter4"); + + if (m_pReal4) + { + AddRef(); + *ppvObject = (IDXGIAdapter4*)this; + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter4 result: OK"); + return S_OK; + } + else + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapter4 result: E_NOINTERFACE"); + return E_NOINTERFACE; + } + } +#ifndef BLOCK_IDXGIAdapterInternal2 + else if (riid == IDXGIAdapterInternal2_uuid && m_pReal != nullptr) + { + LOG("WrappedIDXGIAdapter4.QueryInterface for IDXGIAdapterInternal2, returning real adapter"); + return m_pReal->QueryInterface(riid, ppvObject); + } +#endif + + return RefCountDXGIObject::QueryInterface("IDXGIAdapter", riid, ppvObject); +} + +WrappedIDXGIFactory::WrappedIDXGIFactory(IDXGIFactory* real) + : RefCountDXGIObject(real), m_pReal(real) +{ + LOG("WrappedIDXGIFactory.ctor"); + + m_pReal1 = NULL; + real->QueryInterface(__uuidof(IDXGIFactory1), (void**)&m_pReal1); + m_pReal2 = NULL; + real->QueryInterface(__uuidof(IDXGIFactory2), (void**)&m_pReal2); + m_pReal3 = NULL; + real->QueryInterface(__uuidof(IDXGIFactory3), (void**)&m_pReal3); + m_pReal4 = NULL; + real->QueryInterface(__uuidof(IDXGIFactory4), (void**)&m_pReal4); + m_pReal5 = NULL; + real->QueryInterface(__uuidof(IDXGIFactory5), (void**)&m_pReal5); + m_pReal6 = NULL; + real->QueryInterface(__uuidof(IDXGIFactory6), (void**)&m_pReal6); + m_pReal7 = NULL; + real->QueryInterface(__uuidof(IDXGIFactory7), (void**)&m_pReal7); +} + +WrappedIDXGIFactory::~WrappedIDXGIFactory() +{ + LOG("WrappedIDXGIFactory.dtor"); + + SAFE_RELEASE(m_pReal1); + SAFE_RELEASE(m_pReal2); + SAFE_RELEASE(m_pReal3); + SAFE_RELEASE(m_pReal4); + SAFE_RELEASE(m_pReal5); + SAFE_RELEASE(m_pReal6); + SAFE_RELEASE(m_pReal7); + SAFE_RELEASE(m_pReal); +} + +HRESULT STDMETHODCALLTYPE WrappedIDXGIFactory::QueryInterface(REFIID riid, void** ppvObject) +{ + LOG("WrappedIDXGIFactory.QueryInterface"); + + // {713f394e-92ca-47e7-ab81-1159c2791e54} + static const GUID IDXGIFactoryDWM_uuid = { + 0x713f394e, 0x92ca, 0x47e7, {0xab, 0x81, 0x11, 0x59, 0xc2, 0x79, 0x1e, 0x54} }; + + // {1ddd77aa-9a4a-4cc8-9e55-98c196bafc8f} + static const GUID IDXGIFactoryDWM8_uuid = { + 0x1ddd77aa, 0x9a4a, 0x4cc8, {0x9e, 0x55, 0x98, 0xc1, 0x96, 0xba, 0xfc, 0x8f} }; + + if (riid == __uuidof(IDXGIFactory)) + { + AddRef(); + *ppvObject = (IDXGIFactory*)this; + return S_OK; + } + else if (riid == __uuidof(IDXGIFactory1)) + { + if (m_pReal1) + { + AddRef(); + *ppvObject = (IDXGIFactory1*)this; + return S_OK; + } + else + { + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIFactory2)) + { + if (m_pReal2) + { + AddRef(); + *ppvObject = (IDXGIFactory2*)this; + return S_OK; + } + else + { + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIFactory3)) + { + if (m_pReal3) + { + AddRef(); + *ppvObject = (IDXGIFactory3*)this; + return S_OK; + } + else + { + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIFactory4)) + { + if (m_pReal4) + { + AddRef(); + *ppvObject = (IDXGIFactory4*)this; + return S_OK; + } + else + { + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIFactory5)) + { + if (m_pReal5) + { + AddRef(); + *ppvObject = (IDXGIFactory5*)this; + return S_OK; + } + else + { + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIFactory6)) + { + if (m_pReal6) + { + AddRef(); + *ppvObject = (IDXGIFactory6*)this; + return S_OK; + } + else + { + return E_NOINTERFACE; + } + } + else if (riid == __uuidof(IDXGIFactory7)) + { + if (m_pReal7) + { + AddRef(); + *ppvObject = (IDXGIFactory7*)this; + return S_OK; + } + else + { + return E_NOINTERFACE; + } + } + else if (riid == IDXGIFactoryDWM_uuid) + { + //RDCWARN("Blocking QueryInterface for IDXGIFactoryDWM"); + return E_NOINTERFACE; + } + else if (riid == IDXGIFactoryDWM8_uuid) + { + //RDCWARN("Blocking QueryInterface for IDXGIFactoryDWM8"); + return E_NOINTERFACE; + } + + return RefCountDXGIObject::QueryInterface("IDXGIFactory", riid, ppvObject); +} + +HRESULT WrappedIDXGIFactory::CreateSwapChain(IUnknown* pDevice, DXGI_SWAP_CHAIN_DESC* pDesc, + IDXGISwapChain** ppSwapChain) +{ + LOG("WrappedIDXGIFactory.CreateSwapChain"); + + return m_pReal->CreateSwapChain(pDevice, pDesc, ppSwapChain); +} + +HRESULT WrappedIDXGIFactory::CreateSwapChainForHwnd( + IUnknown* pDevice, HWND hWnd, const DXGI_SWAP_CHAIN_DESC1* pDesc, + const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc, IDXGIOutput* pRestrictToOutput, + IDXGISwapChain1** ppSwapChain) +{ + LOG("WrappedIDXGIFactory.CreateSwapChainForHwnd"); + + return m_pReal2->CreateSwapChainForHwnd(pDevice, hWnd, pDesc, pFullscreenDesc, pRestrictToOutput, ppSwapChain); +} + +HRESULT WrappedIDXGIFactory::CreateSwapChainForCoreWindow(IUnknown* pDevice, IUnknown* pWindow, + const DXGI_SWAP_CHAIN_DESC1* pDesc, + IDXGIOutput* pRestrictToOutput, + IDXGISwapChain1** ppSwapChain) +{ + LOG("WrappedIDXGIFactory.CreateSwapChainForCoreWindow"); + + return m_pReal2->CreateSwapChainForCoreWindow(pDevice, pWindow, pDesc, pRestrictToOutput, ppSwapChain); +} + +HRESULT WrappedIDXGIFactory::CreateSwapChainForComposition(IUnknown* pDevice, + const DXGI_SWAP_CHAIN_DESC1* pDesc, + IDXGIOutput* pRestrictToOutput, + IDXGISwapChain1** ppSwapChain) +{ + LOG("WrappedIDXGIFactory.CreateSwapChainForComposition"); + + return m_pReal2->CreateSwapChainForComposition(pDevice, pDesc, pRestrictToOutput, ppSwapChain); +} diff --git a/CyberXeSS/WrappedDXGIObjects.h b/CyberXeSS/WrappedDXGIObjects.h new file mode 100644 index 00000000..c7044f0c --- /dev/null +++ b/CyberXeSS/WrappedDXGIObjects.h @@ -0,0 +1,882 @@ +#include "pch.h" +#include "dxgi1_6.h" + +//#define BLOCK_IDXGIAdapterInternal2 + +class RefCountDXGIObject : public IDXGIObject +{ + IDXGIObject* m_pReal; + unsigned int m_iRefcount; + +public: + RefCountDXGIObject(IDXGIObject* real) : m_pReal(real), m_iRefcount(1) {} + virtual ~RefCountDXGIObject() {} + static bool HandleWrap(const char* ifaceName, REFIID riid, void** ppvObject); + static HRESULT WrapQueryInterface(IUnknown* real, const char* ifaceName, REFIID riid, void** ppvObject); + + ////////////////////////////// + // implement IUnknown + HRESULT STDMETHODCALLTYPE QueryInterface( /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ __RPC__deref_out void** ppvObject) + { + LOG("RefCountDXGIObject.QueryInterface"); + auto result = QueryInterface("IUnknown", riid, ppvObject); + LOG("RefCountDXGIObject.QueryInterface result: " + int_to_hex(result)); + + return result; + } + + // optional overload that's useful for passing down the name of the current interface to put in + // any 'unknown interface' query logs. + HRESULT STDMETHODCALLTYPE QueryInterface(const char* ifaceName, REFIID riid, void** ppvObject) + { + if (riid == __uuidof(IUnknown)) + { + AddRef(); + *ppvObject = (IUnknown*)(IDXGIObject*)this; + return S_OK; + } + else if (riid == __uuidof(IDXGIObject)) + { + AddRef(); + *ppvObject = (IDXGIObject*)this; + return S_OK; + } + + return WrapQueryInterface(m_pReal, ifaceName, riid, ppvObject); + } + + ULONG STDMETHODCALLTYPE AddRef() + { + LOG("RefCountDXGIObject.AddRef"); + InterlockedIncrement(&m_iRefcount); + LOG("RefCountDXGIObject.AddRef result: " + int_to_hex(m_iRefcount)); + return m_iRefcount; + } + ULONG STDMETHODCALLTYPE Release() + { + LOG("RefCountDXGIObject.Release"); + + unsigned int ret = InterlockedDecrement(&m_iRefcount); + + LOG("RefCountDXGIObject.Release result: " + int_to_hex(m_iRefcount)); + + if (ret == 0) + { + LOG("RefCountDXGIObject.Release deleting object"); + delete this; + } + + return ret; + } + + ////////////////////////////// + // implement IDXGIObject + + virtual HRESULT STDMETHODCALLTYPE SetPrivateData( + /* [in] */ REFGUID Name, + /* [in] */ UINT DataSize, + /* [in] */ const void* pData) + { + LOG("RefCountDXGIObject.SetPrivateData"); + auto result = m_pReal->SetPrivateData(Name, DataSize, pData); + LOG("RefCountDXGIObject.SetPrivateData result: " + int_to_hex(result)); + return result; + } + + virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface( + /* [in] */ REFGUID Name, + /* [in] */ const IUnknown* pUnknown) + { + LOG("RefCountDXGIObject.SetPrivateDataInterface"); + auto result = m_pReal->SetPrivateDataInterface(Name, pUnknown); + LOG("RefCountDXGIObject.SetPrivateDataInterface result: " + int_to_hex(result)); + return result; + } + + virtual HRESULT STDMETHODCALLTYPE GetPrivateData( + /* [in] */ REFGUID Name, + /* [out][in] */ UINT* pDataSize, + /* [out] */ void* pData) + { + LOG("RefCountDXGIObject.GetPrivateData"); + auto result = m_pReal->GetPrivateData(Name, pDataSize, pData); + LOG("RefCountDXGIObject.GetPrivateData result: " + int_to_hex(result)); + return result; + } + + virtual HRESULT STDMETHODCALLTYPE GetParent( + /* [in] */ REFIID riid, + /* [retval][out] */ void** ppParent); +}; + +#define IMPLEMENT_IDXGIOBJECT_WITH_REFCOUNTDXGIOBJECT_CUSTOMQUERY \ + ULONG STDMETHODCALLTYPE AddRef() \ + { \ + return RefCountDXGIObject::AddRef(); \ + } \ + ULONG STDMETHODCALLTYPE Release() \ + { \ + return RefCountDXGIObject::Release(); \ + } \ + HRESULT STDMETHODCALLTYPE SetPrivateData(REFIID Name, UINT DataSize, const void *pData) \ + { \ + return RefCountDXGIObject::SetPrivateData(Name, DataSize, pData); \ + } \ + HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(REFIID Name, const IUnknown *pUnknown) \ + { \ + return RefCountDXGIObject::SetPrivateDataInterface(Name, pUnknown); \ + } \ + HRESULT STDMETHODCALLTYPE GetPrivateData(REFIID Name, UINT *pDataSize, void *pData) \ + { \ + return RefCountDXGIObject::GetPrivateData(Name, pDataSize, pData); \ + } \ + HRESULT STDMETHODCALLTYPE GetParent(REFIID riid, void **ppvObject) \ + { \ + return RefCountDXGIObject::GetParent(riid, ppvObject); \ + } + + +MIDL_INTERFACE("cfdf09b3-a084-4453-a755-7d4e5389b845") +IDXGIProxyAdapter : public IUnknown +{ +public: + virtual HRESULT STDMETHODCALLTYPE Spoofing(bool enable); + virtual HRESULT STDMETHODCALLTYPE Wrapping(bool enable); +}; + +static bool b_spoofEnabled = true; +static bool b_wrappingEnabled = true; + +class WrappedIDXGIAdapter4 : public IDXGIAdapter4, public RefCountDXGIObject, public IDXGIProxyAdapter +{ + IDXGIAdapter* m_pReal; + IDXGIAdapter1* m_pReal1; + IDXGIAdapter2* m_pReal2; + IDXGIAdapter3* m_pReal3; + IDXGIAdapter4* m_pReal4; + +public: + WrappedIDXGIAdapter4(IDXGIAdapter* real); + virtual ~WrappedIDXGIAdapter4(); + + IMPLEMENT_IDXGIOBJECT_WITH_REFCOUNTDXGIOBJECT_CUSTOMQUERY; + + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject); + + ////////////////////////////// + // implement IDXGIAdapter + + virtual HRESULT STDMETHODCALLTYPE EnumOutputs( /* [in] */ UINT Output, /* [annotation][out][in] */ __out IDXGIOutput** ppOutput) + { + LOG("WrappedIDXGIAdapter4.EnumOutputs"); + HRESULT ret = m_pReal->EnumOutputs(Output, ppOutput); + LOG("WrappedIDXGIAdapter4.EnumOutputs result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE GetDesc( /* [annotation][out] */ __out DXGI_ADAPTER_DESC* pDesc) + { + LOG("WrappedIDXGIAdapter4.GetDesc"); + + HRESULT hr; + hr = m_pReal->GetDesc(pDesc); + + if (hr == S_OK && b_spoofEnabled && pDesc != nullptr && (pDesc->VendorId == 0x8086 || pDesc->VendorId == 0x1002)) + { + LOG("WrappedIDXGIAdapter4.GetDesc Spoofing card info"); + pDesc->VendorId = 0x10de; + pDesc->DeviceId = 0x24c9; + pDesc->SubSysId = 0x88ac1043; + pDesc->Revision = 0x00a1; + + std::wstring name(L"NVIDIA GeForce RTX 3060 Ti"); + const wchar_t* szName = name.c_str(); + std::memset(pDesc->Description, 0, sizeof(pDesc->Description)); + std::memcpy(pDesc->Description, szName, 54); + + LUID luid = LUID{ 0, 56090 }; + std::memcpy(&pDesc->AdapterLuid, &luid, 8); + } + + //b_spoofEnabled = true; + + LOG("WrappedIDXGIAdapter4.GetDesc result: " + int_to_hex(hr)); + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE CheckInterfaceSupport( + /* [annotation][in] */ + __in REFGUID InterfaceName, + /* [annotation][out] */ + __out LARGE_INTEGER* pUMDVersion) + { + LOG("WrappedIDXGIAdapter4.CheckInterfaceSupport"); + auto result = m_pReal->CheckInterfaceSupport(InterfaceName, pUMDVersion); + LOG("WrappedIDXGIAdapter4.CheckInterfaceSupport result: " + int_to_hex(result)); + return result; + } + + ////////////////////////////// + // implement IDXGIAdapter1 + + virtual HRESULT STDMETHODCALLTYPE GetDesc1( + /* [out] */ DXGI_ADAPTER_DESC1* pDesc) + { + LOG("WrappedIDXGIAdapter4.GetDesc1"); + + if (!m_pReal1) + { + LOG("WrappedIDXGIAdapter4.GetDesc1 no adapter!"); + return E_NOINTERFACE; + } + + + HRESULT hr; + hr = m_pReal1->GetDesc1(pDesc); + + if (hr == S_OK && b_spoofEnabled && pDesc != nullptr && (pDesc->VendorId == 0x8086 || pDesc->VendorId == 0x1002)) + { + LOG("WrappedIDXGIAdapter4.GetDesc1 Spoofing card info"); + + pDesc->VendorId = 0x10de; + pDesc->DeviceId = 0x24c9; + pDesc->SubSysId = 0x88ac1043; + pDesc->Revision = 0x00a1; + + std::wstring name(L"NVIDIA GeForce RTX 3060 Ti"); + const wchar_t* szName = name.c_str(); + std::memset(pDesc->Description, 0, sizeof(pDesc->Description)); + std::memcpy(pDesc->Description, szName, 54); + + LUID luid = LUID{ 0, 56090 }; + std::memcpy(&pDesc->AdapterLuid, &luid, 8); + } + + //b_spoofEnabled = true; + + LOG("WrappedIDXGIAdapter4.GetDesc1 result: " + int_to_hex(hr)); + return hr; + } + + ////////////////////////////// + // implement IDXGIAdapter2 + + virtual HRESULT STDMETHODCALLTYPE GetDesc2( + /* [annotation][out] */ + _Out_ DXGI_ADAPTER_DESC2* pDesc) + { + LOG("WrappedIDXGIAdapter4.GetDesc2"); + + if (!m_pReal2) + { + LOG("WrappedIDXGIAdapter4.GetDesc2 no adapter!"); + return E_NOINTERFACE; + } + + HRESULT hr; + hr = m_pReal2->GetDesc2(pDesc); + + if (hr == S_OK && b_spoofEnabled && pDesc != nullptr && (pDesc->VendorId == 0x8086 || pDesc->VendorId == 0x1002)) + { + LOG("WrappedIDXGIAdapter4.GetDesc2 Spoofing card info"); + + pDesc->VendorId = 0x10de; + pDesc->DeviceId = 0x24c9; + pDesc->SubSysId = 0x88ac1043; + pDesc->Revision = 0x00a1; + + std::wstring name(L"NVIDIA GeForce RTX 3060 Ti"); + const wchar_t* szName = name.c_str(); + std::memset(pDesc->Description, 0, sizeof(pDesc->Description)); + std::memcpy(pDesc->Description, szName, 54); + + LUID luid = LUID{ 0, 56090 }; + std::memcpy(&pDesc->AdapterLuid, &luid, 8); + } + + //b_spoofEnabled = true; + + LOG("WrappedIDXGIAdapter4.GetDesc2 result: " + int_to_hex(hr)); + + return hr; + } + + ////////////////////////////// + // implement IDXGIAdapter3 + + virtual HRESULT STDMETHODCALLTYPE RegisterHardwareContentProtectionTeardownStatusEvent( + /* [annotation][in] */ + _In_ HANDLE hEvent, + /* [annotation][out] */ + _Out_ DWORD* pdwCookie) + { + LOG("WrappedIDXGIAdapter4.RegisterHardwareContentProtectionTeardownStatusEvent"); + auto result = m_pReal3->RegisterHardwareContentProtectionTeardownStatusEvent(hEvent, pdwCookie); + LOG("WrappedIDXGIAdapter4.RegisterHardwareContentProtectionTeardownStatusEvent result: " + int_to_hex(result)); + return result; + } + + virtual void STDMETHODCALLTYPE UnregisterHardwareContentProtectionTeardownStatus( + /* [annotation][in] */ + _In_ DWORD dwCookie) + { + LOG("WrappedIDXGIAdapter4.UnregisterHardwareContentProtectionTeardownStatus"); + m_pReal3->UnregisterHardwareContentProtectionTeardownStatus(dwCookie); + LOG("WrappedIDXGIAdapter4.UnregisterHardwareContentProtectionTeardownStatus done"); + } + + virtual HRESULT STDMETHODCALLTYPE QueryVideoMemoryInfo( + /* [annotation][in] */ + _In_ UINT NodeIndex, + /* [annotation][in] */ + _In_ DXGI_MEMORY_SEGMENT_GROUP MemorySegmentGroup, + /* [annotation][out] */ + _Out_ DXGI_QUERY_VIDEO_MEMORY_INFO* pVideoMemoryInfo) + { + LOG("WrappedIDXGIAdapter4.QueryVideoMemoryInfo"); + + auto result = m_pReal3->QueryVideoMemoryInfo(NodeIndex, MemorySegmentGroup, pVideoMemoryInfo); + LOG("WrappedIDXGIAdapter4.QueryVideoMemoryInfo result: " + int_to_hex(result)); + return result; + } + + virtual HRESULT STDMETHODCALLTYPE SetVideoMemoryReservation( + /* [annotation][in] */ + _In_ UINT NodeIndex, + /* [annotation][in] */ + _In_ DXGI_MEMORY_SEGMENT_GROUP MemorySegmentGroup, + /* [annotation][in] */ + _In_ UINT64 Reservation) + { + LOG("WrappedIDXGIAdapter4.SetVideoMemoryReservation"); + + auto result = m_pReal3->SetVideoMemoryReservation(NodeIndex, MemorySegmentGroup, Reservation); + LOG("WrappedIDXGIAdapter4.SetVideoMemoryReservation result: " + int_to_hex(result)); + return result; + } + + virtual HRESULT STDMETHODCALLTYPE RegisterVideoMemoryBudgetChangeNotificationEvent( + /* [annotation][in] */ + _In_ HANDLE hEvent, + /* [annotation][out] */ + _Out_ DWORD* pdwCookie) + { + LOG("WrappedIDXGIAdapter4.RegisterVideoMemoryBudgetChangeNotificationEvent"); + + auto result = m_pReal3->RegisterVideoMemoryBudgetChangeNotificationEvent(hEvent, pdwCookie); + LOG("WrappedIDXGIAdapter4.RegisterVideoMemoryBudgetChangeNotificationEvent result: " + int_to_hex(result)); + return result; + } + + virtual void STDMETHODCALLTYPE UnregisterVideoMemoryBudgetChangeNotification( + /* [annotation][in] */ + _In_ DWORD dwCookie) + { + LOG("WrappedIDXGIAdapter4.UnregisterVideoMemoryBudgetChangeNotification"); + + m_pReal3->UnregisterVideoMemoryBudgetChangeNotification(dwCookie); + LOG("WrappedIDXGIAdapter4.UnregisterVideoMemoryBudgetChangeNotification done"); + } + + ////////////////////////////// + // implement IDXGIAdapter4 + + virtual HRESULT STDMETHODCALLTYPE GetDesc3( + /* [annotation][out] */ + _Out_ DXGI_ADAPTER_DESC3* pDesc) + { + LOG("WrappedIDXGIAdapter4.GetDesc3"); + + if (!m_pReal4) + { + LOG("WrappedIDXGIAdapter4.GetDesc3 no adapter!"); + return E_NOINTERFACE; + } + + HRESULT hr; + hr = m_pReal4->GetDesc3(pDesc); + + if (hr == S_OK && b_spoofEnabled && pDesc != nullptr && (pDesc->VendorId == 0x8086 || pDesc->VendorId == 0x1002)) + { + LOG("WrappedIDXGIAdapter4.GetDesc3 Spoofing card info"); + + pDesc->VendorId = 0x10de; + pDesc->DeviceId = 0x24c9; + pDesc->SubSysId = 0x88ac1043; + pDesc->Revision = 0x00a1; + + std::wstring name(L"NVIDIA GeForce RTX 3060 Ti"); + const wchar_t* szName = name.c_str(); + std::memset(pDesc->Description, 0, sizeof(pDesc->Description)); + std::memcpy(pDesc->Description, szName, 54); + + LUID luid = LUID{ 0, 56090 }; + std::memcpy(&pDesc->AdapterLuid, &luid, 8); + } + + //b_spoofEnabled = true; + + LOG("WrappedIDXGIAdapter4.GetDesc3 result: " + int_to_hex(hr)); + + return hr; + } + + virtual HRESULT STDMETHODCALLTYPE Spoofing(bool enable) + { + LOG("WrappedIDXGIAdapter4.Spoofing : " + std::to_string(enable)); + b_spoofEnabled = enable; + return S_OK; + } + + virtual HRESULT STDMETHODCALLTYPE Wrapping(bool enable) + { + LOG("WrappedIDXGIAdapter4.Wrapping : " + std::to_string(enable)); + b_wrappingEnabled = enable; + return S_OK; + } +}; + +class WrappedIDXGIFactory : public IDXGIFactory7, public RefCountDXGIObject +{ + IDXGIFactory* m_pReal; + IDXGIFactory1* m_pReal1; + IDXGIFactory2* m_pReal2; + IDXGIFactory3* m_pReal3; + IDXGIFactory4* m_pReal4; + IDXGIFactory5* m_pReal5; + IDXGIFactory6* m_pReal6; + IDXGIFactory7* m_pReal7; + +public: + WrappedIDXGIFactory(IDXGIFactory* real); + virtual ~WrappedIDXGIFactory(); + + IMPLEMENT_IDXGIOBJECT_WITH_REFCOUNTDXGIOBJECT_CUSTOMQUERY; + HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject); + + ////////////////////////////// + // implement IDXGIFactory + + virtual HRESULT STDMETHODCALLTYPE EnumAdapters( + /* [in] */ UINT Adapter, + /* [annotation][out] */ + __out IDXGIAdapter** ppAdapter) + { + LOG("WrappedIDXGIFactory.EnumAdapters " + std::to_string(Adapter)); + + HRESULT ret = m_pReal->EnumAdapters(Adapter, ppAdapter); + + if (ret == S_OK && b_wrappingEnabled) + *ppAdapter = (IDXGIAdapter*)(new WrappedIDXGIAdapter4(*ppAdapter)); + + LOG("WrappedIDXGIFactory.EnumAdapters result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE MakeWindowAssociation(HWND WindowHandle, UINT Flags) + { + LOG("WrappedIDXGIFactory.MakeWindowAssociation"); + + auto ret = m_pReal->MakeWindowAssociation(WindowHandle, Flags); + LOG("WrappedIDXGIFactory.MakeWindowAssociation result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE GetWindowAssociation( + /* [annotation][out] */ + __out HWND* pWindowHandle) + { + LOG("WrappedIDXGIFactory.GetWindowAssociation"); + + auto ret = m_pReal->GetWindowAssociation(pWindowHandle); + LOG("WrappedIDXGIFactory.GetWindowAssociation result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE CreateSwapChain( + /* [annotation][in] */ + __in IUnknown* pDevice, + /* [annotation][in] */ + __in DXGI_SWAP_CHAIN_DESC* pDesc, + /* [annotation][out] */ + __out IDXGISwapChain** ppSwapChain); + + virtual HRESULT STDMETHODCALLTYPE CreateSoftwareAdapter( + /* [in] */ HMODULE Module, + /* [annotation][out] */ + __out IDXGIAdapter** ppAdapter) + { + LOG("WrappedIDXGIFactory.CreateSoftwareAdapter"); + + HRESULT ret = m_pReal->CreateSoftwareAdapter(Module, ppAdapter); + + if (ret == S_OK && b_wrappingEnabled) + *ppAdapter = (IDXGIAdapter*)(new WrappedIDXGIAdapter4(*ppAdapter)); + + LOG("WrappedIDXGIFactory.CreateSoftwareAdapter result: " + int_to_hex(ret)); + return ret; + } + + ////////////////////////////// + // implement IDXGIFactory1 + + virtual HRESULT STDMETHODCALLTYPE EnumAdapters1( + /* [in] */ UINT Adapter, + /* [annotation][out] */ + __out IDXGIAdapter1** ppAdapter) + { + LOG("WrappedIDXGIFactory.EnumAdapters1 " + std::to_string(Adapter)); + + IDXGIFactory1* factory = m_pReal1; + if (m_pReal1 == NULL) + { + // see comment in RefCountDXGIObject::HandleWrap for IDXGIFactory + //RDCWARN("Calling EnumAdapters1 with no IDXGIFactory1 - assuming weird internal call"); + factory = (IDXGIFactory1*)m_pReal; + } + + HRESULT ret = factory->EnumAdapters1(Adapter, ppAdapter); + + if (ret == S_OK && b_wrappingEnabled) + *ppAdapter = (IDXGIAdapter1*)(new WrappedIDXGIAdapter4(*ppAdapter)); + + LOG("WrappedIDXGIFactory.EnumAdapters1 result: " + int_to_hex(ret)); + return ret; + } + + virtual BOOL STDMETHODCALLTYPE IsCurrent(void) + { + LOG("WrappedIDXGIFactory.IsCurrent"); + + auto ret = m_pReal1->IsCurrent(); + LOG("WrappedIDXGIFactory.IsCurrent result: " + std::to_string(ret)); + return ret; + } + ////////////////////////////// + // implement IDXGIFactory2 + + virtual BOOL STDMETHODCALLTYPE IsWindowedStereoEnabled(void) + { + LOG("WrappedIDXGIFactory.IsWindowedStereoEnabled"); + + auto ret = m_pReal2->IsWindowedStereoEnabled(); + LOG("WrappedIDXGIFactory.IsCurrent result: " + std::to_string(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE CreateSwapChainForHwnd( + /* [annotation][in] */ + _In_ IUnknown* pDevice, + /* [annotation][in] */ + _In_ HWND hWnd, + /* [annotation][in] */ + _In_ const DXGI_SWAP_CHAIN_DESC1* pDesc, + /* [annotation][in] */ + _In_opt_ const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* pFullscreenDesc, + /* [annotation][in] */ + _In_opt_ IDXGIOutput* pRestrictToOutput, + /* [annotation][out] */ + _Out_ IDXGISwapChain1** ppSwapChain); + + virtual HRESULT STDMETHODCALLTYPE CreateSwapChainForCoreWindow( + /* [annotation][in] */ + _In_ IUnknown* pDevice, + /* [annotation][in] */ + _In_ IUnknown* pWindow, + /* [annotation][in] */ + _In_ const DXGI_SWAP_CHAIN_DESC1* pDesc, + /* [annotation][in] */ + _In_opt_ IDXGIOutput* pRestrictToOutput, + /* [annotation][out] */ + _Out_ IDXGISwapChain1** ppSwapChain); + + virtual HRESULT STDMETHODCALLTYPE GetSharedResourceAdapterLuid( + /* [annotation] */ + _In_ HANDLE hResource, + /* [annotation] */ + _Out_ LUID* pLuid) + { + LOG("WrappedIDXGIFactory.GetSharedResourceAdapterLuid"); + + auto ret = m_pReal2->GetSharedResourceAdapterLuid(hResource, pLuid); + LOG("WrappedIDXGIFactory.GetSharedResourceAdapterLuid result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE RegisterStereoStatusWindow( + /* [annotation][in] */ + _In_ HWND WindowHandle, + /* [annotation][in] */ + _In_ UINT wMsg, + /* [annotation][out] */ + _Out_ DWORD* pdwCookie) + { + LOG("WrappedIDXGIFactory.RegisterStereoStatusWindow"); + + auto ret = m_pReal2->RegisterOcclusionStatusWindow(WindowHandle, wMsg, pdwCookie); + LOG("WrappedIDXGIFactory.RegisterStereoStatusWindow result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE RegisterStereoStatusEvent( + /* [annotation][in] */ + _In_ HANDLE hEvent, + /* [annotation][out] */ + _Out_ DWORD* pdwCookie) + { + LOG("WrappedIDXGIFactory.RegisterStereoStatusEvent"); + + auto ret = m_pReal2->RegisterStereoStatusEvent(hEvent, pdwCookie); + LOG("WrappedIDXGIFactory.RegisterStereoStatusEvent result: " + int_to_hex(ret)); + return ret; + } + + virtual void STDMETHODCALLTYPE UnregisterStereoStatus( + /* [annotation][in] */ + _In_ DWORD dwCookie) + { + LOG("WrappedIDXGIFactory.UnregisterStereoStatus"); + + m_pReal2->UnregisterStereoStatus(dwCookie); + LOG("WrappedIDXGIFactory.UnregisterStereoStatus done"); + } + + virtual HRESULT STDMETHODCALLTYPE RegisterOcclusionStatusWindow( + /* [annotation][in] */ + _In_ HWND WindowHandle, + /* [annotation][in] */ + _In_ UINT wMsg, + /* [annotation][out] */ + _Out_ DWORD* pdwCookie) + { + LOG("WrappedIDXGIFactory.RegisterOcclusionStatusWindow"); + + auto ret = m_pReal2->RegisterOcclusionStatusWindow(WindowHandle, wMsg, pdwCookie); + LOG("WrappedIDXGIFactory.RegisterOcclusionStatusWindow result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE RegisterOcclusionStatusEvent( + /* [annotation][in] */ + _In_ HANDLE hEvent, + /* [annotation][out] */ + _Out_ DWORD* pdwCookie) + { + LOG("WrappedIDXGIFactory.RegisterOcclusionStatusEvent"); + + auto ret = m_pReal2->RegisterOcclusionStatusEvent(hEvent, pdwCookie); + LOG("WrappedIDXGIFactory.RegisterOcclusionStatusEvent result: " + int_to_hex(ret)); + return ret; + } + + virtual void STDMETHODCALLTYPE UnregisterOcclusionStatus( + /* [annotation][in] */ + _In_ DWORD dwCookie) + { + LOG("WrappedIDXGIFactory.UnregisterOcclusionStatus"); + + m_pReal2->UnregisterOcclusionStatus(dwCookie); + LOG("WrappedIDXGIFactory.UnregisterOcclusionStatus done"); + } + + virtual HRESULT STDMETHODCALLTYPE CreateSwapChainForComposition( + /* [annotation][in] */ + _In_ IUnknown* pDevice, + /* [annotation][in] */ + _In_ const DXGI_SWAP_CHAIN_DESC1* pDesc, + /* [annotation][in] */ + _In_opt_ IDXGIOutput* pRestrictToOutput, + /* [annotation][out] */ + _Outptr_ IDXGISwapChain1** ppSwapChain); + + ////////////////////////////// + // implement IDXGIFactory3 + + virtual UINT STDMETHODCALLTYPE GetCreationFlags(void) + { + LOG("WrappedIDXGIFactory.GetCreationFlags"); + + auto ret = m_pReal3->GetCreationFlags(); + LOG("WrappedIDXGIFactory.GetCreationFlags result: " + int_to_hex(ret)); + return ret; + } + ////////////////////////////// + // implement IDXGIFactory4 + + bool WrapAdapter(REFIID riid, void** ppvAdapter) + { + LOG("WrappedIDXGIFactory.WrapAdapter"); + + if (ppvAdapter == NULL || *ppvAdapter == NULL) + { + LOG("WrappedIDXGIFactory.WrapAdapter ppvAdapter is NULL!"); + return false; + } + + if (riid == __uuidof(IDXGIAdapter4) && b_wrappingEnabled) + { + IDXGIAdapter4* adapter = (IDXGIAdapter4*)*ppvAdapter; + *ppvAdapter = (IDXGIAdapter4*)(new WrappedIDXGIAdapter4(adapter)); + return true; + } + else if (riid == __uuidof(IDXGIAdapter3) && b_wrappingEnabled) + { + IDXGIAdapter3* adapter = (IDXGIAdapter3*)*ppvAdapter; + *ppvAdapter = (IDXGIAdapter3*)(new WrappedIDXGIAdapter4(adapter)); + return true; + } + else if (riid == __uuidof(IDXGIAdapter2) && b_wrappingEnabled) + { + IDXGIAdapter2* adapter = (IDXGIAdapter2*)*ppvAdapter; + *ppvAdapter = (IDXGIAdapter2*)(new WrappedIDXGIAdapter4(adapter)); + return true; + } + else if (riid == __uuidof(IDXGIAdapter1) && b_wrappingEnabled) + { + IDXGIAdapter1* adapter = (IDXGIAdapter1*)*ppvAdapter; + *ppvAdapter = (IDXGIAdapter1*)(new WrappedIDXGIAdapter4(adapter)); + return true; + } + else if (riid == __uuidof(IDXGIAdapter) && b_wrappingEnabled) + { + IDXGIAdapter* adapter = (IDXGIAdapter*)*ppvAdapter; + *ppvAdapter = (IDXGIAdapter*)(new WrappedIDXGIAdapter4(adapter)); + return true; + } + else + { + return RefCountDXGIObject::HandleWrap("IDXGIAdapter", riid, ppvAdapter); + } + + return false; + } + + virtual HRESULT STDMETHODCALLTYPE EnumAdapterByLuid( /* [annotation] */ _In_ LUID AdapterLuid, /* [annotation] */ _In_ REFIID riid, /* [annotation] */ _COM_Outptr_ void** ppvAdapter) + + { +#ifdef BLOCK_IDXGIAdapterInternal2 + // unknown/undocumented internal interface + // {7abb6563-02bc-47c4-8ef9-acc4795edbcf} + static const GUID IDXGIAdapterInternal2_uuid = { + 0x7abb6563, 0x02bc, 0x47c4, {0x8e, 0xf9, 0xac, 0xc4, 0x79, 0x5e, 0xdb, 0xcf} }; + + if (riid == IDXGIAdapterInternal2_uuid) + { + LOG("WrappedIDXGIFactory.EnumAdapterByLuid IDXGIAdapterInternal2_uuid result: " + int_to_hex(DXGI_ERROR_NOT_FOUND)); + return DXGI_ERROR_NOT_FOUND; + } +#endif + + LOG("WrappedIDXGIFactory.EnumAdapterByLuid LUID: " + int_to_hex(AdapterLuid.HighPart) + "-" + int_to_hex(AdapterLuid.LowPart) + " riid: " + ToString(riid)); + + HRESULT ret = m_pReal4->EnumAdapterByLuid(AdapterLuid, riid, ppvAdapter); + + if (ret == S_OK && b_wrappingEnabled) + { + auto wrapResult = this->WrapAdapter(riid, ppvAdapter); + + if (!wrapResult) + { + LOG("WrappedIDXGIFactory.EnumAdapterByLuid wrapResult result: " + int_to_hex(DXGI_ERROR_NOT_FOUND)); + return DXGI_ERROR_NOT_FOUND; + } + } + else + { + LOG("WrappedIDXGIFactory.EnumAdapterByLuid can't get adapter by LUID, user first adapter"); + IDXGIAdapter* wrappedAdapter; + ret = this->EnumAdapters(0, &wrappedAdapter); + + if (ret == S_OK) + *ppvAdapter = wrappedAdapter; + } + + LOG("WrappedIDXGIFactory.EnumAdapterByLuid result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE EnumWarpAdapter( + /* [annotation] */ + _In_ REFIID riid, + /* [annotation] */ + _COM_Outptr_ void** ppvAdapter) + { + LOG("WrappedIDXGIFactory.EnumWarpAdapter"); + + HRESULT ret = m_pReal4->EnumWarpAdapter(riid, ppvAdapter); + + if (ret == S_OK && b_wrappingEnabled) + WrapAdapter(riid, ppvAdapter); + + LOG("WrappedIDXGIFactory.EnumWarpAdapter result: " + int_to_hex(ret)); + return ret; + } + + ////////////////////////////// + // implement IDXGIFactory5 + + virtual HRESULT STDMETHODCALLTYPE + CheckFeatureSupport(DXGI_FEATURE Feature, + /* [annotation] */ + _Inout_updates_bytes_(FeatureSupportDataSize) void* pFeatureSupportData, + UINT FeatureSupportDataSize) + { + LOG("WrappedIDXGIFactory.CheckFeatureSupport"); + + auto ret = m_pReal5->CheckFeatureSupport(Feature, pFeatureSupportData, FeatureSupportDataSize); + LOG("WrappedIDXGIFactory.CheckFeatureSupport result: " + int_to_hex(ret)); + return ret; + } + + ////////////////////////////// + // implement IDXGIFactory6 + + virtual HRESULT STDMETHODCALLTYPE EnumAdapterByGpuPreference( + /* [annotation] */ + _In_ UINT Adapter, + /* [annotation] */ + _In_ DXGI_GPU_PREFERENCE GpuPreference, + /* [annotation] */ + _In_ REFIID riid, + /* [annotation] */ + _COM_Outptr_ void** ppvAdapter) + { + LOG("WrappedIDXGIFactory.EnumAdapterByGpuPreference " + std::to_string(Adapter) + ", GpuPreference: " + int_to_hex(GpuPreference)); + + HRESULT ret = m_pReal6->EnumAdapterByGpuPreference(Adapter, GpuPreference, riid, ppvAdapter); + + if (ret == S_OK && b_wrappingEnabled) + WrapAdapter(riid, ppvAdapter); + + LOG("WrappedIDXGIFactory.EnumAdapterByGpuPreference result: " + int_to_hex(ret)); + return ret; + } + + ////////////////////////////// + // implement IDXGIFactory7 + + virtual HRESULT STDMETHODCALLTYPE RegisterAdaptersChangedEvent( + /* [annotation][in] */ + _In_ HANDLE hEvent, + /* [annotation][out] */ + _Out_ DWORD* pdwCookie) + { + LOG("WrappedIDXGIFactory.RegisterAdaptersChangedEvent"); + + auto ret = m_pReal7->RegisterAdaptersChangedEvent(hEvent, pdwCookie); + LOG("WrappedIDXGIFactory.RegisterAdaptersChangedEvent result: " + int_to_hex(ret)); + return ret; + } + + virtual HRESULT STDMETHODCALLTYPE UnregisterAdaptersChangedEvent( + /* [annotation][in] */ + _In_ DWORD dwCookie) + { + LOG("WrappedIDXGIFactory.UnregisterAdaptersChangedEvent"); + + auto ret = m_pReal7->UnregisterAdaptersChangedEvent(dwCookie); + LOG("WrappedIDXGIFactory.UnregisterAdaptersChangedEvent result: " + int_to_hex(ret)); + return ret; + } +}; + diff --git a/CyberXeSS/pch.h b/CyberXeSS/pch.h index 54bfb67a..1848bcc6 100644 --- a/CyberXeSS/pch.h +++ b/CyberXeSS/pch.h @@ -1,7 +1,7 @@ #pragma once #include "framework.h" -//#define LOGGING_ACTIVE +#define LOGGING_ACTIVE typedef enum _log_level_t { @@ -12,9 +12,18 @@ typedef enum _log_level_t LEVEL_ERROR = 3 } log_level_t; +#define SAFE_RELEASE(p) \ + do \ + { \ + if(p) \ + { \ + (p)->Release(); \ + (p) = NULL; \ + } \ + } while((void)0, 0) #ifdef LOGGING_ACTIVE -#define LOG(string, level) logprintf(string, level) +#define LOG(string, ...) logprintf(string, __VA_ARGS__) #else #define LOG(string, level) #endif @@ -25,7 +34,7 @@ typedef enum _log_level_t #include #include "Config.h" -void logprintf(std::string logMsg, log_level_t level); +void logprintf(std::string logMsg, log_level_t level = LEVEL_DEBUG); void prepareOfs(std::string fileName, log_level_t level); @@ -40,4 +49,30 @@ static inline int64_t GetTicks() return ticks.QuadPart; } +template< typename T > +static inline std::string int_to_hex(T i) +{ + std::stringstream stream; + stream << "0x" + << std::setfill('0') + << std::setw(sizeof(T) * 2) + << std::hex << i; + return stream.str(); +} + +static inline std::string ToString(REFIID guid) +{ + char guid_string[37]; // 32 hex chars + 4 hyphens + null terminator + + snprintf( + guid_string, sizeof(guid_string), + "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", + guid.Data1, guid.Data2, guid.Data3, + guid.Data4[0], guid.Data4[1], guid.Data4[2], + guid.Data4[3], guid.Data4[4], guid.Data4[5], + guid.Data4[6], guid.Data4[7]); + + return guid_string; +} + #endif \ No newline at end of file