TAA update (new defaults) + optional Intel XeSS

docs/upscaler.md

@@ -384,10 +384,50 @@ skipping screen-space passes (3 or 4 indices) so a shifted full-screen quad leav
 - `pad` bits: 0-7 diagnostic view (4 = history debug view: red depth-rejected, green history lost,
   blue weight used), 8-15 A/B switches, 16-23 moving-object history loss in percent, 24 view-projection
   depth, 25 8-bit scene, 26-31 spatial smoothing.
-- Defaults (tuned in game on a GTX 1070 Ti): history 99% still / 55% moving, tolerance 115%,
-  moving objects 90%, edges 70%, texture detail 75%, sharpening 165%. They live in
+- Defaults (tuned in game on a GTX 1070 Ti): history 99% still / 55% moving, tolerance 175%,
+  moving objects 55%, edges 55%, texture detail 80%, sharpening 130%. They live in
   `shim/spartanport_settings.h` and in the menu hints.
 
+### XeSS in place of the accumulation (upscaler "XeSS", ini `upscaler=xess`, Windows only)
+
+Intel XeSS-SR at its native anti-aliasing setting (`XESS_QUALITY_SETTING_AA`, the game's own
+resolution) can take the place of `taa.comp`. It gets the same inputs: the jittered scene colour (the
+sRGB view, so linear values, with `XESS_INIT_FLAG_LDR_INPUT_COLOR` since the colour is already tonemapped),
+the scene depth (not inverted: 0 at the near plane) and the motion vectors of `camera_motion_vp.comp` in render pixels
+(previous minus current, without jitter), and it writes into the TAA's output image, so the alpha
+pass, the write back and the HUD stay as they are. Code: `vk_xess.cpp` (loads `libxess.dll` at run time,
+Windows only), the hook is `TemporalUpscaler::RecordXess`.
+
+- The library is Intel's binary (`packaging/fetch_xess.sh` takes it from github.com/intel/xess at a pinned
+  commit and checks its hash; the Intel Simplified Software License allows redistributing it unmodified
+  with its license, which the package keeps in `LICENSES/`). The headers in `gpu/third_party/xess` are MIT.
+- XeSS needs `VK_EXT_mutable_descriptor_type` and the extensions its library lists
+  (`xessVKGetRequiredDeviceExtensions`); `Instance::CreateDevice` enables them only when `upscaler=xess` is in
+  the ini at start, which fits the upscaler choice being applied on restart. It is a choice of its own in the
+  launcher and the menu, next to the TAA (`IsTaa()` covers both: same live path, jitter and motion vectors).
+- The device is created with XeSS's extensions and its required features (`xessVKGetRequiredDeviceFeatures`,
+  patched into the device's feature chain) only when XeSS is the upscaler at start. If the card cannot give
+  them, the device is created from a copy of the chain without them. The result goes to
+  `XessAa::SetDeviceReady`: `Record` refuses to create a context on a device that was not made for XeSS and
+  fails for good with a message in the menu, so the TAA runs. Choosing XeSS in the menu when the game did not
+  start with it therefore needs a restart (`NeedsXessRestart`, in the three restart predicates and the menu's
+  count of changes).
+- `libxess.dll` is loaded only by full path, from the executable's folder or its `bin` folder, with the
+  search limited to that folder and the system folder (never the current directory or `PATH`). The waits
+  for an idle GPU (at the start and when the picture changes size) hold `Scheduler::submit_mutex`, the lock
+  the scheduler and the presenter take around `vkQueueSubmit` and `vkQueuePresent`.
+- The TAA look sliders (history, tolerance, moving objects, edges) do not apply to XeSS, which has its own
+  history. Texture detail (`taa_lod`, the rasterizer's mip bias) and the sharpening (`xess_sharpen`, default 145%; the
+  `taa_sharpen.comp` pass run over the output image through `SharpenImage`) do, and are logged as
+  `XeSS look:`. If XeSS cannot run, the TAA does, and the menu shows why.
+- Ghosting: the scene TAA's motion vectors are the camera's only (characters have none), so XeSS gets a
+  responsive pixel mask (`XESS_INIT_FLAG_RESPONSIVE_PIXEL_MASK`, R8): the scene stencil's characters and
+  objects, the mask `RecordStencilReactive` makes for FSR, clipped by `xessSetMaxResponsiveMaskValue` to
+  the menu's "Moving objects" (`xess_objects`, default 95%, 0 = off). Without a stencil XeSS runs without it.
+- Jitter sign: the same as FSR's; `SPARTAN_XESS_INVERT_JITTER=1` flips it for a test.
+- XeSS is meant to run before tonemapping; here it gets the tonemapped scene, because that is where the
+  game's TAA sits. Treat the quality as unproven.
+
 ### Simulator
 
 The tuning used a software renderer of a procedural scene (static, slow and fast camera, moving box)

