WinDurango/archived-WinDurango
1
0
Fork 0
mirror of https://github.com/WinDurango/WinDurango.git synced 2026-01-31 00:55:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #93 from Patoke/main

Browse Source 
Add missing wrappers, unwrap routines, better file naming
This commit is contained in:
Serenity
2025-01-07 06:22:34 -05:00
committed by GitHub
parent f537a2e530 5031a118f1
commit 36759a731f
11 changed files with 1154 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
dlls/d3d11_x/ID3D11RenderTargetViewWrapper.cpp
View File

@@ -1,82 +0,0 @@
#include "pch.h"
#include "ID3DWrappers.h"
namespace d3d11x
{
HRESULT ID3D11RenderTargetViewWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
if (riid == __uuidof(::ID3D11RenderTargetView))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
else
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[IDXGIDeviceWrapper] QueryInterface: %s\n", iidstr);
}
return m_realTarget->QueryInterface(riid, ppvObject);
}
ULONG ID3D11RenderTargetViewWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11RenderTargetViewWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
void __stdcall ID3D11RenderTargetViewWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTarget->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11RenderTargetViewWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTarget->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11RenderTargetViewWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTarget->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11RenderTargetViewWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTarget->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11RenderTargetViewWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11RenderTargetViewWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11RenderTargetViewWrapper::GetResource(ID3D11Resource** ppResource)
{
::ID3D11Texture2D* texture2d = nullptr;
m_realTarget->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<ID3D11Texture2D_X**>(ppResource) = new ID3D11Texture2DWrapper(texture2d);
}
void __stdcall ID3D11RenderTargetViewWrapper::GetDesc(D3D11_RENDER_TARGET_VIEW_DESC* pDesc)
{
m_realTarget->GetDesc(pDesc);
}
}

95
dlls/d3d11_x/ID3D11Texture2DWrapper.cpp
View File

@@ -1,95 +0,0 @@
#include "pch.h"
#include "ID3DWrappers.h"
namespace d3d11x
{
HRESULT ID3D11Texture2DWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
if (riid == __uuidof(::ID3D11Texture2D))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
else
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[IDXGIDeviceWrapper] QueryInterface: %s\n", iidstr);
}
return m_realTexture->QueryInterface(riid, ppvObject);
}
ULONG ID3D11Texture2DWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11Texture2DWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
// @Patoke todo: unwrap?
void __stdcall ID3D11Texture2DWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTexture->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11Texture2DWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTexture->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11Texture2DWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTexture->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11Texture2DWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTexture->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11Texture2DWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11Texture2DWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11Texture2DWrapper::GetType(D3D11_RESOURCE_DIMENSION* pResourceDimension)
{
return m_realTexture->GetType(pResourceDimension);
}
void __stdcall ID3D11Texture2DWrapper::SetEvictionPriority(UINT EvictionPriority)
{
return m_realTexture->SetEvictionPriority(EvictionPriority);
}
UINT __stdcall ID3D11Texture2DWrapper::GetEvictionPriority(void)
{
return m_realTexture->GetEvictionPriority();
}
void __stdcall ID3D11Texture2DWrapper::GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor)
{
printf("[ID3D11Texture2DWrapper]: GetDescriptor STUB\n");
}
void __stdcall ID3D11Texture2DWrapper::GetDesc(D3D11_TEXTURE2D_DESC* pDesc)
{
return m_realTexture->GetDesc(pDesc);
}
}

268
dlls/d3d11_x/ID3D11TextureWrapper.cpp Normal file
View File

@@ -0,0 +1,268 @@
#include "pch.h"
#include "ID3DWrappers.h"
namespace d3d11x
{
HRESULT ID3D11Texture1DWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[ID3D11Texture1DWrapper] QueryInterface: %s\n", iidstr);
if (riid == __uuidof(::ID3D11Texture1D))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
return m_realTexture->QueryInterface(riid, ppvObject);
}
ULONG ID3D11Texture1DWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11Texture1DWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
// @Patoke todo: unwrap?
void __stdcall ID3D11Texture1DWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTexture->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11Texture1DWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTexture->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11Texture1DWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTexture->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11Texture1DWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTexture->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11Texture1DWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11Texture1DWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11Texture1DWrapper::GetType(D3D11_RESOURCE_DIMENSION* pResourceDimension)
{
return m_realTexture->GetType(pResourceDimension);
}
void __stdcall ID3D11Texture1DWrapper::SetEvictionPriority(UINT EvictionPriority)
{
return m_realTexture->SetEvictionPriority(EvictionPriority);
}
UINT __stdcall ID3D11Texture1DWrapper::GetEvictionPriority(void)
{
return m_realTexture->GetEvictionPriority( );
}
void __stdcall ID3D11Texture1DWrapper::GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor)
{
printf("[ID3D11Texture1DWrapper]: GetDescriptor STUB\n");
}
void __stdcall ID3D11Texture1DWrapper::GetDesc(D3D11_TEXTURE1D_DESC* pDesc)
{
return m_realTexture->GetDesc(pDesc);
}
HRESULT ID3D11Texture2DWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[ID3D11Texture2DWrapper] QueryInterface: %s\n", iidstr);
if (riid == __uuidof(::ID3D11Texture2D))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
return m_realTexture->QueryInterface(riid, ppvObject);
}
ULONG ID3D11Texture2DWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11Texture2DWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
// @Patoke todo: unwrap?
void __stdcall ID3D11Texture2DWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTexture->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11Texture2DWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTexture->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11Texture2DWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTexture->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11Texture2DWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTexture->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11Texture2DWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11Texture2DWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11Texture2DWrapper::GetType(D3D11_RESOURCE_DIMENSION* pResourceDimension)
{
return m_realTexture->GetType(pResourceDimension);
}
void __stdcall ID3D11Texture2DWrapper::SetEvictionPriority(UINT EvictionPriority)
{
return m_realTexture->SetEvictionPriority(EvictionPriority);
}
UINT __stdcall ID3D11Texture2DWrapper::GetEvictionPriority(void)
{
return m_realTexture->GetEvictionPriority();
}
void __stdcall ID3D11Texture2DWrapper::GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor)
{
printf("[ID3D11Texture2DWrapper]: GetDescriptor STUB\n");
}
void __stdcall ID3D11Texture2DWrapper::GetDesc(D3D11_TEXTURE2D_DESC* pDesc)
{
return m_realTexture->GetDesc(pDesc);
}
HRESULT ID3D11Texture3DWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[ID3D11Texture3DWrapper] QueryInterface: %s\n", iidstr);
if (riid == __uuidof(::ID3D11Texture3D))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
return m_realTexture->QueryInterface(riid, ppvObject);
}
ULONG ID3D11Texture3DWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11Texture3DWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
// @Patoke todo: unwrap?
void __stdcall ID3D11Texture3DWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTexture->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11Texture3DWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTexture->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11Texture3DWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTexture->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11Texture3DWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTexture->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11Texture3DWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11Texture3DWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11Texture3DWrapper::GetType(D3D11_RESOURCE_DIMENSION* pResourceDimension)
{
return m_realTexture->GetType(pResourceDimension);
}
void __stdcall ID3D11Texture3DWrapper::SetEvictionPriority(UINT EvictionPriority)
{
return m_realTexture->SetEvictionPriority(EvictionPriority);
}
UINT __stdcall ID3D11Texture3DWrapper::GetEvictionPriority(void)
{
return m_realTexture->GetEvictionPriority( );
}
void __stdcall ID3D11Texture3DWrapper::GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor)
{
printf("[ID3D11Texture3DWrapper]: GetDescriptor STUB\n");
}
void __stdcall ID3D11Texture3DWrapper::GetDesc(D3D11_TEXTURE3D_DESC* pDesc)
{
return m_realTexture->GetDesc(pDesc);
}
}

