fuck

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

CMakeModules/CPMUtil.cmake

@@ -370,7 +370,6 @@ function(AddPackage)
 
         URL
 
-        KEY
         SOURCE_SUBDIR
         BUNDLED_PACKAGE
         FORCE_BUNDLED_PACKAGE
@@ -435,9 +434,7 @@ function(AddPackage)
 
     cpm_utils_message(DEBUG ${PKG_ARGS_NAME} "Download URL is ${pkg_url}")
 
-    if(DEFINED PKG_ARGS_KEY AND NOT PKG_ARGS_KEY STREQUAL "")
-        set(pkg_key ${PKG_ARGS_KEY})
-    elseif(DEFINED PKG_ARGS_SHA)
+    if(DEFINED PKG_ARGS_SHA)
         string(SUBSTRING ${PKG_ARGS_SHA} 0 4 pkg_key)
     elseif(DEFINED PKG_ARGS_VERSION)
         set(pkg_key ${PKG_ARGS_VERSION})
@@ -720,7 +717,6 @@ function(AddCIPackage)
             TAG "v${ARTIFACT_VERSION}"
             MIN_VERSION ${ARTIFACT_VERSION}
             ARTIFACT ${ARTIFACT}
-            KEY "${pkgname}-${ARTIFACT_VERSION}"
             HASH ${sha512sum_hash}
             FORCE_BUNDLED_PACKAGE ON
             ${EXTRA_ARGS})

src/common/dynamic_library.cpp

@@ -5,11 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <string>
-
-#ifndef _WIN32
 #include <cstring>
-#endif
-
 #include <utility>
 
 #include <fmt/ranges.h>

src/common/uuid.cpp

@@ -208,4 +208,12 @@ UUID UUID::MakeRandomRFC4122V4() {
     return uuid;
 }
 
+UUID UUID::MakeRFC4122V5(std::span<u8, 20> sha1) {
+    UUID uuid{};
+    std::memcpy(&uuid.uuid, sha1.data(), sizeof(UUID));
+    uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
+    uuid.uuid[6] = 0x50 | (uuid.uuid[6] & 0xF);
+    return uuid;
+}
+
 } // namespace Common

src/common/uuid.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -5,6 +8,7 @@
 
 #include <array>
 #include <functional>
+#include <span>
 #include <string>
 
 #include "common/common_types.h"
@@ -86,28 +90,20 @@ struct UUID {
         };
     }
 
-    /**
-     * Creates a random UUID.
-     *
-     * @returns A random UUID.
-     */
-    static UUID MakeRandom();
+    /// @brief Creates a random UUID.
+    /// @returns A random UUID.
+    [[nodiscard]] static UUID MakeRandom();
 
-    /**
-     * Creates a random UUID with a seed.
-     *
-     * @param seed A seed to initialize the Mersenne-Twister RNG
-     *
-     * @returns A random UUID.
-     */
-    static UUID MakeRandomWithSeed(u32 seed);
+    /// @brief Creates a random UUID with a seed.
+    /// @param seed A seed to initialize the Mersenne-Twister RNG
+    /// @returns A random UUID.
+    [[nodiscard]] static UUID MakeRandomWithSeed(u32 seed);
 
-    /**
-     * Creates a random UUID. The generated UUID is RFC 4122 Version 4 compliant.
-     *
-     * @returns A random UUID that is RFC 4122 Version 4 compliant.
-     */
-    static UUID MakeRandomRFC4122V4();
+    /// @brief Creates a random UUID. The generated UUID is RFC 4122 Version 4 compliant.
+    /// @returns A random UUID that is RFC 4122 Version 4 compliant.
+    [[nodiscard]] static UUID MakeRandomRFC4122V4();
+
+    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 20> sha1);
 
     friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };

src/core/file_sys/control_metadata.h

@@ -274,23 +274,22 @@ public:
     explicit NACP(VirtualFile file);
     ~NACP();
 
