renderer_vulkan/wrapper: Fix physical device sorting

The old code had a sort function that was invalid and it didn't work as
expected when the base vector had a different order (e.g. renderdoc was
attached).

This sorts devices as expected and fixes a debug assert on MSVC.

src/video_core/renderer_vulkan/wrapper.cpp

@@ -6,6 +6,7 @@
 #include <exception>
 #include <memory>
 #include <optional>
+#include <string_view>
 #include <utility>
 #include <vector>
 
@@ -17,23 +18,44 @@ namespace Vulkan::vk {
 
 namespace {
 
-void SortPhysicalDevices(std::vector<VkPhysicalDevice>& devices, const InstanceDispatch& dld) {
+template <typename Func>
-    std::stable_sort(devices.begin(), devices.end(), [&](auto lhs, auto rhs) {
+void SortPhysicalDevices(std::vector<VkPhysicalDevice>& devices, const InstanceDispatch& dld,
-        // This will call Vulkan more than needed, but these calls are cheap.
+                         Func&& func) {
-        const auto lhs_properties = vk::PhysicalDevice(lhs, dld).GetProperties();
+    // Calling GetProperties calls Vulkan more than needed. But they are supposed to be cheap
-        const auto rhs_properties = vk::PhysicalDevice(rhs, dld).GetProperties();
+    // functions.
-
+    std::stable_sort(devices.begin(), devices.end(),
-        // Prefer discrete GPUs, Nvidia over AMD, AMD over Intel, Intel over the rest.
+                     [&dld, &func](VkPhysicalDevice lhs, VkPhysicalDevice rhs) {
-        const bool preferred =
+                         return func(vk::PhysicalDevice(lhs, dld).GetProperties(),
-            (lhs_properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU &&
+                                     vk::PhysicalDevice(rhs, dld).GetProperties());
-             rhs_properties.deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) ||
-            (lhs_properties.vendorID == 0x10DE && rhs_properties.vendorID != 0x10DE) ||
-            (lhs_properties.vendorID == 0x1002 && rhs_properties.vendorID != 0x1002) ||
-            (lhs_properties.vendorID == 0x8086 && rhs_properties.vendorID != 0x8086);
-        return !preferred;
                      });
 }
 
+void SortPhysicalDevicesPerVendor(std::vector<VkPhysicalDevice>& devices,
+                                  const InstanceDispatch& dld,
+                                  std::initializer_list<u32> vendor_ids) {
+    for (auto it = vendor_ids.end(); it != vendor_ids.begin();) {
+        --it;
+        SortPhysicalDevices(devices, dld, [id = *it](const auto& lhs, const auto& rhs) {
+            return lhs.vendorID == id && rhs.vendorID != id;
+        });
+    }
+}
+
+void SortPhysicalDevices(std::vector<VkPhysicalDevice>& devices, const InstanceDispatch& dld) {
+    // Sort by name, this will set a base and make GPUs with higher numbers appear first
+    // (e.g. GTX 1650 will intentionally be listed before a GTX 1080).
+    SortPhysicalDevices(devices, dld, [](const auto& lhs, const auto& rhs) {
+        return std::string_view{lhs.deviceName} > std::string_view{rhs.deviceName};
+    });
+    // Prefer discrete over non-discrete
+    SortPhysicalDevices(devices, dld, [](const auto& lhs, const auto& rhs) {
+        return lhs.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU &&
+               rhs.deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;
+    });
+    // Prefer Nvidia over AMD, AMD over Intel, Intel over the rest.
+    SortPhysicalDevicesPerVendor(devices, dld, {0x10DE, 0x1002, 0x8086});
+}
+
 template <typename T>
 bool Proc(T& result, const InstanceDispatch& dld, const char* proc_name,
           VkInstance instance = nullptr) noexcept {