early-access version 1794

This commit is contained in:
pineappleEA 2021-06-18 16:07:15 +02:00
parent d7e99270a3
commit b57607168a
15 changed files with 133 additions and 56 deletions

View file

@ -1,7 +1,7 @@
yuzu emulator early access yuzu emulator early access
============= =============
This is the source code for early-access 1793. This is the source code for early-access 1794.
## Legal Notice ## Legal Notice

View file

@ -149,6 +149,7 @@ struct Values {
Setting<bool> use_nvdec_emulation; Setting<bool> use_nvdec_emulation;
Setting<bool> accelerate_astc; Setting<bool> accelerate_astc;
Setting<bool> use_vsync; Setting<bool> use_vsync;
Setting<bool> disable_fps_limit;
Setting<bool> use_assembly_shaders; Setting<bool> use_assembly_shaders;
Setting<bool> use_asynchronous_shaders; Setting<bool> use_asynchronous_shaders;
Setting<bool> use_fast_gpu_time; Setting<bool> use_fast_gpu_time;
@ -224,7 +225,6 @@ struct Values {
bool reporting_services; bool reporting_services;
bool quest_flag; bool quest_flag;
bool disable_macro_jit; bool disable_macro_jit;
bool unlimit_fps;
bool extended_logging; bool extended_logging;
bool use_debug_asserts; bool use_debug_asserts;
bool use_auto_stub; bool use_auto_stub;

View file

@ -307,7 +307,7 @@ void NVFlinger::Compose() {
} }
s64 NVFlinger::GetNextTicks() const { s64 NVFlinger::GetNextTicks() const {
if (Settings::values.unlimit_fps) { if (Settings::values.disable_fps_limit.GetValue()) {
return 0; return 0;
} }
constexpr s64 max_hertz = 120LL; constexpr s64 max_hertz = 120LL;

View file

@ -18,11 +18,15 @@
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <cstring> #include <cstring>
#if __cpp_lib_parallel_algorithm
#include <execution>
#endif
#include <span> #include <span>
#include <vector> #include <vector>
#include <boost/container/static_vector.hpp> #include <boost/container/static_vector.hpp>
#include "common/alignment.h"
#include "common/common_types.h" #include "common/common_types.h"
#include "video_core/textures/astc.h" #include "video_core/textures/astc.h"
@ -1548,30 +1552,87 @@ static void DecompressBlock(std::span<const u8, 16> inBuf, const u32 blockWidth,
void Decompress(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth, void Decompress(std::span<const uint8_t> data, uint32_t width, uint32_t height, uint32_t depth,
uint32_t block_width, uint32_t block_height, std::span<uint8_t> output) { uint32_t block_width, uint32_t block_height, std::span<uint8_t> output) {
u32 block_index = 0; struct ASTCStrideInfo {
std::size_t depth_offset = 0; u32 z{};
for (u32 z = 0; z < depth; z++) { u32 index{};
for (u32 y = 0; y < height; y += block_height) { };
for (u32 x = 0; x < width; x += block_width) {
const u32 rows = Common::DivideUp(height, block_height);
const u32 cols = Common::DivideUp(width, block_width);
const u32 num_strides = depth * rows;
std::vector<ASTCStrideInfo> astc_strides(num_strides);
for (u32 z = 0; z < depth; ++z) {
for (u32 index = 0; index < rows; ++index) {
astc_strides.emplace_back(ASTCStrideInfo{
.z{z},
.index{index},
});
}
}
auto decompress_stride = [&](const ASTCStrideInfo& stride) {
const u32 y = stride.index * block_height;
const u32 depth_offset = stride.z * height * width * 4;
for (u32 x_index = 0; x_index < cols; ++x_index) {
const u32 block_index = stride.index * cols + x_index;
const u32 x = x_index * block_width;
const std::span<const u8, 16> blockPtr{data.subspan(block_index * 16, 16)}; const std::span<const u8, 16> blockPtr{data.subspan(block_index * 16, 16)};
// Blocks can be at most 12x12 // Blocks can be at most 12x12
std::array<u32, 12 * 12> uncompData; std::array<u32, 12 * 12> uncompData;
DecompressBlock(blockPtr, block_width, block_height, uncompData); DecompressBlock(blockPtr, block_width, block_height, uncompData);
u32 decompWidth = std::min(block_width, width - x); const u32 decompWidth = std::min(block_width, width - x);
u32 decompHeight = std::min(block_height, height - y); const u32 decompHeight = std::min(block_height, height - y);
const std::span<u8> outRow = output.subspan(depth_offset + (y * width + x) * 4); const std::span<u8> outRow = output.subspan(depth_offset + (y * width + x) * 4);
for (u32 jj = 0; jj < decompHeight; jj++) {
std::memcpy(outRow.data() + jj * width * 4, for (u32 h = 0; h < decompHeight; ++h) {
uncompData.data() + jj * block_width, decompWidth * 4); std::memcpy(outRow.data() + h * width * 4, uncompData.data() + h * block_width,
} decompWidth * 4);
++block_index;
} }
} }
depth_offset += height * width * 4; };
}
#if __cpp_lib_parallel_algorithm
std::for_each(std::execution::par, astc_strides.cbegin(), astc_strides.cend(),
decompress_stride);
#else
std::for_each(astc_strides.cbegin(), astc_strides.cend(), decompress_stride);
#endif
// const u32 rows = Common::DivideUp(height, block_height);
// const u32 cols = Common::DivideUp(width, block_width);
// for (u32 z = 0; z < depth; ++z) {
// const u32 depth_offset = z * height * width * 4;
// for (u32 y_index = 0; y_index < rows; ++y_index) {
// const u32 y = y_index * block_height;
// for (u32 x_index = 0; x_index < cols; ++x_index) {
// const u32 block_index = y_index * cols + x_index;
// const u32 x = x_index * block_width;
// const std::span<const u8, 16> blockPtr{data.subspan(block_index * 16, 16)};
// // Blocks can be at most 12x12
// std::array<u32, 12 * 12> uncompData;
// DecompressBlock(blockPtr, block_width, block_height, uncompData);
// u32 decompWidth = std::min(block_width, width - x);
// u32 decompHeight = std::min(block_height, height - y);
// const std::span<u8> outRow = output.subspan(depth_offset + (y * width + x) * 4);
// for (u32 h = 0; h < decompHeight; ++h) {
// std::memcpy(outRow.data() + h * width * 4, uncompData.data() + h *
// block_width,
// decompWidth * 4);
// }
// }
// }
// }
} }
} // namespace Tegra::Texture::ASTC } // namespace Tegra::Texture::ASTC

View file

@ -12,6 +12,14 @@ VkBool32 Callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
VkDebugUtilsMessageTypeFlagsEXT type, VkDebugUtilsMessageTypeFlagsEXT type,
const VkDebugUtilsMessengerCallbackDataEXT* data, const VkDebugUtilsMessengerCallbackDataEXT* data,
[[maybe_unused]] void* user_data) { [[maybe_unused]] void* user_data) {
// Skip logging known false-positive validation errors
switch (static_cast<u32>(data->messageIdNumber)) {
case 0x682a878au: // VUID-vkCmdBindVertexBuffers2EXT-pBuffers-parameter
case 0x99fb7dfdu: // UNASSIGNED-RequiredParameter (vkCmdBindVertexBuffers2EXT pBuffers[0])
return VK_FALSE;
default:
break;
}
const std::string_view message{data->pMessage}; const std::string_view message{data->pMessage};
if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) { if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
LOG_CRITICAL(Render_Vulkan, "{}", message); LOG_CRITICAL(Render_Vulkan, "{}", message);

View file

@ -821,13 +821,11 @@ void Device::CollectTelemetryParameters() {
void Device::CollectPhysicalMemoryInfo() { void Device::CollectPhysicalMemoryInfo() {
const auto mem_properties = physical.GetMemoryProperties(); const auto mem_properties = physical.GetMemoryProperties();
const std::size_t num_properties = mem_properties.memoryTypeCount; const std::size_t num_properties = mem_properties.memoryHeapCount;
device_access_memory = 0; device_access_memory = 0;
for (std::size_t element = 0; element < num_properties; element++) { for (std::size_t element = 0; element < num_properties; element++) {
if ((mem_properties.memoryTypes[element].propertyFlags & if ((mem_properties.memoryHeaps[element].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0) {
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0) { device_access_memory += mem_properties.memoryHeaps[element].size;
const std::size_t heap_index = mem_properties.memoryTypes[element].heapIndex;
device_access_memory += mem_properties.memoryHeaps[heap_index].size;
} }
} }
} }

View file

@ -236,9 +236,9 @@ const std::array<UISettings::Shortcut, 18> Config::default_hotkeys{{
{QStringLiteral("Restart Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}}, {QStringLiteral("Restart Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}},
{QStringLiteral("Stop Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}}, {QStringLiteral("Stop Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}},
{QStringLiteral("Toggle Filter Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}}, {QStringLiteral("Toggle Filter Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}},
{QStringLiteral("Toggle Framerate Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"), Qt::ApplicationShortcut}},
{QStringLiteral("Toggle Mouse Panning"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), Qt::ApplicationShortcut}}, {QStringLiteral("Toggle Mouse Panning"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), Qt::ApplicationShortcut}},
{QStringLiteral("Toggle Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}}, {QStringLiteral("Toggle Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}},
{QStringLiteral("Toggle Frame Limiter"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"), Qt::ApplicationShortcut}},
{QStringLiteral("Toggle Status Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}}, {QStringLiteral("Toggle Status Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}},
}}; }};
// clang-format on // clang-format on
@ -655,7 +655,6 @@ void Config::ReadDebuggingValues() {
Settings::values.quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool(); Settings::values.quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
Settings::values.disable_macro_jit = Settings::values.disable_macro_jit =
ReadSetting(QStringLiteral("disable_macro_jit"), false).toBool(); ReadSetting(QStringLiteral("disable_macro_jit"), false).toBool();
Settings::values.unlimit_fps = ReadSetting(QStringLiteral("unlimit_fps"), false).toBool();
Settings::values.extended_logging = Settings::values.extended_logging =
ReadSetting(QStringLiteral("extended_logging"), false).toBool(); ReadSetting(QStringLiteral("extended_logging"), false).toBool();
Settings::values.use_debug_asserts = Settings::values.use_debug_asserts =
@ -813,6 +812,8 @@ void Config::ReadRendererValues() {
true); true);
ReadSettingGlobal(Settings::values.accelerate_astc, QStringLiteral("accelerate_astc"), true); ReadSettingGlobal(Settings::values.accelerate_astc, QStringLiteral("accelerate_astc"), true);
ReadSettingGlobal(Settings::values.use_vsync, QStringLiteral("use_vsync"), true); ReadSettingGlobal(Settings::values.use_vsync, QStringLiteral("use_vsync"), true);
ReadSettingGlobal(Settings::values.disable_fps_limit, QStringLiteral("disable_fps_limit"),
false);
ReadSettingGlobal(Settings::values.use_assembly_shaders, QStringLiteral("use_assembly_shaders"), ReadSettingGlobal(Settings::values.use_assembly_shaders, QStringLiteral("use_assembly_shaders"),
false); false);
ReadSettingGlobal(Settings::values.use_asynchronous_shaders, ReadSettingGlobal(Settings::values.use_asynchronous_shaders,
@ -1269,7 +1270,6 @@ void Config::SaveDebuggingValues() {
WriteSetting(QStringLiteral("quest_flag"), Settings::values.quest_flag, false); WriteSetting(QStringLiteral("quest_flag"), Settings::values.quest_flag, false);
WriteSetting(QStringLiteral("use_debug_asserts"), Settings::values.use_debug_asserts, false); WriteSetting(QStringLiteral("use_debug_asserts"), Settings::values.use_debug_asserts, false);
WriteSetting(QStringLiteral("disable_macro_jit"), Settings::values.disable_macro_jit, false); WriteSetting(QStringLiteral("disable_macro_jit"), Settings::values.disable_macro_jit, false);
WriteSetting(QStringLiteral("unlimit_fps"), Settings::values.unlimit_fps, false);
qt_config->endGroup(); qt_config->endGroup();
} }
@ -1399,6 +1399,8 @@ void Config::SaveRendererValues() {
true); true);
WriteSettingGlobal(QStringLiteral("accelerate_astc"), Settings::values.accelerate_astc, true); WriteSettingGlobal(QStringLiteral("accelerate_astc"), Settings::values.accelerate_astc, true);
WriteSettingGlobal(QStringLiteral("use_vsync"), Settings::values.use_vsync, true); WriteSettingGlobal(QStringLiteral("use_vsync"), Settings::values.use_vsync, true);
WriteSettingGlobal(QStringLiteral("disable_fps_limit"), Settings::values.disable_fps_limit,
false);
WriteSettingGlobal(QStringLiteral("use_assembly_shaders"), WriteSettingGlobal(QStringLiteral("use_assembly_shaders"),
Settings::values.use_assembly_shaders, false); Settings::values.use_assembly_shaders, false);
WriteSettingGlobal(QStringLiteral("use_asynchronous_shaders"), WriteSettingGlobal(QStringLiteral("use_asynchronous_shaders"),

View file

@ -44,7 +44,6 @@ void ConfigureDebug::SetConfiguration() {
ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug); ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug);
ui->disable_macro_jit->setEnabled(runtime_lock); ui->disable_macro_jit->setEnabled(runtime_lock);
ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit); ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit);
ui->unlimit_fps->setChecked(Settings::values.unlimit_fps);
ui->extended_logging->setChecked(Settings::values.extended_logging); ui->extended_logging->setChecked(Settings::values.extended_logging);
} }
@ -59,7 +58,6 @@ void ConfigureDebug::ApplyConfiguration() {
Settings::values.use_auto_stub = ui->use_auto_stub->isChecked(); Settings::values.use_auto_stub = ui->use_auto_stub->isChecked();
Settings::values.renderer_debug = ui->enable_graphics_debugging->isChecked(); Settings::values.renderer_debug = ui->enable_graphics_debugging->isChecked();
Settings::values.disable_macro_jit = ui->disable_macro_jit->isChecked(); Settings::values.disable_macro_jit = ui->disable_macro_jit->isChecked();
Settings::values.unlimit_fps = ui->unlimit_fps->isChecked();
Settings::values.extended_logging = ui->extended_logging->isChecked(); Settings::values.extended_logging = ui->extended_logging->isChecked();
Debugger::ToggleConsole(); Debugger::ToggleConsole();
Common::Log::Filter filter; Common::Log::Filter filter;

View file

@ -138,24 +138,6 @@
</property> </property>
</widget> </widget>
</item> </item>
<item>
<widget class="QCheckBox" name="unlimit_fps">
<property name="enabled">
<bool>true</bool>
</property>
<property name="toolTip">
<string>
&lt;html&gt;&lt;head/&gt;&lt;body&gt;
&lt;p&gt;Presents guest frames as they become available, disabling the fps limit in most titles.&lt;/p&gt;
&lt;p&gt;NOTE: Will cause instabilities.&lt;/p&gt;
&lt;/body&gt;&lt;/html&gt;
</string>
</property>
<property name="text">
<string>Unlimit Framerate (Experimental)</string>
</property>
</widget>
</item>
</layout> </layout>
</widget> </widget>
</item> </item>

View file

@ -28,6 +28,7 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
ui->anisotropic_filtering_combobox->setEnabled(runtime_lock); ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
ui->use_vsync->setChecked(Settings::values.use_vsync.GetValue()); ui->use_vsync->setChecked(Settings::values.use_vsync.GetValue());
ui->disable_fps_limit->setChecked(Settings::values.disable_fps_limit.GetValue());
ui->use_assembly_shaders->setChecked(Settings::values.use_assembly_shaders.GetValue()); ui->use_assembly_shaders->setChecked(Settings::values.use_assembly_shaders.GetValue());
ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue()); ui->use_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.GetValue());
ui->use_caches_gc->setChecked(Settings::values.use_caches_gc.GetValue()); ui->use_caches_gc->setChecked(Settings::values.use_caches_gc.GetValue());
@ -58,6 +59,8 @@ void ConfigureGraphicsAdvanced::ApplyConfiguration() {
ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy, ConfigurationShared::ApplyPerGameSetting(&Settings::values.max_anisotropy,
ui->anisotropic_filtering_combobox); ui->anisotropic_filtering_combobox);
ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync, use_vsync); ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_vsync, ui->use_vsync, use_vsync);
ConfigurationShared::ApplyPerGameSetting(&Settings::values.disable_fps_limit,
ui->disable_fps_limit, disable_fps_limit);
ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_assembly_shaders, ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_assembly_shaders,
ui->use_assembly_shaders, use_assembly_shaders); ui->use_assembly_shaders, use_assembly_shaders);
ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders, ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders,
@ -100,6 +103,7 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
if (Settings::IsConfiguringGlobal()) { if (Settings::IsConfiguringGlobal()) {
ui->gpu_accuracy->setEnabled(Settings::values.gpu_accuracy.UsingGlobal()); ui->gpu_accuracy->setEnabled(Settings::values.gpu_accuracy.UsingGlobal());
ui->use_vsync->setEnabled(Settings::values.use_vsync.UsingGlobal()); ui->use_vsync->setEnabled(Settings::values.use_vsync.UsingGlobal());
ui->disable_fps_limit->setEnabled(Settings::values.disable_fps_limit.UsingGlobal());
ui->use_assembly_shaders->setEnabled(Settings::values.use_assembly_shaders.UsingGlobal()); ui->use_assembly_shaders->setEnabled(Settings::values.use_assembly_shaders.UsingGlobal());
ui->use_asynchronous_shaders->setEnabled( ui->use_asynchronous_shaders->setEnabled(
Settings::values.use_asynchronous_shaders.UsingGlobal()); Settings::values.use_asynchronous_shaders.UsingGlobal());
@ -112,6 +116,8 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
} }
ConfigurationShared::SetColoredTristate(ui->use_vsync, Settings::values.use_vsync, use_vsync); ConfigurationShared::SetColoredTristate(ui->use_vsync, Settings::values.use_vsync, use_vsync);
ConfigurationShared::SetColoredTristate(ui->disable_fps_limit,
Settings::values.disable_fps_limit, disable_fps_limit);
ConfigurationShared::SetColoredTristate( ConfigurationShared::SetColoredTristate(
ui->use_assembly_shaders, Settings::values.use_assembly_shaders, use_assembly_shaders); ui->use_assembly_shaders, Settings::values.use_assembly_shaders, use_assembly_shaders);
ConfigurationShared::SetColoredTristate(ui->use_asynchronous_shaders, ConfigurationShared::SetColoredTristate(ui->use_asynchronous_shaders,

View file

@ -35,6 +35,7 @@ private:
std::unique_ptr<Ui::ConfigureGraphicsAdvanced> ui; std::unique_ptr<Ui::ConfigureGraphicsAdvanced> ui;
ConfigurationShared::CheckState use_vsync; ConfigurationShared::CheckState use_vsync;
ConfigurationShared::CheckState disable_fps_limit;
ConfigurationShared::CheckState use_assembly_shaders; ConfigurationShared::CheckState use_assembly_shaders;
ConfigurationShared::CheckState use_asynchronous_shaders; ConfigurationShared::CheckState use_asynchronous_shaders;
ConfigurationShared::CheckState use_fast_gpu_time; ConfigurationShared::CheckState use_fast_gpu_time;

View file

@ -76,6 +76,24 @@
</property> </property>
</widget> </widget>
</item> </item>
<item>
<widget class="QCheckBox" name="disable_fps_limit">
<property name="enabled">
<bool>true</bool>
</property>
<property name="toolTip">
<string>
&lt;html&gt;&lt;head/&gt;&lt;body&gt;
&lt;p&gt;Presents guest frames as they become available, disabling the FPS limit in most titles.&lt;/p&gt;
&lt;p&gt;NOTE: Will cause instabilities.&lt;/p&gt;
&lt;/body&gt;&lt;/html&gt;
</string>
</property>
<property name="text">
<string>Disable framerate limit (experimental)</string>
</property>
</widget>
</item>
<item> <item>
<widget class="QCheckBox" name="use_assembly_shaders"> <widget class="QCheckBox" name="use_assembly_shaders">
<property name="toolTip"> <property name="toolTip">
@ -109,7 +127,7 @@
<string>Enables garbage collection for the GPU caches, this will try to keep VRAM within 3-4 GB by flushing the least used textures/buffers. May cause issues in a few games.</string> <string>Enables garbage collection for the GPU caches, this will try to keep VRAM within 3-4 GB by flushing the least used textures/buffers. May cause issues in a few games.</string>
</property> </property>
<property name="text"> <property name="text">
<string>Enable GPU cache garbage collection (unsafe)</string> <string>Enable GPU cache garbage collection (experimental)</string>
</property> </property>
</widget> </widget>
</item> </item>

View file

@ -1025,9 +1025,11 @@ void GMainWindow::InitializeHotkeys() {
connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Mute Audio"), this), connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Mute Audio"), this),
&QShortcut::activated, this, &QShortcut::activated, this,
[] { Settings::values.audio_muted = !Settings::values.audio_muted; }); [] { Settings::values.audio_muted = !Settings::values.audio_muted; });
connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Toggle Frame Limiter"), this), connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Toggle Framerate Limit"), this),
&QShortcut::activated, this, &QShortcut::activated, this, [] {
[] { Settings::values.unlimit_fps = !Settings::values.unlimit_fps; }); Settings::values.disable_fps_limit.SetValue(
!Settings::values.disable_fps_limit.GetValue());
});
connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Toggle Mouse Panning"), this), connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Toggle Mouse Panning"), this),
&QShortcut::activated, this, [&] { &QShortcut::activated, this, [&] {
Settings::values.mouse_panning = !Settings::values.mouse_panning; Settings::values.mouse_panning = !Settings::values.mouse_panning;

View file

@ -443,6 +443,8 @@ void Config::ReadValues() {
sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", true)); sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", true));
Settings::values.use_vsync.SetValue( Settings::values.use_vsync.SetValue(
static_cast<u16>(sdl2_config->GetInteger("Renderer", "use_vsync", 1))); static_cast<u16>(sdl2_config->GetInteger("Renderer", "use_vsync", 1)));
Settings::values.disable_fps_limit.SetValue(
sdl2_config->GetBoolean("Renderer", "disable_fps_limit", false));
Settings::values.use_assembly_shaders.SetValue( Settings::values.use_assembly_shaders.SetValue(
sdl2_config->GetBoolean("Renderer", "use_assembly_shaders", true)); sdl2_config->GetBoolean("Renderer", "use_assembly_shaders", true));
Settings::values.use_asynchronous_shaders.SetValue( Settings::values.use_asynchronous_shaders.SetValue(
@ -490,7 +492,6 @@ void Config::ReadValues() {
Settings::values.disable_macro_jit = Settings::values.disable_macro_jit =
sdl2_config->GetBoolean("Debugging", "disable_macro_jit", false); sdl2_config->GetBoolean("Debugging", "disable_macro_jit", false);
Settings::values.unlimit_fps = sdl2_config->GetBoolean("Debugging", "unlimit_fps", false);
const auto title_list = sdl2_config->Get("AddOns", "title_ids", ""); const auto title_list = sdl2_config->Get("AddOns", "title_ids", "");
std::stringstream ss(title_list); std::stringstream ss(title_list);

View file

@ -368,7 +368,7 @@ use_auto_stub =
disable_macro_jit=false disable_macro_jit=false
# Presents guest frames as they become available. Experimental. # Presents guest frames as they become available. Experimental.
# false: Disabled (default), true: Enabled # false: Disabled (default), true: Enabled
unlimit_fps=false disable_fps_limit=false
[WebService] [WebService]
# Whether or not to enable telemetry # Whether or not to enable telemetry