29 files changed, 27 insertions, 1521 deletions

diff --git a/src/video_core/renderer_vulkan/blit_image.cpp b/src/video_core/renderer_vulkan/blit_image.cpp
index b412cdb7f..1f6a169ae 100644
--- a/src/video_core/renderer_vulkan/blit_image.cpp
+++ b/src/video_core/renderer_vulkan/blit_image.cpp
@@ -11,13 +11,13 @@
 #include "video_core/host_shaders/vulkan_blit_depth_stencil_frag_spv.h"
 #include "video_core/renderer_vulkan/blit_image.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_shader_util.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/surface.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
index 9c0fcfbce..ca7c2c579 100644
--- a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
+++ b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
@@ -9,8 +9,8 @@
 #include "common/logging/log.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/surface.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan::MaxwellToVK {
diff --git a/src/video_core/renderer_vulkan/maxwell_to_vk.h b/src/video_core/renderer_vulkan/maxwell_to_vk.h
index 8fa63c1c9..537969840 100644
--- a/src/video_core/renderer_vulkan/maxwell_to_vk.h
+++ b/src/video_core/renderer_vulkan/maxwell_to_vk.h
@@ -6,9 +6,9 @@
 
 #include "common/common_types.h"
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/surface.h"
 #include "video_core/textures/texture.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan::MaxwellToVK {
