early-access version 1794

README.md

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

src/common/settings.h

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

src/core/hle/service/nvflinger/nvflinger.cpp

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

src/video_core/textures/astc.cpp

@@ -18,11 +18,15 @@
 #include <algorithm>
 #include <cassert>
 #include <cstring>
+#if __cpp_lib_parallel_algorithm
+#include <execution>
+#endif
 #include <span>
 #include <vector>
 
 #include <boost/container/static_vector.hpp>
 
+#include "common/alignment.h"
 #include "common/common_types.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,
                 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 std::span<const u8, 16> blockPtr{data.subspan(block_index * 16, 16)};
 
-                // Blocks can be at most 12x12
+    const u32 rows = Common::DivideUp(height, block_height);
-                std::array<u32, 12 * 12> uncompData;
+    const u32 cols = Common::DivideUp(width, block_width);
-                DecompressBlock(blockPtr, block_width, block_height, uncompData);
 
-                u32 decompWidth = std::min(block_width, width - x);
+    const u32 num_strides = depth * rows;
-                u32 decompHeight = std::min(block_height, height - y);
+    std::vector<ASTCStrideInfo> astc_strides(num_strides);
 
-                const std::span<u8> outRow = output.subspan(depth_offset + (y * width + x) * 4);
+    for (u32 z = 0; z < depth; ++z) {
-                for (u32 jj = 0; jj < decompHeight; jj++) {
+        for (u32 index = 0; index < rows; ++index) {
-                    std::memcpy(outRow.data() + jj * width * 4,
+            astc_strides.emplace_back(ASTCStrideInfo{
-                                uncompData.data() + jj * block_width, decompWidth * 4);
+                .z{z},
-                }
+                .index{index},
-                ++block_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)};
+
+            // Blocks can be at most 12x12
+            std::array<u32, 12 * 12> uncompData;
+            DecompressBlock(blockPtr, block_width, block_height, uncompData);
+
+            const u32 decompWidth = std::min(block_width, width - x);
+            const 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);
             }
         }
-        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

src/video_core/vulkan_common/vulkan_debug_callback.cpp

@@ -12,6 +12,14 @@ VkBool32 Callback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
                   VkDebugUtilsMessageTypeFlagsEXT type,
                   const VkDebugUtilsMessengerCallbackDataEXT* 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};
     if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
         LOG_CRITICAL(Render_Vulkan, "{}", message);

src/video_core/vulkan_common/vulkan_device.cpp

@@ -821,13 +821,11 @@ void Device::CollectTelemetryParameters() {
 
 void Device::CollectPhysicalMemoryInfo() {
     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;
     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;
         }
     }
 }

src/yuzu/configuration/config.cpp

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

src/yuzu/configuration/configure_debug.cpp

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

src/yuzu/configuration/configure_debug.ui

@@ -138,24 +138,6 @@
         </property>
        </widget>
       </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>
     </widget>
    </item>

src/yuzu/configuration/configure_graphics_advanced.cpp

@@ -28,6 +28,7 @@ void ConfigureGraphicsAdvanced::SetConfiguration() {
     ui->anisotropic_filtering_combobox->setEnabled(runtime_lock);
 
     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_asynchronous_shaders->setChecked(Settings::values.use_asynchronous_shaders.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,
                                              ui->anisotropic_filtering_combobox);
     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,
                                              ui->use_assembly_shaders, use_assembly_shaders);
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_asynchronous_shaders,
@@ -100,6 +103,7 @@ void ConfigureGraphicsAdvanced::SetupPerGameUI() {
     if (Settings::IsConfiguringGlobal()) {
         ui->gpu_accuracy->setEnabled(Settings::values.gpu_accuracy.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_asynchronous_shaders->setEnabled(
             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->disable_fps_limit,
+                                            Settings::values.disable_fps_limit, disable_fps_limit);
     ConfigurationShared::SetColoredTristate(
         ui->use_assembly_shaders, Settings::values.use_assembly_shaders, use_assembly_shaders);
     ConfigurationShared::SetColoredTristate(ui->use_asynchronous_shaders,

src/yuzu/configuration/configure_graphics_advanced.h

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

src/yuzu/configuration/configure_graphics_advanced.ui

@@ -76,6 +76,24 @@
           </property>
          </widget>
         </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>
          <widget class="QCheckBox" name="use_assembly_shaders">
           <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>
           </property>
           <property name="text">
-           <string>Enable GPU cache garbage collection (unsafe)</string>
+           <string>Enable GPU cache garbage collection (experimental)</string>
           </property>
          </widget>
         </item>

src/yuzu/main.cpp

@@ -1025,9 +1025,11 @@ void GMainWindow::InitializeHotkeys() {
     connect(hotkey_registry.GetHotkey(main_window, QStringLiteral("Mute Audio"), this),
             &QShortcut::activated, this,
             [] { 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),
             &QShortcut::activated, this, [&] {
                 Settings::values.mouse_panning = !Settings::values.mouse_panning;

src/yuzu_cmd/config.cpp

@@ -443,6 +443,8 @@ void Config::ReadValues() {
         sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", true));
     Settings::values.use_vsync.SetValue(
         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(
         sdl2_config->GetBoolean("Renderer", "use_assembly_shaders", true));
     Settings::values.use_asynchronous_shaders.SetValue(
@@ -490,7 +492,6 @@ void Config::ReadValues() {
 
     Settings::values.disable_macro_jit =
         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", "");
     std::stringstream ss(title_list);

src/yuzu_cmd/default_ini.h

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