[vk] use RTE for FMZ mode; be more strict on missing FTZ-defaultness

invalidates all vulkan caches now, sorry not sorry, but will fix your broken games :)
Signed-off-by: lizzie <lizzie@eden-emu.dev>

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3114
Reviewed-by: Caio Oliveira <caiooliveirafarias0@gmail.com>
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Co-authored-by: lizzie <lizzie@eden-emu.dev>
Co-committed-by: lizzie <lizzie@eden-emu.dev>

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -338,55 +338,73 @@ void DefineEntryPoint(const IR::Program& program, EmitContext& ctx, Id main) {
     ctx.AddEntryPoint(execution_model, main, "main", interfaces);
 }
 
-void SetupDenormControl(const Profile& profile, const IR::Program& program, EmitContext& ctx,
-                        Id main_func) {
-    const Info& info{program.info};
-    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) {
+void SetupDenormControl(const Profile& profile, IR::Program const& program, EmitContext& ctx, Id main_func) {
+    Info const& info = program.info;
+    switch (info.fp32_denorm) {
+    case Shader::FloatDenormKind::None:
+    default:
+        break;
+    case Shader::FloatDenormKind::DenormFlushToZero:
         if (profile.support_fp32_denorm_flush) {
             ctx.AddCapability(spv::Capability::DenormFlushToZero);
             ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormFlushToZero, 32U);
-        } else {
-            // Drivers will most likely flush denorms by default, no need to warn
+        } else if(!profile.uses_ftz_as_default) {
+            LOG_WARNING(Shader_SPIRV, "f32.ftz requested but not supported");
         }
-    } else if (info.uses_fp32_denorms_preserve) {
+        break;
+    case Shader::FloatDenormKind::RoundingModeRTE:
+        if (profile.support_fp32_round_rte) {
+            ctx.AddCapability(spv::Capability::RoundingModeRTE);
+            ctx.AddExecutionMode(main_func, spv::ExecutionMode::RoundingModeRTE, 32U);
+        } else {
+            LOG_WARNING(Shader_SPIRV, "f32.rte requested but not supported");
+        }
+        break;
+    case Shader::FloatDenormKind::DenormPreserve:
         if (profile.support_fp32_denorm_preserve) {
             ctx.AddCapability(spv::Capability::DenormPreserve);
             ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormPreserve, 32U);
         } else {
-            LOG_DEBUG(Shader_SPIRV, "Fp32 denorm preserve used in shader without host support");
+            LOG_WARNING(Shader_SPIRV, "f32.pre requested but not supported");
         }
+        break;
     }
-    if (!profile.support_separate_denorm_behavior || profile.has_broken_fp16_float_controls) {
-        // No separate denorm behavior
-        return;
-    }
-    if (info.uses_fp16_denorms_flush && info.uses_fp16_denorms_preserve) {
-        LOG_DEBUG(Shader_SPIRV, "Fp16 denorm flush and preserve on the same shader");
-    } else if (info.uses_fp16_denorms_flush) {
-        if (profile.support_fp16_denorm_flush) {
+
+    // No separate denorm behavior
+    bool can_fp16 = !(!profile.support_separate_denorm_behavior || profile.has_broken_fp16_float_controls);
+    switch (info.fp16_denorm) {
+    case Shader::FloatDenormKind::None:
+    default:
+        break;
+    case Shader::FloatDenormKind::DenormFlushToZero:
+        if (can_fp16 && profile.support_fp16_denorm_flush) {
             ctx.AddCapability(spv::Capability::DenormFlushToZero);
             ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormFlushToZero, 16U);
-        } else {
-            // Same as fp32, no need to warn as most drivers will flush by default
+        } else if(!profile.uses_ftz_as_default) {
+            LOG_WARNING(Shader_SPIRV, "f16.ftz requested but not supported");
         }
-    } else if (info.uses_fp16_denorms_preserve) {
-        if (profile.support_fp16_denorm_preserve) {
+        break;
+    case Shader::FloatDenormKind::RoundingModeRTE:
+        if (can_fp16 && profile.support_fp16_round_rte) {
+            ctx.AddCapability(spv::Capability::RoundingModeRTE);
+            ctx.AddExecutionMode(main_func, spv::ExecutionMode::RoundingModeRTE, 16U);
+        } else {
+            LOG_WARNING(Shader_SPIRV, "f16.rte requested but not supported");
+        }
+        break;
+    case Shader::FloatDenormKind::DenormPreserve:
+        if (can_fp16 && profile.support_fp16_denorm_preserve) {
             ctx.AddCapability(spv::Capability::DenormPreserve);
             ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormPreserve, 16U);
         } else {
-            LOG_DEBUG(Shader_SPIRV, "Fp16 denorm preserve used in shader without host support");
+            LOG_WARNING(Shader_SPIRV, "f16.pre requested but not supported");
         }
+        break;
     }
 }
 
