Merge remote-tracking branch 'remotes/Joey/ue57performance' into Joey-Merged

Author: PureDark

dependencies/submodules/UESDK

@@ -13,6 +13,7 @@
 
 #include "WindowFilter.hpp"
 #include "Framework.hpp"
+#include "mods/GameSpecific.hpp"
 #include "render/D3D12Diagnostics.hpp"
 #include "render/ShaderOverrideRegistry.hpp"
 
@@ -54,7 +55,8 @@ bool should_preserve_present_params_for_current_game() {
 bool is_dune_awakening_current_game() {
     static const bool result = []() {
         const auto exe_path = utility::get_module_pathw(utility::get_executable());
-        return exe_path && exe_path->find(L"DuneSandbox-Win64-Shipping") != std::wstring::npos;
+        return uevr::games::dune_experimental_rendering_enabled &&
+               exe_path && uevr::games::is_dune_awakening_executable_path(*exe_path);
     }();
 
     return result;

src/hooks/D3D12Hook.cpp

@@ -7,6 +7,12 @@
 
 namespace uevr::games {
 
+// The legacy Dune rendering experiment depends on binary-specific D3D12
+// descriptor and render-target hooks. Current game builds no longer match
+// those guards, so keep every Dune-only runtime path retired and use UEVR's
+// generic rendering paths instead.
+inline constexpr bool dune_experimental_rendering_enabled = false;
+
 inline std::wstring lowercase_path(std::wstring_view path) {
     std::wstring lowered{path};
     std::transform(lowered.begin(), lowered.end(), lowered.begin(), [](wchar_t ch) {

src/mods/GameSpecific.hpp

@@ -530,7 +530,8 @@ bool is_stalker2_executable_cached() {
 bool is_dune_awakening_executable_cached() {
     static const bool is_dune = []() {
         const auto exe_path = utility::get_module_pathw(utility::get_executable());
-        return exe_path && uevr::games::is_dune_awakening_executable_path(*exe_path);
+        return uevr::games::dune_experimental_rendering_enabled &&
+               exe_path && uevr::games::is_dune_awakening_executable_path(*exe_path);
     }();
 
     return is_dune;

src/mods/VR.cpp

@@ -585,6 +585,11 @@ class VR : public Mod {
                m_extreme_compat_mode->value() == true;
     }
 
+    bool is_using_native_stereo() const {
+        return m_rendering_method->value() == RenderingMethod::NATIVE_STEREO &&
+               !is_using_afr();
+    }
+
     bool is_using_synchronized_afr() const {
         return m_rendering_method->value() == RenderingMethod::SYNCHRONIZED ||
                (m_extreme_compat_mode->value() && m_rendering_method->value() == RenderingMethod::NATIVE_STEREO) ||

src/mods/VR.hpp

@@ -61,9 +61,11 @@ float4 SpritePixelShader(float4 color : COLOR0, float2 texCoord : TEXCOORD0) : S
     float4 tex = Texture.Sample(TextureSampler, texCoord);
     float threshold = saturate(color.r);
     float softness = max(color.g, 0.001);
+    float invertAmount = saturate(color.b);
     float opacity = saturate(color.a);
     float luma = max(max(tex.r, tex.g), tex.b);
     float alpha = smoothstep(threshold, threshold + softness, luma) * opacity;
+    alpha = lerp(alpha, 1.0 - alpha, invertAmount);
     return float4(tex.rgb, alpha);
 }
 )";
@@ -740,9 +742,9 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
         native_stereo_packet.reset();
     }
 
-    // Update the UI overlay. Days Gone normally composites Slate through BendTemporalAA
-    // into the scene. When the game-specific overlay path is enabled, use the captured
-    // SlateIntermediateBuffer and key black out into a real OpenXR UI layer.
+    // Days Gone bypasses the normal viewport UI target and feeds a private
+    // SlateIntermediateBuffer into BendTemporalAA. AHUD consumes that exact
+    // target while leaving every other game's UI path unchanged.
     const auto daysgone_menu_is_in_scene = is_daysgone_executable();
     auto* daysgone_native_ui_target = static_cast<ID3D11Texture2D*>(nullptr);
     D3D11_TEXTURE2D_DESC daysgone_native_ui_desc{};
@@ -752,8 +754,19 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
         daysgone_menu_is_in_scene &&
         vr != nullptr &&
         vr->is_daysgone_bend_ui_placement_fix_enabled();
-
-    if (daysgone_bend_fix_active && ffsr != nullptr && ffsr->should_use_daysgone_slate_ui_overlay()) {
+    const bool daysgone_ahud_active =
+        daysgone_menu_is_in_scene &&
+        vr != nullptr &&
+        runtime != nullptr &&
+        runtime->is_openxr() &&
+        vr->is_hmd_active() &&
+        vr->is_ahud_compatibility_enabled();
+    const bool daysgone_slate_target_requested =
+        ffsr != nullptr &&
+        (daysgone_ahud_active ||
+         (daysgone_bend_fix_active && ffsr->should_use_daysgone_slate_ui_overlay()));
+
+    if (daysgone_slate_target_requested) {
         daysgone_native_ui_target = reinterpret_cast<ID3D11Texture2D*>(ffsr->get_daysgone_slate_native_ui_target());
         if (daysgone_native_ui_target != nullptr &&
             is_d3d11_or_dxgi_com_object(reinterpret_cast<IUnknown*>(daysgone_native_ui_target)))
@@ -769,6 +782,23 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
     }
 
     const auto using_daysgone_native_ui_target = daysgone_native_ui_target != nullptr;
+    const auto using_daysgone_ahud_ui_target =
+        using_daysgone_native_ui_target && daysgone_ahud_active;
+
+    if (daysgone_ahud_active != m_daysgone_ahud_was_active) {
+        if (ffsr != nullptr) {
+            ffsr->reset_daysgone_ahud_overlay_readiness();
+        }
+        if (vr != nullptr) {
+            vr->get_overlay_component().get_openxr().reset_daysgone_ahud_pose();
+        }
+
+        if (daysgone_ahud_active) {
+            SPDLOG_INFO("[DaysGone][AHUD] Armed fixed-stage UI after OpenXR/HMD became ready");
+        }
+    }
+    m_daysgone_ahud_was_active = daysgone_ahud_active;
+
     const auto ui_target = (!using_daysgone_native_ui_target && !daysgone_menu_is_in_scene)
         ? ffsr->get_render_target_manager()->get_ui_target()
         : nullptr;
@@ -789,7 +819,8 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
 
             SPDLOG_INFO_EVERY_N_SEC(
                 5,
-                "[DaysGone][SlateOverlay] using captured SlateIntermediateBuffer native={:x} [{}x{} fmt={} bind=0x{:X}] key=({:.3f},{:.3f},{:.3f}) offset=({:.1f},{:.1f}) scale={:.3f}",
+                "[DaysGone][SlateOverlay] using captured SlateIntermediateBuffer route={} native={:x} [{}x{} fmt={} bind=0x{:X}] key=({:.3f},{:.3f},{:.3f}) invert={:.3f} offset=({:.1f},{:.1f}) scale={:.3f}",
+                using_daysgone_ahud_ui_target ? "AHUD fixed-stage" : "Bend placement",
                 (uintptr_t)native_ui_target,
                 daysgone_native_ui_desc.Width,
                 daysgone_native_ui_desc.Height,
@@ -798,9 +829,10 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
                 ffsr->get_daysgone_slate_ui_key_threshold(),
                 ffsr->get_daysgone_slate_ui_key_softness(),
                 ffsr->get_daysgone_slate_ui_key_opacity(),
-                ffsr->get_daysgone_slate_ui_offset_x(),
-                ffsr->get_daysgone_slate_ui_offset_y(),
-                ffsr->get_daysgone_slate_ui_scale());
+                vr->get_overlay_component().get_ui_invert_alpha(),
+                using_daysgone_ahud_ui_target ? 0.0f : ffsr->get_daysgone_slate_ui_offset_x(),
+                using_daysgone_ahud_ui_target ? 0.0f : ffsr->get_daysgone_slate_ui_offset_y(),
+                using_daysgone_ahud_ui_target ? 1.0f : ffsr->get_daysgone_slate_ui_scale());
         } else if (is_naruto_executable() && native_ui_target != nullptr) {
             D3D11_TEXTURE2D_DESC desc{};
             native_ui_target->GetDesc(&desc);
@@ -833,15 +865,17 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
                 native->GetDesc(&desc);
 
                 if (runtime->is_openxr()) {
-                    if (auto it = vr->m_openxr->swapchains.find((uint32_t)runtimes::OpenXR::SwapchainIndex::UI);
-                        it != vr->m_openxr->swapchains.end()) 
-                    {
-                        const auto& uisc = it->second;
-                        if (desc.Width != uisc.width ||
-                            desc.Height != uisc.height)
+                    if (!using_daysgone_ahud_ui_target) {
+                        if (auto it = vr->m_openxr->swapchains.find((uint32_t)runtimes::OpenXR::SwapchainIndex::UI);
+                            it != vr->m_openxr->swapchains.end())
                         {
-                            SPDLOG_INFO_EVERY_N_SEC(1, "[OpenXR] UI size changed, recreating [{}x{}]->[{}x{}]", desc.Width, desc.Height, uisc.width, uisc.height);
-                            ffsr->set_should_recreate_textures(true);
+                            const auto& uisc = it->second;
+                            if (desc.Width != uisc.width ||
+                                desc.Height != uisc.height)
+                            {
+                                SPDLOG_INFO_EVERY_N_SEC(1, "[OpenXR] UI size changed, recreating [{}x{}]->[{}x{}]", desc.Width, desc.Height, uisc.width, uisc.height);
+                                ffsr->set_should_recreate_textures(true);
+                            }
                         }
                     }
                 } else if (m_ui_tex != nullptr) {
@@ -960,7 +994,7 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
             } else {
                 if (m_engine_ui_ref.has_texture() && m_engine_ui_ref.has_srv()) {
                     if (using_daysgone_native_ui_target && ensure_daysgone_ui_key_resources()) {
-                        m_openxr.copy(
+                        const auto copied = m_openxr.copy(
                             (uint32_t)runtimes::OpenXR::SwapchainIndex::UI,
                             nullptr,
                             nullptr,
@@ -971,10 +1005,11 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
                                     ffsr->get_daysgone_slate_ui_key_threshold(),
                                     ffsr->get_daysgone_slate_ui_key_softness(),
                                     ffsr->get_daysgone_slate_ui_key_opacity(),
-                                    ffsr->get_daysgone_slate_ui_offset_x(),
-                                    ffsr->get_daysgone_slate_ui_offset_y(),
-                                    ffsr->get_daysgone_slate_ui_scale(),
-                                    ffsr->should_split_daysgone_slate_ui_overlay(),
+                                    ui_invert_alpha,
+                                    using_daysgone_ahud_ui_target ? 0.0f : ffsr->get_daysgone_slate_ui_offset_x(),
+                                    using_daysgone_ahud_ui_target ? 0.0f : ffsr->get_daysgone_slate_ui_offset_y(),
+                                    using_daysgone_ahud_ui_target ? 1.0f : ffsr->get_daysgone_slate_ui_scale(),
+                                    using_daysgone_ahud_ui_target ? false : ffsr->should_split_daysgone_slate_ui_overlay(),
                                     ffsr->get_daysgone_slate_ui_menu_src_x(),
                                     ffsr->get_daysgone_slate_ui_menu_src_y(),
                                     ffsr->get_daysgone_slate_ui_menu_src_w(),
@@ -985,6 +1020,9 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
                                     ffsr->get_daysgone_slate_ui_footer_src_y(),
                                     ffsr->get_daysgone_slate_ui_footer_src_h());
                             });
+                        if (copied && using_daysgone_ahud_ui_target) {
+                            ffsr->note_daysgone_ahud_overlay_submitted();
+                        }
                     } else if (ui_invert_alpha > 0.0f && ensure_ui_invert_resources()) {
                         m_openxr.copy(
                             (uint32_t)runtimes::OpenXR::SwapchainIndex::UI,
@@ -1237,7 +1275,9 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
                     quad_layers.push_back((XrCompositionLayerBaseHeader*)&right_layer->get());
                 }
             } else if (m_openxr.ever_acquired((uint32_t)runtimes::OpenXR::SwapchainIndex::UI)) {
-                const auto slate_layer = openxr_overlay.generate_slate_layer();
+                const auto slate_layer = daysgone_ahud_active && using_daysgone_ahud_ui_target
+                    ? openxr_overlay.generate_daysgone_ahud_slate_layer()
+                    : openxr_overlay.generate_slate_layer();
 
                 if (slate_layer) {
                     quad_layers.push_back(&slate_layer->get());
@@ -1572,6 +1612,14 @@ void D3D11Component::on_post_present(VR* vr) {
 
 void D3D11Component::on_reset(VR* vr) {
     m_force_reset = true;
+    m_daysgone_ahud_was_active = false;
+
+    if (vr != nullptr) {
+        if (vr->m_fake_stereo_hook != nullptr) {
+            vr->m_fake_stereo_hook->reset_daysgone_ahud_overlay_readiness();
+        }
+        vr->get_overlay_component().get_openxr().reset_daysgone_ahud_pose();
+    }
 
     m_backbuffer_rtv.Reset();
     m_backbuffer.Reset();
@@ -2008,6 +2056,7 @@ void D3D11Component::render_daysgone_ui_key_to_rt(
     float threshold,
     float softness,
     float opacity,
+    float invert_amount,
     float offset_x,
     float offset_y,
     float scale,
@@ -2087,7 +2136,7 @@ void D3D11Component::render_daysgone_ui_key_to_rt(
     const auto tint = DirectX::XMVectorSet(
         std::clamp(threshold, 0.0f, 0.5f),
         std::clamp(softness, 0.001f, 0.5f),
-        1.0f,
+        std::clamp(invert_amount, 0.0f, 1.0f),
         std::clamp(opacity, 0.0f, 2.0f));
 
     auto set_custom_shaders = [&]() {
@@ -3095,13 +3144,13 @@ void D3D11Component::OpenXR::destroy_swapchains() {
     vr->m_openxr->swapchains.clear();
 }
 
-void D3D11Component::OpenXR::copy(uint32_t swapchain_idx, ID3D11Texture2D* resource, D3D11_BOX* src_box, std::function<void(ID3D11Texture2D*)> pre_commands) {
+bool D3D11Component::OpenXR::copy(uint32_t swapchain_idx, ID3D11Texture2D* resource, D3D11_BOX* src_box, std::function<void(ID3D11Texture2D*)> pre_commands) {
     std::scoped_lock _{this->mtx};
 
     auto vr = VR::get();
 
     if (vr->m_openxr->frame_state.shouldRender != XR_TRUE) {
-        return;
+        return false;
     }
 
     if (!vr->m_openxr->frame_began) {
@@ -3111,12 +3160,12 @@ void D3D11Component::OpenXR::copy(uint32_t swapchain_idx, ID3D11Texture2D* resou
 
     if (!this->contexts.contains(swapchain_idx)) {
         spdlog::error("[VR] OpenXR: Trying to copy to swapchain {} but it doesn't exist.", swapchain_idx);
-        return;
+        return false;
     }
 
     if (!vr->m_openxr->swapchains.contains(swapchain_idx)) {
         spdlog::error("[VR] OpenXR: Trying to copy to swapchain {} but it doesn't exist.", swapchain_idx);
-        return;
+        return false;
     }
 
     if (this->contexts[swapchain_idx].num_textures_acquired > 0) {
@@ -3176,12 +3225,15 @@ void D3D11Component::OpenXR::copy(uint32_t swapchain_idx, ID3D11Texture2D* resou
 
             if (result != XR_SUCCESS) {
                 spdlog::error("[VR] xrReleaseSwapchainImage failed: {}", vr->m_openxr->get_result_string(result));
-                return;
+                return false;
             }
 
             ctx.num_textures_acquired--;
             ctx.ever_acquired = true;
+            return true;
         }
     }
+
+    return false;
 }
 } // namespace vrmod

src/mods/vr/D3D11Component.cpp

@@ -74,6 +74,7 @@ class D3D11Component {
         float threshold,
         float softness,
         float opacity,
+        float invert_amount,
         float offset_x,
         float offset_y,
         float scale,
@@ -212,14 +213,15 @@ class D3D11Component {
     bool m_submitted_left_eye{false};
     bool m_is_shader_setup{false};
     bool m_last_afr_state{false};
+    bool m_daysgone_ahud_was_active{false};
 
     struct OpenXR {
         OpenXR(D3D11Component* p) : parent(p) {}
 
         void initialize(XrSessionCreateInfo& session_info);
         std::optional<std::string> create_swapchains();
         void destroy_swapchains();
-        void copy(uint32_t swapchain_idx, ID3D11Texture2D* resource, D3D11_BOX* src_box = nullptr, std::function<void(ID3D11Texture2D*)> pre_commands = nullptr);
+        bool copy(uint32_t swapchain_idx, ID3D11Texture2D* resource, D3D11_BOX* src_box = nullptr, std::function<void(ID3D11Texture2D*)> pre_commands = nullptr);
 
         bool ever_acquired(uint32_t swapchain_idx) {
             std::scoped_lock _{this->mtx};