Implementing NRI/NRD command context

[StudenteChamp2]

I am adding real-time denoising support to my CPU(Yes CPU) path tracer. I already have Optix denoising running and it works like a charm. Now i need a solution for AMD GPUs. I chose NRD. I have a budget of 0.5 sec/ frame to perform denoising.

How to properly execute an NRI/NRD command context? Basically i have a native DX12 command context:

    struct CommandContext
    {
        IDXGIFactory4* factory;
        ID3D12Device* device;
        ID3D12CommandAllocator* commandAllocator;
        ID3D12GraphicsCommandList* commandList;
        ID3D12CommandQueue* commandQueue;
        ID3D12Fence* fence;
        HANDLE fenceEvent;
        UINT64 fenceValue;
    } m_cmdContext;

I use that native context to create an NRI/NRD command context

void NvidiaNRDDenoiser::createNRDContext(nbUint32 imageWidth, nbUint32 imageHeight)
{
    m_NRD = new NrdIntegration(1, false, "NvidiaNRDDenoiser NrdIntegration");

    //=======================================================================================================
    // INITIALIZATION - WRAP NATIVE DEVICE
    //=======================================================================================================

    // Wrap the device
    nri::DeviceCreationD3D12Desc deviceDesc = {};
    deviceDesc.d3d12Device = m_cmdContext.device;
    deviceDesc.d3d12GraphicsQueue = m_cmdContext.commandQueue;

    #if defined (_DEBUG)
    deviceDesc.enableNRIValidation = true;
    #else
    deviceDesc.enableNRIValidation = false;
    #endif
    nri::Result nriResult = nri::nriCreateDeviceFromD3D12Device(deviceDesc, m_nriDevice);

    // Get core functionality
    nriResult = nri::nriGetInterface(*m_nriDevice,
        NRI_INTERFACE(nri::CoreInterface), (nri::CoreInterface*)&m_NRI);

    nriResult = nri::nriGetInterface(*m_nriDevice,
        NRI_INTERFACE(nri::HelperInterface), (nri::HelperInterface*)&m_NRI);

    // Get appropriate "wrapper" extension (XXX - can be D3D11, D3D12 or VULKAN)
    nriResult = nri::nriGetInterface(*m_nriDevice,
        NRI_INTERFACE(nri::WrapperD3D12Interface), (nri::WrapperD3D12Interface*)&m_NRI);

    //=======================================================================================================
    // INITIALIZATION - INITIALIZE NRD
    //=======================================================================================================

    const nrd::DenoiserDesc denoiserDescs[] =
    {
        { NRD_ID(REBLUR_DIFFUSE_SPECULAR), nrd::Denoiser::REBLUR_DIFFUSE_SPECULAR },
    };

    nrd::InstanceCreationDesc instanceCreationDesc = {};
    instanceCreationDesc.denoisers = denoiserDescs;
    instanceCreationDesc.denoisersNum = _countof(denoiserDescs);

    // NRD itself is flexible and supports any kind of dynamic resolution scaling, but NRD INTEGRATION pre-
    // allocates resources with statically defined dimensions. DRS is only supported by adjusting the viewport
    // via "CommonSettings::rectSize"
    bool result = m_NRD->Initialize((uint16_t)imageWidth, (uint16_t)imageHeight, instanceCreationDesc, *m_nriDevice, m_NRI, m_NRI);
    ASSERT(result);

    //=======================================================================================================
    // INITIALIZATION or RENDER - WRAP NATIVE POINTERS
    //=======================================================================================================

    // Wrap the command buffer
    nri::CommandBufferD3D12Desc commandBufferDesc = {};
    commandBufferDesc.d3d12CommandList = m_cmdContext.commandList;

    // Not needed for NRD integration layer, but needed for NRI validation layer
    commandBufferDesc.d3d12CommandAllocator = m_cmdContext.commandAllocator;

    m_NRI.CreateCommandBufferD3D12(*m_nriDevice, commandBufferDesc, m_nriCommandBuffer);
}

Now I need to implement denoising. Execution should look like this:

startCommandRecording()
PerformDensoising()
EndCommandRecording()
WaitForGPU()

So i Need to implement startCommandRecording, EndCommandRecording, and WaitForGPU for NRI

With my native DX12 context it would look like this:

void NvidiaNRDDenoiser::startCommandRecording()
{
    HRESULT hr = m_cmdContext.commandAllocator->Reset();
    ASSERT(SUCCEEDED(hr));

    hr = m_cmdContext.commandList->Reset(m_cmdContext.commandAllocator, nullptr);
    ASSERT(SUCCEEDED(hr));
}

void NvidiaNRDDenoiser::endCommandRecording()
{
    HRESULT hr = m_cmdContext.commandList->Close();
    ASSERT(SUCCEEDED(hr));

    // Execute the command lists
    ID3D12CommandList* ppCommandLists[] = { m_cmdContext.commandList };
    m_cmdContext.commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);
}

void NvidiaNRDDenoiser::WaitForGPU()
{
    const UINT64 fence = m_cmdContext.fenceValue;
    HRESULT hr = m_cmdContext.commandQueue->Signal(m_cmdContext.fence, fence);

    // Wait until GPU finish with command queue.
    if (m_cmdContext.fence->GetCompletedValue() < fence)
    {
        hr = m_cmdContext.fence->SetEventOnCompletion(fence, m_cmdContext.fenceEvent);
        ASSERT(SUCCEEDED(hr));

        WaitForSingleObject(m_cmdContext.fenceEvent, INFINITE);
    }

    ++m_cmdContext.fenceValue;
}

How to implement these 3 for NRI?

Thanks for helping!

[dzhdanNV]

If you wrap d3d12CommandList then you have access to BeginCommandBuffer/EndCommandBuffer from NRI Core interface. You can additionally wrap d3d12commandQueue and get access to QueueSubmit from NRI Core interface and WaitForIdle from NRI Helper interface. But I don't think that it's needed. Just use your native code. NRI is needed only to wrap d3d12CommandList and invoke Denoise.

[StudenteChamp2]

Will give it a try ASAP thank you :)