FSR 3.1 Draft #1

-Adds FSR 3.1 Upscaling
-Adds early FSR 3.1 Framegen
-Adds FidelityFX-SDK

FSR FG QoL fixes

DLL Linking
Main Menu fix

Device Queue fixes

FSR 3.1 Fixes and QoL updates

Hudless fix

-Fixes UI for FSR FG

Update rcas.comp.slang

FSR FG View Model fix

-Removes ghosting from view model

Update d3d9_swapchain.cpp

Author: KingVulpes

.gitmodules

@@ -42,3 +42,6 @@
 [submodule "submodules/xess"]
 	path = submodules/xess
 	url = https://github.com/intel/xess.git
+[submodule "submodules/FidelityFX-SDK"]
+	path = submodules/FidelityFX-SDK
+	url = https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK.git

meson.build

@@ -561,6 +561,8 @@ nrc_dll_path = join_paths(global_src_root_norm, 'submodules/nrc/bin/')
 
 xess_dll_path = join_paths(global_src_root_norm, 'submodules/xess/bin/')
 
+fsr3_dll_path = join_paths(global_src_root_norm, 'submodules/FidelityFX-SDK/PrebuiltSignedDLL/')
+
 nrd_lib_path = join_paths(global_src_root_norm, 'external/nrd/Lib/Release/')
 if get_option('buildtype') == 'debug'  
   nrd_lib_path = join_paths(global_src_root_norm, 'external/nrd/Lib/Debug/')
@@ -750,6 +752,8 @@ if dxvk_is_ninja
 
     install_data(join_paths(xess_dll_path, 'libxess.dll'), install_dir : output_path, install_tag: target_suffix)
 
+    install_data(join_paths(fsr3_dll_path, 'amd_fidelityfx_vk.dll'), install_dir : output_path, install_tag: target_suffix)
+
     install_data(join_paths(dlss_lib_path, 'nvngx_dlss.dll'), install_dir : output_path, install_tag: target_suffix) 
     install_data(join_paths(dlss_lib_path, 'nvngx_dlssd.dll'), install_dir : output_path, install_tag: target_suffix) 
 

src/d3d9/d3d9_swapchain.cpp

@@ -36,6 +36,10 @@
 #include "../dxvk/rtx_render/rtx_dlfg.h"
 // NV-DXVK end
 