-void SetupSignedNanCapabilities(const Profile& profile, const IR::Program& program,
-                                EmitContext& ctx, Id main_func) {
-    if (profile.has_broken_fp16_float_controls && program.info.uses_fp16) {
-        return;
-    }
-    if (program.info.uses_fp16 && profile.support_fp16_signed_zero_nan_preserve) {
+void SetupSignedNanCapabilities(const Profile& profile, const IR::Program& program, EmitContext& ctx, Id main_func) {
+    if (!profile.has_broken_fp16_float_controls && program.info.uses_fp16 && profile.support_fp16_signed_zero_nan_preserve) {
         ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);
         ctx.AddExecutionMode(main_func, spv::ExecutionMode::SignedZeroInfNanPreserve, 16U);
     }

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -76,8 +76,8 @@ std::optional<OutAttr> OutputAttrPointer(EmitContext& ctx, IR::Attribute attr) {
     case IR::Attribute::ClipDistance5:
     case IR::Attribute::ClipDistance6:
     case IR::Attribute::ClipDistance7: {
-        const u32 base{static_cast<u32>(IR::Attribute::ClipDistance0)};
-        const u32 index{static_cast<u32>(attr) - base};
+        const u32 base{u32(IR::Attribute::ClipDistance0)};
+        const u32 index{u32(attr) - base};
         if (index >= ctx.profile.max_user_clip_distances) {
             LOG_WARNING(Shader, "Ignoring clip distance store {} >= {} supported", index,
                         ctx.profile.max_user_clip_distances);

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -198,34 +195,6 @@ Id Texture(EmitContext& ctx, IR::TextureInstInfo info, [[maybe_unused]] const IR
     }
 }
 
-Id TextureColorResultType(EmitContext& ctx, const TextureDefinition& def) {
-    switch (def.component_type) {
-    case SamplerComponentType::Float:
-    case SamplerComponentType::Depth:
-        return ctx.F32[4];
-    case SamplerComponentType::Sint:
-    case SamplerComponentType::Stencil:
-        return ctx.S32[4];
-    case SamplerComponentType::Uint:
-        return ctx.U32[4];
-    }
-    throw InvalidArgument("Invalid sampler component type {}", def.component_type);
-}
-
-Id TextureSampleResultToFloat(EmitContext& ctx, const TextureDefinition& def, Id color) {
-    switch (def.component_type) {
-    case SamplerComponentType::Float:
-    case SamplerComponentType::Depth:
-        return color;
-    case SamplerComponentType::Sint:
-    case SamplerComponentType::Stencil:
-        return ctx.OpConvertSToF(ctx.F32[4], color);
-    case SamplerComponentType::Uint:
-        return ctx.OpConvertUToF(ctx.F32[4], color);
-    }
-    throw InvalidArgument("Invalid sampler component type {}", def.component_type);
-}
-
 Id TextureImage(EmitContext& ctx, IR::TextureInstInfo info, const IR::Value& index) {
     if (!index.IsImmediate() || index.U32() != 0) {
         throw NotImplementedException("Indirect image indexing");
@@ -480,39 +449,31 @@ 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>()};
-    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
-    const Id color_type{TextureColorResultType(ctx, def)};
-    const Id texture{Texture(ctx, info, index)};
-    Id color{};
     if (ctx.stage == Stage::Fragment) {
         const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
                                      bias_lc, offset);
-        color = Emit(&EmitContext::OpImageSparseSampleImplicitLod,
-                     &EmitContext::OpImageSampleImplicitLod, ctx, inst, color_type, texture,
-                     coords, operands.MaskOptional(), operands.Span());
+        return Emit(&EmitContext::OpImageSparseSampleImplicitLod,
+                    &EmitContext::OpImageSampleImplicitLod, ctx, inst, ctx.F32[4],
+                    Texture(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
     } else {
         // We can't use implicit lods on non-fragment stages on SPIR-V. Maxwell hardware behaves as
         // if the lod was explicitly zero.  This may change on Turing with implicit compute
         // derivatives
         const Id lod{ctx.Const(0.0f)};
         const ImageOperands operands(ctx, false, true, info.has_lod_clamp != 0, lod, offset);
-        color = Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                     &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type, texture,
-                     coords, operands.Mask(), operands.Span());
+        return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                    &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
+                    Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
     }
-    return TextureSampleResultToFloat(ctx, def, color);
 }
 
 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>()};
-    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
-    const Id color_type{TextureColorResultType(ctx, def)};
     const ImageOperands operands(ctx, false, true, false, lod, offset);
-    const Id color{Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                        &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type,
-                        Texture(ctx, info, index), coords, operands.Mask(), operands.Span())};
-    return TextureSampleResultToFloat(ctx, def, color);
+    return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
+                Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
 }
 
 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
@@ -548,18 +509,13 @@ 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>()};
-    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
-    const Id color_type{TextureColorResultType(ctx, def)};
     const ImageOperands operands(ctx, offset, offset2);
-    const Id texture{Texture(ctx, info, index)};
     if (ctx.profile.need_gather_subpixel_offset) {
         coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
     }
