gl_rasterizer: Implement DrawTransformFeedback macro

CMakeLists.txt

@@ -305,7 +305,7 @@ find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)
 
 if (NOT YUZU_USE_EXTERNAL_VULKAN_HEADERS)
-    find_package(Vulkan 1.3.274 REQUIRED)
+    find_package(Vulkan 1.3.256 REQUIRED)
 endif()
 
 if (ENABLE_LIBUSB)

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/arm/nce/arm_nce.cpp

@@ -39,7 +39,7 @@ fpsimd_context* GetFloatingPointState(mcontext_t& host_ctx) {
 }
 
 using namespace Common::Literals;
-constexpr u32 StackSize = 128_KiB;
+constexpr u32 StackSize = 32_KiB;
 
 } // namespace
 

src/core/arm/nce/interpreter_visitor.cpp

@@ -5,6 +5,8 @@
 #include "common/bit_cast.h"
 #include "core/arm/nce/interpreter_visitor.h"
 
+#include <dynarmic/frontend/A64/decoder/a64.h>
+
 namespace Core {
 
 template <u32 BitSize>
@@ -247,7 +249,6 @@ bool InterpreterVisitor::LDR_lit_fpsimd(Imm<2> opc, Imm<19> imm19, Vec Vt) {
         return false;
     }
 
-    // Size in bytes
     const u64 size = 4 << opc.ZeroExtend();
     const u64 offset = imm19.SignExtend<u64>() << 2;
     const u64 address = this->GetPc() + offset;
@@ -529,7 +530,7 @@ bool InterpreterVisitor::SIMDImmediate(bool wback, bool postindex, size_t scale,
     }
     case MemOp::Load: {
         u128 data{};
-        m_memory.ReadBlock(address, &data, datasize / 8);
+        m_memory.ReadBlock(address, &data, datasize);
         this->SetVec(Vt, data);
         break;
     }

src/core/arm/nce/visitor_base.h

@@ -4,15 +4,9 @@
 
 #pragma once
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow"
-
 #include <dynarmic/frontend/A64/a64_types.h>
-#include <dynarmic/frontend/A64/decoder/a64.h>
 #include <dynarmic/frontend/imm.h>
 
-#pragma GCC diagnostic pop
-
 namespace Core {
 
 class VisitorBase {

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_context_get_set.cpp

@@ -74,11 +74,6 @@ std::optional<OutAttr> OutputAttrPointer(EmitContext& ctx, IR::Attribute attr) {
     case IR::Attribute::ClipDistance7: {
         const u32 base{static_cast<u32>(IR::Attribute::ClipDistance0)};
         const u32 index{static_cast<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);
-            return std::nullopt;
-        }
         const Id clip_num{ctx.Const(index)};
         return OutputAccessChain(ctx, ctx.output_f32, ctx.clip_distances, clip_num);
     }

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -74,17 +74,9 @@ spv::ImageFormat GetImageFormat(ImageFormat format) {
     throw InvalidArgument("Invalid image format {}", format);
 }
 
-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)};
+    const Id type{ctx.U32[1]};
     switch (desc.type) {
     case TextureType::Color1D:
         return ctx.TypeImage(type, spv::Dim::Dim1D, false, false, false, 2, format);
@@ -1536,8 +1528,7 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
         if (stage == Stage::Fragment) {
             throw NotImplementedException("Storing ClipDistance in fragment stage");
         }
-        const Id type{TypeArray(
-            F32[1], Const(std::min(info.used_clip_distances, profile.max_user_clip_distances)))};
+        const Id type{TypeArray(F32[1], Const(8U))};
         clip_distances = DefineOutput(*this, type, invocations, spv::BuiltIn::ClipDistance);
     }
     if (info.stores[IR::Attribute::Layer] &&

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,         Opaque,                                         )
+OPCODE(ImageWrite,                                          Void,           Opaque,         Opaque,         U32x4,                                          )
 
 OPCODE(IsTextureScaled,                                     U1,             U32,                                                                            )
 OPCODE(IsImageScaled,                                       U1,             U32,                                                                            )

src/shader_recompiler/host_translate_info.h

@@ -19,10 +19,8 @@ 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_ufloat_write_as_uint{}; ///< True when the device supports writing float images
-                                         ///< as bitcasts to uint
+    bool support_conditional_barrier{}; ///< True when the device supports barriers in conditional
+                                        ///< control flow
 };
 
 } // namespace Shader