diff --git a/src/video_core/renderer_vulkan/nsight_aftermath_tracker.cpp b/src/video_core/renderer_vulkan/nsight_aftermath_tracker.cpp
deleted file mode 100644
index 5b01020ec..000000000
--- a/src/video_core/renderer_vulkan/nsight_aftermath_tracker.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#ifdef HAS_NSIGHT_AFTERMATH
-
-#include <mutex>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-#include <fmt/format.h>
-
-#define VK_NO_PROTOTYPES
-#include <vulkan/vulkan.h>
-
-#include <GFSDK_Aftermath.h>
-#include <GFSDK_Aftermath_Defines.h>
-#include <GFSDK_Aftermath_GpuCrashDump.h>
-#include <GFSDK_Aftermath_GpuCrashDumpDecoding.h>
-
-#include "common/common_paths.h"
-#include "common/common_types.h"
-#include "common/file_util.h"
-#include "common/logging/log.h"
-#include "common/scope_exit.h"
-
-#include "video_core/renderer_vulkan/nsight_aftermath_tracker.h"
-
-namespace Vulkan {
-
-static constexpr char AFTERMATH_LIB_NAME[] = "GFSDK_Aftermath_Lib.x64.dll";
-
-NsightAftermathTracker::NsightAftermathTracker() = default;
-
-NsightAftermathTracker::~NsightAftermathTracker() {
-    if (initialized) {
-        (void)GFSDK_Aftermath_DisableGpuCrashDumps();
-    }
-}
-
-bool NsightAftermathTracker::Initialize() {
-    if (!dl.Open(AFTERMATH_LIB_NAME)) {
-        LOG_ERROR(Render_Vulkan, "Failed to load Nsight Aftermath DLL");
-        return false;
-    }
-
-    if (!dl.GetSymbol("GFSDK_Aftermath_DisableGpuCrashDumps",
-                      &GFSDK_Aftermath_DisableGpuCrashDumps) ||
-        !dl.GetSymbol("GFSDK_Aftermath_EnableGpuCrashDumps",
-                      &GFSDK_Aftermath_EnableGpuCrashDumps) ||
-        !dl.GetSymbol("GFSDK_Aftermath_GetShaderDebugInfoIdentifier",
-                      &GFSDK_Aftermath_GetShaderDebugInfoIdentifier) ||
-        !dl.GetSymbol("GFSDK_Aftermath_GetShaderHashSpirv", &GFSDK_Aftermath_GetShaderHashSpirv) ||
-        !dl.GetSymbol("GFSDK_Aftermath_GpuCrashDump_CreateDecoder",
-                      &GFSDK_Aftermath_GpuCrashDump_CreateDecoder) ||
-        !dl.GetSymbol("GFSDK_Aftermath_GpuCrashDump_DestroyDecoder",
-                      &GFSDK_Aftermath_GpuCrashDump_DestroyDecoder) ||
-        !dl.GetSymbol("GFSDK_Aftermath_GpuCrashDump_GenerateJSON",
-                      &GFSDK_Aftermath_GpuCrashDump_GenerateJSON) ||
-        !dl.GetSymbol("GFSDK_Aftermath_GpuCrashDump_GetJSON",
-                      &GFSDK_Aftermath_GpuCrashDump_GetJSON)) {
-        LOG_ERROR(Render_Vulkan, "Failed to load Nsight Aftermath function pointers");
-        return false;
-    }
-
-    dump_dir = Common::FS::GetUserPath(Common::FS::UserPath::LogDir) + "gpucrash";
-
-    (void)Common::FS::DeleteDirRecursively(dump_dir);
-    if (!Common::FS::CreateDir(dump_dir)) {
-        LOG_ERROR(Render_Vulkan, "Failed to create Nsight Aftermath dump directory");
-        return false;
-    }
-
-    if (!GFSDK_Aftermath_SUCCEED(GFSDK_Aftermath_EnableGpuCrashDumps(
-            GFSDK_Aftermath_Version_API, GFSDK_Aftermath_GpuCrashDumpWatchedApiFlags_Vulkan,
-            GFSDK_Aftermath_GpuCrashDumpFeatureFlags_Default, GpuCrashDumpCallback,
-            ShaderDebugInfoCallback, CrashDumpDescriptionCallback, this))) {
-        LOG_ERROR(Render_Vulkan, "GFSDK_Aftermath_EnableGpuCrashDumps failed");
-        return false;
-    }
-
-    LOG_INFO(Render_Vulkan, "Nsight Aftermath dump directory is \"{}\"", dump_dir);
-
-    initialized = true;
-    return true;
-}
-
-void NsightAftermathTracker::SaveShader(const std::vector<u32>& spirv) const {
-    if (!initialized) {
-        return;
-    }
-
-    std::vector<u32> spirv_copy = spirv;
-    GFSDK_Aftermath_SpirvCode shader;
-    shader.pData = spirv_copy.data();
-    shader.size = static_cast<u32>(spirv_copy.size() * 4);
-
-    std::scoped_lock lock{mutex};
-
-    GFSDK_Aftermath_ShaderHash hash;
-    if (!GFSDK_Aftermath_SUCCEED(
-            GFSDK_Aftermath_GetShaderHashSpirv(GFSDK_Aftermath_Version_API, &shader, &hash))) {
-        LOG_ERROR(Render_Vulkan, "Failed to hash SPIR-V module");
-        return;
-    }
-
-    Common::FS::IOFile file(fmt::format("{}/source_{:016x}.spv", dump_dir, hash.hash), "wb");
-    if (!file.IsOpen()) {
-        LOG_ERROR(Render_Vulkan, "Failed to dump SPIR-V module with hash={:016x}", hash.hash);
-        return;
-    }
-    if (file.WriteArray(spirv.data(), spirv.size()) != spirv.size()) {
-        LOG_ERROR(Render_Vulkan, "Failed to write SPIR-V module with hash={:016x}", hash.hash);
-        return;
-    }
-}
-
-void NsightAftermathTracker::OnGpuCrashDumpCallback(const void* gpu_crash_dump,
-                                                    u32 gpu_crash_dump_size) {
-    std::scoped_lock lock{mutex};
-
-    LOG_CRITICAL(Render_Vulkan, "called");
-
-    GFSDK_Aftermath_GpuCrashDump_Decoder decoder;
-    if (!GFSDK_Aftermath_SUCCEED(GFSDK_Aftermath_GpuCrashDump_CreateDecoder(
-            GFSDK_Aftermath_Version_API, gpu_crash_dump, gpu_crash_dump_size, &decoder))) {
-        LOG_ERROR(Render_Vulkan, "Failed to create decoder");
-        return;
-    }
-    SCOPE_EXIT({ GFSDK_Aftermath_GpuCrashDump_DestroyDecoder(decoder); });
-
-    u32 json_size = 0;
-    if (!GFSDK_Aftermath_SUCCEED(GFSDK_Aftermath_GpuCrashDump_GenerateJSON(
-            decoder, GFSDK_Aftermath_GpuCrashDumpDecoderFlags_ALL_INFO,
-            GFSDK_Aftermath_GpuCrashDumpFormatterFlags_NONE, nullptr, nullptr, nullptr, nullptr,
-            this, &json_size))) {
-        LOG_ERROR(Render_Vulkan, "Failed to generate JSON");
-        return;
-    }
-    std::vector<char> json(json_size);
-    if (!GFSDK_Aftermath_SUCCEED(
-            GFSDK_Aftermath_GpuCrashDump_GetJSON(decoder, json_size, json.data()))) {
-        LOG_ERROR(Render_Vulkan, "Failed to query JSON");
-        return;
-    }
-
-    const std::string base_name = [this] {
-        const int id = dump_id++;
-        if (id == 0) {
-            return fmt::format("{}/crash.nv-gpudmp", dump_dir);
-        } else {
-            return fmt::format("{}/crash_{}.nv-gpudmp", dump_dir, id);
-        }
-    }();
-
-    std::string_view dump_view(static_cast<const char*>(gpu_crash_dump), gpu_crash_dump_size);
-    if (Common::FS::WriteStringToFile(false, base_name, dump_view) != gpu_crash_dump_size) {
-        LOG_ERROR(Render_Vulkan, "Failed to write dump file");
-        return;
-    }
-    const std::string_view json_view(json.data(), json.size());
-    if (Common::FS::WriteStringToFile(true, base_name + ".json", json_view) != json.size()) {
-        LOG_ERROR(Render_Vulkan, "Failed to write JSON");
-        return;
-    }
-}
-
-void NsightAftermathTracker::OnShaderDebugInfoCallback(const void* shader_debug_info,
-                                                       u32 shader_debug_info_size) {
-    std::scoped_lock lock{mutex};
-
-    GFSDK_Aftermath_ShaderDebugInfoIdentifier identifier;
-    if (!GFSDK_Aftermath_SUCCEED(GFSDK_Aftermath_GetShaderDebugInfoIdentifier(
-            GFSDK_Aftermath_Version_API, shader_debug_info, shader_debug_info_size, &identifier))) {
-        LOG_ERROR(Render_Vulkan, "GFSDK_Aftermath_GetShaderDebugInfoIdentifier failed");
-        return;
-    }
-
-    const std::string path =
-        fmt::format("{}/shader_{:016x}{:016x}.nvdbg", dump_dir, identifier.id[0], identifier.id[1]);
-    Common::FS::IOFile file(path, "wb");
-    if (!file.IsOpen()) {
-        LOG_ERROR(Render_Vulkan, "Failed to create file {}", path);
-        return;
-    }
-    if (file.WriteBytes(static_cast<const u8*>(shader_debug_info), shader_debug_info_size) !=
-        shader_debug_info_size) {
-        LOG_ERROR(Render_Vulkan, "Failed to write file {}", path);
-        return;
-    }
-}
-
-void NsightAftermathTracker::OnCrashDumpDescriptionCallback(
-    PFN_GFSDK_Aftermath_AddGpuCrashDumpDescription add_description) {
-    add_description(GFSDK_Aftermath_GpuCrashDumpDescriptionKey_ApplicationName, "yuzu");
-}
-
-void NsightAftermathTracker::GpuCrashDumpCallback(const void* gpu_crash_dump,
-                                                  u32 gpu_crash_dump_size, void* user_data) {
-    static_cast<NsightAftermathTracker*>(user_data)->OnGpuCrashDumpCallback(gpu_crash_dump,
-                                                                            gpu_crash_dump_size);
-}
-
-void NsightAftermathTracker::ShaderDebugInfoCallback(const void* shader_debug_info,
-                                                     u32 shader_debug_info_size, void* user_data) {
-    static_cast<NsightAftermathTracker*>(user_data)->OnShaderDebugInfoCallback(
-        shader_debug_info, shader_debug_info_size);
-}
-
-void NsightAftermathTracker::CrashDumpDescriptionCallback(
-    PFN_GFSDK_Aftermath_AddGpuCrashDumpDescription add_description, void* user_data) {
-    static_cast<NsightAftermathTracker*>(user_data)->OnCrashDumpDescriptionCallback(
-        add_description);
-}
-
-} // namespace Vulkan
-
-#endif // HAS_NSIGHT_AFTERMATH
diff --git a/src/video_core/renderer_vulkan/nsight_aftermath_tracker.h b/src/video_core/renderer_vulkan/nsight_aftermath_tracker.h
deleted file mode 100644
index afe7ae99e..000000000
--- a/src/video_core/renderer_vulkan/nsight_aftermath_tracker.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <mutex>
-#include <string>
-#include <vector>
-
-#define VK_NO_PROTOTYPES
-#include <vulkan/vulkan.h>
-
-#ifdef HAS_NSIGHT_AFTERMATH
-#include <GFSDK_Aftermath_Defines.h>
-#include <GFSDK_Aftermath_GpuCrashDump.h>
-#include <GFSDK_Aftermath_GpuCrashDumpDecoding.h>
-#endif
-
-#include "common/common_types.h"
-#include "common/dynamic_library.h"
-
-namespace Vulkan {
-
-class NsightAftermathTracker {
-public:
-    NsightAftermathTracker();
-    ~NsightAftermathTracker();
-
-    NsightAftermathTracker(const NsightAftermathTracker&) = delete;
-    NsightAftermathTracker& operator=(const NsightAftermathTracker&) = delete;
-
-    // Delete move semantics because Aftermath initialization uses a pointer to this.
-    NsightAftermathTracker(NsightAftermathTracker&&) = delete;
-    NsightAftermathTracker& operator=(NsightAftermathTracker&&) = delete;
-
-    bool Initialize();
-
-    void SaveShader(const std::vector<u32>& spirv) const;
-
-private:
-#ifdef HAS_NSIGHT_AFTERMATH
-    static void GpuCrashDumpCallback(const void* gpu_crash_dump, u32 gpu_crash_dump_size,
-                                     void* user_data);
-
-    static void ShaderDebugInfoCallback(const void* shader_debug_info, u32 shader_debug_info_size,
-                                        void* user_data);
-
-    static void CrashDumpDescriptionCallback(
-        PFN_GFSDK_Aftermath_AddGpuCrashDumpDescription add_description, void* user_data);
-
-    void OnGpuCrashDumpCallback(const void* gpu_crash_dump, u32 gpu_crash_dump_size);
-
-    void OnShaderDebugInfoCallback(const void* shader_debug_info, u32 shader_debug_info_size);
-
-    void OnCrashDumpDescriptionCallback(
-        PFN_GFSDK_Aftermath_AddGpuCrashDumpDescription add_description);
-
-    mutable std::mutex mutex;
-
-    std::string dump_dir;
-    int dump_id = 0;
-
-    bool initialized = false;
-
-    Common::DynamicLibrary dl;
-    PFN_GFSDK_Aftermath_DisableGpuCrashDumps GFSDK_Aftermath_DisableGpuCrashDumps;
-    PFN_GFSDK_Aftermath_EnableGpuCrashDumps GFSDK_Aftermath_EnableGpuCrashDumps;
-    PFN_GFSDK_Aftermath_GetShaderDebugInfoIdentifier GFSDK_Aftermath_GetShaderDebugInfoIdentifier;
-    PFN_GFSDK_Aftermath_GetShaderHashSpirv GFSDK_Aftermath_GetShaderHashSpirv;
-    PFN_GFSDK_Aftermath_GpuCrashDump_CreateDecoder GFSDK_Aftermath_GpuCrashDump_CreateDecoder;
-    PFN_GFSDK_Aftermath_GpuCrashDump_DestroyDecoder GFSDK_Aftermath_GpuCrashDump_DestroyDecoder;
-    PFN_GFSDK_Aftermath_GpuCrashDump_GenerateJSON GFSDK_Aftermath_GpuCrashDump_GenerateJSON;
-    PFN_GFSDK_Aftermath_GpuCrashDump_GetJSON GFSDK_Aftermath_GpuCrashDump_GetJSON;
-#endif
-};
-
-#ifndef HAS_NSIGHT_AFTERMATH
-inline NsightAftermathTracker::NsightAftermathTracker() = default;
-inline NsightAftermathTracker::~NsightAftermathTracker() = default;
-inline bool NsightAftermathTracker::Initialize() {
-    return false;
-}
-inline void NsightAftermathTracker::SaveShader(const std::vector<u32>&) const {}
-#endif
-
-} // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
index 0224fc445..d7437e185 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -22,7 +22,6 @@
 #include "video_core/gpu.h"
 #include "video_core/renderer_vulkan/renderer_vulkan.h"
 #include "video_core/renderer_vulkan/vk_blit_screen.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
 #include "video_core/renderer_vulkan/vk_memory_manager.h"
 #include "video_core/renderer_vulkan/vk_rasterizer.h"
@@ -30,6 +29,7 @@
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 #include "video_core/renderer_vulkan/vk_swapchain.h"
 #include "video_core/vulkan_common/vulkan_debug_callback.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_instance.h"
 #include "video_core/vulkan_common/vulkan_library.h"
 #include "video_core/vulkan_common/vulkan_surface.h"
diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.cpp b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
index a0f2825e2..5e184eb42 100644
--- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
@@ -21,7 +21,6 @@
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_vulkan/renderer_vulkan.h"
 #include "video_core/renderer_vulkan/vk_blit_screen.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
 #include "video_core/renderer_vulkan/vk_memory_manager.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
@@ -29,6 +28,7 @@
 #include "video_core/renderer_vulkan/vk_swapchain.h"
 #include "video_core/surface.h"
 #include "video_core/textures/decoders.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
index f87779c4b..4d517c547 100644
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
@@ -9,9 +9,9 @@
 #include "core/core.h"
 #include "video_core/buffer_cache/buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_stream_buffer.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_command_pool.cpp b/src/video_core/renderer_vulkan/vk_command_pool.cpp
index ca512d667..a99df9323 100644
--- a/src/video_core/renderer_vulkan/vk_command_pool.cpp
+++ b/src/video_core/renderer_vulkan/vk_command_pool.cpp
@@ -5,7 +5,7 @@
 #include <cstddef>
 
 #include "video_core/renderer_vulkan/vk_command_pool.h"
-#include "video_core/renderer_vulkan/vk_device.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_compute_pass.cpp b/src/video_core/renderer_vulkan/vk_compute_pass.cpp
index b13ed219a..02a6d54b7 100644
--- a/src/video_core/renderer_vulkan/vk_compute_pass.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pass.cpp
@@ -15,10 +15,10 @@
 #include "video_core/host_shaders/vulkan_uint8_comp_spv.h"
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
index cd92d5dbe..3a48219b7 100644
--- a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
@@ -6,11 +6,11 @@
 
 #include "video_core/renderer_vulkan/vk_compute_pipeline.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_shader_decompiler.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp b/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
index f5ea1ff62..ef9fb5910 100644
--- a/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
+++ b/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
@@ -6,9 +6,9 @@
 
 #include "common/common_types.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_resource_pool.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_device.cpp b/src/video_core/renderer_vulkan/vk_device.cpp
