renderer_vulkan: Fix staging buffer size

src/citra_qt/configuration/config.cpp

@@ -332,7 +332,8 @@ void Config::ReadDebuggingValues() {
     Settings::values.use_gdbstub = ReadSetting(QStringLiteral("use_gdbstub"), false).toBool();
     Settings::values.gdbstub_port = ReadSetting(QStringLiteral("gdbstub_port"), 24689).toInt();
     Settings::values.renderer_debug = ReadSetting(QStringLiteral("renderer_debug"), false).toBool();
-    Settings::values.dump_command_buffers = ReadSetting(QStringLiteral("dump_command_buffers"), false).toBool();
+    Settings::values.dump_command_buffers =
+        ReadSetting(QStringLiteral("dump_command_buffers"), false).toBool();
 
     qt_config->beginGroup(QStringLiteral("LLE"));
     for (const auto& service_module : Service::service_module_map) {
@@ -893,7 +894,8 @@ void Config::SaveDebuggingValues() {
     WriteSetting(QStringLiteral("use_gdbstub"), Settings::values.use_gdbstub, false);
     WriteSetting(QStringLiteral("gdbstub_port"), Settings::values.gdbstub_port, 24689);
     WriteSetting(QStringLiteral("renderer_debug"), Settings::values.renderer_debug, false);
-    WriteSetting(QStringLiteral("dump_command_buffers"), Settings::values.dump_command_buffers, false);
+    WriteSetting(QStringLiteral("dump_command_buffers"), Settings::values.dump_command_buffers,
+                 false);
 
     qt_config->beginGroup(QStringLiteral("LLE"));
     for (const auto& service_module : Settings::values.lle_modules) {

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -154,11 +154,14 @@ struct ScreenRectVertex {
 constexpr u32 VERTEX_BUFFER_SIZE = sizeof(ScreenRectVertex) * 8192;
 
 RendererVulkan::RendererVulkan(Frontend::EmuWindow& window)
-    : RendererBase{window}, instance{window, Settings::values.physical_device},
+    : RendererBase{window}, instance{window, Settings::values.physical_device}, scheduler{instance,
-      scheduler{instance, *this}, renderpass_cache{instance, scheduler},
+                                                                                          *this},
-      runtime{instance, scheduler, renderpass_cache}, swapchain{instance, renderpass_cache},
+      renderpass_cache{instance, scheduler}, runtime{instance, scheduler, renderpass_cache},
-      vertex_buffer{
+      swapchain{instance, renderpass_cache}, vertex_buffer{instance,
-          instance, scheduler, VERTEX_BUFFER_SIZE, vk::BufferUsageFlagBits::eVertexBuffer, {}} {
+                                                           scheduler,
+                                                           VERTEX_BUFFER_SIZE,
+                                                           vk::BufferUsageFlagBits::eVertexBuffer,
+                                                           {}} {
 
     auto& telemetry_session = Core::System::GetInstance().TelemetrySession();
     constexpr auto user_system = Common::Telemetry::FieldType::UserSystem;

src/video_core/renderer_vulkan/vk_instance.cpp

@@ -4,8 +4,8 @@
 
 #include <span>
 #include "common/assert.h"
-#include "core/settings.h"
 #include "core/frontend/emu_window.h"
+#include "core/settings.h"
 #include "video_core/renderer_vulkan/vk_instance.h"
 #include "video_core/renderer_vulkan/vk_platform.h"
 

src/video_core/renderer_vulkan/vk_instance.h

@@ -87,7 +87,6 @@ public:
 
     /// Returns true when VK_KHR_timeline_semaphore is supported
     bool IsTimelineSemaphoreSupported() const {
-        return false;
         return timeline_semaphores;
     }
 

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -604,8 +604,8 @@ void PipelineCache::BindDescriptorSets() {
                 try {
                     batch = device.allocateDescriptorSets(alloc_info);
                 } catch (vk::OutOfPoolMemoryError& err) {
-                    LOG_CRITICAL(Render_Vulkan, "Run out of pool memory for layout {}: {}",
+                    LOG_CRITICAL(Render_Vulkan, "Run out of pool memory for layout {}: {}", i,
-                                 i, err.what());
+                                 err.what());
                     UNREACHABLE();
                 }
             }

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -1589,17 +1589,15 @@ bool RasterizerVulkan::AccelerateDisplay(const GPU::Regs::FramebufferConfig& con
 
 vk::Sampler RasterizerVulkan::CreateSampler(const SamplerInfo& info) {
     const bool use_border_color = instance.IsCustomBorderColorSupported() &&
-            (info.wrap_s == SamplerInfo::TextureConfig::ClampToBorder ||
+                                  (info.wrap_s == SamplerInfo::TextureConfig::ClampToBorder ||
-            info.wrap_t == SamplerInfo::TextureConfig::ClampToBorder);
+                                   info.wrap_t == SamplerInfo::TextureConfig::ClampToBorder);
     auto properties = instance.GetPhysicalDevice().getProperties();
 
     const auto color = PicaToVK::ColorRGBA8(info.border_color);
     const vk::SamplerCustomBorderColorCreateInfoEXT border_color_info = {
-        .customBorderColor = vk::ClearColorValue{
+        .customBorderColor =
-            .float32 = std::array{color[0], color[1], color[2], color[3]}
+            vk::ClearColorValue{.float32 = std::array{color[0], color[1], color[2], color[3]}},
-        },
+        .format = vk::Format::eUndefined};
-        .format = vk::Format::eUndefined
-    };
 
     const vk::SamplerCreateInfo sampler_info = {
         .pNext = use_border_color ? &border_color_info : nullptr,
@@ -1615,8 +1613,8 @@ vk::Sampler RasterizerVulkan::CreateSampler(const SamplerInfo& info) {
         .compareOp = vk::CompareOp::eAlways,
         .minLod = info.lod_min,
         .maxLod = info.lod_max,
-        .borderColor = use_border_color ? vk::BorderColor::eFloatCustomEXT
+        .borderColor =
-                                        : vk::BorderColor::eIntOpaqueBlack,
+            use_border_color ? vk::BorderColor::eFloatCustomEXT : vk::BorderColor::eIntOpaqueBlack,
         .unnormalizedCoordinates = false};
 
     vk::Device device = instance.GetDevice();

src/video_core/renderer_vulkan/vk_stream_buffer.cpp

@@ -67,9 +67,8 @@ StagingBuffer::~StagingBuffer() {
 
 StreamBuffer::StreamBuffer(const Instance& instance, TaskScheduler& scheduler, u32 size,
                            vk::BufferUsageFlagBits usage, std::span<const vk::Format> view_formats)
-    : instance{instance}, scheduler{scheduler}, staging{instance, size,
+    : instance{instance}, scheduler{scheduler}, total_size{size * SCHEDULER_COMMAND_COUNT},
-                                                        vk::BufferUsageFlagBits::eTransferSrc},
+      staging{instance, total_size, vk::BufferUsageFlagBits::eTransferSrc}, usage{usage} {
-      usage{usage}, total_size{size * SCHEDULER_COMMAND_COUNT} {
 
     const vk::BufferCreateInfo buffer_info = {
         .size = total_size, .usage = usage | vk::BufferUsageFlagBits::eTransferDst};

src/video_core/renderer_vulkan/vk_stream_buffer.h

@@ -75,12 +75,12 @@ private:
 
     const Instance& instance;
     TaskScheduler& scheduler;
+    u32 total_size = 0;
     StagingBuffer staging;
 
     vk::Buffer buffer{};
     VmaAllocation allocation{};
     vk::BufferUsageFlagBits usage;
-    u32 total_size = 0;
     std::array<vk::BufferView, MAX_BUFFER_VIEWS> views{};
     std::size_t view_count = 0;