Android #167

README.md

@@ -1,7 +1,7 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
+| [12407](https://github.com/yuzu-emu/yuzu//pull/12407) | [`6e2cbd474`](https://github.com/yuzu-emu/yuzu//pull/12407/files) | shader_recompiler: patch small float image writes on broken drivers | [liamwhite](https://github.com/liamwhite/) | Yes |
 | [12410](https://github.com/yuzu-emu/yuzu//pull/12410) | [`d0a75580d`](https://github.com/yuzu-emu/yuzu//pull/12410/files) | renderer_vulkan: don't pass null view when nullDescriptor is not supported | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12432](https://github.com/yuzu-emu/yuzu//pull/12432) | [`9e9aed41b`](https://github.com/yuzu-emu/yuzu//pull/12432/files) | shader_recompiler: use float image operations on load/store when required | [liamwhite](https://github.com/liamwhite/) | Yes |
 
 
 End of merge log. You can find the original README.md below the break.

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/GamesFragment.kt

@@ -91,20 +91,18 @@ class GamesFragment : Fragment() {
         viewLifecycleOwner.lifecycleScope.apply {
             launch {
                 repeatOnLifecycle(Lifecycle.State.RESUMED) {
-                    gamesViewModel.isReloading.collect {
-                        binding.swipeRefresh.isRefreshing = it
-                        if (gamesViewModel.games.value.isEmpty() && !it) {
-                            binding.noticeText.visibility = View.VISIBLE
-                        } else {
-                            binding.noticeText.visibility = View.INVISIBLE
-                        }
-                    }
+                    gamesViewModel.isReloading.collect { binding.swipeRefresh.isRefreshing = it }
                 }
             }
             launch {
                 repeatOnLifecycle(Lifecycle.State.RESUMED) {
                     gamesViewModel.games.collectLatest {
                         (binding.gridGames.adapter as GameAdapter).submitList(it)
+                        if (it.isEmpty()) {
+                            binding.noticeText.visibility = View.VISIBLE
+                        } else {
+                            binding.noticeText.visibility = View.GONE
+                        }
                     }
                 }
             }

src/core/hle/service/hid/hid_server.cpp

@@ -51,7 +51,7 @@ private:
         IPC::RequestParser rp{ctx};
         const auto vibration_device_handle{rp.PopRaw<Core::HID::VibrationDeviceHandle>()};
 
-        if (resource_manager != nullptr && resource_manager->GetNpad()) {
+        if (resource_manager != nullptr) {
             resource_manager->GetNpad()->InitializeVibrationDevice(vibration_device_handle);
         }
 

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -214,16 +214,16 @@ Id TextureImage(EmitContext& ctx, IR::TextureInstInfo info, const IR::Value& ind
     }
 }
 
-std::pair<Id, bool> Image(EmitContext& ctx, const IR::Value& index, IR::TextureInstInfo info) {
+Id Image(EmitContext& ctx, const IR::Value& index, IR::TextureInstInfo info) {
     if (!index.IsImmediate() || index.U32() != 0) {
         throw NotImplementedException("Indirect image indexing");
     }
     if (info.type == TextureType::Buffer) {
         const ImageBufferDefinition def{ctx.image_buffers.at(info.descriptor_index)};
-        return {ctx.OpLoad(def.image_type, def.id), def.is_integer};
+        return ctx.OpLoad(def.image_type, def.id);
     } else {
         const ImageDefinition def{ctx.images.at(info.descriptor_index)};
-        return {ctx.OpLoad(def.image_type, def.id), def.is_integer};
+        return ctx.OpLoad(def.image_type, def.id);
     }
 }
 
@@ -566,23 +566,13 @@ Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id co
         LOG_WARNING(Shader_SPIRV, "Typeless image read not supported by host");
         return ctx.ConstantNull(ctx.U32[4]);
     }
-    const auto [image, is_integer] = Image(ctx, index, info);
-    const Id result_type{is_integer ? ctx.U32[4] : ctx.F32[4]};
-    Id color{Emit(&EmitContext::OpImageSparseRead, &EmitContext::OpImageRead, ctx, inst,
-                  result_type, image, coords, std::nullopt, std::span<const Id>{})};
-    if (!is_integer) {
-        color = ctx.OpBitcast(ctx.U32[4], color);
-    }
-    return color;
+    return Emit(&EmitContext::OpImageSparseRead, &EmitContext::OpImageRead, ctx, inst, ctx.U32[4],
+                Image(ctx, index, info), coords, std::nullopt, std::span<const Id>{});
 }
 
 void EmitImageWrite(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id color) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    const auto [image, is_integer] = Image(ctx, index, info);
-    if (!is_integer) {
-        color = ctx.OpBitcast(ctx.F32[4], color);
-    }
-    ctx.OpImageWrite(image, coords, color);
+    ctx.OpImageWrite(Image(ctx, index, info), coords, color);
 }
 
 Id EmitIsTextureScaled(EmitContext& ctx, const IR::Value& index) {

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -74,19 +74,28 @@ spv::ImageFormat GetImageFormat(ImageFormat format) {
     throw InvalidArgument("Invalid image format {}", format);
 }
 
-Id ImageType(EmitContext& ctx, const ImageDescriptor& desc, Id sampled_type) {
+Id GetImageSampledType(EmitContext& ctx, const ImageDescriptor& desc) {
+    if (desc.is_float) {
+        return ctx.F32[1];
+    } else {
+        return ctx.U32[1];
+    }
+}
+
+Id ImageType(EmitContext& ctx, const ImageDescriptor& desc) {
     const spv::ImageFormat format{GetImageFormat(desc.format)};
+    const Id type{GetImageSampledType(ctx, desc)};
     switch (desc.type) {
     case TextureType::Color1D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, false, false, 2, format);
+        return ctx.TypeImage(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 ctx.TypeImage(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);
+        return ctx.TypeImage(type, spv::Dim::Dim2D, false, false, false, 2, format);
     case TextureType::ColorArray2D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, false, true, false, 2, format);
+        return ctx.TypeImage(type, spv::Dim::Dim2D, false, true, false, 2, format);
     case TextureType::Color3D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim3D, false, false, false, 2, format);
+        return ctx.TypeImage(type, spv::Dim::Dim3D, false, false, false, 2, format);
     case TextureType::Buffer:
         throw NotImplementedException("Image buffer");
     default:
@@ -1272,9 +1281,7 @@ void EmitContext::DefineImageBuffers(const Info& info, u32& binding) {
             throw NotImplementedException("Array of image buffers");
         }
         const spv::ImageFormat format{GetImageFormat(desc.format)};
-        const Id sampled_type{desc.is_integer ? U32[1] : F32[1]};
-        const Id image_type{
-            TypeImage(sampled_type, spv::Dim::Buffer, false, false, false, 2, format)};
+        const Id image_type{TypeImage(U32[1], spv::Dim::Buffer, false, false, false, 2, format)};
         const Id pointer_type{TypePointer(spv::StorageClass::UniformConstant, image_type)};
         const Id id{AddGlobalVariable(pointer_type, spv::StorageClass::UniformConstant)};
         Decorate(id, spv::Decoration::Binding, binding);
@@ -1284,7 +1291,6 @@ void EmitContext::DefineImageBuffers(const Info& info, u32& binding) {
             .id = id,
             .image_type = image_type,
             .count = desc.count,
-            .is_integer = desc.is_integer,
         });
         if (profile.supported_spirv >= 0x00010400) {
             interfaces.push_back(id);
@@ -1329,8 +1335,7 @@ void EmitContext::DefineImages(const Info& info, u32& binding, u32& scaling_inde
         if (desc.count != 1) {
             throw NotImplementedException("Array of images");
         }
-        const Id sampled_type{desc.is_integer ? U32[1] : F32[1]};
-        const Id image_type{ImageType(*this, desc, sampled_type)};
+        const Id image_type{ImageType(*this, desc)};
         const Id pointer_type{TypePointer(spv::StorageClass::UniformConstant, image_type)};
         const Id id{AddGlobalVariable(pointer_type, spv::StorageClass::UniformConstant)};
         Decorate(id, spv::Decoration::Binding, binding);
@@ -1340,7 +1345,6 @@ void EmitContext::DefineImages(const Info& info, u32& binding, u32& scaling_inde
             .id = id,
             .image_type = image_type,
             .count = desc.count,
-            .is_integer = desc.is_integer,
         });
         if (profile.supported_spirv >= 0x00010400) {
             interfaces.push_back(id);

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -47,14 +47,12 @@ struct ImageBufferDefinition {
     Id id;
     Id image_type;
     u32 count;
-    bool is_integer;
 };
 
 struct ImageDefinition {
     Id id;
     Id image_type;
     u32 count;
-    bool is_integer;
 };
 
 struct UniformDefinitions {

src/shader_recompiler/environment.h

@@ -24,8 +24,6 @@ public:
 
     [[nodiscard]] virtual TexturePixelFormat ReadTexturePixelFormat(u32 raw_handle) = 0;
 
-    [[nodiscard]] virtual bool IsTexturePixelFormatInteger(u32 raw_handle) = 0;
-
     [[nodiscard]] virtual u32 ReadViewportTransformState() = 0;
 
     [[nodiscard]] virtual u32 TextureBoundBuffer() const = 0;

src/shader_recompiler/frontend/ir/opcodes.inc

@@ -512,7 +512,7 @@ OPCODE(ImageQueryDimensions,                                U32x4,          Opaq
 OPCODE(ImageQueryLod,                                       F32x4,          Opaque,         Opaque,                                                         )
 OPCODE(ImageGradient,                                       F32x4,          Opaque,         Opaque,         Opaque,         Opaque,         Opaque,         )
 OPCODE(ImageRead,                                           U32x4,          Opaque,         Opaque,                                                         )
-OPCODE(ImageWrite,                                          Void,           Opaque,         Opaque,         U32x4,                                          )
+OPCODE(ImageWrite,                                          Void,           Opaque,         Opaque,         Opaque,                                         )
 
 OPCODE(IsTextureScaled,                                     U1,             U32,                                                                            )
 OPCODE(IsImageScaled,                                       U1,             U32,                                                                            )

src/shader_recompiler/host_translate_info.h

@@ -19,8 +19,10 @@ struct HostTranslateInfo {
     u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
     bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                 ///< passthrough shaders
-    bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional
-                                        ///< control flow
+    bool support_conditional_barrier{};  ///< True when the device supports barriers in conditional
+                                         ///< control flow
+    bool support_ufloat_write_as_uint{}; ///< True when the device supports writing float images
+                                         ///< as bitcasts to uint
 };
 
 } // namespace Shader

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -372,8 +372,8 @@ TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAdd
     return env.ReadTexturePixelFormat(GetTextureHandle(env, cbuf));
 }
 
-bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf) {
-    return env.IsTexturePixelFormatInteger(GetTextureHandle(env, cbuf));
+bool TexturePixelFormatIsFloat(Environment& env, const ConstBufferAddr& cbuf) {
+    return ReadTexturePixelFormat(env, cbuf) == TexturePixelFormat::B10G11R11_FLOAT;
 }
 
 class Descriptors {
@@ -407,7 +407,6 @@ public:
         })};
         image_buffer_descriptors[index].is_written |= desc.is_written;
         image_buffer_descriptors[index].is_read |= desc.is_read;
-        image_buffer_descriptors[index].is_integer |= desc.is_integer;
         return index;
     }
 
@@ -433,11 +432,11 @@ public:
             return desc.type == existing.type && desc.format == existing.format &&
                    desc.cbuf_index == existing.cbuf_index &&
                    desc.cbuf_offset == existing.cbuf_offset && desc.count == existing.count &&
-                   desc.size_shift == existing.size_shift;
+                   desc.size_shift == existing.size_shift && desc.is_float == existing.is_float;
         })};