deleted file mode 100644
index 7a8b3fea0..000000000
--- a/src/video_core/renderer_vulkan/vk_device.cpp
+++ /dev/null
@@ -1,883 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <bitset>
-#include <chrono>
-#include <optional>
-#include <string_view>
-#include <thread>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include "common/assert.h"
-#include "core/settings.h"
-#include "video_core/renderer_vulkan/vk_device.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
-namespace Vulkan {
-
-namespace {
-
-namespace Alternatives {
-
-constexpr std::array Depth24UnormS8_UINT{
-    VK_FORMAT_D32_SFLOAT_S8_UINT,
-    VK_FORMAT_D16_UNORM_S8_UINT,
-    VkFormat{},
-};
-
-constexpr std::array Depth16UnormS8_UINT{
-    VK_FORMAT_D24_UNORM_S8_UINT,
-    VK_FORMAT_D32_SFLOAT_S8_UINT,
-    VkFormat{},
-};
-
-} // namespace Alternatives
-
-constexpr std::array REQUIRED_EXTENSIONS{
-    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
-    VK_KHR_MAINTENANCE1_EXTENSION_NAME,
-    VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME,
-    VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME,
-    VK_KHR_16BIT_STORAGE_EXTENSION_NAME,
-    VK_KHR_8BIT_STORAGE_EXTENSION_NAME,
-    VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME,
-    VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME,
-    VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME,
-    VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME,
-    VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,
-    VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME,
-    VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME,
-    VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME,
-};
-
-template <typename T>
-void SetNext(void**& next, T& data) {
-    *next = &data;
-    next = &data.pNext;
-}
-
-constexpr const VkFormat* GetFormatAlternatives(VkFormat format) {
-    switch (format) {
-    case VK_FORMAT_D24_UNORM_S8_UINT:
-        return Alternatives::Depth24UnormS8_UINT.data();
-    case VK_FORMAT_D16_UNORM_S8_UINT:
-        return Alternatives::Depth16UnormS8_UINT.data();
-    default:
-        return nullptr;
-    }
-}
-
-VkFormatFeatureFlags GetFormatFeatures(VkFormatProperties properties, FormatType format_type) {
-    switch (format_type) {
-    case FormatType::Linear:
-        return properties.linearTilingFeatures;
-    case FormatType::Optimal:
-        return properties.optimalTilingFeatures;
-    case FormatType::Buffer:
-        return properties.bufferFeatures;
-    default:
-        return {};
-    }
-}
-
-[[nodiscard]] bool IsRDNA(std::string_view device_name, VkDriverIdKHR driver_id) {
-    static constexpr std::array RDNA_DEVICES{
-        "5700",
-        "5600",
-        "5500",
-        "5300",
-    };
-    if (driver_id != VK_DRIVER_ID_AMD_PROPRIETARY_KHR) {
-        return false;
-    }
-    return std::any_of(RDNA_DEVICES.begin(), RDNA_DEVICES.end(), [device_name](const char* name) {
-        return device_name.find(name) != std::string_view::npos;
-    });
-}
-
-std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(
-    vk::PhysicalDevice physical, const vk::InstanceDispatch& dld) {
-    static constexpr std::array formats{
-        VK_FORMAT_A8B8G8R8_UNORM_PACK32,
-        VK_FORMAT_A8B8G8R8_UINT_PACK32,
-        VK_FORMAT_A8B8G8R8_SNORM_PACK32,
-        VK_FORMAT_A8B8G8R8_SINT_PACK32,
-        VK_FORMAT_A8B8G8R8_SRGB_PACK32,
-        VK_FORMAT_B5G6R5_UNORM_PACK16,
-        VK_FORMAT_A2B10G10R10_UNORM_PACK32,
-        VK_FORMAT_A2B10G10R10_UINT_PACK32,
-        VK_FORMAT_A1R5G5B5_UNORM_PACK16,
-        VK_FORMAT_R32G32B32A32_SFLOAT,
-        VK_FORMAT_R32G32B32A32_SINT,
-        VK_FORMAT_R32G32B32A32_UINT,
-        VK_FORMAT_R32G32_SFLOAT,
-        VK_FORMAT_R32G32_SINT,
-        VK_FORMAT_R32G32_UINT,
-        VK_FORMAT_R16G16B16A16_SINT,
-        VK_FORMAT_R16G16B16A16_UINT,
-        VK_FORMAT_R16G16B16A16_SNORM,
-        VK_FORMAT_R16G16B16A16_UNORM,
-        VK_FORMAT_R16G16_UNORM,
-        VK_FORMAT_R16G16_SNORM,
-        VK_FORMAT_R16G16_SFLOAT,
-        VK_FORMAT_R16G16_SINT,
-        VK_FORMAT_R16_UNORM,
-        VK_FORMAT_R16_UINT,
-        VK_FORMAT_R8G8B8A8_SRGB,
-        VK_FORMAT_R8G8_UNORM,
-        VK_FORMAT_R8G8_SNORM,
-        VK_FORMAT_R8G8_SINT,
-        VK_FORMAT_R8G8_UINT,
-        VK_FORMAT_R8_UNORM,
-        VK_FORMAT_R8_SNORM,
-        VK_FORMAT_R8_SINT,
-        VK_FORMAT_R8_UINT,
-        VK_FORMAT_B10G11R11_UFLOAT_PACK32,
-        VK_FORMAT_R32_SFLOAT,
-        VK_FORMAT_R32_UINT,
-        VK_FORMAT_R32_SINT,
-        VK_FORMAT_R16_SFLOAT,
-        VK_FORMAT_R16G16B16A16_SFLOAT,
-        VK_FORMAT_B8G8R8A8_UNORM,
-        VK_FORMAT_B8G8R8A8_SRGB,
-        VK_FORMAT_R4G4B4A4_UNORM_PACK16,
-        VK_FORMAT_D32_SFLOAT,
-        VK_FORMAT_D16_UNORM,
-        VK_FORMAT_D16_UNORM_S8_UINT,
-        VK_FORMAT_D24_UNORM_S8_UINT,
-        VK_FORMAT_D32_SFLOAT_S8_UINT,
-        VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
-        VK_FORMAT_BC2_UNORM_BLOCK,
-        VK_FORMAT_BC3_UNORM_BLOCK,
-        VK_FORMAT_BC4_UNORM_BLOCK,
-        VK_FORMAT_BC4_SNORM_BLOCK,
-        VK_FORMAT_BC5_UNORM_BLOCK,
-        VK_FORMAT_BC5_SNORM_BLOCK,
-        VK_FORMAT_BC7_UNORM_BLOCK,
-        VK_FORMAT_BC6H_UFLOAT_BLOCK,
-        VK_FORMAT_BC6H_SFLOAT_BLOCK,
-        VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
-        VK_FORMAT_BC2_SRGB_BLOCK,
-        VK_FORMAT_BC3_SRGB_BLOCK,
-        VK_FORMAT_BC7_SRGB_BLOCK,
-        VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
-        VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
-        VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
-        VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
-        VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
-        VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
-        VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
-        VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
-        VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
-        VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
-        VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
-        VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
-        VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
-        VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
-        VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
-        VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
-        VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
-        VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
-        VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
-        VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
-        VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
-        VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
-    };
-    std::unordered_map<VkFormat, VkFormatProperties> format_properties;
-    for (const auto format : formats) {
-        format_properties.emplace(format, physical.GetFormatProperties(format));
-    }
-    return format_properties;
-}
-
-} // Anonymous namespace
-
-Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR surface,
-               const vk::InstanceDispatch& dld_)
-    : instance{instance_}, dld{dld_}, physical{physical_}, properties{physical.GetProperties()},
-      format_properties{GetFormatProperties(physical, dld)} {
-    CheckSuitability();
-    SetupFamilies(surface);
-    SetupFeatures();
-
-    const auto queue_cis = GetDeviceQueueCreateInfos();
-    const std::vector extensions = LoadExtensions();
-
-    VkPhysicalDeviceFeatures2 features2{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
-        .pNext = nullptr,
-    };
-    const void* first_next = &features2;
-    void** next = &features2.pNext;
-
-    features2.features = {
-        .robustBufferAccess = false,
-        .fullDrawIndexUint32 = false,
-        .imageCubeArray = true,
-        .independentBlend = true,
-        .geometryShader = true,
-        .tessellationShader = true,
-        .sampleRateShading = false,
-        .dualSrcBlend = false,
-        .logicOp = false,
-        .multiDrawIndirect = false,
-        .drawIndirectFirstInstance = false,
-        .depthClamp = true,
-        .depthBiasClamp = true,
-        .fillModeNonSolid = false,
-        .depthBounds = false,
-        .wideLines = false,
-        .largePoints = true,
-        .alphaToOne = false,
-        .multiViewport = true,
-        .samplerAnisotropy = true,
-        .textureCompressionETC2 = false,
-        .textureCompressionASTC_LDR = is_optimal_astc_supported,
-        .textureCompressionBC = false,
-        .occlusionQueryPrecise = true,
-        .pipelineStatisticsQuery = false,
-        .vertexPipelineStoresAndAtomics = true,
-        .fragmentStoresAndAtomics = true,
-        .shaderTessellationAndGeometryPointSize = false,
-        .shaderImageGatherExtended = true,
-        .shaderStorageImageExtendedFormats = false,
-        .shaderStorageImageMultisample = true,
-        .shaderStorageImageReadWithoutFormat = is_formatless_image_load_supported,
-        .shaderStorageImageWriteWithoutFormat = true,
-        .shaderUniformBufferArrayDynamicIndexing = false,
-        .shaderSampledImageArrayDynamicIndexing = false,
-        .shaderStorageBufferArrayDynamicIndexing = false,
-        .shaderStorageImageArrayDynamicIndexing = false,
-        .shaderClipDistance = false,
-        .shaderCullDistance = false,
-        .shaderFloat64 = false,
-        .shaderInt64 = false,
-        .shaderInt16 = false,
-        .shaderResourceResidency = false,
-        .shaderResourceMinLod = false,
-        .sparseBinding = false,
-        .sparseResidencyBuffer = false,
-        .sparseResidencyImage2D = false,
-        .sparseResidencyImage3D = false,
-        .sparseResidency2Samples = false,
-        .sparseResidency4Samples = false,
-        .sparseResidency8Samples = false,
-        .sparseResidency16Samples = false,
-        .sparseResidencyAliased = false,
-        .variableMultisampleRate = false,
-        .inheritedQueries = false,
-    };
-    VkPhysicalDeviceTimelineSemaphoreFeaturesKHR timeline_semaphore{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR,
-        .pNext = nullptr,
-        .timelineSemaphore = true,
-    };
-    SetNext(next, timeline_semaphore);
-
-    VkPhysicalDevice16BitStorageFeaturesKHR bit16_storage{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,
-        .pNext = nullptr,
-        .storageBuffer16BitAccess = false,
-        .uniformAndStorageBuffer16BitAccess = true,
-        .storagePushConstant16 = false,
-        .storageInputOutput16 = false,
-    };
-    SetNext(next, bit16_storage);
-
-    VkPhysicalDevice8BitStorageFeaturesKHR bit8_storage{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR,
-        .pNext = nullptr,
-        .storageBuffer8BitAccess = false,
-        .uniformAndStorageBuffer8BitAccess = true,
-        .storagePushConstant8 = false,
-    };
-    SetNext(next, bit8_storage);
-
-    VkPhysicalDeviceHostQueryResetFeaturesEXT host_query_reset{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT,
-        .hostQueryReset = true,
-    };
-    SetNext(next, host_query_reset);
-
-    VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8;
-    if (is_float16_supported) {
-        float16_int8 = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR,
-            .pNext = nullptr,
-            .shaderFloat16 = true,
-            .shaderInt8 = false,
-        };
-        SetNext(next, float16_int8);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support float16 natively");
-    }
-
-    if (!nv_viewport_swizzle) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support viewport swizzles");
-    }
-
-    VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR std430_layout;
-    if (khr_uniform_buffer_standard_layout) {
-        std430_layout = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR,
-            .pNext = nullptr,
-            .uniformBufferStandardLayout = true,
-        };
-        SetNext(next, std430_layout);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support packed UBOs");
-    }
-
-    VkPhysicalDeviceIndexTypeUint8FeaturesEXT index_type_uint8;
-    if (ext_index_type_uint8) {
-        index_type_uint8 = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
-            .pNext = nullptr,
-            .indexTypeUint8 = true,
-        };
-        SetNext(next, index_type_uint8);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support uint8 indexes");
-    }
-
-    VkPhysicalDeviceTransformFeedbackFeaturesEXT transform_feedback;
-    if (ext_transform_feedback) {
-        transform_feedback = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
-            .pNext = nullptr,
-            .transformFeedback = true,
-            .geometryStreams = true,
-        };
-        SetNext(next, transform_feedback);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support transform feedbacks");
-    }
-
-    VkPhysicalDeviceCustomBorderColorFeaturesEXT custom_border;
-    if (ext_custom_border_color) {
-        custom_border = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
-            .pNext = nullptr,
-            .customBorderColors = VK_TRUE,
-            .customBorderColorWithoutFormat = VK_TRUE,
-        };
-        SetNext(next, custom_border);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support custom border colors");
-    }
-
-    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state;
-    if (ext_extended_dynamic_state) {
-        dynamic_state = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
-            .pNext = nullptr,
-            .extendedDynamicState = VK_TRUE,
-        };
-        SetNext(next, dynamic_state);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support extended dynamic state");
-    }
-
-    VkPhysicalDeviceRobustness2FeaturesEXT robustness2;
-    if (ext_robustness2) {
-        robustness2 = {
-            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
-            .pNext = nullptr,
-            .robustBufferAccess2 = false,
-            .robustImageAccess2 = true,
-            .nullDescriptor = true,
-        };
-        SetNext(next, robustness2);
-    } else {
-        LOG_INFO(Render_Vulkan, "Device doesn't support robustness2");
-    }
-
-    if (!ext_depth_range_unrestricted) {
-        LOG_INFO(Render_Vulkan, "Device doesn't support depth range unrestricted");
-    }
-
-    VkDeviceDiagnosticsConfigCreateInfoNV diagnostics_nv;
-    if (nv_device_diagnostics_config) {
-        nsight_aftermath_tracker.Initialize();
-
-        diagnostics_nv = {
-            .sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
-            .pNext = &features2,
-            .flags = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV |
-                     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV |
-                     VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV,
-        };
-        first_next = &diagnostics_nv;
-    }
-    logical = vk::Device::Create(physical, queue_cis, extensions, first_next, dld);
-
-    CollectTelemetryParameters();
-    CollectToolingInfo();
-
-    if (ext_extended_dynamic_state && driver_id == VK_DRIVER_ID_MESA_RADV) {
-        LOG_WARNING(
-            Render_Vulkan,
-            "Blacklisting RADV for VK_EXT_extended_dynamic state, likely due to a bug in yuzu");
-        ext_extended_dynamic_state = false;
-    }
-    if (ext_extended_dynamic_state && IsRDNA(properties.deviceName, driver_id)) {
-        // AMD's proprietary driver supports VK_EXT_extended_dynamic_state but on RDNA devices it
-        // seems to cause stability issues
-        LOG_WARNING(
-            Render_Vulkan,
-            "Blacklisting AMD proprietary on RDNA devices from VK_EXT_extended_dynamic_state");
-        ext_extended_dynamic_state = false;
-    }
-
-    graphics_queue = logical.GetQueue(graphics_family);
-    present_queue = logical.GetQueue(present_family);
-
-    use_asynchronous_shaders = Settings::values.use_asynchronous_shaders.GetValue();
-}
-
-Device::~Device() = default;
-
-VkFormat Device::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
-                                    FormatType format_type) const {
-    if (IsFormatSupported(wanted_format, wanted_usage, format_type)) {
-        return wanted_format;
-    }
-    // The wanted format is not supported by hardware, search for alternatives
-    const VkFormat* alternatives = GetFormatAlternatives(wanted_format);
-    if (alternatives == nullptr) {
-        UNREACHABLE_MSG("Format={} with usage={} and type={} has no defined alternatives and host "
-                        "hardware does not support it",
-                        wanted_format, wanted_usage, format_type);
-        return wanted_format;
-    }
-
-    std::size_t i = 0;
-    for (VkFormat alternative = *alternatives; alternative; alternative = alternatives[++i]) {
-        if (!IsFormatSupported(alternative, wanted_usage, format_type)) {
-            continue;
-        }
-        LOG_WARNING(Render_Vulkan,
-                    "Emulating format={} with alternative format={} with usage={} and type={}",
-                    wanted_format, alternative, wanted_usage, format_type);
-        return alternative;
-    }
-
-    // No alternatives found, panic
-    UNREACHABLE_MSG("Format={} with usage={} and type={} is not supported by the host hardware and "
-                    "doesn't support any of the alternatives",
-                    wanted_format, wanted_usage, format_type);
-    return wanted_format;
-}
-
-void Device::ReportLoss() const {
-    LOG_CRITICAL(Render_Vulkan, "Device loss occured!");
-
-    // Wait for the log to flush and for Nsight Aftermath to dump the results
-    std::this_thread::sleep_for(std::chrono::seconds{15});
-}
-
-void Device::SaveShader(const std::vector<u32>& spirv) const {
-    nsight_aftermath_tracker.SaveShader(spirv);
-}
-
-bool Device::IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) const {
-    // Disable for now to avoid converting ASTC twice.
-    static constexpr std::array astc_formats = {
-        VK_FORMAT_ASTC_4x4_UNORM_BLOCK,   VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
-        VK_FORMAT_ASTC_5x4_UNORM_BLOCK,   VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
-        VK_FORMAT_ASTC_5x5_UNORM_BLOCK,   VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_6x5_UNORM_BLOCK,   VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_6x6_UNORM_BLOCK,   VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x5_UNORM_BLOCK,   VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x6_UNORM_BLOCK,   VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x8_UNORM_BLOCK,   VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x5_UNORM_BLOCK,  VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x6_UNORM_BLOCK,  VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x8_UNORM_BLOCK,  VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
-        VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
-        VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
-    };
-    if (!features.textureCompressionASTC_LDR) {
-        return false;
-    }
-    const auto format_feature_usage{
-        VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT |
-        VK_FORMAT_FEATURE_BLIT_DST_BIT | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
-        VK_FORMAT_FEATURE_TRANSFER_DST_BIT};
-    for (const auto format : astc_formats) {
-        const auto physical_format_properties{physical.GetFormatProperties(format)};
-        if ((physical_format_properties.optimalTilingFeatures & format_feature_usage) == 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-bool Device::TestDepthStencilBlits() const {
-    static constexpr VkFormatFeatureFlags required_features =
-        VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
-    const auto test_features = [](VkFormatProperties props) {
-        return (props.optimalTilingFeatures & required_features) == required_features;
-    };
-    return test_features(format_properties.at(VK_FORMAT_D32_SFLOAT_S8_UINT)) &&
-           test_features(format_properties.at(VK_FORMAT_D24_UNORM_S8_UINT));
-}
-
-bool Device::IsFormatSupported(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
-                               FormatType format_type) const {
-    const auto it = format_properties.find(wanted_format);
-    if (it == format_properties.end()) {
-        UNIMPLEMENTED_MSG("Unimplemented format query={}", wanted_format);
-        return true;
-    }
-    const auto supported_usage = GetFormatFeatures(it->second, format_type);
-    return (supported_usage & wanted_usage) == wanted_usage;
-}
-
-void Device::CheckSuitability() const {
-    std::bitset<REQUIRED_EXTENSIONS.size()> available_extensions;
-    for (const VkExtensionProperties& property : physical.EnumerateDeviceExtensionProperties()) {
-        for (std::size_t i = 0; i < REQUIRED_EXTENSIONS.size(); ++i) {
-            if (available_extensions[i]) {
-                continue;
-            }
-            const std::string_view name{property.extensionName};
-            available_extensions[i] = name == REQUIRED_EXTENSIONS[i];
-        }
-    }
-    for (size_t i = 0; i < REQUIRED_EXTENSIONS.size(); ++i) {
-        if (available_extensions[i]) {
-            continue;
-        }
-        LOG_ERROR(Render_Vulkan, "Missing required extension: {}", REQUIRED_EXTENSIONS[i]);
-        throw vk::Exception(VK_ERROR_EXTENSION_NOT_PRESENT);
-    }
-    struct LimitTuple {
-        u32 minimum;
-        u32 value;
-        const char* name;
-    };
-    const VkPhysicalDeviceLimits& limits{properties.limits};
-    const std::array limits_report{
-        LimitTuple{65536, limits.maxUniformBufferRange, "maxUniformBufferRange"},
-        LimitTuple{16, limits.maxViewports, "maxViewports"},
-        LimitTuple{8, limits.maxColorAttachments, "maxColorAttachments"},
-        LimitTuple{8, limits.maxClipDistances, "maxClipDistances"},
-    };
-    for (const auto& tuple : limits_report) {
-        if (tuple.value < tuple.minimum) {
-            LOG_ERROR(Render_Vulkan, "{} has to be {} or greater but it is {}", tuple.name,
-                      tuple.minimum, tuple.value);
-            throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
-        }
-    }
-    const VkPhysicalDeviceFeatures features{physical.GetFeatures()};
-    const std::array feature_report{
-        std::make_pair(features.vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics"),
-        std::make_pair(features.imageCubeArray, "imageCubeArray"),
-        std::make_pair(features.independentBlend, "independentBlend"),
-        std::make_pair(features.depthClamp, "depthClamp"),
-        std::make_pair(features.samplerAnisotropy, "samplerAnisotropy"),
-        std::make_pair(features.largePoints, "largePoints"),
-        std::make_pair(features.multiViewport, "multiViewport"),
-        std::make_pair(features.depthBiasClamp, "depthBiasClamp"),
-        std::make_pair(features.geometryShader, "geometryShader"),
-        std::make_pair(features.tessellationShader, "tessellationShader"),
-        std::make_pair(features.occlusionQueryPrecise, "occlusionQueryPrecise"),
-        std::make_pair(features.fragmentStoresAndAtomics, "fragmentStoresAndAtomics"),
-        std::make_pair(features.shaderImageGatherExtended, "shaderImageGatherExtended"),
-        std::make_pair(features.shaderStorageImageMultisample, "shaderStorageImageMultisample"),
-        std::make_pair(features.shaderStorageImageWriteWithoutFormat,
-                       "shaderStorageImageWriteWithoutFormat"),
-    };
-    for (const auto& [is_supported, name] : feature_report) {
-        if (is_supported) {
-            continue;
-        }
-        LOG_ERROR(Render_Vulkan, "Missing required feature: {}", name);
-        throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
-    }
-}
-
-std::vector<const char*> Device::LoadExtensions() {
-    std::vector<const char*> extensions;
-    extensions.reserve(7 + REQUIRED_EXTENSIONS.size());
-    extensions.insert(extensions.begin(), REQUIRED_EXTENSIONS.begin(), REQUIRED_EXTENSIONS.end());
-
-    bool has_khr_shader_float16_int8{};
-    bool has_ext_subgroup_size_control{};
-    bool has_ext_transform_feedback{};
-    bool has_ext_custom_border_color{};
-    bool has_ext_extended_dynamic_state{};
-    bool has_ext_robustness2{};
-    for (const VkExtensionProperties& extension : physical.EnumerateDeviceExtensionProperties()) {
-        const auto test = [&](std::optional<std::reference_wrapper<bool>> status, const char* name,
-                              bool push) {
-            if (extension.extensionName != std::string_view(name)) {
-                return;
-            }
-            if (push) {
-                extensions.push_back(name);
-            }
-            if (status) {
-                status->get() = true;
-            }
-        };
-        test(nv_viewport_swizzle, VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, true);
-        test(khr_uniform_buffer_standard_layout,
-             VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, true);
-        test(has_khr_shader_float16_int8, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, false);
-        test(ext_depth_range_unrestricted, VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, true);
-        test(ext_index_type_uint8, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, true);
-        test(ext_sampler_filter_minmax, VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME, true);
-        test(ext_shader_viewport_index_layer, VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME,
-             true);
-        test(ext_tooling_info, VK_EXT_TOOLING_INFO_EXTENSION_NAME, true);
-        test(ext_shader_stencil_export, VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, true);
-        test(has_ext_transform_feedback, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, false);
-        test(has_ext_custom_border_color, VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME, false);
-        test(has_ext_extended_dynamic_state, VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, false);
-        test(has_ext_robustness2, VK_EXT_ROBUSTNESS_2_EXTENSION_NAME, false);
-        test(has_ext_subgroup_size_control, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, false);
-        if (Settings::values.renderer_debug) {
-            test(nv_device_diagnostics_config, VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME,
-                 true);
-        }
-    }
-
-    VkPhysicalDeviceFeatures2KHR features;
-    features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
-
-    VkPhysicalDeviceProperties2KHR physical_properties;
-    physical_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
-
-    if (has_khr_shader_float16_int8) {
-        VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8_features;
-        float16_int8_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR;
-        float16_int8_features.pNext = nullptr;
-        features.pNext = &float16_int8_features;
-
-        physical.GetFeatures2KHR(features);
-        is_float16_supported = float16_int8_features.shaderFloat16;
-        extensions.push_back(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME);
-    }
-
-    if (has_ext_subgroup_size_control) {
-        VkPhysicalDeviceSubgroupSizeControlFeaturesEXT subgroup_features;
-        subgroup_features.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT;
-        subgroup_features.pNext = nullptr;
-        features.pNext = &subgroup_features;
-        physical.GetFeatures2KHR(features);
-
-        VkPhysicalDeviceSubgroupSizeControlPropertiesEXT subgroup_properties;
-        subgroup_properties.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT;
-        subgroup_properties.pNext = nullptr;
-        physical_properties.pNext = &subgroup_properties;
-        physical.GetProperties2KHR(physical_properties);
-
-        is_warp_potentially_bigger = subgroup_properties.maxSubgroupSize > GuestWarpSize;
-
-        if (subgroup_features.subgroupSizeControl &&
-            subgroup_properties.minSubgroupSize <= GuestWarpSize &&
-            subgroup_properties.maxSubgroupSize >= GuestWarpSize) {
-            extensions.push_back(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
-            guest_warp_stages = subgroup_properties.requiredSubgroupSizeStages;
-        }
-    } else {
-        is_warp_potentially_bigger = true;
-    }
-
-    if (has_ext_transform_feedback) {
-        VkPhysicalDeviceTransformFeedbackFeaturesEXT tfb_features;
-        tfb_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
-        tfb_features.pNext = nullptr;
-        features.pNext = &tfb_features;
-        physical.GetFeatures2KHR(features);
-
-        VkPhysicalDeviceTransformFeedbackPropertiesEXT tfb_properties;
-        tfb_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
-        tfb_properties.pNext = nullptr;
-        physical_properties.pNext = &tfb_properties;
-        physical.GetProperties2KHR(physical_properties);
-
-        if (tfb_features.transformFeedback && tfb_features.geometryStreams &&
-            tfb_properties.maxTransformFeedbackStreams >= 4 &&
-            tfb_properties.maxTransformFeedbackBuffers && tfb_properties.transformFeedbackQueries &&
-            tfb_properties.transformFeedbackDraw) {
-            extensions.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
-            ext_transform_feedback = true;
-        }
-    }
-
-    if (has_ext_custom_border_color) {
-        VkPhysicalDeviceCustomBorderColorFeaturesEXT border_features;
-        border_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
-        border_features.pNext = nullptr;
-        features.pNext = &border_features;
-        physical.GetFeatures2KHR(features);
-
-        if (border_features.customBorderColors && border_features.customBorderColorWithoutFormat) {
-            extensions.push_back(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
-            ext_custom_border_color = true;
-        }
-    }
-
-    if (has_ext_extended_dynamic_state) {
-        VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state;
-        dynamic_state.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
-        dynamic_state.pNext = nullptr;
-        features.pNext = &dynamic_state;
-        physical.GetFeatures2KHR(features);
-
-        if (dynamic_state.extendedDynamicState) {
-            extensions.push_back(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
-            ext_extended_dynamic_state = true;
-        }
-    }
-
-    if (has_ext_robustness2) {
-        VkPhysicalDeviceRobustness2FeaturesEXT robustness2;
-        robustness2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
-        robustness2.pNext = nullptr;
-        features.pNext = &robustness2;
-        physical.GetFeatures2KHR(features);
-        if (robustness2.nullDescriptor && robustness2.robustImageAccess2) {
-            extensions.push_back(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
-            ext_robustness2 = true;
-        }
-    }
-
-    return extensions;
-}
-
-void Device::SetupFamilies(VkSurfaceKHR surface) {
-    const std::vector queue_family_properties = physical.GetQueueFamilyProperties();
-    std::optional<u32> graphics;
-    std::optional<u32> present;
-    for (u32 index = 0; index < static_cast<u32>(queue_family_properties.size()); ++index) {
-        if (graphics && present) {
-            break;
-        }
-        const VkQueueFamilyProperties& queue_family = queue_family_properties[index];
-        if (queue_family.queueCount == 0) {
-            continue;
-        }
-        if (queue_family.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-            graphics = index;
-        }
-        if (physical.GetSurfaceSupportKHR(index, surface)) {
-            present = index;
-        }
-    }
-    if (!graphics) {
-        LOG_ERROR(Render_Vulkan, "Device lacks a graphics queue");
-        throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
-    }
-    if (!present) {
-        LOG_ERROR(Render_Vulkan, "Device lacks a present queue");
-        throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
-    }
-    graphics_family = *graphics;
-    present_family = *present;
-}
-
-void Device::SetupFeatures() {
-    const auto supported_features{physical.GetFeatures()};
-    is_formatless_image_load_supported = supported_features.shaderStorageImageReadWithoutFormat;
-    is_blit_depth_stencil_supported = TestDepthStencilBlits();
-    is_optimal_astc_supported = IsOptimalAstcSupported(supported_features);
-}
-
-void Device::CollectTelemetryParameters() {
-    VkPhysicalDeviceDriverPropertiesKHR driver{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
-        .pNext = nullptr,
-        .driverID = {},
-        .driverName = {},
-        .driverInfo = {},
-        .conformanceVersion = {},
-    };
-
-    VkPhysicalDeviceProperties2KHR device_properties{
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
-        .pNext = &driver,
-        .properties = {},
-    };
-    physical.GetProperties2KHR(device_properties);
-
-    driver_id = driver.driverID;
-    vendor_name = driver.driverName;
-
-    const std::vector extensions = physical.EnumerateDeviceExtensionProperties();
-    reported_extensions.reserve(std::size(extensions));
-    for (const auto& extension : extensions) {
-        reported_extensions.emplace_back(extension.extensionName);
-    }
-}
-
-void Device::CollectToolingInfo() {
-    if (!ext_tooling_info) {
-        return;
-    }
-    const auto vkGetPhysicalDeviceToolPropertiesEXT =
-        reinterpret_cast<PFN_vkGetPhysicalDeviceToolPropertiesEXT>(
-            dld.vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT"));
-    if (!vkGetPhysicalDeviceToolPropertiesEXT) {
-        return;
-    }
-    u32 tool_count = 0;
-    if (vkGetPhysicalDeviceToolPropertiesEXT(physical, &tool_count, nullptr) != VK_SUCCESS) {
-        return;
-    }
-    std::vector<VkPhysicalDeviceToolPropertiesEXT> tools(tool_count);
-    if (vkGetPhysicalDeviceToolPropertiesEXT(physical, &tool_count, tools.data()) != VK_SUCCESS) {
-        return;
-    }
-    for (const VkPhysicalDeviceToolPropertiesEXT& tool : tools) {
-        const std::string_view name = tool.name;
-        LOG_INFO(Render_Vulkan, "{}", name);
-        has_renderdoc = has_renderdoc || name == "RenderDoc";
-        has_nsight_graphics = has_nsight_graphics || name == "NVIDIA Nsight Graphics";
-    }
-}
-
-std::vector<VkDeviceQueueCreateInfo> Device::GetDeviceQueueCreateInfos() const {
-    static constexpr float QUEUE_PRIORITY = 1.0f;
-
-    std::unordered_set<u32> unique_queue_families{graphics_family, present_family};
-    std::vector<VkDeviceQueueCreateInfo> queue_cis;
-    queue_cis.reserve(unique_queue_families.size());
-
-    for (const u32 queue_family : unique_queue_families) {
-        auto& ci = queue_cis.emplace_back(VkDeviceQueueCreateInfo{
-            .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .queueFamilyIndex = queue_family,
-            .queueCount = 1,
-            .pQueuePriorities = nullptr,
-        });
-        ci.pQueuePriorities = &QUEUE_PRIORITY;
-    }
-
-    return queue_cis;
-}
-
-} // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/vk_device.h b/src/video_core/renderer_vulkan/vk_device.h
deleted file mode 100644
index b2651e049..000000000
--- a/src/video_core/renderer_vulkan/vk_device.h
+++ /dev/null
@@ -1,306 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <vector>
-
-#include "common/common_types.h"
-#include "video_core/renderer_vulkan/nsight_aftermath_tracker.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
-namespace Vulkan {
-
-/// Format usage descriptor.
-enum class FormatType { Linear, Optimal, Buffer };
-
-/// Subgroup size of the guest emulated hardware (Nvidia has 32 threads per subgroup).
-const u32 GuestWarpSize = 32;
-
-/// Handles data specific to a physical device.
-class Device final {
-public:
-    explicit Device(VkInstance instance, vk::PhysicalDevice physical, VkSurfaceKHR surface,
-                    const vk::InstanceDispatch& dld);
-    ~Device();
-
-    /**
-     * Returns a format supported by the device for the passed requeriments.
-     * @param wanted_format The ideal format to be returned. It may not be the returned format.
-     * @param wanted_usage The usage that must be fulfilled even if the format is not supported.
-     * @param format_type Format type usage.
-     * @returns A format supported by the device.
-     */
-    VkFormat GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
-                                FormatType format_type) const;
-
-    /// Reports a device loss.
-    void ReportLoss() const;
-
-    /// Reports a shader to Nsight Aftermath.
-    void SaveShader(const std::vector<u32>& spirv) const;
-
-    /// Returns the dispatch loader with direct function pointers of the device.
-    const vk::DeviceDispatch& GetDispatchLoader() const {
-        return dld;
-    }
-
-    /// Returns the logical device.
-    const vk::Device& GetLogical() const {
-        return logical;
-    }
-
-    /// Returns the physical device.
-    vk::PhysicalDevice GetPhysical() const {
-        return physical;
-    }
-
-    /// Returns the main graphics queue.
-    vk::Queue GetGraphicsQueue() const {
-        return graphics_queue;
-    }
-
-    /// Returns the main present queue.
-    vk::Queue GetPresentQueue() const {
-        return present_queue;
-    }
-
-    /// Returns main graphics queue family index.
-    u32 GetGraphicsFamily() const {
-        return graphics_family;
-    }
-
-    /// Returns main present queue family index.
-    u32 GetPresentFamily() const {
-        return present_family;
-    }
-
-    /// Returns the current Vulkan API version provided in Vulkan-formatted version numbers.
-    u32 ApiVersion() const {
-        return properties.apiVersion;
-    }
-
-    /// Returns the current driver version provided in Vulkan-formatted version numbers.
-    u32 GetDriverVersion() const {
-        return properties.driverVersion;
-    }
-
-    /// Returns the device name.
-    std::string_view GetModelName() const {
-        return properties.deviceName;
-    }
-
-    /// Returns the driver ID.
-    VkDriverIdKHR GetDriverID() const {
-        return driver_id;
-    }
-
-    /// Returns uniform buffer alignment requeriment.
-    VkDeviceSize GetUniformBufferAlignment() const {
-        return properties.limits.minUniformBufferOffsetAlignment;
-    }
-
-    /// Returns storage alignment requeriment.
-    VkDeviceSize GetStorageBufferAlignment() const {
-        return properties.limits.minStorageBufferOffsetAlignment;
-    }
-
-    /// Returns the maximum range for storage buffers.
-    VkDeviceSize GetMaxStorageBufferRange() const {
-        return properties.limits.maxStorageBufferRange;
-    }
-
-    /// Returns the maximum size for push constants.
-    VkDeviceSize GetMaxPushConstantsSize() const {
-        return properties.limits.maxPushConstantsSize;
-    }
-
-    /// Returns the maximum size for shared memory.
-    u32 GetMaxComputeSharedMemorySize() const {
-        return properties.limits.maxComputeSharedMemorySize;
-    }
-
-    /// Returns true if ASTC is natively supported.
-    bool IsOptimalAstcSupported() const {
-        return is_optimal_astc_supported;
-    }
-
-    /// Returns true if the device supports float16 natively
-    bool IsFloat16Supported() const {
-        return is_float16_supported;
-    }
-
-    /// Returns true if the device warp size can potentially be bigger than guest's warp size.
-    bool IsWarpSizePotentiallyBiggerThanGuest() const {
-        return is_warp_potentially_bigger;
-    }
-
-    /// Returns true if the device can be forced to use the guest warp size.
-    bool IsGuestWarpSizeSupported(VkShaderStageFlagBits stage) const {
-        return guest_warp_stages & stage;
-    }
-
-    /// Returns true if formatless image load is supported.
-    bool IsFormatlessImageLoadSupported() const {
-        return is_formatless_image_load_supported;
-    }
-
-    /// Returns true when blitting from and to depth stencil images is supported.
-    bool IsBlitDepthStencilSupported() const {
-        return is_blit_depth_stencil_supported;
-    }
-
-    /// Returns true if the device supports VK_NV_viewport_swizzle.
-    bool IsNvViewportSwizzleSupported() const {
-        return nv_viewport_swizzle;
-    }
-
-    /// Returns true if the device supports VK_EXT_scalar_block_layout.
-    bool IsKhrUniformBufferStandardLayoutSupported() const {
-        return khr_uniform_buffer_standard_layout;
-    }
-
-    /// Returns true if the device supports VK_EXT_index_type_uint8.
-    bool IsExtIndexTypeUint8Supported() const {
-        return ext_index_type_uint8;
-    }
-
-    /// Returns true if the device supports VK_EXT_sampler_filter_minmax.
-    bool IsExtSamplerFilterMinmaxSupported() const {
-        return ext_sampler_filter_minmax;
-    }
-
-    /// Returns true if the device supports VK_EXT_depth_range_unrestricted.
-    bool IsExtDepthRangeUnrestrictedSupported() const {
-        return ext_depth_range_unrestricted;
-    }
-
-    /// Returns true if the device supports VK_EXT_shader_viewport_index_layer.
-    bool IsExtShaderViewportIndexLayerSupported() const {
-        return ext_shader_viewport_index_layer;
-    }
-
-    /// Returns true if the device supports VK_EXT_transform_feedback.
-    bool IsExtTransformFeedbackSupported() const {
-        return ext_transform_feedback;
-    }
-
-    /// Returns true if the device supports VK_EXT_custom_border_color.
-    bool IsExtCustomBorderColorSupported() const {
-        return ext_custom_border_color;
-    }
-
-    /// Returns true if the device supports VK_EXT_extended_dynamic_state.
-    bool IsExtExtendedDynamicStateSupported() const {
-        return ext_extended_dynamic_state;
-    }
-
-    /// Returns true if the device supports VK_EXT_shader_stencil_export.
-    bool IsExtShaderStencilExportSupported() const {
-        return ext_shader_stencil_export;
-    }
-
-    /// Returns true when a known debugging tool is attached.
-    bool HasDebuggingToolAttached() const {
-        return has_renderdoc || has_nsight_graphics;
-    }
-
-    /// Returns the vendor name reported from Vulkan.
-    std::string_view GetVendorName() const {
-        return vendor_name;
-    }
-
-    /// Returns the list of available extensions.
-    const std::vector<std::string>& GetAvailableExtensions() const {
-        return reported_extensions;
-    }
-
-    /// Returns true if the setting for async shader compilation is enabled.
-    bool UseAsynchronousShaders() const {
-        return use_asynchronous_shaders;
-    }
-
-private:
-    /// Checks if the physical device is suitable.
-    void CheckSuitability() const;
-
-    /// Loads extensions into a vector and stores available ones in this object.
-    std::vector<const char*> LoadExtensions();
-
-    /// Sets up queue families.
-    void SetupFamilies(VkSurfaceKHR surface);
-
-    /// Sets up device features.
-    void SetupFeatures();
-
-    /// Collects telemetry information from the device.
-    void CollectTelemetryParameters();
-
-    /// Collects information about attached tools.
-    void CollectToolingInfo();
-
-    /// Returns a list of queue initialization descriptors.
-    std::vector<VkDeviceQueueCreateInfo> GetDeviceQueueCreateInfos() const;
-
-    /// Returns true if ASTC textures are natively supported.
-    bool IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) const;
-
-    /// Returns true if the device natively supports blitting depth stencil images.
-    bool TestDepthStencilBlits() const;
-
-    /// Returns true if a format is supported.
-    bool IsFormatSupported(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
-                           FormatType format_type) const;
-
-    VkInstance instance;                    ///< Vulkan instance.
-    vk::DeviceDispatch dld;                 ///< Device function pointers.
-    vk::PhysicalDevice physical;            ///< Physical device.
-    VkPhysicalDeviceProperties properties;  ///< Device properties.
-    vk::Device logical;                     ///< Logical device.
-    vk::Queue graphics_queue;               ///< Main graphics queue.
-    vk::Queue present_queue;                ///< Main present queue.
-    u32 instance_version{};                 ///< Vulkan onstance version.
-    u32 graphics_family{};                  ///< Main graphics queue family index.
-    u32 present_family{};                   ///< Main present queue family index.
-    VkDriverIdKHR driver_id{};              ///< Driver ID.
-    VkShaderStageFlags guest_warp_stages{}; ///< Stages where the guest warp size can be forced.ed
-    bool is_optimal_astc_supported{};       ///< Support for native ASTC.
-    bool is_float16_supported{};            ///< Support for float16 arithmetics.
-    bool is_warp_potentially_bigger{};      ///< Host warp size can be bigger than guest.
-    bool is_formatless_image_load_supported{}; ///< Support for shader image read without format.
-    bool is_blit_depth_stencil_supported{};    ///< Support for blitting from and to depth stencil.
-    bool nv_viewport_swizzle{};                ///< Support for VK_NV_viewport_swizzle.
-    bool khr_uniform_buffer_standard_layout{}; ///< Support for std430 on UBOs.
-    bool ext_index_type_uint8{};               ///< Support for VK_EXT_index_type_uint8.
-    bool ext_sampler_filter_minmax{};          ///< Support for VK_EXT_sampler_filter_minmax.
-    bool ext_depth_range_unrestricted{};       ///< Support for VK_EXT_depth_range_unrestricted.
-    bool ext_shader_viewport_index_layer{};    ///< Support for VK_EXT_shader_viewport_index_layer.
-    bool ext_tooling_info{};                   ///< Support for VK_EXT_tooling_info.
-    bool ext_transform_feedback{};             ///< Support for VK_EXT_transform_feedback.
-    bool ext_custom_border_color{};            ///< Support for VK_EXT_custom_border_color.
-    bool ext_extended_dynamic_state{};         ///< Support for VK_EXT_extended_dynamic_state.
-    bool ext_robustness2{};                    ///< Support for VK_EXT_robustness2.
-    bool ext_shader_stencil_export{};          ///< Support for VK_EXT_shader_stencil_export.
-    bool nv_device_diagnostics_config{};       ///< Support for VK_NV_device_diagnostics_config.
-    bool has_renderdoc{};                      ///< Has RenderDoc attached
-    bool has_nsight_graphics{};                ///< Has Nsight Graphics attached
-
-    // Asynchronous Graphics Pipeline setting
-    bool use_asynchronous_shaders{}; ///< Setting to use asynchronous shaders/graphics pipeline
-
-    // Telemetry parameters
-    std::string vendor_name;                      ///< Device's driver name.
-    std::vector<std::string> reported_extensions; ///< Reported Vulkan extensions.
-
-    /// Format properties dictionary.
-    std::unordered_map<VkFormat, VkFormatProperties> format_properties;
-
-    /// Nsight Aftermath GPU crash tracker
-    NsightAftermathTracker nsight_aftermath_tracker;
-};
-
-} // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/vk_fence_manager.cpp b/src/video_core/renderer_vulkan/vk_fence_manager.cpp
index 3ec1769ed..4c5bc0aa1 100644
--- a/src/video_core/renderer_vulkan/vk_fence_manager.cpp
+++ b/src/video_core/renderer_vulkan/vk_fence_manager.cpp
@@ -6,10 +6,10 @@
 #include <thread>
 
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_fence_manager.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
index 360ab86eb..8a94464f6 100644
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -12,11 +12,11 @@
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp
index 16e764cb8..56ec5e380 100644
--- a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp
+++ b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp
@@ -6,8 +6,8 @@
 #include <chrono>
 
 #include "core/settings.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_memory_manager.cpp b/src/video_core/renderer_vulkan/vk_memory_manager.cpp
index 875bc65db..a6abd0eee 100644
--- a/src/video_core/renderer_vulkan/vk_memory_manager.cpp
+++ b/src/video_core/renderer_vulkan/vk_memory_manager.cpp
@@ -11,8 +11,8 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_memory_manager.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
index e3e0ecf15..02282e36f 100644
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -19,7 +19,6 @@
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
 #include "video_core/renderer_vulkan/vk_compute_pipeline.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_rasterizer.h"
@@ -29,6 +28,7 @@
 #include "video_core/shader/memory_util.h"
 #include "video_core/shader_cache.h"
 #include "video_core/shader_notify.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_query_cache.cpp b/src/video_core/renderer_vulkan/vk_query_cache.cpp
index 1288d58ec..7cadd5147 100644
--- a/src/video_core/renderer_vulkan/vk_query_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_query_cache.cpp
@@ -7,10 +7,10 @@
 #include <utility>
 #include <vector>
 
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_query_cache.h"
 #include "video_core/renderer_vulkan/vk_resource_pool.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index 05be023ad..93fbea510 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -27,7 +27,6 @@
 #include "video_core/renderer_vulkan/vk_compute_pass.h"
 #include "video_core/renderer_vulkan/vk_compute_pipeline.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_rasterizer.h"
@@ -38,6 +37,7 @@
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/shader_cache.h"
 #include "video_core/texture_cache/texture_cache.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_scheduler.cpp b/src/video_core/renderer_vulkan/vk_scheduler.cpp
index 86ac1100f..66004f9c0 100644
--- a/src/video_core/renderer_vulkan/vk_scheduler.cpp
+++ b/src/video_core/renderer_vulkan/vk_scheduler.cpp
@@ -11,12 +11,12 @@
 #include "common/microprofile.h"
 #include "common/thread.h"
 #include "video_core/renderer_vulkan/vk_command_pool.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
 #include "video_core/renderer_vulkan/vk_query_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp b/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
index f80cc1955..89cbe01ad 100644
--- a/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
+++ b/src/video_core/renderer_vulkan/vk_shader_decompiler.cpp
@@ -22,11 +22,11 @@
 #include "video_core/engines/shader_bytecode.h"
 #include "video_core/engines/shader_header.h"
 #include "video_core/engines/shader_type.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_shader_decompiler.h"
 #include "video_core/shader/node.h"
 #include "video_core/shader/shader_ir.h"
 #include "video_core/shader/transform_feedback.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 
 namespace Vulkan {
 
diff --git a/src/video_core/renderer_vulkan/vk_shader_util.cpp b/src/video_core/renderer_vulkan/vk_shader_util.cpp
index a5f554a6d..aaad4f292 100644
--- a/src/video_core/renderer_vulkan/vk_shader_util.cpp
+++ b/src/video_core/renderer_vulkan/vk_shader_util.cpp
@@ -7,8 +7,8 @@
 
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_shader_util.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp b/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp
index 34038f3d0..1e0b8b922 100644
--- a/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp
+++ b/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp
@@ -9,9 +9,9 @@
 
 #include "common/bit_util.h"
 #include "common/common_types.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_stream_buffer.cpp b/src/video_core/renderer_vulkan/vk_stream_buffer.cpp
index d72acb467..a09fe084e 100644
--- a/src/video_core/renderer_vulkan/vk_stream_buffer.cpp
+++ b/src/video_core/renderer_vulkan/vk_stream_buffer.cpp
@@ -10,9 +10,9 @@
 
 #include "common/alignment.h"
 #include "common/assert.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_stream_buffer.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp
index 7020e2c66..725a2a05d 100644
--- a/src/video_core/renderer_vulkan/vk_swapchain.cpp
+++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp
@@ -11,9 +11,9 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/frontend/framebuffer_layout.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_swapchain.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.cpp b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
index cf8983f70..bd11de012 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -10,10 +10,12 @@
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/renderer_vulkan/blit_image.h"
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"
-#include "video_core/renderer_vulkan/vk_device.h"
+#include "video_core/renderer_vulkan/vk_memory_manager.h"
+#include "video_core/renderer_vulkan/vk_rasterizer.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {
diff --git a/src/video_core/renderer_vulkan/vk_update_descriptor.cpp b/src/video_core/renderer_vulkan/vk_update_descriptor.cpp
index 19948845e..f99273c6a 100644
--- a/src/video_core/renderer_vulkan/vk_update_descriptor.cpp
+++ b/src/video_core/renderer_vulkan/vk_update_descriptor.cpp
@@ -7,9 +7,9 @@
 
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
+#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
 namespace Vulkan {