Android 219

service: mii: Set arguments as const

.gitmodules

@@ -64,3 +64,6 @@
 [submodule "oaknut"]
 	path = externals/oaknut
 	url = https://github.com/merryhime/oaknut
+[submodule "Vulkan-Utility-Libraries"]
+	path = externals/Vulkan-Utility-Libraries
+	url = https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git

CMakeLists.txt

@@ -36,6 +36,8 @@ option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")
 
 option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ON)
 
+option(YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES "Use Vulkan-Utility-Libraries from externals" ON)
+
 option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
 
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
@@ -308,6 +310,10 @@ if (NOT YUZU_USE_EXTERNAL_VULKAN_HEADERS)
     find_package(Vulkan 1.3.274 REQUIRED)
 endif()
 
+if (NOT YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES)
+    find_package(VulkanUtilityLibraries REQUIRED)
+endif()
+
 if (ENABLE_LIBUSB)
     find_package(libusb 1.0.24 MODULE)
 endif()

README.md

@@ -1,9 +1,7 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
 | [12749](https://github.com/yuzu-emu/yuzu-android//pull/12749) | [`e3171486d`](https://github.com/yuzu-emu/yuzu-android//pull/12749/files) | general: workarounds for SMMU syncing issues | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12760](https://github.com/yuzu-emu/yuzu-android//pull/12760) | [`c6b88b62d`](https://github.com/yuzu-emu/yuzu-android//pull/12760/files) | am: rewrite for multiprocess support | [liamwhite](https://github.com/liamwhite/) | Yes |
+| [12760](https://github.com/yuzu-emu/yuzu-android//pull/12760) | [`a407f9bf5`](https://github.com/yuzu-emu/yuzu-android//pull/12760/files) | am: rewrite for multiprocess support | [liamwhite](https://github.com/liamwhite/) | Yes |
-| [12814](https://github.com/yuzu-emu/yuzu-android//pull/12814) | [`da410506a`](https://github.com/yuzu-emu/yuzu-android//pull/12814/files) | Move time services to new IPC and add debug printing | [Kelebek1](https://github.com/Kelebek1/) | Yes |
-| [12830](https://github.com/yuzu-emu/yuzu-android//pull/12830) | [`6cc82fd43`](https://github.com/yuzu-emu/yuzu-android//pull/12830/files) | externals/dynarmic: Update to 6.6.1 | [merryhime](https://github.com/merryhime/) | Yes |
 
 
 End of merge log. You can find the original README.md below the break.

externals/CMakeLists.txt

@@ -154,6 +154,11 @@ if (YUZU_USE_EXTERNAL_VULKAN_HEADERS)
     add_subdirectory(Vulkan-Headers)
 endif()
 
+# Vulkan-Utility-Libraries
+if (YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES)
+    add_subdirectory(Vulkan-Utility-Libraries)
+endif()
+
 # TZDB (Time Zone Database)
 add_subdirectory(nx_tzdb)
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/DriverAdapter.kt

@@ -7,6 +7,7 @@ import android.text.TextUtils
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.databinding.CardDriverOptionBinding
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
 import org.yuzu.yuzu_emu.model.Driver
@@ -57,13 +58,9 @@ class DriverAdapter(private val driverViewModel: DriverViewModel) :
                 title.text = model.title
                 version.text = model.version
                 description.text = model.description
-                if (model.description.isNotEmpty()) {
+                if (model.title != binding.root.context.getString(R.string.system_gpu_driver)) {
-                    version.visibility = View.VISIBLE
-                    description.visibility = View.VISIBLE
                     buttonDelete.visibility = View.VISIBLE
                 } else {
-                    version.visibility = View.GONE
-                    description.visibility = View.GONE
                     buttonDelete.visibility = View.GONE
                 }
             }

src/core/hle/service/am/applet_manager.cpp

@@ -303,8 +303,8 @@ void AppletManager::CreateAndInsertByFrontendAppletParameters(
     }
 
     // Applet was started by frontend, so it is foreground.
-    applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
     applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoForeground);
+    applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
     applet->focus_state = FocusState::InFocus;
 
     this->InsertApplet(std::move(applet));

src/core/hle/service/am/library_applet_creator.cpp

@@ -85,24 +85,26 @@ AppletProgramId AppletIdToProgramId(AppletId applet_id) {
     applet->library_applet_mode = mode;
 
     // Set focus state
-    applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
     switch (mode) {
     case LibraryAppletMode::AllForeground:
     case LibraryAppletMode::NoUI:
-        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoForeground);
         applet->focus_state = FocusState::InFocus;
         applet->hid_registration.EnableAppletToGetInput(true);
+        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::ChangeIntoForeground);
+        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
         break;
     case LibraryAppletMode::AllForegroundInitiallyHidden:
         applet->system_buffer_manager.SetWindowVisibility(false);
         applet->focus_state = FocusState::NotInFocus;
         applet->hid_registration.EnableAppletToGetInput(false);
+        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
         break;
     case LibraryAppletMode::Background:
     case LibraryAppletMode::BackgroundIndirectDisplay:
     default:
         applet->focus_state = FocusState::Background;
         applet->hid_registration.EnableAppletToGetInput(true);
+        applet->message_queue.PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
         break;
     }
 

src/core/hle/service/mii/mii.cpp

@@ -111,7 +111,8 @@ private:
         R_RETURN(result);
     }
 
-    Result UpdateLatest(Out<CharInfo> out_char_info, CharInfo& char_info, SourceFlag source_flag) {
+    Result UpdateLatest(Out<CharInfo> out_char_info, const CharInfo& char_info,
+                        SourceFlag source_flag) {
         LOG_INFO(Service_Mii, "called with source_flag={}", source_flag);
 
         R_RETURN(manager->UpdateLatest(metadata, *out_char_info, char_info, source_flag));
@@ -159,7 +160,7 @@ private:
         R_RETURN(result);
     }
 
-    Result UpdateLatest1(Out<StoreData> out_store_data, StoreData& store_data,
+    Result UpdateLatest1(Out<StoreData> out_store_data, const StoreData& store_data,
                          SourceFlag source_flag) {
         LOG_INFO(Service_Mii, "called with source_flag={}", source_flag);
         R_UNLESS(is_system, ResultPermissionDenied);
@@ -243,7 +244,7 @@ private:
         R_SUCCEED();
     }
 
-    Result GetIndex(Out<s32> out_index, CharInfo& char_info) {
+    Result GetIndex(Out<s32> out_index, const CharInfo& char_info) {
         LOG_DEBUG(Service_Mii, "called");
 
         R_RETURN(manager->GetIndex(metadata, char_info, *out_index));
@@ -257,25 +258,25 @@ private:
         R_SUCCEED();
     }
 
-    Result Convert(Out<CharInfo> out_char_info, Ver3StoreData& mii_v3) {
+    Result Convert(Out<CharInfo> out_char_info, const Ver3StoreData& mii_v3) {
         LOG_INFO(Service_Mii, "called");
 
         R_RETURN(manager->ConvertV3ToCharInfo(*out_char_info, mii_v3));
     }
 
-    Result ConvertCoreDataToCharInfo(Out<CharInfo> out_char_info, CoreData& core_data) {
+    Result ConvertCoreDataToCharInfo(Out<CharInfo> out_char_info, const CoreData& core_data) {
         LOG_INFO(Service_Mii, "called");
 
         R_RETURN(manager->ConvertCoreDataToCharInfo(*out_char_info, core_data));
     }
 
-    Result ConvertCharInfoToCoreData(Out<CoreData> out_core_data, CharInfo& char_info) {
+    Result ConvertCharInfoToCoreData(Out<CoreData> out_core_data, const CharInfo& char_info) {
         LOG_INFO(Service_Mii, "called");
 
         R_RETURN(manager->ConvertCharInfoToCoreData(*out_core_data, char_info));
     }
 
-    Result Append(CharInfo& char_info) {
+    Result Append(const CharInfo& char_info) {
         LOG_INFO(Service_Mii, "called");
 
         R_RETURN(manager->Append(metadata, char_info));

src/core/hle/service/set/setting_formats/system_settings.cpp

@@ -45,7 +45,7 @@ SystemSettings DefaultSystemSettings() {
         .console_sleep_plan = ConsoleSleepPlan::Sleep1Hour,
     };
 
-    settings.device_time_zone_location_name = {"UTC"};
+    settings.device_time_zone_location_name = Service::PSC::Time::LocationName{"UTC"};
     settings.user_system_clock_automatic_correction_enabled = true;
 
     settings.primary_album_storage = PrimaryAlbumStorage::SdCard;

src/hid_core/CMakeLists.txt

@@ -96,6 +96,7 @@ add_library(hid_core STATIC
     resources/system_buttons/home_button.h
     resources/system_buttons/sleep_button.cpp
     resources/system_buttons/sleep_button.h
+    resources/system_buttons/system_button_types.h
     resources/touch_screen/gesture.cpp
     resources/touch_screen/gesture.h
     resources/touch_screen/gesture_types.h

src/hid_core/hid_types.h

@@ -437,6 +437,16 @@ struct LedPattern {
     };
 };
 
+struct SleepButtonState {
+    union {
+        u64 raw{};
+
+        // Buttons
+        BitField<0, 1, u64> sleep;
+    };
+};
+static_assert(sizeof(SleepButtonState) == 0x8, "SleepButtonState has incorrect size.");
+
 struct HomeButtonState {
     union {
         u64 raw{};

src/hid_core/resources/shared_memory_format.h

@@ -12,6 +12,7 @@
 #include "hid_core/resources/mouse/mouse_types.h"
 #include "hid_core/resources/npad/npad_types.h"
 #include "hid_core/resources/ring_lifo.h"
+#include "hid_core/resources/system_buttons/system_button_types.h"
 #include "hid_core/resources/touch_screen/touch_types.h"
 
 namespace Service::HID {
@@ -75,24 +76,24 @@ static_assert(sizeof(DigitizerSharedMemoryFormat) == 0x1000,
 
 // This is nn::hid::detail::HomeButtonSharedMemoryFormat
 struct HomeButtonSharedMemoryFormat {
-    CommonHeader header;
+    Lifo<HomeButtonState, HidEntryCount> home_lifo{};
-    INSERT_PADDING_BYTES(0x1E0);
+    INSERT_PADDING_BYTES(0x48);
 };
 static_assert(sizeof(HomeButtonSharedMemoryFormat) == 0x200,
               "HomeButtonSharedMemoryFormat is an invalid size");
 
 // This is nn::hid::detail::SleepButtonSharedMemoryFormat
 struct SleepButtonSharedMemoryFormat {
-    CommonHeader header;
+    Lifo<SleepButtonState, HidEntryCount> sleep_lifo{};
-    INSERT_PADDING_BYTES(0x1E0);
+    INSERT_PADDING_BYTES(0x48);
 };
 static_assert(sizeof(SleepButtonSharedMemoryFormat) == 0x200,
               "SleepButtonSharedMemoryFormat is an invalid size");
 
 // This is nn::hid::detail::CaptureButtonSharedMemoryFormat
 struct CaptureButtonSharedMemoryFormat {
-    CommonHeader header;
+    Lifo<CaptureButtonState, HidEntryCount> capture_lifo{};
-    INSERT_PADDING_BYTES(0x1E0);
+    INSERT_PADDING_BYTES(0x48);
 };
 static_assert(sizeof(CaptureButtonSharedMemoryFormat) == 0x200,
               "CaptureButtonSharedMemoryFormat is an invalid size");

src/hid_core/resources/system_buttons/capture_button.cpp

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/core_timing.h"
+#include "hid_core/frontend/emulated_controller.h"
+#include "hid_core/hid_core.h"
 #include "hid_core/resources/applet_resource.h"
 #include "hid_core/resources/shared_memory_format.h"
 #include "hid_core/resources/system_buttons/capture_button.h"
@@ -17,10 +19,6 @@ void CaptureButton::OnInit() {}
 void CaptureButton::OnRelease() {}
 
 void CaptureButton::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
-    if (!smart_update) {
-        return;
-    }
-
     std::scoped_lock shared_lock{*shared_mutex};
     const u64 aruid = applet_resource->GetActiveAruid();
     auto* data = applet_resource->GetAruidData(aruid);
@@ -29,11 +27,21 @@ void CaptureButton::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
         return;
     }
 
-    auto& header = data->shared_memory_format->capture_button.header;
+    auto& shared_memory = data->shared_memory_format->capture_button;
-    header.timestamp = core_timing.GetGlobalTimeNs().count();
+
-    header.total_entry_count = 17;
+    if (!IsControllerActivated()) {
-    header.entry_count = 0;
+        shared_memory.capture_lifo.buffer_count = 0;
-    header.last_entry_index = 0;
+        shared_memory.capture_lifo.buffer_tail = 0;
+        return;
+    }
+
+    const auto& last_entry = shared_memory.capture_lifo.ReadCurrentEntry().state;
+    next_state.sampling_number = last_entry.sampling_number + 1;
+
+    auto* controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1);
+    next_state.buttons.raw = controller->GetHomeButtons().raw;
+
+    shared_memory.capture_lifo.WriteNextEntry(next_state);
 }
 
 } // namespace Service::HID

src/hid_core/resources/system_buttons/capture_button.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "hid_core/resources/controller_base.h"
+#include "hid_core/resources/system_buttons/system_button_types.h"
 
 namespace Service::HID {
 
@@ -22,6 +23,6 @@ public:
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
 
 private:
-    bool smart_update{};
+    CaptureButtonState next_state{};
 };
 } // namespace Service::HID

src/hid_core/resources/system_buttons/home_button.cpp

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "core/core_timing.h"
+#include "hid_core/frontend/emulated_controller.h"
+#include "hid_core/hid_core.h"
 #include "hid_core/resources/applet_resource.h"
 #include "hid_core/resources/shared_memory_format.h"
 #include "hid_core/resources/system_buttons/home_button.h"
@@ -17,10 +19,6 @@ void HomeButton::OnInit() {}
 void HomeButton::OnRelease() {}
 
 void HomeButton::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
-    if (!smart_update) {
-        return;
-    }
-
     std::scoped_lock shared_lock{*shared_mutex};
     const u64 aruid = applet_resource->GetActiveAruid();
     auto* data = applet_resource->GetAruidData(aruid);
@@ -29,11 +27,21 @@ void HomeButton::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
         return;
     }
 
-    auto& header = data->shared_memory_format->home_button.header;
+    auto& shared_memory = data->shared_memory_format->home_button;
-    header.timestamp = core_timing.GetGlobalTimeNs().count();
+
-    header.total_entry_count = 17;
+    if (!IsControllerActivated()) {
-    header.entry_count = 0;
+        shared_memory.home_lifo.buffer_count = 0;
-    header.last_entry_index = 0;
+        shared_memory.home_lifo.buffer_tail = 0;
+        return;
+    }
+
+    const auto& last_entry = shared_memory.home_lifo.ReadCurrentEntry().state;
+    next_state.sampling_number = last_entry.sampling_number + 1;
+
+    auto* controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1);
+    next_state.buttons.raw = controller->GetHomeButtons().raw;
+
+    shared_memory.home_lifo.WriteNextEntry(next_state);
 }
 
 } // namespace Service::HID

src/hid_core/resources/system_buttons/home_button.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "hid_core/resources/controller_base.h"
+#include "hid_core/resources/system_buttons/system_button_types.h"
 
 namespace Service::HID {
 
@@ -22,6 +23,6 @@ public:
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
 
 private:
-    bool smart_update{};
+    HomeButtonState next_state{};
 };
 } // namespace Service::HID

src/hid_core/resources/system_buttons/sleep_button.cpp

@@ -17,10 +17,6 @@ void SleepButton::OnInit() {}
 void SleepButton::OnRelease() {}
 
 void SleepButton::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
-    if (!smart_update) {
-        return;
-    }
-
     std::scoped_lock shared_lock{*shared_mutex};
     const u64 aruid = applet_resource->GetActiveAruid();
     auto* data = applet_resource->GetAruidData(aruid);
@@ -29,11 +25,20 @@ void SleepButton::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
         return;
     }
 
-    auto& header = data->shared_memory_format->capture_button.header;
+    auto& shared_memory = data->shared_memory_format->sleep_button;
-    header.timestamp = core_timing.GetGlobalTimeNs().count();
+
-    header.total_entry_count = 17;
+    if (!IsControllerActivated()) {
-    header.entry_count = 0;
+        shared_memory.sleep_lifo.buffer_count = 0;
-    header.last_entry_index = 0;
+        shared_memory.sleep_lifo.buffer_tail = 0;
+        return;
+    }
+
+    const auto& last_entry = shared_memory.sleep_lifo.ReadCurrentEntry().state;
+    next_state.sampling_number = last_entry.sampling_number + 1;
+
+    next_state.buttons.raw = 0;
+
+    shared_memory.sleep_lifo.WriteNextEntry(next_state);
 }
 
 } // namespace Service::HID