gpu/CMakeLists.txt

@@ -177,7 +177,7 @@ target_compile_definitions(spartanportgpu PRIVATE IMGUI_IMPL_VULKAN_NO_PROTOTYPE
     SPARTAN_TITLE_FONT_PATH="${CMAKE_CURRENT_SOURCE_DIR}/../launcher/Cinzel-Black.ttf")
 set_source_files_properties(shim/spartanport_overlay.cpp PROPERTIES
     OBJECT_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/fonts/DejaVuSans.ttf;${CMAKE_CURRENT_SOURCE_DIR}/../launcher/Cinzel-Black.ttf")
-target_include_directories(spartanportgpu PRIVATE shim shadps4 ${SHADER_INCLUDE} third_party/gcn/include third_party/half/include)
+target_include_directories(spartanportgpu PRIVATE shim shadps4 ${SHADER_INCLUDE} third_party/gcn/include third_party/half/include third_party/xess)
 target_compile_definitions(spartanportgpu PRIVATE BOOST_ASIO_STANDALONE NDEBUG)
 target_compile_options(spartanportgpu PRIVATE -Wno-deprecated-declarations -Wno-missing-field-initializers)
 # Runtime symbols (runtime_memory_*, runtime_process_*) resolve against spartanport-probe.

gpu/shadps4/video_core/renderer_vulkan/vk_camera_motion.cpp

@@ -539,7 +539,7 @@ void CameraMotion::OnDisplayPass(VideoCore::ImageId frame) {
     if (debug_overlay && frame && DepthLive() && current.valid && previous.valid) {
         Overlay(frame);
     }
-    if (SpartanSettings::Get().upscaler != SpartanSettings::UpscalerTaa) {
+    if (!SpartanSettings::IsTaa(SpartanSettings::Get().upscaler)) {
         // Upscaler path (FSR): the unchanged upstream behaviour, nothing of the scene TAA applies.
         if (!frame_has_camera) InvalidateHistory();
         frame_has_camera = false;

gpu/shadps4/video_core/renderer_vulkan/vk_instance.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <algorithm>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -20,6 +21,7 @@
 #include "video_core/renderer_vulkan/vk_amd_paths.h"
 #include "video_core/renderer_vulkan/vk_instance.h"
 #include "video_core/renderer_vulkan/vk_platform.h"
+#include "video_core/renderer_vulkan/vk_xess.h"
 
 #include <vk_mem_alloc.h>
 
@@ -276,7 +278,8 @@ bool Instance::CreateDevice() {
         vk::PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE,
         vk::PhysicalDevicePipelineBinaryFeaturesKHR,
         vk::PhysicalDeviceMaintenance5FeaturesKHR,
-        vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>();
+        vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
+        vk::PhysicalDeviceMutableDescriptorTypeFeaturesEXT>();
     features = feature_chain.get().features;
 
     const vk::StructureChain properties_chain = physical_device.getProperties2<
@@ -422,6 +425,26 @@ bool Instance::CreateDevice() {
         LOG_INFO(Render_Vulkan, "- sampler2DViewOf3D: {}",
                  image_2d_view_of_3d_features.sampler2DViewOf3D);
     }
+    // spartanport: XeSS (vk_xess.cpp) asks for device extensions of its own (mutable descriptors
+    // among them); they are enabled only when it is selected, so the device is the same without it.
+    const bool xess_selected = SpartanSettings::Get().upscaler == SpartanSettings::UpscalerXess;
+    bool xess_extensions = false; ///< XeSS's own extensions are all enabled
+    if (xess_selected) {
+        const auto enable = [&](const char* name) {
+            const bool already = std::any_of(
+                enabled_extensions.begin(), enabled_extensions.end(),
+                [&](const char* have) { return std::strcmp(have, name) == 0; });
+            return already || add_extension(name);
+        };
+        const auto xess_names = XessAa::DeviceExtensions(*instance, physical_device);
+        xess_extensions = !xess_names.empty();
+        for (const char* name : xess_names) {
+            xess_extensions = enable(name) && xess_extensions;
+        }
+        mutable_descriptor_type = enable(VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME) &&
+            feature_chain.get<vk::PhysicalDeviceMutableDescriptorTypeFeaturesEXT>()
+                .mutableDescriptorType;
+    }
     image_view_min_lod = add_extension(VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME);
     supports_memory_budget = add_extension(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME);
     // spartanport: FSR 4 v07 INT8 (vk_temporal_upscaler): quad derivatives in compute shaders.
@@ -646,6 +669,9 @@ bool Instance::CreateDevice() {
             .image2DViewOf3D = image_2d_view_of_3d_features.image2DViewOf3D,
             .sampler2DViewOf3D = image_2d_view_of_3d_features.sampler2DViewOf3D,
         },
+        vk::PhysicalDeviceMutableDescriptorTypeFeaturesEXT{
+            .mutableDescriptorType = mutable_descriptor_type,
+        },
         vk::PhysicalDeviceImageViewMinLodFeaturesEXT{
             .minLod = true,
         },
@@ -715,6 +741,9 @@ bool Instance::CreateDevice() {
     if (!image_2d_view_of_3d) {
         device_chain.unlink<vk::PhysicalDeviceImage2DViewOf3DFeaturesEXT>();
     }
+    if (!mutable_descriptor_type) {
+        device_chain.unlink<vk::PhysicalDeviceMutableDescriptorTypeFeaturesEXT>();
+    }
     if (!image_view_min_lod) {
         device_chain.unlink<vk::PhysicalDeviceImageViewMinLodFeaturesEXT>();
     }
@@ -728,7 +757,36 @@ bool Instance::CreateDevice() {
         device_chain.unlink<vk::PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE>();
     }
 
-    auto [device_result, dev] = physical_device.createDeviceUnique(device_chain.get());
+    // spartanport: XeSS's device features (xessVKGetRequiredDeviceFeatures) are patched into the
+    // chain only when its extensions are there too. A copy of the chain without them is the way
+    // back if the card cannot give them: the game starts, XeSS says why it does not run and the
+    // TAA runs.
+    auto plain_chain = device_chain;
+    bool xess_patched = false;
+    if (xess_selected) {
+        void* head = &device_chain.get<vk::PhysicalDeviceFeatures2>();
+        if (xess_extensions && XessAa::PatchDeviceFeatures(*instance, physical_device, head)) {
+            if (head != static_cast<void*>(&device_chain.get<vk::PhysicalDeviceFeatures2>())) {
+                device_chain.get<vk::DeviceCreateInfo>().pNext = head;
+            }
+            xess_patched = true;
+        }
+        XessAa::SetDeviceReady(xess_patched,
+                               xess_extensions ? "the graphics card or driver does not offer the "
+                                                 "features XeSS needs"
+                                               : "the graphics driver does not offer the "
+                                                 "extensions XeSS needs");
+    }
+    auto created = physical_device.createDeviceUnique(device_chain.get());
+    if (xess_patched && created.result != vk::Result::eSuccess) {
+        LOG_WARNING(Render_Vulkan, "Device with XeSS's features failed ({}), creating it without",
+                    vk::to_string(created.result));
+        XessAa::SetDeviceReady(false, "the graphics card or driver does not offer the features "
+                                      "XeSS needs");
+        created = physical_device.createDeviceUnique(plain_chain.get());
+    }
+    const vk::Result device_result = created.result;
+    auto dev = std::move(created.value);
     if (device_result != vk::Result::eSuccess) {
         LOG_CRITICAL(Render_Vulkan, "Failed to create device: {}", vk::to_string(device_result));
         return false;
@@ -819,7 +877,7 @@ void Instance::CollectDeviceParameters() {
     // The port's TAA is also chosen by the launcher in spartanport.ini (upscaler=taa; settings are
     // loaded before the device), without any environment variable.
     const bool temporal_mode =
-        SpartanSettings::Get().upscaler == SpartanSettings::UpscalerTaa ||
+        SpartanSettings::IsTaa(SpartanSettings::Get().upscaler) ||
         (temporal_env && temporal_on && *temporal_on == '1' &&
          (std::strcmp(temporal_env, "taa") == 0 || std::strcmp(temporal_env, "fsr3") == 0));
     const bool no_msaa = no_msaa_env && *no_msaa_env

gpu/shadps4/video_core/renderer_vulkan/vk_instance.h

@@ -593,6 +593,7 @@ class Instance {
     bool maintenance_8{};
     bool attachment_feedback_loop{};
     bool image_2d_view_of_3d{};
+    bool mutable_descriptor_type{}; ///< enabled for XeSS only (vk_xess.cpp)
     bool image_view_min_lod{};
     bool shader_clock{};
     bool pipeline_executable_properties{}; // spartanport: SPARTAN_WAVE_STATS=1 (vk_wave_stats.h)