Replace old GPU accuracy modes with new ones

src/common/settings.cpp

@@ -149,13 +149,16 @@ void UpdateGPUAccuracy() {
     values.current_gpu_accuracy = values.gpu_accuracy.GetValue();
 }
 
-bool IsGPULevelExtreme() {
-    return values.current_gpu_accuracy == GpuAccuracy::Extreme;
+bool IsGPULevelLow() {
+    return values.current_gpu_accuracy == GpuAccuracy::Low;
+}
+
+bool IsGPULevelMedium() {
+    return values.current_gpu_accuracy == GpuAccuracy::Medium;
 }
 
 bool IsGPULevelHigh() {
-    return values.current_gpu_accuracy == GpuAccuracy::Extreme ||
-           values.current_gpu_accuracy == GpuAccuracy::High;
+    return values.current_gpu_accuracy == GpuAccuracy::High;
 }
 
 bool IsDMALevelDefault() {

src/common/settings.h

@@ -419,9 +419,9 @@ struct Values {
 
     SwitchableSetting<GpuAccuracy, true> gpu_accuracy{linkage,
 #ifdef ANDROID
-                                                      GpuAccuracy::Normal,
+                                                      GpuAccuracy::Low,
 #else
-                                                      GpuAccuracy::High,
+                                                      GpuAccuracy::Medium,
 #endif
                                                       "gpu_accuracy",
                                                       Category::RendererAdvanced,
@@ -429,7 +429,7 @@ struct Values {
                                                       true,
                                                       true};
 
-    GpuAccuracy current_gpu_accuracy{GpuAccuracy::High};
+    GpuAccuracy current_gpu_accuracy{GpuAccuracy::Medium};
 
     SwitchableSetting<DmaAccuracy, true> dma_accuracy{linkage,
                                                       DmaAccuracy::Default,
@@ -774,7 +774,8 @@ extern Values values;
 bool getDebugKnobAt(u8 i);
 
 void UpdateGPUAccuracy();
-bool IsGPULevelExtreme();
+bool IsGPULevelLow();
+bool IsGPULevelMedium();
 bool IsGPULevelHigh();
 
 bool IsDMALevelDefault();

src/common/settings_enums.h

@@ -133,7 +133,7 @@ ENUM(VSyncMode, Immediate, Mailbox, Fifo, FifoRelaxed);
 ENUM(VramUsageMode, Conservative, Aggressive);
 ENUM(RendererBackend, OpenGL, Vulkan, Null);
 ENUM(ShaderBackend, Glsl, Glasm, SpirV);
-ENUM(GpuAccuracy, Normal, High, Extreme);
+ENUM(GpuAccuracy, Low, Medium, High);
 ENUM(DmaAccuracy, Default, Unsafe, Safe);
 ENUM(CpuBackend, Dynarmic, Nce);
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid, Debugging);

src/qt_common/config/shared_translation.cpp

@@ -507,9 +507,9 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent)
          }});
     translations->insert({Settings::EnumMetadata<Settings::GpuAccuracy>::Index(),
                           {
-                              PAIR(GpuAccuracy, Normal, tr("Normal")),
+                              PAIR(GpuAccuracy, Low, tr("Low")),
+                              PAIR(GpuAccuracy, Medium, tr("Medium")),
                               PAIR(GpuAccuracy, High, tr("High")),
-                              PAIR(GpuAccuracy, Extreme, tr("Extreme")),
                           }});
     translations->insert({Settings::EnumMetadata<Settings::DmaAccuracy>::Index(),
                           {

src/qt_common/config/shared_translation.h

@@ -61,9 +61,9 @@ static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map
 };
 
 static const std::map<Settings::GpuAccuracy, QString> gpu_accuracy_texts_map = {
-    {Settings::GpuAccuracy::Normal, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Normal"))},
+    {Settings::GpuAccuracy::Low, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Low"))},
+    {Settings::GpuAccuracy::Medium, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Medium"))},
     {Settings::GpuAccuracy::High, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "High"))},
-    {Settings::GpuAccuracy::Extreme, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Extreme"))},
 };
 
 static const std::map<Settings::RendererBackend, QString> renderer_backend_texts_map = {

src/video_core/dma_pusher.cpp

@@ -103,7 +103,7 @@ bool DmaPusher::Step() {
             ProcessCommands(headers);
         };
 
-        const bool use_safe = Settings::IsDMALevelDefault() ? Settings::IsGPULevelHigh() : Settings::IsDMALevelSafe();
+        const bool use_safe = Settings::IsDMALevelDefault() ? (Settings::IsGPULevelMedium() || Settings::IsGPULevelHigh()) : Settings::IsDMALevelSafe();
 
         if (use_safe) {
             safe_process();

src/video_core/engines/maxwell_3d.cpp

@@ -224,7 +224,7 @@ void Maxwell3D::ProcessMacro(u32 method, const u32* base_start, u32 amount, bool
 }
 
 void Maxwell3D::RefreshParametersImpl() {
-    if (!Settings::IsGPULevelHigh()) {
+    if (!Settings::IsGPULevelMedium() && !Settings::IsGPULevelHigh()) {
         return;
     }
     size_t current_index = 0;

src/video_core/fence_manager.h

@@ -72,7 +72,6 @@ public:
     }
 
     void SignalFence(std::function<void()>&& func) {
-        bool delay_fence = Settings::IsGPULevelHigh();
         if constexpr (!can_async_check) {
             TryReleasePendingFences<false>();
         }
@@ -82,7 +81,7 @@ public:
         if constexpr (can_async_check) {
             guard.lock();
         }
-        if (!delay_fence && !should_flush) {
+        if (Settings::IsGPULevelLow() || (Settings::IsGPULevelMedium() && !should_flush)) {
             func();
         } else {
             uncommitted_operations.emplace_back(std::move(func));

src/video_core/gpu_thread.cpp

@@ -79,15 +79,8 @@ void ThreadManager::FlushRegion(DAddr addr, u64 size) {
     if (!is_async) {
         // Always flush with synchronous GPU mode
         PushCommand(FlushRegionCommand(addr, size));
-        return;
     }
-    if (!Settings::IsGPULevelExtreme()) {
-        return;
-    }
-    auto& gpu = system.GPU();
-    u64 fence = gpu.RequestFlush(addr, size);
-    TickGPU();
-    gpu.WaitForSyncOperation(fence);
+    return;
 }
 
 void ThreadManager::TickGPU() {

src/video_core/query_cache/query_cache.h

@@ -260,7 +260,7 @@ void QueryCacheBase<Traits>::CounterReport(GPUVAddr addr, QueryType counter_type
     };
     u8* pointer = impl->device_memory.template GetPointer<u8>(cpu_addr);
     u8* pointer_timestamp = impl->device_memory.template GetPointer<u8>(cpu_addr + 8);
-    bool is_synced = !Settings::IsGPULevelHigh() && is_fence;
+    bool is_synced = (!Settings::IsGPULevelMedium() && !Settings::IsGPULevelHigh()) && is_fence;
     std::function<void()> operation([this, is_synced, streamer, query_base = query, query_location,
                                      pointer, pointer_timestamp] {
         if (True(query_base->flags & QueryFlagBits::IsInvalidated)) {
@@ -294,7 +294,7 @@ void QueryCacheBase<Traits>::CounterReport(GPUVAddr addr, QueryType counter_type
     if (is_fence) {
         impl->rasterizer.SignalFence(std::move(operation));
     } else {
-        if (!Settings::IsGPULevelHigh() && counter_type == QueryType::Payload) {
+        if ((!Settings::IsGPULevelMedium() && !Settings::IsGPULevelHigh()) && counter_type == QueryType::Payload) {
             if (has_timestamp) {
                 u64 timestamp = impl->gpu.GetTicks();
                 u64 value = static_cast<u64>(payload);

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -500,7 +500,7 @@ bool RasterizerOpenGL::MustFlushRegion(DAddr addr, u64 size, VideoCommon::CacheT
             return true;
         }
     }
-    if (!Settings::IsGPULevelHigh()) {
+    if (!Settings::IsGPULevelMedium() && !Settings::IsGPULevelHigh()) {
         return false;
     }
     if (True(which & VideoCommon::CacheType::TextureCache)) {
@@ -629,9 +629,6 @@ void RasterizerOpenGL::ReleaseFences(bool force) {
 
 void RasterizerOpenGL::FlushAndInvalidateRegion(DAddr addr, u64 size,
                                                 VideoCommon::CacheType which) {
-    if (Settings::IsGPULevelExtreme()) {
-        FlushRegion(addr, size, which);
-    }
     InvalidateRegion(addr, size, which);
 }
 
@@ -682,7 +679,7 @@ void RasterizerOpenGL::TickFrame() {
 
 bool RasterizerOpenGL::AccelerateConditionalRendering() {
     gpu_memory->FlushCaching();
-    if (Settings::IsGPULevelHigh()) {
+    if (Settings::IsGPULevelMedium() || Settings::IsGPULevelHigh()) {
         // Reimplement Host conditional rendering.
         return false;
     }

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -1415,14 +1415,10 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValues(VideoCommon::Looku
         return false;
     }
 
-    const bool is_gpu_high = Settings::IsGPULevelHigh();
-    if (!is_gpu_high && impl->device.GetDriverID() == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
-        return true;
-    }
-
     auto driver_id = impl->device.GetDriverID();
-    if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-        driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+    const bool is_gpu_medium_or_high = (Settings::IsGPULevelMedium() || Settings::IsGPULevelHigh());
+
+    if ((!is_gpu_medium_or_high && driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) || driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY || driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
         return true;
     }
 
@@ -1438,12 +1434,11 @@ bool QueryCacheRuntime::HostConditionalRenderingCompareValues(VideoCommon::Looku
         }
     }
 
-    if (!is_gpu_high) {
+    if (!is_gpu_medium_or_high) {
         return true;
     }
 
     if (!is_in_bc[0] && !is_in_bc[1]) {
-        // Both queries are in query cache, it's best to just flush.
         return true;
     }
     HostConditionalRenderingCompareBCImpl(object_1.address, equal_check);

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -586,7 +586,7 @@ bool RasterizerVulkan::MustFlushRegion(DAddr addr, u64 size, VideoCommon::CacheT
             return true;
         }
     }
-    if (!Settings::IsGPULevelHigh()) {
+    if (!Settings::IsGPULevelMedium() && !Settings::IsGPULevelHigh()) {
         return false;
     }
     if (True(which & VideoCommon::CacheType::TextureCache)) {
@@ -730,9 +730,6 @@ void RasterizerVulkan::ReleaseFences(bool force) {
 
 void RasterizerVulkan::FlushAndInvalidateRegion(DAddr addr, u64 size,
                                                 VideoCommon::CacheType which) {
-    if (Settings::IsGPULevelExtreme()) {
-        FlushRegion(addr, size, which);
-    }
     InvalidateRegion(addr, size, which);
 }
 

src/yuzu/main_window.cpp

@@ -1271,9 +1271,6 @@ void MainWindow::InitializeWidgets() {
                 QMenu context_menu;
 
                 for (auto const& gpu_accuracy_pair : ConfigurationShared::gpu_accuracy_texts_map) {
-                    if (gpu_accuracy_pair.first == Settings::GpuAccuracy::Extreme) {
-                        continue;
-                    }
                     context_menu.addAction(gpu_accuracy_pair.second, [this, gpu_accuracy_pair] {
                         Settings::values.gpu_accuracy.SetValue(gpu_accuracy_pair.first);
                         UpdateGPUAccuracyButton();
@@ -3580,16 +3577,15 @@ void MainWindow::OnToggleDockedMode() {
 
 void MainWindow::OnToggleGpuAccuracy() {
     switch (Settings::values.gpu_accuracy.GetValue()) {
-    case Settings::GpuAccuracy::High: {
-        Settings::values.gpu_accuracy.SetValue(Settings::GpuAccuracy::Normal);
+    case Settings::GpuAccuracy::Low:
+        Settings::values.gpu_accuracy.SetValue(Settings::GpuAccuracy::Medium);
         break;
-    }
-    case Settings::GpuAccuracy::Normal:
-    case Settings::GpuAccuracy::Extreme:
-    default: {
+    case Settings::GpuAccuracy::Medium:
         Settings::values.gpu_accuracy.SetValue(Settings::GpuAccuracy::High);
         break;
-    }
+    case Settings::GpuAccuracy::High:
+        Settings::values.gpu_accuracy.SetValue(Settings::GpuAccuracy::Low);
+        break;
     }
 
     QtCommon::system->ApplySettings();
@@ -4277,7 +4273,7 @@ void MainWindow::UpdateGPUAccuracyButton() {
     const auto gpu_accuracy_text =
         ConfigurationShared::gpu_accuracy_texts_map.find(gpu_accuracy)->second;
     gpu_accuracy_button->setText(gpu_accuracy_text.toUpper());
-    gpu_accuracy_button->setChecked(gpu_accuracy != Settings::GpuAccuracy::Normal);
+    gpu_accuracy_button->setChecked(gpu_accuracy != Settings::GpuAccuracy::Low);
 }
 
 void MainWindow::UpdateDockedButton() {