extra fixups for cross compile

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

externals/ffmpeg/CMakeLists.txt

@@ -58,16 +58,24 @@ endif()
 
 if (PLATFORM_PS4 OR PLATFORM_MANAGARM)
     # Doesn't support VA-API, don't go thru the embarrassment of trying to enable it
-    list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
+    list(APPEND FFmpeg_HWACCEL_FLAGS
+        --disable-vaapi
+        --disnable-cuvid
+        --disnable-ffnvcodec
+        --disnable-nvdec
+        --disable-vulkan
+        --disable-libdrm)
+elseif (UNIX)
     find_package(PkgConfig REQUIRED)
-    pkg_check_modules(LIBVA libva)
-    pkg_check_modules(CUDA cuda)
-    pkg_check_modules(FFNVCODEC ffnvcodec)
-    pkg_check_modules(VDPAU vdpau)
 
+    # X11 is "optional", some distros may opt for a super-fully wayland install...
     find_package(X11)
     if(X11_FOUND)
+        # Include X11 if possible, some APIs such as VDPAU heavily depend
+        # upon it's existence!
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${X11_LIBRARIES})
+        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${X11_INCLUDE_DIRS})
+        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${X11_LDFLAGS})
         if (NOT APPLE)
             # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
             if(PLATFORM_SUN)
@@ -76,32 +84,37 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
                     "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
             else()
                 pkg_check_modules(LIBDRM libdrm REQUIRED)
-                list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                    ${LIBDRM_LIBRARIES})
-                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                    ${LIBDRM_INCLUDE_DIRS})
+                list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBDRM_LIBRARIES})
+                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBDRM_INCLUDE_DIRS})
+                list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBDRM_LDFLAGS})
             endif()
-            list(APPEND FFmpeg_HWACCEL_FLAGS
-                --enable-libdrm)
+            list(APPEND FFmpeg_HWACCEL_FLAGS --enable-libdrm)
         endif()
+
+        pkg_check_modules(LIBVA libva)
         if(LIBVA_FOUND)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA_INCLUDE_DIRS})
+            list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA_LDFLAGS})
+
+            # Logically, they can only exist if libva itself exists
             pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
             pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                ${X11_LIBRARIES}
-                ${LIBVA-DRM_LIBRARIES}
-                ${LIBVA-X11_LIBRARIES}
-                ${LIBVA_LIBRARIES})
+            if (LIBVA-DRM_FOUND)
+                list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA-DRM_LIBRARIES})
+                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA-DRM_INCLUDE_DIRS})
+                list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA-DRM_LDFLAGS})
+            endif()
+            if (LIBVA-X11_FOUND)
+                list(APPEND FFmpeg_HWACCEL_LIBRARIES ${LIBVA-X11_LIBRARIES})
+                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${LIBVA-X11_INCLUDE_DIRS})
+                list(APPEND FFmpeg_HWACCEL_LDFLAGS ${LIBVA-X11_LDFLAGS})
+            endif()
+
             list(APPEND FFmpeg_HWACCEL_FLAGS
                 --enable-hwaccel=h264_vaapi
                 --enable-hwaccel=vp8_vaapi
                 --enable-hwaccel=vp9_vaapi)
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                ${X11_INCLUDE_DIRS}
-                ${LIBVA-DRM_INCLUDE_DIRS}
-                ${LIBVA-X11_INCLUDE_DIRS}
-                ${LIBVA_INCLUDE_DIRS}
-            )
             message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
         else()
             list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
@@ -112,6 +125,12 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
         message(WARNING "ffmpeg: X11 libraries not found, disabling VA-API...")
     endif()
 
+    pkg_check_modules(CUDA cuda)
+    pkg_check_modules(FFNVCODEC ffnvcodec)
+    pkg_check_modules(VDPAU vdpau)
+    pkg_check_modules(VULKAN vulkan)
+    find_package(spirv-headers)
+
     if (FFNVCODEC_FOUND)
         list(APPEND FFmpeg_HWACCEL_FLAGS
             --enable-cuvid
@@ -119,8 +138,7 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
             --enable-nvdec
             --enable-hwaccel=h264_nvdec
             --enable-hwaccel=vp8_nvdec
-            --enable-hwaccel=vp9_nvdec
-        )
+            --enable-hwaccel=vp9_nvdec)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES ${FFNVCODEC_LIBRARIES})
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${FFNVCODEC_INCLUDE_DIRS})
         list(APPEND FFmpeg_HWACCEL_LDFLAGS ${FFNVCODEC_LDFLAGS})
@@ -141,8 +159,7 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
         list(APPEND FFmpeg_HWACCEL_FLAGS
             --enable-vdpau
             --enable-hwaccel=h264_vdpau
-            --enable-hwaccel=vp9_vdpau
-        )
+            --enable-hwaccel=vp9_vdpau)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
         list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
