diff --git a/Editor/config.ini b/Editor/config.ini index fcbe7ab01..db7591a73 100644 --- a/Editor/config.ini +++ b/Editor/config.ini @@ -1,7 +1,7 @@ enabled 1 x 0 y 0 -w 3840 -h 2160 +w 1920 +h 1080 fullscreen 0 borderless 1 \ No newline at end of file diff --git a/WickedEngine/wiGraphicsDevice.h b/WickedEngine/wiGraphicsDevice.h index 5be7ad772..377aed802 100644 --- a/WickedEngine/wiGraphicsDevice.h +++ b/WickedEngine/wiGraphicsDevice.h @@ -19,6 +19,7 @@ namespace wiGraphicsTypes bool FULLSCREEN; bool RESOLUTIONCHANGED; static FORMAT BACKBUFFER_FORMAT; + static const UINT BACKBUFFER_COUNT = 2; bool TESSELLATION, MULTITHREADED_RENDERING, CONSERVATIVE_RASTERIZATION, RASTERIZER_ORDERED_VIEWS, UNORDEREDACCESSTEXTURE_LOAD_EXT; public: GraphicsDevice() @@ -82,6 +83,7 @@ namespace wiGraphicsTypes return XMMatrixOrthographicOffCenterLH(0, (float)GetScreenWidth(), (float)GetScreenHeight(), 0, -1, 1); } static FORMAT GetBackBufferFormat(); + static UINT GetBackBufferCount() { return BACKBUFFER_COUNT; } ///////////////Thread-sensitive//////////////////////// diff --git a/WickedEngine/wiGraphicsDevice_DX12.cpp b/WickedEngine/wiGraphicsDevice_DX12.cpp index 5f11ff3d4..e69f44dac 100644 --- a/WickedEngine/wiGraphicsDevice_DX12.cpp +++ b/WickedEngine/wiGraphicsDevice_DX12.cpp @@ -1152,13 +1152,13 @@ namespace wiGraphicsTypes // Allocator heaps: - GraphicsDevice_DX12::DescriptorAllocator::DescriptorAllocator(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, bool shaderVisible, UINT maxCount) + GraphicsDevice_DX12::DescriptorAllocator::DescriptorAllocator(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, UINT maxCount) { D3D12_DESCRIPTOR_HEAP_DESC heapDesc = {}; heapDesc.NodeMask = 0; heapDesc.NumDescriptors = maxCount; heapDesc.Type = type; - heapDesc.Flags = shaderVisible ? D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE : D3D12_DESCRIPTOR_HEAP_FLAG_NONE; + heapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; HRESULT hr = device->CreateDescriptorHeap(&heapDesc, __uuidof(ID3D12DescriptorHeap), (void**)&heap); assert(SUCCEEDED(hr)); @@ -1177,6 +1177,62 @@ namespace wiGraphicsTypes +#define GPU_RESOURCE_HEAP_CBV_COUNT 15 +#define GPU_RESOURCE_HEAP_SRV_COUNT 64 +#define GPU_RESOURCE_HEAP_UAV_COUNT 8 +#define GPU_SAMPLER_HEAP_COUNT 16 + GraphicsDevice_DX12::FrameResources::DescriptorTableRingBuffer::DescriptorTableRingBuffer(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, UINT maxRenameCount) + { + if (type == D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER) + { + itemCount = GPU_SAMPLER_HEAP_COUNT; + } + else if (type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV) + { + itemCount = (GPU_RESOURCE_HEAP_CBV_COUNT + GPU_RESOURCE_HEAP_SRV_COUNT + GPU_RESOURCE_HEAP_UAV_COUNT); + } + else + { + assert(0); + } + + D3D12_DESCRIPTOR_HEAP_DESC heapDesc = {}; + heapDesc.NodeMask = 0; + heapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; + heapDesc.Type = type; + heapDesc.NumDescriptors = itemCount * SHADERSTAGE_COUNT * maxRenameCount; + HRESULT hr = device->CreateDescriptorHeap(&heapDesc, __uuidof(ID3D12DescriptorHeap), (void**)&heap); + assert(SUCCEEDED(hr)); + + itemSize = device->GetDescriptorHandleIncrementSize(type); + reset(); + } + GraphicsDevice_DX12::FrameResources::DescriptorTableRingBuffer::~DescriptorTableRingBuffer() + { + SAFE_RELEASE(heap); + } + void GraphicsDevice_DX12::FrameResources::DescriptorTableRingBuffer::reset() + { + for (int i = 0; i < SHADERSTAGE_COUNT; ++i) + { + offset[i] = 0; + } + } + UINT64 GraphicsDevice_DX12::FrameResources::DescriptorTableRingBuffer::GetGPUAddress(SHADERSTAGE stage) + { + D3D12_GPU_DESCRIPTOR_HANDLE table = heap->GetGPUDescriptorHandleForHeapStart(); + table.ptr += stage * itemCount * itemSize; + return table.ptr; + } + SIZE_T GraphicsDevice_DX12::FrameResources::DescriptorTableRingBuffer::GetCPUAddress(SHADERSTAGE stage, UINT offset) + { + D3D12_CPU_DESCRIPTOR_HANDLE table = heap->GetCPUDescriptorHandleForHeapStart(); + table.ptr += (stage * itemCount + offset) * itemSize; + return table.ptr; + } + + + GraphicsDevice_DX12::UploadBuffer::UploadBuffer(ID3D12Device* device, size_t size) { HRESULT hr = device->CreateCommittedResource( @@ -1226,13 +1282,6 @@ namespace wiGraphicsTypes return static_cast(address - dataBegin); } - -#define GPU_RESOURCE_HEAP_CBV_COUNT 15 -#define GPU_RESOURCE_HEAP_SRV_COUNT 64 -#define GPU_RESOURCE_HEAP_UAV_COUNT 8 -#define GPU_RESOURCE_HEAP_COUNT (GPU_RESOURCE_HEAP_CBV_COUNT + GPU_RESOURCE_HEAP_SRV_COUNT + GPU_RESOURCE_HEAP_UAV_COUNT) -#define GPU_SAMPLER_HEAP_COUNT 16 - // Engine functions GraphicsDevice_DX12::GraphicsDevice_DX12(wiWindowRegistration::window_type window, bool fullscreen) : GraphicsDevice() @@ -1303,7 +1352,7 @@ namespace wiGraphicsTypes sd.SampleDesc.Count = 1; // Don't use multi-sampling. sd.SampleDesc.Quality = 0; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; - sd.BufferCount = 2; // Use double-buffering to minimize latency. + sd.BufferCount = BACKBUFFER_COUNT; sd.Flags = 0; sd.AlphaMode = DXGI_ALPHA_MODE_IGNORE; @@ -1338,29 +1387,39 @@ namespace wiGraphicsTypes // Create common descriptor heaps - RTAllocator = new DescriptorAllocator(device, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, false, 128); - DSAllocator = new DescriptorAllocator(device, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, false, 128); - ResourceAllocator = new DescriptorAllocator(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, false, 4096); - SamplerAllocator = new DescriptorAllocator(device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, false, 64); - for (int i = 0; i < GRAPHICSTHREAD_COUNT; ++i) + RTAllocator = new DescriptorAllocator(device, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, 128); + DSAllocator = new DescriptorAllocator(device, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, 128); + ResourceAllocator = new DescriptorAllocator(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 4096); + SamplerAllocator = new DescriptorAllocator(device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, 64); + + // Create frame-resident resources: + for (UINT fr = 0; fr < BACKBUFFER_COUNT; ++fr) { - D3D12_DESCRIPTOR_HEAP_DESC heapDesc = {}; - heapDesc.NodeMask = 0; - heapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; - - heapDesc.NumDescriptors = GPU_RESOURCE_HEAP_COUNT * SHADERSTAGE_COUNT; - heapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV; - HRESULT hr = device->CreateDescriptorHeap(&heapDesc, __uuidof(ID3D12DescriptorHeap), (void**)&ResourceDescriptorHeapGPU[i]); - assert(SUCCEEDED(hr)); - - heapDesc.NumDescriptors = GPU_SAMPLER_HEAP_COUNT * SHADERSTAGE_COUNT; - heapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER; - hr = device->CreateDescriptorHeap(&heapDesc, __uuidof(ID3D12DescriptorHeap), (void**)&SamplerDescriptorHeapGPU[i]); - assert(SUCCEEDED(hr)); + for (int i = 0; i < GRAPHICSTHREAD_COUNT; ++i) + { + frames[fr].ResourceDescriptorsGPU[i] = new FrameResources::DescriptorTableRingBuffer(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1024); + frames[fr].SamplerDescriptorsGPU[i] = new FrameResources::DescriptorTableRingBuffer(device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, 16); + } } // Create null resources for unbinding: { + D3D12_SAMPLER_DESC sampler_desc = {}; + sampler_desc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + sampler_desc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + sampler_desc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + sampler_desc.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER; + sampler_desc.Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR; + nullSampler = new D3D12_CPU_DESCRIPTOR_HANDLE; + nullSampler->ptr = SamplerAllocator->allocate(); + device->CreateSampler(&sampler_desc, *nullSampler); + + + D3D12_CONSTANT_BUFFER_VIEW_DESC cbv_desc = {}; + nullCBV = new D3D12_CPU_DESCRIPTOR_HANDLE; + nullCBV->ptr = ResourceAllocator->allocate(); + device->CreateConstantBufferView(&cbv_desc, *nullCBV); + D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; @@ -1387,12 +1446,15 @@ namespace wiGraphicsTypes D3D12_CPU_DESCRIPTOR_HANDLE renderTargetViewHandle = {}; renderTargetViewHandle.ptr = RTAllocator->allocate(); - hr = swapChain->GetBuffer(0, __uuidof(ID3D12Resource), (void**)&backBuffer[0]); - device->CreateRenderTargetView(backBuffer[0], nullptr, renderTargetViewHandle); + for (UINT buf = 0; buf < BACKBUFFER_COUNT; ++buf) + { + hr = swapChain->GetBuffer(buf, __uuidof(ID3D12Resource), (void**)&backBuffer[buf]); + device->CreateRenderTargetView(backBuffer[buf], nullptr, renderTargetViewHandle); - renderTargetViewHandle.ptr = RTAllocator->allocate(); - hr = swapChain->GetBuffer(1, __uuidof(ID3D12Resource), (void**)&backBuffer[1]); - device->CreateRenderTargetView(backBuffer[1], nullptr, renderTargetViewHandle); + renderTargetViewHandle.ptr = RTAllocator->allocate(); + hr = swapChain->GetBuffer(buf, __uuidof(ID3D12Resource), (void**)&backBuffer[buf]); + device->CreateRenderTargetView(backBuffer[buf], nullptr, renderTargetViewHandle); + } backBufferIndex = swapChain->GetCurrentBackBufferIndex(); @@ -1479,7 +1541,8 @@ namespace wiGraphicsTypes - UINT paramCount = 2 * (SHADERSTAGE_COUNT - 1); // 2: resource,sampler; 5: vs,hs,ds,gs,ps + + UINT paramCount = 2 * (SHADERSTAGE_COUNT - 1); // 2: resource,sampler; 5: vs,hs,ds,gs,ps; D3D12_ROOT_PARAMETER* params = new D3D12_ROOT_PARAMETER[paramCount]; params[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; params[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_VERTEX; @@ -1638,14 +1701,19 @@ namespace wiGraphicsTypes SAFE_RELEASE(commandFences[i]); CloseHandle(commandFenceEvents[i]); - SAFE_RELEASE(ResourceDescriptorHeapGPU[i]); - SAFE_RELEASE(SamplerDescriptorHeapGPU[i]); + for (UINT fr = 0; fr < BACKBUFFER_COUNT; ++fr) + { + SAFE_DELETE(frames[fr].ResourceDescriptorsGPU[i]); + SAFE_DELETE(frames[fr].SamplerDescriptorsGPU[i]); + } } SAFE_RELEASE(copyQueue); SAFE_RELEASE(copyAllocator); SAFE_RELEASE(copyCommandList); + SAFE_DELETE(nullSampler); + SAFE_DELETE(nullCBV); SAFE_DELETE(nullSRV); SAFE_DELETE(nullUAV); @@ -2757,10 +2825,7 @@ namespace wiGraphicsTypes // Get the render target view handle for the current back buffer. D3D12_CPU_DESCRIPTOR_HANDLE renderTargetViewHandle = RTAllocator->heap->GetCPUDescriptorHandleForHeapStart(); UINT renderTargetViewDescriptorSize = RTAllocator->itemSize; - if (backBufferIndex == 1) - { - renderTargetViewHandle.ptr += renderTargetViewDescriptorSize; - } + renderTargetViewHandle.ptr += renderTargetViewDescriptorSize * backBufferIndex; // Set the back buffer as the render target. @@ -2827,33 +2892,35 @@ namespace wiGraphicsTypes ID3D12DescriptorHeap* heaps[] = { - ResourceDescriptorHeapGPU[GRAPHICSTHREAD_IMMEDIATE], SamplerDescriptorHeapGPU[GRAPHICSTHREAD_IMMEDIATE] + GetFrameResources().ResourceDescriptorsGPU[GRAPHICSTHREAD_IMMEDIATE]->heap, GetFrameResources().SamplerDescriptorsGPU[GRAPHICSTHREAD_IMMEDIATE]->heap }; static_cast(commandLists[GRAPHICSTHREAD_IMMEDIATE])->SetDescriptorHeaps(ARRAYSIZE(heaps), heaps); static_cast(commandLists[GRAPHICSTHREAD_IMMEDIATE])->SetGraphicsRootSignature(graphicsRootSig); static_cast(commandLists[GRAPHICSTHREAD_IMMEDIATE])->SetComputeRootSignature(computeRootSig); + // graphics descriptor heap: for (UINT shader = VS; shader < SHADERSTAGE_COUNT - 1; ++shader) { - D3D12_GPU_DESCRIPTOR_HANDLE resource_table = ResourceDescriptorHeapGPU[GRAPHICSTHREAD_IMMEDIATE]->GetGPUDescriptorHandleForHeapStart(); - resource_table.ptr += shader * GPU_RESOURCE_HEAP_COUNT * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + D3D12_GPU_DESCRIPTOR_HANDLE resource_table; + resource_table.ptr = GetFrameResources().ResourceDescriptorsGPU[GRAPHICSTHREAD_IMMEDIATE]->GetGPUAddress((SHADERSTAGE)shader); static_cast(commandLists[GRAPHICSTHREAD_IMMEDIATE])->SetGraphicsRootDescriptorTable(shader * 2 + 0, resource_table); - D3D12_GPU_DESCRIPTOR_HANDLE sampler_table = SamplerDescriptorHeapGPU[GRAPHICSTHREAD_IMMEDIATE]->GetGPUDescriptorHandleForHeapStart(); - sampler_table.ptr += shader * GPU_SAMPLER_HEAP_COUNT * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); + D3D12_GPU_DESCRIPTOR_HANDLE sampler_table; + sampler_table.ptr = GetFrameResources().SamplerDescriptorsGPU[GRAPHICSTHREAD_IMMEDIATE]->GetGPUAddress((SHADERSTAGE)shader); static_cast(commandLists[GRAPHICSTHREAD_IMMEDIATE])->SetGraphicsRootDescriptorTable(shader * 2 + 1, sampler_table); } - D3D12_GPU_DESCRIPTOR_HANDLE resource_table = ResourceDescriptorHeapGPU[GRAPHICSTHREAD_IMMEDIATE]->GetGPUDescriptorHandleForHeapStart(); - resource_table.ptr += CS * GPU_RESOURCE_HEAP_COUNT * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + // compute descriptor heap: + D3D12_GPU_DESCRIPTOR_HANDLE resource_table; + resource_table.ptr = GetFrameResources().ResourceDescriptorsGPU[GRAPHICSTHREAD_IMMEDIATE]->GetGPUAddress(CS); static_cast(commandLists[GRAPHICSTHREAD_IMMEDIATE])->SetComputeRootDescriptorTable(0, resource_table); - D3D12_GPU_DESCRIPTOR_HANDLE sampler_table = SamplerDescriptorHeapGPU[GRAPHICSTHREAD_IMMEDIATE]->GetGPUDescriptorHandleForHeapStart(); - sampler_table.ptr += CS * GPU_SAMPLER_HEAP_COUNT * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); + D3D12_GPU_DESCRIPTOR_HANDLE sampler_table; + sampler_table.ptr = GetFrameResources().SamplerDescriptorsGPU[GRAPHICSTHREAD_IMMEDIATE]->GetGPUAddress(CS); static_cast(commandLists[GRAPHICSTHREAD_IMMEDIATE])->SetComputeRootDescriptorTable(1, sampler_table); @@ -3118,9 +3185,7 @@ namespace wiGraphicsTypes resource->resourceState[threadID] = _ConvertResourceStates_Inv(requiredState); } - D3D12_CPU_DESCRIPTOR_HANDLE dst = ResourceDescriptorHeapGPU[threadID]->GetCPUDescriptorHandleForHeapStart(); - int offset = CS * GPU_RESOURCE_HEAP_COUNT + GPU_RESOURCE_HEAP_CBV_COUNT + GPU_RESOURCE_HEAP_SRV_COUNT + slot; - dst.ptr += (SIZE_T)(offset * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)); + D3D12_CPU_DESCRIPTOR_HANDLE dst = { GetFrameResources().ResourceDescriptorsGPU[threadID]->GetCPUAddress(CS, GPU_RESOURCE_HEAP_CBV_COUNT + GPU_RESOURCE_HEAP_SRV_COUNT + slot) }; if (arrayIndex < 0) { @@ -3152,9 +3217,7 @@ namespace wiGraphicsTypes { for (int i = 0; i < num; ++i) { - D3D12_CPU_DESCRIPTOR_HANDLE dst = ResourceDescriptorHeapGPU[threadID]->GetCPUDescriptorHandleForHeapStart(); - int offset = stage * GPU_RESOURCE_HEAP_COUNT + GPU_RESOURCE_HEAP_CBV_COUNT + slot + i; - dst.ptr += (SIZE_T)(offset * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)); + D3D12_CPU_DESCRIPTOR_HANDLE dst = { GetFrameResources().ResourceDescriptorsGPU[threadID]->GetCPUAddress((SHADERSTAGE)stage, GPU_RESOURCE_HEAP_CBV_COUNT + slot + i) }; device->CopyDescriptorsSimple(1, dst, *nullSRV, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); } @@ -3162,13 +3225,14 @@ namespace wiGraphicsTypes } void GraphicsDevice_DX12::UnBindUnorderedAccessResources(int slot, int num, GRAPHICSTHREAD threadID) { - for (int i = 0; i < num; ++i) + for (int stage = 0; stage < SHADERSTAGE_COUNT; ++stage) { - D3D12_CPU_DESCRIPTOR_HANDLE dst = ResourceDescriptorHeapGPU[threadID]->GetCPUDescriptorHandleForHeapStart(); - int offset = CS * GPU_RESOURCE_HEAP_COUNT + GPU_RESOURCE_HEAP_CBV_COUNT + GPU_RESOURCE_HEAP_SRV_COUNT + slot + i; - dst.ptr += (SIZE_T)(offset * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)); + for (int i = 0; i < num; ++i) + { + D3D12_CPU_DESCRIPTOR_HANDLE dst = { GetFrameResources().ResourceDescriptorsGPU[threadID]->GetCPUAddress((SHADERSTAGE)stage, GPU_RESOURCE_HEAP_CBV_COUNT + GPU_RESOURCE_HEAP_SRV_COUNT + slot + i) }; - device->CopyDescriptorsSimple(1, dst, *nullUAV, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + device->CopyDescriptorsSimple(1, dst, *nullUAV, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + } } } void GraphicsDevice_DX12::BindSamplerPS(Sampler* sampler, int slot, GRAPHICSTHREAD threadID) @@ -3334,6 +3398,89 @@ namespace wiGraphicsTypes } void GraphicsDevice_DX12::UpdateBuffer(GPUBuffer* buffer, const void* data, GRAPHICSTHREAD threadID, int dataSize) { + //assert(buffer->desc.Usage != USAGE_IMMUTABLE && "Cannot update IMMUTABLE GPUBuffer!"); + //assert((int)buffer->desc.ByteWidth >= dataSize || dataSize < 0 && "Data size is too big!"); + + //if (dataSize == 0) + //{ + // return; + //} + + //dataSize = min((int)buffer->desc.ByteWidth, dataSize); + + //if (buffer->desc.BindFlags & BIND_CONSTANT_BUFFER) + //{ + // { + // D3D12_RESOURCE_STATES currentState = _ConvertResourceStates(buffer->resourceState[threadID]); + // D3D12_RESOURCE_STATES requiredState = D3D12_RESOURCE_STATE_COPY_DEST; + // if (currentState != requiredState) + // { + // D3D12_RESOURCE_BARRIER barrier = {}; + // barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; + // barrier.Transition.pResource = buffer->resource_DX12; + // barrier.Transition.StateBefore = currentState; + // barrier.Transition.StateAfter = requiredState; + // barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; + // barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; + // static_cast(commandLists[threadID])->ResourceBarrier(1, &barrier); + + // buffer->resourceState[threadID] = _ConvertResourceStates_Inv(requiredState); + // } + // } + + // UINT count = (dataSize >= 0 ? dataSize : buffer->desc.ByteWidth) / sizeof(uint32_t); + // static D3D12_WRITEBUFFERIMMEDIATE_PARAMETER params[GRAPHICSTHREAD_COUNT][128] = {}; + // for (UINT i = 0; i < count; ++i) + // { + // params[threadID][i].Dest = buffer->resource_DX12->GetGPUVirtualAddress() + i * 4; + // params[threadID][i].Value = *reinterpret_cast((uint8_t*)data + i * 4); + // } + // //static_cast(commandLists[threadID])->WriteBufferImmediate(count, params[threadID], nullptr); + // ID3D12GraphicsCommandList1* cmd; + // HRESULT hr = commandLists[threadID]->QueryInterface(__uuidof(ID3D12GraphicsCommandList1), (void**)&cmd); + + // { + // D3D12_RESOURCE_STATES currentState = D3D12_RESOURCE_STATE_COPY_DEST; + // D3D12_RESOURCE_STATES requiredState = D3D12_RESOURCE_STATE_GENERIC_READ; + // if (currentState != requiredState) + // { + // D3D12_RESOURCE_BARRIER barrier = {}; + // barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; + // barrier.Transition.pResource = buffer->resource_DX12; + // barrier.Transition.StateBefore = currentState; + // barrier.Transition.StateAfter = requiredState; + // barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; + // barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; + // static_cast(commandLists[threadID])->ResourceBarrier(1, &barrier); + + // buffer->resourceState[threadID] = _ConvertResourceStates_Inv(requiredState); + // } + // } + //} + + //if (buffer->desc.Usage == USAGE_DYNAMIC) + //{ + // D3D12_MAPPED_SUBRESOURCE mappedResource; + // HRESULT hr = deviceContexts[threadID]->Map(buffer->resource_DX11, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + // assert(SUCCEEDED(hr) && "GPUBuffer mapping failed!"); + // memcpy(mappedResource.pData, data, (dataSize >= 0 ? dataSize : buffer->desc.ByteWidth)); + // deviceContexts[threadID]->Unmap(buffer->resource_DX11, 0); + //} + //else if (buffer->desc.BindFlags & BIND_CONSTANT_BUFFER || dataSize < 0) + //{ + // deviceContexts[threadID]->UpdateSubresource(buffer->resource_DX11, 0, nullptr, data, 0, 0); + //} + //else + //{ + // D3D11_BOX box = {}; + // box.left = 0; + // box.right = static_cast(dataSize); + // box.top = 0; + // box.bottom = 1; + // box.front = 0; + // box.back = 1; + // deviceContexts[threadID]->UpdateSubresource(buffer->resource_DX11, 0, &box, data, 0, 0); + //} } void* GraphicsDevice_DX12::AllocateFromRingBuffer(GPURingBuffer* buffer, size_t dataSize, UINT& offsetIntoBuffer, GRAPHICSTHREAD threadID) { @@ -3423,10 +3570,7 @@ namespace wiGraphicsTypes resource->resourceState[threadID] = _ConvertResourceStates_Inv(requiredState); } - - D3D12_CPU_DESCRIPTOR_HANDLE dst = ResourceDescriptorHeapGPU[threadID]->GetCPUDescriptorHandleForHeapStart(); - int offset = stage * GPU_RESOURCE_HEAP_COUNT + GPU_RESOURCE_HEAP_CBV_COUNT + slot; - dst.ptr += (SIZE_T)(offset * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)); + D3D12_CPU_DESCRIPTOR_HANDLE dst = { GetFrameResources().ResourceDescriptorsGPU[threadID]->GetCPUAddress(stage, GPU_RESOURCE_HEAP_CBV_COUNT + slot) }; if (arrayIndex < 0) { @@ -3446,9 +3590,7 @@ namespace wiGraphicsTypes { if (sampler != nullptr && sampler->resource_DX12 != nullptr) { - D3D12_CPU_DESCRIPTOR_HANDLE dst = SamplerDescriptorHeapGPU[threadID]->GetCPUDescriptorHandleForHeapStart(); - int offset = stage * GPU_SAMPLER_HEAP_COUNT + slot; - dst.ptr += (SIZE_T)(offset * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER)); + D3D12_CPU_DESCRIPTOR_HANDLE dst = { GetFrameResources().SamplerDescriptorsGPU[threadID]->GetCPUAddress(stage, slot) }; device->CopyDescriptorsSimple(1, dst, *sampler->resource_DX12, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); } @@ -3457,9 +3599,7 @@ namespace wiGraphicsTypes { if (buffer != nullptr && buffer->CBV_DX12 != nullptr) { - D3D12_CPU_DESCRIPTOR_HANDLE dst = ResourceDescriptorHeapGPU[threadID]->GetCPUDescriptorHandleForHeapStart(); - int offset = stage * GPU_RESOURCE_HEAP_COUNT + slot; - dst.ptr += (SIZE_T)(offset * device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)); + D3D12_CPU_DESCRIPTOR_HANDLE dst = { GetFrameResources().ResourceDescriptorsGPU[threadID]->GetCPUAddress(stage, slot) }; device->CopyDescriptorsSimple(1, dst, *buffer->CBV_DX12, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); } diff --git a/WickedEngine/wiGraphicsDevice_DX12.h b/WickedEngine/wiGraphicsDevice_DX12.h index db422b02f..72ff6ec5f 100644 --- a/WickedEngine/wiGraphicsDevice_DX12.h +++ b/WickedEngine/wiGraphicsDevice_DX12.h @@ -35,7 +35,7 @@ namespace wiGraphicsTypes ID3D12CommandQueue* copyQueue; ID3D12CommandAllocator* copyAllocator; ID3D12CommandList* copyCommandList; - ID3D12Resource* backBuffer[2]; + ID3D12Resource* backBuffer[BACKBUFFER_COUNT]; UINT backBufferIndex; ID3D12RootSignature* graphicsRootSig; @@ -48,7 +48,7 @@ namespace wiGraphicsTypes UINT maxCount; UINT itemSize; - DescriptorAllocator(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, bool shaderVisible, UINT maxCount); + DescriptorAllocator(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, UINT maxCount); ~DescriptorAllocator(); size_t allocate(); @@ -57,9 +57,33 @@ namespace wiGraphicsTypes DescriptorAllocator* DSAllocator; DescriptorAllocator* ResourceAllocator; DescriptorAllocator* SamplerAllocator; - ID3D12DescriptorHeap* ResourceDescriptorHeapGPU[GRAPHICSTHREAD_COUNT]; - ID3D12DescriptorHeap* SamplerDescriptorHeapGPU[GRAPHICSTHREAD_COUNT]; + + struct FrameResources + { + struct DescriptorTableRingBuffer + { + ID3D12DescriptorHeap* heap; + UINT itemSize; + UINT itemCount; + UINT offset[SHADERSTAGE_COUNT]; + + DescriptorTableRingBuffer(ID3D12Device* device, D3D12_DESCRIPTOR_HEAP_TYPE type, UINT maxRenameCount); + ~DescriptorTableRingBuffer(); + + void reset(); + UINT64 GetGPUAddress(SHADERSTAGE stage); + SIZE_T GetCPUAddress(SHADERSTAGE stage, UINT offset); + }; + DescriptorTableRingBuffer* ResourceDescriptorsGPU[GRAPHICSTHREAD_COUNT]; + DescriptorTableRingBuffer* SamplerDescriptorsGPU[GRAPHICSTHREAD_COUNT]; + }; + FrameResources frames[BACKBUFFER_COUNT]; + FrameResources& GetFrameResources() { return frames[GetFrameCount() % BACKBUFFER_COUNT]; } + + + D3D12_CPU_DESCRIPTOR_HANDLE* nullSampler; + D3D12_CPU_DESCRIPTOR_HANDLE* nullCBV; D3D12_CPU_DESCRIPTOR_HANDLE* nullSRV; D3D12_CPU_DESCRIPTOR_HANDLE* nullUAV;