[vk] Reordering disabled broken DynamicState and ExtendedDynamicState

[vk] compiler baka baka
[vk] Handling padding (compiler tomto)
2025-11-22 19:05:10 +01:00 · 2025-11-22 19:04:43 +01:00 · 2025-11-22 19:04:04 +01:00 · 2025-11-22 19:03:42 +01:00 · 2025-11-22 19:03:05 +01:00 · 2025-11-22 19:02:27 +01:00
50 changed files with 1999 additions and 369 deletions
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -121,7 +121,7 @@ else()
        -Werror=unused

        -Wno-attributes
-        -Wno-invalid-offsetof
+        $<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>
        -Wno-unused-parameter
        -Wno-missing-field-initializers
    )
--- a/src/common/host_memory.cpp
+++ b/src/common/host_memory.cpp
@@ -730,7 +730,9 @@ void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length,
    ASSERT(virtual_offset % PageAlignment == 0);
    ASSERT(host_offset % PageAlignment == 0);
    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
+    if (impl && virtual_base) {
+        ASSERT(virtual_offset + length <= virtual_size);
+    }
    ASSERT(host_offset + length <= backing_size);
    if (length == 0 || !virtual_base || !impl) {
        return;
@@ -741,7 +743,9 @@ void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length,
 void HostMemory::Unmap(size_t virtual_offset, size_t length, bool separate_heap) {
    ASSERT(virtual_offset % PageAlignment == 0);
    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
+    if (impl && virtual_base) {
+        ASSERT(virtual_offset + length <= virtual_size);
+    }
    if (length == 0 || !virtual_base || !impl) {
        return;
    }
@@ -751,7 +755,9 @@ void HostMemory::Unmap(size_t virtual_offset, size_t length, bool separate_heap)
 void HostMemory::Protect(size_t virtual_offset, size_t length, MemoryPermission perm) {
    ASSERT(virtual_offset % PageAlignment == 0);
    ASSERT(length % PageAlignment == 0);
-    ASSERT(virtual_offset + length <= virtual_size);
+    if (impl && virtual_base) {
+        ASSERT(virtual_offset + length <= virtual_size);
+    }
    if (length == 0 || !virtual_base || !impl) {
        return;
    }
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -546,6 +546,15 @@ struct Values {
                                           Category::RendererExtensions,
                                           Specialization::Scalar};

+    SwitchableSetting<bool> vertex_input_dynamic_state{linkage,
+#if defined (ANDROID)
+                                                        false,  // Disabled by default on Android (some drivers have issues)
+#else
+                                                        false, // Disabled by default on desktop (some drivers have issues)
+#endif
+                                                        "vertex_input_dynamic_state",
+                                                        Category::RendererExtensions};
+
    SwitchableSetting<bool> provoking_vertex{linkage, false, "provoking_vertex", Category::RendererExtensions};
    SwitchableSetting<bool> descriptor_indexing{linkage, false, "descriptor_indexing", Category::RendererExtensions};
    SwitchableSetting<bool> sample_shading{linkage, false, "sample_shading", Category::RendererExtensions, Specialization::Paired};
@@ -560,6 +569,60 @@ struct Values {
                                                         false,
                                                         &sample_shading};

+#ifdef ANDROID
+    // Shader Float Controls (Android only) - Eden Veil / Extensions
+    // Force enable VK_KHR_shader_float_controls even if driver has known issues
+    // Allows fine-tuning float behavior to match Switch/Maxwell or optimize performance
+    SwitchableSetting<bool> shader_float_controls_force_enable{linkage, 
+                                                               false, 
+                                                               "shader_float_controls_force_enable", 
+                                                               Category::RendererExtensions,
+                                                               Specialization::Paired};
+    
+    // Individual float behavior controls (visible only when force_enable is true)
+    // Multiple can be active simultaneously EXCEPT FTZ and DenormPreserve (mutually exclusive)
+    // 
+    // Recommended configurations:
+    //   Switch-native: FTZ=ON, RTE=ON, SignedZero=ON (matches Maxwell behavior)
+    //   Performance:   FTZ=ON only (fastest)
+    //   Accuracy:      DenormPreserve=ON, RTE=ON, SignedZero=ON (slowest, highest precision)
+    SwitchableSetting<bool> shader_float_ftz{linkage,
+                                             false,
+                                             "shader_float_ftz",
+                                             Category::RendererExtensions,
+                                             Specialization::Default,
+                                             true,
+                                             false,
+                                             &shader_float_controls_force_enable};
+    
+    SwitchableSetting<bool> shader_float_denorm_preserve{linkage,
+                                                         false,
+                                                         "shader_float_denorm_preserve",
+                                                         Category::RendererExtensions,
+                                                         Specialization::Default,
+                                                         true,
+                                                         false,
+                                                         &shader_float_controls_force_enable};
+    
+    SwitchableSetting<bool> shader_float_rte{linkage,
+                                             false,
+                                             "shader_float_rte",
+                                             Category::RendererExtensions,
+                                             Specialization::Default,
+                                             true,
+                                             false,
+                                             &shader_float_controls_force_enable};
+    
+    SwitchableSetting<bool> shader_float_signed_zero_inf_nan{linkage,
+                                                             false,
+                                                             "shader_float_signed_zero_inf_nan",
+                                                             Category::RendererExtensions,
+                                                             Specialization::Default,
+                                                             true,
+                                                             false,
+                                                             &shader_float_controls_force_enable};
+#endif
+
    Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug};
    Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback",
                                           Category::RendererDebug};
--- a/src/common/settings_enums.h
+++ b/src/common/settings_enums.h
@@ -152,6 +152,16 @@ ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
 ENUM(GpuOverclock, Low, Medium, High)
 ENUM(TemperatureUnits, Celsius, Fahrenheit)

+// Shader Float Controls behavior modes
+// These control how floating-point denormals and special values are handled in shaders
+ENUM(ShaderFloatBehavior, 
+     DriverDefault,        // Let driver choose (safest, may not match Switch behavior)
+     SwitchNative,         // Emulate Switch/Maxwell behavior (FTZ + RTE + SignedZero)
+     FlushToZero,          // FTZ only - flush denorms to zero (fastest, some precision loss)
+     PreserveDenorms,      // Preserve denorms (slowest, highest precision)
+     RoundToEven,          // RTE rounding mode (IEEE 754 compliant)
+     SignedZeroInfNan);    // Preserve signed zero, inf, nan (accuracy for edge cases)
+
 template <typename Type>
 inline std::string_view CanonicalizeEnum(Type id) {
    const auto group = EnumMetadata<Type>::Canonicalizations();
--- a/src/core/hle/service/hle_ipc.cpp
+++ b/src/core/hle/service/hle_ipc.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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

@@ -393,6 +396,24 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
    const bool is_buffer_b{BufferDescriptorB().size() > buffer_index &&
                           BufferDescriptorB()[buffer_index].Size()};
    const std::size_t buffer_size{GetWriteBufferSize(buffer_index)};
+    
+    // Defensive check: if client didn't provide output buffer, log detailed error but don't crash
+    if (buffer_size == 0) {
+        LOG_ERROR(Core,
+                  "WriteBuffer called but client provided NO output buffer! "
+                  "Requested size: 0x{:X}, buffer_index: {}, is_buffer_b: {}, "
+                  "BufferB count: {}, BufferC count: {}",
+                  size, buffer_index, is_buffer_b, BufferDescriptorB().size(),
+                  BufferDescriptorC().size());
+        
+        // Log command context for debugging
+        LOG_ERROR(Core, "IPC Command: 0x{:X}, Type: {}", GetCommand(), 
+                  static_cast<u32>(GetCommandType()));
+        
+        // Return 0 instead of crashing - let service handle error
+        return 0;
+    }
+    
    if (size > buffer_size) {
        LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
                     buffer_size);
--- a/src/shader_recompiler/backend/glsl/glsl_emit_context.cpp
+++ b/src/shader_recompiler/backend/glsl/glsl_emit_context.cpp
@@ -380,13 +380,14 @@ void EmitContext::SetupExtensions() {
    if (info.uses_int64 && profile.support_int64) {
        header += "#extension GL_ARB_gpu_shader_int64 : enable\n";
    }
-    if (info.uses_int64_bit_atomics) {
+    if (info.uses_int64_bit_atomics && profile.support_gl_shader_atomic_int64) {
        header += "#extension GL_NV_shader_atomic_int64 : enable\n";
    }
-    if (info.uses_atomic_f32_add) {
+    if (info.uses_atomic_f32_add && profile.support_gl_shader_atomic_float) {
        header += "#extension GL_NV_shader_atomic_float : enable\n";
    }
-    if (info.uses_atomic_f16x2_add || info.uses_atomic_f16x2_min || info.uses_atomic_f16x2_max) {
+    if ((info.uses_atomic_f16x2_add || info.uses_atomic_f16x2_min || info.uses_atomic_f16x2_max) &&
+        profile.support_gl_shader_atomic_fp16_vector) {
        header += "#extension GL_NV_shader_atomic_fp16_vector : enable\n";
    }
    if (info.uses_fp16) {
--- a/src/shader_recompiler/backend/spirv/emit_spirv.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv.cpp
@@ -341,19 +341,35 @@ void DefineEntryPoint(const IR::Program& program, EmitContext& ctx, Id main) {
 void SetupDenormControl(const Profile& profile, const IR::Program& program, EmitContext& ctx,
                        Id main_func) {
    const Info& info{program.info};
+    
+    // User-forced behavior overrides (Android Eden Veil/Extensions)
+    // When force flags are active, they take precedence over shader-declared behavior
+    const bool force_flush = profile.force_fp32_denorm_flush;
+    const bool force_preserve = profile.force_fp32_denorm_preserve;
+    
+    if (force_flush && force_preserve) {
+        LOG_WARNING(Shader_SPIRV, "Both FTZ and Preserve forced simultaneously - FTZ takes precedence");
+    }
+    
    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) {
+    } else if (force_flush || info.uses_fp32_denorms_flush) {
        if (profile.support_fp32_denorm_flush) {
            ctx.AddCapability(spv::Capability::DenormFlushToZero);
            ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormFlushToZero, 32U);
+            if (force_flush) {
+                LOG_DEBUG(Shader_SPIRV, "Fp32 DenormFlushToZero FORCED by user setting");
+            }
        } else {
            // Drivers will most likely flush denorms by default, no need to warn
        }
-    } else if (info.uses_fp32_denorms_preserve) {
+    } else if (force_preserve || info.uses_fp32_denorms_preserve) {
        if (profile.support_fp32_denorm_preserve) {
            ctx.AddCapability(spv::Capability::DenormPreserve);
            ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormPreserve, 32U);
+            if (force_preserve) {
+                LOG_DEBUG(Shader_SPIRV, "Fp32 DenormPreserve FORCED by user setting");
+            }
        } else {
            LOG_DEBUG(Shader_SPIRV, "Fp32 denorm preserve used in shader without host support");
        }
@@ -386,13 +402,24 @@ void SetupSignedNanCapabilities(const Profile& profile, const IR::Program& progr
    if (profile.has_broken_fp16_float_controls && program.info.uses_fp16) {
        return;
    }
+    
+    // User-forced behavior (Android Eden Veil/Extensions)
+    const bool force_signed_zero_inf_nan = profile.force_fp32_signed_zero_inf_nan;
+    
    if (program.info.uses_fp16 && profile.support_fp16_signed_zero_nan_preserve) {
        ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);
        ctx.AddExecutionMode(main_func, spv::ExecutionMode::SignedZeroInfNanPreserve, 16U);
    }
-    if (profile.support_fp32_signed_zero_nan_preserve) {
-        ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);
-        ctx.AddExecutionMode(main_func, spv::ExecutionMode::SignedZeroInfNanPreserve, 32U);
+    if (force_signed_zero_inf_nan || profile.support_fp32_signed_zero_nan_preserve) {
+        if (profile.support_fp32_signed_zero_nan_preserve) {
+            ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);
+            ctx.AddExecutionMode(main_func, spv::ExecutionMode::SignedZeroInfNanPreserve, 32U);
+            if (force_signed_zero_inf_nan) {
+                LOG_DEBUG(Shader_SPIRV, "Fp32 SignedZeroInfNanPreserve FORCED by user setting");
+            }
+        } else if (force_signed_zero_inf_nan) {
+            LOG_WARNING(Shader_SPIRV, "SignedZeroInfNanPreserve forced but driver doesn't support it");
+        }
    }
    if (program.info.uses_fp64 && profile.support_fp64_signed_zero_nan_preserve) {
        ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);
--- a/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -318,13 +321,23 @@ void AddOffsetToCoordinates(EmitContext& ctx, const IR::TextureInstInfo& info, I
        return;
    }

+    // Mobile GPUs: 1D textures emulated as 2D with height=1
+    const bool emulate_1d = ctx.profile.needs_1d_texture_emulation;
+    
    Id result_type{};
    switch (info.type) {
    case TextureType::Buffer:
-    case TextureType::Color1D: {
        result_type = ctx.U32[1];
        break;
-    }
+    case TextureType::Color1D:
+        if (emulate_1d) {
+            // Treat as 2D: offset needs Y component
+            offset = ctx.OpCompositeConstruct(ctx.U32[2], offset, ctx.u32_zero_value);
+            result_type = ctx.U32[2];
+        } else {
+            result_type = ctx.U32[1];
+        }
+        break;
    case TextureType::ColorArray1D:
        offset = ctx.OpCompositeConstruct(ctx.U32[2], offset, ctx.u32_zero_value);
        [[fallthrough]];
@@ -348,6 +361,40 @@ void AddOffsetToCoordinates(EmitContext& ctx, const IR::TextureInstInfo& info, I
    }
    coords = ctx.OpIAdd(result_type, coords, offset);
 }
+
+// Helper: Convert 1D coordinates to 2D when emulating 1D textures on mobile GPUs
+[[nodiscard]] Id AdjustCoordinatesForEmulation(EmitContext& ctx, const IR::TextureInstInfo& info,
+                                               Id coords) {
+    if (!ctx.profile.needs_1d_texture_emulation) {
+        return coords;
+    }
+    
+    switch (info.type) {
+    case TextureType::Color1D: {
+        // Convert scalar → vec2(x, 0.0)
+        return ctx.OpCompositeConstruct(ctx.F32[2], coords, ctx.f32_zero_value);
+    }
+    case TextureType::ColorArray1D: {
+        // Convert vec2(x, layer) → vec3(x, 0.0, layer)
+        // ColorArray1D coords are always vec2 in IR
+        const Id x = ctx.OpCompositeExtract(ctx.F32[1], coords, 0);
+        const Id layer = ctx.OpCompositeExtract(ctx.F32[1], coords, 1);
+        return ctx.OpCompositeConstruct(ctx.F32[3], x, ctx.f32_zero_value, layer);
+    }
+    case TextureType::Color2D:
+    case TextureType::ColorArray2D:
+    case TextureType::Color3D:
+    case TextureType::ColorCube:
+    case TextureType::ColorArrayCube:
+    case TextureType::Buffer:
+    case TextureType::Color2DRect:
+        // No adjustment needed for non-1D textures
+        return coords;
+    }
+    
+    return coords; // Unreachable, but silences -Werror=return-type
+}
+
 } // Anonymous namespace

 Id EmitBindlessImageSampleImplicitLod(EmitContext&) {
@@ -449,6 +496,7 @@ Id EmitBoundImageWrite(EmitContext&) {
 Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                              Id bias_lc, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    if (ctx.stage == Stage::Fragment) {
        const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
                                     bias_lc, offset);
@@ -470,6 +518,7 @@ Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value&
 Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                              Id lod, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    const ImageOperands operands(ctx, false, true, false, lod, offset);
    return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
                &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
@@ -479,6 +528,7 @@ Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value&
 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
                                  Id coords, Id dref, Id bias_lc, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    if (ctx.stage == Stage::Fragment) {
        const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
                                     bias_lc, offset);
@@ -500,6 +550,7 @@ Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Va
 Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
                                  Id coords, Id dref, Id lod, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    const ImageOperands operands(ctx, false, true, false, lod, offset);
    return Emit(&EmitContext::OpImageSparseSampleDrefExplicitLod,
                &EmitContext::OpImageSampleDrefExplicitLod, ctx, inst, ctx.F32[1],
@@ -509,6 +560,7 @@ Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Va
 Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                   const IR::Value& offset, const IR::Value& offset2) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    const ImageOperands operands(ctx, offset, offset2);
    if (ctx.profile.need_gather_subpixel_offset) {
        coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
@@ -521,6 +573,7 @@ Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id
 Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                       const IR::Value& offset, const IR::Value& offset2, Id dref) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    const ImageOperands operands(ctx, offset, offset2);
    if (ctx.profile.need_gather_subpixel_offset) {
        coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
@@ -533,6 +586,7 @@ Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
 Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id offset,
                  Id lod, Id ms) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    AddOffsetToCoordinates(ctx, info, coords, offset);
    if (info.type == TextureType::Buffer) {
        lod = Id{};
@@ -559,9 +613,20 @@ Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& i
        return uses_lod ? ctx.OpImageQuerySizeLod(type, image, lod)
                        : ctx.OpImageQuerySize(type, image);
    }};
+    
+    // Mobile GPUs: 1D textures emulated as 2D, query returns vec2 instead of scalar
+    const bool emulate_1d = ctx.profile.needs_1d_texture_emulation;
+    
    switch (info.type) {
    case TextureType::Color1D:
-        return ctx.OpCompositeConstruct(ctx.U32[4], query(ctx.U32[1]), zero, zero, mips());
+        if (emulate_1d) {
+            // Query as 2D, extract only X component for 1D size
+            const Id size_2d = query(ctx.U32[2]);
+            const Id width = ctx.OpCompositeExtract(ctx.U32[1], size_2d, 0);
+            return ctx.OpCompositeConstruct(ctx.U32[4], width, zero, zero, mips());
+        } else {
+            return ctx.OpCompositeConstruct(ctx.U32[4], query(ctx.U32[1]), zero, zero, mips());
+        }
    case TextureType::ColorArray1D:
    case TextureType::Color2D:
    case TextureType::ColorCube:
@@ -579,6 +644,7 @@ Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& i

 Id EmitImageQueryLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    const Id zero{ctx.f32_zero_value};
    const Id sampler{Texture(ctx, info, index)};
    return ctx.OpCompositeConstruct(ctx.F32[4], ctx.OpImageQueryLod(ctx.F32[2], sampler, coords),
@@ -588,6 +654,7 @@ Id EmitImageQueryLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, I
 Id EmitImageGradient(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                     Id derivatives, const IR::Value& offset, Id lod_clamp) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    const auto operands = info.num_derivatives == 3
                              ? ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                              ctx.Def(offset), {}, lod_clamp)
@@ -600,6 +667,7 @@ Id EmitImageGradient(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, I

 Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    if (info.image_format == ImageFormat::Typeless && !ctx.profile.support_typeless_image_loads) {
        LOG_WARNING(Shader_SPIRV, "Typeless image read not supported by host");
        return ctx.ConstantNull(ctx.U32[4]);
@@ -616,6 +684,7 @@ Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id co

 void EmitImageWrite(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id color) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
+    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
    const auto [image, is_integer] = Image(ctx, index, info);
    if (!is_integer) {
        color = ctx.OpBitcast(ctx.F32[4], color);
--- a/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -92,7 +95,7 @@ void EmitLoadGlobalS16(EmitContext&) {
 }

 Id EmitLoadGlobal32(EmitContext& ctx, Id address) {
-    if (ctx.profile.support_int64) {
+    if (ctx.SupportsNativeInt64() || ctx.UsesInt64Emulation()) {
        return ctx.OpFunctionCall(ctx.U32[1], ctx.load_global_func_u32, address);
    }
    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
@@ -100,7 +103,7 @@ Id EmitLoadGlobal32(EmitContext& ctx, Id address) {
 }

 Id EmitLoadGlobal64(EmitContext& ctx, Id address) {
-    if (ctx.profile.support_int64) {
+    if (ctx.SupportsNativeInt64() || ctx.UsesInt64Emulation()) {
        return ctx.OpFunctionCall(ctx.U32[2], ctx.load_global_func_u32x2, address);
    }
    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
@@ -108,7 +111,7 @@ Id EmitLoadGlobal64(EmitContext& ctx, Id address) {
 }

 Id EmitLoadGlobal128(EmitContext& ctx, Id address) {
-    if (ctx.profile.support_int64) {
+    if (ctx.SupportsNativeInt64() || ctx.UsesInt64Emulation()) {
        return ctx.OpFunctionCall(ctx.U32[4], ctx.load_global_func_u32x4, address);
    }
    LOG_WARNING(Shader_SPIRV, "Int64 not supported, ignoring memory operation");
@@ -132,7 +135,7 @@ void EmitWriteGlobalS16(EmitContext&) {
 }

 void EmitWriteGlobal32(EmitContext& ctx, Id address, Id value) {
-    if (ctx.profile.support_int64) {
+    if (ctx.SupportsNativeInt64() || ctx.UsesInt64Emulation()) {
        ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32, address, value);
        return;
    }
@@ -140,7 +143,7 @@ void EmitWriteGlobal32(EmitContext& ctx, Id address, Id value) {
 }

 void EmitWriteGlobal64(EmitContext& ctx, Id address, Id value) {
-    if (ctx.profile.support_int64) {
+    if (ctx.SupportsNativeInt64() || ctx.UsesInt64Emulation()) {
        ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32x2, address, value);
        return;
    }
@@ -148,7 +151,7 @@ void EmitWriteGlobal64(EmitContext& ctx, Id address, Id value) {
 }

 void EmitWriteGlobal128(EmitContext& ctx, Id address, Id value) {
-    if (ctx.profile.support_int64) {
+    if (ctx.SupportsNativeInt64() || ctx.UsesInt64Emulation()) {
        ctx.OpFunctionCall(ctx.void_id, ctx.write_global_func_u32x4, address, value);
        return;
    }
--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp
+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp
@@ -33,11 +33,24 @@ Id ImageType(EmitContext& ctx, const TextureDescriptor& desc) {
    const Id type{ctx.F32[1]};
    const bool depth{desc.is_depth};
    const bool ms{desc.is_multisample};
+    
+    // Mobile GPUs lack Sampled1D SPIR-V capability - emulate 1D as 2D with array layer
+    const bool emulate_1d = ctx.profile.needs_1d_texture_emulation;
+    
+    // Debug log for 1D emulation
+    if (desc.type == TextureType::Color1D || desc.type == TextureType::ColorArray1D) {
+        LOG_WARNING(Shader_SPIRV, "ImageType(texture): Creating {} texture, emulate_1d={}", 
+                    desc.type == TextureType::Color1D ? "Color1D" : "ColorArray1D",
+                    emulate_1d);
+    }
+    
    switch (desc.type) {
    case TextureType::Color1D:
-        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, false, false, 1, format);
+        return emulate_1d ? ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, false, 1, format)
+                          : ctx.TypeImage(type, spv::Dim::Dim1D, depth, false, false, 1, format);
    case TextureType::ColorArray1D:
-        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, true, false, 1, format);
+        return emulate_1d ? ctx.TypeImage(type, spv::Dim::Dim2D, depth, true, false, 1, format)
+                          : ctx.TypeImage(type, spv::Dim::Dim1D, depth, true, false, 1, format);
    case TextureType::Color2D:
    case TextureType::Color2DRect:
        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, ms, 1, format);
@@ -79,11 +92,22 @@ spv::ImageFormat GetImageFormat(ImageFormat format) {

 Id ImageType(EmitContext& ctx, const ImageDescriptor& desc, Id sampled_type) {
    const spv::ImageFormat format{GetImageFormat(desc.format)};
+    const bool emulate_1d = ctx.profile.needs_1d_texture_emulation;
+    
+    // Debug log for 1D emulation
+    if (desc.type == TextureType::Color1D || desc.type == TextureType::ColorArray1D) {
+        LOG_WARNING(Shader_SPIRV, "ImageType: Creating {} image, emulate_1d={}", 
+                    desc.type == TextureType::Color1D ? "Color1D" : "ColorArray1D",
+                    emulate_1d);
+    }
+    
    switch (desc.type) {
    case TextureType::Color1D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, false, false, 2, format);
+        return emulate_1d ? ctx.TypeImage(sampled_type, spv::Dim::Dim2D, false, false, false, 2, format)
+                          : ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, false, false, 2, format);
    case TextureType::ColorArray1D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, true, false, 2, format);
+        return emulate_1d ? ctx.TypeImage(sampled_type, spv::Dim::Dim2D, false, true, false, 2, format)
+                          : ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, true, false, 2, format);
    case TextureType::Color2D:
        return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, false, false, false, 2, format);
    case TextureType::ColorArray2D:
@@ -460,9 +484,14 @@ void VectorTypes::Define(Sirit::Module& sirit_ctx, Id base_type, std::string_vie

 EmitContext::EmitContext(const Profile& profile_, const RuntimeInfo& runtime_info_,
                         IR::Program& program, Bindings& bindings)
-    : Sirit::Module(profile_.supported_spirv), profile{profile_}, runtime_info{runtime_info_},
-      stage{program.stage}, texture_rescaling_index{bindings.texture_scaling_index},
-      image_rescaling_index{bindings.image_scaling_index} {
+        : Sirit::Module(profile_.supported_spirv), profile{profile_}, runtime_info{runtime_info_},
+            stage{program.stage},
+            // Enable int64 emulation if host lacks int64 but we either use int64 ops
+            // or we need 64-bit addressing for global memory operations.
+            emulate_int64{!profile.support_int64 &&
+                          (program.info.uses_int64 || program.info.uses_global_memory)},
+            texture_rescaling_index{bindings.texture_scaling_index},
+            image_rescaling_index{bindings.image_scaling_index} {
    const bool is_unified{profile.unified_descriptor_binding};
    u32& uniform_binding{is_unified ? bindings.unified : bindings.uniform_buffer};
    u32& storage_binding{is_unified ? bindings.unified : bindings.storage_buffer};
@@ -932,11 +961,163 @@ void EmitContext::DefineWriteStorageCasLoopFunction(const Info& info) {
 }

 void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
-    if (!info.uses_global_memory || !profile.support_int64) {
+    if (!info.uses_global_memory) {
        return;
    }
    using DefPtr = Id StorageDefinitions::*;
    const Id zero{u32_zero_value};
+
+    if (SupportsNativeInt64()) {
+        const auto define_body{[&](DefPtr ssbo_member, Id addr, Id element_pointer, u32 shift,
+                                   auto&& callback) {
+            AddLabel();
+            const size_t num_buffers{info.storage_buffers_descriptors.size()};
+            for (size_t index = 0; index < num_buffers; ++index) {
+                if (!info.nvn_buffer_used[index]) {
+                    continue;
+                }
+                const auto& ssbo{info.storage_buffers_descriptors[index]};
+                const Id ssbo_addr_cbuf_offset{Const(ssbo.cbuf_offset / 8)};
+                const Id ssbo_size_cbuf_offset{Const(ssbo.cbuf_offset / 4 + 2)};
+                const Id ssbo_addr_pointer{OpAccessChain(
+                    uniform_types.U32x2, cbufs[ssbo.cbuf_index].U32x2, zero,
+                    ssbo_addr_cbuf_offset)};
+                const Id ssbo_size_pointer{OpAccessChain(
+                    uniform_types.U32, cbufs[ssbo.cbuf_index].U32, zero, ssbo_size_cbuf_offset)};
+
+                const u64 ssbo_align_mask{~(profile.min_ssbo_alignment - 1U)};
+                const Id unaligned_addr{OpBitcast(U64, OpLoad(U32[2], ssbo_addr_pointer))};
+                const Id ssbo_addr{OpBitwiseAnd(U64, unaligned_addr, Constant(U64, ssbo_align_mask))};
+                const Id ssbo_size{OpUConvert(U64, OpLoad(U32[1], ssbo_size_pointer))};
+                const Id ssbo_end{OpIAdd(U64, ssbo_addr, ssbo_size)};
+                const Id cond{OpLogicalAnd(U1, OpUGreaterThanEqual(U1, addr, ssbo_addr),
+                                           OpULessThan(U1, addr, ssbo_end))};
+                const Id then_label{OpLabel()};
+                const Id else_label{OpLabel()};
+                OpSelectionMerge(else_label, spv::SelectionControlMask::MaskNone);
+                OpBranchConditional(cond, then_label, else_label);
+                AddLabel(then_label);
+                const Id ssbo_id{ssbos[index].*ssbo_member};
+                const Id ssbo_offset{OpUConvert(U32[1], OpISub(U64, addr, ssbo_addr))};
+                const Id ssbo_index{OpShiftRightLogical(U32[1], ssbo_offset, Const(shift))};
+                const Id ssbo_pointer{OpAccessChain(element_pointer, ssbo_id, zero, ssbo_index)};
+                callback(ssbo_pointer);
+                AddLabel(else_label);
+            }
+        }};
+        const auto define_load{[&](DefPtr ssbo_member, Id element_pointer, Id type, u32 shift) {
+            const Id function_type{TypeFunction(type, U64)};
+            const Id func_id{OpFunction(type, spv::FunctionControlMask::MaskNone, function_type)};
+            const Id addr{OpFunctionParameter(U64)};
+            define_body(ssbo_member, addr, element_pointer, shift,
+                        [&](Id ssbo_pointer) { OpReturnValue(OpLoad(type, ssbo_pointer)); });
+            OpReturnValue(ConstantNull(type));
+            OpFunctionEnd();
+            return func_id;
+        }};
+        const auto define_write{[&](DefPtr ssbo_member, Id element_pointer, Id type, u32 shift) {
+            const Id function_type{TypeFunction(void_id, U64, type)};
+            const Id func_id{
+                OpFunction(void_id, spv::FunctionControlMask::MaskNone, function_type)};
+            const Id addr{OpFunctionParameter(U64)};
+            const Id data{OpFunctionParameter(type)};
+            define_body(ssbo_member, addr, element_pointer, shift, [&](Id ssbo_pointer) {
+                OpStore(ssbo_pointer, data);
+                OpReturn();
+            });
+            OpReturn();
+            OpFunctionEnd();
+            return func_id;
+        }};
+        const auto define{
+            [&](DefPtr ssbo_member, const StorageTypeDefinition& type_def, Id type, size_t size) {
+                const Id element_type{type_def.element};
+                const u32 shift{static_cast<u32>(std::countr_zero(size))};
+                const Id load_func{define_load(ssbo_member, element_type, type, shift)};
+                const Id write_func{define_write(ssbo_member, element_type, type, shift)};
+                return std::make_pair(load_func, write_func);
+            }};
+        std::tie(load_global_func_u32, write_global_func_u32) =
+            define(&StorageDefinitions::U32, storage_types.U32, U32[1], sizeof(u32));
+        std::tie(load_global_func_u32x2, write_global_func_u32x2) =
+            define(&StorageDefinitions::U32x2, storage_types.U32x2, U32[2], sizeof(u32[2]));
+        std::tie(load_global_func_u32x4, write_global_func_u32x4) =
+            define(&StorageDefinitions::U32x4, storage_types.U32x4, U32[4], sizeof(u32[4]));
+        return;
+    }
+
+    if (!UsesInt64Emulation()) {
+        return;
+    }
+
+    const auto make_pair = [&](Id lo, Id hi) {
+        return OpCompositeConstruct(U32[2], lo, hi);
+    };
+    const auto split_pair = [&](Id value) {
+        return std::array<Id, 2>{OpCompositeExtract(U32[1], value, 0U),
+                                 OpCompositeExtract(U32[1], value, 1U)};
+    };
+    const auto bool_to_u32 = [&](Id predicate) {
+        return OpSelect(U32[1], predicate, Const(1u), zero);
+    };
+    const auto and_pair = [&](Id value, Id mask) {
+        const auto value_parts{split_pair(value)};
+        const auto mask_parts{split_pair(mask)};
+        return make_pair(OpBitwiseAnd(U32[1], value_parts[0], mask_parts[0]),
+                         OpBitwiseAnd(U32[1], value_parts[1], mask_parts[1]));
+    };
+    const auto add_pair = [&](Id lhs, Id rhs) {
+        const auto lhs_parts{split_pair(lhs)};
+        const auto rhs_parts{split_pair(rhs)};
+        const Id sum_lo{OpIAdd(U32[1], lhs_parts[0], rhs_parts[0])};
+        const Id carry{OpULessThan(U1, sum_lo, lhs_parts[0])};
+        Id sum_hi{OpIAdd(U32[1], lhs_parts[1], rhs_parts[1])};
+        sum_hi = OpIAdd(U32[1], sum_hi, bool_to_u32(carry));
+        return make_pair(sum_lo, sum_hi);
+    };
+    const auto sub_pair = [&](Id lhs, Id rhs) {
+        const auto lhs_parts{split_pair(lhs)};
+        const auto rhs_parts{split_pair(rhs)};
+        const Id borrow{OpULessThan(U1, lhs_parts[0], rhs_parts[0])};
+        const Id diff_lo{OpISub(U32[1], lhs_parts[0], rhs_parts[0])};
+        Id diff_hi{OpISub(U32[1], lhs_parts[1], rhs_parts[1])};
+        diff_hi = OpISub(U32[1], diff_hi, bool_to_u32(borrow));
+        return make_pair(diff_lo, diff_hi);
+    };
+    const auto shift_right_pair = [&](Id value, u32 shift) {
+        if (shift == 0) {
+            return value;
+        }
+        const auto parts{split_pair(value)};
+        const Id shift_id{Const(shift)};
+        const Id high_shifted{OpShiftRightLogical(U32[1], parts[1], shift_id)};
+        Id low_shifted{OpShiftRightLogical(U32[1], parts[0], shift_id)};
+        const Id carry_bits{OpShiftLeftLogical(U32[1], parts[1], Const(32u - shift))};
+        low_shifted = OpBitwiseOr(U32[1], low_shifted, carry_bits);
+        return make_pair(low_shifted, high_shifted);
+    };
+    const auto greater_equal_pair = [&](Id lhs, Id rhs) {
+        const auto lhs_parts{split_pair(lhs)};
+        const auto rhs_parts{split_pair(rhs)};
+        const Id hi_gt{OpUGreaterThan(U1, lhs_parts[1], rhs_parts[1])};
+        const Id hi_eq{OpIEqual(U1, lhs_parts[1], rhs_parts[1])};
+        const Id lo_ge{OpUGreaterThanEqual(U1, lhs_parts[0], rhs_parts[0])};
+        return OpLogicalOr(U1, hi_gt, OpLogicalAnd(U1, hi_eq, lo_ge));
+    };
+    const auto less_than_pair = [&](Id lhs, Id rhs) {
+        const auto lhs_parts{split_pair(lhs)};
+        const auto rhs_parts{split_pair(rhs)};
+        const Id hi_lt{OpULessThan(U1, lhs_parts[1], rhs_parts[1])};
+        const Id hi_eq{OpIEqual(U1, lhs_parts[1], rhs_parts[1])};
+        const Id lo_lt{OpULessThan(U1, lhs_parts[0], rhs_parts[0])};
+        return OpLogicalOr(U1, hi_lt, OpLogicalAnd(U1, hi_eq, lo_lt));
+    };
+
+    const u64 ssbo_align_mask_value{~(profile.min_ssbo_alignment - 1U)};
+    const Id ssbo_align_mask{
+        Const(static_cast<u32>(ssbo_align_mask_value & 0xFFFFFFFFu),
+              static_cast<u32>(ssbo_align_mask_value >> 32))};
+
    const auto define_body{[&](DefPtr ssbo_member, Id addr, Id element_pointer, u32 shift,
                               auto&& callback) {
        AddLabel();
@@ -953,40 +1134,44 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
            const Id ssbo_size_pointer{OpAccessChain(uniform_types.U32, cbufs[ssbo.cbuf_index].U32,
                                                     zero, ssbo_size_cbuf_offset)};

-            const u64 ssbo_align_mask{~(profile.min_ssbo_alignment - 1U)};
-            const Id unaligned_addr{OpBitcast(U64, OpLoad(U32[2], ssbo_addr_pointer))};
-            const Id ssbo_addr{OpBitwiseAnd(U64, unaligned_addr, Constant(U64, ssbo_align_mask))};
-            const Id ssbo_size{OpUConvert(U64, OpLoad(U32[1], ssbo_size_pointer))};
-            const Id ssbo_end{OpIAdd(U64, ssbo_addr, ssbo_size)};
-            const Id cond{OpLogicalAnd(U1, OpUGreaterThanEqual(U1, addr, ssbo_addr),
-                                       OpULessThan(U1, addr, ssbo_end))};
+            const Id unaligned_addr_pair{OpLoad(U32[2], ssbo_addr_pointer)};
+            const Id ssbo_addr_pair{and_pair(unaligned_addr_pair, ssbo_align_mask)};
+            const Id ssbo_size_value{OpLoad(U32[1], ssbo_size_pointer)};
+            const Id ssbo_size_pair{make_pair(ssbo_size_value, zero)};
+            const Id ssbo_end_pair{add_pair(ssbo_addr_pair, ssbo_size_pair)};
+            const Id cond{OpLogicalAnd(U1, greater_equal_pair(addr, ssbo_addr_pair),
+                                       less_than_pair(addr, ssbo_end_pair))};
            const Id then_label{OpLabel()};
            const Id else_label{OpLabel()};
            OpSelectionMerge(else_label, spv::SelectionControlMask::MaskNone);
            OpBranchConditional(cond, then_label, else_label);
            AddLabel(then_label);
            const Id ssbo_id{ssbos[index].*ssbo_member};
-            const Id ssbo_offset{OpUConvert(U32[1], OpISub(U64, addr, ssbo_addr))};
-            const Id ssbo_index{OpShiftRightLogical(U32[1], ssbo_offset, Const(shift))};
+            const Id ssbo_offset_pair{sub_pair(addr, ssbo_addr_pair)};
+            const Id ssbo_index_pair{shift_right_pair(ssbo_offset_pair, shift)};
+            const Id ssbo_index{OpCompositeExtract(U32[1], ssbo_index_pair, 0U)};
            const Id ssbo_pointer{OpAccessChain(element_pointer, ssbo_id, zero, ssbo_index)};
            callback(ssbo_pointer);
            AddLabel(else_label);
        }
    }};
+
    const auto define_load{[&](DefPtr ssbo_member, Id element_pointer, Id type, u32 shift) {
-        const Id function_type{TypeFunction(type, U64)};
+        const Id function_type{TypeFunction(type, U32[2])};
        const Id func_id{OpFunction(type, spv::FunctionControlMask::MaskNone, function_type)};
-        const Id addr{OpFunctionParameter(U64)};
+        const Id addr{OpFunctionParameter(U32[2])};
        define_body(ssbo_member, addr, element_pointer, shift,
                    [&](Id ssbo_pointer) { OpReturnValue(OpLoad(type, ssbo_pointer)); });
        OpReturnValue(ConstantNull(type));
        OpFunctionEnd();
        return func_id;
    }};
+
    const auto define_write{[&](DefPtr ssbo_member, Id element_pointer, Id type, u32 shift) {
-        const Id function_type{TypeFunction(void_id, U64, type)};
-        const Id func_id{OpFunction(void_id, spv::FunctionControlMask::MaskNone, function_type)};
-        const Id addr{OpFunctionParameter(U64)};
+        const Id function_type{TypeFunction(void_id, U32[2], type)};
+        const Id func_id{
+            OpFunction(void_id, spv::FunctionControlMask::MaskNone, function_type)};
+        const Id addr{OpFunctionParameter(U32[2])};
        const Id data{OpFunctionParameter(type)};
        define_body(ssbo_member, addr, element_pointer, shift, [&](Id ssbo_pointer) {
            OpStore(ssbo_pointer, data);
@@ -996,6 +1181,7 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
        OpFunctionEnd();
        return func_id;
    }};
+
    const auto define{
        [&](DefPtr ssbo_member, const StorageTypeDefinition& type_def, Id type, size_t size) {
            const Id element_type{type_def.element};
@@ -1004,6 +1190,7 @@ void EmitContext::DefineGlobalMemoryFunctions(const Info& info) {
            const Id write_func{define_write(ssbo_member, element_type, type, shift)};
            return std::make_pair(load_func, write_func);
        }};
+
    std::tie(load_global_func_u32, write_global_func_u32) =
        define(&StorageDefinitions::U32, storage_types.U32, U32[1], sizeof(u32));
    std::tie(load_global_func_u32x2, write_global_func_u32x2) =
@@ -1442,6 +1629,15 @@ void EmitContext::DefineInputs(const IR::Program& program) {
        subgroup_mask_le = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLeMaskKHR);
        subgroup_mask_gt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGtMaskKHR);
        subgroup_mask_ge = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGeMaskKHR);
+        
+        // Vulkan spec: Fragment shader Input variables with integer/float type must have Flat decoration
+        if (stage == Stage::Fragment) {
+            Decorate(subgroup_mask_eq, spv::Decoration::Flat);
+            Decorate(subgroup_mask_lt, spv::Decoration::Flat);
+            Decorate(subgroup_mask_le, spv::Decoration::Flat);
+            Decorate(subgroup_mask_gt, spv::Decoration::Flat);
+            Decorate(subgroup_mask_ge, spv::Decoration::Flat);
+        }
    }
    if (info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
        (profile.warp_size_potentially_larger_than_guest &&
--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.h
+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -207,6 +210,15 @@ public:
    const Profile& profile;
    const RuntimeInfo& runtime_info;
    Stage stage{};
+    const bool emulate_int64{};
+
+    bool SupportsNativeInt64() const {
+        return profile.support_int64;
+    }
+
+    bool UsesInt64Emulation() const {
+        return emulate_int64;
+    }

    Id void_id{};
    Id U1{};
--- a/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp
+++ b/src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -293,6 +296,14 @@ std::optional<LowAddrInfo> TrackLowAddress(IR::Inst* inst) {
    }
    // This address is expected to either be a PackUint2x32, a IAdd64, or a CompositeConstructU32x2
    IR::Inst* addr_inst{addr.InstRecursive()};
+    // Unwrap Identity ops introduced by lowerings (e.g., PackUint2x32 -> Identity)
+    while (addr_inst->GetOpcode() == IR::Opcode::Identity) {
+        const IR::Value id_arg{addr_inst->Arg(0)};
+        if (id_arg.IsImmediate()) {
+            return std::nullopt;
+        }
+        addr_inst = id_arg.InstRecursive();
+    }
    s32 imm_offset{0};
    if (addr_inst->GetOpcode() == IR::Opcode::IAdd64) {
        // If it's an IAdd64, get the immediate offset it is applying and grab the address
@@ -308,6 +319,14 @@ std::optional<LowAddrInfo> TrackLowAddress(IR::Inst* inst) {
            return std::nullopt;
        }
        addr_inst = iadd_addr.InstRecursive();
+        // Unwrap Identity again if present after folding IAdd64
+        while (addr_inst->GetOpcode() == IR::Opcode::Identity) {
+            const IR::Value id_arg{addr_inst->Arg(0)};
+            if (id_arg.IsImmediate()) {
+                return std::nullopt;
+            }
+            addr_inst = id_arg.InstRecursive();
+        }
    }
    // With IAdd64 handled, now PackUint2x32 is expected
    if (addr_inst->GetOpcode() == IR::Opcode::PackUint2x32) {
@@ -317,6 +336,14 @@ std::optional<LowAddrInfo> TrackLowAddress(IR::Inst* inst) {
            return std::nullopt;
        }
        addr_inst = vector.InstRecursive();
+        // Unwrap Identity that may replace PackUint2x32
+        while (addr_inst->GetOpcode() == IR::Opcode::Identity) {
+            const IR::Value id_arg{addr_inst->Arg(0)};
+            if (id_arg.IsImmediate()) {
+                return std::nullopt;
+            }
+            addr_inst = id_arg.InstRecursive();
+        }
    }
    // The vector is expected to be a CompositeConstructU32x2
    if (addr_inst->GetOpcode() != IR::Opcode::CompositeConstructU32x2) {
--- a/src/shader_recompiler/profile.h
+++ b/src/shader_recompiler/profile.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -25,6 +28,14 @@ struct Profile {
    bool support_fp16_signed_zero_nan_preserve{};
    bool support_fp32_signed_zero_nan_preserve{};
    bool support_fp64_signed_zero_nan_preserve{};
+    
+    // User-forced float behavior overrides (Android Eden Veil/Extensions)
+    // When shader_float_controls_force_enable is true, these override shader-declared behavior
+    bool force_fp32_denorm_flush{};           // Force FTZ for all FP32 ops
+    bool force_fp32_denorm_preserve{};        // Force denorm preservation for all FP32 ops
+    bool force_fp32_rte_rounding{};           // Force Round-To-Even for all FP32 ops
+    bool force_fp32_signed_zero_inf_nan{};    // Force signed zero/inf/nan preservation
+    
    bool support_explicit_workgroup_layout{};
    bool support_vote{};
    bool support_viewport_index_layer_non_geometry{};
@@ -38,6 +49,9 @@ struct Profile {
    bool support_gl_nv_gpu_shader_5{};
    bool support_gl_amd_gpu_shader_half_float{};
    bool support_gl_texture_shadow_lod{};
+    bool support_gl_shader_atomic_float{};
+    bool support_gl_shader_atomic_fp16_vector{};
+    bool support_gl_shader_atomic_int64{};
    bool support_gl_warp_intrinsics{};
    bool support_gl_variable_aoffi{};
    bool support_gl_sparse_textures{};
@@ -81,6 +95,8 @@ struct Profile {
    bool ignore_nan_fp_comparisons{};
    /// Some drivers have broken support for OpVectorExtractDynamic on subgroup mask inputs
    bool has_broken_spirv_subgroup_mask_vector_extract_dynamic{};
+    /// Mobile GPUs lack Sampled1D capability - need to emulate 1D textures as 2D with height=1
+    bool needs_1d_texture_emulation{};

    u32 gl_max_compute_smem_size{};

--- a/src/shader_recompiler/shader_info.h
+++ b/src/shader_recompiler/shader_info.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -130,7 +133,7 @@ enum class TexturePixelFormat {
    ASTC_2D_8X6_SRGB,
    ASTC_2D_6X5_UNORM,
    ASTC_2D_6X5_SRGB,
-    E5B9G9R9_FLOAT,
+
    D32_FLOAT,
    D16_UNORM,
    X8_D24_UNORM,
--- a/src/video_core/compatible_formats.cpp
+++ b/src/video_core/compatible_formats.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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

@@ -42,7 +45,7 @@ constexpr std::array VIEW_CLASS_32_BITS{
    PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT,     PixelFormat::R32_UINT,
    PixelFormat::R16G16_SINT,       PixelFormat::R32_SINT,        PixelFormat::A8B8G8R8_UNORM,
    PixelFormat::R16G16_UNORM,      PixelFormat::A8B8G8R8_SNORM,  PixelFormat::R16G16_SNORM,
-    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::E5B9G9R9_FLOAT,  PixelFormat::B8G8R8A8_UNORM,
+    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::B8G8R8A8_UNORM,
    PixelFormat::B8G8R8A8_SRGB,     PixelFormat::A8B8G8R8_UINT,   PixelFormat::A8B8G8R8_SINT,
    PixelFormat::A2B10G10R10_UINT,
 };
@@ -52,7 +55,7 @@ constexpr std::array VIEW_CLASS_32_BITS_NO_BGR{
    PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT,      PixelFormat::R32_UINT,
    PixelFormat::R16G16_SINT,       PixelFormat::R32_SINT,         PixelFormat::A8B8G8R8_UNORM,
    PixelFormat::R16G16_UNORM,      PixelFormat::A8B8G8R8_SNORM,   PixelFormat::R16G16_SNORM,
-    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::E5B9G9R9_FLOAT,   PixelFormat::A8B8G8R8_UINT,
+    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::A8B8G8R8_UINT,
    PixelFormat::A8B8G8R8_SINT,     PixelFormat::A2B10G10R10_UINT,
 };

--- a/src/video_core/host_shaders/CMakeLists.txt
+++ b/src/video_core/host_shaders/CMakeLists.txt
@@ -76,6 +76,7 @@ set(SHADER_FILES
    vulkan_quad_indexed.comp
    vulkan_turbo_mode.comp
    vulkan_uint8.comp
+    vulkan_qcom_msaa_resolve.frag
    convert_rgba8_to_bgra8.frag
    convert_yuv420_to_rgb.comp
    convert_rgb_to_yuv420.comp
--- a/src/video_core/host_shaders/vulkan_qcom_msaa_resolve.frag
+++ b/src/video_core/host_shaders/vulkan_qcom_msaa_resolve.frag
@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#version 450
+
+// VK_QCOM_render_pass_shader_resolve fragment shader
+// Resolves MSAA attachment to single-sample within render pass
+// Requires VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM in subpass flags
+
+// Use combined image sampler for MSAA texture instead of input attachment
+// This allows us to sample MSAA textures from previous rendering
+layout(set = 0, binding = 0) uniform sampler2DMS msaa_texture;
+
+layout(location = 0) out vec4 color_output;
+
+layout(push_constant) uniform PushConstants {
+    vec2 tex_scale;
+    vec2 tex_offset;
+} push_constants;
+
+// Custom MSAA resolve using box filter (simple average)
+// Assumes 4x MSAA (can be extended with push constant for dynamic sample count)
+void main() {
+    ivec2 coord = ivec2(gl_FragCoord.xy);
+    ivec2 tex_size = textureSize(msaa_texture);
+    
+    // Clamp coordinates to texture bounds
+    coord = clamp(coord, ivec2(0), tex_size - ivec2(1));
+    
+    vec4 accumulated_color = vec4(0.0);
+    int sample_count = 4; // Adreno typically uses 4x MSAA max
+    
+    // Box filter: simple average of all MSAA samples
+    for (int i = 0; i < sample_count; i++) {
+        accumulated_color += texelFetch(msaa_texture, coord, i);
+    }
+    
+    color_output = accumulated_color / float(sample_count);
+}
--- a/src/video_core/renderer_opengl/gl_device.cpp
+++ b/src/video_core/renderer_opengl/gl_device.cpp
@@ -225,6 +225,9 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
    has_amd_shader_half_float = GLAD_GL_AMD_gpu_shader_half_float;
    has_sparse_texture_2 = GLAD_GL_ARB_sparse_texture2;
    has_draw_texture = GLAD_GL_NV_draw_texture;
+    has_shader_atomic_float = GLAD_GL_NV_shader_atomic_float;
+    has_shader_atomic_fp16_vector = GLAD_GL_NV_shader_atomic_fp16_vector;
+    has_shader_atomic_int64 = GLAD_GL_NV_shader_atomic_int64;
    warp_size_potentially_larger_than_guest = !is_nvidia && !is_intel;
    need_fastmath_off = is_nvidia;
    can_report_memory = GLAD_GL_NVX_gpu_memory_info;
--- a/src/video_core/renderer_opengl/gl_device.h
+++ b/src/video_core/renderer_opengl/gl_device.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -152,6 +155,18 @@ public:
        return has_draw_texture;
    }

+    bool HasShaderAtomicFloat() const {
+        return has_shader_atomic_float;
+    }
+
+    bool HasShaderAtomicFp16Vector() const {
+        return has_shader_atomic_fp16_vector;
+    }
+
+    bool HasShaderAtomicInt64() const {
+        return has_shader_atomic_int64;
+    }
+
    bool IsWarpSizePotentiallyLargerThanGuest() const {
        return warp_size_potentially_larger_than_guest;
    }
@@ -235,6 +250,9 @@ private:
    bool has_amd_shader_half_float{};
    bool has_sparse_texture_2{};
    bool has_draw_texture{};
+    bool has_shader_atomic_float{};
+    bool has_shader_atomic_fp16_vector{};
+    bool has_shader_atomic_int64{};
    bool warp_size_potentially_larger_than_guest{};
    bool need_fastmath_off{};
    bool has_cbuf_ftou_bug{};
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -215,6 +215,9 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
          .support_gl_nv_gpu_shader_5 = device.HasNvGpuShader5(),
          .support_gl_amd_gpu_shader_half_float = device.HasAmdShaderHalfFloat(),
          .support_gl_texture_shadow_lod = device.HasTextureShadowLod(),
+          .support_gl_shader_atomic_float = device.HasShaderAtomicFloat(),
+          .support_gl_shader_atomic_fp16_vector = device.HasShaderAtomicFp16Vector(),
+          .support_gl_shader_atomic_int64 = device.HasShaderAtomicInt64(),
          .support_gl_warp_intrinsics = false,
          .support_gl_variable_aoffi = device.HasVariableAoffi(),
          .support_gl_sparse_textures = device.HasSparseTexture2(),
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -97,6 +100,10 @@ public:
        return true;
    }

+    bool CanDownloadMSAA() const noexcept {
+        return true;
+    }
+
    void CopyImage(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);

    void CopyImageMSAA(Image& dst, Image& src, std::span<const VideoCommon::ImageCopy> copies);
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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

@@ -113,7 +116,6 @@ constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> FORMAT_TAB
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR},                        // ASTC_2D_8X6_SRGB
    {GL_COMPRESSED_RGBA_ASTC_6x5_KHR},                                // ASTC_2D_6X5_UNORM
    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR},                        // ASTC_2D_6X5_SRGB
-    {GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV},                // E5B9G9R9_FLOAT
    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT},            // D32_FLOAT
    {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT},    // D16_UNORM
    {GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT_24_8}, // X8_D24_UNORM
--- a/src/video_core/renderer_vulkan/blit_image.cpp
+++ b/src/video_core/renderer_vulkan/blit_image.cpp
@@ -40,6 +40,7 @@
 #include "video_core/host_shaders/convert_rgba16f_to_rgba8_frag_spv.h"
 #include "video_core/host_shaders/dither_temporal_frag_spv.h"
 #include "video_core/host_shaders/dynamic_resolution_scale_comp_spv.h"
+#include "video_core/host_shaders/vulkan_qcom_msaa_resolve_frag_spv.h"

 namespace Vulkan {

@@ -545,6 +546,7 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
      convert_rgba16f_to_rgba8_frag(BuildShader(device, CONVERT_RGBA16F_TO_RGBA8_FRAG_SPV)),
      dither_temporal_frag(BuildShader(device, DITHER_TEMPORAL_FRAG_SPV)),
      dynamic_resolution_scale_comp(BuildShader(device, DYNAMIC_RESOLUTION_SCALE_COMP_SPV)),
+      qcom_msaa_resolve_frag(BuildShader(device, VULKAN_QCOM_MSAA_RESOLVE_FRAG_SPV)),
      linear_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_LINEAR>)),
      nearest_sampler(device.GetLogical().CreateSampler(SAMPLER_CREATE_INFO<VK_FILTER_NEAREST>)) {}

@@ -1240,4 +1242,30 @@ void BlitImageHelper::ApplyDynamicResolutionScale(const Framebuffer* dst_framebu
    Convert(*dynamic_resolution_scale_pipeline, dst_framebuffer, src_image_view);
 }

+void BlitImageHelper::ResolveMSAAQcom(const Framebuffer* dst_framebuffer,
+                                      const ImageView& src_image_view) {
+    // VK_QCOM_render_pass_shader_resolve implementation
+    // This must be used within a render pass with VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM
+    ConvertPipeline(qcom_msaa_resolve_pipeline,
+                    dst_framebuffer->RenderPass(),
+                    false);
+    
+    RecordShaderReadBarrier(scheduler, src_image_view);
+    scheduler.RequestRenderpass(dst_framebuffer);
+    
+    const VkImageView src_view = src_image_view.Handle(Shader::TextureType::Color2D);
+    const VkPipelineLayout layout = *one_texture_pipeline_layout;
+    const VkPipeline pipeline = *qcom_msaa_resolve_pipeline;
+    
+    scheduler.Record([this, src_view, layout, pipeline](vk::CommandBuffer cmdbuf) {
+        const VkDescriptorSet descriptor_set = one_texture_descriptor_allocator.Commit();
+        UpdateOneTextureDescriptorSet(device, descriptor_set, *nearest_sampler, src_view);
+        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, descriptor_set, nullptr);
+        cmdbuf.Draw(3, 1, 0, 0);
+    });
+    
+    scheduler.InvalidateState();
+}
+
 } // namespace Vulkan
--- a/src/video_core/renderer_vulkan/blit_image.h
+++ b/src/video_core/renderer_vulkan/blit_image.h
@@ -95,6 +95,8 @@ public:
    void ConvertRGBA16FtoRGBA8(const Framebuffer* dst_framebuffer, const ImageView& src_image_view);
    void ApplyDitherTemporal(const Framebuffer* dst_framebuffer, const ImageView& src_image_view);
    void ApplyDynamicResolutionScale(const Framebuffer* dst_framebuffer, const ImageView& src_image_view);
+    
+    void ResolveMSAAQcom(const Framebuffer* dst_framebuffer, const ImageView& src_image_view);

 private:
    void Convert(VkPipeline pipeline, const Framebuffer* dst_framebuffer,
@@ -159,6 +161,7 @@ private:
    vk::ShaderModule convert_rgba16f_to_rgba8_frag;
    vk::ShaderModule dither_temporal_frag;
    vk::ShaderModule dynamic_resolution_scale_comp;
+    vk::ShaderModule qcom_msaa_resolve_frag;
    vk::Sampler linear_sampler;
    vk::Sampler nearest_sampler;

@@ -188,6 +191,7 @@ private:
    vk::Pipeline convert_rgba16f_to_rgba8_pipeline;
    vk::Pipeline dither_temporal_pipeline;
    vk::Pipeline dynamic_resolution_scale_pipeline;
+    vk::Pipeline qcom_msaa_resolve_pipeline;
 };

 } // namespace Vulkan
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
@@ -58,12 +58,42 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
    const auto topology_ = maxwell3d.draw_manager->GetDrawState().topology;

    raw1 = 0;
-    extended_dynamic_state.Assign(features.has_extended_dynamic_state ? 1 : 0);
-    extended_dynamic_state_2.Assign(features.has_extended_dynamic_state_2 ? 1 : 0);
-    extended_dynamic_state_2_extra.Assign(features.has_extended_dynamic_state_2_extra ? 1 : 0);
-    extended_dynamic_state_3_blend.Assign(features.has_extended_dynamic_state_3_blend ? 1 : 0);
-    extended_dynamic_state_3_enables.Assign(features.has_extended_dynamic_state_3_enables ? 1 : 0);
-    dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
+    raw1_eds3_extended = 0;
+    pad_align_u64 = 0;
+    
+    // EDS1
+    extended_dynamic_state.Assign(features.has_extended_dynamic_state);
+    
+    // EDS2
+    extended_dynamic_state_2.Assign(features.has_extended_dynamic_state_2);
+    extended_dynamic_state_2_logic_op.Assign(features.has_extended_dynamic_state_2_logic_op);
+    extended_dynamic_state_2_patch_control_points.Assign(features.has_extended_dynamic_state_2_patch_control_points);
+    
+    // EDS3 - Blending/Enables
+    extended_dynamic_state_3_blend.Assign(features.has_extended_dynamic_state_3_blend);
+    extended_dynamic_state_3_enables.Assign(features.has_extended_dynamic_state_3_enables);
+    
+    // EDS3 - Granular features
+    extended_dynamic_state_3_depth_clamp.Assign(features.has_extended_dynamic_state_3_depth_clamp);
+    extended_dynamic_state_3_logic_op_enable.Assign(features.has_extended_dynamic_state_3_logic_op_enable);
+    extended_dynamic_state_3_tessellation_domain_origin.Assign(features.has_extended_dynamic_state_3_tessellation_domain_origin);
+    extended_dynamic_state_3_polygon_mode.Assign(features.has_extended_dynamic_state_3_polygon_mode);
+    extended_dynamic_state_3_rasterization_samples.Assign(features.has_extended_dynamic_state_3_rasterization_samples);
+    extended_dynamic_state_3_sample_mask.Assign(features.has_extended_dynamic_state_3_sample_mask);
+    extended_dynamic_state_3_alpha_to_coverage_enable.Assign(features.has_extended_dynamic_state_3_alpha_to_coverage_enable);
+    extended_dynamic_state_3_alpha_to_one_enable.Assign(features.has_extended_dynamic_state_3_alpha_to_one_enable);
+    extended_dynamic_state_3_depth_clip_enable.Assign(features.has_extended_dynamic_state_3_depth_clip_enable);
+    extended_dynamic_state_3_depth_clip_negative_one_to_one.Assign(features.has_extended_dynamic_state_3_depth_clip_negative_one_to_one);
+    extended_dynamic_state_3_line_rasterization_mode.Assign(features.has_extended_dynamic_state_3_line_rasterization_mode);
+    extended_dynamic_state_3_line_stipple_enable.Assign(features.has_extended_dynamic_state_3_line_stipple_enable);
+    extended_dynamic_state_3_provoking_vertex_mode.Assign(features.has_extended_dynamic_state_3_provoking_vertex_mode);
+    extended_dynamic_state_3_conservative_rasterization_mode.Assign(features.has_extended_dynamic_state_3_conservative_rasterization_mode);
+    extended_dynamic_state_3_sample_locations_enable.Assign(features.has_extended_dynamic_state_3_sample_locations_enable);
+    extended_dynamic_state_3_rasterization_stream.Assign(features.has_extended_dynamic_state_3_rasterization_stream);
+    
+    // Vertex Input
+    dynamic_vertex_input.Assign(features.has_dynamic_vertex_input);
+    
    xfb_enabled.Assign(regs.transform_feedback_enabled != 0);
    ndc_minus_one_to_one.Assign(regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1 : 0);
    polygon_mode.Assign(PackPolygonMode(VideoCore::EffectivePolygonMode(regs)));
@@ -158,7 +188,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
            return static_cast<u16>(array.stride.Value());
        });
    }
-    if (!extended_dynamic_state_2_extra) {
+    if (!extended_dynamic_state_2_logic_op) {
        dynamic_state.Refresh2(regs, topology_, extended_dynamic_state_2);
    }
    if (!extended_dynamic_state_3_blend) {
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.h
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -18,13 +21,45 @@ namespace Vulkan {
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;

 struct DynamicFeatures {
-    bool has_extended_dynamic_state;
-    bool has_extended_dynamic_state_2;
-    bool has_extended_dynamic_state_2_extra;
-    bool has_extended_dynamic_state_3_blend;
-    bool has_extended_dynamic_state_3_enables;
-    bool has_dynamic_vertex_input;
+    union {
+        u32 raw0;
+        // VK_EXT_extended_dynamic_state (EDS1) - Bit 0
+        BitField<0, 1, u32> has_extended_dynamic_state;
+        
+        // VK_EXT_extended_dynamic_state2 (EDS2) - Bits 1-3
+        BitField<1, 1, u32> has_extended_dynamic_state_2;              // Core EDS2
+        BitField<2, 1, u32> has_extended_dynamic_state_2_logic_op;     // LogicOp
+        BitField<3, 1, u32> has_extended_dynamic_state_2_patch_control_points; // Tessellation
+        
+        // VK_EXT_extended_dynamic_state3 (EDS3) - Bits 4-5
+        BitField<4, 1, u32> has_extended_dynamic_state_3_blend;        // Blending composite
+        BitField<5, 1, u32> has_extended_dynamic_state_3_enables;      // Enables composite
+        
+        // VK_EXT_vertex_input_dynamic_state - Bit 6
+        BitField<6, 1, u32> has_dynamic_vertex_input;
+        
+        // EDS3 Granular Features - Bits 7-15
+        BitField<7, 1, u32> has_extended_dynamic_state_3_depth_clamp;
+        BitField<8, 1, u32> has_extended_dynamic_state_3_logic_op_enable;
+        BitField<9, 1, u32> has_extended_dynamic_state_3_tessellation_domain_origin;
+        BitField<10, 1, u32> has_extended_dynamic_state_3_polygon_mode;
+        BitField<11, 1, u32> has_extended_dynamic_state_3_rasterization_samples;
+        BitField<12, 1, u32> has_extended_dynamic_state_3_sample_mask;
+        BitField<13, 1, u32> has_extended_dynamic_state_3_alpha_to_coverage_enable;
+        BitField<14, 1, u32> has_extended_dynamic_state_3_alpha_to_one_enable;
+        BitField<15, 1, u32> has_extended_dynamic_state_3_depth_clip_enable;
+        
+        // EDS3 Additional Features - Bits 16-22
+        BitField<16, 1, u32> has_extended_dynamic_state_3_depth_clip_negative_one_to_one;
+        BitField<17, 1, u32> has_extended_dynamic_state_3_line_rasterization_mode;
+        BitField<18, 1, u32> has_extended_dynamic_state_3_line_stipple_enable;
+        BitField<19, 1, u32> has_extended_dynamic_state_3_provoking_vertex_mode;
+        BitField<20, 1, u32> has_extended_dynamic_state_3_conservative_rasterization_mode;
+        BitField<21, 1, u32> has_extended_dynamic_state_3_sample_locations_enable;
+        BitField<22, 1, u32> has_extended_dynamic_state_3_rasterization_stream;
+    };
 };
+static_assert(std::has_unique_object_representations_v<DynamicFeatures>);

 struct FixedPipelineState {
    static u32 PackComparisonOp(Maxwell::ComparisonOp op) noexcept;
@@ -184,23 +219,56 @@ struct FixedPipelineState {

    union {
        u32 raw1;
+        // EDS1 - Bit 0
        BitField<0, 1, u32> extended_dynamic_state;
+        
+        // EDS2 - Bits 1-3
        BitField<1, 1, u32> extended_dynamic_state_2;
-        BitField<2, 1, u32> extended_dynamic_state_2_extra;
-        BitField<3, 1, u32> extended_dynamic_state_3_blend;
-        BitField<4, 1, u32> extended_dynamic_state_3_enables;
-        BitField<5, 1, u32> dynamic_vertex_input;
-        BitField<6, 1, u32> xfb_enabled;
-        BitField<7, 1, u32> ndc_minus_one_to_one;
-        BitField<8, 2, u32> polygon_mode;
-        BitField<10, 2, u32> tessellation_primitive;
-        BitField<12, 2, u32> tessellation_spacing;
-        BitField<14, 1, u32> tessellation_clockwise;
-        BitField<15, 5, u32> patch_control_points_minus_one;
+        BitField<2, 1, u32> extended_dynamic_state_2_logic_op;
+        BitField<3, 1, u32> extended_dynamic_state_2_patch_control_points;
+        
+        // EDS3 Blending/Enables - Bits 4-5
+        BitField<4, 1, u32> extended_dynamic_state_3_blend;
+        BitField<5, 1, u32> extended_dynamic_state_3_enables;
+        
+        // Vertex Input - Bit 6
+        BitField<6, 1, u32> dynamic_vertex_input;
+        
+        // Other state - Bits 7-19
+        BitField<7, 1, u32> xfb_enabled;
+        BitField<8, 1, u32> ndc_minus_one_to_one;
+        BitField<9, 2, u32> polygon_mode;
+        BitField<11, 2, u32> tessellation_primitive;
+        BitField<13, 2, u32> tessellation_spacing;
+        BitField<15, 1, u32> tessellation_clockwise;
+        BitField<16, 5, u32> patch_control_points_minus_one;

+        // Topology and MSAA - Bits 24-31
        BitField<24, 4, Maxwell::PrimitiveTopology> topology;
        BitField<28, 4, Tegra::Texture::MsaaMode> msaa_mode;
    };
+    
+    union {
+        u32 raw1_eds3_extended;
+        // EDS3 Additional Features - Bits 0-15
+        BitField<0, 1, u32> extended_dynamic_state_3_depth_clamp;
+        BitField<1, 1, u32> extended_dynamic_state_3_logic_op_enable;
+        BitField<2, 1, u32> extended_dynamic_state_3_tessellation_domain_origin;
+        BitField<3, 1, u32> extended_dynamic_state_3_polygon_mode;
+        BitField<4, 1, u32> extended_dynamic_state_3_rasterization_samples;
+        BitField<5, 1, u32> extended_dynamic_state_3_sample_mask;
+        BitField<6, 1, u32> extended_dynamic_state_3_alpha_to_coverage_enable;
+        BitField<7, 1, u32> extended_dynamic_state_3_alpha_to_one_enable;
+        BitField<8, 1, u32> extended_dynamic_state_3_depth_clip_enable;
+        BitField<9, 1, u32> extended_dynamic_state_3_depth_clip_negative_one_to_one;
+        BitField<10, 1, u32> extended_dynamic_state_3_line_rasterization_mode;
+        BitField<11, 1, u32> extended_dynamic_state_3_line_stipple_enable;
+        BitField<12, 1, u32> extended_dynamic_state_3_provoking_vertex_mode;
+        BitField<13, 1, u32> extended_dynamic_state_3_conservative_rasterization_mode;
+        BitField<14, 1, u32> extended_dynamic_state_3_sample_locations_enable;
+        BitField<15, 1, u32> extended_dynamic_state_3_rasterization_stream;
+    };
+    
    union {
        u32 raw2;
        BitField<1, 3, u32> alpha_test_func;
@@ -215,12 +283,15 @@ struct FixedPipelineState {
        BitField<16, 1, u32> alpha_to_one_enabled;
        BitField<17, 3, Tegra::Engines::Maxwell3D::EngineHint> app_stage;
    };
-    std::array<u8, Maxwell::NumRenderTargets> color_formats;
-
+    
    u32 alpha_test_ref;
    u32 point_size;
-
+    
+    std::array<u8, Maxwell::NumRenderTargets> color_formats;
    std::array<u16, Maxwell::NumViewports> viewport_swizzles;
+    
+    u32 pad_align_u64;
+    
    union {
        u64 attribute_types; // Used with VK_EXT_vertex_input_dynamic_state
        u64 enabled_divisors;
--- a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
+++ b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
@@ -214,7 +214,6 @@ struct FormatTuple {
    {VK_FORMAT_ASTC_8x6_SRGB_BLOCK},                           // ASTC_2D_8X6_SRGB
    {VK_FORMAT_ASTC_6x5_UNORM_BLOCK},                          // ASTC_2D_6X5_UNORM
    {VK_FORMAT_ASTC_6x5_SRGB_BLOCK},                           // ASTC_2D_6X5_SRGB
-    {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32},                        // E5B9G9R9_FLOAT

    // Depth formats
    {VK_FORMAT_D32_SFLOAT, Attachable},          // D32_FLOAT
--- a/src/video_core/renderer_vulkan/pipeline_helper.h
+++ b/src/video_core/renderer_vulkan/pipeline_helper.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -24,8 +27,13 @@ public:
    DescriptorLayoutBuilder(const Device& device_) : device{&device_} {}

    bool CanUsePushDescriptor() const noexcept {
-        return device->IsKhrPushDescriptorSupported() &&
-               num_descriptors <= device->MaxPushDescriptors();
+        if (!device->IsKhrPushDescriptorSupported()) {
+            return false;
+        }
+        if (num_descriptors > device->MaxPushDescriptors()) {
+            return false;
+        }
+        return true;
    }

    // TODO(crueter): utilize layout binding flags
--- a/src/video_core/renderer_vulkan/present/util.cpp
+++ b/src/video_core/renderer_vulkan/present/util.cpp
@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include "common/assert.h"
-#include <ranges>
 #include "video_core/renderer_vulkan/present/util.h"

 namespace Vulkan {
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -837,13 +837,38 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
        .pAttachments = cb_attachments.data(),
        .blendConstants = {}
    };
-    static_vector<VkDynamicState, 34> dynamic_states{
-        VK_DYNAMIC_STATE_VIEWPORT,           VK_DYNAMIC_STATE_SCISSOR,
-        VK_DYNAMIC_STATE_DEPTH_BIAS,         VK_DYNAMIC_STATE_BLEND_CONSTANTS,
-        VK_DYNAMIC_STATE_DEPTH_BOUNDS,       VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-        VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-        VK_DYNAMIC_STATE_LINE_WIDTH,
-    };
+    // Base Vulkan Dynamic States - Always active (independent of EDS)
+    // Granular fallback: Each state added only if device supports it (protection against broken drivers)
+    static_vector<VkDynamicState, 34> dynamic_states;
+    if (device.SupportsDynamicViewport()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_VIEWPORT);
+    }
+    if (device.SupportsDynamicScissor()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_SCISSOR);
+    }
+    if (device.SupportsDynamicLineWidth()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_LINE_WIDTH);
+    }
+    if (device.SupportsDynamicDepthBias()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_DEPTH_BIAS);
+    }
+    if (device.SupportsDynamicBlendConstants()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_BLEND_CONSTANTS);
+    }
+    if (device.SupportsDynamicDepthBounds()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_DEPTH_BOUNDS);
+    }
+    if (device.SupportsDynamicStencilCompareMask()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK);
+    }
+    if (device.SupportsDynamicStencilWriteMask()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK);
+    }
+    if (device.SupportsDynamicStencilReference()) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_STENCIL_REFERENCE);
+    }
+
+    // EDS1 - Extended Dynamic State (12 states)
    if (key.state.extended_dynamic_state) {
        static constexpr std::array extended{
            VK_DYNAMIC_STATE_CULL_MODE_EXT,
@@ -856,49 +881,59 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
            VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
            VK_DYNAMIC_STATE_STENCIL_OP_EXT,
        };
-        if (key.state.dynamic_vertex_input) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
-        }
        dynamic_states.insert(dynamic_states.end(), extended.begin(), extended.end());
-        if (key.state.extended_dynamic_state_2) {
-            static constexpr std::array extended2{
-                VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
-                VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
-                VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended2.begin(), extended2.end());
-        }
-        if (key.state.extended_dynamic_state_2_extra) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_EXT);
-        }
-        if (key.state.extended_dynamic_state_3_blend) {
-            static constexpr std::array extended3{
-                VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
-                VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
-                VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
+    }

-                // VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
-        }
-        if (key.state.extended_dynamic_state_3_enables) {
-            static constexpr std::array extended3{
-                VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT,
-                VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT,
+    // Vertex Input Dynamic State (independent toggle)
+    if (key.state.dynamic_vertex_input) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
+    }

-                // additional state3 extensions
-                VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT,
+    // EDS2 - Extended Dynamic State 2 Core (3 states)
+    if (key.state.extended_dynamic_state_2) {
+        static constexpr std::array extended2{
+            VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
+            VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
+            VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
+        };
+        dynamic_states.insert(dynamic_states.end(), extended2.begin(), extended2.end());
+    }

-                VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT,
+    // EDS2 - Logic Op (granular feature)
+    if (key.state.extended_dynamic_state_2_logic_op) {
+        dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_EXT);
+    }

-                VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT,
-                VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT,
-                VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT,
-            };
-            dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
-        }
+    // EDS3 - Blending (composite: ColorBlendEnable + Equation + WriteMask)
+    if (key.state.extended_dynamic_state_3_blend) {
+        static constexpr std::array extended3{
+            VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
+            VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
+            VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
+
+            // VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT,
+        };
+        dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
+    }
+
+    // EDS3 - Enables (granular: DepthClamp + LogicOpEnable + ...)
+    if (key.state.extended_dynamic_state_3_enables) {
+        static constexpr std::array extended3{
+            VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT,
+            VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT,
+
+            // additional state3 extensions
+            VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT,
+
+            VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT,
+
+            VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT,
+            VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT,
+            VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT,
+            VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT,
+            VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT,
+        };
+        dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
    }

    const VkPipelineDynamicStateCreateInfo dynamic_state_ci{
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -341,6 +341,17 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
            float_control.shaderSignedZeroInfNanPreserveFloat32 != VK_FALSE,
        .support_fp64_signed_zero_nan_preserve =
            float_control.shaderSignedZeroInfNanPreserveFloat64 != VK_FALSE,
+        
+        // Switch/Maxwell native float behavior - ONLY for Turnip Mesa (Stock Qualcomm broken)
+        // Stock Adreno drivers have broken float controls disabled in vulkan_device.cpp
+        .force_fp32_denorm_flush = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY && 
+                                   device.IsKhrShaderFloatControlsSupported(),  // false on Stock, true on Turnip
+        .force_fp32_denorm_preserve = false,  // FTZ dominates
+        .force_fp32_rte_rounding = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY && 
+                                   device.IsKhrShaderFloatControlsSupported(),  // false on Stock, true on Turnip
+        .force_fp32_signed_zero_inf_nan = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY && 
+                                          device.IsKhrShaderFloatControlsSupported(),  // false on Stock, true on Turnip
+        
        .support_explicit_workgroup_layout = device.IsKhrWorkgroupMemoryExplicitLayoutSupported(),
        .support_vote = device.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_VOTE_BIT),
        .support_viewport_index_layer_non_geometry =
@@ -371,10 +382,17 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .has_broken_spirv_position_input = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
        .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_fp16_float_controls = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY ||
+                                          driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
        .ignore_nan_fp_comparisons = false,
        .has_broken_spirv_subgroup_mask_vector_extract_dynamic =
            driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
+        .needs_1d_texture_emulation = 
+            driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+            driver_id == VK_DRIVER_ID_MESA_TURNIP ||
+            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY ||
+            driver_id == VK_DRIVER_ID_BROADCOM_PROPRIETARY ||
+            driver_id == VK_DRIVER_ID_IMAGINATION_PROPRIETARY,
        .has_broken_robust =
            device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
        .min_ssbo_alignment = device.GetStorageBufferAlignment(),
@@ -408,14 +426,39 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,

    LOG_INFO(Render_Vulkan, "DynamicState value is set to {}", (u32) dynamic_state);

-    dynamic_features = DynamicFeatures{
-        .has_extended_dynamic_state = device.IsExtExtendedDynamicStateSupported() && dynamic_state > 0,
-        .has_extended_dynamic_state_2 = device.IsExtExtendedDynamicState2Supported() && dynamic_state > 1,
-        .has_extended_dynamic_state_2_extra = device.IsExtExtendedDynamicState2ExtrasSupported() && dynamic_state > 1,
-        .has_extended_dynamic_state_3_blend = device.IsExtExtendedDynamicState3BlendingSupported() && dynamic_state > 2,
-        .has_extended_dynamic_state_3_enables = device.IsExtExtendedDynamicState3EnablesSupported() && dynamic_state > 2,
-        .has_dynamic_vertex_input = device.IsExtVertexInputDynamicStateSupported() && dynamic_state > 2,
-    };
+    dynamic_features.raw0 = 0;
+    
+    // EDS1 - All-or-nothing (enabled if driver supports AND setting > 0)
+    dynamic_features.has_extended_dynamic_state.Assign(device.IsExtExtendedDynamicStateSupported() && dynamic_state > 0);
+    
+    // EDS2 - Core features (enabled if driver supports AND setting > 1)
+    dynamic_features.has_extended_dynamic_state_2.Assign(device.IsExtExtendedDynamicState2Supported() && dynamic_state > 1);
+    dynamic_features.has_extended_dynamic_state_2_logic_op.Assign(device.IsExtExtendedDynamicState2LogicOpSupported() && dynamic_state > 1);
+    dynamic_features.has_extended_dynamic_state_2_patch_control_points.Assign(device.IsExtExtendedDynamicState2PatchControlPointsSupported() && dynamic_state > 1);
+    
+    // EDS3 - Granular features (enabled if driver supports AND setting > 2)
+    dynamic_features.has_extended_dynamic_state_3_blend.Assign(device.IsExtExtendedDynamicState3BlendingSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_enables.Assign(device.IsExtExtendedDynamicState3EnablesSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_depth_clamp.Assign(device.IsExtExtendedDynamicState3DepthClampEnableSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_logic_op_enable.Assign(device.IsExtExtendedDynamicState3LogicOpEnableSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_tessellation_domain_origin.Assign(device.IsExtExtendedDynamicState3TessellationDomainOriginSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_polygon_mode.Assign(device.IsExtExtendedDynamicState3PolygonModeSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_rasterization_samples.Assign(device.IsExtExtendedDynamicState3RasterizationSamplesSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_sample_mask.Assign(device.IsExtExtendedDynamicState3SampleMaskSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_alpha_to_coverage_enable.Assign(device.IsExtExtendedDynamicState3AlphaToCoverageEnableSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_alpha_to_one_enable.Assign(device.IsExtExtendedDynamicState3AlphaToOneEnableSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_depth_clip_enable.Assign(device.IsExtExtendedDynamicState3DepthClipEnableSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_depth_clip_negative_one_to_one.Assign(device.IsExtExtendedDynamicState3DepthClipNegativeOneToOneSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_line_rasterization_mode.Assign(device.IsExtExtendedDynamicState3LineRasterizationModeSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_line_stipple_enable.Assign(device.IsExtExtendedDynamicState3LineStippleEnableSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_provoking_vertex_mode.Assign(device.IsExtExtendedDynamicState3ProvokingVertexModeSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_conservative_rasterization_mode.Assign(device.IsExtExtendedDynamicState3ConservativeRasterizationModeSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_sample_locations_enable.Assign(device.IsExtExtendedDynamicState3SampleLocationsEnableSupported() && dynamic_state > 2);
+    dynamic_features.has_extended_dynamic_state_3_rasterization_stream.Assign(device.IsExtExtendedDynamicState3RasterizationStreamSupported() && dynamic_state > 2);
+    
+    // Vertex input dynamic state (independent toggle)
+    dynamic_features.has_dynamic_vertex_input.Assign(device.IsExtVertexInputDynamicStateSupported() && 
+                                                     Settings::values.vertex_input_dynamic_state.GetValue());
 }

 PipelineCache::~PipelineCache() {
@@ -516,16 +559,29 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
        GraphicsPipelineCacheKey key;
        file.read(reinterpret_cast<char*>(&key), sizeof(key));

-        if ((key.state.extended_dynamic_state != 0) !=
-                dynamic_features.has_extended_dynamic_state ||
-            (key.state.extended_dynamic_state_2 != 0) !=
-                dynamic_features.has_extended_dynamic_state_2 ||
-            (key.state.extended_dynamic_state_2_extra != 0) !=
-                dynamic_features.has_extended_dynamic_state_2_extra ||
-            (key.state.extended_dynamic_state_3_blend != 0) !=
-                dynamic_features.has_extended_dynamic_state_3_blend ||
-            (key.state.extended_dynamic_state_3_enables != 0) !=
-                dynamic_features.has_extended_dynamic_state_3_enables ||
+        // Validate dynamic features compatibility - granular per-feature check
+        if ((key.state.extended_dynamic_state != 0) != dynamic_features.has_extended_dynamic_state ||
+            (key.state.extended_dynamic_state_2 != 0) != dynamic_features.has_extended_dynamic_state_2 ||
+            (key.state.extended_dynamic_state_2_logic_op != 0) != dynamic_features.has_extended_dynamic_state_2_logic_op ||
+            (key.state.extended_dynamic_state_2_patch_control_points != 0) != dynamic_features.has_extended_dynamic_state_2_patch_control_points ||
+            (key.state.extended_dynamic_state_3_blend != 0) != dynamic_features.has_extended_dynamic_state_3_blend ||
+            (key.state.extended_dynamic_state_3_enables != 0) != dynamic_features.has_extended_dynamic_state_3_enables ||
+            (key.state.extended_dynamic_state_3_depth_clamp != 0) != dynamic_features.has_extended_dynamic_state_3_depth_clamp ||
+            (key.state.extended_dynamic_state_3_logic_op_enable != 0) != dynamic_features.has_extended_dynamic_state_3_logic_op_enable ||
+            (key.state.extended_dynamic_state_3_tessellation_domain_origin != 0) != dynamic_features.has_extended_dynamic_state_3_tessellation_domain_origin ||
+            (key.state.extended_dynamic_state_3_polygon_mode != 0) != dynamic_features.has_extended_dynamic_state_3_polygon_mode ||
+            (key.state.extended_dynamic_state_3_rasterization_samples != 0) != dynamic_features.has_extended_dynamic_state_3_rasterization_samples ||
+            (key.state.extended_dynamic_state_3_sample_mask != 0) != dynamic_features.has_extended_dynamic_state_3_sample_mask ||
+            (key.state.extended_dynamic_state_3_alpha_to_coverage_enable != 0) != dynamic_features.has_extended_dynamic_state_3_alpha_to_coverage_enable ||
+            (key.state.extended_dynamic_state_3_alpha_to_one_enable != 0) != dynamic_features.has_extended_dynamic_state_3_alpha_to_one_enable ||
+            (key.state.extended_dynamic_state_3_depth_clip_enable != 0) != dynamic_features.has_extended_dynamic_state_3_depth_clip_enable ||
+            (key.state.extended_dynamic_state_3_depth_clip_negative_one_to_one != 0) != dynamic_features.has_extended_dynamic_state_3_depth_clip_negative_one_to_one ||
+            (key.state.extended_dynamic_state_3_line_rasterization_mode != 0) != dynamic_features.has_extended_dynamic_state_3_line_rasterization_mode ||
+            (key.state.extended_dynamic_state_3_line_stipple_enable != 0) != dynamic_features.has_extended_dynamic_state_3_line_stipple_enable ||
+            (key.state.extended_dynamic_state_3_provoking_vertex_mode != 0) != dynamic_features.has_extended_dynamic_state_3_provoking_vertex_mode ||
+            (key.state.extended_dynamic_state_3_conservative_rasterization_mode != 0) != dynamic_features.has_extended_dynamic_state_3_conservative_rasterization_mode ||
+            (key.state.extended_dynamic_state_3_sample_locations_enable != 0) != dynamic_features.has_extended_dynamic_state_3_sample_locations_enable ||
+            (key.state.extended_dynamic_state_3_rasterization_stream != 0) != dynamic_features.has_extended_dynamic_state_3_rasterization_stream ||
            (key.state.dynamic_vertex_input != 0) != dynamic_features.has_dynamic_vertex_input) {
            return;
        }
@@ -677,7 +733,17 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(

        const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage)};
        ConvertLegacyToGeneric(program, runtime_info);
-        const std::vector<u32> code{EmitSPIRV(profile, runtime_info, program, binding, this->optimize_spirv_output)};
+        
+        // Adreno don't support subgroup operations in vertex stages
+        // Disable subgroup features for vertex shaders if not supported by the device
+        Shader::Profile stage_profile = profile;
+        if (program.stage == Shader::Stage::VertexA || program.stage == Shader::Stage::VertexB) {
+            if (!device.IsSubgroupSupportedForStage(VK_SHADER_STAGE_VERTEX_BIT)) {
+                stage_profile.support_vote = false;
+            }
+        }
+        
+        const std::vector<u32> code{EmitSPIRV(stage_profile, runtime_info, program, binding, this->optimize_spirv_output)};
        device.SaveShader(code);
        modules[stage_index] = BuildShader(device, code);
        if (device.HasDebuggingToolAttached()) {
@@ -771,6 +837,18 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
    }

    auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
+    
+    // Adreno and mobile GPUs have lower shared memory limits (32KB vs Switch's 48KB)
+    // Skip shader compilation if it exceeds device limits to prevent GPU crashes
+    const u32 max_shared_memory = device.GetMaxComputeSharedMemorySize();
+    if (program.shared_memory_size > max_shared_memory) {
+        LOG_ERROR(Render_Vulkan, 
+                  "Compute shader 0x{:016x} requests {}KB shared memory but device max is {}KB - "
+                  "SKIPPING compilation to prevent GPU crash. Visual effect will be missing.",
+                  key.unique_hash, program.shared_memory_size / 1024, max_shared_memory / 1024);
+        return nullptr;
+    }
+    
    const std::vector<u32> code{EmitSPIRV(profile, program, this->optimize_spirv_output)};
    device.SaveShader(code);
    vk::ShaderModule spv_module{BuildShader(device, code)};
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.h
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -113,6 +116,10 @@ public:
    void LoadDiskResources(u64 title_id, std::stop_token stop_loading,
                           const VideoCore::DiskResourceLoadCallback& callback);

+    [[nodiscard]] const DynamicFeatures& GetDynamicFeatures() const noexcept {
+        return dynamic_features;
+    }
+
 private:
    [[nodiscard]] GraphicsPipeline* CurrentGraphicsPipelineSlowPath();

--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -954,9 +954,10 @@ void RasterizerVulkan::UpdateDynamicStates() {
    UpdateStencilFaces(regs);
    UpdateLineWidth(regs);

-    const u8 dynamic_state = Settings::values.dyna_state.GetValue();
+    const auto& dynamic_features = pipeline_cache.GetDynamicFeatures();

-    if (device.IsExtExtendedDynamicStateSupported() && dynamic_state > 0) {
+    // EDS1 - Extended Dynamic State 1
+    if (dynamic_features.has_extended_dynamic_state) {
        UpdateCullMode(regs);
        UpdateDepthCompareOp(regs);
        UpdateFrontFace(regs);
@@ -966,40 +967,78 @@ void RasterizerVulkan::UpdateDynamicStates() {
            UpdateDepthTestEnable(regs);
            UpdateDepthWriteEnable(regs);
            UpdateStencilTestEnable(regs);
-            if (device.IsExtExtendedDynamicState2Supported() && dynamic_state > 1) {
-                UpdatePrimitiveRestartEnable(regs);
-                UpdateRasterizerDiscardEnable(regs);
-                UpdateDepthBiasEnable(regs);
-            }
-            if (device.IsExtExtendedDynamicState3EnablesSupported() && dynamic_state > 2) {
-                using namespace Tegra::Engines;
-                if (device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_OPEN_SOURCE || device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_PROPRIETARY) {
-                    struct In {
-                        const Maxwell3D::Regs::VertexAttribute::Type d;
-                        In(Maxwell3D::Regs::VertexAttribute::Type n) : d(n) {}
-                        bool operator()(Maxwell3D::Regs::VertexAttribute n) const {
-                            return n.type == d;
-                        }
-                    };
-                    auto has_float = std::any_of(regs.vertex_attrib_format.begin(), regs.vertex_attrib_format.end(), In(Maxwell3D::Regs::VertexAttribute::Type::Float));
-                    if (regs.logic_op.enable) {
-                        regs.logic_op.enable = static_cast<u32>(!has_float);
-                    }
-                }
-                UpdateLogicOpEnable(regs);
-                UpdateDepthClampEnable(regs);
-                UpdateLineStippleEnable(regs);
-                UpdateConservativeRasterizationMode(regs);
-            }
-        }
-        if (device.IsExtExtendedDynamicState2ExtrasSupported() && dynamic_state > 1) {
-            UpdateLogicOp(regs);
-        }
-        if (device.IsExtExtendedDynamicState3BlendingSupported() && dynamic_state > 2) {
-            UpdateBlending(regs);
        }
    }
-    if (device.IsExtVertexInputDynamicStateSupported() && dynamic_state > 2) {
+
+    // EDS2 - Extended Dynamic State 2 Core
+    if (dynamic_features.has_extended_dynamic_state_2) {
+        if (state_tracker.TouchStateEnable()) {
+            UpdatePrimitiveRestartEnable(regs);
+            UpdateRasterizerDiscardEnable(regs);
+            UpdateDepthBiasEnable(regs);
+        }
+    }
+
+    // EDS2 - LogicOp (granular feature)
+    if (dynamic_features.has_extended_dynamic_state_2_logic_op) {
+        UpdateLogicOp(regs);
+    }
+
+    // EDS3 - Depth Clamp Enable (granular)
+    if (dynamic_features.has_extended_dynamic_state_3_depth_clamp || 
+        dynamic_features.has_extended_dynamic_state_3_enables) {
+        if (state_tracker.TouchStateEnable()) {
+            UpdateDepthClampEnable(regs);
+        }
+    }
+
+    // EDS3 - Logic Op Enable (granular)
+    if (dynamic_features.has_extended_dynamic_state_3_logic_op_enable || 
+        dynamic_features.has_extended_dynamic_state_3_enables) {
+        if (state_tracker.TouchStateEnable()) {
+            using namespace Tegra::Engines;
+            // AMD workaround for logic op with float vertex attributes
+            if (device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_OPEN_SOURCE || 
+                device.GetDriverID() == VkDriverIdKHR::VK_DRIVER_ID_AMD_PROPRIETARY) {
+                struct In {
+                    const Maxwell3D::Regs::VertexAttribute::Type d;
+                    In(Maxwell3D::Regs::VertexAttribute::Type n) : d(n) {}
+                    bool operator()(Maxwell3D::Regs::VertexAttribute n) const {
+                        return n.type == d;
+                    }
+                };
+                auto has_float = std::any_of(regs.vertex_attrib_format.begin(), 
+                                            regs.vertex_attrib_format.end(), 
+                                            In(Maxwell3D::Regs::VertexAttribute::Type::Float));
+                if (regs.logic_op.enable) {
+                    regs.logic_op.enable = static_cast<u32>(!has_float);
+                }
+            }
+            UpdateLogicOpEnable(regs);
+        }
+    }
+
+    // EDS3 - Line Stipple Enable (granular)
+    if (dynamic_features.has_extended_dynamic_state_3_line_stipple_enable) {
+        if (state_tracker.TouchStateEnable()) {
+            UpdateLineStippleEnable(regs);
+        }
+    }
+
+    // EDS3 - Conservative Rasterization Mode (granular)
+    if (dynamic_features.has_extended_dynamic_state_3_conservative_rasterization_mode) {
+        if (state_tracker.TouchStateEnable()) {
+            UpdateConservativeRasterizationMode(regs);
+        }
+    }
+
+    // EDS3 - Blending (composite feature: ColorBlendEnable + ColorBlendEquation + ColorWriteMask)
+    if (dynamic_features.has_extended_dynamic_state_3_blend) {
+        UpdateBlending(regs);
+    }
+
+    // Vertex Input Dynamic State
+    if (dynamic_features.has_dynamic_vertex_input) {
        if (auto* gp = pipeline_cache.CurrentGraphicsPipeline(); gp && gp->HasDynamicVertexInput()) {
            UpdateVertexInput(regs);
        }
--- a/src/video_core/renderer_vulkan/vk_render_pass_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_render_pass_cache.cpp
@@ -8,6 +8,7 @@

 #include <boost/container/static_vector.hpp>

+#include "common/logging/log.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
 #include "video_core/renderer_vulkan/vk_render_pass_cache.h"
 #include "video_core/surface.h"
@@ -19,6 +20,23 @@ namespace {
 using VideoCore::Surface::PixelFormat;
 using VideoCore::Surface::SurfaceType;

+        // Check if the driver uses tile-based deferred rendering (TBDR) architecture
+        // These GPUs benefit from optimized load/store operations to keep data on-chip
+        // 
+        // TBDR GPUs supported in Eden:
+        // - Qualcomm Adreno (Snapdragon): Most Android flagship/midrange devices
+        // - ARM Mali: Android devices (Samsung Exynos, MediaTek, etc.)
+        // - Imagination PowerVR: Older iOS devices, some Android tablets
+        // - Samsung Xclipse: Galaxy S22+ (AMD RDNA2-based, but uses TBDR mode)
+        // - Broadcom VideoCore: Raspberry Pi
+        [[nodiscard]] constexpr bool IsTBDRGPU(VkDriverId driver_id) {
+            return driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+                   driver_id == VK_DRIVER_ID_ARM_PROPRIETARY ||
+                   driver_id == VK_DRIVER_ID_IMAGINATION_PROPRIETARY ||
+                   driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY ||
+                   driver_id == VK_DRIVER_ID_BROADCOM_PROPRIETARY;
+        }
+
        constexpr SurfaceType GetSurfaceType(PixelFormat format) {
            switch (format) {
                // Depth formats
@@ -44,23 +62,57 @@ using VideoCore::Surface::SurfaceType;
        }

        VkAttachmentDescription AttachmentDescription(const Device& device, PixelFormat format,
-                                                      VkSampleCountFlagBits samples) {
+                                                      VkSampleCountFlagBits samples,
+                                                      bool tbdr_will_clear,
+                                                      bool tbdr_discard_after,
+                                                      bool tbdr_read_only = false) {
            using MaxwellToVK::SurfaceFormat;

            const SurfaceType surface_type = GetSurfaceType(format);
            const bool has_stencil = surface_type == SurfaceType::DepthStencil ||
                                     surface_type == SurfaceType::Stencil;

+            // TBDR optimization: Apply hints only on tile-based GPUs
+            // Desktop GPUs (NVIDIA/AMD/Intel) ignore these hints and use standard behavior
+            const bool is_tbdr = IsTBDRGPU(device.GetDriverID());
+            
+            // On TBDR: Use DONT_CARE if clear is guaranteed (avoids loading from main memory)
+            // On Desktop: Always LOAD to preserve existing content (safer default)
+            VkAttachmentLoadOp load_op = VK_ATTACHMENT_LOAD_OP_LOAD;
+            if (is_tbdr && tbdr_will_clear) {
+                load_op = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+            }
+
+            // On TBDR: Use DONT_CARE if content won't be read (avoids storing to main memory)
+            // On Desktop: Always STORE (safer default)
+            // VK_QCOM_render_pass_store_ops: Use NONE_QCOM for read-only attachments (preserves outside render area)
+            VkAttachmentStoreOp store_op = VK_ATTACHMENT_STORE_OP_STORE;
+            if (is_tbdr && tbdr_discard_after) {
+                store_op = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+            } else if (is_tbdr && tbdr_read_only && device.IsQcomRenderPassStoreOpsSupported()) {
+                store_op = static_cast<VkAttachmentStoreOp>(1000301000); // VK_ATTACHMENT_STORE_OP_NONE_QCOM
+            }
+
+            // Stencil operations follow same logic
+            VkAttachmentLoadOp stencil_load_op = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+            VkAttachmentStoreOp stencil_store_op = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+            if (has_stencil && tbdr_read_only && device.IsQcomRenderPassStoreOpsSupported()) {
+                stencil_store_op = static_cast<VkAttachmentStoreOp>(1000301000); // VK_ATTACHMENT_STORE_OP_NONE_QCOM
+            } else if (has_stencil) {
+                stencil_load_op = (is_tbdr && tbdr_will_clear) ? VK_ATTACHMENT_LOAD_OP_DONT_CARE
+                                                                : VK_ATTACHMENT_LOAD_OP_LOAD;
+                stencil_store_op = (is_tbdr && tbdr_discard_after) ? VK_ATTACHMENT_STORE_OP_DONT_CARE
+                                                                    : VK_ATTACHMENT_STORE_OP_STORE;
+            }
+
            return {
                .flags = {},
                .format = SurfaceFormat(device, FormatType::Optimal, true, format).format,
                .samples = samples,
-                .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
-                .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
-                .stencilLoadOp = has_stencil ? VK_ATTACHMENT_LOAD_OP_LOAD
-                                                 : VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-                .stencilStoreOp = has_stencil ? VK_ATTACHMENT_STORE_OP_STORE
-                                                  : VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                .loadOp = load_op,
+                .storeOp = store_op,
+                .stencilLoadOp = stencil_load_op,
+                .stencilStoreOp = stencil_store_op,
                .initialLayout = VK_IMAGE_LAYOUT_GENERAL,
                .finalLayout = VK_IMAGE_LAYOUT_GENERAL,
            };
@@ -75,6 +127,13 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {
    if (!is_new) {
        return *pair->second;
    }
+
+    const bool is_tbdr = IsTBDRGPU(device->GetDriverID());
+    if (is_tbdr && (key.tbdr_will_clear || key.tbdr_discard_after)) {
+        LOG_DEBUG(Render_Vulkan, "Creating TBDR-optimized render pass (driver={}, clear={}, discard={})",
+                  static_cast<u32>(device->GetDriverID()), key.tbdr_will_clear, key.tbdr_discard_after);
+    }
+
    boost::container::static_vector<VkAttachmentDescription, 9> descriptions;
    std::array<VkAttachmentReference, 8> references{};
    u32 num_attachments{};
@@ -87,7 +146,8 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {
            .layout = VK_IMAGE_LAYOUT_GENERAL,
        };
        if (is_valid) {
-            descriptions.push_back(AttachmentDescription(*device, format, key.samples));
+            descriptions.push_back(AttachmentDescription(*device, format, key.samples,
+                                                         key.tbdr_will_clear, key.tbdr_discard_after));
            num_attachments = static_cast<u32>(index + 1);
            ++num_colors;
        }
@@ -99,10 +159,19 @@ VkRenderPass RenderPassCache::Get(const RenderPassKey& key) {
            .attachment = num_colors,
            .layout = VK_IMAGE_LAYOUT_GENERAL,
        };
-        descriptions.push_back(AttachmentDescription(*device, key.depth_format, key.samples));
+        descriptions.push_back(AttachmentDescription(*device, key.depth_format, key.samples,
+                                                     key.tbdr_will_clear, key.tbdr_discard_after, key.tbdr_read_only));
    }
+    VkSubpassDescriptionFlags subpass_flags = 0;
+    if (key.qcom_shader_resolve) {
+        // VK_QCOM_render_pass_shader_resolve: enables custom shader resolve in fragment shader
+        // This flag allows using a programmable fragment shader for MSAA resolve instead of
+        // fixed-function hardware resolve, enabling better quality and HDR format support
+        subpass_flags |= 0x00000004; // VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM
+    }
+    
    const VkSubpassDescription subpass{
-        .flags = 0,
+        .flags = subpass_flags,
        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
        .inputAttachmentCount = 0,
        .pInputAttachments = nullptr,
--- a/src/video_core/renderer_vulkan/vk_render_pass_cache.h
+++ b/src/video_core/renderer_vulkan/vk_render_pass_cache.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -17,6 +20,15 @@ struct RenderPassKey {
    std::array<VideoCore::Surface::PixelFormat, 8> color_formats;
    VideoCore::Surface::PixelFormat depth_format;
    VkSampleCountFlagBits samples;
+    
+    // TBDR optimization hints - only affect tile-based GPUs (Qualcomm, ARM, Imagination)
+    // These flags indicate the expected usage pattern to optimize load/store operations
+    bool tbdr_will_clear{false};  // Attachment will be cleared with vkCmdClearAttachments
+    bool tbdr_discard_after{false};  // Attachment won't be read after render pass
+    bool tbdr_read_only{false};  // Attachment is read-only (input attachment, depth test without writes)
+    
+    // VK_QCOM_render_pass_shader_resolve support
+    bool qcom_shader_resolve{false};  // Use shader resolve instead of fixed-function (last subpass)
 };

 } // namespace Vulkan
@@ -27,6 +39,8 @@ struct hash<Vulkan::RenderPassKey> {
    [[nodiscard]] size_t operator()(const Vulkan::RenderPassKey& key) const noexcept {
        size_t value = static_cast<size_t>(key.depth_format) << 48;
        value ^= static_cast<size_t>(key.samples) << 52;
+        value ^= (static_cast<size_t>(key.tbdr_will_clear) << 56);
+        value ^= (static_cast<size_t>(key.tbdr_discard_after) << 57);
        for (size_t i = 0; i < key.color_formats.size(); ++i) {
            value ^= static_cast<size_t>(key.color_formats[i]) << (i * 6);
        }
--- a/src/video_core/renderer_vulkan/vk_swapchain.cpp
+++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp
@@ -171,6 +171,10 @@ void Swapchain::Create(

    resource_ticks.clear();
    resource_ticks.resize(image_count);
+
+    // Initialize incremental-present probe flags for this swapchain.
+    incremental_present_usable = device.IsKhrIncrementalPresentSupported();
+    incremental_present_probed = false;
 }

 bool Swapchain::AcquireNextImage() {
@@ -202,7 +206,13 @@ bool Swapchain::AcquireNextImage() {

 void Swapchain::Present(VkSemaphore render_semaphore) {
    const auto present_queue{device.GetPresentQueue()};
-    const VkPresentInfoKHR present_info{
+    // If the device advertises VK_KHR_incremental_present, we attempt a one-time probe
+    // on the first present to validate the driver/compositor accepts present-region info.
+    VkPresentRegionsKHR present_regions{};
+    VkPresentRegionKHR region{};
+    VkRectLayerKHR layer{};
+
+    VkPresentInfoKHR present_info{
        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
        .pNext = nullptr,
        .waitSemaphoreCount = render_semaphore ? 1U : 0U,
@@ -212,6 +222,20 @@ void Swapchain::Present(VkSemaphore render_semaphore) {
        .pImageIndices = &image_index,
        .pResults = nullptr,
    };
+
+    if (incremental_present_usable && !incremental_present_probed) {
+        // Build a minimal present-region describing a single 1x1 dirty rect at (0,0).
+        layer.offset = {0, 0};
+        layer.extent = {1, 1};
+        region.rectangleCount = 1;
+        region.pRectangles = &layer;
+        present_regions.sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
+        present_regions.pNext = nullptr;
+        present_regions.swapchainCount = 1;
+        present_regions.pRegions = &region;
+
+        present_info.pNext = &present_regions;
+    }
    std::scoped_lock lock{scheduler.submit_mutex};
    switch (const VkResult result = present_queue.Present(present_info)) {
    case VK_SUCCESS:
@@ -227,8 +251,18 @@ void Swapchain::Present(VkSemaphore render_semaphore) {
        break;
    default:
        LOG_CRITICAL(Render_Vulkan, "Failed to present with error {}", string_VkResult(result));
+        // If the first present with incremental-present pNext failed, disable future use.
+        if (incremental_present_usable && !incremental_present_probed) {
+            incremental_present_usable = false;
+            LOG_WARNING(Render_Vulkan, "Disabling VK_KHR_incremental_present for this swapchain due to present failure: {}", string_VkResult(result));
+        }
        break;
    }
+    if (incremental_present_usable && !incremental_present_probed) {
+        // Mark probe as completed if we reached here (success or handled failure above).
+        incremental_present_probed = true;
+        LOG_INFO(Render_Vulkan, "VK_KHR_incremental_present probe completed: usable={}", incremental_present_usable);
+    }
    ++frame_index;
    if (frame_index >= image_count) {
        frame_index = 0;
--- a/src/video_core/renderer_vulkan/vk_swapchain.h
+++ b/src/video_core/renderer_vulkan/vk_swapchain.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -158,6 +161,8 @@ private:

    bool is_outdated{};
    bool is_suboptimal{};
+    bool incremental_present_usable{};
+    bool incremental_present_probed{};
 };

 } // namespace Vulkan
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -66,10 +66,20 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    }
 }

-[[nodiscard]] VkImageType ConvertImageType(const ImageType type) {
+[[nodiscard]] VkImageType ConvertImageType(const ImageType type, const Device& device) {
    switch (type) {
    case ImageType::e1D:
-        return VK_IMAGE_TYPE_1D;
+        // Mobile Vulkan (Adreno, Mali, PowerVR, IMG) lacks Sampled1D SPIR-V capability
+        // Emulate as 2D texture with height=1 on mobile, use native 1D on desktop
+        {
+            const auto driver_id = device.GetDriverID();
+            const bool is_mobile = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+                                   driver_id == VK_DRIVER_ID_MESA_TURNIP ||
+                                   driver_id == VK_DRIVER_ID_ARM_PROPRIETARY ||
+                                   driver_id == VK_DRIVER_ID_BROADCOM_PROPRIETARY ||
+                                   driver_id == VK_DRIVER_ID_IMAGINATION_PROPRIETARY;
+            return is_mobile ? VK_IMAGE_TYPE_2D : VK_IMAGE_TYPE_1D;
+        }
    case ImageType::e2D:
    case ImageType::Linear:
        return VK_IMAGE_TYPE_2D;
@@ -141,7 +151,7 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
        .pNext = nullptr,
        .flags = flags,
-        .imageType = ConvertImageType(info.type),
+        .imageType = ConvertImageType(info.type, device),
        .format = format_info.format,
        .extent{
            .width = info.size.width >> samples_x,
@@ -160,6 +170,40 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    };
 }

+/// Emergency fallback: degrade MSAA to non-MSAA for HDR formats when no resolve support exists
+[[nodiscard]] ImageInfo AdjustMSAAForHDRFormats(const Device& device, ImageInfo info) {
+    if (info.num_samples <= 1) {
+        return info;
+    }
+
+    const auto vk_format = MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, 
+                                                      false, info.format).format;
+    const bool is_hdr_format = vk_format == VK_FORMAT_B10G11R11_UFLOAT_PACK32;
+
+    if (!is_hdr_format) {
+        return info;
+    }
+
+    // Qualcomm: VK_QCOM_render_pass_shader_resolve handles HDR+MSAA
+    if (device.GetDriverID() == VK_DRIVER_ID_QUALCOMM_PROPRIETARY) {
+        if (device.IsQcomRenderPassShaderResolveSupported()) {
+            return info;
+        }
+    }
+
+    // Other vendors: shaderStorageImageMultisample handles HDR+MSAA
+    if (device.IsStorageImageMultisampleSupported()) {
+        return info;
+    }
+
+    // No suitable resolve method - degrade to non-MSAA
+    LOG_WARNING(Render_Vulkan, "HDR format {} with MSAA not supported, degrading to 1x samples",
+                vk_format);
+    info.num_samples = 1;
+    
+    return info;
+}
+
 [[nodiscard]] vk::Image MakeImage(const Device& device, const MemoryAllocator& allocator,
                                  const ImageInfo& info, std::span<const VkFormat> view_formats) {
    if (info.type == ImageType::Buffer) {
@@ -272,10 +316,18 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    return VK_COMPONENT_SWIZZLE_ZERO;
 }

-[[nodiscard]] VkImageViewType ImageViewType(Shader::TextureType type) {
+[[nodiscard]] VkImageViewType ImageViewType(Shader::TextureType type, const Device& device) {
+    const auto driver_id = device.GetDriverID();
+    const bool is_mobile = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+                           driver_id == VK_DRIVER_ID_MESA_TURNIP ||
+                           driver_id == VK_DRIVER_ID_ARM_PROPRIETARY ||
+                           driver_id == VK_DRIVER_ID_BROADCOM_PROPRIETARY ||
+                           driver_id == VK_DRIVER_ID_IMAGINATION_PROPRIETARY;
+    
    switch (type) {
    case Shader::TextureType::Color1D:
-        return VK_IMAGE_VIEW_TYPE_1D;
+        // Emulate 1D as 2D with height=1 on mobile (no Sampled1D capability)
+        return is_mobile ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_1D;
    case Shader::TextureType::Color2D:
    case Shader::TextureType::Color2DRect:
        return VK_IMAGE_VIEW_TYPE_2D;
@@ -284,7 +336,8 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    case Shader::TextureType::Color3D:
        return VK_IMAGE_VIEW_TYPE_3D;
    case Shader::TextureType::ColorArray1D:
-        return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
+        // Emulate 1D array as 2D array with height=1 on mobile
+        return is_mobile ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_1D_ARRAY;
    case Shader::TextureType::ColorArray2D:
        return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
    case Shader::TextureType::ColorArrayCube:
@@ -297,10 +350,18 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    return VK_IMAGE_VIEW_TYPE_2D;
 }

-[[nodiscard]] VkImageViewType ImageViewType(VideoCommon::ImageViewType type) {
+[[nodiscard]] VkImageViewType ImageViewType(VideoCommon::ImageViewType type, const Device& device) {
+    const auto driver_id = device.GetDriverID();
+    const bool is_mobile = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+                           driver_id == VK_DRIVER_ID_MESA_TURNIP ||
+                           driver_id == VK_DRIVER_ID_ARM_PROPRIETARY ||
+                           driver_id == VK_DRIVER_ID_BROADCOM_PROPRIETARY ||
+                           driver_id == VK_DRIVER_ID_IMAGINATION_PROPRIETARY;
+    
    switch (type) {
    case VideoCommon::ImageViewType::e1D:
-        return VK_IMAGE_VIEW_TYPE_1D;
+        // Emulate 1D as 2D with height=1 on mobile (no Sampled1D capability)
+        return is_mobile ? VK_IMAGE_VIEW_TYPE_2D : VK_IMAGE_VIEW_TYPE_1D;
    case VideoCommon::ImageViewType::e2D:
    case VideoCommon::ImageViewType::Rect:
        return VK_IMAGE_VIEW_TYPE_2D;
@@ -309,7 +370,8 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    case VideoCommon::ImageViewType::e3D:
        return VK_IMAGE_VIEW_TYPE_3D;
    case VideoCommon::ImageViewType::e1DArray:
-        return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
+        // Emulate 1D array as 2D array with height=1 on mobile
+        return is_mobile ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_1D_ARRAY;
    case VideoCommon::ImageViewType::e2DArray:
        return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
    case VideoCommon::ImageViewType::CubeArray:
@@ -857,6 +919,9 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, Scheduler& sched
        astc_decoder_pass.emplace(device, scheduler, descriptor_pool, staging_buffer_pool,
                                  compute_pass_descriptor_queue, memory_allocator);
    }
+    
+    // MSAA copy support via compute shader (only for non-Qualcomm with shaderStorageImageMultisample)
+    // Qualcomm uses VK_QCOM_render_pass_shader_resolve (fragment shader in render pass)
    if (device.IsStorageImageMultisampleSupported()) {
        msaa_copy_pass = std::make_unique<MSAACopyPass>(
            device, scheduler, descriptor_pool, staging_buffer_pool, compute_pass_descriptor_queue);
@@ -1323,7 +1388,6 @@ void TextureCacheRuntime::ConvertImage(Framebuffer* dst, ImageView& dst_view, Im
    case PixelFormat::ASTC_2D_8X6_SRGB:
    case PixelFormat::ASTC_2D_6X5_UNORM:
    case PixelFormat::ASTC_2D_6X5_SRGB:
-    case PixelFormat::E5B9G9R9_FLOAT:
    case PixelFormat::D32_FLOAT:
    case PixelFormat::D16_UNORM:
    case PixelFormat::X8_D24_UNORM:
@@ -1487,6 +1551,23 @@ void TextureCacheRuntime::CopyImage(Image& dst, Image& src,
 void TextureCacheRuntime::CopyImageMSAA(Image& dst, Image& src,
                                        std::span<const VideoCommon::ImageCopy> copies) {
    const bool msaa_to_non_msaa = src.info.num_samples > 1 && dst.info.num_samples == 1;
+    
+    // Use VK_QCOM_render_pass_shader_resolve for HDR formats on Qualcomm
+    // This is more efficient than compute shader (stays on-chip in TBDR)
+    const bool is_hdr_format = src.info.format == PixelFormat::B10G11R11_FLOAT ||
+                               dst.info.format == PixelFormat::B10G11R11_FLOAT;
+    const bool use_qcom_resolve = msaa_to_non_msaa && 
+                                   device.IsQcomRenderPassShaderResolveSupported() &&
+                                   is_hdr_format &&
+                                   copies.size() == 1; // QCOM resolve works best with single full copy
+    
+    if (use_qcom_resolve) {
+        // Create temporary framebuffer with resolve target
+        // TODO Camille: Implement QCOM shader resolve path with proper framebuffer setup
+        // For now, fall through to standard path
+        LOG_DEBUG(Render_Vulkan, "QCOM shader resolve opportunity detected but not yet implemented");
+    }
+    
    if (msaa_copy_pass) {
        return msaa_copy_pass->CopyImage(dst, src, copies, msaa_to_non_msaa);
    }
@@ -1510,10 +1591,20 @@ void TextureCacheRuntime::TickFrame() {}
 Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu_addr_,
             VAddr cpu_addr_)
    : VideoCommon::ImageBase(info_, gpu_addr_, cpu_addr_), scheduler{&runtime_.scheduler},
-      runtime{&runtime_}, original_image(MakeImage(runtime_.device, runtime_.memory_allocator, info,
-                                                   runtime->ViewFormats(info.format))),
-      aspect_mask(ImageAspectMask(info.format)) {
-    if (IsPixelFormatASTC(info.format) && !runtime->device.IsOptimalAstcSupported()) {
+      runtime{&runtime_} {
+    // CRITICAL: Adjust MSAA for HDR formats if driver doesn't support shaderStorageImageMultisample
+    // This prevents texture corruption by degrading to non-MSAA when msaa_copy_pass would fail
+    const ImageInfo adjusted_info = AdjustMSAAForHDRFormats(runtime_.device, info_);
+    
+    // Update our stored info with adjusted values (may have num_samples=1 now)
+    info = adjusted_info;
+    
+    // Create image with adjusted info
+    original_image = MakeImage(runtime_.device, runtime_.memory_allocator, adjusted_info,
+                              runtime->ViewFormats(adjusted_info.format));
+    aspect_mask = ImageAspectMask(adjusted_info.format);
+    
+    if (IsPixelFormatASTC(adjusted_info.format) && !runtime->device.IsOptimalAstcSupported()) {
        switch (Settings::values.accelerate_astc.GetValue()) {
        case Settings::AstcDecodeMode::Gpu:
            if (Settings::values.astc_recompression.GetValue() ==
@@ -2029,6 +2120,14 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
        }
    }
    const auto format_info = MaxwellToVK::SurfaceFormat(*device, FormatType::Optimal, true, format);
+    VkFormat view_format = format_info.format;
+    
+    // TODO: Format reinterpretation toggles (per-game settings)
+    // Some games incorrectly use integer formats with float samplers:
+    // - R32_UINT with texture() instead of texelFetch() causes flickering
+    // - R8_UINT with LINEAR filter causes validation errors
+    // Cannot auto-detect: need user toggles to force format reinterpretation
+    
    if (ImageUsageFlags(format_info, format) != image.UsageFlags()) {
        LOG_WARNING(Render_Vulkan,
                    "Image view format {} has different usage flags than image format {}", format,
@@ -2039,13 +2138,14 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
        .pNext = nullptr,
        .usage = ImageUsageFlags(format_info, format),
    };
+    
    const VkImageViewCreateInfo create_info{
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .pNext = &image_view_usage,
        .flags = 0,
        .image = image.Handle(),
        .viewType = VkImageViewType{},
-        .format = format_info.format,
+        .format = view_format,
        .components{
            .r = ComponentSwizzle(swizzle[0]),
            .g = ComponentSwizzle(swizzle[1]),
@@ -2056,7 +2156,7 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
    };
    const auto create = [&](TextureType tex_type, std::optional<u32> num_layers) {
        VkImageViewCreateInfo ci{create_info};
-        ci.viewType = ImageViewType(tex_type);
+        ci.viewType = ImageViewType(tex_type, *device);
        if (num_layers) {
            ci.subresourceRange.layerCount = *num_layers;
        }
@@ -2197,7 +2297,7 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
        .pNext = nullptr,
        .flags = 0,
        .image = image_handle,
-        .viewType = ImageViewType(type),
+        .viewType = ImageViewType(type, *device),
        .format = vk_format,
        .components{
            .r = VK_COMPONENT_SWIZZLE_IDENTITY,
@@ -2343,6 +2443,26 @@ void Framebuffer::CreateFramebuffer(TextureCacheRuntime& runtime,
    }
    renderpass_key.samples = samples;

+    // Enable VK_QCOM_render_pass_shader_resolve for HDR+MSAA on Qualcomm
+    // This performs MSAA resolve using fragment shader IN the render pass (on-chip)
+    // Benefits: ~70% bandwidth reduction, better performance on TBDR architectures
+    // Requirements: pResolveAttachments configured + explicit shader execution
+    if (samples > VK_SAMPLE_COUNT_1_BIT && runtime.device.IsQcomRenderPassShaderResolveSupported()) {
+        // Check if any color attachment is HDR format that benefits from shader resolve
+        bool has_hdr_attachment = false;
+        for (size_t index = 0; index < NUM_RT && !has_hdr_attachment; ++index) {
+            const auto format = renderpass_key.color_formats[index];
+            // B10G11R11_FLOAT benefits most: compute shader limited, fixed-function slower
+            if (format == PixelFormat::B10G11R11_FLOAT) {
+                has_hdr_attachment = true;
+            }
+        }
+        
+        if (has_hdr_attachment) {
+            renderpass_key.qcom_shader_resolve = true;
+        }
+    }
+
    renderpass = runtime.render_pass_cache.Get(renderpass_key);
    render_area.width = (std::min)(render_area.width, width);
    render_area.height = (std::min)(render_area.height, height);
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

@@ -85,6 +88,10 @@ public:
        return msaa_copy_pass.operator bool();
    }

+    bool CanDownloadMSAA() const noexcept {
+        return msaa_copy_pass.operator bool();
+    }
+
    void AccelerateImageUpload(Image&, const StagingBufferRef&,
                               std::span<const VideoCommon::SwizzleParameters>);

--- a/src/video_core/shader_environment.cpp
+++ b/src/video_core/shader_environment.cpp
@@ -277,7 +277,19 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
 Tegra::Texture::TICEntry GenericEnvironment::ReadTextureInfo(GPUVAddr tic_addr, u32 tic_limit,
                                                             bool via_header_index, u32 raw) {
    const auto handle{Tegra::Texture::TexturePair(raw, via_header_index)};
-    ASSERT(handle.first <= tic_limit);
+    
+    // Some games (especially on updates) use invalid texture handles beyond tic_limit
+    // Clamp to limit instead of asserting to prevent crashes
+    if (handle.first > tic_limit) {
+        LOG_WARNING(HW_GPU, "Texture handle {} exceeds TIC limit {}, clamping to limit", 
+                    handle.first, tic_limit);
+        const u32 clamped_handle = std::min(handle.first, tic_limit);
+        const GPUVAddr descriptor_addr{tic_addr + clamped_handle * sizeof(Tegra::Texture::TICEntry)};
+        Tegra::Texture::TICEntry entry;
+        gpu_memory->ReadBlock(descriptor_addr, &entry, sizeof(entry));
+        return entry;
+    }
+    
    const GPUVAddr descriptor_addr{tic_addr + handle.first * sizeof(Tegra::Texture::TICEntry)};
    Tegra::Texture::TICEntry entry;
    gpu_memory->ReadBlock(descriptor_addr, &entry, sizeof(entry));
--- a/src/video_core/surface.h
+++ b/src/video_core/surface.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -108,7 +111,6 @@ enum class PixelFormat {
    ASTC_2D_8X6_SRGB,
    ASTC_2D_6X5_UNORM,
    ASTC_2D_6X5_SRGB,
-    E5B9G9R9_FLOAT,

    MaxColorFormat,

@@ -249,7 +251,6 @@ constexpr std::array<u8, MaxPixelFormat> BLOCK_WIDTH_TABLE = {{
    8,  // ASTC_2D_8X6_SRGB
    6,  // ASTC_2D_6X5_UNORM
    6,  // ASTC_2D_6X5_SRGB
-    1,  // E5B9G9R9_FLOAT
    1,  // D32_FLOAT
    1,  // D16_UNORM
    1,  // X8_D24_UNORM
@@ -359,7 +360,6 @@ constexpr std::array<u8, MaxPixelFormat> BLOCK_HEIGHT_TABLE = {{
    6,  // ASTC_2D_8X6_SRGB
    5,  // ASTC_2D_6X5_UNORM
    5,  // ASTC_2D_6X5_SRGB
-    1,  // E5B9G9R9_FLOAT
    1,  // D32_FLOAT
    1,  // D16_UNORM
    1,  // X8_D24_UNORM
@@ -469,7 +469,6 @@ constexpr std::array<u8, MaxPixelFormat> BITS_PER_BLOCK_TABLE = {{
    128, // ASTC_2D_8X6_SRGB
    128, // ASTC_2D_6X5_UNORM
    128, // ASTC_2D_6X5_SRGB
-    32,  // E5B9G9R9_FLOAT
    32,  // D32_FLOAT
    16,  // D16_UNORM
    32,  // X8_D24_UNORM
--- a/src/video_core/texture_cache/format_lookup_table.cpp
+++ b/src/video_core/texture_cache/format_lookup_table.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -135,7 +138,7 @@ PixelFormat PixelFormatFromTextureInfo(TextureFormat format, ComponentType red,
    case Hash(TextureFormat::R32, SINT):
        return PixelFormat::R32_SINT;
    case Hash(TextureFormat::E5B9G9R9, FLOAT):
-        return PixelFormat::E5B9G9R9_FLOAT;
+        return PixelFormat::B10G11R11_FLOAT;
    case Hash(TextureFormat::Z32, FLOAT):
        return PixelFormat::D32_FLOAT;
    case Hash(TextureFormat::Z32, FLOAT, UINT, UINT, UINT, LINEAR):
--- a/src/video_core/texture_cache/formatter.h
+++ b/src/video_core/texture_cache/formatter.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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

@@ -205,8 +208,7 @@ struct fmt::formatter<VideoCore::Surface::PixelFormat> : fmt::formatter<fmt::str
                return "ASTC_2D_6X5_UNORM";
            case PixelFormat::ASTC_2D_6X5_SRGB:
                return "ASTC_2D_6X5_SRGB";
-            case PixelFormat::E5B9G9R9_FLOAT:
-                return "E5B9G9R9_FLOAT";
+
            case PixelFormat::D32_FLOAT:
                return "D32_FLOAT";
            case PixelFormat::D16_UNORM:
--- a/src/video_core/texture_cache/image_base.cpp
+++ b/src/video_core/texture_cache/image_base.cpp
@@ -131,10 +131,6 @@ bool ImageBase::IsSafeDownload() const noexcept {
    if (True(flags & ImageFlagBits::CpuModified)) {
        return false;
    }
-    if (info.num_samples > 1) {
-        LOG_WARNING(HW_GPU, "MSAA image downloads are not implemented");
-        return false;
-    }
    return true;
 }

--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -101,8 +101,12 @@ void TextureCache<P>::RunGarbageCollector() {
        if (!aggressive_mode && True(image.flags & ImageFlagBits::CostlyLoad)) {
            return false;
        }
-        const bool must_download =
-            image.IsSafeDownload() && False(image.flags & ImageFlagBits::BadOverlap);
+        const bool supports_msaa_download = HasMsaaDownloadSupport(image.info);
+        if (!supports_msaa_download && image.info.num_samples > 1) {
+            LOG_WARNING(HW_GPU, "MSAA image downloads are not implemented");
+        }
+        const bool must_download = supports_msaa_download && image.IsSafeDownload() &&
+                                    False(image.flags & ImageFlagBits::BadOverlap);
        if (!high_priority_mode && must_download) {
            return false;
        }
@@ -548,10 +552,14 @@ void TextureCache<P>::WriteMemory(DAddr cpu_addr, size_t size) {
 template <class P>
 void TextureCache<P>::DownloadMemory(DAddr cpu_addr, size_t size) {
    boost::container::small_vector<ImageId, 16> images;
-    ForEachImageInRegion(cpu_addr, size, [&images](ImageId image_id, ImageBase& image) {
+    ForEachImageInRegion(cpu_addr, size, [this, &images](ImageId image_id, ImageBase& image) {
        if (!image.IsSafeDownload()) {
            return;
        }
+        if (!HasMsaaDownloadSupport(image.info)) {
+            LOG_WARNING(HW_GPU, "MSAA image downloads are not implemented");
+            return;
+        }
        image.flags &= ~ImageFlagBits::GpuModified;
        images.push_back(image_id);
    });
@@ -930,6 +938,17 @@ ImageId TextureCache<P>::DmaImageId(const Tegra::DMA::ImageOperand& operand, boo
        return NULL_IMAGE_ID;
    }
    auto& image = slot_images[dst_id];
+    if (image.info.num_samples > 1) {
+        if (is_upload) {
+            if (!HasMsaaUploadSupport(image.info)) {
+                return NULL_IMAGE_ID;
+            }
+        } else {
+            if (!HasMsaaDownloadSupport(image.info)) {
+                return NULL_IMAGE_ID;
+            }
+        }
+    }
    if (False(image.flags & ImageFlagBits::GpuModified)) {
        // No need to waste time on an image that's synced with guest
        return NULL_IMAGE_ID;
@@ -1056,7 +1075,7 @@ void TextureCache<P>::RefreshContents(Image& image, ImageId image_id) {
    image.flags &= ~ImageFlagBits::CpuModified;
    TrackImage(image, image_id);

-    if (image.info.num_samples > 1 && !runtime.CanUploadMSAA()) {
+    if (!HasMsaaUploadSupport(image.info)) {
        LOG_WARNING(HW_GPU, "MSAA image uploads are not implemented");
        runtime.TransitionImageLayout(image);
        return;
@@ -1274,6 +1293,16 @@ u64 TextureCache<P>::GetScaledImageSizeBytes(const ImageBase& image) {
    return fitted_size;
 }

+template <class P>
+bool TextureCache<P>::HasMsaaUploadSupport(const ImageInfo& info) const noexcept {
+    return info.num_samples <= 1 || runtime.CanUploadMSAA();
+}
+
+template <class P>
+bool TextureCache<P>::HasMsaaDownloadSupport(const ImageInfo& info) const noexcept {
+    return info.num_samples <= 1 || runtime.CanDownloadMSAA();
+}
+
 template <class P>
 void TextureCache<P>::QueueAsyncDecode(Image& image, ImageId image_id) {
    UNIMPLEMENTED_IF(False(image.flags & ImageFlagBits::Converted));
@@ -1491,7 +1520,31 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DA
    for (const ImageId overlap_id : join_ignore_textures) {
        Image& overlap = slot_images[overlap_id];
        if (True(overlap.flags & ImageFlagBits::GpuModified)) {
-            UNIMPLEMENTED();
+            // Merge GPU-modified contents from the overlapping image into the newly
+            // created image to preserve guest-visible data. Compute shrink/scale
+            // copies and dispatch a GPU-side copy. This mirrors the behavior used
+            // for overlaps handled in join_copies_to_do above.
+            new_image.flags |= ImageFlagBits::GpuModified;
+            const auto& resolution = Settings::values.resolution_info;
+            const auto base_opt = new_image.TryFindBase(overlap.gpu_addr);
+            if (base_opt) {
+                const SubresourceBase base = base_opt.value();
+                const u32 up_scale = can_rescale ? resolution.up_scale : 1;
+                const u32 down_shift = can_rescale ? resolution.down_shift : 0;
+                auto copies = MakeShrinkImageCopies(new_info, overlap.info, base, up_scale, down_shift);
+                if (overlap.info.num_samples != new_image.info.num_samples) {
+                    runtime.CopyImageMSAA(new_image, overlap, FixSmallVectorADL(copies));
+                } else {
+                    runtime.CopyImage(new_image, overlap, FixSmallVectorADL(copies));
+                }
+                new_image.modification_tick = overlap.modification_tick;
+            } else {
+                // If we cannot determine a base mapping, fallback to preserving the
+                // overlap (avoid deleting GPU-modified data) and log the event so
+                // it can be investigated, we're trying to pinpoint the issue of texture flickering.
+                LOG_WARNING(HW_GPU, "Could not map overlap gpu_addr {:#x} into new image; preserving overlap", u64(overlap.gpu_addr));
+                continue;
+            }
        }
        if (True(overlap.flags & ImageFlagBits::Tracked)) {
            UntrackImage(overlap, overlap_id);
@@ -1551,6 +1604,10 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DA
    for (const auto& copy_object : join_copies_to_do) {
        Image& overlap = slot_images[copy_object.id];
        if (copy_object.is_alias) {
+            if (!HasMsaaDownloadSupport(overlap.info)) {
+                LOG_WARNING(HW_GPU, "MSAA image downloads are not implemented");
+                continue;
+            }
            if (!overlap.IsSafeDownload()) {
                continue;
            }
@@ -2467,8 +2524,13 @@ void TextureCache<P>::BindRenderTarget(ImageViewId* old_id, ImageViewId new_id)
    if (new_id) {
        const ImageViewBase& old_view = slot_image_views[new_id];
        if (True(old_view.flags & ImageViewFlagBits::PreemtiveDownload)) {
-            const PendingDownload new_download{true, 0, old_view.image_id};
-            uncommitted_downloads.emplace_back(new_download);
+            const ImageBase& image = slot_images[old_view.image_id];
+            if (!HasMsaaDownloadSupport(image.info)) {
+                LOG_WARNING(HW_GPU, "MSAA image downloads are not implemented");
+            } else {
+                const PendingDownload new_download{true, 0, old_view.image_id};
+                uncommitted_downloads.emplace_back(new_download);
+            }
        }
    }
    *old_id = new_id;
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/src/video_core/texture_cache/texture_cache_base.h
@@ -426,6 +426,8 @@ private:
    bool ScaleUp(Image& image);
    bool ScaleDown(Image& image);
    u64 GetScaledImageSizeBytes(const ImageBase& image);
+    [[nodiscard]] bool HasMsaaUploadSupport(const ImageInfo& info) const noexcept;
+    [[nodiscard]] bool HasMsaaDownloadSupport(const ImageInfo& info) const noexcept;

    void QueueAsyncDecode(Image& image, ImageId image_id);
    void TickAsyncDecode();
--- a/src/video_core/vulkan_common/vulkan.h
+++ b/src/video_core/vulkan_common/vulkan.h
@@ -22,6 +22,34 @@

 #include <vulkan/vulkan.h>

+#ifndef VK_KHR_MAINTENANCE_1_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_maintenance1"
+#endif
+#ifndef VK_KHR_MAINTENANCE_2_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_maintenance2"
+#endif
+#ifndef VK_KHR_MAINTENANCE_3_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_3_EXTENSION_NAME "VK_KHR_maintenance3"
+#endif
+#ifndef VK_KHR_MAINTENANCE_4_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_4_EXTENSION_NAME "VK_KHR_maintenance4"
+#endif
+#ifndef VK_KHR_MAINTENANCE_5_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_5_EXTENSION_NAME "VK_KHR_maintenance5"
+#endif
+#ifndef VK_KHR_MAINTENANCE_6_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_6_EXTENSION_NAME "VK_KHR_maintenance6"
+#endif
+#ifndef VK_KHR_MAINTENANCE_7_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_7_EXTENSION_NAME "VK_KHR_maintenance7"
+#endif
+#ifndef VK_KHR_MAINTENANCE_8_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8"
+#endif
+#ifndef VK_KHR_MAINTENANCE_9_EXTENSION_NAME
+#   define VK_KHR_MAINTENANCE_9_EXTENSION_NAME "VK_KHR_maintenance9"
+#endif
+
 // Sanitize macros
 #undef CreateEvent
 #undef CreateSemaphore
--- a/src/video_core/vulkan_common/vulkan_device.cpp
+++ b/src/video_core/vulkan_common/vulkan_device.cpp
@@ -90,6 +90,25 @@ constexpr std::array VK_FORMAT_A4B4G4R4_UNORM_PACK16{
    VK_FORMAT_UNDEFINED,
 };

+// B10G11R11_UFLOAT (R11G11B10F) - PRIMARY HDR format for Nintendo Switch
+// Nintendo Switch hardware validation: FULL support (COLOR_ATTACHMENT + STORAGE_IMAGE + BLEND)
+// Reference: vp_gpuinfo_nintendo_switch_v2_495_0_0_0 - All required feature bits present
+//
+// Fallback strategy: Degrade to LDR instead of expensive HDR emulation
+// - RGBA8 UNORM/SRGB: Universal support, 32-bit (same size as B10G11R11), acceptable quality
+// - RGB10A2: Better precision if available, still 32-bit
+// - RGBA16F: Last resort only if RGB8 variants fail (should never happen)
+constexpr std::array B10G11R11_UFLOAT_PACK32{
+    #ifdef ANDROID
+        VK_FORMAT_A8B8G8R8_SRGB_PACK32,       // sRGB variant (for gamma-correct fallback)
+    #else
+        VK_FORMAT_A8B8G8R8_UNORM_PACK32,      // Primary fallback: RGBA8 LDR (32-bit, universal)
+        VK_FORMAT_A2B10G10R10_UNORM_PACK32,   // Better precision: RGB10A2 (32-bit, common)
+    #endif
+        VK_FORMAT_R16G16B16A16_SFLOAT,        // Emergency fallback: RGBA16F (64-bit, should never reach)
+        VK_FORMAT_UNDEFINED,
+};
+
 } // namespace Alternatives

 template <typename T>
@@ -122,6 +141,9 @@ constexpr const VkFormat* GetFormatAlternatives(VkFormat format) {
        return Alternatives::VK_FORMAT_R32G32B32_SFLOAT.data();
    case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
        return Alternatives::VK_FORMAT_A4B4G4R4_UNORM_PACK16.data();
+    case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
+        return Alternatives::B10G11R11_UFLOAT_PACK32.data();
+
    default:
        return nullptr;
    }
@@ -209,7 +231,6 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
        VK_FORMAT_D24_UNORM_S8_UINT,
        VK_FORMAT_D32_SFLOAT,
        VK_FORMAT_D32_SFLOAT_S8_UINT,
-        VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
        VK_FORMAT_R16G16B16A16_SFLOAT,
        VK_FORMAT_R16G16B16A16_SINT,
        VK_FORMAT_R16G16B16A16_SNORM,
@@ -416,7 +437,9 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
    const bool is_suitable = GetSuitability(surface != nullptr);

    const VkDriverId driver_id = properties.driver.driverID;
-    const auto device_id = properties.properties.deviceID;
+    // uncomment this if you want per-device overrides :P
+    // const u32 device_id = properties.properties.deviceID;
+
    const bool is_radv = driver_id == VK_DRIVER_ID_MESA_RADV;
    const bool is_amd_driver =
        driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE;
@@ -427,7 +450,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
    const bool is_mvk = driver_id == VK_DRIVER_ID_MOLTENVK;
    const bool is_qualcomm = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
    const bool is_turnip = driver_id == VK_DRIVER_ID_MESA_TURNIP;
-    const bool is_s8gen2 = device_id == 0x43050a01;
    const bool is_arm = driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;

    if ((is_mvk || is_qualcomm || is_turnip || is_arm) && !is_suitable) {
@@ -494,11 +516,24 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
    CollectPhysicalMemoryInfo();
    CollectToolingInfo();

-    if (is_qualcomm || is_turnip) {
-        LOG_WARNING(Render_Vulkan,
-                    "Qualcomm and Turnip drivers have broken VK_EXT_custom_border_color");
-        //RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
-        //VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+    // Driver-specific handling for VK_EXT_custom_border_color
+    // On some Qualcomm/Turnip/ARM drivers the extension may be partially implemented.
+    // Disable completely if no feature bits are reported to avoid crashes/undefined behavior.
+    if (is_qualcomm || is_turnip || is_arm) {
+        const bool has_any_custom_border_color =
+            features.custom_border_color.customBorderColors ||
+            features.custom_border_color.customBorderColorWithoutFormat;
+        if (!has_any_custom_border_color) {
+            LOG_WARNING(Render_Vulkan,
+                        "Disabling VK_EXT_custom_border_color on '{}' — no usable features reported",
+                        properties.driver.driverName);
+            RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
+                                   VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+        } else {
+            LOG_INFO(Render_Vulkan,
+                     "VK_EXT_custom_border_color enabled on '{}' (partial support detected)",
+                     properties.driver.driverName);
+        }
    }

    if (is_qualcomm) {
@@ -506,9 +541,36 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
                    "Qualcomm drivers have a slow VK_KHR_push_descriptor implementation");
        //RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);

-        LOG_WARNING(Render_Vulkan,
-                    "Disabling shader float controls and 64-bit integer features on Qualcomm proprietary drivers");
-        RemoveExtension(extensions.shader_float_controls, VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
+        // Log Qualcomm-specific optimizations
+        if (extensions.render_pass_store_ops) {
+            LOG_INFO(Render_Vulkan, "VK_QCOM_render_pass_store_ops: Enabled");
+        }
+        if (extensions.tile_properties) {
+            LOG_INFO(Render_Vulkan, "VK_QCOM_tile_properties: Enabled");
+        }
+        if (extensions.render_pass_shader_resolve) {
+            LOG_INFO(Render_Vulkan, "VK_QCOM_render_pass_shader_resolve: Enabled");
+        }
+        if (extensions.render_pass_transform) {
+            LOG_INFO(Render_Vulkan, "VK_QCOM_render_pass_transform: Enabled");
+        }
+        if (extensions.rotated_copy_commands) {
+            LOG_INFO(Render_Vulkan, "VK_QCOM_rotated_copy_commands: Enabled");
+        }
+        if (extensions.image_processing) {
+            LOG_INFO(Render_Vulkan, "VK_QCOM_image_processing: Enabled");
+        }
+
+        // Shader Float Controls: Completely broken on Stock Qualcomm
+        // The extension causes rendering issues regardless of FP16/FP32 mode
+        // Turnip Mesa: Works correctly, keep enabled
+        if (!is_turnip) {
+            LOG_WARNING(Render_Vulkan, "Disabling Shader Float Controls for Stock Qualcomm (broken implementation)");
+            RemoveExtensionFeature(extensions.shader_float_controls, features.shader_float_controls,
+                                   VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
+        }
+        
+        // Int64 atomics - genuinely broken, always disable
        RemoveExtensionFeature(extensions.shader_atomic_int64, features.shader_atomic_int64,
                               VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
        features.shader_atomic_int64.shaderBufferInt64Atomics = false;
@@ -555,83 +617,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
            cant_blit_msaa = true;
        }
    }
-    if (extensions.extended_dynamic_state && is_radv) {
-        // Mask driver version variant
-        const u32 version = (properties.properties.driverVersion << 3) >> 3;
-        if (version < VK_MAKE_API_VERSION(0, 21, 2, 0)) {
-            LOG_WARNING(Render_Vulkan,
-                        "RADV versions older than 21.2 have broken VK_EXT_extended_dynamic_state");
-            //RemoveExtensionFeature(extensions.extended_dynamic_state,
-            //features.extended_dynamic_state,
-            //VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
-        }
-    }
-    if (extensions.extended_dynamic_state2 && is_radv) {
-        const u32 version = (properties.properties.driverVersion << 3) >> 3;
-        if (version < VK_MAKE_API_VERSION(0, 22, 3, 1)) {
-            LOG_WARNING(
-                Render_Vulkan,
-                "RADV versions older than 22.3.1 have broken VK_EXT_extended_dynamic_state2");
-            // RemoveExtensionFeature(extensions.extended_dynamic_state2,
-            //        features.extended_dynamic_state2,
-            //      VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-        }
-    }
-    if (extensions.extended_dynamic_state2 && is_qualcomm) {
-        const u32 version = (properties.properties.driverVersion << 3) >> 3;
-        if (version >= VK_MAKE_API_VERSION(0, 0, 676, 0) &&
-            version < VK_MAKE_API_VERSION(0, 0, 680, 0)) {
-            // Qualcomm Adreno 7xx drivers do not properly support extended_dynamic_state2.
-            LOG_WARNING(Render_Vulkan,
-                        "Qualcomm Adreno 7xx drivers have broken VK_EXT_extended_dynamic_state2");
-            //RemoveExtensionFeature(extensions.extended_dynamic_state2,
-            //features.extended_dynamic_state2,
-            //VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-        }
-    }
-    if (extensions.extended_dynamic_state3 && is_radv) {
-        LOG_WARNING(Render_Vulkan, "RADV has broken extendedDynamicState3ColorBlendEquation");
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = true;
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = true;
-        dynamic_state3_blending = true;
-
-        const u32 version = (properties.properties.driverVersion << 3) >> 3;
-        if (version < VK_MAKE_API_VERSION(0, 23, 1, 0)) {
-            LOG_WARNING(Render_Vulkan,
-                        "RADV versions older than 23.1.0 have broken depth clamp dynamic state");
-            features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = true;
-            dynamic_state3_enables = true;
-        }
-    }
-    if (extensions.extended_dynamic_state3 && (is_amd_driver || driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY)) {
-        // AMD and Samsung drivers have broken extendedDynamicState3ColorBlendEquation
-        LOG_WARNING(Render_Vulkan,
-                    "AMD and Samsung drivers have broken extendedDynamicState3ColorBlendEquation");
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = true;
-        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = true;
-        dynamic_state3_blending = true;
-    }
-    if (extensions.vertex_input_dynamic_state && is_radv) {
-        // TODO(ameerj): Blacklist only offending driver versions
-        // TODO(ameerj): Confirm if RDNA1 is affected
-        const bool is_rdna2 =
-            supported_extensions.contains(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
-        if (is_rdna2) {
-            LOG_WARNING(Render_Vulkan,
-                        "RADV has broken VK_EXT_vertex_input_dynamic_state on RDNA2 hardware");
-            //  RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-            //      features.vertex_input_dynamic_state,
-            //    VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
-        }
-    }
-    if (extensions.vertex_input_dynamic_state && is_qualcomm) {
-        // Qualcomm drivers do not properly support vertex_input_dynamic_state.
-        LOG_WARNING(Render_Vulkan,
-                    "Qualcomm drivers have broken VK_EXT_vertex_input_dynamic_state");
-        //RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-        //  features.vertex_input_dynamic_state,
-        //     VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
-    }
+    // Dynamic state blacklists moved to GetSuitability() for proper ordering

    sets_per_pool = 64;
    if (is_amd_driver) {
@@ -660,15 +646,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        }
    }

-    if (extensions.vertex_input_dynamic_state && is_intel_windows) {
-        const u32 version = (properties.properties.driverVersion << 3) >> 3;
-        if (version < VK_MAKE_API_VERSION(27, 20, 100, 0)) {
-            LOG_WARNING(Render_Vulkan, "Intel has broken VK_EXT_vertex_input_dynamic_state");
-            //RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
-            //features.vertex_input_dynamic_state,
-            //VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
-        }
-    }
+    // VertexInputDynamicState blacklist moved to GetSuitability() for proper ordering
    if (features.shader_float16_int8.shaderFloat16 && is_intel_windows) {
        // Intel's compiler crashes when using fp16 on Astral Chain, disable it for the time being.
        LOG_WARNING(Render_Vulkan, "Intel has broken float16 math");
@@ -681,9 +659,40 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
    has_broken_compute =
        CheckBrokenCompute(properties.driver.driverID, properties.properties.driverVersion) &&
        !Settings::values.enable_compute_pipelines.GetValue();
-    if (is_intel_anv || (is_qualcomm && !is_s8gen2)) {
-        LOG_WARNING(Render_Vulkan, "Driver does not support native BGR format");
+    must_emulate_bgr565 = false; // Default: assume emulation isn't required
+
+    if (is_intel_anv) {
+        LOG_WARNING(Render_Vulkan, "Intel ANV driver does not support native BGR format");
        must_emulate_bgr565 = true;
+    } else if (is_qualcomm) {
+        // Qualcomm driver version where VK_KHR_maintenance5 and A1B5G5R5 become reliable
+        constexpr uint32_t QUALCOMM_FIXED_DRIVER_VERSION = VK_MAKE_VERSION(512, 800, 1);
+        // Check if VK_KHR_maintenance5 is supported
+        if (extensions.maintenance5 && properties.properties.driverVersion >= QUALCOMM_FIXED_DRIVER_VERSION) {
+            LOG_INFO(Render_Vulkan, "Qualcomm driver supports VK_KHR_maintenance5, disabling BGR emulation");
+            must_emulate_bgr565 = false;
+        } else {
+            LOG_WARNING(Render_Vulkan, "Qualcomm driver doesn't support native BGR, emulating formats");
+            must_emulate_bgr565 = true;
+        }
+    } else if (is_turnip) {
+        // Mesa Turnip added support for maintenance5 in Mesa 25.0
+        if (extensions.maintenance5) {
+            LOG_INFO(Render_Vulkan, "Turnip driver supports VK_KHR_maintenance5, disabling BGR emulation");
+            must_emulate_bgr565 = false;
+        } else {
+            LOG_WARNING(Render_Vulkan, "Turnip driver doesn't support native BGR, emulating formats");
+            must_emulate_bgr565 = true;
+        }
+    } else if (is_arm) {
+        // ARM Mali: stop emulating BGR5 formats when VK_KHR_maintenance5 is available
+        if (extensions.maintenance5) {
+            LOG_INFO(Render_Vulkan, "ARM driver supports VK_KHR_maintenance5, disabling BGR emulation");
+            must_emulate_bgr565 = false;
+        } else {
+            LOG_WARNING(Render_Vulkan, "ARM driver doesn't support native BGR, emulating formats");
+            must_emulate_bgr565 = true;
+        }
    }
    if (extensions.push_descriptor && is_intel_anv) {
        const u32 version = (properties.properties.driverVersion << 3) >> 3;
@@ -713,8 +722,11 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
            (std::min)(properties.properties.limits.maxVertexInputBindings, 16U);
    }

-    if (is_turnip) {
-        LOG_WARNING(Render_Vulkan, "Turnip requires higher-than-reported binding limits");
+    if (is_turnip || is_qualcomm) {
+        // Ensure proper vertex input bindings limit for Qualcomm hardware
+        LOG_WARNING(Render_Vulkan, 
+                    "{}: Ensuring maxVertexInputBindings = 32",
+                    is_turnip ? "Turnip" : "Qualcomm");
        properties.properties.limits.maxVertexInputBindings = 32;
    }

@@ -725,41 +737,21 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
                               VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
    }

-    if (!extensions.extended_dynamic_state2 && extensions.extended_dynamic_state3) {
-        LOG_INFO(Render_Vulkan,
-                 "Removing extendedDynamicState3 due to missing extendedDynamicState2");
-        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3,
-                               VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
-        dynamic_state3_blending = true;
-        dynamic_state3_enables = true;
-    }
+    // Intel iGPU/MoltenVK blacklist moved to GetSuitability() for proper ordering

-    // Mesa Intel drivers on UHD 620 have broken EDS causing extreme flickering - unknown if it affects other iGPUs
-    // ALSO affects ALL versions of UHD drivers on Windows 10+, seems to cause even worse issues like straight up crashing
-    // So... Yeah, UHD drivers fucking suck -- maybe one day we can work past this, maybe; some driver hacking?
-    // And then we can rest in peace by doing `< VK_MAKE_API_VERSION(26, 0, 0)` for our beloved mesa drivers... one day
-    if ((is_mvk || (is_integrated && is_intel_anv) || (is_integrated && is_intel_windows)) && Settings::values.dyna_state.GetValue() != 0) {
-        LOG_WARNING(Render_Vulkan, "Driver has broken dynamic state, forcing to 0 to prevent graphical issues");
-        Settings::values.dyna_state.SetValue(0);
-    }
-
-    if (Settings::values.dyna_state.GetValue() == 0) {
+#ifdef ANDROID
+    // Stock Qualcomm and ARM Mali drivers don't report VK_FORMAT_*_SSCALED/USCALED formats
+    // Turnip implements them in software, so only force emulation for stock drivers
+    if ((is_qualcomm && !is_turnip) || is_arm) {
        must_emulate_scaled_formats = true;
-        LOG_INFO(Render_Vulkan, "Extended dynamic state is fully disabled, scaled format emulation is ON");
-
-        RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color, VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
-        RemoveExtensionFeature(extensions.extended_dynamic_state, features.extended_dynamic_state, VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
-        RemoveExtensionFeature(extensions.extended_dynamic_state2, features.extended_dynamic_state2, VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME);
-        RemoveExtensionFeature(extensions.extended_dynamic_state3, features.extended_dynamic_state3, VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
-        RemoveExtensionFeature(extensions.vertex_input_dynamic_state, features.vertex_input_dynamic_state, VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
-        dynamic_state3_blending = false;
-        dynamic_state3_enables = false;
-
-        LOG_INFO(Render_Vulkan, "All dynamic state extensions and features have been disabled");
+        LOG_INFO(Render_Vulkan, "Mobile GPU detected: forcing scaled format emulation (hardware limitation)");
    } else {
        must_emulate_scaled_formats = false;
-        LOG_INFO(Render_Vulkan, "Extended dynamic state is enabled, scaled format emulation is OFF");
    }
+#else
+    // Desktop GPUs support scaled formats natively
+    must_emulate_scaled_formats = false;
+#endif

    logical = vk::Device::Create(physical, queue_cis, ExtensionListForVulkan(loaded_extensions), first_next, dld);

@@ -800,15 +792,32 @@ Device::~Device() {
 VkFormat Device::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
                                    FormatType format_type) const {
    if (IsFormatSupported(wanted_format, wanted_usage, format_type)) {
-        return wanted_format;
+        // Critical: Even if format is "supported", check for STORAGE + HDR + no MSAA support
+        // Driver may report STORAGE_IMAGE_BIT but shaderStorageImageMultisample=false means
+        // it will fail at runtime when used with MSAA (CopyImageMSAA silently fails)
+        const bool requests_storage = (wanted_usage & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0;
+        const bool is_hdr_format = wanted_format == VK_FORMAT_B10G11R11_UFLOAT_PACK32;
+        
+        // If driver doesn't support shader storage image with MSAA, and we're requesting storage
+        // for an HDR format (which will likely be used with MSAA), force fallback
+        if (requests_storage && is_hdr_format && !features.features.shaderStorageImageMultisample) {
+            LOG_WARNING(Render_Vulkan,
+                      "Format {} reports STORAGE_IMAGE_BIT but driver doesn't support "
+                      "shaderStorageImageMultisample. Forcing fallback for MSAA compatibility.",
+                      wanted_format);
+            // Continue to alternatives search below
+        } else {
+            return wanted_format;
+        }
    }
    // The wanted format is not supported by hardware, search for alternatives
    const VkFormat* alternatives = GetFormatAlternatives(wanted_format);
    if (alternatives == nullptr) {
        LOG_ERROR(Render_Vulkan,
-                  "Format={} with usage={} and type={} has no defined alternatives and host "
-                  "hardware does not support it",
-                  wanted_format, wanted_usage, format_type);
+                  "Format={} (0x{:X}) with usage={} and type={} has no defined alternatives and host "
+                  "hardware does not support it. Driver: {} Device: {}",
+                  wanted_format, static_cast<u32>(wanted_format), wanted_usage, format_type,
+                  GetDriverName(), properties.properties.deviceName);
        return wanted_format;
    }

@@ -817,9 +826,17 @@ VkFormat Device::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags
        if (!IsFormatSupported(alternative, wanted_usage, format_type)) {
            continue;
        }
-        LOG_DEBUG(Render_Vulkan,
+        // Special logging for HDR formats (common across multiple engines) on problematic drivers
+        if (wanted_format == VK_FORMAT_B10G11R11_UFLOAT_PACK32) {
+            LOG_WARNING(Render_Vulkan,
+                  "B10G11R11_UFLOAT_PACK32 (R11G11B10F HDR format) not fully supported. "
+                  "Falling back to {} on {}",
+                  alternative, properties.properties.deviceName);
+        } else {
+            LOG_DEBUG(Render_Vulkan,
                  "Emulating format={} with alternative format={} with usage={} and type={}",
                  wanted_format, alternative, wanted_usage, format_type);
+        }
        return alternative;
    }

@@ -1202,6 +1219,148 @@ bool Device::GetSuitability(bool requires_swapchain) {
        }
    }

+    // CRITICAL: Apply driver-specific feature workarounds BEFORE validation
+    // These blacklists disable broken features on specific drivers to prevent
+    // rendering issues and crashes.
+    // MUST execute before RemoveUnsuitableExtensions() calculates feature flags.
+    
+    const VkDriverId driver_id = properties.driver.driverID;
+    const bool is_radv = driver_id == VK_DRIVER_ID_MESA_RADV;
+    const bool is_amd_driver =
+        driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE;
+    const bool is_intel_windows = driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
+    const bool is_intel_anv = driver_id == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
+    const bool is_qualcomm = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
+    const bool is_mvk = driver_id == VK_DRIVER_ID_MOLTENVK;
+    const bool is_integrated = properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
+    
+    // VK_DYNAMIC_STATE
+    
+    // Mesa Intel drivers on UHD 620 have broken EDS causing extreme flickering - unknown if it affects other iGPUs
+    // ALSO affects ALL versions of UHD drivers on Windows 10+, seems to cause even worse issues like straight up crashing
+    // So... Yeah, UHD drivers fucking suck -- maybe one day we can work past this, maybe; some driver hacking?
+    // And then we can rest in peace by doing `< VK_MAKE_API_VERSION(26, 0, 0)` for our beloved mesa drivers... one day
+    // Disable dynamic state on affected drivers
+    if ((is_mvk || (is_integrated && is_intel_anv) || (is_integrated && is_intel_windows)) && 
+        Settings::values.dyna_state.GetValue() != 0) {
+        LOG_WARNING(Render_Vulkan, 
+                    "Intel iGPU/MoltenVK: Forcing dyna_state=0 due to broken dynamic state implementation");
+        Settings::values.dyna_state.SetValue(0);
+    }
+
+    // VK_EXT_extended_dynamic_state
+    
+    // RADV < 21.2.0: Broken ExtendedDynamicState implementation
+    // Disable entire extension on old drivers
+    if (extensions.extended_dynamic_state && is_radv) {
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version < VK_MAKE_API_VERSION(0, 21, 2, 0)) {
+            LOG_WARNING(Render_Vulkan,
+                        "RADV < 21.2.0: Disabling broken VK_EXT_extended_dynamic_state");
+            features.extended_dynamic_state.extendedDynamicState = false;
+        }
+    }
+    
+    // VK_EXT_extended_dynamic_state2
+    
+    // RADV < 22.3.1: Broken ExtendedDynamicState2 implementation
+    // Disable entire extension on old drivers
+    if (extensions.extended_dynamic_state2 && is_radv) {
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version < VK_MAKE_API_VERSION(0, 22, 3, 1)) {
+            LOG_WARNING(Render_Vulkan,
+                        "RADV < 22.3.1: Disabling broken VK_EXT_extended_dynamic_state2");
+            features.extended_dynamic_state2.extendedDynamicState2 = false;
+        }
+    }
+    
+    // Qualcomm Adreno 7xx (drivers 676.0 - 679.x): Broken ExtendedDynamicState2
+    // Disable ExtendedDynamicState2 on affected driver versions
+    if (extensions.extended_dynamic_state2 && is_qualcomm) {
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version >= VK_MAKE_API_VERSION(0, 0, 676, 0) &&
+            version < VK_MAKE_API_VERSION(0, 0, 680, 0)) {
+            LOG_WARNING(Render_Vulkan,
+                        "Qualcomm Adreno 7xx (676-679): Disabling broken VK_EXT_extended_dynamic_state2");
+            features.extended_dynamic_state2.extendedDynamicState2 = false;
+        }
+    }
+    
+    // VK_EXT_extended_dynamic_state3
+    
+    // AMD/Samsung: Broken extendedDynamicState3ColorBlendEquation
+    // Disable blend equation dynamic state, force static pipeline state
+    if (extensions.extended_dynamic_state3 && 
+        (is_amd_driver || driver_id == VK_DRIVER_ID_SAMSUNG_PROPRIETARY)) {
+        LOG_WARNING(Render_Vulkan,
+                    "AMD/Samsung: Disabling broken extendedDynamicState3ColorBlendEquation");
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+    }
+
+    // RADV: Broken extendedDynamicState3ColorBlendEquation
+    // Disable problematic features based on driver version < 23.1.0
+    if (extensions.extended_dynamic_state3 && is_radv) {
+        LOG_WARNING(Render_Vulkan, "RADV: Disabling broken extendedDynamicState3ColorBlendEquation");
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version < VK_MAKE_API_VERSION(0, 23, 1, 0)) {
+            LOG_WARNING(Render_Vulkan,
+                        "RADV < 23.1.0: Disabling broken depth clamp dynamic state");
+            features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = false;
+        }
+    }
+    
+    // VK_EXT_vertex_input_dynamic_state
+    
+    // RADV + RDNA2: Broken VertexInputDynamicState on RDNA2 hardware
+    // Disable VertexInputDynamicState on RDNA2
+    if (extensions.vertex_input_dynamic_state && is_radv) {
+        const bool is_rdna2 =
+            supported_extensions.contains(VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
+        if (is_rdna2) {
+            LOG_WARNING(Render_Vulkan,
+                        "RADV + RDNA2: Disabling broken VK_EXT_vertex_input_dynamic_state");
+            features.vertex_input_dynamic_state.vertexInputDynamicState = false;
+        }
+    }
+    
+    // Qualcomm: Broken VertexInputDynamicState implementation
+    // Disable VertexInputDynamicState on all Qualcomm drivers
+    if (extensions.vertex_input_dynamic_state && is_qualcomm) {
+        LOG_WARNING(Render_Vulkan,
+                    "Qualcomm: Disabling broken VK_EXT_vertex_input_dynamic_state");
+        features.vertex_input_dynamic_state.vertexInputDynamicState = false;
+    }
+    
+    // Intel Windows < 27.20.100.0: Broken VertexInputDynamicState
+    // Disable VertexInputDynamicState on old Intel Windows drivers
+    if (extensions.vertex_input_dynamic_state && is_intel_windows) {
+        const u32 version = (properties.properties.driverVersion << 3) >> 3;
+        if (version < VK_MAKE_API_VERSION(27, 20, 100, 0)) {
+            LOG_WARNING(Render_Vulkan,
+                        "Intel Windows < 27.20.100.0: Disabling broken VK_EXT_vertex_input_dynamic_state");
+            features.vertex_input_dynamic_state.vertexInputDynamicState = false;
+        }
+    }
+    
+    // If user setting is dyna_state=0, disable all dynamic state features
+    if (Settings::values.dyna_state.GetValue() == 0) {
+        LOG_INFO(Render_Vulkan, "Dynamic state disabled by user setting, clearing all EDS features");
+        features.custom_border_color.customBorderColors = false;
+        features.custom_border_color.customBorderColorWithoutFormat = false;
+        features.extended_dynamic_state.extendedDynamicState = false;
+        features.extended_dynamic_state2.extendedDynamicState2 = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorBlendEquation = false;
+        features.extended_dynamic_state3.extendedDynamicState3ColorWriteMask = false;
+        features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable = false;
+        features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable = false;
+        // Note: vertex_input_dynamic_state has independent toggle, NOT affected by dyna_state=0
+    }
+
    // Return whether we were suitable.
    return suitable;
 }
@@ -1267,6 +1426,43 @@ void Device::RemoveUnsuitableExtensions() {
                               VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
    }

+    // VK_KHR_shader_float16_int8
+    const bool float16_int8_requested = extensions.shader_float16_int8;
+    const bool float16_int8_usable =
+        features.shader_float16_int8.shaderFloat16 || features.shader_float16_int8.shaderInt8;
+    if (float16_int8_requested && !float16_int8_usable) {
+        LOG_WARNING(Render_Vulkan,
+                    "Disabling VK_KHR_shader_float16_int8 — no shaderFloat16/shaderInt8 features reported");
+    }
+    extensions.shader_float16_int8 = float16_int8_requested && float16_int8_usable;
+    RemoveExtensionFeatureIfUnsuitable(float16_int8_usable, features.shader_float16_int8,
+                                       VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME);
+
+    // VK_EXT_shader_atomic_float
+    const bool atomic_float_requested = extensions.shader_atomic_float;
+    const auto& atomic_float_features = features.shader_atomic_float;
+    const bool supports_buffer_f32 = atomic_float_features.shaderBufferFloat32Atomics ||
+                                     atomic_float_features.shaderBufferFloat32AtomicAdd;
+    const bool supports_shared_f32 = atomic_float_features.shaderSharedFloat32Atomics ||
+                                     atomic_float_features.shaderSharedFloat32AtomicAdd;
+    const bool supports_image_f32 = atomic_float_features.shaderImageFloat32Atomics ||
+                                    atomic_float_features.shaderImageFloat32AtomicAdd;
+    const bool supports_sparse_f32 = atomic_float_features.sparseImageFloat32Atomics ||
+                                     atomic_float_features.sparseImageFloat32AtomicAdd;
+    const bool supports_buffer_f64 = atomic_float_features.shaderBufferFloat64Atomics ||
+                                     atomic_float_features.shaderBufferFloat64AtomicAdd;
+    const bool supports_shared_f64 = atomic_float_features.shaderSharedFloat64Atomics ||
+                                     atomic_float_features.shaderSharedFloat64AtomicAdd;
+    const bool atomic_float_usable = supports_buffer_f32 || supports_shared_f32 || supports_image_f32 ||
+                                     supports_sparse_f32 || supports_buffer_f64 || supports_shared_f64;
+    if (atomic_float_requested && !atomic_float_usable) {
+        LOG_WARNING(Render_Vulkan,
+                    "Disabling VK_EXT_shader_atomic_float — no usable atomic float feature bits reported");
+    }
+    extensions.shader_atomic_float = atomic_float_requested && atomic_float_usable;
+    RemoveExtensionFeatureIfUnsuitable(atomic_float_usable, features.shader_atomic_float,
+                                       VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME);
+
    // VK_KHR_shader_atomic_int64
    extensions.shader_atomic_int64 = features.shader_atomic_int64.shaderBufferInt64Atomics &&
                                     features.shader_atomic_int64.shaderSharedInt64Atomics;
@@ -1300,12 +1496,34 @@ void Device::RemoveUnsuitableExtensions() {
    RemoveExtensionFeatureIfUnsuitable(extensions.transform_feedback, features.transform_feedback,
                                       VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);

+    // VK_EXT_robustness2
+    extensions.robustness_2 =
+        features.robustness2.robustBufferAccess2 && features.robustness2.robustImageAccess2;
+    RemoveExtensionFeatureIfUnsuitable(extensions.robustness_2, features.robustness2,
+                                       VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
+
+    // VK_EXT_image_robustness
+    extensions.image_robustness = features.image_robustness.robustImageAccess;
+    RemoveExtensionFeatureIfUnsuitable(extensions.image_robustness, features.image_robustness,
+                                       VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME);
+
+    // VK_EXT_swapchain_maintenance1
+    extensions.swapchain_maintenance1 = loaded_extensions.contains(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME);
+    RemoveExtensionIfUnsuitable(extensions.swapchain_maintenance1, VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME);
+
    // VK_EXT_vertex_input_dynamic_state
-    extensions.vertex_input_dynamic_state =
-        features.vertex_input_dynamic_state.vertexInputDynamicState;
-    RemoveExtensionFeatureIfUnsuitable(extensions.vertex_input_dynamic_state,
-                                       features.vertex_input_dynamic_state,
-                                       VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+    if (Settings::values.vertex_input_dynamic_state.GetValue()) {
+        extensions.vertex_input_dynamic_state =
+            features.vertex_input_dynamic_state.vertexInputDynamicState;
+        RemoveExtensionFeatureIfUnsuitable(extensions.vertex_input_dynamic_state,
+                                           features.vertex_input_dynamic_state,
+                                           VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+    } else {
+        RemoveExtensionFeature(extensions.vertex_input_dynamic_state,
+                               features.vertex_input_dynamic_state,
+                               VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+        LOG_INFO(Render_Vulkan, "Vertex Input Dynamic State disabled by user setting");
+    }

    // VK_KHR_pipeline_executable_properties
    if (Settings::values.renderer_shader_feedback.GetValue()) {
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@@ -49,9 +49,11 @@ VK_DEFINE_HANDLE(VmaAllocator)
    FEATURE(EXT, ExtendedDynamicState, EXTENDED_DYNAMIC_STATE, extended_dynamic_state)             \
    FEATURE(EXT, ExtendedDynamicState2, EXTENDED_DYNAMIC_STATE_2, extended_dynamic_state2)         \
    FEATURE(EXT, ExtendedDynamicState3, EXTENDED_DYNAMIC_STATE_3, extended_dynamic_state3)         \
+    FEATURE(EXT, ShaderAtomicFloat, SHADER_ATOMIC_FLOAT, shader_atomic_float)                      \
    FEATURE(EXT, 4444Formats, 4444_FORMATS, format_a4b4g4r4)                                       \
    FEATURE(EXT, IndexTypeUint8, INDEX_TYPE_UINT8, index_type_uint8)                               \
    FEATURE(EXT, LineRasterization, LINE_RASTERIZATION, line_rasterization)                        \
+    FEATURE(EXT, ImageRobustness, IMAGE_ROBUSTNESS, image_robustness)                              \
    FEATURE(EXT, PrimitiveTopologyListRestart, PRIMITIVE_TOPOLOGY_LIST_RESTART,                    \
            primitive_topology_list_restart)                                                       \
    FEATURE(EXT, ProvokingVertex, PROVOKING_VERTEX, provoking_vertex)                              \
@@ -61,7 +63,9 @@ VK_DEFINE_HANDLE(VmaAllocator)
    FEATURE(KHR, PipelineExecutableProperties, PIPELINE_EXECUTABLE_PROPERTIES,                     \
            pipeline_executable_properties)                                                        \
    FEATURE(KHR, WorkgroupMemoryExplicitLayout, WORKGROUP_MEMORY_EXPLICIT_LAYOUT,                  \
-            workgroup_memory_explicit_layout)
+            workgroup_memory_explicit_layout)                                                      \
+    FEATURE(QCOM, ImageProcessing, IMAGE_PROCESSING, image_processing_qcom)                        \
+    FEATURE(QCOM, TileProperties, TILE_PROPERTIES, tile_properties_qcom)

 // Define miscellaneous extensions which may be used by the implementation here.
 #define FOR_EACH_VK_EXTENSION(EXTENSION)                                                           \
@@ -82,7 +86,9 @@ VK_DEFINE_HANDLE(VmaAllocator)
    EXTENSION(KHR, SHADER_FLOAT_CONTROLS, shader_float_controls)                                   \
    EXTENSION(KHR, SPIRV_1_4, spirv_1_4)                                                           \
    EXTENSION(KHR, SWAPCHAIN, swapchain)                                                           \
+    EXTENSION(KHR, INCREMENTAL_PRESENT, incremental_present)                                       \
    EXTENSION(KHR, SWAPCHAIN_MUTABLE_FORMAT, swapchain_mutable_format)                             \
+    EXTENSION(EXT, SWAPCHAIN_MAINTENANCE_1, swapchain_maintenance1)                                \
    EXTENSION(KHR, IMAGE_FORMAT_LIST, image_format_list)                                           \
    EXTENSION(NV, DEVICE_DIAGNOSTICS_CONFIG, device_diagnostics_config)                            \
    EXTENSION(NV, GEOMETRY_SHADER_PASSTHROUGH, geometry_shader_passthrough)                        \
@@ -90,7 +96,22 @@ VK_DEFINE_HANDLE(VmaAllocator)
    EXTENSION(NV, VIEWPORT_SWIZZLE, viewport_swizzle)                                              \
    EXTENSION(EXT, DESCRIPTOR_INDEXING, descriptor_indexing)                                       \
    EXTENSION(EXT, FILTER_CUBIC, filter_cubic)                                                     \
-    EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)
+    EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)                                    \
+    EXTENSION(QCOM, RENDER_PASS_SHADER_RESOLVE, render_pass_shader_resolve)                        \
+    EXTENSION(QCOM, RENDER_PASS_STORE_OPS, render_pass_store_ops)                                  \
+    EXTENSION(QCOM, RENDER_PASS_TRANSFORM, render_pass_transform)                                  \
+    EXTENSION(QCOM, ROTATED_COPY_COMMANDS, rotated_copy_commands)                                  \
+    EXTENSION(QCOM, IMAGE_PROCESSING, image_processing)                                            \
+    EXTENSION(QCOM, TILE_PROPERTIES, tile_properties)                                               \
+    EXTENSION(KHR, MAINTENANCE_1, maintenance1)                                                    \
+    EXTENSION(KHR, MAINTENANCE_2, maintenance2)                                                    \
+    EXTENSION(KHR, MAINTENANCE_3, maintenance3)                                                    \
+    EXTENSION(KHR, MAINTENANCE_4, maintenance4)                                                    \
+    EXTENSION(KHR, MAINTENANCE_5, maintenance5)                                                    \
+    EXTENSION(KHR, MAINTENANCE_6, maintenance6)                                                    \
+    EXTENSION(KHR, MAINTENANCE_7, maintenance7)                                                    \
+    EXTENSION(KHR, MAINTENANCE_8, maintenance8)                                                    \
+    EXTENSION(KHR, MAINTENANCE_9, maintenance9)

 // Define extensions which must be supported.
 #define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
@@ -365,6 +386,12 @@ public:
        return properties.subgroup_properties.supportedOperations & feature;
    }

+    /// Returns true if subgroup operations are supported in the specified shader stage.
+    /// Mobile GPUs (Qualcomm Adreno) often only support subgroups in fragment/compute stages.
+    bool IsSubgroupSupportedForStage(VkShaderStageFlagBits stage) const {
+        return properties.subgroup_properties.supportedStages & stage;
+    }
+
    /// Returns the maximum number of push descriptors.
    u32 MaxPushDescriptors() const {
        return properties.push_descriptor.maxPushDescriptors;
@@ -455,6 +482,11 @@ public:
        return extensions.image_format_list || instance_version >= VK_API_VERSION_1_2;
    }

+    /// Returns true if the device supports VK_KHR_incremental_present.
+    bool IsKhrIncrementalPresentSupported() const {
+        return extensions.incremental_present;
+    }
+
    /// Returns true if the device supports VK_EXT_primitive_topology_list_restart.
    bool IsTopologyListPrimitiveRestartSupported() const {
        return features.primitive_topology_list_restart.primitiveTopologyListRestart;
@@ -520,6 +552,21 @@ public:
        return extensions.custom_border_color;
    }

+    /// Base Vulkan Dynamic State support checks.
+    /// These provide granular control over each base dynamic state, allowing individual states
+    /// to be disabled if broken driver implementations are detected at device initialization.
+    /// By default all states are enabled. If a specific driver has issues with certain states,
+    /// they can be disabled in vulkan_device.cpp constructor (see has_broken_compute pattern).
+    bool SupportsDynamicViewport() const { return supports_dynamic_viewport; }
+    bool SupportsDynamicScissor() const { return supports_dynamic_scissor; }
+    bool SupportsDynamicLineWidth() const { return supports_dynamic_line_width; }
+    bool SupportsDynamicDepthBias() const { return supports_dynamic_depth_bias; }
+    bool SupportsDynamicBlendConstants() const { return supports_dynamic_blend_constants; }
+    bool SupportsDynamicDepthBounds() const { return supports_dynamic_depth_bounds; }
+    bool SupportsDynamicStencilCompareMask() const { return supports_dynamic_stencil_compare; }
+    bool SupportsDynamicStencilWriteMask() const { return supports_dynamic_stencil_write; }
+    bool SupportsDynamicStencilReference() const { return supports_dynamic_stencil_reference; }
+
    /// Returns true if the device supports VK_EXT_extended_dynamic_state.
    bool IsExtExtendedDynamicStateSupported() const {
        return extensions.extended_dynamic_state;
@@ -554,6 +601,98 @@ public:
        return dynamic_state3_enables;
    }

+    // EDS2 granular feature checks
+    bool IsExtExtendedDynamicState2LogicOpSupported() const {
+        return extensions.extended_dynamic_state2 && 
+               features.extended_dynamic_state2.extendedDynamicState2LogicOp;
+    }
+
+    bool IsExtExtendedDynamicState2PatchControlPointsSupported() const {
+        return extensions.extended_dynamic_state2 && 
+               features.extended_dynamic_state2.extendedDynamicState2PatchControlPoints;
+    }
+
+    // EDS3 granular feature checks
+    bool IsExtExtendedDynamicState3DepthClampEnableSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3DepthClampEnable;
+    }
+
+    bool IsExtExtendedDynamicState3LogicOpEnableSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3LogicOpEnable;
+    }
+
+    bool IsExtExtendedDynamicState3TessellationDomainOriginSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3TessellationDomainOrigin;
+    }
+
+    bool IsExtExtendedDynamicState3PolygonModeSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3PolygonMode;
+    }
+
+    bool IsExtExtendedDynamicState3RasterizationSamplesSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3RasterizationSamples;
+    }
+
+    bool IsExtExtendedDynamicState3SampleMaskSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3SampleMask;
+    }
+
+    bool IsExtExtendedDynamicState3AlphaToCoverageEnableSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3AlphaToCoverageEnable;
+    }
+
+    bool IsExtExtendedDynamicState3AlphaToOneEnableSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3AlphaToOneEnable;
+    }
+
+    bool IsExtExtendedDynamicState3DepthClipEnableSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3DepthClipEnable;
+    }
+
+    bool IsExtExtendedDynamicState3DepthClipNegativeOneToOneSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3DepthClipNegativeOneToOne;
+    }
+
+    bool IsExtExtendedDynamicState3LineRasterizationModeSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3LineRasterizationMode;
+    }
+
+    bool IsExtExtendedDynamicState3LineStippleEnableSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3LineStippleEnable;
+    }
+
+    bool IsExtExtendedDynamicState3ProvokingVertexModeSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3ProvokingVertexMode;
+    }
+
+    bool IsExtExtendedDynamicState3ConservativeRasterizationModeSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3ConservativeRasterizationMode;
+    }
+
+    bool IsExtExtendedDynamicState3SampleLocationsEnableSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3SampleLocationsEnable;
+    }
+
+    bool IsExtExtendedDynamicState3RasterizationStreamSupported() const {
+        return extensions.extended_dynamic_state3 && 
+               features.extended_dynamic_state3.extendedDynamicState3RasterizationStream;
+    }
+
    /// Returns true if the device supports VK_EXT_filter_cubic
    bool IsExtFilterCubicSupported() const {
        return extensions.filter_cubic;
@@ -564,6 +703,56 @@ public:
        return extensions.filter_cubic_weights;
    }

+    /// Returns true if the device supports VK_QCOM_render_pass_shader_resolve
+    bool IsQcomRenderPassShaderResolveSupported() const {
+        return extensions.render_pass_shader_resolve;
+    }
+
+    /// Returns true if the device supports VK_QCOM_render_pass_store_ops
+    bool IsQcomRenderPassStoreOpsSupported() const {
+        return extensions.render_pass_store_ops;
+    }
+
+    /// Returns true if the device supports VK_QCOM_tile_properties
+    bool IsQcomTilePropertiesSupported() const {
+        return extensions.tile_properties;
+    }
+
+    /// Returns true if the device supports VK_QCOM_render_pass_transform
+    bool IsQcomRenderPassTransformSupported() const {
+        return extensions.render_pass_transform;
+    }
+
+    /// Returns true if the device supports VK_QCOM_rotated_copy_commands
+    bool IsQcomRotatedCopyCommandsSupported() const {
+        return extensions.rotated_copy_commands;
+    }
+
+    /// Returns true if the device supports VK_QCOM_image_processing
+    bool IsQcomImageProcessingSupported() const {
+        return extensions.image_processing;
+    }
+
+    /// Returns Qualcomm tile size (width, height, depth). Returns {0,0,0} if not queried or unsupported
+    VkExtent3D GetQcomTileSize() const {
+        return properties.qcom_tile_size;
+    }
+
+    /// Returns Qualcomm tile apron size. Returns {0,0} if not queried or unsupported
+    VkExtent2D GetQcomApronSize() const {
+        return properties.qcom_apron_size;
+    }
+
+    /// Returns true if MSAA copy operations are supported via compute shader (upload/download)
+    /// Qualcomm uses render pass shader resolve instead, so this returns false for Qualcomm
+    bool CanUploadMSAA() const {
+        return IsStorageImageMultisampleSupported();
+    }
+
+    bool CanDownloadMSAA() const {
+        return CanUploadMSAA();
+    }
+
    /// Returns true if the device supports VK_EXT_line_rasterization.
    bool IsExtLineRasterizationSupported() const {
        return extensions.line_rasterization;
@@ -594,6 +783,11 @@ public:
        return extensions.shader_atomic_int64;
    }

+    /// Returns true if the device supports VK_EXT_shader_atomic_float.
+    bool IsExtShaderAtomicFloatSupported() const {
+        return extensions.shader_atomic_float;
+    }
+
    bool IsExtConditionalRendering() const {
        return extensions.conditional_rendering;
    }
@@ -817,8 +1011,9 @@ private:
        VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor{};
        VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
        VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
-
        VkPhysicalDeviceProperties properties{};
+        VkExtent3D qcom_tile_size{};          // Qualcomm tile dimensions (0 if not queried)
+        VkExtent2D qcom_apron_size{};         // Qualcomm tile apron size
    };

    Extensions extensions{};
@@ -849,6 +1044,22 @@ private:
    bool dynamic_state3_blending{};            ///< Has all blending features of dynamic_state3.
    bool dynamic_state3_enables{};             ///< Has all enables features of dynamic_state3.
    bool supports_conditional_barriers{};      ///< Allows barriers in conditional control flow.
+
+    /// Base Vulkan Dynamic State support flags (granular fallback for broken drivers).
+    /// All default to true. These can be individually disabled in vulkan_device.cpp
+    /// if specific broken driver implementations are detected during initialization.
+    /// This provides emergency protection against drivers that report support but crash/misbehave.
+    /// Pattern: Check driver/device and set to false in vulkan_device.cpp constructor.
+    bool supports_dynamic_viewport{true};         ///< VK_DYNAMIC_STATE_VIEWPORT
+    bool supports_dynamic_scissor{true};          ///< VK_DYNAMIC_STATE_SCISSOR
+    bool supports_dynamic_line_width{true};       ///< VK_DYNAMIC_STATE_LINE_WIDTH
+    bool supports_dynamic_depth_bias{true};       ///< VK_DYNAMIC_STATE_DEPTH_BIAS
+    bool supports_dynamic_blend_constants{true};  ///< VK_DYNAMIC_STATE_BLEND_CONSTANTS
+    bool supports_dynamic_depth_bounds{true};     ///< VK_DYNAMIC_STATE_DEPTH_BOUNDS
+    bool supports_dynamic_stencil_compare{true};  ///< VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK
+    bool supports_dynamic_stencil_write{true};    ///< VK_DYNAMIC_STATE_STENCIL_WRITE_MASK
+    bool supports_dynamic_stencil_reference{true};///< VK_DYNAMIC_STATE_STENCIL_REFERENCE
+
    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};
--- a/src/video_core/vulkan_common/vulkan_memory_allocator.cpp
+++ b/src/video_core/vulkan_common/vulkan_memory_allocator.cpp
@@ -226,11 +226,24 @@ namespace Vulkan {
    vk::Buffer
    MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage) const
    {
+        // Qualcomm uses unified memory architecture - prefer DEVICE_LOCAL + HOST_VISIBLE
+        // for zero-copy access without staging buffers
+        const bool is_qualcomm = device.GetDriverID() == VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
+        const bool prefer_unified = is_qualcomm && (usage == MemoryUsage::Upload ||
+                                                     usage == MemoryUsage::Download ||
+                                                     usage == MemoryUsage::Stream);
+
+        VkMemoryPropertyFlags preferred_flags = MemoryUsagePreferredVmaFlags(usage);
+        if (prefer_unified) {
+            // Request DEVICE_LOCAL + HOST_VISIBLE for zero-copy on unified memory architectures
+            preferred_flags |= VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+        }
+
        const VmaAllocationCreateInfo alloc_ci = {
                .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage),
                .usage = MemoryUsageVma(usage),
                .requiredFlags = 0,
-                .preferredFlags = MemoryUsagePreferredVmaFlags(usage),
+                .preferredFlags = preferred_flags,
                .memoryTypeBits = usage == MemoryUsage::Stream ? 0u : valid_memory_types,
                .pool = VK_NULL_HANDLE,
                .pUserData = nullptr,
@@ -245,6 +258,13 @@ namespace Vulkan {
        vk::Check(vmaCreateBuffer(allocator, &ci, &alloc_ci, &handle, &allocation, &alloc_info));
        vmaGetAllocationMemoryProperties(allocator, allocation, &property_flags);

+        if (is_qualcomm && prefer_unified) {
+            const bool got_unified = (property_flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) &&
+                                     (property_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+            LOG_DEBUG(Render_Vulkan, "Qualcomm buffer allocation: usage={}, unified={}, flags=0x{:X}",
+                      static_cast<u32>(usage), got_unified, property_flags);
+        }
+
        u8 *data = reinterpret_cast<u8 *>(alloc_info.pMappedData);
        const std::span<u8> mapped_data = data ? std::span<u8>{data, ci.size} : std::span<u8>{};
        const bool is_coherent = (property_flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
Author	SHA1	Message	Date
Bix	d4cfe0b44e	[vk] Reordering disabled broken DynamicState and ExtendedDynamicState	2025-11-22 19:05:10 +01:00
Bix	f3a50cfcf7	[vk] compiler baka baka	2025-11-22 19:04:43 +01:00
Bix	6cfdecbc7b	[vk] Handling padding (compiler tomto)	2025-11-22 19:04:04 +01:00
Bix	d06ef6b83b	Adding missing headers	2025-11-22 19:03:42 +01:00
Bix	963365716e	[vk] Simplifying DynamicState and ExtendedState with Bitfield	2025-11-22 19:03:05 +01:00
Bix	587c601dfe	[vk] Refactor to DynamicState and ExtendedState	2025-11-22 19:02:27 +01:00
CamilleLaVey	bba1904529	[vk] Refactor to DynamicState and ExtendedState	2025-11-17 21:53:34 -04:00
CamilleLaVey	e33d2541d2	[vk, texture_cache] Remove Force Identity in Component Swizzle	2025-11-17 20:55:47 -04:00
CamilleLaVey	3628654a98	[vk, android] Scaled Formats Emulation Only Available on Android	2025-11-17 20:47:49 -04:00
CamilleLaVey	1f5def5756	[vk, pipeline_cache] TEST: Refactor shader float controls handling for Qualcomm devices	2025-11-17 20:30:17 -04:00
CamilleLaVey	ca479883ec	[vk, texture_cache, pipeline_cache] Removing handling for wrong vk formats	2025-11-17 02:13:39 -04:00
PavelBARABANOV	300c913883	comment	2025-11-16 20:11:56 +03:00
PavelBARABANOV	15b9a373cc	[vk] Add Android-specific sRGB fallback format	2025-11-16 20:07:30 +03:00
CamilleLaVey	d19229b179	Fixing building issues again, dammed binding.	2025-11-16 02:20:00 -04:00
CamilleLaVey	0d999519a4	[spir-v] Include more cases for ColorArray1D	2025-11-16 02:03:46 -04:00
CamilleLaVey	92e9b82f6e	[vk, spir-v] Refining the path for Array 1D emulation and R32 Uint handling consistency	2025-11-16 01:48:18 -04:00
CamilleLaVey	21575a7cc2	Fix building/ licensing issues	2025-11-15 23:18:39 -04:00
CamilleLaVey	7d8c5dad97	[vk, texture_cache, pipeline_cache] Refining handling of R32	2025-11-15 23:06:47 -04:00
CamilleLaVey	674f552ff1	[vk, texture_cache] Workaround for games with wrong usage of R32 with float samplers	2025-11-15 19:41:26 -04:00
CamilleLaVey	75d9236520	[vk, pipeline_cache, texture_cache, qcom] Resolving textures and pipeline usage for QCOM	2025-11-15 19:18:00 -04:00
CamilleLaVey	89926bce0b	[vk, spir-v] Adding emulation of Array 1D with 2D for Android	2025-11-15 18:54:53 -04:00
CamilleLaVey	6c1fc4b4ed	[vk] Handling threading missuse of VkQueue	2025-11-15 18:30:31 -04:00
CamilleLaVey	311f06047b	[vk, Maxwell] Refining support for HDR Formats based on Specs	2025-11-15 18:24:14 -04:00
CamilleLaVey	46df717f7c	[vk] Degrade HDR Format to LDR	2025-11-15 16:12:44 -04:00
CamilleLaVey	dcf9483b0b	[vk, qcom] TEST: Adjustment to the MSAA and format resolve with native support	2025-11-15 15:06:43 -04:00
CamilleLaVey	2b828a9fee	[vk] Re-adjusted HDR format handling based on physical specifications	2025-11-15 14:44:47 -04:00
CamilleLaVey	6fe1f86984	[vk, qcom] Revert Push Descriptors Threshold due to data corruption	2025-11-15 14:14:37 -04:00
CamilleLaVey	af073f13cf	[vk, qcom] Including Tile Properties and Store Ops based on QCOM specifications	2025-11-15 03:02:08 -04:00
CamilleLaVey	aea945b671	[vk, host shaders, qcom] MSAA Handling by Native QCOM Shader Resolve	2025-11-15 01:47:28 -04:00
CamilleLaVey	c52fda760a	Merge branch 'stuffmadeforfun' of https://git.eden-emu.dev/eden-emu/eden into stuffmadeforfun	2025-11-14 23:40:23 -04:00
lizzie	c168755c65	fix license	2025-11-15 03:38:33 +00:00
CamilleLaVey	8a83cf0271	[service, hle] Add defensive check in WriteBuffer	2025-11-15 03:37:57 +00:00
CamilleLaVey	3db41fbce6	[memory, vk] TEST: Tiled GPU optimization try #1	2025-11-15 03:37:56 +00:00
CamilleLaVey	5e7fb6eead	Fix building issues	2025-11-15 03:37:56 +00:00
CamilleLaVey	bcc5390943	[texture_cache, gl, vk] Initial implementation for HDR + MSAA detection on QCOM drivers.	2025-11-15 03:37:44 +00:00
CamilleLaVey	a51d875d91	[shader_recompiler, spir-v] verifying int64 emulation path activation	2025-11-15 03:37:17 +00:00
PavelBARABANOV	6134a57367	Revert "TEST: Enabling TimelineSemaphores for QCOM and Turnip" This reverts commit `3cd33fce44`.	2025-11-15 03:37:01 +00:00
CamilleLaVey	c845b6086f	Adding missing headers	2025-11-15 03:37:01 +00:00
CamilleLaVey	31c168efe1	[shader_recompiler, spir-v] Adding INT64 emulation path	2025-11-15 03:36:25 +00:00
CamilleLaVey	8bd87204f5	TEST: Enabling TimelineSemaphores for QCOM and Turnip	2025-11-15 03:36:09 +00:00
lizzie	e72a206aee	fix	2025-11-15 03:36:08 +00:00
CamilleLaVey	6a62fa7ee3	Implement handling for texture cache flickering	2025-11-15 03:36:01 +00:00
crueter	52b630dfdc	build Signed-off-by: crueter <crueter@eden-emu.dev>	2025-11-15 03:35:37 +00:00
CamilleLaVey	4860050358	attempt to fix building issues	2025-11-15 03:35:37 +00:00
CamilleLaVey	47f0563c1b	Giving maintance to driver features and unused extensions	2025-11-15 03:35:35 +00:00
CamilleLaVey	b1208f03ee	Fix building issues	2025-11-15 03:33:30 +00:00
CamilleLaVey	0fd603c094	[texture_cache, gl, vk] Initial implementation for HDR + MSAA detection on QCOM drivers.	2025-11-15 03:33:30 +00:00
CamilleLaVey	1ca19af7fb	[shader_recompiler, spir-v] verifying int64 emulation path activation	2025-11-15 03:33:30 +00:00
PavelBARABANOV	ddd78c3b37	Revert "TEST: Enabling TimelineSemaphores for QCOM and Turnip" This reverts commit `3cd33fce44`.	2025-11-15 03:33:30 +00:00
CamilleLaVey	2e68f8795d	Adding missing headers	2025-11-15 03:33:28 +00:00
CamilleLaVey	d3595fd2b1	[gl, vk, texture cache] Attempt to get correct MSAA image upload and download	2025-11-15 03:33:28 +00:00
CamilleLaVey	033531509b	[shader_recompiler, spir-v] Adding INT64 emulation path	2025-11-15 03:33:28 +00:00
CamilleLaVey	b9954de1ca	Fixing missing headers	2025-11-15 03:33:28 +00:00
CamilleLaVey	5f88deeebf	[gl. vk] Extending impl for atomic floats operations	2025-11-15 03:33:28 +00:00
CamilleLaVey	d25da944ed	Changing checks in HostMemor for virtual memory mapping	2025-11-15 03:33:27 +00:00
CamilleLaVey	ec274a855e	TEST: Enabling TimelineSemaphores for QCOM and Turnip	2025-11-15 03:33:27 +00:00
CamilleLaVey	8133d4a8b4	Improved handling for Custom Border Color buggy impl on ARM/ QCOM and Turnip	2025-11-15 03:33:27 +00:00
lizzie	4f3e4bf9cb	fix	2025-11-15 03:33:27 +00:00
CamilleLaVey	ec9e0f37ea	Implement handling for texture cache flickering	2025-11-15 03:33:27 +00:00
crueter	b5f7735dba	build Signed-off-by: crueter <crueter@eden-emu.dev>	2025-11-15 03:33:27 +00:00
CamilleLaVey	5f501d6ec0	attempt to fix building issues	2025-11-15 03:33:27 +00:00
CamilleLaVey	e820f304a5	Giving maintance to driver features and unused extensions	2025-11-15 03:33:26 +00:00
CamilleLaVey	3527a33430	[service, hle] Add defensive check in WriteBuffer	2025-11-14 20:31:14 -04:00
CamilleLaVey	ee5565077c	[memory, vk] TEST: Tiled GPU optimization try #1	2025-11-14 01:32:02 -04:00
CamilleLaVey	9085ff1229	Merge branch 'stuffmadeforfun' of https://git.eden-emu.dev/eden-emu/eden into stuffmadeforfun	2025-11-13 23:10:40 -04:00
CamilleLaVey	6eff1779a2	Fix building issues	2025-11-14 03:03:28 +01:00
CamilleLaVey	3228cffd23	[texture_cache, gl, vk] Initial implementation for HDR + MSAA detection on QCOM drivers.	2025-11-14 03:03:28 +01:00
CamilleLaVey	9d9530efe0	[shader_recompiler, spir-v] verifying int64 emulation path activation	2025-11-14 03:03:28 +01:00
PavelBARABANOV	aaaa7c7601	Revert "TEST: Enabling TimelineSemaphores for QCOM and Turnip" This reverts commit `3cd33fce44`.	2025-11-14 03:03:28 +01:00
CamilleLaVey	7f8a507b79	Adding missing headers	2025-11-14 03:03:28 +01:00
CamilleLaVey	c28ae059e8	[gl, vk, texture cache] Attempt to get correct MSAA image upload and download	2025-11-14 03:03:28 +01:00
CamilleLaVey	7f1369f9a8	[shader_recompiler, spir-v] Adding INT64 emulation path	2025-11-14 03:03:28 +01:00
CamilleLaVey	6b05c164a1	Fixing missing headers	2025-11-14 03:03:28 +01:00
CamilleLaVey	a3f9d3b59c	[gl. vk] Extending impl for atomic floats operations	2025-11-14 03:03:28 +01:00
CamilleLaVey	b066a6ffa0	Changing checks in HostMemor for virtual memory mapping	2025-11-14 03:03:28 +01:00
CamilleLaVey	a14cba7f11	TEST: Enabling TimelineSemaphores for QCOM and Turnip	2025-11-14 03:03:28 +01:00
CamilleLaVey	2d85b70373	Improved handling for Custom Border Color buggy impl on ARM/ QCOM and Turnip	2025-11-14 03:03:28 +01:00
lizzie	aa8cc4da38	fix	2025-11-14 03:03:28 +01:00
CamilleLaVey	baddaf0040	Implement handling for texture cache flickering	2025-11-14 03:03:28 +01:00
crueter	35b4e34e09	build Signed-off-by: crueter <crueter@eden-emu.dev>	2025-11-14 03:03:28 +01:00
CamilleLaVey	b574e9c334	attempt to fix building issues	2025-11-14 03:03:28 +01:00
CamilleLaVey	d6b5a3e181	Giving maintance to driver features and unused extensions	2025-11-14 03:03:28 +01:00
CamilleLaVey	a65a35432e	Fix building issues	2025-11-13 21:30:19 -04:00
CamilleLaVey	6e575364eb	[texture_cache, gl, vk] Initial implementation for HDR + MSAA detection on QCOM drivers.	2025-11-13 20:37:47 -04:00
CamilleLaVey	71a1442ab6	[shader_recompiler, spir-v] verifying int64 emulation path activation	2025-11-13 18:42:49 -04:00
PavelBARABANOV	4a17762ed7	Revert "TEST: Enabling TimelineSemaphores for QCOM and Turnip" This reverts commit `3cd33fce44`.	2025-11-10 18:52:31 +03:00
CamilleLaVey	447c4de73d	Adding missing headers	2025-11-10 00:27:38 -04:00
CamilleLaVey	cd2c4d8caf	[gl, vk, texture cache] Attempt to get correct MSAA image upload and download	2025-11-10 00:22:08 -04:00
CamilleLaVey	ee64c945fb	[shader_recompiler, spir-v] Adding INT64 emulation path	2025-11-09 23:14:51 -04:00
CamilleLaVey	eec5d48220	Fixing missing headers	2025-11-09 20:03:19 -04:00
CamilleLaVey	75cc43a57a	[gl. vk] Extending impl for atomic floats operations	2025-11-10 00:55:57 +01:00
CamilleLaVey	0078094b86	Changing checks in HostMemor for virtual memory mapping	2025-11-10 00:55:57 +01:00
CamilleLaVey	3cd33fce44	TEST: Enabling TimelineSemaphores for QCOM and Turnip	2025-11-10 00:55:57 +01:00
CamilleLaVey	ccafe0ed91	Improved handling for Custom Border Color buggy impl on ARM/ QCOM and Turnip	2025-11-10 00:55:57 +01:00
lizzie	94af9ff51f	fix	2025-11-10 00:55:57 +01:00
CamilleLaVey	d229fdca32	Implement handling for texture cache flickering	2025-11-10 00:55:57 +01:00
crueter	e636e940ed	build Signed-off-by: crueter <crueter@eden-emu.dev>	2025-11-10 00:55:57 +01:00
CamilleLaVey	2798174b00	attempt to fix building issues	2025-11-10 00:55:57 +01:00
CamilleLaVey	46f2084114	Giving maintance to driver features and unused extensions	2025-11-10 00:55:57 +01:00