mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-01-15 10:39:13 +01:00
57c59c18d4
The name was confusing as changing it at runtime would not change the window to fullscreen, as it effectively only affects the start of the emulation. Also blocked the ability to change it when the emulation is running, to be more inline with other similar settings, like "Render to main Window".
338 lines
15 KiB
C++
338 lines
15 KiB
C++
// Copyright 2017 Dolphin Emulator Project5~5~5~
|
|
// Licensed under GPLv2+
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "DolphinQt/Config/Graphics/GeneralWidget.h"
|
|
|
|
#include <QCheckBox>
|
|
#include <QComboBox>
|
|
#include <QGridLayout>
|
|
#include <QGroupBox>
|
|
#include <QHBoxLayout>
|
|
#include <QLabel>
|
|
#include <QRadioButton>
|
|
#include <QSignalBlocker>
|
|
#include <QVBoxLayout>
|
|
|
|
#include "Core/Config/GraphicsSettings.h"
|
|
#include "Core/Config/MainSettings.h"
|
|
#include "Core/ConfigManager.h"
|
|
#include "Core/Core.h"
|
|
|
|
#include "DolphinQt/Config/Graphics/GraphicsBool.h"
|
|
#include "DolphinQt/Config/Graphics/GraphicsChoice.h"
|
|
#include "DolphinQt/Config/Graphics/GraphicsRadio.h"
|
|
#include "DolphinQt/Config/Graphics/GraphicsWindow.h"
|
|
#include "DolphinQt/Config/ToolTipControls/ToolTipComboBox.h"
|
|
#include "DolphinQt/QtUtils/ModalMessageBox.h"
|
|
#include "DolphinQt/Settings.h"
|
|
|
|
#include "UICommon/VideoUtils.h"
|
|
|
|
#include "VideoCommon/VideoBackendBase.h"
|
|
#include "VideoCommon/VideoConfig.h"
|
|
|
|
GeneralWidget::GeneralWidget(X11Utils::XRRConfiguration* xrr_config, GraphicsWindow* parent)
|
|
: m_xrr_config(xrr_config)
|
|
{
|
|
CreateWidgets();
|
|
LoadSettings();
|
|
ConnectWidgets();
|
|
AddDescriptions();
|
|
emit BackendChanged(QString::fromStdString(Config::Get(Config::MAIN_GFX_BACKEND)));
|
|
|
|
connect(parent, &GraphicsWindow::BackendChanged, this, &GeneralWidget::OnBackendChanged);
|
|
connect(&Settings::Instance(), &Settings::EmulationStateChanged, this,
|
|
[=](Core::State state) { OnEmulationStateChanged(state != Core::State::Uninitialized); });
|
|
OnEmulationStateChanged(Core::GetState() != Core::State::Uninitialized);
|
|
}
|
|
|
|
void GeneralWidget::CreateWidgets()
|
|
{
|
|
auto* main_layout = new QVBoxLayout;
|
|
|
|
// Basic Section
|
|
auto* m_video_box = new QGroupBox(tr("Basic"));
|
|
m_video_layout = new QGridLayout();
|
|
|
|
m_backend_combo = new ToolTipComboBox();
|
|
m_aspect_combo =
|
|
new GraphicsChoice({tr("Auto"), tr("Force 16:9"), tr("Force 4:3"), tr("Stretch to Window")},
|
|
Config::GFX_ASPECT_RATIO);
|
|
m_adapter_combo = new ToolTipComboBox;
|
|
m_enable_vsync = new GraphicsBool(tr("V-Sync"), Config::GFX_VSYNC);
|
|
m_enable_fullscreen = new GraphicsBool(tr("Start in Fullscreen"), Config::MAIN_FULLSCREEN);
|
|
|
|
m_video_box->setLayout(m_video_layout);
|
|
|
|
for (auto& backend : VideoBackendBase::GetAvailableBackends())
|
|
{
|
|
m_backend_combo->addItem(tr(backend->GetDisplayName().c_str()),
|
|
QVariant(QString::fromStdString(backend->GetName())));
|
|
}
|
|
|
|
m_video_layout->addWidget(new QLabel(tr("Backend:")), 0, 0);
|
|
m_video_layout->addWidget(m_backend_combo, 0, 1);
|
|
|
|
m_video_layout->addWidget(new QLabel(tr("Adapter:")), 1, 0);
|
|
m_video_layout->addWidget(m_adapter_combo, 1, 1);
|
|
|
|
m_video_layout->addWidget(new QLabel(tr("Aspect Ratio:")), 3, 0);
|
|
m_video_layout->addWidget(m_aspect_combo, 3, 1);
|
|
|
|
m_video_layout->addWidget(m_enable_vsync, 4, 0);
|
|
m_video_layout->addWidget(m_enable_fullscreen, 4, 1);
|
|
|
|
// Other
|
|
auto* m_options_box = new QGroupBox(tr("Other"));
|
|
auto* m_options_layout = new QGridLayout();
|
|
|
|
m_show_fps = new GraphicsBool(tr("Show FPS"), Config::GFX_SHOW_FPS);
|
|
m_show_ping = new GraphicsBool(tr("Show NetPlay Ping"), Config::GFX_SHOW_NETPLAY_PING);
|
|
m_log_render_time =
|
|
new GraphicsBool(tr("Log Render Time to File"), Config::GFX_LOG_RENDER_TIME_TO_FILE);
|
|
m_autoadjust_window_size =
|
|
new GraphicsBool(tr("Auto-Adjust Window Size"), Config::MAIN_RENDER_WINDOW_AUTOSIZE);
|
|
m_show_messages =
|
|
new GraphicsBool(tr("Show NetPlay Messages"), Config::GFX_SHOW_NETPLAY_MESSAGES);
|
|
m_render_main_window = new GraphicsBool(tr("Render to Main Window"), Config::MAIN_RENDER_TO_MAIN);
|
|
|
|
m_options_box->setLayout(m_options_layout);
|
|
|
|
m_options_layout->addWidget(m_show_fps, 0, 0);
|
|
m_options_layout->addWidget(m_log_render_time, 0, 1);
|
|
|
|
m_options_layout->addWidget(m_render_main_window, 1, 0);
|
|
m_options_layout->addWidget(m_autoadjust_window_size, 1, 1);
|
|
|
|
m_options_layout->addWidget(m_show_messages, 2, 0);
|
|
m_options_layout->addWidget(m_show_ping, 2, 1);
|
|
|
|
// Other
|
|
auto* shader_compilation_box = new QGroupBox(tr("Shader Compilation"));
|
|
auto* shader_compilation_layout = new QGridLayout();
|
|
|
|
const std::array<const char*, 4> modes = {{
|
|
QT_TR_NOOP("Synchronous"),
|
|
QT_TR_NOOP("Synchronous (Ubershaders)"),
|
|
QT_TR_NOOP("Asynchronous (Ubershaders)"),
|
|
QT_TR_NOOP("Asynchronous (Skip Drawing)"),
|
|
}};
|
|
for (size_t i = 0; i < modes.size(); i++)
|
|
{
|
|
m_shader_compilation_mode[i] = new GraphicsRadioInt(
|
|
tr(modes[i]), Config::GFX_SHADER_COMPILATION_MODE, static_cast<int>(i));
|
|
shader_compilation_layout->addWidget(m_shader_compilation_mode[i], static_cast<int>(i / 2),
|
|
static_cast<int>(i % 2));
|
|
}
|
|
m_wait_for_shaders = new GraphicsBool(tr("Compile Shaders Before Starting"),
|
|
Config::GFX_WAIT_FOR_SHADERS_BEFORE_STARTING);
|
|
shader_compilation_layout->addWidget(m_wait_for_shaders);
|
|
shader_compilation_box->setLayout(shader_compilation_layout);
|
|
|
|
main_layout->addWidget(m_video_box);
|
|
main_layout->addWidget(m_options_box);
|
|
main_layout->addWidget(shader_compilation_box);
|
|
main_layout->addStretch();
|
|
|
|
setLayout(main_layout);
|
|
}
|
|
|
|
void GeneralWidget::ConnectWidgets()
|
|
{
|
|
// Video Backend
|
|
connect(m_backend_combo, qOverload<int>(&QComboBox::currentIndexChanged), this,
|
|
&GeneralWidget::SaveSettings);
|
|
connect(m_adapter_combo, qOverload<int>(&QComboBox::currentIndexChanged), this, [](int index) {
|
|
g_Config.iAdapter = index;
|
|
Config::SetBaseOrCurrent(Config::GFX_ADAPTER, index);
|
|
});
|
|
}
|
|
|
|
void GeneralWidget::LoadSettings()
|
|
{
|
|
// Video Backend
|
|
m_backend_combo->setCurrentIndex(m_backend_combo->findData(
|
|
QVariant(QString::fromStdString(Config::Get(Config::MAIN_GFX_BACKEND)))));
|
|
}
|
|
|
|
void GeneralWidget::SaveSettings()
|
|
{
|
|
// Video Backend
|
|
const auto current_backend = m_backend_combo->currentData().toString().toStdString();
|
|
if (Config::Get(Config::MAIN_GFX_BACKEND) != current_backend)
|
|
{
|
|
auto warningMessage = VideoBackendBase::GetAvailableBackends()[m_backend_combo->currentIndex()]
|
|
->GetWarningMessage();
|
|
if (warningMessage)
|
|
{
|
|
ModalMessageBox confirm_sw(this);
|
|
|
|
confirm_sw.setIcon(QMessageBox::Warning);
|
|
confirm_sw.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
|
|
confirm_sw.setWindowTitle(tr("Confirm backend change"));
|
|
confirm_sw.setText(tr(warningMessage->c_str()));
|
|
|
|
if (confirm_sw.exec() != QMessageBox::Yes)
|
|
{
|
|
m_backend_combo->setCurrentIndex(m_backend_combo->findData(
|
|
QVariant(QString::fromStdString(Config::Get(Config::MAIN_GFX_BACKEND)))));
|
|
return;
|
|
}
|
|
}
|
|
emit BackendChanged(QString::fromStdString(current_backend));
|
|
}
|
|
}
|
|
|
|
void GeneralWidget::OnEmulationStateChanged(bool running)
|
|
{
|
|
m_backend_combo->setEnabled(!running);
|
|
m_render_main_window->setEnabled(!running);
|
|
m_enable_fullscreen->setEnabled(!running);
|
|
|
|
const bool supports_adapters = !g_Config.backend_info.Adapters.empty();
|
|
m_adapter_combo->setEnabled(!running && supports_adapters);
|
|
}
|
|
|
|
void GeneralWidget::AddDescriptions()
|
|
{
|
|
// We need QObject::tr
|
|
#if defined(_WIN32)
|
|
static const char TR_BACKEND_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Selects which graphics API to use internally.<br><br>The software renderer is extremely "
|
|
"slow and only useful for debugging, so either OpenGL, Direct3D, or Vulkan are "
|
|
"recommended. Different games and different GPUs will behave differently on each "
|
|
"backend, so for the best emulation experience it is recommended to try each and "
|
|
"select the backend that is least problematic.<br><br><dolphin_emphasis>If unsure, "
|
|
"select OpenGL.</dolphin_emphasis>");
|
|
#else
|
|
static const char TR_BACKEND_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Selects which graphics API to use internally.<br><br>The software renderer is extremely "
|
|
"slow and only useful for debugging, so any of the other backends are "
|
|
"recommended.<br><br><dolphin_emphasis>If unsure, select OpenGL.</dolphin_emphasis>");
|
|
#endif
|
|
static const char TR_ADAPTER_DESCRIPTION[] =
|
|
QT_TR_NOOP("Selects a hardware adapter to use.<br><br><dolphin_emphasis>If unsure, "
|
|
"select the first one.</dolphin_emphasis>");
|
|
static const char TR_FULLSCREEN_DESCRIPTION[] =
|
|
QT_TR_NOOP("Uses the entire screen for rendering.<br><br>If disabled, a "
|
|
"render window will be created instead.<br><br><dolphin_emphasis>If "
|
|
"unsure, leave this unchecked.</dolphin_emphasis>");
|
|
static const char TR_AUTOSIZE_DESCRIPTION[] =
|
|
QT_TR_NOOP("Automatically adjusts the window size to the internal resolution.<br><br>"
|
|
"<dolphin_emphasis>If unsure, leave this unchecked.</dolphin_emphasis>");
|
|
static const char TR_RENDER_TO_MAINWINDOW_DESCRIPTION[] =
|
|
QT_TR_NOOP("Uses the main Dolphin window for rendering rather than "
|
|
"a separate render window.<br><br><dolphin_emphasis>If unsure, leave "
|
|
"this unchecked.</dolphin_emphasis>");
|
|
static const char TR_ASPECT_RATIO_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Selects which aspect ratio to use when rendering.<br><br>Auto: Uses the native aspect "
|
|
"ratio<br>Force 16:9: Mimics an analog TV with a widescreen aspect ratio.<br>Force 4:3: "
|
|
"Mimics a standard 4:3 analog TV.<br>Stretch to Window: Stretches the picture to the "
|
|
"window size.<br><br><dolphin_emphasis>If unsure, select Auto.</dolphin_emphasis>");
|
|
static const char TR_VSYNC_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Waits for vertical blanks in order to prevent tearing.<br><br>Decreases performance "
|
|
"if emulation speed is below 100%.<br><br><dolphin_emphasis>If unsure, leave "
|
|
"this "
|
|
"unchecked.</dolphin_emphasis>");
|
|
static const char TR_SHOW_FPS_DESCRIPTION[] =
|
|
QT_TR_NOOP("Shows the number of frames rendered per second as a measure of "
|
|
"emulation speed.<br><br><dolphin_emphasis>If unsure, leave this "
|
|
"unchecked.</dolphin_emphasis>");
|
|
static const char TR_SHOW_NETPLAY_PING_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Shows the player's maximum ping while playing on "
|
|
"NetPlay.<br><br><dolphin_emphasis>If unsure, leave this unchecked.</dolphin_emphasis>");
|
|
static const char TR_LOG_RENDERTIME_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Logs the render time of every frame to User/Logs/render_time.txt.<br><br>Use this "
|
|
"feature when to measure the performance of Dolphin.<br><br><dolphin_emphasis>If "
|
|
"unsure, leave this unchecked.</dolphin_emphasis>");
|
|
static const char TR_SHOW_NETPLAY_MESSAGES_DESCRIPTION[] =
|
|
QT_TR_NOOP("Shows chat messages, buffer changes, and desync alerts "
|
|
"while playing NetPlay.<br><br><dolphin_emphasis>If unsure, leave "
|
|
"this unchecked.</dolphin_emphasis>");
|
|
static const char TR_SHADER_COMPILE_SYNC_DESCRIPTION[] =
|
|
QT_TR_NOOP("Ubershaders are never used. Stuttering will occur during shader "
|
|
"compilation, but GPU demands are low.<br><br>Recommended for low-end hardware. "
|
|
"<br><br><dolphin_emphasis>If unsure, select this mode.</dolphin_emphasis>");
|
|
static const char TR_SHADER_COMPILE_SYNC_UBER_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Ubershaders will always be used. Provides a near stutter-free experience at the cost of "
|
|
"high GPU performance requirements.<br><br><dolphin_emphasis>Only recommended "
|
|
"for high-end systems.</dolphin_emphasis>");
|
|
static const char TR_SHADER_COMPILE_ASYNC_UBER_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Ubershaders will be used to prevent stuttering during shader compilation, but "
|
|
"specialized shaders will be used when they will not cause stuttering.<br><br>In the "
|
|
"best case it eliminates shader compilation stuttering while having minimal "
|
|
"performance impact, but results depend on video driver behavior.");
|
|
static const char TR_SHADER_COMPILE_ASYNC_SKIP_DESCRIPTION[] = QT_TR_NOOP(
|
|
"Prevents shader compilation stuttering by not rendering waiting objects. Can work in "
|
|
"scenarios where Ubershaders doesn't, at the cost of introducing visual glitches and broken "
|
|
"effects.<br><br><dolphin_emphasis>Not recommended, only use if the other "
|
|
"options give poor results.</dolphin_emphasis>");
|
|
static const char TR_SHADER_COMPILE_BEFORE_START_DESCRIPTION[] =
|
|
QT_TR_NOOP("Waits for all shaders to finish compiling before starting a game. Enabling this "
|
|
"option may reduce stuttering or hitching for a short time after the game is "
|
|
"started, at the cost of a longer delay before the game starts. For systems with "
|
|
"two or fewer cores, it is recommended to enable this option, as a large shader "
|
|
"queue may reduce frame rates.<br><br><dolphin_emphasis>Otherwise, if "
|
|
"unsure, leave this unchecked.</dolphin_emphasis>");
|
|
|
|
m_backend_combo->SetTitle(tr("Backend"));
|
|
m_backend_combo->SetDescription(tr(TR_BACKEND_DESCRIPTION));
|
|
|
|
m_adapter_combo->SetTitle(tr("Adapter"));
|
|
m_adapter_combo->SetDescription(tr(TR_ADAPTER_DESCRIPTION));
|
|
|
|
m_aspect_combo->SetTitle(tr("Aspect Ratio"));
|
|
m_aspect_combo->SetDescription(tr(TR_ASPECT_RATIO_DESCRIPTION));
|
|
|
|
m_enable_vsync->SetDescription(tr(TR_VSYNC_DESCRIPTION));
|
|
|
|
m_enable_fullscreen->SetDescription(tr(TR_FULLSCREEN_DESCRIPTION));
|
|
|
|
m_show_fps->SetDescription(tr(TR_SHOW_FPS_DESCRIPTION));
|
|
|
|
m_show_ping->SetDescription(tr(TR_SHOW_NETPLAY_PING_DESCRIPTION));
|
|
|
|
m_log_render_time->SetDescription(tr(TR_LOG_RENDERTIME_DESCRIPTION));
|
|
|
|
m_autoadjust_window_size->SetDescription(tr(TR_AUTOSIZE_DESCRIPTION));
|
|
|
|
m_show_messages->SetDescription(tr(TR_SHOW_NETPLAY_MESSAGES_DESCRIPTION));
|
|
|
|
m_render_main_window->SetDescription(tr(TR_RENDER_TO_MAINWINDOW_DESCRIPTION));
|
|
|
|
m_shader_compilation_mode[0]->SetDescription(tr(TR_SHADER_COMPILE_SYNC_DESCRIPTION));
|
|
|
|
m_shader_compilation_mode[1]->SetDescription(tr(TR_SHADER_COMPILE_SYNC_UBER_DESCRIPTION));
|
|
|
|
m_shader_compilation_mode[2]->SetDescription(tr(TR_SHADER_COMPILE_ASYNC_UBER_DESCRIPTION));
|
|
|
|
m_shader_compilation_mode[3]->SetDescription(tr(TR_SHADER_COMPILE_ASYNC_SKIP_DESCRIPTION));
|
|
|
|
m_wait_for_shaders->SetDescription(tr(TR_SHADER_COMPILE_BEFORE_START_DESCRIPTION));
|
|
}
|
|
|
|
void GeneralWidget::OnBackendChanged(const QString& backend_name)
|
|
{
|
|
m_backend_combo->setCurrentIndex(m_backend_combo->findData(QVariant(backend_name)));
|
|
|
|
const QSignalBlocker blocker(m_adapter_combo);
|
|
|
|
m_adapter_combo->clear();
|
|
|
|
const auto& adapters = g_Config.backend_info.Adapters;
|
|
|
|
for (const auto& adapter : adapters)
|
|
m_adapter_combo->addItem(QString::fromStdString(adapter));
|
|
|
|
const bool supports_adapters = !adapters.empty();
|
|
|
|
m_adapter_combo->setCurrentIndex(g_Config.iAdapter);
|
|
m_adapter_combo->setEnabled(supports_adapters && !Core::IsRunning());
|
|
|
|
m_adapter_combo->setToolTip(supports_adapters ?
|
|
QString{} :
|
|
tr("%1 doesn't support this feature.")
|
|
.arg(tr(g_video_backend->GetDisplayName().c_str())));
|
|
}
|