src/shader_recompiler/ir_opt/collect_shader_info_pass.cpp

@@ -913,11 +913,7 @@ void GatherInfoFromHeader(Environment& env, Info& info) {
         }
         for (size_t index = 0; index < 8; ++index) {
             const u16 mask{header.vtg.omap_systemc.clip_distances};
-            const bool used{((mask >> index) & 1) != 0};
-            info.stores.Set(IR::Attribute::ClipDistance0 + index, used);
-            if (used) {
-                info.used_clip_distances = static_cast<u32>(index) + 1;
-            }
+            info.stores.Set(IR::Attribute::ClipDistance0 + index, ((mask >> index) & 1) != 0);
         }
         info.stores.Set(IR::Attribute::PrimitiveId,
                         header.vtg.omap_systemb.primitive_array_id != 0);

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -372,10 +372,6 @@ TexturePixelFormat ReadTexturePixelFormat(Environment& env, const ConstBufferAdd
     return env.ReadTexturePixelFormat(GetTextureHandle(env, cbuf));
 }
 
-bool TexturePixelFormatIsFloat(Environment& env, const ConstBufferAddr& cbuf) {
-    return ReadTexturePixelFormat(env, cbuf) == TexturePixelFormat::B10G11R11_FLOAT;
-}
-
 class Descriptors {
 public:
     explicit Descriptors(TextureBufferDescriptors& texture_buffer_descriptors_,
@@ -432,9 +428,8 @@ 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.is_float == existing.is_float;
+                   desc.size_shift == existing.size_shift;
         })};
-        // TODO: handle is_float?
         image_descriptors[index].is_written |= desc.is_written;
         image_descriptors[index].is_read |= desc.is_read;
         return index;
@@ -505,19 +500,6 @@ 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) {
@@ -549,9 +531,6 @@ 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()) {
@@ -624,7 +603,6 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                     .format = flags.image_format,
                     .is_written = is_written,
                     .is_read = is_read,
-                    .is_float = is_float_write,
                     .cbuf_index = cbuf.index,
                     .cbuf_offset = cbuf.offset,
                     .count = cbuf.count,
@@ -684,10 +662,6 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                 PatchTexelFetch(*texture_inst.block, *texture_inst.inst, pixel_format);
             }
         }
-
-        if (is_float_write) {
-            PatchSmallFloatImageWrite(*texture_inst.block, *inst);
-        }
     }
 }
 

src/shader_recompiler/profile.h

@@ -87,8 +87,6 @@ struct Profile {
     bool has_broken_robust{};
 
     u64 min_ssbo_alignment{};
-
-    u32 max_user_clip_distances{};
 };
 
 } // namespace Shader

src/shader_recompiler/shader_info.h

@@ -42,7 +42,6 @@ enum class TexturePixelFormat : u32 {
     R16G16B16A16_SNORM,
     R16G16_SNORM,
     R16_SNORM,
-    B10G11R11_FLOAT,
     OTHER
 };
 
