mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-01-29 00:33:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1181 from vlj/d3d12

Browse Source 
D3d12: Fixes
This commit is contained in:
Raul Tambre 2015-08-15 10:31:35 +03:00
commit a3dc623270
9 changed files with 156 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
rpcs3/Emu/RSX/D3D12/D3D12.h
View File

@ -3,19 +3,24 @@
#include <d3d12.h>
#include <cassert>
#include <wrl/client.h>
#include "utilities/Log.h"
#include "Emu/Memory/vm.h"
#include "Emu/RSX/GCM.h"
#pragma comment (lib, "dxgi.lib")
using namespace Microsoft::WRL;
#define SAFE_RELEASE(x) if (x) x->Release();
inline
void check(HRESULT hr)
// From DX12 D3D11On12 Sample (MIT Licensed)
inline void ThrowIfFailed(HRESULT hr)
{
if (hr != 0)
abort();
if (FAILED(hr))
{
throw;
}
}
/**

18
rpcs3/Emu/RSX/D3D12/D3D12Buffer.cpp
View File

@ -205,7 +205,7 @@ ID3D12Resource *createVertexBuffer(const VertexBufferFormat &vbf, const RSXVerte
size_t heapOffset = vertexIndexHeap.alloc(subBufferSize);
ID3D12Resource *vertexBuffer;
check(device->CreatePlacedResource(
ThrowIfFailed(device->CreatePlacedResource(
vertexIndexHeap.m_heap,
heapOffset,
&getBufferResourceDesc(subBufferSize),
@ -214,7 +214,7 @@ ID3D12Resource *createVertexBuffer(const VertexBufferFormat &vbf, const RSXVerte
IID_PPV_ARGS(&vertexBuffer)
));
void *bufferMap;
check(vertexBuffer->Map(0, nullptr, (void**)&bufferMap));
ThrowIfFailed(vertexBuffer->Map(0, nullptr, (void**)&bufferMap));
memset(bufferMap, -1, subBufferSize);
#pragma omp parallel for
for (int vertex = 0; vertex < vbf.elementCount; vertex++)
@ -279,7 +279,7 @@ std::vector<D3D12_VERTEX_BUFFER_VIEW> D3D12GSRender::UploadVertexBuffers(bool in
{
std::vector<D3D12_VERTEX_BUFFER_VIEW> result;
const std::vector<VertexBufferFormat> &vertexBufferFormat = FormatVertexData(m_vertex_data);
m_IASet = getIALayout(m_device, vertexBufferFormat, m_vertex_data);
m_IASet = getIALayout(m_device.Get(), vertexBufferFormat, m_vertex_data);
const u32 data_offset = indexed_draw ? 0 : m_draw_array_first;
@ -302,7 +302,7 @@ std::vector<D3D12_VERTEX_BUFFER_VIEW> D3D12GSRender::UploadVertexBuffers(bool in
vertexBuffer = It->second;
else
{
vertexBuffer = createVertexBuffer(vbf, m_vertex_data, m_device, m_vertexIndexData);
vertexBuffer = createVertexBuffer(vbf, m_vertex_data, m_device.Get(), m_vertexIndexData);
m_vertexCache[key] = vertexBuffer;
}
@ -405,7 +405,7 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
size_t heapOffset = m_vertexIndexData.alloc(subBufferSize);
ID3D12Resource *indexBuffer;
check(m_device->CreatePlacedResource(
ThrowIfFailed(m_device->CreatePlacedResource(
m_vertexIndexData.m_heap,
heapOffset,
&getBufferResourceDesc(subBufferSize),
@ -415,7 +415,7 @@ D3D12_INDEX_BUFFER_VIEW D3D12GSRender::uploadIndexBuffers(bool indexed_draw)
));
void *bufferMap;
check(indexBuffer->Map(0, nullptr, (void**)&bufferMap));
ThrowIfFailed(indexBuffer->Map(0, nullptr, (void**)&bufferMap));
if (indexed_draw && !forcedIndexBuffer)
streamBuffer(bufferMap, m_indexed_array.m_data.data(), subBufferSize);
else if (indexed_draw && forcedIndexBuffer)
@ -499,7 +499,7 @@ void D3D12GSRender::setScaleOffset()
D3D12_RANGE range = { heapOffset, heapOffset + 256 };
void *scaleOffsetMap;
check(m_constantsData.m_heap->Map(0, &range, &scaleOffsetMap));
ThrowIfFailed(m_constantsData.m_heap->Map(0, &range, &scaleOffsetMap));
streamToBuffer((char*)scaleOffsetMap + heapOffset, scaleOffsetMat, 16 * sizeof(float));
int isAlphaTested = m_set_alpha_test;
memcpy((char*)scaleOffsetMap + heapOffset + 16 * sizeof(float), &isAlphaTested, sizeof(int));
@ -531,7 +531,7 @@ void D3D12GSRender::FillVertexShaderConstantsBuffer()
D3D12_RANGE range = { heapOffset, heapOffset + bufferSize };
void *constantsBufferMap;
check(m_constantsData.m_heap->Map(0, &range, &constantsBufferMap));
ThrowIfFailed(m_constantsData.m_heap->Map(0, &range, &constantsBufferMap));
for (const auto &vertexConstants : m_vertexConstants)
{
float data[4] = {
@ -568,7 +568,7 @@ void D3D12GSRender::FillPixelShaderConstantsBuffer()
size_t offset = 0;
void *constantsBufferMap;
check(m_constantsData.m_heap->Map(0, &range, &constantsBufferMap));
ThrowIfFailed(m_constantsData.m_heap->Map(0, &range, &constantsBufferMap));
for (size_t offsetInFP : fragmentOffset)
{
u32 vector[4];

145
rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp
View File

@ -119,31 +119,31 @@ void D3D12GSRender::ResourceStorage::Init(ID3D12Device *device)
// Create a global command allocator
device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_commandAllocator));
device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_textureUploadCommandAllocator));
check(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COPY, IID_PPV_ARGS(&m_downloadCommandAllocator)));
ThrowIfFailed(device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_COPY, IID_PPV_ARGS(&m_downloadCommandAllocator)));
D3D12_DESCRIPTOR_HEAP_DESC descriptorHeapDesc = {};
descriptorHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
descriptorHeapDesc.NumDescriptors = 10000; // For safety
descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
check(device->CreateDescriptorHeap(&descriptorHeapDesc, IID_PPV_ARGS(&m_constantsBufferDescriptorsHeap)));
ThrowIfFailed(device->CreateDescriptorHeap(&descriptorHeapDesc, IID_PPV_ARGS(&m_constantsBufferDescriptorsHeap)));
descriptorHeapDesc = {};
descriptorHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
descriptorHeapDesc.NumDescriptors = 10000; // For safety
descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
check(device->CreateDescriptorHeap(&descriptorHeapDesc, IID_PPV_ARGS(&m_scaleOffsetDescriptorHeap)));
ThrowIfFailed(device->CreateDescriptorHeap(&descriptorHeapDesc, IID_PPV_ARGS(&m_scaleOffsetDescriptorHeap)));
D3D12_DESCRIPTOR_HEAP_DESC textureDescriptorDesc = {};
textureDescriptorDesc.NumDescriptors = 10000; // For safety
textureDescriptorDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
textureDescriptorDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
check(device->CreateDescriptorHeap(&textureDescriptorDesc, IID_PPV_ARGS(&m_textureDescriptorsHeap)));
ThrowIfFailed(device->CreateDescriptorHeap(&textureDescriptorDesc, IID_PPV_ARGS(&m_textureDescriptorsHeap)));
textureDescriptorDesc.NumDescriptors = 2048; // For safety
textureDescriptorDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
check(device->CreateDescriptorHeap(&textureDescriptorDesc, IID_PPV_ARGS(&m_samplerDescriptorHeap[0])));
check(device->CreateDescriptorHeap(&textureDescriptorDesc, IID_PPV_ARGS(&m_samplerDescriptorHeap[1])));
ThrowIfFailed(device->CreateDescriptorHeap(&textureDescriptorDesc, IID_PPV_ARGS(&m_samplerDescriptorHeap[0])));
ThrowIfFailed(device->CreateDescriptorHeap(&textureDescriptorDesc, IID_PPV_ARGS(&m_samplerDescriptorHeap[1])));
}
void D3D12GSRender::ResourceStorage::Release()
@ -203,8 +203,18 @@ bool D3D12GSRender::invalidateTexture(u32 addr)
return handled;
}
D3D12DLLManagement::D3D12DLLManagement()
{
loadD3D12FunctionPointers();
}
D3D12DLLManagement::~D3D12DLLManagement()
{
unloadD3D12FunctionPointers();
}
D3D12GSRender::D3D12GSRender()
: GSRender(), m_PSO(nullptr)
: GSRender(), m_D3D12Lib(), m_PSO(nullptr)
{
gfxHandler = [this](u32 addr) {
bool result = invalidateTexture(addr);
@ -212,7 +222,6 @@ D3D12GSRender::D3D12GSRender()
LOG_WARNING(RSX, "Reporting Cell writing to %x", addr);
return result;
};
loadD3D12FunctionPointers();
if (Ini.GSDebugOutputEnable.GetValue())
{
Microsoft::WRL::ComPtr<ID3D12Debug> debugInterface;
@ -221,13 +230,13 @@ D3D12GSRender::D3D12GSRender()
}
Microsoft::WRL::ComPtr<IDXGIFactory4> dxgiFactory;
check(CreateDXGIFactory(IID_PPV_ARGS(&dxgiFactory)));
ThrowIfFailed(CreateDXGIFactory(IID_PPV_ARGS(&dxgiFactory)));
// Create adapter
IDXGIAdapter* adaptater = nullptr;
switch (Ini.GSD3DAdaptater.GetValue())
{
case 0: // WARP
check(dxgiFactory->EnumWarpAdapter(IID_PPV_ARGS(&adaptater)));
ThrowIfFailed(dxgiFactory->EnumWarpAdapter(IID_PPV_ARGS(&adaptater)));
break;
case 1: // Default
dxgiFactory->EnumAdapters(0, &adaptater);
@ -236,14 +245,13 @@ D3D12GSRender::D3D12GSRender()
dxgiFactory->EnumAdapters(Ini.GSD3DAdaptater.GetValue() - 2,&adaptater);
break;
}
check(wrapD3D12CreateDevice(adaptater, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device)));
ThrowIfFailed(wrapD3D12CreateDevice(adaptater, D3D_FEATURE_LEVEL_11_0, IID_PPV_ARGS(&m_device)));
// Queues
D3D12_COMMAND_QUEUE_DESC copyQueueDesc = {}, graphicQueueDesc = {};
copyQueueDesc.Type = D3D12_COMMAND_LIST_TYPE_COPY;
graphicQueueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
check(m_device->CreateCommandQueue(&copyQueueDesc, IID_PPV_ARGS(&m_commandQueueCopy)));
check(m_device->CreateCommandQueue(&graphicQueueDesc, IID_PPV_ARGS(&m_commandQueueGraphic)));
ThrowIfFailed(m_device->CreateCommandQueue(&graphicQueueDesc, IID_PPV_ARGS(m_commandQueueGraphic.GetAddressOf())));
g_descriptorStrideSRVCBVUAV = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
g_descriptorStrideDSV = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
@ -266,7 +274,7 @@ D3D12GSRender::D3D12GSRender()
swapChain.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
swapChain.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
check(dxgiFactory->CreateSwapChain(m_commandQueueGraphic, &swapChain, (IDXGISwapChain**)&m_swapChain));
ThrowIfFailed(dxgiFactory->CreateSwapChain(m_commandQueueGraphic.Get(), &swapChain, (IDXGISwapChain**)m_swapChain.GetAddressOf()));
m_swapChain->GetBuffer(0, IID_PPV_ARGS(&m_backBuffer[0]));
m_swapChain->GetBuffer(1, IID_PPV_ARGS(&m_backBuffer[1]));
@ -277,9 +285,9 @@ D3D12GSRender::D3D12GSRender()
rttDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
rttDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
m_device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_backbufferAsRendertarget[0]));
m_device->CreateRenderTargetView(m_backBuffer[0], &rttDesc, m_backbufferAsRendertarget[0]->GetCPUDescriptorHandleForHeapStart());
m_device->CreateRenderTargetView(m_backBuffer[0].Get(), &rttDesc, m_backbufferAsRendertarget[0]->GetCPUDescriptorHandleForHeapStart());
m_device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_backbufferAsRendertarget[1]));
m_device->CreateRenderTargetView(m_backBuffer[1], &rttDesc, m_backbufferAsRendertarget[1]->GetCPUDescriptorHandleForHeapStart());
m_device->CreateRenderTargetView(m_backBuffer[1].Get(), &rttDesc, m_backbufferAsRendertarget[1]->GetCPUDescriptorHandleForHeapStart());
// Common root signatures
for (unsigned textureCount = 0; textureCount < 17; textureCount++)
@ -326,25 +334,25 @@ D3D12GSRender::D3D12GSRender()
Microsoft::WRL::ComPtr<ID3DBlob> rootSignatureBlob;
Microsoft::WRL::ComPtr<ID3DBlob> errorBlob;
check(wrapD3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &rootSignatureBlob, &errorBlob));
ThrowIfFailed(wrapD3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &rootSignatureBlob, &errorBlob));
m_device->CreateRootSignature(0,
rootSignatureBlob->GetBufferPointer(),
rootSignatureBlob->GetBufferSize(),
IID_PPV_ARGS(&m_rootSignatures[textureCount]));
IID_PPV_ARGS(m_rootSignatures[textureCount].GetAddressOf()));
}
m_perFrameStorage[0].Init(m_device);
m_perFrameStorage[0].Init(m_device.Get());
m_perFrameStorage[0].Reset();
m_perFrameStorage[1].Init(m_device);
m_perFrameStorage[1].Init(m_device.Get());
m_perFrameStorage[1].Reset();
initConvertShader();
m_outputScalingPass.Init(m_device);
m_outputScalingPass.Init(m_device.Get());
D3D12_HEAP_PROPERTIES hp = {};
hp.Type = D3D12_HEAP_TYPE_DEFAULT;
check(
ThrowIfFailed(
m_device->CreateCommittedResource(
&hp,
D3D12_HEAP_FLAG_NONE,
@ -354,14 +362,14 @@ D3D12GSRender::D3D12GSRender()
IID_PPV_ARGS(&m_dummyTexture))
);
m_readbackResources.Init(m_device, 1024 * 1024 * 128, D3D12_HEAP_TYPE_READBACK, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS);
m_UAVHeap.Init(m_device, 1024 * 1024 * 128, D3D12_HEAP_TYPE_DEFAULT, D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES);
m_readbackResources.Init(m_device.Get(), 1024 * 1024 * 128, D3D12_HEAP_TYPE_READBACK, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS);
m_UAVHeap.Init(m_device.Get(), 1024 * 1024 * 128, D3D12_HEAP_TYPE_DEFAULT, D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES);
m_rtts.Init(m_device);
m_rtts.Init(m_device.Get());
m_constantsData.Init(m_device, 1024 * 1024 * 64, D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_FLAG_NONE);
m_vertexIndexData.Init(m_device, 1024 * 1024 * 384, D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS);
m_textureUploadData.Init(m_device, 1024 * 1024 * 256, D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS);
m_constantsData.Init(m_device.Get(), 1024 * 1024 * 64, D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_FLAG_NONE);
m_vertexIndexData.Init(m_device.Get(), 1024 * 1024 * 384, D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS);
m_textureUploadData.Init(m_device.Get(), 1024 * 1024 * 256, D3D12_HEAP_TYPE_UPLOAD, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS);
}
D3D12GSRender::~D3D12GSRender()
@ -378,23 +386,12 @@ D3D12GSRender::~D3D12GSRender()
m_convertRootSignature->Release();
m_perFrameStorage[0].Release();
m_perFrameStorage[1].Release();
m_commandQueueGraphic->Release();
m_commandQueueCopy->Release();
m_backbufferAsRendertarget[0]->Release();
m_backBuffer[0]->Release();
m_backbufferAsRendertarget[1]->Release();
m_backBuffer[1]->Release();
m_rtts.Release();
for (unsigned i = 0; i < 17; i++)
m_rootSignatures[i]->Release();
for (auto &tmp : m_texToClean)
tmp->Release();
for (auto &tmp : m_texturesCache)
tmp.second->Release();
m_swapChain->Release();
m_outputScalingPass.Release();
m_device->Release();
unloadD3D12FunctionPointers();
}
void D3D12GSRender::Close()
@ -431,12 +428,12 @@ void D3D12GSRender::Clear(u32 cmd)
{
assert(cmd == NV4097_CLEAR_SURFACE);
PrepareRenderTargets();
ID3D12GraphicsCommandList *commandList;
check(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList)));
ThrowIfFailed(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList)));
getCurrentResourceStorage().m_inflightCommandList.push_back(commandList);
PrepareRenderTargets(commandList);
/* if (m_set_color_mask)
{
glColorMask(m_color_mask_r, m_color_mask_g, m_color_mask_b, m_color_mask_a);
@ -503,13 +500,17 @@ void D3D12GSRender::Clear(u32 cmd)
}
}
check(commandList->Close());
ThrowIfFailed(commandList->Close());
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**) &commandList);
}
void D3D12GSRender::Draw()
{
PrepareRenderTargets();
ID3D12GraphicsCommandList *commandList;
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList));
getCurrentResourceStorage().m_inflightCommandList.push_back(commandList);
PrepareRenderTargets(commandList);
// Init vertex count
// TODO: Very hackish, clean this
@ -536,11 +537,6 @@ void D3D12GSRender::Draw()
}
}
ID3D12GraphicsCommandList *commandList;
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList));
getCurrentResourceStorage().m_inflightCommandList.push_back(commandList);
std::chrono::time_point<std::chrono::system_clock> startVertexTime = std::chrono::system_clock::now();
if (m_indexed_array.m_count || m_draw_array_count)
{
@ -560,7 +556,7 @@ void D3D12GSRender::Draw()
return;
}
commandList->SetGraphicsRootSignature(m_rootSignatures[m_PSO->second]);
commandList->SetGraphicsRootSignature(m_rootSignatures[m_PSO->second].Get());
commandList->OMSetStencilRef(m_stencil_func_ref);
// Constants
@ -588,7 +584,7 @@ void D3D12GSRender::Draw()
if (m_PSO->second > 0)
{
std::chrono::time_point<std::chrono::system_clock> startTextureTime = std::chrono::system_clock::now();
size_t usedTexture = UploadTextures();
size_t usedTexture = UploadTextures(commandList);
// Fill empty slots
for (; usedTexture < m_PSO->second; usedTexture++)
@ -717,7 +713,7 @@ void D3D12GSRender::Draw()
else
commandList->DrawInstanced((UINT)m_renderingInfo.m_count, 1, (UINT)m_renderingInfo.m_baseVertex, 0);
check(commandList->Close());
ThrowIfFailed(commandList->Close());
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)&commandList);
m_indexed_array.Reset();
}
@ -772,7 +768,7 @@ void D3D12GSRender::Flip()
assert(m_textureUploadData.canAlloc(textureSize));
size_t heapOffset = m_textureUploadData.alloc(textureSize);
check(m_device->CreatePlacedResource(
ThrowIfFailed(m_device->CreatePlacedResource(
m_textureUploadData.m_heap,
heapOffset,
&getBufferResourceDesc(textureSize),
@ -783,13 +779,13 @@ void D3D12GSRender::Flip()
m_textureUploadData.m_resourceStoredSinceLastSync.push_back(std::make_tuple(heapOffset, textureSize, stagingTexture));
void *dstBuffer;
check(stagingTexture->Map(0, nullptr, &dstBuffer));
ThrowIfFailed(stagingTexture->Map(0, nullptr, &dstBuffer));
for (unsigned row = 0; row < h; row++)
memcpy((char*)dstBuffer + row * rowPitch, (char*)src_buffer + row * w * 4, w * 4);
stagingTexture->Unmap(0, nullptr);
}
check(
ThrowIfFailed(
m_device->CreateCommittedResource(
&heapProp,
D3D12_HEAP_FLAG_NONE,
@ -817,11 +813,12 @@ void D3D12GSRender::Flip()
}
else
{
commandList->ResourceBarrier(1, &getResourceBarrierTransition(m_rtts.m_currentlyBoundRenderTargets[0], D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_GENERIC_READ));
if (m_rtts.m_currentlyBoundRenderTargets[0] != nullptr)
commandList->ResourceBarrier(1, &getResourceBarrierTransition(m_rtts.m_currentlyBoundRenderTargets[0], D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_GENERIC_READ));
resourceToFlip = m_rtts.m_currentlyBoundRenderTargets[0];
}
commandList->ResourceBarrier(1, &getResourceBarrierTransition(m_backBuffer[m_swapChain->GetCurrentBackBufferIndex()], D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET));
commandList->ResourceBarrier(1, &getResourceBarrierTransition(m_backBuffer[m_swapChain->GetCurrentBackBufferIndex()].Get(), D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET));
D3D12_VIEWPORT viewport =
{
@ -890,16 +887,16 @@ void D3D12GSRender::Flip()
vbv.SizeInBytes = 16 * sizeof(float);
commandList->IASetVertexBuffers(0, 1, &vbv);
commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
if (m_rtts.m_currentlyBoundRenderTargets[0] != nullptr)
commandList->DrawInstanced(4, 1, 0, 0);
commandList->DrawInstanced(4, 1, 0, 0);
commandList->ResourceBarrier(1, &getResourceBarrierTransition(m_backBuffer[m_swapChain->GetCurrentBackBufferIndex()], D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT));
if (isFlipSurfaceInLocalMemory(m_surface_color_target))
commandList->ResourceBarrier(1, &getResourceBarrierTransition(m_backBuffer[m_swapChain->GetCurrentBackBufferIndex()].Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT));
if (isFlipSurfaceInLocalMemory(m_surface_color_target) && m_rtts.m_currentlyBoundRenderTargets[0] != nullptr)
commandList->ResourceBarrier(1, &getResourceBarrierTransition(m_rtts.m_currentlyBoundRenderTargets[0], D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_RENDER_TARGET));
check(commandList->Close());
ThrowIfFailed(commandList->Close());
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)&commandList);
check(m_swapChain->Present(Ini.GSVSyncEnable.GetValue() ? 1 : 0, 0));
ThrowIfFailed(m_swapChain->Present(Ini.GSVSyncEnable.GetValue() ? 1 : 0, 0));
// Add an event signaling queue completion
ResourceStorage &storage = getNonCurrentResourceStorage();
@ -996,7 +993,7 @@ ID3D12Resource * D3D12GSRender::writeColorBuffer(ID3D12Resource * RTT, ID3D12Gra
size_t heapOffset = m_readbackResources.alloc(sizeInByte);
resdesc = getBufferResourceDesc(sizeInByte);
check(
ThrowIfFailed(
m_device->CreatePlacedResource(
m_readbackResources.m_heap,
heapOffset,
@ -1030,7 +1027,7 @@ static
void copyToCellRamAndRelease(void *dstAddress, ID3D12Resource *res, size_t dstPitch, size_t srcPitch, size_t width, size_t height)
{
void *srcBuffer;
check(res->Map(0, nullptr, &srcBuffer));
ThrowIfFailed(res->Map(0, nullptr, &srcBuffer));
for (unsigned row = 0; row < height; row++)
memcpy((char*)dstAddress + row * dstPitch, (char*)srcBuffer + row * srcPitch, srcPitch);
res->Unmap(0, nullptr);
@ -1050,7 +1047,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
ID3D12Fence *fence;
check(
ThrowIfFailed(
m_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&fence))
);
HANDLE handle = CreateEvent(0, FALSE, FALSE, 0);
@ -1076,7 +1073,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
assert(m_UAVHeap.canAlloc(sizeInByte));
size_t heapOffset = m_UAVHeap.alloc(sizeInByte);
check(
ThrowIfFailed(
m_device->CreatePlacedResource(
m_UAVHeap.m_heap,
heapOffset,
@ -1093,7 +1090,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
heapOffset = m_readbackResources.alloc(sizeInByte);
resdesc = getBufferResourceDesc(sizeInByte);
check(
ThrowIfFailed(
m_device->CreatePlacedResource(
m_readbackResources.m_heap,
heapOffset,
@ -1105,7 +1102,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
);
m_readbackResources.m_resourceStoredSinceLastSync.push_back(std::make_tuple(heapOffset, sizeInByte, writeDest));
check(
ThrowIfFailed(
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&convertCommandList))
);
@ -1113,7 +1110,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
descriptorHeapDesc.NumDescriptors = 2;
descriptorHeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
descriptorHeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
check(
ThrowIfFailed(
m_device->CreateDescriptorHeap(&descriptorHeapDesc, IID_PPV_ARGS(&descriptorHeap))
);
D3D12_CPU_DESCRIPTOR_HANDLE Handle = descriptorHeap->GetCPUDescriptorHandleForHeapStart();
@ -1164,14 +1161,14 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
convertCommandList->ResourceBarrier(2, barriers);
convertCommandList->ResourceBarrier(1, &getResourceBarrierTransition(depthConverted, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_SOURCE));
check(convertCommandList->Close());
ThrowIfFailed(convertCommandList->Close());
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)&convertCommandList);
}
ID3D12GraphicsCommandList *downloadCommandList;
if (needTransfer)
{
check(
ThrowIfFailed(
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&downloadCommandList))
);
}
@ -1237,7 +1234,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
}
if (needTransfer)
{
check(downloadCommandList->Close());
ThrowIfFailed(downloadCommandList->Close());
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)&downloadCommandList);
}
@ -1259,7 +1256,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
auto ptr = vm::get_ptr<void>(address);
char *ptrAsChar = (char*)ptr;
unsigned char *writeDestPtr;
check(writeDest->Map(0, nullptr, (void**)&writeDestPtr));
ThrowIfFailed(writeDest->Map(0, nullptr, (void**)&writeDestPtr));
// TODO : this should be done by the gpu
for (unsigned row = 0; row < m_surface_clip_h; row++)
{

50
rpcs3/Emu/RSX/D3D12/D3D12GSRender.h
View File

@ -82,7 +82,7 @@ struct InitHeap<ID3D12Heap>
heapDesc.SizeInBytes = heapSize;
heapDesc.Properties.Type = type;
heapDesc.Flags = flags;
check(device->CreateHeap(&heapDesc, IID_PPV_ARGS(&result)));
ThrowIfFailed(device->CreateHeap(&heapDesc, IID_PPV_ARGS(&result)));
return result;
}
};
@ -95,7 +95,7 @@ struct InitHeap<ID3D12Resource>
ID3D12Resource *result;
D3D12_HEAP_PROPERTIES heapProperties = {};
heapProperties.Type = type;
check(device->CreateCommittedResource(&heapProperties,
ThrowIfFailed(device->CreateCommittedResource(&heapProperties,
flags,
&getBufferResourceDesc(heapSize),
D3D12_RESOURCE_STATE_GENERIC_READ,
@ -227,9 +227,29 @@ struct GarbageCollectionThread
void waitForCompletion();
};
/**
* Structure used to load/unload D3D12 lib.
*/
struct D3D12DLLManagement
{
D3D12DLLManagement();
~D3D12DLLManagement();
};
class D3D12GSRender : public GSRender
{
private:
/** D3D12 structures.
* Note: they should be declared in reverse order of destruction
*/
D3D12DLLManagement m_D3D12Lib;
ComPtr<ID3D12Device> m_device;
ComPtr<ID3D12CommandQueue> m_commandQueueGraphic;
ComPtr<struct IDXGISwapChain3> m_swapChain;
ComPtr<ID3D12Resource> m_backBuffer[2];
ComPtr<ID3D12DescriptorHeap> m_backbufferAsRendertarget[2];
// m_rootSignatures[N] is RS with N texture/sample
ComPtr<ID3D12RootSignature> m_rootSignatures[17];
/**
* Mutex protecting m_texturesCache and m_Textoclean access
* Memory protection fault catch can be generated by any thread and
@ -253,8 +273,6 @@ private:
PipelineStateObjectCache m_cachePSO;
std::pair<ID3D12PipelineState *, size_t> *m_PSO;
// m_rootSignatures[N] is RS with N texture/sample
ID3D12RootSignature *m_rootSignatures[17];
struct
{
@ -346,22 +364,15 @@ private:
RenderTargets m_rtts;
std::vector<D3D12_INPUT_ELEMENT_DESC> m_IASet;
ID3D12Device* m_device;
size_t g_descriptorStrideSRVCBVUAV;
size_t g_descriptorStrideDSV;
size_t g_descriptorStrideRTV;
size_t g_descriptorStrideSamplers;
ID3D12CommandQueue *m_commandQueueCopy;
ID3D12CommandQueue *m_commandQueueGraphic;
// Used to fill unused texture slot
ID3D12Resource *m_dummyTexture;
struct IDXGISwapChain3 *m_swapChain;
//BackBuffers
ID3D12Resource* m_backBuffer[2];
ID3D12DescriptorHeap *m_backbufferAsRendertarget[2];
size_t m_lastWidth, m_lastHeight, m_lastDepth;
public:
GSFrameBase2 *m_frame;
@ -402,12 +413,19 @@ private:
void FillVertexShaderConstantsBuffer();
void FillPixelShaderConstantsBuffer();
/**
* Upload textures to Data heap if necessary and create necessary descriptor in the per frame storage struct.
* returns the number of texture uploaded
* Fetch all textures recorded in the state in the render target cache and in the texture cache.
* If a texture is not cached, populate cmdlist with uploads command.
* Create necessary resource view/sampler descriptors in the per frame storage struct.
* returns the number of texture uploaded.
*/
size_t UploadTextures();
size_t UploadTextures(ID3D12GraphicsCommandList *cmdlist);
void PrepareRenderTargets();
/**
* Creates render target if necessary.
* Populate cmdlist with render target state change (from RTT to generic read for previous rtt,
* from generic to rtt for rtt in cache).
*/
void PrepareRenderTargets(ID3D12GraphicsCommandList *cmdlist);
protected:
virtual void OnInit() override;
virtual void OnInitThread() override;

10
rpcs3/Emu/RSX/D3D12/D3D12PipelineState.cpp
View File

@ -10,8 +10,9 @@
#define TO_STRING(x) #x
void Shader::Compile(const std::string &code, SHADER_TYPE st)
{ HRESULT hr;
Microsoft::WRL::ComPtr<ID3DBlob> errorBlob;
{
HRESULT hr;
ComPtr<ID3DBlob> errorBlob;
switch (st)
{
case SHADER_TYPE::SHADER_TYPE_VERTEX:
@ -27,9 +28,6 @@ void Shader::Compile(const std::string &code, SHADER_TYPE st)
}
}
bool D3D12GSRender::LoadProgram()
{
if (!m_cur_fragment_prog)
@ -287,7 +285,7 @@ bool D3D12GSRender::LoadProgram()
prop.IASet = m_IASet;
m_PSO = m_cachePSO.getGraphicPipelineState(m_cur_vertex_prog, m_cur_fragment_prog, prop, std::make_pair(m_device, m_rootSignatures));
m_PSO = m_cachePSO.getGraphicPipelineState(m_cur_vertex_prog, m_cur_fragment_prog, prop, std::make_pair(m_device.Get(), m_rootSignatures));
return m_PSO != nullptr;
}

11
rpcs3/Emu/RSX/D3D12/D3D12PipelineState.h
View File

@ -1,15 +1,12 @@
#pragma once
#if defined (DX12_SUPPORT)
#include <d3d12.h>
#include <wrl/client.h>
#include "D3D12.h"
#include "../Common/ProgramStateCache.h"
#include "D3D12VertexProgramDecompiler.h"
#include "D3D12FragmentProgramDecompiler.h"
#include "Utilities/File.h"
struct D3D12PipelineProperties
{
D3D12_PRIMITIVE_TOPOLOGY_TYPE Topology;
@ -66,7 +63,7 @@ public:
~Shader() {}
u32 id;
Microsoft::WRL::ComPtr<ID3DBlob> bytecode;
ComPtr<ID3DBlob> bytecode;
std::vector<size_t> FragmentConstantOffsetCache;
size_t m_textureCount;
@ -86,7 +83,7 @@ struct D3D12Traits
typedef Shader FragmentProgramData;
typedef std::pair<ID3D12PipelineState *, size_t> PipelineData;
typedef D3D12PipelineProperties PipelineProperties;
typedef std::pair<ID3D12Device *, ID3D12RootSignature **> ExtraData;
typedef std::pair<ID3D12Device *, ComPtr<ID3D12RootSignature> *> ExtraData;
static
void RecompileFragmentProgram(RSXFragmentProgram *RSXFP, FragmentProgramData& fragmentProgramData, size_t ID)
@ -145,7 +142,7 @@ struct D3D12Traits
graphicPipelineStateDesc.PS.BytecodeLength = fragmentProgramData.bytecode->GetBufferSize();
graphicPipelineStateDesc.PS.pShaderBytecode = fragmentProgramData.bytecode->GetBufferPointer();
graphicPipelineStateDesc.pRootSignature = extraData.second[fragmentProgramData.m_textureCount];
graphicPipelineStateDesc.pRootSignature = extraData.second[fragmentProgramData.m_textureCount].Get();
result->second = fragmentProgramData.m_textureCount;
graphicPipelineStateDesc.BlendState = pipelineProperties.Blend;

33
rpcs3/Emu/RSX/D3D12/D3D12RenderTargetSets.cpp
View File

@ -12,7 +12,7 @@
#include "D3D12.h"
#include "D3D12GSRender.h"
void D3D12GSRender::PrepareRenderTargets()
void D3D12GSRender::PrepareRenderTargets(ID3D12GraphicsCommandList *copycmdlist)
{
// FBO location has changed, previous data might be copied
u32 address_a = m_set_context_dma_color_a ? GetAddress(m_surface_offset_a, m_context_dma_color_a - 0xfeed0000) : 0;
@ -21,10 +21,6 @@ void D3D12GSRender::PrepareRenderTargets()
u32 address_d = m_set_context_dma_color_d ? GetAddress(m_surface_offset_d, m_context_dma_color_d - 0xfeed0000) : 0;
u32 address_z = m_set_context_dma_z ? GetAddress(m_surface_offset_z, m_context_dma_z - 0xfeed0000) : 0;
ID3D12GraphicsCommandList *copycmdlist;
check(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&copycmdlist)));
getCurrentResourceStorage().m_inflightCommandList.push_back(copycmdlist);
// Make previous RTTs sampleable
for (unsigned i = 0; i < 4; i++)
{
@ -63,66 +59,66 @@ void D3D12GSRender::PrepareRenderTargets()
{
case CELL_GCM_SURFACE_TARGET_0:
{
ID3D12Resource *rttA = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 0, address_a, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttA = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 0, address_a, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttA, &rttViewDesc, Handle);
break;
}
case CELL_GCM_SURFACE_TARGET_1:
{
ID3D12Resource *rttB = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 0, address_b, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttB = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 0, address_b, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttB, &rttViewDesc, Handle);
break;
}
case CELL_GCM_SURFACE_TARGET_MRT1:
{
ID3D12Resource *rttA = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 0, address_a, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttA = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 0, address_a, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttA, &rttViewDesc, Handle);
Handle.ptr += g_RTTIncrement;
ID3D12Resource *rttB = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 1, address_b, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttB = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 1, address_b, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttB, &rttViewDesc, Handle);
}
break;
case CELL_GCM_SURFACE_TARGET_MRT2:
{
ID3D12Resource *rttA = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 0, address_a, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttA = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 0, address_a, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttA, &rttViewDesc, Handle);
Handle.ptr += g_RTTIncrement;
ID3D12Resource *rttB = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 1, address_b, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttB = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 1, address_b, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttB, &rttViewDesc, Handle);
Handle.ptr += g_RTTIncrement;
ID3D12Resource *rttC = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 2, address_c, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttC = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 2, address_c, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttC, &rttViewDesc, Handle);
break;
}
case CELL_GCM_SURFACE_TARGET_MRT3:
{
ID3D12Resource *rttA = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 0, address_a, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttA = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 0, address_a, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttA, &rttViewDesc, Handle);
Handle.ptr += g_RTTIncrement;
ID3D12Resource *rttB = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 1, address_b, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttB = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 1, address_b, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttB, &rttViewDesc, Handle);
Handle.ptr += g_RTTIncrement;
ID3D12Resource *rttC = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 2, address_c, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttC = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 2, address_c, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttC, &rttViewDesc, Handle);
Handle.ptr += g_RTTIncrement;
ID3D12Resource *rttD = m_rtts.bindAddressAsRenderTargets(m_device, copycmdlist, 3, address_d, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
ID3D12Resource *rttD = m_rtts.bindAddressAsRenderTargets(m_device.Get(), copycmdlist, 3, address_d, m_surface_clip_w, m_surface_clip_h, m_surface_color_format,
m_clear_surface_color_r / 255.0f, m_clear_surface_color_g / 255.0f, m_clear_surface_color_b / 255.0f, m_clear_surface_color_a / 255.0f);
m_device->CreateRenderTargetView(rttD, &rttViewDesc, Handle);
break;
}
}
ID3D12Resource *ds = m_rtts.bindAddressAsDepthStencil(m_device, copycmdlist, address_z, m_surface_clip_w, m_surface_clip_h, m_surface_depth_format, 1., 0);
ID3D12Resource *ds = m_rtts.bindAddressAsDepthStencil(m_device.Get(), copycmdlist, address_z, m_surface_clip_w, m_surface_clip_h, m_surface_depth_format, 1., 0);
D3D12_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc = {};
switch (m_surface_depth_format)
@ -141,9 +137,6 @@ void D3D12GSRender::PrepareRenderTargets()
}
depthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
m_device->CreateDepthStencilView(ds, &depthStencilViewDesc, m_rtts.m_depthStencilDescriptorHeap->GetCPUDescriptorHandleForHeapStart());
check(copycmdlist->Close());
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)&copycmdlist);
}
ID3D12Resource *RenderTargets::bindAddressAsRenderTargets(ID3D12Device *device, ID3D12GraphicsCommandList *cmdList, size_t slot, u32 address,

20
rpcs3/Emu/RSX/D3D12/D3D12Texture.cpp
View File

@ -555,7 +555,7 @@ ID3D12Resource *uploadSingleTexture(
assert(textureBuffersHeap.canAlloc(textureSize));
size_t heapOffset = textureBuffersHeap.alloc(textureSize);
check(device->CreatePlacedResource(
ThrowIfFailed(device->CreatePlacedResource(
textureBuffersHeap.m_heap,
heapOffset,
&getBufferResourceDesc(textureSize),
@ -567,7 +567,7 @@ ID3D12Resource *uploadSingleTexture(
auto pixels = vm::get_ptr<const u8>(texaddr);
void *textureData;
check(Texture->Map(0, nullptr, (void**)&textureData));
ThrowIfFailed(Texture->Map(0, nullptr, (void**)&textureData));
std::vector<MipmapLevelInfo> mipInfos;
switch (format)
@ -616,7 +616,7 @@ ID3D12Resource *uploadSingleTexture(
D3D12_HEAP_PROPERTIES heapProp = {};
heapProp.Type = D3D12_HEAP_TYPE_DEFAULT;
check(device->CreateCommittedResource(
ThrowIfFailed(device->CreateCommittedResource(
&heapProp,
D3D12_HEAP_FLAG_NONE,
&texturedesc,
@ -726,7 +726,7 @@ size_t getTextureSize(const RSXTexture &texture)
}
}
size_t D3D12GSRender::UploadTextures()
size_t D3D12GSRender::UploadTextures(ID3D12GraphicsCommandList *cmdlist)
{
std::lock_guard<std::mutex> lock(mut);
size_t usedTexture = 0;
@ -758,15 +758,7 @@ size_t D3D12GSRender::UploadTextures()
}
else
{
// Upload at each iteration to take advantage of overlapping transfer
ID3D12GraphicsCommandList *commandList;
check(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_textureUploadCommandAllocator, nullptr, IID_PPV_ARGS(&commandList)));
vramTexture = uploadSingleTexture(m_textures[i], m_device, commandList, m_textureUploadData);
check(commandList->Close());
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)&commandList);
getCurrentResourceStorage().m_inflightCommandList.push_back(commandList);
vramTexture = uploadSingleTexture(m_textures[i], m_device.Get(), cmdlist, m_textureUploadData);
m_texturesCache[texaddr] = vramTexture;
u32 s = (u32)align(getTextureSize(m_textures[i]), 4096);
@ -897,4 +889,4 @@ size_t D3D12GSRender::UploadTextures()
return usedTexture;
}
#endif
#endif

12
rpcs3/Emu/RSX/D3D12/D3D12Utils.cpp
View File

@ -185,7 +185,7 @@ void D3D12GSRender::Shader::Init(ID3D12Device *device)
psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
psoDesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
check(device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&m_PSO)));
ThrowIfFailed(device->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&m_PSO)));
float quadVertex[16] = {
@ -197,7 +197,7 @@ void D3D12GSRender::Shader::Init(ID3D12Device *device)
D3D12_HEAP_PROPERTIES heapProp = {};
heapProp.Type = D3D12_HEAP_TYPE_UPLOAD;
check(
ThrowIfFailed(
device->CreateCommittedResource(
&heapProp,
D3D12_HEAP_FLAG_NONE,
@ -217,11 +217,11 @@ void D3D12GSRender::Shader::Init(ID3D12Device *device)
heapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
heapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
check(
ThrowIfFailed(
device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_textureDescriptorHeap))
);
heapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
check(
ThrowIfFailed(
device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_samplerDescriptorHeap))
);
}
@ -229,7 +229,7 @@ void D3D12GSRender::Shader::Init(ID3D12Device *device)
void D3D12GSRender::initConvertShader()
{
const auto &p = compileF32toU8CS();
check(
ThrowIfFailed(
m_device->CreateRootSignature(0, p.second->GetBufferPointer(), p.second->GetBufferSize(), IID_PPV_ARGS(&m_convertRootSignature))
);
@ -238,7 +238,7 @@ void D3D12GSRender::initConvertShader()
computePipelineStateDesc.CS.pShaderBytecode = p.first->GetBufferPointer();
computePipelineStateDesc.pRootSignature = m_convertRootSignature;
check(
ThrowIfFailed(
m_device->CreateComputePipelineState(&computePipelineStateDesc, IID_PPV_ARGS(&m_convertPSO))
);