GC: Address Feedback.

src/video_core/renderer_opengl/gl_buffer_cache.cpp

@@ -136,21 +136,17 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_)
         glNamedBufferData(buffer.handle, 0x10'000, nullptr, GL_STREAM_COPY);
     }
 
-    device_access_memory = []() -> u64 {
-        if (GLAD_GL_NVX_gpu_memory_info) {
-            GLint cur_avail_mem_kb = 0;
-            glGetIntegerv(GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, &cur_avail_mem_kb);
-            return static_cast<u64>(cur_avail_mem_kb) * 1_KiB;
+    device_access_memory = [this]() -> u64 {
+        if (device.CanReportMemoryUsage()) {
+            return device.GetCurrentDedicatedVideoMemory() + 512_MiB;
         }
         return 2_GiB; // Return minimum requirements
     }();
 }
 
 u64 BufferCacheRuntime::GetDeviceMemoryUsage() const {
-    if (GLAD_GL_NVX_gpu_memory_info) {
-        GLint cur_avail_mem_kb = 0;
-        glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &cur_avail_mem_kb);
-        return device_access_memory - static_cast<u64>(cur_avail_mem_kb) * 1_KiB;
+    if (device.CanReportMemoryUsage()) {
+        return device_access_memory - device.GetCurrentDedicatedVideoMemory();
     }
     return 2_GiB;
 }

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -89,6 +89,8 @@ public:
     void BindImageBuffer(Buffer& buffer, u32 offset, u32 size,
                          VideoCore::Surface::PixelFormat format);
 
+    u64 GetDeviceMemoryUsage() const;
+
     void BindFastUniformBuffer(size_t stage, u32 binding_index, u32 size) {
         const GLuint handle = fast_uniforms[stage][binding_index].handle;
         const GLsizeiptr gl_size = static_cast<GLsizeiptr>(size);
@@ -155,10 +157,8 @@ public:
         return device_access_memory;
     }
 
-    u64 GetDeviceMemoryUsage() const;
-
     bool CanReportMemoryUsage() const {
-        return GLAD_GL_NVX_gpu_memory_info;
+        return device.CanReportMemoryUsage();
     }
 
 private:

src/video_core/renderer_opengl/gl_device.cpp

@@ -13,12 +13,15 @@
 
 #include <glad/glad.h>
 
+#include "common/literals.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
 #include "shader_recompiler/stage.h"
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 
+using namespace Common::Literals;
+
 namespace OpenGL {
 namespace {
 constexpr std::array LIMIT_UBOS = {
@@ -165,6 +168,7 @@ Device::Device() {
     has_sparse_texture_2 = GLAD_GL_ARB_sparse_texture2;
     warp_size_potentially_larger_than_guest = !is_nvidia && !is_intel;
     need_fastmath_off = is_nvidia;
+    can_report_memory = GLAD_GL_NVX_gpu_memory_info;
 
     // At the moment of writing this, only Nvidia's driver optimizes BufferSubData on exclusive
     // uniform buffers as "push constants"
@@ -276,4 +280,10 @@ void main() {
 })");
 }
 
+u64 Device::GetCurrentDedicatedVideoMemory() const {
+    GLint cur_avail_mem_kb = 0;
+    glGetIntegerv(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &cur_avail_mem_kb);
+    return static_cast<u64>(cur_avail_mem_kb) * 1_KiB;
+}
+
 } // namespace OpenGL

src/video_core/renderer_opengl/gl_device.h

@@ -20,6 +20,8 @@ public:
 
     [[nodiscard]] std::string GetVendorName() const;
 
+    u64 GetCurrentDedicatedVideoMemory() const;
+
     u32 GetMaxUniformBuffers(Shader::Stage stage) const noexcept {
         return max_uniform_buffers[static_cast<size_t>(stage)];
     }
@@ -168,6 +170,10 @@ public:
         return vendor_name == "ATI Technologies Inc.";
     }
 
+    bool CanReportMemoryUsage() const {
+        return can_report_memory;
+    }
+
 private:
     static bool TestVariableAoffi();
     static bool TestPreciseBug();
@@ -210,6 +216,7 @@ private:
     bool need_fastmath_off{};
     bool has_cbuf_ftou_bug{};
     bool has_bool_ref_bug{};
+    bool can_report_memory{};
 
     std::string vendor_name;
 };

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -485,11 +485,9 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, ProgramManager&
         }
     }
 
