use shell wrapper

Signed-off-by: lizzie <lizzie@eden-emu.dev>

.patch/openssl-cmake/0001-cpmutil-compat.patch

@@ -15,16 +15,6 @@ diff --git a/CMakeLists.txt b/CMakeLists.txt
 index 5420ecc..9ffd5a0 100644
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
-@@ -19,9 +19,7 @@ include(FetchContent)
- include(ProcessorCount)
- include(cmake/ConfigureOpenSSL.cmake)
- include(cmake/DetectTargetPlatform.cmake)
--include(cmake/FetchOpenSSL.cmake)
- include(cmake/FindVcvarsall.cmake)
--include(cmake/GetCPM.cmake)
- 
- # Custom options
- option(OPENSSL_BUILD_VERBOSE "Enable verbose output from build" OFF)
 @@ -47,9 +45,6 @@ if("${OPENSSL_TARGET_PLATFORM}" STREQUAL "")
      detect_target_platform(OPENSSL_TARGET_PLATFORM)
  endif()
@@ -128,87 +118,3 @@ index 5420ecc..9ffd5a0 100644
          )"
      )
  endif()
-diff --git a/cmake/FetchOpenSSL.cmake b/cmake/FetchOpenSSL.cmake
-deleted file mode 100644
-index a43505d..0000000
---- a/cmake/FetchOpenSSL.cmake
-+++ /dev/null
-@@ -1,64 +0,0 @@
--function(fetch_openssl)
--    if(EXISTS "${OPENSSL_SOURCE}" AND IS_DIRECTORY "${OPENSSL_SOURCE}")
--        # Fetch the local OpenSSL source
--        if(NOT IS_ABSOLUTE "${OPENSSL_SOURCE}")
--            string(PREPEND OPENSSL_SOURCE ${CMAKE_SOURCE_DIR}/)
--        endif()
--
--        string(REPLACE "\\" "/" openssl-source_SOURCE_DIR "${OPENSSL_SOURCE}")
--        set(openssl-source_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/openssl-source-build)
--    else()
--        set(CPM_OPTIONS
--            NAME openssl-source
--            DOWNLOAD_ONLY ON
--        )
--
--        if(NOT OPENSSL_CONFIGURE_VERBOSE)
--            list(APPEND CPM_OPTIONS QUIET)
--        endif()
--
--        if("${OPENSSL_SOURCE}" MATCHES "^http")
--            # Download OpenSSL source from the internet
--            list(APPEND CPM_OPTIONS URL ${OPENSSL_SOURCE})
--        else()
--            # Download OpenSSL source from the official website
--            if("${OPENSSL_TARGET_VERSION}" STREQUAL "")
--                set(OPENSSL_TARGET_VERSION ${PROJECT_VERSION})
--            endif()
--
--            if(OPENSSL_TARGET_VERSION VERSION_EQUAL PROJECT_VERSION)
--                list(APPEND CPM_OPTIONS URL_HASH SHA256=aaf51a1fe064384f811daeaeb4ec4dce7340ec8bd893027eee676af31e83a04f)
--            endif()
--
--            if(OPENSSL_TARGET_VERSION MATCHES "^1\.1\.1[a-w]$")
--                string(REPLACE "." "_" OPENSSL_TAGGED_VERSION ${OPENSSL_TARGET_VERSION})
--                list(APPEND CPM_OPTIONS URL https://github.com/openssl/openssl/releases/download/OpenSSL_${OPENSSL_TAGGED_VERSION}/openssl-${OPENSSL_TARGET_VERSION}.tar.gz)
--            else()
--                list(APPEND CPM_OPTIONS URL https://github.com/openssl/openssl/releases/download/openssl-${OPENSSL_TARGET_VERSION}/openssl-${OPENSSL_TARGET_VERSION}.tar.gz)
--            endif()
--        endif()
--
--        CPMAddPackage(${CPM_OPTIONS})
--    endif()
--
--    # Clean build directory if source directory has changed
--    if(DEFINED CACHE{openssl-source_SOURCE_DIR_OLD} AND NOT openssl-source_SOURCE_DIR STREQUAL openssl-source_SOURCE_DIR_OLD)
--        set(openssl-source_SOURCE_DIR_OLD ${openssl-source_SOURCE_DIR} CACHE INTERNAL "Previously fetched OpenSSL source")
--
--        if(IS_DIRECTORY ${openssl-source_BINARY_DIR})
--            file(REMOVE_RECURSE ${openssl-source_BINARY_DIR})
--            file(MAKE_DIRECTORY ${openssl-source_BINARY_DIR})
--        endif()
--    endif()
--
--    # Override the FindOpenSSL module
--    FetchContent_Declare(
--        OpenSSL
--        SOURCE_DIR ${openssl-source_SOURCE_DIR}
--        BINARY_DIR ${openssl-source_BINARY_DIR}
--        OVERRIDE_FIND_PACKAGE
--    )
--    FetchContent_MakeAvailable(OpenSSL)
--
--    return(PROPAGATE openssl_SOURCE_DIR openssl_BINARY_DIR)
--endfunction()
-diff --git a/cmake/GetCPM.cmake b/cmake/GetCPM.cmake
-deleted file mode 100644
-index bfc50f5..0000000
---- a/cmake/GetCPM.cmake
-+++ /dev/null
-@@ -1,5 +0,0 @@
--file(
--    DOWNLOAD https://github.com/cpm-cmake/CPM.cmake/releases/latest/download/get_cpm.cmake
--    ${CMAKE_CURRENT_BINARY_DIR}/get_cpm.cmake
--)
--include(${CMAKE_CURRENT_BINARY_DIR}/get_cpm.cmake)
--- 
-2.54.0
-

.patch/openssl-cmake/0002-use-ccache.patch

@@ -9,23 +9,23 @@ Subject: [PATCH] use ccache
  2 files changed, 3 insertions(+), 10 deletions(-)
 
 diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 9ffd5a0..9ff14c8 100644
+index d6c998c..d943c59 100644
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
-@@ -28,7 +28,6 @@ option(OPENSSL_ENABLE_PARALLEL "Build and test in parallel if possible" ON)
- option(OPENSSL_INSTALL "Install OpenSSL components to the <prefix> directory" OFF)
- option(OPENSSL_INSTALL_CERT "Install cert.pem to the <openssldir> directory" OFF)
- option(OPENSSL_TEST "Enable testing and build OpenSSL self tests" OFF)
--option(OPENSSL_USE_CCACHE "Use ccache if available" ON)
+@@ -20,7 +20,6 @@ include(ProcessorCount)
+ include(cmake/CheckBuildMismatches.cmake)
+ include(cmake/ConfigureOpenSSL.cmake)
+ include(cmake/DetectTargetPlatform.cmake)
+-include(cmake/FetchOpenSSL.cmake)
+ include(cmake/FindVcvarsall.cmake)
  
- if("${OPENSSL_BUILD_TARGET}" STREQUAL "")
-     # Makefile target for build
+ # Custom options
 diff --git a/cmake/ConfigureOpenSSL.cmake b/cmake/ConfigureOpenSSL.cmake
-index 211c18b..3d8cbed 100644
+index be8d651..c186c16 100644
 --- a/cmake/ConfigureOpenSSL.cmake
 +++ b/cmake/ConfigureOpenSSL.cmake
-@@ -69,15 +69,9 @@ function(apply_ccache FILE)
-         message(FATAL_ERROR "Couldn't find Makefile")
+@@ -77,15 +77,9 @@ function(apply_ccache FILE)
+         )
      endif()
  
 -    if(OPENSSL_USE_CCACHE)
@@ -42,13 +42,3 @@ index 211c18b..3d8cbed 100644
  
          if(MSVC)
              string(REPLACE "/Zi /Fdossl_static.pdb " "" MAKEFILE "${MAKEFILE}")
-@@ -171,4 +165,4 @@ function(configure_openssl)
-         string(REPLACE "/W3" "/W0" MAKEFILE "${MAKEFILE}")
-         file(WRITE ${OPENSSL_MAKEFILE} "${MAKEFILE}")
-     endif()
--endfunction()
-\ No newline at end of file
-+endfunction()
--- 
-2.54.0
-

.patch/openssl-cmake/0003-use-cmake-compiler-flags.patch

@@ -8,10 +8,10 @@ Subject: [PATCH 2/2] use cmake compiler flags
  1 file changed, 4 insertions(+), 1 deletion(-)
 
 diff --git a/cmake/ConfigureOpenSSL.cmake b/cmake/ConfigureOpenSSL.cmake
-index 3d8cbed..3012e05 100644
+index c186c16..222e9c2 100644
 --- a/cmake/ConfigureOpenSSL.cmake
 +++ b/cmake/ConfigureOpenSSL.cmake
-@@ -135,7 +135,10 @@ function(configure_openssl)
+@@ -147,7 +147,10 @@ function(configure_openssl)
      endif()
  
      execute_process(
@@ -23,6 +23,3 @@ index 3d8cbed..3012e05 100644
          WORKING_DIRECTORY ${CONFIGURE_BUILD_DIR}
          ${VERBOSE_OPTION}
          COMMAND_ERROR_IS_FATAL ANY
--- 
-2.54.0
-

.patch/openssl-cmake/0004-use-shell-wrapper.patch

@@ -1,39 +0,0 @@
---- a/CMakeLists.txt	2026-06-01 23:53:16.498043856 -0400
-+++ b/CMakeLists.txt	2026-06-01 23:53:23.910543615 -0400
-@@ -312,13 +312,29 @@
-     ${OPENSSL_SHARED_CRYPTO_LIBRARY}
-     ${OPENSSL_SHARED_SSL_LIBRARY}
- )
--add_custom_command(
--    OUTPUT ${OPENSSL_BUILD_OUTPUT}
--    COMMAND ${OPENSSL_BUILD_COMMAND}
--    DEPENDS ${OPENSSL_SOURCES}
--    WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}
--    VERBATIM
--)
-+if (WIN32)
-+    add_custom_command(
-+        OUTPUT ${OPENSSL_BUILD_OUTPUT}
-+        COMMAND ${OPENSSL_BUILD_COMMAND}
-+        DEPENDS ${OPENSSL_SOURCES}
-+        WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}
-+        VERBATIM)
-+else()
-+    set(_openssl_build_script "${CMAKE_CURRENT_BINARY_DIR}/BuildOpenSSL.cmake")
-+    file(WRITE ${_openssl_build_script}
-+        "execute_process(\n"
-+        "    COMMAND ${OPENSSL_BUILD_COMMAND}\n"
-+        "    WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}\n"
-+        "    RESULT_VARIABLE _r)\n"
-+        "if(_r)\n"
-+        "    message(FATAL_ERROR \"OpenSSL build failed: \${_r}\")\n"
-+        "endif()\n")
-+    add_custom_command(
-+        OUTPUT ${OPENSSL_BUILD_OUTPUT}
-+        COMMAND ${CMAKE_COMMAND} -P ${_openssl_build_script}
-+        DEPENDS ${OPENSSL_SOURCES}
-+        VERBATIM)
-+endif()
- 
- if(PROJECT_IS_TOP_LEVEL)
-     add_custom_target(openssl-build ALL DEPENDS ${OPENSSL_BUILD_OUTPUT})

