FD3D12ResourceLocation* FD3D12DynamicRHI::CreateBuffer(FRHICommandListImmediate* RHICmdList, const D3D12_RESOURCE_DESC Desc, uint32 Size, uint32 InUsage, FRHIResourceCreateInfo& CreateInfo, uint32 Alignment) { // Explicitly check that the size is nonzero before allowing CreateBuffer to opaquely fail. check(Size > 0); const bool bIsDynamic = (InUsage & BUF_AnyDynamic) ? true : false; FD3D12ResourceLocation* ResourceLocation = new FD3D12ResourceLocation(GetRHIDevice()); // If a resource array was provided for the resource, create the resource pre-populated D3D12_SUBRESOURCE_DATA InitData = { 0 }; D3D12_SUBRESOURCE_DATA* pInitData = nullptr; if (CreateInfo.ResourceArray) { check(Size == CreateInfo.ResourceArray->GetResourceDataSize()); InitData.pData = CreateInfo.ResourceArray->GetResourceData(); InitData.RowPitch = Size; InitData.SlicePitch = 0; pInitData = &InitData; } if (bIsDynamic) { void* pData = GetRHIDevice()->GetDefaultUploadHeapAllocator().AllocUploadResource(Size, Alignment, ResourceLocation); check(ResourceLocation->GetEffectiveBufferSize() == Size); if (pInitData) { // Handle initial data FMemory::Memcpy(pData, InitData.pData, Size); } } else { if (RHICmdList && pInitData) { // We only need to synchronize when creating default resource buffers (because we need a command list to initialize them) FScopedRHIThreadStaller StallRHIThread(*RHICmdList); VERIFYD3D11RESULT(GetRHIDevice()->GetDefaultBufferAllocator().AllocDefaultResource(Desc, pInitData, ResourceLocation, Alignment)); } else { VERIFYD3D11RESULT(GetRHIDevice()->GetDefaultBufferAllocator().AllocDefaultResource(Desc, pInitData, ResourceLocation, Alignment)); } check(ResourceLocation->GetEffectiveBufferSize() == Size); } if (CreateInfo.ResourceArray) { // Discard the resource array's contents. CreateInfo.ResourceArray->Discard(); } return ResourceLocation; }
FUnorderedAccessViewRHIRef FD3D12DynamicRHI::RHICreateUnorderedAccessView(FStructuredBufferRHIParamRef StructuredBufferRHI, bool bUseUAVCounter, bool bAppendBuffer) { FD3D12StructuredBuffer* StructuredBuffer = FD3D12DynamicRHI::ResourceCast(StructuredBufferRHI); const D3D12_RESOURCE_DESC& BufferDesc = StructuredBuffer->Resource->GetDesc(); const uint32 BufferUsage = StructuredBuffer->GetUsage(); const bool bByteAccessBuffer = (BufferUsage & BUF_ByteAddressBuffer) != 0; const bool bStructuredBuffer = !bByteAccessBuffer; check(bByteAccessBuffer != bStructuredBuffer); // You can't have a structured buffer that allows raw views D3D12_UNORDERED_ACCESS_VIEW_DESC UAVDesc ={}; UAVDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER; UAVDesc.Format = DXGI_FORMAT_UNKNOWN; uint32 EffectiveStride = StructuredBuffer->GetStride(); if (bByteAccessBuffer) { UAVDesc.Format = DXGI_FORMAT_R32_TYPELESS; EffectiveStride = 4; } else if (BufferUsage & BUF_DrawIndirect) { UAVDesc.Format = DXGI_FORMAT_R32_UINT; EffectiveStride = 4; } UAVDesc.Buffer.FirstElement = StructuredBuffer->ResourceLocation->GetOffset() / EffectiveStride; UAVDesc.Buffer.NumElements = StructuredBuffer->ResourceLocation->GetEffectiveBufferSize() / EffectiveStride; UAVDesc.Buffer.StructureByteStride = bStructuredBuffer ? EffectiveStride : 0; UAVDesc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE; UAVDesc.Buffer.CounterOffsetInBytes = 0; const bool bNeedsCounterResource = bAppendBuffer | bUseUAVCounter; TRefCountPtr<FD3D12Resource> CounterResource; if (bNeedsCounterResource) { GetRHIDevice()->GetResourceHelper().CreateBuffer(D3D12_HEAP_TYPE_DEFAULT, 4, CounterResource.GetInitReference(), D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS); } if (bByteAccessBuffer) { UAVDesc.Buffer.Flags |= D3D12_BUFFER_UAV_FLAG_RAW; } return new FD3D12UnorderedAccessView(GetRHIDevice(), &UAVDesc, StructuredBuffer->ResourceLocation, CounterResource); }
/** * Creates a bound shader state instance which encapsulates a decl, vertex shader, and pixel shader * @param VertexDeclaration - existing vertex decl * @param StreamStrides - optional stream strides * @param VertexShader - existing vertex shader * @param HullShader - existing hull shader * @param DomainShader - existing domain shader * @param PixelShader - existing pixel shader * @param GeometryShader - existing geometry shader */ FBoundShaderStateRHIRef FD3D12DynamicRHI::RHICreateBoundShaderState( FVertexDeclarationRHIParamRef VertexDeclarationRHI, FVertexShaderRHIParamRef VertexShaderRHI, FHullShaderRHIParamRef HullShaderRHI, FDomainShaderRHIParamRef DomainShaderRHI, FPixelShaderRHIParamRef PixelShaderRHI, FGeometryShaderRHIParamRef GeometryShaderRHI ) { SCOPE_CYCLE_COUNTER(STAT_D3D12CreateBoundShaderStateTime); checkf(GIsRHIInitialized && GetRHIDevice()->GetCommandListManager().IsReady(), (TEXT("Bound shader state RHI resource was created without initializing Direct3D first"))); #if D3D12_SUPPORTS_PARALLEL_RHI_EXECUTE // Check for an existing bound shader state which matches the parameters FBoundShaderStateRHIRef CachedBoundShaderState = GetCachedBoundShaderState_Threadsafe( VertexDeclarationRHI, VertexShaderRHI, PixelShaderRHI, HullShaderRHI, DomainShaderRHI, GeometryShaderRHI ); if(CachedBoundShaderState.GetReference()) { // If we've already created a bound shader state with these parameters, reuse it. return CachedBoundShaderState; } #else check(IsInRenderingThread() || IsInRHIThread()); // Check for an existing bound shader state which matches the parameters FCachedBoundShaderStateLink* CachedBoundShaderStateLink = GetCachedBoundShaderState( VertexDeclarationRHI, VertexShaderRHI, PixelShaderRHI, HullShaderRHI, DomainShaderRHI, GeometryShaderRHI ); if(CachedBoundShaderStateLink) { // If we've already created a bound shader state with these parameters, reuse it. return CachedBoundShaderStateLink->BoundShaderState; } #endif else { SCOPE_CYCLE_COUNTER(STAT_D3D12NewBoundShaderStateTime); return new FD3D12BoundShaderState(VertexDeclarationRHI, VertexShaderRHI, PixelShaderRHI, HullShaderRHI, DomainShaderRHI, GeometryShaderRHI); } }
void* FD3D12DynamicRHI::LockBuffer(FRHICommandListImmediate* RHICmdList, BufferType* Buffer, uint32 Offset, uint32 Size, EResourceLockMode LockMode) { FD3D12LockedData LockedData; // Determine whether the buffer is dynamic or not. const bool bIsDynamic = (Buffer->GetUsage() & BUF_AnyDynamic) ? true : false; void* Data = nullptr; if (bIsDynamic) { check(LockMode == RLM_WriteOnly); TRefCountPtr<FD3D12ResourceLocation> newLocation = new FD3D12ResourceLocation(GetRHIDevice()); // Allocate a new resource Data = GetRHIDevice()->GetDefaultUploadHeapAllocator().AllocUploadResource(Buffer->ResourceLocation->GetEffectiveBufferSize(), Buffer->BufferAlignment, newLocation); // If on the RenderThread, queue up a command on the RHIThread to rename this buffer at the correct time if (ShouldDeferBufferLockOperation(RHICmdList)) { new (RHICmdList->AllocCommand<FRHICommandRenameUploadBuffer<BufferType>>()) FRHICommandRenameUploadBuffer<BufferType>(Buffer, newLocation); } else { Buffer->Rename(newLocation); } } else { FD3D12Resource* pResource = Buffer->ResourceLocation->GetResource(); // Locking for read must occur immediately so we can't queue up the operations later. if (LockMode == RLM_ReadOnly) { // If the static buffer is being locked for reading, create a staging buffer. TRefCountPtr<FD3D12Resource> StagingBuffer; VERIFYD3D11RESULT(GetRHIDevice()->GetResourceHelper().CreateBuffer(D3D12_HEAP_TYPE_READBACK, Offset + Size, StagingBuffer.GetInitReference())); LockedData.StagingResource = StagingBuffer; // Copy the contents of the buffer to the staging buffer. { const auto& pfnCopyContents = [&]() { FD3D12CommandContext& DefaultContext = GetRHIDevice()->GetDefaultCommandContext(); FD3D12CommandListHandle& hCommandList = DefaultContext.CommandListHandle; FScopeResourceBarrier ScopeResourceBarrierSource(hCommandList, pResource, pResource->GetDefaultResourceState(), D3D12_RESOURCE_STATE_COPY_SOURCE, 0); // Don't need to transition upload heaps DefaultContext.numCopies++; hCommandList->CopyBufferRegion( StagingBuffer->GetResource(), 0, pResource->GetResource(), Offset, Size); DefaultContext.FlushCommands(true); }; if (ShouldDeferBufferLockOperation(RHICmdList)) { // Sync when in the render thread implementation check(IsInRHIThread() == false); RHICmdList->ImmediateFlush(EImmediateFlushType::FlushRHIThread); pfnCopyContents(); } else { check(IsInRHIThread()); pfnCopyContents(); } } // Map the staging buffer's memory for reading. VERIFYD3D11RESULT(StagingBuffer->GetResource()->Map(0, nullptr, &Data)); } else { // If the static buffer is being locked for writing, allocate memory for the contents to be written to. TRefCountPtr<FD3D12ResourceLocation> UploadBufferLocation = new FD3D12ResourceLocation(GetRHIDevice()); Data = GetRHIDevice()->GetDefaultFastAllocator().Allocate(Offset + Size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT, UploadBufferLocation); // Keep track of the underlying resource for the upload heap so it can be referenced during Unmap. LockedData.UploadHeapLocation = UploadBufferLocation; } } check(Data); // Add the lock to the lock map. LockedData.SetData(Data); LockedData.Pitch = Offset + Size; // Add the lock to the lock map. FD3D12LockedKey LockedKey(Buffer); AddToOutstandingLocks(LockedKey, LockedData); // Return the offset pointer return (void*)((uint8*)LockedData.GetData() + Offset); }
void* FD3D12DynamicRHI::LockBuffer(FRHICommandListImmediate* RHICmdList, BufferType* Buffer, uint32 Offset, uint32 Size, EResourceLockMode LockMode) { #if STATS LockBufferCalls++; SCOPE_CYCLE_COUNTER(STAT_D3D12LockBufferTime); INC_DWORD_STAT_BY(STAT_D3D12LockBufferCalls, LockBufferCalls); #endif FD3D12LockedResource& LockedData = Buffer->LockedData; check(LockedData.bLocked == false); FD3D12Device* Device = GetRHIDevice(); FD3D12Adapter& Adapter = GetAdapter(); // Determine whether the buffer is dynamic or not. const bool bIsDynamic = (Buffer->GetUsage() & BUF_AnyDynamic) ? true : false; void* Data = nullptr; if (bIsDynamic) { check(LockMode == RLM_WriteOnly); BufferType* CurrentBuffer = Buffer; // Update all of the resources in the LDA chain while (CurrentBuffer) { // Allocate a new resource // If on the RenderThread, queue up a command on the RHIThread to rename this buffer at the correct time if (ShouldDeferBufferLockOperation(RHICmdList)) { FRHICommandRenameUploadBuffer<BufferType>* Command = new (RHICmdList->AllocCommand<FRHICommandRenameUploadBuffer<BufferType>>()) FRHICommandRenameUploadBuffer<BufferType>(CurrentBuffer, Device); Data = Adapter.GetUploadHeapAllocator().AllocUploadResource(Buffer->GetSize(), Buffer->BufferAlignment, Command->NewResource); } else { FD3D12ResourceLocation Location(CurrentBuffer->GetParentDevice()); Data = Adapter.GetUploadHeapAllocator().AllocUploadResource(Buffer->GetSize(), Buffer->BufferAlignment, Location); CurrentBuffer->Rename(Location); } CurrentBuffer = CurrentBuffer->GetNextObject(); } } else { FD3D12Resource* pResource = Buffer->ResourceLocation.GetResource(); // Locking for read must occur immediately so we can't queue up the operations later. if (LockMode == RLM_ReadOnly) { LockedData.bLockedForReadOnly = true; // If the static buffer is being locked for reading, create a staging buffer. FD3D12Resource* StagingBuffer = nullptr; const GPUNodeMask Node = Device->GetNodeMask(); VERIFYD3D12RESULT(Adapter.CreateBuffer(D3D12_HEAP_TYPE_READBACK, Node, Node, Offset + Size, &StagingBuffer)); // Copy the contents of the buffer to the staging buffer. { const auto& pfnCopyContents = [&]() { FD3D12CommandContext& DefaultContext = Device->GetDefaultCommandContext(); FD3D12CommandListHandle& hCommandList = DefaultContext.CommandListHandle; FScopeResourceBarrier ScopeResourceBarrierSource(hCommandList, pResource, pResource->GetDefaultResourceState(), D3D12_RESOURCE_STATE_COPY_SOURCE, 0); // Don't need to transition upload heaps DefaultContext.numCopies++; hCommandList->CopyBufferRegion( StagingBuffer->GetResource(), 0, pResource->GetResource(), Offset, Size); hCommandList.UpdateResidency(StagingBuffer); hCommandList.UpdateResidency(pResource); DefaultContext.FlushCommands(true); }; if (ShouldDeferBufferLockOperation(RHICmdList)) { // Sync when in the render thread implementation check(IsInRHIThread() == false); RHICmdList->ImmediateFlush(EImmediateFlushType::FlushRHIThread); pfnCopyContents(); } else { check(IsInRHIThread()); pfnCopyContents(); } } LockedData.ResourceLocation.AsStandAlone(StagingBuffer, Size); Data = LockedData.ResourceLocation.GetMappedBaseAddress(); } else { // If the static buffer is being locked for writing, allocate memory for the contents to be written to. Data = Device->GetDefaultFastAllocator().Allocate<FD3D12ScopeLock>(Size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT, &LockedData.ResourceLocation); } } LockedData.LockedOffset = Offset; LockedData.LockedPitch = Size; LockedData.bLocked = true; // Return the offset pointer check(Data != nullptr); return Data; }