Android #164

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)

README.md

@@ -1,7 +1,10 @@
 | 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 |
+| [12304](https://github.com/yuzu-emu/yuzu//pull/12304) | [`fcc85abe2`](https://github.com/yuzu-emu/yuzu//pull/12304/files) | nvnflinger: mark buffer as acquired when acquired | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12349](https://github.com/yuzu-emu/yuzu//pull/12349) | [`6851e9329`](https://github.com/yuzu-emu/yuzu//pull/12349/files) | Have GetActiveChannelCount return the system channels instead of host device channels | [Kelebek1](https://github.com/Kelebek1/) | Yes |
+| [12382](https://github.com/yuzu-emu/yuzu//pull/12382) | [`7fc06260d`](https://github.com/yuzu-emu/yuzu//pull/12382/files) | renderer_vulkan: allow up to 7 swapchain images | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12387](https://github.com/yuzu-emu/yuzu//pull/12387) | [`6ca530a72`](https://github.com/yuzu-emu/yuzu//pull/12387/files) | android: add oboe audio sink | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12391](https://github.com/yuzu-emu/yuzu//pull/12391) | [`65e646eeb`](https://github.com/yuzu-emu/yuzu//pull/12391/files) | Revert "video_core: use interval map for page count tracking" | [liamwhite](https://github.com/liamwhite/) | Yes |
 
 
 End of merge log. You can find the original README.md below the break.

src/audio_core/sink/oboe_sink.cpp

@@ -29,7 +29,7 @@ public:
     }
 
     ~OboeSinkStream() override {
-        LOG_INFO(Audio_Sink, "Destroyed Oboe stream");
+        LOG_DEBUG(Audio_Sink, "Destructing Oboe stream {}", name);
     }
 
     void Finalize() override {
@@ -66,7 +66,11 @@ public:
         std::shared_ptr<oboe::AudioStream> temp_stream;
         oboe::AudioStreamBuilder builder;
 
-        const auto result = ConfigureBuilder(builder, direction)->openStream(temp_stream);
+        const auto result = builder.setDirection(direction)
+                                ->setSampleRate(TargetSampleRate)
+                                ->setFormat(oboe::AudioFormat::I16)
+                                ->setFormatConversionAllowed(true)
+                                ->openStream(temp_stream);
         ASSERT(result == oboe::Result::OK);
 
         return temp_stream->getChannelCount() >= 6 ? 6 : 2;
@@ -101,20 +105,6 @@ protected:
     }
 
 private:
-    static oboe::AudioStreamBuilder* ConfigureBuilder(oboe::AudioStreamBuilder& builder,
-                                                      oboe::Direction direction) {
-        // TODO: investigate callback delay issues when using AAudio
-        return builder.setPerformanceMode(oboe::PerformanceMode::LowLatency)
-            ->setAudioApi(oboe::AudioApi::OpenSLES)
-            ->setDirection(direction)
-            ->setSampleRate(TargetSampleRate)
-            ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::High)
-            ->setFormat(oboe::AudioFormat::I16)
-            ->setFormatConversionAllowed(true)
-            ->setUsage(oboe::Usage::Game)
-            ->setBufferCapacityInFrames(TargetSampleCount * 2);
-    }
-
     bool OpenStream() {
         const auto direction = [&]() {
             switch (type) {
@@ -145,10 +135,12 @@ private:
         }();
 
         oboe::AudioStreamBuilder builder;
-        const auto result = ConfigureBuilder(builder, direction)
+        const auto result = builder.setDirection(direction)
+                                ->setSampleRate(TargetSampleRate)
                                 ->setChannelCount(expected_channels)
                                 ->setChannelMask(expected_mask)
-                                ->setChannelConversionAllowed(true)
+                                ->setFormat(oboe::AudioFormat::I16)
+                                ->setFormatConversionAllowed(true)
                                 ->setDataCallback(this)
                                 ->setErrorCallback(this)
                                 ->openStream(m_stream);
@@ -159,16 +151,8 @@ private:
     bool SetStreamProperties() {
         ASSERT(m_stream);
 
-        m_stream->setBufferSizeInFrames(TargetSampleCount * 2);
         device_channels = m_stream->getChannelCount();
-
-        const auto sample_rate = m_stream->getSampleRate();
-        const auto buffer_capacity = m_stream->getBufferCapacityInFrames();
-        const auto stream_backend =
-            m_stream->getAudioApi() == oboe::AudioApi::AAudio ? "AAudio" : "OpenSLES";
-
-        LOG_INFO(Audio_Sink, "Opened Oboe {} stream with {} channels sample rate {} capacity {}",
-                 stream_backend, device_channels, sample_rate, buffer_capacity);
+        LOG_INFO(Audio_Sink, "Opened Oboe stream with {} channels", device_channels);
 
         return true;
     }

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/filesystem/filesystem.h

@@ -54,13 +54,6 @@ enum class ImageDirectoryId : u32 {
     SdCard,
 };
 
-enum class OpenDirectoryMode : u64 {
-    Directory = (1 << 0),
-    File = (1 << 1),
-    All = Directory | File
-};
-DECLARE_ENUM_FLAG_OPERATORS(OpenDirectoryMode);
-
 class FileSystemController {
 public:
     explicit FileSystemController(Core::System& system_);

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -259,7 +259,7 @@ static void BuildEntryIndex(std::vector<FileSys::Entry>& entries, const std::vec
 
 class IDirectory final : public ServiceFramework<IDirectory> {
 public:
-    explicit IDirectory(Core::System& system_, FileSys::VirtualDir backend_, OpenDirectoryMode mode)
+    explicit IDirectory(Core::System& system_, FileSys::VirtualDir backend_)
         : ServiceFramework{system_, "IDirectory"}, backend(std::move(backend_)) {
         static const FunctionInfo functions[] = {
             {0, &IDirectory::Read, "Read"},
@@ -269,12 +269,8 @@ public:
 
         // TODO(DarkLordZach): Verify that this is the correct behavior.
         // Build entry index now to save time later.
-        if (True(mode & OpenDirectoryMode::Directory)) {
-            BuildEntryIndex(entries, backend->GetSubdirectories(), FileSys::EntryType::Directory);
-        }
-        if (True(mode & OpenDirectoryMode::File)) {
-            BuildEntryIndex(entries, backend->GetFiles(), FileSys::EntryType::File);
-        }
+        BuildEntryIndex(entries, backend->GetFiles(), FileSys::EntryType::File);
+        BuildEntryIndex(entries, backend->GetSubdirectories(), FileSys::EntryType::Directory);
     }
 
 private:
@@ -450,9 +446,11 @@ public:
 
         const auto file_buffer = ctx.ReadBuffer();
         const std::string name = Common::StringFromBuffer(file_buffer);
-        const auto mode = rp.PopRaw<OpenDirectoryMode>();
 
-        LOG_DEBUG(Service_FS, "called. directory={}, mode={}", name, mode);
+        // TODO(Subv): Implement this filter.
+        const u32 filter_flags = rp.Pop<u32>();
+
+        LOG_DEBUG(Service_FS, "called. directory={}, filter={}", name, filter_flags);
 
         FileSys::VirtualDir vfs_dir{};
         auto result = backend.OpenDirectory(&vfs_dir, name);
@@ -462,7 +460,7 @@ public:
             return;
         }
 
-        auto directory = std::make_shared<IDirectory>(system, vfs_dir, mode);
+        auto directory = std::make_shared<IDirectory>(system, vfs_dir);
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(ResultSuccess);

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/renderer_opengl/gl_buffer_cache.cpp

@@ -58,9 +58,6 @@ Buffer::Buffer(BufferCacheRuntime& runtime, VideoCore::RasterizerInterface& rast
         glObjectLabel(GL_BUFFER, buffer.handle, static_cast<GLsizei>(name.size()), name.data());
     }
     glNamedBufferData(buffer.handle, SizeBytes(), nullptr, GL_DYNAMIC_DRAW);
-    if (runtime.has_unified_vertex_buffers) {
-        glGetNamedBufferParameterui64vNV(buffer.handle, GL_BUFFER_GPU_ADDRESS_NV, &address);
-    }
 }
 
 void Buffer::ImmediateUpload(size_t offset, std::span<const u8> data) noexcept {
@@ -112,7 +109,6 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_,
     : device{device_}, staging_buffer_pool{staging_buffer_pool_},
       has_fast_buffer_sub_data{device.HasFastBufferSubData()},
       use_assembly_shaders{device.UseAssemblyShaders()},
-      has_unified_vertex_buffers{device.HasVertexBufferUnifiedMemory()},
       stream_buffer{has_fast_buffer_sub_data ? std::nullopt : std::make_optional<StreamBuffer>()} {
     GLint gl_max_attributes;
     glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &gl_max_attributes);
@@ -214,14 +210,8 @@ void BufferCacheRuntime::ClearBuffer(Buffer& dest_buffer, u32 offset, size_t siz
 }
 
 void BufferCacheRuntime::BindIndexBuffer(Buffer& buffer, u32 offset, u32 size) {
-    if (has_unified_vertex_buffers) {
-        buffer.MakeResident(GL_READ_ONLY);
-        glBufferAddressRangeNV(GL_ELEMENT_ARRAY_ADDRESS_NV, 0, buffer.HostGpuAddr() + offset,
-                               static_cast<GLsizeiptr>(Common::AlignUp(size, 4)));
-    } else {
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer.Handle());
-        index_buffer_offset = offset;
-    }
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer.Handle());
+    index_buffer_offset = offset;
 }
 
 void BufferCacheRuntime::BindVertexBuffer(u32 index, Buffer& buffer, u32 offset, u32 size,
@@ -229,15 +219,8 @@ void BufferCacheRuntime::BindVertexBuffer(u32 index, Buffer& buffer, u32 offset,
     if (index >= max_attributes) {
         return;
     }
-    if (has_unified_vertex_buffers) {
-        buffer.MakeResident(GL_READ_ONLY);
-        glBindVertexBuffer(index, 0, 0, static_cast<GLsizei>(stride));
-        glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, index,
-                               buffer.HostGpuAddr() + offset, static_cast<GLsizeiptr>(size));
-    } else {
-        glBindVertexBuffer(index, buffer.Handle(), static_cast<GLintptr>(offset),
-                           static_cast<GLsizei>(stride));
-    }
+    glBindVertexBuffer(index, buffer.Handle(), static_cast<GLintptr>(offset),
+                       static_cast<GLsizei>(stride));
 }
 
 void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bindings) {
@@ -250,23 +233,9 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
                            [](u64 stride) { return static_cast<GLsizei>(stride); });
     const u32 count =
         std::min(static_cast<u32>(bindings.buffers.size()), max_attributes - bindings.min_index);
-    if (has_unified_vertex_buffers) {
-        for (u32 index = 0; index < count; ++index) {
-            Buffer& buffer = *bindings.buffers[index];
-            buffer.MakeResident(GL_READ_ONLY);
-            glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, bindings.min_index + index,
-                                   buffer.HostGpuAddr() + bindings.offsets[index],
-                                   static_cast<GLsizeiptr>(bindings.sizes[index]));
-        }
-        static constexpr std::array<size_t, 32> ZEROS{};
-        glBindVertexBuffers(bindings.min_index, static_cast<GLsizei>(count),
-                            reinterpret_cast<const GLuint*>(ZEROS.data()),
-                            reinterpret_cast<const GLintptr*>(ZEROS.data()), buffer_strides.data());
-    } else {
-        glBindVertexBuffers(bindings.min_index, static_cast<GLsizei>(count), buffer_handles.data(),
-                            reinterpret_cast<const GLintptr*>(bindings.offsets.data()),
-                            buffer_strides.data());
-    }
+    glBindVertexBuffers(bindings.min_index, static_cast<GLsizei>(count), buffer_handles.data(),
+                        reinterpret_cast<const GLintptr*>(bindings.offsets.data()),
+                        buffer_strides.data());
 }
 
 void BufferCacheRuntime::BindUniformBuffer(size_t stage, u32 binding_index, Buffer& buffer,

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -209,7 +209,6 @@ private:
 
     bool has_fast_buffer_sub_data = false;
     bool use_assembly_shaders = false;
-    bool has_unified_vertex_buffers = false;
 
     bool use_storage_buffers = false;
 

src/video_core/renderer_opengl/gl_device.cpp

@@ -200,7 +200,6 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     has_broken_texture_view_formats = is_amd || (!is_linux && is_intel);
     has_nv_viewport_array2 = GLAD_GL_NV_viewport_array2;
     has_derivative_control = GLAD_GL_ARB_derivative_control;
-    has_vertex_buffer_unified_memory = GLAD_GL_NV_vertex_buffer_unified_memory;
     has_debugging_tool_attached = IsDebugToolAttached(extensions);
     has_depth_buffer_float = HasExtension(extensions, "GL_NV_depth_buffer_float");
     has_geometry_shader_passthrough = GLAD_GL_NV_geometry_shader_passthrough;

src/video_core/renderer_opengl/gl_device.h

@@ -72,10 +72,6 @@ public:
         return has_texture_shadow_lod;
     }
 