src/hid_core/resources/system_buttons/sleep_button.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "hid_core/resources/controller_base.h"
+#include "hid_core/resources/system_buttons/system_button_types.h"
 
 namespace Service::HID {
 
@@ -22,6 +23,6 @@ public:
     void OnUpdate(const Core::Timing::CoreTiming& core_timing) override;
 
 private:
-    bool smart_update{};
+    SleepButtonState next_state{};
 };
 } // namespace Service::HID

src/hid_core/resources/system_buttons/system_button_types.h

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "hid_core/hid_types.h"
+
+namespace Service::HID {
+
+// This is nn::hid::system::SleepButtonState
+struct SleepButtonState {
+    s64 sampling_number{};
+    Core::HID::SleepButtonState buttons;
+};
+static_assert(sizeof(SleepButtonState) == 0x10, "SleepButtonState is an invalid size");
+
+// This is nn::hid::system::HomeButtonState
+struct HomeButtonState {
+    s64 sampling_number{};
+    Core::HID::HomeButtonState buttons;
+};
+static_assert(sizeof(HomeButtonState) == 0x10, "HomeButtonState is an invalid size");
+
+// This is nn::hid::system::SleepButtonState
+struct CaptureButtonState {
+    s64 sampling_number{};
+    Core::HID::CaptureButtonState buttons;
+};
+static_assert(sizeof(CaptureButtonState) == 0x10, "CaptureButtonState is an invalid size");
+
+} // namespace Service::HID