cpmfile.json

@@ -203,7 +203,7 @@
         "version": "1.10.0"
     },
     "openssl": {
-        "hash": "29002ce50cb95a4f4f1d0e9d3f684401fbd4eac34203dc2eef3b6334af5d44aa46bf788b63a6f5c139c383eafb7269ae87a58a9a3ad5912903b9773e545ccc0a",
+        "hash": "2405891660b67e4cc01c7868e100f2766e1c6290120213ae62f775ef3d9610c3527bdc43d4c831260417450c74353b0693ae3e24cca3e99b02e4daa548b93904",
         "min_version": "3.0.0",
         "package": "OpenSSL",
         "patches": [
@@ -211,7 +211,7 @@
         ],
         "repo": "openssl/openssl",
         "tag": "openssl-%VERSION%",
-        "version": "3.6.2"
+        "version": "4.0.1"
     },
     "openssl-ci": {
         "ci": true,
@@ -223,19 +223,18 @@
     },
     "openssl-cmake": {
         "bundled": true,
-        "hash": "2cc185c924fd70e7d886257ca0caa42b3b8f7f712f2052b4f94dde74759e27022de76178460e18c9bdfc57c366583999e198fbb6052d4e7d91c099d15a0ca63e",
+        "hash": "bc73a6c035f299711bb90e20b16fa3521e8ffdab32d8d17f9e7f5cde1ff5def37ec6f9e03de25c3466d18885815c0874331f56e592b8a2f7deeb484c69c5c621",
         "options": [
             "OPENSSL_CONFIGURE_OPTIONS threads"
         ],
         "patches": [
             "0001-cpmutil-compat.patch",
             "0002-use-ccache.patch",
-            "0003-use-cmake-compiler-flags.patch",
-            "0004-use-shell-wrapper.patch"
+            "0003-use-cmake-compiler-flags.patch"
         ],
         "repo": "jimmy-park/openssl-cmake",
         "tag": "%VERSION%",
-        "version": "3.6.2"
+        "version": "4.0.1"
     },
     "opus": {
         "find_args": "MODULE",
@@ -371,11 +370,11 @@
         "version": "1.4.341.0"
     },
     "xbyak": {
-        "hash": "b6475276b2faaeb315734ea8f4f8bd87ededcee768961b39679bee547e7f3e98884d8b7851e176d861dab30a80a76e6ea302f8c111483607dde969b4797ea95a",
+        "hash": "03d870f63741ff8c00501329bf9947bdf58e7cc4c3884e3de9b827f31942438887555f601a5f80d405946854eb54ab907b4e2a3ad955ca4ad890a243917dd4ae",
         "package": "xbyak",
         "repo": "herumi/xbyak",
         "tag": "v%VERSION%",
-        "version": "7.35.2"
+        "version": "7.37.3"
     },
     "zlib": {
         "hash": "16fea4df307a68cf0035858abe2fd550250618a97590e202037acd18a666f57afc10f8836cbbd472d54a0e76539d0e558cb26f059d53de52ff90634bbf4f47d4",

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -169,7 +169,6 @@ try
 }
 
 RendererVulkan::~RendererVulkan() {
-    scheduler.WaitWorker();
     scheduler.RegisterOnSubmit([] {});
     void(device.GetLogical().WaitIdle());
 }

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -25,9 +25,6 @@
 #include "video_core/host_shaders/vulkan_quad_indexed_comp_spv.h"
 #include "video_core/host_shaders/vulkan_uint8_comp_spv.h"
 #include "video_core/host_shaders/block_linear_unswizzle_3d_bcn_comp_spv.h"