307
dlls/d3d11_x/ID3D11ViewWrapper.cpp Normal file
View File

@@ -0,0 +1,307 @@
#include "pch.h"
#include "ID3DWrappers.h"
namespace d3d11x
{
HRESULT ID3D11RenderTargetViewWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
if (riid == __uuidof(::ID3D11RenderTargetView))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
else
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[IDXGIDeviceWrapper] QueryInterface: %s\n", iidstr);
}
return m_realTarget->QueryInterface(riid, ppvObject);
}
ULONG ID3D11RenderTargetViewWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11RenderTargetViewWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
void __stdcall ID3D11RenderTargetViewWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTarget->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11RenderTargetViewWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTarget->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11RenderTargetViewWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTarget->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11RenderTargetViewWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTarget->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11RenderTargetViewWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11RenderTargetViewWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11RenderTargetViewWrapper::GetResource(ID3D11Resource** ppResource)
{
::ID3D11Texture2D* texture2d = nullptr;
m_realTarget->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<ID3D11Texture2D_X**>(ppResource) = new ID3D11Texture2DWrapper(texture2d);
}
void __stdcall ID3D11RenderTargetViewWrapper::GetDesc(D3D11_RENDER_TARGET_VIEW_DESC* pDesc)
{
m_realTarget->GetDesc(pDesc);
}
HRESULT ID3D11DepthStencilViewWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
if (riid == __uuidof(::ID3D11DepthStencilView))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
else
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[IDXGIDeviceWrapper] QueryInterface: %s\n", iidstr);
}
return m_realTarget->QueryInterface(riid, ppvObject);
}
ULONG ID3D11DepthStencilViewWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11DepthStencilViewWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
void __stdcall ID3D11DepthStencilViewWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTarget->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11DepthStencilViewWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTarget->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11DepthStencilViewWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTarget->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11DepthStencilViewWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTarget->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11DepthStencilViewWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11DepthStencilViewWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11DepthStencilViewWrapper::GetResource(ID3D11Resource** ppResource)
{
::ID3D11Texture2D* texture2d = nullptr;
m_realTarget->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<ID3D11Texture2D_X**>(ppResource) = new ID3D11Texture2DWrapper(texture2d);
}
void __stdcall ID3D11DepthStencilViewWrapper::GetDesc(D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc)
{
m_realTarget->GetDesc(pDesc);
}
HRESULT ID3D11ShaderResourceViewWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
if (riid == __uuidof(::ID3D11ShaderResourceView))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
else
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[IDXGIDeviceWrapper] QueryInterface: %s\n", iidstr);
}
return m_realTarget->QueryInterface(riid, ppvObject);
}
ULONG ID3D11ShaderResourceViewWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11ShaderResourceViewWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
void __stdcall ID3D11ShaderResourceViewWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTarget->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11ShaderResourceViewWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTarget->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11ShaderResourceViewWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTarget->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11ShaderResourceViewWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTarget->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11ShaderResourceViewWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11ShaderResourceViewWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11ShaderResourceViewWrapper::GetResource(ID3D11Resource** ppResource)
{
::ID3D11Texture2D* texture2d = nullptr;
m_realTarget->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<ID3D11Texture2D_X**>(ppResource) = new ID3D11Texture2DWrapper(texture2d);
}
void __stdcall ID3D11ShaderResourceViewWrapper::GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc)
{
m_realTarget->GetDesc(pDesc);
}
HRESULT ID3D11UnorderedAccessViewWrapper::QueryInterface(REFIID riid, void** ppvObject)
{
if (riid == __uuidof(::ID3D11UnorderedAccessView))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
else
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[IDXGIDeviceWrapper] QueryInterface: %s\n", iidstr);
}
return m_realTarget->QueryInterface(riid, ppvObject);
}
ULONG ID3D11UnorderedAccessViewWrapper::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11UnorderedAccessViewWrapper::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
void __stdcall ID3D11UnorderedAccessViewWrapper::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realTarget->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11UnorderedAccessViewWrapper::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realTarget->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11UnorderedAccessViewWrapper::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realTarget->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11UnorderedAccessViewWrapper::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realTarget->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11UnorderedAccessViewWrapper::SetName(const wchar_t* name)
{
printf("[ID3D11UnorderedAccessViewWrapper]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11UnorderedAccessViewWrapper::GetResource(ID3D11Resource** ppResource)
{
::ID3D11Texture2D* texture2d = nullptr;
m_realTarget->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<ID3D11Texture2D_X**>(ppResource) = new ID3D11Texture2DWrapper(texture2d);
}
void __stdcall ID3D11UnorderedAccessViewWrapper::GetDesc(D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc)
{
m_realTarget->GetDesc(pDesc);
}
}

80
dlls/d3d11_x/ID3DWrappers.cpp
View File

@@ -1 +1,79 @@
#include "pch.h"
#include "pch.h"
#include "ID3DWrappers.h"
namespace d3d11x {
HRESULT ID3D11ResourceWrapperX::QueryInterface(REFIID riid, void** ppvObject)
{
// DEBUG
char iidstr[ sizeof("{AAAAAAAA-BBBB-CCCC-DDEE-FFGGHHIIJJKK}") ];
OLECHAR iidwstr[ sizeof(iidstr) ];
StringFromGUID2(riid, iidwstr, ARRAYSIZE(iidwstr));
WideCharToMultiByte(CP_UTF8, 0, iidwstr, -1, iidstr, sizeof(iidstr), nullptr, nullptr);
printf("[ID3D11ResourceWrapperX] QueryInterface: %s\n", iidstr);
return m_realResource->QueryInterface(riid, ppvObject);
}
ULONG ID3D11ResourceWrapperX::AddRef( )
{
return InterlockedIncrement(&m_RefCount);
}
ULONG ID3D11ResourceWrapperX::Release( )
{
ULONG refCount = InterlockedDecrement(&m_RefCount);
if (refCount == 0)
delete this;
return refCount;
}
// @Patoke todo: unwrap?
void __stdcall ID3D11ResourceWrapperX::GetDevice(ID3D11Device** ppDevice)
{
// Probably not necessary but just to be sure -AleBlbl
::ID3D11Device** device = nullptr;
this->m_realResource->GetDevice(device);
ppDevice = reinterpret_cast<ID3D11Device**>(ppDevice);
}
HRESULT __stdcall ID3D11ResourceWrapperX::GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData)
{
return m_realResource->GetPrivateData(guid, pDataSize, pData);
}
HRESULT __stdcall ID3D11ResourceWrapperX::SetPrivateData(REFGUID guid, UINT DataSize, const void* pData)
{
return m_realResource->SetPrivateData(guid, DataSize, pData);
}
HRESULT __stdcall ID3D11ResourceWrapperX::SetPrivateDataInterface(REFGUID guid, const IUnknown* pData)
{
return m_realResource->SetPrivateDataInterface(guid, pData);
}
HRESULT __stdcall ID3D11ResourceWrapperX::SetName(const wchar_t* name)
{
printf("[ID3D11ResourceWrapperX]: SetName STUB\n");
return S_OK;
}
void __stdcall ID3D11ResourceWrapperX::GetType(D3D11_RESOURCE_DIMENSION* pResourceDimension)
{
return m_realResource->GetType(pResourceDimension);
}
void __stdcall ID3D11ResourceWrapperX::SetEvictionPriority(UINT EvictionPriority)
{
return m_realResource->SetEvictionPriority(EvictionPriority);
}
UINT __stdcall ID3D11ResourceWrapperX::GetEvictionPriority(void)
{
return m_realResource->GetEvictionPriority( );
}
void __stdcall ID3D11ResourceWrapperX::GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor)
{
printf("[ID3D11ResourceWrapperX]: GetDescriptor STUB\n");
}
}

