1 files changed, 43 insertions, 144 deletions

diff --git a/src/yuzu/configuration/configure_graphics_advanced.cpp b/src/yuzu/configuration/configure_graphics_advanced.cpp
index c0a044767..4db18673d 100644
--- a/src/yuzu/configuration/configure_graphics_advanced.cpp
+++ b/src/yuzu/configuration/configure_graphics_advanced.cpp
@@ -1,104 +1,68 @@
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <vector>
+#include <QLabel>
+#include <qnamespace.h>
 #include "common/settings.h"
 #include "core/core.h"
 #include "ui_configure_graphics_advanced.h"
 #include "yuzu/configuration/configuration_shared.h"
 #include "yuzu/configuration/configure_graphics_advanced.h"
+#include "yuzu/configuration/shared_translation.h"
+#include "yuzu/configuration/shared_widget.h"
 
-ConfigureGraphicsAdvanced::ConfigureGraphicsAdvanced(const Core::System& system_, QWidget* parent)
-    : QWidget(parent), ui{std::make_unique<Ui::ConfigureGraphicsAdvanced>()}, system{system_} {
+ConfigureGraphicsAdvanced::ConfigureGraphicsAdvanced(
+    const Core::System& system_, std::shared_ptr<std::vector<ConfigurationShared::Tab*>> group_,
+    const ConfigurationShared::Builder& builder, QWidget* parent)
+    : Tab(group_, parent), ui{std::make_unique<Ui::ConfigureGraphicsAdvanced>()}, system{system_} {
 
     ui->setupUi(this);
 
-    SetupPerGameUI();
+    Setup(builder);
 
     SetConfiguration();
 
-    ui->enable_compute_pipelines_checkbox->setVisible(false);
+    checkbox_enable_compute_pipelines->setVisible(false);
 }
 
 ConfigureGraphicsAdvanced::~ConfigureGraphicsAdvanced() = default;
 
-void ConfigureGraphicsAdvanced::SetConfiguration() {
-    const bool runtime_lock = !system.IsPoweredOn();
-    ui->use_reactive_flushing->setEnabled(runtime_lock);
-    ui->async_present->setEnabled(runtime_lock);
-    ui->renderer_force_max_clock->setEnabled(runtime_lock);
-    ui->async_astc->setEnabled(runtime_lock);
-    ui->astc_recompression_combobox->setEnabled(runtime_lock);
-    ui->use_asynchronous_shaders->setEnabled(runtime_lock);
-    ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
-    ui->enable_compute_pipelines_checkbox->setEnabled(runtime_lock);
-
-    ui->async_present->setChecked(Settings::values.async_presentation.GetValue());
-    ui->renderer_force_max_clock->setChecked(Settings::values.renderer_force_max_clock.GetValue());
-    ui->use_reactive_flushing->setChecked(Settings::values.use_reactive_flushing.GetValue());
-    ui->async_astc->setChecked(Settings::values.async_astc.GetValue());
-    ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());
-    ui->use_fast_gpu_time->setChecked(Settings::values.use_fast_gpu_time.GetValue());
-    ui->use_vulkan_driver_pipeline_cache->setChecked(
-        Settings::values.use_vulkan_driver_pipeline_cache.GetValue());
-    ui->enable_compute_pipelines_checkbox->setChecked(
-        Settings::values.enable_compute_pipelines.GetValue());
-    ui->use_video_framerate_checkbox->setChecked(Settings::values.use_video_framerate.GetValue());
-    ui->barrier_feedback_loops_checkbox->setChecked(
-        Settings::values.barrier_feedback_loops.GetValue());
-
-    if (Settings::IsConfiguringGlobal()) {
-        ui->gpu_accuracy->setCurrentIndex(
-            static_cast<int>(Settings::values.gpu_accuracy.GetValue()));
-        ui->anisotropic_filtering_combobox->setCurrentIndex(
-            Settings::values.max_anisotropy.GetValue());
-        ui->astc_recompression_combobox->setCurrentIndex(
-            static_cast<int>(Settings::values.astc_recompression.GetValue()));
-    } else {
-        ConfigurationShared::SetPerGameSetting(ui->gpu_accuracy, &Settings::values.gpu_accuracy);
-        ConfigurationShared::SetPerGameSetting(ui->anisotropic_filtering_combobox,
-                                               &Settings::values.max_anisotropy);
-        ConfigurationShared::SetPerGameSetting(ui->astc_recompression_combobox,
-                                               &Settings::values.astc_recompression);
-        ConfigurationShared::SetHighlight(ui->label_gpu_accuracy,
-                                          !Settings::values.gpu_accuracy.UsingGlobal());
-        ConfigurationShared::SetHighlight(ui->af_label,
-                                          !Settings::values.max_anisotropy.UsingGlobal());
-        ConfigurationShared::SetHighlight(ui->label_astc_recompression,
-                                          !Settings::values.astc_recompression.UsingGlobal());
+void ConfigureGraphicsAdvanced::SetConfiguration() {}
+
+void ConfigureGraphicsAdvanced::Setup(const ConfigurationShared::Builder& builder) {
+    auto& layout = *ui->populate_target->layout();
+    std::map<u32, QWidget*> hold{}; // A map will sort the data for us
+
+    for (auto setting :
+         Settings::values.linkage.by_category[Settings::Category::RendererAdvanced]) {
+        ConfigurationShared::Widget* widget = builder.BuildWidget(setting, apply_funcs);
+
+        if (widget == nullptr) {
+            continue;
+        }
+        if (!widget->Valid()) {
+            widget->deleteLater();
+            continue;
+        }
+
+        hold.emplace(setting->Id(), widget);
+
+        // Keep track of enable_compute_pipelines so we can display it when needed
+        if (setting->Id() == Settings::values.enable_compute_pipelines.Id()) {
+            checkbox_enable_compute_pipelines = widget;
+        }
+    }
+    for (const auto& [id, widget] : hold) {
+        layout.addWidget(widget);
     }
 }
 
 void ConfigureGraphicsAdvanced::ApplyConfiguration() {
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.gpu_accuracy, ui->gpu_accuracy);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.async_presentation,
-                                             ui->async_present, async_present);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.renderer_force_max_clock,
-                                             ui->renderer_force_max_clock,
-                                             renderer_force_max_clock);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
-                                             ui->anisotropic_filtering_combobox);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_reactive_flushing,
-                                             ui->use_reactive_flushing, use_reactive_flushing);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.async_astc, ui->async_astc,
-                                             async_astc);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.astc_recompression,
-                                             ui->astc_recompression_combobox);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders,
-                                             ui->use_asynchronous_shaders,
-                                             use_asynchronous_shaders);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_fast_gpu_time,
-                                             ui->use_fast_gpu_time, use_fast_gpu_time);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vulkan_driver_pipeline_cache,
-                                             ui->use_vulkan_driver_pipeline_cache,
-                                             use_vulkan_driver_pipeline_cache);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.enable_compute_pipelines,
-                                             ui->enable_compute_pipelines_checkbox,
-                                             enable_compute_pipelines);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_video_framerate,
-                                             ui->use_video_framerate_checkbox, use_video_framerate);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.barrier_feedback_loops,
-                                             ui->barrier_feedback_loops_checkbox,
-                                             barrier_feedback_loops);
+    const bool is_powered_on = system.IsPoweredOn();
+    for (const auto& func : apply_funcs) {
+        func(is_powered_on);
+    }
 }
 
 void ConfigureGraphicsAdvanced::changeEvent(QEvent* event) {
@@ -113,71 +77,6 @@ void ConfigureGraphicsAdvanced::RetranslateUI() {
     ui->retranslateUi(this);
 }
 
-void ConfigureGraphicsAdvanced::SetupPerGameUI() {
-    // Disable if not global (only happens during game)
-    if (Settings::IsConfiguringGlobal()) {
-        ui->gpu_accuracy->setEnabled(Settings::values.gpu_accuracy.UsingGlobal());
-        ui->async_present->setEnabled(Settings::values.async_presentation.UsingGlobal());
-        ui->renderer_force_max_clock->setEnabled(
-            Settings::values.renderer_force_max_clock.UsingGlobal());
-        ui->use_reactive_flushing->setEnabled(Settings::values.use_reactive_flushing.UsingGlobal());
-        ui->async_astc->setEnabled(Settings::values.async_astc.UsingGlobal());
-        ui->astc_recompression_combobox->setEnabled(
-            Settings::values.astc_recompression.UsingGlobal());
-        ui->use_asynchronous_shaders->setEnabled(
-            Settings::values.use_asynchronous_shaders.UsingGlobal());
-        ui->use_fast_gpu_time->setEnabled(Settings::values.use_fast_gpu_time.UsingGlobal());
-        ui->use_vulkan_driver_pipeline_cache->setEnabled(
-            Settings::values.use_vulkan_driver_pipeline_cache.UsingGlobal());
-        ui->anisotropic_filtering_combobox->setEnabled(
-            Settings::values.max_anisotropy.UsingGlobal());
-        ui->enable_compute_pipelines_checkbox->setEnabled(
-            Settings::values.enable_compute_pipelines.UsingGlobal());
-        ui->use_video_framerate_checkbox->setEnabled(
-            Settings::values.use_video_framerate.UsingGlobal());
-        ui->barrier_feedback_loops_checkbox->setEnabled(
-            Settings::values.barrier_feedback_loops.UsingGlobal());
-
-        return;
-    }
-
-    ConfigurationShared::SetColoredTristate(ui->async_present, Settings::values.async_presentation,
-                                            async_present);
-    ConfigurationShared::SetColoredTristate(ui->renderer_force_max_clock,
-                                            Settings::values.renderer_force_max_clock,
-                                            renderer_force_max_clock);
-    ConfigurationShared::SetColoredTristate(
-        ui->use_reactive_flushing, Settings::values.use_reactive_flushing, use_reactive_flushing);
-    ConfigurationShared::SetColoredTristate(ui->async_astc, Settings::values.async_astc,
-                                            async_astc);
-    ConfigurationShared::SetColoredTristate(ui->use_asynchronous_shaders,
-                                            Settings::values.use_asynchronous_shaders,
-                                            use_asynchronous_shaders);
-    ConfigurationShared::SetColoredTristate(ui->use_fast_gpu_time,
-                                            Settings::values.use_fast_gpu_time, use_fast_gpu_time);
-    ConfigurationShared::SetColoredTristate(ui->use_vulkan_driver_pipeline_cache,
-                                            Settings::values.use_vulkan_driver_pipeline_cache,
-                                            use_vulkan_driver_pipeline_cache);
-    ConfigurationShared::SetColoredTristate(ui->enable_compute_pipelines_checkbox,
-                                            Settings::values.enable_compute_pipelines,
-                                            enable_compute_pipelines);
-    ConfigurationShared::SetColoredTristate(ui->use_video_framerate_checkbox,
-                                            Settings::values.use_video_framerate,
-                                            use_video_framerate);
-    ConfigurationShared::SetColoredTristate(ui->barrier_feedback_loops_checkbox,
-                                            Settings::values.barrier_feedback_loops,
-                                            barrier_feedback_loops);
-    ConfigurationShared::SetColoredComboBox(
-        ui->gpu_accuracy, ui->label_gpu_accuracy,
-        static_cast<int>(Settings::values.gpu_accuracy.GetValue(true)));
-    ConfigurationShared::SetColoredComboBox(
-        ui->anisotropic_filtering_combobox, ui->af_label,
-        static_cast<int>(Settings::values.max_anisotropy.GetValue(true)));
-    ConfigurationShared::SetColoredComboBox(
-        ui->astc_recompression_combobox, ui->label_astc_recompression,
-        static_cast<int>(Settings::values.astc_recompression.GetValue(true)));
-}
-
 void ConfigureGraphicsAdvanced::ExposeComputeOption() {
-    ui->enable_compute_pipelines_checkbox->setVisible(true);
+    checkbox_enable_compute_pipelines->setVisible(true);
 }