-#include "video_core/host_shaders/block_linear_unswizzle_2d_comp_spv.h"
-#include "video_core/host_shaders/block_linear_unswizzle_3d_comp_spv.h"
-#include "video_core/host_shaders/pitch_unswizzle_comp_spv.h"
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
@@ -235,26 +232,6 @@ struct QueriesPrefixScanPushConstants {
 struct ConditionalRenderingResolvePushConstants {
     u32 compare_to_zero;
 };
-
-struct BlockLinear3DImagePushConstants {
-    alignas(16) std::array<u32, 3> origin;
-    alignas(16) std::array<s32, 3> destination;
-    u32 bytes_per_block_log2;
-    u32 slice_size;
-    u32 block_size;
-    u32 x_shift;
-    u32 block_height;
-    u32 block_height_mask;
-    u32 block_depth;
-    u32 block_depth_mask;
-};
-
-struct PitchUnswizzlePushConstants {
-    std::array<u32, 2> origin;
-    std::array<s32, 2> destination;
-    u32 bytes_per_block;
-    u32 pitch;
-};
 } // Anonymous namespace
 
 ComputePass::ComputePass(const Device& device_, Scheduler& scheduler, DescriptorPool& descriptor_pool,
@@ -676,309 +653,6 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
     scheduler.Finish();
 }
 