305
dlls/d3d11_x/ID3DWrappers.h
View File

@@ -51,7 +51,74 @@ namespace d3d11x
void STDMETHODCALLTYPE GetDesc(_Out_ D3D11_BUFFER_DESC* pDesc) override;
};
class ID3D11ResourceWrapperX : public ID3D11DeviceChild_X
{
public:
ID3D11Resource* m_realResource;
ID3D11ResourceWrapperX(::ID3D11Resource* resource) : m_realResource(resource)
{
m_RefCount = 1;
}
// IGraphicsUnknown
HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
ULONG AddRef( ) override;
ULONG Release( ) override;
// ID3D11DeviceChild
void STDMETHODCALLTYPE GetDevice(_Outptr_ ID3D11Device** ppDevice) override;
HRESULT STDMETHODCALLTYPE GetPrivateData(_In_ REFGUID guid, _Inout_ UINT* pDataSize, _Out_writes_bytes_opt_(*pDataSize) void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateData(_In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_(DataSize) const void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_ REFGUID guid, _In_opt_ const IUnknown* pData) override;
HRESULT STDMETHODCALLTYPE SetName(const wchar_t* name) override;
virtual void STDMETHODCALLTYPE GetType(
/* [annotation] */
_Out_ D3D11_RESOURCE_DIMENSION* pResourceDimension);
virtual void STDMETHODCALLTYPE SetEvictionPriority(
/* [annotation] */
_In_ UINT EvictionPriority);
virtual UINT STDMETHODCALLTYPE GetEvictionPriority(void);
// xbox extra function
virtual void STDMETHODCALLTYPE GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor);
};
class ID3D11Texture1DWrapper : public ID3D11Texture1D_X
{
public:
ID3D11Texture1D* m_realTexture;
ID3D11Texture1DWrapper(::ID3D11Texture1D* tex) : m_realTexture(tex)
{
m_RefCount = 1;
}
// IGraphicsUnknown
HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
ULONG AddRef( ) override;
ULONG Release( ) override;
// ID3D11DeviceChild
void STDMETHODCALLTYPE GetDevice(_Outptr_ ID3D11Device** ppDevice) override;
HRESULT STDMETHODCALLTYPE GetPrivateData(_In_ REFGUID guid, _Inout_ UINT* pDataSize, _Out_writes_bytes_opt_(*pDataSize) void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateData(_In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_(DataSize) const void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_ REFGUID guid, _In_opt_ const IUnknown* pData) override;
HRESULT STDMETHODCALLTYPE SetName(const wchar_t* name) override;
// ID3D11Resource
void STDMETHODCALLTYPE GetType(_Out_ D3D11_RESOURCE_DIMENSION* pResourceDimension) override;
void STDMETHODCALLTYPE SetEvictionPriority(_In_ UINT EvictionPriority) override;
UINT STDMETHODCALLTYPE GetEvictionPriority(void) override;
void STDMETHODCALLTYPE GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor) override;
// ID3D11Texture1D
void STDMETHODCALLTYPE GetDesc(_Out_ D3D11_TEXTURE1D_DESC* pDesc) override;
};
class ID3D11Texture2DWrapper : public ID3D11Texture2D_X
{
public:
@@ -85,7 +152,38 @@ namespace d3d11x
void STDMETHODCALLTYPE GetDesc(_Out_ D3D11_TEXTURE2D_DESC* pDesc) override;
};
class ID3D11Texture3DWrapper : public ID3D11Texture3D_X
{
public:
ID3D11Texture3D* m_realTexture;
ID3D11Texture3DWrapper(::ID3D11Texture3D* tex) : m_realTexture(tex)
{
m_RefCount = 1;
}
// IGraphicsUnknown
HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
ULONG AddRef( ) override;
ULONG Release( ) override;
// ID3D11DeviceChild
void STDMETHODCALLTYPE GetDevice(_Outptr_ ID3D11Device** ppDevice) override;
HRESULT STDMETHODCALLTYPE GetPrivateData(_In_ REFGUID guid, _Inout_ UINT* pDataSize, _Out_writes_bytes_opt_(*pDataSize) void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateData(_In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_(DataSize) const void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_ REFGUID guid, _In_opt_ const IUnknown* pData) override;
HRESULT STDMETHODCALLTYPE SetName(const wchar_t* name) override;
// ID3D11Resource
void STDMETHODCALLTYPE GetType(_Out_ D3D11_RESOURCE_DIMENSION* pResourceDimension) override;
void STDMETHODCALLTYPE SetEvictionPriority(_In_ UINT EvictionPriority) override;
UINT STDMETHODCALLTYPE GetEvictionPriority(void) override;
void STDMETHODCALLTYPE GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor) override;
// ID3D11Texture3D
void STDMETHODCALLTYPE GetDesc(_Out_ D3D11_TEXTURE3D_DESC* pDesc) override;
};
class ID3D11RenderTargetViewWrapper : ID3D11RenderTargetView_X
{
@@ -94,6 +192,7 @@ namespace d3d11x
ID3D11RenderTargetViewWrapper(::ID3D11RenderTargetView* tex) : m_realTarget(tex)
{
this->m_pResource = reinterpret_cast<::ID3D11Resource*>(m_realTarget);
m_RefCount = 1;
}
@@ -120,6 +219,108 @@ namespace d3d11x
_Out_ D3D11_RENDER_TARGET_VIEW_DESC* pDesc) override;
};
class ID3D11DepthStencilViewWrapper : ID3D11DepthStencilView_X
{
public:
ID3D11DepthStencilView* m_realTarget;
ID3D11DepthStencilViewWrapper(::ID3D11DepthStencilView* tex) : m_realTarget(tex)
{
this->m_pResource = reinterpret_cast<::ID3D11Resource*>(m_realTarget);
m_RefCount = 1;
}
// IGraphicsUnknown
HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
ULONG AddRef( ) override;
ULONG Release( ) override;
// ID3D11DeviceChild
void STDMETHODCALLTYPE GetDevice(_Outptr_ ID3D11Device** ppDevice) override;
HRESULT STDMETHODCALLTYPE GetPrivateData(_In_ REFGUID guid, _Inout_ UINT* pDataSize, _Out_writes_bytes_opt_(*pDataSize) void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateData(_In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_(DataSize) const void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_ REFGUID guid, _In_opt_ const IUnknown* pData) override;
HRESULT STDMETHODCALLTYPE SetName(const wchar_t* name) override;
// ID3D11View
void STDMETHODCALLTYPE GetResource(
_Outptr_ ID3D11Resource** ppResource) override;
// ID3D11DepthStencilView
void STDMETHODCALLTYPE GetDesc(
_Out_ D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc) override;
};
class ID3D11ShaderResourceViewWrapper : ID3D11ShaderResourceView_X
{
public:
ID3D11ShaderResourceView* m_realTarget;
ID3D11ShaderResourceViewWrapper(::ID3D11ShaderResourceView* tex) : m_realTarget(tex)
{
this->m_pResource = reinterpret_cast<::ID3D11Resource*>(m_realTarget);
m_RefCount = 1;
}
// IGraphicsUnknown
HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
ULONG AddRef( ) override;
ULONG Release( ) override;
// ID3D11DeviceChild
void STDMETHODCALLTYPE GetDevice(_Outptr_ ID3D11Device** ppDevice) override;
HRESULT STDMETHODCALLTYPE GetPrivateData(_In_ REFGUID guid, _Inout_ UINT* pDataSize, _Out_writes_bytes_opt_(*pDataSize) void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateData(_In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_(DataSize) const void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_ REFGUID guid, _In_opt_ const IUnknown* pData) override;
HRESULT STDMETHODCALLTYPE SetName(const wchar_t* name) override;
// ID3D11View
void STDMETHODCALLTYPE GetResource(
_Outptr_ ID3D11Resource** ppResource) override;
// ID3D11ShaderResourceView
void STDMETHODCALLTYPE GetDesc(
_Out_ D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) override;
};
class ID3D11UnorderedAccessViewWrapper : ID3D11UnorderedAccessView_X
{
public:
ID3D11UnorderedAccessView* m_realTarget;
ID3D11UnorderedAccessViewWrapper(::ID3D11UnorderedAccessView* tex) : m_realTarget(tex)
{
this->m_pResource = reinterpret_cast<::ID3D11Resource*>(m_realTarget);
m_RefCount = 1;
}
// IGraphicsUnknown
HRESULT QueryInterface(REFIID riid, void** ppvObject) override;
ULONG AddRef( ) override;
ULONG Release( ) override;
// ID3D11DeviceChild
void STDMETHODCALLTYPE GetDevice(_Outptr_ ID3D11Device** ppDevice) override;
HRESULT STDMETHODCALLTYPE GetPrivateData(_In_ REFGUID guid, _Inout_ UINT* pDataSize, _Out_writes_bytes_opt_(*pDataSize) void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateData(_In_ REFGUID guid, _In_ UINT DataSize, _In_reads_bytes_opt_(DataSize) const void* pData) override;
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(_In_ REFGUID guid, _In_opt_ const IUnknown* pData) override;
HRESULT STDMETHODCALLTYPE SetName(const wchar_t* name) override;
// ID3D11View
void STDMETHODCALLTYPE GetResource(
_Outptr_ ID3D11Resource** ppResource) override;
// ID3D11UnorderedAccessView
void STDMETHODCALLTYPE GetDesc(
_Out_ D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc) override;
};
//MIDL_INTERFACE("c0bfa96c-e089-44fb-8eaf-26f8796190da")
@@ -204,13 +405,13 @@ namespace d3d11x
_In_ UINT MapFlags,
_Out_opt_ D3D11_MAPPED_SUBRESOURCE* pMappedResource)
{
return m_realDeviceCtx->Map(reinterpret_cast<ID3D11BufferWrapper*>(pResource)->m_realBuffer, Subresource, MapType, MapFlags, pMappedResource);
return m_realDeviceCtx->Map(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource, Subresource, MapType, MapFlags, pMappedResource);
}
virtual void STDMETHODCALLTYPE Unmap(
_In_ ID3D11Resource* pResource,
_In_ UINT Subresource) {
m_realDeviceCtx->Unmap(reinterpret_cast<ID3D11BufferWrapper*>(pResource)->m_realBuffer, Subresource);
m_realDeviceCtx->Unmap(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource, Subresource);
}
virtual void STDMETHODCALLTYPE PSSetConstantBuffers(
@@ -249,13 +450,15 @@ namespace d3d11x
}
virtual void STDMETHODCALLTYPE IASetIndexBuffer(
_In_opt_ ID3D11Buffer* pIndexBuffer,
// @Patoke note: this one changes prototype
_In_ DXGI_FORMAT Format,
_In_opt_ ID3D11Buffer* pIndexBuffer,
_In_ UINT Offset) {
m_realDeviceCtx->IASetIndexBuffer(pIndexBuffer, Format, Offset);
// @Patoke note: remember pIndexBuffer is optional
if (pIndexBuffer == nullptr)
return m_realDeviceCtx->IASetIndexBuffer(pIndexBuffer, Format, Offset);
m_realDeviceCtx->IASetIndexBuffer(reinterpret_cast<ID3D11BufferWrapper*>(pIndexBuffer)->m_realBuffer, Format, Offset);
}
virtual void STDMETHODCALLTYPE DrawIndexedInstanced(
@@ -345,8 +548,12 @@ namespace d3d11x
virtual void STDMETHODCALLTYPE OMSetRenderTargets(
_In_range_(0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT) UINT NumViews,
_In_reads_opt_(NumViews) ID3D11RenderTargetView* const* ppRenderTargetViews,
_In_opt_ ID3D11DepthStencilView* pDepthStencilView)
_In_opt_ ID3D11DepthStencilView_X* pDepthStencilView)
{
auto* depthStencilView = reinterpret_cast<ID3D11DepthStencilView*>(pDepthStencilView);
if (depthStencilView != nullptr)
depthStencilView = reinterpret_cast<ID3D11DepthStencilViewWrapper*>(pDepthStencilView)->m_realTarget;
if (ppRenderTargetViews != NULL)
{
ID3D11RenderTargetView** modifiedViews = new ID3D11RenderTargetView * [ NumViews ];
@@ -354,11 +561,11 @@ namespace d3d11x
{
modifiedViews[ i ] = reinterpret_cast<ID3D11RenderTargetViewWrapper*>(ppRenderTargetViews[ i ])->m_realTarget;
}
m_realDeviceCtx->OMSetRenderTargets(NumViews, modifiedViews, pDepthStencilView);
m_realDeviceCtx->OMSetRenderTargets(NumViews, modifiedViews, depthStencilView);
}
else
{
m_realDeviceCtx->OMSetRenderTargets(NumViews, ppRenderTargetViews, pDepthStencilView);
m_realDeviceCtx->OMSetRenderTargets(NumViews, ppRenderTargetViews, depthStencilView);
}
@@ -402,13 +609,13 @@ namespace d3d11x
virtual void STDMETHODCALLTYPE DrawIndexedInstancedIndirect(
_In_ ID3D11Buffer* pBufferForArgs,
_In_ UINT AlignedByteOffsetForArgs) {
m_realDeviceCtx->DrawIndexedInstancedIndirect(pBufferForArgs, AlignedByteOffsetForArgs);
m_realDeviceCtx->DrawIndexedInstancedIndirect(reinterpret_cast<ID3D11BufferWrapper*>(pBufferForArgs)->m_realBuffer, AlignedByteOffsetForArgs);
}
virtual void STDMETHODCALLTYPE DrawInstancedIndirect(
_In_ ID3D11Buffer* pBufferForArgs,
_In_ UINT AlignedByteOffsetForArgs) {
m_realDeviceCtx->DrawInstancedIndirect(pBufferForArgs, AlignedByteOffsetForArgs);
m_realDeviceCtx->DrawInstancedIndirect(reinterpret_cast<ID3D11BufferWrapper*>(pBufferForArgs)->m_realBuffer, AlignedByteOffsetForArgs);
}
virtual void STDMETHODCALLTYPE Dispatch(
@@ -421,7 +628,7 @@ namespace d3d11x
virtual void STDMETHODCALLTYPE DispatchIndirect(
_In_ ID3D11Buffer* pBufferForArgs,
_In_ UINT AlignedByteOffsetForArgs) {
m_realDeviceCtx->DispatchIndirect(pBufferForArgs, AlignedByteOffsetForArgs);
m_realDeviceCtx->DispatchIndirect(reinterpret_cast<ID3D11BufferWrapper*>(pBufferForArgs)->m_realBuffer, AlignedByteOffsetForArgs);
}
virtual void STDMETHODCALLTYPE RSSetState(
@@ -450,13 +657,13 @@ namespace d3d11x
_In_ ID3D11Resource* pSrcResource,
_In_ UINT SrcSubresource,
_In_opt_ const D3D11_BOX* pSrcBox) {
m_realDeviceCtx->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox);
m_realDeviceCtx->CopySubresourceRegion(reinterpret_cast<ID3D11ResourceWrapperX*>(pDstResource)->m_realResource, DstSubresource, DstX, DstY, DstZ, reinterpret_cast<ID3D11ResourceWrapperX*>(pSrcResource)->m_realResource, SrcSubresource, pSrcBox);
}
virtual void STDMETHODCALLTYPE CopyResource(
_In_ ID3D11Resource* pDstResource,
_In_ ID3D11Resource* pSrcResource) {
m_realDeviceCtx->CopyResource(pDstResource, pSrcResource);
m_realDeviceCtx->CopyResource(reinterpret_cast<ID3D11ResourceWrapperX*>(pDstResource)->m_realResource, reinterpret_cast<ID3D11ResourceWrapperX*>(pSrcResource)->m_realResource);
}
virtual void STDMETHODCALLTYPE UpdateSubresource(
@@ -466,14 +673,14 @@ namespace d3d11x
_In_ const void* pSrcData,
_In_ UINT SrcRowPitch,
_In_ UINT SrcDepthPitch) {
m_realDeviceCtx->UpdateSubresource(reinterpret_cast<ID3D11Texture2DWrapper*>(pDstResource)->m_realTexture, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch);
m_realDeviceCtx->UpdateSubresource(reinterpret_cast<ID3D11ResourceWrapperX*>(pDstResource)->m_realResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch);
}
virtual void STDMETHODCALLTYPE CopyStructureCount(
_In_ ID3D11Buffer* pDstBuffer,
_In_ UINT DstAlignedByteOffset,
_In_ ID3D11UnorderedAccessView* pSrcView) {
m_realDeviceCtx->CopyStructureCount(pDstBuffer, DstAlignedByteOffset, pSrcView);
m_realDeviceCtx->CopyStructureCount(reinterpret_cast<ID3D11BufferWrapper*>(pDstBuffer)->m_realBuffer, DstAlignedByteOffset, pSrcView);
}
virtual void STDMETHODCALLTYPE ClearRenderTargetView(
@@ -510,12 +717,12 @@ namespace d3d11x
virtual void STDMETHODCALLTYPE SetResourceMinLOD(
_In_ ID3D11Resource* pResource,
FLOAT MinLOD) {
m_realDeviceCtx->SetResourceMinLOD(pResource, MinLOD);
m_realDeviceCtx->SetResourceMinLOD(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource, MinLOD);
}
virtual FLOAT STDMETHODCALLTYPE GetResourceMinLOD(
_In_ ID3D11Resource* pResource) {
return m_realDeviceCtx->GetResourceMinLOD(pResource);
return m_realDeviceCtx->GetResourceMinLOD(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource);
}
virtual void STDMETHODCALLTYPE ResolveSubresource(
@@ -524,7 +731,7 @@ namespace d3d11x
_In_ ID3D11Resource* pSrcResource,
_In_ UINT SrcSubresource,
_In_ DXGI_FORMAT Format) {
m_realDeviceCtx->ResolveSubresource(pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format);
m_realDeviceCtx->ResolveSubresource(reinterpret_cast<ID3D11ResourceWrapperX*>(pDstResource)->m_realResource, DstSubresource, reinterpret_cast<ID3D11ResourceWrapperX*>(pSrcResource)->m_realResource, SrcSubresource, Format);
}
virtual void STDMETHODCALLTYPE ExecuteCommandList(
@@ -558,7 +765,19 @@ namespace d3d11x
_In_range_(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1) UINT StartSlot,
_In_range_(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot) UINT NumBuffers,
_In_reads_opt_(NumBuffers) ID3D11Buffer* const* ppConstantBuffers) {
m_realDeviceCtx->HSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers);
if (ppConstantBuffers != NULL)
{
ID3D11Buffer** modifiedBuffers = new ID3D11Buffer * [ NumBuffers ];
for (UINT i = 0; i < NumBuffers; ++i)
{
modifiedBuffers[ i ] = reinterpret_cast<ID3D11BufferWrapper*>(ppConstantBuffers[ i ])->m_realBuffer;
}
m_realDeviceCtx->HSSetConstantBuffers(StartSlot, NumBuffers, modifiedBuffers);
}
else
{
m_realDeviceCtx->HSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers);
}
}
virtual void STDMETHODCALLTYPE DSSetShaderResources(
@@ -586,7 +805,19 @@ namespace d3d11x
_In_range_(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1) UINT StartSlot,
_In_range_(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot) UINT NumBuffers,
_In_reads_opt_(NumBuffers) ID3D11Buffer* const* ppConstantBuffers) {
m_realDeviceCtx->DSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers);
if (ppConstantBuffers != NULL)
{
ID3D11Buffer** modifiedBuffers = new ID3D11Buffer * [ NumBuffers ];
for (UINT i = 0; i < NumBuffers; ++i)
{
modifiedBuffers[ i ] = reinterpret_cast<ID3D11BufferWrapper*>(ppConstantBuffers[ i ])->m_realBuffer;
}
m_realDeviceCtx->DSSetConstantBuffers(StartSlot, NumBuffers, modifiedBuffers);
}
else
{
m_realDeviceCtx->DSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers);
}
}
virtual void STDMETHODCALLTYPE CSSetShaderResources(
@@ -622,7 +853,19 @@ namespace d3d11x
_In_range_(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1) UINT StartSlot,
_In_range_(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot) UINT NumBuffers,
_In_reads_opt_(NumBuffers) ID3D11Buffer* const* ppConstantBuffers) {
m_realDeviceCtx->CSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers);
if (ppConstantBuffers != NULL)
{
ID3D11Buffer** modifiedBuffers = new ID3D11Buffer * [ NumBuffers ];
for (UINT i = 0; i < NumBuffers; ++i)
{
modifiedBuffers[ i ] = reinterpret_cast<ID3D11BufferWrapper*>(ppConstantBuffers[ i ])->m_realBuffer;
}
m_realDeviceCtx->CSSetConstantBuffers(StartSlot, NumBuffers, modifiedBuffers);
}
else
{
m_realDeviceCtx->CSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers);
}
}
virtual void STDMETHODCALLTYPE VSGetConstantBuffers(
@@ -924,7 +1167,7 @@ namespace d3d11x
_In_ UINT SrcSubresource,
_In_opt_ const D3D11_BOX* pSrcBox,
_In_ UINT CopyFlags) {
m_realDeviceCtx->CopySubresourceRegion1(pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox, CopyFlags);
m_realDeviceCtx->CopySubresourceRegion1(reinterpret_cast<ID3D11ResourceWrapperX*>(pDstResource)->m_realResource, DstSubresource, DstX, DstY, DstZ, reinterpret_cast<ID3D11ResourceWrapperX*>(pSrcResource)->m_realResource, SrcSubresource, pSrcBox, CopyFlags);
}
virtual void STDMETHODCALLTYPE UpdateSubresource1(
@@ -935,12 +1178,12 @@ namespace d3d11x
_In_ UINT SrcRowPitch,
_In_ UINT SrcDepthPitch,
_In_ UINT CopyFlags) {
m_realDeviceCtx->UpdateSubresource1(pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags);
m_realDeviceCtx->UpdateSubresource1(reinterpret_cast<ID3D11ResourceWrapperX*>(pDstResource)->m_realResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch, CopyFlags);
}
virtual void STDMETHODCALLTYPE DiscardResource(
_In_ ID3D11Resource* pResource) {
m_realDeviceCtx->DiscardResource(pResource);
m_realDeviceCtx->DiscardResource(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource);
}
virtual void STDMETHODCALLTYPE DiscardView(
@@ -1088,7 +1331,7 @@ namespace d3d11x
_In_reads_opt_(NumRanges) const UINT* pTilePoolStartOffsets,
_In_reads_opt_(NumRanges) const UINT* pRangeTileCounts,
_In_ UINT Flags) {
return m_realDeviceCtx->UpdateTileMappings(pTiledResource, NumTiledResourceRegions, pTiledResourceRegionStartCoordinates, pTiledResourceRegionSizes, pTilePool, NumRanges, pRangeFlags, pTilePoolStartOffsets, pRangeTileCounts, Flags);
return m_realDeviceCtx->UpdateTileMappings(reinterpret_cast<ID3D11ResourceWrapperX*>(pTiledResource)->m_realResource, NumTiledResourceRegions, pTiledResourceRegionStartCoordinates, pTiledResourceRegionSizes, pTilePool, NumRanges, pRangeFlags, pTilePoolStartOffsets, pRangeTileCounts, Flags);
}
virtual HRESULT STDMETHODCALLTYPE CopyTileMappings(
@@ -1098,7 +1341,7 @@ namespace d3d11x
_In_ const D3D11_TILED_RESOURCE_COORDINATE* pSourceRegionStartCoordinate,
_In_ const D3D11_TILE_REGION_SIZE* pTileRegionSize,
_In_ UINT Flags) {
return m_realDeviceCtx->CopyTileMappings(pDestTiledResource, pDestRegionStartCoordinate, pSourceTiledResource, pSourceRegionStartCoordinate, pTileRegionSize, Flags);
return m_realDeviceCtx->CopyTileMappings(reinterpret_cast<ID3D11ResourceWrapperX*>(pDestTiledResource)->m_realResource, pDestRegionStartCoordinate, reinterpret_cast<ID3D11ResourceWrapperX*>(pSourceTiledResource)->m_realResource, pSourceRegionStartCoordinate, pTileRegionSize, Flags);
}
virtual void STDMETHODCALLTYPE CopyTiles(
@@ -1108,7 +1351,7 @@ namespace d3d11x
_In_ ID3D11Buffer* pBuffer,
_In_ UINT64 BufferStartOffsetInBytes,
_In_ UINT Flags) {
m_realDeviceCtx->CopyTiles(pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags);
m_realDeviceCtx->CopyTiles(reinterpret_cast<ID3D11ResourceWrapperX*>(pTiledResource)->m_realResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer, BufferStartOffsetInBytes, Flags);
}
virtual void STDMETHODCALLTYPE UpdateTiles(
@@ -1117,7 +1360,7 @@ namespace d3d11x
_In_ const D3D11_TILE_REGION_SIZE* pDestTileRegionSize,
_In_ const void* pSourceTileData,
_In_ UINT Flags) {
m_realDeviceCtx->UpdateTiles(pDestTiledResource, pDestTileRegionStartCoordinate, pDestTileRegionSize, pSourceTileData, Flags);
m_realDeviceCtx->UpdateTiles(reinterpret_cast<ID3D11ResourceWrapperX*>(pDestTiledResource)->m_realResource, pDestTileRegionStartCoordinate, pDestTileRegionSize, pSourceTileData, Flags);
}
virtual HRESULT STDMETHODCALLTYPE ResizeTilePool(

60
dlls/d3d11_x/ID3DX.h
View File

@@ -7,7 +7,15 @@
namespace d3d11x
{
struct D3D11X_DESCRIPTOR_TEXTURE_VIEW
{
union
{
//__m128i Oword[ 2 ]; @Patoke todo: cannot be arsed
unsigned __int64 Qword[ 4 ];
unsigned int Dword[ 8 ];
};
};
@@ -70,6 +78,15 @@ namespace d3d11x
virtual void STDMETHODCALLTYPE GetDescriptor(D3D11X_DESCRIPTOR_RESOURCE* descriptor) PURE;
};
struct ID3D11Texture1D_X : public ID3D11Resource_X
{
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_TEXTURE1D_DESC* pDesc) PURE;
};
struct ID3D11Texture2D_X : public ID3D11Resource_X
{
@@ -79,10 +96,21 @@ namespace d3d11x
};
struct ID3D11Texture3D_X : public ID3D11Resource_X
{
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_TEXTURE3D_DESC* pDesc) PURE;
};
struct ID3D11View_X : ID3D11DeviceChild_X
{
public:
ID3D11Resource* m_pResource;
unsigned int m_Type;
virtual void STDMETHODCALLTYPE GetResource(
/* [annotation] */
_Outptr_ ID3D11Resource** ppResource) PURE;
@@ -98,6 +126,36 @@ namespace d3d11x
};
struct ID3D11DepthStencilView_X : ID3D11View_X
{
public:
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc) PURE;
};
struct ID3D11ShaderResourceView_X : ID3D11View_X
{
public:
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) PURE;
};
struct ID3D11UnorderedAccessView_X : ID3D11View_X
{
public:
D3D11X_DESCRIPTOR_TEXTURE_VIEW m_Descriptor;
void* m_pAllocationStart;
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc) PURE;
};
struct ID3D11Buffer_X : ID3D11Resource_X
{
public:

4
dlls/d3d11_x/d3d11_x.vcxproj
View File

@@ -104,8 +104,8 @@
<ClCompile Include="d3d_x\d3d11_x_device.cpp" />
<ClCompile Include="dllmain.cpp" />
<ClCompile Include="ID3D11BufferWrapper.cpp" />
<ClCompile Include="ID3D11RenderTargetViewWrapper.cpp" />
<ClCompile Include="ID3D11Texture2DWrapper.cpp" />
<ClCompile Include="ID3D11ViewWrapper.cpp" />
<ClCompile Include="ID3D11TextureWrapper.cpp" />
<ClCompile Include="ID3DWrappers.cpp" />
<ClCompile Include="IDXGI.h" />
<ClCompile Include="IDXGIAdapterWrapper.cpp" />

4
dlls/d3d11_x/d3d11_x.vcxproj.filters
View File

@@ -83,13 +83,13 @@
<ClCompile Include="IDXGIAdapterWrapper.cpp">
<Filter>Source Files\IDXGI</Filter>
</ClCompile>
<ClCompile Include="ID3D11Texture2DWrapper.cpp">
<ClCompile Include="ID3D11TextureWrapper.cpp">
<Filter>Source Files\ID3D</Filter>
</ClCompile>
<ClCompile Include="IDXGISwapChainWrapper.cpp">
<Filter>Source Files\IDXGI</Filter>
</ClCompile>
<ClCompile Include="ID3D11RenderTargetViewWrapper.cpp">
<ClCompile Include="ID3D11ViewWrapper.cpp">
<Filter>Source Files\ID3D</Filter>
</ClCompile>
<ClCompile Include="ID3DWrappers.cpp">

161
dlls/d3d11_x/d3d_x/d3d11_x_device.cpp
View File

@@ -28,8 +28,7 @@ HRESULT d3d11x::D3D11DeviceXWrapperX::QueryInterface(REFIID riid, void** ppvObje
if (riid == __uuidof(IDXGIDevice) ||
riid == __uuidof(IDXGIDevice1))
{
void** giDevice = nullptr;
HRESULT hr = m_realDevice->QueryInterface(riid, ppvObject);
HRESULT hr = m_realDevice->QueryInterface(__uuidof(IDXGIDevice1), ppvObject);
*ppvObject = new IDXGIDeviceWrapper(static_cast<IDXGIDevice1*>(*ppvObject));
return S_OK;
}
@@ -37,24 +36,105 @@ HRESULT d3d11x::D3D11DeviceXWrapperX::QueryInterface(REFIID riid, void** ppvObje
return m_realDevice->QueryInterface(riid, ppvObject);
}
HRESULT d3d11x::D3D11DeviceXWrapperX::CreateTexture1D(
const D3D11_TEXTURE1D_DESC* pDesc,
const D3D11_SUBRESOURCE_DATA* pInitialData,
ID3D11Texture1D_X** ppTexture1D) {
ID3D11Texture1D* texture1d = nullptr;
HRESULT hr = m_realDevice->CreateTexture1D(pDesc, pInitialData, &texture1d);
if (SUCCEEDED(hr))
{
*ppTexture1D = new ID3D11Texture1DWrapper(texture1d);
}
else
{
*ppTexture1D = nullptr;
}
return hr;
}
HRESULT d3d11x::D3D11DeviceXWrapperX::CreateTexture2D(
const D3D11_TEXTURE2D_DESC* pDesc,
const D3D11_SUBRESOURCE_DATA* pInitialData,
ID3D11Texture2D** ppTexture2D) {
ID3D11Texture2D_X** ppTexture2D) {
ID3D11Texture2D* texture2d = nullptr;
HRESULT hr = m_realDevice->CreateTexture2D(pDesc, pInitialData, &texture2d);
*reinterpret_cast<ID3D11Texture2D_X**>(ppTexture2D) = new ID3D11Texture2DWrapper(texture2d);
if (SUCCEEDED(hr))
{
*ppTexture2D = new ID3D11Texture2DWrapper(texture2d);
}
else
{
*ppTexture2D = nullptr;
}
return hr;
}
HRESULT d3d11x::D3D11DeviceXWrapperX::CreateTexture3D(
const D3D11_TEXTURE3D_DESC* pDesc,
const D3D11_SUBRESOURCE_DATA* pInitialData,
ID3D11Texture3D_X** ppTexture3D) {
ID3D11Texture3D* texture3d = nullptr;
HRESULT hr = m_realDevice->CreateTexture3D(pDesc, pInitialData, &texture3d);
if (SUCCEEDED(hr))
{
*ppTexture3D = new ID3D11Texture3DWrapper(texture3d);
}
else
{
*ppTexture3D = nullptr;
}
return hr;
}
HRESULT d3d11x::D3D11DeviceXWrapperX::CreateShaderResourceView(
ID3D11Resource* pResource,
const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
ID3D11ShaderResourceView** ppSRView) {
return m_realDevice->CreateShaderResourceView(reinterpret_cast<ID3D11Texture2DWrapper*>(pResource)->m_realTexture, pDesc, ppSRView);
ID3D11ShaderResourceView_X** ppSRView) {
::ID3D11ShaderResourceView* target = nullptr;
HRESULT hr = m_realDevice->CreateShaderResourceView(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource, pDesc, &target);
if (SUCCEEDED(hr))
{
*ppSRView = reinterpret_cast<ID3D11ShaderResourceView_X*>(new ID3D11ShaderResourceViewWrapper(target));
}
else
{
*ppSRView = nullptr;
}
return hr;
}
HRESULT d3d11x::D3D11DeviceXWrapperX::CreateUnorderedAccessView(
ID3D11Resource* pResource,
const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
ID3D11UnorderedAccessView_X** ppUAView) {
::ID3D11UnorderedAccessView* target = nullptr;
HRESULT hr = m_realDevice->CreateUnorderedAccessView(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource, pDesc, &target);
if (SUCCEEDED(hr))
{
*ppUAView = reinterpret_cast<ID3D11UnorderedAccessView_X*>(new ID3D11UnorderedAccessViewWrapper(target));
}
else
{
*ppUAView = nullptr;
}
return hr;
}
HRESULT d3d11x::D3D11DeviceXWrapperX::CreateRenderTargetView(
ID3D11Resource* pResource,
@@ -62,32 +142,66 @@ HRESULT d3d11x::D3D11DeviceXWrapperX::CreateRenderTargetView(
ID3D11RenderTargetView_X** ppRTView) {
::ID3D11RenderTargetView* target = nullptr;
HRESULT hr = m_realDevice->CreateRenderTargetView(reinterpret_cast<ID3D11Texture2DWrapper*>(pResource)->m_realTexture, pDesc, &target);
*ppRTView = reinterpret_cast<ID3D11RenderTargetView_X*>(new ID3D11RenderTargetViewWrapper(target));
HRESULT hr = m_realDevice->CreateRenderTargetView(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource, pDesc, &target);
if (SUCCEEDED(hr))
{
*ppRTView = reinterpret_cast<ID3D11RenderTargetView_X*>(new ID3D11RenderTargetViewWrapper(target));
}
else
{
*ppRTView = nullptr;
}
return hr;
}
HRESULT d3d11x::D3D11DeviceXWrapperX::CreateDepthStencilView(
ID3D11Resource* pResource,
const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc,
ID3D11DepthStencilView** ppDepthStencilView) {
return m_realDevice->CreateDepthStencilView(reinterpret_cast<ID3D11Texture2DWrapper*>(pResource)->m_realTexture, pDesc, ppDepthStencilView);
ID3D11DepthStencilView_X** ppDepthStencilView) {
::ID3D11DepthStencilView* target = nullptr;
HRESULT hr = m_realDevice->CreateDepthStencilView(reinterpret_cast<ID3D11ResourceWrapperX*>(pResource)->m_realResource, pDesc, &target);
if (SUCCEEDED(hr))
{
*ppDepthStencilView = reinterpret_cast<ID3D11DepthStencilView_X*>(new ID3D11DepthStencilViewWrapper(target));
}
else
{
*ppDepthStencilView = nullptr;
}
return hr;
}
void d3d11x::D3D11DeviceXWrapperX::GetImmediateContext(ID3D11DeviceContext** ppImmediateContext)
{
::ID3D11DeviceContext2* ctx;
m_realDevice->GetImmediateContext(reinterpret_cast<::ID3D11DeviceContext**>(&ctx));
*ppImmediateContext = reinterpret_cast<d3d11x::ID3D11DeviceContext*>(new d3d11x::ID3D11DeviceContextXWrapper(ctx));
::ID3D11DeviceContext* ctx{};
m_realDevice->GetImmediateContext(&ctx);
if(ctx)
{
::ID3D11DeviceContext2* ctx2{};
ctx->QueryInterface(IID_PPV_ARGS(&ctx2));
*ppImmediateContext = reinterpret_cast<d3d11x::ID3D11DeviceContext*>(new d3d11x::ID3D11DeviceContextXWrapper(ctx2));
}
}
HRESULT d3d11x::D3D11DeviceXWrapperX::CreateDeferredContext(UINT ContextFlags, d3d11x::ID3D11DeviceContext** ppDeferredContext)
{
::ID3D11DeviceContext2* cxt2{};
HRESULT hr = m_realDevice->CreateDeferredContext(ContextFlags, (::ID3D11DeviceContext**) & cxt2);
// (*ppDeferredContext)->QueryInterface(IID_PPV_ARGS(&cxt2));
*ppDeferredContext = reinterpret_cast<d3d11x::ID3D11DeviceContext*>(new d3d11x::ID3D11DeviceContextXWrapper(cxt2));
::ID3D11DeviceContext* ctx{};
HRESULT hr = m_realDevice->CreateDeferredContext(ContextFlags, &ctx);
if(SUCCEEDED(hr))
{
::ID3D11DeviceContext2* ctx2{};
ctx->QueryInterface(IID_PPV_ARGS(&ctx2));
*ppDeferredContext = reinterpret_cast<d3d11x::ID3D11DeviceContext*>(new d3d11x::ID3D11DeviceContextXWrapper(ctx2));
}
return hr;
}
@@ -101,7 +215,16 @@ HRESULT d3d11x::D3D11DeviceXWrapperX::CreateBuffer(
ID3D11Buffer* buffer = nullptr;
HRESULT hr = m_realDevice->CreateBuffer(pDesc, pInitialData, &buffer);
*reinterpret_cast<ID3D11Buffer_X**>(ppBuffer) = new ID3D11BufferWrapper(buffer);
if (SUCCEEDED(hr))
{
*ppBuffer = new ID3D11BufferWrapper(buffer);
}
else
{
*ppBuffer = nullptr;
}
return hr;
}

39
dlls/d3d11_x/d3d_x/d3d11_x_device.h
View File

@@ -94,12 +94,21 @@ namespace d3d11x
IUnknown* m_pUnknown;
};
// Wrappers
class ID3D11Buffer_X;
class ID3D11BufferWrapper;
class ID3D11RenderTargetView_X;
class ID3D11UnorderedAccessView_X;
class ID3D11ShaderResourceView_X;
class ID3D11DepthStencilView_X;
class ID3D11RenderTargetViewWrapper;
class IDXGIDeviceWrapper;
class ID3D11Texture2DWrapper;
class ID3D11Texture1D_X;
class ID3D11Texture2D_X;
class ID3D11Texture3D_X;
// D3D11.X forward declarations
class IGraphicsUnknown;
class ID3D11DeviceContext;
class ID3D11DeviceContextX;
@@ -138,23 +147,23 @@ namespace d3d11x
virtual HRESULT CreateTexture1D(_In_ const D3D11_TEXTURE1D_DESC* pDesc,
_In_reads_opt_(_Inexpressible_(pDesc->MipLevels* pDesc->ArraySize)) const D3D11_SUBRESOURCE_DATA* pInitialData,
_Out_opt_ ID3D11Texture1D** ppTexture1D) = 0;
_Out_opt_ ID3D11Texture1D_X** ppTexture1D) = 0;
virtual HRESULT CreateTexture2D(_In_ const D3D11_TEXTURE2D_DESC* pDesc,
_In_reads_opt_(_Inexpressible_(pDesc->MipLevels* pDesc->ArraySize)) const D3D11_SUBRESOURCE_DATA* pInitialData,
_Out_opt_ ID3D11Texture2D** ppTexture2D) = 0;
_Out_opt_ ID3D11Texture2D_X** ppTexture2D) = 0;
virtual HRESULT CreateTexture3D(_In_ const D3D11_TEXTURE3D_DESC* pDesc,
_In_reads_opt_(_Inexpressible_(pDesc->MipLevels)) const D3D11_SUBRESOURCE_DATA* pInitialData,
_Out_opt_ ID3D11Texture3D** ppTexture3D) = 0;
_Out_opt_ ID3D11Texture3D_X** ppTexture3D) = 0;
virtual HRESULT CreateShaderResourceView(_In_ ID3D11Resource* pResource,
_In_opt_ const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
_Out_opt_ ID3D11ShaderResourceView** ppSRView) = 0;
_Out_opt_ ID3D11ShaderResourceView_X** ppSRView) = 0;
virtual HRESULT CreateUnorderedAccessView(_In_ ID3D11Resource* pResource,
_In_opt_ const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
_Out_opt_ ID3D11UnorderedAccessView** ppUAView) = 0;
_Out_opt_ ID3D11UnorderedAccessView_X** ppUAView) = 0;
virtual HRESULT CreateRenderTargetView(_In_ ID3D11Resource* pResource,
_In_opt_ const D3D11_RENDER_TARGET_VIEW_DESC* pDesc,
@@ -163,7 +172,7 @@ namespace d3d11x
virtual HRESULT CreateDepthStencilView(
_In_ ID3D11Resource* pResource,
_In_opt_ const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc,
_Out_opt_ ID3D11DepthStencilView** ppDepthStencilView) = 0;
_Out_opt_ ID3D11DepthStencilView_X** ppDepthStencilView) = 0;
virtual HRESULT CreateInputLayout(
_In_reads_(NumElements) const D3D11_INPUT_ELEMENT_DESC * pInputElementDescs,
@@ -453,33 +462,27 @@ namespace d3d11x
HRESULT CreateTexture1D(
const D3D11_TEXTURE1D_DESC* pDesc,
const D3D11_SUBRESOURCE_DATA* pInitialData,
ID3D11Texture1D** ppTexture1D) override {
return m_realDevice->CreateTexture1D(pDesc, pInitialData, ppTexture1D);
}
ID3D11Texture1D_X** ppTexture1D) override;
HRESULT CreateTexture2D(
const D3D11_TEXTURE2D_DESC* pDesc,
const D3D11_SUBRESOURCE_DATA* pInitialData,
ID3D11Texture2D** ppTexture2D) override;
ID3D11Texture2D_X** ppTexture2D) override;
HRESULT CreateTexture3D(
const D3D11_TEXTURE3D_DESC* pDesc,
const D3D11_SUBRESOURCE_DATA* pInitialData,
ID3D11Texture3D** ppTexture3D) override {
return m_realDevice->CreateTexture3D(pDesc, pInitialData, ppTexture3D);
}
ID3D11Texture3D_X** ppTexture3D) override;
HRESULT CreateShaderResourceView(
ID3D11Resource* pResource,
const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
ID3D11ShaderResourceView** ppSRView) override;
ID3D11ShaderResourceView_X** ppSRView) override;
HRESULT CreateUnorderedAccessView(
ID3D11Resource* pResource,
const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
ID3D11UnorderedAccessView** ppUAView) override {
return m_realDevice->CreateUnorderedAccessView(pResource, pDesc, ppUAView);
}
ID3D11UnorderedAccessView_X** ppUAView) override;
HRESULT CreateRenderTargetView(ID3D11Resource* pResource,
const D3D11_RENDER_TARGET_VIEW_DESC* pDesc,
@@ -488,7 +491,7 @@ namespace d3d11x
HRESULT CreateDepthStencilView(
ID3D11Resource* pResource,
const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc,
ID3D11DepthStencilView** ppDepthStencilView) override;
ID3D11DepthStencilView_X** ppDepthStencilView) override;
HRESULT CreateInputLayout(
const D3D11_INPUT_ELEMENT_DESC* pInputElementDescs,