From 51c6488f97f98aa3d216092c01d9601008be0fbf Mon Sep 17 00:00:00 2001
From: unknown <[EMAIL REDACTED]>
Date: Sun, 26 Jun 2022 18:47:34 +0000
Subject: [PATCH] Add support for SDL_render_d3d12.c to compile in C++ mode
---
src/core/windows/SDL_windows.h | 10 +
src/render/SDL_d3dmath.h | 10 +
src/render/SDL_sysrender.h | 9 +
src/render/direct3d12/SDL_render_d3d12.c | 303 ++++++++++++----------
src/render/direct3d12/SDL_shaders_d3d12.h | 10 +
src/video/windows/SDL_windowswindow.h | 10 +
6 files changed, 211 insertions(+), 141 deletions(-)
diff --git a/src/core/windows/SDL_windows.h b/src/core/windows/SDL_windows.h
index 21d6f0fef20..7b3b9bcfa46 100644
--- a/src/core/windows/SDL_windows.h
+++ b/src/core/windows/SDL_windows.h
@@ -65,6 +65,11 @@
#define SDL_tcsstr SDL_strstr
#endif
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
/* Sets an error message based on a given HRESULT */
extern int WIN_SetErrorFromHRESULT(const char *prefix, HRESULT hr);
@@ -104,6 +109,11 @@ extern BOOL WIN_IsEqualIID(REFIID a, REFIID b);
extern void WIN_RECTToRect(const RECT *winrect, SDL_Rect *sdlrect);
extern void WIN_RectToRECT(const SDL_Rect *sdlrect, RECT *winrect);
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
#endif /* _INCLUDED_WINDOWS_H */
/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/render/SDL_d3dmath.h b/src/render/SDL_d3dmath.h
index 211bfdd5a67..6460bf17dc1 100644
--- a/src/render/SDL_d3dmath.h
+++ b/src/render/SDL_d3dmath.h
@@ -22,6 +22,11 @@
#if (SDL_VIDEO_RENDER_D3D || SDL_VIDEO_RENDER_D3D11 || SDL_VIDEO_RENDER_D3D12) && !SDL_RENDER_DISABLED
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
/* Direct3D matrix math functions */
typedef struct
@@ -67,6 +72,11 @@ Float4X4 MatrixRotationX(float r);
Float4X4 MatrixRotationY(float r);
Float4X4 MatrixRotationZ(float r);
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
#endif /* (SDL_VIDEO_RENDER_D3D || SDL_VIDEO_RENDER_D3D11 || SDL_VIDEO_RENDER_D3D12) && !SDL_RENDER_DISABLED */
/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/render/SDL_sysrender.h b/src/render/SDL_sysrender.h
index 481ae91bfc5..f559a2629be 100644
--- a/src/render/SDL_sysrender.h
+++ b/src/render/SDL_sysrender.h
@@ -28,6 +28,10 @@
#include "SDL_mutex.h"
#include "SDL_yuv_sw_c.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
/**
* A rectangle, with the origin at the upper left (double precision).
@@ -309,6 +313,11 @@ extern void *SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t num
extern int SDL_PrivateLowerBlitScaled(SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect, SDL_ScaleMode scaleMode);
extern int SDL_PrivateUpperBlitScaled(SDL_Surface * src, const SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect, SDL_ScaleMode scaleMode);
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
#endif /* SDL_sysrender_h_ */
/* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/render/direct3d12/SDL_render_d3d12.c b/src/render/direct3d12/SDL_render_d3d12.c
index 413e1d8804f..47870e6646a 100644
--- a/src/render/direct3d12/SDL_render_d3d12.c
+++ b/src/render/direct3d12/SDL_render_d3d12.c
@@ -52,8 +52,22 @@
#define SDL_COMPOSE_ERROR(str) SDL_STRINGIFY_ARG(__FUNCTION__) ", " str
#endif
+#ifdef __cplusplus
+#define SAFE_RELEASE(X) if (X) { (X)->Release(); X = NULL; }
+#define D3D_CALL(THIS, FUNC, ...) (THIS)->FUNC(__VA_ARGS__)
+#define D3D_CALL_RET(THIS, FUNC, RETVAL, ...) *(RETVAL) = (THIS)->FUNC(__VA_ARGS__)
+#define D3D_GUID(X) (X)
+#else
#define SAFE_RELEASE(X) if (X) { (X)->lpVtbl->Release(X); X = NULL; }
+#define D3D_CALL(THIS, FUNC, ...) (THIS)->lpVtbl->FUNC((THIS), __VA_ARGS__)
+#define D3D_CALL_RET(THIS, FUNC, ...) (THIS)->lpVtbl->FUNC((THIS), __VA_ARGS__)
+#define D3D_GUID(X) &(X)
+#endif
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
/* !!! FIXME: vertex buffer bandwidth could be lower; only use UV coords when
!!! FIXME: textures are needed. */
@@ -335,7 +349,8 @@ D3D12_ReleaseAll(SDL_Renderer * renderer)
/* Check for any leaks if in debug mode */
if (data->dxgiDebug) {
- data->dxgiDebug->lpVtbl->ReportLiveObjects(data->dxgiDebug, SDL_DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_SUMMARY | DXGI_DEBUG_RLO_IGNORE_INTERNAL);
+ DXGI_DEBUG_RLO_FLAGS rloFlags = (DXGI_DEBUG_RLO_FLAGS)(DXGI_DEBUG_RLO_SUMMARY | DXGI_DEBUG_RLO_IGNORE_INTERNAL);
+ D3D_CALL(data->dxgiDebug, ReportLiveObjects, SDL_DXGI_DEBUG_ALL, rloFlags);
SAFE_RELEASE(data->dxgiDebug);
}
@@ -361,10 +376,10 @@ D3D12_CPUtoGPUHandle(ID3D12DescriptorHeap * heap, D3D12_CPU_DESCRIPTOR_HANDLE CP
SIZE_T offset;
/* Calculate the correct offset into the heap */
- heap->lpVtbl->GetCPUDescriptorHandleForHeapStart(heap, &CPUHeapStart);
+ D3D_CALL_RET(heap, GetCPUDescriptorHandleForHeapStart, &CPUHeapStart);
offset = CPUHandle.ptr - CPUHeapStart.ptr;
- heap->lpVtbl->GetGPUDescriptorHandleForHeapStart(heap, &GPUHandle);
+ D3D_CALL_RET(heap, GetGPUDescriptorHandleForHeapStart, &GPUHandle);
GPUHandle.ptr += offset;
return GPUHandle;
@@ -375,10 +390,9 @@ D3D12_WaitForGPU(D3D12_RenderData * data)
{
if (data->commandQueue && data->fence && data->fenceEvent)
{
- data->commandQueue->lpVtbl->Signal(data->commandQueue, data->fence, data->fenceValue);
- if (data->fence->lpVtbl->GetCompletedValue(data->fence) < data->fenceValue) {
- data->fence->lpVtbl->SetEventOnCompletion(
- data->fence,
+ D3D_CALL(data->commandQueue, Signal, data->fence, data->fenceValue);
+ if (D3D_CALL(data->fence, GetCompletedValue) < data->fenceValue) {
+ D3D_CALL(data->fence, SetEventOnCompletion,
data->fenceValue,
data->fenceEvent
);
@@ -400,7 +414,7 @@ D3D12_GetCurrentRenderTargetView(SDL_Renderer * renderer)
}
SDL_zero(rtvDescriptor);
- data->rtvDescriptorHeap->lpVtbl->GetCPUDescriptorHandleForHeapStart(data->rtvDescriptorHeap, &rtvDescriptor);
+ D3D_CALL_RET(data->rtvDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &rtvDescriptor);
rtvDescriptor.ptr += data->currentBackBufferIndex * data->rtvDescriptorSize;
return rtvDescriptor;
}
@@ -422,7 +436,7 @@ D3D12_TransitionResource(D3D12_RenderData * data,
barrier.Transition.StateAfter = afterState;
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
- data->commandList->lpVtbl->ResourceBarrier(data->commandList, 1, &barrier);
+ D3D_CALL(data->commandList, ResourceBarrier, 1, &barrier);
}
}
@@ -433,8 +447,8 @@ D3D12_ResetCommandList(D3D12_RenderData * data)
ID3D12DescriptorHeap *rootDescriptorHeaps[] = { data->srvDescriptorHeap, data->samplerDescriptorHeap };
ID3D12CommandAllocator *commandAllocator = data->commandAllocators[data->currentBackBufferIndex];
- commandAllocator->lpVtbl->Reset(commandAllocator);
- data->commandList->lpVtbl->Reset(data->commandList, commandAllocator, NULL);
+ D3D_CALL(commandAllocator, Reset);
+ D3D_CALL(data->commandList, Reset, commandAllocator, NULL);
data->currentPipelineState = NULL;
data->currentVertexBuffer = 0;
data->issueBatch = SDL_FALSE;
@@ -448,7 +462,7 @@ D3D12_ResetCommandList(D3D12_RenderData * data)
}
data->currentUploadBuffer = 0;
- data->commandList->lpVtbl->SetDescriptorHeaps(data->commandList, 2, rootDescriptorHeaps);
+ D3D_CALL(data->commandList, SetDescriptorHeaps, 2, rootDescriptorHeaps);
}
static int
@@ -457,12 +471,12 @@ D3D12_IssueBatch(D3D12_RenderData * data)
HRESULT result = S_OK;
/* Issue the command list */
- result = data->commandList->lpVtbl->Close(data->commandList);
+ result = D3D_CALL(data->commandList, Close);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("D3D12_IssueBatch"), result);
return result;
}
- data->commandQueue->lpVtbl->ExecuteCommandLists(data->commandQueue, 1, (ID3D12CommandList* const*)&data->commandList);
+ D3D_CALL(data->commandQueue, ExecuteCommandLists, 1, (ID3D12CommandList* const*)&data->commandList);
D3D12_WaitForGPU(data);
@@ -607,10 +621,9 @@ D3D12_CreatePipelineState(SDL_Renderer * renderer,
pipelineDesc.SampleDesc.Count = 1;
pipelineDesc.SampleDesc.Quality = 0;
- result = data->d3dDevice->lpVtbl->CreateGraphicsPipelineState(
- data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateGraphicsPipelineState,
&pipelineDesc,
- &SDL_IID_ID3D12PipelineState,
+ D3D_GUID(SDL_IID_ID3D12PipelineState),
(void **)&pipelineState
);
if (FAILED(result)) {
@@ -705,8 +718,8 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
result = E_FAIL;
goto done;
}
- D3D12GetDebugInterfaceFunc(&SDL_IID_ID3D12Debug, (void**)&data->debugInterface);
- data->debugInterface->lpVtbl->EnableDebugLayer(data->debugInterface);
+ D3D12GetDebugInterfaceFunc(D3D_GUID(SDL_IID_ID3D12Debug), (void**)&data->debugInterface);
+ D3D_CALL(data->debugInterface, EnableDebugLayer);
}
if (createDebug) {
@@ -721,36 +734,36 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
goto done;
}
- result = DXGIGetDebugInterfaceFunc(0, &SDL_IID_IDXGIDebug1, (void **)&data->dxgiDebug);
+ result = DXGIGetDebugInterfaceFunc(0, D3D_GUID(SDL_IID_IDXGIDebug1), (void **)&data->dxgiDebug);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("DXGIGetDebugInterface1"), result);
goto done;
}
- result = DXGIGetDebugInterfaceFunc(0, &SDL_IID_IDXGIInfoQueue, (void **)&dxgiInfoQueue);
+ result = DXGIGetDebugInterfaceFunc(0, D3D_GUID(SDL_IID_IDXGIInfoQueue), (void **)&dxgiInfoQueue);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("DXGIGetDebugInterface1"), result);
goto done;
}
- dxgiInfoQueue->lpVtbl->SetBreakOnSeverity(dxgiInfoQueue, SDL_DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, TRUE);
- dxgiInfoQueue->lpVtbl->SetBreakOnSeverity(dxgiInfoQueue, SDL_DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, TRUE);
+ D3D_CALL(dxgiInfoQueue, SetBreakOnSeverity, SDL_DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_ERROR, TRUE);
+ D3D_CALL(dxgiInfoQueue, SetBreakOnSeverity, SDL_DXGI_DEBUG_ALL, DXGI_INFO_QUEUE_MESSAGE_SEVERITY_CORRUPTION, TRUE);
SAFE_RELEASE(dxgiInfoQueue);
#endif /* __IDXGIInfoQueue_INTERFACE_DEFINED__ */
creationFlags = DXGI_CREATE_FACTORY_DEBUG;
}
- result = CreateDXGIFactoryFunc(creationFlags, &SDL_IID_IDXGIFactory6, (void**)&data->dxgiFactory);
+ result = CreateDXGIFactoryFunc(creationFlags, D3D_GUID(SDL_IID_IDXGIFactory6), (void**)&data->dxgiFactory);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("CreateDXGIFactory"), result);
goto done;
}
/* Prefer a high performance adapter if there are multiple choices */
- result = data->dxgiFactory->lpVtbl->EnumAdapterByGpuPreference(data->dxgiFactory,
+ result = D3D_CALL(data->dxgiFactory, EnumAdapterByGpuPreference,
0,
DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE,
- &SDL_IID_IDXGIAdapter4,
+ D3D_GUID(SDL_IID_IDXGIAdapter4),
(void **)&data->dxgiAdapter
);
if (FAILED(result)) {
@@ -760,7 +773,7 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
result = D3D12CreateDeviceFunc((IUnknown *)data->dxgiAdapter,
D3D_FEATURE_LEVEL_11_0, /* Request minimum feature level 11.0 for maximum compatibility */
- &SDL_IID_ID3D12Device5,
+ D3D_GUID(SDL_IID_ID3D12Device5),
(void **)&d3dDevice
);
if (FAILED(result)) {
@@ -774,7 +787,7 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
D3D12_MESSAGE_SEVERITY severities[] = { D3D12_MESSAGE_SEVERITY_INFO };
D3D12_INFO_QUEUE_FILTER filter;
- result = d3dDevice->lpVtbl->QueryInterface(d3dDevice, &SDL_IID_ID3D12InfoQueue, (void **)&infoQueue);
+ result = D3D_CALL(d3dDevice, QueryInterface, D3D_GUID(SDL_IID_ID3D12InfoQueue), (void **)&infoQueue);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device to ID3D12InfoQueue"), result);
goto done;
@@ -783,15 +796,15 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
SDL_zero(filter);
filter.DenyList.NumSeverities = 1;
filter.DenyList.pSeverityList = severities;
- infoQueue->lpVtbl->PushStorageFilter(infoQueue, &filter);
+ D3D_CALL(infoQueue, PushStorageFilter, &filter);
- infoQueue->lpVtbl->SetBreakOnSeverity(infoQueue, D3D12_MESSAGE_SEVERITY_ERROR, TRUE);
- infoQueue->lpVtbl->SetBreakOnSeverity(infoQueue, D3D12_MESSAGE_SEVERITY_CORRUPTION, TRUE);
+ D3D_CALL(infoQueue, SetBreakOnSeverity, D3D12_MESSAGE_SEVERITY_ERROR, TRUE);
+ D3D_CALL(infoQueue, SetBreakOnSeverity, D3D12_MESSAGE_SEVERITY_CORRUPTION, TRUE);
SAFE_RELEASE(infoQueue);
}
- result = d3dDevice->lpVtbl->QueryInterface(d3dDevice, &SDL_IID_ID3D12Device5, (void **)&data->d3dDevice);
+ result = D3D_CALL(d3dDevice, QueryInterface, D3D_GUID(SDL_IID_ID3D12Device5), (void **)&data->d3dDevice);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device to ID3D12Device5"), result);
goto done;
@@ -802,9 +815,9 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
- result = data->d3dDevice->lpVtbl->CreateCommandQueue(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateCommandQueue,
&queueDesc,
- &SDL_IID_ID3D12CommandQueue,
+ D3D_GUID(SDL_IID_ID3D12CommandQueue),
(void **)&data->commandQueue
);
if (FAILED(result)) {
@@ -816,21 +829,21 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
SDL_zero(descriptorHeapDesc);
descriptorHeapDesc.NumDescriptors = SDL_D3D12_NUM_BUFFERS;
descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
- result = data->d3dDevice->lpVtbl->CreateDescriptorHeap(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateDescriptorHeap,
&descriptorHeapDesc,
- &SDL_IID_ID3D12DescriptorHeap,
+ D3D_GUID(SDL_IID_ID3D12DescriptorHeap),
(void **)&data->rtvDescriptorHeap
);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateDescriptorHeap [rtv]"), result);
goto done;
}
- data->rtvDescriptorSize = d3dDevice->lpVtbl->GetDescriptorHandleIncrementSize(d3dDevice, D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+ data->rtvDescriptorSize = D3D_CALL(d3dDevice, GetDescriptorHandleIncrementSize, D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
descriptorHeapDesc.NumDescriptors = SDL_D3D12_MAX_NUM_TEXTURES;
- result = data->d3dDevice->lpVtbl->CreateDescriptorHeap(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateDescriptorHeap,
&descriptorHeapDesc,
- &SDL_IID_ID3D12DescriptorHeap,
+ D3D_GUID(SDL_IID_ID3D12DescriptorHeap),
(void **)&data->textureRTVDescriptorHeap
);
if (FAILED(result)) {
@@ -842,9 +855,9 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
descriptorHeapDesc.NumDescriptors = SDL_D3D12_MAX_NUM_TEXTURES;
descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
descriptorHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
- result = data->d3dDevice->lpVtbl->CreateDescriptorHeap(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateDescriptorHeap,
&descriptorHeapDesc,
- &SDL_IID_ID3D12DescriptorHeap,
+ D3D_GUID(SDL_IID_ID3D12DescriptorHeap),
(void **)&data->srvDescriptorHeap
);
if (FAILED(result)) {
@@ -852,15 +865,15 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
goto done;
}
rootDescriptorHeaps[0] = data->srvDescriptorHeap;
- data->srvDescriptorSize = d3dDevice->lpVtbl->GetDescriptorHandleIncrementSize(d3dDevice, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+ data->srvDescriptorSize = D3D_CALL(d3dDevice, GetDescriptorHandleIncrementSize, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
SDL_zero(descriptorHeapDesc);
descriptorHeapDesc.NumDescriptors = 2;
descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
descriptorHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
- result = data->d3dDevice->lpVtbl->CreateDescriptorHeap(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateDescriptorHeap,
&descriptorHeapDesc,
- &SDL_IID_ID3D12DescriptorHeap,
+ D3D_GUID(SDL_IID_ID3D12DescriptorHeap),
(void **)&data->samplerDescriptorHeap
);
if (FAILED(result)) {
@@ -868,13 +881,13 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
goto done;
}
rootDescriptorHeaps[1] = data->samplerDescriptorHeap;
- data->samplerDescriptorSize = d3dDevice->lpVtbl->GetDescriptorHandleIncrementSize(d3dDevice, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
+ data->samplerDescriptorSize = D3D_CALL(d3dDevice, GetDescriptorHandleIncrementSize, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
/* Create a command allocator for each back buffer */
for (i = 0; i < SDL_D3D12_NUM_BUFFERS; ++i) {
- result = data->d3dDevice->lpVtbl->CreateCommandAllocator(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateCommandAllocator,
D3D12_COMMAND_LIST_TYPE_DIRECT,
- &SDL_IID_ID3D12CommandAllocator,
+ D3D_GUID(SDL_IID_ID3D12CommandAllocator),
(void **)&data->commandAllocators[i]
);
if (FAILED(result)) {
@@ -884,12 +897,12 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
}
/* Create the command list */
- result = data->d3dDevice->lpVtbl->CreateCommandList(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateCommandList,
0,
D3D12_COMMAND_LIST_TYPE_DIRECT,
data->commandAllocators[0],
NULL,
- &SDL_IID_ID3D12GraphicsCommandList2,
+ D3D_GUID(SDL_IID_ID3D12GraphicsCommandList2),
(void **)&data->commandList
);
if (FAILED(result)) {
@@ -898,13 +911,13 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
}
/* Set the descriptor heaps to the correct initial value */
- data->commandList->lpVtbl->SetDescriptorHeaps(data->commandList, 2, rootDescriptorHeaps);
+ D3D_CALL(data->commandList, SetDescriptorHeaps, 2, rootDescriptorHeaps);
/* Create the fence and fence event */
- result = data->d3dDevice->lpVtbl->CreateFence(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreateFence,
data->fenceValue,
D3D12_FENCE_FLAG_NONE,
- &SDL_IID_ID3D12Fence,
+ D3D_GUID(SDL_IID_ID3D12Fence),
(void **)&data->fence
);
if (FAILED(result)) {
@@ -923,12 +936,12 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
/* Create all the root signatures */
for (i = 0; i < NUM_ROOTSIGS; ++i) {
D3D12_SHADER_BYTECODE rootSigData;
- D3D12_GetRootSignatureData(i, &rootSigData);
- result = data->d3dDevice->lpVtbl->CreateRootSignature(data->d3dDevice,
+ D3D12_GetRootSignatureData((D3D12_RootSignature) i, &rootSigData);
+ result = D3D_CALL(data->d3dDevice, CreateRootSignature,
0,
rootSigData.pShaderBytecode,
rootSigData.BytecodeLength,
- &SDL_IID_ID3D12RootSignature,
+ D3D_GUID(SDL_IID_ID3D12RootSignature),
(void **)&data->rootSignatures[i]
);
if (FAILED(result)) {
@@ -943,7 +956,7 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
for (j = 0; j < SDL_arraysize(defaultBlendModes); ++j) {
for (k = D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT; k < D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH; ++k) {
for (l = 0; l < SDL_arraysize(defaultRTVFormats); ++l) {
- if (!D3D12_CreatePipelineState(renderer, i, defaultBlendModes[j], k, defaultRTVFormats[l])) {
+ if (!D3D12_CreatePipelineState(renderer, (D3D12_Shader) i, defaultBlendModes[j], (D3D12_PRIMITIVE_TOPOLOGY_TYPE) k, defaultRTVFormats[l])) {
/* D3D12_CreatePipelineState will set the SDL error, if it fails */
goto done;
}
@@ -955,10 +968,10 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
/* Create a vertex buffer heap and populate it with resources */
SDL_zero(vbufferHeapDesc);
vbufferHeapDesc.SizeInBytes = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT * SDL_D3D12_NUM_VERTEX_BUFFERS;
- data->d3dDevice->lpVtbl->GetCustomHeapProperties(data->d3dDevice, &vbufferHeapDesc.Properties, 0, D3D12_HEAP_TYPE_UPLOAD);
+ D3D_CALL_RET(data->d3dDevice, GetCustomHeapProperties, &vbufferHeapDesc.Properties, 0, D3D12_HEAP_TYPE_UPLOAD);
vbufferHeapDesc.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT;
vbufferHeapDesc.Flags = D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS;
- result = data->d3dDevice->lpVtbl->CreateHeap(data->d3dDevice, &vbufferHeapDesc, &SDL_IID_ID3D12Heap, (void **)&data->vertexBufferHeap);
+ result = D3D_CALL(data->d3dDevice, CreateHeap, &vbufferHeapDesc, D3D_GUID(SDL_IID_ID3D12Heap), (void **)&data->vertexBufferHeap);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("ID3D12Device::CreateHeap"), result);
goto done;
@@ -978,13 +991,13 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
vbufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
for (i = 0; i < SDL_D3D12_NUM_VERTEX_BUFFERS; ++i) {
- result = data->d3dDevice->lpVtbl->CreatePlacedResource(data->d3dDevice,
+ result = D3D_CALL(data->d3dDevice, CreatePlacedResource,
data->vertexBufferHeap,
i * D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,
&vbufferDesc,
D3D12_RESOURCE_STATE_GENERIC_READ,
NULL,
- &SDL_IID_ID3D12Resource,
+ D3D_GUID(SDL_IID_ID3D12Resource),
(void **)&data->vertexBuffers[i].resource
);
@@ -993,7 +1006,7 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
goto done;
}
- data->vertexBuffers[i].view.BufferLocation = data->vertexBuffers[i].resource->lpVtbl->GetGPUVirtualAddress(data->vertexBuffers[i].resource);
+ data->vertexBuffers[i].view.BufferLocation = D3D_CALL(data->vertexBuffers[i].resource, GetGPUVirtualAddress);
data->vertexBuffers[i].view.StrideInBytes = sizeof(VertexPositionColor);
}
@@ -1008,12 +1021,12 @@ D3D12_CreateDeviceResources(SDL_Renderer* renderer)
samplerDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;
samplerDesc.MinLOD = 0.0f;
samplerDesc.MaxLOD = D3D12_FLOAT32_MAX;
- data->samplerDescriptorHeap->lpVtbl->GetCPUDescriptorHandleForHeapStart(data->samplerDescriptorHeap, &data->nearestPixelSampler);
- data->d3dDevice->lpVtbl->CreateSampler(data->d3dDevice, &samplerDesc, data->nearestPixelSampler);
+ D3D_CALL_RET(data->samplerDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &data->nearestPixelSampler);
+ D3D_CALL(data->d3dDevice, CreateSampler, &samplerDesc, data->nearestPixelSampler);
samplerDesc.Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR;
data->linearSampler.ptr = data->nearestPixelSampler.ptr + data->samplerDescriptorSize;
- data->d3dDevice->lpVtbl->CreateSampler(data->d3dDevice, &samplerDesc, data->linearSampler);
+ D3D_CALL(data->d3dDevice, CreateSampler, &samplerDesc, data->linearSampler);
/* Initialize the pool allocator for SRVs */
for (i = 0; i < SDL_D3D12_MAX_NUM_TEXTURES; ++i) {
@@ -1133,7 +1146,7 @@ D3D12_CreateSwapChain(SDL_Renderer * renderer, int w, int h)
SDL_VERSION(&windowinfo.version);
SDL_GetWindowWMInfo(renderer->window, &windowinfo);
- result = data->dxgiFactory->lpVtbl->CreateSwapChainForHwnd(data->dxgiFactory,
+ result = D3D_CALL(data->dxgiFactory, CreateSwapChainForHwnd,
(IUnknown *)data->commandQueue,
windowinfo.info.win.window,
&swapChainDesc,
@@ -1146,9 +1159,9 @@ D3D12_CreateSwapChain(SDL_Renderer * renderer, int w, int h)
goto done;
}
- data->dxgiFactory->lpVtbl->MakeWindowAssociation(data->dxgiFactory, windowinfo.info.win.window, DXGI_MWA_NO_WINDOW_CHANGES);
+ D3D_CALL(data->dxgiFactory, MakeWindowAssociation, windowinfo.info.win.window, DXGI_MWA_NO_WINDOW_CHANGES);
- result = swapChain->lpVtbl->QueryInterface(swapChain, &SDL_IID_IDXGISwapChain4, (void **)&data->swapChain);
+ result = D3D_CALL(swapChain, QueryInterface, D3D_GUID(SDL_IID_IDXGISwapChain4), (void **)&data->swapChain);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain1::QueryInterface"), result);
goto done;
@@ -1157,7 +1170,7 @@ D3D12_CreateSwapChain(SDL_Renderer * renderer, int w, int h)
/* Ensure that the swapchain does not queue more than one frame at a time. This both reduces latency
* and ensures that the application will only render after each VSync, minimizing power consumption.
*/
- result = data->swapChain->lpVtbl->SetMaximumFrameLatency(data->swapChain, 1);
+ result = D3D_CALL(data->swapChain, SetMaximumFrameLatency, 1);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain4::SetMaximumFrameLatency"), result);
goto done;
@@ -1230,7 +1243,7 @@ D3D12_CreateWindowSizeDependentResources(SDL_Renderer * renderer)
if (data->swapChain) {
/* If the swap chain already exists, resize it. */
- result = data->swapChain->lpVtbl->ResizeBuffers(data->swapChain,
+ result = D3D_CALL(data->swapChain, ResizeBuffers,
0,
w, h,
DXGI_FORMAT_UNKNOWN,
@@ -1258,7 +1271,7 @@ D3D12_CreateWindowSizeDependentResources(SDL_Renderer * renderer)
/* Set the proper rotation for the swap chain. */
if (WIN_IsWindows8OrGreater()) {
if (data->swapEffect == DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL) {
- result = data->swapChain->lpVtbl->SetRotation(data->swapChain, data->rotation);
+ result = D3D_CALL(data->swapChain, SetRotation, data->rotation);
if (FAILED(result)) {
WIN_SetErrorFromHRESULT(SDL_COMPOSE_ERROR("IDXGISwapChain4::SetRotation"), result);
goto done;
@@ -1268,9 +1281,9 @@ D3D12_CreateWindowSizeDependentResources(SDL_Renderer * renderer)
/* Get each back buffer render target and create render target views */
for (i = 0; i < SDL_D3D12_NUM_BUFFERS; ++i) {
- result = data->swapChain->lpVtbl->GetBuffer(data->swapChain,
+ result = D3D_CALL(data->swapChain, GetBuffer,
i,
- &SDL_IID_ID3D12Resource,
+ D3D_GUID(SDL_IID_ID3D12Resource),
(void **) &data->renderTargets[i]
);
if (FAILED(result)) {
@@ -1283,20 +1296,20 @@ D3D12_CreateWindowSizeDependentResources(SDL_Renderer * renderer)
rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
SDL_zero(rtvDescriptor);
- data->rtvDescriptorHeap->lpVtbl->GetCPUDescriptorHandleForHeapStart(data->rtvDescriptorHeap, &rtvDescriptor);
+ D3D_CALL_RET(data->rtvDescriptorHeap, GetCPUDescriptorHandleForHeapStart, &rtvDescriptor);
rtvDescriptor.ptr += i * data->rtvDescriptorSize;
- data->d3dDevice->lpVtbl->CreateRenderTargetView(data->d3dDevice, data->renderTargets[i], &rtvDesc, rtvDescriptor);
+ D3D_CALL(data->d3dDevice, CreateRenderTargetView, data->renderTargets[i], &rtvDesc, rtvDescriptor);
}
/* Set back buffer index to current buffer */
- data->currentBackBufferIndex = data->swapChain->lpVtbl->GetCurrentBackBufferIndex(data->swapChain);
+ data->currentBackBufferIndex = D3D_CALL(data->swapChain, GetCurrentBackBufferIndex);
/* Set the swap chain target immediately, so that a target is always set
* even before we get to SetDrawState. Without this it's possible to hit
* null references in places like ReadPixels!
*/
data->currentRenderTargetView = D3D12_GetCurrentRenderTargetView(renderer);
- data->commandList->lpVtbl->OMSetRenderTargets(data->commandList, 1, &data->currentRenderTargetView, FALSE, NULL);
+ D3D_CALL(data->commandList, OMSetRenderTargets, 1, &data->currentRenderTargetView, FALSE, NULL);
D3D12_TransitionResource(data,
data->renderTargets[data->currentBackBufferIndex],
D3D12_RESOURCE_STATE_PRESENT,
@@ -1352,7 +1365,7 @@ D3D12_GetAvailableSRVIndex(SDL_Renderer * renderer)
D3D12_RenderData* rendererData = (D3D12_RenderData*)renderer->driverdata;
if (rendererData->srvPoolHead) {
SIZE_T index = rendererData->srvPoolHead->index;
- rendererData->srvPoolHead = rendererData->srvPoolHead->next;
+ rendererData->srvPoolHead = (D3D12_SRVPoolNode*)(rendererData->srvPoolHead->next);
return index;
} else {
SDL_SetError("[d3d12] Cannot allocate more than %d textures!", SDL_D3D12_MAX_NUM_TEXTURES);
@@ -1403,7 +1416,7 @@ D3D12_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
textureDesc.SampleDesc.Count = 1;
textureDesc.SampleDesc.Quality = 0;
textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
- textureDesc.Flags = 0;
+ textureDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
if (texture->access == SDL_TEXTUREACCESS_TARGET) {
textureDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
@@ -1414,13 +1427,13 @@ D3D12_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
- result = rendererData->d3dDevice->lpVtbl->CreateCommittedResource(rendererData->d3dDevice,
+ result = D3D_CALL(rendererData->d3dDevice, CreateCommittedResource,
&heapProps,
D3D12_HEAP_FLAG_NONE,
&textureDesc,
D3D12_RESOURCE_STATE_COPY_DEST,
NULL,
- &SDL_IID_ID3D12Resource,
+ D3D_GUID(SDL_IID_ID3D12Resource),
(void **)&textureData->mainTexture
);
textureData->mainResourceState = D3D12_RESOURCE_STATE_COPY_DEST;
@@ -1436,13 +1449,13 @@ D3D12_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
textureDesc.Width = (textureDesc.Width + 1) / 2;
textureDesc.Height = (textureDesc.Height + 1) / 2;
- result = rendererData->d3dDevice->lpVtbl->CreateCommittedResource(rendererData->d3dDevice,
+ result = D3D_CALL(rendererData->d3dDevice, CreateCommittedResource,
&heapProps,
D3D12_HEAP_FLAG_NONE,
&textureDesc,
D3D12_RESOURCE_STATE_COPY_DEST,
NULL,
- &SDL_IID_ID3D12Resource,
+ D3D_GUID(SDL_IID_ID3D12Resource),
(void **)&textureData->mainTextureU
);
textureData->mainResourceStateU = D3D12_RESOURCE_STATE_COPY_DEST;
@@ -
(Patch may be truncated, please check the link at the top of this post.)