-BlockLinearUnswizzleImage2DPass::BlockLinearUnswizzleImage2DPass(
-    const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
-    StagingBufferPool& staging_buffer_pool_,
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
-    : ComputePass(device_, scheduler_, descriptor_pool_, ASTC_DESCRIPTOR_SET_BINDINGS,
-                  ASTC_PASS_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY, ASTC_BANK_INFO,
-                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearSwizzle2DParams)>,
-                  BLOCK_LINEAR_UNSWIZZLE_2D_COMP_SPV),
-      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
-
-BlockLinearUnswizzleImage2DPass::~BlockLinearUnswizzleImage2DPass() = default;
-
-void BlockLinearUnswizzleImage2DPass::Unswizzle(
-    Image& image, const StagingBufferRef& map,
-    std::span<const VideoCommon::SwizzleParameters> swizzles) {
-    using namespace VideoCommon::Accelerated;
-    scheduler.RequestOutsideRenderPassOperationContext();
-    const VkPipeline vk_pipeline = *pipeline;
-    const VkImageAspectFlags aspect_mask = image.AspectMask();
-    const VkImage vk_image = image.Handle();
-    const bool is_initialized = image.ExchangeInitialization();
-    scheduler.Record([vk_pipeline, vk_image, aspect_mask,
-                      is_initialized](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier image_barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = static_cast<VkAccessFlags>(is_initialized ? VK_ACCESS_SHADER_WRITE_BIT
-                                                                       : VK_ACCESS_NONE),
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
-            .oldLayout = is_initialized ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_UNDEFINED,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = vk_image,
-            .subresourceRange{
-                .aspectMask = aspect_mask,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(is_initialized ? vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER
-                              : VkPipelineStageFlags(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT),
-                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
-        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline);
-    });
-    for (const VideoCommon::SwizzleParameters& swizzle : swizzles) {
-        const size_t input_offset = swizzle.buffer_offset + map.offset;
-        const u32 num_dispatches_x = Common::DivCeil(swizzle.num_tiles.width, 32U);
-        const u32 num_dispatches_y = Common::DivCeil(swizzle.num_tiles.height, 32U);
-        const u32 num_dispatches_z = image.info.resources.layers;
-
-        compute_pass_descriptor_queue.Acquire(scheduler, 2);
-        compute_pass_descriptor_queue.AddBuffer(map.buffer, input_offset,
-                                                image.guest_size_bytes - swizzle.buffer_offset);
-        compute_pass_descriptor_queue.AddImage(image.StorageImageView(swizzle.level));
-        const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
-
-        const auto params = MakeBlockLinearSwizzle2DParams(swizzle, image.info);
-        scheduler.Record([this, num_dispatches_x, num_dispatches_y, num_dispatches_z, params,
-                          descriptor_data](vk::CommandBuffer cmdbuf) {
-            const VkDescriptorSet set = descriptor_allocator.Commit();
-            device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
-            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
-            cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, params);
-            cmdbuf.Dispatch(num_dispatches_x, num_dispatches_y, num_dispatches_z);
-        });
-    }
-    scheduler.Record([vk_image, aspect_mask](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier image_barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
-                             VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
-            .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = vk_image,
-            .subresourceRange{
-                .aspectMask = aspect_mask,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                       vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, 0, image_barrier);
-    });
-    scheduler.Finish();
-}
-
-BlockLinearUnswizzleImage3DPass::BlockLinearUnswizzleImage3DPass(
-    const Device& device_, Scheduler& scheduler_, DescriptorPool& descriptor_pool_,
-    StagingBufferPool& staging_buffer_pool_,
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
-    : ComputePass(device_, scheduler_, descriptor_pool_, ASTC_DESCRIPTOR_SET_BINDINGS,
-                  ASTC_PASS_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY, ASTC_BANK_INFO,
-                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinear3DImagePushConstants)>,
-                  BLOCK_LINEAR_UNSWIZZLE_3D_COMP_SPV),
-      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
-
-BlockLinearUnswizzleImage3DPass::~BlockLinearUnswizzleImage3DPass() = default;
-
-void BlockLinearUnswizzleImage3DPass::Unswizzle(
-    Image& image, const StagingBufferRef& map,
-    std::span<const VideoCommon::SwizzleParameters> swizzles) {
-    using namespace VideoCommon::Accelerated;
-    scheduler.RequestOutsideRenderPassOperationContext();
-    const VkPipeline vk_pipeline = *pipeline;
-    const VkImageAspectFlags aspect_mask = image.AspectMask();
-    const VkImage vk_image = image.Handle();
-    const bool is_initialized = image.ExchangeInitialization();
-    scheduler.Record([vk_pipeline, vk_image, aspect_mask,
-                      is_initialized](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier image_barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = static_cast<VkAccessFlags>(is_initialized ? VK_ACCESS_SHADER_WRITE_BIT
-                                                                       : VK_ACCESS_NONE),
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
-            .oldLayout = is_initialized ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_UNDEFINED,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = vk_image,
-            .subresourceRange{
-                .aspectMask = aspect_mask,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(is_initialized ? vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER
-                              : VkPipelineStageFlags(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT),
-                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
-        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline);
-    });
-    for (const VideoCommon::SwizzleParameters& swizzle : swizzles) {
-        const size_t input_offset = swizzle.buffer_offset + map.offset;
-        const u32 num_dispatches_x = Common::DivCeil(swizzle.num_tiles.width, 16U);
-        const u32 num_dispatches_y = Common::DivCeil(swizzle.num_tiles.height, 8U);
-        const u32 num_dispatches_z = Common::DivCeil(swizzle.num_tiles.depth, 8U);
-
-        compute_pass_descriptor_queue.Acquire(scheduler, 2);
-        compute_pass_descriptor_queue.AddBuffer(map.buffer, input_offset,
-                                                image.guest_size_bytes - swizzle.buffer_offset);
-        compute_pass_descriptor_queue.AddImage(image.StorageImageView(swizzle.level));
-        const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
-
-        const auto p = MakeBlockLinearSwizzle3DParams(swizzle, image.info);
-        const BlockLinear3DImagePushConstants params{
-            .origin = p.origin,
-            .destination = p.destination,
-            .bytes_per_block_log2 = p.bytes_per_block_log2,
-            .slice_size = p.slice_size,
-            .block_size = p.block_size,
-            .x_shift = p.x_shift,
-            .block_height = p.block_height,
-            .block_height_mask = p.block_height_mask,
-            .block_depth = p.block_depth,
-            .block_depth_mask = p.block_depth_mask,
-        };
-        scheduler.Record([this, num_dispatches_x, num_dispatches_y, num_dispatches_z, params,
-                          descriptor_data](vk::CommandBuffer cmdbuf) {
-            const VkDescriptorSet set = descriptor_allocator.Commit();
-            device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
-            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
-            cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, params);
-            cmdbuf.Dispatch(num_dispatches_x, num_dispatches_y, num_dispatches_z);
-        });
-    }
-    scheduler.Record([vk_image, aspect_mask](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier image_barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
-                             VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
-            .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = vk_image,
-            .subresourceRange{
-                .aspectMask = aspect_mask,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                       vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, 0, image_barrier);
-    });
-    scheduler.Finish();
-}
-
-PitchUnswizzlePass::PitchUnswizzlePass(const Device& device_, Scheduler& scheduler_,
-                                       DescriptorPool& descriptor_pool_,
-                                       StagingBufferPool& staging_buffer_pool_,
-                                       ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
-    : ComputePass(device_, scheduler_, descriptor_pool_, ASTC_DESCRIPTOR_SET_BINDINGS,
-                  ASTC_PASS_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY, ASTC_BANK_INFO,
-                  COMPUTE_PUSH_CONSTANT_RANGE<sizeof(PitchUnswizzlePushConstants)>,
-                  PITCH_UNSWIZZLE_COMP_SPV),
-      scheduler{scheduler_}, staging_buffer_pool{staging_buffer_pool_},
-      compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
-
-PitchUnswizzlePass::~PitchUnswizzlePass() = default;
-
-void PitchUnswizzlePass::Unswizzle(Image& image, const StagingBufferRef& map,
-                                   std::span<const VideoCommon::SwizzleParameters> swizzles) {
-    scheduler.RequestOutsideRenderPassOperationContext();
-    const VkPipeline vk_pipeline = *pipeline;
-    const VkImageAspectFlags aspect_mask = image.AspectMask();
-    const VkImage vk_image = image.Handle();
-    const bool is_initialized = image.ExchangeInitialization();
-    scheduler.Record([vk_pipeline, vk_image, aspect_mask,
-                      is_initialized](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier image_barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = static_cast<VkAccessFlags>(is_initialized ? VK_ACCESS_SHADER_WRITE_BIT
-                                                                       : VK_ACCESS_NONE),
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
-            .oldLayout = is_initialized ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_UNDEFINED,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = vk_image,
-            .subresourceRange{
-                .aspectMask = aspect_mask,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(is_initialized ? vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER
-                              : VkPipelineStageFlags(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT),
-                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
-        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline);
-    });
-    const u32 bytes_per_block = VideoCore::Surface::BytesPerBlock(image.info.format);
-    for (const VideoCommon::SwizzleParameters& swizzle : swizzles) {
-        const size_t input_offset = swizzle.buffer_offset + map.offset;
-        const u32 num_dispatches_x = Common::DivCeil(swizzle.num_tiles.width, 32U);
-        const u32 num_dispatches_y = Common::DivCeil(swizzle.num_tiles.height, 32U);
-
-        compute_pass_descriptor_queue.Acquire(scheduler, 2);
-        compute_pass_descriptor_queue.AddBuffer(map.buffer, input_offset,
-                                                image.guest_size_bytes - swizzle.buffer_offset);
-        compute_pass_descriptor_queue.AddImage(image.StorageImageView(swizzle.level));
-        const void* const descriptor_data{compute_pass_descriptor_queue.UpdateData()};
-
-        const PitchUnswizzlePushConstants params{
-            .origin = {0, 0},
-            .destination = {0, 0},
-            .bytes_per_block = bytes_per_block,
-            .pitch = image.info.pitch,
-        };
-        scheduler.Record([this, num_dispatches_x, num_dispatches_y, params,
-                          descriptor_data](vk::CommandBuffer cmdbuf) {
-            const VkDescriptorSet set = descriptor_allocator.Commit();
-            device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
-            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
-            cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, params);
-            cmdbuf.Dispatch(num_dispatches_x, num_dispatches_y, 1);
-        });
-    }
-    scheduler.Record([vk_image, aspect_mask](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier image_barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT |
-                             VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
-            .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = vk_image,
-            .subresourceRange{
-                .aspectMask = aspect_mask,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                       vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, 0, image_barrier);
-    });
-    scheduler.Finish();
-}
-
 constexpr u32 BL3D_BINDING_INPUT_BUFFER  = 0;
 constexpr u32 BL3D_BINDING_OUTPUT_BUFFER = 1;
 
@@ -1159,23 +833,6 @@ void BlockLinearUnswizzle3DPass::UnswizzleChunk(
             return;
         }
 
-        if (!is_first_chunk) {
-            const VkBufferMemoryBarrier reuse_barrier{
-                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-                .pNext = nullptr,
-                .srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
-                .dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-                .buffer = out_buffer,
-                .offset = 0,
-                .size = VK_WHOLE_SIZE,
-            };
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, nullptr,
-                                   reuse_barrier, nullptr);
-        }
-
         device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});