@@ -130,7 +129,6 @@ struct ImageDescriptor {
     ImageFormat format;
     bool is_written;
     bool is_read;
-    bool is_float;
     u32 cbuf_index;
     u32 cbuf_offset;
     u32 count;
@@ -229,8 +227,6 @@ struct Info {
     bool requires_layer_emulation{};
     IR::Attribute emulated_layer{};
 
-    u32 used_clip_distances{};
-
     boost::container::static_vector<ConstantBufferDescriptor, MAX_CBUFS>
         constant_buffer_descriptors;
     boost::container::static_vector<StorageBufferDescriptor, MAX_SSBOS> storage_buffers_descriptors;

src/video_core/macro/macro_hle.cpp

@@ -327,12 +327,13 @@ public:
     explicit HLE_DrawIndirectByteCount(Maxwell3D& maxwell3d_) : HLEMacroImpl(maxwell3d_) {}
 
     void Execute(const std::vector<u32>& parameters, [[maybe_unused]] u32 method) override {
+        const bool force = maxwell3d.Rasterizer().HasDrawTransformFeedback();
+
         auto topology = static_cast<Maxwell3D::Regs::PrimitiveTopology>(parameters[0] & 0xFFFFU);
-        if (!maxwell3d.AnyParametersDirty() || !IsTopologySafe(topology)) {
+        if (!force && (!maxwell3d.AnyParametersDirty() || !IsTopologySafe(topology))) {
             Fallback(parameters);
             return;
         }
-
         auto& params = maxwell3d.draw_manager->GetIndirectParams();
         params.is_byte_count = true;
         params.is_indexed = false;
@@ -503,6 +504,8 @@ public:
         maxwell3d.CallMethod(static_cast<size_t>(MAXWELL3D_REG_INDEX(launch_dma)), 0x1011, true);
         maxwell3d.CallMethod(static_cast<size_t>(MAXWELL3D_REG_INDEX(inline_data)),
                              regs.transform_feedback.controls[0].stride, true);
+
+        maxwell3d.Rasterizer().RegisterTransformFeedback(regs.upload.dest.Address());
     }
 };
 

src/video_core/rasterizer_interface.h

@@ -173,5 +173,13 @@ public:
     virtual void BindChannel(Tegra::Control::ChannelState& channel) {}
 
     virtual void ReleaseChannel(s32 channel_id) {}
+
+    /// Register the address as a Transform Feedback Object
+    virtual void RegisterTransformFeedback(GPUVAddr tfb_object_addr) {}
+
+    /// Returns true when the rasterizer has Draw Transform Feedback capabilities
+    virtual bool HasDrawTransformFeedback() {
+        return false;
+    }
 };
 } // namespace VideoCore

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -376,4 +376,15 @@ void BufferCacheRuntime::BindImageBuffer(Buffer& buffer, u32 offset, u32 size, P
     *image_handles++ = buffer.View(offset, size, format);
 }
 
+void BufferCacheRuntime::BindTransformFeedbackObject(GPUVAddr tfb_object_addr) {
+    OGLTransformFeedback& tfb_object = tfb_objects[tfb_object_addr];
+    tfb_object.Create();
+    glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfb_object.handle);
+}
+
+GLuint BufferCacheRuntime::GetTransformFeedbackObject(GPUVAddr tfb_object_addr) {
+    ASSERT(tfb_objects.contains(tfb_object_addr));
+    return tfb_objects[tfb_object_addr].handle;
+}
+
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -5,6 +5,7 @@
 
 #include <array>
 #include <span>
+#include <unordered_map>
 
 #include "common/common_types.h"
 #include "video_core/buffer_cache/buffer_cache_base.h"
@@ -121,6 +122,9 @@ public:
     void BindImageBuffer(Buffer& buffer, u32 offset, u32 size,
                          VideoCore::Surface::PixelFormat format);
 
