fix-formatting

src/citra_qt/main.cpp

@@ -3215,4 +3215,3 @@ int main(int argc, char* argv[]) {
     detached_tasks.WaitForAllTasks();
     return result;
 }
-

src/core/core.h

@@ -458,4 +458,3 @@ private:
 } // namespace Core
 
 BOOST_CLASS_VERSION(Core::System, 1)
-

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -75,8 +75,9 @@ static std::array<GLfloat, 3 * 2> MakeOrthographicMatrix(const float width, cons
 RendererOpenGL::RendererOpenGL(Core::System& system, Pica::PicaCore& pica_,
                                Frontend::EmuWindow& window, Frontend::EmuWindow* secondary_window)
     : VideoCore::RendererBase{system, window, secondary_window}, pica{pica_},
-      rasterizer{system.Memory(), pica, system.CustomTexManager(), *this, driver},
+      rasterizer{system.Memory(), pica, system.CustomTexManager(), *this, driver}, frame_dumper{
-      frame_dumper{system, window} {
+                                                                                       system,
+                                                                                       window} {
     const bool has_debug_tool = driver.HasDebugTool();
     window.mailbox = std::make_unique<OGLTextureMailbox>(has_debug_tool);
     if (secondary_window) {

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -54,8 +54,8 @@ RendererVulkan::RendererVulkan(Core::System& system, Pica::PicaCore& pica_,
                                Frontend::EmuWindow& window, Frontend::EmuWindow* secondary_window)
     : RendererBase{system, window, secondary_window}, memory{system.Memory()}, pica{pica_},
       instance{window, Settings::values.physical_device.GetValue()}, scheduler{instance},
-      renderpass_cache{instance, scheduler}, pool{instance},
+      renderpass_cache{instance, scheduler}, pool{instance}, main_window{window, instance,
-      main_window{window, instance, scheduler},
+                                                                         scheduler},
       vertex_buffer{instance, scheduler, vk::BufferUsageFlagBits::eVertexBuffer,
                     VERTEX_BUFFER_SIZE},
       rasterizer{memory,

src/video_core/renderer_vulkan/vk_instance.cpp

@@ -132,16 +132,16 @@ std::string GetReadableVersion(u32 version) {
 } // Anonymous namespace
 
 Instance::Instance(bool enable_validation, bool dump_command_buffers)
-    : library{OpenLibrary()},
+    : library{OpenLibrary()}, instance{CreateInstance(*library,
-      instance{CreateInstance(*library, Frontend::WindowSystemType::Headless, enable_validation,
+                                                      Frontend::WindowSystemType::Headless,
-                              dump_command_buffers)},
+                                                      enable_validation, dump_command_buffers)},
       physical_devices{instance->enumeratePhysicalDevices()} {}
 
 Instance::Instance(Frontend::EmuWindow& window, u32 physical_device_index)
-    : library{OpenLibrary(&window)},
+    : library{OpenLibrary(&window)}, instance{CreateInstance(
-      instance{CreateInstance(*library, window.GetWindowInfo().type,
+                                         *library, window.GetWindowInfo().type,
-                              Settings::values.renderer_debug.GetValue(),
+                                         Settings::values.renderer_debug.GetValue(),
-                              Settings::values.dump_command_buffers.GetValue())},
+                                         Settings::values.dump_command_buffers.GetValue())},
       debug_callback{CreateDebugCallback(*instance, debug_utils_supported)},
       physical_devices{instance->enumeratePhysicalDevices()} {
     const std::size_t num_physical_devices = static_cast<u16>(physical_devices.size());

src/video_core/renderer_vulkan/vk_present_window.cpp

@@ -100,9 +100,9 @@ bool CanBlitToSwapchain(const vk::PhysicalDevice& physical_device, vk::Format fo
 PresentWindow::PresentWindow(Frontend::EmuWindow& emu_window_, const Instance& instance_,
                              Scheduler& scheduler_)
     : emu_window{emu_window_}, instance{instance_}, scheduler{scheduler_},
-      surface{CreateSurface(instance.GetInstance(), emu_window)}, next_surface{surface},
+      surface{CreateSurface(instance.GetInstance(), emu_window)},
-      swapchain{instance, emu_window.GetFramebufferLayout().width,
+      next_surface{surface}, swapchain{instance, emu_window.GetFramebufferLayout().width,
-                emu_window.GetFramebufferLayout().height, surface},
+                                       emu_window.GetFramebufferLayout().height, surface},
       graphics_queue{instance.GetGraphicsQueue()}, present_renderpass{CreateRenderpass()},
       vsync_enabled{Settings::values.use_vsync_new.GetValue()},
       blit_supported{

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -61,8 +61,8 @@ RasterizerVulkan::RasterizerVulkan(Memory::MemorySystem& memory, Pica::PicaCore&
                                    Scheduler& scheduler, DescriptorPool& pool,
                                    RenderpassCache& renderpass_cache, u32 image_count)
     : RasterizerAccelerated{memory, pica}, instance{instance}, scheduler{scheduler},
-      renderpass_cache{renderpass_cache},
+      renderpass_cache{renderpass_cache}, pipeline_cache{instance, scheduler, renderpass_cache,
-      pipeline_cache{instance, scheduler, renderpass_cache, pool},
+                                                         pool},
       runtime{instance,   scheduler, renderpass_cache, pool, pipeline_cache.TextureProvider(),
               image_count},
       res_cache{memory, custom_tex_manager, runtime, regs, renderer},

src/video_core/renderer_vulkan/vk_texture_runtime.cpp

@@ -1458,8 +1458,8 @@ void Surface::BlitScale(const VideoCore::TextureBlit& blit, bool up_scale) {
 
 Framebuffer::Framebuffer(TextureRuntime& runtime, const VideoCore::FramebufferParams& params,
                          Surface* color, Surface* depth)
-    : VideoCore::FramebufferParams{params},
+    : VideoCore::FramebufferParams{params}, res_scale{color ? color->res_scale
-      res_scale{color ? color->res_scale : (depth ? depth->res_scale : 1u)} {
+                                                            : (depth ? depth->res_scale : 1u)} {
     auto& renderpass_cache = runtime.GetRenderpassCache();
     if (shadow_rendering && !color) {
         return;
@@ -1552,8 +1552,8 @@ Sampler::Sampler(TextureRuntime& runtime, const VideoCore::SamplerParams& params
 Sampler::~Sampler() = default;
 
 DebugScope::DebugScope(TextureRuntime& runtime, Common::Vec4f color, std::string_view label)
-    : scheduler{runtime.GetScheduler()},
+    : scheduler{runtime.GetScheduler()}, has_debug_tool{
-      has_debug_tool{runtime.GetInstance().HasDebuggingToolAttached()} {
+                                             runtime.GetInstance().HasDebuggingToolAttached()} {
     if (!has_debug_tool) {
         return;
     }