+        // TODO: handle is_float?
         image_descriptors[index].is_written |= desc.is_written;
         image_descriptors[index].is_read |= desc.is_read;
-        image_descriptors[index].is_integer |= desc.is_integer;
         return index;
     }
 
@@ -475,20 +474,6 @@ void PatchImageSampleImplicitLod(IR::Block& block, IR::Inst& inst) {
                         ir.FPRecip(ir.ConvertUToF(32, 32, ir.CompositeExtract(texture_size, 1))))));
 }
 
-bool IsPixelFormatSNorm(TexturePixelFormat pixel_format) {
-    switch (pixel_format) {
-    case TexturePixelFormat::A8B8G8R8_SNORM:
-    case TexturePixelFormat::R8G8_SNORM:
-    case TexturePixelFormat::R8_SNORM:
-    case TexturePixelFormat::R16G16B16A16_SNORM:
-    case TexturePixelFormat::R16G16_SNORM:
-    case TexturePixelFormat::R16_SNORM:
-        return true;
-    default:
-        return false;
-    }
-}
-
 void PatchTexelFetch(IR::Block& block, IR::Inst& inst, TexturePixelFormat pixel_format) {
     const auto it{IR::Block::InstructionList::s_iterator_to(inst)};
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
@@ -520,6 +505,19 @@ void PatchTexelFetch(IR::Block& block, IR::Inst& inst, TexturePixelFormat pixel_
                               ir.FPMul(ir.ConvertSToF(32, 32, ir.BitCast<IR::U32>(w)), max_value));
     inst.ReplaceUsesWith(converted);
 }