-    const LanguageEntry& GetLanguageEntry() const;
-    std::string GetApplicationName() const;
-    std::string GetDeveloperName() const;
-    u64 GetTitleId() const;
-    u64 GetDLCBaseTitleId() const;
-    std::string GetVersionString() const;
-    u64 GetDefaultNormalSaveSize() const;
-    u64 GetDefaultJournalSaveSize() const;
-    u32 GetSupportedLanguages() const;
-    std::vector<std::string> GetApplicationNames() const;
-    std::vector<u8> GetRawBytes() const;
-    bool GetUserAccountSwitchLock() const;
-    u64 GetDeviceSaveDataSize() const;
-    u32 GetParentalControlFlag() const;
-    const std::array<u8, 0x20>& GetRatingAge() const;
+    [[nodiscard]] const LanguageEntry& GetLanguageEntry() const;
+    [[nodiscard]] std::string GetApplicationName() const;
+    [[nodiscard]] std::string GetDeveloperName() const;
+    [[nodiscard]] u64 GetTitleId() const;
+    [[nodiscard]] u64 GetDLCBaseTitleId() const;
+    [[nodiscard]] std::string GetVersionString() const;
+    [[nodiscard]] u64 GetDefaultNormalSaveSize() const;
+    [[nodiscard]] u64 GetDefaultJournalSaveSize() const;
+    [[nodiscard]] u32 GetSupportedLanguages() const;
+    [[nodiscard]] std::vector<std::string> GetApplicationNames() const;
+    [[nodiscard]] std::vector<u8> GetRawBytes() const;
+    [[nodiscard]] bool GetUserAccountSwitchLock() const;
+    [[nodiscard]] u64 GetDeviceSaveDataSize() const;
+    [[nodiscard]] u32 GetParentalControlFlag() const;
+    [[nodiscard]] const std::array<u8, 0x20>& GetRatingAge() const;
 
-private:
     RawNACP raw{};
     std::vector<LanguageEntry> language_entries;
 };

src/core/file_sys/patch_manager.cpp

@@ -1156,4 +1156,14 @@ PatchManager::Metadata PatchManager::ParseControlNCA(const NCA& nca) const {
 
     return {std::move(nacp), icon_file};
 }
+
+[[nodiscard]] PatchManager::Metadata PatchManager::GetMetadataFromBaseOrUpdate(Core::System& system, u64 application_id) noexcept {
+    const FileSys::PatchManager pm{application_id, system.GetFileSystemController(), system.GetContentProvider()};
+    auto metadata = pm.GetControlMetadata();
+    if (metadata.first != nullptr)
+        return metadata;
+    const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(application_id), system.GetFileSystemController(), system.GetContentProvider()};
+    return pm_update.GetControlMetadata();
+}
+
 } // namespace FileSys

src/core/file_sys/patch_manager.h

@@ -105,6 +105,9 @@ public:
     // Version of GetControlMetadata that takes an arbitrary NCA
     [[nodiscard]] Metadata ParseControlNCA(const NCA& nca) const;
 
+    /// @brief Gets NACP metadata (accounting for any patches or updates)
+    [[nodiscard]] static PatchManager::Metadata GetMetadataFromBaseOrUpdate(Core::System& system, u64 application_id) noexcept;
+
 private:
     [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
                                                           const std::string& build_id) const;

src/core/hle/service/am/service/application_functions.cpp

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <openssl/evp.h>
+
 #include "common/settings.h"
 #include "common/uuid.h"
 #include "core/file_sys/control_metadata.h"
@@ -154,20 +156,7 @@ Result IApplicationFunctions::GetDesiredLanguage(Out<u64> out_language_code) {
     // Default to 0 (all languages supported)
     u32 supported_languages = 0;
 
-    const auto res = [this] {
-        const FileSys::PatchManager pm{m_applet->program_id, system.GetFileSystemController(),
-                                       system.GetContentProvider()};
-        auto metadata = pm.GetControlMetadata();
-        if (metadata.first != nullptr) {
-            return metadata;
-        }
-
-        const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(m_applet->program_id),
-                                              system.GetFileSystemController(),
-                                              system.GetContentProvider()};
-        return pm_update.GetControlMetadata();
-    }();
-
+    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
     if (res.first != nullptr) {
         supported_languages = res.first->GetSupportedLanguages();
     }