src/video_core/renderer_vulkan/vk_compute_pass.h

@@ -25,7 +25,6 @@ struct SwizzleParameters;
 
 namespace Vulkan {
 
-using VideoCommon::Accelerated::BlockLinearSwizzle2DParams;
 using VideoCommon::Accelerated::BlockLinearSwizzle3DParams;
 
 class Device;
@@ -165,56 +164,6 @@ private:
     ComputePassDescriptorQueue& compute_pass_descriptor_queue;
 };
 
-class BlockLinearUnswizzleImage2DPass final : public ComputePass {
-public:
-    explicit BlockLinearUnswizzleImage2DPass(const Device& device_, Scheduler& scheduler_,
-                                             DescriptorPool& descriptor_pool_,
-                                             StagingBufferPool& staging_buffer_pool_,
-                                             ComputePassDescriptorQueue& compute_pass_descriptor_queue_);
-    ~BlockLinearUnswizzleImage2DPass();
-
-    void Unswizzle(Image& image, const StagingBufferRef& map,
-                   std::span<const VideoCommon::SwizzleParameters> swizzles);
-
-private:
-    Scheduler& scheduler;
-    StagingBufferPool& staging_buffer_pool;
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
-};
-
-class BlockLinearUnswizzleImage3DPass final : public ComputePass {
-public:
-    explicit BlockLinearUnswizzleImage3DPass(const Device& device_, Scheduler& scheduler_,
-                                             DescriptorPool& descriptor_pool_,
-                                             StagingBufferPool& staging_buffer_pool_,
-                                             ComputePassDescriptorQueue& compute_pass_descriptor_queue_);
-    ~BlockLinearUnswizzleImage3DPass();
-
-    void Unswizzle(Image& image, const StagingBufferRef& map,
-                   std::span<const VideoCommon::SwizzleParameters> swizzles);
-
-private:
-    Scheduler& scheduler;
-    StagingBufferPool& staging_buffer_pool;
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
-};
-
-class PitchUnswizzlePass final : public ComputePass {
-public:
-    explicit PitchUnswizzlePass(const Device& device_, Scheduler& scheduler_,
-                                DescriptorPool& descriptor_pool_,
-                                StagingBufferPool& staging_buffer_pool_,
-                                ComputePassDescriptorQueue& compute_pass_descriptor_queue_);
-    ~PitchUnswizzlePass();
-
-    void Unswizzle(Image& image, const StagingBufferRef& map,
-                   std::span<const VideoCommon::SwizzleParameters> swizzles);
-
-private:
-    Scheduler& scheduler;
-    StagingBufferPool& staging_buffer_pool;
-    ComputePassDescriptorQueue& compute_pass_descriptor_queue;
-};
 
 class MSAACopyPass final : public ComputePass {
 public:

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -195,42 +195,8 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
     return allocator.CreateImage(image_ci);
 }
 