src/hid_core/resources/unique_pad/unique_pad.cpp

@@ -28,7 +28,7 @@ void UniquePad::OnUpdate(const Core::Timing::CoreTiming& core_timing) {
         return;
     }
 
-    auto& header = data->shared_memory_format->capture_button.header;
+    auto& header = data->shared_memory_format->unique_pad.header;
     header.timestamp = core_timing.GetGlobalTimeNs().count();
     header.total_entry_count = 17;
     header.entry_count = 0;

src/video_core/CMakeLists.txt

@@ -302,7 +302,7 @@ target_link_options(video_core PRIVATE ${FFmpeg_LDFLAGS})
 
 add_dependencies(video_core host_shaders)
 target_include_directories(video_core PRIVATE ${HOST_SHADERS_INCLUDE})
-target_link_libraries(video_core PRIVATE sirit Vulkan::Headers GPUOpen::VulkanMemoryAllocator)
+target_link_libraries(video_core PRIVATE sirit Vulkan::Headers Vulkan::UtilityHeaders GPUOpen::VulkanMemoryAllocator)
 
 if (ENABLE_NSIGHT_AFTERMATH)
     if (NOT DEFINED ENV{NSIGHT_AFTERMATH_SDK})

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -12,6 +12,7 @@
 #include "core/core.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_swapchain.h"
