FidelityFX Super Resolution 3.0.3 (FSR3) – Interpolation

#include <FidelityFX/host/ffx_fsr3.h>

for (auto i = 0; i < FSR3_BACKEND_COUNT; i++)
{
    const size_t scratchBufferSize = ffxGetScratchMemorySize(FFX_FSR3_CONTEXT_COUNT);
    void*        scratchBuffer     = malloc(scratchBufferSize);
    memset(scratchBuffer, 0, scratchBufferSize);
    ffxGetInterface(&ffxFsr3Backends_[i], GetDevice (), scratchBuffer, scratchBufferSize, FFX_FSR3_CONTEXT_COUNT);
}

m_InitializationParameters.backendInterfaceSharedResources    = ffxFsr3Backends_[FSR3_BACKEND_SHARED_RESOURCES];
m_InitializationParameters.backendInterfaceUpscaling          = ffxFsr3Backends_[FSR3_BACKEND_UPSCALING];
m_InitializationParameters.backendInterfaceFrameInterpolation = ffxFsr3Backends_[FSR3_BACKEND_FRAME_INTERPOLATION];

// FSR upscaler output resolution, as this may be different than display resolution in some titles
m_InitializationParameters.upscaleOutputSize.width      = resInfo.DisplayWidth;
m_InitializationParameters.upscaleOutputSize.height     = resInfo.DisplayHeight;

// set this flag if interpolation should run on an async queue
m_InitializationParameters.flags |= FFX_FSR3_ENABLE_ASYNC_WORKLOAD_SUPPORT;

// fill in the format of the backbuffer that will be used for interpolation
m_InitializationParameters.backBufferFormat = GetFfxSurfaceFormat(GetSwapChainFormat());

FfxErrorCode  errorCode = ffxFsr3ContextCreate(&m_FSR3Context, &m_InitializationParameters);

FfxSwapchain        ffxSwapChain = ffxGetSwapchainDX12(pSwapchain->GetImpl()->DX12SwapChain());
ID3D12CommandQueue* pCmdQueue    = GetDevice ()->GetImpl ()->DX12CmdQueue(CommandQueue::Graphics);
FfxCommandQueue     ffxGameQueue = ffxGetCommandQueueDX12(pCmdQueue);

// unset the swapchain in the engine
GetFramework ()->GetSwapChain ()->GetImpl ()->SetDXGISwapChain(nullptr);

// this function takes a FfxCommandQueue and a FfxSwapchain and
// will replace the swapchain inside the ffxSwapchain with the frame interpolation swapchain
ffxReplaceSwapchainForFrameinterpolation(ffxGameQueue, ffxSwapChain);

// alternatively we provide functions to create a swap chain similar to the Windows API
// ffxCreateFrameinterpolationSwapchainDX12(const DXGI_SWAP_CHAIN_DESC* desc,
//                                          ID3D12CommandQueue* queue,
//                                          IDXGIFactory* dxgiFactory,
//                                          FfxSwapchain& outGameSwapChain);
//
// ffxCreateFrameinterpolationSwapchainForHwndDX12(HWND hWnd,
//                                                 const DXGI_SWAP_CHAIN_DESC1* desc1,
//                                                 const DXGI_SWAP_CHAIN_FULLSCREEN_DESC* fullscreenDesc,
//                                                 ID3D12CommandQueue* queue,
//                                                 IDXGIFactory* dxgiFactory,
//                                                 FfxSwapchain& outGameSwapChain);

// Set frameinterpolation swapchain to engine
IDXGISwapChain4* frameinterpolationSwapchain = ffxGetDX12SwapchainPtr(ffxSwapChain);
GetFramework ()->GetSwapChain ()->GetImpl ()->SetDXGISwapChain(frameinterpolationSwapchain);

// In case the app is handling Alt-Enter manually we need to update the window association after creating a different swapchain
IDXGIFactory7* factory = nullptr;
if (SUCCEEDED(frameinterpolationSwapchain->GetParent(IID_PPV_ARGS(&factory))))
{
    factory->MakeWindowAssociation(GetFramework ()->GetInternal()->GetHWND(), DXGI_MWA_NO_WINDOW_CHANGES);
    factory->Release();
}

// call SetHDRMetaData and SetColorSpace1 if needed
GetFramework ()->GetSwapChain ()->SetHDRMetadataAndColorspace ();

FfxFsr3DispatchUpscaleDescription  dispatchParameters = {};

// fill out dispatchParameters identical to FSR2

FfxErrorCode  errorCode = ffxFsr3ContextDispatchUpscale(&m_FSR2Context, &dispatchParameters);
FFX_ASSERT(errorCode == FFX_OK );