-[[nodiscard]] VkFormat UnswizzleStorageFormat(u32 bytes_per_block) {
-    switch (bytes_per_block) {
-    case 1:
-        return VK_FORMAT_R8_UINT;
-    case 2:
-        return VK_FORMAT_R16_UINT;
-    case 4:
-        return VK_FORMAT_R32_UINT;
-    case 8:
-        return VK_FORMAT_R32G32_UINT;
-    case 16:
-        return VK_FORMAT_R32G32B32A32_UINT;
-    default:
-        ASSERT_MSG(false, "Invalid bytes_per_block={} for accelerated unswizzle", bytes_per_block);
-        return VK_FORMAT_R32_UINT;
-    }
-}
-
-[[nodiscard]] bool IsUnswizzleStorageFormatSupported(const Device& device, u32 bytes_per_block) {
-    switch (bytes_per_block) {
-    case 1:
-        return device.IsStorageBuffer8BitAccessSupported();
-    case 2:
-        return device.IsStorageBuffer16BitAccessSupported();
-    case 4:
-    case 8:
-    case 16:
-        return true;
-    default:
-        return false;
-    }
-}
-
 [[nodiscard]] vk::ImageView MakeStorageView(const vk::Device& device, u32 level, VkImage image,
-                                            VkFormat format,
-                                            VkImageViewType view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY) {
+                                            VkFormat format) {
     static constexpr VkImageViewUsageCreateInfo storage_image_view_usage_create_info{
         .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
         .pNext = nullptr,
@@ -241,7 +207,7 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
         .pNext = &storage_image_view_usage_create_info,
         .flags = 0,
         .image = image,
-        .viewType = view_type,
+        .viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
         .format = format,
         .components{
             .r = VK_COMPONENT_SWIZZLE_IDENTITY,
@@ -921,12 +887,6 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& sched
     if (device.IsStorageImageMultisampleSupported()) {
         msaa_copy_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool, compute_pass_descriptor_queue);
     }
-    bl_unswizzle_2d_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,
-                                 compute_pass_descriptor_queue);
-    bl_unswizzle_3d_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,
-                                 compute_pass_descriptor_queue);
-    pitch_unswizzle_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,
-                                 compute_pass_descriptor_queue);
     if (!device.IsKhrImageFormatListSupported()) {
         return;
     }