+    void BindTransformFeedbackObject(GPUVAddr tfb_object_addr);
+    GLuint GetTransformFeedbackObject(GPUVAddr tfb_object_addr);
+
     u64 GetDeviceMemoryUsage() const;
 
     void BindFastUniformBuffer(size_t stage, u32 binding_index, u32 size) {
@@ -233,6 +237,7 @@ private:
     u32 index_buffer_offset = 0;
 
     u64 device_access_memory;
+    std::unordered_map<GPUVAddr, OGLTransformFeedback> tfb_objects;
 };
 
 struct BufferCacheParams {

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -294,6 +294,13 @@ void RasterizerOpenGL::DrawIndirect() {
     const auto& params = maxwell3d->draw_manager->GetIndirectParams();
     buffer_cache.SetDrawIndirect(&params);
     PrepareDraw(params.is_indexed, [this, &params](GLenum primitive_mode) {
+        if (params.is_byte_count) {
+            const GPUVAddr tfb_object_base_addr = params.indirect_start_address - 4U;
+            const GLuint tfb_object =
+                buffer_cache_runtime.GetTransformFeedbackObject(tfb_object_base_addr);
+            glDrawTransformFeedback(primitive_mode, tfb_object);
+            return;
+        }
         const auto [buffer, offset] = buffer_cache.GetDrawIndirectBuffer();
         const GLvoid* const gl_offset =
             reinterpret_cast<const GLvoid*>(static_cast<uintptr_t>(offset));
@@ -1350,6 +1357,10 @@ void RasterizerOpenGL::ReleaseChannel(s32 channel_id) {
     query_cache.EraseChannel(channel_id);
 }
 
+void RasterizerOpenGL::RegisterTransformFeedback(GPUVAddr tfb_object_addr) {
+    buffer_cache_runtime.BindTransformFeedbackObject(tfb_object_addr);
+}
+
 AccelerateDMA::AccelerateDMA(BufferCache& buffer_cache_, TextureCache& texture_cache_)
     : buffer_cache{buffer_cache_}, texture_cache{texture_cache_} {}
 

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -139,6 +139,12 @@ public:
 
     void ReleaseChannel(s32 channel_id) override;
 
+    void RegisterTransformFeedback(GPUVAddr tfb_object_addr) override;
+
+    bool HasDrawTransformFeedback() override {
+        return true;
+    }
+
 private:
     static constexpr size_t MAX_TEXTURES = 192;
     static constexpr size_t MAX_IMAGES = 48;

src/video_core/renderer_opengl/gl_resource_manager.cpp

@@ -207,4 +207,21 @@ void OGLQuery::Release() {
     handle = 0;
 }
 
+void OGLTransformFeedback::Create() {
+    if (handle != 0)
+        return;
+
+    MICROPROFILE_SCOPE(OpenGL_ResourceCreation);
+    glCreateTransformFeedbacks(1, &handle);
+}
+
+void OGLTransformFeedback::Release() {
+    if (handle == 0)
+        return;
+
+    MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
+    glDeleteTransformFeedbacks(1, &handle);
+    handle = 0;
+}
+
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_resource_manager.h

@@ -323,4 +323,31 @@ public:
     GLuint handle = 0;
 };
 
+class OGLTransformFeedback final {
+public:
+    YUZU_NON_COPYABLE(OGLTransformFeedback);
+
+    OGLTransformFeedback() = default;
+
+    OGLTransformFeedback(OGLTransformFeedback&& o) noexcept : handle(std::exchange(o.handle, 0)) {}
+
+    ~OGLTransformFeedback() {
+        Release();
+    }
+
+    OGLTransformFeedback& operator=(OGLTransformFeedback&& o) noexcept {
+        Release();
+        handle = std::exchange(o.handle, 0);
+        return *this;
+    }
+
+    /// Creates a new internal OpenGL resource and stores the handle
+    void Create();
+
+    /// Deletes the internal OpenGL resource
+    void Release();
+
+    GLuint handle = 0;
+};
+
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -233,7 +233,6 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .ignore_nan_fp_comparisons = true,
           .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
           .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
-          .max_user_clip_distances = 8,
       },
       host_info{
           .support_float64 = true,
@@ -245,7 +244,6 @@ 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_buffer_cache.cpp

@@ -563,27 +563,22 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
         }
         buffer_handles.push_back(handle);
     }
-    const u32 device_max = device.GetMaxVertexInputBindings();
-    const u32 min_binding = std::min(bindings.min_index, device_max);
-    const u32 max_binding = std::min(bindings.max_index, device_max);
-    const u32 binding_count = max_binding - min_binding;
-    if (binding_count == 0) {
-        return;
-    }
     if (device.IsExtExtendedDynamicStateSupported()) {
-        scheduler.Record([bindings_ = std::move(bindings),
-                          buffer_handles_ = std::move(buffer_handles),
-                          binding_count](vk::CommandBuffer cmdbuf) {
-            cmdbuf.BindVertexBuffers2EXT(bindings_.min_index, binding_count, buffer_handles_.data(),
-                                         bindings_.offsets.data(), bindings_.sizes.data(),
-                                         bindings_.strides.data());
+        scheduler.Record([this, bindings_ = std::move(bindings),
+                          buffer_handles_ = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
+            cmdbuf.BindVertexBuffers2EXT(bindings_.min_index,
+                                         std::min(bindings_.max_index - bindings_.min_index,
+                                                  device.GetMaxVertexInputBindings()),
+                                         buffer_handles_.data(), bindings_.offsets.data(),
+                                         bindings_.sizes.data(), bindings_.strides.data());
         });
     } else {
-        scheduler.Record([bindings_ = std::move(bindings),
-                          buffer_handles_ = std::move(buffer_handles),
-                          binding_count](vk::CommandBuffer cmdbuf) {
-            cmdbuf.BindVertexBuffers(bindings_.min_index, binding_count, buffer_handles_.data(),
-                                     bindings_.offsets.data());
+        scheduler.Record([this, bindings_ = std::move(bindings),
+                          buffer_handles_ = std::move(buffer_handles)](vk::CommandBuffer cmdbuf) {
+            cmdbuf.BindVertexBuffers(bindings_.min_index,
+                                     std::min(bindings_.max_index - bindings_.min_index,
+                                              device.GetMaxVertexInputBindings()),
+                                     buffer_handles_.data(), bindings_.offsets.data());
         });
     }
 }

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -374,7 +374,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
         .has_broken_robust =
             device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
         .min_ssbo_alignment = device.GetStorageBufferAlignment(),
-        .max_user_clip_distances = device.GetMaxUserClipDistances(),
     };
 
     host_info = Shader::HostTranslateInfo{
@@ -388,8 +387,6 @@ 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,
     };
 
     if (device.GetMaxVertexInputAttributes() < Maxwell::NumVertexAttributes) {

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -289,15 +289,12 @@ public:
         }
 
         if (has_multi_queries) {
-            const size_t min_accumulation_limit =
-                std::min(first_accumulation_checkpoint, num_slots_used);
-            const size_t max_accumulation_limit =
-                std::max(last_accumulation_checkpoint, num_slots_used);
-            const size_t intermediary_buffer_index = ObtainBuffer<false>(num_slots_used);
+            size_t intermediary_buffer_index = ObtainBuffer<false>(num_slots_used);
             resolve_buffers.push_back(intermediary_buffer_index);
             queries_prefix_scan_pass->Run(*accumulation_buffer, *buffers[intermediary_buffer_index],
                                           *buffers[resolve_buffer_index], num_slots_used,
-                                          min_accumulation_limit, max_accumulation_limit);
+                                          std::min(first_accumulation_checkpoint, num_slots_used),
+                                          last_accumulation_checkpoint);
 
         } else {
             scheduler.RequestOutsideRenderPassOperationContext();

src/video_core/shader_environment.cpp

@@ -76,8 +76,6 @@ static Shader::TexturePixelFormat ConvertTexturePixelFormat(const Tegra::Texture
         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;
     }

src/video_core/vulkan_common/vulkan_device.cpp

@@ -695,11 +695,6 @@ 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");
-        properties.properties.limits.maxVertexInputBindings = 32;
-    }
-
     if (!extensions.extended_dynamic_state && extensions.extended_dynamic_state2) {
         LOG_INFO(Render_Vulkan,
                  "Removing extendedDynamicState2 due to missing extendedDynamicState");

src/video_core/vulkan_common/vulkan_device.h

@@ -665,10 +665,6 @@ public:
         return properties.properties.limits.maxViewports;
     }
 
-    u32 GetMaxUserClipDistances() const {
-        return properties.properties.limits.maxClipDistances;
-    }
-
     bool SupportsConditionalBarriers() const {
         return supports_conditional_barriers;
     }

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -377,8 +377,6 @@ const char* ToString(VkResult result) noexcept {
         return "VK_OPERATION_DEFERRED_KHR";
     case VkResult::VK_OPERATION_NOT_DEFERRED_KHR:
         return "VK_OPERATION_NOT_DEFERRED_KHR";
-    case VkResult::VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR:
-        return "VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR";
     case VkResult::VK_PIPELINE_COMPILE_REQUIRED_EXT:
         return "VK_PIPELINE_COMPILE_REQUIRED_EXT";
     case VkResult::VK_RESULT_MAX_ENUM:

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;