+// NV-DXVK start: FSR FG integration
+#include "../dxvk/rtx_render/rtx_fsr_framegen.h"
+// NV-DXVK end
+
 namespace dxvk {
   // NV-DXVK start: App Controlled FSE
   enum FSEState {
@@ -406,22 +410,41 @@ namespace dxvk {
       if (m_dlfgPresenter == nullptr) {
         return true;
       }
+    } else if (m_context->isFSRFGEnabled()) {
+      // FSR FG is enabled - need FSR FG presenter
+      if (m_fsrfgPresenter == nullptr) {
+        Logger::info("NeedRecreatePresenter: FSR FG enabled but no FSR FG presenter, need to recreate");
+        return true;
+      }
+    } else if (m_fsrfgPresenter != nullptr) {
+      // FSR FG presenter exists but FSR FG is disabled - recreate a normal presenter
+      // so present mode / vsync behavior is restored and future FG mode switches are clean.
+      Logger::info("NeedRecreatePresenter: FSR FG disabled with FSR presenter active, recreating presenter");
+      return true;
     } else {
       if (m_presenter == nullptr) {
         return true;
       }
     }
 
     // one must be null, one must be non-null
-    assert(m_presenter != nullptr || m_dlfgPresenter != nullptr);
-    assert(m_presenter == nullptr || m_dlfgPresenter == nullptr);
+    assert(m_presenter != nullptr || m_dlfgPresenter != nullptr || m_fsrfgPresenter != nullptr);
+    assert((m_presenter == nullptr) + (m_dlfgPresenter == nullptr) + (m_fsrfgPresenter == nullptr) >= 2);
     return false;
   }
 
   vk::Presenter* D3D9SwapChainEx::GetPresenter() const {
-    const auto presenter = m_presenter != nullptr ? m_presenter.ptr() : m_dlfgPresenter.ptr();
+    // NV-DXVK: Return whichever presenter is active (normal, DLFG, or FSR FG)
+    vk::Presenter* presenter = nullptr;
+    if (m_presenter != nullptr) {
+      presenter = m_presenter.ptr();
+    } else if (m_dlfgPresenter != nullptr) {
+      presenter = m_dlfgPresenter.ptr();
+    } else if (m_fsrfgPresenter != nullptr) {
+      presenter = m_fsrfgPresenter.ptr();
+    }
 
-    // Note: The returned presenter must be non-null as one of the two presenters must be non-null at all times,
+    // Note: The returned presenter must be non-null as one of the presenters must be non-null at all times,
     // and because code will blindly dereference this returned pointer.
     assert(presenter != nullptr);
 
@@ -1350,13 +1373,40 @@ namespace dxvk {
 
     m_device->waitForIdle();
 
+    // NV-DXVK start: FSR FG - Capture surface before destroying old presenter
+    // This allows reusing the surface when switching presenter types at runtime
+    // We call releaseSurface() which sets the presenter's internal handle to VK_NULL_HANDLE
+    // so the destructor won't destroy it - we transfer ownership to the new presenter
+    VkSurfaceKHR existingSurface = VK_NULL_HANDLE;
+    vk::Presenter* currentPresenter = GetPresenter();
+    if (currentPresenter != nullptr) {
+      existingSurface = currentPresenter->releaseSurface();
+      Logger::info("CreatePresenter: Captured existing surface for reuse");
+    }
+    // NV-DXVK end
+
+    // Destroy old presenters - must happen before creating new ones
+    // to release the swapchain (but surface ownership transferred above)
     m_presenter = nullptr;
     m_presentStatus.result = VK_SUCCESS;
 
-    // NV-DXVK start: DLFG integration
+    // NV-DXVK start: DLFG/FSR FG integration
     m_dlfgPresenter = nullptr;
+    m_fsrfgPresenter = nullptr;
+    
+    // Wait after destroying presenters to ensure swapchains are fully released
+    m_device->waitForIdle();
+    
     const bool dlfgEnabled = m_context->isDLFGEnabled();
-    DxvkDeviceQueue presentQueue = dlfgEnabled ? m_device->queues().present : m_device->queues().graphics;
+    const bool fsrfgEnabled = m_context->isFSRFGEnabled();
+    // Only create FSR FG presenter if enabled - runtime enabling requires restart
+    // This avoids VK_ERROR_NATIVE_WINDOW_IN_USE_KHR crash at startup
+    const bool fsrfgSupported = DxvkFSRFrameGen::supportsFSRFrameGen();
+    const bool createFsrfgPresenter = fsrfgEnabled && fsrfgSupported && !dlfgEnabled;
+    Logger::info(str::format("CreatePresenter: dlfgEnabled=", dlfgEnabled, 
+      ", fsrfgEnabled=", fsrfgEnabled, ", fsrfgSupported=", fsrfgSupported,
+      ", createFsrfgPresenter=", createFsrfgPresenter));
+    DxvkDeviceQueue presentQueue = (dlfgEnabled || createFsrfgPresenter) ? m_device->queues().present : m_device->queues().graphics;
 
     vk::PresenterDevice presenterDevice;
     presenterDevice.queueFamily   = presentQueue.queueFamily;
@@ -1372,19 +1422,49 @@ namespace dxvk {
     presenterDesc.numPresentModes = PickPresentModes(false, presenterDesc.presentModes);
     presenterDesc.fullScreenExclusive = PickFullscreenMode();
 
-    // NV-DXVK start: DLFG integration
+    // NV-DXVK start: DLFG/FSR FG integration
     if (dlfgEnabled) {
       // DLFG presents 2 times (1 more frame) in each real frame,
       // increase image count by 1 to avoid resource waiting.
       presenterDesc.imageCount++;
+      // destroy the existing surface if we're creating DLFG presenter
+      if (existingSurface != VK_NULL_HANDLE) {
+        m_device->adapter()->vki()->vkDestroySurfaceKHR(
+          m_device->adapter()->vki()->instance(), existingSurface, nullptr);
+        existingSurface = VK_NULL_HANDLE;
+      }
       m_dlfgPresenter = new DxvkDLFGPresenter(m_device,
                                               m_context,
                                               m_window,
                                               m_device->adapter()->vki(),
                                               m_device->vkd(),
                                               presenterDevice,
                                               presenterDesc);
+    } else if (createFsrfgPresenter) {
+      // Create FSR FG presenter when enabled
+      // FFX contexts are created lazily in presentImage() when ready
+      // Pass the existing surface to avoid VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
+      presenterDesc.imageCount++;
+      m_fsrfgPresenter = new DxvkFSRFGPresenter(m_device,
+                                                m_context,
+                                                m_window,
+                                                m_device->adapter()->vki(),
+                                                m_device->vkd(),
+                                                presenterDevice,
+                                                presenterDesc,
+                                                existingSurface);
+      existingSurface = VK_NULL_HANDLE;  // Ownership transferred
+      Logger::info(str::format("FSR FG: Created FSR FG Presenter for swapchain ", 
+        presenterDesc.imageExtent.width, "x", presenterDesc.imageExtent.height,
+        " (frame generation ", fsrfgEnabled ? "enabled" : "disabled, can be enabled at runtime", ")"));
     } else {
+      // Regular presenter - needs to destroy existing surface and create new one
+      // TODO: Could also add surface reuse to regular presenter
+      if (existingSurface != VK_NULL_HANDLE) {
+        m_device->adapter()->vki()->vkDestroySurfaceKHR(
+          m_device->adapter()->vki()->instance(), existingSurface, nullptr);
+        existingSurface = VK_NULL_HANDLE;
+      }
       m_presenter = new vk::Presenter(m_window,
         m_device->adapter()->vki(),
         m_device->vkd(),

src/d3d9/d3d9_swapchain.h

@@ -39,6 +39,7 @@
 namespace dxvk {
 
   class D3D9Surface;
+  class DxvkFSRFGPresenter;
 
   using D3D9SwapChainExBase = D3D9DeviceChild<IDirect3DSwapChain9Ex>;
   class D3D9SwapChainEx : public D3D9SwapChainExBase {
@@ -150,6 +151,10 @@ namespace dxvk {
     Rc <DxvkDLFGPresenter>    m_dlfgPresenter;
     // NV-DXVK end
 
+    // NV-DXVK begin: FSR FG integration
+    Rc <DxvkFSRFGPresenter>   m_fsrfgPresenter;
+    // NV-DXVK end
+
     Rc<hud::Hud>              m_hud;
 
     std::vector<Com<D3D9Surface, false>> m_backBuffers;

src/d3d9/meson.build

@@ -106,6 +106,17 @@ d3d9_dll = shared_library('d3d9', d3d9_src, dxvk_version, glsl_generator.process
   install: true
   )
 
+# Copy FSR3 DLL to d3d9 output directory for runtime loading
+fsr3_dll_src = join_paths(global_src_root_norm, 'submodules/FidelityFX-SDK/PrebuiltSignedDLL/amd_fidelityfx_vk.dll')
+fsr3_dll_build = custom_target('copy_fsr3_dll',
+  output: 'amd_fidelityfx_vk.dll',
+  input: fsr3_dll_src,
+  command: [python_interpreter, '-c', 'import shutil; import sys; shutil.copy(sys.argv[1], sys.argv[2])', '@INPUT@', '@OUTPUT@'],
+  build_by_default: true,
+  install: true,
+  install_dir: get_option('bindir')
+)
+
 d3d9_dep = declare_dependency(
   link_with           : [ d3d9_dll ],
   include_directories : [ dxvk_include_path ])

src/dxvk/dxvk_adapter.cpp

@@ -175,6 +175,28 @@ namespace dxvk {
     }
     // NV_DXVK end
 
+    // NV-DXVK start: FSR FG integration
+    // Image acquire queue for FSR3 Frame Interpolation - can use any queue family
+    // Prefer a queue from a family with transfer support for efficiency
+    uint32_t imageAcquireQueue = findQueueFamily(VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT,
+                                                  VK_QUEUE_TRANSFER_BIT);
+    if (imageAcquireQueue == VK_QUEUE_FAMILY_IGNORED) {
+      // Fall back to compute+transfer if no dedicated transfer queue
+      imageAcquireQueue = findQueueFamily(VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT,
+                                          VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT);
+    }
+
+    if (imageAcquireQueue != VK_QUEUE_FAMILY_IGNORED) {
+      queues.imageAcquire = imageAcquireQueue;
+    }
+    
+    // Prefer a dedicated FSR present queue when available.
+    // Surface support gets validated later during swapchain creation where a surface is available.
+    if (presentQueue != VK_QUEUE_FAMILY_IGNORED && presentQueue != graphicsQueue) {
+      queues.fsrPresent = presentQueue;
+    }
+    // NV-DXVK end
+
     return queues;
   }
 
@@ -453,6 +475,11 @@ namespace dxvk {
       extensionsEnabled);
     // NV-DXVK end
 
+    // NV-DXVK start: Add memory requirements extension for Remix
+    if (m_deviceExtensions.supports(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME))
+      extensionsEnabled.add(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
+    // NV-DXVK end
+
     // Enable additional extensions if necessary
     extensionsEnabled.merge(m_extraExtensions);
     DxvkNameList extensionNameList = extensionsEnabled.toNameList();
@@ -758,6 +785,16 @@ namespace dxvk {
       handleQueueFamily(queueFamilies.present, queueInfos.present);
     }
 
+    // NV-DXVK start: FSR FG integration
+    if (queueFamilies.imageAcquire != VK_QUEUE_FAMILY_IGNORED) {
+      handleQueueFamily(queueFamilies.imageAcquire, queueInfos.imageAcquire);
+    }
+    
+    if (queueFamilies.fsrPresent != VK_QUEUE_FAMILY_IGNORED) {
+      handleQueueFamily(queueFamilies.fsrPresent, queueInfos.fsrPresent);
+    }
+    // NV-DXVK end
+
     // Create the requested queues
 
     std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};

src/dxvk/dxvk_adapter.h

@@ -80,6 +80,10 @@ namespace dxvk {
     // NV-DXVK start: DLFG integration
     uint32_t present = VK_QUEUE_FAMILY_IGNORED;
     // NV-DXVK end
+    // NV-DXVK start: FSR FG integration
+    uint32_t imageAcquire = VK_QUEUE_FAMILY_IGNORED;
+    uint32_t fsrPresent = VK_QUEUE_FAMILY_IGNORED;  // Present queue for FSR FG (must support presentation)
+    // NV-DXVK end
   };
 
   // NV-DXVK begin: General Queue Allocation Improvements
@@ -100,6 +104,10 @@ namespace dxvk {
     DxvkAdapterQueueInfo transfer{};
     std::optional<DxvkAdapterQueueInfo> asyncCompute{};
     std::optional<DxvkAdapterQueueInfo> present{};
+    // NV-DXVK start: FSR FG integration
+    std::optional<DxvkAdapterQueueInfo> imageAcquire{};
+    std::optional<DxvkAdapterQueueInfo> fsrPresent{};  // Present queue for FSR FG (must support presentation)
+    // NV-DXVK end
   };
   // NV-DXVK end
 

src/dxvk/dxvk_context.cpp

@@ -28,6 +28,11 @@
 #include "../d3d9/d3d9_state.h"
 #include "../d3d9/d3d9_spec_constants.h"
 
+// NV-DXVK start: FSR FG integration
+#include "rtx_render/rtx_fsr_framegen.h"
+#include "rtx_render/rtx_options.h"
+// NV-DXVK end
+
 namespace dxvk {
   DxvkContext::DxvkContext(const Rc<DxvkDevice>& device)
     : m_device(device),
@@ -70,6 +75,29 @@ namespace dxvk {
   }
   // NV-DXVK end
 
+  // NV-DXVK start: FSR FG integration
+  bool DxvkContext::isFSRFGEnabled() const {
+    ScopedCpuProfileZone();
+    const bool typeIsFSR = RtxOptions::frameGenerationType() == FrameGenerationType::FSR;
+    const bool enableFlag = DxvkFSRFrameGen::enable();
+    const bool supported = DxvkFSRFrameGen::supportsFSRFrameGen();
+    const bool result = typeIsFSR && enableFlag && supported;
+    
+    // Debug logging - log on first check or when state changes
+    static bool lastResult = false;
+    static bool firstCheck = true;
+    if (firstCheck || result != lastResult) {
+      Logger::info(str::format("FSR FG: isFSRFGEnabled = ", result, 
+        " (type=", static_cast<int>(RtxOptions::frameGenerationType()), 
+        ", enable=", enableFlag, ", supported=", supported, ")"));
+      firstCheck = false;
+      lastResult = result;
+    }
+    
+    return result;
+  }
+  // NV-DXVK end
+
   void DxvkContext::beginRecording(const Rc<DxvkCommandList>& cmdList) {
     ScopedCpuProfileZone();
     m_cmd = cmdList;

src/dxvk/dxvk_context.h

@@ -70,6 +70,15 @@ namespace dxvk {
      */
     uint32_t dlfgMaxSupportedInterpolatedFrameCount() const;
     // NV-DXVK end
+
+    // NV-DXVK start: FSR FG integration
+    /**
+     * \brief Returns true if FSR Frame Generation is enabled
+     *
+     * This is a combination of the setting being enabled and the device supporting it.
+     */
+    bool isFSRFGEnabled() const;
+    // NV-DXVK end
 
     /**
      * \brief Begins command buffer recording

src/dxvk/dxvk_device.cpp

@@ -31,6 +31,7 @@
 #include "rtx_render/rtx_composite.h"
 #include "rtx_render/rtx_debug_view.h"
 #include "rtx_render/rtx_xess.h"
+#include "rtx_render/rtx_fsr.h"
 
 
 namespace dxvk {
@@ -67,6 +68,16 @@ namespace dxvk {
       m_queues.present = getQueue(adapterQueueInfos.present->queueFamilyIndex, adapterQueueInfos.present->queueIndex);
     }
 
+    // NV-DXVK start: FSR FG integration
+    if (adapterQueueInfos.imageAcquire.has_value()) {
+      m_queues.imageAcquire = getQueue(adapterQueueInfos.imageAcquire->queueFamilyIndex, adapterQueueInfos.imageAcquire->queueIndex);
+    }
+    
+    if (adapterQueueInfos.fsrPresent.has_value()) {
+      m_queues.fsrPresent = getQueue(adapterQueueInfos.fsrPresent->queueFamilyIndex, adapterQueueInfos.fsrPresent->queueIndex);
+    }
+    // NV-DXVK end
+
     if (__DLFG_QUEUE_INFO_CHECK(adapterQueueInfos)) {
       // Note: When DLFG is active a separate queue is used for out of band rendering/presentation, so it should be marked accordingly.
       // Additionally, we do not mark the out of band render queue here as apparently it should only be marked when the out of band rendering
@@ -550,6 +561,9 @@ namespace dxvk {
     m_nis(device),
     m_taa(device),
     m_xess(device),
+    m_fsr(device),
+    m_fsrFrameGen(device),
+    m_rcas(device),
     m_composite(device),
     m_debug_view(device),
     m_autoExposure(device),
@@ -582,5 +596,6 @@ namespace dxvk {
     m_rayReconstruction.get().onDestroy();
     m_dlss.get().onDestroy();
     m_dlfg.get().onDestroy();
+    m_fsrFrameGen.get().onDestroy();
   }
 }