-    const Id color{
-        Emit(&EmitContext::OpImageSparseGather, &EmitContext::OpImageGather, ctx, inst, color_type,
-             texture, coords, ctx.Const(info.gather_component), operands.MaskOptional(),
-             operands.Span())};
-    return TextureSampleResultToFloat(ctx, def, color);
+    return Emit(&EmitContext::OpImageSparseGather, &EmitContext::OpImageGather, ctx, inst,
+                ctx.F32[4], Texture(ctx, info, index), coords, ctx.Const(info.gather_component),
+                operands.MaskOptional(), operands.Span());
 }
 
 Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
@@ -577,9 +533,6 @@ 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>()};
-    const TextureDefinition* def =
-        info.type == TextureType::Buffer ? nullptr : &ctx.textures.at(info.descriptor_index);
-    const Id result_type{def ? TextureColorResultType(ctx, *def) : ctx.F32[4]};
     AddOffsetToCoordinates(ctx, info, coords, offset);
     if (info.type == TextureType::Buffer) {
         lod = Id{};
@@ -589,13 +542,8 @@ Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id c
         lod = Id{};
     }
     const ImageOperands operands(lod, ms);
-    Id color{Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst,
-                  result_type, TextureImage(ctx, info, index), coords, operands.MaskOptional(),
-                  operands.Span())};
-    if (def) {
-        color = TextureSampleResultToFloat(ctx, *def, color);
-    }
-    return color;
+    return Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst, ctx.F32[4],
+                TextureImage(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
 }
 
 Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id lod,
@@ -640,17 +588,14 @@ 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>()};
-    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
-    const Id color_type{TextureColorResultType(ctx, def)};
     const auto operands = info.num_derivatives == 3
                               ? ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                               ctx.Def(offset), {}, lod_clamp)
                               : ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                               info.num_derivatives, offset, lod_clamp);
-    const Id color{Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                        &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type,
-                        Texture(ctx, info, index), coords, operands.Mask(), operands.Span())};
-    return TextureSampleResultToFloat(ctx, def, color);
+    return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
+                Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
 }
 
 Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords) {

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -28,40 +28,27 @@ enum class Operation {
     FPMax,
 };
 
-Id ComponentScalarType(EmitContext& ctx, SamplerComponentType component_type) {
-    switch (component_type) {
-    case SamplerComponentType::Float:
-    case SamplerComponentType::Depth:
-        return ctx.F32[1];
-    case SamplerComponentType::Sint:
-    case SamplerComponentType::Stencil:
-        return ctx.S32[1];
-    case SamplerComponentType::Uint:
-        return ctx.U32[1];
-    }
-    throw InvalidArgument("Invalid sampler component type {}", component_type);
-}
-
-Id ImageType(EmitContext& ctx, const TextureDescriptor& desc, Id sampled_type) {
+Id ImageType(EmitContext& ctx, const TextureDescriptor& desc) {
     const spv::ImageFormat format{spv::ImageFormat::Unknown};
+    const Id type{ctx.F32[1]};
     const bool depth{desc.is_depth};
     const bool ms{desc.is_multisample};
     switch (desc.type) {
     case TextureType::Color1D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, depth, false, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, false, false, 1, format);
     case TextureType::ColorArray1D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, depth, true, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, true, false, 1, format);
     case TextureType::Color2D:
     case TextureType::Color2DRect:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, depth, false, ms, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, ms, 1, format);
     case TextureType::ColorArray2D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, depth, true, ms, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, true, ms, 1, format);
     case TextureType::Color3D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim3D, depth, false, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim3D, depth, false, false, 1, format);
     case TextureType::ColorCube:
-        return ctx.TypeImage(sampled_type, spv::Dim::Cube, depth, false, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Cube, depth, false, false, 1, format);
     case TextureType::ColorArrayCube:
-        return ctx.TypeImage(sampled_type, spv::Dim::Cube, depth, true, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Cube, depth, true, false, 1, format);
     case TextureType::Buffer:
         break;
     }
