eden-emu
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Releases Wiki Activity
Browse Source

configure_graphics: More complete reimplementation

nce_cpp
lat9nq 3 years ago
parent
cc4dbb8c8c
commit
bb015feefd
4 changed files with 116 additions and 348 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 107
      src/yuzu/configuration/configuration_shared.cpp
  2. 3
      src/yuzu/configuration/configuration_shared.h
  3. 350
      src/yuzu/configuration/configure_graphics.cpp
  4. 4
      src/yuzu/configuration/configure_graphics.h

107
src/yuzu/configuration/configuration_shared.cpp
View File

@ -9,6 +9,7 @@
#include <QObject>
#include <QString>
#include <QWidget>
#include <qcheckbox.h>
#include <qnamespace.h>
#include "common/settings.h"
#include "yuzu/configuration/configuration_shared.h"
@ -57,7 +58,7 @@ static std::pair<QWidget*, std::function<void()>> CreateCheckBox(Settings::Basic
}
static std::tuple<QWidget*, void*, std::function<void()>> CreateCombobox(
Settings::BasicSetting* setting, const QString& label, QWidget* parent) {
Settings::BasicSetting* setting, const QString& label, QWidget* parent, bool managed) {
const auto type = setting->TypeId();
QWidget* group = new QWidget(parent);
@ -78,7 +79,7 @@ static std::tuple<QWidget*, void*, std::function<void()>> CreateCombobox(
combobox_layout->setSpacing(6);
combobox_layout->setContentsMargins(0, 0, 0, 0);
if (setting->Switchable() && !Settings::IsConfiguringGlobal()) {
if (setting->Switchable() && !Settings::IsConfiguringGlobal() && managed) {
int current = std::stoi(setting->ToString());
int global_value = std::stoi(setting->ToStringGlobal());
SetColoredComboBox(combobox, group, global_value);
@ -92,23 +93,26 @@ static std::tuple<QWidget*, void*, std::function<void()>> CreateCombobox(
combobox->setCurrentIndex(std::stoi(setting->ToString()));
}
const auto load_func = [combobox, setting]() {
if (Settings::IsConfiguringGlobal()) {
setting->LoadString(std::to_string(combobox->currentIndex()));
}
if (Settings::IsConfiguringGlobal() || !setting->Switchable()) {
return;
}
bool using_global = combobox->currentIndex() == USE_GLOBAL_INDEX;
int index = combobox->currentIndex() - USE_GLOBAL_OFFSET;
setting->SetGlobal(using_global);
if (!using_global) {
setting->LoadString(std::to_string(index));
}
};
std::function<void()> load_func = []() {};
if (managed) {
load_func = [combobox, setting]() {
if (Settings::IsConfiguringGlobal()) {
setting->LoadString(std::to_string(combobox->currentIndex()));
}
if (Settings::IsConfiguringGlobal() || !setting->Switchable()) {
return;
}
bool using_global = combobox->currentIndex() == USE_GLOBAL_INDEX;
int index = combobox->currentIndex() - USE_GLOBAL_OFFSET;
setting->SetGlobal(using_global);
if (!using_global) {
setting->LoadString(std::to_string(index));
}
};
}
return {group, combobox, load_func};
}
@ -116,25 +120,68 @@ static std::tuple<QWidget*, void*, std::function<void()>> CreateCombobox(
static std::tuple<QWidget*, void*, std::function<void()>> CreateLineEdit(
Settings::BasicSetting* setting, const QString& label, QWidget* parent) {
QWidget* widget = new QWidget(parent);
widget->setObjectName(label);
QHBoxLayout* layout = new QHBoxLayout(widget);
QLineEdit* line_edit = new QLineEdit(parent);
const QString text = QString::fromStdString(setting->ToString());
line_edit->setText(text);
std::function<void()> load_func;
QLabel* q_label = new QLabel(label, widget);
QLineEdit* line_edit = new QLineEdit(widget);
// setSizePolicy lets widget expand and take an equal part of the space as the line edit
if (Settings::IsConfiguringGlobal()) {
QLabel* q_label = new QLabel(label, widget);
q_label->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
layout->addWidget(q_label);
load_func = [&]() {
std::string load_text = line_edit->text().toStdString();
setting->LoadString(load_text);
};
} else {
QCheckBox* checkbox = new QCheckBox(label, parent);
checkbox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
layout->addWidget(checkbox);
const auto highlight_func = [widget, line_edit](int state) {
bool using_global = state != Qt::Checked;
SetHighlight(widget, !using_global);
line_edit->setEnabled(!using_global);
};
QObject::connect(checkbox, qOverload<int>(&QCheckBox::stateChanged), widget,
highlight_func);
checkbox->setCheckState(setting->UsingGlobal() ? Qt::Unchecked : Qt::Checked);
highlight_func(checkbox->checkState());
load_func = [&]() {
if (checkbox->checkState() == Qt::Checked) {
setting->SetGlobal(false);
std::string load_text = line_edit->text().toStdString();
setting->LoadString(load_text);
} else {
setting->SetGlobal(true);
}
};
}
layout->addWidget(q_label);
layout->addStretch();
layout->addWidget(line_edit);
layout->setContentsMargins(0, 0, 0, 0);
return {widget, line_edit, []() {}};
return {widget, line_edit, load_func};
}
std::pair<QWidget*, void*> CreateWidget(Settings::BasicSetting* setting,
const TranslationMap& translations, QWidget* parent,
bool runtime_lock,
std::forward_list<std::function<void(bool)>>& apply_funcs,
std::list<CheckState>& trackers, RequestType request) {
std::list<CheckState>& trackers, RequestType request,
bool managed) {
const auto type = setting->TypeId();
const int id = setting->Id();
QWidget* widget{nullptr};
@ -162,7 +209,7 @@ std::pair<QWidget*, void*> CreateWidget(Settings::BasicSetting* setting,
widget = pair.first;
load_func = pair.second;
} else if (setting->IsEnum()) {
auto tuple = CreateCombobox(setting, label, parent);
auto tuple = CreateCombobox(setting, label, parent, managed);
widget = std::get<0>(tuple);
extra = std::get<1>(tuple);
load_func = std::get<2>(tuple);
@ -176,7 +223,7 @@ std::pair<QWidget*, void*> CreateWidget(Settings::BasicSetting* setting,
break;
}
case RequestType::ComboBox: {
auto tuple = CreateCombobox(setting, label, parent);
auto tuple = CreateCombobox(setting, label, parent, managed);
widget = std::get<0>(tuple);
extra = std::get<1>(tuple);
load_func = std::get<2>(tuple);
@ -201,9 +248,9 @@ std::pair<QWidget*, void*> CreateWidget(Settings::BasicSetting* setting,
});
bool enable = runtime_lock || setting->RuntimeModfiable();
enable &=
setting->Switchable() && !(Settings::IsConfiguringGlobal() && !setting->UsingGlobal());
enable |= !setting->Switchable() && Settings::IsConfiguringGlobal() && runtime_lock;
if (setting->Switchable() && Settings::IsConfiguringGlobal() && !runtime_lock) {
enable &= !setting->UsingGlobal();
}
widget->setEnabled(enable);
widget->setVisible(Settings::IsConfiguringGlobal() || setting->Switchable());

3
src/yuzu/configuration/configuration_shared.h
View File

@ -54,7 +54,8 @@ std::pair<QWidget*, void*> CreateWidget(Settings::BasicSetting* setting,
bool runtime_lock,
std::forward_list<std::function<void(bool)>>& apply_funcs,
std::list<CheckState>& trackers,
RequestType request = RequestType::Default);
RequestType request = RequestType::Default,
bool managed = true);
// Global-aware apply and set functions

350
src/yuzu/configuration/configure_graphics.cpp
View File

@ -55,20 +55,20 @@ static constexpr VkPresentModeKHR VSyncSettingToMode(Settings::VSyncMode mode) {
}
}
// static constexpr Settings::VSyncMode PresentModeToSetting(VkPresentModeKHR mode) {
// switch (mode) {
// case VK_PRESENT_MODE_IMMEDIATE_KHR:
// return Settings::VSyncMode::Immediate;
// case VK_PRESENT_MODE_MAILBOX_KHR:
// return Settings::VSyncMode::Mailbox;
// case VK_PRESENT_MODE_FIFO_KHR:
// return Settings::VSyncMode::FIFO;
// case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
// return Settings::VSyncMode::FIFORelaxed;
// default:
// return Settings::VSyncMode::FIFO;
// }
// }
static constexpr Settings::VSyncMode PresentModeToSetting(VkPresentModeKHR mode) {
switch (mode) {
case VK_PRESENT_MODE_IMMEDIATE_KHR:
return Settings::VSyncMode::Immediate;
case VK_PRESENT_MODE_MAILBOX_KHR:
return Settings::VSyncMode::Mailbox;
case VK_PRESENT_MODE_FIFO_KHR:
return Settings::VSyncMode::FIFO;
case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
return Settings::VSyncMode::FIFORelaxed;
default:
return Settings::VSyncMode::FIFO;
}
}
ConfigureGraphics::ConfigureGraphics(
const Core::System& system_, std::vector<VkDeviceInfo::Record>& records_,
@ -112,16 +112,9 @@ ConfigureGraphics::ConfigureGraphics(
}
}
SetupPerGameUI();
connect(api_combobox, qOverload<int>(&QComboBox::currentIndexChanged), this, [this] {
UpdateAPILayout();
PopulateVSyncModeSelection();
if (!Settings::IsConfiguringGlobal()) {
ConfigurationShared::SetHighlight(ui->api_widget,
api_combobox->currentIndex() !=
ConfigurationShared::USE_GLOBAL_INDEX);
}
});
connect(vulkan_device_combobox, qOverload<int>(&QComboBox::activated), this,
[this](int device) {
@ -215,18 +208,22 @@ void ConfigureGraphics::SetConfiguration() {
QLayout& graphics_layout = *ui->graphics_widget->layout();
std::map<bool, std::map<std::string, QWidget*>> hold_graphics;
std::forward_list<QWidget*> hold_api;
for (const auto setting : Settings::values.linkage.by_category[Settings::Category::Renderer]) {
const auto& setting_label = setting->GetLabel();
auto [widget, extra] = [&]() {
if (setting->Id() == Settings::values.vulkan_device.Id()) {
if (setting->Id() == Settings::values.vulkan_device.Id() ||
setting->Id() == Settings::values.shader_backend.Id() ||
setting->Id() == Settings::values.vsync_mode.Id()) {
return ConfigurationShared::CreateWidget(
setting, translations, this, runtime_lock, apply_funcs, trackers,
ConfigurationShared::RequestType::ComboBox);
ConfigurationShared::RequestType::ComboBox, false);
} else {
return ConfigurationShared::CreateWidget(setting, translations, this, runtime_lock,
apply_funcs, trackers);
}
return ConfigurationShared::CreateWidget(setting, translations, this, runtime_lock,
apply_funcs, trackers);
}();
if (widget == nullptr) {
@ -237,11 +234,11 @@ void ConfigureGraphics::SetConfiguration() {
api_layout.addWidget(widget);
api_combobox = reinterpret_cast<QComboBox*>(extra);
} else if (setting->Id() == Settings::values.vulkan_device.Id()) {
api_layout.addWidget(widget);
hold_api.push_front(widget);
vulkan_device_combobox = reinterpret_cast<QComboBox*>(extra);
vulkan_device_widget = widget;
} else if (setting->Id() == Settings::values.shader_backend.Id()) {
api_layout.addWidget(widget);
hold_api.push_front(widget);
shader_backend_combobox = reinterpret_cast<QComboBox*>(extra);
shader_backend_widget = widget;
} else if (setting->Id() == Settings::values.vsync_mode.Id()) {
@ -258,86 +255,9 @@ void ConfigureGraphics::SetConfiguration() {
}
}
// ui->api_widget->setEnabled(runtime_lock);
// ui->use_asynchronous_gpu_emulation->setEnabled(runtime_lock);
// ui->use_disk_shader_cache->setEnabled(runtime_lock);
// ui->nvdec_emulation_widget->setEnabled(runtime_lock);
// ui->resolution_combobox->setEnabled(runtime_lock);
// ui->astc_decode_mode_combobox->setEnabled(runtime_lock);
// ui->vsync_mode_layout->setEnabled(runtime_lock ||
// Settings::values.renderer_backend.GetValue() ==
// Settings::RendererBackend::Vulkan);
// ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache.GetValue());
// ui->use_asynchronous_gpu_emulation->setChecked(
// Settings::values.use_asynchronous_gpu_emulation.GetValue());
// if (Settings::IsConfiguringGlobal()) {
// api_combobox->setCurrentIndex(static_cast<int>(Settings::values.renderer_backend.GetValue()));
// ui->fullscreen_mode_combobox->setCurrentIndex(
// static_cast<int>(Settings::values.fullscreen_mode.GetValue()));
// ui->nvdec_emulation->setCurrentIndex(
// static_cast<int>(Settings::values.nvdec_emulation.GetValue()));
// ui->aspect_ratio_combobox->setCurrentIndex(Settings::values.aspect_ratio.GetValue());
// ui->resolution_combobox->setCurrentIndex(
// static_cast<int>(Settings::values.resolution_setup.GetValue()));
// ui->scaling_filter_combobox->setCurrentIndex(
// static_cast<int>(Settings::values.scaling_filter.GetValue()));
// ui->fsr_sharpening_slider->setValue(Settings::values.fsr_sharpening_slider.GetValue());
// ui->anti_aliasing_combobox->setCurrentIndex(
// static_cast<int>(Settings::values.anti_aliasing.GetValue()));
// } else {
// ConfigurationShared::SetPerGameSetting(api_combobox, &Settings::values.renderer_backend);
// ConfigurationShared::SetHighlight(ui->api_widget,
// !Settings::values.renderer_backend.UsingGlobal());
// ConfigurationShared::SetPerGameSetting(ui->astc_decode_mode_combobox,
// &Settings::values.accelerate_astc);
// ConfigurationShared::SetHighlight(ui->astc_decode_mode_layout,
// !Settings::values.accelerate_astc.UsingGlobal());
// ConfigurationShared::SetPerGameSetting(ui->nvdec_emulation,
// &Settings::values.nvdec_emulation);
// ConfigurationShared::SetHighlight(ui->nvdec_emulation_widget,
// !Settings::values.nvdec_emulation.UsingGlobal());
// ConfigurationShared::SetPerGameSetting(ui->fullscreen_mode_combobox,
// &Settings::values.fullscreen_mode);
// ConfigurationShared::SetHighlight(ui->fullscreen_mode_label,
// !Settings::values.fullscreen_mode.UsingGlobal());
// ConfigurationShared::SetPerGameSetting(ui->aspect_ratio_combobox,
// &Settings::values.aspect_ratio);
// ConfigurationShared::SetHighlight(ui->ar_label,
// !Settings::values.aspect_ratio.UsingGlobal());
// ConfigurationShared::SetPerGameSetting(ui->resolution_combobox,
// &Settings::values.resolution_setup);
// ConfigurationShared::SetHighlight(ui->resolution_label,
// !Settings::values.resolution_setup.UsingGlobal());
// ConfigurationShared::SetPerGameSetting(ui->scaling_filter_combobox,
// &Settings::values.scaling_filter);
// ConfigurationShared::SetHighlight(ui->scaling_filter_label,
// !Settings::values.scaling_filter.UsingGlobal());
// ConfigurationShared::SetPerGameSetting(ui->anti_aliasing_combobox,
// &Settings::values.anti_aliasing);
// ConfigurationShared::SetHighlight(ui->anti_aliasing_label,
// !Settings::values.anti_aliasing.UsingGlobal());
// ui->fsr_sharpening_combobox->setCurrentIndex(
// Settings::values.fsr_sharpening_slider.UsingGlobal() ? 0 : 1);
// ui->fsr_sharpening_slider->setEnabled(
// !Settings::values.fsr_sharpening_slider.UsingGlobal());
// ui->fsr_sharpening_value->setEnabled(!Settings::values.fsr_sharpening_slider.UsingGlobal());
// ConfigurationShared::SetHighlight(ui->fsr_sharpening_layout,
// !Settings::values.fsr_sharpening_slider.UsingGlobal());
// ui->fsr_sharpening_slider->setValue(Settings::values.fsr_sharpening_slider.GetValue());
// ui->bg_combobox->setCurrentIndex(Settings::values.bg_red.UsingGlobal() ? 0 : 1);
// ui->bg_button->setEnabled(!Settings::values.bg_red.UsingGlobal());
// ConfigurationShared::SetHighlight(ui->bg_layout, !Settings::values.bg_red.UsingGlobal());
// }
for (auto widget : hold_api) {
api_layout.addWidget(widget);
}
}
void ConfigureGraphics::SetFSRIndicatorText(int percentage) {
@ -367,134 +287,16 @@ const QString ConfigureGraphics::TranslateVSyncMode(VkPresentModeKHR mode,
}
void ConfigureGraphics::ApplyConfiguration() {
// const auto resolution_setup = static_cast<Settings::ResolutionSetup>(
// ui->resolution_combobox->currentIndex() -
// ((Settings::IsConfiguringGlobal()) ? 0 : ConfigurationShared::USE_GLOBAL_OFFSET));
// const auto scaling_filter = static_cast<Settings::ScalingFilter>(
// ui->scaling_filter_combobox->currentIndex() -
// ((Settings::IsConfiguringGlobal()) ? 0 : ConfigurationShared::USE_GLOBAL_OFFSET));
// const auto anti_aliasing = static_cast<Settings::AntiAliasing>(
// ui->anti_aliasing_combobox->currentIndex() -
// ((Settings::IsConfiguringGlobal()) ? 0 : ConfigurationShared::USE_GLOBAL_OFFSET));
// ConfigurationShared::ApplyPerGameSetting(&Settings::values.fullscreen_mode,
// ui->fullscreen_mode_combobox);
// ConfigurationShared::ApplyPerGameSetting(&Settings::values.aspect_ratio,
// ui->aspect_ratio_combobox);
// ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_disk_shader_cache,
// ui->use_disk_shader_cache, use_disk_shader_cache);
// ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_gpu_emulation,
// ui->use_asynchronous_gpu_emulation,
// use_asynchronous_gpu_emulation);
// ConfigurationShared::ApplyPerGameSetting(&Settings::values.accelerate_astc,
// ui->astc_decode_mode_combobox);
// if (Settings::IsConfiguringGlobal()) {
// // Guard if during game and set to game-specific value
// if (Settings::values.renderer_backend.UsingGlobal()) {
// Settings::values.renderer_backend.SetValue(GetCurrentGraphicsBackend());
// }
// if (Settings::values.nvdec_emulation.UsingGlobal()) {
// Settings::values.nvdec_emulation.SetValue(GetCurrentNvdecEmulation());
// }
// if (Settings::values.shader_backend.UsingGlobal()) {
// Settings::values.shader_backend.SetValue(shader_backend);
// }
// if (Settings::values.vulkan_device.UsingGlobal()) {
// Settings::values.vulkan_device.SetValue(vulkan_device);
// }
// if (Settings::values.bg_red.UsingGlobal()) {
// Settings::values.bg_red.SetValue(static_cast<u8>(bg_color.red()));
// Settings::values.bg_green.SetValue(static_cast<u8>(bg_color.green()));
// Settings::values.bg_blue.SetValue(static_cast<u8>(bg_color.blue()));
// }
// if (Settings::values.resolution_setup.UsingGlobal()) {
// Settings::values.resolution_setup.SetValue(resolution_setup);
// }
// if (Settings::values.scaling_filter.UsingGlobal()) {
// Settings::values.scaling_filter.SetValue(scaling_filter);
// }
// if (Settings::values.anti_aliasing.UsingGlobal()) {
// Settings::values.anti_aliasing.SetValue(anti_aliasing);
// }
// Settings::values.fsr_sharpening_slider.SetValue(ui->fsr_sharpening_slider->value());
// const auto mode = vsync_mode_combobox_enum_map[vsync_mode_combobox->currentIndex()];
// const auto vsync_mode = PresentModeToSetting(mode);
// Settings::values.vsync_mode.SetValue(vsync_mode);
// } else {
// if (ui->resolution_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
// Settings::values.resolution_setup.SetGlobal(true);
// } else {
// Settings::values.resolution_setup.SetGlobal(false);
// Settings::values.resolution_setup.SetValue(resolution_setup);
// }
// if (ui->scaling_filter_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX)
// {
// Settings::values.scaling_filter.SetGlobal(true);
// } else {
// Settings::values.scaling_filter.SetGlobal(false);
// Settings::values.scaling_filter.SetValue(scaling_filter);
// }
// if (ui->anti_aliasing_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX)
// {
// Settings::values.anti_aliasing.SetGlobal(true);
// } else {
// Settings::values.anti_aliasing.SetGlobal(false);
// Settings::values.anti_aliasing.SetValue(anti_aliasing);
// }
// if (api_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
// Settings::values.renderer_backend.SetGlobal(true);
// Settings::values.shader_backend.SetGlobal(true);
// Settings::values.vulkan_device.SetGlobal(true);
// } else {
// Settings::values.renderer_backend.SetGlobal(false);
// Settings::values.renderer_backend.SetValue(GetCurrentGraphicsBackend());
// switch (GetCurrentGraphicsBackend()) {
// case Settings::RendererBackend::OpenGL:
// case Settings::RendererBackend::Null:
// Settings::values.shader_backend.SetGlobal(false);
// Settings::values.vulkan_device.SetGlobal(true);
// Settings::values.shader_backend.SetValue(shader_backend);
// break;
// case Settings::RendererBackend::Vulkan:
// Settings::values.shader_backend.SetGlobal(true);
// Settings::values.vulkan_device.SetGlobal(false);
// Settings::values.vulkan_device.SetValue(vulkan_device);
// break;
// }
// }
// if (ui->nvdec_emulation->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
// Settings::values.nvdec_emulation.SetGlobal(true);
// } else {
// Settings::values.nvdec_emulation.SetGlobal(false);
// Settings::values.nvdec_emulation.SetValue(GetCurrentNvdecEmulation());
// }
// if (ui->bg_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
// Settings::values.bg_red.SetGlobal(true);
// Settings::values.bg_green.SetGlobal(true);
// Settings::values.bg_blue.SetGlobal(true);
// } else {
// Settings::values.bg_red.SetGlobal(false);
// Settings::values.bg_green.SetGlobal(false);
// Settings::values.bg_blue.SetGlobal(false);
// Settings::values.bg_red.SetValue(static_cast<u8>(bg_color.red()));
// Settings::values.bg_green.SetValue(static_cast<u8>(bg_color.green()));
// Settings::values.bg_blue.SetValue(static_cast<u8>(bg_color.blue()));
// }
const bool powered_on = system.IsPoweredOn();
for (const auto& func : apply_funcs) {
func(powered_on);
}
// if (ui->fsr_sharpening_combobox->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX)
// {
// Settings::values.fsr_sharpening_slider.SetGlobal(true);
// } else {
// Settings::values.fsr_sharpening_slider.SetGlobal(false);
// Settings::values.fsr_sharpening_slider.SetValue(ui->fsr_sharpening_slider->value());
// }
// }
if (Settings::IsConfiguringGlobal()) {
const auto mode = vsync_mode_combobox_enum_map[vsync_mode_combobox->currentIndex()];
const auto vsync_mode = PresentModeToSetting(mode);
Settings::values.vsync_mode.SetValue(vsync_mode);
}
}
void ConfigureGraphics::changeEvent(QEvent* event) {
@ -581,83 +383,3 @@ Settings::RendererBackend ConfigureGraphics::GetCurrentGraphicsBackend() const {
return static_cast<Settings::RendererBackend>(api_combobox->currentIndex() -
ConfigurationShared::USE_GLOBAL_OFFSET);
}
Settings::NvdecEmulation ConfigureGraphics::GetCurrentNvdecEmulation() const {
return Settings::NvdecEmulation::CPU;
// if (Settings::IsConfiguringGlobal()) {
// return static_cast<Settings::NvdecEmulation>(ui->nvdec_emulation->currentIndex());
// }
// if (ui->nvdec_emulation->currentIndex() == ConfigurationShared::USE_GLOBAL_INDEX) {
// Settings::values.nvdec_emulation.SetGlobal(true);
// return Settings::values.nvdec_emulation.GetValue();
// }
// Settings::values.nvdec_emulation.SetGlobal(false);
// return static_cast<Settings::NvdecEmulation>(ui->nvdec_emulation->currentIndex() -
// ConfigurationShared::USE_GLOBAL_OFFSET);
}
void ConfigureGraphics::SetupPerGameUI() {
// if (Settings::IsConfiguringGlobal()) {
// api_combobox->setEnabled(Settings::values.renderer_backend.UsingGlobal());
// vulkan_device_combobox->setEnabled(Settings::values.renderer_backend.UsingGlobal());
// ui->fullscreen_mode_combobox->setEnabled(Settings::values.fullscreen_mode.UsingGlobal());
// ui->aspect_ratio_combobox->setEnabled(Settings::values.aspect_ratio.UsingGlobal());
// ui->resolution_combobox->setEnabled(Settings::values.resolution_setup.UsingGlobal());
// ui->scaling_filter_combobox->setEnabled(Settings::values.scaling_filter.UsingGlobal());
// ui->fsr_sharpening_slider->setEnabled(Settings::values.fsr_sharpening_slider.UsingGlobal());
// ui->anti_aliasing_combobox->setEnabled(Settings::values.anti_aliasing.UsingGlobal());
// ui->use_asynchronous_gpu_emulation->setEnabled(
// Settings::values.use_asynchronous_gpu_emulation.UsingGlobal());
// ui->nvdec_emulation->setEnabled(Settings::values.nvdec_emulation.UsingGlobal());
// ui->astc_decode_mode_combobox->setEnabled(Settings::values.accelerate_astc.UsingGlobal());
// ui->use_disk_shader_cache->setEnabled(Settings::values.use_disk_shader_cache.UsingGlobal());
// ui->bg_button->setEnabled(Settings::values.bg_red.UsingGlobal());
// ui->fsr_slider_layout->setEnabled(Settings::values.fsr_sharpening_slider.UsingGlobal());
// return;
// }
// connect(ui->bg_combobox, qOverload<int>(&QComboBox::activated), this, [this](int index) {
// ui->bg_button->setEnabled(index == 1);
// ConfigurationShared::SetHighlight(ui->bg_layout, index == 1);
// });
// connect(ui->fsr_sharpening_combobox, qOverload<int>(&QComboBox::activated), this,
// [this](int index) {
// ui->fsr_sharpening_slider->setEnabled(index == 1);
// ui->fsr_sharpening_value->setEnabled(index == 1);
// ConfigurationShared::SetHighlight(ui->fsr_sharpening_layout, index == 1);
// });
// ConfigurationShared::SetColoredTristate(
// ui->use_disk_shader_cache, Settings::values.use_disk_shader_cache,
// use_disk_shader_cache);
// ConfigurationShared::SetColoredTristate(ui->use_asynchronous_gpu_emulation,
// Settings::values.use_asynchronous_gpu_emulation,
// use_asynchronous_gpu_emulation);
// ConfigurationShared::SetColoredComboBox(ui->aspect_ratio_combobox, ui->ar_label,
// Settings::values.aspect_ratio.GetValue(true));
// ConfigurationShared::SetColoredComboBox(
// ui->fullscreen_mode_combobox, ui->fullscreen_mode_label,
// static_cast<int>(Settings::values.fullscreen_mode.GetValue(true)));
// ConfigurationShared::SetColoredComboBox(
// ui->resolution_combobox, ui->resolution_label,
// static_cast<int>(Settings::values.resolution_setup.GetValue(true)));
// ConfigurationShared::SetColoredComboBox(
// ui->scaling_filter_combobox, ui->scaling_filter_label,
// static_cast<int>(Settings::values.scaling_filter.GetValue(true)));
// ConfigurationShared::SetColoredComboBox(
// ui->anti_aliasing_combobox, ui->anti_aliasing_label,
// static_cast<int>(Settings::values.anti_aliasing.GetValue(true)));
// ConfigurationShared::SetColoredComboBox(
// ui->astc_decode_mode_combobox, ui->astc_decode_mode_label,
// static_cast<int>(Settings::values.accelerate_astc.GetValue(true)));
// ConfigurationShared::InsertGlobalItem(
// api_combobox, static_cast<int>(Settings::values.renderer_backend.GetValue(true)));
// ConfigurationShared::InsertGlobalItem(
// ui->nvdec_emulation, static_cast<int>(Settings::values.nvdec_emulation.GetValue(true)));
// ui->vsync_mode_layout->setVisible(false);
}

4
src/yuzu/configuration/configure_graphics.h
View File

@ -64,10 +64,7 @@ private:
const QString TranslateVSyncMode(VkPresentModeKHR mode,
Settings::RendererBackend backend) const;
void SetupPerGameUI();
Settings::RendererBackend GetCurrentGraphicsBackend() const;
Settings::NvdecEmulation GetCurrentNvdecEmulation() const;
std::unique_ptr<Ui::ConfigureGraphics> ui;
QColor bg_color;
@ -93,5 +90,6 @@ private:
QComboBox* shader_backend_combobox;
QComboBox* vsync_mode_combobox;
QWidget* vulkan_device_widget;
QWidget* api_widget;
QWidget* shader_backend_widget;
};
Write Preview
Loading…
Cancel
Save