Forza Horizon 2 renders!

This commit is contained in:
Rodrigo Todescatto
2025-04-01 18:54:33 -03:00
parent 668ae0e680
commit 0fe40cd4c1
11 changed files with 553 additions and 277 deletions
+72
View File
@@ -0,0 +1,72 @@
#include "device_child_x.h"
namespace wdi
{
D3DINTERFACE(ID3D11BlendState, 75b68faa, 347d, 4159, 8f, 45, a0, 64, 0f, 01, cd, 9a) : public ID3D11DeviceChild
{
public:
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_BLEND_DESC* pDesc) PURE;
};
}
namespace wd
{
class blend_state : public wdi::ID3D11BlendState
{
public:
blend_state(::ID3D11BlendState* blendState) : wrapped_interface(blendState)
{
wrapped_interface->AddRef( );
}
IGU_DEFINE_REF
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
{
if (riid == __uuidof(wdi::ID3D11BlendState))
{
*ppvObject = this;
AddRef( );
return S_OK;
}
TRACE_INTERFACE_NOT_HANDLED("blend_state");
*ppvObject = nullptr;
return E_NOINTERFACE;
}
void STDMETHODCALLTYPE GetDesc(D3D11_BLEND_DESC* pDesc) override
{
wrapped_interface->GetDesc(pDesc);
}
void GetDevice(ID3D11Device** ppDevice) override
{
printf("WARN: texture_2d::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override
{
TRACE_NOT_IMPLEMENTED("blend_state");
return E_NOTIMPL;
}
::ID3D11BlendState *wrapped_interface;
};
}
+1 -3
View File
@@ -215,9 +215,7 @@ HRESULT __stdcall D3DFreeGraphicsMemory_X(void* pAddress)
}
HRESULT __stdcall D3DMapEsramMemory_X(UINT Flags, VOID* pVirtualAddress, UINT NumPages, const UINT* pPageList)
{
printf("D3DMapEsramMemory_X was called!!!\n");
{
//Rodrigo Todescatto: This will allocate 4mb of RAM as a stub.
VirtualAlloc(pVirtualAddress, 0x3D0900, MEM_COMMIT, PAGE_READWRITE);
+2
View File
@@ -107,6 +107,7 @@
<ClCompile Include="device_child_x.cpp" />
<ClCompile Include="device_context_x.cpp" />
<ClCompile Include="device_x.cpp" />
<ClCompile Include="view.cpp" />
<ClCompile Include="XGUIDs.cpp" />
<ClCompile Include="dllmain.cpp" />
<ClCompile Include="dma_engine.cpp" />
@@ -127,6 +128,7 @@
<ClInclude Include="..\..\thirdparty\imgui\imstb_textedit.h" />
<ClInclude Include="..\..\thirdparty\imgui\imstb_truetype.h" />
<ClInclude Include="..\..\thirdparty\imgui_impl_uwp.h" />
<ClInclude Include="Blend.hpp" />
<ClInclude Include="d3d11_x.h" />
<ClInclude Include="device_child_x.h" />
<ClInclude Include="device_context_x.h" />
+6
View File
@@ -60,6 +60,9 @@
<ClCompile Include="dma_engine.cpp">
<Filter>wrappers\dma_engine</Filter>
</ClCompile>
<ClCompile Include="view.cpp">
<Filter>wrappers\shared</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="d3d11_x.h" />
@@ -129,6 +132,9 @@
<ClInclude Include="dma_engine.h">
<Filter>wrappers\dma_engine</Filter>
</ClInclude>
<ClInclude Include="Blend.hpp">
<Filter>wrappers\shared</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="Exports.def" />
-1
View File
@@ -1,7 +1,6 @@
#pragma once
#include <cassert>
#include <exception>
#include "d3d11_x.h"
#include "graphics_unknown.h"
+121 -53
View File
@@ -1,9 +1,8 @@
#include <d3d11_1.h>
#include <d3d11_2.h>
#include "view.hpp"
#include "device_context_x.h"
#include <stdexcept>
#include "view.hpp"
#include <vector>
void wd::device_context_x::GetDevice(ID3D11Device** ppDevice)
@@ -336,46 +335,73 @@ void wd::device_context_x::GSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D1
wrapped_interface->GSSetSamplers(StartSlot, NumSamplers, ppSamplers);
}
void wd::device_context_x::OMSetRenderTargets(UINT NumViews, ID3D11RenderTargetView* const* ppRenderTargetViews,
ID3D11DepthStencilView* pDepthStencilView)
void wd::device_context_x::OMSetRenderTargets(UINT NumViews, wdi::ID3D11RenderTargetView* const* ppRenderTargetViews,
wdi::ID3D11DepthStencilView* pDepthStencilView)
{
//printf("OMSetRenderTargets was called!!!!!!!\n");
auto* depthStencilView = pDepthStencilView;
if (depthStencilView != nullptr)
depthStencilView = reinterpret_cast<depth_stencil_view*>(pDepthStencilView)->wrapped_interface;
if (ppRenderTargetViews != NULL)
ID3D11DepthStencilView* depthStencilView = nullptr;
ID3D11RenderTargetView* modifiedViews[ D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT ] = {};
if (pDepthStencilView != nullptr)
{
depthStencilView = reinterpret_cast<depth_stencil_view*>(pDepthStencilView)->wrapped_interface;
}
if (ppRenderTargetViews != nullptr)
{
ID3D11RenderTargetView* modifiedViews[ D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT ];
for (UINT i = 0; i < NumViews; i++)
{
if (ppRenderTargetViews[ i ] == nullptr)
modifiedViews[ i ] = nullptr;
modifiedViews[ i ] = 0;
else
modifiedViews[ i ] = reinterpret_cast<render_target_view*>(ppRenderTargetViews[ i ])->wrapped_interface;
modifiedViews[ i ] = reinterpret_cast<wd::render_target_view*>(ppRenderTargetViews[ i ])->wrapped_interface;
}
wrapped_interface->OMSetRenderTargets(NumViews, modifiedViews, depthStencilView);
}
else
{
wrapped_interface->OMSetRenderTargets(NumViews, ppRenderTargetViews, depthStencilView);
}
wrapped_interface->OMSetRenderTargets(NumViews, modifiedViews, pDepthStencilView ? depthStencilView : nullptr);
}
void wd::device_context_x::OMSetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs,
ID3D11RenderTargetView* const* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView, UINT UAVStartSlot,
UINT NumUAVs, ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts)
wdi::ID3D11RenderTargetView* const* ppRenderTargetViews, wdi::ID3D11DepthStencilView* pDepthStencilView, UINT UAVStartSlot,
UINT NumUAVs, wdi::ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts)
{
//printf("OMSetRenderTargetsAndUnorderedAccessViews was called!!!!!!!\n");
wrapped_interface->OMSetRenderTargetsAndUnorderedAccessViews(NumRTVs, ppRenderTargetViews, pDepthStencilView,
UAVStartSlot, NumUAVs, ppUnorderedAccessViews,
ID3D11DepthStencilView* depthStencilView = nullptr;
if (depthStencilView != nullptr)
depthStencilView = reinterpret_cast<depth_stencil_view*>(pDepthStencilView)->wrapped_interface;
ID3D11UnorderedAccessView* unorderedAccessViews[ D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT ];
ID3D11RenderTargetView* modifiedViews[ D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT ];
for (UINT i = 0; i < NumUAVs; i++)
{
if (ppRenderTargetViews[ i ] == nullptr)
modifiedViews[ i ] = 0;
else
modifiedViews[ i ] = reinterpret_cast<render_target_view*>(ppRenderTargetViews[ i ])->wrapped_interface;
if (ppUnorderedAccessViews[ i ] == nullptr)
unorderedAccessViews[ i ] = 0;
else
unorderedAccessViews[ i ] = reinterpret_cast<unordered_access_view*>(ppUnorderedAccessViews[ i ])->wrapped_interface;
}
wrapped_interface->OMSetRenderTargetsAndUnorderedAccessViews(NumRTVs, modifiedViews, depthStencilView,
UAVStartSlot, NumUAVs, unorderedAccessViews,
pUAVInitialCounts);
}
void wd::device_context_x::OMSetBlendState(ID3D11BlendState* pBlendState, const FLOAT BlendFactor[4], UINT SampleMask)
void wd::device_context_x::OMSetBlendState(wdi::ID3D11BlendState* pBlendState, const FLOAT BlendFactor[4], UINT SampleMask)
{
//printf("OMSetBlendState was called!!!!!!!\n");
wrapped_interface->OMSetBlendState(pBlendState, BlendFactor, SampleMask);
ID3D11BlendState* blendState = nullptr;
if (pBlendState != nullptr)
{
blendState = reinterpret_cast<blend_state*>(pBlendState)->wrapped_interface;
}
wrapped_interface->OMSetBlendState(blendState, BlendFactor, SampleMask);
}
void wd::device_context_x::OMSetDepthStencilState(ID3D11DepthStencilState* pDepthStencilState, UINT StencilRef)
@@ -451,32 +477,32 @@ void wd::device_context_x::UpdateSubresource(ID3D11Resource* pDstResource, UINT
}
void wd::device_context_x::CopyStructureCount(ID3D11Buffer* pDstBuffer, UINT DstAlignedByteOffset,
ID3D11UnorderedAccessView* pSrcView)
wdi::ID3D11UnorderedAccessView* pSrcView)
{
wrapped_interface->CopyStructureCount(pDstBuffer, DstAlignedByteOffset, pSrcView);
wrapped_interface->CopyStructureCount(pDstBuffer, DstAlignedByteOffset, reinterpret_cast<wd::unordered_access_view*>(pSrcView)->wrapped_interface);
}
void wd::device_context_x::ClearRenderTargetView(ID3D11RenderTargetView* pRenderTargetView, const FLOAT ColorRGBA[4])
void wd::device_context_x::ClearRenderTargetView(wdi::ID3D11RenderTargetView* pRenderTargetView, const FLOAT ColorRGBA[4])
{
wrapped_interface->ClearRenderTargetView(reinterpret_cast<wd::render_target_view*>(pRenderTargetView)->wrapped_interface, ColorRGBA);
}
void wd::device_context_x::ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUnorderedAccessView,
void wd::device_context_x::ClearUnorderedAccessViewUint(wdi::ID3D11UnorderedAccessView* pUnorderedAccessView,
const UINT Values[4])
{
wrapped_interface->ClearUnorderedAccessViewUint(pUnorderedAccessView, Values);
wrapped_interface->ClearUnorderedAccessViewUint(reinterpret_cast<wd::unordered_access_view*>(pUnorderedAccessView)->wrapped_interface, Values);
}
void wd::device_context_x::ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUnorderedAccessView,
void wd::device_context_x::ClearUnorderedAccessViewFloat(wdi::ID3D11UnorderedAccessView* pUnorderedAccessView,
const FLOAT Values[4])
{
wrapped_interface->ClearUnorderedAccessViewFloat(pUnorderedAccessView, Values);
wrapped_interface->ClearUnorderedAccessViewFloat(reinterpret_cast<wd::unordered_access_view*>(pUnorderedAccessView)->wrapped_interface, Values);
}
void wd::device_context_x::ClearDepthStencilView(ID3D11DepthStencilView* pDepthStencilView, UINT ClearFlags,
void wd::device_context_x::ClearDepthStencilView(wdi::ID3D11DepthStencilView* pDepthStencilView, UINT ClearFlags,
FLOAT Depth, UINT8 Stencil)
{
//wrapped_interface->ClearDepthStencilView(reinterpret_cast<wd::depth_stencil_view*>(pDepthStencilView)->wrapped_interface, ClearFlags, Depth, Stencil);
//wrapped_interface->ClearDepthStencilView(reinterpret_cast<depth_stencil_view*>(pDepthStencilView)->wrapped_interface, ClearFlags, Depth, Stencil);
}
void wd::device_context_x::GenerateMips(ID3D11ShaderResourceView* pShaderResourceView)
@@ -549,9 +575,9 @@ void wd::device_context_x::DSSetConstantBuffers(UINT StartSlot, UINT NumBuffers,
}
void wd::device_context_x::CSSetUnorderedAccessViews(UINT StartSlot, UINT NumUAVs,
ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts)
wdi::ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts)
{
wrapped_interface->CSSetUnorderedAccessViews(StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts);
//wrapped_interface->CSSetUnorderedAccessViews(StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts);
}
void wd::device_context_x::CSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers)
@@ -729,39 +755,72 @@ void wd::device_context_x::GSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D1
wrapped_interface->GSGetSamplers(StartSlot, NumSamplers, ppSamplers);
}
void wd::device_context_x::OMGetRenderTargets(UINT NumViews, ID3D11RenderTargetView** ppRenderTargetViews,
ID3D11DepthStencilView** ppDepthStencilView)
void wd::device_context_x::OMGetRenderTargets(
UINT NumViews,
wdi::ID3D11RenderTargetView** ppRenderTargetViews,
wdi::ID3D11DepthStencilView** ppDepthStencilView)
{
/*ID3D11DepthStencilView* pDepthStencilView = nullptr;
ID3D11DepthStencilView* pDepthStencilView = nullptr;
ID3D11RenderTargetView* RenderTargetViews[ D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT ] = {};
wrapped_interface->OMGetRenderTargets(NumViews, RenderTargetViews, ppDepthStencilView ? &pDepthStencilView : nullptr);
if (ppRenderTargetViews != nullptr)
{
for (UINT i = 0; i < NumViews; i++)
{
ppRenderTargetViews[i] = reinterpret_cast<ID3D11RenderTargetView*>(new render_target_view(RenderTargetViews[i]));
ppRenderTargetViews[ i ] = RenderTargetViews[ i ] ? new render_target_view(RenderTargetViews[ i ]) : nullptr;
}
}
if (ppDepthStencilView != nullptr)
{
*ppDepthStencilView = ppDepthStencilView ? reinterpret_cast<ID3D11DepthStencilView*>(new depth_stencil_view(pDepthStencilView)) : nullptr;
}*/
*ppDepthStencilView = pDepthStencilView ? new depth_stencil_view(pDepthStencilView) : nullptr;
}
}
void wd::device_context_x::OMGetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs,
ID3D11RenderTargetView** ppRenderTargetViews, ID3D11DepthStencilView** ppDepthStencilView, UINT UAVStartSlot,
UINT NumUAVs, ID3D11UnorderedAccessView** ppUnorderedAccessViews)
wdi::ID3D11RenderTargetView** ppRenderTargetViews, wdi::ID3D11DepthStencilView** ppDepthStencilView, UINT UAVStartSlot,
UINT NumUAVs, wdi::ID3D11UnorderedAccessView** ppUnorderedAccessViews)
{
wrapped_interface->OMGetRenderTargetsAndUnorderedAccessViews(NumRTVs, ppRenderTargetViews, ppDepthStencilView,
UAVStartSlot, NumUAVs, ppUnorderedAccessViews);
ID3D11DepthStencilView* pDepthStencilView = nullptr;
ID3D11RenderTargetView* RenderTargetViews[ D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT ] = {};
ID3D11UnorderedAccessView* unorderedAccessViews[ 8 ] = {};
wrapped_interface->OMGetRenderTargetsAndUnorderedAccessViews(NumRTVs, RenderTargetViews, ppDepthStencilView ? &pDepthStencilView : nullptr,
UAVStartSlot, NumUAVs, unorderedAccessViews);
if (RenderTargetViews != nullptr)
{
for (UINT i = 0; i < NumUAVs; i++)
{
ppRenderTargetViews[ i ] = new render_target_view(RenderTargetViews[ i ]);
}
}
if (unorderedAccessViews != nullptr)
{
for (UINT i = 0; i < NumUAVs; i++)
{
ppUnorderedAccessViews[ i ] = new unordered_access_view(unorderedAccessViews[ i ]);
}
}
if (pDepthStencilView != nullptr)
{
*ppDepthStencilView = pDepthStencilView ? new depth_stencil_view(pDepthStencilView) : nullptr;
}
}
void wd::device_context_x::OMGetBlendState(ID3D11BlendState** ppBlendState, FLOAT BlendFactor[4], UINT* pSampleMask)
void wd::device_context_x::OMGetBlendState(wdi::ID3D11BlendState** ppBlendState, FLOAT BlendFactor[4], UINT* pSampleMask)
{
wrapped_interface->OMGetBlendState(ppBlendState, BlendFactor, pSampleMask);
ID3D11BlendState* blendState;
wrapped_interface->OMGetBlendState(&blendState, BlendFactor, pSampleMask);
if (ppBlendState != nullptr)
{
*ppBlendState = blendState ? new blend_state(blendState) : nullptr;
}
}
void wd::device_context_x::OMGetDepthStencilState(ID3D11DepthStencilState** ppDepthStencilState, UINT* pStencilRef)
@@ -840,9 +899,18 @@ void wd::device_context_x::CSGetShaderResources(UINT StartSlot, UINT NumViews,
}
void wd::device_context_x::CSGetUnorderedAccessViews(UINT StartSlot, UINT NumUAVs,
ID3D11UnorderedAccessView** ppUnorderedAccessViews)
wdi::ID3D11UnorderedAccessView** ppUnorderedAccessViews)
{
wrapped_interface->CSGetUnorderedAccessViews(StartSlot, NumUAVs, ppUnorderedAccessViews);
ID3D11UnorderedAccessView* unorderedAccessViews[ 8 ] = {};
wrapped_interface->CSGetUnorderedAccessViews(StartSlot, NumUAVs, unorderedAccessViews);
if (unorderedAccessViews != nullptr)
{
for (UINT i = 0; i < NumUAVs; i++)
{
ppUnorderedAccessViews[ i ] = new unordered_access_view(unorderedAccessViews[ i ]);
}
}
}
void wd::device_context_x::CSGetShader(ID3D11ComputeShader** ppComputeShader, ID3D11ClassInstance** ppClassInstances,
@@ -1137,7 +1205,7 @@ void wd::device_context_x::FlushGpuCaches(ID3D11Resource* pResource)
void wd::device_context_x::FlushGpuCacheRange(UINT Flags, void* pBaseAddress, SIZE_T SizeInBytes)
{
throw std::logic_error("Not implemented");
}
void wd::device_context_x::InsertWaitUntilIdle(UINT Flags)
@@ -1375,7 +1443,7 @@ void wd::device_context_x::CSEnableAutomaticGpuFlush(BOOL Enable)
void wd::device_context_x::GpuSendPipelinedEvent(wdi::D3D11X_GPU_PIPELINED_EVENT Event)
{
throw std::logic_error("Not implemented");
}
HRESULT wd::device_context_x::Suspend(UINT Flags)
@@ -1515,7 +1583,7 @@ void wd::device_context_x::InsertWaitOnPresent(UINT Flags, ID3D11Resource* pBack
throw std::logic_error("Not implemented");
}
void wd::device_context_x::ClearRenderTargetViewX(ID3D11RenderTargetView* pRenderTargetView, UINT Flags,
void wd::device_context_x::ClearRenderTargetViewX(wdi::ID3D11RenderTargetView* pRenderTargetView, UINT Flags,
const FLOAT ColorRGBA[4])
{
throw std::logic_error("Not implemented");
+25 -22
View File
@@ -1,9 +1,9 @@
#pragma once
#include <array>
#include <map>
#include "device_child_x.h"
#include "device_x.h"
#include "blend.hpp"
static std::map<UINT64, int> D3D11X_HARDWARE_TO_TOPOLOGY_MAP = {
{0x000001ffc0009e00, 0}, {0x000003ffc0009e00, 1}, {0x000005ffc0009e00, 2}, {0x000007ffc0009e00, 3},
@@ -27,6 +27,9 @@ static std::map<UINT64, int> D3D11X_HARDWARE_TO_TOPOLOGY_MAP = {
namespace wdi
{
class ID3D11RenderTargetView;
class ID3D11DepthStencilView;
class ID3D11UnorderedAccessView;
#pragma region struct_defs
typedef enum _D3D11X_GDS_REGION_TYPE
@@ -340,7 +343,7 @@ namespace wdi
virtual void (GetPredication)(_Out_opt_ ID3D11Predicate** ppPredicate,_Out_opt_ BOOL* pPredicateValue) = 0;
virtual void (GSGetShaderResources)(_In_range_(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1) UINT StartSlot,_In_range_(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot) UINT NumViews,_Out_writes_opt_(NumViews) ID3D11ShaderResourceView** ppShaderResourceViews) = 0;
virtual void (GSGetSamplers)(_In_range_(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1) UINT StartSlot,_In_range_(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot) UINT NumSamplers,_Out_writes_opt_(NumSamplers) ID3D11SamplerState** ppSamplers) = 0;
virtual void (OMGetRenderTargets)(_In_range_(0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT) UINT NumViews,_Out_writes_opt_(NumViews) ID3D11RenderTargetView** ppRenderTargetViews,_Out_opt_ ID3D11DepthStencilView** ppDepthStencilView) = 0;
virtual void (OMGetRenderTargets)(_In_range_(0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT) UINT NumViews,_Out_writes_opt_(NumViews) wdi::ID3D11RenderTargetView** ppRenderTargetViews,_Out_opt_ ID3D11DepthStencilView** ppDepthStencilView) = 0;
virtual void (OMGetRenderTargetsAndUnorderedAccessViews)(_In_range_(0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT) UINT NumRTVs,_Out_writes_opt_(NumRTVs) ID3D11RenderTargetView** ppRenderTargetViews,_Out_opt_ ID3D11DepthStencilView** ppDepthStencilView,_In_range_(0, D3D11_PS_CS_UAV_REGISTER_COUNT - 1) UINT UAVStartSlot,_In_range_(0, D3D11_PS_CS_UAV_REGISTER_COUNT - UAVStartSlot) UINT NumUAVs,_Out_writes_opt_(NumUAVs) ID3D11UnorderedAccessView** ppUnorderedAccessViews) = 0;
virtual void (OMGetBlendState)(_Out_opt_ ID3D11BlendState** ppBlendState,_Out_writes_all_opt_(4) FLOAT BlendFactor[ 4 ],_Out_opt_ UINT* pSampleMask) = 0;
virtual void (OMGetDepthStencilState)(_Out_opt_ ID3D11DepthStencilState** ppDepthStencilState,_Out_opt_ UINT* pStencilRef) = 0;
@@ -729,12 +732,12 @@ namespace wd
HRESULT GetData(ID3D11Asynchronous* pAsync, void* pData, UINT DataSize, UINT GetDataFlags) override;
void SetPredication(ID3D11Predicate* pPredicate, BOOL PredicateValue) override;
void GSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers) override;
void OMSetRenderTargets(UINT NumViews, ID3D11RenderTargetView* const* ppRenderTargetViews,
ID3D11DepthStencilView* pDepthStencilView) override;
void OMSetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs, ID3D11RenderTargetView* const* ppRenderTargetViews,
ID3D11DepthStencilView* pDepthStencilView, UINT UAVStartSlot, UINT NumUAVs,
ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts) override;
void OMSetBlendState(ID3D11BlendState* pBlendState, const FLOAT BlendFactor[4], UINT SampleMask) override;
void OMSetRenderTargets(UINT NumViews, wdi::ID3D11RenderTargetView* const* ppRenderTargetViews,
wdi::ID3D11DepthStencilView* pDepthStencilView) override;
void OMSetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs, wdi::ID3D11RenderTargetView* const* ppRenderTargetViews,
wdi::ID3D11DepthStencilView* pDepthStencilView, UINT UAVStartSlot, UINT NumUAVs,
wdi::ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts) override;
void OMSetBlendState(wdi::ID3D11BlendState* pBlendState, const FLOAT BlendFactor[4], UINT SampleMask) override;
void OMSetDepthStencilState(ID3D11DepthStencilState* pDepthStencilState, UINT StencilRef) override;
void SOSetTargets(UINT NumBuffers, ID3D11Buffer* const* ppSOTargets, const UINT* pOffsets) override;
void DrawIndexedInstancedIndirect(ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs) override;
@@ -750,13 +753,13 @@ namespace wd
void UpdateSubresource(ID3D11Resource* pDstResource, UINT DstSubresource, const D3D11_BOX* pDstBox,
const void* pSrcData, UINT SrcRowPitch, UINT SrcDepthPitch) override;
void CopyStructureCount(ID3D11Buffer* pDstBuffer, UINT DstAlignedByteOffset,
ID3D11UnorderedAccessView* pSrcView) override;
void ClearRenderTargetView(ID3D11RenderTargetView* pRenderTargetView, const FLOAT ColorRGBA[4]) override;
void ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUnorderedAccessView,
wdi::ID3D11UnorderedAccessView* pSrcView) override;
void ClearRenderTargetView(wdi::ID3D11RenderTargetView* pRenderTargetView, const FLOAT ColorRGBA[4]) override;
void ClearUnorderedAccessViewUint(wdi::ID3D11UnorderedAccessView* pUnorderedAccessView,
const UINT Values[4]) override;
void ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUnorderedAccessView,
void ClearUnorderedAccessViewFloat(wdi::ID3D11UnorderedAccessView* pUnorderedAccessView,
const FLOAT Values[4]) override;
void ClearDepthStencilView(ID3D11DepthStencilView* pDepthStencilView, UINT ClearFlags, FLOAT Depth,
void ClearDepthStencilView(wdi::ID3D11DepthStencilView* pDepthStencilView, UINT ClearFlags, FLOAT Depth,
UINT8 Stencil) override;
void GenerateMips(ID3D11ShaderResourceView* pShaderResourceView) override;
void SetResourceMinLOD(ID3D11Resource* pResource, FLOAT MinLOD) override;
@@ -769,7 +772,7 @@ namespace wd
void DSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers) override;
void DSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers) override;
void CSSetUnorderedAccessViews(UINT StartSlot, UINT NumUAVs,
ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts) override;
wdi::ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts) override;
void CSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers) override;
void CSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers) override;
void VSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers) override;
@@ -796,12 +799,12 @@ namespace wd
void GSGetShaderResources(UINT StartSlot, UINT NumViews,
ID3D11ShaderResourceView** ppShaderResourceViews) override;
void GSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers) override;
void OMGetRenderTargets(UINT NumViews, ID3D11RenderTargetView** ppRenderTargetViews,
ID3D11DepthStencilView** ppDepthStencilView) override;
void OMGetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs, ID3D11RenderTargetView** ppRenderTargetViews,
ID3D11DepthStencilView** ppDepthStencilView, UINT UAVStartSlot, UINT NumUAVs,
ID3D11UnorderedAccessView** ppUnorderedAccessViews) override;
void OMGetBlendState(ID3D11BlendState** ppBlendState, FLOAT BlendFactor[4], UINT* pSampleMask) override;
void OMGetRenderTargets(UINT NumViews, wdi::ID3D11RenderTargetView** ppRenderTargetViews,
wdi::ID3D11DepthStencilView** ppDepthStencilView) override;
void OMGetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs, wdi::ID3D11RenderTargetView** ppRenderTargetViews,
wdi::ID3D11DepthStencilView** ppDepthStencilView, UINT UAVStartSlot, UINT NumUAVs,
wdi::ID3D11UnorderedAccessView** ppUnorderedAccessViews) override;
void OMGetBlendState(wdi::ID3D11BlendState** ppBlendState, FLOAT BlendFactor[4], UINT* pSampleMask) override;
void OMGetDepthStencilState(ID3D11DepthStencilState** ppDepthStencilState, UINT* pStencilRef) override;
void SOGetTargets(UINT NumBuffers, ID3D11Buffer** ppSOTargets) override;
void RSGetState(ID3D11RasterizerState** ppRasterizerState) override;
@@ -822,7 +825,7 @@ namespace wd
void CSGetShaderResources(UINT StartSlot, UINT NumViews,
ID3D11ShaderResourceView** ppShaderResourceViews) override;
void CSGetUnorderedAccessViews(UINT StartSlot, UINT NumUAVs,
ID3D11UnorderedAccessView** ppUnorderedAccessViews) override;
wdi::ID3D11UnorderedAccessView** ppUnorderedAccessViews) override;
void CSGetShader(ID3D11ComputeShader** ppComputeShader, ID3D11ClassInstance** ppClassInstances,
UINT* pNumClassInstances) override;
void CSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers) override;
@@ -989,7 +992,7 @@ namespace wd
void IASetPrimitiveResetIndex(UINT ResetIndex) override;
void SetShaderResourceViewMinLOD(ID3D11ShaderResourceView* pShaderResourceView, FLOAT MinLOD) override;
void InsertWaitOnPresent(UINT Flags, ID3D11Resource* pBackBuffer) override;
void ClearRenderTargetViewX(ID3D11RenderTargetView* pRenderTargetView, UINT Flags,
void ClearRenderTargetViewX(wdi::ID3D11RenderTargetView* pRenderTargetView, UINT Flags,
const FLOAT ColorRGBA[4]) override;
UINT GetResourceCompression(ID3D11Resource* pResource) override;
UINT GetResourceCompressionX(const wdi::D3D11X_DESCRIPTOR_RESOURCE* pResource) override;
+67 -24
View File
@@ -5,6 +5,8 @@
#include <iostream>
#include "d3d11_x.h"
DXGI_FORMAT LastResourceFormat2D = DXGI_FORMAT_UNKNOWN;
HRESULT wd::device_x::CreateBuffer(const D3D11_BUFFER_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData,
ID3D11Buffer** ppBuffer)
{
@@ -28,7 +30,33 @@ HRESULT wd::device_x::CreateBuffer(const D3D11_BUFFER_DESC* pDesc, const D3D11_S
pDesc2.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE;
}
if (pDesc->MiscFlags == 0x40)
{
pDesc2.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
}
if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILE_POOL_X)
{
pDesc2.MiscFlags |= D3D11_RESOURCE_MISC_TILE_POOL;
pInitialData = NULL;
pDesc2.BindFlags = 0;
}
if (pDesc->MiscFlags & D3D11_RESOURCE_MISC_TILED_X)
{
pDesc2.MiscFlags |= D3D11_RESOURCE_MISC_TILED;
pInitialData = NULL;
pDesc2.BindFlags = 0;
}
if (pDesc->MiscFlags == D3D11X_RESOURCE_MISC_ESRAM_RESIDENT)
{
VirtualAlloc(&pInitialData, 0x3D0900, MEM_COMMIT, PAGE_READWRITE);
pDesc2.MiscFlags = 0;
}
ID3D11Buffer* buffer = nullptr;
HRESULT hr = wrapped_interface->CreateBuffer(&pDesc2, pInitialData, &buffer);
if (ppBuffer != nullptr)
@@ -43,23 +71,17 @@ HRESULT wd::device_x::CreateTexture1D(const D3D11_TEXTURE1D_DESC* pDesc, const D
ID3D11Texture1D** ppTexture1D)
{
ID3D11Texture1D* texture1d = nullptr;
HRESULT hr = wrapped_interface->CreateTexture1D(pDesc, pInitialData, &texture1d);
printf("[CreateTexture1D] created texture at 0x%llX\n", texture1d);
if (ppTexture1D != nullptr)
{
*ppTexture1D = SUCCEEDED(hr) ? reinterpret_cast<ID3D11Texture1D*>(new texture_1d(texture1d)) : nullptr;
}
return hr;
}
HRESULT wd::device_x::CreateTexture2D(const D3D11_TEXTURE2D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData,
ID3D11Texture2D** ppTexture2D)
{
std::cout << std::hex << "CreateTexture2D MiscFlag---> " << pDesc->MiscFlags << "\n";
auto pDesc2 = *pDesc;
pDesc2.MiscFlags &= D3D11_MISC_FLAGS_MASK;
@@ -83,7 +105,7 @@ HRESULT wd::device_x::CreateTexture2D(const D3D11_TEXTURE2D_DESC* pDesc, const D
if (pDesc->MiscFlags == 0x4)
{
pDesc2.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE;
pDesc2.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE;
}
if (pDesc->MiscFlags == D3D11X_RESOURCE_MISC_ESRAM_RESIDENT)
@@ -97,6 +119,11 @@ HRESULT wd::device_x::CreateTexture2D(const D3D11_TEXTURE2D_DESC* pDesc, const D
pDesc2.MiscFlags = 0;
}
if (pDesc->MiscFlags == 0x40)
{
pDesc2.MiscFlags |= D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
}
ID3D11Texture2D* texture2d = nullptr;
HRESULT hr = wrapped_interface->CreateTexture2D(&pDesc2, pInitialData, &texture2d);
@@ -141,12 +168,14 @@ HRESULT wd::device_x::CreateShaderResourceView(ID3D11Resource* pResource, const
}
return hr;
}
HRESULT wd::device_x::CreateUnorderedAccessView(ID3D11Resource* pResource,
const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc, ID3D11UnorderedAccessView** ppUAView)
{
::ID3D11UnorderedAccessView* target = nullptr;
HRESULT hr = wrapped_interface->CreateUnorderedAccessView(reinterpret_cast<d3d11_resource*>(pResource)->wrapped_interface, pDesc, &target);
if (ppUAView != nullptr)
@@ -162,6 +191,7 @@ HRESULT wd::device_x::CreateRenderTargetView(ID3D11Resource* pResource, const D3
ID3D11RenderTargetView** ppRTView)
{
::ID3D11RenderTargetView* target = nullptr;
HRESULT hr = wrapped_interface->CreateRenderTargetView(reinterpret_cast<wd::d3d11_resource*>(pResource)->wrapped_interface, pDesc, &target);
if (ppRTView != nullptr)
@@ -176,9 +206,8 @@ HRESULT wd::device_x::CreateRenderTargetView(ID3D11Resource* pResource, const D3
HRESULT wd::device_x::CreateDepthStencilView(ID3D11Resource* pResource, const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc,
ID3D11DepthStencilView** ppDepthStencilView)
{
printf("CreateDepthStencilView was called!!!!!!!\n");
::ID3D11DepthStencilView* target = nullptr;
HRESULT hr = wrapped_interface->CreateDepthStencilView(reinterpret_cast<d3d11_resource*>(pResource)->wrapped_interface, pDesc, &target);
if (ppDepthStencilView != nullptr)
@@ -190,6 +219,20 @@ HRESULT wd::device_x::CreateDepthStencilView(ID3D11Resource* pResource, const D3
return hr;
}
HRESULT wd::device_x::CreateBlendState(const D3D11_BLEND_DESC* pBlendStateDesc, wdi::ID3D11BlendState** ppBlendState)
{
ID3D11BlendState* blendState = nullptr;
HRESULT hr = wrapped_interface->CreateBlendState(pBlendStateDesc, &blendState);
if (ppBlendState != nullptr)
{
*ppBlendState = SUCCEEDED(hr) ? reinterpret_cast<wdi::ID3D11BlendState*>(new wd::blend_state(blendState)) : nullptr;
}
return S_OK;
}
HRESULT wd::device_x::CreateDeferredContext(UINT ContextFlags, ID3D11DeviceContext** ppDeferredContext)
{
if (ContextFlags != 0)
@@ -199,10 +242,6 @@ HRESULT wd::device_x::CreateDeferredContext(UINT ContextFlags, ID3D11DeviceConte
::ID3D11DeviceContext* ctx{};
HRESULT hr = wrapped_interface->CreateDeferredContext(ContextFlags, &ctx);
if (FAILED(hr))
{
printf("CreateDeferredContext failed!!!!!!!\n");
}
if (ppDeferredContext != nullptr && SUCCEEDED(hr))
{
@@ -217,7 +256,6 @@ HRESULT wd::device_x::CreateDeferredContext(UINT ContextFlags, ID3D11DeviceConte
void wd::device_x::GetImmediateContext(ID3D11DeviceContext** ppImmediateContext)
{
printf("GetImmediateContext was called!!!\n");
::ID3D11DeviceContext* ctx{};
wrapped_interface->GetImmediateContext(&ctx);
@@ -276,6 +314,7 @@ HRESULT wd::device_x::SetDriverHint(UINT Feature, UINT Value)
HRESULT wd::device_x::CreateDmaEngineContext(const wdi::D3D11_DMA_ENGINE_CONTEXT_DESC* pDmaEngineContextDesc,
wdi::ID3D11DmaEngineContextX** ppDmaDeviceContext)
{
*ppDmaDeviceContext = new D3D11DmaEngineContextX();
return S_OK;
}
@@ -296,14 +335,13 @@ BOOL wd::device_x::IsResourcePending(ID3D11Resource* pResource)
HRESULT wd::device_x::CreatePlacementBuffer(const D3D11_BUFFER_DESC* pDesc, void* pVirtualAddress,
ID3D11Buffer** ppBuffer)
{
printf("CreatePlacementBuffer was called!!!!!!!\n");
D3D11_SUBRESOURCE_DATA initialData = {};
initialData.pSysMem = pVirtualAddress;
initialData.SysMemPitch = pDesc->ByteWidth * 3;
return CreateBuffer(pDesc, &initialData, ppBuffer);
return S_OK;
HRESULT hr = CreateBuffer(pDesc, &initialData, ppBuffer);
return hr;
}
HRESULT wd::device_x::CreatePlacementTexture1D(const D3D11_TEXTURE1D_DESC* pDesc, UINT TileModeIndex, UINT Pitch,
@@ -317,9 +355,9 @@ HRESULT wd::device_x::CreatePlacementTexture1D(const D3D11_TEXTURE1D_DESC* pDesc
initialData[ i ].SysMemPitch = pDesc->Width;
}
CreateTexture1D(pDesc, initialData.data(), ppTexture1D);
HRESULT hr = CreateTexture1D(pDesc, initialData.data(), ppTexture1D);
return S_OK;
return hr;
}
HRESULT wd::device_x::CreatePlacementTexture2D(const D3D11_TEXTURE2D_DESC* pDesc, UINT TileModeIndex, UINT Pitch,
@@ -337,7 +375,7 @@ HRESULT wd::device_x::CreatePlacementTexture2D(const D3D11_TEXTURE2D_DESC* pDesc
for (int i = 0; i < initialData.size( ); i++)
{
initialData[ i ].pSysMem = pVirtualAddress;
initialData[ i ].SysMemPitch = pDesc->Width;
initialData[ i ].SysMemPitch = pDesc->Width * 2;
}
CreateTexture2D(pDesc, initialData.data(), ppTexture2D);
@@ -353,7 +391,7 @@ HRESULT wd::device_x::CreatePlacementTexture3D(const D3D11_TEXTURE3D_DESC* pDesc
for (int i = 0; i < initialData.size( ); i++)
{
initialData[ i ].pSysMem = pVirtualAddress;
initialData[ i ].SysMemPitch = pDesc->Width;
initialData[ i ].SysMemPitch = pDesc->Width * 2;
initialData[ i ].SysMemSlicePitch = pDesc->Width;
}
@@ -411,7 +449,8 @@ HRESULT wd::device_x::CreateComputeContextX(const wdi::D3D11_COMPUTE_CONTEXT_DES
wdi::ID3D11ComputeContextX** ppComputeContext)
{
printf("CreateComputeContextX was called!!!!!!!\n");
return CreateDeferredContext2(0, (ID3D11DeviceContext2**)ppComputeContext);
return S_OK;
}
void wd::device_x::ComposeShaderResourceView(const wdi::D3D11X_DESCRIPTOR_RESOURCE* pDescriptorResource,
@@ -484,4 +523,8 @@ HRESULT wd::device_x::SetGpuMemoryPriority(UINT Priority)
void wd::device_x::GetGpuHardwareConfiguration(wdi::D3D11X_GPU_HARDWARE_CONFIGURATION* pGpuHardwareConfiguration)
{
printf("GetGpuHardwareConfiguration was called!!!!!!!\n");
//Xbox One X
pGpuHardwareConfiguration->GpuFrequency = 1172;
pGpuHardwareConfiguration->GpuCuCount = 2560;
}
+4 -4
View File
@@ -8,6 +8,7 @@
#include "dxgi_device.h"
#include "dma_engine.h"
#define D3D11_RESOURCE_MISC_TILE_POOL_X 0x4000000
#define D3D11_RESOURCE_MISC_TILED_X 0x8000000
#define D3D11_MISC_FLAGS_MASK (D3D11_RESOURCE_MISC_TILE_POOL | D3D11_RESOURCE_MISC_TILED)
@@ -15,6 +16,8 @@
namespace wdi
{
class ID3D11DeviceContext;
class ID3D11BlendState;
class ID3D11DeviceContextX;
struct D3D11X_COUNTER_SET_DESC;
struct D3D11X_DESCRIPTOR_RESOURCE;
@@ -365,10 +368,7 @@ namespace wd
return wrapped_interface->CreateClassLinkage(ppLinkage);
}
HRESULT CreateBlendState(const D3D11_BLEND_DESC* pBlendStateDesc, ID3D11BlendState** ppBlendState) override
{
return wrapped_interface->CreateBlendState(pBlendStateDesc, ppBlendState);
}
HRESULT CreateBlendState(const D3D11_BLEND_DESC* pBlendStateDesc, wdi::ID3D11BlendState** ppBlendState) override;
HRESULT CreateDepthStencilState(const D3D11_DEPTH_STENCIL_DESC* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState) override
{
+199
View File
@@ -0,0 +1,199 @@
#include "view.hpp"
//wdi::ID3D11RenderTargetView starts.
void STDMETHODCALLTYPE wd::render_target_view::GetDesc(D3D11_RENDER_TARGET_VIEW_DESC* pDesc)
{
wrapped_interface->GetDesc(pDesc);
}
void wd::render_target_view::GetDevice(ID3D11Device** ppDevice)
{
printf("WARN: render_target_view::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
HRESULT wd::render_target_view::GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData)
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT wd::render_target_view::SetPrivateData(const GUID& guid, UINT DataSize, const void* pData)
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT wd::render_target_view::SetPrivateDataInterface(const GUID& guid, const IUnknown* pData)
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT wd::render_target_view::SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData)
{
TRACE_NOT_IMPLEMENTED("render_target_view");
return E_NOTIMPL;
}
void wd::render_target_view::GetResource(wdi::ID3D11Resource** ppResource)
{
D3D11_RENDER_TARGET_VIEW_DESC desc;
wrapped_interface->GetDesc(&desc);
// FIXME: this only targets 2D textures, but it doesn't matter since all texture* classes are the same
::ID3D11Texture2D* texture2d = nullptr;
wrapped_interface->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<wdi::ID3D11Texture2D**>(ppResource) = new texture_2d(texture2d);
}
//wdi::ID3D11RenderTargetView ends.
//wdi::ID3D11DepthStencilView starts.
void STDMETHODCALLTYPE wd::depth_stencil_view::GetDesc(D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc)
{
printf("WARN: depth_stencil_view:: GetDesc!!!\n");
wrapped_interface->GetDesc(pDesc);
}
void wd::depth_stencil_view::GetDevice(ID3D11Device** ppDevice)
{
printf("WARN: depth_stencil_view::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
HRESULT wd::depth_stencil_view::GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData)
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT wd::depth_stencil_view::SetPrivateData(const GUID& guid, UINT DataSize, const void* pData)
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT wd::depth_stencil_view::SetPrivateDataInterface(const GUID& guid, const IUnknown* pData)
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT wd::depth_stencil_view::SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData)
{
TRACE_NOT_IMPLEMENTED("depth_stencil_view");
return E_NOTIMPL;
}
void wd::depth_stencil_view::GetResource(wdi::ID3D11Resource** ppResource)
{
D3D11_DEPTH_STENCIL_VIEW_DESC desc;
wrapped_interface->GetDesc(&desc);
// FIXME: this only targets 2D textures, but it doesn't matter since all texture* classes are the same
::ID3D11Texture2D* texture2d = nullptr;
wrapped_interface->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<wdi::ID3D11Texture2D**>(ppResource) = new texture_2d(texture2d);
}
//wdi::ID3D11DepthStencilView ends.
//wdi::ID3D11ShaderResourceView starts.
void STDMETHODCALLTYPE wd::shader_resource_view::GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc)
{
wrapped_interface->GetDesc(pDesc);
}
void wd::shader_resource_view::GetDevice(ID3D11Device** ppDevice)
{
printf("WARN: shader_resource_view::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
HRESULT wd::shader_resource_view::GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData)
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT wd::shader_resource_view::SetPrivateData(const GUID& guid, UINT DataSize, const void* pData)
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT wd::shader_resource_view::SetPrivateDataInterface(const GUID& guid, const IUnknown* pData)
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT wd::shader_resource_view::SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData)
{
TRACE_NOT_IMPLEMENTED("shader_resource_view");
return E_NOTIMPL;
}
void wd::shader_resource_view::GetResource(wdi::ID3D11Resource** ppResource)
{
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
wrapped_interface->GetDesc(&desc);
// FIXME: this only targets 2D textures, but it doesn't matter since all texture* classes are the same
::ID3D11Texture2D* texture2d = nullptr;
wrapped_interface->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<wdi::ID3D11Texture2D**>(ppResource) = new texture_2d(texture2d);
}
//wdi::ID3D11ShaderResourceView ends.
//wdi::ID3D11UnorderedAccessView starts.
void wd::unordered_access_view::GetDesc(D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc)
{
wrapped_interface->GetDesc(pDesc);
}
void wd::unordered_access_view::GetDevice(ID3D11Device** ppDevice)
{
printf("WARN: depth_stencil_view::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
HRESULT wd::unordered_access_view::GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData)
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT wd::unordered_access_view::SetPrivateData(const GUID& guid, UINT DataSize, const void* pData)
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT wd::unordered_access_view::SetPrivateDataInterface(const GUID& guid, const IUnknown* pData)
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT wd::unordered_access_view::SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData)
{
TRACE_NOT_IMPLEMENTED("shader_resource_view");
return E_NOTIMPL;
}
void wd::unordered_access_view::GetResource(wdi::ID3D11Resource** ppResource)
{
D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
wrapped_interface->GetDesc(&desc);
// FIXME: this only targets 2D textures, but it doesn't matter since all texture* classes are the same
::ID3D11Texture2D* texture2d = nullptr;
wrapped_interface->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<wdi::ID3D11Texture2D**>(ppResource) = new texture_2d(texture2d);
}
//wdi::ID3D11UnorderedAccessView ends.
+56 -170
View File
@@ -5,10 +5,10 @@
namespace wdi
{
#define D3D11X_DESCRIPTOR_TEXTURE_VIEW_SIZE_IN_OWORDS 2
#define D3D11X_DESCRIPTOR_TEXTURE_VIEW_SIZE_IN_QWORDS 4
#define D3D11X_DESCRIPTOR_TEXTURE_VIEW_SIZE_IN_DWORDS 8
#define D3D11X_DESCRIPTOR_TEXTURE_VIEW_SIZE_IN_BYTES 32
#define D3D11X_DESCRIPTOR_TEXTURE_VIEW_SIZE_IN_OWORDS 2
#define D3D11X_DESCRIPTOR_TEXTURE_VIEW_SIZE_IN_QWORDS 4
#define D3D11X_DESCRIPTOR_TEXTURE_VIEW_SIZE_IN_DWORDS 8
#define D3D11X_DESCRIPTOR_TEXTURE_VIEW_SIZE_IN_BYTES 32
typedef struct D3D11X_DESCRIPTOR_TEXTURE_VIEW
{
@@ -21,23 +21,23 @@ namespace wdi
} D3D11X_DESCRIPTOR_TEXTURE_VIEW;
D3DINTERFACE(ID3D11View, 839d1216, bb2e, 412b, b7, f4, a9, db, eb, e0, 8e, d1) : public ID3D11DeviceChild
{
public:
ID3D11Resource* m_pResource;
unsigned int m_Type;
D3DINTERFACE(ID3D11View, 839d1216, bb2e, 412b, b7, f4, a9, db, eb, e0, 8e, d1) : public ID3D11DeviceChild
{
public:
ID3D11Resource * m_pResource;
unsigned int m_Type;
virtual void STDMETHODCALLTYPE GetResource(
/* [annotation] */
_Outptr_ ID3D11Resource** ppResource) PURE;
};
virtual void STDMETHODCALLTYPE GetResource(
/* [annotation] */
_Outptr_ ID3D11Resource** ppResource) PURE;
};
D3DINTERFACE(ID3D11RenderTargetView, dfdba067, 0b8d, 4865, 87, 5b, d7, b4, 51, 6c, c1, 64) : public ID3D11View
{
public:
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_RENDER_TARGET_VIEW_DESC* pDesc) PURE;
_Out_ D3D11_RENDER_TARGET_VIEW_DESC * pDesc) PURE;
};
@@ -46,7 +46,7 @@ namespace wdi
public:
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc) PURE;
_Out_ D3D11_DEPTH_STENCIL_VIEW_DESC * pDesc) PURE;
};
@@ -55,7 +55,7 @@ namespace wdi
public:
virtual void STDMETHODCALLTYPE GetDesc(
/* [annotation] */
_Out_ D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) PURE;
_Out_ D3D11_SHADER_RESOURCE_VIEW_DESC * pDesc) PURE;
};
@@ -80,11 +80,11 @@ namespace wd
render_target_view(::ID3D11RenderTargetView* view) : wrapped_interface(view)
{
m_pResource = reinterpret_cast<wdi::ID3D11Resource*>(wrapped_interface);
wrapped_interface->AddRef( );
wrapped_interface->AddRef( );
}
IGU_DEFINE_REF
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
{
if (riid == __uuidof(wdi::ID3D11RenderTargetView) || riid == __uuidof(wdi::ID3D11View) || riid == __uuidof(wdi::ID3D11DepthStencilView))
{
@@ -97,37 +97,18 @@ namespace wd
return E_NOINTERFACE;
}
void STDMETHODCALLTYPE GetDesc(D3D11_RENDER_TARGET_VIEW_DESC* pDesc) override
{
wrapped_interface->GetDesc(pDesc);
}
void STDMETHODCALLTYPE GetDesc(D3D11_RENDER_TARGET_VIEW_DESC* pDesc) override;
void GetDevice(ID3D11Device** ppDevice) override
{
printf("WARN: render_target_view::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
void GetDevice(ID3D11Device** ppDevice) override;
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override;
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override;
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override;
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override;
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override
{
TRACE_NOT_IMPLEMENTED("render_target_view");
return E_NOTIMPL;
}
#if !defined(DX_VERSION) || DX_VERSION > MAKEINTVERSION(1, 11)
HRESULT SetName(LPCWSTR pName) override
{
@@ -136,21 +117,12 @@ namespace wd
}
#endif
void GetResource(wdi::ID3D11Resource** ppResource) override
{
D3D11_RENDER_TARGET_VIEW_DESC desc;
wrapped_interface->GetDesc(&desc);
// FIXME: this only targets 2D textures, but it doesn't matter since all texture* classes are the same
::ID3D11Texture2D* texture2d = nullptr;
wrapped_interface->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<wdi::ID3D11Texture2D**>(ppResource) = new texture_2d(texture2d);
}
void GetResource(wdi::ID3D11Resource** ppResource) override;
::ID3D11RenderTargetView* wrapped_interface;
};
class depth_stencil_view : public wdi::ID3D11DepthStencilView
class depth_stencil_view : public wdi::ID3D11DepthStencilView
{
public:
depth_stencil_view(::ID3D11DepthStencilView* view) : wrapped_interface(view)
@@ -160,7 +132,7 @@ namespace wd
}
IGU_DEFINE_REF
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
{
if (riid == __uuidof(wdi::ID3D11DepthStencilView) || riid == __uuidof(wdi::ID3D11View))
{
@@ -173,38 +145,17 @@ namespace wd
return E_NOINTERFACE;
}
void STDMETHODCALLTYPE GetDesc(D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc) override
{
printf("WARN: depth_stencil_view:: GetDesc!!!\n");
wrapped_interface->GetDesc(pDesc);
}
void STDMETHODCALLTYPE GetDesc(D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc) override;
void GetDevice(ID3D11Device** ppDevice) override
{
printf("WARN: depth_stencil_view::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
void GetDevice(ID3D11Device** ppDevice) override;
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override;
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override;
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override;
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override
{
TRACE_NOT_IMPLEMENTED("depth_stencil_view");
return E_NOTIMPL;
}
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override;
#if !defined(DX_VERSION) || DX_VERSION > MAKEINTVERSION(1, 11)
HRESULT SetName(LPCWSTR pName) override
{
@@ -213,16 +164,7 @@ namespace wd
}
#endif
void GetResource(wdi::ID3D11Resource** ppResource) override
{
D3D11_DEPTH_STENCIL_VIEW_DESC desc;
wrapped_interface->GetDesc(&desc);
// FIXME: this only targets 2D textures, but it doesn't matter since all texture* classes are the same
::ID3D11Texture2D* texture2d = nullptr;
wrapped_interface->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<wdi::ID3D11Texture2D**>(ppResource) = new texture_2d(texture2d);
}
void GetResource(wdi::ID3D11Resource** ppResource) override;
::ID3D11DepthStencilView* wrapped_interface;
};
@@ -237,50 +179,31 @@ namespace wd
}
IGU_DEFINE_REF
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
{
if (riid == __uuidof(wdi::ID3D11ShaderResourceView))
{
*ppvObject = this;
AddRef( );
return S_OK;
AddRef( );
return S_OK;
}
TRACE_INTERFACE_NOT_HANDLED("shader_resource_view");
*ppvObject = nullptr;
return E_NOINTERFACE;
return E_NOINTERFACE;
}
void STDMETHODCALLTYPE GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) override
{
wrapped_interface->GetDesc(pDesc);
}
void STDMETHODCALLTYPE GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc) override;
void GetDevice(ID3D11Device** ppDevice) override
{
printf("WARN: shader_resource_view::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
void GetDevice(ID3D11Device** ppDevice) override;
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override;
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override;
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override;
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override;
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override
{
TRACE_NOT_IMPLEMENTED("shader_resource_view");
return E_NOTIMPL;
}
#if !defined(DX_VERSION) || DX_VERSION > MAKEINTVERSION(1, 11)
HRESULT SetName(LPCWSTR pName) override
{
@@ -289,16 +212,7 @@ namespace wd
}
#endif
void GetResource(wdi::ID3D11Resource** ppResource) override
{
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
wrapped_interface->GetDesc(&desc);
// FIXME: this only targets 2D textures, but it doesn't matter since all texture* classes are the same
::ID3D11Texture2D* texture2d = nullptr;
wrapped_interface->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<wdi::ID3D11Texture2D**>(ppResource) = new texture_2d(texture2d);
}
void GetResource(wdi::ID3D11Resource** ppResource) override;
::ID3D11ShaderResourceView* wrapped_interface;
};
@@ -314,7 +228,7 @@ namespace wd
IGU_DEFINE_REF
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
HRESULT QueryInterface(const IID& riid, void** ppvObject) override
{
if (riid == __uuidof(wdi::ID3D11UnorderedAccessView))
{
@@ -327,37 +241,18 @@ namespace wd
return E_NOINTERFACE;
}
void STDMETHODCALLTYPE GetDesc(D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc) override
{
wrapped_interface->GetDesc(pDesc);
}
void STDMETHODCALLTYPE GetDesc(D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc) override;
void GetDevice(ID3D11Device** ppDevice) override
{
printf("WARN: depth_stencil_view::GetDevice returns a PC device!!\n");
wrapped_interface->GetDevice(ppDevice);
}
void GetDevice(ID3D11Device** ppDevice) override;
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override
{
return wrapped_interface->GetPrivateData(guid, pDataSize, pData);
}
HRESULT GetPrivateData(const GUID& guid, UINT* pDataSize, void* pData) override;
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override
{
return wrapped_interface->SetPrivateData(guid, DataSize, pData);
}
HRESULT SetPrivateData(const GUID& guid, UINT DataSize, const void* pData) override;
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override
{
return wrapped_interface->SetPrivateDataInterface(guid, pData);
}
HRESULT SetPrivateDataInterface(const GUID& guid, const IUnknown* pData) override;
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override;
HRESULT SetPrivateDataInterfaceGraphics(const GUID& guid, const IGraphicsUnknown* pData) override
{
TRACE_NOT_IMPLEMENTED("shader_resource_view");
return E_NOTIMPL;
}
#if !defined(DX_VERSION) || DX_VERSION > MAKEINTVERSION(1, 11)
HRESULT SetName(LPCWSTR pName) override
{
@@ -366,16 +261,7 @@ namespace wd
}
#endif
void GetResource(wdi::ID3D11Resource** ppResource) override
{
D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
wrapped_interface->GetDesc(&desc);
// FIXME: this only targets 2D textures, but it doesn't matter since all texture* classes are the same
::ID3D11Texture2D* texture2d = nullptr;
wrapped_interface->GetResource(reinterpret_cast<::ID3D11Resource**>(&texture2d));
*reinterpret_cast<wdi::ID3D11Texture2D**>(ppResource) = new texture_2d(texture2d);
}
void GetResource(wdi::ID3D11Resource** ppResource) override;
::ID3D11UnorderedAccessView* wrapped_interface;
};