@@ -328,9 +315,6 @@ void DefineSsbos(EmitContext& ctx, StorageTypeDefinition& type_def,
         ctx.Decorate(id, spv::Decoration::Binding, binding);
         ctx.Decorate(id, spv::Decoration::DescriptorSet, 0U);
         ctx.Name(id, fmt::format("ssbo{}", index));
-        if (!desc.is_written) {
-            ctx.Decorate(id, spv::Decoration::NonWritable);
-        }
         if (ctx.profile.supported_spirv >= 0x00010400) {
             ctx.interfaces.push_back(id);
         }
@@ -1375,8 +1359,7 @@ void EmitContext::DefineImageBuffers(const Info& info, u32& binding) {
 void EmitContext::DefineTextures(const Info& info, u32& binding, u32& scaling_index) {
     textures.reserve(info.texture_descriptors.size());
     for (const TextureDescriptor& desc : info.texture_descriptors) {
-        const Id result_type{ComponentScalarType(*this, desc.component_type)};
-        const Id image_type{ImageType(*this, desc, result_type)};
+        const Id image_type{ImageType(*this, desc)};
         const Id sampled_type{TypeSampledImage(image_type)};
         const Id pointer_type{TypePointer(spv::StorageClass::UniformConstant, sampled_type)};
         const Id desc_type{DescType(*this, sampled_type, pointer_type, desc.count)};
@@ -1389,10 +1372,8 @@ void EmitContext::DefineTextures(const Info& info, u32& binding, u32& scaling_in
             .sampled_type = sampled_type,
             .pointer_type = pointer_type,
             .image_type = image_type,
-            .result_type = result_type,
             .count = desc.count,
             .is_multisample = desc.is_multisample,
-            .component_type = desc.component_type,
         });
         if (profile.supported_spirv >= 0x00010400) {
             interfaces.push_back(id);
@@ -1451,9 +1432,6 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     }
     if (info.uses_sample_id) {
         sample_id = DefineInput(*this, U32[1], false, spv::BuiltIn::SampleId);
-        if (stage == Stage::Fragment) {
-            Decorate(sample_id, spv::Decoration::Flat);
-        }
     }
     if (info.uses_is_helper_invocation) {
         is_helper_invocation = DefineInput(*this, U1, false, spv::BuiltIn::HelperInvocation);
@@ -1464,21 +1442,14 @@ 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);
-        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 &&
+        (profile.warp_size_potentially_larger_than_guest &&
          (info.uses_subgroup_vote || info.uses_subgroup_mask))) {
         AddCapability(spv::Capability::GroupNonUniform);
         subgroup_local_invocation_id =
             DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
-            Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
+        Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
     }
     if (info.uses_fswzadd) {
         const Id f32_one{Const(1.0f)};
@@ -1490,9 +1461,6 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     }
     if (loads[IR::Attribute::PrimitiveId]) {
         primitive_id = DefineInput(*this, U32[1], false, spv::BuiltIn::PrimitiveId);
-        if (stage == Stage::Fragment) {
-            Decorate(primitive_id, spv::Decoration::Flat);
-        }
     }
     if (loads[IR::Attribute::Layer]) {
         AddCapability(spv::Capability::Geometry);
@@ -1584,21 +1552,17 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         if (stage != Stage::Fragment) {
             continue;
         }
-        const bool is_integer = input_type == AttributeType::SignedInt ||
-                                input_type == AttributeType::UnsignedInt;
-        if (is_integer) {
+        switch (info.interpolation[index]) {
+        case Interpolation::Smooth:
+            // Default
+            // Decorate(id, spv::Decoration::Smooth);
+            break;
+        case Interpolation::NoPerspective:
+            Decorate(id, spv::Decoration::NoPerspective);
+            break;
+        case Interpolation::Flat:
             Decorate(id, spv::Decoration::Flat);
-        } else {
-            switch (info.interpolation[index]) {
-            case Interpolation::Smooth:
-                break;
-            case Interpolation::NoPerspective:
-                Decorate(id, spv::Decoration::NoPerspective);
-                break;
-            case Interpolation::Flat:
-                Decorate(id, spv::Decoration::Flat);
-                break;
-            }
+            break;
         }
     }
     if (stage == Stage::TessellationEval) {

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -36,10 +36,8 @@ struct TextureDefinition {
     Id sampled_type;
     Id pointer_type;
     Id image_type;
-    Id result_type;
     u32 count;
     bool is_multisample;
-    SamplerComponentType component_type;
 };
 
 struct TextureBufferDefinition {

src/shader_recompiler/environment.h

@@ -22,8 +22,6 @@ public:
 
     [[nodiscard]] virtual TextureType ReadTextureType(u32 raw_handle) = 0;
 
-    [[nodiscard]] virtual SamplerComponentType ReadTextureComponentType(u32 raw_handle) = 0;
-
     [[nodiscard]] virtual TexturePixelFormat ReadTexturePixelFormat(u32 raw_handle) = 0;
 
     [[nodiscard]] virtual bool IsTexturePixelFormatInteger(u32 raw_handle) = 0;

src/shader_recompiler/ir_opt/collect_shader_info_pass.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/alignment.h"
+#include "common/assert.h"
 #include "shader_recompiler/environment.h"
 #include "shader_recompiler/frontend/ir/modifiers.h"
 #include "shader_recompiler/frontend/ir/program.h"
@@ -769,6 +770,15 @@ void VisitUsages(Info& info, IR::Inst& inst) {
     }
 }
 
+constexpr Shader::FloatDenormKind FloatDenormModeToShaderMode(IR::FmzMode const mode) noexcept {
+    switch (mode) {
+    case IR::FmzMode::DontCare: return Shader::FloatDenormKind::None;
+    case IR::FmzMode::FTZ: return Shader::FloatDenormKind::DenormFlushToZero;
+    case IR::FmzMode::FMZ: return Shader::FloatDenormKind::RoundingModeRTE;
+    case IR::FmzMode::None: return Shader::FloatDenormKind::DenormPreserve;
+    }
+}
+
 void VisitFpModifiers(Info& info, IR::Inst& inst) {
     switch (inst.GetOpcode()) {
     case IR::Opcode::FPAdd16:
@@ -778,18 +788,10 @@ void VisitFpModifiers(Info& info, IR::Inst& inst) {
     case IR::Opcode::FPFloor16:
     case IR::Opcode::FPCeil16:
     case IR::Opcode::FPTrunc16: {
-        const auto control{inst.Flags<IR::FpControl>()};
-        switch (control.fmz_mode) {
-        case IR::FmzMode::DontCare:
-            break;
-        case IR::FmzMode::FTZ:
-        case IR::FmzMode::FMZ:
-            info.uses_fp16_denorms_flush = true;
-            break;
-        case IR::FmzMode::None:
-            info.uses_fp16_denorms_preserve = true;
-            break;
-        }
+        auto const control = inst.Flags<IR::FpControl>();
+        auto const denorm = FloatDenormModeToShaderMode(control.fmz_mode);
+        ASSERT(info.fp16_denorm == FloatDenormKind::None || info.fp16_denorm == denorm);
+        info.fp16_denorm = denorm;
         break;
     }
     case IR::Opcode::FPAdd32:
@@ -813,18 +815,10 @@ void VisitFpModifiers(Info& info, IR::Inst& inst) {
     case IR::Opcode::FPUnordGreaterThanEqual32:
     case IR::Opcode::ConvertF16F32:
     case IR::Opcode::ConvertF64F32: {
-        const auto control{inst.Flags<IR::FpControl>()};
-        switch (control.fmz_mode) {
-        case IR::FmzMode::DontCare:
-            break;
-        case IR::FmzMode::FTZ:
-        case IR::FmzMode::FMZ:
-            info.uses_fp32_denorms_flush = true;
-            break;
-        case IR::FmzMode::None:
-            info.uses_fp32_denorms_preserve = true;
-            break;
-        }
+        const auto control = inst.Flags<IR::FpControl>();
+        auto const denorm = FloatDenormModeToShaderMode(control.fmz_mode);
+        ASSERT(info.fp32_denorm == FloatDenormKind::None || info.fp32_denorm == denorm);
+        info.fp32_denorm = denorm;
         break;
     }
     default:

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -396,10 +396,6 @@ bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf)
     return env.IsTexturePixelFormatInteger(GetTextureHandle(env, cbuf));
 }
 
-SamplerComponentType ReadTextureComponentType(Environment& env, const ConstBufferAddr& cbuf) {
-    return env.ReadTextureComponentType(GetTextureHandle(env, cbuf));
-}
-
 class Descriptors {
 public:
     explicit Descriptors(TextureBufferDescriptors& texture_buffer_descriptors_,
@@ -437,9 +433,7 @@ public:
 
     u32 Add(const TextureDescriptor& desc) {
         const u32 index{Add(texture_descriptors, desc, [&desc](const auto& existing) {
-            return desc.type == existing.type &&
-                   desc.component_type == existing.component_type &&
-                   desc.is_depth == existing.is_depth &&
+            return desc.type == existing.type && desc.is_depth == existing.is_depth &&
                    desc.has_secondary == existing.has_secondary &&
                    desc.cbuf_index == existing.cbuf_index &&
                    desc.cbuf_offset == existing.cbuf_offset &&
@@ -676,7 +670,6 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
             } else {
                 index = descriptors.Add(TextureDescriptor{
                     .type = flags.type,
-                    .component_type = ReadTextureComponentType(env, cbuf),
                     .is_depth = flags.is_depth != 0,
                     .is_multisample = is_multisample,
                     .has_secondary = cbuf.has_secondary,

src/shader_recompiler/profile.h

@@ -22,6 +22,8 @@ struct Profile {
     bool support_fp32_denorm_preserve{};
     bool support_fp16_denorm_flush{};
     bool support_fp32_denorm_flush{};
+    bool support_fp16_round_rte{};
+    bool support_fp32_round_rte{};
     bool support_fp16_signed_zero_nan_preserve{};
     bool support_fp32_signed_zero_nan_preserve{};
     bool support_fp64_signed_zero_nan_preserve{};
@@ -46,6 +48,9 @@ struct Profile {
     bool support_multi_viewport{};
     bool support_geometry_streams{};
 
+    /// FTZ is default mode so no need to specify it again (QCOM)
+    bool uses_ftz_as_default{};
+
     bool warp_size_potentially_larger_than_guest{};
 
     bool lower_left_origin_mode{};

src/shader_recompiler/shader_info.h

@@ -1,6 +1,3 @@
-// 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
 
@@ -154,14 +151,6 @@ enum class ImageFormat : u32 {
     R32G32B32A32_UINT,
 };
 
-enum class SamplerComponentType : u8 {
-    Float,
-    Sint,
-    Uint,
-    Depth,
-    Stencil,
-};
-
 enum class Interpolation {
     Smooth,
     Flat,
@@ -215,7 +204,6 @@ using ImageBufferDescriptors = boost::container::small_vector<ImageBufferDescrip
 
 struct TextureDescriptor {
     TextureType type;
-    SamplerComponentType component_type;
     bool is_depth;
     bool is_multisample;
     bool has_secondary;
@@ -247,6 +235,15 @@ struct ImageDescriptor {
 };
 using ImageDescriptors = boost::container::small_vector<ImageDescriptor, 4>;
 
+enum class FloatDenormKind : u32 {
+    None = 0,
+    DenormPreserve,
+    DenormFlushToZero,
+    SignedZeroInfNanPreserve,
+    RoundingModeRTE,
+    RoundingModeRTZ
+};
+
 struct Info {
     static constexpr size_t MAX_INDIRECT_CBUFS{14};
     static constexpr size_t MAX_CBUFS{18};
@@ -285,10 +282,8 @@ struct Info {
 
     bool uses_fp16{};
     bool uses_fp64{};
-    bool uses_fp16_denorms_flush{};
-    bool uses_fp16_denorms_preserve{};
-    bool uses_fp32_denorms_flush{};
-    bool uses_fp32_denorms_preserve{};
+    FloatDenormKind fp16_denorm{};
+    FloatDenormKind fp32_denorm{};
     bool uses_int8{};
     bool uses_int16{};
     bool uses_int64{};

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -198,6 +198,8 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
           .support_fp32_denorm_preserve = false,
           .support_fp16_denorm_flush = false,
           .support_fp32_denorm_flush = false,
+          .support_fp16_round_rte = false,
+          .support_fp32_round_rte = false,
           .support_fp16_signed_zero_nan_preserve = false,
           .support_fp32_signed_zero_nan_preserve = false,
           .support_fp64_signed_zero_nan_preserve = false,
@@ -221,6 +223,7 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
           .support_gl_derivative_control = device.HasDerivativeControl(),
           .support_geometry_streams = true,
 
+          .uses_ftz_as_default = false,
           .warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyLargerThanGuest(),
 
           .lower_left_origin_mode = true,

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -55,7 +55,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
-constexpr u32 CACHE_VERSION = 13;
+constexpr u32 CACHE_VERSION = 14;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
 
 template <typename Container>
@@ -335,12 +335,11 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         .support_fp32_denorm_preserve = float_control.shaderDenormPreserveFloat32 != VK_FALSE,
         .support_fp16_denorm_flush = float_control.shaderDenormFlushToZeroFloat16 != VK_FALSE,
         .support_fp32_denorm_flush = float_control.shaderDenormFlushToZeroFloat32 != VK_FALSE,
-        .support_fp16_signed_zero_nan_preserve =
-            float_control.shaderSignedZeroInfNanPreserveFloat16 != VK_FALSE,
-        .support_fp32_signed_zero_nan_preserve =
-            float_control.shaderSignedZeroInfNanPreserveFloat32 != VK_FALSE,
-        .support_fp64_signed_zero_nan_preserve =
-            float_control.shaderSignedZeroInfNanPreserveFloat64 != VK_FALSE,
+        .support_fp16_round_rte = float_control.shaderRoundingModeRTEFloat16 != VK_FALSE,
+        .support_fp32_round_rte = float_control.shaderRoundingModeRTEFloat32 != VK_FALSE,
+        .support_fp16_signed_zero_nan_preserve = float_control.shaderSignedZeroInfNanPreserveFloat16 != VK_FALSE,
+        .support_fp32_signed_zero_nan_preserve = float_control.shaderSignedZeroInfNanPreserveFloat32 != VK_FALSE,
+        .support_fp64_signed_zero_nan_preserve = float_control.shaderSignedZeroInfNanPreserveFloat64 != VK_FALSE,
         .support_explicit_workgroup_layout = device.IsKhrWorkgroupMemoryExplicitLayoutSupported(),
         .support_vote = device.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_VOTE_BIT),
         .support_viewport_index_layer_non_geometry =
@@ -357,6 +356,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         .support_multi_viewport = device.SupportsMultiViewport(),
         .support_geometry_streams = device.AreTransformFeedbackGeometryStreamsSupported(),
 
+        .uses_ftz_as_default = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
         .warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyBiggerThanGuest(),
 
         .lower_left_origin_mode = false,

src/video_core/shader_environment.cpp

@@ -70,59 +70,6 @@ static Shader::TexturePixelFormat ConvertTexturePixelFormat(const Tegra::Texture
                                    entry.a_type, entry.srgb_conversion));
 }
 
-static Shader::SamplerComponentType ConvertSamplerComponentType(
-    const Tegra::Texture::TICEntry& entry) {
-    const auto pixel_format = PixelFormatFromTextureInfo(entry.format, entry.r_type, entry.g_type,
-                                                        entry.b_type, entry.a_type,
-                                                        entry.srgb_conversion);
-    const auto surface_type = VideoCore::Surface::GetFormatType(pixel_format);
-    if (entry.depth_texture != 0 || surface_type == VideoCore::Surface::SurfaceType::Depth) {
-        return Shader::SamplerComponentType::Depth;
-    }
-    if (surface_type == VideoCore::Surface::SurfaceType::Stencil) {
-        return Shader::SamplerComponentType::Stencil;
-    }
-    if (surface_type == VideoCore::Surface::SurfaceType::DepthStencil) {
-        return entry.depth_texture != 0 ? Shader::SamplerComponentType::Depth
-                                        : Shader::SamplerComponentType::Stencil;
-    }
-
-    const auto accumulate = [](const Tegra::Texture::ComponentType component,
-                               bool& has_signed, bool& has_unsigned) {
-        switch (component) {
-        case Tegra::Texture::ComponentType::SINT:
-            has_signed = true;
-            break;
-        case Tegra::Texture::ComponentType::UINT:
-            has_unsigned = true;
-            break;
-        default:
-            break;
-        }
-    };
-
-    bool has_signed{};
-    bool has_unsigned{};
-    accumulate(entry.r_type, has_signed, has_unsigned);
-    accumulate(entry.g_type, has_signed, has_unsigned);
-    accumulate(entry.b_type, has_signed, has_unsigned);
-    accumulate(entry.a_type, has_signed, has_unsigned);
-
-    if (has_signed && !has_unsigned) {
-        return Shader::SamplerComponentType::Sint;
-    }
-    if (has_unsigned && !has_signed) {
-        return Shader::SamplerComponentType::Uint;
-    }
-    if (has_signed) {
-        return Shader::SamplerComponentType::Sint;
-    }
-    if (has_unsigned) {
-        return Shader::SamplerComponentType::Uint;
-    }
-    return Shader::SamplerComponentType::Float;
-}
-
 static std::string_view StageToPrefix(Shader::Stage stage) {
     switch (stage) {
     case Shader::Stage::VertexB:
@@ -253,7 +200,6 @@ void GenericEnvironment::Serialize(std::ofstream& file) const {
     const u64 code_size{static_cast<u64>(CachedSizeBytes())};
     const u64 num_texture_types{static_cast<u64>(texture_types.size())};
     const u64 num_texture_pixel_formats{static_cast<u64>(texture_pixel_formats.size())};
-    const u64 num_texture_component_types{static_cast<u64>(texture_component_types.size())};
     const u64 num_cbuf_values{static_cast<u64>(cbuf_values.size())};
     const u64 num_cbuf_replacement_values{static_cast<u64>(cbuf_replacements.size())};
 
@@ -261,8 +207,6 @@ void GenericEnvironment::Serialize(std::ofstream& file) const {
         .write(reinterpret_cast<const char*>(&num_texture_types), sizeof(num_texture_types))
         .write(reinterpret_cast<const char*>(&num_texture_pixel_formats),
                sizeof(num_texture_pixel_formats))
-        .write(reinterpret_cast<const char*>(&num_texture_component_types),
-               sizeof(num_texture_component_types))
         .write(reinterpret_cast<const char*>(&num_cbuf_values), sizeof(num_cbuf_values))
         .write(reinterpret_cast<const char*>(&num_cbuf_replacement_values),
                sizeof(num_cbuf_replacement_values))
@@ -279,10 +223,6 @@ void GenericEnvironment::Serialize(std::ofstream& file) const {
         file.write(reinterpret_cast<const char*>(&key), sizeof(key))
             .write(reinterpret_cast<const char*>(&type), sizeof(type));
     }
-    for (const auto& [key, component] : texture_component_types) {
-        file.write(reinterpret_cast<const char*>(&key), sizeof(key))
-            .write(reinterpret_cast<const char*>(&component), sizeof(component));
-    }
     for (const auto& [key, format] : texture_pixel_formats) {
         file.write(reinterpret_cast<const char*>(&key), sizeof(key))
             .write(reinterpret_cast<const char*>(&format), sizeof(format));
@@ -434,21 +374,6 @@ Shader::TextureType GraphicsEnvironment::ReadTextureType(u32 handle) {
         ReadTextureInfo(regs.tex_header.Address(), regs.tex_header.limit, via_header_index, handle);
     const Shader::TextureType result{ConvertTextureType(entry)};
     texture_types.emplace(handle, result);
-    texture_component_types.emplace(handle, ConvertSamplerComponentType(entry));
-    return result;
-}
-
-Shader::SamplerComponentType GraphicsEnvironment::ReadTextureComponentType(u32 handle) {
-    const auto it{texture_component_types.find(handle)};
-    if (it != texture_component_types.end()) {
-        return it->second;
-    }
-    const auto& regs{maxwell3d->regs};
-    const bool via_header_index{regs.sampler_binding == Maxwell::SamplerBinding::ViaHeaderBinding};
-    auto entry =
-        ReadTextureInfo(regs.tex_header.Address(), regs.tex_header.limit, via_header_index, handle);
-    const Shader::SamplerComponentType result{ConvertSamplerComponentType(entry)};
-    texture_component_types.emplace(handle, result);
     return result;
 }
 
@@ -505,20 +430,6 @@ Shader::TextureType ComputeEnvironment::ReadTextureType(u32 handle) {
     auto entry = ReadTextureInfo(regs.tic.Address(), regs.tic.limit, qmd.linked_tsc != 0, handle);
     const Shader::TextureType result{ConvertTextureType(entry)};
     texture_types.emplace(handle, result);
-    texture_component_types.emplace(handle, ConvertSamplerComponentType(entry));
-    return result;
-}
-
-Shader::SamplerComponentType ComputeEnvironment::ReadTextureComponentType(u32 handle) {
-    const auto it{texture_component_types.find(handle)};
-    if (it != texture_component_types.end()) {
-        return it->second;
-    }
-    const auto& regs{kepler_compute->regs};
-    const auto& qmd{kepler_compute->launch_description};
-    auto entry = ReadTextureInfo(regs.tic.Address(), regs.tic.limit, qmd.linked_tsc != 0, handle);
-    const Shader::SamplerComponentType result{ConvertSamplerComponentType(entry)};
-    texture_component_types.emplace(handle, result);
     return result;
 }
 
@@ -544,15 +455,12 @@ void FileEnvironment::Deserialize(std::ifstream& file) {
     u64 code_size{};
     u64 num_texture_types{};
     u64 num_texture_pixel_formats{};
-    u64 num_texture_component_types{};
     u64 num_cbuf_values{};
     u64 num_cbuf_replacement_values{};
     file.read(reinterpret_cast<char*>(&code_size), sizeof(code_size))
         .read(reinterpret_cast<char*>(&num_texture_types), sizeof(num_texture_types))
-          .read(reinterpret_cast<char*>(&num_texture_pixel_formats),
+        .read(reinterpret_cast<char*>(&num_texture_pixel_formats),
               sizeof(num_texture_pixel_formats))
-          .read(reinterpret_cast<char*>(&num_texture_component_types),
-              sizeof(num_texture_component_types))
         .read(reinterpret_cast<char*>(&num_cbuf_values), sizeof(num_cbuf_values))
         .read(reinterpret_cast<char*>(&num_cbuf_replacement_values),
               sizeof(num_cbuf_replacement_values))
@@ -572,13 +480,6 @@ void FileEnvironment::Deserialize(std::ifstream& file) {
             .read(reinterpret_cast<char*>(&type), sizeof(type));
         texture_types.emplace(key, type);
     }
-    for (size_t i = 0; i < num_texture_component_types; ++i) {
-        u32 key;
-        Shader::SamplerComponentType component;
-        file.read(reinterpret_cast<char*>(&key), sizeof(key))
-            .read(reinterpret_cast<char*>(&component), sizeof(component));
-        texture_component_types.emplace(key, component);
-    }
     for (size_t i = 0; i < num_texture_pixel_formats; ++i) {
         u32 key;
         Shader::TexturePixelFormat format;
@@ -633,15 +534,6 @@ u32 FileEnvironment::ReadCbufValue(u32 cbuf_index, u32 cbuf_offset) {
     return it->second;
 }
 
-Shader::SamplerComponentType FileEnvironment::ReadTextureComponentType(u32 handle) {
-    const auto it{texture_component_types.find(handle)};
-    if (it == texture_component_types.end()) {
-        LOG_WARNING(Render_Vulkan, "Texture component descriptor {:08x} not found", handle);
-        return Shader::SamplerComponentType::Float;
-    }
-    return it->second;
-}
-
 Shader::TextureType FileEnvironment::ReadTextureType(u32 handle) {
     const auto it{texture_types.find(handle)};
     if (it == texture_types.end()) {

src/video_core/shader_environment.h

@@ -80,7 +80,6 @@ protected:
 
     std::vector<u64> code;
     std::unordered_map<u32, Shader::TextureType> texture_types;
-    std::unordered_map<u32, Shader::SamplerComponentType> texture_component_types;
     std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
     std::unordered_map<u64, u32> cbuf_values;
     std::unordered_map<u64, Shader::ReplaceConstant> cbuf_replacements;
@@ -117,8 +116,6 @@ public:
 
     Shader::TextureType ReadTextureType(u32 handle) override;
 
-    Shader::SamplerComponentType ReadTextureComponentType(u32 handle) override;
-
     Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;
 
     bool IsTexturePixelFormatInteger(u32 handle) override;
@@ -145,8 +142,6 @@ public:
 
     Shader::TextureType ReadTextureType(u32 handle) override;
 
-    Shader::SamplerComponentType ReadTextureComponentType(u32 handle) override;
-
     Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;
 
     bool IsTexturePixelFormatInteger(u32 handle) override;
@@ -181,8 +176,6 @@ public:
 
     [[nodiscard]] Shader::TextureType ReadTextureType(u32 handle) override;
 
-    [[nodiscard]] Shader::SamplerComponentType ReadTextureComponentType(u32 handle) override;
-
     [[nodiscard]] Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;
 
     [[nodiscard]] bool IsTexturePixelFormatInteger(u32 handle) override;
@@ -209,7 +202,6 @@ public:
 private:
     std::vector<u64> code;
     std::unordered_map<u32, Shader::TextureType> texture_types;
-    std::unordered_map<u32, Shader::SamplerComponentType> texture_component_types;
     std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
     std::unordered_map<u64, u32> cbuf_values;
     std::unordered_map<u64, Shader::ReplaceConstant> cbuf_replacements;