-    bool HasVertexBufferUnifiedMemory() const {
-        return has_vertex_buffer_unified_memory;
-    }
-
     bool HasASTC() const {
         return has_astc;
     }
@@ -215,7 +211,6 @@ private:
     bool has_vertex_viewport_layer{};
     bool has_image_load_formatted{};
     bool has_texture_shadow_lod{};
-    bool has_vertex_buffer_unified_memory{};
     bool has_astc{};
     bool has_variable_aoffi{};
     bool has_component_indexing_bug{};

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -162,18 +162,14 @@ void RasterizerOpenGL::Clear(u32 layer_count) {
         SyncFramebufferSRGB();
     }
     if (regs.clear_surface.Z) {
-        if (regs.zeta_enable != 0) {
-            LOG_DEBUG(Render_OpenGL, "Tried to clear Z but buffer is not enabled!");
-        }
+        ASSERT_MSG(regs.zeta_enable != 0, "Tried to clear Z but buffer is not enabled!");
         use_depth = true;
 
         state_tracker.NotifyDepthMask();
         glDepthMask(GL_TRUE);
     }
     if (regs.clear_surface.S) {
-        if (regs.zeta_enable) {
-            LOG_DEBUG(Render_OpenGL, "Tried to clear stencil but buffer is not enabled!");
-        }
+        ASSERT_MSG(regs.zeta_enable, "Tried to clear stencil but buffer is not enabled!");
         use_stencil = true;
     }
 