@@ -934,11 +894,6 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& sched
         const auto image_format = static_cast<PixelFormat>(index_a);
         if (IsPixelFormatASTC(image_format) && !device.IsOptimalAstcSupported()) {
             view_formats[index_a].push_back(VK_FORMAT_A8B8G8R8_UNORM_PACK32);
-        } else if (!IsPixelFormatASTC(image_format) && !IsPixelFormatBCn(image_format)) {
-            const u32 bpp = VideoCore::Surface::BytesPerBlock(image_format);
-            if (IsUnswizzleStorageFormatSupported(device, bpp)) {
-                view_formats[index_a].push_back(UnswizzleStorageFormat(bpp));
-            }
         }
         for (size_t index_b = 0; index_b < VideoCore::Surface::MaxPixelFormat; index_b++) {
             const auto view_format = static_cast<PixelFormat>(index_b);
@@ -1625,16 +1580,6 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
         flags |= VideoCommon::ImageFlagBits::Converted;
         flags |= VideoCommon::ImageFlagBits::CostlyLoad;
     }
-    if (!IsPixelFormatASTC(info.format) && !IsPixelFormatBCn(info.format) &&
-        VideoCore::Surface::GetFormatType(info.format) ==
-            VideoCore::Surface::SurfaceType::ColorTexture &&
-        (info.type == ImageType::e2D || info.type == ImageType::e3D ||
-         info.type == ImageType::Linear)) {
-        if (IsUnswizzleStorageFormatSupported(runtime->device,
-                                              VideoCore::Surface::BytesPerBlock(info.format))) {
-            flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
-        }
-    }
     if (runtime->device.HasDebuggingToolAttached()) {
         original_image.SetObjectNameEXT(VideoCommon::Name(*this).c_str());
     }
