.github/workflows/build.yml

@@ -81,7 +81,7 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-${{ matrix.target }}-
       - name: Install tools
-        run: brew install ccache ninja
+        run: brew install ccache glslang ninja
       - name: Build
         run: ./.ci/macos.sh
       - name: Prepare outputs for caching
@@ -153,6 +153,13 @@ jobs:
       - name: Install extra tools (MSVC)
         run: choco install ccache ninja wget
         if: ${{ matrix.target == 'msvc' }}
+      - name: Set up Vulkan SDK (MSVC)
+        uses: humbletim/setup-vulkan-sdk@v1.2.0
+        if: ${{ matrix.target == 'msvc' }}
+        with:
+          vulkan-query-version: latest
+          vulkan-components: SPIRV-Tools, Glslang
+          vulkan-use-cache: true
       - name: Set up MSYS2
         uses: msys2/setup-msys2@v2
         if: ${{ matrix.target == 'msys2' }}
@@ -161,8 +168,10 @@ jobs:
           update: true
           install: git make p7zip
           pacboy: >-
-            toolchain:p ccache:p cmake:p ninja:p
+            toolchain:p ccache:p cmake:p ninja:p glslang:p
             qt6-base:p qt6-multimedia:p qt6-multimedia-wmf:p qt6-tools:p qt6-translations:p
+      - name: Test glslang
+        run: glslang --version || glslangValidator --version
       - name: Disable line ending translation
         run: git config --global core.autocrlf input
       - name: Build
@@ -206,7 +215,7 @@ jobs:
         run: |
           sudo add-apt-repository -y ppa:theofficialgman/gpu-tools
           sudo apt-get update -y
-          sudo apt-get install ccache apksigner -y
+          sudo apt-get install ccache glslang-dev glslang-tools apksigner -y
       - name: Build
         run: JAVA_HOME=$JAVA_HOME_17_X64 ./.ci/android.sh
         env:
@@ -244,7 +253,7 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-ios-
       - name: Install tools
-        run: brew install ccache ninja
+        run: brew install ccache glslang ninja
       - name: Build
         run: ./.ci/ios.sh
   release:

src/common/logging/backend.cpp

