Settings: Indicate AMD's compatibility with SPIR-V on OGL

gl_buffer_cache: Reintroduce NV_vertex_buffer_unified_memory

src/shader_recompiler/backend/glsl/emit_glsl_image.cpp

@@ -449,7 +449,7 @@ void EmitImageGatherDref(EmitContext& ctx, IR::Inst& inst, const IR::Value& inde
 }
 
 void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                    std::string_view coords, std::string_view offset, std::string_view lod,
+                    std::string_view coords, const IR::Value& offset, std::string_view lod,
                     std::string_view ms) {
     const auto info{inst.Flags<IR::TextureInstInfo>()};
     if (info.has_bias) {
@@ -470,9 +470,9 @@ void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
         const auto int_coords{CoordsCastToInt(coords, info)};
         if (!ms.empty()) {
             ctx.Add("{}=texelFetch({},{},int({}));", texel, texture, int_coords, ms);
-        } else if (!offset.empty()) {
+        } else if (!offset.IsEmpty()) {
             ctx.Add("{}=texelFetchOffset({},{},int({}),{});", texel, texture, int_coords, lod,
-                    CoordsCastToInt(offset, info));
+                    GetOffsetVec(ctx, offset));
         } else {
             if (info.type == TextureType::Buffer) {
                 ctx.Add("{}=texelFetch({},int({}));", texel, texture, coords);
@@ -485,10 +485,10 @@ void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
     if (!ms.empty()) {
         throw NotImplementedException("EmitImageFetch Sparse MSAA samples");
     }
-    if (!offset.empty()) {
+    if (!offset.IsEmpty()) {
         ctx.AddU1("{}=sparseTexelsResidentARB(sparseTexelFetchOffsetARB({},{},int({}),{},{}));",
-                  *sparse_inst, texture, CastToIntVec(coords, info), lod,
-                  CastToIntVec(offset, info), texel);
+                  *sparse_inst, texture, CastToIntVec(coords, info), lod, GetOffsetVec(ctx, offset),
+                  texel);
     } else {
         ctx.AddU1("{}=sparseTexelsResidentARB(sparseTexelFetchARB({},{},int({}),{}));",
                   *sparse_inst, texture, CastToIntVec(coords, info), lod, texel);

src/shader_recompiler/backend/glsl/emit_glsl_instructions.h

@@ -651,7 +651,7 @@ void EmitImageGatherDref(EmitContext& ctx, IR::Inst& inst, const IR::Value& inde
                          std::string_view coords, const IR::Value& offset, const IR::Value& offset2,
                          std::string_view dref);
 void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                    std::string_view coords, std::string_view offset, std::string_view lod,
+                    std::string_view coords, const IR::Value& offset, std::string_view lod,
                     std::string_view ms);
 void EmitImageQueryDimensions(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
                               std::string_view lod, const IR::Value& skip_mips);

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -1427,7 +1427,7 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         if (profile.support_vertex_instance_id) {
             instance_id = DefineInput(*this, U32[1], true, spv::BuiltIn::InstanceId);
             if (loads[IR::Attribute::BaseInstance]) {
-                base_instance = DefineInput(*this, U32[1], true, spv::BuiltIn::BaseVertex);
+                base_instance = DefineInput(*this, U32[1], true, spv::BuiltIn::BaseInstance);
             }
         } else {
             instance_index = DefineInput(*this, U32[1], true, spv::BuiltIn::InstanceIndex);

src/video_core/engines/maxwell_3d.cpp

@@ -586,22 +586,14 @@ void Maxwell3D::ProcessQueryCondition() {
 }
 
 void Maxwell3D::ProcessCounterReset() {
-    const auto query_type = [clear_report = regs.clear_report_value]() {
-        switch (clear_report) {
-        case Tegra::Engines::Maxwell3D::Regs::ClearReport::ZPassPixelCount:
-            return VideoCommon::QueryType::ZPassPixelCount64;
-        case Tegra::Engines::Maxwell3D::Regs::ClearReport::StreamingPrimitivesSucceeded:
-            return VideoCommon::QueryType::StreamingPrimitivesSucceeded;
-        case Tegra::Engines::Maxwell3D::Regs::ClearReport::PrimitivesGenerated:
-            return VideoCommon::QueryType::PrimitivesGenerated;
-        case Tegra::Engines::Maxwell3D::Regs::ClearReport::VtgPrimitivesOut:
-            return VideoCommon::QueryType::VtgPrimitivesOut;
-        default:
-            LOG_DEBUG(HW_GPU, "Unimplemented counter reset={}", clear_report);
-            return VideoCommon::QueryType::Payload;
-        }
-    }();
-    rasterizer->ResetCounter(query_type);
+    switch (regs.clear_report_value) {
+    case Regs::ClearReport::ZPassPixelCount:
+        rasterizer->ResetCounter(VideoCommon::QueryType::ZPassPixelCount64);
+        break;
+    default:
+        LOG_DEBUG(Render_OpenGL, "Unimplemented counter reset={}", regs.clear_report_value);
+        break;
+    }
 }
 
 void Maxwell3D::ProcessSyncPoint() {

src/video_core/query_cache.h

@@ -28,11 +28,8 @@
 namespace VideoCore {
 enum class QueryType {
     SamplesPassed,
-    PrimitivesGenerated,
-    TfbPrimitivesWritten,
-    Count,
 };
-constexpr std::size_t NumQueryTypes = static_cast<size_t>(QueryType::Count);
+constexpr std::size_t NumQueryTypes = 1;
 } // namespace VideoCore
 
 namespace VideoCommon {
@@ -47,6 +44,15 @@ public:
     explicit CounterStreamBase(QueryCache& cache_, VideoCore::QueryType type_)
         : cache{cache_}, type{type_} {}
 
+    /// Updates the state of the stream, enabling or disabling as needed.
+    void Update(bool enabled) {
+        if (enabled) {
+            Enable();
+        } else {
+            Disable();
+        }
+    }
+
     /// Resets the stream to zero. It doesn't disable the query after resetting.
     void Reset() {
         if (current) {
@@ -74,6 +80,7 @@ public:
         return current != nullptr;
     }
 
+private:
     /// Enables the stream.
     void Enable() {
         if (current) {
@@ -90,7 +97,6 @@ public:
         last = std::exchange(current, nullptr);
     }
 
-private:
     QueryCache& cache;
     const VideoCore::QueryType type;
 
@@ -106,14 +112,8 @@ public:
         : rasterizer{rasterizer_},
           // Use reinterpret_cast instead of static_cast as workaround for
           // UBSan bug (https://github.com/llvm/llvm-project/issues/59060)
-          cpu_memory{cpu_memory_}, streams{{
-                                       {CounterStream{reinterpret_cast<QueryCache&>(*this),
-                                                      VideoCore::QueryType::SamplesPassed}},
-                                       {CounterStream{reinterpret_cast<QueryCache&>(*this),
-                                                      VideoCore::QueryType::PrimitivesGenerated}},
-                                       {CounterStream{reinterpret_cast<QueryCache&>(*this),
-                                                      VideoCore::QueryType::TfbPrimitivesWritten}},
-                                   }} {
+          cpu_memory{cpu_memory_}, streams{{CounterStream{reinterpret_cast<QueryCache&>(*this),
+                                                          VideoCore::QueryType::SamplesPassed}}} {
         (void)slot_async_jobs.insert(); // Null value
     }
 
@@ -157,11 +157,12 @@ public:
         AsyncFlushQuery(query, timestamp, lock);
     }
 
-    /// Enables all available GPU counters
-    void EnableCounters() {
+    /// Updates counters from GPU state. Expected to be called once per draw, clear or dispatch.
+    void UpdateCounters() {
         std::unique_lock lock{mutex};
-        for (auto& stream : streams) {
-            stream.Enable();
+        if (maxwell3d) {
+            const auto& regs = maxwell3d->regs;
+            Stream(VideoCore::QueryType::SamplesPassed).Update(regs.zpass_pixel_count_enable);
         }
     }
 
@@ -175,7 +176,7 @@ public:
     void DisableStreams() {
         std::unique_lock lock{mutex};
         for (auto& stream : streams) {
-            stream.Disable();
+            stream.Update(false);
         }
     }
 
@@ -352,7 +353,7 @@ private:
 
     std::shared_ptr<std::vector<AsyncJobId>> uncommitted_flushes{};
     std::list<std::shared_ptr<std::vector<AsyncJobId>>> committed_flushes;
-}; // namespace VideoCommon
+};
 
 template <class QueryCache, class HostCounter>
 class HostCounterBase {

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -58,6 +58,9 @@ 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 {
@@ -109,6 +112,7 @@ 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);
@@ -210,8 +214,14 @@ void BufferCacheRuntime::ClearBuffer(Buffer& dest_buffer, u32 offset, size_t siz
 }
 
 void BufferCacheRuntime::BindIndexBuffer(Buffer& buffer, u32 offset, u32 size) {
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer.Handle());
-    index_buffer_offset = offset;
+    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;
+    }
 }
 
 void BufferCacheRuntime::BindVertexBuffer(u32 index, Buffer& buffer, u32 offset, u32 size,
@@ -219,8 +229,15 @@ void BufferCacheRuntime::BindVertexBuffer(u32 index, Buffer& buffer, u32 offset,
     if (index >= max_attributes) {
         return;
     }
-    glBindVertexBuffer(index, buffer.Handle(), static_cast<GLintptr>(offset),
-                       static_cast<GLsizei>(stride));
+    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));
+    }
 }
 
 void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bindings) {
@@ -233,9 +250,23 @@ 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);
-    glBindVertexBuffers(bindings.min_index, static_cast<GLsizei>(count), buffer_handles.data(),
-                        reinterpret_cast<const GLintptr*>(bindings.offsets.data()),
-                        buffer_strides.data());
+    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());
+    }
 }
 
 void BufferCacheRuntime::BindUniformBuffer(size_t stage, u32 binding_index, Buffer& buffer,

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -209,6 +209,7 @@ 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

@@ -195,11 +195,12 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     has_texture_shadow_lod = HasExtension(extensions, "GL_EXT_texture_shadow_lod");
     has_astc = !has_slow_software_astc && IsASTCSupported();
     has_variable_aoffi = TestVariableAoffi();
-    has_component_indexing_bug = is_amd;
+    has_component_indexing_bug = false;
     has_precise_bug = TestPreciseBug();
-    has_broken_texture_view_formats = is_amd || (!is_linux && is_intel);
+    has_broken_texture_view_formats = (!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;
@@ -237,10 +238,11 @@ Device::Device(Core::Frontend::EmuWindow& emu_window) {
     has_lmem_perf_bug = is_nvidia;
 
     strict_context_required = emu_window.StrictContextRequired();
-    // Blocks AMD and Intel OpenGL drivers on Windows from using asynchronous shader compilation.
+    // Blocks Intel OpenGL drivers on Windows from using asynchronous shader compilation.
     // Blocks EGL on Wayland from using asynchronous shader compilation.
-    use_asynchronous_shaders = Settings::values.use_asynchronous_shaders.GetValue() &&
-                               !(is_amd || (is_intel && !is_linux)) && !strict_context_required;
+    const bool blacklist_async_shaders = (is_intel && !is_linux) || strict_context_required;
+    use_asynchronous_shaders =
+        Settings::values.use_asynchronous_shaders.GetValue() && !blacklist_async_shaders;
     use_driver_cache = is_nvidia;
     supports_conditional_barriers = !is_intel;
 

src/video_core/renderer_opengl/gl_device.h

@@ -72,6 +72,10 @@ public:
         return has_texture_shadow_lod;
     }
 
+    bool HasVertexBufferUnifiedMemory() const {
+        return has_vertex_buffer_unified_memory;
+    }
+
     bool HasASTC() const {
         return has_astc;
     }
@@ -211,6 +215,7 @@ 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_query_cache.cpp

@@ -18,27 +18,16 @@ namespace OpenGL {
 
 namespace {
 
+constexpr std::array<GLenum, VideoCore::NumQueryTypes> QueryTargets = {GL_SAMPLES_PASSED};
+
 constexpr GLenum GetTarget(VideoCore::QueryType type) {
-    switch (type) {
-    case VideoCore::QueryType::SamplesPassed:
-        return GL_SAMPLES_PASSED;
-    case VideoCore::QueryType::PrimitivesGenerated:
-        return GL_PRIMITIVES_GENERATED;
-    case VideoCore::QueryType::TfbPrimitivesWritten:
-        return GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN;
-    default:
-        break;
-    }
-    UNIMPLEMENTED_MSG("Query type {}", type);
-    return 0;
+    return QueryTargets[static_cast<std::size_t>(type)];
 }
 
 } // Anonymous namespace
 
 QueryCache::QueryCache(RasterizerOpenGL& rasterizer_, Core::Memory::Memory& cpu_memory_)
-    : QueryCacheLegacy(rasterizer_, cpu_memory_), gl_rasterizer{rasterizer_} {
-    EnableCounters();
-}
+    : QueryCacheLegacy(rasterizer_, cpu_memory_), gl_rasterizer{rasterizer_} {}
 
 QueryCache::~QueryCache() = default;
 
@@ -114,13 +103,13 @@ u64 CachedQuery::Flush([[maybe_unused]] bool async) {
     auto& stream = cache->Stream(type);
     const bool slice_counter = WaitPending() && stream.IsEnabled();
     if (slice_counter) {
-        stream.Disable();
+        stream.Update(false);
     }
 
     auto result = VideoCommon::CachedQueryBase<HostCounter>::Flush();
 
     if (slice_counter) {
-        stream.Enable();
+        stream.Update(true);
     }
 
     return result;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -51,22 +51,6 @@ constexpr size_t NUM_SUPPORTED_VERTEX_ATTRIBUTES = 16;
 void oglEnable(GLenum cap, bool state) {
     (state ? glEnable : glDisable)(cap);
 }
-
-std::optional<VideoCore::QueryType> MaxwellToVideoCoreQuery(VideoCommon::QueryType type) {
-    switch (type) {
-    case VideoCommon::QueryType::PrimitivesGenerated:
-    case VideoCommon::QueryType::VtgPrimitivesOut:
-        return VideoCore::QueryType::PrimitivesGenerated;
-    case VideoCommon::QueryType::ZPassPixelCount64:
-        return VideoCore::QueryType::SamplesPassed;
-    case VideoCommon::QueryType::StreamingPrimitivesSucceeded:
-        // case VideoCommon::QueryType::StreamingByteCount:
-        // TODO: StreamingByteCount = StreamingPrimitivesSucceeded * num_verts * vert_stride
-        return VideoCore::QueryType::TfbPrimitivesWritten;
-    default:
-        return std::nullopt;
-    }
-}
 } // Anonymous namespace
 
 RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
@@ -178,14 +162,18 @@ void RasterizerOpenGL::Clear(u32 layer_count) {
         SyncFramebufferSRGB();
     }
     if (regs.clear_surface.Z) {
-        ASSERT_MSG(regs.zeta_enable != 0, "Tried to clear Z but buffer is not enabled!");
+        if (regs.zeta_enable != 0) {
+            LOG_DEBUG(Render_OpenGL, "Tried to clear Z but buffer is not enabled!");
+        }
         use_depth = true;
 
         state_tracker.NotifyDepthMask();
         glDepthMask(GL_TRUE);
     }
     if (regs.clear_surface.S) {
-        ASSERT_MSG(regs.zeta_enable, "Tried to clear stencil but buffer is not enabled!");
+        if (regs.zeta_enable) {
+            LOG_DEBUG(Render_OpenGL, "Tried to clear stencil but buffer is not enabled!");
+        }
         use_stencil = true;
     }
 
@@ -228,6 +216,7 @@ void RasterizerOpenGL::PrepareDraw(bool is_indexed, Func&& draw_func) {
 
     SCOPE_EXIT({ gpu.TickWork(); });
     gpu_memory->FlushCaching();
+    query_cache.UpdateCounters();
 
     GraphicsPipeline* const pipeline{shader_cache.CurrentGraphicsPipeline()};
     if (!pipeline) {
@@ -345,6 +334,7 @@ void RasterizerOpenGL::DrawTexture() {
     MICROPROFILE_SCOPE(OpenGL_Drawing);
 
     SCOPE_EXIT({ gpu.TickWork(); });
+    query_cache.UpdateCounters();
 
     texture_cache.SynchronizeGraphicsDescriptors();
     texture_cache.UpdateRenderTargets(false);
@@ -411,28 +401,21 @@ void RasterizerOpenGL::DispatchCompute() {
 }
 
 void RasterizerOpenGL::ResetCounter(VideoCommon::QueryType type) {
-    const auto query_cache_type = MaxwellToVideoCoreQuery(type);
-    if (!query_cache_type.has_value()) {
-        UNIMPLEMENTED_IF_MSG(type != VideoCommon::QueryType::Payload, "Reset query type: {}", type);
-        return;
+    if (type == VideoCommon::QueryType::ZPassPixelCount64) {
+        query_cache.ResetCounter(VideoCore::QueryType::SamplesPassed);
     }
-    query_cache.ResetCounter(*query_cache_type);
 }
 
 void RasterizerOpenGL::Query(GPUVAddr gpu_addr, VideoCommon::QueryType type,
                              VideoCommon::QueryPropertiesFlags flags, u32 payload, u32 subreport) {
-    const auto query_cache_type = MaxwellToVideoCoreQuery(type);
-    if (!query_cache_type.has_value()) {
-        return QueryFallback(gpu_addr, type, flags, payload, subreport);
+    if (type == VideoCommon::QueryType::ZPassPixelCount64) {
+        if (True(flags & VideoCommon::QueryPropertiesFlags::HasTimeout)) {
+            query_cache.Query(gpu_addr, VideoCore::QueryType::SamplesPassed, {gpu.GetTicks()});
+        } else {
+            query_cache.Query(gpu_addr, VideoCore::QueryType::SamplesPassed, std::nullopt);
+        }
+        return;
     }
-    const bool has_timeout = True(flags & VideoCommon::QueryPropertiesFlags::HasTimeout);
-    const auto timestamp = has_timeout ? std::optional<u64>{gpu.GetTicks()} : std::nullopt;
-    query_cache.Query(gpu_addr, *query_cache_type, timestamp);
-}
-
-void RasterizerOpenGL::QueryFallback(GPUVAddr gpu_addr, VideoCommon::QueryType type,
-                                     VideoCommon::QueryPropertiesFlags flags, u32 payload,
-                                     u32 subreport) {
     if (type != VideoCommon::QueryType::Payload) {
         payload = 1u;
     }

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -225,9 +225,6 @@ private:
     /// End a transform feedback
     void EndTransformFeedback();
 
-    void QueryFallback(GPUVAddr gpu_addr, VideoCommon::QueryType type,
-                       VideoCommon::QueryPropertiesFlags flags, u32 payload, u32 subreport);
-
     Tegra::GPU& gpu;
 
     const Device& device;

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -168,6 +168,14 @@ 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;
@@ -667,7 +675,13 @@ void RendererOpenGL::DrawScreen(const Layout::FramebufferLayout& layout) {
                          offsetof(ScreenRectVertex, tex_coord));
     glVertexAttribBinding(PositionLocation, 0);
     glVertexAttribBinding(TexCoordLocation, 0);
-    glBindVertexBuffer(0, vertex_buffer.handle, 0, sizeof(ScreenRectVertex));
+    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));
+    }
 
     if (Settings::values.scaling_filter.GetValue() != Settings::ScalingFilter::NearestNeighbor) {
         glBindSampler(0, present_sampler.handle);

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -485,10 +485,6 @@ void RasterizerVulkan::DispatchCompute() {
 }
 
 void RasterizerVulkan::ResetCounter(VideoCommon::QueryType type) {
-    if (type != VideoCommon::QueryType::ZPassPixelCount64) {
-        LOG_DEBUG(Render_Vulkan, "Unimplemented counter reset={}", type);
-        return;
-    }
     query_cache.CounterReset(type);
 }
 

src/yuzu/configuration/qt_config.cpp

@@ -225,6 +225,8 @@ void QtConfig::ReadPathValues() {
         QString::fromStdString(ReadStringSetting(std::string("recentFiles")))
             .split(QStringLiteral(", "), Qt::SkipEmptyParts, Qt::CaseSensitive);
 
+    ReadCategory(Settings::Category::Paths);
+
     EndGroup();
 }
 
@@ -405,6 +407,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);
     BeginArray(std::string("gamedirs"));
     for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {

src/yuzu/configuration/shared_translation.cpp

@@ -228,7 +228,7 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QWidget* parent) {
          {
              PAIR(ShaderBackend, Glsl, tr("GLSL")),
              PAIR(ShaderBackend, Glasm, tr("GLASM (Assembly Shaders, NVIDIA Only)")),
-             PAIR(ShaderBackend, SpirV, tr("SPIR-V (Experimental, Mesa Only)")),
+             PAIR(ShaderBackend, SpirV, tr("SPIR-V (Experimental, AMD/Mesa Only)")),
          }});
     translations->insert({Settings::EnumMetadata<Settings::GpuAccuracy>::Index(),
                           {