+#include "video_core/vulkan_common/vk_enum_string_helper.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 #include "vulkan/vulkan_core.h"
@@ -151,7 +152,7 @@ bool Swapchain::AcquireNextImage() {
         vk::Check(result);
         break;
     default:
-        LOG_ERROR(Render_Vulkan, "vkAcquireNextImageKHR returned {}", vk::ToString(result));
+        LOG_ERROR(Render_Vulkan, "vkAcquireNextImageKHR returned {}", string_VkResult(result));
         break;
     }
 
@@ -187,7 +188,7 @@ void Swapchain::Present(VkSemaphore render_semaphore) {
         vk::Check(result);
         break;
     default:
-        LOG_CRITICAL(Render_Vulkan, "Failed to present with error {}", vk::ToString(result));
+        LOG_CRITICAL(Render_Vulkan, "Failed to present with error {}", string_VkResult(result));
         break;
     }
     ++frame_index;

src/video_core/vulkan_common/vk_enum_string_helper.h

@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "video_core/vulkan_common/vulkan.h"
+
+#include <vulkan/vk_enum_string_helper.h>

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -9,6 +9,7 @@
 
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "video_core/vulkan_common/vk_enum_string_helper.h"
 #include "video_core/vulkan_common/vma.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
@@ -298,109 +299,7 @@ bool Load(VkInstance instance, InstanceDispatch& dld) noexcept {
 }
 
 const char* Exception::what() const noexcept {
-    return ToString(result);
+    return string_VkResult(result);
-}
-
-const char* ToString(VkResult result) noexcept {
-    switch (result) {
-    case VkResult::VK_SUCCESS:
-        return "VK_SUCCESS";
-    case VkResult::VK_NOT_READY:
-        return "VK_NOT_READY";
-    case VkResult::VK_TIMEOUT:
-        return "VK_TIMEOUT";
-    case VkResult::VK_EVENT_SET:
-        return "VK_EVENT_SET";
-    case VkResult::VK_EVENT_RESET:
-        return "VK_EVENT_RESET";
-    case VkResult::VK_INCOMPLETE:
-        return "VK_INCOMPLETE";
-    case VkResult::VK_ERROR_OUT_OF_HOST_MEMORY:
-        return "VK_ERROR_OUT_OF_HOST_MEMORY";
-    case VkResult::VK_ERROR_OUT_OF_DEVICE_MEMORY:
-        return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
-    case VkResult::VK_ERROR_INITIALIZATION_FAILED:
-        return "VK_ERROR_INITIALIZATION_FAILED";
-    case VkResult::VK_ERROR_DEVICE_LOST:
-        return "VK_ERROR_DEVICE_LOST";
-    case VkResult::VK_ERROR_MEMORY_MAP_FAILED:
-        return "VK_ERROR_MEMORY_MAP_FAILED";
-    case VkResult::VK_ERROR_LAYER_NOT_PRESENT:
-        return "VK_ERROR_LAYER_NOT_PRESENT";
-    case VkResult::VK_ERROR_EXTENSION_NOT_PRESENT:
-        return "VK_ERROR_EXTENSION_NOT_PRESENT";
-    case VkResult::VK_ERROR_FEATURE_NOT_PRESENT:
-        return "VK_ERROR_FEATURE_NOT_PRESENT";
-    case VkResult::VK_ERROR_INCOMPATIBLE_DRIVER:
-        return "VK_ERROR_INCOMPATIBLE_DRIVER";
-    case VkResult::VK_ERROR_TOO_MANY_OBJECTS:
-        return "VK_ERROR_TOO_MANY_OBJECTS";
-    case VkResult::VK_ERROR_FORMAT_NOT_SUPPORTED:
-        return "VK_ERROR_FORMAT_NOT_SUPPORTED";
-    case VkResult::VK_ERROR_FRAGMENTED_POOL:
-        return "VK_ERROR_FRAGMENTED_POOL";
-    case VkResult::VK_ERROR_OUT_OF_POOL_MEMORY:
-        return "VK_ERROR_OUT_OF_POOL_MEMORY";
-    case VkResult::VK_ERROR_INVALID_EXTERNAL_HANDLE:
-        return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
-    case VkResult::VK_ERROR_SURFACE_LOST_KHR:
-        return "VK_ERROR_SURFACE_LOST_KHR";
-    case VkResult::VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
-        return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
-    case VkResult::VK_SUBOPTIMAL_KHR:
-        return "VK_SUBOPTIMAL_KHR";
-    case VkResult::VK_ERROR_OUT_OF_DATE_KHR:
-        return "VK_ERROR_OUT_OF_DATE_KHR";
-    case VkResult::VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
-        return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
-    case VkResult::VK_ERROR_VALIDATION_FAILED_EXT:
-        return "VK_ERROR_VALIDATION_FAILED_EXT";
-    case VkResult::VK_ERROR_INVALID_SHADER_NV:
-        return "VK_ERROR_INVALID_SHADER_NV";
-    case VkResult::VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR:
-        return "VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR";
-    case VkResult::VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR:
-        return "VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR";
-    case VkResult::VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR:
-        return "VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR";
-    case VkResult::VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR:
-        return "VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR";
-    case VkResult::VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR:
-        return "VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR";
-    case VkResult::VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR:
-        return "VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR";
-    case VkResult::VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
-        return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
-    case VkResult::VK_ERROR_FRAGMENTATION_EXT:
-        return "VK_ERROR_FRAGMENTATION_EXT";
-    case VkResult::VK_ERROR_NOT_PERMITTED_EXT:
-        return "VK_ERROR_NOT_PERMITTED_EXT";
-    case VkResult::VK_ERROR_INVALID_DEVICE_ADDRESS_EXT:
-        return "VK_ERROR_INVALID_DEVICE_ADDRESS_EXT";
-    case VkResult::VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
-        return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
-    case VkResult::VK_ERROR_UNKNOWN:
-        return "VK_ERROR_UNKNOWN";
-    case VkResult::VK_THREAD_IDLE_KHR:
-        return "VK_THREAD_IDLE_KHR";
-    case VkResult::VK_THREAD_DONE_KHR:
-        return "VK_THREAD_DONE_KHR";
-    case VkResult::VK_OPERATION_DEFERRED_KHR:
-        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:
-        return "VK_RESULT_MAX_ENUM";
-    case VkResult::VK_ERROR_COMPRESSION_EXHAUSTED_EXT:
-        return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT";
-    case VkResult::VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT:
-        return "VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT";
-    }
-    return "Unknown";
 }
 
 void Destroy(VkInstance instance, const InstanceDispatch& dld) noexcept {
@@ -1067,7 +966,7 @@ u32 AvailableVersion(const InstanceDispatch& dld) noexcept {
     u32 version;
     if (const VkResult result = vkEnumerateInstanceVersion(&version); result != VK_SUCCESS) {
         LOG_ERROR(Render_Vulkan, "vkEnumerateInstanceVersion returned {}, assuming Vulkan 1.1",
-                  ToString(result));
+                  string_VkResult(result));
         return VK_API_VERSION_1_1;
     }
     return version;

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -125,9 +125,6 @@ private:
     VkResult result;
 };
 
-/// Converts a VkResult enum into a rodata string
-const char* ToString(VkResult) noexcept;
-
 /// Throws a Vulkan exception if result is not success.
 inline void Check(VkResult result) {
     if (result != VK_SUCCESS) {