@@ -1298,13 +1294,15 @@ void RasterizerOpenGL::BeginTransformFeedback(GraphicsPipeline* program, GLenum
     program->ConfigureTransformFeedback();
 
     UNIMPLEMENTED_IF(regs.IsShaderConfigEnabled(Maxwell::ShaderType::TessellationInit) ||
-                     regs.IsShaderConfigEnabled(Maxwell::ShaderType::Tessellation));
+                     regs.IsShaderConfigEnabled(Maxwell::ShaderType::Tessellation) ||
+                     regs.IsShaderConfigEnabled(Maxwell::ShaderType::Geometry));
+    UNIMPLEMENTED_IF(primitive_mode != GL_POINTS);
 
     // We may have to call BeginTransformFeedbackNV here since they seem to call different
     // implementations on Nvidia's driver (the pointer is different) but we are using
     // ARB_transform_feedback3 features with NV_transform_feedback interactions and the ARB
     // extension doesn't define BeginTransformFeedback (without NV) interactions. It just works.
-    glBeginTransformFeedback(primitive_mode);
+    glBeginTransformFeedback(GL_POINTS);
 }
 
 void RasterizerOpenGL::EndTransformFeedback() {

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_opengl/renderer_opengl.cpp

@@ -168,14 +168,6 @@ RendererOpenGL::RendererOpenGL(Core::TelemetrySession& telemetry_session_,
     if (!GLAD_GL_ARB_seamless_cubemap_per_texture && !GLAD_GL_AMD_seamless_cubemap_per_texture) {
         glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
     }
-    // Enable unified vertex attributes and query vertex buffer address when the driver supports it
-    if (device.HasVertexBufferUnifiedMemory()) {
-        glEnableClientState(GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV);
-        glEnableClientState(GL_ELEMENT_ARRAY_UNIFIED_NV);
-        glMakeNamedBufferResidentNV(vertex_buffer.handle, GL_READ_ONLY);
-        glGetNamedBufferParameterui64vNV(vertex_buffer.handle, GL_BUFFER_GPU_ADDRESS_NV,
-                                         &vertex_buffer_address);
-    }
 }
 
 RendererOpenGL::~RendererOpenGL() = default;
@@ -675,13 +667,7 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
                          offsetof(ScreenRectVertex, tex_coord));
     glVertexAttribBinding(PositionLocation, 0);
     glVertexAttribBinding(TexCoordLocation, 0);