@@ -1648,19 +1593,6 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
             storage_image_views[level] =
                 MakeStorageView(device, level, *original_image, VK_FORMAT_A8B8G8R8_UNORM_PACK32);
         }
-    } else if (True(flags & VideoCommon::ImageFlagBits::AcceleratedUpload)) {
-        const auto& device = runtime->device.GetLogical();
-        const VkFormat storage_format =
-            UnswizzleStorageFormat(VideoCore::Surface::BytesPerBlock(info.format));
-        const VkImageViewType storage_view_type = info.type == ImageType::e3D
-                                                       ? VK_IMAGE_VIEW_TYPE_3D
-                                                   : info.type == ImageType::Linear
-                                                       ? VK_IMAGE_VIEW_TYPE_2D
-                                                       : VK_IMAGE_VIEW_TYPE_2D_ARRAY;
-        for (s32 level = 0; level < info.resources.levels; ++level) {
-            storage_image_views[level] =
-                MakeStorageView(device, level, *original_image, storage_format, storage_view_type);
-        }
     }
 }
 
@@ -2516,24 +2448,16 @@ void TextureCacheRuntime::AccelerateImageUpload(
         return astc_decoder_pass->Assemble(image, map, swizzles);
     }
 
-    if (IsPixelFormatBCn(image.info.format)) {
-        if (Settings::values.gpu_unswizzle_enabled.GetValue() && bl3d_unswizzle_pass &&
-            image.info.type == ImageType::e3D && image.info.resources.levels == 1 &&
-            image.info.resources.layers == 1) {
-            return bl3d_unswizzle_pass->Unswizzle(image, map, swizzles, z_start, z_count);
+    if (!Settings::values.gpu_unswizzle_enabled.GetValue() || !bl3d_unswizzle_pass) {
+        if (IsPixelFormatBCn(image.info.format) && image.info.type == ImageType::e3D) {
+            ASSERT(false && "GPU unswizzle is disabled for BCn 3D texture");
         }
-        ASSERT(false && "GPU unswizzle is disabled for BCn 3D texture");
+        ASSERT(false);
         return;
     }
 
-    if (image.info.type == ImageType::e2D) {
-        return bl_unswizzle_2d_pass->Unswizzle(image, map, swizzles);
-    }
-    if (image.info.type == ImageType::e3D) {
-        return bl_unswizzle_3d_pass->Unswizzle(image, map, swizzles);
-    }
-    if (image.info.type == ImageType::Linear) {
-        return pitch_unswizzle_pass->Unswizzle(image, map, swizzles);
+    if (bl3d_unswizzle_pass && IsPixelFormatBCn(image.info.format) && image.info.type == ImageType::e3D && image.info.resources.levels == 1 && image.info.resources.layers == 1) {
+        return bl3d_unswizzle_pass->Unswizzle(image, map, swizzles, z_start, z_count);
     }
 
     ASSERT(false);

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -130,9 +130,6 @@ public:
     std::optional<ASTCDecoderPass> astc_decoder_pass;
 
     std::optional<BlockLinearUnswizzle3DPass> bl3d_unswizzle_pass;
-    std::optional<BlockLinearUnswizzleImage2DPass> bl_unswizzle_2d_pass;
-    std::optional<BlockLinearUnswizzleImage3DPass> bl_unswizzle_3d_pass;
-    std::optional<PitchUnswizzlePass> pitch_unswizzle_pass;
     std::optional<MSAACopyPass> msaa_copy_pass;
     const Settings::ResolutionScalingInfo& resolution;
     std::array<std::vector<VkFormat>, VideoCore::Surface::MaxPixelFormat> view_formats;

src/video_core/vulkan_common/vulkan_device.h

@@ -888,16 +888,6 @@ FN_MAX_LIMIT_LIST
                features.bit16_storage.storageBuffer16BitAccess;
     }
 
-    /// Returns true if the device supports reading 8-bit values from a storage buffer.
-    bool IsStorageBuffer8BitAccessSupported() const {
-        return features.bit8_storage.storageBuffer8BitAccess;
-    }
-
-    /// Returns true if the device supports reading 16-bit values from a storage buffer.
-    bool IsStorageBuffer16BitAccessSupported() const {
-        return features.bit16_storage.storageBuffer16BitAccess;
-    }
-
     [[nodiscard]] static constexpr bool CheckBrokenCompute(VkDriverId driver_id,
                                                            u32 driver_version) {
         if (driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {