yuzu/configure_filesystem: Remove "Select Cache Directory" option

This tab of the settings is already extremely bloated and the setting itself is quite useless. With a gamelist of almost 30 games, the cache directory is smaller than 1MB for me and therefore I don't see why it needs to be configurable.
2021-01-04 06:29:48 +01:00
107 changed files with 560 additions and 661 deletions
--- a/.ci/scripts/common/post-upload.sh
+++ b/.ci/scripts/common/post-upload.sh
@@ -15,5 +15,5 @@ mv "${REV_NAME}-source.tar.xz" $RELEASE_NAME
 7z a "$REV_NAME.7z" $RELEASE_NAME

 # move the compiled archive into the artifacts directory to be uploaded by travis releases
-mv "$ARCHIVE_NAME" "${ARTIFACTS_DIR}/"
-mv "$REV_NAME.7z" "${ARTIFACTS_DIR}/"
+mv "$ARCHIVE_NAME" artifacts/
+mv "$REV_NAME.7z" artifacts/
--- a/.ci/scripts/common/pre-upload.sh
+++ b/.ci/scripts/common/pre-upload.sh
@@ -2,6 +2,5 @@

 GITDATE="`git show -s --date=short --format='%ad' | sed 's/-//g'`"
 GITREV="`git show -s --format='%h'`"
-ARTIFACTS_DIR="artifacts"

-mkdir -p "${ARTIFACTS_DIR}/"
+mkdir -p artifacts
--- a/.ci/scripts/linux/docker.sh
+++ b/.ci/scripts/linux/docker.sh
@@ -1,54 +1,14 @@
 #!/bin/bash -ex

-# Exit on error, rather than continuing with the rest of the script.
-set -e
-
 cd /yuzu

 ccache -s

 mkdir build || true && cd build
-cmake .. -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON

-make -j$(nproc)
+ninja

 ccache -s

 ctest -VV -C Release
-
-make install DESTDIR=AppDir
-rm -vf AppDir/usr/bin/yuzu-cmd AppDir/usr/bin/yuzu-tester
-
-# Download tools needed to build an AppImage
-wget -nc https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
-wget -nc https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage
-wget -nc https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
-wget -nc https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/AppRun-patched-x86_64
-wget -nc https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/exec-x86_64.so
-# Set executable bit
-chmod 755 \
-    appimagetool-x86_64.AppImage \
-    AppRun-patched-x86_64 \
-    exec-x86_64.so \
-    linuxdeploy-x86_64.AppImage \
-    linuxdeploy-plugin-qt-x86_64.AppImage
-
-# Workaround for https://github.com/AppImage/AppImageKit/issues/828
-export APPIMAGE_EXTRACT_AND_RUN=1
-
-mkdir -p AppDir/usr/optional
-mkdir -p AppDir/usr/optional/libstdc++
-mkdir -p AppDir/usr/optional/libgcc_s
-
-# Deploy yuzu's needed dependencies
-./linuxdeploy-x86_64.AppImage --appdir AppDir --plugin qt
-
-# Workaround for building yuzu with GCC 10 but also trying to distribute it to Ubuntu 18.04 et al.
-# See https://github.com/darealshinji/AppImageKit-checkrt
-cp exec-x86_64.so AppDir/usr/optional/exec.so
-cp AppRun-patched-x86_64 AppDir/AppRun
-cp --dereference /usr/lib/x86_64-linux-gnu/libstdc++.so.6 AppDir/usr/optional/libstdc++/libstdc++.so.6
-cp --dereference /lib/x86_64-linux-gnu/libgcc_s.so.1 AppDir/usr/optional/libgcc_s/libgcc_s.so.1
-
-# Build the AppImage
-./appimagetool-x86_64.AppImage AppDir
--- a/.ci/scripts/linux/upload.sh
+++ b/.ci/scripts/linux/upload.sh
@@ -2,8 +2,6 @@

 . .ci/scripts/common/pre-upload.sh

-APPIMAGE_NAME="yuzu-x86_64.AppImage"
-NEW_APPIMAGE_NAME="yuzu-${GITDATE}-${GITREV}-x86_64.AppImage"
 REV_NAME="yuzu-linux-${GITDATE}-${GITREV}"
 ARCHIVE_NAME="${REV_NAME}.tar.xz"
 COMPRESSION_FLAGS="-cJvf"
@@ -19,7 +17,4 @@ mkdir "$DIR_NAME"
 cp build/bin/yuzu-cmd "$DIR_NAME"
 cp build/bin/yuzu "$DIR_NAME"

-# Copy the AppImage to the artifacts directory and avoid compressing it
-cp "build/${APPIMAGE_NAME}" "${ARTIFACTS_DIR}/${NEW_APPIMAGE_NAME}"
-
 . .ci/scripts/common/post-upload.sh
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,10 +26,6 @@ option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)

 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)

-if (NOT ENABLE_WEB_SERVICE)
-    set(YUZU_ENABLE_BOXCAT OFF)
-endif()
-
 # Default to a Release build
 get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
@@ -243,7 +239,7 @@ if(ENABLE_QT)
    if (YUZU_USE_QT_WEB_ENGINE)
        find_package(Qt5 COMPONENTS WebEngineCore WebEngineWidgets)
    endif()
-
+	
    if (ENABLE_QT_TRANSLATION)
        find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
    endif()
@@ -326,7 +322,7 @@ if (CONAN_REQUIRED_LIBS)
            list(APPEND Boost_LIBRARIES Boost::context)
        endif()
    endif()
-
+    
    # Due to issues with variable scopes in functions, we need to also find_package(qt5) outside of the function
    if(ENABLE_QT)
        list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
--- a/README.md
+++ b/README.md
@@ -30,6 +30,7 @@ If you want to contribute to the user interface translation, please check out th

 * __Windows__: [Windows Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Windows)
 * __Linux__: [Linux Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Linux)
+* __macOS__: [macOS Build](https://github.com/yuzu-emu/yuzu/wiki/Building-for-macOS)


 ### Support
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -45,14 +45,10 @@ if (MSVC)

        # Warnings
        /W3
-        /we4062 # enumerator 'identifier' in a switch of enum 'enumeration' is not handled
-        /we4265 # 'class': class has virtual functions, but destructor is not virtual
-        /we4388 # signed/unsigned mismatch
        /we4547 # 'operator' : operator before comma has no effect; expected operator with side-effect
        /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
        /we4555 # Expression has no effect; expected expression with side-effect
        /we4834 # Discarding return value of function with 'nodiscard' attribute
-        /we5038 # data member 'member1' will be initialized after data member 'member2'
    )

    # /GS- - No stack buffer overflow checks
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -635,8 +635,6 @@ if (MSVC)
        /we4267
        # 'context' : truncation from 'type1' to 'type2'
        /we4305
-        # 'function' : not all control paths return a value
-        /we4715
    )
 else()
    target_compile_options(core PRIVATE
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -71,8 +71,15 @@ public:
    }

    void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
+        switch (exception) {
+        case Dynarmic::A32::Exception::UndefinedInstruction:
+        case Dynarmic::A32::Exception::UnpredictableInstruction:
+            break;
+        case Dynarmic::A32::Exception::Breakpoint:
+            break;
+        }
        LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                     exception, pc, MemoryReadCode(pc));
+                     static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
        UNIMPLEMENTED();
    }

--- a/src/core/crypto/key_manager.cpp
+++ b/src/core/crypto/key_manager.cpp
@@ -143,7 +143,6 @@ u64 GetSignatureTypeDataSize(SignatureType type) {
        return 0x3C;
    }
    UNREACHABLE();
-    return 0;
 }

 u64 GetSignatureTypePaddingSize(SignatureType type) {
@@ -158,7 +157,6 @@ u64 GetSignatureTypePaddingSize(SignatureType type) {
        return 0x40;
    }
    UNREACHABLE();
-    return 0;
 }

 SignatureType Ticket::GetSignatureType() const {
@@ -171,7 +169,8 @@ SignatureType Ticket::GetSignatureType() const {
    if (const auto* ticket = std::get_if<ECDSATicket>(&data)) {
        return ticket->sig_type;
    }
-    throw std::bad_variant_access{};
+
+    UNREACHABLE();
 }

 TicketData& Ticket::GetData() {
@@ -184,7 +183,8 @@ TicketData& Ticket::GetData() {
    if (auto* ticket = std::get_if<ECDSATicket>(&data)) {
        return ticket->data;
    }
-    throw std::bad_variant_access{};
+
+    UNREACHABLE();
 }

 const TicketData& Ticket::GetData() const {
@@ -197,7 +197,8 @@ const TicketData& Ticket::GetData() const {
    if (const auto* ticket = std::get_if<ECDSATicket>(&data)) {
        return ticket->data;
    }
-    throw std::bad_variant_access{};
+
+    UNREACHABLE();
 }

 u64 Ticket::GetSize() const {
--- a/src/core/file_sys/nca_patch.cpp
+++ b/src/core/file_sys/nca_patch.cpp
@@ -51,8 +51,8 @@ std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, const BlockTyp
            low = mid + 1;
        }
    }
+
    UNREACHABLE_MSG("Offset could not be found in BKTR block.");
-    return {0, 0};
 }
 } // Anonymous namespace

--- a/src/core/file_sys/registered_cache.cpp
+++ b/src/core/file_sys/registered_cache.cpp
@@ -105,8 +105,7 @@ ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
        // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
        return ContentRecordType::HtmlDocument;
    default:
-        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", type);
-        return ContentRecordType{};
+        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", static_cast<u8>(type));
    }
 }

--- a/src/core/file_sys/registered_cache.h
+++ b/src/core/file_sys/registered_cache.h
@@ -67,18 +67,18 @@ public:
    virtual void Refresh() = 0;

    virtual bool HasEntry(u64 title_id, ContentRecordType type) const = 0;
-    bool HasEntry(ContentProviderEntry entry) const;
+    virtual bool HasEntry(ContentProviderEntry entry) const;

    virtual std::optional<u32> GetEntryVersion(u64 title_id) const = 0;

    virtual VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const = 0;
-    VirtualFile GetEntryUnparsed(ContentProviderEntry entry) const;
+    virtual VirtualFile GetEntryUnparsed(ContentProviderEntry entry) const;

    virtual VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const = 0;
-    VirtualFile GetEntryRaw(ContentProviderEntry entry) const;
+    virtual VirtualFile GetEntryRaw(ContentProviderEntry entry) const;

    virtual std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const = 0;
-    std::unique_ptr<NCA> GetEntry(ContentProviderEntry entry) const;
+    virtual std::unique_ptr<NCA> GetEntry(ContentProviderEntry entry) const;

    virtual std::vector<ContentProviderEntry> ListEntries() const;

--- a/src/core/hle/kernel/memory/address_space_info.cpp
+++ b/src/core/hle/kernel/memory/address_space_info.cpp
@@ -96,7 +96,6 @@ u64 AddressSpaceInfo::GetAddressSpaceStart(std::size_t width, Type type) {
        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].address;
    }
    UNREACHABLE();
-    return 0;
 }

 std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, Type type) {
@@ -113,7 +112,6 @@ std::size_t AddressSpaceInfo::GetAddressSpaceSize(std::size_t width, Type type)
        return AddressSpaceInfos[AddressSpaceIndices39Bit[index]].size;
    }
    UNREACHABLE();
-    return 0;
 }

 } // namespace Kernel::Memory
--- a/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp
@@ -11,9 +11,8 @@

 namespace Service::Nvidia::Devices {

-nvhost_nvdec::nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-                           SyncpointManager& syncpoint_manager)
-    : nvhost_nvdec_common(system, std::move(nvmap_dev), syncpoint_manager) {}
+nvhost_nvdec::nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
+    : nvhost_nvdec_common(system, std::move(nvmap_dev)) {}
 nvhost_nvdec::~nvhost_nvdec() = default;

 NvResult nvhost_nvdec::Ioctl1(Ioctl command, const std::vector<u8>& input,
--- a/src/core/hle/service/nvdrv/devices/nvhost_nvdec.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_nvdec.h
@@ -11,8 +11,7 @@ namespace Service::Nvidia::Devices {

 class nvhost_nvdec final : public nvhost_nvdec_common {
 public:
-    explicit nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-                          SyncpointManager& syncpoint_manager);
+    explicit nvhost_nvdec(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
    ~nvhost_nvdec() override;

    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
--- a/src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp
@@ -11,7 +11,6 @@
 #include "core/core.h"
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec_common.h"
 #include "core/hle/service/nvdrv/devices/nvmap.h"
-#include "core/hle/service/nvdrv/syncpoint_manager.h"
 #include "core/memory.h"
 #include "video_core/memory_manager.h"
 #include "video_core/renderer_base.h"
@@ -37,9 +36,8 @@ std::size_t WriteVectors(std::vector<u8>& dst, const std::vector<T>& src, std::s
 }
 } // Anonymous namespace

-nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-                                         SyncpointManager& syncpoint_manager)
-    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)), syncpoint_manager(syncpoint_manager) {}
+nvhost_nvdec_common::nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
+    : nvdevice(system), nvmap_dev(std::move(nvmap_dev)) {}
 nvhost_nvdec_common::~nvhost_nvdec_common() = default;

 NvResult nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) {
@@ -73,15 +71,10 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
    offset = SpliceVectors(input, wait_checks, params.syncpoint_count, offset);
    offset = SpliceVectors(input, fences, params.fence_count, offset);

+    // TODO(ameerj): For async gpu, utilize fences for syncpoint 'max' increment
+
    auto& gpu = system.GPU();
-    if (gpu.UseNvdec()) {
-        for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
-            const SyncptIncr& syncpt_incr = syncpt_increments[i];
-            fences[i].id = syncpt_incr.id;
-            fences[i].value =
-                syncpoint_manager.IncreaseSyncpoint(syncpt_incr.id, syncpt_incr.increments);
-        }
-    }
+
    for (const auto& cmd_buffer : command_buffers) {
        auto object = nvmap_dev->GetObject(cmd_buffer.memory_id);
        ASSERT_OR_EXECUTE(object, return NvResult::InvalidState;);
@@ -96,13 +89,7 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
                                      cmdlist.size() * sizeof(u32));
        gpu.PushCommandBuffer(cmdlist);
    }
-    if (gpu.UseNvdec()) {

-        fences[0].value = syncpoint_manager.IncreaseSyncpoint(fences[0].id, 1);
-
-        Tegra::ChCommandHeaderList cmdlist{{(4 << 28) | fences[0].id}};
-        gpu.PushCommandBuffer(cmdlist);
-    }
    std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
    // Some games expect command_buffers to be written back
    offset = sizeof(IoctlSubmit);
@@ -111,7 +98,6 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
    offset = WriteVectors(output, reloc_shifts, offset);
    offset = WriteVectors(output, syncpt_increments, offset);
    offset = WriteVectors(output, wait_checks, offset);
-    offset = WriteVectors(output, fences, offset);

    return NvResult::Success;
 }
@@ -121,10 +107,9 @@ NvResult nvhost_nvdec_common::GetSyncpoint(const std::vector<u8>& input, std::ve
    std::memcpy(&params, input.data(), sizeof(IoctlGetSyncpoint));
    LOG_DEBUG(Service_NVDRV, "called GetSyncpoint, id={}", params.param);

-    if (device_syncpoints[params.param] == 0 && system.GPU().UseNvdec()) {
-        device_syncpoints[params.param] = syncpoint_manager.AllocateSyncpoint();
-    }
-    params.value = device_syncpoints[params.param];
+    // We found that implementing this causes deadlocks with async gpu, along with degraded
+    // performance. TODO: RE the nvdec async implementation
+    params.value = 0;
    std::memcpy(output.data(), &params, sizeof(IoctlGetSyncpoint));

    return NvResult::Success;
--- a/src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h
@@ -10,16 +10,12 @@
 #include "common/swap.h"
 #include "core/hle/service/nvdrv/devices/nvdevice.h"

-namespace Service::Nvidia {
-class SyncpointManager;
-
-namespace Devices {
+namespace Service::Nvidia::Devices {
 class nvmap;

 class nvhost_nvdec_common : public nvdevice {
 public:
-    explicit nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-                                 SyncpointManager& syncpoint_manager);
+    explicit nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
    ~nvhost_nvdec_common() override;

 protected:
@@ -161,10 +157,8 @@ protected:
    s32_le nvmap_fd{};
    u32_le submit_timeout{};
    std::shared_ptr<nvmap> nvmap_dev;
-    SyncpointManager& syncpoint_manager;
-    std::array<u32, MaxSyncPoints> device_syncpoints{};
+
    // This is expected to be ordered, therefore we must use a map, not unordered_map
    std::map<GPUVAddr, BufferMap> buffer_mappings;
 };
-}; // namespace Devices
-} // namespace Service::Nvidia
+}; // namespace Service::Nvidia::Devices
--- a/src/core/hle/service/nvdrv/devices/nvhost_vic.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_vic.cpp
@@ -10,9 +10,8 @@
 #include "video_core/renderer_base.h"

 namespace Service::Nvidia::Devices {
-nvhost_vic::nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-                       SyncpointManager& syncpoint_manager)
-    : nvhost_nvdec_common(system, std::move(nvmap_dev), syncpoint_manager) {}
+nvhost_vic::nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev)
+    : nvhost_nvdec_common(system, std::move(nvmap_dev)) {}

 nvhost_vic::~nvhost_vic() = default;

--- a/src/core/hle/service/nvdrv/devices/nvhost_vic.h
+++ b/src/core/hle/service/nvdrv/devices/nvhost_vic.h
@@ -7,11 +7,11 @@
 #include "core/hle/service/nvdrv/devices/nvhost_nvdec_common.h"

 namespace Service::Nvidia::Devices {
+class nvmap;

 class nvhost_vic final : public nvhost_nvdec_common {
 public:
-    explicit nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev,
-                        SyncpointManager& syncpoint_manager);
+    explicit nvhost_vic(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
    ~nvhost_vic();

    NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) override;
--- a/src/core/hle/service/nvdrv/nvdrv.cpp
+++ b/src/core/hle/service/nvdrv/nvdrv.cpp
@@ -55,11 +55,9 @@ Module::Module(Core::System& system) : syncpoint_manager{system.GPU()} {
    devices["/dev/nvdisp_disp0"] = std::make_shared<Devices::nvdisp_disp0>(system, nvmap_dev);
    devices["/dev/nvhost-ctrl"] =
        std::make_shared<Devices::nvhost_ctrl>(system, events_interface, syncpoint_manager);
-    devices["/dev/nvhost-nvdec"] =
-        std::make_shared<Devices::nvhost_nvdec>(system, nvmap_dev, syncpoint_manager);
+    devices["/dev/nvhost-nvdec"] = std::make_shared<Devices::nvhost_nvdec>(system, nvmap_dev);
    devices["/dev/nvhost-nvjpg"] = std::make_shared<Devices::nvhost_nvjpg>(system);
-    devices["/dev/nvhost-vic"] =
-        std::make_shared<Devices::nvhost_vic>(system, nvmap_dev, syncpoint_manager);
+    devices["/dev/nvhost-vic"] = std::make_shared<Devices::nvhost_vic>(system, nvmap_dev);
 }

 Module::~Module() = default;
--- a/src/core/hle/service/nvflinger/buffer_queue.cpp
+++ b/src/core/hle/service/nvflinger/buffer_queue.cpp
@@ -26,10 +26,10 @@ void BufferQueue::SetPreallocatedBuffer(u32 slot, const IGBPBuffer& igbp_buffer)
    LOG_WARNING(Service, "Adding graphics buffer {}", slot);

    {
-        std::unique_lock lock{free_buffers_mutex};
+        std::unique_lock lock{queue_mutex};
        free_buffers.push_back(slot);
    }
-    free_buffers_condition.notify_one();
+    condition.notify_one();

    buffers[slot] = {
        .slot = slot,
@@ -48,8 +48,8 @@ std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::Dequeue
                                                                                       u32 height) {
    // Wait for first request before trying to dequeue
    {
-        std::unique_lock lock{free_buffers_mutex};
-        free_buffers_condition.wait(lock, [this] { return !free_buffers.empty() || !is_connect; });
+        std::unique_lock lock{queue_mutex};
+        condition.wait(lock, [this] { return !free_buffers.empty() || !is_connect; });
    }

    if (!is_connect) {
@@ -58,7 +58,7 @@ std::optional<std::pair<u32, Service::Nvidia::MultiFence*>> BufferQueue::Dequeue
        return std::nullopt;
    }

-    std::unique_lock lock{free_buffers_mutex};
+    std::unique_lock lock{queue_mutex};

    auto f_itr = free_buffers.begin();
    auto slot = buffers.size();
@@ -100,7 +100,6 @@ void BufferQueue::QueueBuffer(u32 slot, BufferTransformFlags transform,
    buffers[slot].crop_rect = crop_rect;
    buffers[slot].swap_interval = swap_interval;
    buffers[slot].multi_fence = multi_fence;
-    std::unique_lock lock{queue_sequence_mutex};
    queue_sequence.push_back(slot);
 }

@@ -114,16 +113,15 @@ void BufferQueue::CancelBuffer(u32 slot, const Service::Nvidia::MultiFence& mult
    buffers[slot].swap_interval = 0;

    {
-        std::unique_lock lock{free_buffers_mutex};
+        std::unique_lock lock{queue_mutex};
        free_buffers.push_back(slot);
    }
-    free_buffers_condition.notify_one();
+    condition.notify_one();

    buffer_wait_event.writable->Signal();
 }

 std::optional<std::reference_wrapper<const BufferQueue::Buffer>> BufferQueue::AcquireBuffer() {
-    std::unique_lock lock{queue_sequence_mutex};
    std::size_t buffer_slot = buffers.size();
    // Iterate to find a queued buffer matching the requested slot.
    while (buffer_slot == buffers.size() && !queue_sequence.empty()) {
@@ -149,29 +147,25 @@ void BufferQueue::ReleaseBuffer(u32 slot) {

    buffers[slot].status = Buffer::Status::Free;
    {
-        std::unique_lock lock{free_buffers_mutex};
+        std::unique_lock lock{queue_mutex};
        free_buffers.push_back(slot);
    }
-    free_buffers_condition.notify_one();
+    condition.notify_one();

    buffer_wait_event.writable->Signal();
 }

 void BufferQueue::Connect() {
-    std::unique_lock lock{queue_sequence_mutex};
    queue_sequence.clear();
    is_connect = true;
 }

 void BufferQueue::Disconnect() {
    buffers.fill({});
-    {
-        std::unique_lock lock{queue_sequence_mutex};
-        queue_sequence.clear();
-    }
+    queue_sequence.clear();
    buffer_wait_event.writable->Signal();
    is_connect = false;
-    free_buffers_condition.notify_one();
+    condition.notify_one();
 }

 u32 BufferQueue::Query(QueryType type) {
@@ -180,11 +174,9 @@ u32 BufferQueue::Query(QueryType type) {
    switch (type) {
    case QueryType::NativeWindowFormat:
        return static_cast<u32>(PixelFormat::RGBA8888);
-    case QueryType::NativeWindowWidth:
-    case QueryType::NativeWindowHeight:
-        break;
    }
-    UNIMPLEMENTED_MSG("Unimplemented query type={}", type);
+
+    UNIMPLEMENTED();
    return 0;
 }

--- a/src/core/hle/service/nvflinger/buffer_queue.h
+++ b/src/core/hle/service/nvflinger/buffer_queue.h
@@ -129,10 +129,8 @@ private:
    std::list<u32> queue_sequence;
    Kernel::EventPair buffer_wait_event;

-    std::mutex free_buffers_mutex;
-    std::condition_variable free_buffers_condition;
-
-    std::mutex queue_sequence_mutex;
+    std::mutex queue_mutex;
+    std::condition_variable condition;
 };

 } // namespace Service::NVFlinger
--- a/src/core/hle/service/sockets/sockets_translate.cpp
+++ b/src/core/hle/service/sockets/sockets_translate.cpp
@@ -64,7 +64,6 @@ Network::Type Translate(Type type) {
        return Network::Type::DGRAM;
    default:
        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
-        return Network::Type{};
    }
 }

--- a/src/tests/common/ring_buffer.cpp
+++ b/src/tests/common/ring_buffer.cpp
@@ -20,60 +20,60 @@ TEST_CASE("RingBuffer: Basic Tests", "[common]") {
    for (std::size_t i = 0; i < 4; i++) {
        const char elem = static_cast<char>(i);
        const std::size_t count = buf.Push(&elem, 1);
-        REQUIRE(count == 1U);
+        REQUIRE(count == 1);
    }

-    REQUIRE(buf.Size() == 4U);
+    REQUIRE(buf.Size() == 4);

    // Pushing values into a full ring buffer should fail.
    {
        const char elem = static_cast<char>(42);
        const std::size_t count = buf.Push(&elem, 1);
-        REQUIRE(count == 0U);
+        REQUIRE(count == 0);
    }

-    REQUIRE(buf.Size() == 4U);
+    REQUIRE(buf.Size() == 4);

    // Popping multiple values from a ring buffer with values should succeed.
    {
        const std::vector<char> popped = buf.Pop(2);
-        REQUIRE(popped.size() == 2U);
+        REQUIRE(popped.size() == 2);
        REQUIRE(popped[0] == 0);
        REQUIRE(popped[1] == 1);
    }

-    REQUIRE(buf.Size() == 2U);
+    REQUIRE(buf.Size() == 2);

    // Popping a single value from a ring buffer with values should succeed.
    {
        const std::vector<char> popped = buf.Pop(1);
-        REQUIRE(popped.size() == 1U);
+        REQUIRE(popped.size() == 1);
        REQUIRE(popped[0] == 2);
    }

-    REQUIRE(buf.Size() == 1U);
+    REQUIRE(buf.Size() == 1);

    // Pushing more values than space available should partially suceed.
    {
        std::vector<char> to_push(6);
        std::iota(to_push.begin(), to_push.end(), 88);
        const std::size_t count = buf.Push(to_push);
-        REQUIRE(count == 3U);
+        REQUIRE(count == 3);
    }

-    REQUIRE(buf.Size() == 4U);
+    REQUIRE(buf.Size() == 4);

    // Doing an unlimited pop should pop all values.
    {
        const std::vector<char> popped = buf.Pop();
-        REQUIRE(popped.size() == 4U);
+        REQUIRE(popped.size() == 4);
        REQUIRE(popped[0] == 3);
        REQUIRE(popped[1] == 88);
        REQUIRE(popped[2] == 89);
        REQUIRE(popped[3] == 90);
    }

-    REQUIRE(buf.Size() == 0U);
+    REQUIRE(buf.Size() == 0);
 }

 TEST_CASE("RingBuffer: Threaded Test", "[common]") {
@@ -93,7 +93,7 @@ TEST_CASE("RingBuffer: Threaded Test", "[common]") {
        std::size_t i = 0;
        while (i < count) {
            if (const std::size_t c = buf.Push(&value[0], 1); c > 0) {
-                REQUIRE(c == 1U);
+                REQUIRE(c == 1);
                i++;
                next_value(value);
            } else {
@@ -108,7 +108,7 @@ TEST_CASE("RingBuffer: Threaded Test", "[common]") {
        std::size_t i = 0;
        while (i < count) {
            if (const std::vector<char> v = buf.Pop(1); v.size() > 0) {
-                REQUIRE(v.size() == 2U);
+                REQUIRE(v.size() == 2);
                REQUIRE(v[0] == value[0]);
                REQUIRE(v[1] == value[1]);
                i++;
@@ -123,7 +123,7 @@ TEST_CASE("RingBuffer: Threaded Test", "[common]") {
    producer.join();
    consumer.join();

-    REQUIRE(buf.Size() == 0U);
+    REQUIRE(buf.Size() == 0);
    printf("RingBuffer: Threaded Test: full: %zu, empty: %zu\n", full, empty);
 }

--- a/src/video_core/CMakeLists.txt
+++ b/src/video_core/CMakeLists.txt
@@ -115,6 +115,8 @@ add_library(video_core STATIC
    renderer_vulkan/fixed_pipeline_state.h
    renderer_vulkan/maxwell_to_vk.cpp
    renderer_vulkan/maxwell_to_vk.h
+    renderer_vulkan/nsight_aftermath_tracker.cpp
+    renderer_vulkan/nsight_aftermath_tracker.h
    renderer_vulkan/renderer_vulkan.h
    renderer_vulkan/renderer_vulkan.cpp
    renderer_vulkan/vk_blit_screen.cpp
@@ -129,6 +131,8 @@ add_library(video_core STATIC
    renderer_vulkan/vk_compute_pipeline.h
    renderer_vulkan/vk_descriptor_pool.cpp
    renderer_vulkan/vk_descriptor_pool.h
+    renderer_vulkan/vk_device.cpp
+    renderer_vulkan/vk_device.h
    renderer_vulkan/vk_fence_manager.cpp
    renderer_vulkan/vk_fence_manager.h
    renderer_vulkan/vk_graphics_pipeline.cpp
@@ -253,8 +257,6 @@ add_library(video_core STATIC
    video_core.h
    vulkan_common/vulkan_debug_callback.cpp
    vulkan_common/vulkan_debug_callback.h
-    vulkan_common/vulkan_device.cpp
-    vulkan_common/vulkan_device.h
    vulkan_common/vulkan_instance.cpp
    vulkan_common/vulkan_instance.h
    vulkan_common/vulkan_library.cpp
@@ -263,8 +265,6 @@ add_library(video_core STATIC
    vulkan_common/vulkan_surface.h
    vulkan_common/vulkan_wrapper.cpp
    vulkan_common/vulkan_wrapper.h
-    vulkan_common/nsight_aftermath_tracker.cpp
-    vulkan_common/nsight_aftermath_tracker.h
 )

 create_target_directory_groups(video_core)
--- a/src/video_core/cdma_pusher.cpp
+++ b/src/video_core/cdma_pusher.cpp
@@ -33,7 +33,8 @@ CDmaPusher::CDmaPusher(GPU& gpu_)
    : gpu{gpu_}, nvdec_processor(std::make_shared<Nvdec>(gpu)),
      vic_processor(std::make_unique<Vic>(gpu, nvdec_processor)),
      host1x_processor(std::make_unique<Host1x>(gpu)),
-      sync_manager(std::make_unique<SyncptIncrManager>(gpu)) {}
+      nvdec_sync(std::make_unique<SyncptIncrManager>(gpu)),
+      vic_sync(std::make_unique<SyncptIncrManager>(gpu)) {}

 CDmaPusher::~CDmaPusher() = default;

@@ -109,10 +110,10 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
            const auto cond = static_cast<u32>((data >> 8) & 0xFF);
            if (cond == 0) {
-                sync_manager->Increment(syncpoint_id);
+                nvdec_sync->Increment(syncpoint_id);
            } else {
-                sync_manager->SignalDone(
-                    sync_manager->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id));
+                nvdec_sync->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id);
+                nvdec_sync->SignalDone(syncpoint_id);
            }
            break;
        }
@@ -134,10 +135,10 @@ void CDmaPusher::ExecuteCommand(u32 state_offset, u32 data) {
            const auto syncpoint_id = static_cast<u32>(data & 0xFF);
            const auto cond = static_cast<u32>((data >> 8) & 0xFF);
            if (cond == 0) {
-                sync_manager->Increment(syncpoint_id);
+                vic_sync->Increment(syncpoint_id);
            } else {
-                sync_manager->SignalDone(
-                    sync_manager->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id));
+                vic_sync->IncrementWhenDone(static_cast<u32>(current_class), syncpoint_id);
+                vic_sync->SignalDone(syncpoint_id);
            }
            break;
        }
--- a/src/video_core/cdma_pusher.h
+++ b/src/video_core/cdma_pusher.h
@@ -116,10 +116,12 @@ private:
    void ThiStateWrite(ThiRegisters& state, u32 state_offset, const std::vector<u32>& arguments);

    GPU& gpu;
-    std::shared_ptr<Tegra::Nvdec> nvdec_processor;
-    std::unique_ptr<Tegra::Vic> vic_processor;
-    std::unique_ptr<Tegra::Host1x> host1x_processor;
-    std::unique_ptr<SyncptIncrManager> sync_manager;
+
+    std::shared_ptr<Nvdec> nvdec_processor;
+    std::unique_ptr<Vic> vic_processor;
+    std::unique_ptr<Host1x> host1x_processor;
+    std::unique_ptr<SyncptIncrManager> nvdec_sync;
+    std::unique_ptr<SyncptIncrManager> vic_sync;
    ChClassId current_class{};
    ThiRegisters vic_thi_state{};
    ThiRegisters nvdec_thi_state{};
--- a/src/video_core/command_classes/host1x.cpp
+++ b/src/video_core/command_classes/host1x.cpp
@@ -10,14 +10,22 @@ Tegra::Host1x::Host1x(GPU& gpu_) : gpu(gpu_) {}

 Tegra::Host1x::~Host1x() = default;

-void Tegra::Host1x::ProcessMethod(Method method, u32 argument) {
+void Tegra::Host1x::StateWrite(u32 offset, u32 arguments) {
+    u8* const state_offset = reinterpret_cast<u8*>(&state) + offset * sizeof(u32);
+    std::memcpy(state_offset, &arguments, sizeof(u32));
+}
+
+void Tegra::Host1x::ProcessMethod(Method method, const std::vector<u32>& arguments) {
+    StateWrite(static_cast<u32>(method), arguments[0]);
    switch (method) {
-    case Method::LoadSyncptPayload32:
-        syncpoint_value = argument;
-        break;
    case Method::WaitSyncpt:
+        Execute(arguments[0]);
+        break;
+    case Method::LoadSyncptPayload32:
+        syncpoint_value = arguments[0];
+        break;
    case Method::WaitSyncpt32:
-        Execute(argument);
+        Execute(arguments[0]);
        break;
    default:
        UNIMPLEMENTED_MSG("Host1x method 0x{:X}", static_cast<u32>(method));
@@ -26,5 +34,6 @@ void Tegra::Host1x::ProcessMethod(Method method, u32 argument) {
 }

 void Tegra::Host1x::Execute(u32 data) {
-    gpu.WaitFence(data, syncpoint_value);
+    // This method waits on a valid syncpoint.
+    // TODO: Implement when proper Async is in place
 }
--- a/src/video_core/command_classes/host1x.h
+++ b/src/video_core/command_classes/host1x.h
@@ -14,23 +14,64 @@ class Nvdec;

 class Host1x {
 public:
+    struct Host1xClassRegisters {
+        u32 incr_syncpt{};
+        u32 incr_syncpt_ctrl{};
+        u32 incr_syncpt_error{};
+        INSERT_PADDING_WORDS(5);
+        u32 wait_syncpt{};
+        u32 wait_syncpt_base{};
+        u32 wait_syncpt_incr{};
+        u32 load_syncpt_base{};
+        u32 incr_syncpt_base{};
+        u32 clear{};
+        u32 wait{};
+        u32 wait_with_interrupt{};
+        u32 delay_use{};
+        u32 tick_count_high{};
+        u32 tick_count_low{};
+        u32 tick_ctrl{};
+        INSERT_PADDING_WORDS(23);
+        u32 ind_ctrl{};
+        u32 ind_off2{};
+        u32 ind_off{};
+        std::array<u32, 31> ind_data{};
+        INSERT_PADDING_WORDS(1);
+        u32 load_syncpoint_payload32{};
+        u32 stall_ctrl{};
+        u32 wait_syncpt32{};
+        u32 wait_syncpt_base32{};
+        u32 load_syncpt_base32{};
+        u32 incr_syncpt_base32{};
+        u32 stall_count_high{};
+        u32 stall_count_low{};
+        u32 xref_ctrl{};
+        u32 channel_xref_high{};
+        u32 channel_xref_low{};
+    };
+    static_assert(sizeof(Host1xClassRegisters) == 0x164, "Host1xClassRegisters is an invalid size");
+
    enum class Method : u32 {
-        WaitSyncpt = 0x8,
-        LoadSyncptPayload32 = 0x4e,
-        WaitSyncpt32 = 0x50,
+        WaitSyncpt = offsetof(Host1xClassRegisters, wait_syncpt) / 4,
+        LoadSyncptPayload32 = offsetof(Host1xClassRegisters, load_syncpoint_payload32) / 4,
+        WaitSyncpt32 = offsetof(Host1xClassRegisters, wait_syncpt32) / 4,
    };

    explicit Host1x(GPU& gpu);
    ~Host1x();

    /// Writes the method into the state, Invoke Execute() if encountered
-    void ProcessMethod(Method method, u32 argument);
+    void ProcessMethod(Method method, const std::vector<u32>& arguments);

 private:
    /// For Host1x, execute is waiting on a syncpoint previously written into the state
    void Execute(u32 data);

+    /// Write argument into the provided offset
+    void StateWrite(u32 offset, u32 arguments);
+
    u32 syncpoint_value{};
+    Host1xClassRegisters state{};
    GPU& gpu;
 };

--- a/src/video_core/compatible_formats.cpp
+++ b/src/video_core/compatible_formats.cpp
@@ -10,7 +10,9 @@
 #include "video_core/surface.h"

 namespace VideoCore::Surface {
+
 namespace {
+
 using Table = std::array<std::array<u64, 2>, MaxPixelFormat>;

 // Compatibility table taken from Table 3.X.2 in:
@@ -231,13 +233,10 @@ constexpr Table MakeCopyTable() {
    EnableRange(copy, COPY_CLASS_64_BITS);
    return copy;
 }
+
 } // Anonymous namespace

-bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views) {
-    if (broken_views) {
-        // If format views are broken, only accept formats that are identical.
-        return format_a == format_b;
-    }
+bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b) {
    static constexpr Table TABLE = MakeViewTable();
    return IsSupported(TABLE, format_a, format_b);
 }
--- a/src/video_core/compatible_formats.h
+++ b/src/video_core/compatible_formats.h
@@ -8,7 +8,7 @@

 namespace VideoCore::Surface {

-bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views);
+bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b);

 bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b);

--- a/src/video_core/renderer_opengl/gl_device.cpp
+++ b/src/video_core/renderer_opengl/gl_device.cpp
@@ -208,7 +208,6 @@ Device::Device()

    const bool is_nvidia = vendor == "NVIDIA Corporation";
    const bool is_amd = vendor == "ATI Technologies Inc.";
-    const bool is_intel = vendor == "Intel";

    bool disable_fast_buffer_sub_data = false;
    if (is_nvidia && version == "4.6.0 NVIDIA 443.24") {
@@ -232,7 +231,6 @@ Device::Device()
    has_variable_aoffi = TestVariableAoffi();
    has_component_indexing_bug = is_amd;
    has_precise_bug = TestPreciseBug();
-    has_broken_texture_view_formats = is_amd || is_intel;
    has_nv_viewport_array2 = GLAD_GL_NV_viewport_array2;
    has_vertex_buffer_unified_memory = GLAD_GL_NV_vertex_buffer_unified_memory;
    has_debugging_tool_attached = IsDebugToolAttached(extensions);
@@ -250,8 +248,6 @@ Device::Device()
    LOG_INFO(Render_OpenGL, "Renderer_VariableAOFFI: {}", has_variable_aoffi);
    LOG_INFO(Render_OpenGL, "Renderer_ComponentIndexingBug: {}", has_component_indexing_bug);
    LOG_INFO(Render_OpenGL, "Renderer_PreciseBug: {}", has_precise_bug);
-    LOG_INFO(Render_OpenGL, "Renderer_BrokenTextureViewFormats: {}",
-             has_broken_texture_view_formats);

    if (Settings::values.use_assembly_shaders.GetValue() && !use_assembly_shaders) {
        LOG_ERROR(Render_OpenGL, "Assembly shaders enabled but not supported");
--- a/src/video_core/renderer_opengl/gl_device.h
+++ b/src/video_core/renderer_opengl/gl_device.h
@@ -96,10 +96,6 @@ public:
        return has_precise_bug;
    }

-    bool HasBrokenTextureViewFormats() const {
-        return has_broken_texture_view_formats;
-    }
-
    bool HasFastBufferSubData() const {
        return has_fast_buffer_sub_data;
    }
@@ -141,7 +137,6 @@ private:
    bool has_variable_aoffi{};
    bool has_component_indexing_bug{};
    bool has_precise_bug{};
-    bool has_broken_texture_view_formats{};
    bool has_fast_buffer_sub_data{};
    bool has_nv_viewport_array2{};
    bool has_debugging_tool_attached{};
--- a/src/video_core/renderer_opengl/gl_texture_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp
@@ -61,99 +61,100 @@ struct FormatTuple {
    GLenum internal_format;
    GLenum format = GL_NONE;
    GLenum type = GL_NONE;
+    GLenum store_format = internal_format;
 };

 constexpr std::array<FormatTuple, MaxPixelFormat> FORMAT_TABLE = {{
-    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},                 // A8B8G8R8_UNORM
-    {GL_RGBA8_SNORM, GL_RGBA, GL_BYTE},                               // A8B8G8R8_SNORM
-    {GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE},                            // A8B8G8R8_SINT
-    {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE},                  // A8B8G8R8_UINT
-    {GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5},                     // R5G6B5_UNORM
-    {GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV},                 // B5G6R5_UNORM
-    {GL_RGB5_A1, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV},             // A1R5G5B5_UNORM
-    {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV},           // A2B10G10R10_UNORM
-    {GL_RGB10_A2UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV}, // A2B10G10R10_UINT
-    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV},             // A1B5G5R5_UNORM
-    {GL_R8, GL_RED, GL_UNSIGNED_BYTE},                                // R8_UNORM
-    {GL_R8_SNORM, GL_RED, GL_BYTE},                                   // R8_SNORM
-    {GL_R8I, GL_RED_INTEGER, GL_BYTE},                                // R8_SINT
-    {GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE},                      // R8_UINT
-    {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT},                             // R16G16B16A16_FLOAT
-    {GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT},                          // R16G16B16A16_UNORM
-    {GL_RGBA16_SNORM, GL_RGBA, GL_SHORT},                             // R16G16B16A16_SNORM
-    {GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT},                          // R16G16B16A16_SINT
-    {GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT},                // R16G16B16A16_UINT
-    {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV},     // B10G11R11_FLOAT
-    {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT},                  // R32G32B32A32_UINT
-    {GL_COMPRESSED_RGBA_S3TC_DXT1_EXT},                               // BC1_RGBA_UNORM
-    {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT},                               // BC2_UNORM
-    {GL_COMPRESSED_RGBA_S3TC_DXT5_EXT},                               // BC3_UNORM
-    {GL_COMPRESSED_RED_RGTC1},                                        // BC4_UNORM
-    {GL_COMPRESSED_SIGNED_RED_RGTC1},                                 // BC4_SNORM
-    {GL_COMPRESSED_RG_RGTC2},                                         // BC5_UNORM
-    {GL_COMPRESSED_SIGNED_RG_RGTC2},                                  // BC5_SNORM
-    {GL_COMPRESSED_RGBA_BPTC_UNORM},                                  // BC7_UNORM
-    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT},                          // BC6H_UFLOAT
-    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT},                            // BC6H_SFLOAT
-    {GL_COMPRESSED_RGBA_ASTC_4x4_KHR},                                // ASTC_2D_4X4_UNORM
-    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE},                            // B8G8R8A8_UNORM
-    {GL_RGBA32F, GL_RGBA, GL_FLOAT},                                  // R32G32B32A32_FLOAT
-    {GL_RGBA32I, GL_RGBA_INTEGER, GL_INT},                            // R32G32B32A32_SINT
-    {GL_RG32F, GL_RG, GL_FLOAT},                                      // R32G32_FLOAT
-    {GL_RG32I, GL_RG_INTEGER, GL_INT},                                // R32G32_SINT
-    {GL_R32F, GL_RED, GL_FLOAT},                                      // R32_FLOAT
-    {GL_R16F, GL_RED, GL_HALF_FLOAT},                                 // R16_FLOAT
-    {GL_R16, GL_RED, GL_UNSIGNED_SHORT},                              // R16_UNORM
-    {GL_R16_SNORM, GL_RED, GL_SHORT},                                 // R16_SNORM
-    {GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT},                    // R16_UINT
-    {GL_R16I, GL_RED_INTEGER, GL_SHORT},                              // R16_SINT
-    {GL_RG16, GL_RG, GL_UNSIGNED_SHORT},                              // R16G16_UNORM
-    {GL_RG16F, GL_RG, GL_HALF_FLOAT},                                 // R16G16_FLOAT
-    {GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT},                    // R16G16_UINT
-    {GL_RG16I, GL_RG_INTEGER, GL_SHORT},                              // R16G16_SINT
-    {GL_RG16_SNORM, GL_RG, GL_SHORT},                                 // R16G16_SNORM
-    {GL_RGB32F, GL_RGB, GL_FLOAT},                                    // R32G32B32_FLOAT
-    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},          // A8B8G8R8_SRGB
-    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE},                                // R8G8_UNORM
-    {GL_RG8_SNORM, GL_RG, GL_BYTE},                                   // R8G8_SNORM
-    {GL_RG8I, GL_RG_INTEGER, GL_BYTE},                                // R8G8_SINT
-    {GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE},                      // R8G8_UINT
-    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT},                      // R32G32_UINT
-    {GL_RGB16F, GL_RGBA, GL_HALF_FLOAT},                              // R16G16B16X16_FLOAT
-    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT},                      // R32_UINT
-    {GL_R32I, GL_RED_INTEGER, GL_INT},                                // R32_SINT
-    {GL_COMPRESSED_RGBA_ASTC_8x8_KHR},                                // ASTC_2D_8X8_UNORM
-    {GL_COMPRESSED_RGBA_ASTC_8x5_KHR},                                // ASTC_2D_8X5_UNORM
-    {GL_COMPRESSED_RGBA_ASTC_5x4_KHR},                                // ASTC_2D_5X4_UNORM
-    {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE},                     // B8G8R8A8_UNORM
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT},                         // BC1_RGBA_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT},                         // BC2_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT},                         // BC3_SRGB
-    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM},                            // BC7_SRGB
-    {GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV},               // A4B4G4R4_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR},                        // ASTC_2D_4X4_SRGB
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR},                        // ASTC_2D_8X8_SRGB
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR},                        // ASTC_2D_8X5_SRGB
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR},                        // ASTC_2D_5X4_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_5x5_KHR},                                // ASTC_2D_5X5_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR},                        // ASTC_2D_5X5_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_10x8_KHR},                               // ASTC_2D_10X8_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR},                       // ASTC_2D_10X8_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_6x6_KHR},                                // ASTC_2D_6X6_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR},                        // ASTC_2D_6X6_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_10x10_KHR},                              // ASTC_2D_10X10_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR},                      // ASTC_2D_10X10_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_12x12_KHR},                              // ASTC_2D_12X12_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR},                      // ASTC_2D_12X12_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_8x6_KHR},                                // ASTC_2D_8X6_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR},                        // ASTC_2D_8X6_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_6x5_KHR},                                // ASTC_2D_6X5_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR},                        // ASTC_2D_6X5_SRGB
-    {GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV},                // E5B9G9R9_FLOAT
-    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT},            // D32_FLOAT
-    {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT},    // D16_UNORM
-    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8},    // D24_UNORM_S8_UINT
-    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8},    // S8_UINT_D24_UNORM
+    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},                  // A8B8G8R8_UNORM
+    {GL_RGBA8_SNORM, GL_RGBA, GL_BYTE},                                // A8B8G8R8_SNORM
+    {GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE},                             // A8B8G8R8_SINT
+    {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE},                   // A8B8G8R8_UINT
+    {GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5},                      // R5G6B5_UNORM
+    {GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV},                  // B5G6R5_UNORM
+    {GL_RGB5_A1, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV},              // A1R5G5B5_UNORM
+    {GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV},            // A2B10G10R10_UNORM
+    {GL_RGB10_A2UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV},  // A2B10G10R10_UINT
+    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV},              // A1B5G5R5_UNORM
+    {GL_R8, GL_RED, GL_UNSIGNED_BYTE},                                 // R8_UNORM
+    {GL_R8_SNORM, GL_RED, GL_BYTE},                                    // R8_SNORM
+    {GL_R8I, GL_RED_INTEGER, GL_BYTE},                                 // R8_SINT
+    {GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE},                       // R8_UINT
+    {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT},                              // R16G16B16A16_FLOAT
+    {GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT},                           // R16G16B16A16_UNORM
+    {GL_RGBA16_SNORM, GL_RGBA, GL_SHORT},                              // R16G16B16A16_SNORM
+    {GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT},                           // R16G16B16A16_SINT
+    {GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT},                 // R16G16B16A16_UINT
+    {GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV},      // B10G11R11_FLOAT
+    {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT},                   // R32G32B32A32_UINT
+    {GL_COMPRESSED_RGBA_S3TC_DXT1_EXT},                                // BC1_RGBA_UNORM
+    {GL_COMPRESSED_RGBA_S3TC_DXT3_EXT},                                // BC2_UNORM
+    {GL_COMPRESSED_RGBA_S3TC_DXT5_EXT},                                // BC3_UNORM
+    {GL_COMPRESSED_RED_RGTC1},                                         // BC4_UNORM
+    {GL_COMPRESSED_SIGNED_RED_RGTC1},                                  // BC4_SNORM
+    {GL_COMPRESSED_RG_RGTC2},                                          // BC5_UNORM
+    {GL_COMPRESSED_SIGNED_RG_RGTC2},                                   // BC5_SNORM
+    {GL_COMPRESSED_RGBA_BPTC_UNORM},                                   // BC7_UNORM
+    {GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT},                           // BC6H_UFLOAT
+    {GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT},                             // BC6H_SFLOAT
+    {GL_COMPRESSED_RGBA_ASTC_4x4_KHR},                                 // ASTC_2D_4X4_UNORM
+    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE},                             // B8G8R8A8_UNORM
+    {GL_RGBA32F, GL_RGBA, GL_FLOAT},                                   // R32G32B32A32_FLOAT
+    {GL_RGBA32I, GL_RGBA_INTEGER, GL_INT},                             // R32G32B32A32_SINT
+    {GL_RG32F, GL_RG, GL_FLOAT},                                       // R32G32_FLOAT
+    {GL_RG32I, GL_RG_INTEGER, GL_INT},                                 // R32G32_SINT
+    {GL_R32F, GL_RED, GL_FLOAT},                                       // R32_FLOAT
+    {GL_R16F, GL_RED, GL_HALF_FLOAT},                                  // R16_FLOAT
+    {GL_R16, GL_RED, GL_UNSIGNED_SHORT},                               // R16_UNORM
+    {GL_R16_SNORM, GL_RED, GL_SHORT},                                  // R16_SNORM
+    {GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT},                     // R16_UINT
+    {GL_R16I, GL_RED_INTEGER, GL_SHORT},                               // R16_SINT
+    {GL_RG16, GL_RG, GL_UNSIGNED_SHORT},                               // R16G16_UNORM
+    {GL_RG16F, GL_RG, GL_HALF_FLOAT},                                  // R16G16_FLOAT
+    {GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT},                     // R16G16_UINT
+    {GL_RG16I, GL_RG_INTEGER, GL_SHORT},                               // R16G16_SINT
+    {GL_RG16_SNORM, GL_RG, GL_SHORT},                                  // R16G16_SNORM
+    {GL_RGB32F, GL_RGB, GL_FLOAT},                                     // R32G32B32_FLOAT
+    {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, GL_RGBA8}, // A8B8G8R8_SRGB
+    {GL_RG8, GL_RG, GL_UNSIGNED_BYTE},                                 // R8G8_UNORM
+    {GL_RG8_SNORM, GL_RG, GL_BYTE},                                    // R8G8_SNORM
+    {GL_RG8I, GL_RG_INTEGER, GL_BYTE},                                 // R8G8_SINT
+    {GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE},                       // R8G8_UINT
+    {GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT},                       // R32G32_UINT
+    {GL_RGB16F, GL_RGBA, GL_HALF_FLOAT},                               // R16G16B16X16_FLOAT
+    {GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT},                       // R32_UINT
+    {GL_R32I, GL_RED_INTEGER, GL_INT},                                 // R32_SINT
+    {GL_COMPRESSED_RGBA_ASTC_8x8_KHR},                                 // ASTC_2D_8X8_UNORM
+    {GL_COMPRESSED_RGBA_ASTC_8x5_KHR},                                 // ASTC_2D_8X5_UNORM
+    {GL_COMPRESSED_RGBA_ASTC_5x4_KHR},                                 // ASTC_2D_5X4_UNORM
+    {GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE, GL_RGBA8},            // B8G8R8A8_UNORM
+    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT},                          // BC1_RGBA_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT},                          // BC2_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT},                          // BC3_SRGB
+    {GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM},                             // BC7_SRGB
+    {GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV},                // A4B4G4R4_UNORM
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR},                         // ASTC_2D_4X4_SRGB
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR},                         // ASTC_2D_8X8_SRGB
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR},                         // ASTC_2D_8X5_SRGB
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR},                         // ASTC_2D_5X4_SRGB
+    {GL_COMPRESSED_RGBA_ASTC_5x5_KHR},                                 // ASTC_2D_5X5_UNORM
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR},                         // ASTC_2D_5X5_SRGB
+    {GL_COMPRESSED_RGBA_ASTC_10x8_KHR},                                // ASTC_2D_10X8_UNORM
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR},                        // ASTC_2D_10X8_SRGB
+    {GL_COMPRESSED_RGBA_ASTC_6x6_KHR},                                 // ASTC_2D_6X6_UNORM
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR},                         // ASTC_2D_6X6_SRGB
+    {GL_COMPRESSED_RGBA_ASTC_10x10_KHR},                               // ASTC_2D_10X10_UNORM
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR},                       // ASTC_2D_10X10_SRGB
+    {GL_COMPRESSED_RGBA_ASTC_12x12_KHR},                               // ASTC_2D_12X12_UNORM
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR},                       // ASTC_2D_12X12_SRGB
+    {GL_COMPRESSED_RGBA_ASTC_8x6_KHR},                                 // ASTC_2D_8X6_UNORM
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR},                         // ASTC_2D_8X6_SRGB
+    {GL_COMPRESSED_RGBA_ASTC_6x5_KHR},                                 // ASTC_2D_6X5_UNORM
+    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR},                         // ASTC_2D_6X5_SRGB
+    {GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV},                 // E5B9G9R9_FLOAT
+    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT},             // D32_FLOAT
+    {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT},     // D16_UNORM
+    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8},     // D24_UNORM_S8_UINT
+    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8},     // S8_UINT_D24_UNORM
    {GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL,
     GL_FLOAT_32_UNSIGNED_INT_24_8_REV}, // D32_FLOAT_S8_UINT
 }};
@@ -430,8 +431,6 @@ TextureCacheRuntime::TextureCacheRuntime(const Device& device_, ProgramManager&
            format_properties[i].emplace(format, properties);
        }
    }
-    has_broken_texture_view_formats = device.HasBrokenTextureViewFormats();
-
    null_image_1d_array.Create(GL_TEXTURE_1D_ARRAY);
    null_image_cube_array.Create(GL_TEXTURE_CUBE_MAP_ARRAY);
    null_image_3d.Create(GL_TEXTURE_3D);
@@ -652,11 +651,13 @@ Image::Image(TextureCacheRuntime& runtime, const VideoCommon::ImageInfo& info_,
    if (IsConverted(runtime.device, info.format, info.type)) {
        flags |= ImageFlagBits::Converted;
        gl_internal_format = IsPixelFormatSRGB(info.format) ? GL_SRGB8_ALPHA8 : GL_RGBA8;
+        gl_store_format = GL_RGBA8;
        gl_format = GL_RGBA;
        gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
    } else {
        const auto& tuple = GetFormatTuple(info.format);
        gl_internal_format = tuple.internal_format;
+        gl_store_format = tuple.store_format;
        gl_format = tuple.format;
        gl_type = tuple.type;
    }
@@ -676,23 +677,23 @@ Image::Image(TextureCacheRuntime& runtime, const VideoCommon::ImageInfo& info_,
    }
    switch (target) {
    case GL_TEXTURE_1D_ARRAY:
-        glTextureStorage2D(handle, num_levels, gl_internal_format, width, num_layers);
+        glTextureStorage2D(handle, num_levels, gl_store_format, width, num_layers);
        break;
    case GL_TEXTURE_2D_ARRAY:
-        glTextureStorage3D(handle, num_levels, gl_internal_format, width, height, num_layers);
+        glTextureStorage3D(handle, num_levels, gl_store_format, width, height, num_layers);
        break;
    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: {
        // TODO: Where should 'fixedsamplelocations' come from?
        const auto [samples_x, samples_y] = SamplesLog2(info.num_samples);
-        glTextureStorage3DMultisample(handle, num_samples, gl_internal_format, width >> samples_x,
+        glTextureStorage3DMultisample(handle, num_samples, gl_store_format, width >> samples_x,
                                      height >> samples_y, num_layers, GL_FALSE);
        break;
    }
    case GL_TEXTURE_RECTANGLE:
-        glTextureStorage2D(handle, num_levels, gl_internal_format, width, height);
+        glTextureStorage2D(handle, num_levels, gl_store_format, width, height);
        break;
    case GL_TEXTURE_3D:
-        glTextureStorage3D(handle, num_levels, gl_internal_format, width, height, depth);
+        glTextureStorage3D(handle, num_levels, gl_store_format, width, height, depth);
        break;
    case GL_TEXTURE_BUFFER:
        buffer.Create();
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -96,10 +96,6 @@ public:

    FormatProperties FormatInfo(VideoCommon::ImageType type, GLenum internal_format) const;

-    bool HasBrokenTextureViewFormats() const noexcept {
-        return has_broken_texture_view_formats;
-    }
-
 private:
    struct StagingBuffers {
        explicit StagingBuffers(GLenum storage_flags_, GLenum map_flags_);
@@ -124,7 +120,6 @@ private:
    UtilShaders util_shaders;

    std::array<std::unordered_map<GLenum, FormatProperties>, 3> format_properties;
-    bool has_broken_texture_view_formats = false;

    StagingBuffers upload_buffers{GL_MAP_WRITE_BIT, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT};
    StagingBuffers download_buffers{GL_MAP_READ_BIT, GL_MAP_READ_BIT};
@@ -170,6 +165,7 @@ private:
    OGLTextureView store_view;
    OGLBuffer buffer;
    GLenum gl_internal_format = GL_NONE;
+    GLenum gl_store_format = GL_NONE;
    GLenum gl_format = GL_NONE;
    GLenum gl_type = GL_NONE;
 };
--- 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 {
@@ -225,7 +225,7 @@ constexpr std::array<VkPipelineShaderStageCreateInfo, 2> MakeStages(
    };
 }

-void UpdateOneTextureDescriptorSet(const Device& device, VkDescriptorSet descriptor_set,
+void UpdateOneTextureDescriptorSet(const VKDevice& device, VkDescriptorSet descriptor_set,
                                   VkSampler sampler, VkImageView image_view) {
    const VkDescriptorImageInfo image_info{
        .sampler = sampler,
@@ -247,7 +247,7 @@ void UpdateOneTextureDescriptorSet(const Device& device, VkDescriptorSet descrip
    device.GetLogical().UpdateDescriptorSets(write_descriptor_set, nullptr);
 }

-void UpdateTwoTexturesDescriptorSet(const Device& device, VkDescriptorSet descriptor_set,
+void UpdateTwoTexturesDescriptorSet(const VKDevice& device, VkDescriptorSet descriptor_set,
                                    VkSampler sampler, VkImageView image_view_0,
                                    VkImageView image_view_1) {
    const VkDescriptorImageInfo image_info_0{
@@ -326,7 +326,7 @@ void BindBlitState(vk::CommandBuffer cmdbuf, VkPipelineLayout layout,

 } // Anonymous namespace

-BlitImageHelper::BlitImageHelper(const Device& device_, VKScheduler& scheduler_,
+BlitImageHelper::BlitImageHelper(const VKDevice& device_, VKScheduler& scheduler_,
                                 StateTracker& state_tracker_, VKDescriptorPool& descriptor_pool)
    : device{device_}, scheduler{scheduler_}, state_tracker{state_tracker_},
      one_texture_set_layout(device.GetLogical().CreateDescriptorSetLayout(
--- a/src/video_core/renderer_vulkan/blit_image.h
+++ b/src/video_core/renderer_vulkan/blit_image.h
@@ -15,11 +15,12 @@ namespace Vulkan {

 using VideoCommon::Offset2D;

-class Device;
+class VKDevice;
+class VKScheduler;
+class StateTracker;
+
 class Framebuffer;
 class ImageView;
-class StateTracker;
-class VKScheduler;

 struct BlitImagePipelineKey {
    constexpr auto operator<=>(const BlitImagePipelineKey&) const noexcept = default;
@@ -30,7 +31,7 @@ struct BlitImagePipelineKey {

 class BlitImageHelper {
 public:
-    explicit BlitImageHelper(const Device& device, VKScheduler& scheduler,
+    explicit BlitImageHelper(const VKDevice& device, VKScheduler& scheduler,
                             StateTracker& state_tracker, VKDescriptorPool& descriptor_pool);
    ~BlitImageHelper();

@@ -66,7 +67,7 @@ private:

    void ConvertColorToDepthPipeline(vk::Pipeline& pipeline, VkRenderPass renderpass);

-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
    StateTracker& state_tracker;

--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
@@ -76,7 +76,7 @@ void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_sta
            regs.instanced_arrays.IsInstancingEnabled(index) ? regs.vertex_array[index].divisor : 0;
    }

-    for (size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
+    for (std::size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
        const auto& input = regs.vertex_attrib_format[index];
        auto& attribute = attributes[index];
        attribute.raw = 0;
@@ -85,7 +85,6 @@ void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_sta
        attribute.offset.Assign(input.offset);
        attribute.type.Assign(static_cast<u32>(input.type.Value()));
        attribute.size.Assign(static_cast<u32>(input.size.Value()));
-        attribute.binding_index_enabled.Assign(regs.vertex_array[index].IsEnabled() ? 1 : 0);
    }

    for (std::size_t index = 0; index < std::size(attachments); ++index) {
@@ -173,9 +172,14 @@ void FixedPipelineState::DynamicState::Fill(const Maxwell& regs) {
    depth_test_func.Assign(PackComparisonOp(regs.depth_test_func));
    cull_face.Assign(PackCullFace(regs.cull_face));
    cull_enable.Assign(regs.cull_test_enabled != 0 ? 1 : 0);
-    std::ranges::transform(regs.vertex_array, vertex_strides.begin(), [](const auto& array) {
-        return static_cast<u16>(array.stride.Value());
-    });
+
+    for (std::size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
+        const auto& input = regs.vertex_array[index];
+        VertexBinding& binding = vertex_bindings[index];
+        binding.raw = 0;
+        binding.enabled.Assign(input.IsEnabled() ? 1 : 0);
+        binding.stride.Assign(static_cast<u16>(input.stride.Value()));
+    }
 }

 std::size_t FixedPipelineState::Hash() const noexcept {
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.h
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.h
@@ -96,8 +96,6 @@ struct FixedPipelineState {
        BitField<6, 14, u32> offset;
        BitField<20, 3, u32> type;
        BitField<23, 6, u32> size;
-        // Not really an element of a vertex attribute, but it can be packed here
-        BitField<29, 1, u32> binding_index_enabled;

        constexpr Maxwell::VertexAttribute::Type Type() const noexcept {
            return static_cast<Maxwell::VertexAttribute::Type>(type.Value());
@@ -132,6 +130,12 @@ struct FixedPipelineState {
        }
    };

+    union VertexBinding {
+        u16 raw;
+        BitField<0, 12, u16> stride;
+        BitField<12, 1, u16> enabled;
+    };
+
    struct DynamicState {
        union {
            u32 raw1;
@@ -149,8 +153,7 @@ struct FixedPipelineState {
            BitField<0, 2, u32> cull_face;
            BitField<2, 1, u32> cull_enable;
        };
-        // Vertex stride is a 12 bits value, we have 4 bits to spare per element
-        std::array<u16, Maxwell::NumVertexArrays> vertex_strides;
+        std::array<VertexBinding, Maxwell::NumVertexArrays> vertex_bindings;

        void Fill(const Maxwell& regs);

--- 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 {
@@ -47,7 +47,7 @@ VkSamplerMipmapMode MipmapMode(Tegra::Texture::TextureMipmapFilter mipmap_filter
    return {};
 }

-VkSamplerAddressMode WrapMode(const Device& device, Tegra::Texture::WrapMode wrap_mode,
+VkSamplerAddressMode WrapMode(const VKDevice& device, Tegra::Texture::WrapMode wrap_mode,
                              Tegra::Texture::TextureFilter filter) {
    switch (wrap_mode) {
    case Tegra::Texture::WrapMode::Wrap:
@@ -222,7 +222,7 @@ constexpr bool IsZetaFormat(PixelFormat pixel_format) {

 } // Anonymous namespace

-FormatInfo SurfaceFormat(const Device& device, FormatType format_type, PixelFormat pixel_format) {
+FormatInfo SurfaceFormat(const VKDevice& device, FormatType format_type, PixelFormat pixel_format) {
    ASSERT(static_cast<std::size_t>(pixel_format) < std::size(tex_format_tuples));

    auto tuple = tex_format_tuples[static_cast<std::size_t>(pixel_format)];
@@ -280,7 +280,7 @@ VkShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage) {
    return {};
 }

-VkPrimitiveTopology PrimitiveTopology([[maybe_unused]] const Device& device,
+VkPrimitiveTopology PrimitiveTopology([[maybe_unused]] const VKDevice& device,
                                      Maxwell::PrimitiveTopology topology) {
    switch (topology) {
    case Maxwell::PrimitiveTopology::Points:
@@ -526,7 +526,7 @@ VkCompareOp ComparisonOp(Maxwell::ComparisonOp comparison) {
    return {};
 }

-VkIndexType IndexFormat(const Device& device, Maxwell::IndexFormat index_format) {
+VkIndexType IndexFormat(const VKDevice& device, Maxwell::IndexFormat index_format) {
    switch (index_format) {
    case Maxwell::IndexFormat::UnsignedByte:
        if (!device.IsExtIndexTypeUint8Supported()) {
--- 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 {
@@ -22,7 +22,7 @@ VkFilter Filter(Tegra::Texture::TextureFilter filter);

 VkSamplerMipmapMode MipmapMode(Tegra::Texture::TextureMipmapFilter mipmap_filter);

-VkSamplerAddressMode WrapMode(const Device& device, Tegra::Texture::WrapMode wrap_mode,
+VkSamplerAddressMode WrapMode(const VKDevice& device, Tegra::Texture::WrapMode wrap_mode,
                              Tegra::Texture::TextureFilter filter);

 VkCompareOp DepthCompareFunction(Tegra::Texture::DepthCompareFunc depth_compare_func);
@@ -35,17 +35,17 @@ struct FormatInfo {
    bool storage;
 };

-FormatInfo SurfaceFormat(const Device& device, FormatType format_type, PixelFormat pixel_format);
+FormatInfo SurfaceFormat(const VKDevice& device, FormatType format_type, PixelFormat pixel_format);

 VkShaderStageFlagBits ShaderStage(Tegra::Engines::ShaderType stage);

-VkPrimitiveTopology PrimitiveTopology(const Device& device, Maxwell::PrimitiveTopology topology);
+VkPrimitiveTopology PrimitiveTopology(const VKDevice& device, Maxwell::PrimitiveTopology topology);

 VkFormat VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttribute::Size size);

 VkCompareOp ComparisonOp(Maxwell::ComparisonOp comparison);

-VkIndexType IndexFormat(const Device& device, Maxwell::IndexFormat index_format);
+VkIndexType IndexFormat(const VKDevice& device, Maxwell::IndexFormat index_format);

 VkStencilOp StencilOp(Maxwell::StencilOp stencil_op);

--- a/src/video_core/renderer_vulkan/nsight_aftermath_tracker.cpp
+++ b/src/video_core/renderer_vulkan/nsight_aftermath_tracker.cpp
@@ -32,11 +32,20 @@ namespace Vulkan {

 static constexpr char AFTERMATH_LIB_NAME[] = "GFSDK_Aftermath_Lib.x64.dll";

-NsightAftermathTracker::NsightAftermathTracker() {
+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;
+        return false;
    }
+
    if (!dl.GetSymbol("GFSDK_Aftermath_DisableGpuCrashDumps",
                      &GFSDK_Aftermath_DisableGpuCrashDumps) ||
        !dl.GetSymbol("GFSDK_Aftermath_EnableGpuCrashDumps",
@@ -55,28 +64,27 @@ NsightAftermathTracker::NsightAftermathTracker() {
        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));
+    (void)Common::FS::DeleteDirRecursively(dump_dir);
    if (!Common::FS::CreateDir(dump_dir)) {
        LOG_ERROR(Render_Vulkan, "Failed to create Nsight Aftermath dump directory");
-        return;
+        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;
+        return false;
    }
-    LOG_INFO(Render_Vulkan, "Nsight Aftermath dump directory is \"{}\"", dump_dir);
-    initialized = true;
-}

-NsightAftermathTracker::~NsightAftermathTracker() {
-    if (initialized) {
-        (void)GFSDK_Aftermath_DisableGpuCrashDumps();
-    }
+    LOG_INFO(Render_Vulkan, "Nsight Aftermath dump directory is \"{}\"", dump_dir);
+
+    initialized = true;
+    return true;
 }

 void NsightAftermathTracker::SaveShader(const std::vector<u32>& spirv) const {
--- a/src/video_core/renderer_vulkan/nsight_aftermath_tracker.h
+++ b/src/video_core/renderer_vulkan/nsight_aftermath_tracker.h
@@ -34,6 +34,8 @@ public:
    NsightAftermathTracker(NsightAftermathTracker&&) = delete;
    NsightAftermathTracker& operator=(NsightAftermathTracker&&) = delete;

+    bool Initialize();
+
    void SaveShader(const std::vector<u32>& spirv) const;

 private:
@@ -76,6 +78,9 @@ private:
 #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

--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
@@ -22,6 +22,7 @@
 #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"
@@ -29,7 +30,6 @@
 #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"
@@ -42,7 +42,7 @@ std::string GetReadableVersion(u32 version) {
                       VK_VERSION_PATCH(version));
 }

-std::string GetDriverVersion(const Device& device) {
+std::string GetDriverVersion(const VKDevice& device) {
    // Extracted from
    // https://github.com/SaschaWillems/vulkan.gpuinfo.org/blob/5dddea46ea1120b0df14eef8f15ff8e318e35462/functions.php#L308-L314
    const u32 version = device.GetDriverVersion();
@@ -184,7 +184,7 @@ void RendererVulkan::InitializeDevice() {
        throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
    }
    const vk::PhysicalDevice physical_device(devices[static_cast<size_t>(device_index)], dld);
-    device = std::make_unique<Device>(*instance, physical_device, *surface, dld);
+    device = std::make_unique<VKDevice>(*instance, physical_device, *surface, dld);
 }

 void RendererVulkan::Report() const {
--- a/src/video_core/renderer_vulkan/renderer_vulkan.h
+++ b/src/video_core/renderer_vulkan/renderer_vulkan.h
@@ -27,9 +27,9 @@ class GPU;

 namespace Vulkan {

-class Device;
 class StateTracker;
 class VKBlitScreen;
+class VKDevice;
 class VKMemoryManager;
 class VKSwapchain;
 class VKScheduler;
@@ -74,7 +74,7 @@ private:
    VKScreenInfo screen_info;

    vk::DebugUtilsMessenger debug_callback;
-    std::unique_ptr<Device> device;
+    std::unique_ptr<VKDevice> device;
    std::unique_ptr<VKMemoryManager> memory_manager;
    std::unique_ptr<StateTracker> state_tracker;
    std::unique_ptr<VKScheduler> scheduler;
--- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
@@ -21,6 +21,7 @@
 #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"
@@ -28,7 +29,6 @@
 #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 {
@@ -114,7 +114,7 @@ struct VKBlitScreen::BufferData {

 VKBlitScreen::VKBlitScreen(Core::Memory::Memory& cpu_memory_,
                           Core::Frontend::EmuWindow& render_window_,
-                           VideoCore::RasterizerInterface& rasterizer_, const Device& device_,
+                           VideoCore::RasterizerInterface& rasterizer_, const VKDevice& device_,
                           VKMemoryManager& memory_manager_, VKSwapchain& swapchain_,
                           VKScheduler& scheduler_, const VKScreenInfo& screen_info_)
    : cpu_memory{cpu_memory_}, render_window{render_window_}, rasterizer{rasterizer_},
--- a/src/video_core/renderer_vulkan/vk_blit_screen.h
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.h
@@ -33,8 +33,8 @@ namespace Vulkan {

 struct ScreenInfo;

-class Device;
 class RasterizerVulkan;
+class VKDevice;
 class VKScheduler;
 class VKSwapchain;

@@ -42,7 +42,7 @@ class VKBlitScreen final {
 public:
    explicit VKBlitScreen(Core::Memory::Memory& cpu_memory,
                          Core::Frontend::EmuWindow& render_window,
-                          VideoCore::RasterizerInterface& rasterizer, const Device& device,
+                          VideoCore::RasterizerInterface& rasterizer, const VKDevice& device,
                          VKMemoryManager& memory_manager, VKSwapchain& swapchain,
                          VKScheduler& scheduler, const VKScreenInfo& screen_info);
    ~VKBlitScreen();
@@ -85,7 +85,7 @@ private:
    Core::Memory::Memory& cpu_memory;
    Core::Frontend::EmuWindow& render_window;
    VideoCore::RasterizerInterface& rasterizer;
-    const Device& device;
+    const VKDevice& device;
    VKMemoryManager& memory_manager;
    VKSwapchain& swapchain;
    VKScheduler& scheduler;
--- 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 {
@@ -34,13 +34,13 @@ constexpr VkAccessFlags UPLOAD_ACCESS_BARRIERS =
 constexpr VkAccessFlags TRANSFORM_FEEDBACK_WRITE_ACCESS =
    VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT | VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;

-std::unique_ptr<VKStreamBuffer> CreateStreamBuffer(const Device& device, VKScheduler& scheduler) {
+std::unique_ptr<VKStreamBuffer> CreateStreamBuffer(const VKDevice& device, VKScheduler& scheduler) {
    return std::make_unique<VKStreamBuffer>(device, scheduler);
 }

 } // Anonymous namespace

-Buffer::Buffer(const Device& device_, VKMemoryManager& memory_manager, VKScheduler& scheduler_,
+Buffer::Buffer(const VKDevice& device_, VKMemoryManager& memory_manager, VKScheduler& scheduler_,
               VKStagingBufferPool& staging_pool_, VAddr cpu_addr_, std::size_t size_)
    : BufferBlock{cpu_addr_, size_}, device{device_}, scheduler{scheduler_}, staging_pool{
                                                                                 staging_pool_} {
@@ -168,7 +168,7 @@ void Buffer::CopyFrom(const Buffer& src, std::size_t src_offset, std::size_t dst

 VKBufferCache::VKBufferCache(VideoCore::RasterizerInterface& rasterizer_,
                             Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
-                             const Device& device_, VKMemoryManager& memory_manager_,
+                             const VKDevice& device_, VKMemoryManager& memory_manager_,
                             VKScheduler& scheduler_, VKStreamBuffer& stream_buffer_,
                             VKStagingBufferPool& staging_pool_)
    : VideoCommon::BufferCache<Buffer, VkBuffer, VKStreamBuffer>{rasterizer_, gpu_memory_,
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.h
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.h
@@ -15,13 +15,13 @@

 namespace Vulkan {

-class Device;
+class VKDevice;
 class VKMemoryManager;
 class VKScheduler;

 class Buffer final : public VideoCommon::BufferBlock {
 public:
-    explicit Buffer(const Device& device, VKMemoryManager& memory_manager, VKScheduler& scheduler,
+    explicit Buffer(const VKDevice& device, VKMemoryManager& memory_manager, VKScheduler& scheduler,
                    VKStagingBufferPool& staging_pool, VAddr cpu_addr_, std::size_t size_);
    ~Buffer();

@@ -41,7 +41,7 @@ public:
    }

 private:
-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
    VKStagingBufferPool& staging_pool;

@@ -52,7 +52,7 @@ class VKBufferCache final : public VideoCommon::BufferCache<Buffer, VkBuffer, VK
 public:
    explicit VKBufferCache(VideoCore::RasterizerInterface& rasterizer,
                           Tegra::MemoryManager& gpu_memory, Core::Memory::Memory& cpu_memory,
-                           const Device& device, VKMemoryManager& memory_manager,
+                           const VKDevice& device, VKMemoryManager& memory_manager,
                           VKScheduler& scheduler, VKStreamBuffer& stream_buffer,
                           VKStagingBufferPool& staging_pool);
    ~VKBufferCache();
@@ -63,7 +63,7 @@ protected:
    std::shared_ptr<Buffer> CreateBlock(VAddr cpu_addr, std::size_t size) override;

 private:
-    const Device& device;
+    const VKDevice& device;
    VKMemoryManager& memory_manager;
    VKScheduler& scheduler;
    VKStagingBufferPool& staging_pool;
--- 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/vulkan_common/vulkan_device.h"
+#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"

 namespace Vulkan {
@@ -17,7 +17,7 @@ struct CommandPool::Pool {
    vk::CommandBuffers cmdbufs;
 };

-CommandPool::CommandPool(MasterSemaphore& master_semaphore_, const Device& device_)
+CommandPool::CommandPool(MasterSemaphore& master_semaphore_, const VKDevice& device_)
    : ResourcePool(master_semaphore_, COMMAND_BUFFER_POOL_SIZE), device{device_} {}

 CommandPool::~CommandPool() = default;
--- a/src/video_core/renderer_vulkan/vk_command_pool.h
+++ b/src/video_core/renderer_vulkan/vk_command_pool.h
@@ -12,12 +12,12 @@

 namespace Vulkan {

-class Device;
 class MasterSemaphore;
+class VKDevice;

 class CommandPool final : public ResourcePool {
 public:
-    explicit CommandPool(MasterSemaphore& master_semaphore_, const Device& device_);
+    explicit CommandPool(MasterSemaphore& master_semaphore_, const VKDevice& device_);
    ~CommandPool() override;

    void Allocate(size_t begin, size_t end) override;
@@ -27,7 +27,7 @@ public:
 private:
    struct Pool;

-    const Device& device;
+    const VKDevice& device;
    std::vector<Pool> pools;
 };

--- 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 {
@@ -86,7 +86,7 @@ VkDescriptorUpdateTemplateEntryKHR BuildInputOutputDescriptorUpdateTemplate() {

 } // Anonymous namespace

-VKComputePass::VKComputePass(const Device& device, VKDescriptorPool& descriptor_pool,
+VKComputePass::VKComputePass(const VKDevice& device, VKDescriptorPool& descriptor_pool,
                             vk::Span<VkDescriptorSetLayoutBinding> bindings,
                             vk::Span<VkDescriptorUpdateTemplateEntryKHR> templates,
                             vk::Span<VkPushConstantRange> push_constants,
@@ -162,7 +162,7 @@ VkDescriptorSet VKComputePass::CommitDescriptorSet(
    return set;
 }

-QuadArrayPass::QuadArrayPass(const Device& device_, VKScheduler& scheduler_,
+QuadArrayPass::QuadArrayPass(const VKDevice& device_, VKScheduler& scheduler_,
                             VKDescriptorPool& descriptor_pool_,
                             VKStagingBufferPool& staging_buffer_pool_,
                             VKUpdateDescriptorQueue& update_descriptor_queue_)
@@ -211,7 +211,7 @@ std::pair<VkBuffer, VkDeviceSize> QuadArrayPass::Assemble(u32 num_vertices, u32
    return {*buffer.handle, 0};
 }

-Uint8Pass::Uint8Pass(const Device& device, VKScheduler& scheduler_,
+Uint8Pass::Uint8Pass(const VKDevice& device, VKScheduler& scheduler_,
                     VKDescriptorPool& descriptor_pool, VKStagingBufferPool& staging_buffer_pool_,
                     VKUpdateDescriptorQueue& update_descriptor_queue_)
    : VKComputePass(device, descriptor_pool, BuildInputOutputDescriptorSetBindings(),
@@ -255,7 +255,7 @@ std::pair<VkBuffer, u64> Uint8Pass::Assemble(u32 num_vertices, VkBuffer src_buff
    return {*buffer.handle, 0};
 }

-QuadIndexedPass::QuadIndexedPass(const Device& device_, VKScheduler& scheduler_,
+QuadIndexedPass::QuadIndexedPass(const VKDevice& device_, VKScheduler& scheduler_,
                                 VKDescriptorPool& descriptor_pool_,
                                 VKStagingBufferPool& staging_buffer_pool_,
                                 VKUpdateDescriptorQueue& update_descriptor_queue_)
--- a/src/video_core/renderer_vulkan/vk_compute_pass.h
+++ b/src/video_core/renderer_vulkan/vk_compute_pass.h
@@ -15,14 +15,14 @@

 namespace Vulkan {

-class Device;
+class VKDevice;
 class VKScheduler;
 class VKStagingBufferPool;
 class VKUpdateDescriptorQueue;

 class VKComputePass {
 public:
-    explicit VKComputePass(const Device& device, VKDescriptorPool& descriptor_pool,
+    explicit VKComputePass(const VKDevice& device, VKDescriptorPool& descriptor_pool,
                           vk::Span<VkDescriptorSetLayoutBinding> bindings,
                           vk::Span<VkDescriptorUpdateTemplateEntryKHR> templates,
                           vk::Span<VkPushConstantRange> push_constants, std::span<const u32> code);
@@ -43,7 +43,7 @@ private:

 class QuadArrayPass final : public VKComputePass {
 public:
-    explicit QuadArrayPass(const Device& device_, VKScheduler& scheduler_,
+    explicit QuadArrayPass(const VKDevice& device_, VKScheduler& scheduler_,
                           VKDescriptorPool& descriptor_pool_,
                           VKStagingBufferPool& staging_buffer_pool_,
                           VKUpdateDescriptorQueue& update_descriptor_queue_);
@@ -59,7 +59,7 @@ private:

 class Uint8Pass final : public VKComputePass {
 public:
-    explicit Uint8Pass(const Device& device_, VKScheduler& scheduler_,
+    explicit Uint8Pass(const VKDevice& device_, VKScheduler& scheduler_,
                       VKDescriptorPool& descriptor_pool_,
                       VKStagingBufferPool& staging_buffer_pool_,
                       VKUpdateDescriptorQueue& update_descriptor_queue_);
@@ -75,7 +75,7 @@ private:

 class QuadIndexedPass final : public VKComputePass {
 public:
-    explicit QuadIndexedPass(const Device& device_, VKScheduler& scheduler_,
+    explicit QuadIndexedPass(const VKDevice& device_, VKScheduler& scheduler_,
                             VKDescriptorPool& descriptor_pool_,
                             VKStagingBufferPool& staging_buffer_pool_,
                             VKUpdateDescriptorQueue& update_descriptor_queue_);
--- a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
@@ -6,16 +6,16 @@

 #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 {

-VKComputePipeline::VKComputePipeline(const Device& device_, VKScheduler& scheduler_,
+VKComputePipeline::VKComputePipeline(const VKDevice& device_, VKScheduler& scheduler_,
                                     VKDescriptorPool& descriptor_pool_,
                                     VKUpdateDescriptorQueue& update_descriptor_queue_,
                                     const SPIRVShader& shader_)
--- a/src/video_core/renderer_vulkan/vk_compute_pipeline.h
+++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.h
@@ -11,13 +11,13 @@

 namespace Vulkan {

-class Device;
+class VKDevice;
 class VKScheduler;
 class VKUpdateDescriptorQueue;

 class VKComputePipeline final {
 public:
-    explicit VKComputePipeline(const Device& device_, VKScheduler& scheduler_,
+    explicit VKComputePipeline(const VKDevice& device_, VKScheduler& scheduler_,
                               VKDescriptorPool& descriptor_pool_,
                               VKUpdateDescriptorQueue& update_descriptor_queue_,
                               const SPIRVShader& shader_);
@@ -48,7 +48,7 @@ private:

    vk::Pipeline CreatePipeline() const;

-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
    ShaderEntries entries;

--- 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 {
@@ -32,7 +32,7 @@ void DescriptorAllocator::Allocate(std::size_t begin, std::size_t end) {
    descriptors_allocations.push_back(descriptor_pool.AllocateDescriptors(layout, end - begin));
 }

-VKDescriptorPool::VKDescriptorPool(const Device& device_, VKScheduler& scheduler)
+VKDescriptorPool::VKDescriptorPool(const VKDevice& device_, VKScheduler& scheduler)
    : device{device_}, master_semaphore{scheduler.GetMasterSemaphore()}, active_pool{
                                                                             AllocateNewPool()} {}

--- a/src/video_core/renderer_vulkan/vk_descriptor_pool.h
+++ b/src/video_core/renderer_vulkan/vk_descriptor_pool.h
@@ -11,7 +11,7 @@

 namespace Vulkan {

-class Device;
+class VKDevice;
 class VKDescriptorPool;
 class VKScheduler;

@@ -39,7 +39,7 @@ class VKDescriptorPool final {
    friend DescriptorAllocator;

 public:
-    explicit VKDescriptorPool(const Device& device, VKScheduler& scheduler);
+    explicit VKDescriptorPool(const VKDevice& device, VKScheduler& scheduler);
    ~VKDescriptorPool();

    VKDescriptorPool(const VKDescriptorPool&) = delete;
@@ -50,7 +50,7 @@ private:

    vk::DescriptorSets AllocateDescriptors(VkDescriptorSetLayout layout, std::size_t count);

-    const Device& device;
+    const VKDevice& device;
    MasterSemaphore& master_semaphore;

    std::vector<vk::DescriptorPool> pools;
--- a/src/video_core/vulkan_common/vulkan_device.cpp
+++ b/src/video_core/vulkan_common/vulkan_device.cpp
@@ -13,8 +13,7 @@

 #include "common/assert.h"
 #include "core/settings.h"
-#include "video_core/vulkan_common/nsight_aftermath_tracker.h"
-#include "video_core/vulkan_common/vulkan_device.h"
+#include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"

 namespace Vulkan {
@@ -207,8 +206,8 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(

 } // Anonymous namespace

-Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR surface,
-               const vk::InstanceDispatch& dld_)
+VKDevice::VKDevice(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();
@@ -413,7 +412,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR

    VkDeviceDiagnosticsConfigCreateInfoNV diagnostics_nv;
    if (nv_device_diagnostics_config) {
-        nsight_aftermath_tracker = std::make_unique<NsightAftermathTracker>();
+        nsight_aftermath_tracker.Initialize();

        diagnostics_nv = {
            .sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
@@ -450,10 +449,10 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
    use_asynchronous_shaders = Settings::values.use_asynchronous_shaders.GetValue();
 }

-Device::~Device() = default;
+VKDevice::~VKDevice() = default;

-VkFormat Device::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
-                                    FormatType format_type) const {
+VkFormat VKDevice::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
+                                      FormatType format_type) const {
    if (IsFormatSupported(wanted_format, wanted_usage, format_type)) {
        return wanted_format;
    }
@@ -484,20 +483,18 @@ VkFormat Device::GetSupportedFormat(VkFormat wanted_format, VkFormatFeatureFlags
    return wanted_format;
 }

-void Device::ReportLoss() const {
-    LOG_CRITICAL(Render_Vulkan, "Device loss occured!");
+void VKDevice::ReportLoss() const {
+    LOG_CRITICAL(Render_Vulkan, "Device loss occurred!");

    // 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 {
-    if (nsight_aftermath_tracker) {
-        nsight_aftermath_tracker->SaveShader(spirv);
-    }
+void VKDevice::SaveShader(const std::vector<u32>& spirv) const {
+    nsight_aftermath_tracker.SaveShader(spirv);
 }

-bool Device::IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) const {
+bool VKDevice::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,
@@ -531,7 +528,7 @@ bool Device::IsOptimalAstcSupported(const VkPhysicalDeviceFeatures& features) co
    return true;
 }

-bool Device::TestDepthStencilBlits() const {
+bool VKDevice::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) {
@@ -541,8 +538,8 @@ bool Device::TestDepthStencilBlits() const {
           test_features(format_properties.at(VK_FORMAT_D24_UNORM_S8_UINT));
 }

-bool Device::IsFormatSupported(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
-                               FormatType format_type) const {
+bool VKDevice::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);
@@ -552,7 +549,7 @@ bool Device::IsFormatSupported(VkFormat wanted_format, VkFormatFeatureFlags want
    return (supported_usage & wanted_usage) == wanted_usage;
 }

-void Device::CheckSuitability() const {
+void VKDevice::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) {
@@ -617,7 +614,7 @@ void Device::CheckSuitability() const {
    }
 }

-std::vector<const char*> Device::LoadExtensions() {
+std::vector<const char*> VKDevice::LoadExtensions() {
    std::vector<const char*> extensions;
    extensions.reserve(7 + REQUIRED_EXTENSIONS.size());
    extensions.insert(extensions.begin(), REQUIRED_EXTENSIONS.begin(), REQUIRED_EXTENSIONS.end());
@@ -770,12 +767,12 @@ std::vector<const char*> Device::LoadExtensions() {
    return extensions;
 }

-void Device::SetupFamilies(VkSurfaceKHR surface) {
+void VKDevice::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 || !surface)) {
+        if (graphics && present) {
            break;
        }
        const VkQueueFamilyProperties& queue_family = queue_family_properties[index];
@@ -785,7 +782,7 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
        if (queue_family.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
            graphics = index;
        }
-        if (surface && physical.GetSurfaceSupportKHR(index, surface)) {
+        if (physical.GetSurfaceSupportKHR(index, surface)) {
            present = index;
        }
    }
@@ -793,7 +790,7 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
        LOG_ERROR(Render_Vulkan, "Device lacks a graphics queue");
        throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
    }
-    if (surface && !present) {
+    if (!present) {
        LOG_ERROR(Render_Vulkan, "Device lacks a present queue");
        throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
    }
@@ -801,14 +798,14 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
    present_family = *present;
 }

-void Device::SetupFeatures() {
+void VKDevice::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() {
+void VKDevice::CollectTelemetryParameters() {
    VkPhysicalDeviceDriverPropertiesKHR driver{
        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR,
        .pNext = nullptr,
@@ -835,7 +832,7 @@ void Device::CollectTelemetryParameters() {
    }
 }

-void Device::CollectToolingInfo() {
+void VKDevice::CollectToolingInfo() {
    if (!ext_tooling_info) {
        return;
    }
@@ -861,7 +858,7 @@ void Device::CollectToolingInfo() {
    }
 }

-std::vector<VkDeviceQueueCreateInfo> Device::GetDeviceQueueCreateInfos() const {
+std::vector<VkDeviceQueueCreateInfo> VKDevice::GetDeviceQueueCreateInfos() const {
    static constexpr float QUEUE_PRIORITY = 1.0f;

    std::unordered_set<u32> unique_queue_families{graphics_family, present_family};
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@@ -10,12 +10,11 @@
 #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 {

-class NsightAftermathTracker;
-
 /// Format usage descriptor.
 enum class FormatType { Linear, Optimal, Buffer };

@@ -23,11 +22,11 @@ enum class FormatType { Linear, Optimal, Buffer };
 const u32 GuestWarpSize = 32;

 /// Handles data specific to a physical device.
-class Device final {
+class VKDevice final {
 public:
-    explicit Device(VkInstance instance, vk::PhysicalDevice physical, VkSurfaceKHR surface,
-                    const vk::InstanceDispatch& dld);
-    ~Device();
+    explicit VKDevice(VkInstance instance, vk::PhysicalDevice physical, VkSurfaceKHR surface,
+                      const vk::InstanceDispatch& dld);
+    ~VKDevice();

    /**
     * Returns a format supported by the device for the passed requeriments.
@@ -301,7 +300,7 @@ private:
    std::unordered_map<VkFormat, VkFormatProperties> format_properties;

    /// Nsight Aftermath GPU crash tracker
-    std::unique_ptr<NsightAftermathTracker> nsight_aftermath_tracker;
+    NsightAftermathTracker nsight_aftermath_tracker;
 };

 } // namespace Vulkan
--- a/src/video_core/renderer_vulkan/vk_fence_manager.cpp
+++ b/src/video_core/renderer_vulkan/vk_fence_manager.cpp
@@ -6,19 +6,19 @@
 #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 {

-InnerFence::InnerFence(const Device& device_, VKScheduler& scheduler_, u32 payload_,
+InnerFence::InnerFence(const VKDevice& device_, VKScheduler& scheduler_, u32 payload_,
                       bool is_stubbed_)
    : FenceBase{payload_, is_stubbed_}, device{device_}, scheduler{scheduler_} {}

-InnerFence::InnerFence(const Device& device_, VKScheduler& scheduler_, GPUVAddr address_,
+InnerFence::InnerFence(const VKDevice& device_, VKScheduler& scheduler_, GPUVAddr address_,
                       u32 payload_, bool is_stubbed_)
    : FenceBase{address_, payload_, is_stubbed_}, device{device_}, scheduler{scheduler_} {}

@@ -75,7 +75,7 @@ bool InnerFence::IsEventSignalled() const {
 VKFenceManager::VKFenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
                               Tegra::MemoryManager& memory_manager_, TextureCache& texture_cache_,
                               VKBufferCache& buffer_cache_, VKQueryCache& query_cache_,
-                               const Device& device_, VKScheduler& scheduler_)
+                               const VKDevice& device_, VKScheduler& scheduler_)
    : GenericFenceManager{rasterizer_, gpu_, texture_cache_, buffer_cache_, query_cache_},
      device{device_}, scheduler{scheduler_} {}

--- a/src/video_core/renderer_vulkan/vk_fence_manager.h
+++ b/src/video_core/renderer_vulkan/vk_fence_manager.h
@@ -21,16 +21,16 @@ class RasterizerInterface;

 namespace Vulkan {

-class Device;
 class VKBufferCache;
+class VKDevice;
 class VKQueryCache;
 class VKScheduler;

 class InnerFence : public VideoCommon::FenceBase {
 public:
-    explicit InnerFence(const Device& device_, VKScheduler& scheduler_, u32 payload_,
+    explicit InnerFence(const VKDevice& device_, VKScheduler& scheduler_, u32 payload_,
                        bool is_stubbed_);
-    explicit InnerFence(const Device& device_, VKScheduler& scheduler_, GPUVAddr address_,
+    explicit InnerFence(const VKDevice& device_, VKScheduler& scheduler_, GPUVAddr address_,
                        u32 payload_, bool is_stubbed_);
    ~InnerFence();

@@ -43,7 +43,7 @@ public:
 private:
    bool IsEventSignalled() const;

-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
    vk::Event event;
    u64 ticks = 0;
@@ -58,7 +58,7 @@ public:
    explicit VKFenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
                            Tegra::MemoryManager& memory_manager_, TextureCache& texture_cache_,
                            VKBufferCache& buffer_cache_, VKQueryCache& query_cache_,
-                            const Device& device_, VKScheduler& scheduler_);
+                            const VKDevice& device_, VKScheduler& scheduler_);

 protected:
    Fence CreateFence(u32 value, bool is_stubbed) override;
@@ -68,7 +68,7 @@ protected:
    void WaitFence(Fence& fence) override;

 private:
-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
 };

--- 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 {
@@ -94,7 +94,7 @@ VkSampleCountFlagBits ConvertMsaaMode(Tegra::Texture::MsaaMode msaa_mode) {

 } // Anonymous namespace

-VKGraphicsPipeline::VKGraphicsPipeline(const Device& device_, VKScheduler& scheduler_,
+VKGraphicsPipeline::VKGraphicsPipeline(const VKDevice& device_, VKScheduler& scheduler_,
                                       VKDescriptorPool& descriptor_pool_,
                                       VKUpdateDescriptorQueue& update_descriptor_queue_,
                                       const GraphicsPipelineCacheKey& key,
@@ -212,7 +212,11 @@ vk::Pipeline VKGraphicsPipeline::CreatePipeline(const SPIRVProgram& program,
        // state is ignored
        dynamic.raw1 = 0;
        dynamic.raw2 = 0;
-        dynamic.vertex_strides.fill(0);
+        for (FixedPipelineState::VertexBinding& binding : dynamic.vertex_bindings) {
+            // Enable all vertex bindings
+            binding.raw = 0;
+            binding.enabled.Assign(1);
+        }
    } else {
        dynamic = state.dynamic_state;
    }
@@ -220,16 +224,19 @@ vk::Pipeline VKGraphicsPipeline::CreatePipeline(const SPIRVProgram& program,
    std::vector<VkVertexInputBindingDescription> vertex_bindings;
    std::vector<VkVertexInputBindingDivisorDescriptionEXT> vertex_binding_divisors;
    for (std::size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
-        if (state.attributes[index].binding_index_enabled == 0) {
+        const auto& binding = dynamic.vertex_bindings[index];
+        if (!binding.enabled) {
            continue;
        }
        const bool instanced = state.binding_divisors[index] != 0;
        const auto rate = instanced ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX;
+
        vertex_bindings.push_back({
            .binding = static_cast<u32>(index),
-            .stride = dynamic.vertex_strides[index],
+            .stride = binding.stride,
            .inputRate = rate,
        });
+
        if (instanced) {
            vertex_binding_divisors.push_back({
                .binding = static_cast<u32>(index),
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.h
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.h
@@ -40,8 +40,8 @@ static_assert(std::has_unique_object_representations_v<GraphicsPipelineCacheKey>
 static_assert(std::is_trivially_copyable_v<GraphicsPipelineCacheKey>);
 static_assert(std::is_trivially_constructible_v<GraphicsPipelineCacheKey>);

-class Device;
 class VKDescriptorPool;
+class VKDevice;
 class VKScheduler;
 class VKUpdateDescriptorQueue;

@@ -49,7 +49,7 @@ using SPIRVProgram = std::array<std::optional<SPIRVShader>, Maxwell::MaxShaderSt

 class VKGraphicsPipeline final {
 public:
-    explicit VKGraphicsPipeline(const Device& device_, VKScheduler& scheduler_,
+    explicit VKGraphicsPipeline(const VKDevice& device_, VKScheduler& scheduler_,
                                VKDescriptorPool& descriptor_pool,
                                VKUpdateDescriptorQueue& update_descriptor_queue_,
                                const GraphicsPipelineCacheKey& key,
@@ -85,7 +85,7 @@ private:
    vk::Pipeline CreatePipeline(const SPIRVProgram& program, VkRenderPass renderpass,
                                u32 num_color_buffers) const;

-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
    const GraphicsPipelineCacheKey cache_key;
    const u64 hash;
--- a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp
+++ b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp
@@ -6,15 +6,15 @@
 #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 {

 using namespace std::chrono_literals;

-MasterSemaphore::MasterSemaphore(const Device& device) {
+MasterSemaphore::MasterSemaphore(const VKDevice& device) {
    static constexpr VkSemaphoreTypeCreateInfoKHR semaphore_type_ci{
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR,
        .pNext = nullptr,
--- a/src/video_core/renderer_vulkan/vk_master_semaphore.h
+++ b/src/video_core/renderer_vulkan/vk_master_semaphore.h
@@ -12,11 +12,11 @@

 namespace Vulkan {

-class Device;
+class VKDevice;

 class MasterSemaphore {
 public:
-    explicit MasterSemaphore(const Device& device);
+    explicit MasterSemaphore(const VKDevice& device);
    ~MasterSemaphore();

    /// Returns the current logical tick.
--- 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 {
@@ -29,7 +29,7 @@ u64 GetAllocationChunkSize(u64 required_size) {

 class VKMemoryAllocation final {
 public:
-    explicit VKMemoryAllocation(const Device& device_, vk::DeviceMemory memory_,
+    explicit VKMemoryAllocation(const VKDevice& device_, vk::DeviceMemory memory_,
                                VkMemoryPropertyFlags properties_, u64 allocation_size_, u32 type_)
        : device{device_}, memory{std::move(memory_)}, properties{properties_},
          allocation_size{allocation_size_}, shifted_type{ShiftType(type_)} {}
@@ -104,7 +104,7 @@ private:
        return std::nullopt;
    }

-    const Device& device;                   ///< Vulkan device.
+    const VKDevice& device;                 ///< Vulkan device.
    const vk::DeviceMemory memory;          ///< Vulkan memory allocation handler.
    const VkMemoryPropertyFlags properties; ///< Vulkan properties.
    const u64 allocation_size;              ///< Size of this allocation.
@@ -117,7 +117,7 @@ private:
    std::vector<const VKMemoryCommitImpl*> commits;
 };

-VKMemoryManager::VKMemoryManager(const Device& device_)
+VKMemoryManager::VKMemoryManager(const VKDevice& device_)
    : device{device_}, properties{device_.GetPhysical().GetMemoryProperties()} {}

 VKMemoryManager::~VKMemoryManager() = default;
@@ -207,7 +207,7 @@ VKMemoryCommit VKMemoryManager::TryAllocCommit(const VkMemoryRequirements& requi
    return {};
 }

-VKMemoryCommitImpl::VKMemoryCommitImpl(const Device& device_, VKMemoryAllocation* allocation_,
+VKMemoryCommitImpl::VKMemoryCommitImpl(const VKDevice& device_, VKMemoryAllocation* allocation_,
                                       const vk::DeviceMemory& memory_, u64 begin_, u64 end_)
    : device{device_}, memory{memory_}, interval{begin_, end_}, allocation{allocation_} {}

--- a/src/video_core/renderer_vulkan/vk_memory_manager.h
+++ b/src/video_core/renderer_vulkan/vk_memory_manager.h
@@ -13,8 +13,8 @@

 namespace Vulkan {

-class Device;
 class MemoryMap;
+class VKDevice;
 class VKMemoryAllocation;
 class VKMemoryCommitImpl;

@@ -22,7 +22,7 @@ using VKMemoryCommit = std::unique_ptr<VKMemoryCommitImpl>;

 class VKMemoryManager final {
 public:
-    explicit VKMemoryManager(const Device& device_);
+    explicit VKMemoryManager(const VKDevice& device_);
    VKMemoryManager(const VKMemoryManager&) = delete;
    ~VKMemoryManager();

@@ -49,7 +49,7 @@ private:
    VKMemoryCommit TryAllocCommit(const VkMemoryRequirements& requirements,
                                  VkMemoryPropertyFlags wanted_properties);

-    const Device& device;                                         ///< Device handler.
+    const VKDevice& device;                                       ///< Device handler.
    const VkPhysicalDeviceMemoryProperties properties;            ///< Physical device properties.
    std::vector<std::unique_ptr<VKMemoryAllocation>> allocations; ///< Current allocations.
 };
@@ -59,7 +59,7 @@ class VKMemoryCommitImpl final {
    friend MemoryMap;

 public:
-    explicit VKMemoryCommitImpl(const Device& device_, VKMemoryAllocation* allocation_,
+    explicit VKMemoryCommitImpl(const VKDevice& device_, VKMemoryAllocation* allocation_,
                                const vk::DeviceMemory& memory_, u64 begin_, u64 end_);
    ~VKMemoryCommitImpl();

@@ -85,7 +85,7 @@ private:
    /// Unmaps memory.
    void Unmap() const;

-    const Device& device;             ///< Vulkan device.
+    const VKDevice& device;           ///< Vulkan device.
    const vk::DeviceMemory& memory;   ///< Vulkan device memory handler.
    std::pair<u64, u64> interval{};   ///< Interval where the commit exists.
    VKMemoryAllocation* allocation{}; ///< Pointer to the large memory allocation.
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -19,6 +19,7 @@
 #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"
@@ -28,7 +29,6 @@
 #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 {
@@ -149,7 +149,7 @@ Shader::~Shader() = default;
 VKPipelineCache::VKPipelineCache(RasterizerVulkan& rasterizer_, Tegra::GPU& gpu_,
                                 Tegra::Engines::Maxwell3D& maxwell3d_,
                                 Tegra::Engines::KeplerCompute& kepler_compute_,
-                                 Tegra::MemoryManager& gpu_memory_, const Device& device_,
+                                 Tegra::MemoryManager& gpu_memory_, const VKDevice& device_,
                                 VKScheduler& scheduler_, VKDescriptorPool& descriptor_pool_,
                                 VKUpdateDescriptorQueue& update_descriptor_queue_)
    : VideoCommon::ShaderCache<Shader>{rasterizer_}, gpu{gpu_}, maxwell3d{maxwell3d_},
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.h
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.h
@@ -33,10 +33,10 @@ class System;

 namespace Vulkan {

-class Device;
 class RasterizerVulkan;
 class VKComputePipeline;
 class VKDescriptorPool;
+class VKDevice;
 class VKScheduler;
 class VKUpdateDescriptorQueue;

@@ -121,7 +121,7 @@ public:
    explicit VKPipelineCache(RasterizerVulkan& rasterizer, Tegra::GPU& gpu,
                             Tegra::Engines::Maxwell3D& maxwell3d,
                             Tegra::Engines::KeplerCompute& kepler_compute,
-                             Tegra::MemoryManager& gpu_memory, const Device& device,
+                             Tegra::MemoryManager& gpu_memory, const VKDevice& device,
                             VKScheduler& scheduler, VKDescriptorPool& descriptor_pool,
                             VKUpdateDescriptorQueue& update_descriptor_queue);
    ~VKPipelineCache() override;
@@ -148,7 +148,7 @@ private:
    Tegra::Engines::KeplerCompute& kepler_compute;
    Tegra::MemoryManager& gpu_memory;

-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
    VKDescriptorPool& descriptor_pool;
    VKUpdateDescriptorQueue& update_descriptor_queue;
--- 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 {
@@ -27,7 +27,7 @@ constexpr VkQueryType GetTarget(QueryType type) {

 } // Anonymous namespace

-QueryPool::QueryPool(const Device& device_, VKScheduler& scheduler, QueryType type_)
+QueryPool::QueryPool(const VKDevice& device_, VKScheduler& scheduler, QueryType type_)
    : ResourcePool{scheduler.GetMasterSemaphore(), GROW_STEP}, device{device_}, type{type_} {}

 QueryPool::~QueryPool() = default;
@@ -68,7 +68,7 @@ void QueryPool::Reserve(std::pair<VkQueryPool, u32> query) {

 VKQueryCache::VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
                           Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-                           const Device& device_, VKScheduler& scheduler_)
+                           const VKDevice& device_, VKScheduler& scheduler_)
    : QueryCacheBase{rasterizer_, maxwell3d_, gpu_memory_}, device{device_}, scheduler{scheduler_},
      query_pools{
          QueryPool{device_, scheduler_, QueryType::SamplesPassed},
@@ -96,9 +96,9 @@ void VKQueryCache::Reserve(QueryType type, std::pair<VkQueryPool, u32> query) {
 HostCounter::HostCounter(VKQueryCache& cache_, std::shared_ptr<HostCounter> dependency_,
                         QueryType type_)
    : HostCounterBase{std::move(dependency_)}, cache{cache_}, type{type_},
-      query{cache_.AllocateQuery(type_)}, tick{cache_.GetScheduler().CurrentTick()} {
-    const vk::Device* logical = &cache.GetDevice().GetLogical();
-    cache.GetScheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
+      query{cache_.AllocateQuery(type_)}, tick{cache_.Scheduler().CurrentTick()} {
+    const vk::Device* logical = &cache_.Device().GetLogical();
+    cache_.Scheduler().Record([logical, query = query](vk::CommandBuffer cmdbuf) {
        logical->ResetQueryPoolEXT(query.first, query.second, 1);
        cmdbuf.BeginQuery(query.first, query.second, VK_QUERY_CONTROL_PRECISE_BIT);
    });
@@ -109,17 +109,17 @@ HostCounter::~HostCounter() {
 }

 void HostCounter::EndQuery() {
-    cache.GetScheduler().Record(
+    cache.Scheduler().Record(
        [query = query](vk::CommandBuffer cmdbuf) { cmdbuf.EndQuery(query.first, query.second); });
 }

 u64 HostCounter::BlockingQuery() const {
-    if (tick >= cache.GetScheduler().CurrentTick()) {
-        cache.GetScheduler().Flush();
+    if (tick >= cache.Scheduler().CurrentTick()) {
+        cache.Scheduler().Flush();
    }

    u64 data;
-    const VkResult query_result = cache.GetDevice().GetLogical().GetQueryResults(
+    const VkResult query_result = cache.Device().GetLogical().GetQueryResults(
        query.first, query.second, 1, sizeof(data), &data, sizeof(data),
        VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);

@@ -127,7 +127,7 @@ u64 HostCounter::BlockingQuery() const {
    case VK_SUCCESS:
        return data;
    case VK_ERROR_DEVICE_LOST:
-        cache.GetDevice().ReportLoss();
+        cache.Device().ReportLoss();
        [[fallthrough]];
    default:
        throw vk::Exception(query_result);
--- a/src/video_core/renderer_vulkan/vk_query_cache.h
+++ b/src/video_core/renderer_vulkan/vk_query_cache.h
@@ -21,8 +21,8 @@ class RasterizerInterface;
 namespace Vulkan {

 class CachedQuery;
-class Device;
 class HostCounter;
+class VKDevice;
 class VKQueryCache;
 class VKScheduler;

@@ -30,7 +30,7 @@ using CounterStream = VideoCommon::CounterStreamBase<VKQueryCache, HostCounter>;

 class QueryPool final : public ResourcePool {
 public:
-    explicit QueryPool(const Device& device, VKScheduler& scheduler, VideoCore::QueryType type);
+    explicit QueryPool(const VKDevice& device, VKScheduler& scheduler, VideoCore::QueryType type);
    ~QueryPool() override;

    std::pair<VkQueryPool, u32> Commit();
@@ -43,7 +43,7 @@ protected:
 private:
    static constexpr std::size_t GROW_STEP = 512;

-    const Device& device;
+    const VKDevice& device;
    const VideoCore::QueryType type;

    std::vector<vk::QueryPool> pools;
@@ -55,23 +55,23 @@ class VKQueryCache final
 public:
    explicit VKQueryCache(VideoCore::RasterizerInterface& rasterizer_,
                          Tegra::Engines::Maxwell3D& maxwell3d_, Tegra::MemoryManager& gpu_memory_,
-                          const Device& device_, VKScheduler& scheduler_);
+                          const VKDevice& device_, VKScheduler& scheduler_);
    ~VKQueryCache();

    std::pair<VkQueryPool, u32> AllocateQuery(VideoCore::QueryType type);

    void Reserve(VideoCore::QueryType type, std::pair<VkQueryPool, u32> query);

-    const Device& GetDevice() const noexcept {
+    const VKDevice& Device() const noexcept {
        return device;
    }

-    VKScheduler& GetScheduler() const noexcept {
+    VKScheduler& Scheduler() const noexcept {
        return scheduler;
    }

 private:
-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
    std::array<QueryPool, VideoCore::NumQueryTypes> query_pools;
 };
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -27,6 +27,7 @@
 #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"
@@ -37,7 +38,6 @@
 #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 {
@@ -62,7 +62,7 @@ namespace {

 constexpr auto COMPUTE_SHADER_INDEX = static_cast<size_t>(Tegra::Engines::ShaderType::Compute);

-VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t index) {
+VkViewport GetViewportState(const VKDevice& device, const Maxwell& regs, size_t index) {
    const auto& src = regs.viewport_transform[index];
    const float width = src.scale_x * 2.0f;
    const float height = src.scale_y * 2.0f;
@@ -239,7 +239,7 @@ public:
        index.type = type;
    }

-    void Bind(const Device& device, VKScheduler& scheduler) const {
+    void Bind(const VKDevice& device, VKScheduler& scheduler) const {
        // Use this large switch case to avoid dispatching more memory in the record lambda than
        // what we need. It looks horrible, but it's the best we can do on standard C++.
        switch (vertex.num_buffers) {
@@ -330,7 +330,7 @@ private:
    } index;

    template <size_t N>
-    void BindStatic(const Device& device, VKScheduler& scheduler) const {
+    void BindStatic(const VKDevice& device, VKScheduler& scheduler) const {
        if (device.IsExtExtendedDynamicStateSupported()) {
            if (index.buffer) {
                BindStatic<N, true, true>(scheduler);
@@ -409,7 +409,7 @@ void RasterizerVulkan::DrawParameters::Draw(vk::CommandBuffer cmdbuf) const {
 RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                                   Tegra::MemoryManager& gpu_memory_,
                                   Core::Memory::Memory& cpu_memory_, VKScreenInfo& screen_info_,
-                                   const Device& device_, VKMemoryManager& memory_manager_,
+                                   const VKDevice& device_, VKMemoryManager& memory_manager_,
                                   StateTracker& state_tracker_, VKScheduler& scheduler_)
    : RasterizerAccelerated{cpu_memory_}, gpu{gpu_},
      gpu_memory{gpu_memory_}, maxwell3d{gpu.Maxwell3D()}, kepler_compute{gpu.KeplerCompute()},
@@ -628,10 +628,8 @@ void RasterizerVulkan::DispatchCompute(GPUVAddr code_addr) {
                      grid_z = launch_desc.grid_dim_z, pipeline_handle, pipeline_layout,
                      descriptor_set](vk::CommandBuffer cmdbuf) {
        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_handle);
-        if (descriptor_set) {
-            cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_layout,
-                                      DESCRIPTOR_SET, descriptor_set, nullptr);
-        }
+        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_layout, DESCRIPTOR_SET,
+                                  descriptor_set, {});
        cmdbuf.Dispatch(grid_x, grid_y, grid_z);
    });
 }
--- a/src/video_core/renderer_vulkan/vk_rasterizer.h
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.h
@@ -55,7 +55,7 @@ class RasterizerVulkan final : public VideoCore::RasterizerAccelerated {
 public:
    explicit RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                              Tegra::MemoryManager& gpu_memory_, Core::Memory::Memory& cpu_memory_,
-                              VKScreenInfo& screen_info_, const Device& device_,
+                              VKScreenInfo& screen_info_, const VKDevice& device_,
                              VKMemoryManager& memory_manager_, StateTracker& state_tracker_,
                              VKScheduler& scheduler_);
    ~RasterizerVulkan() override;
@@ -212,7 +212,7 @@ private:
    Tegra::Engines::KeplerCompute& kepler_compute;

    VKScreenInfo& screen_info;
-    const Device& device;
+    const VKDevice& device;
    VKMemoryManager& memory_manager;
    StateTracker& state_tracker;
    VKScheduler& scheduler;
--- 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 {
@@ -37,7 +37,7 @@ void VKScheduler::CommandChunk::ExecuteAll(vk::CommandBuffer cmdbuf) {
    last = nullptr;
 }

-VKScheduler::VKScheduler(const Device& device_, StateTracker& state_tracker_)
+VKScheduler::VKScheduler(const VKDevice& device_, StateTracker& state_tracker_)
    : device{device_}, state_tracker{state_tracker_},
      master_semaphore{std::make_unique<MasterSemaphore>(device)},
      command_pool{std::make_unique<CommandPool>(*master_semaphore, device)} {
--- a/src/video_core/renderer_vulkan/vk_scheduler.h
+++ b/src/video_core/renderer_vulkan/vk_scheduler.h
@@ -17,17 +17,17 @@
 namespace Vulkan {

 class CommandPool;
-class Device;
 class Framebuffer;
 class MasterSemaphore;
 class StateTracker;
+class VKDevice;
 class VKQueryCache;

 /// The scheduler abstracts command buffer and fence management with an interface that's able to do
 /// OpenGL-like operations on Vulkan command buffers.
 class VKScheduler {
 public:
-    explicit VKScheduler(const Device& device, StateTracker& state_tracker);
+    explicit VKScheduler(const VKDevice& device, StateTracker& state_tracker);
    ~VKScheduler();

    /// Returns the current command buffer tick.
@@ -179,7 +179,7 @@ private:

    void AcquireNewChunk();

-    const Device& device;
+    const VKDevice& device;
    StateTracker& state_tracker;

    std::unique_ptr<MasterSemaphore> master_semaphore;
--- 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 {

@@ -274,7 +274,7 @@ bool IsPrecise(Operation operand) {

 class SPIRVDecompiler final : public Sirit::Module {
 public:
-    explicit SPIRVDecompiler(const Device& device_, const ShaderIR& ir_, ShaderType stage_,
+    explicit SPIRVDecompiler(const VKDevice& device_, const ShaderIR& ir_, ShaderType stage_,
                             const Registry& registry_, const Specialization& specialization_)
        : Module(0x00010300), device{device_}, ir{ir_}, stage{stage_}, header{ir_.GetHeader()},
          registry{registry_}, specialization{specialization_} {
@@ -2742,7 +2742,7 @@ private:
    };
    static_assert(operation_decompilers.size() == static_cast<std::size_t>(OperationCode::Amount));

-    const Device& device;
+    const VKDevice& device;
    const ShaderIR& ir;
    const ShaderType stage;
    const Tegra::Shader::Header header;
@@ -3130,7 +3130,7 @@ ShaderEntries GenerateShaderEntries(const VideoCommon::Shader::ShaderIR& ir) {
    return entries;
 }

-std::vector<u32> Decompile(const Device& device, const VideoCommon::Shader::ShaderIR& ir,
+std::vector<u32> Decompile(const VKDevice& device, const VideoCommon::Shader::ShaderIR& ir,
                           ShaderType stage, const VideoCommon::Shader::Registry& registry,
                           const Specialization& specialization) {
    return SPIRVDecompiler(device, ir, stage, registry, specialization).Assemble();
--- a/src/video_core/renderer_vulkan/vk_shader_decompiler.h
+++ b/src/video_core/renderer_vulkan/vk_shader_decompiler.h
@@ -15,8 +15,10 @@
 #include "video_core/shader/shader_ir.h"

 namespace Vulkan {
+class VKDevice;
+}

-class Device;
+namespace Vulkan {

 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 using UniformTexelEntry = VideoCommon::Shader::SamplerEntry;
@@ -107,7 +109,7 @@ struct SPIRVShader {

 ShaderEntries GenerateShaderEntries(const VideoCommon::Shader::ShaderIR& ir);

-std::vector<u32> Decompile(const Device& device, const VideoCommon::Shader::ShaderIR& ir,
+std::vector<u32> Decompile(const VKDevice& device, const VideoCommon::Shader::ShaderIR& ir,
                           Tegra::Engines::ShaderType stage,
                           const VideoCommon::Shader::Registry& registry,
                           const Specialization& specialization);
--- a/src/video_core/renderer_vulkan/vk_shader_util.cpp
+++ b/src/video_core/renderer_vulkan/vk_shader_util.cpp
@@ -7,13 +7,13 @@

 #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 {

-vk::ShaderModule BuildShader(const Device& device, std::span<const u32> code) {
+vk::ShaderModule BuildShader(const VKDevice& device, std::span<const u32> code) {
    return device.GetLogical().CreateShaderModule({
        .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
        .pNext = nullptr,
--- a/src/video_core/renderer_vulkan/vk_shader_util.h
+++ b/src/video_core/renderer_vulkan/vk_shader_util.h
@@ -11,8 +11,8 @@

 namespace Vulkan {

-class Device;
+class VKDevice;

-vk::ShaderModule BuildShader(const Device& device, std::span<const u32> code);
+vk::ShaderModule BuildShader(const VKDevice& device, std::span<const u32> code);

 } // namespace Vulkan
--- 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 {
@@ -19,7 +19,7 @@ namespace Vulkan {
 VKStagingBufferPool::StagingBuffer::StagingBuffer(std::unique_ptr<VKBuffer> buffer_)
    : buffer{std::move(buffer_)} {}

-VKStagingBufferPool::VKStagingBufferPool(const Device& device_, VKMemoryManager& memory_manager_,
+VKStagingBufferPool::VKStagingBufferPool(const VKDevice& device_, VKMemoryManager& memory_manager_,
                                         VKScheduler& scheduler_)
    : device{device_}, memory_manager{memory_manager_}, scheduler{scheduler_} {}

--- a/src/video_core/renderer_vulkan/vk_staging_buffer_pool.h
+++ b/src/video_core/renderer_vulkan/vk_staging_buffer_pool.h
@@ -14,7 +14,7 @@

 namespace Vulkan {

-class Device;
+class VKDevice;
 class VKScheduler;

 struct VKBuffer final {
@@ -24,7 +24,7 @@ struct VKBuffer final {

 class VKStagingBufferPool final {
 public:
-    explicit VKStagingBufferPool(const Device& device, VKMemoryManager& memory_manager,
+    explicit VKStagingBufferPool(const VKDevice& device, VKMemoryManager& memory_manager,
                                 VKScheduler& scheduler);
    ~VKStagingBufferPool();

@@ -58,7 +58,7 @@ private:

    u64 ReleaseLevel(StagingBuffersCache& cache, std::size_t log2);

-    const Device& device;
+    const VKDevice& device;
    VKMemoryManager& memory_manager;
    VKScheduler& scheduler;

--- 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 {
@@ -60,7 +60,7 @@ u32 GetMemoryType(const VkPhysicalDeviceMemoryProperties& properties,

 } // Anonymous namespace

-VKStreamBuffer::VKStreamBuffer(const Device& device_, VKScheduler& scheduler_)
+VKStreamBuffer::VKStreamBuffer(const VKDevice& device_, VKScheduler& scheduler_)
    : device{device_}, scheduler{scheduler_} {
    CreateBuffers();
    ReserveWatches(current_watches, WATCHES_INITIAL_RESERVE);
--- a/src/video_core/renderer_vulkan/vk_stream_buffer.h
+++ b/src/video_core/renderer_vulkan/vk_stream_buffer.h
@@ -13,13 +13,13 @@

 namespace Vulkan {

-class Device;
+class VKDevice;
 class VKFenceWatch;
 class VKScheduler;

 class VKStreamBuffer final {
 public:
-    explicit VKStreamBuffer(const Device& device, VKScheduler& scheduler);
+    explicit VKStreamBuffer(const VKDevice& device, VKScheduler& scheduler);
    ~VKStreamBuffer();

    /**
@@ -54,7 +54,7 @@ private:

    void WaitPendingOperations(u64 requested_upper_bound);

-    const Device& device;   ///< Vulkan device manager.
+    const VKDevice& device; ///< Vulkan device manager.
    VKScheduler& scheduler; ///< Command scheduler.

    vk::Buffer buffer;        ///< Mapped buffer.
--- 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 {
@@ -56,7 +56,7 @@ VkExtent2D ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, u32 wi

 } // Anonymous namespace

-VKSwapchain::VKSwapchain(VkSurfaceKHR surface_, const Device& device_, VKScheduler& scheduler_)
+VKSwapchain::VKSwapchain(VkSurfaceKHR surface_, const VKDevice& device_, VKScheduler& scheduler_)
    : surface{surface_}, device{device_}, scheduler{scheduler_} {}

 VKSwapchain::~VKSwapchain() = default;
--- a/src/video_core/renderer_vulkan/vk_swapchain.h
+++ b/src/video_core/renderer_vulkan/vk_swapchain.h
@@ -15,12 +15,12 @@ struct FramebufferLayout;

 namespace Vulkan {

-class Device;
+class VKDevice;
 class VKScheduler;

 class VKSwapchain {
 public:
-    explicit VKSwapchain(VkSurfaceKHR surface, const Device& device, VKScheduler& scheduler);
+    explicit VKSwapchain(VkSurfaceKHR surface, const VKDevice& device, VKScheduler& scheduler);
    ~VKSwapchain();

    /// Creates (or recreates) the swapchain with a given size.
@@ -73,7 +73,7 @@ private:
    void Destroy();

    const VkSurfaceKHR surface;
-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;

    vk::SwapchainKHR swapchain;
--- a/src/video_core/renderer_vulkan/vk_texture_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.cpp
@@ -10,12 +10,10 @@
 #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_memory_manager.h"
-#include "video_core/renderer_vulkan/vk_rasterizer.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_texture_cache.h"
-#include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"

 namespace Vulkan {
@@ -95,7 +93,7 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    }
 }

-[[nodiscard]] VkImageCreateInfo MakeImageCreateInfo(const Device& device, const ImageInfo& info) {
+[[nodiscard]] VkImageCreateInfo MakeImageCreateInfo(const VKDevice& device, const ImageInfo& info) {
    const auto format_info = MaxwellToVK::SurfaceFormat(device, FormatType::Optimal, info.format);
    VkImageCreateFlags flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
    if (info.type == ImageType::e2D && info.resources.layers >= 6 &&
@@ -148,14 +146,14 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    };
 }

-[[nodiscard]] vk::Image MakeImage(const Device& device, const ImageInfo& info) {
+[[nodiscard]] vk::Image MakeImage(const VKDevice& device, const ImageInfo& info) {
    if (info.type == ImageType::Buffer) {
        return vk::Image{};
    }
    return device.GetLogical().CreateImage(MakeImageCreateInfo(device, info));
 }

-[[nodiscard]] vk::Buffer MakeBuffer(const Device& device, const ImageInfo& info) {
+[[nodiscard]] vk::Buffer MakeBuffer(const VKDevice& device, const ImageInfo& info) {
    if (info.type != ImageType::Buffer) {
        return vk::Buffer{};
    }
@@ -207,7 +205,7 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    }
 }

-[[nodiscard]] VkAttachmentDescription AttachmentDescription(const Device& device,
+[[nodiscard]] VkAttachmentDescription AttachmentDescription(const VKDevice& device,
                                                            const ImageView* image_view) {
    const auto pixel_format = image_view->format;
    return VkAttachmentDescription{
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -19,11 +19,11 @@ using VideoCommon::Offset2D;
 using VideoCommon::RenderTargets;
 using VideoCore::Surface::PixelFormat;

+class VKDevice;
 class VKScheduler;
 class VKStagingBufferPool;

 class BlitImageHelper;
-class Device;
 class Image;
 class ImageView;
 class Framebuffer;
@@ -68,7 +68,7 @@ struct ImageBufferMap {
 };

 struct TextureCacheRuntime {
-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;
    VKMemoryManager& memory_manager;
    VKStagingBufferPool& staging_buffer_pool;
@@ -104,11 +104,6 @@ struct TextureCacheRuntime {
    }

    void InsertUploadMemoryBarrier() {}
-
-    bool HasBrokenTextureViewFormats() const noexcept {
-        // No known Vulkan driver has broken image views
-        return false;
-    }
 };

 class Image : public VideoCommon::ImageBase {
@@ -182,7 +177,7 @@ public:
 private:
    [[nodiscard]] vk::ImageView MakeDepthStencilView(VkImageAspectFlags aspect_mask);

-    const Device* device = nullptr;
+    const VKDevice* device = nullptr;
    std::array<vk::ImageView, VideoCommon::NUM_IMAGE_VIEW_TYPES> image_views;
    vk::ImageView depth_view;
    vk::ImageView stencil_view;
--- a/src/video_core/renderer_vulkan/vk_update_descriptor.cpp
+++ b/src/video_core/renderer_vulkan/vk_update_descriptor.cpp
@@ -7,14 +7,14 @@

 #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 {

-VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const Device& device_, VKScheduler& scheduler_)
+VKUpdateDescriptorQueue::VKUpdateDescriptorQueue(const VKDevice& device_, VKScheduler& scheduler_)
    : device{device_}, scheduler{scheduler_} {}

 VKUpdateDescriptorQueue::~VKUpdateDescriptorQueue() = default;
--- a/src/video_core/renderer_vulkan/vk_update_descriptor.h
+++ b/src/video_core/renderer_vulkan/vk_update_descriptor.h
@@ -12,7 +12,7 @@

 namespace Vulkan {

-class Device;
+class VKDevice;
 class VKScheduler;

 struct DescriptorUpdateEntry {
@@ -31,7 +31,7 @@ struct DescriptorUpdateEntry {

 class VKUpdateDescriptorQueue final {
 public:
-    explicit VKUpdateDescriptorQueue(const Device& device_, VKScheduler& scheduler_);
+    explicit VKUpdateDescriptorQueue(const VKDevice& device_, VKScheduler& scheduler_);
    ~VKUpdateDescriptorQueue();

    void TickFrame();
@@ -69,7 +69,7 @@ public:
    }

 private:
-    const Device& device;
+    const VKDevice& device;
    VKScheduler& scheduler;

    const DescriptorUpdateEntry* upload_start = nullptr;
--- a/src/video_core/shader/async_shaders.cpp
+++ b/src/video_core/shader/async_shaders.cpp
@@ -134,7 +134,7 @@ void AsyncShaders::QueueOpenGLShader(const OpenGL::Device& device,
 }

 void AsyncShaders::QueueVulkanShader(Vulkan::VKPipelineCache* pp_cache,
-                                     const Vulkan::Device& device, Vulkan::VKScheduler& scheduler,
+                                     const Vulkan::VKDevice& device, Vulkan::VKScheduler& scheduler,
                                     Vulkan::VKDescriptorPool& descriptor_pool,
                                     Vulkan::VKUpdateDescriptorQueue& update_descriptor_queue,
                                     std::vector<VkDescriptorSetLayoutBinding> bindings,
--- a/src/video_core/shader/async_shaders.h
+++ b/src/video_core/shader/async_shaders.h
@@ -24,9 +24,9 @@
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_decompiler.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/vulkan_common/vulkan_device.h"

 namespace Core::Frontend {
 class EmuWindow;
@@ -94,7 +94,7 @@ public:
                           CompilerSettings compiler_settings, const Registry& registry,
                           VAddr cpu_addr);

-    void QueueVulkanShader(Vulkan::VKPipelineCache* pp_cache, const Vulkan::Device& device,
+    void QueueVulkanShader(Vulkan::VKPipelineCache* pp_cache, const Vulkan::VKDevice& device,
                           Vulkan::VKScheduler& scheduler,
                           Vulkan::VKDescriptorPool& descriptor_pool,
                           Vulkan::VKUpdateDescriptorQueue& update_descriptor_queue,
@@ -123,7 +123,7 @@ private:

        // For Vulkan
        Vulkan::VKPipelineCache* pp_cache;
-        const Vulkan::Device* vk_device;
+        const Vulkan::VKDevice* vk_device;
        Vulkan::VKScheduler* scheduler;
        Vulkan::VKDescriptorPool* descriptor_pool;
        Vulkan::VKUpdateDescriptorQueue* update_descriptor_queue;
--- a/src/video_core/texture_cache/image_base.cpp
+++ b/src/video_core/texture_cache/image_base.cpp
@@ -120,9 +120,7 @@ void AddImageAlias(ImageBase& lhs, ImageBase& rhs, ImageId lhs_id, ImageId rhs_i
    if (lhs.info.type == ImageType::Linear) {
        base = SubresourceBase{.level = 0, .layer = 0};
    } else {
-        // We are passing relaxed formats as an option, having broken views or not won't matter
-        static constexpr bool broken_views = false;
-        base = FindSubresource(rhs.info, lhs, rhs.gpu_addr, OPTIONS, broken_views);
+        base = FindSubresource(rhs.info, lhs, rhs.gpu_addr, OPTIONS);
    }
    if (!base) {
        LOG_ERROR(HW_GPU, "Image alias should have been flipped");
--- a/src/video_core/texture_cache/image_view_base.cpp
+++ b/src/video_core/texture_cache/image_view_base.cpp
@@ -24,7 +24,7 @@ ImageViewBase::ImageViewBase(const ImageViewInfo& info, const ImageInfo& image_i
          .height = std::max(image_info.size.height >> range.base.level, 1u),
          .depth = std::max(image_info.size.depth >> range.base.level, 1u),
      } {
-    ASSERT_MSG(VideoCore::Surface::IsViewCompatible(image_info.format, info.format, false),
+    ASSERT_MSG(VideoCore::Surface::IsViewCompatible(image_info.format, info.format),
               "Image view format {} is incompatible with image format {}", info.format,
               image_info.format);
    const bool is_async = Settings::values.use_asynchronous_gpu_emulation.GetValue();
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -61,7 +61,7 @@ using VideoCore::Surface::SurfaceType;
 template <class P>
 class TextureCache {
    /// Address shift for caching images into a hash table
-    static constexpr u64 PAGE_BITS = 20;
+    static constexpr u64 PAGE_SHIFT = 20;

    /// Enables debugging features to the texture cache
    static constexpr bool ENABLE_VALIDATION = P::ENABLE_VALIDATION;
@@ -184,8 +184,8 @@ private:
    template <typename Func>
    static void ForEachPage(VAddr addr, size_t size, Func&& func) {
        static constexpr bool RETURNS_BOOL = std::is_same_v<std::invoke_result<Func, u64>, bool>;
-        const u64 page_end = (addr + size - 1) >> PAGE_BITS;
-        for (u64 page = addr >> PAGE_BITS; page <= page_end; ++page) {
+        const u64 page_end = (addr + size - 1) >> PAGE_SHIFT;
+        for (u64 page = addr >> PAGE_SHIFT; page <= page_end; ++page) {
            if constexpr (RETURNS_BOOL) {
                if (func(page)) {
                    break;
@@ -708,7 +708,7 @@ void TextureCache<P>::InvalidateDepthBuffer() {
 template <class P>
 typename P::ImageView* TextureCache<P>::TryFindFramebufferImageView(VAddr cpu_addr) {
    // TODO: Properly implement this
-    const auto it = page_table.find(cpu_addr >> PAGE_BITS);
+    const auto it = page_table.find(cpu_addr >> PAGE_SHIFT);
    if (it == page_table.end()) {
        return nullptr;
    }
@@ -883,7 +883,6 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
    if (!cpu_addr) {
        return ImageId{};
    }
-    const bool broken_views = runtime.HasBrokenTextureViewFormats();
    ImageId image_id;
    const auto lambda = [&](ImageId existing_image_id, ImageBase& existing_image) {
        if (info.type == ImageType::Linear || existing_image.info.type == ImageType::Linear) {
@@ -893,11 +892,11 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
            if (existing_image.gpu_addr == gpu_addr && existing.type == info.type &&
                existing.pitch == info.pitch &&
                IsPitchLinearSameSize(existing, info, strict_size) &&
-                IsViewCompatible(existing.format, info.format, broken_views)) {
+                IsViewCompatible(existing.format, info.format)) {
                image_id = existing_image_id;
                return true;
            }
-        } else if (IsSubresource(info, existing_image, gpu_addr, options, broken_views)) {
+        } else if (IsSubresource(info, existing_image, gpu_addr, options)) {
            image_id = existing_image_id;
            return true;
        }
@@ -927,7 +926,6 @@ template <class P>
 ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VAddr cpu_addr) {
    ImageInfo new_info = info;
    const size_t size_bytes = CalculateGuestSizeInBytes(new_info);
-    const bool broken_views = runtime.HasBrokenTextureViewFormats();
    std::vector<ImageId> overlap_ids;
    std::vector<ImageId> left_aliased_ids;
    std::vector<ImageId> right_aliased_ids;
@@ -942,9 +940,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
            }
            return;
        }
-        static constexpr bool strict_size = true;
-        const std::optional<OverlapResult> solution =
-            ResolveOverlap(new_info, gpu_addr, cpu_addr, overlap, strict_size, broken_views);
+        const auto solution = ResolveOverlap(new_info, gpu_addr, cpu_addr, overlap, true);
        if (solution) {
            gpu_addr = solution->gpu_addr;
            cpu_addr = solution->cpu_addr;
@@ -954,10 +950,9 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
        }
        static constexpr auto options = RelaxedOptions::Size | RelaxedOptions::Format;
        const ImageBase new_image_base(new_info, gpu_addr, cpu_addr);
-        if (IsSubresource(new_info, overlap, gpu_addr, options, broken_views)) {
+        if (IsSubresource(new_info, overlap, gpu_addr, options)) {
            left_aliased_ids.push_back(overlap_id);
-        } else if (IsSubresource(overlap.info, new_image_base, overlap.gpu_addr, options,
-                                 broken_views)) {
+        } else if (IsSubresource(overlap.info, new_image_base, overlap.gpu_addr, options)) {
            right_aliased_ids.push_back(overlap_id);
        }
    });
@@ -1170,13 +1165,13 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
    ForEachPage(image.cpu_addr, image.guest_size_bytes, [this, image_id](u64 page) {
        const auto page_it = page_table.find(page);
        if (page_it == page_table.end()) {
-            UNREACHABLE_MSG("Unregistering unregistered page=0x{:x}", page << PAGE_BITS);
+            UNREACHABLE_MSG("Unregistering unregistered page=0x{:x}", page << PAGE_SHIFT);
            return;
        }
        std::vector<ImageId>& image_ids = page_it->second;
        const auto vector_it = std::ranges::find(image_ids, image_id);
        if (vector_it == image_ids.end()) {
-            UNREACHABLE_MSG("Unregistering unregistered image in page=0x{:x}", page << PAGE_BITS);
+            UNREACHABLE_MSG("Unregistering unregistered image in page=0x{:x}", page << PAGE_SHIFT);
            return;
        }
        image_ids.erase(vector_it);
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -1069,13 +1069,13 @@ bool IsPitchLinearSameSize(const ImageInfo& lhs, const ImageInfo& rhs, bool stri

 std::optional<OverlapResult> ResolveOverlap(const ImageInfo& new_info, GPUVAddr gpu_addr,
                                            VAddr cpu_addr, const ImageBase& overlap,
-                                            bool strict_size, bool broken_views) {
+                                            bool strict_size) {
    ASSERT(new_info.type != ImageType::Linear);
    ASSERT(overlap.info.type != ImageType::Linear);
    if (!IsLayerStrideCompatible(new_info, overlap.info)) {
        return std::nullopt;
    }
-    if (!IsViewCompatible(overlap.info.format, new_info.format, broken_views)) {
+    if (!IsViewCompatible(overlap.info.format, new_info.format)) {
        return std::nullopt;
    }
    if (gpu_addr == overlap.gpu_addr) {
@@ -1118,15 +1118,14 @@ bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs) {
 }

 std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const ImageBase& image,
-                                               GPUVAddr candidate_addr, RelaxedOptions options,
-                                               bool broken_views) {
+                                               GPUVAddr candidate_addr, RelaxedOptions options) {
    const std::optional<SubresourceBase> base = image.TryFindBase(candidate_addr);
    if (!base) {
        return std::nullopt;
    }
    const ImageInfo& existing = image.info;
    if (False(options & RelaxedOptions::Format)) {
-        if (!IsViewCompatible(existing.format, candidate.format, broken_views)) {
+        if (!IsViewCompatible(existing.format, candidate.format)) {
            return std::nullopt;
        }
    }
@@ -1163,8 +1162,8 @@ std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const
 }

 bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr candidate_addr,
-                   RelaxedOptions options, bool broken_views) {
-    return FindSubresource(candidate, image, candidate_addr, options, broken_views).has_value();
+                   RelaxedOptions options) {
+    return FindSubresource(candidate, image, candidate_addr, options).has_value();
 }

 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
--- a/src/video_core/texture_cache/util.h
+++ b/src/video_core/texture_cache/util.h
@@ -87,19 +87,17 @@ void SwizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, const Ima
 [[nodiscard]] std::optional<OverlapResult> ResolveOverlap(const ImageInfo& new_info,
                                                          GPUVAddr gpu_addr, VAddr cpu_addr,
                                                          const ImageBase& overlap,
-                                                          bool strict_size, bool broken_views);
+                                                          bool strict_size);

 [[nodiscard]] bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs);

 [[nodiscard]] std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate,
                                                             const ImageBase& image,
                                                             GPUVAddr candidate_addr,
-                                                             RelaxedOptions options,
-                                                             bool broken_views);
+                                                             RelaxedOptions options);

 [[nodiscard]] bool IsSubresource(const ImageInfo& candidate, const ImageBase& image,
-                                 GPUVAddr candidate_addr, RelaxedOptions options,
-                                 bool broken_views);
+                                 GPUVAddr candidate_addr, RelaxedOptions options);

 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
                      const ImageBase* src);
--- a/src/video_core/vulkan_common/vulkan_library.cpp
+++ b/src/video_core/vulkan_common/vulkan_library.cpp
@@ -20,7 +20,7 @@ Common::DynamicLibrary OpenLibrary() {
        // Use the libvulkan.dylib from the application bundle.
        const std::string filename =
            Common::FS::GetBundleDirectory() + "/Contents/Frameworks/libvulkan.dylib";
-        void(library.Open(filename.c_str()));
+        library.Open(filename.c_str());
    }
 #else
    std::string filename = Common::DynamicLibrary::GetVersionedFilename("vulkan", 1);
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -397,7 +397,7 @@ void GRenderWindow::mousePressEvent(QMouseEvent* event) {
        this->TouchPressed(x, y);
    }

-    emit MouseActivity();
+    QWidget::mousePressEvent(event);
 }

 void GRenderWindow::mouseMoveEvent(QMouseEvent* event) {
@@ -411,7 +411,7 @@ void GRenderWindow::mouseMoveEvent(QMouseEvent* event) {
    input_subsystem->GetMouse()->MouseMove(x, y);
    this->TouchMoved(x, y);

-    emit MouseActivity();
+    QWidget::mouseMoveEvent(event);
 }

 void GRenderWindow::mouseReleaseEvent(QMouseEvent* event) {
@@ -688,10 +688,3 @@ void GRenderWindow::showEvent(QShowEvent* event) {
    connect(windowHandle(), &QWindow::screenChanged, this, &GRenderWindow::OnFramebufferSizeChanged,
            Qt::UniqueConnection);
 }
-
-bool GRenderWindow::eventFilter(QObject* object, QEvent* event) {
-    if (event->type() == QEvent::HoverMove) {
-        emit MouseActivity();
-    }
-    return false;
-}
--- a/src/yuzu/bootmanager.h
+++ b/src/yuzu/bootmanager.h
@@ -184,7 +184,6 @@ signals:
    void Closed();
    void FirstFrameDisplayed();
    void ExecuteProgramSignal(std::size_t program_index);
-    void MouseActivity();

 private:
    void TouchBeginEvent(const QTouchEvent* event);
@@ -217,5 +216,4 @@ private:

 protected:
    void showEvent(QShowEvent* event) override;
-    bool eventFilter(QObject* object, QEvent* event) override;
 };
--- a/Show More
+++ b/Show More