HRESULT WrappedID3D11Device::CreateDeviceContextState(UINT Flags, const D3D_FEATURE_LEVEL *pFeatureLevels, UINT FeatureLevels, UINT SDKVersion, REFIID EmulatedInterface,
D3D_FEATURE_LEVEL *pChosenFeatureLevel, ID3DDeviceContextState **ppContextState)
{
if(m_pDevice1 == NULL) return E_NOINTERFACE;
RDCUNIMPLEMENTED("Not wrapping CreateDeviceContextState");
return m_pDevice1->CreateDeviceContextState(Flags, pFeatureLevels, FeatureLevels, SDKVersion, EmulatedInterface, pChosenFeatureLevel, ppContextState);
}
HRESULT WrappedIDXGISwapChain2::GetDevice(
/* [in] */ REFIID riid,
/* [retval][out] */ void **ppDevice)
{
HRESULT ret = m_pReal->GetDevice(riid, ppDevice);
if(SUCCEEDED(ret))
{
// try one of the trivial wraps, we don't mind making a new one of those
if(riid == __uuidof(ID3D11Device))
{
// probably they're asking for the device device.
*ppDevice = m_pDevice;
m_pDevice->AddRef();
}
else if(riid == __uuidof(IDXGISwapChain))
{
// don't think anyone would try this, but what the hell.
*ppDevice = this;
AddRef();
}
else if(!HandleWrap(riid, ppDevice))
{
// can probably get away with returning the real result here,
// but it worries me a bit.
RDCUNIMPLEMENTED("Not returning trivial type");
}
}
return ret;
}
HRESULT WrappedID3D11Device::OpenSharedResource1(HANDLE hResource, REFIID returnedInterface,
void **ppResource)
{
if(m_pDevice1 == NULL)
return E_NOINTERFACE;
RDCUNIMPLEMENTED("Not wrapping OpenSharedResource1");
return m_pDevice1->OpenSharedResource1(hResource, returnedInterface, ppResource);
}
HRESULT WrappedID3D11Device::OpenSharedResourceByName(LPCWSTR lpName, DWORD dwDesiredAccess,
REFIID returnedInterface, void **ppResource)
{
if(m_pDevice1 == NULL)
return E_NOINTERFACE;
RDCUNIMPLEMENTED("Not wrapping OpenSharedResourceByName");
return m_pDevice1->OpenSharedResourceByName(lpName, dwDesiredAccess, returnedInterface, ppResource);
}
void WrappedID3D11Device::WriteToSubresource(ID3D11Resource *pDstResource, UINT DstSubresource,
const D3D11_BOX *pDstBox, const void *pSrcData,
UINT SrcRowPitch, UINT SrcDepthPitch)
{
if(m_pDevice3 == NULL)
return;
RDCUNIMPLEMENTED(
"WriteToSubresource is not supported. Please contact me if you have a working example! "
"https://github.com/baldurk/renderdoc/issues");
m_pDevice3->WriteToSubresource(pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch,
SrcDepthPitch);
return;
}
void WrappedID3D11Device::ReadFromSubresource(void *pDstData, UINT DstRowPitch, UINT DstDepthPitch,
ID3D11Resource *pSrcResource, UINT SrcSubresource,
const D3D11_BOX *pSrcBox)
{
if(m_pDevice3 == NULL)
return;
RDCUNIMPLEMENTED(
"ReadFromSubresource is not supported. Please contact me if you have a working example! "
"https://github.com/baldurk/renderdoc/issues");
m_pDevice3->ReadFromSubresource(pDstData, DstRowPitch, DstDepthPitch, pSrcResource,
SrcSubresource, pSrcBox);
return;
}
void GLReplay::FreeTargetResource(ResourceId id)
{
RDCUNIMPLEMENTED();
}
extern "C" RENDERDOC_API void RENDERDOC_CC ReplayRenderer_ShutdownOutput(ReplayRenderer *rend, ReplayOutput *output)
{ RDCUNIMPLEMENTED("destroying individual outputs"); }
byte *GLReplay::GetTextureData(ResourceId tex, uint32_t arrayIdx, uint32_t mip, size_t &dataSize)
{
RDCUNIMPLEMENTED();
return NULL;
}
void GLReplay::SetContextFilter(ResourceId id, uint32_t firstDefEv, uint32_t lastDefEv)
{
RDCUNIMPLEMENTED();
}
bool GLReplay::IsOutputWindowVisible(uint64_t id)
{
RDCUNIMPLEMENTED("GLReplay::IsOutputWindowVisible");
return false;
}
void GLReplay::DestroyOutputWindow(uint64_t id)
{
RDCUNIMPLEMENTED("GLReplay::DestroyOutputWindow");
}
void GLReplay::CloseReplayContext()
{
RDCUNIMPLEMENTED("GLReplay::CloseReplayContext");
}
ShaderDebugTrace GLReplay::DebugVertex(uint32_t frameID, uint32_t eventID, uint32_t vertid, uint32_t instid, uint32_t idx, uint32_t instOffset, uint32_t vertOffset)
{
RDCUNIMPLEMENTED();
return ShaderDebugTrace();
}
void GLReplay::BuildCustomShader(string source, string entry, const uint32_t compileFlags, ShaderStageType type, ResourceId *id, string *errors)
{
RDCUNIMPLEMENTED();
}
bool GLReplay::SaveTexture(ResourceId tex, uint32_t saveMip, wstring path)
{
RDCUNIMPLEMENTED();
return false;
}
void GLReplay::TimeDrawcalls(rdctype::array<FetchDrawcall> &arr)
{
RDCUNIMPLEMENTED();
}
void GLReplay::RemoveReplacement(ResourceId id)
{
RDCUNIMPLEMENTED();
}
void GLReplay::ReplaceResource(ResourceId from, ResourceId to)
{
RDCUNIMPLEMENTED();
}
void GLReplay::MakeCurrentReplayContext(GLWindowingData *ctx)
{
RDCUNIMPLEMENTED("GLReplay::MakeCurrentReplayContext");
}
void GLReplay::SwapBuffers(GLWindowingData *ctx)
{
RDCUNIMPLEMENTED("GLReplay::SwapBuffers");
}
ShaderDebugTrace GLReplay::DebugPixel(uint32_t frameID, uint32_t eventID, uint32_t x, uint32_t y)
{
RDCUNIMPLEMENTED();
return ShaderDebugTrace();
}
uint64_t GLReplay::MakeOutputWindow(WindowingSystem system, void *data, bool depth)
{
RDCUNIMPLEMENTED("GLReplay::MakeOutputWindow");
return 0;
}
ShaderDebugTrace GLReplay::DebugThread(uint32_t frameID, uint32_t eventID, uint32_t groupid[3], uint32_t threadid[3])
{
RDCUNIMPLEMENTED();
return ShaderDebugTrace();
}
void GLReplay::GetOutputWindowDimensions(uint64_t id, int32_t &w, int32_t &h)
{
RDCUNIMPLEMENTED("GLReplay::GetOutputWindowDimensions");
}
ResourceId GLReplay::CreateProxyTexture( FetchTexture templateTex )
{
RDCUNIMPLEMENTED();
return ResourceId();
}
ReplayCreateStatus GL_CreateReplayDevice(const char *logfile, IReplayDriver **driver)
{
RDCUNIMPLEMENTED("GL_CreateReplayDevice");
return eReplayCreate_APIHardwareUnsupported;
}
void GLReplay::SetProxyTextureData(ResourceId texid, uint32_t arrayIdx, uint32_t mip, byte *data, size_t dataSize)
{
RDCUNIMPLEMENTED();
}
ResourceId GLReplay::ApplyCustomShader(ResourceId shader, ResourceId texid, uint32_t mip)
{
RDCUNIMPLEMENTED();
return ResourceId();
}
void GLReplay::FreeCustomShader(ResourceId id)
{
RDCUNIMPLEMENTED();
}
