Fix build

[vulkan] Removal of QCOM sampler limiters + CustomBorderColor and ColorBorderSwizzle adjustments
[vulkan, qcom] Fix shader float controls on QCOM driver (#4297 )
2026-08-25 16:54:41 +00:00 · 2026-08-24 18:37:26 -04:00 · 2026-08-24 18:01:19 -04:00 · 2026-08-24 17:57:12 +02:00
26 changed files with 467 additions and 356 deletions
@@ -340,10 +340,10 @@
        "version": "vulkan-sdk-%NUMERIC_VERSION%"
    },
    "xbyak": {
-        "hash": "e0aa0a603dd3ac1a39d82213df1e73c042831aec2d6b2fe382c899651eaae4ed7e8aeb6be9c41ea0097087c9d091961ab18f313cd6a9e10d621715ffd49bfe36",
+        "hash": "b6475276b2faaeb315734ea8f4f8bd87ededcee768961b39679bee547e7f3e98884d8b7851e176d861dab30a80a76e6ea302f8c111483607dde969b4797ea95a",
        "package": "xbyak",
        "repo": "herumi/xbyak",
-        "version": "v7.40.1"
+        "version": "v7.35.2"
    },
    "zlib": {
        "hash": "16fea4df307a68cf0035858abe2fd550250618a97590e202037acd18a666f57afc10f8836cbbd472d54a0e76539d0e558cb26f059d53de52ff90634bbf4f47d4",
@@ -247,7 +247,7 @@ void A32EmitX64::GenTerminalHandlers() {
    calculate_location_descriptor();
    code.mov(eax, dword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_ptr)]);
    code.sub(eax, 1);