@@ -151,6 +168,24 @@ elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING AND NOT ANDROID)
         list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
         message(WARNING "ffmpeg: libvdpau-dev not found, disabling Video Decode and Presentation API for Unix (VDPAU)...")
     endif()
+
+    if (VULKAN_FOUND AND NOT APPLE)
+        list(APPEND FFmpeg_HWACCEL_FLAGS
+            --enable-vulkan
+            --enable-hwaccel=h264_vulkan
+            --enable-hwaccel=vp9_vulkan)
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VULKAN_LIBRARIES})
+        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VULKAN_INCLUDE_DIRS})
+        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VULKAN_LDFLAGS})
+        message(STATUS "ffmpeg: vulkan libraries version ${VULKAN_VERSION} found")
+    endif()
+
+    if (SPIRV_HEADERS_FOUND)
+        list(APPEND FFmpeg_HWACCEL_LIBRARIES ${SPIRV_HEADERS_LIBRARIES})
+        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${SPIRV_HEADERS_INCLUDE_DIRS})
+        list(APPEND FFmpeg_HWACCEL_LDFLAGS ${SPIRV_HEADERS_LDFLAGS})
+        message(STATUS "ffmpeg: spirv-headers libraries version ${SPIRV_HEADERS_VERSION} found")
+    endif()
 endif()
 
 if (PLATFORM_PS4)
@@ -169,7 +204,7 @@ if (PLATFORM_PS4)
     )
 elseif (PLATFORM_MANAGARM)
     # Required for proper stuff
-    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
+    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS 
         --disable-pthreads
         --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
     )
@@ -247,8 +282,14 @@ else()
 
     # `configure` parameters builds only exactly what yuzu needs from FFmpeg
     # `--disable-vdpau` is needed to avoid linking issues
-    set(FFmpeg_CC ${CMAKE_C_COMPILER_LAUNCHER}  ${CMAKE_C_COMPILER})
-    set(FFmpeg_CXX ${CMAKE_CXX_COMPILER_LAUNCHER}  ${CMAKE_CXX_COMPILER})
+    set(FFmpeg_CC ${CMAKE_C_COMPILER_LAUNCHER} ${CMAKE_C_COMPILER})
+    set(FFmpeg_CXX ${CMAKE_CXX_COMPILER_LAUNCHER} ${CMAKE_CXX_COMPILER})
+    if (FFmpeg_IS_CROSS_COMPILING)
+        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --ld=${CMAKE_LINKER})
+    endif ()
+    # TODO: This is a bit fragile, it depends on FFmpeg_HWACCEL_LDFLAGS being a list
+    # whereas CMAKE_C_FLAGS (and likewise) is meant to NOT be a list, but rather
+    # an elongated piece of string
     add_custom_command(
         OUTPUT
             ${FFmpeg_MAKEFILE}
@@ -262,6 +303,7 @@ else()
                 --disable-ffprobe
                 --disable-network
                 --disable-swresample
+                --disable-iconv
                 --enable-decoder=h264
                 --enable-decoder=vp8
                 --enable-decoder=vp9
@@ -269,10 +311,9 @@ else()
                 --enable-pic
                 --cc=${FFmpeg_CC}
                 --cxx=${FFmpeg_CXX}
-                --ld=${CMAKE_LINKER}
                 --extra-cflags=${CMAKE_C_FLAGS}
                 --extra-cxxflags=${CMAKE_CXX_FLAGS}
-                --extra-ldflags=${CMAKE_C_LINK_FLAGS}
+                --extra-ldflags="${FFmpeg_HWACCEL_LDFLAGS}"
                 ${FFmpeg_HWACCEL_FLAGS}
                 ${FFmpeg_CROSS_COMPILE_FLAGS}
         WORKING_DIRECTORY
@@ -280,6 +321,7 @@ else()
     )
     unset(FFmpeg_CC)
     unset(FFmpeg_CXX)
+    unset(FFmpeg_LD)
     unset(FFmpeg_HWACCEL_FLAGS)
     unset(FFmpeg_CROSS_COMPILE_FLAGS)
 
@@ -294,7 +336,7 @@ else()
     set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
 
     # BSD make or Solaris make don't support ffmpeg make-j8
-    if (PLATFORM_LINUX OR ANDROID OR APPLE OR WIN32 OR PLATFORM_FREEBSD)
+    if (DEFINED SYSTEM_THREADS AND (PLATFORM_LINUX OR ANDROID OR APPLE OR WIN32 OR PLATFORM_FREEBSD))
         set(FFmpeg_MAKE_ARGS -j${SYSTEM_THREADS})
     else()
         set(FFmpeg_MAKE_ARGS "")

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) {