archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-13 10:18:40 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

d3d12: Revert back to a signel resource storage

Browse source 
Using two of them doesnt increase perf atm but eats twice the space
This commit is contained in:
vlj 2015-05-28 18:05:58 +02:00 • committed by Vincent Lejeune
parent b81fd13232
commit c167a1228e
4 changed files with 89 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

52
rpcs3/Emu/RSX/D3D12/D3D12Buffer.cpp
View file

@ -207,13 +207,13 @@ std::pair<std::vector<D3D12_VERTEX_BUFFER_VIEW>, D3D12_INDEX_BUFFER_VIEW> D3D12G
{ {
const VertexBufferFormat &vbf = vertexBufferFormat[buffer]; const VertexBufferFormat &vbf = vertexBufferFormat[buffer];
// 65536 alignment // 65536 alignment
size_t bufferHeapOffset = getCurrentResourceStorage().m_vertexIndexBuffersHeapFreeSpace; size_t bufferHeapOffset = m_perFrameStorage.m_vertexIndexBuffersHeapFreeSpace;
bufferHeapOffset = (bufferHeapOffset + 65536 - 1) & ~65535; bufferHeapOffset = (bufferHeapOffset + 65536 - 1) & ~65535;
size_t subBufferSize = vbf.range.second - vbf.range.first; size_t subBufferSize = vbf.range.second - vbf.range.first;
ID3D12Resource *vertexBuffer; ID3D12Resource *vertexBuffer;
check(m_device->CreatePlacedResource( check(m_device->CreatePlacedResource(
getCurrentResourceStorage().m_vertexIndexBuffersHeap, m_perFrameStorage.m_vertexIndexBuffersHeap,
bufferHeapOffset, bufferHeapOffset,
&getBufferResourceDesc(subBufferSize), &getBufferResourceDesc(subBufferSize),
D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_GENERIC_READ,
@ -262,14 +262,14 @@ std::pair<std::vector<D3D12_VERTEX_BUFFER_VIEW>, D3D12_INDEX_BUFFER_VIEW> D3D12G
} }
vertexBuffer->Unmap(0, nullptr); vertexBuffer->Unmap(0, nullptr);
getCurrentResourceStorage().m_inflightResources.push_back(vertexBuffer); m_perFrameStorage.m_inflightResources.push_back(vertexBuffer);
D3D12_VERTEX_BUFFER_VIEW vertexBufferView = {}; D3D12_VERTEX_BUFFER_VIEW vertexBufferView = {};
vertexBufferView.BufferLocation = vertexBuffer->GetGPUVirtualAddress(); vertexBufferView.BufferLocation = vertexBuffer->GetGPUVirtualAddress();
vertexBufferView.SizeInBytes = (UINT)subBufferSize; vertexBufferView.SizeInBytes = (UINT)subBufferSize;
vertexBufferView.StrideInBytes = (UINT)vbf.stride; vertexBufferView.StrideInBytes = (UINT)vbf.stride;
result.first.push_back(vertexBufferView); result.first.push_back(vertexBufferView);
getCurrentResourceStorage().m_vertexIndexBuffersHeapFreeSpace = bufferHeapOffset + subBufferSize; m_perFrameStorage.m_vertexIndexBuffersHeapFreeSpace = bufferHeapOffset + subBufferSize;
} }
// Only handle quads now // Only handle quads now
@ -326,12 +326,12 @@ std::pair<std::vector<D3D12_VERTEX_BUFFER_VIEW>, D3D12_INDEX_BUFFER_VIEW> D3D12G
indexCount = m_draw_array_count * 6 / 4; indexCount = m_draw_array_count * 6 / 4;
size_t subBufferSize = powerOf2Align(indexCount * indexSize, 64); size_t subBufferSize = powerOf2Align(indexCount * indexSize, 64);
// 65536 alignment // 65536 alignment
size_t bufferHeapOffset = getCurrentResourceStorage().m_vertexIndexBuffersHeapFreeSpace; size_t bufferHeapOffset = m_perFrameStorage.m_vertexIndexBuffersHeapFreeSpace;
bufferHeapOffset = (bufferHeapOffset + 65536 - 1) & ~65535; bufferHeapOffset = (bufferHeapOffset + 65536 - 1) & ~65535;
ID3D12Resource *indexBuffer; ID3D12Resource *indexBuffer;
check(m_device->CreatePlacedResource( check(m_device->CreatePlacedResource(
getCurrentResourceStorage().m_vertexIndexBuffersHeap, m_perFrameStorage.m_vertexIndexBuffersHeap,
bufferHeapOffset, bufferHeapOffset,
&getBufferResourceDesc(subBufferSize), &getBufferResourceDesc(subBufferSize),
D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_GENERIC_READ,
@ -371,8 +371,8 @@ std::pair<std::vector<D3D12_VERTEX_BUFFER_VIEW>, D3D12_INDEX_BUFFER_VIEW> D3D12G
} }
} }
indexBuffer->Unmap(0, nullptr); indexBuffer->Unmap(0, nullptr);
getCurrentResourceStorage().m_inflightResources.push_back(indexBuffer); m_perFrameStorage.m_inflightResources.push_back(indexBuffer);
getCurrentResourceStorage().m_vertexIndexBuffersHeapFreeSpace = bufferHeapOffset + subBufferSize; m_perFrameStorage.m_vertexIndexBuffersHeapFreeSpace = bufferHeapOffset + subBufferSize;
indexBufferView.SizeInBytes = (UINT)subBufferSize; indexBufferView.SizeInBytes = (UINT)subBufferSize;
@ -406,7 +406,7 @@ void D3D12GSRender::setScaleOffset()
scaleOffsetMat[3] /= RSXThread::m_width / RSXThread::m_width_scale; scaleOffsetMat[3] /= RSXThread::m_width / RSXThread::m_width_scale;
scaleOffsetMat[7] /= RSXThread::m_height / RSXThread::m_height_scale; scaleOffsetMat[7] /= RSXThread::m_height / RSXThread::m_height_scale;
size_t constantBuffersHeapOffset = getCurrentResourceStorage().m_constantsBuffersHeapFreeSpace; size_t constantBuffersHeapOffset = m_perFrameStorage.m_constantsBuffersHeapFreeSpace;
// 65536 alignment // 65536 alignment
constantBuffersHeapOffset = (constantBuffersHeapOffset + 65536 - 1) & ~65535; constantBuffersHeapOffset = (constantBuffersHeapOffset + 65536 - 1) & ~65535;
@ -414,7 +414,7 @@ void D3D12GSRender::setScaleOffset()
// Separate constant buffer // Separate constant buffer
ID3D12Resource *scaleOffsetBuffer; ID3D12Resource *scaleOffsetBuffer;
check(m_device->CreatePlacedResource( check(m_device->CreatePlacedResource(
getCurrentResourceStorage().m_constantsBuffersHeap, m_perFrameStorage.m_constantsBuffersHeap,
constantBuffersHeapOffset, constantBuffersHeapOffset,
&getBufferResourceDesc(256), &getBufferResourceDesc(256),
D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_GENERIC_READ,
@ -430,11 +430,11 @@ void D3D12GSRender::setScaleOffset()
D3D12_CONSTANT_BUFFER_VIEW_DESC constantBufferViewDesc = {}; D3D12_CONSTANT_BUFFER_VIEW_DESC constantBufferViewDesc = {};
constantBufferViewDesc.BufferLocation = scaleOffsetBuffer->GetGPUVirtualAddress(); constantBufferViewDesc.BufferLocation = scaleOffsetBuffer->GetGPUVirtualAddress();
constantBufferViewDesc.SizeInBytes = (UINT)256; constantBufferViewDesc.SizeInBytes = (UINT)256;
D3D12_CPU_DESCRIPTOR_HANDLE Handle = getCurrentResourceStorage().m_scaleOffsetDescriptorHeap->GetCPUDescriptorHandleForHeapStart(); D3D12_CPU_DESCRIPTOR_HANDLE Handle = m_perFrameStorage.m_scaleOffsetDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
Handle.ptr += getCurrentResourceStorage().m_currentScaleOffsetBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); Handle.ptr += m_perFrameStorage.m_currentScaleOffsetBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
m_device->CreateConstantBufferView(&constantBufferViewDesc, Handle); m_device->CreateConstantBufferView(&constantBufferViewDesc, Handle);
getCurrentResourceStorage().m_constantsBuffersHeapFreeSpace = constantBuffersHeapOffset + 256; m_perFrameStorage.m_constantsBuffersHeapFreeSpace = constantBuffersHeapOffset + 256;
getCurrentResourceStorage().m_inflightResources.push_back(scaleOffsetBuffer); m_perFrameStorage.m_inflightResources.push_back(scaleOffsetBuffer);
} }
void D3D12GSRender::FillVertexShaderConstantsBuffer() void D3D12GSRender::FillVertexShaderConstantsBuffer()
@ -446,13 +446,13 @@ void D3D12GSRender::FillVertexShaderConstantsBuffer()
memcpy((char*)vertexConstantShadowCopy + offset, vector, 4 * sizeof(float)); memcpy((char*)vertexConstantShadowCopy + offset, vector, 4 * sizeof(float));
} }
size_t constantBuffersHeapOffset = getCurrentResourceStorage().m_constantsBuffersHeapFreeSpace; size_t constantBuffersHeapOffset = m_perFrameStorage.m_constantsBuffersHeapFreeSpace;
// 65536 alignment // 65536 alignment
constantBuffersHeapOffset = (constantBuffersHeapOffset + 65536 - 1) & ~65535; constantBuffersHeapOffset = (constantBuffersHeapOffset + 65536 - 1) & ~65535;
ID3D12Resource *constantsBuffer; ID3D12Resource *constantsBuffer;
check(m_device->CreatePlacedResource( check(m_device->CreatePlacedResource(
getCurrentResourceStorage().m_constantsBuffersHeap, m_perFrameStorage.m_constantsBuffersHeap,
constantBuffersHeapOffset, constantBuffersHeapOffset,
&getBufferResourceDesc(512 * 4 * sizeof(float)), &getBufferResourceDesc(512 * 4 * sizeof(float)),
D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_GENERIC_READ,
@ -468,11 +468,11 @@ void D3D12GSRender::FillVertexShaderConstantsBuffer()
D3D12_CONSTANT_BUFFER_VIEW_DESC constantBufferViewDesc = {}; D3D12_CONSTANT_BUFFER_VIEW_DESC constantBufferViewDesc = {};
constantBufferViewDesc.BufferLocation = constantsBuffer->GetGPUVirtualAddress(); constantBufferViewDesc.BufferLocation = constantsBuffer->GetGPUVirtualAddress();
constantBufferViewDesc.SizeInBytes = 512 * 4 * sizeof(float); constantBufferViewDesc.SizeInBytes = 512 * 4 * sizeof(float);
D3D12_CPU_DESCRIPTOR_HANDLE Handle = getCurrentResourceStorage().m_constantsBufferDescriptorsHeap->GetCPUDescriptorHandleForHeapStart(); D3D12_CPU_DESCRIPTOR_HANDLE Handle = m_perFrameStorage.m_constantsBufferDescriptorsHeap->GetCPUDescriptorHandleForHeapStart();
Handle.ptr += getCurrentResourceStorage().m_constantsBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); Handle.ptr += m_perFrameStorage.m_constantsBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
m_device->CreateConstantBufferView(&constantBufferViewDesc, Handle); m_device->CreateConstantBufferView(&constantBufferViewDesc, Handle);
getCurrentResourceStorage().m_constantsBuffersHeapFreeSpace = constantBuffersHeapOffset + 512 * 4 * sizeof(float); m_perFrameStorage.m_constantsBuffersHeapFreeSpace = constantBuffersHeapOffset + 512 * 4 * sizeof(float);
getCurrentResourceStorage().m_inflightResources.push_back(constantsBuffer); m_perFrameStorage.m_inflightResources.push_back(constantsBuffer);
} }
void D3D12GSRender::FillPixelShaderConstantsBuffer() void D3D12GSRender::FillPixelShaderConstantsBuffer()
@ -483,13 +483,13 @@ void D3D12GSRender::FillPixelShaderConstantsBuffer()
// Multiple of 256 never 0 // Multiple of 256 never 0
bufferSize = (bufferSize + 255) & ~255; bufferSize = (bufferSize + 255) & ~255;
size_t constantBuffersHeapOffset = getCurrentResourceStorage().m_constantsBuffersHeapFreeSpace; size_t constantBuffersHeapOffset = m_perFrameStorage.m_constantsBuffersHeapFreeSpace;
// 65536 alignment // 65536 alignment
constantBuffersHeapOffset = (constantBuffersHeapOffset + 65536 - 1) & ~65535; constantBuffersHeapOffset = (constantBuffersHeapOffset + 65536 - 1) & ~65535;
ID3D12Resource *constantsBuffer; ID3D12Resource *constantsBuffer;
check(m_device->CreatePlacedResource( check(m_device->CreatePlacedResource(
getCurrentResourceStorage().m_constantsBuffersHeap, m_perFrameStorage.m_constantsBuffersHeap,
constantBuffersHeapOffset, constantBuffersHeapOffset,
&getBufferResourceDesc(bufferSize), &getBufferResourceDesc(bufferSize),
D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_GENERIC_READ,
@ -536,11 +536,11 @@ void D3D12GSRender::FillPixelShaderConstantsBuffer()
D3D12_CONSTANT_BUFFER_VIEW_DESC constantBufferViewDesc = {}; D3D12_CONSTANT_BUFFER_VIEW_DESC constantBufferViewDesc = {};
constantBufferViewDesc.BufferLocation = constantsBuffer->GetGPUVirtualAddress(); constantBufferViewDesc.BufferLocation = constantsBuffer->GetGPUVirtualAddress();
constantBufferViewDesc.SizeInBytes = (UINT)bufferSize; constantBufferViewDesc.SizeInBytes = (UINT)bufferSize;
D3D12_CPU_DESCRIPTOR_HANDLE Handle = getCurrentResourceStorage().m_constantsBufferDescriptorsHeap->GetCPUDescriptorHandleForHeapStart(); D3D12_CPU_DESCRIPTOR_HANDLE Handle = m_perFrameStorage.m_constantsBufferDescriptorsHeap->GetCPUDescriptorHandleForHeapStart();
Handle.ptr += getCurrentResourceStorage().m_constantsBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); Handle.ptr += m_perFrameStorage.m_constantsBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
m_device->CreateConstantBufferView(&constantBufferViewDesc, Handle); m_device->CreateConstantBufferView(&constantBufferViewDesc, Handle);
getCurrentResourceStorage().m_constantsBuffersHeapFreeSpace = constantBuffersHeapOffset + bufferSize; m_perFrameStorage.m_constantsBuffersHeapFreeSpace = constantBuffersHeapOffset + bufferSize;
getCurrentResourceStorage().m_inflightResources.push_back(constantsBuffer); m_perFrameStorage.m_inflightResources.push_back(constantsBuffer);
} }

107
rpcs3/Emu/RSX/D3D12/D3D12GSRender.cpp
View file

@ -88,12 +88,11 @@ void D3D12GSRender::ResourceStorage::Init(ID3D12Device *device)
void D3D12GSRender::ResourceStorage::Release() void D3D12GSRender::ResourceStorage::Release()
{ {
// NOTE: Should be released only if no command are in flight ! // NOTE: Should be released only if no command are in flight !
m_backbufferAsRendertarget->Release();
m_constantsBufferDescriptorsHeap->Release(); m_constantsBufferDescriptorsHeap->Release();
m_scaleOffsetDescriptorHeap->Release(); m_scaleOffsetDescriptorHeap->Release();
m_constantsBuffersHeap->Release(); m_constantsBuffersHeap->Release();
m_vertexIndexBuffersHeap->Release(); m_vertexIndexBuffersHeap->Release();
m_backBuffer->Release();
for (auto tmp : m_inflightResources) for (auto tmp : m_inflightResources)
tmp->Release(); tmp->Release();
m_textureDescriptorsHeap->Release(); m_textureDescriptorsHeap->Release();
@ -218,8 +217,8 @@ D3D12GSRender::D3D12GSRender()
swapChain.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; swapChain.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
check(dxgiFactory->CreateSwapChain(m_commandQueueGraphic, &swapChain, (IDXGISwapChain**)&m_swapChain)); check(dxgiFactory->CreateSwapChain(m_commandQueueGraphic, &swapChain, (IDXGISwapChain**)&m_swapChain));
m_swapChain->GetBuffer(0, IID_PPV_ARGS(&m_perFrameStorage[0].m_backBuffer)); m_swapChain->GetBuffer(0, IID_PPV_ARGS(&m_backBuffer[0]));
m_swapChain->GetBuffer(1, IID_PPV_ARGS(&m_perFrameStorage[1].m_backBuffer)); m_swapChain->GetBuffer(1, IID_PPV_ARGS(&m_backBuffer[1]));
D3D12_DESCRIPTOR_HEAP_DESC heapDesc = {}; D3D12_DESCRIPTOR_HEAP_DESC heapDesc = {};
heapDesc.NumDescriptors = 1; heapDesc.NumDescriptors = 1;
@ -227,10 +226,10 @@ D3D12GSRender::D3D12GSRender()
D3D12_RENDER_TARGET_VIEW_DESC rttDesc = {}; D3D12_RENDER_TARGET_VIEW_DESC rttDesc = {};
rttDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D; rttDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
rttDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; rttDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
m_device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_perFrameStorage[0].m_backbufferAsRendertarget)); m_device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_backbufferAsRendertarget[0]));
m_device->CreateRenderTargetView(m_perFrameStorage[0].m_backBuffer, &rttDesc, m_perFrameStorage[0].m_backbufferAsRendertarget->GetCPUDescriptorHandleForHeapStart()); m_device->CreateRenderTargetView(m_backBuffer[0], &rttDesc, m_backbufferAsRendertarget[0]->GetCPUDescriptorHandleForHeapStart());
m_device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_perFrameStorage[1].m_backbufferAsRendertarget)); m_device->CreateDescriptorHeap(&heapDesc, IID_PPV_ARGS(&m_backbufferAsRendertarget[1]));
m_device->CreateRenderTargetView(m_perFrameStorage[1].m_backBuffer, &rttDesc, m_perFrameStorage[1].m_backbufferAsRendertarget->GetCPUDescriptorHandleForHeapStart()); m_device->CreateRenderTargetView(m_backBuffer[1], &rttDesc, m_backbufferAsRendertarget[1]->GetCPUDescriptorHandleForHeapStart());
// Common root signature // Common root signature
D3D12_DESCRIPTOR_RANGE descriptorRange[4] = {}; D3D12_DESCRIPTOR_RANGE descriptorRange[4] = {};
@ -282,12 +281,9 @@ D3D12GSRender::D3D12GSRender()
rootSignatureBlob->GetBufferSize(), rootSignatureBlob->GetBufferSize(),
IID_PPV_ARGS(&m_rootSignature)); IID_PPV_ARGS(&m_rootSignature));
m_perFrameStorage[0].Init(m_device); m_perFrameStorage.Init(m_device);
m_perFrameStorage[0].Reset(); m_perFrameStorage.Reset();
m_perFrameStorage[1].Init(m_device);
m_perFrameStorage[1].Reset();
m_currentResourceStorageIndex = m_swapChain->GetCurrentBackBufferIndex();
vertexConstantShadowCopy = new float[512 * 4]; vertexConstantShadowCopy = new float[512 * 4];
// Convert shader // Convert shader
@ -313,10 +309,13 @@ D3D12GSRender::~D3D12GSRender()
{ {
m_convertPSO->Release(); m_convertPSO->Release();
m_convertRootSignature->Release(); m_convertRootSignature->Release();
m_perFrameStorage[0].Release(); m_perFrameStorage.Release();
m_perFrameStorage[1].Release();
m_commandQueueGraphic->Release(); m_commandQueueGraphic->Release();
m_commandQueueCopy->Release(); m_commandQueueCopy->Release();
m_backbufferAsRendertarget[0]->Release();
m_backBuffer[0]->Release();
m_backbufferAsRendertarget[1]->Release();
m_backBuffer[1]->Release();
if (m_fbo) if (m_fbo)
delete m_fbo; delete m_fbo;
m_rootSignature->Release(); m_rootSignature->Release();
@ -325,16 +324,6 @@ D3D12GSRender::~D3D12GSRender()
delete[] vertexConstantShadowCopy; delete[] vertexConstantShadowCopy;
} }
D3D12GSRender::ResourceStorage &D3D12GSRender::getCurrentResourceStorage()
{
return m_perFrameStorage[m_currentResourceStorageIndex];
}
D3D12GSRender::ResourceStorage &D3D12GSRender::getNonCurrentResourceStorage()
{
return m_perFrameStorage[1 - m_currentResourceStorageIndex];
}
void D3D12GSRender::Close() void D3D12GSRender::Close()
{ {
Stop(); Stop();
@ -387,8 +376,8 @@ void D3D12GSRender::ExecCMD(u32 cmd)
InitDrawBuffers(); InitDrawBuffers();
ID3D12GraphicsCommandList *commandList; ID3D12GraphicsCommandList *commandList;
check(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList))); check(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_perFrameStorage.m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList)));
getCurrentResourceStorage().m_inflightCommandList.push_back(commandList); m_perFrameStorage.m_inflightCommandList.push_back(commandList);
/* if (m_set_color_mask) /* if (m_set_color_mask)
{ {
@ -582,8 +571,8 @@ bool D3D12GSRender::LoadProgram()
void D3D12GSRender::ExecCMD() void D3D12GSRender::ExecCMD()
{ {
ID3D12GraphicsCommandList *commandList; ID3D12GraphicsCommandList *commandList;
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList)); m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_perFrameStorage.m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList));
getCurrentResourceStorage().m_inflightCommandList.push_back(commandList); m_perFrameStorage.m_inflightCommandList.push_back(commandList);
commandList->SetGraphicsRootSignature(m_rootSignature); commandList->SetGraphicsRootSignature(m_rootSignature);
@ -607,36 +596,36 @@ void D3D12GSRender::ExecCMD()
// Constants // Constants
setScaleOffset(); setScaleOffset();
commandList->SetDescriptorHeaps(1, &getCurrentResourceStorage().m_scaleOffsetDescriptorHeap); commandList->SetDescriptorHeaps(1, &m_perFrameStorage.m_scaleOffsetDescriptorHeap);
D3D12_GPU_DESCRIPTOR_HANDLE Handle = getCurrentResourceStorage().m_scaleOffsetDescriptorHeap->GetGPUDescriptorHandleForHeapStart(); D3D12_GPU_DESCRIPTOR_HANDLE Handle = m_perFrameStorage.m_scaleOffsetDescriptorHeap->GetGPUDescriptorHandleForHeapStart();
Handle.ptr += getCurrentResourceStorage().m_currentScaleOffsetBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); Handle.ptr += m_perFrameStorage.m_currentScaleOffsetBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
commandList->SetGraphicsRootDescriptorTable(0, Handle); commandList->SetGraphicsRootDescriptorTable(0, Handle);
getCurrentResourceStorage().m_currentScaleOffsetBufferIndex++; m_perFrameStorage.m_currentScaleOffsetBufferIndex++;
size_t currentBufferIndex = getCurrentResourceStorage().m_constantsBufferIndex; size_t currentBufferIndex = m_perFrameStorage.m_constantsBufferIndex;
FillVertexShaderConstantsBuffer(); FillVertexShaderConstantsBuffer();
getCurrentResourceStorage().m_constantsBufferIndex++; m_perFrameStorage.m_constantsBufferIndex++;
FillPixelShaderConstantsBuffer(); FillPixelShaderConstantsBuffer();
getCurrentResourceStorage().m_constantsBufferIndex++; m_perFrameStorage.m_constantsBufferIndex++;
commandList->SetDescriptorHeaps(1, &getCurrentResourceStorage().m_constantsBufferDescriptorsHeap); commandList->SetDescriptorHeaps(1, &m_perFrameStorage.m_constantsBufferDescriptorsHeap);
Handle = getCurrentResourceStorage().m_constantsBufferDescriptorsHeap->GetGPUDescriptorHandleForHeapStart(); Handle = m_perFrameStorage.m_constantsBufferDescriptorsHeap->GetGPUDescriptorHandleForHeapStart();
Handle.ptr += currentBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); Handle.ptr += currentBufferIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
commandList->SetGraphicsRootDescriptorTable(1, Handle); commandList->SetGraphicsRootDescriptorTable(1, Handle);
commandList->SetPipelineState(m_PSO); commandList->SetPipelineState(m_PSO);
size_t usedTexture = UploadTextures(); size_t usedTexture = UploadTextures();
Handle = getCurrentResourceStorage().m_textureDescriptorsHeap->GetGPUDescriptorHandleForHeapStart(); Handle = m_perFrameStorage.m_textureDescriptorsHeap->GetGPUDescriptorHandleForHeapStart();
Handle.ptr += getCurrentResourceStorage().m_currentTextureIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); Handle.ptr += m_perFrameStorage.m_currentTextureIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
commandList->SetDescriptorHeaps(1, &getCurrentResourceStorage().m_textureDescriptorsHeap); commandList->SetDescriptorHeaps(1, &m_perFrameStorage.m_textureDescriptorsHeap);
commandList->SetGraphicsRootDescriptorTable(2, Handle); commandList->SetGraphicsRootDescriptorTable(2, Handle);
Handle = getCurrentResourceStorage().m_samplerDescriptorHeap->GetGPUDescriptorHandleForHeapStart(); Handle = m_perFrameStorage.m_samplerDescriptorHeap->GetGPUDescriptorHandleForHeapStart();
Handle.ptr += getCurrentResourceStorage().m_currentTextureIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); Handle.ptr += m_perFrameStorage.m_currentTextureIndex * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
commandList->SetDescriptorHeaps(1, &getCurrentResourceStorage().m_samplerDescriptorHeap); commandList->SetDescriptorHeaps(1, &m_perFrameStorage.m_samplerDescriptorHeap);
commandList->SetGraphicsRootDescriptorTable(3, Handle); commandList->SetGraphicsRootDescriptorTable(3, Handle);
getCurrentResourceStorage().m_currentTextureIndex += usedTexture; m_perFrameStorage.m_currentTextureIndex += usedTexture;
InitDrawBuffers(); InitDrawBuffers();
@ -1030,8 +1019,8 @@ void D3D12GSRender::ExecCMD()
void D3D12GSRender::Flip() void D3D12GSRender::Flip()
{ {
ID3D12GraphicsCommandList *commandList; ID3D12GraphicsCommandList *commandList;
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList)); m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_perFrameStorage.m_commandAllocator, nullptr, IID_PPV_ARGS(&commandList));
getCurrentResourceStorage().m_inflightCommandList.push_back(commandList); m_perFrameStorage.m_inflightCommandList.push_back(commandList);
switch (m_surface_color_target) switch (m_surface_color_target)
{ {
@ -1043,7 +1032,7 @@ void D3D12GSRender::Flip()
{ {
D3D12_RESOURCE_BARRIER barriers[2] = {}; D3D12_RESOURCE_BARRIER barriers[2] = {};
barriers[0].Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; barriers[0].Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barriers[0].Transition.pResource = getCurrentResourceStorage().m_backBuffer; barriers[0].Transition.pResource = m_backBuffer[m_swapChain->GetCurrentBackBufferIndex()];
barriers[0].Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT; barriers[0].Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
barriers[0].Transition.StateAfter = D3D12_RESOURCE_STATE_COPY_DEST; barriers[0].Transition.StateAfter = D3D12_RESOURCE_STATE_COPY_DEST;
@ -1056,7 +1045,7 @@ void D3D12GSRender::Flip()
D3D12_TEXTURE_COPY_LOCATION src = {}, dst = {}; D3D12_TEXTURE_COPY_LOCATION src = {}, dst = {};
src.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX, dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX; src.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX, dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
src.SubresourceIndex = 0, dst.SubresourceIndex = 0; src.SubresourceIndex = 0, dst.SubresourceIndex = 0;
src.pResource = m_fbo->getRenderTargetTexture(0), dst.pResource = getCurrentResourceStorage().m_backBuffer; src.pResource = m_fbo->getRenderTargetTexture(0), dst.pResource = m_backBuffer[m_swapChain->GetCurrentBackBufferIndex()];
D3D12_BOX box = { 0, 0, 0, RSXThread::m_width, RSXThread::m_height, 1 }; D3D12_BOX box = { 0, 0, 0, RSXThread::m_width, RSXThread::m_height, 1 };
commandList->CopyTextureRegion(&dst, 0, 0, 0, &src, &box); commandList->CopyTextureRegion(&dst, 0, 0, 0, &src, &box);
@ -1074,18 +1063,12 @@ void D3D12GSRender::Flip()
// Add an event signaling queue completion // Add an event signaling queue completion
Microsoft::WRL::ComPtr<ID3D12Fence> fence; Microsoft::WRL::ComPtr<ID3D12Fence> fence;
m_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&fence)); m_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&fence));
getCurrentResourceStorage().m_queueCompletion = CreateEvent(0, 0, 0, 0); HANDLE handle = CreateEvent(0, 0, 0, 0);
fence->SetEventOnCompletion(1, getCurrentResourceStorage().m_queueCompletion); fence->SetEventOnCompletion(1, handle);
m_commandQueueGraphic->Signal(fence.Get(), 1); m_commandQueueGraphic->Signal(fence.Get(), 1);
WaitForSingleObject(handle, INFINITE);
// Wait execution is over CloseHandle(handle);
if (getNonCurrentResourceStorage().m_queueCompletion) m_perFrameStorage.Reset();
{
WaitForSingleObject(getNonCurrentResourceStorage().m_queueCompletion, INFINITE);
CloseHandle(getNonCurrentResourceStorage().m_queueCompletion);
getNonCurrentResourceStorage().Reset();
}
m_currentResourceStorageIndex = 1 - m_currentResourceStorageIndex;
m_frame->Flip(nullptr); m_frame->Flip(nullptr);
} }
@ -1166,7 +1149,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
); );
check( check(
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_commandAllocator, nullptr, IID_PPV_ARGS(&convertCommandList)) m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_perFrameStorage.m_commandAllocator, nullptr, IID_PPV_ARGS(&convertCommandList))
); );
D3D12_DESCRIPTOR_HEAP_DESC descriptorHeapDesc = {}; D3D12_DESCRIPTOR_HEAP_DESC descriptorHeapDesc = {};
@ -1246,7 +1229,7 @@ void D3D12GSRender::semaphorePGRAPHBackendRelease(u32 offset, u32 value)
m_commandQueueGraphic->Signal(convertDownloadFence, 1); m_commandQueueGraphic->Signal(convertDownloadFence, 1);
check( check(
m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, getCurrentResourceStorage().m_downloadCommandAllocator, nullptr, IID_PPV_ARGS(&downloadCommandList)) m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_COPY, m_perFrameStorage.m_downloadCommandAllocator, nullptr, IID_PPV_ARGS(&downloadCommandList))
); );
// Copy // Copy

12
rpcs3/Emu/RSX/D3D12/D3D12GSRender.h
View file

@ -85,10 +85,6 @@ private:
ID3D12DescriptorHeap *m_samplerDescriptorHeap; ID3D12DescriptorHeap *m_samplerDescriptorHeap;
size_t m_currentTextureIndex; size_t m_currentTextureIndex;
//BackBuffers
ID3D12Resource* m_backBuffer;
ID3D12DescriptorHeap *m_backbufferAsRendertarget;
// Fence // Fence
HANDLE m_queueCompletion; HANDLE m_queueCompletion;
@ -97,7 +93,7 @@ private:
void Release(); void Release();
}; };
ResourceStorage m_perFrameStorage[2]; ResourceStorage m_perFrameStorage;
bool m_forcedIndexBuffer; bool m_forcedIndexBuffer;
size_t indexCount; size_t indexCount;
@ -109,11 +105,11 @@ private:
ID3D12CommandQueue *m_commandQueueGraphic; ID3D12CommandQueue *m_commandQueueGraphic;
struct IDXGISwapChain3 *m_swapChain; struct IDXGISwapChain3 *m_swapChain;
//BackBuffers
ID3D12Resource* m_backBuffer[2];
ID3D12DescriptorHeap *m_backbufferAsRendertarget[2];
size_t m_lastWidth, m_lastHeight, m_lastDepth; size_t m_lastWidth, m_lastHeight, m_lastDepth;
size_t m_currentResourceStorageIndex;
ResourceStorage& getCurrentResourceStorage();
ResourceStorage& getNonCurrentResourceStorage();
public: public:
GSFrameBase2 *m_frame; GSFrameBase2 *m_frame;
u32 m_draw_frames; u32 m_draw_frames;

28
rpcs3/Emu/RSX/D3D12/D3D12Texture.cpp
View file

@ -60,7 +60,7 @@ size_t D3D12GSRender::UploadTextures()
// Upload at each iteration to take advantage of overlapping transfer // Upload at each iteration to take advantage of overlapping transfer
ID3D12GraphicsCommandList *commandList; ID3D12GraphicsCommandList *commandList;
check(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, getCurrentResourceStorage().m_textureUploadCommandAllocator, nullptr, IID_PPV_ARGS(&commandList))); check(m_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_perFrameStorage.m_textureUploadCommandAllocator, nullptr, IID_PPV_ARGS(&commandList)));
DXGI_FORMAT dxgiFormat; DXGI_FORMAT dxgiFormat;
size_t pixelSize; size_t pixelSize;
@ -89,8 +89,8 @@ size_t D3D12GSRender::UploadTextures()
textureDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; textureDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
check(m_device->CreatePlacedResource( check(m_device->CreatePlacedResource(
getCurrentResourceStorage().m_uploadTextureHeap, m_perFrameStorage.m_uploadTextureHeap,
getCurrentResourceStorage().m_currentStorageOffset, m_perFrameStorage.m_currentStorageOffset,
&textureDesc, &textureDesc,
D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_GENERIC_READ,
nullptr, nullptr,
@ -119,18 +119,18 @@ size_t D3D12GSRender::UploadTextures()
vramTextureDesc.SampleDesc.Count = 1; vramTextureDesc.SampleDesc.Count = 1;
vramTextureDesc.MipLevels = 1; vramTextureDesc.MipLevels = 1;
check(m_device->CreatePlacedResource( check(m_device->CreatePlacedResource(
getCurrentResourceStorage().m_textureStorage, m_perFrameStorage.m_textureStorage,
getCurrentResourceStorage().m_currentStorageOffset, m_perFrameStorage.m_currentStorageOffset,
&vramTextureDesc, &vramTextureDesc,
D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COPY_DEST,
nullptr, nullptr,
IID_PPV_ARGS(&vramTexture) IID_PPV_ARGS(&vramTexture)
)); ));
getCurrentResourceStorage().m_currentStorageOffset += textureSize; m_perFrameStorage.m_currentStorageOffset += textureSize;
getCurrentResourceStorage().m_currentStorageOffset = (getCurrentResourceStorage().m_currentStorageOffset + 65536 - 1) & ~65535; m_perFrameStorage.m_currentStorageOffset = (m_perFrameStorage.m_currentStorageOffset + 65536 - 1) & ~65535;
getCurrentResourceStorage().m_inflightResources.push_back(Texture); m_perFrameStorage.m_inflightResources.push_back(Texture);
getCurrentResourceStorage().m_inflightResources.push_back(vramTexture); m_perFrameStorage.m_inflightResources.push_back(vramTexture);
D3D12_TEXTURE_COPY_LOCATION dst = {}, src = {}; D3D12_TEXTURE_COPY_LOCATION dst = {}, src = {};
@ -158,8 +158,8 @@ size_t D3D12GSRender::UploadTextures()
srvDesc.Format = dxgiFormat; srvDesc.Format = dxgiFormat;
srvDesc.Texture2D.MipLevels = 1; srvDesc.Texture2D.MipLevels = 1;
srvDesc.Shader4ComponentMapping = D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1, D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2, D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3, D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0); srvDesc.Shader4ComponentMapping = D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1, D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2, D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3, D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0);
D3D12_CPU_DESCRIPTOR_HANDLE Handle = getCurrentResourceStorage().m_textureDescriptorsHeap->GetCPUDescriptorHandleForHeapStart(); D3D12_CPU_DESCRIPTOR_HANDLE Handle = m_perFrameStorage.m_textureDescriptorsHeap->GetCPUDescriptorHandleForHeapStart();
Handle.ptr += (getCurrentResourceStorage().m_currentTextureIndex + usedTexture) * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); Handle.ptr += (m_perFrameStorage.m_currentTextureIndex + usedTexture) * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
m_device->CreateShaderResourceView(vramTexture, &srvDesc, Handle); m_device->CreateShaderResourceView(vramTexture, &srvDesc, Handle);
// TODO : Correctly define sampler // TODO : Correctly define sampler
@ -174,13 +174,13 @@ size_t D3D12GSRender::UploadTextures()
samplerDesc.BorderColor[4] = m_textures[i].GetBorderColor(); samplerDesc.BorderColor[4] = m_textures[i].GetBorderColor();
samplerDesc.MinLOD = m_textures[i].GetMinLOD() >> 8; samplerDesc.MinLOD = m_textures[i].GetMinLOD() >> 8;
samplerDesc.MaxLOD = m_textures[i].GetMaxLOD() >> 8; samplerDesc.MaxLOD = m_textures[i].GetMaxLOD() >> 8;
Handle = getCurrentResourceStorage().m_samplerDescriptorHeap->GetCPUDescriptorHandleForHeapStart(); Handle = m_perFrameStorage.m_samplerDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
Handle.ptr += (getCurrentResourceStorage().m_currentTextureIndex + usedTexture) * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); Handle.ptr += (m_perFrameStorage.m_currentTextureIndex + usedTexture) * m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
m_device->CreateSampler(&samplerDesc, Handle); m_device->CreateSampler(&samplerDesc, Handle);
commandList->Close(); commandList->Close();
m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)&commandList); m_commandQueueGraphic->ExecuteCommandLists(1, (ID3D12CommandList**)&commandList);
getCurrentResourceStorage().m_inflightCommandList.push_back(commandList); m_perFrameStorage.m_inflightCommandList.push_back(commandList);
usedTexture++; usedTexture++;
} }