@@ -205,20 +194,7 @@ Result IApplicationFunctions::SetTerminateResult(Result terminate_result) {
 Result IApplicationFunctions::GetDisplayVersion(Out<DisplayVersion> out_display_version) {
     LOG_DEBUG(Service_AM, "called");
 
-    const auto res = [this] {
-        const FileSys::PatchManager pm{m_applet->program_id, system.GetFileSystemController(),
-                                       system.GetContentProvider()};
-        auto metadata = pm.GetControlMetadata();
-        if (metadata.first != nullptr) {
-            return metadata;
-        }
-
-        const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(m_applet->program_id),
-                                              system.GetFileSystemController(),
-                                              system.GetContentProvider()};
-        return pm_update.GetControlMetadata();
-    }();
-
+    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
     if (res.first != nullptr) {
         const auto& version = res.first->GetVersionString();
         std::memcpy(out_display_version->string.data(), version.data(),
@@ -347,8 +323,21 @@ Result IApplicationFunctions::NotifyRunning(Out<bool> out_became_running) {
 }
 
 Result IApplicationFunctions::GetPseudoDeviceId(Out<Common::UUID> out_pseudo_device_id) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_pseudo_device_id = {};
+    LOG_WARNING(Service_AM, "(stubbed)");
+
+    // This should be hashed with the device specific hash
+    // for now this will do
+    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
+    u8 hash[EVP_MAX_MD_SIZE];
+    unsigned int hash_len = 0;
+    auto const seed = res.first->raw.seed_for_pseudo_device_id;
+    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
+    auto const algorithm = EVP_sha1();
+    EVP_DigestInit_ex(ctx, algorithm, nullptr);
+    EVP_DigestUpdate(ctx, &seed, sizeof(seed));
+    EVP_DigestFinal_ex(ctx, hash, &hash_len);
+    EVP_MD_CTX_free(ctx);
+    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 20>{hash, std::size(hash)});
     R_SUCCEED();
 }
 

src/core/hle/service/am/service/library_applet_self_accessor.cpp

@@ -252,19 +252,7 @@ Result ILibraryAppletSelfAccessor::GetMainAppletApplicationDesiredLanguage(
     // Default to 0 (all languages supported)
     u32 supported_languages = 0;
 
-    const auto res = [this, identity] {
-        const FileSys::PatchManager pm{identity.application_id, system.GetFileSystemController(),
-                                       system.GetContentProvider()};
-        auto metadata = pm.GetControlMetadata();
-        if (metadata.first != nullptr) {
-            return metadata;
-        }
-
-        const FileSys::PatchManager pm_update{FileSys::GetUpdateTitleID(identity.application_id),
-                                              system.GetFileSystemController(),
-                                              system.GetContentProvider()};
-        return pm_update.GetControlMetadata();
-    }();
+    const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, identity.application_id);
 
     if (res.first != nullptr) {
         supported_languages = res.first->GetSupportedLanguages();

src/video_core/host_shaders/block_linear_unswizzle_2d.comp

@@ -11,9 +11,8 @@
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)
-#define BINDING_SWIZZLE_BUFFER 0
-#define BINDING_INPUT_BUFFER 1
-#define BINDING_OUTPUT_IMAGE 2
+#define BINDING_INPUT_BUFFER 0
+#define BINDING_OUTPUT_IMAGE 1
 
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
 
@@ -26,8 +25,7 @@
 #define BEGIN_PUSH_CONSTANTS
 #define END_PUSH_CONSTANTS
 #define UNIFORM(n) layout (location = n) uniform
-#define BINDING_SWIZZLE_BUFFER 0
-#define BINDING_INPUT_BUFFER 1
+#define BINDING_INPUT_BUFFER 0
 #define BINDING_OUTPUT_IMAGE 0
 
 #endif
@@ -43,10 +41,6 @@ UNIFORM(6) uint block_height;
 UNIFORM(7) uint block_height_mask;
 END_PUSH_CONSTANTS
 
-layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
-    uint swizzle_table[];
-};
-
 #if HAS_EXTENDED_TYPES
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8 { uint8_t u8data[]; };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16 { uint16_t u16data[]; };
@@ -71,9 +65,19 @@ const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHI
 
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1);
 
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
 uint SwizzleOffset(uvec2 pos) {
     pos = pos & SWIZZLE_MASK;
-    return swizzle_table[pos.y * 64 + pos.x];
+    return SwizzleTable(pos.y * 64 + pos.x);
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/host_shaders/block_linear_unswizzle_3d.comp

@@ -11,9 +11,8 @@
 #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
 #define END_PUSH_CONSTANTS };
 #define UNIFORM(n)
-#define BINDING_SWIZZLE_BUFFER 0
-#define BINDING_INPUT_BUFFER 1
-#define BINDING_OUTPUT_IMAGE 2
+#define BINDING_INPUT_BUFFER 0
+#define BINDING_OUTPUT_IMAGE 1
 
 #else // ^^^ Vulkan ^^^ // vvv OpenGL vvv
 
@@ -26,8 +25,7 @@
 #define BEGIN_PUSH_CONSTANTS
 #define END_PUSH_CONSTANTS
 #define UNIFORM(n) layout (location = n) uniform
-#define BINDING_SWIZZLE_BUFFER 0
-#define BINDING_INPUT_BUFFER 1
+#define BINDING_INPUT_BUFFER 0
 #define BINDING_OUTPUT_IMAGE 0
 
 #endif
@@ -45,10 +43,6 @@ UNIFORM(8) uint block_depth;
 UNIFORM(9) uint block_depth_mask;
 END_PUSH_CONSTANTS
 
-layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
-    uint swizzle_table[];
-};
-
 #if HAS_EXTENDED_TYPES
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8 { uint8_t u8data[]; };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16 { uint16_t u16data[]; };
@@ -73,9 +67,19 @@ const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHI
 
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1, GOB_SIZE_Y - 1);
 
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
 uint SwizzleOffset(uvec2 pos) {
     pos = pos & SWIZZLE_MASK;
-    return swizzle_table[pos.y * 64 + pos.x];
+    return SwizzleTable(pos.y * 64 + pos.x);
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/host_shaders/block_linear_unswizzle_3d_bcn.comp

@@ -10,9 +10,8 @@
     #define BEGIN_PUSH_CONSTANTS layout(push_constant) uniform PushConstants {
     #define END_PUSH_CONSTANTS };
     #define UNIFORM(n)
-    #define BINDING_SWIZZLE_BUFFER 0
-    #define BINDING_INPUT_BUFFER   1
-    #define BINDING_OUTPUT_BUFFER  2
+    #define BINDING_INPUT_BUFFER   0
+    #define BINDING_OUTPUT_BUFFER  1
 #else
     #extension GL_NV_gpu_shader5 : enable
     #ifdef GL_NV_gpu_shader5
@@ -23,7 +22,6 @@
     #define BEGIN_PUSH_CONSTANTS
     #define END_PUSH_CONSTANTS
     #define UNIFORM(n) layout(location = n) uniform
-    #define BINDING_SWIZZLE_BUFFER 0
     #define BINDING_INPUT_BUFFER   1
     #define BINDING_OUTPUT_BUFFER  0
 #endif
@@ -66,13 +64,9 @@ END_PUSH_CONSTANTS
 #endif
 
 // --- Buffers ---
-layout(binding = BINDING_SWIZZLE_BUFFER, std430) readonly buffer SwizzleTable {
-    uint swizzle_table[];
-};
-
 #if HAS_EXTENDED_TYPES
-    layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8   { uint8_t  u8data[];  };
-    layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16  { uint16_t u16data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU8   { uint8_t  u8data[];  };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU16  { uint16_t u16data[]; };
 #endif
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32  { uint   u32data[];  };
 layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64  { uvec2  u64data[];  };
@@ -96,10 +90,20 @@ const uint GOB_SIZE_Z_SHIFT = 0;
 const uint GOB_SIZE_SHIFT   = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHIFT;
 const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
 
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
 // --- Helpers ---
 uint SwizzleOffset(uvec2 pos) {
     pos &= SWIZZLE_MASK;
-    return swizzle_table[pos.y * 64u + pos.x];
+    return SwizzleTable(pos.y * 64u + pos.x);
 }
 
 uvec4 ReadTexel(uint offset) {

src/video_core/renderer_opengl/util_shaders.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -56,10 +59,8 @@ UtilShaders::UtilShaders(ProgramManager& program_manager_)
       copy_bc4_program(MakeProgram(OPENGL_COPY_BC4_COMP)),
       convert_s8d24_program(MakeProgram(OPENGL_CONVERT_S8D24_COMP)),
       convert_ms_to_nonms_program(MakeProgram(CONVERT_MSAA_TO_NON_MSAA_COMP)),
-      convert_nonms_to_ms_program(MakeProgram(CONVERT_NON_MSAA_TO_MSAA_COMP)) {
-    const auto swizzle_table = Tegra::Texture::MakeSwizzleTable();
-    swizzle_table_buffer.Create();
-    glNamedBufferStorage(swizzle_table_buffer.handle, sizeof(swizzle_table), &swizzle_table, 0);
+      convert_nonms_to_ms_program(MakeProgram(CONVERT_NON_MSAA_TO_MSAA_COMP))
+{
 }
 
 UtilShaders::~UtilShaders() = default;
@@ -116,13 +117,11 @@ void UtilShaders::ASTCDecode(Image& image, const StagingBufferMap& map,
 void UtilShaders::BlockLinearUpload2D(Image& image, const StagingBufferMap& map,
                                       std::span<const SwizzleParameters> swizzles) {
     static constexpr Extent3D WORKGROUP_SIZE{32, 32, 1};
-    static constexpr GLuint BINDING_SWIZZLE_BUFFER = 0;
-    static constexpr GLuint BINDING_INPUT_BUFFER = 1;
+    static constexpr GLuint BINDING_INPUT_BUFFER = 0;
     static constexpr GLuint BINDING_OUTPUT_IMAGE = 0;
 
     program_manager.BindComputeProgram(block_linear_unswizzle_2d_program.handle);
     glFlushMappedNamedBufferRange(map.buffer, map.offset, image.guest_size_bytes);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_SWIZZLE_BUFFER, swizzle_table_buffer.handle);
 
     const GLenum store_format = StoreFormat(BytesPerBlock(image.info.format));
     for (const SwizzleParameters& swizzle : swizzles) {
@@ -153,14 +152,11 @@ void UtilShaders::BlockLinearUpload2D(Image& image, const StagingBufferMap& map,
 void UtilShaders::BlockLinearUpload3D(Image& image, const StagingBufferMap& map,
                                       std::span<const SwizzleParameters> swizzles) {
     static constexpr Extent3D WORKGROUP_SIZE{16, 8, 8};
-
-    static constexpr GLuint BINDING_SWIZZLE_BUFFER = 0;
-    static constexpr GLuint BINDING_INPUT_BUFFER = 1;
+    static constexpr GLuint BINDING_INPUT_BUFFER = 0;
     static constexpr GLuint BINDING_OUTPUT_IMAGE = 0;
 
     glFlushMappedNamedBufferRange(map.buffer, map.offset, image.guest_size_bytes);
     program_manager.BindComputeProgram(block_linear_unswizzle_3d_program.handle);
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, BINDING_SWIZZLE_BUFFER, swizzle_table_buffer.handle);
 
     const GLenum store_format = StoreFormat(BytesPerBlock(image.info.format));
     for (const SwizzleParameters& swizzle : swizzles) {

src/video_core/renderer_opengl/util_shaders.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -45,9 +48,6 @@ public:
 
 private:
     ProgramManager& program_manager;
-
-    OGLBuffer swizzle_table_buffer;
-
     OGLProgram astc_decoder_program;
     OGLProgram block_linear_unswizzle_2d_program;
     OGLProgram block_linear_unswizzle_3d_program;

src/video_core/renderer_vulkan/pipeline_helper.h

@@ -203,7 +203,11 @@ inline void PushImageDescriptors(TextureCache& texture_cache,
             const VideoCommon::ImageViewId image_view_id{(views++)->id};
             const VideoCommon::SamplerId sampler_id{*(samplers++)};
             ImageView& image_view{texture_cache.GetImageView(image_view_id)};
-            const VkImageView vk_image_view{image_view.Handle(desc.type)};
+            VkImageView vk_image_view{image_view.Handle(desc.type)};
+            if (vk_image_view == VK_NULL_HANDLE) {
+                const VkImageView null_image_view{texture_cache.GetImageView(VideoCommon::NULL_IMAGE_VIEW_ID).Handle(desc.type)};
+                if (null_image_view != VK_NULL_HANDLE) vk_image_view = null_image_view;
+            }
             const Sampler& sampler{texture_cache.GetSampler(sampler_id)};
             const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
                                             !image_view.SupportsAnisotropy()};

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -653,71 +653,8 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
     scheduler.Finish();
 }
 
-constexpr u32 BL3D_BINDING_SWIZZLE_TABLE = 0;
-constexpr u32 BL3D_BINDING_INPUT_BUFFER  = 1;
-constexpr u32 BL3D_BINDING_OUTPUT_BUFFER = 2;
-
-constexpr std::array<VkDescriptorSetLayoutBinding, 3> BL3D_DESCRIPTOR_SET_BINDINGS{{
-    {
-        .binding = BL3D_BINDING_SWIZZLE_TABLE,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // swizzle_table[]
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-    {
-        .binding = BL3D_BINDING_INPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // block-linear input
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-    {
-        .binding = BL3D_BINDING_OUTPUT_BUFFER,
-        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-        .descriptorCount = 1,
-        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
-        .pImmutableSamplers = nullptr,
-    },
-}};
-
-constexpr DescriptorBankInfo BL3D_BANK_INFO{
-    .uniform_buffers = 0,
-    .storage_buffers = 3,
-    .texture_buffers = 0,
-    .image_buffers = 0,
-    .textures = 0,
-    .images = 0,
-    .score = 3,
-};
-
-constexpr std::array<VkDescriptorUpdateTemplateEntry, 3>
-    BL3D_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY{{
-        {
-            .dstBinding = BL3D_BINDING_SWIZZLE_TABLE,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = BL3D_BINDING_SWIZZLE_TABLE * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        },
-        {
-            .dstBinding = BL3D_BINDING_INPUT_BUFFER,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = BL3D_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        },
-        {
-            .dstBinding = BL3D_BINDING_OUTPUT_BUFFER,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-            .offset = BL3D_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
-            .stride = sizeof(DescriptorUpdateEntry),
-        }
-    }};
+constexpr u32 BL3D_BINDING_INPUT_BUFFER  = 0;
+constexpr u32 BL3D_BINDING_OUTPUT_BUFFER = 1;
 
 struct alignas(16) BlockLinearUnswizzle3DPushConstants {
     u32 blocks_dim[3];           // Offset 0
@@ -745,11 +682,50 @@ BlockLinearUnswizzle3DPass::BlockLinearUnswizzle3DPass(
     DescriptorPool& descriptor_pool_,
     StagingBufferPool& staging_buffer_pool_,
     ComputePassDescriptorQueue& compute_pass_descriptor_queue_)
-    : ComputePass(
-          device_, scheduler_, descriptor_pool_,
-          BL3D_DESCRIPTOR_SET_BINDINGS,
-          BL3D_DESCRIPTOR_UPDATE_TEMPLATE_ENTRY,
-          BL3D_BANK_INFO,
+    : ComputePass(device_, scheduler_, descriptor_pool_,
+        std::array<VkDescriptorSetLayoutBinding, 2>{{
+    {
+        .binding = BL3D_BINDING_INPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, // block-linear input
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+    {
+        .binding = BL3D_BINDING_OUTPUT_BUFFER,
+        .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+        .descriptorCount = 1,
+        .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+        .pImmutableSamplers = nullptr,
+    },
+        }},
+        std::array<VkDescriptorUpdateTemplateEntry, 2>{{
+        {
+            .dstBinding = BL3D_BINDING_INPUT_BUFFER,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .offset = BL3D_BINDING_INPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+            .stride = sizeof(DescriptorUpdateEntry),
+        },
+        {
+            .dstBinding = BL3D_BINDING_OUTPUT_BUFFER,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .offset = BL3D_BINDING_OUTPUT_BUFFER * sizeof(DescriptorUpdateEntry),
+            .stride = sizeof(DescriptorUpdateEntry),
+        }
+        }},
+        DescriptorBankInfo{
+            .uniform_buffers = 0,
+            .storage_buffers = 2,
+            .texture_buffers = 0,
+            .image_buffers = 0,
+            .textures = 0,
+            .images = 0,
+            .score = 2,
+        },
           COMPUTE_PUSH_CONSTANT_RANGE<sizeof(BlockLinearUnswizzle3DPushConstants)>,
           BLOCK_LINEAR_UNSWIZZLE_3D_BCN_COMP_SPV),
       scheduler{scheduler_},
@@ -822,8 +798,6 @@ void BlockLinearUnswizzle3DPass::UnswizzleChunk(
     pc.blocks_dim[2] = z_count; // Only process the count
 
     compute_pass_descriptor_queue.Acquire(scheduler, 3);
-    compute_pass_descriptor_queue.AddBuffer(*image.runtime->swizzle_table_buffer, 0,
-                                           image.runtime->swizzle_table_size);
     compute_pass_descriptor_queue.AddBuffer(swizzled.buffer,
                                            sw.buffer_offset + swizzled.offset,
                                            image.guest_size_bytes - sw.buffer_offset);

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -909,40 +909,6 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& sched
         bl3d_unswizzle_pass.emplace(device, scheduler, descriptor_pool,
                                    staging_buffer_pool, compute_pass_descriptor_queue);
     }
-
-    // --- Create swizzle table buffer ---
-    {
-        auto table = Tegra::Texture::MakeSwizzleTable();
-
-        swizzle_table_size = static_cast<VkDeviceSize>(table.size() * sizeof(table[0]));
-
-        auto staging = staging_buffer_pool.Request(swizzle_table_size, MemoryUsage::Upload);
-        std::memcpy(staging.mapped_span.data(), table.data(), static_cast<size_t>(swizzle_table_size));
-
-        VkBufferCreateInfo ci{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .size = swizzle_table_size,
-            .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
-                     VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                     VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        };
-        swizzle_table_buffer = memory_allocator.CreateBuffer(ci, MemoryUsage::DeviceLocal);
-
-        scheduler.RequestOutsideRenderPassOperationContext();
-        scheduler.Record([staging_buf = staging.buffer,
-                          dst_buf = *swizzle_table_buffer,
-                          size = swizzle_table_size,
-                          src_off = staging.offset](vk::CommandBuffer cmdbuf) {
-
-            const VkBufferCopy region{
-                .srcOffset = src_off,
-                .dstOffset = 0,
-                .size = size,
-            };
-            cmdbuf.CopyBuffer(staging_buf, dst_buf, region);
-        });
-    }
 }
 
 void TextureCacheRuntime::Finish() {
@@ -2484,18 +2450,13 @@ void TextureCacheRuntime::AccelerateImageUpload(
 
     if (!Settings::values.gpu_unswizzle_enabled.GetValue() || !bl3d_unswizzle_pass) {
         if (IsPixelFormatBCn(image.info.format) && image.info.type == ImageType::e3D) {
-            ASSERT_MSG(false, "GPU unswizzle is disabled for BCn 3D texture");
+            ASSERT(false && "GPU unswizzle is disabled for BCn 3D texture");
         }
         ASSERT(false);
         return;
     }
 
-    if (bl3d_unswizzle_pass &&
-        IsPixelFormatBCn(image.info.format) &&
-        image.info.type == ImageType::e3D &&
-        image.info.resources.levels == 1 &&
-        image.info.resources.layers == 1) {
-
+    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);
     }
 

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -130,9 +130,6 @@ public:
     std::optional<ASTCDecoderPass> astc_decoder_pass;
 
     std::optional<BlockLinearUnswizzle3DPass> bl3d_unswizzle_pass;
-    vk::Buffer swizzle_table_buffer;
-    VkDeviceSize swizzle_table_size = 0;
-
     std::optional<MSAACopyPass> msaa_copy_pass;
     const Settings::ResolutionScalingInfo& resolution;
     std::array<std::vector<VkFormat>, VideoCore::Surface::MaxPixelFormat> view_formats;

src/video_core/shader_environment.cpp

@@ -255,8 +255,7 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
     static constexpr u64 SELF_BRANCH_A = 0xE2400FFFFF87000FULL;
     static constexpr u64 SELF_BRANCH_B = 0xE2400FFFFF07000FULL;
 
-    static constexpr u64 MESA_EXIT_MASK = 0xFFF00000000F001FULL;
-    static constexpr u64 MESA_EXIT_VALUE = (0xE30ULL << 52) | (0x7ULL << 16) | 0xFULL;
+    static constexpr u64 EXIT_VALUE = 0xE30000000007000FULL;
 
     code.resize(MAXIMUM_SIZE / INST_SIZE);
 
@@ -271,7 +270,7 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
             if (inst == SELF_BRANCH_A || inst == SELF_BRANCH_B) {
                 return offset + index;
             }
-            if ((inst & MESA_EXIT_MASK) == MESA_EXIT_VALUE) {
+            if (!is_proprietary_driver && inst == EXIT_VALUE) {
                 return offset + index + INST_SIZE;
             }
         }

src/video_core/textures/decoders.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -23,24 +26,6 @@ constexpr u32 GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_
 constexpr u32 SWIZZLE_X_BITS = 0b100101111;
 constexpr u32 SWIZZLE_Y_BITS = 0b011010000;
 
-using SwizzleTable = std::array<std::array<u32, GOB_SIZE_X>, GOB_SIZE_Y>;
-
-/**
- * This table represents the internal swizzle of a gob, in format 16 bytes x 2 sector packing.
- * Calculates the offset of an (x, y) position within a swizzled texture.
- * Taken from the Tegra X1 Technical Reference Manual. pages 1187-1188
- */
-constexpr SwizzleTable MakeSwizzleTable() {
-    SwizzleTable table{};
-    for (u32 y = 0; y < table.size(); ++y) {
-        for (u32 x = 0; x < table[0].size(); ++x) {
-            table[y][x] = ((x % 64) / 32) * 256 + ((y % 8) / 2) * 64 + ((x % 32) / 16) * 32 +
-                          (y % 2) * 16 + (x % 16);
-        }
-    }
-    return table;
-}
-
 /// Unswizzles a block linear texture into linear memory.
 void UnswizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel,
                       u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth,