[vk] macro-ify PixelSurface and SurfaceFormat lists

src/core/CMakeLists.txt

@@ -17,6 +17,8 @@ add_library(core STATIC
     constants.h
     core.cpp
     core.h
+    game_settings.cpp
+    game_settings.h
     core_timing.cpp
     core_timing.h
     cpu_manager.cpp
@@ -43,11 +45,7 @@ add_library(core STATIC
     device_memory.cpp
     device_memory.h
     device_memory_manager.h
-    device_memory.h
-    device_memory_manager.h
     device_memory_manager.inc
-    internal_network/legacy_online.cpp
-    internal_network/legacy_online.h
     file_sys/bis_factory.cpp
     file_sys/bis_factory.h
     file_sys/card_image.cpp

src/core/core.cpp

@@ -49,7 +49,6 @@
 #include "core/hle/service/services.h"
 #include "core/hle/service/set/system_settings_server.h"
 #include "core/hle/service/sm/sm.h"
-#include "core/internal_network/legacy_online.h"
 #include "core/internal_network/network.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
@@ -138,13 +137,6 @@ struct System::Impl {
         kernel.SetMulticore(is_multicore);
         cpu_manager.SetMulticore(is_multicore);
         cpu_manager.SetAsyncGpu(is_async_gpu);
-        cpu_manager.SetMulticore(is_multicore);
-        cpu_manager.SetAsyncGpu(is_async_gpu);
-
-        if (!legacy_online) {
-            legacy_online = std::make_unique<Network::LegacyOnlineService>();
-            legacy_online->Start();
-        }
     }
 
     void ReinitializeIfNecessary(System& system) {
@@ -301,48 +293,6 @@ struct System::Impl {
         return SystemResultStatus::Success;
     }
 
-
-    void LoadOverrides(u64 programId) const {
-        std::string vendor = gpu_core->Renderer().GetDeviceVendor();
-        LOG_INFO(Core, "GPU Vendor: {}", vendor);
-
-        // Reset all per-game flags
-        Settings::values.use_squashed_iterated_blend = false;
-
-        // Insert PC overrides here
-
-    #ifdef ANDROID
-        // Example on how to set a setting based on the program ID and vendor
-        if (programId == 0x010028600EBDA000 && vendor == "Mali") { // Mario 3d World
-          // Settings::values.example = true;
-        }
-
-        // Example array of program IDs
-        const std::array<u64, 10> example_array = {
-                //0xprogramId
-                0x0004000000033400, // Game 1
-                0x0004000000033500 // Game 2
-                // And so on
-        };
-
-        for (auto id : example_array) {
-            if (programId == id) {
-             // Settings::values.example = true;
-                break;
-            }
-        }
-
-    #endif
-
-        // Ninja Gaiden Ragebound
-        constexpr u64 ngr = 0x0100781020710000ULL;
-
-        if (programId == ngr) {
-            LOG_INFO(Core, "Enabling game specifc override: use_squashed_iterated_blend");
-            Settings::values.use_squashed_iterated_blend = true;
-        }
-    }
-
     SystemResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
                             const std::string& filepath,
                             Service::AM::FrontendAppletParameters& params) {
@@ -428,7 +378,8 @@ struct System::Impl {
             LOG_ERROR(Core, "Failed to find program id for ROM");
         }
 
-        LoadOverrides(program_id);
+
+        GameSettings::LoadOverrides(program_id, gpu_core->Renderer());
         if (auto room_member = Network::GetRoomMember().lock()) {
             Network::GameInfo game_info;
             game_info.name = name;
@@ -477,11 +428,6 @@ struct System::Impl {
         stop_event = {};
         Network::RestartSocketOperations();
 
-        if (legacy_online) {
-            legacy_online->Stop();
-            legacy_online.reset();
-        }
-
         if (auto room_member = Network::GetRoomMember().lock()) {
             Network::GameInfo game_info{};
             room_member->SendGameInfo(game_info);
@@ -570,9 +516,6 @@ struct System::Impl {
 
     /// Network instance
     Network::NetworkInstance network_instance;
-    
-    /// Legacy Online Service
-    std::unique_ptr<Network::LegacyOnlineService> legacy_online;
 
     /// Debugger
     std::unique_ptr<Core::Debugger> debugger;

src/core/file_sys/savedata_factory.cpp

@@ -11,8 +11,6 @@
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs/vfs.h"
-#include "core/file_sys/sdmc_factory.h"
-#include "core/hle/service/filesystem/filesystem.h"
 
 namespace FileSys {
 
@@ -76,97 +74,20 @@ VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribut
 
 VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
 
-    u64 target_program_id = meta.program_id;
-    // CRITICAL FIX: If the game requests Cache/Temp with ProgramID 0 (generic),
-    // we MUST redirect it to the actual running TitleID, otherwise it looks in '.../0000000000000000'.
-    if ((meta.type == SaveDataType::Cache || meta.type == SaveDataType::Temporary) && target_program_id == 0) {
-        target_program_id = system.GetApplicationProcessProgramID();
-        LOG_INFO(Service_FS, "Redirecting generic Cache request (ID 0) to active TitleID: {:016X}", target_program_id);
-    }
-
-    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, target_program_id,
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
                                             meta.user_id, meta.system_save_data_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
-    // Fallback for Ryujinx-style cache paths: sdcard/Nintendo/save/{TitleID} (No /cache/ subdir)
-    // Also include Temporary, as games like Just Dance use Temporary storage for cache-like data (MapBaseCache),
-    // and Ryujinx stores this in the same simple 'save/{ID}' structure.
-    // Fallback logic removed. We now enforce standard paths.
-    // User instructions will direct them to the correct folder.
-
-    if (out == nullptr) {
-        LOG_WARNING(Service_FS, "Cache/Save path NOT FOUND: '{}'. Auto-create={}", save_directory, auto_create);
-    } else {
-        LOG_INFO(Service_FS, "Cache/Save path FOUND: '{}'", save_directory);
-    }
-
     if (out == nullptr && (ShouldSaveDataBeAutomaticallyCreated(space, meta) && auto_create)) {
-        LOG_INFO(Service_FS, "Auto-creating save directory...");
         return Create(space, meta);
     }
 
-    if (out != nullptr) {
-        // Some emulators (Ryujinx) or even different firmware versions may rely on the commit
-        // directories /0 or /1 being present for cache or save data.
-        // We prioritizing /1 as it usually implies a newer commit if both exist,
-        // but /0 is what's commonly used by Ryujinx for cache.
-
-        // Ryujinx behavior: If 0 exists and 1 does not, copy 0 to 1.
-        auto dir_0 = out->GetSubdirectory("0");
-        auto dir_1 = out->GetSubdirectory("1");
-
-        if (dir_0) LOG_INFO(Service_FS, "Found subdirectory '0' in save path.");
-        if (dir_1) LOG_INFO(Service_FS, "Found subdirectory '1' in save path.");
-
-        if (dir_0 != nullptr && dir_1 == nullptr) {
-            LOG_INFO(Service_FS, "Ryujinx structure detected: '0' exists, '1' missing. Copying 0->1 for compatibility.");
-            dir_1 = out->CreateSubdirectory("1");
-            if (dir_1 != nullptr) {
-                // Copy contents from 0 to 1
-                VfsRawCopyD(dir_0, dir_1);
-            }
-        }
-
-        // Check for 'Addressables' and 'Addressables2' and delete 'json.cache' if present.
-        // This is a specific workaround for games (e.g. Just Dance) that freeze if they find old cache metadata.
-        // We force them to regenerate it.
-        const auto CleanCache = [](VirtualDir root) {
-            if (root == nullptr) return;
-            const char* subdirs[] = {"Addressables", "Addressables2"};
-            for (const char* subdir_name : subdirs) {
-                auto subdir = root->GetSubdirectory(subdir_name);
-                if (subdir != nullptr) {
-                    if (subdir->DeleteFile("json.cache")) {
-                        LOG_INFO(Service_FS, "Deleted stale 'json.cache' in '{}'", subdir_name);
-                    }
-                }
-            }
-        };
-
-        if (dir_1 != nullptr) {
-            LOG_INFO(Service_FS, "Returning subdirectory '1' as Save Root.");
-            CleanCache(dir_1);
-            return dir_1;
-        }
-        if (dir_0 != nullptr) {
-            LOG_INFO(Service_FS, "Returning subdirectory '0' as Save Root.");
-            CleanCache(dir_0);
-            return dir_0;
-        }
-        
-        LOG_INFO(Service_FS, "No '0' or '1' subdirectories found. Returning parent folder as Save Root.");
-        CleanCache(out);
-    }
-
     return out;
 }
 
 VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {
-    const auto path = GetSaveDataSpaceIdPath(space);
-    // Ensure the directory exists, otherwise FindAllSaves fails.
-    return GetOrCreateDirectoryRelative(dir, path);
-    // return dir->GetDirectoryRelative(GetSaveDataSpaceIdPath(space));
+    return dir->GetDirectoryRelative(GetSaveDataSpaceIdPath(space));
 }
 
 std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
@@ -175,12 +96,12 @@ std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
         return "/system/";
     case SaveDataSpaceId::User:
     case SaveDataSpaceId::SdUser:
-    case SaveDataSpaceId::Temporary: // Map into User so we can find the save/ folder
         return "/user/";
+    case SaveDataSpaceId::Temporary:
+        return "/temp/";
     default:
-        // ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
-        LOG_WARNING(Service_FS, "Unrecognized SaveDataSpaceId: {:02X}, defaulting to /user/", static_cast<u8>(space));
-        return "/user/"; 
+        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
+        return "/unrecognized/"; ///< To prevent corruption when ignoring asserts.
     }
 }
 
@@ -216,9 +137,8 @@ std::string SaveDataFactory::GetFullPath(ProgramId program_id, VirtualDir dir,
         return fmt::format("{}save/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
     case SaveDataType::Temporary:
-        // Unified Cache/Temporary Path: Always use save/cache/{TitleID}
-        // This simplifies user instructions and avoids UUID/Permission issues.
-        return fmt::format("{}save/cache/{:016X}", out, title_id);
+        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+                           title_id);
     case SaveDataType::Cache:
         return fmt::format("{}save/cache/{:016X}", out, title_id);
     default:

src/core/hle/service/filesystem/filesystem.cpp

@@ -686,154 +686,6 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
     using EdenPath = Common::FS::EdenPath;
     const auto sdmc_dir_path = Common::FS::GetEdenPath(EdenPath::SDMCDir);
     const auto sdmc_load_dir_path = sdmc_dir_path / "atmosphere/contents";
-
-    // If the NAND user save location doesn't exist but the SDMC contains
-    // Nintendo/save (common portable save structure), create a host-side
-    // symlink so the emulator will see those saves under the expected NAND path.
-    // This helps users who placed saves under `<eden>/user/sdmc/Nintendo/save/...`.
-    try {
-        const auto nand_fs_path = Common::FS::GetEdenPath(EdenPath::NANDDir);
-        const auto sdmc_fs_path = sdmc_dir_path;
-        const auto nand_user_save_path = nand_fs_path / "user" / "save";
-        const auto sdmc_nintendo_save_path = sdmc_fs_path / "Nintendo" / "save";
-
-        std::error_code ec;
-        if (!std::filesystem::exists(nand_user_save_path) &&
-            std::filesystem::exists(sdmc_nintendo_save_path)) {
-            std::filesystem::create_directory_symlink(sdmc_nintendo_save_path, nand_user_save_path, ec);
-            if (ec) {
-                LOG_WARNING(Service_FS, "Could not create symlink {} -> {}: {}",
-                            Common::FS::PathToUTF8String(nand_user_save_path),
-                            Common::FS::PathToUTF8String(sdmc_nintendo_save_path), ec.message());
-
-                // Fallback: copy the SDMC saves into the NAND save folder so the emulator can see them
-                try {
-                    if (!std::filesystem::exists(nand_user_save_path)) {
-                        std::filesystem::create_directories(nand_user_save_path);
-                    }
-                    std::filesystem::copy(sdmc_nintendo_save_path, nand_user_save_path,
-                                          std::filesystem::copy_options::recursive |
-                                              std::filesystem::copy_options::skip_existing,
-                                          ec);
-                    if (ec) {
-                        LOG_WARNING(Service_FS, "Failed to copy SDMC saves to {}: {}",
-                                    Common::FS::PathToUTF8String(nand_user_save_path), ec.message());
-                    } else {
-                        LOG_INFO(Service_FS, "Copied SDMC saves to NAND save path: {} -> {}",
-                                 Common::FS::PathToUTF8String(sdmc_nintendo_save_path),
-                                 Common::FS::PathToUTF8String(nand_user_save_path));
-                    }
-                } catch (const std::exception& ex) {
-                    LOG_WARNING(Service_FS, "Exception while copying SDMC saves: {}", ex.what());
-                }
-            } else {
-                LOG_INFO(Service_FS, "Linked NAND save path to SDMC saves: {} -> {}",
-                         Common::FS::PathToUTF8String(nand_user_save_path),
-                         Common::FS::PathToUTF8String(sdmc_nintendo_save_path));
-            }
-        }
-
-            // Also support official-style SD cache directory name used by some Switch setups.
-            // If users placed saves or cache under `<eden>/user/sdmc/Nintendo/SD_Cache.0000`,
-            // expose it to the NAND user save path as well so the emulator can find them.
-            const auto sdmc_nintendo_cache_path = sdmc_fs_path / "Nintendo" / "SD_Cache.0000";
-            if (!std::filesystem::exists(nand_user_save_path) &&
-                std::filesystem::exists(sdmc_nintendo_cache_path)) {
-                std::error_code ec2;
-                std::filesystem::create_directory_symlink(sdmc_nintendo_cache_path, nand_user_save_path,
-                                                         ec2);
-                if (ec2) {
-                    LOG_WARNING(Service_FS,
-                                "Could not create symlink {} -> {}: {}",
-                                Common::FS::PathToUTF8String(nand_user_save_path),
-                                Common::FS::PathToUTF8String(sdmc_nintendo_cache_path), ec2.message());
-
-                    // Fallback: copy the SDMC cache into the NAND save folder so the emulator can see them
-                    try {
-                        if (!std::filesystem::exists(nand_user_save_path)) {
-                            std::filesystem::create_directories(nand_user_save_path);
-                        }
-                        std::filesystem::copy(sdmc_nintendo_cache_path, nand_user_save_path,
-                                              std::filesystem::copy_options::recursive |
-                                                  std::filesystem::copy_options::skip_existing,
-                                              ec2);
-                        if (ec2) {
-                            LOG_WARNING(Service_FS, "Failed to copy SDMC cache to {}: {}",
-                                        Common::FS::PathToUTF8String(nand_user_save_path), ec2.message());
-                        } else {
-                            LOG_INFO(Service_FS, "Copied SDMC cache to NAND save path: {} -> {}",
-                                     Common::FS::PathToUTF8String(sdmc_nintendo_cache_path),
-                                     Common::FS::PathToUTF8String(nand_user_save_path));
-                        }
-                    } catch (const std::exception& ex) {
-                        LOG_WARNING(Service_FS, "Exception while copying SDMC cache: {}", ex.what());
-                    }
-                } else {
-                    LOG_INFO(Service_FS, "Linked NAND save path to SDMC cache: {} -> {}",
-                             Common::FS::PathToUTF8String(nand_user_save_path),
-                             Common::FS::PathToUTF8String(sdmc_nintendo_cache_path));
-                }
-            }
-
-            // If the NAND save folder already exists, ensure individual entries from
-            // SDMC (both `Nintendo/save` and `Nintendo/SD_Cache.0000`) are visible
-            // inside it: create per-entry symlinks (with copy fallback) for missing
-            // title/account directories so saves placed in SDMC are reachable.
-            auto try_merge_sdmc_entries = [&](const std::filesystem::path& sdmc_src) {
-                try {
-                    if (!std::filesystem::exists(sdmc_src))
-                        return;
-
-                    std::error_code ec;
-                    if (!std::filesystem::exists(nand_user_save_path))
-                        std::filesystem::create_directories(nand_user_save_path, ec);
-
-                    for (auto& ent : std::filesystem::directory_iterator(sdmc_src)) {
-                        const auto name = ent.path().filename();
-                        const auto target = nand_user_save_path / name;
-                        if (std::filesystem::exists(target))
-                            continue;
-
-                        std::error_code ec2;
-                        std::filesystem::create_directory_symlink(ent.path(), target, ec2);
-                        if (ec2) {
-                            LOG_WARNING(Service_FS, "Could not create symlink {} -> {}: {}",
-                                        Common::FS::PathToUTF8String(target),
-                                        Common::FS::PathToUTF8String(ent.path()), ec2.message());
-                            try {
-                                std::filesystem::copy(ent.path(), target,
-                                                      std::filesystem::copy_options::recursive |
-                                                          std::filesystem::copy_options::skip_existing,
-                                                      ec2);
-                                if (ec2) {
-                                    LOG_WARNING(Service_FS, "Failed to copy {} -> {}: {}",
-                                                Common::FS::PathToUTF8String(ent.path()),
-                                                Common::FS::PathToUTF8String(target), ec2.message());
-                                } else {
-                                    LOG_INFO(Service_FS, "Copied SDMC entry to NAND: {} -> {}",
-                                             Common::FS::PathToUTF8String(ent.path()),
-                                             Common::FS::PathToUTF8String(target));
-                                }
-                            } catch (const std::exception& ex) {
-                                LOG_WARNING(Service_FS, "Exception while copying SDMC entry: {}",
-                                            ex.what());
-                            }
-                        } else {
-                            LOG_INFO(Service_FS, "Linked NAND entry to SDMC: {} -> {}",
-                                     Common::FS::PathToUTF8String(target),
-                                     Common::FS::PathToUTF8String(ent.path()));
-                        }
-                    }
-                } catch (const std::exception& ex) {
-                    LOG_WARNING(Service_FS, "Exception while merging SDMC entries: {}", ex.what());
-                }
-            };
-
-            try_merge_sdmc_entries(sdmc_nintendo_save_path);
-            try_merge_sdmc_entries(sdmc_nintendo_cache_path);
-    } catch (const std::exception& e) {
-        LOG_WARNING(Service_FS, "Exception while linking SDMC saves: {}", e.what());
-    }
     const auto rw_mode = FileSys::OpenMode::ReadWrite;
 
     auto nand_directory =

src/core/internal_network/legacy_online.cpp

@@ -1,164 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/internal_network/legacy_online.h"
-
-#include <cstring>
-#include <iostream>
-
-#ifdef _WIN32
-#include <winsock2.h>
-#else
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <unistd.h>
-#endif
-
-#include "common/logging/log.h"
-
-namespace Network {
-
-LegacyOnlineService::LegacyOnlineService() = default;
-
-LegacyOnlineService::~LegacyOnlineService() {
-    Stop();
-}
-
-void LegacyOnlineService::Start() {
-    if (is_running) {
-        return;
-    }
-
-    is_running = true;
-    worker_thread = std::thread(&LegacyOnlineService::ServerLoop, this);
-}
-
-void LegacyOnlineService::Stop() {
-    if (!is_running) {
-        return;
-    }
-
-    is_running = false;
-
-    // Close socket to wake up the thread if it's blocked on recvfrom
-    if (socket_fd != ~0ULL) {
-#ifdef _WIN32
-        closesocket(static_cast<SOCKET>(socket_fd));
-#else
-        close(static_cast<int>(socket_fd));
-#endif
-        socket_fd = ~0ULL;
-    }
-
-    if (worker_thread.joinable()) {
-        worker_thread.join();
-    }
-}
-
-void LegacyOnlineService::ServerLoop() {
-    LOG_INFO(Network, "Starting Legacy Online UDP Server on port {}", PORT);
-
-#ifdef _WIN32
-    WSADATA wsa_data;
-    if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
-        LOG_ERROR(Network, "WSAStartup failed");
-        is_running = false;
-        return;
-    }
-#endif
-
-
-
-    auto s = socket(AF_INET, SOCK_DGRAM, 0);
-#ifdef _WIN32
-    if (s == INVALID_SOCKET) {
-#else
-    if (s == -1) {
-#endif
-        LOG_ERROR(Network, "Failed to create socket");
-        is_running = false;
-        return;
-    }
-    socket_fd = static_cast<uintptr_t>(s);
-
-    int opt = 1;
-#ifdef _WIN32
-    setsockopt(static_cast<SOCKET>(socket_fd), SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt));
-#else
-    setsockopt(static_cast<int>(socket_fd), SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-#endif
-
-    sockaddr_in server_addr{};
-    server_addr.sin_family = AF_INET;
-    server_addr.sin_addr.s_addr = INADDR_ANY;
-    server_addr.sin_port = htons(PORT);
-
-    int res = -1;
-#ifdef _WIN32
-    res = bind(static_cast<SOCKET>(socket_fd), (sockaddr*)&server_addr, sizeof(server_addr));
-#else
-    res = bind(static_cast<int>(socket_fd), (sockaddr*)&server_addr, sizeof(server_addr));
-#endif
-
-    if (res < 0) {
-        LOG_ERROR(Network, "Failed to bind to port {}", PORT);
-#ifdef _WIN32
-        closesocket(static_cast<SOCKET>(socket_fd));
-#else
-        close(static_cast<int>(socket_fd));
-#endif
-        socket_fd = ~0ULL;
-        is_running = false;
-        return;
-    }
-
-    LOG_INFO(Network, "Legacy Online Server waiting for messages...");
-    
-    // Set a timeout for recvfrom so check is_running periodically if not closed via socket
-    // Alternatively, closing the socket (as done in Stop) will cause recvfrom to return error
-    
-    char buffer[2048];
-    while (is_running) {
-        sockaddr_in client_addr{};
-#ifdef _WIN32
-        int client_len = sizeof(client_addr);
-#else
-        socklen_t client_len = sizeof(client_addr);
-#endif
-
-        int len = -1;
-#ifdef _WIN32
-        len = recvfrom(static_cast<SOCKET>(socket_fd), buffer, sizeof(buffer), 0, (sockaddr*)&client_addr, &client_len);
-#else
-        len = recvfrom(static_cast<int>(socket_fd), buffer, sizeof(buffer), 0, (sockaddr*)&client_addr, &client_len);
-#endif
-
-        if (!is_running) break;
-
-        if (len > 0) {
-            // Send ACK
-            const char* ack_msg = "ACK";
-#ifdef _WIN32
-            sendto(static_cast<SOCKET>(socket_fd), ack_msg, static_cast<int>(strlen(ack_msg)), 0, (sockaddr*)&client_addr, client_len);
-#else
-            sendto(static_cast<int>(socket_fd), ack_msg, strlen(ack_msg), 0, (sockaddr*)&client_addr, client_len);
-#endif
-        } else {
-             // Error or closed
-             // If we closed the socket in Stop(), this will likely trigger.
-             break;
-        }
-    }
-
-#ifdef _WIN32
-    if (socket_fd != ~0ULL) closesocket(static_cast<SOCKET>(socket_fd));
-    WSACleanup();
-#else
-    if (socket_fd != ~0ULL) close(static_cast<int>(socket_fd));
-#endif
-    socket_fd = ~0ULL;
-    LOG_INFO(Network, "Legacy Online Server stopped");
-}
-
-} // namespace Network

src/core/internal_network/legacy_online.h

@@ -1,30 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <cstdint>
-#include <memory>
-#include <thread>
-
-namespace Network {
-
-class LegacyOnlineService {
-public:
-    LegacyOnlineService();
-    ~LegacyOnlineService();
-
-    void Start();
-    void Stop();
-
-private:
-    void ServerLoop();
-
-    std::atomic_bool is_running{false};
-    std::thread worker_thread;
-    uintptr_t socket_fd{~0ULL}; // ~0ULL is approx -1 equivalent for unsigned
-    static constexpr int PORT = 6000;
-};
-
-} // namespace Network

src/video_core/host1x/vic.cpp

@@ -107,19 +107,9 @@ void Vic::Execute() {
     auto output_height{config.output_surface_config.out_surface_height + 1};
     output_surface.resize_destructive(output_width * output_height);
 
-    // Initialize the surface with the appropriate black pixel
-    Pixel black_pixel{};
-    if (config.output_surface_config.out_pixel_format == VideoPixelFormat::Y8__V8U8_N420) {
-        // Y=0, U=512, V=512 (10-bit), A=0
-        black_pixel = {0, 512, 512, 0};
-    } else {
-        // R=0, G=0, B=0, A=0
-        black_pixel = {0, 0, 0, 0};
-    }
-    std::fill(output_surface.begin(), output_surface.end(), black_pixel);
-
     if (Settings::values.nvdec_emulation.GetValue() == Settings::NvdecEmulation::Off) [[unlikely]] {
-
+        // Fill the frame with black, as otherwise they can have random data and be very glitchy.
+        std::fill(output_surface.begin(), output_surface.end(), Pixel{});
     } else {
         for (size_t i = 0; i < config.slot_structs.size(); i++) {
             auto& slot_config{config.slot_structs[i]};
@@ -132,18 +122,7 @@ void Vic::Execute() {
                 nvdec_id = frame_queue.VicFindNvdecFdFromOffset(luma_offset);
             }
 
-            auto frame = frame_queue.GetFrame(nvdec_id, luma_offset);
-            if (!frame) {
-                // We might've failed to find the frame, or the nvdec id is stale/wrong.
-                // Try to find the nvdec id again.
-                const s32 new_id = frame_queue.VicFindNvdecFdFromOffset(luma_offset);
-                if (new_id != -1) {
-                    nvdec_id = new_id;
-                    frame = frame_queue.GetFrame(nvdec_id, luma_offset);
-                }
-            }
-
-            if (frame) {
+            if (auto frame = frame_queue.GetFrame(nvdec_id, luma_offset); frame) {
                 if (frame.get()) {
                     switch (frame->GetPixelFormat()) {
                     case AV_PIX_FMT_YUV420P:
@@ -191,7 +170,6 @@ void Vic::ReadProgressiveY8__V8U8_N420(const SlotStruct& slot, std::span<const P
     }
 
     slot_surface.resize_destructive(out_luma_width * out_luma_height);
-    std::fill(slot_surface.begin(), slot_surface.end(), Pixel{0, 512, 512, 0});
 
     const auto in_luma_width{(std::min)(frame->GetWidth(), s32(out_luma_width))};
     const auto in_luma_height{(std::min)(frame->GetHeight(), s32(out_luma_height))};
@@ -241,7 +219,6 @@ void Vic::ReadInterlacedY8__V8U8_N420(const SlotStruct& slot, std::span<const Pl
     const auto out_luma_stride{out_luma_width};
 
     slot_surface.resize_destructive(out_luma_width * out_luma_height);
-    std::fill(slot_surface.begin(), slot_surface.end(), Pixel{0, 512, 512, 0});
 
     const auto in_luma_width{(std::min)(frame->GetWidth(), s32(out_luma_width))};
     [[maybe_unused]] const auto in_luma_height{

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -20,116 +20,122 @@ struct FormatTuple {
     GLenum format = GL_NONE;
     GLenum type = GL_NONE;
 };
-
+#define SURFACE_FORMAT_LIST \
+    SURFACE_FORMAT_ELEM(GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, A8B8G8R8_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGBA8_SNORM, GL_RGBA, GL_BYTE, A8B8G8R8_SNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, A8B8G8R8_SINT) \
+    SURFACE_FORMAT_ELEM(GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, A8B8G8R8_UINT) \
+    SURFACE_FORMAT_ELEM(GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, R5G6B5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, B5G6R5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGB5_A1, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, A1R5G5B5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, A2B10G10R10_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGB10_A2UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV, A2B10G10R10_UINT) \
+    SURFACE_FORMAT_ELEM(GL_RGB10_A2, GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV, A2R10G10B10_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, A1B5G5R5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, A5B5G5R1_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_R8, GL_RED, GL_UNSIGNED_BYTE, R8_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_R8_SNORM, GL_RED, GL_BYTE, R8_SNORM) \
+    SURFACE_FORMAT_ELEM(GL_R8I, GL_RED_INTEGER, GL_BYTE, R8_SINT) \
+    SURFACE_FORMAT_ELEM(GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, R8_UINT) \
+    SURFACE_FORMAT_ELEM(GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT, R16G16B16A16_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT, R16G16B16A16_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGBA16_SNORM, GL_RGBA, GL_SHORT, R16G16B16A16_SNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT, R16G16B16A16_SINT) \
+    SURFACE_FORMAT_ELEM(GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, R16G16B16A16_UINT) \
+    SURFACE_FORMAT_ELEM(GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, B10G11R11_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, R32G32B32A32_UINT) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_NONE, GL_NONE, BC1_RGBA_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_NONE, GL_NONE, BC2_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_NONE, GL_NONE, BC3_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RED_RGTC1, GL_NONE, GL_NONE, BC4_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SIGNED_RED_RGTC1, GL_NONE, GL_NONE, BC4_SNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RG_RGTC2, GL_NONE, GL_NONE, BC5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SIGNED_RG_RGTC2, GL_NONE, GL_NONE, BC5_SNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_BPTC_UNORM, GL_NONE, GL_NONE, BC7_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, GL_NONE, GL_NONE, BC6H_UFLOAT) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, GL_NONE, GL_NONE, BC6H_SFLOAT) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_4x4_KHR, GL_NONE, GL_NONE, ASTC_2D_4X4_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGBA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, B8G8R8A8_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGBA32F, GL_RGBA, GL_FLOAT, R32G32B32A32_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_RGBA32I, GL_RGBA_INTEGER, GL_INT, R32G32B32A32_SINT) \
+    SURFACE_FORMAT_ELEM(GL_RG32F, GL_RG, GL_FLOAT, R32G32_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_RG32I, GL_RG_INTEGER, GL_INT, R32G32_SINT) \
+    SURFACE_FORMAT_ELEM(GL_R32F, GL_RED, GL_FLOAT, R32_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_R16F, GL_RED, GL_HALF_FLOAT, R16_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_R16, GL_RED, GL_UNSIGNED_SHORT, R16_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_R16_SNORM, GL_RED, GL_SHORT, R16_SNORM) \
+    SURFACE_FORMAT_ELEM(GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT, R16_UINT) \
+    SURFACE_FORMAT_ELEM(GL_R16I, GL_RED_INTEGER, GL_SHORT, R16_SINT) \
+    SURFACE_FORMAT_ELEM(GL_RG16, GL_RG, GL_UNSIGNED_SHORT, R16G16_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RG16F, GL_RG, GL_HALF_FLOAT, R16G16_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT, R16G16_UINT) \
+    SURFACE_FORMAT_ELEM(GL_RG16I, GL_RG_INTEGER, GL_SHORT, R16G16_SINT) \
+    SURFACE_FORMAT_ELEM(GL_RG16_SNORM, GL_RG, GL_SHORT, R16G16_SNORM) \
+    SURFACE_FORMAT_ELEM(GL_RGB32F, GL_RGB, GL_FLOAT, R32G32B32_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, A8B8G8R8_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_RG8, GL_RG, GL_UNSIGNED_BYTE, R8G8_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_RG8_SNORM, GL_RG, GL_BYTE, R8G8_SNORM) \
+    SURFACE_FORMAT_ELEM(GL_RG8I, GL_RG_INTEGER, GL_BYTE, R8G8_SINT) \
+    SURFACE_FORMAT_ELEM(GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE, R8G8_UINT) \
+    SURFACE_FORMAT_ELEM(GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, R32G32_UINT) \
+    SURFACE_FORMAT_ELEM(GL_RGB16F, GL_RGBA, GL_HALF_FLOAT, R16G16B16X16_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, R32_UINT) \
+    SURFACE_FORMAT_ELEM(GL_R32I, GL_RED_INTEGER, GL_INT, R32_SINT) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_8x8_KHR, GL_NONE, GL_NONE, ASTC_2D_8X8_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_8x5_KHR, GL_NONE, GL_NONE, ASTC_2D_8X5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_5x4_KHR, GL_NONE, GL_NONE, ASTC_2D_5X4_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, B8G8R8A8_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_NONE, GL_NONE, BC1_RGBA_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_NONE, GL_NONE, BC2_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_NONE, GL_NONE, BC3_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, GL_NONE, GL_NONE, BC7_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV, A4B4G4R4_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_R8, GL_RED, GL_UNSIGNED_BYTE, G4R4_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, GL_NONE, GL_NONE, ASTC_2D_4X4_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, GL_NONE, GL_NONE, ASTC_2D_8X8_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, GL_NONE, GL_NONE, ASTC_2D_8X5_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, GL_NONE, GL_NONE, ASTC_2D_5X4_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_5x5_KHR, GL_NONE, GL_NONE, ASTC_2D_5X5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, GL_NONE, GL_NONE, ASTC_2D_5X5_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_10x8_KHR, GL_NONE, GL_NONE, ASTC_2D_10X8_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, GL_NONE, GL_NONE, ASTC_2D_10X8_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_6x6_KHR, GL_NONE, GL_NONE, ASTC_2D_6X6_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, GL_NONE, GL_NONE, ASTC_2D_6X6_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_10x6_KHR, GL_NONE, GL_NONE, ASTC_2D_10X6_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, GL_NONE, GL_NONE, ASTC_2D_10X6_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_10x5_KHR, GL_NONE, GL_NONE, ASTC_2D_10X5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, GL_NONE, GL_NONE, ASTC_2D_10X5_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_10x10_KHR, GL_NONE, GL_NONE, ASTC_2D_10X10_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, GL_NONE, GL_NONE, ASTC_2D_10X10_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_12x10_KHR, GL_NONE, GL_NONE, ASTC_2D_12X10_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, GL_NONE, GL_NONE, ASTC_2D_12X10_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_12x12_KHR, GL_NONE, GL_NONE, ASTC_2D_12X12_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, GL_NONE, GL_NONE, ASTC_2D_12X12_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_8x6_KHR, GL_NONE, GL_NONE, ASTC_2D_8X6_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, GL_NONE, GL_NONE, ASTC_2D_8X6_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_RGBA_ASTC_6x5_KHR, GL_NONE, GL_NONE, ASTC_2D_6X5_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, GL_NONE, GL_NONE, ASTC_2D_6X5_SRGB) \
+    SURFACE_FORMAT_ELEM(GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV, E5B9G9R9_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, D32_FLOAT) \
+    SURFACE_FORMAT_ELEM(GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, D16_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT_24_8, X8_D24_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_STENCIL_INDEX8, GL_STENCIL, GL_UNSIGNED_BYTE, S8_UINT) \
+    SURFACE_FORMAT_ELEM(GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, D24_UNORM_S8_UINT) \
+    SURFACE_FORMAT_ELEM(GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, S8_UINT_D24_UNORM) \
+    SURFACE_FORMAT_ELEM(GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, D32_FLOAT_S8_UINT)
 constexpr std::array<FormatTuple, VideoCore::Surface::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_RGB10_A2, GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV},           // A2R10G10B10_UNORM
-    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV},             // A1B5G5R5_UNORM
-    {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1},                 // A5B5G5R1_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_INT_8_8_8_8_REV},                 // 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_INT_8_8_8_8_REV},          // B8G8R8A8_SRGB
-    {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_R8, GL_RED, GL_UNSIGNED_BYTE},                                // G4R4_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_10x6_KHR},                               // ASTC_2D_10X6_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR},                       // ASTC_2D_10X6_SRGB
-    {GL_COMPRESSED_RGBA_ASTC_10x5_KHR},                               // ASTC_2D_10X5_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR},                       // ASTC_2D_10X5_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_12x10_KHR},                              // ASTC_2D_12X10_UNORM
-    {GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR},                      // ASTC_2D_12X10_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_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT_24_8}, // X8_D24_UNORM
-    {GL_STENCIL_INDEX8, GL_STENCIL, GL_UNSIGNED_BYTE},                // S8_UINT
-    {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
+#define SURFACE_FORMAT_ELEM(a1, a2, a3, name) {a1, a2, a3},
+    SURFACE_FORMAT_LIST
+#undef SURFACE_FORMAT_ELEM
 }};
-
-inline const FormatTuple& GetFormatTuple(VideoCore::Surface::PixelFormat pixel_format) {
-    ASSERT(static_cast<size_t>(pixel_format) < FORMAT_TABLE.size());
-    return FORMAT_TABLE[static_cast<size_t>(pixel_format)];
+constexpr FormatTuple GetFormatTuple(VideoCore::Surface::PixelFormat pixel_format) noexcept {
+    switch (pixel_format) {
+#define SURFACE_FORMAT_ELEM(a1, a2, a3, name) case VideoCore::Surface::PixelFormat::name: return {a1, a2, a3};
+    SURFACE_FORMAT_LIST
+#undef SURFACE_FORMAT_ELEM
+#undef SURFACE_FORMAT_LIST
+    default: UNREACHABLE();
+    }
 }
 
 inline GLenum VertexFormat(Maxwell::VertexAttribute attrib) {

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -105,148 +105,141 @@ VkCompareOp DepthCompareFunction(Tegra::Texture::DepthCompareFunc depth_compare_
 }
 
 } // namespace Sampler
-
-namespace {
-constexpr u32 Attachable = 1 << 0;
-constexpr u32 Storage = 1 << 1;
-
 struct FormatTuple {
-    VkFormat format; ///< Vulkan format
-    int usage = 0;   ///< Describes image format usage
-} constexpr tex_format_tuples[] = {
-    {VK_FORMAT_A8B8G8R8_UNORM_PACK32, Attachable | Storage},    // A8B8G8R8_UNORM
-    {VK_FORMAT_A8B8G8R8_SNORM_PACK32, Attachable | Storage},    // A8B8G8R8_SNORM
-    {VK_FORMAT_A8B8G8R8_SINT_PACK32, Attachable | Storage},     // A8B8G8R8_SINT
-    {VK_FORMAT_A8B8G8R8_UINT_PACK32, Attachable | Storage},     // A8B8G8R8_UINT
-    {VK_FORMAT_R5G6B5_UNORM_PACK16, Attachable},                // R5G6B5_UNORM
-    {VK_FORMAT_B5G6R5_UNORM_PACK16},                            // B5G6R5_UNORM
-    {VK_FORMAT_A1R5G5B5_UNORM_PACK16, Attachable},              // A1R5G5B5_UNORM
-    {VK_FORMAT_A2B10G10R10_UNORM_PACK32, Attachable | Storage}, // A2B10G10R10_UNORM
-    {VK_FORMAT_A2B10G10R10_UINT_PACK32, Attachable | Storage},  // A2B10G10R10_UINT
-    {VK_FORMAT_A2R10G10B10_UNORM_PACK32, Attachable},           // A2R10G10B10_UNORM
-    {VK_FORMAT_A1R5G5B5_UNORM_PACK16, Attachable},         // A1B5G5R5_UNORM (flipped with swizzle)
-    {VK_FORMAT_R5G5B5A1_UNORM_PACK16},                     // A5B5G5R1_UNORM (specially swizzled)
-    {VK_FORMAT_R8_UNORM, Attachable | Storage},            // R8_UNORM
-    {VK_FORMAT_R8_SNORM, Attachable | Storage},            // R8_SNORM
-    {VK_FORMAT_R8_SINT, Attachable | Storage},             // R8_SINT
-    {VK_FORMAT_R8_UINT, Attachable | Storage},             // R8_UINT
-    {VK_FORMAT_R16G16B16A16_SFLOAT, Attachable | Storage}, // R16G16B16A16_FLOAT
-    {VK_FORMAT_R16G16B16A16_UNORM, Attachable | Storage},  // R16G16B16A16_UNORM
-    {VK_FORMAT_R16G16B16A16_SNORM, Attachable | Storage},  // R16G16B16A16_SNORM
-    {VK_FORMAT_R16G16B16A16_SINT, Attachable | Storage},   // R16G16B16A16_SINT
-    {VK_FORMAT_R16G16B16A16_UINT, Attachable | Storage},   // R16G16B16A16_UINT
-    {VK_FORMAT_B10G11R11_UFLOAT_PACK32, Attachable | Storage}, // B10G11R11_FLOAT
-    {VK_FORMAT_R32G32B32A32_UINT, Attachable | Storage},       // R32G32B32A32_UINT
-    {VK_FORMAT_BC1_RGBA_UNORM_BLOCK},                          // BC1_RGBA_UNORM
-    {VK_FORMAT_BC2_UNORM_BLOCK},                               // BC2_UNORM
-    {VK_FORMAT_BC3_UNORM_BLOCK},                               // BC3_UNORM
-    {VK_FORMAT_BC4_UNORM_BLOCK},                               // BC4_UNORM
-    {VK_FORMAT_BC4_SNORM_BLOCK},                               // BC4_SNORM
-    {VK_FORMAT_BC5_UNORM_BLOCK},                               // BC5_UNORM
-    {VK_FORMAT_BC5_SNORM_BLOCK},                               // BC5_SNORM
-    {VK_FORMAT_BC7_UNORM_BLOCK},                               // BC7_UNORM
-    {VK_FORMAT_BC6H_UFLOAT_BLOCK},                             // BC6H_UFLOAT
-    {VK_FORMAT_BC6H_SFLOAT_BLOCK},                             // BC6H_SFLOAT
-    {VK_FORMAT_ASTC_4x4_UNORM_BLOCK},                          // ASTC_2D_4X4_UNORM
-    {VK_FORMAT_B8G8R8A8_UNORM, Attachable | Storage},          // B8G8R8A8_UNORM
-    {VK_FORMAT_R32G32B32A32_SFLOAT, Attachable | Storage},     // R32G32B32A32_FLOAT
-    {VK_FORMAT_R32G32B32A32_SINT, Attachable | Storage},       // R32G32B32A32_SINT
-    {VK_FORMAT_R32G32_SFLOAT, Attachable | Storage},           // R32G32_FLOAT
-    {VK_FORMAT_R32G32_SINT, Attachable | Storage},             // R32G32_SINT
-    {VK_FORMAT_R32_SFLOAT, Attachable | Storage},              // R32_FLOAT
-    {VK_FORMAT_R16_SFLOAT, Attachable | Storage},              // R16_FLOAT
-    {VK_FORMAT_R16_UNORM, Attachable | Storage},               // R16_UNORM
-    {VK_FORMAT_R16_SNORM, Attachable | Storage},               // R16_SNORM
-    {VK_FORMAT_R16_UINT, Attachable | Storage},                // R16_UINT
-    {VK_FORMAT_R16_SINT, Attachable | Storage},                // R16_SINT
-    {VK_FORMAT_R16G16_UNORM, Attachable | Storage},            // R16G16_UNORM
-    {VK_FORMAT_R16G16_SFLOAT, Attachable | Storage},           // R16G16_FLOAT
-    {VK_FORMAT_R16G16_UINT, Attachable | Storage},             // R16G16_UINT
-    {VK_FORMAT_R16G16_SINT, Attachable | Storage},             // R16G16_SINT
-    {VK_FORMAT_R16G16_SNORM, Attachable | Storage},            // R16G16_SNORM
-    {VK_FORMAT_R32G32B32_SFLOAT},                              // R32G32B32_FLOAT
-    {VK_FORMAT_A8B8G8R8_SRGB_PACK32, Attachable},              // A8B8G8R8_SRGB
-    {VK_FORMAT_R8G8_UNORM, Attachable | Storage},              // R8G8_UNORM
-    {VK_FORMAT_R8G8_SNORM, Attachable | Storage},              // R8G8_SNORM
-    {VK_FORMAT_R8G8_SINT, Attachable | Storage},               // R8G8_SINT
-    {VK_FORMAT_R8G8_UINT, Attachable | Storage},               // R8G8_UINT
-    {VK_FORMAT_R32G32_UINT, Attachable | Storage},             // R32G32_UINT
-    {VK_FORMAT_R16G16B16A16_SFLOAT, Attachable | Storage},     // R16G16B16X16_FLOAT
-    {VK_FORMAT_R32_UINT, Attachable | Storage},                // R32_UINT
-    {VK_FORMAT_R32_SINT, Attachable | Storage},                // R32_SINT
-    {VK_FORMAT_ASTC_8x8_UNORM_BLOCK},                          // ASTC_2D_8X8_UNORM
-    {VK_FORMAT_ASTC_8x5_UNORM_BLOCK},                          // ASTC_2D_8X5_UNORM
-    {VK_FORMAT_ASTC_5x4_UNORM_BLOCK},                          // ASTC_2D_5X4_UNORM
-    {VK_FORMAT_B8G8R8A8_SRGB, Attachable},                     // B8G8R8A8_SRGB
-    {VK_FORMAT_BC1_RGBA_SRGB_BLOCK},                           // BC1_RGBA_SRGB
-    {VK_FORMAT_BC2_SRGB_BLOCK},                                // BC2_SRGB
-    {VK_FORMAT_BC3_SRGB_BLOCK},                                // BC3_SRGB
-    {VK_FORMAT_BC7_SRGB_BLOCK},                                // BC7_SRGB
-    {VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT},                     // A4B4G4R4_UNORM
-    {VK_FORMAT_R4G4_UNORM_PACK8},                              // G4R4_UNORM
-    {VK_FORMAT_ASTC_4x4_SRGB_BLOCK},                           // ASTC_2D_4X4_SRGB
-    {VK_FORMAT_ASTC_8x8_SRGB_BLOCK},                           // ASTC_2D_8X8_SRGB
-    {VK_FORMAT_ASTC_8x5_SRGB_BLOCK},                           // ASTC_2D_8X5_SRGB
-    {VK_FORMAT_ASTC_5x4_SRGB_BLOCK},                           // ASTC_2D_5X4_SRGB
-    {VK_FORMAT_ASTC_5x5_UNORM_BLOCK},                          // ASTC_2D_5X5_UNORM
-    {VK_FORMAT_ASTC_5x5_SRGB_BLOCK},                           // ASTC_2D_5X5_SRGB
-    {VK_FORMAT_ASTC_10x8_UNORM_BLOCK},                         // ASTC_2D_10X8_UNORM
-    {VK_FORMAT_ASTC_10x8_SRGB_BLOCK},                          // ASTC_2D_10X8_SRGB
-    {VK_FORMAT_ASTC_6x6_UNORM_BLOCK},                          // ASTC_2D_6X6_UNORM
-    {VK_FORMAT_ASTC_6x6_SRGB_BLOCK},                           // ASTC_2D_6X6_SRGB
-    {VK_FORMAT_ASTC_10x6_UNORM_BLOCK},                         // ASTC_2D_10X6_UNORM
-    {VK_FORMAT_ASTC_10x6_SRGB_BLOCK},                          // ASTC_2D_10X6_SRGB
-    {VK_FORMAT_ASTC_10x5_UNORM_BLOCK},                         // ASTC_2D_10X5_UNORM
-    {VK_FORMAT_ASTC_10x5_SRGB_BLOCK},                          // ASTC_2D_10X5_SRGB
-    {VK_FORMAT_ASTC_10x10_UNORM_BLOCK},                        // ASTC_2D_10X10_UNORM
-    {VK_FORMAT_ASTC_10x10_SRGB_BLOCK},                         // ASTC_2D_10X10_SRGB
-    {VK_FORMAT_ASTC_12x10_UNORM_BLOCK},                        // ASTC_2D_12X10_UNORM
-    {VK_FORMAT_ASTC_12x10_SRGB_BLOCK},                         // ASTC_2D_12X10_SRGB
-    {VK_FORMAT_ASTC_12x12_UNORM_BLOCK},                        // ASTC_2D_12X12_UNORM
-    {VK_FORMAT_ASTC_12x12_SRGB_BLOCK},                         // ASTC_2D_12X12_SRGB
-    {VK_FORMAT_ASTC_8x6_UNORM_BLOCK},                          // ASTC_2D_8X6_UNORM
-    {VK_FORMAT_ASTC_8x6_SRGB_BLOCK},                           // ASTC_2D_8X6_SRGB
-    {VK_FORMAT_ASTC_6x5_UNORM_BLOCK},                          // ASTC_2D_6X5_UNORM
-    {VK_FORMAT_ASTC_6x5_SRGB_BLOCK},                           // ASTC_2D_6X5_SRGB
-    {VK_FORMAT_E5B9G9R9_UFLOAT_PACK32},                        // E5B9G9R9_FLOAT
-
-    // Depth formats
-    {VK_FORMAT_D32_SFLOAT, Attachable},          // D32_FLOAT
-    {VK_FORMAT_D16_UNORM, Attachable},           // D16_UNORM
-    {VK_FORMAT_X8_D24_UNORM_PACK32, Attachable}, // X8_D24_UNORM
-
-    // Stencil formats
-    {VK_FORMAT_S8_UINT, Attachable}, // S8_UINT
-
-    // DepthStencil formats
-    {VK_FORMAT_D24_UNORM_S8_UINT, Attachable},  // D24_UNORM_S8_UINT
-    {VK_FORMAT_D24_UNORM_S8_UINT, Attachable},  // S8_UINT_D24_UNORM (emulated)
-    {VK_FORMAT_D32_SFLOAT_S8_UINT, Attachable}, // D32_FLOAT_S8_UINT
+    VkFormat format{}; ///< Vulkan format
+    s32 usage = 0; ///< Describes image format usage
 };
-static_assert(std::size(tex_format_tuples) == VideoCore::Surface::MaxPixelFormat);
-
 constexpr bool IsZetaFormat(PixelFormat pixel_format) {
-    return pixel_format >= PixelFormat::MaxColorFormat &&
-           pixel_format < PixelFormat::MaxDepthStencilFormat;
+    return pixel_format >= PixelFormat::MaxColorFormat && pixel_format < PixelFormat::MaxDepthStencilFormat;
 }
 
-} // Anonymous namespace
-
-FormatInfo SurfaceFormat(const Device& device, FormatType format_type, bool with_srgb,
-                         PixelFormat pixel_format) {
-    ASSERT(static_cast<size_t>(pixel_format) < std::size(tex_format_tuples));
-    FormatTuple tuple = tex_format_tuples[static_cast<size_t>(pixel_format)];
+FormatInfo SurfaceFormat(const Device& device, FormatType format_type, bool with_srgb, PixelFormat pixel_format) {
+    u32 const usage_attachable = 1 << 0;
+    u32 const usage_storage = 1 << 1;
+    FormatTuple tuple;
+    switch (pixel_format) {
+#define SURFACE_FORMAT_LIST \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A8B8G8R8_UNORM_PACK32, usage_attachable | usage_storage, A8B8G8R8_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A8B8G8R8_SNORM_PACK32, usage_attachable | usage_storage, A8B8G8R8_SNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A8B8G8R8_SINT_PACK32, usage_attachable | usage_storage, A8B8G8R8_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A8B8G8R8_UINT_PACK32, usage_attachable | usage_storage, A8B8G8R8_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R5G6B5_UNORM_PACK16, usage_attachable, R5G6B5_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_B5G6R5_UNORM_PACK16, 0, B5G6R5_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A1R5G5B5_UNORM_PACK16, usage_attachable, A1R5G5B5_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A2B10G10R10_UNORM_PACK32, usage_attachable | usage_storage, A2B10G10R10_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A2B10G10R10_UINT_PACK32, usage_attachable | usage_storage, A2B10G10R10_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A2R10G10B10_UNORM_PACK32, usage_attachable, A2R10G10B10_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A1R5G5B5_UNORM_PACK16, usage_attachable, A1B5G5R5_UNORM) /*flipped with swizzle*/ \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R5G5B5A1_UNORM_PACK16, 0, A5B5G5R1_UNORM) /*specially swizzled*/ \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R8_UNORM, usage_attachable | usage_storage, R8_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R8_SNORM, usage_attachable | usage_storage, R8_SNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R8_SINT, usage_attachable | usage_storage, R8_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R8_UINT, usage_attachable | usage_storage, R8_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16B16A16_SFLOAT, usage_attachable | usage_storage, R16G16B16A16_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16B16A16_UNORM, usage_attachable | usage_storage, R16G16B16A16_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16B16A16_SNORM, usage_attachable | usage_storage, R16G16B16A16_SNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16B16A16_SINT, usage_attachable | usage_storage, R16G16B16A16_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16B16A16_UINT, usage_attachable | usage_storage, R16G16B16A16_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_B10G11R11_UFLOAT_PACK32, usage_attachable | usage_storage, B10G11R11_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32G32B32A32_UINT, usage_attachable | usage_storage, R32G32B32A32_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC1_RGBA_UNORM_BLOCK, 0, BC1_RGBA_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC2_UNORM_BLOCK, 0, BC2_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC3_UNORM_BLOCK, 0, BC3_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC4_UNORM_BLOCK, 0, BC4_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC4_SNORM_BLOCK, 0, BC4_SNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC5_UNORM_BLOCK, 0, BC5_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC5_SNORM_BLOCK, 0, BC5_SNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC7_UNORM_BLOCK, 0, BC7_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC6H_UFLOAT_BLOCK, 0, BC6H_UFLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC6H_SFLOAT_BLOCK, 0, BC6H_SFLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_4x4_UNORM_BLOCK, 0, ASTC_2D_4X4_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_B8G8R8A8_UNORM, usage_attachable | usage_storage, B8G8R8A8_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32G32B32A32_SFLOAT, usage_attachable | usage_storage, R32G32B32A32_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32G32B32A32_SINT, usage_attachable | usage_storage, R32G32B32A32_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32G32_SFLOAT, usage_attachable | usage_storage, R32G32_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32G32_SINT, usage_attachable | usage_storage, R32G32_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32_SFLOAT, usage_attachable | usage_storage, R32_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16_SFLOAT, usage_attachable | usage_storage, R16_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16_UNORM, usage_attachable | usage_storage, R16_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16_SNORM, usage_attachable | usage_storage, R16_SNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16_UINT, usage_attachable | usage_storage, R16_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16_SINT, usage_attachable | usage_storage, R16_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16_UNORM, usage_attachable | usage_storage, R16G16_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16_SFLOAT, usage_attachable | usage_storage, R16G16_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16_UINT, usage_attachable | usage_storage, R16G16_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16_SINT, usage_attachable | usage_storage, R16G16_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16_SNORM, usage_attachable | usage_storage, R16G16_SNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32G32B32_SFLOAT, 0, R32G32B32_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A8B8G8R8_SRGB_PACK32, usage_attachable, A8B8G8R8_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R8G8_UNORM, usage_attachable | usage_storage, R8G8_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R8G8_SNORM, usage_attachable | usage_storage, R8G8_SNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R8G8_SINT, usage_attachable | usage_storage, R8G8_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R8G8_UINT, usage_attachable | usage_storage, R8G8_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32G32_UINT, usage_attachable | usage_storage, R32G32_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R16G16B16A16_SFLOAT, usage_attachable | usage_storage, R16G16B16X16_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32_UINT, usage_attachable | usage_storage, R32_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R32_SINT, usage_attachable | usage_storage, R32_SINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_8x8_UNORM_BLOCK, 0, ASTC_2D_8X8_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_8x5_UNORM_BLOCK, 0, ASTC_2D_8X5_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_5x4_UNORM_BLOCK, 0, ASTC_2D_5X4_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_B8G8R8A8_SRGB, usage_attachable, B8G8R8A8_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC1_RGBA_SRGB_BLOCK, 0, BC1_RGBA_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC2_SRGB_BLOCK, 0, BC2_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC3_SRGB_BLOCK, 0, BC3_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_BC7_SRGB_BLOCK, 0, BC7_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, 0, A4B4G4R4_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_R4G4_UNORM_PACK8, 0, G4R4_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_4x4_SRGB_BLOCK, 0, ASTC_2D_4X4_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_8x8_SRGB_BLOCK, 0, ASTC_2D_8X8_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_8x5_SRGB_BLOCK, 0, ASTC_2D_8X5_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, 0, ASTC_2D_5X4_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_5x5_UNORM_BLOCK, 0, ASTC_2D_5X5_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_5x5_SRGB_BLOCK, 0, ASTC_2D_5X5_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_10x8_UNORM_BLOCK, 0, ASTC_2D_10X8_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_10x8_SRGB_BLOCK, 0, ASTC_2D_10X8_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_6x6_UNORM_BLOCK, 0, ASTC_2D_6X6_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_6x6_SRGB_BLOCK, 0, ASTC_2D_6X6_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_10x6_UNORM_BLOCK, 0, ASTC_2D_10X6_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_10x6_SRGB_BLOCK, 0, ASTC_2D_10X6_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_10x5_UNORM_BLOCK, 0, ASTC_2D_10X5_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_10x5_SRGB_BLOCK, 0, ASTC_2D_10X5_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_10x10_UNORM_BLOCK, 0, ASTC_2D_10X10_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_10x10_SRGB_BLOCK, 0, ASTC_2D_10X10_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_12x10_UNORM_BLOCK, 0, ASTC_2D_12X10_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_12x10_SRGB_BLOCK, 0, ASTC_2D_12X10_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_12x12_UNORM_BLOCK, 0, ASTC_2D_12X12_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 0, ASTC_2D_12X12_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_8x6_UNORM_BLOCK, 0, ASTC_2D_8X6_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_8x6_SRGB_BLOCK, 0, ASTC_2D_8X6_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_6x5_UNORM_BLOCK, 0, ASTC_2D_6X5_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_ASTC_6x5_SRGB_BLOCK, 0, ASTC_2D_6X5_SRGB) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, 0, E5B9G9R9_FLOAT) \
+    /* Depth formats */ \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_D32_SFLOAT, usage_attachable, D32_FLOAT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_D16_UNORM, usage_attachable, D16_UNORM) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_X8_D24_UNORM_PACK32, usage_attachable, X8_D24_UNORM) \
+    /* Stencil formats */ \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_S8_UINT, usage_attachable, S8_UINT) \
+    /* DepthStencil formats */ \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_D24_UNORM_S8_UINT, usage_attachable, D24_UNORM_S8_UINT) \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_D24_UNORM_S8_UINT, usage_attachable, S8_UINT_D24_UNORM) /* emulated */ \
+    SURFACE_FORMAT_ELEM(VK_FORMAT_D32_SFLOAT_S8_UINT, usage_attachable, D32_FLOAT_S8_UINT)
+#define SURFACE_FORMAT_ELEM(res, usage, pixel) case PixelFormat::pixel: tuple = {res, usage}; break;
+    SURFACE_FORMAT_LIST
+    default: UNREACHABLE_MSG("unknown format {}", pixel_format);
+#undef SURFACE_FORMAT_ELEM
+#undef SURFACE_FORMAT_LIST
+    }
+    bool const is_srgb = with_srgb && VideoCore::Surface::IsPixelFormatSRGB(pixel_format);
     // Transcode on hardware that doesn't support ASTC natively
     if (!device.IsOptimalAstcSupported() && VideoCore::Surface::IsPixelFormatASTC(pixel_format)) {
-        const bool is_srgb = with_srgb && VideoCore::Surface::IsPixelFormatSRGB(pixel_format);
-
         switch (Settings::values.astc_recompression.GetValue()) {
         case Settings::AstcRecompression::Uncompressed:
             if (is_srgb) {
                 tuple.format = VK_FORMAT_A8B8G8R8_SRGB_PACK32;
             } else {
                 tuple.format = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
-                tuple.usage |= Storage;
+                tuple.usage |= usage_storage;
             }
             break;
         case Settings::AstcRecompression::Bc1:
@@ -259,7 +252,6 @@ FormatInfo SurfaceFormat(const Device& device, FormatType format_type, bool with
     }
     // Transcode on hardware that doesn't support BCn natively
     if (!device.IsOptimalBcnSupported() && VideoCore::Surface::IsPixelFormatBCn(pixel_format)) {
-        const bool is_srgb = with_srgb && VideoCore::Surface::IsPixelFormatSRGB(pixel_format);
         if (pixel_format == PixelFormat::BC4_SNORM) {
             tuple.format = VK_FORMAT_R8_SNORM;
         } else if (pixel_format == PixelFormat::BC4_UNORM) {
@@ -268,8 +260,7 @@ FormatInfo SurfaceFormat(const Device& device, FormatType format_type, bool with
             tuple.format = VK_FORMAT_R8G8_SNORM;
         } else if (pixel_format == PixelFormat::BC5_UNORM) {
             tuple.format = VK_FORMAT_R8G8_UNORM;
-        } else if (pixel_format == PixelFormat::BC6H_SFLOAT ||
-                   pixel_format == PixelFormat::BC6H_UFLOAT) {
+        } else if (pixel_format == PixelFormat::BC6H_SFLOAT || pixel_format == PixelFormat::BC6H_UFLOAT) {
             tuple.format = VK_FORMAT_R16G16B16A16_SFLOAT;
         } else if (is_srgb) {
             tuple.format = VK_FORMAT_A8B8G8R8_SRGB_PACK32;
@@ -277,9 +268,8 @@ FormatInfo SurfaceFormat(const Device& device, FormatType format_type, bool with
             tuple.format = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
         }
     }
-    const bool attachable = (tuple.usage & Attachable) != 0;
-    const bool storage = (tuple.usage & Storage) != 0;
-
+    bool const attachable = (tuple.usage & usage_attachable) != 0;
+    bool const storage = (tuple.usage & usage_storage) != 0;
     VkFormatFeatureFlags usage{};
     switch (format_type) {
     case FormatType::Buffer:

src/video_core/surface.h

@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -13,127 +15,125 @@
 
 namespace VideoCore::Surface {
 
+#define PIXEL_FORMAT_LIST \
+    PIXEL_FORMAT_ELEM(A8B8G8R8_UNORM, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(A8B8G8R8_SNORM, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(A8B8G8R8_SINT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(A8B8G8R8_UINT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R5G6B5_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(B5G6R5_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(A1R5G5B5_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(A2B10G10R10_UNORM, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(A2B10G10R10_UINT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(A2R10G10B10_UNORM, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(A1B5G5R5_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(A5B5G5R1_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R8_UNORM, 1, 1, 8) \
+    PIXEL_FORMAT_ELEM(R8_SNORM, 1, 1, 8) \
+    PIXEL_FORMAT_ELEM(R8_SINT, 1, 1, 8) \
+    PIXEL_FORMAT_ELEM(R8_UINT, 1, 1, 8) \
+    PIXEL_FORMAT_ELEM(R16G16B16A16_FLOAT, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(R16G16B16A16_UNORM, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(R16G16B16A16_SNORM, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(R16G16B16A16_SINT, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(R16G16B16A16_UINT, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(B10G11R11_FLOAT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R32G32B32A32_UINT, 1, 1, 128) \
+    PIXEL_FORMAT_ELEM(BC1_RGBA_UNORM, 4, 4, 64) \
+    PIXEL_FORMAT_ELEM(BC2_UNORM, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(BC3_UNORM, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(BC4_UNORM, 4, 4, 64) \
+    PIXEL_FORMAT_ELEM(BC4_SNORM, 4, 4, 64) \
+    PIXEL_FORMAT_ELEM(BC5_UNORM, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(BC5_SNORM, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(BC7_UNORM, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(BC6H_UFLOAT, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(BC6H_SFLOAT, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_4X4_UNORM, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(B8G8R8A8_UNORM, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R32G32B32A32_FLOAT, 1, 1, 128) \
+    PIXEL_FORMAT_ELEM(R32G32B32A32_SINT, 1, 1, 128) \
+    PIXEL_FORMAT_ELEM(R32G32_FLOAT, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(R32G32_SINT, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(R32_FLOAT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R16_FLOAT, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R16_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R16_SNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R16_UINT, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R16_SINT, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R16G16_UNORM, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R16G16_FLOAT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R16G16_UINT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R16G16_SINT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R16G16_SNORM, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R32G32B32_FLOAT, 1, 1, 96) \
+    PIXEL_FORMAT_ELEM(A8B8G8R8_SRGB, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R8G8_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R8G8_SNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R8G8_SINT, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R8G8_UINT, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(R32G32_UINT, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(R16G16B16X16_FLOAT, 1, 1, 64) \
+    PIXEL_FORMAT_ELEM(R32_UINT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(R32_SINT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_8X8_UNORM, 8, 8, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_8X5_UNORM, 8, 5, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_5X4_UNORM, 5, 4, 128) \
+    PIXEL_FORMAT_ELEM(B8G8R8A8_SRGB, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(BC1_RGBA_SRGB, 4, 4, 64) \
+    PIXEL_FORMAT_ELEM(BC2_SRGB, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(BC3_SRGB, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(BC7_SRGB, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(A4B4G4R4_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(G4R4_UNORM, 1, 1, 8) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_4X4_SRGB, 4, 4, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_8X8_SRGB, 8, 8, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_8X5_SRGB, 8, 5, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_5X4_SRGB, 5, 4, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_5X5_UNORM, 5, 5, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_5X5_SRGB, 5, 5, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_10X8_UNORM, 10, 8, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_10X8_SRGB, 10, 8, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_6X6_UNORM, 6, 6, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_6X6_SRGB, 6, 6, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_10X6_UNORM, 10, 6, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_10X6_SRGB, 10, 6, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_10X5_UNORM, 10, 5, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_10X5_SRGB, 10, 5, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_10X10_UNORM, 10, 10, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_10X10_SRGB, 10, 10, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_12X10_UNORM, 12, 10, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_12X10_SRGB, 12, 10, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_12X12_UNORM, 12, 12, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_12X12_SRGB, 12, 12, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_8X6_UNORM, 8, 6, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_8X6_SRGB, 8, 6, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_6X5_UNORM, 6, 5, 128) \
+    PIXEL_FORMAT_ELEM(ASTC_2D_6X5_SRGB, 6, 5, 128) \
+    PIXEL_FORMAT_ELEM(E5B9G9R9_FLOAT, 1, 1, 32) \
+    /* Depth formats */ \
+    PIXEL_FORMAT_ELEM(D32_FLOAT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(D16_UNORM, 1, 1, 16) \
+    PIXEL_FORMAT_ELEM(X8_D24_UNORM, 1, 1, 32) \
+    /* Stencil formats */ \
+    PIXEL_FORMAT_ELEM(S8_UINT, 1, 1, 8) \
+    /* DepthStencil formats */ \
+    PIXEL_FORMAT_ELEM(D24_UNORM_S8_UINT, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(S8_UINT_D24_UNORM, 1, 1, 32) \
+    PIXEL_FORMAT_ELEM(D32_FLOAT_S8_UINT, 1, 1, 64)
+
 enum class PixelFormat {
-    A8B8G8R8_UNORM,
-    A8B8G8R8_SNORM,
-    A8B8G8R8_SINT,
-    A8B8G8R8_UINT,
-    R5G6B5_UNORM,
-    B5G6R5_UNORM,
-    A1R5G5B5_UNORM,
-    A2B10G10R10_UNORM,
-    A2B10G10R10_UINT,
-    A2R10G10B10_UNORM,
-    A1B5G5R5_UNORM,
-    A5B5G5R1_UNORM,
-    R8_UNORM,
-    R8_SNORM,
-    R8_SINT,
-    R8_UINT,
-    R16G16B16A16_FLOAT,
-    R16G16B16A16_UNORM,
-    R16G16B16A16_SNORM,
-    R16G16B16A16_SINT,
-    R16G16B16A16_UINT,
-    B10G11R11_FLOAT,
-    R32G32B32A32_UINT,
-    BC1_RGBA_UNORM,
-    BC2_UNORM,
-    BC3_UNORM,
-    BC4_UNORM,
-    BC4_SNORM,
-    BC5_UNORM,
-    BC5_SNORM,
-    BC7_UNORM,
-    BC6H_UFLOAT,
-    BC6H_SFLOAT,
-    ASTC_2D_4X4_UNORM,
-    B8G8R8A8_UNORM,
-    R32G32B32A32_FLOAT,
-    R32G32B32A32_SINT,
-    R32G32_FLOAT,
-    R32G32_SINT,
-    R32_FLOAT,
-    R16_FLOAT,
-    R16_UNORM,
-    R16_SNORM,
-    R16_UINT,
-    R16_SINT,
-    R16G16_UNORM,
-    R16G16_FLOAT,
-    R16G16_UINT,
-    R16G16_SINT,
-    R16G16_SNORM,
-    R32G32B32_FLOAT,
-    A8B8G8R8_SRGB,
-    R8G8_UNORM,
-    R8G8_SNORM,
-    R8G8_SINT,
-    R8G8_UINT,
-    R32G32_UINT,
-    R16G16B16X16_FLOAT,
-    R32_UINT,
-    R32_SINT,
-    ASTC_2D_8X8_UNORM,
-    ASTC_2D_8X5_UNORM,
-    ASTC_2D_5X4_UNORM,
-    B8G8R8A8_SRGB,
-    BC1_RGBA_SRGB,
-    BC2_SRGB,
-    BC3_SRGB,
-    BC7_SRGB,
-    A4B4G4R4_UNORM,
-    G4R4_UNORM,
-    ASTC_2D_4X4_SRGB,
-    ASTC_2D_8X8_SRGB,
-    ASTC_2D_8X5_SRGB,
-    ASTC_2D_5X4_SRGB,
-    ASTC_2D_5X5_UNORM,
-    ASTC_2D_5X5_SRGB,
-    ASTC_2D_10X8_UNORM,
-    ASTC_2D_10X8_SRGB,
-    ASTC_2D_6X6_UNORM,
-    ASTC_2D_6X6_SRGB,
-    ASTC_2D_10X6_UNORM,
-    ASTC_2D_10X6_SRGB,
-    ASTC_2D_10X5_UNORM,
-    ASTC_2D_10X5_SRGB,
-    ASTC_2D_10X10_UNORM,
-    ASTC_2D_10X10_SRGB,
-    ASTC_2D_12X10_UNORM,
-    ASTC_2D_12X10_SRGB,
-    ASTC_2D_12X12_UNORM,
-    ASTC_2D_12X12_SRGB,
-    ASTC_2D_8X6_UNORM,
-    ASTC_2D_8X6_SRGB,
-    ASTC_2D_6X5_UNORM,
-    ASTC_2D_6X5_SRGB,
-    E5B9G9R9_FLOAT,
-
-    MaxColorFormat,
-
-    // Depth formats
-    D32_FLOAT = MaxColorFormat,
-    D16_UNORM,
-    X8_D24_UNORM,
-
-    MaxDepthFormat,
-
-    // Stencil formats
-    S8_UINT = MaxDepthFormat,
-    MaxStencilFormat,
-
-    // DepthStencil formats
-    D24_UNORM_S8_UINT = MaxStencilFormat,
-    S8_UINT_D24_UNORM,
-    D32_FLOAT_S8_UINT,
-
-    MaxDepthStencilFormat,
-
+#define PIXEL_FORMAT_ELEM(name, ...) name,
+    PIXEL_FORMAT_LIST
+#undef PIXEL_FORMAT_ELEM
+    MaxColorFormat = D32_FLOAT,
+    MaxDepthFormat = S8_UINT,
+    MaxStencilFormat = D24_UNORM_S8_UINT,
+    MaxDepthStencilFormat = u8(D32_FLOAT_S8_UINT) + 1,
     Max = MaxDepthStencilFormat,
     Invalid = 255,
 };
-constexpr std::size_t MaxPixelFormat = static_cast<std::size_t>(PixelFormat::Max);
+constexpr std::size_t MaxPixelFormat = std::size_t(PixelFormat::Max);
 
 enum class SurfaceType {
     ColorTexture = 0,
@@ -154,371 +154,55 @@ enum class SurfaceTarget {
     TextureCubeArray,
 };
 
-constexpr std::array<u8, MaxPixelFormat> BLOCK_WIDTH_TABLE = {{
-    1,  // A8B8G8R8_UNORM
-    1,  // A8B8G8R8_SNORM
-    1,  // A8B8G8R8_SINT
-    1,  // A8B8G8R8_UINT
-    1,  // R5G6B5_UNORM
-    1,  // B5G6R5_UNORM
-    1,  // A1R5G5B5_UNORM
-    1,  // A2B10G10R10_UNORM
-    1,  // A2B10G10R10_UINT
-    1,  // A2R10G10B10_UNORM
-    1,  // A1B5G5R5_UNORM
-    1,  // A5B5G5R1_UNORM
-    1,  // R8_UNORM
-    1,  // R8_SNORM
-    1,  // R8_SINT
-    1,  // R8_UINT
-    1,  // R16G16B16A16_FLOAT
-    1,  // R16G16B16A16_UNORM
-    1,  // R16G16B16A16_SNORM
-    1,  // R16G16B16A16_SINT
-    1,  // R16G16B16A16_UINT
-    1,  // B10G11R11_FLOAT
-    1,  // R32G32B32A32_UINT
-    4,  // BC1_RGBA_UNORM
-    4,  // BC2_UNORM
-    4,  // BC3_UNORM
-    4,  // BC4_UNORM
-    4,  // BC4_SNORM
-    4,  // BC5_UNORM
-    4,  // BC5_SNORM
-    4,  // BC7_UNORM
-    4,  // BC6H_UFLOAT
-    4,  // BC6H_SFLOAT
-    4,  // ASTC_2D_4X4_UNORM
-    1,  // B8G8R8A8_UNORM
-    1,  // R32G32B32A32_FLOAT
-    1,  // R32G32B32A32_SINT
-    1,  // R32G32_FLOAT
-    1,  // R32G32_SINT
-    1,  // R32_FLOAT
-    1,  // R16_FLOAT
-    1,  // R16_UNORM
-    1,  // R16_SNORM
-    1,  // R16_UINT
-    1,  // R16_SINT
-    1,  // R16G16_UNORM
-    1,  // R16G16_FLOAT
-    1,  // R16G16_UINT
-    1,  // R16G16_SINT
-    1,  // R16G16_SNORM
-    1,  // R32G32B32_FLOAT
-    1,  // A8B8G8R8_SRGB
-    1,  // R8G8_UNORM
-    1,  // R8G8_SNORM
-    1,  // R8G8_SINT
-    1,  // R8G8_UINT
-    1,  // R32G32_UINT
-    1,  // R16G16B16X16_FLOAT
-    1,  // R32_UINT
-    1,  // R32_SINT
-    8,  // ASTC_2D_8X8_UNORM
-    8,  // ASTC_2D_8X5_UNORM
-    5,  // ASTC_2D_5X4_UNORM
-    1,  // B8G8R8A8_SRGB
-    4,  // BC1_RGBA_SRGB
-    4,  // BC2_SRGB
-    4,  // BC3_SRGB
-    4,  // BC7_SRGB
-    1,  // A4B4G4R4_UNORM
-    1,  // G4R4_UNORM
-    4,  // ASTC_2D_4X4_SRGB
-    8,  // ASTC_2D_8X8_SRGB
-    8,  // ASTC_2D_8X5_SRGB
-    5,  // ASTC_2D_5X4_SRGB
-    5,  // ASTC_2D_5X5_UNORM
-    5,  // ASTC_2D_5X5_SRGB
-    10, // ASTC_2D_10X8_UNORM
-    10, // ASTC_2D_10X8_SRGB
-    6,  // ASTC_2D_6X6_UNORM
-    6,  // ASTC_2D_6X6_SRGB
-    10, // ASTC_2D_10X6_UNORM
-    10, // ASTC_2D_10X6_SRGB
-    10, // ASTC_2D_10X5_UNORM
-    10, // ASTC_2D_10X5_SRGB
-    10, // ASTC_2D_10X10_UNORM
-    10, // ASTC_2D_10X10_SRGB
-    12, // ASTC_2D_12X10_UNORM
-    12, // ASTC_2D_12X10_SRGB
-    12, // ASTC_2D_12X12_UNORM
-    12, // ASTC_2D_12X12_SRGB
-    8,  // ASTC_2D_8X6_UNORM
-    8,  // ASTC_2D_8X6_SRGB
-    6,  // ASTC_2D_6X5_UNORM
-    6,  // ASTC_2D_6X5_SRGB
-    1,  // E5B9G9R9_FLOAT
-    1,  // D32_FLOAT
-    1,  // D16_UNORM
-    1,  // X8_D24_UNORM
-    1,  // S8_UINT
-    1,  // D24_UNORM_S8_UINT
-    1,  // S8_UINT_D24_UNORM
-    1,  // D32_FLOAT_S8_UINT
-}};
-
-constexpr u32 DefaultBlockWidth(PixelFormat format) {
-    ASSERT(static_cast<std::size_t>(format) < BLOCK_WIDTH_TABLE.size());
-    return BLOCK_WIDTH_TABLE[static_cast<std::size_t>(format)];
+constexpr u32 DefaultBlockWidth(PixelFormat format) noexcept {
+    switch (format) {
+#define PIXEL_FORMAT_ELEM(name, width, height, bits) case PixelFormat::name: return width;
+    PIXEL_FORMAT_LIST
+#undef PIXEL_FORMAT_ELEM
+    default: UNREACHABLE();
+    }
 }
 
-constexpr std::array<u8, MaxPixelFormat> BLOCK_HEIGHT_TABLE = {{
-    1,  // A8B8G8R8_UNORM
-    1,  // A8B8G8R8_SNORM
-    1,  // A8B8G8R8_SINT
-    1,  // A8B8G8R8_UINT
-    1,  // R5G6B5_UNORM
-    1,  // B5G6R5_UNORM
-    1,  // A1R5G5B5_UNORM
-    1,  // A2B10G10R10_UNORM
-    1,  // A2B10G10R10_UINT
-    1,  // A2R10G10B10_UNORM
-    1,  // A1B5G5R5_UNORM
-    1,  // A5B5G5R1_UNORM
-    1,  // R8_UNORM
-    1,  // R8_SNORM
-    1,  // R8_SINT
-    1,  // R8_UINT
-    1,  // R16G16B16A16_FLOAT
-    1,  // R16G16B16A16_UNORM
-    1,  // R16G16B16A16_SNORM
-    1,  // R16G16B16A16_SINT
-    1,  // R16G16B16A16_UINT
-    1,  // B10G11R11_FLOAT
-    1,  // R32G32B32A32_UINT
-    4,  // BC1_RGBA_UNORM
-    4,  // BC2_UNORM
-    4,  // BC3_UNORM
-    4,  // BC4_UNORM
-    4,  // BC4_SNORM
-    4,  // BC5_UNORM
-    4,  // BC5_SNORM
-    4,  // BC7_UNORM
-    4,  // BC6H_UFLOAT
-    4,  // BC6H_SFLOAT
-    4,  // ASTC_2D_4X4_UNORM
-    1,  // B8G8R8A8_UNORM
-    1,  // R32G32B32A32_FLOAT
-    1,  // R32G32B32A32_SINT
-    1,  // R32G32_FLOAT
-    1,  // R32G32_SINT
-    1,  // R32_FLOAT
-    1,  // R16_FLOAT
-    1,  // R16_UNORM
-    1,  // R16_SNORM
-    1,  // R16_UINT
-    1,  // R16_SINT
-    1,  // R16G16_UNORM
-    1,  // R16G16_FLOAT
-    1,  // R16G16_UINT
-    1,  // R16G16_SINT
-    1,  // R16G16_SNORM
-    1,  // R32G32B32_FLOAT
-    1,  // A8B8G8R8_SRGB
-    1,  // R8G8_UNORM
-    1,  // R8G8_SNORM
-    1,  // R8G8_SINT
-    1,  // R8G8_UINT
-    1,  // R32G32_UINT
-    1,  // R16G16B16X16_FLOAT
-    1,  // R32_UINT
-    1,  // R32_SINT
-    8,  // ASTC_2D_8X8_UNORM
-    5,  // ASTC_2D_8X5_UNORM
-    4,  // ASTC_2D_5X4_UNORM
-    1,  // B8G8R8A8_SRGB
-    4,  // BC1_RGBA_SRGB
-    4,  // BC2_SRGB
-    4,  // BC3_SRGB
-    4,  // BC7_SRGB
-    1,  // A4B4G4R4_UNORM
-    1,  // G4R4_UNORM
-    4,  // ASTC_2D_4X4_SRGB
-    8,  // ASTC_2D_8X8_SRGB
-    5,  // ASTC_2D_8X5_SRGB
-    4,  // ASTC_2D_5X4_SRGB
-    5,  // ASTC_2D_5X5_UNORM
-    5,  // ASTC_2D_5X5_SRGB
-    8,  // ASTC_2D_10X8_UNORM
-    8,  // ASTC_2D_10X8_SRGB
-    6,  // ASTC_2D_6X6_UNORM
-    6,  // ASTC_2D_6X6_SRGB
-    6,  // ASTC_2D_10X6_UNORM
-    6,  // ASTC_2D_10X6_SRGB
-    5,  // ASTC_2D_10X5_UNORM
-    5,  // ASTC_2D_10X5_SRGB
-    10, // ASTC_2D_10X10_UNORM
-    10, // ASTC_2D_10X10_SRGB
-    10, // ASTC_2D_12X10_UNORM
-    10, // ASTC_2D_12X10_SRGB
-    12, // ASTC_2D_12X12_UNORM
-    12, // ASTC_2D_12X12_SRGB
-    6,  // ASTC_2D_8X6_UNORM
-    6,  // ASTC_2D_8X6_SRGB
-    5,  // ASTC_2D_6X5_UNORM
-    5,  // ASTC_2D_6X5_SRGB
-    1,  // E5B9G9R9_FLOAT
-    1,  // D32_FLOAT
-    1,  // D16_UNORM
-    1,  // X8_D24_UNORM
-    1,  // S8_UINT
-    1,  // D24_UNORM_S8_UINT
-    1,  // S8_UINT_D24_UNORM
-    1,  // D32_FLOAT_S8_UINT
-}};
-
-constexpr u32 DefaultBlockHeight(PixelFormat format) {
-    ASSERT(static_cast<std::size_t>(format) < BLOCK_HEIGHT_TABLE.size());
-    return BLOCK_HEIGHT_TABLE[static_cast<std::size_t>(format)];
+constexpr u32 DefaultBlockHeight(PixelFormat format) noexcept {
+    switch (format) {
+#define PIXEL_FORMAT_ELEM(name, width, height, bits) case PixelFormat::name: return height;
+    PIXEL_FORMAT_LIST
+#undef PIXEL_FORMAT_ELEM
+    default: UNREACHABLE();
+    }
 }
 
-constexpr std::array<u8, MaxPixelFormat> BITS_PER_BLOCK_TABLE = {{
-    32,  // A8B8G8R8_UNORM
-    32,  // A8B8G8R8_SNORM
-    32,  // A8B8G8R8_SINT
-    32,  // A8B8G8R8_UINT
-    16,  // R5G6B5_UNORM
-    16,  // B5G6R5_UNORM
-    16,  // A1R5G5B5_UNORM
-    32,  // A2B10G10R10_UNORM
-    32,  // A2B10G10R10_UINT
-    32,  // A2R10G10B10_UNORM
-    16,  // A1B5G5R5_UNORM
-    16,  // A5B5G5R1_UNORM
-    8,   // R8_UNORM
-    8,   // R8_SNORM
-    8,   // R8_SINT
-    8,   // R8_UINT
-    64,  // R16G16B16A16_FLOAT
-    64,  // R16G16B16A16_UNORM
-    64,  // R16G16B16A16_SNORM
-    64,  // R16G16B16A16_SINT
-    64,  // R16G16B16A16_UINT
-    32,  // B10G11R11_FLOAT
-    128, // R32G32B32A32_UINT
-    64,  // BC1_RGBA_UNORM
-    128, // BC2_UNORM
-    128, // BC3_UNORM
-    64,  // BC4_UNORM
-    64,  // BC4_SNORM
-    128, // BC5_UNORM
-    128, // BC5_SNORM
-    128, // BC7_UNORM
-    128, // BC6H_UFLOAT
-    128, // BC6H_SFLOAT
-    128, // ASTC_2D_4X4_UNORM
-    32,  // B8G8R8A8_UNORM
-    128, // R32G32B32A32_FLOAT
-    128, // R32G32B32A32_SINT
-    64,  // R32G32_FLOAT
-    64,  // R32G32_SINT
-    32,  // R32_FLOAT
-    16,  // R16_FLOAT
-    16,  // R16_UNORM
-    16,  // R16_SNORM
-    16,  // R16_UINT
-    16,  // R16_SINT
-    32,  // R16G16_UNORM
-    32,  // R16G16_FLOAT
-    32,  // R16G16_UINT
-    32,  // R16G16_SINT
-    32,  // R16G16_SNORM
-    96,  // R32G32B32_FLOAT
-    32,  // A8B8G8R8_SRGB
-    16,  // R8G8_UNORM
-    16,  // R8G8_SNORM
-    16,  // R8G8_SINT
-    16,  // R8G8_UINT
-    64,  // R32G32_UINT
-    64,  // R16G16B16X16_FLOAT
-    32,  // R32_UINT
-    32,  // R32_SINT
-    128, // ASTC_2D_8X8_UNORM
-    128, // ASTC_2D_8X5_UNORM
-    128, // ASTC_2D_5X4_UNORM
-    32,  // B8G8R8A8_SRGB
-    64,  // BC1_RGBA_SRGB
-    128, // BC2_SRGB
-    128, // BC3_SRGB
-    128, // BC7_UNORM
-    16,  // A4B4G4R4_UNORM
-    8,   // G4R4_UNORM
-    128, // ASTC_2D_4X4_SRGB
-    128, // ASTC_2D_8X8_SRGB
-    128, // ASTC_2D_8X5_SRGB
-    128, // ASTC_2D_5X4_SRGB
-    128, // ASTC_2D_5X5_UNORM
-    128, // ASTC_2D_5X5_SRGB
-    128, // ASTC_2D_10X8_UNORM
-    128, // ASTC_2D_10X8_SRGB
-    128, // ASTC_2D_6X6_UNORM
-    128, // ASTC_2D_6X6_SRGB
-    128, // ASTC_2D_10X6_UNORM
-    128, // ASTC_2D_10X6_SRGB
-    128, // ASTC_2D_10X5_UNORM
-    128, // ASTC_2D_10X5_SRGB
-    128, // ASTC_2D_10X10_UNORM
-    128, // ASTC_2D_10X10_SRGB
-    128, // ASTC_2D_12X10_UNORM
-    128, // ASTC_2D_12X10_SRGB
-    128, // ASTC_2D_12X12_UNORM
-    128, // ASTC_2D_12X12_SRGB
-    128, // ASTC_2D_8X6_UNORM
-    128, // ASTC_2D_8X6_SRGB
-    128, // ASTC_2D_6X5_UNORM
-    128, // ASTC_2D_6X5_SRGB
-    32,  // E5B9G9R9_FLOAT
-    32,  // D32_FLOAT
-    16,  // D16_UNORM
-    32,  // X8_D24_UNORM
-    8,   // S8_UINT
-    32,  // D24_UNORM_S8_UINT
-    32,  // S8_UINT_D24_UNORM
-    64,  // D32_FLOAT_S8_UINT
-}};
-
-constexpr u32 BitsPerBlock(PixelFormat format) {
-    ASSERT(static_cast<std::size_t>(format) < BITS_PER_BLOCK_TABLE.size());
-    return BITS_PER_BLOCK_TABLE[static_cast<std::size_t>(format)];
+constexpr u32 BitsPerBlock(PixelFormat format) noexcept {
+    switch (format) {
+#define PIXEL_FORMAT_ELEM(name, width, height, bits) case PixelFormat::name: return bits;
+    PIXEL_FORMAT_LIST
+#undef PIXEL_FORMAT_ELEM
+    default: UNREACHABLE();
+    }
 }
 
+#undef PIXEL_FORMAT_LIST
+
 /// Returns the sizer in bytes of the specified pixel format
 constexpr u32 BytesPerBlock(PixelFormat pixel_format) {
     return BitsPerBlock(pixel_format) / CHAR_BIT;
 }
 
 SurfaceTarget SurfaceTargetFromTextureType(Tegra::Texture::TextureType texture_type);
-
 bool SurfaceTargetIsLayered(SurfaceTarget target);
-
 bool SurfaceTargetIsArray(SurfaceTarget target);
-
 PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format);
-
 PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format);
-
 PixelFormat PixelFormatFromGPUPixelFormat(Service::android::PixelFormat format);
-
 SurfaceType GetFormatType(PixelFormat pixel_format);
-
 bool HasAlpha(PixelFormat pixel_format);
-
 bool IsPixelFormatASTC(PixelFormat format);
-
 bool IsPixelFormatBCn(PixelFormat format);
-
 bool IsPixelFormatSRGB(PixelFormat format);
-
 bool IsPixelFormatInteger(PixelFormat format);
-
 bool IsPixelFormatSignedInteger(PixelFormat format);
-
 size_t PixelComponentSizeBitsInteger(PixelFormat format);
-
 std::pair<u32, u32> GetASTCBlockSize(PixelFormat format);
-
 u64 TranscodedAstcSize(u64 base_size, PixelFormat format);
 
 } // namespace VideoCore::Surface