gpuopen-librariesandsdks / fidelityfx-sdk Goto Github PK

Like "FidelityFX SDK.sln" does.

Bug. I haven't checked FSR code exhaustively (e.g. upscaling) but I do know this applies to frame interpolation at the minimum.

Passing the flag FFX_XXXXX_ENABLE_TEXTURE1D_USAGE to ffxFsr3ContextCreate or ffxFrameInterpolationContextCreate results in TEXTURE1D creation for resources with a height of 1. FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNTERS ("FI_Counters") happens to be one of said resources.

Texture creation is fine by itself. However, backend HLSL shaders hardcode their SRV types. A Texture2D is always used for FFX_FRAMEINTERPOLATION_BIND_SRV_COUNTERS which is bound to the FFX_FRAMEINTERPOLATION_RESOURCE_IDENTIFIER_COUNTERS Texture1D resource from above. These aren't compatible.

From what I can tell reads/writes to the counter variables end up being 0, always, and interpolation stops working. You'll only see duplicated frames.

Here is the FFX_FSR1_RCAS_DENOISE flag.

Miss ?

Hello,

I would like to generate VS solution for the FSR sample, then run it.
When I try to generate solution using Cmake it fails with a copyCommand error:

Thanks for helping!

https://github.com/metarutaiga/FidelityFX-SDK-DX11

Here is the FidelityFX-SDK for DX11
It had FSR3 Upscaler and Frame Interpolation. (NO DXGISwapchain)

Task

• Support for Shader Model 5.0
• Patch GroupMemoryBarrier to GroupMemoryBarrierWithGroupSync
• 16bit RCAS for FSR2
• 16bit RCAS for FSR3 Upscaler
• 16bit SPD for FSR3 Frame Interpolation
• 16bit SPD for FSR3 Optical Flow

And I want to know why the FSR2 / FSR3 haven't any fp16 optimized shaders?

I was integrating https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/tree/release-FSR3-3.0.3/sdk, by:

FetchContent_Declare(
    GIT_REPOSITORY ... .git
    SOURCE_SUBDIR sdk

Hopefully, this does not process content above /sdk.

1 of my engine's RHI DX12 projects contains a pixlib.lib right below ffx_backend_dx12_x64.lib in Additional Dependencies. Build of this project will fail due to missing that lib.

Thanks.

For example, BuildFSRSolutionNative.bat, launch any *VK configuration in Visual Studio.

Both the 3D rendering and the UI are gray-ish.

I'm on a mobile 4090.

Thanks.

Will generate FidelityFX SDK.sln.
Launch FFX_FSR project.

[Result]
Dialog saying "No framework instance to query".

 	KernelBase.dll!00007ff864e4567c()	Unknown
 	vcruntime140d.dll!00007ff8121db760()	Unknown
>	ffx_backend_cauldron_x64DX12D.dll!cauldron::CauldronCritical(const wchar_t * format, ...) Line 91	C++
 	ffx_backend_cauldron_x64DX12D.dll!cauldron::CauldronAssert(cauldron::AssertLevel severity, bool condition, const wchar_t * format, ...) Line 222	C++
 	ffx_backend_cauldron_x64DX12D.dll!cauldron::GetDevice() Line 2013	C++
 	ffx_backend_cauldron_x64DX12D.dll!CreateBackendContextCauldron(FfxInterface * backendInterface, unsigned int * effectContextId) Line 532	C++
 	ffx_fsr2_x64.dll!fsr2Create(FfxFsr2Context_Private * context, const FfxFsr2ContextDescription * contextDescription) Line 497	C++
 	ffx_fsr2_x64.dll!ffxFsr2ContextCreate(FfxFsr2Context * context, const FfxFsr2ContextDescription * contextDescription) Line 1109	C++
 	FFX_FSR_DX12D.exe!FSR2RenderModule::UpdateFSR2Context(bool enabled) Line 290	C++
 	FFX_FSR_DX12D.exe!FSR2RenderModule::EnableModule(bool enabled) Line 127	C++
 	FFX_FSR_DX12D.exe!FSRSample::SwitchUpscaler(FSRSample::UpscaleMethod newUpscaler) Line 204	C++
 	FFX_FSR_DX12D.exe!FSRSample::DoSampleInit() Line 149	C++
 	FFX_FSR_DX12D.exe!cauldron::Framework::Init() Line 362	C++
 	FFX_FSR_DX12D.exe!cauldron::RunFramework(cauldron::Framework * pFramework) Line 2090	C++
 	FFX_FSR_DX12D.exe!wWinMain(HINSTANCE__ * hInstance, HINSTANCE__ * hPrevInstance, wchar_t * lpCmdLine, int nCmdShow) Line 70	C++
 	[External Code]

Hello,
pipelineName in scheduleDispatch is not used.

The worst part is that it's a std::string so it allocates memory at runtime even when passing a static name.
I haven't checked if the whole string construction is optimized out in release.

Same problem is not present in other component like FrameInterpolator or Fsr3 upscaler.

If neither FFX_GLSL or FFX_HLSL is defined SpdReduceQuad fail silently.
This is can lead to really hard to debug issue if you try to add supports for another compiler.

I'm observing a weird behavior where if I provide payload, keys do not get sorted. Is it possible to easily tweak parallel sort to sort both keys and payload?

Hi team, I just wonder if we can do code contributions to FSR3 since now it's an open-soureced project?

Competitor FG can be combined with FSR 2 upsampling or game's own TAA. With FSR 3, this is not possible. FSR 2/3 upsampling or even native AA still have issues with especially complex Nanite geometry as seen in e.g. Immortals of Aveum or The Talos Principle 2 and Unreal Engine's TSR can provide better results. So it's a bit sad that you are forced to use FSR upsampling/AA when you just want to use its FG part.

(On a side note, FSR 2/3 upsampling/AA really should be improved for complex Nanite geometry.)

D:\Code\FidelityFX-SDK-main-fsr1\FidelityFX-SDK-main>UpdateMedia.bat
Default bundle SHA-256: 48f8b87302950208cfea7619a03235a448b913d4e4836422714696192ae1511f
SDK root: D:\Code\FidelityFX-SDK-main-fsr1\FidelityFX-SDK-main\

AMD FidelityFX Media Delivery System
Failed to get bundle information from server (SHA256: 48f8b87302950208cfea7619a03235a448b913d4e4836422714696192ae1511f)

OR

D:\Code\FidelityFX-SDK-main-fsr1\FidelityFX-SDK-main\sdk\tools\media_delivery>MediaDelivery.exe -latest
AMD FidelityFX Media Delivery System
Failed to get latest media bundle information from server

Since FSR2 is now part of the SDK, this seems like the place for such feature requests I guess.

Would be great if future updates to FSR2 Upscaling would add:

• Ultra Quality preset - probably most useful for 1080p, also already a part of FSR1 as 77% scaling, and XeSS has it, so why not?

• Native res AA option (or as it's called in the community, FSRAA) - decouple the AA part from upscaling and give it as an option, akin to DLAA

Probably a long shot, but is there any new info regarding a switch to a signed DLL only approach? As it currently stands, almost all devs build it statically into the exe which makes it impossible for users to manually update FSR2 versions. Both DLSS and XeSS use the signed DLL approach and make it easy for users to update (especially if devs are done supporting a game), so would be great if that were a possibility in the future too.

https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/release-FSR3-3.0.3/sdk/src/components/fsr3/CMakeLists.txt#L34

	file(GLOB PUBLIC_SOURCES
		"${FFX_HOST_PATH}/fsr3/*.h"
		"${FFX_HOST_PATH}/fsr3/*.cpp")
	list(APPEND PUBLIC_SOURCES ${FFX_PUBLIC_SOURCES})

The only fsr3-related (not fsr3upscaler) file in sdk\include\FidelityFX\host is ffx_fsr3.h, which could need to be included in public_source.

https://gpuopen.com/manuals/fidelityfx_sdk/fidelityfx_sdk-page_techniques_super-resolution-temporal/
"Copy the header files for the API backend of your choice, e.g. for DirectX 12 you would copy dx12/ffx_fsr2_dx12.h and dx12/shaders/ffx_fsr2_shaders_dx12.h."

• ffx_fsr2_dx12.h should be ffx_dx12.h?

These are the old (2.2.1/before FidelityFX SDK) file structure.

In ffx_fsr2_upsample.h, looks like this is a path not compiled by the SDK (I don't see anything enabling FFX_FSR2_OPTION_UPSAMPLE_SAMPLERS_USE_DATA_HALF anyway) but, looks like these files are currently missing from the SDK's repository.

Unless I'm missing something here ...

Hey!

I'm observing a pretty low accupancy on my 4090 when running parallel sort

it fluctuates around 51-55%. is it expected? what params should I tune to maximize? is it even possible? I don't see the algorithm hitting any common occupancy limiters: shared memory, register pressure etc is all good

https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/main/docs/getting-started/building-samples.md

• BuildAllCauldronEffectsSolution.bat or the .BAT file for a single effect, such as BuildHybridReflectionsSolution.bat.

CMake Error at framework/cauldron/framework/CMakeLists.txt:30 (message):
  Unable to find vulkan_core.h.
Call Stack (most recent call first):
  framework/cauldron/framework/CMakeLists.txt:76 (ParseVulkanHeader)
  framework/cauldron/framework/CMakeLists.txt:104 (CheckVulkanSDKVersion)


CMake Error at framework/cauldron/framework/CMakeLists.txt:83 (message):
  Vulkan SDK 1.3 or above is required.
Call Stack (most recent call first):
  framework/cauldron/framework/CMakeLists.txt:104 (CheckVulkanSDKVersion)

While:

C:\>vkvia
VIA_INFO:    SDK Found! - Will attempt to run tests
VIA_INFO:       Attempting to run vkcube.exe in D:\VulkanSDK\1.3.250.1\Bin
VIA_INFO:           Command-line: vkcube.exe --c 100 --suppress_popups
VIA_INFO:           Command-line: vkcube.exe --c 100 --suppress_popups --validate
SUCCESS: Vulkan analysis completed properly using Vulkan 1.3

Thanks.

When both enabled with FSR2.2.1 plugin, it would show error like below

If only enabled with FSR3.0.3 plugin, it looks good. Currently on UE5.2.1 version

I am aware that FSR3 comes with latency reduction technique(s) but its latency is still suboptimal.

Someone made this opensource library called LatencyFlex, that is game agnostic and that is an alternative to Nvidia Reflex
and it significantly reduce latency.

Therefore, I am asking you to explore and empirically test wether LatencyFlex provide better latency reduction than the current FSR3 built in reduction, and wether it can be combined with your current built in technique.
If either one of those scenarios are true, then you should integrate it, and by doing so, making gaming a better place!
https://github.com/ishitatsuyuki/LatencyFleX
https://blog.ishitatsuy.uk/post/latencyflex/

Whether C17 is supported?
I want to use the SDK for the C project

It will be nice if number of sorting keys could be provided without CPU/GPU sync, for example by supplying 4 bytes long refrerence to a GPU buffer that should contain the target number of keys. Currently it is impossible to sort arbitrary number of GPU-generated objects without making a CPU sync.

Hi Team, any plan for UE4 plugin support like 4.27, and any schedule for native Vulkan support?

Can Support Linux?
only support Windows we Games cannot use FSR 3.0

I am looking to mod FSR3 into a game by following a pre-existing DLSS -> FSR2 mod, and I am wondering if the FSR3 API is the same as that of FSR2. As in, would it be a simple swap of header files (using FSR3 files instead of FSR2) and then recompiling, or are there new parameters now?

I'm trying to use parallel sort in my custom DX12 renderer and in sample there is a file, which seems weird because from what I can see it is not being used in the sample and I can't find functions from it in the whole repo (like when searching for 'FFX_ParallelSort_Scatter_uint').

So is it correct to assume that this file is a copy-paste leftover from early versions and currently only C++ side code is needed in order to launch a kernel?

Looks like the upscaler is simply FSR 2:
https://gpuopen.com/manuals/fidelityfx_sdk/fidelityfx_sdk-page_techniques_super-resolution-upscaler/

FSR 3 has the additional frameinterpolation:
https://gpuopen.com/manuals/fidelityfx_sdk/fidelityfx_sdk-page_techniques_super-resolution-interpolation/

https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/release-FSR3-3.0.3/sdk/src/components/fsr3upscaler/ffx_fsr3upscaler.cpp#L998
While this upscaler code mention "need to clear here since we need the content of this surface for frameinterpolation".

Thanks.

I need to sort 64 bit UINTs and I wonder if I can patch current implementation in a reasonable time? Could you give me some guidance?

What is the status of Vulkan support for FSR3?

What has been done and what is left?
Is there a public dev branch somewhere with the current Vulkan dev builds?

Could we get a potential ETA?

As we know, Cauldron's generated project is either DX12 or Vulkan, which is selectable as Visual Studio build configuration.

An engine's binary might contains various APIs which is selectable via launch command line flag at runtime.

Thanks.

This is half bug, half feature request.

When a BGRA8 swap chain desc is passed to ffxCreateFrameinterpolationSwapchainDX12, GetFfxSurfaceFormat or ffxGetSurfaceFormatDX12 are called at some point and trip an assertion due to the lack of backend support. Under certain circumstances the code crashes. I didn't see this stated in the documentation anywhere. I could be blind though.

I implemented a workaround by adding relevant formats to the FfxSurfaceFormat enum and adding more switch cases.

In this code == instead of & is used to check if the FFX_RESOURCE_USAGE_DEPTHTARGET bit is set.
I believe this should be changed.

Might be beneficial to remove this line, to reduce dependency on gpu headers

The FFX_HALF is written in FSR1 RCAS

BUT that is not written in FSR2 RCAS

Looks like if I want to include FidelityFX with CMake, it is possible to use add_subdirectory.

source_dir should be FidelityFX-SDK\sdk.

Looks like 2 choices for binary_dir:

• FidelityFX-SDK\sdk\build
  • PROJECT_BINARY_DIR points to my /build/windows, i.e., the BINARY variable points to /build, which is why the question comes into my mind.
• FidelityFX-SDK\sdk\bin
  • Without the above \build, I would of coz choose this \bin.

Thanks.

The macro #define EAN(pass) pass, L#pass found here

doesn't expand correctly in CLANG or GCC.

Can we please change it to #define EAN(pass) pass, L###pass? This should work on all platforms.

Thanks.

Thank you for open sourcing your frame interp solution and allowing us to learn from it! Massive engineering effort and huge success from what we can see so far. :)

I'd love to learn a bit more about the design decisions behind it, if you (the deveolopers behind it) are at liberty to talk about it.

When designing FSR3, I'm sure you also considered doing something similar to Asynchronous Reprojection as it's done in VR devices, but you opted for frame interpolation between two fully rendered frames instead. What were the design considerations and tradeoffs that lead to this decision?
From what I understand, for Async Reprojection / Spacewarp as it's done on VR headsets, you need the information of how far the camera travels in the virtual world in between two frames. Is this something that the game can expose to FSR? Would there be a latency upside?
Would there be large issues in games where you have fast camera movements and the perspective correction couldn't keep up?

Long-Term, are you exploring reprojection-based interpolation for a desktop usecase or is that idea off the table?

Thanks, and props on the release!

I find this formula to calculate the luminance of scRGB (R16G16B16A16F HDR) colors a bit confusing.
In DirectX 11 and 12, scRGB swapchain buffers have a luminance of 80 nits for a rgb value of 1 1 1, and a luminance of 0 for a value of 0 0 0. The display min and peak brightness don't come into play (if not within the game tonemapping).
Is this code maybe referring to the FreeSync version of scRGB HDR?

Code:
https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/a0632abf1350bb64c098573d84c42f053f053a6e/sdk/include/FidelityFX/gpu/frameinterpolation/ffx_frameinterpolation_common.h#L45C14-L45C30

Edit: I think I now understand that this code is meant to normalize R16G16B16A16F buffer values into a 0-1 range, though in doing so, it clips any negative value, which are the ones that define colors out of sRGB/Rec.709 (e.g. go into Rec.2020 and beyond), so FSR FG seems to cut out HDR colors out of games, if it goes through this path.

While working on finding ways to improve the quality of FSR upscaling techniques, I found it quite inconvenient to use the mouse to swap between upscaling modes as I would have to take my eyes off the part of the image I was focusing on to make comparisons.

I think having key bindings for swapping between upscaling modes would be a small but much needed feature to help contributors in improving FSR.

AMD YES!!!

Hallo

It seems, that the included sample (.\FidelityFX-SDK-FSR3-v3.0.3\bin\FFX_FSR_NATIVE_DX12.exe) inside of https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/releases/download/fsr3-v3.0.3/FidelityFX-SDK-FSR3-v3.0.3.zip is missing some textures and fails to start.

Cauldron.log

[20:46:02][Trace]   Initializing configuration
[20:46:02][Trace]   Parsing cauldron config file.
[20:46:02][Trace]   Parsing config file for SkyDomeRenderModule
[20:46:02][Trace]   Parsing config file for RasterShadowRenderModule
[20:46:02][Trace]   Parsing config file for GBufferRenderModule
[20:46:02][Trace]   Could not find config file for LightingRenderModule, skipping...
[20:46:02][Trace]   Could not find config file for AnimatedTexturesRenderModule, skipping...
[20:46:02][Trace]   Parsing config file for TranslucencyRenderModule
[20:46:02][Trace]   Could not find config file for GPUParticleRenderModule, skipping...
[20:46:02][Trace]   Parsing config file for TAARenderModule
[20:46:02][Trace]   Could not find config file for FSR2RenderModule, skipping...
[20:46:02][Trace]   Could not find config file for FSR3UpscaleRenderModule, skipping...
[20:46:02][Trace]   Could not find config file for FSR3RenderModule, skipping...
[20:46:02][Trace]   Could not find config file for UpscaleRenderModule, skipping...
[20:46:02][Trace]   Could not find config file for ToneMappingRenderModule, skipping...
[20:46:02][Trace]   Could not find config file for FSR1RenderModule, skipping...
[20:46:02][Trace]   Parsing command line parameters.
[20:46:02][Trace]   Initializing framework components.
[20:46:02][Trace]   Initializing graphics device.
[20:46:02][Trace]   Initializing graphics resource view allocator.
[20:46:02][Trace]   Initializing raster view allocator.
[20:46:02][Trace]   Initializing graphics dynamic resource pool.
[20:46:02][Trace]   Initializing graphics shadow map resource pool.
[20:46:02][Trace]   Initializing graphics swap chain.
[20:46:02][Warning] HDR modes not supported, defaulting to LDR
[20:46:02][Trace]   Initializing requested render resources.
[20:46:02][Trace]   Initializing profiler.
[20:46:02][Trace]   Initializing graphics upload heap.
[20:46:02][Trace]   Initializing graphics constant buffer pool.
[20:46:02][Trace]   Initializing shader compiler.
[20:46:02][Trace]   Initializing input manager.
[20:46:02][Trace]   Initializing UI manager.
[20:46:02][Trace]   Initializing scene
[20:46:02][Trace]   Initializing content manager.
[20:46:02][Trace]   Creating RenderModules
[20:46:02][Trace]   Initializing RenderModules
[20:46:02][Error]   Could not find texture file ..\media\IBL\mud_road_puresky_Diffuse.dds
[20:46:02][Fatal]   SkyDomeRenderModule: Required texture could not be loaded. Terminating sample.
[20:46:04][Trace]   Initializing sample.
[20:46:04][Error]   Could not find texture file ..\media\IBL\mud_road_puresky_Specular.dds
[20:46:04][Error]   Could not find texture file ..\media\Textures\BRDF\BrdfLut.dds
[20:46:04][Error]   Could not find texture file ..\media\IBL\mud_road_puresky_Diffuse.dds
[20:46:04][Error]   Could not find texture file ..\media\Textures\Particles\atlas.dds

For example, for FSR3Upscaler.

Maybe:

    typedef enum Fsr3BackendTypes : uint32_t
    {
        FSR3_BACKEND_SHARED_RESOURCES,
        FSR3_BACKEND_UPSCALING,
        FSR3_BACKEND_FRAME_INTERPOLATION,
        FSR3_BACKEND_COUNT
    } Fsr3BackendTypes;

            int effectCounts[] = {1, 1, 2};
            for (auto i = 0; i < FSR3_BACKEND_COUNT; i++)

So, 1 for FSR3Upscaler.

Thanks.

Feature request.

Code asserts that currentBackBuffer and currentBackBuffer_HUDLess inputs are identical formats. I believe this isn't necessary as long as the two formats are within the same type group. None of the upscaling/fi shader code appears to rely on this assumption. (Possibly leftover code from raster -> compute refactoring?)

There's one caveat: the previous interpolation source texture is created using the back buffer's format and down the line CopyTextureRegion(prevInterpSource, inputHUDLess) gets called. Different types aren't guaranteed to be copyable.

Game motion vectors exceeding [-1.0, 1.0] in the ReconstructAndDilate pass will likely cause infinite loops in subsequent render passes. computeOpticalFlowVectorField is one example.

A workaround is to clamp fDilatedMotionVector between -1.0 and 1.0.

I understand this bug is a violation of the input constraints per the documentation but it's a fairly important distinction from the previous version. Nobody enjoys debugging TDRs. FSR 2 seems to chug along and produce invalid outputs instead.

What are the cmake flags do I use to build this and examples on linux + vulkan?

My environment is Windows + DX12

I try renderdoc, but,

I try pix, but, "Failed to load the PBD file" of the core SDK shader, but other shader is ok.

I am not familiar with shader compiler, has anyone else encountered this situation?

I am integrating FSR3 support in our software:
https://gpuopen.com/fidelityfx-super-resolution-3/

The documentation says an exposure should be provided when evaluating super sampling, but it is set to nullptr.
What is the meaning of that exposure? Is it a 2D texture that should contain the tone mapping exposure?

Thanks for helping!

Hello, in previous version of FSR (before 2.2.2), we provided const pointer of wchar_t. May I ask you why did you remove const specifier, as in the backend you still do a copy of string, so you don't need to have non-const pointer?

Here's a code snippet from FidelityFX-SDK

Here's from FSR2
https://github.com/GPUOpen-Effects/FidelityFX-FSR2/blob/1680d1edd5c034f88ebbbb793d8b88f8842cf804/src/ffx-fsr2-api/dx12/ffx_fsr2_dx12.h#L96

Thank you for your work!