-    device_access_memory = []() -> u64 {
-        if (GLAD_GL_NVX_gpu_memory_info) {
-            GLint cur_avail_mem_kb = 0;
-            glGetIntegerv(GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, &cur_avail_mem_kb);
-            return static_cast<u64>(cur_avail_mem_kb) * 1_KiB;
+    device_access_memory = [this]() -> u64 {
+        if (device.CanReportMemoryUsage()) {
+            return device.GetCurrentDedicatedVideoMemory() + 512_MiB;
         }
         return 2_GiB; // Return minimum requirements
     }();
@@ -510,10 +508,8 @@ ImageBufferMap TextureCacheRuntime::DownloadStagingBuffer(size_t size) {
 }
 
 u64 TextureCacheRuntime::GetDeviceMemoryUsage() const {
-    if (GLAD_GL_NVX_gpu_memory_info) {
-        GLint cur_avail_mem_kb = 0;
-        glGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &cur_avail_mem_kb);
-        return device_access_memory - static_cast<u64>(cur_avail_mem_kb) * 1_KiB;
+    if (device.CanReportMemoryUsage()) {
+        return device_access_memory - device.GetCurrentDedicatedVideoMemory();
     }
     return 2_GiB;
 }

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -10,6 +10,7 @@
 #include <glad/glad.h>
 
 #include "shader_recompiler/shader_info.h"
+#include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/util_shaders.h"
 #include "video_core/texture_cache/image_view_base.h"
@@ -21,7 +22,6 @@ struct ResolutionScalingInfo;
 
 namespace OpenGL {
 
-class Device;
 class ProgramManager;
 class StateTracker;
 
@@ -90,7 +90,7 @@ public:
     u64 GetDeviceMemoryUsage() const;
 
     bool CanReportMemoryUsage() const {
-        return GLAD_GL_NVX_gpu_memory_info;
+        return device.CanReportMemoryUsage();
     }
 
     bool ShouldReinterpret([[maybe_unused]] Image& dst, [[maybe_unused]] Image& src) {

src/video_core/vulkan_common/vulkan_device.cpp

@@ -598,10 +598,10 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     }
     logical = vk::Device::Create(physical, queue_cis, extensions, first_next, dld);
 
-    is_integrated = (properties.deviceType & VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) != 0;
-    is_virtual = (properties.deviceType & VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) != 0;
-    is_non_gpu = (properties.deviceType & VK_PHYSICAL_DEVICE_TYPE_OTHER) != 0 ||
-                 (properties.deviceType & VK_PHYSICAL_DEVICE_TYPE_CPU) != 0;
+    is_integrated = properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
+    is_virtual = properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
+    is_non_gpu = properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_OTHER ||
+                 properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU;
 
     CollectPhysicalMemoryInfo();
     CollectTelemetryParameters();
@@ -1298,7 +1298,7 @@ void Device::CollectPhysicalMemoryInfo() {
     u64 local_memory = 0;
     for (size_t element = 0; element < num_properties; ++element) {
         const bool is_heap_local =
-            mem_properties.memoryHeaps[element].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT != 0;
+            (mem_properties.memoryHeaps[element].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0;
         if (!is_integrated && !is_heap_local) {
             continue;
         }
@@ -1319,7 +1319,6 @@ void Device::CollectPhysicalMemoryInfo() {
     const s64 available_memory = static_cast<s64>(device_access_memory - device_initial_usage);
     device_access_memory = static_cast<u64>(std::max<s64>(
         std::min<s64>(available_memory - 8_GiB, 4_GiB), static_cast<s64>(local_memory)));
-    device_initial_usage = 0;
 }
 
 void Device::CollectToolingInfo() {