+
+void PatchSmallFloatImageWrite(IR::Block& block, IR::Inst& inst) {
+    IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
+
+    const IR::Value old_value{inst.Arg(2)};
+    const IR::F32 x(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 0))));
+    const IR::F32 y(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 1))));
+    const IR::F32 z(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 2))));
+    const IR::F32 w(ir.BitCast<IR::F32>(IR::U32(ir.CompositeExtract(old_value, 3))));
+    const IR::Value converted = ir.CompositeConstruct(x, y, z, w);
+    inst.SetArg(2, converted);
+}
+
 } // Anonymous namespace
 
 void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo& host_info) {
@@ -551,6 +549,9 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
         inst->ReplaceOpcode(IndexedInstruction(*inst));
 
         const auto& cbuf{texture_inst.cbuf};
+        const bool is_float_write{!host_info.support_ufloat_write_as_uint &&
+                                  inst->GetOpcode() == IR::Opcode::ImageWrite &&
+                                  TexturePixelFormatIsFloat(env, cbuf)};
         auto flags{inst->Flags<IR::TextureInstInfo>()};
         bool is_multisample{false};
         switch (inst->GetOpcode()) {
@@ -607,13 +608,11 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
             }
             const bool is_written{inst->GetOpcode() != IR::Opcode::ImageRead};
             const bool is_read{inst->GetOpcode() != IR::Opcode::ImageWrite};
-            const bool is_integer{IsTexturePixelFormatInteger(env, cbuf)};
             if (flags.type == TextureType::Buffer) {
                 index = descriptors.Add(ImageBufferDescriptor{
                     .format = flags.image_format,
                     .is_written = is_written,
                     .is_read = is_read,
-                    .is_integer = is_integer,
                     .cbuf_index = cbuf.index,
                     .cbuf_offset = cbuf.offset,
                     .count = cbuf.count,
@@ -625,7 +624,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                     .format = flags.image_format,
                     .is_written = is_written,
                     .is_read = is_read,
-                    .is_integer = is_integer,
+                    .is_float = is_float_write,
                     .cbuf_index = cbuf.index,
                     .cbuf_offset = cbuf.offset,
                     .count = cbuf.count,
@@ -681,10 +680,14 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
         if (!host_info.support_snorm_render_buffer && inst->GetOpcode() == IR::Opcode::ImageFetch &&
             flags.type == TextureType::Buffer) {
             const auto pixel_format = ReadTexturePixelFormat(env, cbuf);
-            if (IsPixelFormatSNorm(pixel_format)) {
+            if (pixel_format != TexturePixelFormat::OTHER) {
                 PatchTexelFetch(*texture_inst.block, *texture_inst.inst, pixel_format);
             }
         }
+
+        if (is_float_write) {
+            PatchSmallFloatImageWrite(*texture_inst.block, *inst);
+        }
     }
 }
 

src/shader_recompiler/shader_info.h

@@ -35,109 +35,15 @@ enum class TextureType : u32 {
 };
 constexpr u32 NUM_TEXTURE_TYPES = 9;
 
-enum class TexturePixelFormat {
-    A8B8G8R8_UNORM,
+enum class TexturePixelFormat : u32 {
     A8B8G8R8_SNORM,
-    A8B8G8R8_SINT,
-    A8B8G8R8_UINT,
-    R5G6B5_UNORM,
-    B5G6R5_UNORM,
-    A1R5G5B5_UNORM,
-    A2B10G10R10_UNORM,
-    A2B10G10R10_UINT,
-    A2R10G10B10_UNORM,
-    A1B5G5R5_UNORM,
-    A5B5G5R1_UNORM,
-    R8_UNORM,
     R8_SNORM,
-    R8_SINT,
-    R8_UINT,
-    R16G16B16A16_FLOAT,
-    R16G16B16A16_UNORM,
-    R16G16B16A16_SNORM,
-    R16G16B16A16_SINT,
-    R16G16B16A16_UINT,
-    B10G11R11_FLOAT,
-    R32G32B32A32_UINT,
-    BC1_RGBA_UNORM,
-    BC2_UNORM,
-    BC3_UNORM,
-    BC4_UNORM,
-    BC4_SNORM,
-    BC5_UNORM,
-    BC5_SNORM,
-    BC7_UNORM,
-    BC6H_UFLOAT,
-    BC6H_SFLOAT,
-    ASTC_2D_4X4_UNORM,
-    B8G8R8A8_UNORM,
-    R32G32B32A32_FLOAT,
-    R32G32B32A32_SINT,
-    R32G32_FLOAT,
-    R32G32_SINT,
-    R32_FLOAT,
-    R16_FLOAT,
-    R16_UNORM,
-    R16_SNORM,
-    R16_UINT,
-    R16_SINT,
-    R16G16_UNORM,
-    R16G16_FLOAT,
-    R16G16_UINT,
-    R16G16_SINT,
-    R16G16_SNORM,
-    R32G32B32_FLOAT,
-    A8B8G8R8_SRGB,
-    R8G8_UNORM,
     R8G8_SNORM,
-    R8G8_SINT,
-    R8G8_UINT,
-    R32G32_UINT,
-    R16G16B16X16_FLOAT,
-    R32_UINT,
-    R32_SINT,
-    ASTC_2D_8X8_UNORM,
-    ASTC_2D_8X5_UNORM,
-    ASTC_2D_5X4_UNORM,
-    B8G8R8A8_SRGB,
-    BC1_RGBA_SRGB,
-    BC2_SRGB,
-    BC3_SRGB,
-    BC7_SRGB,
-    A4B4G4R4_UNORM,
-    G4R4_UNORM,
-    ASTC_2D_4X4_SRGB,
-    ASTC_2D_8X8_SRGB,
-    ASTC_2D_8X5_SRGB,
-    ASTC_2D_5X4_SRGB,
-    ASTC_2D_5X5_UNORM,
-    ASTC_2D_5X5_SRGB,
-    ASTC_2D_10X8_UNORM,
-    ASTC_2D_10X8_SRGB,
-    ASTC_2D_6X6_UNORM,
-    ASTC_2D_6X6_SRGB,
-    ASTC_2D_10X6_UNORM,
-    ASTC_2D_10X6_SRGB,
-    ASTC_2D_10X5_UNORM,
-    ASTC_2D_10X5_SRGB,
-    ASTC_2D_10X10_UNORM,
-    ASTC_2D_10X10_SRGB,
-    ASTC_2D_12X10_UNORM,
-    ASTC_2D_12X10_SRGB,
-    ASTC_2D_12X12_UNORM,
-    ASTC_2D_12X12_SRGB,
-    ASTC_2D_8X6_UNORM,
-    ASTC_2D_8X6_SRGB,
-    ASTC_2D_6X5_UNORM,
-    ASTC_2D_6X5_SRGB,
-    E5B9G9R9_FLOAT,
-    D32_FLOAT,
-    D16_UNORM,
-    X8_D24_UNORM,
-    S8_UINT,
-    D24_UNORM_S8_UINT,
-    S8_UINT_D24_UNORM,
-    D32_FLOAT_S8_UINT,
+    R16G16B16A16_SNORM,
+    R16G16_SNORM,
+    R16_SNORM,
+    B10G11R11_FLOAT,
+    OTHER
 };
 
 enum class ImageFormat : u32 {
@@ -192,7 +98,6 @@ struct ImageBufferDescriptor {
     ImageFormat format;
     bool is_written;
     bool is_read;
-    bool is_integer;
     u32 cbuf_index;
     u32 cbuf_offset;
     u32 count;
@@ -225,7 +130,7 @@ struct ImageDescriptor {
     ImageFormat format;
     bool is_written;
     bool is_read;
-    bool is_integer;
+    bool is_float;
     u32 cbuf_index;
     u32 cbuf_offset;
     u32 count;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -51,7 +51,7 @@ using VideoCommon::LoadPipelines;
 using VideoCommon::SerializePipeline;
 using Context = ShaderContext::Context;
 
-constexpr u32 CACHE_VERSION = 10;
+constexpr u32 CACHE_VERSION = 9;
 
 template <typename Container>
 auto MakeSpan(Container& container) {
@@ -245,6 +245,7 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
           .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
           .support_conditional_barrier = device.SupportsConditionalBarriers(),
+          .support_ufloat_write_as_uint = true,
       } {
     if (use_asynchronous_shaders) {
         workers = CreateWorkers();

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -54,7 +54,7 @@ using VideoCommon::FileEnvironment;
 using VideoCommon::GenericEnvironment;
 using VideoCommon::GraphicsEnvironment;
 
-constexpr u32 CACHE_VERSION = 11;
+constexpr u32 CACHE_VERSION = 10;
 constexpr std::array<char, 8> VULKAN_CACHE_MAGIC_NUMBER{'y', 'u', 'z', 'u', 'v', 'k', 'c', 'h'};
 
 template <typename Container>
@@ -388,6 +388,9 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
         .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
         .support_conditional_barrier = device.SupportsConditionalBarriers(),
+        .support_ufloat_write_as_uint = driver_id != VK_DRIVER_ID_QUALCOMM_PROPRIETARY &&
+                                        driver_id != VK_DRIVER_ID_MESA_TURNIP &&
+                                        driver_id != VK_DRIVER_ID_ARM_PROPRIETARY,
     };
 
     if (device.GetMaxVertexInputAttributes() < Maxwell::NumVertexAttributes) {

src/video_core/shader_environment.cpp

@@ -62,9 +62,25 @@ static Shader::TextureType ConvertTextureType(const Tegra::Texture::TICEntry& en
 }
 
 static Shader::TexturePixelFormat ConvertTexturePixelFormat(const Tegra::Texture::TICEntry& entry) {
-    return static_cast<Shader::TexturePixelFormat>(
-        PixelFormatFromTextureInfo(entry.format, entry.r_type, entry.g_type, entry.b_type,
-                                   entry.a_type, entry.srgb_conversion));
+    switch (PixelFormatFromTextureInfo(entry.format, entry.r_type, entry.g_type, entry.b_type,
+                                       entry.a_type, entry.srgb_conversion)) {
+    case VideoCore::Surface::PixelFormat::A8B8G8R8_SNORM:
+        return Shader::TexturePixelFormat::A8B8G8R8_SNORM;
+    case VideoCore::Surface::PixelFormat::R8_SNORM:
+        return Shader::TexturePixelFormat::R8_SNORM;
+    case VideoCore::Surface::PixelFormat::R8G8_SNORM:
+        return Shader::TexturePixelFormat::R8G8_SNORM;
+    case VideoCore::Surface::PixelFormat::R16G16B16A16_SNORM:
+        return Shader::TexturePixelFormat::R16G16B16A16_SNORM;
+    case VideoCore::Surface::PixelFormat::R16G16_SNORM:
+        return Shader::TexturePixelFormat::R16G16_SNORM;
+    case VideoCore::Surface::PixelFormat::R16_SNORM:
+        return Shader::TexturePixelFormat::R16_SNORM;
+    case VideoCore::Surface::PixelFormat::B10G11R11_FLOAT:
+        return Shader::TexturePixelFormat::B10G11R11_FLOAT;
+    default:
+        return Shader::TexturePixelFormat::OTHER;
+    }
 }
 
 static std::string_view StageToPrefix(Shader::Stage stage) {
@@ -384,11 +400,6 @@ Shader::TexturePixelFormat GraphicsEnvironment::ReadTexturePixelFormat(u32 handl
     return result;
 }
 
-bool GraphicsEnvironment::IsTexturePixelFormatInteger(u32 handle) {
-    return VideoCore::Surface::IsPixelFormatInteger(
-        static_cast<VideoCore::Surface::PixelFormat>(ReadTexturePixelFormat(handle)));
-}
-
 u32 GraphicsEnvironment::ReadViewportTransformState() {
     const auto& regs{maxwell3d->regs};
     viewport_transform_state = regs.viewport_scale_offset_enabled;
@@ -439,11 +450,6 @@ Shader::TexturePixelFormat ComputeEnvironment::ReadTexturePixelFormat(u32 handle
     return result;
 }
 
-bool ComputeEnvironment::IsTexturePixelFormatInteger(u32 handle) {
-    return VideoCore::Surface::IsPixelFormatInteger(
-        static_cast<VideoCore::Surface::PixelFormat>(ReadTexturePixelFormat(handle)));
-}
-
 u32 ComputeEnvironment::ReadViewportTransformState() {
     return viewport_transform_state;
 }
@@ -547,11 +553,6 @@ Shader::TexturePixelFormat FileEnvironment::ReadTexturePixelFormat(u32 handle) {
     return it->second;
 }
 
-bool FileEnvironment::IsTexturePixelFormatInteger(u32 handle) {
-    return VideoCore::Surface::IsPixelFormatInteger(
-        static_cast<VideoCore::Surface::PixelFormat>(ReadTexturePixelFormat(handle)));
-}
-
 u32 FileEnvironment::ReadViewportTransformState() {
     return viewport_transform_state;
 }

src/video_core/shader_environment.h

@@ -115,8 +115,6 @@ public:
 
     Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;
 
-    bool IsTexturePixelFormatInteger(u32 handle) override;
-
     u32 ReadViewportTransformState() override;
 
     std::optional<Shader::ReplaceConstant> GetReplaceConstBuffer(u32 bank, u32 offset) override;
@@ -141,8 +139,6 @@ public:
 
     Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;
 
-    bool IsTexturePixelFormatInteger(u32 handle) override;
-
     u32 ReadViewportTransformState() override;
 
     std::optional<Shader::ReplaceConstant> GetReplaceConstBuffer(
@@ -175,8 +171,6 @@ public:
 
     [[nodiscard]] Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;
 
-    [[nodiscard]] bool IsTexturePixelFormatInteger(u32 handle) override;
-
     [[nodiscard]] u32 ReadViewportTransformState() override;
 
     [[nodiscard]] u32 LocalMemorySize() const override;

src/yuzu/configuration/configure_graphics.cpp

@@ -106,30 +106,32 @@ ConfigureGraphics::ConfigureGraphics(
                                                 Settings::values.bg_green.GetValue(),
                                                 Settings::values.bg_blue.GetValue()));
     UpdateAPILayout();
-    PopulateVSyncModeSelection(false); //< must happen after UpdateAPILayout
+    PopulateVSyncModeSelection(); //< must happen after UpdateAPILayout
 
     // VSync setting needs to be determined after populating the VSync combobox
-    const auto vsync_mode_setting = Settings::values.vsync_mode.GetValue();
-    const auto vsync_mode = VSyncSettingToMode(vsync_mode_setting);
-    int index{};
-    for (const auto mode : vsync_mode_combobox_enum_map) {
-        if (mode == vsync_mode) {
-            break;
+    if (Settings::IsConfiguringGlobal()) {
+        const auto vsync_mode_setting = Settings::values.vsync_mode.GetValue();
+        const auto vsync_mode = VSyncSettingToMode(vsync_mode_setting);
+        int index{};
+        for (const auto mode : vsync_mode_combobox_enum_map) {
+            if (mode == vsync_mode) {
+                break;
+            }
+            index++;
+        }
+        if (static_cast<unsigned long>(index) < vsync_mode_combobox_enum_map.size()) {
+            vsync_mode_combobox->setCurrentIndex(index);
         }
-        index++;
-    }
-    if (static_cast<unsigned long>(index) < vsync_mode_combobox_enum_map.size()) {
-        vsync_mode_combobox->setCurrentIndex(index);
     }
 
     connect(api_combobox, qOverload<int>(&QComboBox::activated), this, [this] {
         UpdateAPILayout();
-        PopulateVSyncModeSelection(false);
+        PopulateVSyncModeSelection();
     });
     connect(vulkan_device_combobox, qOverload<int>(&QComboBox::activated), this,
             [this](int device) {
                 UpdateDeviceSelection(device);
-                PopulateVSyncModeSelection(false);
+                PopulateVSyncModeSelection();
             });
     connect(shader_backend_combobox, qOverload<int>(&QComboBox::activated), this,
             [this](int backend) { UpdateShaderBackendSelection(backend); });
@@ -145,9 +147,8 @@ ConfigureGraphics::ConfigureGraphics(
     const auto& update_screenshot_info = [this, &builder]() {
         const auto& combobox_enumerations = builder.ComboboxTranslations().at(
             Settings::EnumMetadata<Settings::AspectRatio>::Index());
-        const auto ratio_index = aspect_ratio_combobox->currentIndex();
-        const auto ratio =
-            static_cast<Settings::AspectRatio>(combobox_enumerations[ratio_index].first);
+        const auto index = aspect_ratio_combobox->currentIndex();
+        const auto ratio = static_cast<Settings::AspectRatio>(combobox_enumerations[index].first);
 
         const auto& combobox_enumerations_resolution = builder.ComboboxTranslations().at(
             Settings::EnumMetadata<Settings::ResolutionSetup>::Index());
@@ -173,7 +174,11 @@ ConfigureGraphics::ConfigureGraphics(
     }
 }
 
-void ConfigureGraphics::PopulateVSyncModeSelection(bool use_setting) {
+void ConfigureGraphics::PopulateVSyncModeSelection() {
+    if (!Settings::IsConfiguringGlobal()) {
+        return;
+    }
+
     const Settings::RendererBackend backend{GetCurrentGraphicsBackend()};
     if (backend == Settings::RendererBackend::Null) {
         vsync_mode_combobox->setEnabled(false);
@@ -184,9 +189,8 @@ void ConfigureGraphics::PopulateVSyncModeSelection(bool use_setting) {
     const int current_index = //< current selected vsync mode from combobox
         vsync_mode_combobox->currentIndex();
     const auto current_mode = //< current selected vsync mode as a VkPresentModeKHR
-        current_index == -1 || use_setting
-            ? VSyncSettingToMode(Settings::values.vsync_mode.GetValue())
-            : vsync_mode_combobox_enum_map[current_index];
+        current_index == -1 ? VSyncSettingToMode(Settings::values.vsync_mode.GetValue())
+                            : vsync_mode_combobox_enum_map[current_index];
     int index{};
     const int device{vulkan_device_combobox->currentIndex()}; //< current selected Vulkan device
 
@@ -210,23 +214,6 @@ void ConfigureGraphics::PopulateVSyncModeSelection(bool use_setting) {
         }
         index++;
     }
-
-    if (!Settings::IsConfiguringGlobal()) {
-        vsync_restore_global_button->setVisible(!Settings::values.vsync_mode.UsingGlobal());
-
-        const Settings::VSyncMode global_vsync_mode = Settings::values.vsync_mode.GetValue(true);
-        vsync_restore_global_button->setEnabled(
-            (backend == Settings::RendererBackend::OpenGL &&
-             (global_vsync_mode == Settings::VSyncMode::Immediate ||
-              global_vsync_mode == Settings::VSyncMode::Fifo)) ||
-            backend == Settings::RendererBackend::Vulkan);
-    }
-}
-
-void ConfigureGraphics::UpdateVsyncSetting() const {
-    const auto mode = vsync_mode_combobox_enum_map[vsync_mode_combobox->currentIndex()];
-    const auto vsync_mode = PresentModeToSetting(mode);
-    Settings::values.vsync_mode.SetValue(vsync_mode);
 }
 
 void ConfigureGraphics::UpdateDeviceSelection(int device) {
@@ -312,33 +299,6 @@ void ConfigureGraphics::Setup(const ConfigurationShared::Builder& builder) {
         } else if (setting->Id() == Settings::values.vsync_mode.Id()) {
             // Keep track of vsync_mode's combobox so we can populate it
             vsync_mode_combobox = widget->combobox;
-
-            // Since vsync is populated at runtime, we have to manually set up the button for
-            // restoring the global setting.
-            if (!Settings::IsConfiguringGlobal()) {
-                QPushButton* restore_button =
-                    ConfigurationShared::Widget::CreateRestoreGlobalButton(
-                        Settings::values.vsync_mode.UsingGlobal(), widget);
-                restore_button->setEnabled(true);
-                widget->layout()->addWidget(restore_button);
-
-                QObject::connect(restore_button, &QAbstractButton::clicked,
-                                 [restore_button, this](bool) {
-                                     Settings::values.vsync_mode.SetGlobal(true);
-                                     PopulateVSyncModeSelection(true);
-
-                                     restore_button->setVisible(false);
-                                 });
-
-                std::function<void()> set_non_global = [restore_button, this]() {
-                    Settings::values.vsync_mode.SetGlobal(false);
-                    UpdateVsyncSetting();
-                    restore_button->setVisible(true);
-                };
-                QObject::connect(widget->combobox, QOverload<int>::of(&QComboBox::activated),
-                                 [set_non_global]() { set_non_global(); });
-                vsync_restore_global_button = restore_button;
-            }
             hold_graphics.emplace(setting->Id(), widget);
         } else if (setting->Id() == Settings::values.aspect_ratio.Id()) {
             // Keep track of the aspect ratio combobox to update other UI tabs that need it
@@ -440,7 +400,11 @@ void ConfigureGraphics::ApplyConfiguration() {
         func(powered_on);
     }
 
-    UpdateVsyncSetting();
+    if (Settings::IsConfiguringGlobal()) {
+        const auto mode = vsync_mode_combobox_enum_map[vsync_mode_combobox->currentIndex()];
+        const auto vsync_mode = PresentModeToSetting(mode);
+        Settings::values.vsync_mode.SetValue(vsync_mode);
+    }
 
     Settings::values.vulkan_device.SetGlobal(true);
     Settings::values.shader_backend.SetGlobal(true);

src/yuzu/configuration/configure_graphics.h

@@ -62,8 +62,7 @@ private:
 
     void Setup(const ConfigurationShared::Builder& builder);
 
-    void PopulateVSyncModeSelection(bool use_setting);
-    void UpdateVsyncSetting() const;
+    void PopulateVSyncModeSelection();
     void UpdateBackgroundColorButton(QColor color);
     void UpdateAPILayout();
     void UpdateDeviceSelection(int device);
@@ -105,7 +104,6 @@ private:
     QComboBox* api_combobox;
     QComboBox* shader_backend_combobox;
     QComboBox* vsync_mode_combobox;
-    QPushButton* vsync_restore_global_button;
     QWidget* vulkan_device_widget;
     QWidget* api_widget;
     QWidget* shader_backend_widget;