-    if (device.HasVertexBufferUnifiedMemory()) {
-        glBindVertexBuffer(0, 0, 0, sizeof(ScreenRectVertex));
-        glBufferAddressRangeNV(GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV, 0, vertex_buffer_address,
-                               sizeof(vertices));
-    } else {
-        glBindVertexBuffer(0, vertex_buffer.handle, 0, sizeof(ScreenRectVertex));
-    }
+    glBindVertexBuffer(0, vertex_buffer.handle, 0, sizeof(ScreenRectVertex));
 
     if (Settings::values.scaling_filter.GetValue() != Settings::ScalingFilter::NearestNeighbor) {
         glBindSampler(0, present_sampler.handle);

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -78,15 +78,8 @@ vk::Buffer CreateBuffer(const Device& device, const MemoryAllocator& memory_allo
 }
 } // Anonymous namespace
 
-Buffer::Buffer(BufferCacheRuntime& runtime, VideoCommon::NullBufferParams null_params)
-    : VideoCommon::BufferBase<VideoCore::RasterizerInterface>(null_params), tracker{4096} {
-    if (runtime.device.HasNullDescriptor()) {
-        return;
-    }
-    device = &runtime.device;
-    buffer = runtime.CreateNullBuffer();
-    is_null = true;
-}
+Buffer::Buffer(BufferCacheRuntime&, VideoCommon::NullBufferParams null_params)
+    : VideoCommon::BufferBase<VideoCore::RasterizerInterface>(null_params), tracker{4096} {}
 
 Buffer::Buffer(BufferCacheRuntime& runtime, VideoCore::RasterizerInterface& rasterizer_,
                VAddr cpu_addr_, u64 size_bytes_)
