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;
}
