[vk] Reordering disabled broken DynamicState and ExtendedDynamicState

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};

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();

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

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

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:
@@ -1605,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 &&

src/shader_recompiler/profile.h

@@ -28,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{};
@@ -87,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{};
 

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,

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,
 };
 

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

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

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;

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, Attachable | Storage},  // E5B9G9R9_FLOAT
 
     // Depth formats
     {VK_FORMAT_D32_SFLOAT, Attachable},          // D32_FLOAT

src/video_core/renderer_vulkan/pipeline_helper.h

@@ -27,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

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{

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)};

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();
 

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);
         }

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,12 +159,14 @@ 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 must be the last subpass in the dependency chain
+        // 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
     }
     

src/video_core/renderer_vulkan/vk_render_pass_cache.h

@@ -25,6 +25,7 @@ struct RenderPassKey {
     // 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)
@@ -38,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);
         }

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:
@@ -1326,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:
@@ -1490,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);
     }
@@ -1513,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() ==
@@ -1552,24 +1640,6 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
                 MakeStorageView(device, level, *original_image, VK_FORMAT_A8B8G8R8_UNORM_PACK32);
         }
     }
-
-    // Proactive warning for problematic HDR format + MSAA combinations on Android
-    // These combinations commonly cause texture flickering/black screens across multiple game engines
-    // Note: MSAA is native Switch rendering technique, cannot be disabled by emulator
-    if (info.num_samples > 1) {
-        const auto vk_format = MaxwellToVK::SurfaceFormat(runtime->device, FormatType::Optimal,
-                                                          false, info.format).format;
-        const bool is_hdr_format = vk_format == VK_FORMAT_B10G11R11_UFLOAT_PACK32 ||
-                                   vk_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
-
-        if (is_hdr_format) {
-            LOG_WARNING(Render_Vulkan,
-                      "Creating MSAA image ({}x samples) with HDR format {} (Maxwell: {}). "
-                      "Driver support may be limited on Android (Qualcomm < 800, Mali pre-maintenance5). "
-                      "Format fallback to RGBA16F should prevent issues.",
-                      info.num_samples, vk_format, info.format);
-        }
-    }
 }
 
 Image::Image(const VideoCommon::NullImageParams& params) : VideoCommon::ImageBase{params} {}
@@ -2050,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,
@@ -2060,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]),
@@ -2077,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;
         }
@@ -2218,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,
@@ -2364,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);

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

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

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

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:

src/video_core/vulkan_common/vulkan_device.cpp

@@ -1,5 +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
 
@@ -89,21 +90,23 @@ constexpr std::array VK_FORMAT_A4B4G4R4_UNORM_PACK16{
     VK_FORMAT_UNDEFINED,
 };
 
-// B10G11R11_UFLOAT (R11G11B10 float) is used by Unreal Engine 5 for HDR textures
-// Some Android drivers (Qualcomm pre-800, Mali pre-maintenance5) have issues with this format
-// when used with MSAA or certain tiling modes, causing texture flickering/black screens
+// 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{
-    VK_FORMAT_R16G16B16A16_SFLOAT, // Fallback: RGBA16F (more memory, but widely supported)
-    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, // Alternative: E5B9G9R9 shared exponent format
-    VK_FORMAT_UNDEFINED,
-};
-
-// E5B9G9R9_UFLOAT (shared exponent RGB9E5) used by various engines (Unity, custom engines)
-// Also problematic on some Android drivers, especially with MSAA and as render target
-constexpr std::array E5B9G9R9_UFLOAT_PACK32{
-    VK_FORMAT_R16G16B16A16_SFLOAT, // Fallback: RGBA16F (safest option)
-    VK_FORMAT_B10G11R11_UFLOAT_PACK32, // Alternative: might work if E5B9G9R9 fails
-    VK_FORMAT_UNDEFINED,
+    #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
@@ -140,8 +143,7 @@ constexpr const VkFormat* GetFormatAlternatives(VkFormat format) {
         return Alternatives::VK_FORMAT_A4B4G4R4_UNORM_PACK16.data();
     case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
         return Alternatives::B10G11R11_UFLOAT_PACK32.data();
-    case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
-        return Alternatives::E5B9G9R9_UFLOAT_PACK32.data();
+
     default:
         return nullptr;
     }
@@ -229,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,
@@ -517,19 +518,20 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
 
     // Driver-specific handling for VK_EXT_custom_border_color
     // On some Qualcomm/Turnip/ARM drivers the extension may be partially implemented.
-    // Enable it if ANY useful feature bit is reported; otherwise, let the removal pass drop it.
+    // 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 custom border color features reported",
+                        "Disabling VK_EXT_custom_border_color on '{}' — no usable features reported",
                         properties.driver.driverName);
-            // Do not clear here; final removal happens in RemoveUnsuitableExtensions based on bits.
+            RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
+                                   VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
         } else {
             LOG_INFO(Render_Vulkan,
-                     "Partial VK_EXT_custom_border_color support detected on '{}' — enabling available features",
+                     "VK_EXT_custom_border_color enabled on '{}' (partial support detected)",
                      properties.driver.driverName);
         }
     }
@@ -539,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;
@@ -588,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) {
@@ -693,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");
@@ -777,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;
     }
 
@@ -789,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);
 
@@ -864,12 +792,11 @@ Device::~Device() {
 VkFormat Device::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
                                     FormatType format_type) const {
     if (IsFormatSupported(wanted_format, wanted_usage, format_type)) {
-        // CRITICAL FIX: Even if format is "supported", check for STORAGE + HDR + no MSAA support
+        // 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 ||
-                                   wanted_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
+        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
@@ -902,13 +829,8 @@ VkFormat Device::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags
         // Special logging for HDR formats (common across multiple engines) on problematic drivers
         if (wanted_format == VK_FORMAT_B10G11R11_UFLOAT_PACK32) {
             LOG_WARNING(Render_Vulkan,
-                  "Emulating B10G11R11_UFLOAT (HDR format: UE5, custom engines) with {} on {}. "
-                  "Native format not supported by driver, using fallback.",
-                  alternative, properties.properties.deviceName);
-        } else if (wanted_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
-            LOG_WARNING(Render_Vulkan,
-                  "Emulating E5B9G9R9_UFLOAT (HDR format: Unity, RE Engine) with {} on {}. "
-                  "Native format not supported by driver, using fallback.",
+                  "B10G11R11_UFLOAT_PACK32 (R11G11B10F HDR format) not fully supported. "
+                  "Falling back to {} on {}",
                   alternative, properties.properties.deviceName);
         } else {
             LOG_DEBUG(Render_Vulkan,
@@ -1297,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;
 }
@@ -1448,11 +1512,18 @@ void Device::RemoveUnsuitableExtensions() {
     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()) {

src/video_core/vulkan_common/vulkan_device.h

@@ -63,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)                                                           \
@@ -96,6 +98,11 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(EXT, FILTER_CUBIC, filter_cubic)                                                     \
     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)                                                    \
@@ -379,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;
@@ -539,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;
@@ -573,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;
@@ -588,6 +708,41 @@ public:
         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 {
@@ -857,6 +1012,8 @@ private:
         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{};
@@ -887,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};

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;