@@ -100,12 +93,8 @@ Buffer::Buffer(BufferCacheRuntime& runtime, VideoCore::RasterizerInterface& rast
 
 VkBufferView Buffer::View(u32 offset, u32 size, VideoCore::Surface::PixelFormat format) {
     if (!device) {
-        // Null buffer supported, return a null descriptor
+        // Null buffer, return a null descriptor
         return VK_NULL_HANDLE;
-    } else if (is_null) {
-        // Null buffer not supported, adjust offset and size
-        offset = 0;
-        size = 0;
     }
     const auto it{std::ranges::find_if(views, [offset, size, format](const BufferView& view) {
         return offset == view.offset && size == view.size && format == view.format;
@@ -574,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());
         });
     }
 }
@@ -638,12 +622,9 @@ void BufferCacheRuntime::BindTransformFeedbackBuffers(VideoCommon::HostBindings<
 }
 
 void BufferCacheRuntime::ReserveNullBuffer() {
-    if (!null_buffer) {
-        null_buffer = CreateNullBuffer();
+    if (null_buffer) {
+        return;
     }
-}
-
-vk::Buffer BufferCacheRuntime::CreateNullBuffer() {
     VkBufferCreateInfo create_info{
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .pNext = nullptr,
@@ -658,17 +639,15 @@ vk::Buffer BufferCacheRuntime::CreateNullBuffer() {
     if (device.IsExtTransformFeedbackSupported()) {
         create_info.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
     }
-    vk::Buffer ret = memory_allocator.CreateBuffer(create_info, MemoryUsage::DeviceLocal);
+    null_buffer = memory_allocator.CreateBuffer(create_info, MemoryUsage::DeviceLocal);
     if (device.HasDebuggingToolAttached()) {
-        ret.SetObjectNameEXT("Null buffer");
+        null_buffer.SetObjectNameEXT("Null buffer");
     }
 
     scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([buffer = *ret](vk::CommandBuffer cmdbuf) {
+    scheduler.Record([buffer = *null_buffer](vk::CommandBuffer cmdbuf) {
         cmdbuf.FillBuffer(buffer, 0, VK_WHOLE_SIZE, 0);
     });
-
-    return ret;
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -63,7 +63,6 @@ private:
     vk::Buffer buffer;
     std::vector<BufferView> views;
     VideoCommon::UsageTracker tracker;
-    bool is_null{};
 };
 
 class QuadArrayIndexBuffer;
@@ -152,7 +151,6 @@ private:
     }
 
     void ReserveNullBuffer();
-    vk::Buffer CreateNullBuffer();
 
     const Device& device;
     MemoryAllocator& memory_allocator;

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,9 +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 &&
-                                        driver_id != VK_DRIVER_ID_ARM_PROPRIETARY,
     };
 
     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_ui.cpp

@@ -193,8 +193,8 @@ void ConfigureUi::RequestGameListUpdate() {
 void ConfigureUi::SetConfiguration() {
     ui->theme_combobox->setCurrentIndex(
         ui->theme_combobox->findData(QString::fromStdString(UISettings::values.theme)));
-    ui->language_combobox->setCurrentIndex(ui->language_combobox->findData(
-        QString::fromStdString(UISettings::values.language.GetValue())));
+    ui->language_combobox->setCurrentIndex(
+        ui->language_combobox->findData(QString::fromStdString(UISettings::values.language)));
     ui->show_add_ons->setChecked(UISettings::values.show_add_ons.GetValue());
     ui->show_compat->setChecked(UISettings::values.show_compat.GetValue());
     ui->show_size->setChecked(UISettings::values.show_size.GetValue());

src/yuzu/configuration/qt_config.cpp

@@ -187,6 +187,7 @@ void QtConfig::ReadPathValues() {
     BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
 
     UISettings::values.roms_path = ReadStringSetting(std::string("romsPath"));
+    UISettings::values.symbols_path = ReadStringSetting(std::string("symbolsPath"));
     UISettings::values.game_dir_deprecated =
         ReadStringSetting(std::string("gameListRootDir"), std::string("."));
     UISettings::values.game_dir_deprecated_deepscan =
@@ -224,8 +225,8 @@ void QtConfig::ReadPathValues() {
     UISettings::values.recent_files =
         QString::fromStdString(ReadStringSetting(std::string("recentFiles")))
             .split(QStringLiteral(", "), Qt::SkipEmptyParts, Qt::CaseSensitive);
-
-    ReadCategory(Settings::Category::Paths);
+    UISettings::values.language =
+        ReadStringSetting(std::string("language"), std::make_optional(std::string("")));
 
     EndGroup();
 }
@@ -407,9 +408,8 @@ void QtConfig::SaveQtControlValues() {
 void QtConfig::SavePathValues() {
     BeginGroup(Settings::TranslateCategory(Settings::Category::Paths));
 
-    WriteCategory(Settings::Category::Paths);
-
     WriteSetting(std::string("romsPath"), UISettings::values.roms_path);
+    WriteSetting(std::string("symbolsPath"), UISettings::values.symbols_path);
     BeginArray(std::string("gamedirs"));
     for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
         SetArrayIndex(i);
@@ -422,6 +422,7 @@ void QtConfig::SavePathValues() {
 
     WriteSetting(std::string("recentFiles"),
                  UISettings::values.recent_files.join(QStringLiteral(", ")).toStdString());
+    WriteSetting(std::string("language"), UISettings::values.language);
 
     EndGroup();
 }

src/yuzu/main.cpp

@@ -5147,12 +5147,12 @@ void GMainWindow::UpdateUITheme() {
 void GMainWindow::LoadTranslation() {
     bool loaded;
 
-    if (UISettings::values.language.GetValue().empty()) {
+    if (UISettings::values.language.empty()) {
         // If the selected language is empty, use system locale
         loaded = translator.load(QLocale(), {}, {}, QStringLiteral(":/languages/"));
     } else {
         // Otherwise load from the specified file
-        loaded = translator.load(QString::fromStdString(UISettings::values.language.GetValue()),
+        loaded = translator.load(QString::fromStdString(UISettings::values.language),
                                  QStringLiteral(":/languages/"));
     }
 
@@ -5164,7 +5164,7 @@ void GMainWindow::LoadTranslation() {
 }
 
 void GMainWindow::OnLanguageChanged(const QString& locale) {
-    if (UISettings::values.language.GetValue() != std::string("en")) {
+    if (UISettings::values.language != std::string("en")) {
         qApp->removeTranslator(&translator);
     }
 

src/yuzu/uisettings.h

@@ -154,11 +154,12 @@ struct Values {
     Setting<u32> screenshot_height{linkage, 0, "screenshot_height", Category::Screenshots};
 
     std::string roms_path;
+    std::string symbols_path;
     std::string game_dir_deprecated;
     bool game_dir_deprecated_deepscan;
     QVector<GameDir> game_dirs;
     QStringList recent_files;
-    Setting<std::string> language{linkage, {}, "language", Category::Paths};
+    std::string language;
 
     std::string theme;