FfxSwapchain         ffxSwapChain = ffxGetSwapchainDX12(pSwapchain->DX12SwapChain());
FfxResourceDescription  hudLessDesc = GetFfxResourceDescription(m_pHudLessTexture[m_curUiTextureIndex]->DX12Resource(), (FfxResourceUsage )0);
FfxResource  hudLessResource = ffxGetResourceDX12 (m_pHudLessTexture[m_curUiTextureIndex]->DX12Resource(), hudLessDesc, L"FSR3_HudLessBackbuffer", FFX_RESOURCE_STATE_PIXEL_COMPUTE_READ );

m_FrameGenerationConfig.swapChain               = ffxSwapChain;                                // FfxSwapchain containing the proxy swapchain
m_FrameGenerationConfig.frameGenerationEnabled  = m_FrameInterpolation;                        // enable or disable generation of interpolated frames
m_FrameGenerationConfig.allowAsyncWorkloads     = m_AllowAsyncCompute && m_EnableAsyncCompute; // should async compute be used this frame?
m_FrameGenerationConfig.frameGenerationCallback = ffxFsr3DispatchFrameGeneration;              // optional: function to record frame generation commandlist. This may be a nullptr.

// max one of the following 2 options should be used at a time:
m_FrameGenerationConfig.presentCallback         = UiCompositionCallback;                       // optional: UI composition callback. This may be a nullptr.
m_FrameGenerationConfig.HUDLessColor            = hudLessResource;                             // optional: may be FfxResource({})

// set optional flags for development purposes:
m_FrameGenerationConfig.flags                  = 0;
m_FrameGenerationConfig.flags |= FFX_FSR3_FRAME_GENERATION_FLAG_DRAW_DEBUG_TEAR_LINES;        // draw debug lines to better show if tearing is enabled
m_FrameGenerationConfig.flags |= FFX_FSR3_FRAME_GENERATION_FLAG_DRAW_DEBUG_VIEW;              // display internal surfaces for debugging visual artifacts

ffxFsr3ConfigureFrameGeneration(&m_FSR3Context, &m_FrameGenerationConfig);

FfxErrorCode  FSR3RenderModule::UiCompositionCallback(const FfxPresentCallbackDescription * params)
{
    ID3D12GraphicsCommandList2* pDxCmdList  = reinterpret_cast<ID3D12GraphicsCommandList2*>(params->commandList );
    CommandListInternal         cmdList     = {L"UI_CommandList", pDxCmdList, nullptr, CommandQueue::Graphics};

    ID3D12Resource*             pRtResource = reinterpret_cast<ID3D12Resource*>(params->outputSwapChainBuffer .resource );
    pRtResource->AddRef();
    GPUResourceInternal rtResource(pRtResource, L"UI_RenderTarget", CauldronGetStateFfx(params->outputSwapChainBuffer .state ), false);

    ID3D12Resource*             pBbResource = reinterpret_cast<ID3D12Resource*>(params->currentBackBuffer .resource );
    pBbResource->AddRef();
    GPUResourceInternal bbResource(pBbResource, L"BackBuffer", CauldronGetStateFfx(params->currentBackBuffer .state ), false);

    // Use pDxCmdList to copy pBbResource and render UI into the outputSwapChainBuffer.
    // The backbuffer is provided as SRV so postprocessing (e.g. adding a blur effect behind the UI) can easily be applied
}

FfxResource  uiColor = ffxGetResource(m_pUiTexture[m_curUiTextureIndex]->GetResource(), L"FSR3_UiTexture", FFX_RESOURCE_STATE_PIXEL_COMPUTE_READ );
ffxRegisterFrameinterpolationUiResourceDX12(ffxSwapChain, uiColor);

// ensure all async workloads related to presents have finished and all surfaces can be released
cauldron::SwapChain * pSwapchain   = GetFramework ()->GetSwapChain ();
FfxSwapchain         ffxSwapChain = ffxGetSwapchainDX12(pSwapchain->GetImpl ()->DX12SwapChain());
ffxWaitForPresents(ffxSwapChain);

m_FrameGenerationConfig.frameGenerationEnabled = false;
m_FrameGenerationConfig.swapChain              = ffxSwapChain;
m_FrameGenerationConfig.presentCallback        = nullptr;
m_FrameGenerationConfig.HUDLessColor           = FfxResource ({});
ffxFsr3ConfigureFrameGeneration(&m_FSR3Context, &m_FrameGenerationConfig);

ffxRegisterFrameinterpolationUiResource(ffxSwapChain, FfxResource ({}));

ffxFsr3ContextDestroy(&m_FSR3Context);

// free memory of the backendInterfaces
free(m_InitializationParameters.backendInterfaceSharedResources.scratchBuffer);
free(m_InitializationParameters.backendInterfaceUpscaling.scratchBuffer);
free(m_InitializationParameters.backendInterfaceFrameInterpolation.scratchBuffer);