From ed7c25672874541ca5b2917190d91a87226d3b7c Mon Sep 17 00:00:00 2001 From: CamilleLaVey Date: Fri, 14 Aug 2026 03:53:59 -0400 Subject: [PATCH] Another take --- .../features/settings/model/IntSetting.kt | 1 + .../settings/model/view/SettingsItem.kt | 10 + .../settings/ui/SettingsFragmentPresenter.kt | 8 +- .../app/src/main/res/values/arrays.xml | 18 ++ .../app/src/main/res/values/strings.xml | 8 + src/common/settings.cpp | 10 + src/common/settings.h | 13 + src/video_core/CMakeLists.txt | 2 + .../renderer_vulkan/present/frame_gen.cpp | 28 +- .../renderer_vulkan/present/frame_gen.h | 9 +- .../present/frame_gen_pacer.cpp | 240 ++++++++++++++++++ .../renderer_vulkan/present/frame_gen_pacer.h | 46 ++++ .../renderer_vulkan/renderer_vulkan.cpp | 6 +- .../renderer_vulkan/vk_present_manager.cpp | 7 +- .../renderer_vulkan/vk_present_manager.h | 2 +- 15 files changed, 383 insertions(+), 25 deletions(-) create mode 100644 src/video_core/renderer_vulkan/present/frame_gen_pacer.cpp create mode 100644 src/video_core/renderer_vulkan/present/frame_gen_pacer.h diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/IntSetting.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/IntSetting.kt index 6029a94861..ea31692fbf 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/IntSetting.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/IntSetting.kt @@ -20,6 +20,7 @@ enum class IntSetting(override val key: String) : AbstractIntSetting { RENDERER_ACCURACY("gpu_accuracy"), RENDERER_RESOLUTION("resolution_setup"), RENDERER_FRAME_GEN_MULTIPLIER("frame_gen_multiplier"), + RENDERER_FRAME_GEN_TARGET_RATE("frame_gen_target_rate"), RENDERER_FRAME_GEN_QUEUE_TARGET("frame_gen_queue_target"), RENDERER_FRAME_GEN_FLOW_SCALE("frame_gen_flow_scale"), RENDERER_VSYNC("use_vsync"), diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt index 473f88c9e0..629383cb12 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt @@ -99,6 +99,7 @@ abstract class SettingsItem( private val frameGenKeys = setOf( BooleanSetting.RENDERER_FRAME_GEN.key, IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key, + IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key, IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET.key, BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.key, IntSetting.RENDERER_FRAME_GEN_FLOW_SCALE.key, @@ -640,6 +641,15 @@ abstract class SettingsItem( valuesId = R.array.frameGenMultiplierValues ) ) + put( + SingleChoiceSetting( + IntSetting.RENDERER_FRAME_GEN_TARGET_RATE, + titleId = R.string.frame_gen_target_rate, + descriptionId = R.string.frame_gen_target_rate_description, + choicesId = R.array.frameGenTargetRateNames, + valuesId = R.array.frameGenTargetRateValues + ) + ) put( SingleChoiceSetting( IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET, diff --git a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt index b241d896f7..6efc3ca71e 100644 --- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt +++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt @@ -125,7 +125,13 @@ class SettingsFragmentPresenter( add(HeaderSetting(R.string.frame_gen)) add(BooleanSetting.RENDERER_FRAME_GEN.key) - add(IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key) + add(IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key) + if (IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.getInt( + getNeedsGlobalForKey(IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key) + ) == 0 + ) { + add(IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key) + } add(IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET.key) add(BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.key) if (!BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.getBoolean( diff --git a/src/android/app/src/main/res/values/arrays.xml b/src/android/app/src/main/res/values/arrays.xml index d8ae109e97..53dd0436dc 100644 --- a/src/android/app/src/main/res/values/arrays.xml +++ b/src/android/app/src/main/res/values/arrays.xml @@ -174,6 +174,24 @@ 4 + + @string/frame_gen_target_rate_off + @string/frame_gen_target_rate_60 + @string/frame_gen_target_rate_90 + @string/frame_gen_target_rate_120 + @string/frame_gen_target_rate_144 + @string/frame_gen_target_rate_165 + + + + 0 + 60 + 90 + 120 + 144 + 165 + + @string/frame_gen_queue_target_0 @string/frame_gen_queue_target_1 diff --git a/src/android/app/src/main/res/values/strings.xml b/src/android/app/src/main/res/values/strings.xml index 6d2f2af75f..596fc012b9 100644 --- a/src/android/app/src/main/res/values/strings.xml +++ b/src/android/app/src/main/res/values/strings.xml @@ -306,6 +306,14 @@ 2x 3x 4x + Target frame rate + Pick the rate your display can actually show. The multiplier then rises or falls on its own to hold it, and rolls back any step that makes the game itself run slower. + Off (use a fixed multiplier) + 60 FPS + 90 FPS + 120 FPS + 144 FPS + 165 FPS Frame queue target How many finished frames may wait ahead of the display. Larger queues absorb GPU spikes at the cost of input latency. Unbuffered (lowest latency) diff --git a/src/common/settings.cpp b/src/common/settings.cpp index 1f747c44b1..6cc976fe51 100644 --- a/src/common/settings.cpp +++ b/src/common/settings.cpp @@ -392,6 +392,16 @@ size_t FrameGenGenerations() { return FrameGenMultiplier() - 1; } +size_t FrameGenMaxGenerations() { + if (!values.frame_gen.GetValue()) { + return 0; + } + if (values.frame_gen_target_rate.GetValue() != 0) { + return MAX_FRAME_GEN_MULTIPLIER - 1; + } + return FrameGenMultiplier() - 1; +} + void RestoreGlobalState(bool is_powered_on) { // If a game is running, DO NOT restore the global settings state if (is_powered_on) { diff --git a/src/common/settings.h b/src/common/settings.h index 730dbc0e02..7ac4b11173 100644 --- a/src/common/settings.h +++ b/src/common/settings.h @@ -402,6 +402,17 @@ struct Values { false, &frame_gen}; + SwitchableSetting frame_gen_target_rate{linkage, + 0, + 0, + 240, + "frame_gen_target_rate", + Category::Renderer, + Specialization::Countable, + true, + true, + &frame_gen}; + SwitchableSetting frame_gen_flow_scale_auto{linkage, true, "frame_gen_flow_scale_auto", @@ -934,6 +945,8 @@ constexpr u32 MAX_FRAME_GEN_MULTIPLIER = 4; [[nodiscard]] size_t FrameGenGenerations(); +[[nodiscard]] size_t FrameGenMaxGenerations(); + bool getDebugKnobAt(u8 i); void UpdateGPUAccuracy(); diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt index f20f58e638..10afffb743 100644 --- a/src/video_core/CMakeLists.txt +++ b/src/video_core/CMakeLists.txt @@ -127,6 +127,8 @@ add_library(video_core STATIC renderer_vulkan/present/filters.h renderer_vulkan/present/frame_gen.cpp renderer_vulkan/present/frame_gen.h + renderer_vulkan/present/frame_gen_pacer.cpp + renderer_vulkan/present/frame_gen_pacer.h renderer_vulkan/present/lsfg_alpha.cpp renderer_vulkan/present/lsfg_alpha.h renderer_vulkan/present/lsfg_beta.cpp diff --git a/src/video_core/renderer_vulkan/present/frame_gen.cpp b/src/video_core/renderer_vulkan/present/frame_gen.cpp index ab1f6c50d4..b0d16819e5 100644 --- a/src/video_core/renderer_vulkan/present/frame_gen.cpp +++ b/src/video_core/renderer_vulkan/present/frame_gen.cpp @@ -21,6 +21,7 @@ namespace { constexpr size_t COLOR_CHANNELS = 4; constexpr u64 LSFG_REQUIRED_FRAMES = 2; +constexpr u32 LSFG_RECURRENCE_FRAMES = 2; [[nodiscard]] f32 ManualFlowScale() { return static_cast(Settings::values.frame_gen_flow_scale.GetValue()) / 100.0f; @@ -43,10 +44,6 @@ constexpr u64 LSFG_REQUIRED_FRAMES = 2; return std::clamp(stepped, 0.25f, 1.0f); } -[[nodiscard]] size_t ConfiguredGenerations() { - return Settings::FrameGenGenerations(); -} - bool IsBlueFirst(VkFormat format) { return format == VK_FORMAT_B8G8R8A8_UNORM || format == VK_FORMAT_B8G8R8A8_SRGB; } @@ -197,15 +194,16 @@ FrameGen::FrameGen(MemoryAllocator& memory_allocator_, Scheduler& scheduler_) FrameGen::~FrameGen() = default; -void FrameGen::Process(const Device& device, Frame* frame, VkFormat format, VkExtent2D guest_extent, - bool generate) { +void FrameGen::Process(const Device& device, Frame* frame, VkFormat format, + VkExtent2D guest_extent) { generated = false; - if (unavailable || ConfiguredGenerations() == 0) { + if (unavailable || !Settings::values.frame_gen.GetValue()) { if (chain) { scheduler.Finish(); chain.reset(); } + warm_streak = 0; return; } @@ -234,12 +232,15 @@ void FrameGen::Process(const Device& device, Frame* frame, VkFormat format, VkEx const u64 count = frame_count++; last_count = count; - last_generations = ConfiguredGenerations(); - generated = generate && count + 1 >= LSFG_REQUIRED_FRAMES; + last_generations = plan.generations; + + const bool warm = plan.warm && count + 1 >= LSFG_REQUIRED_FRAMES; + warm_streak = warm ? warm_streak + 1 : 0; + generated = warm && warm_streak >= LSFG_RECURRENCE_FRAMES && plan.generations > 0; scheduler.RequestOutsideRenderPassOperationContext(); scheduler.Record([this, source = *frame->image, extent, count, - dispatch = generated](vk::CommandBuffer cmdbuf) { + dispatch = warm](vk::CommandBuffer cmdbuf) { CopyPresentedFrame(cmdbuf, source, chain->Input(count), extent); if (dispatch) { chain->DispatchShared(cmdbuf, count); @@ -255,11 +256,13 @@ void FrameGen::Process(const Device& device, Frame* frame, VkFormat format, VkEx } } -size_t FrameGen::WantedGenerations() const { +size_t FrameGen::WantedGenerations(size_t capacity) { if (unavailable) { + plan = {}; return 0; } - return ConfiguredGenerations(); + plan = pacer.Plan(capacity); + return plan.generations; } size_t FrameGen::GeneratedFrameCount() const { @@ -291,6 +294,7 @@ void FrameGen::Rebuild(const Device& device, VkExtent2D extent, VkFormat format, built_extent = extent; built_format = format; frame_count = 0; + warm_streak = 0; generated = false; } diff --git a/src/video_core/renderer_vulkan/present/frame_gen.h b/src/video_core/renderer_vulkan/present/frame_gen.h index 5f1e3e4135..19c6d04289 100644 --- a/src/video_core/renderer_vulkan/present/frame_gen.h +++ b/src/video_core/renderer_vulkan/present/frame_gen.h @@ -6,6 +6,7 @@ #include #include "common/common_types.h" +#include "video_core/renderer_vulkan/present/frame_gen_pacer.h" #include "video_core/renderer_vulkan/present/lsfg_chain.h" #include "video_core/renderer_vulkan/present/lsfg_shaders.h" #include "video_core/vulkan_common/vulkan_memory_allocator.h" @@ -21,10 +22,9 @@ public: explicit FrameGen(MemoryAllocator& memory_allocator, Scheduler& scheduler); ~FrameGen(); - void Process(const Device& device, Frame* frame, VkFormat format, VkExtent2D guest_extent, - bool generate); + void Process(const Device& device, Frame* frame, VkFormat format, VkExtent2D guest_extent); - [[nodiscard]] size_t WantedGenerations() const; + [[nodiscard]] size_t WantedGenerations(size_t capacity); [[nodiscard]] size_t GeneratedFrameCount() const; @@ -39,6 +39,8 @@ private: std::optional shaders; std::optional chain; + FrameGenPacer pacer; + FrameGenPlan plan{}; VkExtent2D peak_guest_extent{}; VkExtent2D built_extent{}; VkFormat built_format{VK_FORMAT_UNDEFINED}; @@ -46,6 +48,7 @@ private: u64 frame_count{}; u64 last_count{}; size_t last_generations{}; + u32 warm_streak{}; bool generated{}; bool unavailable{}; bool dumped{}; diff --git a/src/video_core/renderer_vulkan/present/frame_gen_pacer.cpp b/src/video_core/renderer_vulkan/present/frame_gen_pacer.cpp new file mode 100644 index 0000000000..78a8c83b5a --- /dev/null +++ b/src/video_core/renderer_vulkan/present/frame_gen_pacer.cpp @@ -0,0 +1,240 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#include +#include +#include + +#include "common/settings.h" +#include "video_core/renderer_vulkan/present/frame_gen_pacer.h" + +namespace Vulkan { + +namespace { + +using Clock = std::chrono::steady_clock; + +constexpr f32 INTERVAL_SMOOTHING = 0.25f; +constexpr f32 MINIMUM_BASE_RATE = 10.0f; +constexpr f32 BURST_CADENCE_RATIO = 3.0f; +constexpr f32 BURST_TARGET_RATIO = 2.0f; +constexpr f32 PROBE_THROUGHPUT_TOLERANCE = 0.95f; +constexpr f32 PROBE_BASE_COLLAPSE_RATIO = 0.70f; +constexpr f32 PROBE_MARGINAL_GAIN = 1.15f; +constexpr f32 TARGET_SATISFIED_RATIO = 0.95f; +constexpr f32 UNLOADED_BASE_RETENTION = 0.75f; +constexpr f32 CREDIT_EPSILON = 1.0e-4f; +constexpr u32 MAX_PROBE_FAILURES = 4; + +constexpr auto STABILIZATION_DURATION = std::chrono::seconds(1); +constexpr auto PROBE_DURATION = std::chrono::seconds(1); +constexpr auto DEFICIT_DURATION = std::chrono::seconds(1); +constexpr auto PROBE_STEP_DELAY = std::chrono::milliseconds(250); + +[[nodiscard]] Clock::duration ProbeBackoff(u32 failures) { + switch (failures) { + case 1: + return std::chrono::seconds(5); + case 2: + return std::chrono::seconds(15); + case 3: + return std::chrono::seconds(30); + default: + return std::chrono::seconds(60); + } +} + +} // Anonymous namespace + +FrameGenPlan FrameGenPacer::Plan(size_t capacity) { + const size_t ceiling = std::min(capacity, Settings::FrameGenMaxGenerations()); + if (ceiling == 0) { + Reset(); + return {}; + } + + const Clock::time_point now = Clock::now(); + const size_t previous_generations = std::exchange(issued_generations, 0); + if (!last_frame) { + last_frame = now; + return {}; + } + + const Clock::duration interval = now - *last_frame; + const f32 interval_seconds = std::chrono::duration(interval).count(); + last_frame = now; + + if (interval_seconds <= 0.0f) { + Stabilize(now); + return {}; + } + + const f32 target_rate = static_cast(Settings::values.frame_gen_target_rate.GetValue()); + + if (smoothed_interval > 0.0f) { + f32 burst_threshold = BURST_CADENCE_RATIO / smoothed_interval; + if (target_rate > 0.0f) { + burst_threshold = std::max(burst_threshold, target_rate * BURST_TARGET_RATIO); + } + if (1.0f / interval_seconds > burst_threshold) { + DeferEvaluations(interval); + output_credit = 0.0f; + return {}; + } + } + + if (interval_seconds > 1.0f / MINIMUM_BASE_RATE) { + Stabilize(now); + return {}; + } + + smoothed_interval = smoothed_interval > 0.0f + ? smoothed_interval + + (interval_seconds - smoothed_interval) * INTERVAL_SMOOTHING + : interval_seconds; + + if (previous_generations == 0) { + const f32 measured = 1.0f / smoothed_interval; + unloaded_base_rate = + unloaded_base_rate > 0.0f + ? unloaded_base_rate + (measured - unloaded_base_rate) * INTERVAL_SMOOTHING + : measured; + } + + if (stable_until) { + if (now < *stable_until) { + return {}; + } + stable_until.reset(); + } + + if (target_rate == 0.0f) { + limit = std::min(Settings::FrameGenGenerations(), ceiling); + output_credit = 0.0f; + issued_generations = limit; + return {.generations = limit, .warm = limit > 0}; + } + + UpdateLimit(now, 1.0f / smoothed_interval, target_rate, ceiling); + + const size_t allowed = std::min(limit, ceiling); + const f32 desired_outputs = smoothed_interval * target_rate; + if (allowed == 0 || desired_outputs <= 1.0f) { + output_credit = 0.0f; + return {}; + } + + output_credit += desired_outputs; + const size_t outputs = + std::max(1, static_cast(std::floor(output_credit + CREDIT_EPSILON))); + const size_t generations = std::min(outputs - 1, allowed); + + output_credit -= static_cast(generations + 1); + if (output_credit < 0.0f) { + output_credit = 0.0f; + } else if (generations == allowed && output_credit >= 1.0f) { + output_credit = std::fmod(output_credit, 1.0f); + } + + issued_generations = generations; + return {.generations = generations, .warm = true}; +} + +void FrameGenPacer::UpdateLimit(Clock::time_point now, f32 base_rate, f32 target_rate, + size_t ceiling) { + limit = std::min(limit, ceiling); + + if (probe_until) { + if (now < *probe_until) { + return; + } + probe_until.reset(); + output_credit = 0.0f; + + const f32 previous_output = + std::min(target_rate, probe_base_rate * static_cast(probe_previous_limit + 1)); + const f32 current_output = + std::min(target_rate, base_rate * static_cast(limit + 1)); + + const bool throughput_regressed = + current_output < previous_output * PROBE_THROUGHPUT_TOLERANCE; + const bool collapsed_for_marginal_gain = + base_rate < probe_base_rate * PROBE_BASE_COLLAPSE_RATIO && + current_output < previous_output * PROBE_MARGINAL_GAIN; + const bool emulation_slowed = unloaded_base_rate > 0.0f && + base_rate < unloaded_base_rate * UNLOADED_BASE_RETENTION; + + if (throughput_regressed || collapsed_for_marginal_gain || emulation_slowed) { + limit = probe_previous_limit; + probe_failures = std::min(probe_failures + 1, MAX_PROBE_FAILURES); + next_probe = now + ProbeBackoff(probe_failures); + deficit_since.reset(); + return; + } + + probe_failures = 0; + next_probe = now + PROBE_STEP_DELAY; + } + + if (base_rate * static_cast(limit + 1) >= target_rate * TARGET_SATISFIED_RATIO || + limit >= ceiling) { + deficit_since.reset(); + return; + } + + if (!deficit_since) { + deficit_since = now; + return; + } + if (now - *deficit_since < DEFICIT_DURATION) { + return; + } + if (next_probe && now < *next_probe) { + return; + } + + probe_previous_limit = limit; + probe_base_rate = base_rate; + ++limit; + probe_until = now + PROBE_DURATION; + deficit_since.reset(); + output_credit = 0.0f; +} + +void FrameGenPacer::DeferEvaluations(Clock::duration amount) { + const auto defer = [amount](std::optional& deadline) { + if (deadline) { + *deadline += amount; + } + }; + defer(stable_until); + defer(probe_until); + defer(next_probe); + deficit_since.reset(); +} + +void FrameGenPacer::Stabilize(Clock::time_point now) { + stable_until = now + STABILIZATION_DURATION; + probe_until.reset(); + deficit_since.reset(); + smoothed_interval = 0.0f; + output_credit = 0.0f; +} + +void FrameGenPacer::Reset() { + last_frame.reset(); + stable_until.reset(); + probe_until.reset(); + next_probe.reset(); + deficit_since.reset(); + smoothed_interval = 0.0f; + output_credit = 0.0f; + probe_base_rate = 0.0f; + unloaded_base_rate = 0.0f; + issued_generations = 0; + probe_previous_limit = 0; + limit = 0; + probe_failures = 0; +} + +} // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/present/frame_gen_pacer.h b/src/video_core/renderer_vulkan/present/frame_gen_pacer.h new file mode 100644 index 0000000000..7f4b23920c --- /dev/null +++ b/src/video_core/renderer_vulkan/present/frame_gen_pacer.h @@ -0,0 +1,46 @@ +// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project +// SPDX-License-Identifier: GPL-3.0-or-later + +#pragma once + +#include +#include + +#include "common/common_types.h" + +namespace Vulkan { + +struct FrameGenPlan { + size_t generations{}; + bool warm{}; +}; + +class FrameGenPacer { +public: + [[nodiscard]] FrameGenPlan Plan(size_t capacity); + + void Reset(); + +private: + using Clock = std::chrono::steady_clock; + + void Stabilize(Clock::time_point now); + void DeferEvaluations(Clock::duration amount); + void UpdateLimit(Clock::time_point now, f32 base_rate, f32 target_rate, size_t ceiling); + + std::optional last_frame; + std::optional stable_until; + std::optional probe_until; + std::optional next_probe; + std::optional deficit_since; + f32 smoothed_interval{}; + f32 output_credit{}; + f32 probe_base_rate{}; + f32 unloaded_base_rate{}; + size_t issued_generations{}; + size_t probe_previous_limit{}; + size_t limit{}; + u32 probe_failures{}; +}; + +} // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp index cc0056043b..411a9c5fe2 100644 --- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp +++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp @@ -208,11 +208,9 @@ void RendererVulkan::Composite(std::span framebu render_window.GetFramebufferLayout(), swapchain.GetImageCount(), swapchain.GetImageViewFormat()); - const size_t wanted = frame_gen.WantedGenerations(); - const bool can_present_all = wanted > 0 && present_manager.AvailableExtraFrames() >= wanted; + void(frame_gen.WantedGenerations(present_manager.MaxExtraFrames())); - frame_gen.Process(device, frame, swapchain.GetImageFormat(), GuestExtent(framebuffers), - can_present_all); + frame_gen.Process(device, frame, swapchain.GetImageFormat(), GuestExtent(framebuffers)); const size_t generated_frames = frame_gen.GeneratedFrameCount(); for (size_t generation = 0; generation < generated_frames; ++generation) { diff --git a/src/video_core/renderer_vulkan/vk_present_manager.cpp b/src/video_core/renderer_vulkan/vk_present_manager.cpp index 8924241562..580d35e6d4 100644 --- a/src/video_core/renderer_vulkan/vk_present_manager.cpp +++ b/src/video_core/renderer_vulkan/vk_present_manager.cpp @@ -193,9 +193,8 @@ void PresentManager::Present(Frame* frame) { } } -size_t PresentManager::AvailableExtraFrames() { - std::scoped_lock lock{free_mutex}; - return free_queue.size(); +size_t PresentManager::MaxExtraFrames() const { + return image_count - 1; } void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat image_view_format, @@ -351,7 +350,7 @@ void PresentManager::SetImageCount() { // We cannot have more than 7 images in flight at any given time. // FRAMES_IN_FLIGHT is 8, and the cache TICKS_TO_DESTROY is 8. // Mali drivers will give us 6. - const size_t generations = Settings::FrameGenGenerations(); + const size_t generations = Settings::FrameGenMaxGenerations(); const size_t queued_composites = Settings::values.frame_gen_queue_target.GetValue() + 1; image_count = std::clamp((generations + 1) * queued_composites, swapchain.GetImageCount(), diff --git a/src/video_core/renderer_vulkan/vk_present_manager.h b/src/video_core/renderer_vulkan/vk_present_manager.h index 25e3e12b6e..577a82098a 100644 --- a/src/video_core/renderer_vulkan/vk_present_manager.h +++ b/src/video_core/renderer_vulkan/vk_present_manager.h @@ -63,7 +63,7 @@ public: void WaitPresent(); /// How many additional frames can be queued without stalling the render thread - size_t AvailableExtraFrames(); + [[nodiscard]] size_t MaxExtraFrames() const; private: void PresentThread(std::stop_token token);