-    code.and_(eax, u32(A32JitState::RSB_PTR_MASK));
+    code.and_(eax, u32(A32JitState::RSBPtrMask));
    code.mov(dword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_ptr)], eax);
    code.cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_location_descriptors) + rax * sizeof(u64)]);
    if (conf.HasOptimization(OptimizationFlag::FastDispatch)) {
@@ -37,9 +37,9 @@ using namespace Backend::X64;

 static RunCodeCallbacks GenRunCodeCallbacks(A32::UserCallbacks* cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg, const A32::UserConfig& conf) {
    return RunCodeCallbacks{
-        ArgCallback(LookupBlock, reinterpret_cast<u64>(arg)),
-        ArgCallback(Devirtualize<&A32::UserCallbacks::AddTicks>(cb)),
-        ArgCallback(Devirtualize<&A32::UserCallbacks::GetTicksRemaining>(cb)),
+        std::make_unique<ArgCallback>(LookupBlock, reinterpret_cast<u64>(arg)),
+        std::make_unique<ArgCallback>(Devirtualize<&A32::UserCallbacks::AddTicks>(cb)),
+        std::make_unique<ArgCallback>(Devirtualize<&A32::UserCallbacks::GetTicksRemaining>(cb)),
        conf.enable_cycle_counting,
    };
 }
@@ -79,7 +79,7 @@ struct Jit::Impl {
        jit_interface->is_executing = true;
        const CodePtr current_codeptr = [this] {
            // RSB optimization
-            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A32JitState::RSB_PTR_MASK;
+            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A32JitState::RSBPtrMask;
            if (jit_state.GetUniqueHash() == jit_state.rsb_location_descriptors[new_rsb_ptr]) {
                jit_state.rsb_ptr = new_rsb_ptr;
                return reinterpret_cast<CodePtr>(jit_state.rsb_codeptrs[new_rsb_ptr]);
@@ -27,9 +27,6 @@ struct A32JitState {

    A32JitState() { ResetRSB(); }

-    static constexpr std::size_t RSB_SIZE = 8;  // MUST be a power of 2.
-    static constexpr std::size_t RSB_PTR_MASK = RSB_SIZE - 1;
-
    std::array<u32, 16> Reg{};  // Current register file.
    // TODO: Mode-specific register sets unimplemented.

@@ -39,9 +36,8 @@ struct A32JitState {
    u32 cpsr_q = 0;
    u32 cpsr_nzcv = 0;
    u32 cpsr_jaifm = 0;
-    u32 fpsr_exc = 0;
-    u32 fpsr_qc = 0;
-    u32 fpsr_nzcv = 0;
+    u32 Cpsr() const;
+    void SetCpsr(u32 cpsr);

    alignas(16) std::array<u32, 64> ExtReg{};  // Extension registers.

@@ -53,19 +49,21 @@ struct A32JitState {
    // Exclusive state
    u32 exclusive_state = 0;

+    static constexpr std::size_t RSBSize = 8;  // MUST be a power of 2.
+    static constexpr std::size_t RSBPtrMask = RSBSize - 1;
    u32 rsb_ptr = 0;
-    std::array<u64, RSB_SIZE> rsb_location_descriptors;
-    std::array<u64, RSB_SIZE> rsb_codeptrs;
-
-    u32 Cpsr() const;
-    void SetCpsr(u32 cpsr);
-
+    std::array<u64, RSBSize> rsb_location_descriptors;
+    std::array<u64, RSBSize> rsb_codeptrs;
    void ResetRSB();
+
+    u32 fpsr_exc = 0;
+    u32 fpsr_qc = 0;
+    u32 fpsr_nzcv = 0;
    u32 Fpscr() const;
    void SetFpscr(u32 FPSCR);

    u64 GetUniqueHash() const noexcept {
-        return (u64(upper_location_descriptor) << 32) | (u64(Reg[15]));
+        return (static_cast<u64>(upper_location_descriptor) << 32) | (static_cast<u64>(Reg[15]));
    }

    void TransferJitState(const A32JitState& src, bool reset_rsb) {
@@ -208,7 +208,7 @@ void A64EmitX64::GenTerminalHandlers() {
    calculate_location_descriptor();
    code.mov(eax, dword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_ptr)]);
    code.sub(eax, 1);
-    code.and_(eax, u32(A64JitState::RSB_PTR_MASK));
+    code.and_(eax, u32(A64JitState::RSBPtrMask));
    code.mov(dword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_ptr)], eax);
    code.cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_location_descriptors) + rax * sizeof(u64)]);
    if (conf.HasOptimization(OptimizationFlag::FastDispatch)) {
@@ -33,9 +33,9 @@ using namespace Backend::X64;

 static RunCodeCallbacks GenRunCodeCallbacks(A64::UserCallbacks* cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg, const A64::UserConfig& conf) {
    return RunCodeCallbacks{
-        ArgCallback(LookupBlock, reinterpret_cast<u64>(arg)),
-        ArgCallback(Devirtualize<&A64::UserCallbacks::AddTicks>(cb)),
-        ArgCallback(Devirtualize<&A64::UserCallbacks::GetTicksRemaining>(cb)),
+        std::make_unique<ArgCallback>(LookupBlock, reinterpret_cast<u64>(arg)),
+        std::make_unique<ArgCallback>(Devirtualize<&A64::UserCallbacks::AddTicks>(cb)),
+        std::make_unique<ArgCallback>(Devirtualize<&A64::UserCallbacks::GetTicksRemaining>(cb)),
        conf.enable_cycle_counting,
    };
 }
@@ -78,7 +78,7 @@ public:
        // TODO: Check code alignment
        const CodePtr current_code_ptr = [this] {
            // RSB optimization
-            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A64JitState::RSB_PTR_MASK;
+            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A64JitState::RSBPtrMask;
            if (jit_state.GetUniqueHash() == jit_state.rsb_location_descriptors[new_rsb_ptr]) {
                jit_state.rsb_ptr = new_rsb_ptr;
                return CodePtr(jit_state.rsb_codeptrs[new_rsb_ptr]);
@@ -29,19 +29,18 @@ struct A64JitState {

    A64JitState() { ResetRSB(); }

-    // Exclusive state stuff
-    static constexpr u64 RESERVATION_GRANULE_MASK = 0xFFFF'FFFF'FFFF'FFF0ull;
-    // Return stack buffer
-    static constexpr size_t RSB_SIZE = 8;  // MUST be a power of 2.
-    static constexpr size_t RSB_PTR_MASK = RSB_SIZE - 1;
-
    std::array<u64, 31> reg{};
    u64 sp = 0;
    u64 pc = 0;
+
    u32 cpsr_nzcv = 0;
-    u32 fpsr_exc = 0;
-    u32 fpsr_qc = 0;
-    u32 fpcr = 0;
+
+    u32 GetPstate() const {
+        return NZCV::FromX64(cpsr_nzcv);
+    }
+    void SetPstate(u32 new_pstate) {
+        cpsr_nzcv = NZCV::ToX64(new_pstate);
+    }

    alignas(16) std::array<u64, 64> vec{};  // Extension registers.

@@ -51,31 +50,29 @@ struct A64JitState {
    volatile u32 halt_reason = 0;

    // Exclusive state
+    static constexpr u64 RESERVATION_GRANULE_MASK = 0xFFFF'FFFF'FFFF'FFF0ull;
    u8 exclusive_state = 0;
+
+    static constexpr size_t RSBSize = 8;  // MUST be a power of 2.
+    static constexpr size_t RSBPtrMask = RSBSize - 1;
    u32 rsb_ptr = 0;
-    std::array<u64, RSB_SIZE> rsb_location_descriptors;
-    std::array<u64, RSB_SIZE> rsb_codeptrs;
-
-    u32 GetPstate() const {
-        return NZCV::FromX64(cpsr_nzcv);
-    }
-
-    void SetPstate(u32 new_pstate) {
-        cpsr_nzcv = NZCV::ToX64(new_pstate);
-    }
-
+    std::array<u64, RSBSize> rsb_location_descriptors;
+    std::array<u64, RSBSize> rsb_codeptrs;
    void ResetRSB() {
        rsb_location_descriptors.fill(0xFFFFFFFFFFFFFFFFull);
        rsb_codeptrs.fill(0);
    }

+    u32 fpsr_exc = 0;
+    u32 fpsr_qc = 0;
+    u32 fpcr = 0;
    u32 GetFpcr() const;
    u32 GetFpsr() const;
    void SetFpcr(u32 value);
    void SetFpsr(u32 value);

    u64 GetUniqueHash() const noexcept {
-        const u64 fpcr_u64 = u64(fpcr & A64::LocationDescriptor::fpcr_mask) << A64::LocationDescriptor::fpcr_shift;
+        const u64 fpcr_u64 = static_cast<u64>(fpcr & A64::LocationDescriptor::fpcr_mask) << A64::LocationDescriptor::fpcr_shift;
        const u64 pc_u64 = pc & A64::LocationDescriptor::pc_mask;
        return pc_u64 | fpcr_u64;
    }
@@ -145,9 +145,11 @@ void ProtectMemory(const void* base, size_t size, bool is_executable) {

 HostFeature GetHostFeatures() {
    HostFeature features = {};
+
 #ifdef DYNARMIC_ENABLE_CPU_FEATURE_DETECTION
    using Cpu = Xbyak::util::Cpu;
-    Xbyak::util::Cpu cpu_info{};
+    Xbyak::util::Cpu cpu_info;
+
    if (cpu_info.has(Cpu::tSSSE3))
        features |= HostFeature::SSSE3;
    if (cpu_info.has(Cpu::tSSE41))
@@ -194,6 +196,7 @@ HostFeature GetHostFeatures() {
        features |= HostFeature::GFNI;
    if (cpu_info.has(Cpu::tWAITPKG))
        features |= HostFeature::WAITPKG;
+
    if (cpu_info.has(Cpu::tBMI2)) {
        // BMI2 instructions such as pdep and pext have been very slow up until Zen 3.
        // Check for Zen 3 or newer by its family (0x19).
@@ -211,6 +214,7 @@ HostFeature GetHostFeatures() {
        }
    }
 #endif
+
    return features;
 }

@@ -229,27 +233,23 @@ bool IsUnderRosetta() {

 }  // anonymous namespace

-BlockOfCode::BlockOfCode(RunCodeCallbacks cb, JitStateInfo jsi, size_t total_code_size, std::function<void(BlockOfCode&)> rcp)
-    : Xbyak::CodeGenerator(total_code_size
 #ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
-        , Xbyak::DontSetProtectRWE
+static const auto default_cg_mode = Xbyak::DontSetProtectRWE;
 #else
-        , nullptr //Allow RWE
+static const auto default_cg_mode = nullptr; //Allow RWE
 #endif
-        , &s_allocator)
-    , constant_pool(*this, CONSTANT_POOL_SIZE)
-    , jsi(jsi)
-    , cb(std::move(cb))
-{
+
+BlockOfCode::BlockOfCode(RunCodeCallbacks cb, JitStateInfo jsi, size_t total_code_size, std::function<void(BlockOfCode&)> rcp)
+        : Xbyak::CodeGenerator(total_code_size, default_cg_mode, &s_allocator)
+        , cb(std::move(cb))
+        , jsi(jsi)
+        , constant_pool(*this, CONSTANT_POOL_SIZE)
+        , host_features(GetHostFeatures()) {
    EnableWriting();
    EnsureMemoryCommitted(PRELUDE_COMMIT_SIZE);
    GenRunCode(rcp);
 }

-bool BlockOfCode::HasHostFeature(HostFeature feature) const noexcept {
-    return (GetHostFeatures() & feature) == feature;
-}
-
 void BlockOfCode::PreludeComplete() {
    prelude_complete = true;
    code_begin = getCurr();
@@ -341,7 +341,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
    mov(rbx, ABI_PARAM2); // save temporarily in non-volatile register

    if (cb.enable_cycle_counting) {
-        cb.GetTicksRemaining.EmitCall(*this);
+        cb.GetTicksRemaining->EmitCall(*this);
        mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)], ABI_RETURN);
        mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], ABI_RETURN);
    }
@@ -388,7 +388,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
        cmp(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], 0);
        jng(return_to_caller);
    }
-    cb.LookupBlock.EmitCall(*this);
+    cb.LookupBlock->EmitCall(*this);
    jmp(ABI_RETURN);

    align();
@@ -401,7 +401,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
        jng(return_to_caller_mxcsr_already_exited);
    }
    SwitchMxcsrOnEntry();
-    cb.LookupBlock.EmitCall(*this);
+    cb.LookupBlock->EmitCall(*this);
    jmp(ABI_RETURN);

    align();
@@ -415,7 +415,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
    L(return_to_caller_mxcsr_already_exited);

    if (cb.enable_cycle_counting) {
-        cb.AddTicks.EmitCall(*this, [this](RegList param) {
+        cb.AddTicks->EmitCall(*this, [this](RegList param) {
            mov(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)]);
            sub(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)]);
        });
@@ -455,18 +455,18 @@ void BlockOfCode::UpdateTicks() {
        return;
    }

-    cb.AddTicks.EmitCall(*this, [this](RegList param) {
+    cb.AddTicks->EmitCall(*this, [this](RegList param) {
        mov(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)]);
        sub(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)]);
    });