@@ -451,7 +451,7 @@ void SetColorConsoleBackendEnabled(bool enabled) {
 }
 
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args) {
     if (!initialization_in_progress_suppress_logging) {
         Impl::Instance().PushEntry(log_class, log_level, filename, line_num, function,

src/common/logging/log.h

@@ -24,12 +24,12 @@ constexpr const char* TrimSourcePath(std::string_view source) {
 
 /// Logs a message to the global logger, using fmt
 void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename,
-                       unsigned int line_num, const char* function, fmt::string_view format,
+                       unsigned int line_num, const char* function, const char* format,
                        const fmt::format_args& args);
 
 template <typename... Args>
 void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, fmt::format_string<Args...> format, const Args&... args) {
+                   const char* function, const char* format, const Args&... args) {
     FmtLogMessageImpl(log_class, log_level, filename, line_num, function, format,
                       fmt::make_format_args(args...));
 }

src/core/hle/kernel/config_mem.cpp

@@ -14,18 +14,18 @@ namespace ConfigMem {
 Handler::Handler() {
     std::memset(&config_mem, 0, sizeof(config_mem));
 
-    // Values extracted from firmware 11.17.0-50E
+    // Values extracted from firmware 11.2.0-35E
-    config_mem.kernel_version_min = 0x3a;
+    config_mem.kernel_version_min = 0x34;
     config_mem.kernel_version_maj = 0x2;
     config_mem.ns_tid = 0x0004013000008002;
     config_mem.sys_core_ver = 0x2;
     config_mem.unit_info = 0x1; // Bit 0 set for Retail
     config_mem.prev_firm = 0x1;
-    config_mem.ctr_sdk_ver = 0x0000F450;
+    config_mem.ctr_sdk_ver = 0x0000F297;
-    config_mem.firm_version_min = 0x3a;
+    config_mem.firm_version_min = 0x34;
     config_mem.firm_version_maj = 0x2;
     config_mem.firm_sys_core_ver = 0x2;
-    config_mem.firm_ctr_sdk_ver = 0x0000F450;
+    config_mem.firm_ctr_sdk_ver = 0x0000F297;
 }
 
 ConfigMemDef& Handler::GetConfigMem() {

src/core/hle/kernel/process.cpp

@@ -210,10 +210,10 @@ void Process::Set3dsxKernelCaps() {
     };
 
     // Similar to Rosalina, we set kernel version to a recent one.
-    // This is 11.17.0, to be consistent with core/hle/kernel/config_mem.cpp
+    // This is 11.2.0, to be consistent with core/hle/kernel/config_mem.cpp
     // TODO: refactor kernel version out so it is configurable and consistent
     // among all relevant places.
-    kernel_version = 0x23a;
+    kernel_version = 0x234;
 }
 
 void Process::Run(s32 main_thread_priority, u32 stack_size) {

src/core/hle/service/apt/applet_manager.cpp

@@ -373,10 +373,7 @@ ResultVal<AppletManager::InitializeResult> AppletManager::Initialize(AppletId ap
     if (active_slot == AppletSlot::Error) {
         active_slot = slot;
 
-        // APT automatically calls enable on the first registered applet.
+        // Wake up the application.
-        Enable(attributes);
-
-        // Wake up the applet.
         SendParameter({
             .sender_id = AppletId::None,
             .destination_id = app_id,
@@ -401,8 +398,7 @@ Result AppletManager::Enable(AppletAttributes attributes) {
     auto slot_data = GetAppletSlot(slot);
     slot_data->registered = true;
 
-    if (slot_data->applet_id != AppletId::None &&
+    if (slot_data->attributes.applet_pos == AppletPos::System &&
-        slot_data->attributes.applet_pos == AppletPos::System &&
         slot_data->attributes.is_home_menu) {
         slot_data->attributes.raw |= attributes.raw;
         LOG_DEBUG(Service_APT, "Updated home menu attributes to {:08X}.",
@@ -790,23 +786,16 @@ Result AppletManager::PrepareToStartSystemApplet(AppletId applet_id) {
 
 Result AppletManager::StartSystemApplet(AppletId applet_id, std::shared_ptr<Kernel::Object> object,
                                         const std::vector<u8>& buffer) {
-    auto source_applet_id = AppletId::Application;
+    auto source_applet_id = AppletId::None;
     if (last_system_launcher_slot != AppletSlot::Error) {
-        const auto launcher_slot_data = GetAppletSlot(last_system_launcher_slot);
+        const auto slot_data = GetAppletSlot(last_system_launcher_slot);
-        source_applet_id = launcher_slot_data->applet_id;
+        source_applet_id = slot_data->applet_id;
 
-        // APT generally clears and terminates the caller of StartSystemApplet. This helps in
+        // If a system applet is launching another system applet, reset the slot to avoid conflicts.
-        // situations such as a system applet launching another system applet, which would
+        // This is needed because system applets won't necessarily call CloseSystemApplet before
-        // otherwise deadlock.
+        // exiting.
-        // TODO: In real APT, the check for AppletSlot::Application does not exist; there is
+        if (last_system_launcher_slot == AppletSlot::SystemApplet) {
-        // TODO: something wrong with our implementation somewhere that makes this necessary.
+            slot_data->Reset();
-        // TODO: Otherwise, games that attempt to launch system applets will be cleared and
-        // TODO: emulation will crash.
-        if (!launcher_slot_data->registered ||
-            (last_system_launcher_slot != AppletSlot::Application &&
-             !launcher_slot_data->attributes.no_exit_on_system_applet)) {
-            launcher_slot_data->Reset();
-            // TODO: Implement launcher process termination.
         }
     }
 

src/core/hle/service/apt/applet_manager.h

@@ -152,7 +152,6 @@ union AppletAttributes {
     u32 raw;
 
     BitField<0, 3, AppletPos> applet_pos;
-    BitField<28, 1, u32> no_exit_on_system_applet;
     BitField<29, 1, u32> is_home_menu;
 
     AppletAttributes() : raw(0) {}

src/core/hle/service/soc/soc_u.cpp

@@ -1014,8 +1014,8 @@ void SOC_U::Accept(Kernel::HLERequestContext& ctx) {
                 ctr_addr_buf.resize(async_data->max_addr_len);
             }
 
-            LOG_DEBUG(Service_SOC, "called, pid={}, fd={}, ret={}", async_data->pid,
+            LOG_DEBUG(Service_SOC, "called, pid={}, fd={}, ret={}", async_data->socket_handle,
-                      async_data->socket_handle, static_cast<s32>(async_data->ret));
+                      static_cast<s32>(async_data->ret));
 
             IPC::RequestBuilder rb(ctx, 0x04, 2, 2);
             rb.Push(ResultSuccess);

src/dedicated_room/citra-room.cpp

@@ -152,7 +152,6 @@ static void SaveBanList(const Network::Room::BanList& ban_list, const std::strin
 static void InitializeLogging(const std::string& log_file) {
     Common::Log::Initialize(log_file);
     Common::Log::SetColorConsoleBackendEnabled(true);
-    Common::Log::Start();
 }
 
 /// Application entry point

src/video_core/host_shaders/CMakeLists.txt

@@ -26,6 +26,17 @@ set(SHADER_FILES
     vulkan_blit_depth_stencil.frag
 )
 
+find_program(GLSLANG "glslang")
+if ("${GLSLANG}" STREQUAL "GLSLANG-NOTFOUND")
+    find_program(GLSLANG "glslangValidator")
+    if ("${GLSLANG}" STREQUAL "GLSLANG-NOTFOUND")
+        message(FATAL_ERROR "Required program `glslang` (or `glslangValidator`) not found.")
+    endif()
+endif()
+
+set(MACROS "-Dgl_VertexID=gl_VertexIndex")
+set(QUIET_FLAG "--quiet")
+
 set(SHADER_INCLUDE ${CMAKE_CURRENT_BINARY_DIR}/include)
 set(SHADER_DIR ${SHADER_INCLUDE}/video_core/host_shaders)
 set(HOST_SHADERS_INCLUDE ${SHADER_INCLUDE} PARENT_SCOPE)
@@ -33,22 +44,57 @@ set(HOST_SHADERS_INCLUDE ${SHADER_INCLUDE} PARENT_SCOPE)
 set(INPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/source_shader.h.in)
 set(HEADER_GENERATOR ${CMAKE_CURRENT_SOURCE_DIR}/StringShaderHeader.cmake)
 
+# Check if `--quiet` is available on host's glslang version
+# glslang prints to STDERR iff an unrecognized flag is passed to it
+execute_process(
+    COMMAND
+        ${GLSLANG} ${QUIET_FLAG}
+    ERROR_VARIABLE
+        GLSLANG_ERROR
+    # STDOUT variable defined to silence unnecessary output during CMake configuration
+    OUTPUT_VARIABLE
+        GLSLANG_OUTPUT
+)
+
+if (NOT GLSLANG_ERROR STREQUAL "")
+    message(WARNING "Refusing to use unavailable flag `${QUIET_FLAG}` on `${GLSLANG}`")
+    set(QUIET_FLAG "")
+endif()
+
 foreach(FILENAME IN ITEMS ${SHADER_FILES})
     string(REPLACE "." "_" SHADER_NAME ${FILENAME})
     set(SOURCE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${FILENAME})
-    set(SOURCE_HEADER_FILE ${SHADER_DIR}/${SHADER_NAME}.h)
+    # Skip generating source headers on Vulkan exclusive files
-    add_custom_command(
+    if (NOT ${FILENAME} MATCHES "vulkan.*")
-        OUTPUT
+        set(SOURCE_HEADER_FILE ${SHADER_DIR}/${SHADER_NAME}.h)
-            ${SOURCE_HEADER_FILE}
+        add_custom_command(
-        COMMAND
+            OUTPUT
-            ${CMAKE_COMMAND} -P ${HEADER_GENERATOR} ${SOURCE_FILE} ${SOURCE_HEADER_FILE} ${INPUT_FILE}
+                ${SOURCE_HEADER_FILE}
-        MAIN_DEPENDENCY
+            COMMAND
-            ${SOURCE_FILE}
+                ${CMAKE_COMMAND} -P ${HEADER_GENERATOR} ${SOURCE_FILE} ${SOURCE_HEADER_FILE} ${INPUT_FILE}
-        DEPENDS
+            MAIN_DEPENDENCY
-            ${INPUT_FILE}
+                ${SOURCE_FILE}
-            # HEADER_GENERATOR should be included here but msbuild seems to assume it's always modified
+            DEPENDS
-    )
+                ${INPUT_FILE}
-    set(SHADER_HEADERS ${SHADER_HEADERS} ${SOURCE_HEADER_FILE})
+                # HEADER_GENERATOR should be included here but msbuild seems to assume it's always modified
+        )
+        set(SHADER_HEADERS ${SHADER_HEADERS} ${SOURCE_HEADER_FILE})
+    endif()
+    # Skip compiling to SPIR-V OpenGL exclusive files
+    if (NOT ${FILENAME} MATCHES "opengl.*")
+        get_filename_component(FILE_NAME ${SHADER_NAME} NAME)
+        string(TOUPPER ${FILE_NAME}_SPV SPIRV_VARIABLE_NAME)
+        set(SPIRV_HEADER_FILE ${SHADER_DIR}/${SHADER_NAME}_spv.h)
+        add_custom_command(
+            OUTPUT
+                ${SPIRV_HEADER_FILE}
+            COMMAND
+                ${GLSLANG} --target-env vulkan1.1 --glsl-version 450 ${QUIET_FLAG} ${MACROS} --variable-name ${SPIRV_VARIABLE_NAME} -o ${SPIRV_HEADER_FILE} ${SOURCE_FILE}
+            MAIN_DEPENDENCY
+                ${SOURCE_FILE}
+        )
+        set(SHADER_HEADERS ${SHADER_HEADERS} ${SPIRV_HEADER_FILE})
+    endif()
 endforeach()
 
 set(SHADER_SOURCES ${SHADER_FILES})

src/video_core/host_shaders/format_reinterpreter/fullscreen_quad.vert

@@ -8,10 +8,6 @@ layout(location = 0) out vec2 dst_coord;
 
 layout(location = 0) uniform mediump ivec2 dst_size;
 
-#ifdef VULKAN
-#define gl_VertexID gl_VertexIndex
-#endif
-
 const vec2 vertices[4] =
 vec2[4](vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0), vec2(1.0, 1.0));
 

src/video_core/host_shaders/full_screen_triangle.vert

@@ -10,7 +10,6 @@ out gl_PerVertex {
 layout(location = 0) out vec2 texcoord;
 
 #ifdef VULKAN
-#define gl_VertexID gl_VertexIndex
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)

src/video_core/host_shaders/texture_filtering/tex_coord.vert

@@ -5,10 +5,6 @@
 //? #version 430 core
 layout(location = 0) out vec2 tex_coord;
 
-#ifdef VULKAN
-#define gl_VertexID gl_VertexIndex
-#endif
-
 const vec2 vertices[4] =
     vec2[4](vec2(-1.0, -1.0), vec2(1.0, -1.0), vec2(-1.0, 1.0), vec2(1.0, 1.0));
 

src/video_core/renderer_opengl/pica_to_gl.h

@@ -148,6 +148,8 @@ inline GLenum BlendFunc(Pica::FramebufferRegs::BlendFactor factor) {
     // Range check table for input
     if (index >= blend_func_table.size()) {
         LOG_CRITICAL(Render_OpenGL, "Unknown blend factor {}", index);
+        UNREACHABLE();
+
         return GL_ONE;
     }
 

src/video_core/renderer_vulkan/pica_to_vk.h

@@ -96,10 +96,7 @@ inline vk::BlendFactor BlendFunc(Pica::FramebufferRegs::BlendFactor factor) {
     }};
 
     const auto index = static_cast<std::size_t>(factor);
-    if (index >= blend_func_table.size()) {
+    ASSERT_MSG(index < blend_func_table.size(), "Unknown blend factor {}", index);
-        LOG_CRITICAL(Render_Vulkan, "Unknown blend factor {}", index);
-        return vk::BlendFactor::eOne;
-    }
     return blend_func_table[index];
 }
 

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -15,10 +15,10 @@
 #include "video_core/renderer_vulkan/vk_memory_util.h"
 #include "video_core/renderer_vulkan/vk_shader_util.h"
 
-#include "video_core/host_shaders/vulkan_present_anaglyph_frag.h"
+#include "video_core/host_shaders/vulkan_present_anaglyph_frag_spv.h"
-#include "video_core/host_shaders/vulkan_present_frag.h"
+#include "video_core/host_shaders/vulkan_present_frag_spv.h"
-#include "video_core/host_shaders/vulkan_present_interlaced_frag.h"
+#include "video_core/host_shaders/vulkan_present_interlaced_frag_spv.h"
-#include "video_core/host_shaders/vulkan_present_vert.h"
+#include "video_core/host_shaders/vulkan_present_vert_spv.h"
 
 #include <vk_mem_alloc.h>
 
@@ -225,14 +225,10 @@ void RendererVulkan::LoadFBToScreenInfo(const Pica::FramebufferConfig& framebuff
 
 void RendererVulkan::CompileShaders() {
     vk::Device device = instance.GetDevice();
-    present_vertex_shader =
+    present_vertex_shader = CompileSPV(VULKAN_PRESENT_VERT_SPV, device);
-        Compile(HostShaders::VULKAN_PRESENT_VERT, vk::ShaderStageFlagBits::eVertex, device);
+    present_shaders[0] = CompileSPV(VULKAN_PRESENT_FRAG_SPV, device);
-    present_shaders[0] =
+    present_shaders[1] = CompileSPV(VULKAN_PRESENT_ANAGLYPH_FRAG_SPV, device);
-        Compile(HostShaders::VULKAN_PRESENT_FRAG, vk::ShaderStageFlagBits::eFragment, device);
+    present_shaders[2] = CompileSPV(VULKAN_PRESENT_INTERLACED_FRAG_SPV, device);
-    present_shaders[1] = Compile(HostShaders::VULKAN_PRESENT_ANAGLYPH_FRAG,
-                                 vk::ShaderStageFlagBits::eFragment, device);
-    present_shaders[2] = Compile(HostShaders::VULKAN_PRESENT_INTERLACED_FRAG,
-                                 vk::ShaderStageFlagBits::eFragment, device);
 
     auto properties = instance.GetPhysicalDevice().getProperties();
     for (std::size_t i = 0; i < present_samplers.size(); i++) {

src/video_core/renderer_vulkan/vk_blit_helper.cpp

@@ -10,10 +10,10 @@
 #include "video_core/renderer_vulkan/vk_shader_util.h"
 #include "video_core/renderer_vulkan/vk_texture_runtime.h"
 
-#include "video_core/host_shaders/format_reinterpreter/vulkan_d24s8_to_rgba8_comp.h"
+#include "video_core/host_shaders/format_reinterpreter/vulkan_d24s8_to_rgba8_comp_spv.h"
-#include "video_core/host_shaders/full_screen_triangle_vert.h"
+#include "video_core/host_shaders/full_screen_triangle_vert_spv.h"
-#include "video_core/host_shaders/vulkan_blit_depth_stencil_frag.h"
+#include "video_core/host_shaders/vulkan_blit_depth_stencil_frag_spv.h"
-#include "video_core/host_shaders/vulkan_depth_to_buffer_comp.h"
+#include "video_core/host_shaders/vulkan_depth_to_buffer_comp_spv.h"
 
 namespace Vulkan {
 
@@ -189,14 +189,10 @@ BlitHelper::BlitHelper(const Instance& instance_, Scheduler& scheduler_, Descrip
           PipelineLayoutCreateInfo(&compute_buffer_provider.Layout(), true))},
       two_textures_pipeline_layout{
           device.createPipelineLayout(PipelineLayoutCreateInfo(&two_textures_provider.Layout()))},
-      full_screen_vert{Compile(HostShaders::FULL_SCREEN_TRIANGLE_VERT,
+      full_screen_vert{CompileSPV(FULL_SCREEN_TRIANGLE_VERT_SPV, device)},
-                               vk::ShaderStageFlagBits::eVertex, device)},
+      d24s8_to_rgba8_comp{CompileSPV(VULKAN_D24S8_TO_RGBA8_COMP_SPV, device)},
-      d24s8_to_rgba8_comp{Compile(HostShaders::VULKAN_D24S8_TO_RGBA8_COMP,
+      depth_to_buffer_comp{CompileSPV(VULKAN_DEPTH_TO_BUFFER_COMP_SPV, device)},
-                                  vk::ShaderStageFlagBits::eCompute, device)},
+      blit_depth_stencil_frag{CompileSPV(VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV, device)},
-      depth_to_buffer_comp{Compile(HostShaders::VULKAN_DEPTH_TO_BUFFER_COMP,
-                                   vk::ShaderStageFlagBits::eCompute, device)},
-      blit_depth_stencil_frag{Compile(HostShaders::VULKAN_BLIT_DEPTH_STENCIL_FRAG,
-                                      vk::ShaderStageFlagBits::eFragment, device)},
       d24s8_to_rgba8_pipeline{MakeComputePipeline(d24s8_to_rgba8_comp, compute_pipeline_layout)},
       depth_to_buffer_pipeline{
           MakeComputePipeline(depth_to_buffer_comp, compute_buffer_pipeline_layout)},

src/video_core/renderer_vulkan/vk_texture_runtime.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <boost/container/small_vector.hpp>
-#include <boost/container/static_vector.hpp>
 
 #include "common/literals.h"
 #include "common/microprofile.h"
@@ -120,9 +119,9 @@ u32 UnpackDepthStencil(const VideoCore::StagingData& data, vk::Format dest) {
 }
 
 boost::container::small_vector<vk::ImageMemoryBarrier, 3> MakeInitBarriers(
-    vk::ImageAspectFlags aspect, std::span<const vk::Image> images) {
+    vk::ImageAspectFlags aspect, std::span<const vk::Image> images, std::size_t num_images) {
     boost::container::small_vector<vk::ImageMemoryBarrier, 3> barriers;
-    for (const vk::Image& image : images) {
+    for (std::size_t i = 0; i < num_images; i++) {
         barriers.push_back(vk::ImageMemoryBarrier{
             .srcAccessMask = vk::AccessFlagBits::eNone,
             .dstAccessMask = vk::AccessFlagBits::eNone,
@@ -130,7 +129,7 @@ boost::container::small_vector<vk::ImageMemoryBarrier, 3> MakeInitBarriers(
             .newLayout = vk::ImageLayout::eGeneral,
             .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
             .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = image,
+            .image = images[i],
             .subresourceRange{
                 .aspectMask = aspect,
                 .baseMipLevel = 0,
@@ -220,10 +219,11 @@ Handle MakeHandle(const Instance* instance, u32 width, u32 height, u32 levels, T
 }
 
 vk::UniqueFramebuffer MakeFramebuffer(vk::Device device, vk::RenderPass render_pass, u32 width,
-                                      u32 height, std::span<const vk::ImageView> attachments) {
+                                      u32 height, std::span<const vk::ImageView> attachments,
+                                      u32 num_attachments) {
     const vk::FramebufferCreateInfo framebuffer_info = {
         .renderPass = render_pass,
-        .attachmentCount = static_cast<u32>(attachments.size()),
+        .attachmentCount = num_attachments,
         .pAttachments = attachments.data(),
         .width = width,
         .height = height,
@@ -715,7 +715,8 @@ Surface::Surface(TextureRuntime& runtime_, const VideoCore::SurfaceParams& param
     ASSERT_MSG(format != vk::Format::eUndefined && levels >= 1,
                "Image allocation parameters are invalid");
 
-    boost::container::static_vector<vk::Image, 3> raw_images;
+    u32 num_images = 0;
+    std::array<vk::Image, 3> raw_images;
 
     vk::ImageCreateFlags flags{};
     if (texture_type == VideoCore::TextureType::CubeMap) {
@@ -728,18 +729,18 @@ Surface::Surface(TextureRuntime& runtime_, const VideoCore::SurfaceParams& param
     const bool need_format_list = is_mutable && instance->IsImageFormatListSupported();
     handles[0] = MakeHandle(instance, width, height, levels, texture_type, format, traits.usage,
                             flags, traits.aspect, need_format_list, DebugName(false));
-    raw_images.emplace_back(handles[0].image);
+    raw_images[num_images++] = handles[0].image;
 
     if (res_scale != 1) {
         handles[1] =
             MakeHandle(instance, GetScaledWidth(), GetScaledHeight(), levels, texture_type, format,
                        traits.usage, flags, traits.aspect, need_format_list, DebugName(true));
-        raw_images.emplace_back(handles[1].image);
+        raw_images[num_images++] = handles[1].image;
     }
 
     runtime->renderpass_cache.EndRendering();
-    scheduler->Record([raw_images, aspect = traits.aspect](vk::CommandBuffer cmdbuf) {
+    scheduler->Record([raw_images, num_images, aspect = traits.aspect](vk::CommandBuffer cmdbuf) {
-        const auto barriers = MakeInitBarriers(aspect, raw_images);
+        const auto barriers = MakeInitBarriers(aspect, raw_images, num_images);
         cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe,
                                vk::PipelineStageFlagBits::eTopOfPipe,
                                vk::DependencyFlagBits::eByRegion, {}, {}, barriers);
@@ -757,7 +758,8 @@ Surface::Surface(TextureRuntime& runtime_, const VideoCore::SurfaceBase& surface
     const bool has_normal = mat && mat->Map(MapType::Normal);
     const vk::Format format = traits.native;
 
-    boost::container::static_vector<vk::Image, 2> raw_images;
+    u32 num_images = 0;
+    std::array<vk::Image, 2> raw_images;
 
     vk::ImageCreateFlags flags{};
     if (texture_type == VideoCore::TextureType::CubeMap) {
@@ -767,23 +769,23 @@ Surface::Surface(TextureRuntime& runtime_, const VideoCore::SurfaceBase& surface
     const std::string debug_name = DebugName(false, true);
     handles[0] = MakeHandle(instance, mat->width, mat->height, levels, texture_type, format,
                             traits.usage, flags, traits.aspect, false, debug_name);
-    raw_images.emplace_back(handles[0].image);
+    raw_images[num_images++] = handles[0].image;
 
     if (res_scale != 1) {
         handles[1] = MakeHandle(instance, mat->width, mat->height, levels, texture_type,
                                 vk::Format::eR8G8B8A8Unorm, traits.usage, flags, traits.aspect,
                                 false, debug_name);
-        raw_images.emplace_back(handles[1].image);
+        raw_images[num_images++] = handles[1].image;
     }
     if (has_normal) {
         handles[2] = MakeHandle(instance, mat->width, mat->height, levels, texture_type, format,
                                 traits.usage, flags, traits.aspect, false, debug_name);
-        raw_images.emplace_back(handles[2].image);
+        raw_images[num_images++] = handles[2].image;
     }
 
     runtime->renderpass_cache.EndRendering();
-    scheduler->Record([raw_images, aspect = traits.aspect](vk::CommandBuffer cmdbuf) {
+    scheduler->Record([raw_images, num_images, aspect = traits.aspect](vk::CommandBuffer cmdbuf) {
-        const auto barriers = MakeInitBarriers(aspect, raw_images);
+        const auto barriers = MakeInitBarriers(aspect, raw_images, num_images);
         cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe,
                                vk::PipelineStageFlagBits::eTopOfPipe,
                                vk::DependencyFlagBits::eByRegion, {}, {}, barriers);
@@ -823,10 +825,11 @@ void Surface::Upload(const VideoCore::BufferTextureCopy& upload,
 
     scheduler->Record([buffer = runtime->upload_buffer.Handle(), format = traits.native, params,
                        staging, upload](vk::CommandBuffer cmdbuf) {
-        boost::container::static_vector<vk::BufferImageCopy, 2> buffer_image_copies;
+        u32 num_copies = 1;
+        std::array<vk::BufferImageCopy, 2> buffer_image_copies;
 
         const auto rect = upload.texture_rect;
-        buffer_image_copies.emplace_back(vk::BufferImageCopy{
+        buffer_image_copies[0] = vk::BufferImageCopy{
             .bufferOffset = upload.buffer_offset,
             .bufferRowLength = rect.GetWidth(),
             .bufferImageHeight = rect.GetHeight(),
@@ -838,16 +841,15 @@ void Surface::Upload(const VideoCore::BufferTextureCopy& upload,
             },
             .imageOffset = {static_cast<s32>(rect.left), static_cast<s32>(rect.bottom), 0},
             .imageExtent = {rect.GetWidth(), rect.GetHeight(), 1},
-        });
+        };
 
         if (params.aspect & vk::ImageAspectFlagBits::eStencil) {
             buffer_image_copies[0].imageSubresource.aspectMask = vk::ImageAspectFlagBits::eDepth;
-
+            vk::BufferImageCopy& stencil_copy = buffer_image_copies[1];
-            vk::BufferImageCopy& stencil_copy =
-                buffer_image_copies.emplace_back(buffer_image_copies[0]);
             stencil_copy = buffer_image_copies[0];
             stencil_copy.bufferOffset += UnpackDepthStencil(staging, format);
             stencil_copy.imageSubresource.aspectMask = vk::ImageAspectFlagBits::eStencil;
+            num_copies++;
         }
 
         const vk::ImageMemoryBarrier read_barrier = {
@@ -875,7 +877,7 @@ void Surface::Upload(const VideoCore::BufferTextureCopy& upload,
                                vk::DependencyFlagBits::eByRegion, {}, {}, read_barrier);
 
         cmdbuf.copyBufferToImage(buffer, params.src_image, vk::ImageLayout::eTransferDstOptimal,
-                                 buffer_image_copies);
+                                 num_copies, buffer_image_copies.data());
 
         cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
                                vk::DependencyFlagBits::eByRegion, {}, {}, write_barrier);
@@ -1083,7 +1085,7 @@ void Surface::ScaleUp(u32 new_scale) {
     runtime->renderpass_cache.EndRendering();
     scheduler->Record(
         [raw_images = std::array{Image()}, aspect = traits.aspect](vk::CommandBuffer cmdbuf) {
-            const auto barriers = MakeInitBarriers(aspect, raw_images);
+            const auto barriers = MakeInitBarriers(aspect, raw_images, raw_images.size());
             cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe,
                                    vk::PipelineStageFlagBits::eTopOfPipe,
                                    vk::DependencyFlagBits::eByRegion, {}, {}, barriers);
@@ -1349,7 +1351,7 @@ vk::Framebuffer Surface::Framebuffer() noexcept {
         runtime->renderpass_cache.GetRenderpass(color_format, depth_format, false);
     const auto attachments = std::array{ImageView()};
     framebuffers[index] = MakeFramebuffer(instance->GetDevice(), render_pass, GetScaledWidth(),
-                                          GetScaledHeight(), attachments);
+                                          GetScaledHeight(), attachments, 1);
     return framebuffers[index].get();
 }
 
@@ -1479,16 +1481,17 @@ Framebuffer::Framebuffer(TextureRuntime& runtime, const VideoCore::FramebufferPa
         image_views[index] = shadow_rendering ? surface->StorageView() : surface->FramebufferView();
     };
 
-    boost::container::static_vector<vk::ImageView, 2> attachments;
+    u32 num_attachments = 0;
+    std::array<vk::ImageView, 2> attachments;
 
     if (color) {
         prepare(0, color);
-        attachments.emplace_back(image_views[0]);
+        attachments[num_attachments++] = image_views[0];
     }
 
     if (depth) {
         prepare(1, depth);
-        attachments.emplace_back(image_views[1]);
+        attachments[num_attachments++] = image_views[1];
     }
 
     const vk::Device device = runtime.GetInstance().GetDevice();
@@ -1496,10 +1499,11 @@ Framebuffer::Framebuffer(TextureRuntime& runtime, const VideoCore::FramebufferPa
         render_pass =
             renderpass_cache.GetRenderpass(PixelFormat::Invalid, PixelFormat::Invalid, false);
         framebuffer = MakeFramebuffer(device, render_pass, color->GetScaledWidth(),
-                                      color->GetScaledHeight(), {});
+                                      color->GetScaledHeight(), {}, 0);
     } else {
         render_pass = renderpass_cache.GetRenderpass(formats[0], formats[1], false);
-        framebuffer = MakeFramebuffer(device, render_pass, width, height, attachments);
+        framebuffer =
+            MakeFramebuffer(device, render_pass, width, height, attachments, num_attachments);
     }
 }
 

tools/reset-submodules.sh

@@ -1,8 +0,0 @@
-#!/bin/bash -ex
-
-# SPDX-FileCopyrightText: 2024 yuzu Emulator Project
-# SPDX-License-Identifier: MIT
-
-git submodule sync
-git submodule foreach --recursive git reset --hard
-git submodule update --init --recursive