CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Runtime/D3D12RHI/Private/D3D12Viewport.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

879 lines
29 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
/*=============================================================================
D3D12Viewport.cpp: D3D viewport RHI implementation.
=============================================================================*/
#include "D3D12Viewport.h"
#include "D3D12RHIPrivate.h"
#include "RenderCore.h"
#include "Engine/RendererSettings.h"
#include "HDRHelper.h"
#include "DataDrivenShaderPlatformInfo.h"
#include "RHIUtilities.h"
namespace D3D12RHI
{
/**
* RHI console variables used by viewports.
*/
namespace RHIConsoleVariables
{
#if !UE_BUILD_SHIPPING
#if LOG_VIEWPORT_EVENTS
int32 LogViewportEvents = 1;
#else
int32 LogViewportEvents = 0;
#endif
static FAutoConsoleVariableRef CVarLogViewportEvents(
TEXT("D3D12.LogViewportEvents"),
LogViewportEvents,
TEXT("Log all the viewport events."),
ECVF_RenderThreadSafe
);
#endif
};
}
using namespace D3D12RHI;
FCriticalSection FD3D12Viewport::DXGIBackBufferLock;
/**
* Creates a FD3D12Surface to represent a swap chain's back buffer.
*/
FD3D12Texture* GetSwapChainSurface(FD3D12Device* Parent, EPixelFormat PixelFormat, uint32 SizeX, uint32 SizeY, IDXGISwapChain* SwapChain, uint32 BackBufferIndex, TRefCountPtr<ID3D12Resource> BackBufferResourceOverride)
{
verify(D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN || SwapChain == nullptr);
FD3D12Adapter* Adapter = Parent->GetParentAdapter();
// Grab the back buffer
TRefCountPtr<ID3D12Resource> BackBufferResource;
if (SwapChain)
{
#if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
VERIFYD3D12RESULT_EX(SwapChain->GetBuffer(BackBufferIndex, IID_PPV_ARGS(BackBufferResource.GetInitReference())), Parent->GetDevice());
#else // #if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
return nullptr;
#endif // #if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
}
else if (BackBufferResourceOverride.IsValid())
{
BackBufferResource = BackBufferResourceOverride;
}
else
{
const D3D12_HEAP_PROPERTIES HeapProps = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT, (uint32)Parent->GetGPUIndex(), Parent->GetGPUMask().GetNative());
// Create custom back buffer texture as no swap chain is created in pixel streaming windowless mode
D3D12_RESOURCE_DESC TextureDesc;
TextureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
TextureDesc.Alignment = 0;
TextureDesc.Width = SizeX;
TextureDesc.Height = SizeY;
TextureDesc.DepthOrArraySize = 1;
TextureDesc.MipLevels = 1;
TextureDesc.Format = UE::DXGIUtilities::GetSwapChainFormat(PixelFormat);
TextureDesc.SampleDesc.Count = 1;
TextureDesc.SampleDesc.Quality = 0;
TextureDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
TextureDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
Parent->GetDevice()->CreateCommittedResource(&HeapProps, D3D12_HEAP_FLAG_NONE, &TextureDesc, D3D12_RESOURCE_STATE_PRESENT, nullptr, IID_PPV_ARGS(BackBufferResource.GetInitReference()));
}
FD3D12ResourceDesc BackBufferDesc = BackBufferResource->GetDesc();
BackBufferDesc.bBackBuffer = true;
FString Name = FString::Printf(TEXT("BackBuffer%d"), BackBufferIndex);
ETextureCreateFlags SwapchainTextureCreateFlags = ETextureCreateFlags::RenderTargetable | ETextureCreateFlags::Presentable | ETextureCreateFlags::ResolveTargetable;
#if D3D12RHI_SUPPORTS_UAV_BACKBUFFER
SwapchainTextureCreateFlags |= ETextureCreateFlags::UAV;
#endif
bool const bQuadBufferStereo = FD3D12DynamicRHI::GetD3DRHI()->IsQuadBufferStereoEnabled();
FRHITextureCreateDesc CreateDesc = bQuadBufferStereo
? FRHITextureCreateDesc::Create2DArray(*Name)
: FRHITextureCreateDesc::Create2D(*Name);
CreateDesc
.SetExtent(FIntPoint((uint32)BackBufferDesc.Width, BackBufferDesc.Height))
.SetFormat(PixelFormat)
.SetFlags(SwapchainTextureCreateFlags)
.SetInitialState(ERHIAccess::Present);
if (bQuadBufferStereo)
{
CreateDesc.SetArraySize(2);
}
FD3D12DynamicRHI* DynamicRHI = FD3D12DynamicRHI::GetD3DRHI();
FD3D12Texture* SwapChainTexture = Adapter->CreateLinkedObject<FD3D12Texture>(FRHIGPUMask::All(), [&](FD3D12Device* Device, FD3D12Texture* FirstLinkedObject)
{
FD3D12Texture* NewTexture = DynamicRHI->CreateNewD3D12Texture(CreateDesc, Device);
const D3D12_RESOURCE_STATES InitialState = D3D12_RESOURCE_STATE_COMMON;
if (Device->GetGPUIndex() == Parent->GetGPUIndex())
{
FD3D12Resource* NewResourceWrapper = new FD3D12Resource(Device, FRHIGPUMask::All(), BackBufferResource, InitialState, BackBufferDesc);
NewResourceWrapper->AddRef();
NewTexture->ResourceLocation.AsStandAlone(NewResourceWrapper);
}
else // If this is not the GPU which will hold the back buffer, create a compatible texture so that it can still render to the viewport.
{
FClearValueBinding ClearValueBinding;
SafeCreateTexture2D(Device,
Adapter,
BackBufferDesc,
nullptr, // &ClearValueBinding,
&NewTexture->ResourceLocation,
NewTexture,
PixelFormat,
TexCreate_RenderTargetable | TexCreate_ShaderResource | TexCreate_Presentable,
InitialState,
*Name);
}
// active stereoscopy initialization
if (FD3D12DynamicRHI::GetD3DRHI()->IsQuadBufferStereoEnabled())
{
// left
D3D12_RENDER_TARGET_VIEW_DESC RTVDescLeft = {};
RTVDescLeft.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
RTVDescLeft.Format = BackBufferDesc.Format;
RTVDescLeft.Texture2DArray.MipSlice = 0;
RTVDescLeft.Texture2DArray.FirstArraySlice = 0;
RTVDescLeft.Texture2DArray.ArraySize = 1;
// right
D3D12_RENDER_TARGET_VIEW_DESC RTVDescRight = {};
RTVDescRight.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY;
RTVDescRight.Format = BackBufferDesc.Format;
RTVDescRight.Texture2DArray.MipSlice = 0;
RTVDescRight.Texture2DArray.FirstArraySlice = 1;
RTVDescRight.Texture2DArray.ArraySize = 1;
NewTexture->SetNumRTVs(2);
NewTexture->EmplaceRTV(RTVDescLeft, 0, FirstLinkedObject);
NewTexture->EmplaceRTV(RTVDescRight, 1, FirstLinkedObject);
}
else
{
// create the render target view
D3D12_RENDER_TARGET_VIEW_DESC RTVDesc = {};
RTVDesc.Format = BackBufferDesc.Format;
RTVDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
RTVDesc.Texture2D.MipSlice = 0;
NewTexture->SetNumRTVs(1);
NewTexture->EmplaceRTV(RTVDesc, 0, FirstLinkedObject);
}
// create a shader resource view to allow using the backbuffer as a texture
D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc = {};
SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
SRVDesc.Format = BackBufferDesc.Format;
SRVDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
SRVDesc.Texture2D.MostDetailedMip = 0;
SRVDesc.Texture2D.MipLevels = 1;
NewTexture->EmplaceSRV(SRVDesc, FirstLinkedObject);
return NewTexture;
});
SetD3D12ResourceName(SwapChainTexture->GetResource(), *Name);
const D3D12_RESOURCE_ALLOCATION_INFO AllocationInfo = Parent->GetDevice()->GetResourceAllocationInfo(0, 1, &SwapChainTexture->GetResource()->GetDesc());
SwapChainTexture->ResourceLocation.SetSize(AllocationInfo.SizeInBytes);
FD3D12TextureStats::D3D12TextureAllocated(*SwapChainTexture);
return SwapChainTexture;
}
FD3D12Viewport::~FD3D12Viewport()
{
check(IsInRHIThread() || IsInRenderingThread());
#if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
// If the swap chain was in fullscreen mode, switch back to windowed before releasing the swap chain.
// DXGI throws an error otherwise.
if (SwapChain1)
{
SwapChain1->SetFullscreenState(0, nullptr);
}
#endif // D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
GetParentAdapter()->GetViewports().Remove(this);
FinalDestroyInternal();
}
#if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
inline DXGI_MODE_DESC SetupDXGI_MODE_DESC(uint32 SizeX, uint32 SizeY, EPixelFormat PixelFormat)
{
DXGI_MODE_DESC Ret{};
Ret.Width = SizeX;
Ret.Height = SizeY;
Ret.Format = UE::DXGIUtilities::GetSwapChainFormat(PixelFormat);
return Ret;
}
#endif
void FD3D12Viewport::InitializeBackBufferArrays()
{
#if WITH_MGPU
// This is a temporary helper to visualize what each GPU is rendering.
// Not specifying a value will cycle swap chain through all GPUs.
BackbufferMultiGPUBinding = 0;
if (GNumExplicitGPUsForRendering > 1)
{
if (FParse::Value(FCommandLine::Get(), TEXT("PresentGPU="), BackbufferMultiGPUBinding))
{
BackbufferMultiGPUBinding = FMath::Clamp<int32>(BackbufferMultiGPUBinding, INDEX_NONE, (int32)GNumExplicitGPUsForRendering - 1) ;
}
}
#endif // WITH_MGPU
for (FBackBufferData& Data : BackBuffers)
{
Data = FBackBufferData();
}
}
template<typename TResource, typename TSubresource = TResource>
bool ReleaseBackBufferResource(TRefCountPtr<TResource>& Resource, const TCHAR* ErrorName, uint32 Index)
{
const bool bValidReference = IsValidRef(Resource);
if (bValidReference)
{
// Tell the back buffer to delete immediately so that we can call resize.
if (Resource->GetRefCount() != 1)
{
UE_LOG(LogD3D12RHI, Log, TEXT("%s %d leaking with %d refs during Resize."), ErrorName, Index, Resource->GetRefCount());
}
check(Resource->GetRefCount() == 1);
for (TSubresource& SubResource : *Resource)
{
SubResource.GetResource()->DoNotDeferDelete();
}
}
Resource.SafeRelease();
check(Resource == nullptr);
return bValidReference;
}
void FD3D12Viewport::Resize(uint32 InSizeX, uint32 InSizeY, bool bInIsFullscreen, EPixelFormat PreferredPixelFormat)
{
FD3D12Adapter* Adapter = GetParentAdapter();
#if !UE_BUILD_SHIPPING
if (RHIConsoleVariables::LogViewportEvents)
{
const FString& ThreadName = FThreadManager::GetThreadName(FPlatformTLS::GetCurrentThreadId());
UE_LOG(LogD3D12RHI, Log, TEXT("Thread %s: Resize Viewport, %s"), ThreadName.GetCharArray().GetData(), *GetStateString());
}
#endif
// Log relevant state changes, makes it easier to track/reproduce crashes
const bool bLogEvent =
(bIsFullscreen != bInIsFullscreen) ||
(bIsFullscreen && (InSizeX != SizeX || InSizeY != SizeY));
FString OldState;
if (bLogEvent)
{
OldState = GetStateString();
}
// Flush the outstanding GPU work and wait for it to complete.
FlushRenderingCommands();
Adapter->BlockUntilIdle();
// Unbind any dangling references to resources.
for (uint32 GPUIndex : FRHIGPUMask::All())
{
FD3D12Device* Device = Adapter->GetDevice(GPUIndex);
Device->GetDefaultCommandContext().ClearState(FD3D12ContextCommon::EClearStateMode::TransientOnly);
}
if (IsValidRef(CustomPresent))
{
CustomPresent->OnBackBufferResize();
}
#if D3D12RHI_SUPPORTS_UAV_BACKBUFFER
bool bWaitForBackBuffersUAVDelete = false;
// Release our backbuffer reference, as required by DXGI before calling ResizeBuffers.
for (uint32 Index = 0; Index < NumBackBuffers; Index++)
{
bWaitForBackBuffersUAVDelete |= ReleaseBackBufferResource<FD3D12UnorderedAccessView_RHI, FD3D12UnorderedAccessView>(BackBuffers[Index].UAV, TEXT("BackBuffer UAV"), Index);
}
if (bWaitForBackBuffersUAVDelete)
{
// The D3D12 UAV releases don't happen immediately, but are pushed to a delete queue processed on the RHI Thread. We need to ensure these are processed before releasing the swapchain buffers
// Calling FlushRenderingCommands is enough because it calls ImmediateFlush(EImmediateFlushType::FlushRHIThreadFlushResources) / ImmediateFlush(EImmediateFlushType::FlushRHIThread) internally
FlushRenderingCommands();
}
#endif
for (uint32 Index = 0; Index < NumBackBuffers; Index++)
{
ReleaseBackBufferResource(BackBuffers[Index].Texture, TEXT("BackBuffer"), Index);
#if D3D12RHI_USE_SDR_BACKBUFFER
ReleaseBackBufferResource(BackBuffers[Index].TextureSDR, TEXT("SDR BackBuffer"), Index);
#endif
}
ClearPresentQueue();
// Flush the outstanding GPU work and wait for it to complete.
FlushRenderingCommands();
Adapter->BlockUntilIdle();
// Keep the current pixel format if one wasn't specified.
if (PreferredPixelFormat == PF_Unknown)
{
PreferredPixelFormat = PixelFormat;
}
// Reset the full screen lost because we are resizing and handling fullscreen state change and full recreation of back buffers already
// We don't want to call resize again, which could happen during ConditionalResetSwapChain otherwise
bFullscreenLost = false;
if (SizeX != InSizeX || SizeY != InSizeY || PixelFormat != PreferredPixelFormat)
{
SizeX = InSizeX;
SizeY = InSizeY;
PixelFormat = PreferredPixelFormat;
check(SizeX > 0);
check(SizeY > 0);
#if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
if (bNeedSwapChain)
{
if (bInIsFullscreen)
{
const DXGI_MODE_DESC BufferDesc = SetupDXGI_MODE_DESC(SizeX, SizeY, PixelFormat);
if (FAILED(SwapChain1->ResizeTarget(&BufferDesc)))
{
ConditionalResetSwapChain(true);
}
}
}
#endif // D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
}
if (bIsFullscreen != bInIsFullscreen)
{
bIsFullscreen = bInIsFullscreen;
bIsValid = false;
if (bNeedSwapChain)
{
// Use ConditionalResetSwapChain to call SetFullscreenState, to handle the failure case.
// Ignore the viewport's focus state; since Resize is called as the result of a user action we assume authority without waiting for Focus.
ConditionalResetSwapChain(true);
#if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
if (!bIsFullscreen)
{
// When exiting fullscreen, make sure that the window has the correct size. This is necessary in the following scenario:
// * we enter exclusive fullscreen with a resolution lower than the monitor's native resolution, or from windowed with a window size smaller than the screen
// * the application loses focus, so Slate asks us to switch to Windowed Fullscreen (see FSlateRenderer::IsViewportFullscreen)
// * InSizeX and InSizeY are given to us as the monitor resolution, so we resize the buffers to the correct resolution below (in ResizeInternal)
// * however, the target still has the smaller size, because Slate doesn't know it has to resize the window too (as far as it's concerned, it's already the right size)
// * therefore, we need to call ResizeTarget, which in windowed mode behaves like SetWindowPos.
const DXGI_MODE_DESC BufferDesc = SetupDXGI_MODE_DESC(SizeX, SizeY, PixelFormat);
SwapChain1->ResizeTarget(&BufferDesc);
}
#endif // D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
}
}
RECT WindowRect = {};
#if PLATFORM_WINDOWS
GetWindowRect(WindowHandle, &WindowRect);
#endif
FVector2D WindowTopLeft((float)WindowRect.left, (float)WindowRect.top);
FVector2D WindowBottomRight((float)WindowRect.right, (float)WindowRect.bottom);
bool bHDREnabled;
HDRGetMetaData(DisplayOutputFormat, DisplayColorGamut, bHDREnabled, WindowTopLeft, WindowBottomRight, (void*)WindowHandle);
ResizeInternal();
// Enable HDR if desired.
if (bHDREnabled)
{
EnableHDR();
}
else
{
ShutdownHDR();
}
if (bLogEvent)
{
UE_LOG(LogD3D12RHI, Log, TEXT("Swapchain Resized:\n\tBefore: %s\n\tAfter: %s"), *OldState, *GetStateString());
}
}
#if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
void* FD3D12Viewport::GetNativeSwapChain() const
{
return SwapChain1;
}
#endif // #if D3D12_VIEWPORT_EXPOSES_SWAP_CHAIN
void* FD3D12Viewport::GetNativeBackBufferTexture() const
{
return GetBackBuffer_RHIThread()->GetResource();
}
void* FD3D12Viewport::GetNativeBackBufferRT() const
{
return GetBackBuffer_RHIThread()->GetRenderTargetView(0, 0);
}
void FD3D12Viewport::SetCustomPresent(FRHICustomPresent* InCustomPresent)
{
CustomPresent = InCustomPresent;
}
FRHICustomPresent* FD3D12Viewport::GetCustomPresent() const
{
return CustomPresent;
}
/** Update the expected next present GPU back buffer index from RenderThread point of view */
void FD3D12Viewport::AdvanceExpectedBackBufferIndex_RenderThread()
{
bool bNeedsNativePresent = IsValidRef(CustomPresent) ?
CustomPresent->NeedsNativePresent() || CustomPresent->NeedsAdvanceBackbuffer() : true;
if (bNeedsNativePresent && IsPresentAllowed())
{
#if WITH_MGPU
FScopeLock Lock(&ExpectedBackBufferIndexLock);
#endif
SetBackBufferIndex_RenderThread(ExpectedBackBufferIndex_RenderThread + 1);
#if !UE_BUILD_SHIPPING
if (RHIConsoleVariables::LogViewportEvents)
{
const FString ThreadName(FThreadManager::Get().GetThreadName(FPlatformTLS::GetCurrentThreadId()));
UE_LOG(LogD3D12RHI, Log, TEXT("Thread %s: Incrementing Expected RenderThread back buffer index of viewport: %#016llx to value: %u"), ThreadName.GetCharArray().GetData(), this, ExpectedBackBufferIndex_RenderThread);
}
#endif
}
}
FString FD3D12Viewport::GetStateString()
{
return FString::Printf(
TEXT("Viewport=0x%p, Num=%d, Size=(%d,%d), PF=%d, DXGIFormat=0x%x, Fullscreen=%d, AllowTearing=%d"),
this,
NumBackBuffers, SizeX, SizeY, static_cast<int32>(PixelFormat),
static_cast<int32>(UE::DXGIUtilities::GetSwapChainFormat(PixelFormat)),
static_cast<int32>(bIsFullscreen),
static_cast<int32>(bAllowTearing)
);
}
static bool IsTransientPresentationError(HRESULT Result)
{
return Result == E_INVALIDARG ||
Result == DXGI_ERROR_INVALID_CALL;
}
/** Presents the swap chain checking the return result. */
bool FD3D12Viewport::PresentChecked(IRHICommandContext& RHICmdContext, int32 SyncInterval)
{
#if PLATFORM_WINDOWS
// We can't call Present if !bIsValid, as it waits a window message to be processed, but the main thread may not be pumping the message handler.
if (bIsValid && SwapChain1.IsValid())
{
// Check if the viewport's swap chain has been invalidated by DXGI.
BOOL bSwapChainFullscreenState;
TRefCountPtr<IDXGIOutput> SwapChainOutput;
SwapChain1->GetFullscreenState(&bSwapChainFullscreenState, SwapChainOutput.GetInitReference());
// Can't compare BOOL with bool...
if ( (!!bSwapChainFullscreenState) != bIsFullscreen )
{
bFullscreenLost = true;
bIsValid = false;
}
}
if (!bIsValid)
{
#if WITH_MGPU
// Present failed so current expected GPU index will not match anymore, so patch up expected back buffer index
// Warning: Present is skipped for this frame but could cause a black screen for the next frame as well
FScopeLock Lock(&ExpectedBackBufferIndexLock);
SetBackBufferIndex_RenderThread((ExpectedBackBufferIndex_RenderThread == 0) ? NumBackBuffers - 1 : ExpectedBackBufferIndex_RenderThread - 1);
#endif // WITH_MGPU
return false;
}
#endif
bool bNeedNativePresent = true;
if (IsValidRef(CustomPresent))
{
SCOPE_CYCLE_COUNTER(STAT_D3D12CustomPresentTime);
bNeedNativePresent = CustomPresent->Present(RHICmdContext, SyncInterval);
}
if (bNeedNativePresent)
{
static constexpr uint32 MaxPresentFailures = 5;
// Present the back buffer to the viewport window.
// In case presentation failures are transient, don't fault on the first one.
HRESULT Result = PresentInternal(SyncInterval);
if (SUCCEEDED(Result))
{
CheckedPresentFailureCounter = 0;
}
else if (!IsTransientPresentationError(Result) || ++CheckedPresentFailureCounter >= MaxPresentFailures)
{
VERIFYD3D12RESULT_LAMBDA(Result, GetParentAdapter()->GetD3DDevice(), [this]
{
return GetStateString();
});
}
else
{
UE_LOG(
LogD3D12RHI, Error,
TEXT("Swapchain presentation try %u/%u failed with HR(0x%x): %s"),
CheckedPresentFailureCounter, MaxPresentFailures,
Result, *GetStateString()
);
}
if (IsValidRef(CustomPresent))
{
CustomPresent->PostPresent();
}
#if LOG_PRESENT
const FString& ThreadName = FThreadManager::GetThreadName(FPlatformTLS::GetCurrentThreadId());
UE_LOG(LogD3D12RHI, Log, TEXT("*** PRESENT: Thread %s: Viewport %#016llx: BackBuffer %#016llx (SyncInterval %u) ***"), ThreadName.GetCharArray().GetData(), this, GetBackBuffer_RHIThread(), SyncInterval);
#endif
}
return bNeedNativePresent;
}
bool FD3D12Viewport::Present(FD3D12CommandContextBase& ContextBase, bool bLockToVsync)
{
if (!IsPresentAllowed())
{
return false;
}
check(ContextBase.GetParentAdapter() == GetParentAdapter());
for (uint32 GPUIndex : FRHIGPUMask::All())
{
FD3D12CommandContext& Context = *ContextBase.GetSingleDeviceContext(GPUIndex);
// Those are not necessarily the swap chain back buffer in case of multi-gpu
FD3D12Texture* DeviceBackBuffer = Context.RetrieveObject<FD3D12Texture, FRHITexture>(GetBackBuffer_RHIThread());
Context.FlushResourceBarriers();
// Currently, the swap chain Present() is called directly by the RHI thread.
// We need to submit the above commands and wait for the submission thread to process everything before we can continue.
Context.FlushCommands(ED3D12FlushFlags::WaitForSubmission);
}
const int32 SyncInterval = bLockToVsync ? RHIGetSyncInterval() : 0;
const bool bNativelyPresented = PresentChecked(ContextBase, SyncInterval);
if (bNativelyPresented || (CustomPresent && CustomPresent->NeedsAdvanceBackbuffer()))
{
// Increment back buffer
#if DXGI_MAX_SWAPCHAIN_INTERFACE >= 3
if (bNativelyPresented && SwapChain3)
{
SetBackBufferIndex_RHIThread(SwapChain3->GetCurrentBackBufferIndex());
}
else
#endif
{
SetBackBufferIndex_RHIThread(CurrentBackBufferIndex_RHIThread + 1);
}
#if !UE_BUILD_SHIPPING
if (RHIConsoleVariables::LogViewportEvents)
{
const FString& ThreadName = FThreadManager::GetThreadName(FPlatformTLS::GetCurrentThreadId());
UE_LOG(LogD3D12RHI, Log, TEXT("Thread %s: Incrementing RHIThread back buffer index of viewport: %#016llx to value: %u BackBuffer %#016llx"), ThreadName.GetCharArray().GetData(), this, CurrentBackBufferIndex_RHIThread, CurrentBackBuffer_RHIThread->Texture.GetReference());
}
#endif
}
return bNativelyPresented;
}
void FD3D12Viewport::WaitForFrameEventCompletion()
{
if (FrameSyncPoints.Num())
{
for (auto& SyncPoint : FrameSyncPoints)
{
if (SyncPoint)
{
SyncPoint->Wait();
}
}
FrameSyncPoints.Reset();
}
}
void FD3D12Viewport::IssueFrameEvent()
{
TArray<FD3D12Payload*> Payloads;
for (FD3D12Device* Device : ParentAdapter->GetDevices())
{
FD3D12CommandContext& Context = Device->GetDefaultCommandContext();
FD3D12SyncPointRef SyncPoint = FD3D12SyncPoint::Create(ED3D12SyncPointType::GPUAndCPU);
Context.SignalSyncPoint(SyncPoint);
Context.Finalize(Payloads);
FrameSyncPoints.Emplace(MoveTemp(SyncPoint));
}
FD3D12DynamicRHI::GetD3DRHI()->SubmitPayloads(MoveTemp(Payloads));
}
bool FD3D12Viewport::CheckHDRSupport()
{
return IsHDREnabled();
}
EPixelFormat GetDefaultBackBufferPixelFormat()
{
static const auto CVarDefaultBackBufferPixelFormat = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.DefaultBackBufferPixelFormat"));
return EDefaultBackBufferPixelFormat::Convert2PixelFormat(EDefaultBackBufferPixelFormat::FromInt(CVarDefaultBackBufferPixelFormat->GetValueOnGameThread()));
}
/*==============================================================================
* The following RHI functions must be called from the main thread.
*=============================================================================*/
FViewportRHIRef FD3D12DynamicRHI::RHICreateViewport(void* WindowHandle, uint32 SizeX, uint32 SizeY, bool bIsFullscreen, EPixelFormat PreferredPixelFormat)
{
check(IsInGameThread());
if (PreferredPixelFormat == EPixelFormat::PF_Unknown)
{
PreferredPixelFormat = GetDefaultBackBufferPixelFormat();
}
FD3D12Viewport* RenderingViewport = new FD3D12Viewport(&GetAdapter(), (HWND)WindowHandle, SizeX, SizeY, bIsFullscreen, PreferredPixelFormat);
RenderingViewport->Init();
return RenderingViewport;
}
void FD3D12DynamicRHI::RHIResizeViewport(FRHIViewport* ViewportRHI, uint32 SizeX, uint32 SizeY, bool bIsFullscreen)
{
check(IsInGameThread());
FD3D12Viewport* Viewport = FD3D12DynamicRHI::ResourceCast(ViewportRHI);
Viewport->Resize(SizeX, SizeY, bIsFullscreen, PF_Unknown);
}
void FD3D12DynamicRHI::RHIResizeViewport(FRHIViewport* ViewportRHI, uint32 SizeX, uint32 SizeY, bool bIsFullscreen, EPixelFormat PreferredPixelFormat)
{
check(IsInGameThread());
// Use a default pixel format if none was specified
if (PreferredPixelFormat == EPixelFormat::PF_Unknown)
{
static const auto CVarDefaultBackBufferPixelFormat = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.DefaultBackBufferPixelFormat"));
PreferredPixelFormat = EDefaultBackBufferPixelFormat::Convert2PixelFormat(EDefaultBackBufferPixelFormat::FromInt(CVarDefaultBackBufferPixelFormat->GetValueOnGameThread()));
}
FD3D12Viewport* Viewport = FD3D12DynamicRHI::ResourceCast(ViewportRHI);
Viewport->Resize(SizeX, SizeY, bIsFullscreen, PreferredPixelFormat);
}
void FD3D12DynamicRHI::RHITick(float DeltaTime)
{
check(IsInGameThread());
// Check if any swap chains have been invalidated.
auto& Viewports = GetAdapter().GetViewports();
for (int32 ViewportIndex = 0; ViewportIndex < Viewports.Num(); ViewportIndex++)
{
Viewports[ViewportIndex]->ConditionalResetSwapChain(false);
}
}
/*=============================================================================
* Viewport functions.
*=============================================================================*/
void FD3D12CommandContextBase::RHIBeginDrawingViewport(FRHIViewport* ViewportRHI, FRHITexture* RenderTargetRHI)
{
FD3D12Viewport* Viewport = FD3D12DynamicRHI::ResourceCast(ViewportRHI);
SCOPE_CYCLE_COUNTER(STAT_D3D12PresentTime);
// Set the viewport.
check(!ParentAdapter->GetDrawingViewport());
ParentAdapter->SetDrawingViewport(Viewport);
if (RenderTargetRHI == nullptr)
{
RenderTargetRHI = Viewport->GetBackBuffer_RHIThread();
}
#if !UE_BUILD_SHIPPING
if (RHIConsoleVariables::LogViewportEvents)
{
const FString& ThreadName = FThreadManager::GetThreadName(FPlatformTLS::GetCurrentThreadId());
UE_LOG(LogD3D12RHI, Log, TEXT("Thread %s: RHIBeginDrawingViewport (Viewport %#016llx: BackBuffer %#016llx: CmdList: %016llx)"),
ThreadName.GetCharArray().GetData(),
Viewport,
RenderTargetRHI,
GetSingleDeviceContext(0)->BaseCommandList().GetNoRefCount()
);
}
#endif
FRHICustomPresent* CustomPresent = Viewport->GetCustomPresent();
if (CustomPresent)
{
CustomPresent->BeginDrawing();
}
}
void FD3D12CommandContextBase::RHIEndDrawingViewport(FRHIViewport* ViewportRHI, bool bPresent, bool bLockToVsync)
{
FD3D12Viewport* Viewport = FD3D12DynamicRHI::ResourceCast(ViewportRHI);
#if !UE_BUILD_SHIPPING
if (RHIConsoleVariables::LogViewportEvents)
{
const FString& ThreadName = FThreadManager::GetThreadName(FPlatformTLS::GetCurrentThreadId());
UE_LOG(LogD3D12RHI, Log, TEXT("Thread %s: RHIEndDrawingViewport (Viewport %#016llx: BackBuffer %#016llx: CmdList: %016llx)"),
ThreadName.GetCharArray().GetData(),
Viewport,
Viewport->GetBackBuffer_RHIThread(),
GetSingleDeviceContext(0)->BaseCommandList().GetNoRefCount()
);
}
#endif
SCOPE_CYCLE_COUNTER(STAT_D3D12PresentTime);
check(ParentAdapter->GetDrawingViewport() == Viewport);
ParentAdapter->SetDrawingViewport(nullptr);
bool bNativelyPresented = true;
if (bPresent)
{
bNativelyPresented = Viewport->Present(*this, bLockToVsync);
}
// Multi-GPU support : here each GPU wait's for it's own frame completion.
if (bNativelyPresented)
{
static const auto CFinishFrameVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.FinishCurrentFrame"));
if (!CFinishFrameVar->GetValueOnRenderThread())
{
// Wait for the GPU to finish rendering the previous frame before finishing this frame.
Viewport->WaitForFrameEventCompletion();
Viewport->IssueFrameEvent();
}
else
{
// Finish current frame immediately to reduce latency
Viewport->IssueFrameEvent();
Viewport->WaitForFrameEventCompletion();
}
}
// If the input latency timer has been triggered, block until the GPU is completely
// finished displaying this frame and calculate the delta time.
if (GInputLatencyTimer.RenderThreadTrigger)
{
Viewport->WaitForFrameEventCompletion();
uint32 EndTime = FPlatformTime::Cycles();
GInputLatencyTimer.DeltaTime = EndTime - GInputLatencyTimer.StartTime;
GInputLatencyTimer.RenderThreadTrigger = false;
}
}
void FD3D12DynamicRHI::RHIAdvanceFrameForGetViewportBackBuffer(FRHIViewport* ViewportRHI)
{
check(IsInRenderingThread());
#if !UE_BUILD_SHIPPING
if (RHIConsoleVariables::LogViewportEvents)
{
const FString& ThreadName = FThreadManager::GetThreadName(FPlatformTLS::GetCurrentThreadId());
UE_LOG(LogD3D12RHI, Log, TEXT("Thread %s: RHIAdvanceFrameForGetViewportBackBuffer"), ThreadName.GetCharArray().GetData());
}
#endif
// Don't need to do anything on the back because dummy back buffer texture is used to make sure the correct back
// buffer index is always used on RHI thread
// But advance the expected present GPU index so the next call to RHIGetViewportNextPresentGPUIndex returns the expected GPU index for the next present.
// Warning: when present fails or is not called on the RHIThread then this might not be in sync but RHI thread will fix up the correct state
// Present doesn't happen so shouldn't matter that the index was wrong then
FD3D12Viewport* Viewport = FD3D12DynamicRHI::ResourceCast(ViewportRHI);
Viewport->AdvanceExpectedBackBufferIndex_RenderThread();
}
uint32 FD3D12DynamicRHI::RHIGetViewportNextPresentGPUIndex(FRHIViewport* ViewportRHI)
{
check(IsInRenderingThread());
#if WITH_MGPU
const FD3D12Viewport* Viewport = FD3D12DynamicRHI::ResourceCast(ViewportRHI);
if (Viewport)
{
return Viewport->GetNextPresentGPUIndex();
}
#endif // WITH_MGPU
return 0;
}
FTextureRHIRef FD3D12DynamicRHI::RHIGetViewportBackBuffer(FRHIViewport* ViewportRHI)
{
check(IsInRenderingThread());
const FD3D12Viewport* const Viewport = FD3D12DynamicRHI::ResourceCast(ViewportRHI);
FRHITexture* SelectedBackBuffer = Viewport->GetBackBuffer_RenderThread();
#if !UE_BUILD_SHIPPING
if (RHIConsoleVariables::LogViewportEvents)
{
const FString& ThreadName = FThreadManager::GetThreadName(FPlatformTLS::GetCurrentThreadId());
UE_LOG(LogD3D12RHI, Log, TEXT("Thread %s: RHIGetViewportBackBuffer (Viewport %#016llx: BackBuffer %#016llx)"), ThreadName.GetCharArray().GetData(), Viewport, SelectedBackBuffer);
}
#endif
return SelectedBackBuffer;
}
Reference in New Issue View Git Blame Copy Permalink