-    cb.GetTicksRemaining.EmitCall(*this);
+    cb.GetTicksRemaining->EmitCall(*this);
    mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)], ABI_RETURN);
    mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], ABI_RETURN);
 }

 void BlockOfCode::LookupBlock() {
-    cb.LookupBlock.EmitCall(*this);
+    cb.LookupBlock->EmitCall(*this);
 }

 void BlockOfCode::LoadRequiredFlagsForCondFromRax(IR::Cond cond) {
@@ -520,7 +520,7 @@ void BlockOfCode::LoadRequiredFlagsForCondFromRax(IR::Cond cond) {
 }

 Xbyak::Address BlockOfCode::Const(const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
-    return constant_pool.GetConstant(*this, frame, lower, upper);
+    return constant_pool.GetConstant(frame, lower, upper);
 }

 CodePtr BlockOfCode::GetCodeBegin() const {
@@ -31,9 +31,9 @@ namespace Dynarmic::Backend::X64 {
 using CodePtr = const void*;

 struct RunCodeCallbacks {
-    ArgCallback LookupBlock;
-    ArgCallback AddTicks;
-    ArgCallback GetTicksRemaining;
+    std::unique_ptr<Callback> LookupBlock;
+    std::unique_ptr<Callback> AddTicks;
+    std::unique_ptr<Callback> GetTicksRemaining;
    bool enable_cycle_counting;
 };

@@ -166,24 +166,27 @@ public:

    JitStateInfo GetJitStateInfo() const { return jsi; }

-    bool HasHostFeature(HostFeature feature) const noexcept;
+    bool HasHostFeature(HostFeature feature) const {
+        return (host_features & feature) == feature;
+    }

 private:
    using RunCodeFuncType = HaltReason (*)(void*, CodePtr);
    static constexpr size_t MXCSR_ALREADY_EXITED = 1 << 0;
    static constexpr size_t FORCE_RETURN = 1 << 1;

-    ConstantPool constant_pool;
-    JitStateInfo jsi;
-    std::array<const void*, 4> return_from_run_code;
    RunCodeCallbacks cb;
+    JitStateInfo jsi;
    CodePtr code_begin = nullptr;
-    RunCodeFuncType run_code = nullptr;
-    RunCodeFuncType step_code = nullptr;
 #ifdef _WIN32
    size_t committed_size = 0;
 #endif
+    ConstantPool constant_pool;
+    RunCodeFuncType run_code = nullptr;
+    RunCodeFuncType step_code = nullptr;
+    std::array<const void*, 4> return_from_run_code;
    bool prelude_complete = false;
+    const HostFeature host_features;

    void GenRunCode(std::function<void(BlockOfCode&)> rcp);
 };
@@ -16,7 +16,8 @@
 namespace Dynarmic::Backend::X64 {

 ConstantPool::ConstantPool(BlockOfCode& code, size_t size)
-    : insertion_point(0)
+    : code(code)
+    , insertion_point(0)
 {
    code.EnsureMemoryCommitted(align_size + size);
    code.int3();
@@ -24,17 +25,17 @@ ConstantPool::ConstantPool(BlockOfCode& code, size_t size)
    pool = std::span<ConstantT>(reinterpret_cast<ConstantT*>(code.AllocateFromCodeSpace(size)), size / align_size);
 }

-Xbyak::Address ConstantPool::GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
+Xbyak::Address ConstantPool::GetConstant(const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
    const auto constant = ConstantT(lower, upper);
-    auto it = constant_info.find(constant);
-    if (it == constant_info.end()) {
+    auto iter = constant_info.find(constant);
+    if (iter == constant_info.end()) {
        ASSERT(insertion_point < pool.size());
        ConstantT& target_constant = pool[insertion_point];
        target_constant = constant;
-        it = constant_info.insert({constant, &target_constant}).first;
+        iter = constant_info.insert({constant, &target_constant}).first;
        ++insertion_point;
    }
-    return frame[code.rip + it->second];
+    return frame[code.rip + iter->second];
 }

 }  // namespace Dynarmic::Backend::X64
@@ -29,7 +29,7 @@ class ConstantPool final {
 public:
    ConstantPool(BlockOfCode& code, size_t size);

-    Xbyak::Address GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper = 0);
+    Xbyak::Address GetConstant(const Xbyak::AddressFrame& frame, u64 lower, u64 upper = 0);

 private:
    static constexpr size_t align_size = 16;  // bytes
@@ -45,6 +45,7 @@ private:

    ankerl::unordered_dense::map<ConstantT, void*, ConstantHash> constant_info;
    std::span<ConstantT> pool;
+    BlockOfCode& code;
    std::size_t insertion_point;
 };

@@ -12,7 +12,7 @@

 namespace Dynarmic::Backend::X64 {

-enum class HostFeature : u32 {
+enum class HostFeature : u64 {
    SSSE3 = 1ULL << 0,
    SSE41 = 1ULL << 1,
    SSE42 = 1ULL << 2,
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 /* This file is part of the dynarmic project.
 * Copyright (c) 2016 MerryMage
 * SPDX-License-Identifier: 0BSD
@@ -18,7 +15,7 @@ struct JitStateInfo {
            : offsetof_guest_MXCSR(offsetof(JitStateType, guest_MXCSR))
            , offsetof_asimd_MXCSR(offsetof(JitStateType, asimd_MXCSR))
            , offsetof_rsb_ptr(offsetof(JitStateType, rsb_ptr))
-            , rsb_ptr_mask(JitStateType::RSB_PTR_MASK)
+            , rsb_ptr_mask(JitStateType::RSBPtrMask)
            , offsetof_rsb_location_descriptors(offsetof(JitStateType, rsb_location_descriptors))
            , offsetof_rsb_codeptrs(offsetof(JitStateType, rsb_codeptrs))
            , offsetof_cpsr_nzcv(offsetof(JitStateType, cpsr_nzcv))
@@ -335,7 +335,7 @@ void SetupDenormControl(const Profile& profile, const IR::Program& program, Emit
    if (info.uses_fp32_denorms_flush && info.uses_fp32_denorms_preserve) {
        LOG_DEBUG(Shader_SPIRV, "Fp32 denorm flush and preserve on the same shader");
    } else if (info.uses_fp32_denorms_flush) {
-        if (profile.support_fp32_denorm_flush) {
+        if (profile.support_fp32_denorm_flush && !profile.has_broken_fp32_denorm_flush) {
            ctx.AddCapability(spv::Capability::DenormFlushToZero);
            ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormFlushToZero, 32U);
        } else {
@@ -86,6 +86,8 @@ struct Profile {
    bool has_broken_signed_operations{};
    /// Float controls break when fp16 is enabled
    bool has_broken_fp16_float_controls{};
+    /// Declaring fp32 denorm flush to zero miscompiles on some drivers
+    bool has_broken_fp32_denorm_flush{};
    /// Dynamic vec4 indexing is broken on some OpenGL drivers
    bool has_gl_component_indexing_bug{};
    /// The precise type qualifier is broken in the fragment stage of some drivers
@@ -231,6 +231,7 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
          .has_broken_unsigned_image_offsets = true,
          .has_broken_signed_operations = true,
          .has_broken_fp16_float_controls = false,
+          .has_broken_fp32_denorm_flush = false,
          .has_gl_component_indexing_bug = device.HasComponentIndexingBug(),
          .has_gl_precise_bug = device.HasPreciseBug(),
          .has_gl_cbuf_ftou_bug = device.HasCbufFtouBug(),
@@ -370,20 +370,9 @@ inline void PushImageDescriptors(TextureCache& texture_cache,
                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()};
-            VkSampler vk_sampler{use_fallback_sampler ? sampler.HandleWithDefaultAnisotropy()
-                                                      : sampler.Handle()};
-            if (sampler.HasLinearFiltering() &&
-                VideoCore::Surface::IsPixelFormatInteger(image_view.format)) {
-                vk_sampler = sampler.HandleWithNearestFilter();
-            }
-            if (desc.is_depth && sampler.HasDepthComparison() &&
-                !image_view.SupportsDepthComparison()) {
-                vk_sampler = sampler.HandleWithoutDepthComparison();
-            }
-            guest_descriptor_queue.AddSampledImage(vk_image_view, vk_sampler);
+            Sampler& sampler{texture_cache.GetSampler(sampler_id)};
+            guest_descriptor_queue.AddSampledImage(vk_image_view,
+                                                   sampler.HandleFor(image_view, desc.is_depth));
            const bool element_rescaled{texture_cache.IsRescaling(image_view)};
            is_rescaled |= element_rescaled;
        }
@@ -444,6 +444,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .has_broken_unsigned_image_offsets = false,
        .has_broken_signed_operations = false,
        .has_broken_fp16_float_controls = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY,
+        .has_broken_fp32_denorm_flush = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
        .ignore_nan_fp_comparisons = false,
        .has_broken_spirv_subgroup_mask_vector_extract_dynamic = false,
        .has_broken_robust =
@@ -51,6 +51,7 @@ using VideoCore::Surface::BytesPerBlock;
 using VideoCore::Surface::HasAlpha;
 using VideoCore::Surface::IsPixelFormatASTC;
 using VideoCore::Surface::IsPixelFormatInteger;
+using VideoCore::Surface::IsPixelFormatSRGB;
 using VideoCore::Surface::SurfaceType;

 namespace {
@@ -59,6 +60,17 @@ constexpr bool ENABLE_MSAA_RESOLVE_CONSUME = true;
 constexpr bool ENABLE_MSAA_COLOR_DISCARD = true;
 constexpr bool ENABLE_MSAA_DEPTH_STENCIL_DISCARD = true;

+[[nodiscard]] constexpr bool NeedsExplicitBorderColorFormat(VkFormat format) {
+    switch (format) {
+    case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
+    case VK_FORMAT_B5G6R5_UNORM_PACK16:
+    case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
+        return true;
+    default:
+        return false;
+    }
+}
+
 constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    if (color == std::array<float, 4>{0, 0, 0, 0}) {
        return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
@@ -1802,10 +1814,6 @@ bool TextureCacheRuntime::CanReportMemoryUsage() const {
    return device.CanReportMemoryUsage();
 }

-std::optional<size_t> TextureCacheRuntime::GetSamplerHeapBudget() const {
-    return device.GetSamplerHeapBudget();
-}
-
 void TextureCacheRuntime::FlushDeferredClear() {
    scheduler.FlushDeferredClear();
 }
@@ -2517,9 +2525,23 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
        supports_depth_comparison =
            (properties3.optimalTilingFeatures &
             VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT) != 0;
+        supports_minmax_filter = (properties3.optimalTilingFeatures &
+                                  VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT) != 0;
    } else {
        supports_depth_comparison = true;
+        supports_minmax_filter =
+            (device->GetPhysical().GetFormatProperties(format_info.format).optimalTilingFeatures &
+             VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT) != 0;
    }
+    requires_border_color_format = NeedsExplicitBorderColorFormat(format_info.format);
+    swizzle_mapping = VkComponentMapping{
+        .r = ComponentSwizzle(swizzle[0]),
+        .g = ComponentSwizzle(swizzle[1]),
+        .b = ComponentSwizzle(swizzle[2]),
+        .a = ComponentSwizzle(swizzle[3]),
+    };
+    has_identity_swizzle = swizzle[0] == SwizzleSource::R && swizzle[1] == SwizzleSource::G &&
+                           swizzle[2] == SwizzleSource::B && swizzle[3] == SwizzleSource::A;
    const VkImageUsageFlags requested_view_usage = ImageUsageFlags(format_info, format);
    const VkImageUsageFlags image_usage = image.UsageFlags();
    const VkImageUsageFlags clamped_view_usage = requested_view_usage & image_usage;
@@ -2544,12 +2566,7 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
        .image = image.Handle(),
        .viewType = VkImageViewType{},
        .format = format_info.format,
-        .components{
-            .r = ComponentSwizzle(swizzle[0]),
-            .g = ComponentSwizzle(swizzle[1]),
-            .b = ComponentSwizzle(swizzle[2]),
-            .a = ComponentSwizzle(swizzle[3]),
-        },
+        .components = swizzle_mapping,
        .subresourceRange = MakeSubresourceRange(aspect_mask, info.range),
    };
    const auto create = [&](TextureType tex_type, std::optional<u32> num_layers) {
@@ -2718,92 +2735,223 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
    });
 }

+CustomBorderColorBudget::~CustomBorderColorBudget() {
+    Release();
+}
+
+CustomBorderColorBudget::CustomBorderColorBudget(CustomBorderColorBudget&& rhs) noexcept
+    : device_ptr{std::exchange(rhs.device_ptr, nullptr)}, held{std::exchange(rhs.held, 0)} {}
+
+CustomBorderColorBudget& CustomBorderColorBudget::operator=(
+    CustomBorderColorBudget&& rhs) noexcept {
+    if (this != &rhs) {
+        Release();
+        device_ptr = std::exchange(rhs.device_ptr, nullptr);
+        held = std::exchange(rhs.held, 0);
+    }
+    return *this;
+}
+
+bool CustomBorderColorBudget::TryAcquire(const Device& device, size_t count) {
+    if (!device.TryReserveCustomBorderColorSamplers(count)) {
+        return false;
+    }
+    device_ptr = &device;
+    held += count;
+    return true;
+}
+
+void CustomBorderColorBudget::Release() noexcept {
+    if (device_ptr != nullptr) {
+        device_ptr->ReleaseCustomBorderColorSamplers(held);
+    }
+    device_ptr = nullptr;
+    held = 0;
+}
+
 Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {
    const auto& device = runtime.device;
-    const bool has_custom_border_extension = runtime.device.IsExtCustomBorderColorSupported();
-    const bool has_format_undefined =
-        has_custom_border_extension && runtime.device.IsCustomBorderColorWithoutFormatSupported();
-    const bool has_custom_border_colors =
-        has_format_undefined && runtime.device.IsCustomBorderColorsSupported();
-    const auto color = tsc.BorderColor();
+    device_ptr = &device;
+    border_color = tsc.BorderColor();
+    srgb_border_color = tsc.SrgbBorderColor();

+    const f32 max_anisotropy = std::clamp(tsc.MaxAnisotropy(), 1.0f, 16.0f);
+    default_anisotropy = static_cast<f32>(1U << tsc.max_anisotropy);
+
+    const VkFilter mag_filter{MaxwellToVK::Sampler::Filter(tsc.mag_filter)};
+    const VkFilter min_filter{MaxwellToVK::Sampler::Filter(tsc.min_filter)};
+    const VkSamplerMipmapMode mipmap_mode{MaxwellToVK::Sampler::MipmapMode(tsc.mipmap_filter)};
+
+    const VkSamplerAddressMode wrap_u{
+        MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_u, tsc.mag_filter)};
+    const VkSamplerAddressMode wrap_v{
+        MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_v, tsc.mag_filter)};
+    const VkSamplerAddressMode wrap_p{
+        MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_p, tsc.mag_filter)};
+    const bool samples_border = wrap_u == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER ||
+                                wrap_v == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER ||
+                                wrap_p == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
+
+    reduction_mode = MaxwellToVK::SamplerReduction(tsc.reduction_filter);
+
+    has_added_anisotropy = max_anisotropy > default_anisotropy;
+    has_linear_filtering = mag_filter == VK_FILTER_LINEAR || min_filter == VK_FILTER_LINEAR ||
+                           mipmap_mode == VK_SAMPLER_MIPMAP_MODE_LINEAR;
+    has_depth_comparison = tsc.depth_compare_enabled != 0;
+    has_minmax_reduction = reduction_mode != VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT;
+    has_srgb_border_color = tsc.srgb_conversion != 0 && srgb_border_color != border_color;
+    if (has_minmax_reduction && !device.IsExtSamplerFilterMinmaxSupported()) {
+        LOG_WARNING(Render_Vulkan, "VK_EXT_sampler_filter_minmax is required");
+        has_minmax_reduction = false;
+    }
+    has_custom_border_colors = samples_border && device.IsCustomBorderColorUsable();
+    needs_swizzle_mapping = has_custom_border_colors && device.NeedsBorderColorSwizzleMapping();
+
+    if (has_custom_border_colors && GPU::Logging::IsActive()) {
+        GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
+            "VK_EXT_custom_border_color", "Sampler::Sampler");
+    }
+    if (device.IsExtBorderColorSwizzleSupported() && GPU::Logging::IsActive()) {
+        GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
+            "VK_EXT_border_color_swizzle", "Sampler::Sampler");
+    }
+
+    f32 min_lod = 0.0f;
+    f32 max_lod = 0.25f;
+    if (tsc.mipmap_filter != TextureMipmapFilter::None) {
+        min_lod = tsc.MinLod();
+        max_lod = tsc.MaxLod();
+    }
+    base_ci = VkSamplerCreateInfo{
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .magFilter = mag_filter,
+        .minFilter = min_filter,
+        .mipmapMode = mipmap_mode,
+        .addressModeU = wrap_u,
+        .addressModeV = wrap_v,
+        .addressModeW = wrap_p,
+        .mipLodBias = tsc.LodBias(),
+        .anisotropyEnable = static_cast<VkBool32>(max_anisotropy > 1.0f),
+        .maxAnisotropy = max_anisotropy,
+        .compareEnable = static_cast<VkBool32>(tsc.depth_compare_enabled),
+        .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
+        .minLod = min_lod,
+        .maxLod = max_lod,
+        .borderColor = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT,
+        .unnormalizedCoordinates = VK_FALSE,
+    };
+    variants.reserve(1);
+    Emplace(VariantKey{});
+}
+
+Sampler::VariantKey Sampler::MakeKey(const ImageView& image_view, bool is_depth) const noexcept {
+    VariantKey key{};
+    key.reduce_anisotropy = has_added_anisotropy && !image_view.SupportsAnisotropy();
+    key.force_nearest = has_linear_filtering && IsPixelFormatInteger(image_view.format);
+    key.drop_depth_comparison =
+        is_depth && has_depth_comparison && !image_view.SupportsDepthComparison();
+    key.drop_reduction = has_minmax_reduction && !image_view.SupportsMinmaxFilter();
+    key.drop_custom_border = has_custom_border_colors && image_view.RequiresBorderColorFormat();
+    key.srgb_border = has_srgb_border_color && IsPixelFormatSRGB(image_view.format);
+    if (needs_swizzle_mapping && !key.drop_custom_border && !image_view.HasIdentitySwizzle()) {
+        const VkComponentMapping& mapping = image_view.Swizzle();
+        key.swizzle = {mapping.r, mapping.g, mapping.b, mapping.a};
+    }
+    return key;
+}
+
+VkSampler Sampler::Find(const VariantKey& key) const noexcept {
+    const auto it = std::ranges::find(variants, key, &Variant::key);
+    if (it == variants.end()) {
+        return VK_NULL_HANDLE;
+    }
+    return *it->sampler;
+}
+
+VkSampler Sampler::Emplace(VariantKey key) {
+    bool custom_border = has_custom_border_colors && !key.drop_custom_border;
+    if (custom_border && !custom_border_color_budget.TryAcquire(*device_ptr, 1)) {
+        static bool warned_budget = false;
+        if (!warned_budget) {
+            warned_budget = true;
+        }
+        custom_border = false;
+        key.drop_custom_border = true;
+        key.swizzle = {};
+        if (const VkSampler existing = Find(key); existing != VK_NULL_HANDLE) {
+            return existing;
+        }
+    }
+
+    std::array<float, 4> color = border_color;
+    if (key.srgb_border) {
+        color = srgb_border_color;
+    }
    const VkSamplerCustomBorderColorCreateInfoEXT border_ci{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
        .pNext = nullptr,
        .customBorderColor = std::bit_cast<VkClearColorValue>(color),
        .format = VK_FORMAT_UNDEFINED,
    };
-    const void* pnext = nullptr;
-    if (has_custom_border_colors) {
-        pnext = &border_ci;
-        if (GPU::Logging::IsActive()) {
-            GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
-                "VK_EXT_custom_border_color", "Sampler::Sampler");
+    const VkSamplerBorderColorComponentMappingCreateInfoEXT mapping_ci{
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
+        .pNext = &border_ci,
+        .components{key.swizzle[0], key.swizzle[1], key.swizzle[2], key.swizzle[3]},
+        .srgb = VK_FALSE,
+    };
+    const void* chain = nullptr;
+    if (custom_border) {
+        chain = &border_ci;
+        if (key.HasSwizzle()) {
+            chain = &mapping_ci;
        }
    }
-    if (device.IsExtBorderColorSwizzleSupported() && GPU::Logging::IsActive()) {
-        GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
-            "VK_EXT_border_color_swizzle", "Sampler::Sampler");
-    }
    const VkSamplerReductionModeCreateInfoEXT reduction_ci{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT,
-        .pNext = pnext,
-        .reductionMode = MaxwellToVK::SamplerReduction(tsc.reduction_filter),
+        .pNext = chain,
+        .reductionMode = reduction_mode,
    };
-    if (runtime.device.IsExtSamplerFilterMinmaxSupported()) {
-        pnext = &reduction_ci;
-    } else if (reduction_ci.reductionMode != VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT) {
-        LOG_WARNING(Render_Vulkan, "VK_EXT_sampler_filter_minmax is required");
+    if (has_minmax_reduction && !key.drop_reduction) {
+        chain = &reduction_ci;
    }
-    // Some games have samplers with garbage. Sanitize them here.
-    const f32 max_anisotropy = std::clamp(tsc.MaxAnisotropy(), 1.0f, 16.0f);

-    const VkFilter mag_filter{MaxwellToVK::Sampler::Filter(tsc.mag_filter)};
-    const VkFilter min_filter{MaxwellToVK::Sampler::Filter(tsc.min_filter)};
-    const VkSamplerMipmapMode mipmap_mode{MaxwellToVK::Sampler::MipmapMode(tsc.mipmap_filter)};
-    const bool has_linear_filtering{mag_filter == VK_FILTER_LINEAR ||
-                                    min_filter == VK_FILTER_LINEAR ||
-                                    mipmap_mode == VK_SAMPLER_MIPMAP_MODE_LINEAR};
-
-    const auto create_sampler = [&](const f32 anisotropy, bool force_nearest,
-                                    bool disable_compare = false) {
-        return device.GetLogical().CreateSampler(VkSamplerCreateInfo{
-            .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-            .pNext = pnext,
-            .flags = 0,
-            .magFilter = force_nearest ? VK_FILTER_NEAREST : mag_filter,
-            .minFilter = force_nearest ? VK_FILTER_NEAREST : min_filter,
-            .mipmapMode = force_nearest ? VK_SAMPLER_MIPMAP_MODE_NEAREST : mipmap_mode,
-            .addressModeU = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_u, tsc.mag_filter),
-            .addressModeV = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_v, tsc.mag_filter),
-            .addressModeW = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_p, tsc.mag_filter),
-            .mipLodBias = tsc.LodBias(),
-            .anisotropyEnable =
-                static_cast<VkBool32>(!force_nearest && anisotropy > 1.0f ? VK_TRUE : VK_FALSE),
-            .maxAnisotropy = force_nearest ? 1.0f : anisotropy,
-            .compareEnable = disable_compare ? VK_FALSE
-                                             : static_cast<VkBool32>(tsc.depth_compare_enabled),
-            .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
-            .minLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.0f : tsc.MinLod(),
-            .maxLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.25f : tsc.MaxLod(),
-            .borderColor = has_custom_border_colors ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT
-                                                    : ConvertBorderColor(color),
-            .unnormalizedCoordinates = VK_FALSE,
-        });
-    };
-
-    sampler = create_sampler(max_anisotropy, false);
-
-    const f32 max_anisotropy_default = static_cast<f32>(1U << tsc.max_anisotropy);
-    if (max_anisotropy > max_anisotropy_default) {
-        sampler_default_anisotropy = create_sampler(max_anisotropy_default, false);
+    VkSamplerCreateInfo create_info = base_ci;
+    create_info.pNext = chain;
+    if (key.force_nearest) {
+        create_info.magFilter = VK_FILTER_NEAREST;
+        create_info.minFilter = VK_FILTER_NEAREST;
+        create_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+        create_info.anisotropyEnable = VK_FALSE;
+        create_info.maxAnisotropy = 1.0f;
+    } else if (key.reduce_anisotropy) {
+        create_info.anisotropyEnable = static_cast<VkBool32>(default_anisotropy > 1.0f);
+        create_info.maxAnisotropy = default_anisotropy;
    }
-    if (has_linear_filtering) {
-        sampler_nearest = create_sampler(1.0f, true);
+    if (key.drop_depth_comparison) {
+        create_info.compareEnable = VK_FALSE;
    }
-    if (tsc.depth_compare_enabled) {
-        sampler_noncompare = create_sampler(max_anisotropy, false, true);
+    if (!custom_border) {
+        create_info.borderColor = ConvertBorderColor(color);
    }
+    variants.push_back(Variant{
+        .key = key,
+        .sampler = device_ptr->GetLogical().CreateSampler(create_info),
+    });
+    return *variants.back().sampler;
+}
+
+VkSampler Sampler::HandleFor(const ImageView& image_view, bool is_depth) {
+    VariantKey key = MakeKey(image_view, is_depth);
+    if (variants.size() >= MAX_VARIANTS) {
+        key.srgb_border = false;
+        key.swizzle = {};
+    }
+    if (const VkSampler existing = Find(key); existing != VK_NULL_HANDLE) {
+        return existing;
+    }
+    return Emplace(key);
 }

 Framebuffer::Framebuffer(TextureCacheRuntime& runtime, std::span<ImageView*, NUM_RT> color_buffers,
@@ -68,8 +68,6 @@ public:

    bool CanReportMemoryUsage() const;

-    std::optional<size_t> GetSamplerHeapBudget() const;
-
    bool CanDownloadMsaa(const VideoCommon::ImageInfo& info) const;

    [[nodiscard]] VkImage AcquireMsaaScratchImage(const VkImageCreateInfo& image_ci);
@@ -446,6 +444,22 @@ public:
        return supports_depth_comparison;
    }

+    [[nodiscard]] bool RequiresBorderColorFormat() const noexcept {
+        return requires_border_color_format;
+    }
+
+    [[nodiscard]] bool SupportsMinmaxFilter() const noexcept {
+        return supports_minmax_filter;
+    }
+
+    [[nodiscard]] const VkComponentMapping& Swizzle() const noexcept {
+        return swizzle_mapping;
+    }
+
+    [[nodiscard]] bool HasIdentitySwizzle() const noexcept {
+        return has_identity_swizzle;
+    }
+
    [[nodiscard]] GPUVAddr GpuAddr() const noexcept {
        return gpu_addr;
    }
@@ -478,48 +492,91 @@ private:
    VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
    u32 buffer_size = 0;

+    VkComponentMapping swizzle_mapping{};
+
    bool supports_depth_comparison = false;
+    bool requires_border_color_format = false;
+    bool supports_minmax_filter = false;
+    bool has_identity_swizzle = true;
 };

 class ImageAlloc : public VideoCommon::ImageAllocBase {};

+class CustomBorderColorBudget {
+public:
+    CustomBorderColorBudget() = default;
+    ~CustomBorderColorBudget();
+
+    CustomBorderColorBudget(const CustomBorderColorBudget&) = delete;
+    CustomBorderColorBudget& operator=(const CustomBorderColorBudget&) = delete;
+
+    CustomBorderColorBudget(CustomBorderColorBudget&& rhs) noexcept;
+    CustomBorderColorBudget& operator=(CustomBorderColorBudget&& rhs) noexcept;
+
+    bool TryAcquire(const Device& device, size_t count);
+
+private:
+    void Release() noexcept;
+
+    const Device* device_ptr = nullptr;
+    size_t held = 0;
+};
+
 class Sampler {
 public:
    explicit Sampler(TextureCacheRuntime&, const Tegra::Texture::TSCEntry&);

    [[nodiscard]] VkSampler Handle() const noexcept {
-        return *sampler;
+        return *variants.front().sampler;
    }

-    [[nodiscard]] VkSampler HandleWithDefaultAnisotropy() const noexcept {
-        return *sampler_default_anisotropy;
-    }
-
-    [[nodiscard]] bool HasAddedAnisotropy() const noexcept {
-        return static_cast<bool>(sampler_default_anisotropy);
-    }
-
-    [[nodiscard]] VkSampler HandleWithNearestFilter() const noexcept {
-        return *sampler_nearest;
-    }
-
-    [[nodiscard]] bool HasLinearFiltering() const noexcept {
-        return static_cast<bool>(sampler_nearest);
-    }
-
-    [[nodiscard]] VkSampler HandleWithoutDepthComparison() const noexcept {
-        return *sampler_noncompare;
-    }
-
-    [[nodiscard]] bool HasDepthComparison() const noexcept {
-        return static_cast<bool>(sampler_noncompare);
-    }
+    [[nodiscard]] VkSampler HandleFor(const ImageView& image_view, bool is_depth);

 private:
-    vk::Sampler sampler;
-    vk::Sampler sampler_default_anisotropy;
-    vk::Sampler sampler_nearest;
-    vk::Sampler sampler_noncompare;
+    struct VariantKey {
+        bool reduce_anisotropy;
+        bool force_nearest;
+        bool drop_depth_comparison;
+        bool drop_reduction;
+        bool drop_custom_border;
+        bool srgb_border;
+        std::array<VkComponentSwizzle, 4> swizzle;
+
+        bool operator==(const VariantKey&) const noexcept = default;
+
+        [[nodiscard]] bool HasSwizzle() const noexcept {
+            return swizzle != std::array<VkComponentSwizzle, 4>{};
+        }
+    };
+
+    struct Variant {
+        VariantKey key;
+        vk::Sampler sampler;
+    };
+
+    static constexpr size_t MAX_VARIANTS = 32;
+
+    [[nodiscard]] VariantKey MakeKey(const ImageView& image_view, bool is_depth) const noexcept;
+    [[nodiscard]] VkSampler Find(const VariantKey& key) const noexcept;
+    VkSampler Emplace(VariantKey key);
+
+    CustomBorderColorBudget custom_border_color_budget;
+    std::vector<Variant> variants;
+
+    const Device* device_ptr{nullptr};
+    VkSamplerCreateInfo base_ci{};
+    VkSamplerReductionModeEXT reduction_mode{VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT};
+    std::array<float, 4> border_color{};
+    std::array<float, 4> srgb_border_color{};
+    f32 default_anisotropy{1.0f};
+
+    bool has_added_anisotropy{};
+    bool has_linear_filtering{};
+    bool has_depth_comparison{};
+    bool has_minmax_reduction{};
+    bool has_custom_border_colors{};
+    bool has_srgb_border_color{};
+    bool needs_swizzle_mapping{};
 };

 struct TextureCacheParams {
@@ -1896,67 +1896,10 @@ SamplerId TextureCache<P>::FindSampler(const TSCEntry& config, bool compute) {
    const auto [pair, is_new] = channel_state->samplers.try_emplace(config);
    if (is_new) {
        pair->second = slot_samplers.insert(runtime, config);
-        EnforceSamplerBudget();
    }
    return pair->second;
 }

-template <class P>
-std::optional<size_t> TextureCache<P>::QuerySamplerBudget() const {
-    if constexpr (requires { runtime.GetSamplerHeapBudget(); }) {
-        return runtime.GetSamplerHeapBudget();
-    } else {
-        return std::nullopt;
-    }
-}
-
-template <class P>
-void TextureCache<P>::EnforceSamplerBudget() {
-    if (auto const budget = QuerySamplerBudget(); budget) {
-        if (slot_samplers.size() < *budget) {
-            return;
-        }
-        if (!channel_state) {
-            return;
-        }
-        if (last_sampler_gc_frame == frame_tick) {
-            return;
-        }
-        last_sampler_gc_frame = frame_tick;
-        TrimInactiveSamplers(*budget);
-    }
-}
-
-template <class P>
-void TextureCache<P>::TrimInactiveSamplers(size_t budget) {
-    if (channel_state->samplers.size() > 0) {
-        constexpr size_t SAMPLER_GC_SLACK = 1024;
-        ankerl::unordered_dense::set<SamplerId> active_sampler_ids;
-        for (auto const& e : channel_state->sampler_ids)
-            active_sampler_ids.insert(e.second);
-        // Elements in the map must be necesarily valid
-        size_t removed = 0;
-        for (auto it = channel_state->samplers.begin(); it != channel_state->samplers.end();) {
-            const SamplerId sampler_id = it->second;
-            if (!sampler_id || sampler_id == CORRUPT_ID) {
-                it = channel_state->samplers.erase(it);
-            } else if (std::ranges::find(active_sampler_ids, sampler_id) != active_sampler_ids.end()) {
-                ++it;
-            } else {
-                slot_samplers.erase(sampler_id);
-                it = channel_state->samplers.erase(it);
-                ++removed;
-                if (slot_samplers.size() + SAMPLER_GC_SLACK <= budget) {
-                    break;
-                }
-            }
-        }
-        if (removed != 0) {
-            LOG_WARNING(HW_GPU, "Sampler cache exceeded {} entries on this driver; reclaimed {} inactive samplers", budget, removed);
-        }
-    }
-}
-
 template <class P>
 ImageViewId TextureCache<P>::FindColorBuffer(size_t index) {
    const auto& regs = maxwell3d->regs;
@@ -420,9 +420,6 @@ private:

    void QueueAsyncDecode(Image& image, ImageId image_id);
    void TickAsyncDecode();
-    void EnforceSamplerBudget();
-    void TrimInactiveSamplers(size_t budget);
-    std::optional<size_t> QuerySamplerBudget() const;

    void QueueAsyncUnswizzle(Image& image, ImageId image_id);
    void TickAsyncUnswizzle();
@@ -509,7 +506,6 @@ private:

    u64 modification_tick = 0;
    u64 frame_tick = 0;
-    u64 last_sampler_gc_frame = (std::numeric_limits<u64>::max)();

    Common::ThreadWorker texture_decode_worker{1, "TextureDecoder", {},
                                               Common::ThreadPlacement::Efficiency};
@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <array>
+#include <cmath>

 #include "common/cityhash.h"
 #include "common/settings.h"
@@ -17,53 +18,25 @@ namespace Tegra::Texture {

 namespace {

-[[maybe_unused]] constexpr std::array<float, 256> SRGB_CONVERSION_LUT = {
-    0.000000f, 0.000000f, 0.000000f, 0.000012f, 0.000021f, 0.000033f, 0.000046f, 0.000062f,
-    0.000081f, 0.000102f, 0.000125f, 0.000151f, 0.000181f, 0.000214f, 0.000251f, 0.000293f,
-    0.000338f, 0.000388f, 0.000443f, 0.000503f, 0.000568f, 0.000639f, 0.000715f, 0.000798f,
-    0.000887f, 0.000983f, 0.001085f, 0.001195f, 0.001312f, 0.001437f, 0.001569f, 0.001710f,
-    0.001860f, 0.002019f, 0.002186f, 0.002364f, 0.002551f, 0.002748f, 0.002955f, 0.003174f,
-    0.003403f, 0.003643f, 0.003896f, 0.004160f, 0.004436f, 0.004725f, 0.005028f, 0.005343f,
-    0.005672f, 0.006015f, 0.006372f, 0.006744f, 0.007130f, 0.007533f, 0.007950f, 0.008384f,
-    0.008834f, 0.009301f, 0.009785f, 0.010286f, 0.010805f, 0.011342f, 0.011898f, 0.012472f,
-    0.013066f, 0.013680f, 0.014313f, 0.014967f, 0.015641f, 0.016337f, 0.017054f, 0.017793f,
-    0.018554f, 0.019337f, 0.020144f, 0.020974f, 0.021828f, 0.022706f, 0.023609f, 0.024536f,
-    0.025489f, 0.026468f, 0.027473f, 0.028504f, 0.029563f, 0.030649f, 0.031762f, 0.032904f,
-    0.034074f, 0.035274f, 0.036503f, 0.037762f, 0.039050f, 0.040370f, 0.041721f, 0.043103f,
-    0.044518f, 0.045964f, 0.047444f, 0.048956f, 0.050503f, 0.052083f, 0.053699f, 0.055349f,
-    0.057034f, 0.058755f, 0.060513f, 0.062307f, 0.064139f, 0.066008f, 0.067915f, 0.069861f,
-    0.071845f, 0.073869f, 0.075933f, 0.078037f, 0.080182f, 0.082369f, 0.084597f, 0.086867f,
-    0.089180f, 0.091535f, 0.093935f, 0.096378f, 0.098866f, 0.101398f, 0.103977f, 0.106601f,
-    0.109271f, 0.111988f, 0.114753f, 0.117565f, 0.120426f, 0.123335f, 0.126293f, 0.129301f,
-    0.132360f, 0.135469f, 0.138629f, 0.141841f, 0.145105f, 0.148421f, 0.151791f, 0.155214f,
-    0.158691f, 0.162224f, 0.165810f, 0.169453f, 0.173152f, 0.176907f, 0.180720f, 0.184589f,
-    0.188517f, 0.192504f, 0.196549f, 0.200655f, 0.204820f, 0.209046f, 0.213334f, 0.217682f,
-    0.222093f, 0.226567f, 0.231104f, 0.235704f, 0.240369f, 0.245099f, 0.249894f, 0.254754f,
-    0.259681f, 0.264674f, 0.269736f, 0.274864f, 0.280062f, 0.285328f, 0.290664f, 0.296070f,
-    0.301546f, 0.307094f, 0.312713f, 0.318404f, 0.324168f, 0.330006f, 0.335916f, 0.341902f,
-    0.347962f, 0.354097f, 0.360309f, 0.366597f, 0.372961f, 0.379403f, 0.385924f, 0.392524f,
-    0.399202f, 0.405960f, 0.412798f, 0.419718f, 0.426719f, 0.433802f, 0.440967f, 0.448216f,
-    0.455548f, 0.462965f, 0.470465f, 0.478052f, 0.485725f, 0.493484f, 0.501329f, 0.509263f,
-    0.517285f, 0.525396f, 0.533595f, 0.541885f, 0.550265f, 0.558736f, 0.567299f, 0.575954f,
-    0.584702f, 0.593542f, 0.602477f, 0.611507f, 0.620632f, 0.629852f, 0.639168f, 0.648581f,
-    0.658092f, 0.667700f, 0.677408f, 0.687214f, 0.697120f, 0.707127f, 0.717234f, 0.727443f,
-    0.737753f, 0.748167f, 0.758685f, 0.769305f, 0.780031f, 0.790861f, 0.801798f, 0.812839f,
-    0.823989f, 0.835246f, 0.846611f, 0.858085f, 0.869668f, 0.881360f, 0.893164f, 0.905078f,
-    0.917104f, 0.929242f, 0.941493f, 0.953859f, 0.966338f, 1.000000f, 1.000000f, 1.000000f,
-};
+float SrgbToLinear(u32 value) {
+    const float encoded = static_cast<float>(value) / 255.0f;
+    if (encoded <= 0.04045f) {
+        return encoded / 12.92f;
+    }
+    return std::pow((encoded + 0.055f) / 1.055f, 2.4f);
+}

 } // Anonymous namespace

 std::array<float, 4> TSCEntry::BorderColor() const noexcept {
-    // TODO: Handle SRGB correctly. Using this breaks shadows in some games (Xenoblade).
-    // if (!srgb_conversion) {
-    //    return border_color;
-    //}
-    // return {SRGB_CONVERSION_LUT[srgb_border_color_r], SRGB_CONVERSION_LUT[srgb_border_color_g],
-    //        SRGB_CONVERSION_LUT[srgb_border_color_b], border_color[3]};
    return border_color;
 }

+std::array<float, 4> TSCEntry::SrgbBorderColor() const noexcept {
+    return {SrgbToLinear(srgb_border_color_r), SrgbToLinear(srgb_border_color_g),
+            SrgbToLinear(srgb_border_color_b), border_color[3]};
+}
+
 float TSCEntry::MaxAnisotropy() const noexcept {
    const bool is_suitable_mipmap_filter = mipmap_filter != TextureMipmapFilter::None;
    const bool has_regular_lods = min_lod_clamp == 0 && max_lod_clamp >= 256;
@@ -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

@@ -378,6 +381,8 @@ struct TSCEntry {

    std::array<float, 4> BorderColor() const noexcept;

+    std::array<float, 4> SrgbBorderColor() const noexcept;
+
    float MaxAnisotropy() const noexcept;

    float MinLod() const {
@@ -508,17 +508,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers require scaled vertex format emulation.");
        has_broken_descriptor_aliasing = true;
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken descriptor aliasing.");
-        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken custom border color.");
-        RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
-                               VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
-        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken border color swizzle.");
-        RemoveExtensionFeature(extensions.border_color_swizzle, features.border_color_swizzle,
-                               VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME);
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken color write enable.");
        RemoveExtensionFeature(extensions.color_write_enable, features.color_write_enable,
                               VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME);
-        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken shader float controls.");
-        RemoveExtension(extensions.shader_float_controls, VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken shader atomic int64.");
        RemoveExtensionFeature(extensions.shader_atomic_int64, features.shader_atomic_int64,
                               VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
@@ -619,21 +611,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        }
    }

-    if (is_qualcomm) {
-        const size_t sampler_limit = properties.properties.limits.maxSamplerAllocationCount;
-        if (sampler_limit > 0) {
-            constexpr size_t MIN_SAMPLER_BUDGET = 1024U;
-            const size_t reserved = sampler_limit / 4U;
-            const size_t derived_budget =
-                (std::max)(MIN_SAMPLER_BUDGET, sampler_limit - reserved);
-            sampler_heap_budget = derived_budget;
-            LOG_WARNING(Render_Vulkan,
-                        "Qualcomm driver reports max {} samplers; reserving {} (25%) and "
-                        "allowing Eden to use {} (75%) to avoid heap exhaustion",
-                        sampler_limit, reserved, sampler_heap_budget);
-        }
-    }
-
    if (extensions.sampler_filter_minmax && is_amd) {
        // Disable ext_sampler_filter_minmax on AMD GCN4 and lower as it is broken.
        if (!features.shader_float16_int8.shaderFloat16) {
@@ -1146,6 +1123,11 @@ bool Device::GetSuitability(bool requires_swapchain) {
            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
        SetNext(next, properties.maintenance5);
    }
+    if (extensions.custom_border_color) {
+        properties.custom_border_color.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
+        SetNext(next, properties.custom_border_color);
+    }

    // Perform the property fetch.
    physical.GetProperties2(properties2);
@@ -1242,9 +1224,7 @@ void Device::RemoveUnsuitableExtensions() {
    // VK_EXT_border_color_swizzle
    if (extensions.border_color_swizzle) {
        extensions.border_color_swizzle =
-            extensions.custom_border_color &&
-            features.border_color_swizzle.borderColorSwizzle &&
-            features.border_color_swizzle.borderColorSwizzleFromImage;
+            extensions.custom_border_color && features.border_color_swizzle.borderColorSwizzle;
    }
    RemoveExtensionFeatureIfUnsuitable(extensions.border_color_swizzle,
                                       features.border_color_swizzle,
@@ -1490,11 +1470,26 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
    }
 }

-std::optional<size_t> Device::GetSamplerHeapBudget() const {
-    if (sampler_heap_budget == 0) {
-        return std::nullopt;
+bool Device::TryReserveCustomBorderColorSamplers(size_t count) const {
+    const size_t limit = properties.custom_border_color.maxCustomBorderColorSamplers;
+    if (limit == 0) {
+        return true;
    }
-    return sampler_heap_budget;
+    size_t used = custom_border_color_samplers_used.load(std::memory_order_relaxed);
+    while (used + count <= limit) {
+        if (custom_border_color_samplers_used.compare_exchange_weak(
+                used, used + count, std::memory_order_relaxed, std::memory_order_relaxed)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void Device::ReleaseCustomBorderColorSamplers(size_t count) const {
+    if (count == 0) {
+        return;
+    }
+    custom_border_color_samplers_used.fetch_sub(count, std::memory_order_relaxed);
 }

 u64 Device::GetDeviceMemoryUsage() const {
@@ -6,6 +6,7 @@

 #pragma once

+#include <atomic>
 #include <optional>
 #include <set>
 #include <span>
@@ -699,20 +700,18 @@ FN_MAX_LIMIT_LIST
        return features.transform_feedback.geometryStreams;
    }

-    /// Returns true if the device supports VK_EXT_custom_border_color.
-    bool IsExtCustomBorderColorSupported() const {
-        return extensions.custom_border_color;
+    /// Returns true if custom border colors can be created without a format.
+    bool IsCustomBorderColorUsable() const {
+        return extensions.custom_border_color &&
+               features.custom_border_color.customBorderColors &&
+               features.custom_border_color.customBorderColorWithoutFormat;
    }

-    /// Returns true if customBorderColors feature is available.
-    bool IsCustomBorderColorsSupported() const {
-        return features.custom_border_color.customBorderColors;
-    }
+    /// Takes budget for samplers carrying a custom border color, false when exhausted.
+    bool TryReserveCustomBorderColorSamplers(size_t count) const;

-    /// Returns true if customBorderColorWithoutFormat feature is available.
-    bool IsCustomBorderColorWithoutFormatSupported() const {
-        return features.custom_border_color.customBorderColorWithoutFormat;
-    }
+    /// Gives back budget taken by TryReserveCustomBorderColorSamplers.
+    void ReleaseCustomBorderColorSamplers(size_t count) const;

    /// Returns true if the device supports VK_EXT_color_write_enable.
    bool IsExtColorWriteEnableSupported() const {
@@ -724,6 +723,12 @@ FN_MAX_LIMIT_LIST
        return extensions.border_color_swizzle;
    }

+    /// Returns true if samplers must be carried with border color swizzle mapping.
+    bool NeedsBorderColorSwizzleMapping() const {
+        return extensions.border_color_swizzle &&
+               !features.border_color_swizzle.borderColorSwizzleFromImage;
+    }
+
    /// Returns true if borderColorSwizzleFromImage is available.
    bool IsBorderColorSwizzleFromImageSupported() const {
        return features.border_color_swizzle.borderColorSwizzleFromImage;
@@ -919,8 +924,6 @@ FN_MAX_LIMIT_LIST
        return has_broken_parallel_compiling;
    }

-    std::optional<size_t> GetSamplerHeapBudget() const;
-
    /// Returns the vendor name reported from Vulkan.
    std::string_view GetVendorName() const {
        return properties.driver.driverName;
@@ -1173,6 +1176,7 @@ private:
        VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
        VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
        VkPhysicalDeviceDepthStencilResolveProperties depth_stencil_resolve{};
+        VkPhysicalDeviceCustomBorderColorPropertiesEXT custom_border_color{};

        VkPhysicalDeviceProperties properties{};
    };
@@ -1211,7 +1215,7 @@ private:
    bool dynamic_state3_alpha_to_coverage{};
    bool dynamic_state3_alpha_to_one{};
    bool supports_conditional_barriers{};      ///< Allows barriers in conditional control flow.
-    size_t sampler_heap_budget{};              ///< Sampler budget for buggy drivers (0 = unlimited).
+    mutable std::atomic<size_t> custom_border_color_samplers_used{};
    u64 device_access_memory{};                ///< Total size of device local memory in bytes.
    u32 sets_per_pool{};                       ///< Sets per Description Pool
    NvidiaArchitecture nvidia_arch{NvidiaArchitecture::Arch_AmpereOrNewer};