[vk] macro-ify PixelSurface and SurfaceFormat lists

Yxzx presumes this:
// The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
But in MCI i`ve discovered that there are no sizes, both registers are GPU addresses (hence the 2.8gb allocation, it was an address actually)

Method could be much simpler but for safety i`ve routed both old and new worlds.

Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3206
Reviewed-by: Caio Oliveira <caiooliveirafarias0@gmail.com>
Reviewed-by: Lizzie <lizzie@eden-emu.dev>
Co-authored-by: xbzk <xbzk@eden-emu.dev>
Co-committed-by: xbzk <xbzk@eden-emu.dev>

cpmfile.json

@@ -96,8 +96,8 @@
         "package": "VVL",
         "repo": "KhronosGroup/Vulkan-ValidationLayers",
         "tag": "vulkan-sdk-%VERSION%",
-        "git_version": "1.4.328.1",
+        "git_version": "1.4.335.0",
         "artifact": "android-binaries-%VERSION%.zip",
-        "hash": "5ec895a453cb7c2f156830b9766953a0c2bd44dea99e6a3dac4160305041ccd3e87534b4ce0bd102392178d2a8eca48411856298f9395e60117cdfe89f72137e"
+        "hash": "48167c4a17736301bd08f9290f41830443e1f18cce8ad867fc6f289b49e18b40e93c9850b377951af82f51b5b6d7313aa6a884fc5df79f5ce3df82696c1c1244"
     }
 }

docs/README.md

@@ -13,4 +13,3 @@ This contains documentation created by developers. This contains build instructi
 - **[The NVIDIA SM86 (Maxwell) GPU](./NvidiaGpu.md)**
 - **[User Handbook](./user)**
 - **[Release Policy](./ReleasePolicy.md)**
-- **[Dynarmic](./dynarmic)**

externals/cpmfile.json

@@ -119,10 +119,10 @@
         "package": "VulkanUtilityLibraries",
         "repo": "scripts/VulkanUtilityHeaders",
         "tag": "%VERSION%",
-        "git_version": "1.4.328",
+        "git_version": "1.4.335",
         "artifact": "VulkanUtilityHeaders.tar.zst",
         "git_host": "git.crueter.xyz",
-        "hash": "9922217b39faf73cd4fc1510f2fdba14a49aa5c0d77f9ee24ee0512cef16b234d0cabc83c1fec861fa5df1d43e7f086ca9b6501753899119f39c5ca530cb0dae"
+        "hash": "16dac0e6586702580c4279e4cd37ffe3cf909c93eb31b5069da7af36436d47b270a9cbaac953bb66c22ed12ed67ffa096688599267f307dfb62be1bc09f79833"
     },
     "spirv-tools": {
         "package": "SPIRV-Tools",

externals/ffmpeg/CMakeLists.txt

@@ -217,7 +217,6 @@ else()
                 --disable-ffmpeg
                 --disable-ffprobe
                 --disable-network
-                --disable-postproc
                 --disable-swresample
                 --enable-decoder=h264
                 --enable-decoder=vp8

src/android/app/build.gradle.kts

@@ -39,7 +39,6 @@ android {
 
     buildFeatures {
         viewBinding = true
-        buildConfig = true
     }
 
     compileOptions {

src/android/gradle.properties

@@ -14,6 +14,8 @@ android.useAndroidX=true
 # Kotlin code style for this project: "official" or "obsolete":
 kotlin.code.style=official
 kotlin.parallel.tasks.in.project=true
+android.defaults.buildfeatures.buildconfig=true
+
 # Android Gradle plugin 8.0.2
 android.suppressUnsupportedCompileSdk=34
 android.native.buildOutput=verbose

src/common/announce_multiplayer_room.h

@@ -34,8 +34,8 @@ struct Member {
 struct RoomInformation {
     std::string name;          ///< Name of the server
     std::string description;   ///< Server description
-    u32 member_slots;          ///< Maximum number of members in this room
-    u16 port;                  ///< The port of this room
+    u32 member_slots{};        ///< Maximum number of members in this room
+    u16 port{};                ///< The port of this room
     GameInfo preferred_game;   ///< Game to advertise that you want to play
     std::string host_username; ///< Forum username of the host
 };
@@ -46,8 +46,8 @@ struct Room {
     std::string id;
     std::string verify_uid; ///< UID used for verification
     std::string ip;
-    u32 net_version;
-    bool has_password;
+    u32 net_version{};
+    bool has_password = false;
 
     std::vector<Member> members;
 };

src/core/frontend/applets/cabinet.h

@@ -21,7 +21,7 @@ namespace Core::Frontend {
 struct CabinetParameters {
     Service::NFP::TagInfo tag_info;
     Service::NFP::RegisterInfo register_info;
-    Service::NFP::CabinetMode mode;
+    Service::NFP::CabinetMode mode{};
 };
 
 using CabinetCallback = std::function<void(bool, const std::string&)>;

src/core/frontend/applets/software_keyboard.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -20,9 +23,9 @@ struct KeyboardInitializeParameters {
     std::u16string initial_text;
     char16_t left_optional_symbol_key;
     char16_t right_optional_symbol_key;
-    u32 max_text_length;
-    u32 min_text_length;
-    s32 initial_cursor_position;
+    u32 max_text_length{};
+    u32 min_text_length{};
+    s32 initial_cursor_position{};
     Service::AM::Frontend::SwkbdType type;
     Service::AM::Frontend::SwkbdPasswordMode password_mode;
     Service::AM::Frontend::SwkbdTextDrawType text_draw_type;
@@ -34,12 +37,12 @@ struct KeyboardInitializeParameters {
 };
 
 struct InlineAppearParameters {
-    u32 max_text_length;
-    u32 min_text_length;
-    f32 key_top_scale_x;
-    f32 key_top_scale_y;
-    f32 key_top_translate_x;
-    f32 key_top_translate_y;
+    u32 max_text_length{};
+    u32 min_text_length{};
+    f32 key_top_scale_x{};
+    f32 key_top_scale_y{};
+    f32 key_top_translate_x{};
+    f32 key_top_translate_y{};
     Service::AM::Frontend::SwkbdType type;
     Service::AM::Frontend::SwkbdKeyDisableFlags key_disable_flags;
     bool key_top_as_floating;
@@ -50,7 +53,7 @@ struct InlineAppearParameters {
 
 struct InlineTextParameters {
     std::u16string input_text;
-    s32 cursor_position;
+    s32 cursor_position{};
 };
 
 class SoftwareKeyboardApplet : public Applet {

src/core/hle/service/nfc/nfc_types.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -79,7 +82,7 @@ using DeviceHandle = u64;
 
 // This is nn::nfc::TagInfo
 struct TagInfo {
-    UniqueSerialNumber uuid;
+    UniqueSerialNumber uuid{};
     u8 uuid_length;
     INSERT_PADDING_BYTES(0x15);
     NfcProtocol protocol;

src/core/hle/service/nfp/nfp_types.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -315,7 +318,7 @@ static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
 // This is nn::nfp::RegisterInfo
 struct RegisterInfo {
     Service::Mii::CharInfo mii_char_info;
-    WriteDate creation_date;
+    WriteDate creation_date{};
     AmiiboName amiibo_name;
     u8 font_region;
     INSERT_PADDING_BYTES(0x7A);

src/core/hle/service/ns/platform_service_manager.cpp

@@ -164,7 +164,7 @@ IPlatformServiceManager::IPlatformServiceManager(Core::System& system_, const ch
     // Rebuild shared fonts from data ncas or synthesize
 
     impl->shared_font = std::make_shared<Kernel::PhysicalMemory>(SHARED_FONT_MEM_SIZE);
-    for (auto font : SHARED_FONTS) {
+    for (auto& font : SHARED_FONTS) {
         FileSys::VirtualFile romfs;
         const auto nca =
             nand->GetEntry(static_cast<u64>(font.first), FileSys::ContentRecordType::Data);
@@ -261,7 +261,7 @@ Result IPlatformServiceManager::GetSharedFontInOrderOfPriority(
                                     out_font_sizes.size(), impl->shared_font_regions.size()});
 
     for (size_t i = 0; i < max_size; i++) {
-        auto region = impl->GetSharedFontRegion(i);
+        auto& region = impl->GetSharedFontRegion(i);
 
         out_font_codes[i] = static_cast<u32>(i);
         out_font_offsets[i] = region.offset;

src/dynarmic/README.md

@@ -49,7 +49,7 @@ Important API Changes in v6.x Series
 Documentation
 -------------
 
-Design documentation can be found at [./Design.md](./Design.md).
+Design documentation can be found at [docs/Design.md](docs/Design.md).
 
 
 Usage Example

src/dynarmic/docs/Design.md

@@ -343,279 +343,3 @@ SetTerm(IR::Term::If{cond, term_then, term_else})
 
 This terminal instruction conditionally executes one terminal or another depending
 on the run-time state of the ARM flags.
-
-# Register Allocation (x64 Backend)
-
-`HostLoc`s contain values. A `HostLoc` ("host value location") is either a host CPU register or a host spill location.
-
-Values once set cannot be changed. Values can however be moved by the register allocator between `HostLoc`s. This is
-handled by the register allocator itself and code that uses the register allocator need not and should not move values
-between registers.
-
-The register allocator is based on three concepts: `Use`, `Def` and `Scratch`.
-
-* `Use`: The use of a value.
-* `Define`: The definition of a value, this is the only time when a value is set.
-* `Scratch`: Allocate a register that can be freely modified as one wishes.
-
-Note that `Use`ing a value decrements its `use_count` by one. When the `use_count` reaches zero the value is discarded and no longer exists.
-
-The member functions on `RegAlloc` are just a combination of the above concepts.
-
-The following registers are reserved for internal use and should NOT participate in register allocation:
-- `%xmm0`, `%xmm1`, `%xmm2`: Used as scratch in exclusive memory access.
-- `%rsp`: Stack pointer.
-- `%r15`: JIT pointer
-- `%r14`: Page table pointer.
-- `%r13`: Fastmem pointer.
-
-The layout convenes `%r15` as the JIT state pointer - while it may be tempting to turn it into a synthetic pointer, keeping an entire register (out of 12 available) is preferable over inlining a directly computed immediate.
-
-Do NEVER modify `%r15`, we must make it clear that this register is "immutable" for the entirety of the JIT block duration.
-
-### `Scratch`
-
-```c++
-Xbyak::Reg64 ScratchGpr(HostLocList desired_locations = any_gpr);
-Xbyak::Xmm ScratchXmm(HostLocList desired_locations = any_xmm);
-```
-
-At runtime, allocate one of the registers in `desired_locations`. You are free to modify the register. The register is discarded at the end of the allocation scope.
-
-### Pure `Use`
-
-```c++
-Xbyak::Reg64 UseGpr(Argument& arg);
-Xbyak::Xmm UseXmm(Argument& arg);
-OpArg UseOpArg(Argument& arg);
-void Use(Argument& arg, HostLoc host_loc);
-```
-
-At runtime, the value corresponding to `arg` will be placed a register. The actual register is determined by
-which one of the above functions is called. `UseGpr` places it in an unused GPR, `UseXmm` places it
-in an unused XMM register, `UseOpArg` might be in a register or might be a memory location, and `Use` allows
-you to specify a specific register (GPR or XMM) to use.
-
-This register **must not** have it's value changed.
-
-### `UseScratch`
-
-```c++
-Xbyak::Reg64 UseScratchGpr(Argument& arg);
-Xbyak::Xmm UseScratchXmm(Argument& arg);
-void UseScratch(Argument& arg, HostLoc host_loc);
-```
-
-At runtime, the value corresponding to `arg` will be placed a register. The actual register is determined by
-which one of the above functions is called. `UseScratchGpr` places it in an unused GPR, `UseScratchXmm` places it
-in an unused XMM register, and `UseScratch` allows you to specify a specific register (GPR or XMM) to use.
-
-The return value is the register allocated to you.
-
-You are free to modify the value in the register. The register is discarded at the end of the allocation scope.
-
-### `Define` as register
-
-A `Define` is the defintion of a value. This is the only time when a value may be set.
-
-```c++
-void DefineValue(IR::Inst* inst, const Xbyak::Reg& reg);
-```
-
-By calling `DefineValue`, you are stating that you wish to define the value for `inst`, and you have written the
-value to the specified register `reg`.
-
-### `Define`ing as an alias of a different value
-
-Adding a `Define` to an existing value.
-
-```c++
-void DefineValue(IR::Inst* inst, Argument& arg);
-```
-
-You are declaring that the value for `inst` is the same as the value for `arg`. No host machine instructions are
-emitted.
-
-## When to use each?
-
-* Prefer `Use` to `UseScratch` where possible.
-* Prefer the `OpArg` variants where possible.
-* Prefer to **not** use the specific `HostLoc` variants where possible.
-
-# Return Stack Buffer Optimization (x64 Backend)
-
-One of the optimizations that dynarmic does is block-linking. Block-linking is done when
-the destination address of a jump is available at JIT-time. Instead of returning to the
-dispatcher at the end of a block we can perform block-linking: just jump directly to the
-next block. This is beneficial because returning to the dispatcher can often be quite
-expensive.
-
-What should we do in cases when we can't predict the destination address? The eponymous
-example is when executing a return statement at the end of a function; the return address
-is not statically known at compile time.
-
-We deal with this by using a return stack buffer: When we execute a call instruction,
-we push our prediction onto the RSB. When we execute a return instruction, we pop a
-prediction off the RSB. If the prediction is a hit, we immediately jump to the relevant
-compiled block. Otherwise, we return to the dispatcher.
-
-This is the essential idea behind this optimization.
-
-## `UniqueHash`
-
-One complication dynarmic has is that a compiled block is not uniquely identifiable by
-the PC alone, but bits in the FPSCR and CPSR are also relevant. We resolve this by
-computing a 64-bit `UniqueHash` that is guaranteed to uniquely identify a block.
-
-```c++
-u64 LocationDescriptor::UniqueHash() const {
-    // This value MUST BE UNIQUE.
-    // This calculation has to match up with EmitX64::EmitTerminalPopRSBHint
-    u64 pc_u64 = u64(arm_pc) << 32;
-    u64 fpscr_u64 = u64(fpscr.Value());
-    u64 t_u64 = cpsr.T() ? 1 : 0;
-    u64 e_u64 = cpsr.E() ? 2 : 0;
-    return pc_u64 | fpscr_u64 | t_u64 | e_u64;
-}
-```
-
-## Our implementation isn't actually a stack
-
-Dynarmic's RSB isn't actually a stack. It was implemented as a ring buffer because
-that showed better performance in tests.
-
-### RSB Structure
-
-The RSB is implemented as a ring buffer. `rsb_ptr` is the index of the insertion
-point. Each element in `rsb_location_descriptors` is a `UniqueHash` and they
-each correspond to an element in `rsb_codeptrs`. `rsb_codeptrs` contains the
-host addresses for the corresponding the compiled blocks.
-
-`RSBSize` was chosen by performance testing. Note that this is bigger than the
-size of the real RSB in hardware (which has 3 entries). Larger RSBs than 8
-showed degraded performance.
-
-```c++
-struct JitState {
-    // ...
-
-    static constexpr size_t RSBSize = 8; // MUST be a power of 2.
-    u32 rsb_ptr = 0;
-    std::array<u64, RSBSize> rsb_location_descriptors;
-    std::array<u64, RSBSize> rsb_codeptrs;
-    void ResetRSB();
-
-    // ...
-};
-```
-
-### RSB Push
-
-We insert our prediction at the insertion point iff the RSB doesn't already
-contain a prediction with the same `UniqueHash`.
-
-```c++
-void EmitX64::EmitPushRSB(IR::Block&, IR::Inst* inst) {
-    using namespace Xbyak::util;
-
-    ASSERT(inst->GetArg(0).IsImmediate());
-    u64 imm64 = inst->GetArg(0).GetU64();
-
-    Xbyak::Reg64 code_ptr_reg = reg_alloc.ScratchGpr(code, {HostLoc::RCX});
-    Xbyak::Reg64 loc_desc_reg = reg_alloc.ScratchGpr(code);
-    Xbyak::Reg32 index_reg = reg_alloc.ScratchGpr(code).cvt32();
-    u64 code_ptr = unique_hash_to_code_ptr.find(imm64) != unique_hash_to_code_ptr.end()
-                    ? u64(unique_hash_to_code_ptr[imm64])
-                    : u64(code->GetReturnFromRunCodeAddress());
-
-    code->mov(index_reg, dword[code.ABI_JIT_PTR + offsetof(JitState, rsb_ptr)]);
-    code->add(index_reg, 1);
-    code->and_(index_reg, u32(JitState::RSBSize - 1));
-
-    code->mov(loc_desc_reg, u64(imm64));
-    CodePtr patch_location = code->getCurr<CodePtr>();
-    patch_unique_hash_locations[imm64].emplace_back(patch_location);
-    code->mov(code_ptr_reg, u64(code_ptr)); // This line has to match up with EmitX64::Patch.
-    code->EnsurePatchLocationSize(patch_location, 10);
-
-    Xbyak::Label label;
-    for (size_t i = 0; i < JitState::RSBSize; ++i) {
-        code->cmp(loc_desc_reg, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_location_descriptors) + i * sizeof(u64)]);
-        code->je(label, code->T_SHORT);
-    }
-
-    code->mov(dword[code.ABI_JIT_PTR + offsetof(JitState, rsb_ptr)], index_reg);
-    code->mov(qword[code.ABI_JIT_PTR + index_reg.cvt64() * 8 + offsetof(JitState, rsb_location_descriptors)], loc_desc_reg);
-    code->mov(qword[code.ABI_JIT_PTR + index_reg.cvt64() * 8 + offsetof(JitState, rsb_codeptrs)], code_ptr_reg);
-    code->L(label);
-}
-```
-
-In pseudocode:
-
-```c++
-    for (i := 0 .. RSBSize-1)
-        if (rsb_location_descriptors[i] == imm64)
-        goto label;
-    rsb_ptr++;
-    rsb_ptr %= RSBSize;
-    rsb_location_desciptors[rsb_ptr] = imm64; //< The UniqueHash
-    rsb_codeptr[rsb_ptr] = /* codeptr corresponding to the UniqueHash */;
-label:
-```
-
-## RSB Pop
-
-To check if a predicition is in the RSB, we linearly scan the RSB.
-
-```c++
-void EmitX64::EmitTerminalPopRSBHint(IR::Term::PopRSBHint, IR::LocationDescriptor initial_location) {
-    using namespace Xbyak::util;
-
-    // This calculation has to match up with IREmitter::PushRSB
-    code->mov(ecx, MJitStateReg(Arm::Reg::PC));
-    code->shl(rcx, 32);
-    code->mov(ebx, dword[code.ABI_JIT_PTR + offsetof(JitState, FPSCR_mode)]);
-    code->or_(ebx, dword[code.ABI_JIT_PTR + offsetof(JitState, CPSR_et)]);
-    code->or_(rbx, rcx);
-
-    code->mov(rax, u64(code->GetReturnFromRunCodeAddress()));
-    for (size_t i = 0; i < JitState::RSBSize; ++i) {
-        code->cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_location_descriptors) + i * sizeof(u64)]);
-        code->cmove(rax, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_codeptrs) + i * sizeof(u64)]);
-    }
-
-    code->jmp(rax);
-}
-```
-
-In pseudocode:
-
-```c++
-rbx := ComputeUniqueHash()
-rax := ReturnToDispatch
-for (i := 0 .. RSBSize-1)
-    if (rbx == rsb_location_descriptors[i])
-        rax = rsb_codeptrs[i]
-goto rax
-```
-
-# Fast memory (Fastmem)
-
-The main way of accessing memory in JITed programs is via an invoked function, say "Read()" and "Write()". On our translator, such functions usually take a sizable amounts of code space (push + call + pop). Trash the i-cache (due to an indirect call) and overall make code emission more bloated.
-
-The solution? Delegate invalid accesses to a dedicated arena, similar to a swap. The main idea behind such mechanism is to allow the OS to transmit page faults from invalid accesses into the JIT translator directly, bypassing address space calls, while this sacrifices i-cache coherency, it allows for smaller code-size and "faster" throguhput.
-
-Many kernels however, do not support fast signal dispatching (Solaris, OpenBSD, FreeBSD). Only Linux and Windows support relatively "fast" signal dispatching. Hence this feature is better suited for them only.
-
-![Host to guest translation](./HostToGuest.svg)
-
-![Fastmem translation](./Fastmem.svg)
-
-In x86_64 for example, when a page fault occurs, the CPU will transmit via control registers and the stack (see `IRETQ`) the appropriate arguments for a page fault handler, the OS then will transform that into something that can be sent into userspace.
-
-Most modern OSes implement kernel-page-table-isolation, which means a set of system calls will invoke a context switch (not often used syscalls), whereas others are handled by the same process address space (the smaller kernel portion, often used syscalls) without needing a context switch. This effect can be negated on systems with PCID (up to 4096 unique IDs).
-
-Signal dispatching takes a performance hit from reloading `%cr3` - but Linux does something more clever to avoid reloads:  VDSO will take care of the entire thing in the same address space. Making dispatching as costly as an indirect call - without the hazards of increased code size.
-
-The main downside from this is the constant i-cache trashing and pipeline hazards introduced by the VDSO signal handlers. However on most benchmarks fastmem does perform faster than without (Linux only). This also abuses the fact of continous address space emulation by using an arena - which can then be potentially transparently mapped into a hugepage, reducing TLB walk times.

src/dynarmic/docs/FastMemory.md

@@ -0,0 +1,19 @@
+# Fast memory (Fastmem)
+
+The main way of accessing memory in JITed programs is via an invoked function, say "Read()" and "Write()". On our translator, such functions usually take a sizable amounts of code space (push + call + pop). Trash the i-cache (due to an indirect call) and overall make code emission more bloated.
+
+The solution? Delegate invalid accesses to a dedicated arena, similar to a swap. The main idea behind such mechanism is to allow the OS to transmit page faults from invalid accesses into the JIT translator directly, bypassing address space calls, while this sacrifices i-cache coherency, it allows for smaller code-size and "faster" throguhput.
+
+Many kernels however, do not support fast signal dispatching (Solaris, OpenBSD, FreeBSD). Only Linux and Windows support relatively "fast" signal dispatching. Hence this feature is better suited for them only.
+
+![Host to guest translation](./HostToGuest.svg)
+
+![Fastmem translation](./Fastmem.svg)
+
+In x86_64 for example, when a page fault occurs, the CPU will transmit via control registers and the stack (see `IRETQ`) the appropriate arguments for a page fault handler, the OS then will transform that into something that can be sent into userspace.
+
+Most modern OSes implement kernel-page-table-isolation, which means a set of system calls will invoke a context switch (not often used syscalls), whereas others are handled by the same process address space (the smaller kernel portion, often used syscalls) without needing a context switch. This effect can be negated on systems with PCID (up to 4096 unique IDs).
+
+Signal dispatching takes a performance hit from reloading `%cr3` - but Linux does something more clever to avoid reloads:  VDSO will take care of the entire thing in the same address space. Making dispatching as costly as an indirect call - without the hazards of increased code size.
+
+The main downside from this is the constant i-cache trashing and pipeline hazards introduced by the VDSO signal handlers. However on most benchmarks fastmem does perform faster than without (Linux only). This also abuses the fact of continous address space emulation by using an arena - which can then be potentially transparently mapped into a hugepage, reducing TLB walk times.

src/dynarmic/docs/RegisterAllocator.md

@@ -0,0 +1,97 @@
+# Register Allocation (x64 Backend)
+
+`HostLoc`s contain values. A `HostLoc` ("host value location") is either a host CPU register or a host spill location.
+
+Values once set cannot be changed. Values can however be moved by the register allocator between `HostLoc`s. This is
+handled by the register allocator itself and code that uses the register allocator need not and should not move values
+between registers.
+
+The register allocator is based on three concepts: `Use`, `Def` and `Scratch`.
+
+* `Use`: The use of a value.
+* `Define`: The definition of a value, this is the only time when a value is set.
+* `Scratch`: Allocate a register that can be freely modified as one wishes.
+
+Note that `Use`ing a value decrements its `use_count` by one. When the `use_count` reaches zero the value is discarded and no longer exists.
+
+The member functions on `RegAlloc` are just a combination of the above concepts.
+
+The following registers are reserved for internal use and should NOT participate in register allocation:
+- `%xmm0`, `%xmm1`, `%xmm2`: Used as scratch in exclusive memory access.
+- `%rsp`: Stack pointer.
+- `%r15`: JIT pointer
+- `%r14`: Page table pointer.
+- `%r13`: Fastmem pointer.
+
+The layout convenes `%r15` as the JIT state pointer - while it may be tempting to turn it into a synthetic pointer, keeping an entire register (out of 12 available) is preferable over inlining a directly computed immediate.
+
+Do NEVER modify `%r15`, we must make it clear that this register is "immutable" for the entirety of the JIT block duration.
+
+### `Scratch`
+
+```c++
+Xbyak::Reg64 ScratchGpr(HostLocList desired_locations = any_gpr);
+Xbyak::Xmm ScratchXmm(HostLocList desired_locations = any_xmm);
+```
+
+At runtime, allocate one of the registers in `desired_locations`. You are free to modify the register. The register is discarded at the end of the allocation scope.
+
+### Pure `Use`
+
+```c++
+Xbyak::Reg64 UseGpr(Argument& arg);
+Xbyak::Xmm UseXmm(Argument& arg);
+OpArg UseOpArg(Argument& arg);
+void Use(Argument& arg, HostLoc host_loc);
+```
+
+At runtime, the value corresponding to `arg` will be placed a register. The actual register is determined by
+which one of the above functions is called. `UseGpr` places it in an unused GPR, `UseXmm` places it
+in an unused XMM register, `UseOpArg` might be in a register or might be a memory location, and `Use` allows
+you to specify a specific register (GPR or XMM) to use.
+
+This register **must not** have it's value changed.
+
+### `UseScratch`
+
+```c++
+Xbyak::Reg64 UseScratchGpr(Argument& arg);
+Xbyak::Xmm UseScratchXmm(Argument& arg);
+void UseScratch(Argument& arg, HostLoc host_loc);
+```
+
+At runtime, the value corresponding to `arg` will be placed a register. The actual register is determined by
+which one of the above functions is called. `UseScratchGpr` places it in an unused GPR, `UseScratchXmm` places it
+in an unused XMM register, and `UseScratch` allows you to specify a specific register (GPR or XMM) to use.
+
+The return value is the register allocated to you.
+
+You are free to modify the value in the register. The register is discarded at the end of the allocation scope.
+
+### `Define` as register
+
+A `Define` is the defintion of a value. This is the only time when a value may be set.
+
+```c++
+void DefineValue(IR::Inst* inst, const Xbyak::Reg& reg);
+```
+
+By calling `DefineValue`, you are stating that you wish to define the value for `inst`, and you have written the
+value to the specified register `reg`.
+
+### `Define`ing as an alias of a different value
+
+Adding a `Define` to an existing value.
+
+```c++
+void DefineValue(IR::Inst* inst, Argument& arg);
+```
+
+You are declaring that the value for `inst` is the same as the value for `arg`. No host machine instructions are
+emitted.
+
+## When to use each?
+
+* Prefer `Use` to `UseScratch` where possible.
+* Prefer the `OpArg` variants where possible.
+* Prefer to **not** use the specific `HostLoc` variants where possible.

src/dynarmic/docs/ReturnStackBufferOptimization.md

@@ -0,0 +1,157 @@
+# Return Stack Buffer Optimization (x64 Backend)
+
+One of the optimizations that dynarmic does is block-linking. Block-linking is done when
+the destination address of a jump is available at JIT-time. Instead of returning to the
+dispatcher at the end of a block we can perform block-linking: just jump directly to the
+next block. This is beneficial because returning to the dispatcher can often be quite
+expensive.
+
+What should we do in cases when we can't predict the destination address? The eponymous
+example is when executing a return statement at the end of a function; the return address
+is not statically known at compile time.
+
+We deal with this by using a return stack buffer: When we execute a call instruction,
+we push our prediction onto the RSB. When we execute a return instruction, we pop a
+prediction off the RSB. If the prediction is a hit, we immediately jump to the relevant
+compiled block. Otherwise, we return to the dispatcher.
+
+This is the essential idea behind this optimization.
+
+## `UniqueHash`
+
+One complication dynarmic has is that a compiled block is not uniquely identifiable by
+the PC alone, but bits in the FPSCR and CPSR are also relevant. We resolve this by
+computing a 64-bit `UniqueHash` that is guaranteed to uniquely identify a block.
+
+```c++
+u64 LocationDescriptor::UniqueHash() const {
+    // This value MUST BE UNIQUE.
+    // This calculation has to match up with EmitX64::EmitTerminalPopRSBHint
+    u64 pc_u64 = u64(arm_pc) << 32;
+    u64 fpscr_u64 = u64(fpscr.Value());
+    u64 t_u64 = cpsr.T() ? 1 : 0;
+    u64 e_u64 = cpsr.E() ? 2 : 0;
+    return pc_u64 | fpscr_u64 | t_u64 | e_u64;
+}
+```
+
+## Our implementation isn't actually a stack
+
+Dynarmic's RSB isn't actually a stack. It was implemented as a ring buffer because
+that showed better performance in tests.
+
+### RSB Structure
+
+The RSB is implemented as a ring buffer. `rsb_ptr` is the index of the insertion
+point. Each element in `rsb_location_descriptors` is a `UniqueHash` and they
+each correspond to an element in `rsb_codeptrs`. `rsb_codeptrs` contains the
+host addresses for the corresponding the compiled blocks.
+
+`RSBSize` was chosen by performance testing. Note that this is bigger than the
+size of the real RSB in hardware (which has 3 entries). Larger RSBs than 8
+showed degraded performance.
+
+```c++
+struct JitState {
+    // ...
+
+    static constexpr size_t RSBSize = 8; // MUST be a power of 2.
+    u32 rsb_ptr = 0;
+    std::array<u64, RSBSize> rsb_location_descriptors;
+    std::array<u64, RSBSize> rsb_codeptrs;
+    void ResetRSB();
+
+    // ...
+};
+```
+
+### RSB Push
+
+We insert our prediction at the insertion point iff the RSB doesn't already
+contain a prediction with the same `UniqueHash`.
+
+```c++
+void EmitX64::EmitPushRSB(IR::Block&, IR::Inst* inst) {
+    using namespace Xbyak::util;
+
+    ASSERT(inst->GetArg(0).IsImmediate());
+    u64 imm64 = inst->GetArg(0).GetU64();
+
+    Xbyak::Reg64 code_ptr_reg = reg_alloc.ScratchGpr(code, {HostLoc::RCX});
+    Xbyak::Reg64 loc_desc_reg = reg_alloc.ScratchGpr(code);
+    Xbyak::Reg32 index_reg = reg_alloc.ScratchGpr(code).cvt32();
+    u64 code_ptr = unique_hash_to_code_ptr.find(imm64) != unique_hash_to_code_ptr.end()
+                    ? u64(unique_hash_to_code_ptr[imm64])
+                    : u64(code->GetReturnFromRunCodeAddress());
+
+    code->mov(index_reg, dword[code.ABI_JIT_PTR + offsetof(JitState, rsb_ptr)]);
+    code->add(index_reg, 1);
+    code->and_(index_reg, u32(JitState::RSBSize - 1));
+
+    code->mov(loc_desc_reg, u64(imm64));
+    CodePtr patch_location = code->getCurr<CodePtr>();
+    patch_unique_hash_locations[imm64].emplace_back(patch_location);
+    code->mov(code_ptr_reg, u64(code_ptr)); // This line has to match up with EmitX64::Patch.
+    code->EnsurePatchLocationSize(patch_location, 10);
+
+    Xbyak::Label label;
+    for (size_t i = 0; i < JitState::RSBSize; ++i) {
+        code->cmp(loc_desc_reg, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_location_descriptors) + i * sizeof(u64)]);
+        code->je(label, code->T_SHORT);
+    }
+
+    code->mov(dword[code.ABI_JIT_PTR + offsetof(JitState, rsb_ptr)], index_reg);
+    code->mov(qword[code.ABI_JIT_PTR + index_reg.cvt64() * 8 + offsetof(JitState, rsb_location_descriptors)], loc_desc_reg);
+    code->mov(qword[code.ABI_JIT_PTR + index_reg.cvt64() * 8 + offsetof(JitState, rsb_codeptrs)], code_ptr_reg);
+    code->L(label);
+}
+```
+
+In pseudocode:
+
+```c++
+    for (i := 0 .. RSBSize-1)
+        if (rsb_location_descriptors[i] == imm64)
+        goto label;
+    rsb_ptr++;
+    rsb_ptr %= RSBSize;
+    rsb_location_desciptors[rsb_ptr] = imm64; //< The UniqueHash
+    rsb_codeptr[rsb_ptr] = /* codeptr corresponding to the UniqueHash */;
+label:
+```
+
+## RSB Pop
+
+To check if a predicition is in the RSB, we linearly scan the RSB.
+
+```c++
+void EmitX64::EmitTerminalPopRSBHint(IR::Term::PopRSBHint, IR::LocationDescriptor initial_location) {
+    using namespace Xbyak::util;
+
+    // This calculation has to match up with IREmitter::PushRSB
+    code->mov(ecx, MJitStateReg(Arm::Reg::PC));
+    code->shl(rcx, 32);
+    code->mov(ebx, dword[code.ABI_JIT_PTR + offsetof(JitState, FPSCR_mode)]);
+    code->or_(ebx, dword[code.ABI_JIT_PTR + offsetof(JitState, CPSR_et)]);
+    code->or_(rbx, rcx);
+
+    code->mov(rax, u64(code->GetReturnFromRunCodeAddress()));
+    for (size_t i = 0; i < JitState::RSBSize; ++i) {
+        code->cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_location_descriptors) + i * sizeof(u64)]);
+        code->cmove(rax, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_codeptrs) + i * sizeof(u64)]);
+    }
+
+    code->jmp(rax);
+}
+```
+
+In pseudocode:
+
+```c++
+rbx := ComputeUniqueHash()
+rax := ReturnToDispatch
+for (i := 0 .. RSBSize-1)
+    if (rbx == rsb_location_descriptors[i])
+        rax = rsb_codeptrs[i]
+goto rax
+```

src/frontend_common/play_time_manager.h

@@ -48,7 +48,7 @@ private:
     void Save();
 
     PlayTimeDatabase database;
-    u64 running_program_id;
+    u64 running_program_id{};
     std::jthread play_time_thread;
 };
 

src/input_common/helpers/joycon_protocol/poller.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 

src/network/room_member.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -53,7 +56,7 @@ struct ChatEntry {
 
 /// Represents a system status message.
 struct StatusMessageEntry {
-    StatusMessageTypes type; ///< Type of the message
+    StatusMessageTypes type{}; ///< Type of the message
     /// Subject of the message. i.e. the user who is joining/leaving/being banned, etc.
     std::string nickname;
     std::string username;

src/video_core/buffer_cache/buffer_cache.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include <algorithm>
-#include <cstring>
 #include <memory>
 #include <numeric>
 
@@ -16,8 +15,6 @@
 #include "video_core/guest_memory.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/texture_cache/util.h"
-#include "video_core/polygon_mode_utils.h"
-#include "video_core/renderer_vulkan/line_loop_utils.h"
 
 namespace VideoCommon {
 
@@ -356,37 +353,14 @@ void BufferCache<P>::UpdateComputeBuffers() {
 
 template <class P>
 void BufferCache<P>::BindHostGeometryBuffers(bool is_indexed) {
-    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
     if (is_indexed) {
         BindHostIndexBuffer();
-    } else {
-        if constexpr (!P::IS_OPENGL) {
-            const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
-            if (draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
-                polygon_mode == Maxwell::PolygonMode::Line && draw_state.vertex_buffer.count > 1) {
-                const u32 vertex_count = draw_state.vertex_buffer.count;
-                const u32 generated_count = vertex_count + 1;
-                const bool use_u16 = vertex_count <= 0x10000;
-                const u32 element_size = use_u16 ? sizeof(u16) : sizeof(u32);
-                auto staging = runtime.UploadStagingBuffer(
-                    static_cast<size_t>(generated_count) * element_size);
-                std::span<u8> dst_span{staging.mapped_span.data(),
-                                       generated_count * static_cast<size_t>(element_size)};
-                Vulkan::LineLoop::GenerateSequentialWithClosureRaw(dst_span, element_size);
-                const auto synthetic_format = use_u16 ? Maxwell::IndexFormat::UnsignedShort
-                                                      : Maxwell::IndexFormat::UnsignedInt;
-                runtime.BindIndexBuffer(draw_state.topology, synthetic_format,
-                                        draw_state.vertex_buffer.first, generated_count,
-                                        staging.buffer, static_cast<u32>(staging.offset),
-                                        generated_count * element_size);
-            }
-        }
-        if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-            if (draw_state.topology == Maxwell::PrimitiveTopology::Quads ||
-                draw_state.topology == Maxwell::PrimitiveTopology::QuadStrip) {
-                runtime.BindQuadIndexBuffer(draw_state.topology, draw_state.vertex_buffer.first,
-                                            draw_state.vertex_buffer.count);
-            }
+    } else if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
+        const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+        if (draw_state.topology == Maxwell::PrimitiveTopology::Quads ||
+            draw_state.topology == Maxwell::PrimitiveTopology::QuadStrip) {
+            runtime.BindQuadIndexBuffer(draw_state.topology, draw_state.vertex_buffer.first,
+                                        draw_state.vertex_buffer.count);
         }
     }
     BindHostVertexBuffers();
@@ -715,44 +689,6 @@ void BufferCache<P>::BindHostIndexBuffer() {
     const u32 offset = buffer.Offset(channel_state->index_buffer.device_addr);
     const u32 size = channel_state->index_buffer.size;
     const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
-    if constexpr (!P::IS_OPENGL) {
-        const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
-        const bool polygon_line =
-            draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
-            polygon_mode == Maxwell::PolygonMode::Line;
-        if (polygon_line && draw_state.index_buffer.count > 1) {
-            const u32 element_size = draw_state.index_buffer.FormatSizeInBytes();
-            const size_t src_bytes = static_cast<size_t>(draw_state.index_buffer.count) * element_size;
-            const size_t total_bytes = src_bytes + element_size;
-            auto staging = runtime.UploadStagingBuffer(total_bytes);
-            std::span<u8> dst_span{staging.mapped_span.data(), total_bytes};
-            std::span<const u8> src_span;
-            if (!draw_state.inline_index_draw_indexes.empty()) {
-                const u8* const src =
-                    draw_state.inline_index_draw_indexes.data() +
-                    static_cast<size_t>(draw_state.index_buffer.first) * element_size;
-                src_span = {src, src_bytes};
-            } else if (const u8* const cpu_base =
-                           device_memory.GetPointer<u8>(channel_state->index_buffer.device_addr)) {
-                const u8* const src = cpu_base +
-                                      static_cast<size_t>(draw_state.index_buffer.first) * element_size;
-                src_span = {src, src_bytes};
-            } else {
-                const DAddr src_addr =
-                    channel_state->index_buffer.device_addr +
-                    static_cast<DAddr>(draw_state.index_buffer.first) * element_size;
-                device_memory.ReadBlockUnsafe(src_addr, dst_span.data(), src_bytes);
-                src_span = {dst_span.data(), src_bytes};
-            }
-            Vulkan::LineLoop::CopyWithClosureRaw(dst_span, src_span, element_size);
-            buffer.MarkUsage(offset, size);
-            runtime.BindIndexBuffer(draw_state.topology, draw_state.index_buffer.format,
-                                    draw_state.index_buffer.first, draw_state.index_buffer.count + 1,
-                                    staging.buffer, static_cast<u32>(staging.offset),
-                                    static_cast<u32>(total_bytes));
-            return;
-        }
-    }
     if (!draw_state.inline_index_draw_indexes.empty()) [[unlikely]] {
         if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
             auto upload_staging = runtime.UploadStagingBuffer(size);
@@ -1769,21 +1705,26 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
         return NULL_BINDING;
     }
 
+    // xbzk: New size logic. Fixes MCI.
+    // If ever the * comment below prove wrong, the 'if' block may be removed.
     const auto size = [&]() {
         const bool is_nvn_cbuf = cbuf_index == 0;
-        // The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
         if (is_nvn_cbuf) {
-            const u32 ssbo_size = gpu_memory->Read<u32>(ssbo_addr + 8);
-            if (ssbo_size != 0) {
-                return ssbo_size;
+            // * The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
+            const u64 next_qword = gpu_memory->Read<u64>(ssbo_addr + 8);
+            const u32 upper_32 = static_cast<u32>(next_qword >> 32);
+            // Hardware-based detection: GPU addresses have non-zero upper bits
+            if (upper_32 == 0) {
+                // This is a size field, not a GPU address
+                return static_cast<u32>(next_qword);  // Return lower_32
             }
         }
-        // Other titles (notably Doom Eternal) may use STG/LDG on buffer addresses in custom defined
-        // cbufs, which do not store the sizes adjacent to the addresses, so use the fully
-        // mapped buffer size for now.
+        // Fall through: either not NVN cbuf (Doom Eternal & +), or NVN but ssbo_addr+8 is a GPU address (MCI)
         const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
+        // Cap at 8MB to prevent allocator overflow from misinterpreted addresses
         return (std::min)(memory_layout_size, static_cast<u32>(8_MiB));
     }();
+
     // Alignment only applies to the offset of the buffer
     const u32 alignment = runtime.GetStorageBufferAlignment();
     const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);

src/video_core/control/scheduler.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -17,7 +20,7 @@ void Scheduler::Push(s32 channel, CommandList&& entries) {
     std::unique_lock lk(scheduling_guard);
     auto it = channels.find(channel);
     ASSERT(it != channels.end());
-    auto channel_state = it->second;
+    auto& channel_state = it->second;
     gpu.BindChannel(channel_state->bind_id);
     channel_state->dma_pusher->Push(std::move(entries));
     channel_state->dma_pusher->DispatchCalls();

src/video_core/polygon_mode_utils.h

@@ -1,46 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include "video_core/engines/maxwell_3d.h"
-
-namespace VideoCore {
-
-inline Tegra::Engines::Maxwell3D::Regs::PolygonMode EffectivePolygonMode(
-    const Tegra::Engines::Maxwell3D::Regs& regs) {
-    using Maxwell = Tegra::Engines::Maxwell3D::Regs;
-
-    const bool cull_enabled = regs.gl_cull_test_enabled != 0;
-    const auto cull_face = regs.gl_cull_face;
-    const bool cull_front = cull_enabled && (cull_face == Maxwell::CullFace::Front ||
-                                             cull_face == Maxwell::CullFace::FrontAndBack);
-    const bool cull_back = cull_enabled && (cull_face == Maxwell::CullFace::Back ||
-                                            cull_face == Maxwell::CullFace::FrontAndBack);
-
-    const bool render_front = !cull_front;
-    const bool render_back = !cull_back;
-
-    const auto front_mode = regs.polygon_mode_front;
-    const auto back_mode = regs.polygon_mode_back;
-
-    if (render_front && render_back && front_mode != back_mode) {
-        if (front_mode == Maxwell::PolygonMode::Line || back_mode == Maxwell::PolygonMode::Line) {
-            return Maxwell::PolygonMode::Line;
-        }
-        if (front_mode == Maxwell::PolygonMode::Point || back_mode == Maxwell::PolygonMode::Point) {
-            return Maxwell::PolygonMode::Point;
-        }
-    }
-
-    if (render_front) {
-        return front_mode;
-    }
-    if (render_back) {
-        return back_mode;
-    }
-    return front_mode;
-}
-
-} // namespace VideoCore
-

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/fixed_pipeline_state.cpp

@@ -15,7 +15,6 @@
 #include "video_core/engines/draw_manager.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
-#include "video_core/polygon_mode_utils.h"
 
 namespace Vulkan {
 namespace {
@@ -66,7 +65,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
     dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
     xfb_enabled.Assign(regs.transform_feedback_enabled != 0);
     ndc_minus_one_to_one.Assign(regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1 : 0);
-    polygon_mode.Assign(PackPolygonMode(VideoCore::EffectivePolygonMode(regs)));
+    polygon_mode.Assign(PackPolygonMode(regs.polygon_mode_front));
     tessellation_primitive.Assign(static_cast<u32>(regs.tessellation.params.domain_type.Value()));
     tessellation_spacing.Assign(static_cast<u32>(regs.tessellation.params.spacing.Value()));
     tessellation_clockwise.Assign(regs.tessellation.params.output_primitives.Value() ==

src/video_core/renderer_vulkan/line_loop_utils.h

@@ -1,68 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <algorithm>
-#include <cstring>
-#include <span>
-
-#include "common/assert.h"
-#include "common/common_types.h"
-
-namespace Vulkan::LineLoop {
-
-inline void CopyWithClosureRaw(std::span<u8> dst, std::span<const u8> src, size_t element_size) {
-    ASSERT_MSG(dst.size() == src.size() + element_size, "Invalid line loop copy sizes");
-    if (src.empty()) {
-        if (!dst.empty()) {
-            std::fill(dst.begin(), dst.end(), u8{0});
-        }
-        return;
-    }
-    std::memcpy(dst.data(), src.data(), src.size());
-    std::memcpy(dst.data() + src.size(), src.data(), element_size);
-}
-
-inline void GenerateSequentialWithClosureRaw(std::span<u8> dst, size_t element_size,
-                                             u64 start_value = 0) {
-    if (dst.empty()) {
-        return;
-    }
-    const size_t last = dst.size() - element_size;
-    size_t offset = 0;
-    u64 value = start_value;
-    while (offset < last) {
-        std::memcpy(dst.data() + offset, &value, element_size);
-        offset += element_size;
-        ++value;
-    }
-    std::memcpy(dst.data() + offset, &start_value, element_size);
-}
-
-template <typename T>
-inline void CopyWithClosure(std::span<T> dst, std::span<const T> src) {
-    ASSERT_MSG(dst.size() == src.size() + 1, "Invalid destination size for line loop copy");
-    if (src.empty()) {
-        if (!dst.empty()) {
-            dst.front() = {};
-        }
-        return;
-    }
-    std::copy(src.begin(), src.end(), dst.begin());
-    dst.back() = src.front();
-}
-
-template <typename T>
-inline void GenerateSequentialWithClosure(std::span<T> dst, T start_value = {}) {
-    if (dst.empty()) {
-        return;
-    }
-    const size_t last = dst.size() - 1;
-    for (size_t i = 0; i < last; ++i) {
-        dst[i] = static_cast<T>(start_value + static_cast<T>(i));
-    }
-    dst.back() = start_value;
-}
-
-} // namespace Vulkan::LineLoop

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -108,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:
@@ -262,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) {
@@ -271,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;
@@ -280,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:
@@ -326,9 +313,44 @@ VkShaderStageFlagBits ShaderStage(Shader::Stage stage) {
 }
 
 VkPrimitiveTopology PrimitiveTopology([[maybe_unused]] const Device& device,
-                                      Maxwell::PrimitiveTopology topology,
-                                      Maxwell::PolygonMode polygon_mode) {
-    return detail::PrimitiveTopologyNoDevice(topology, polygon_mode);
+                                      Maxwell::PrimitiveTopology topology) {
+    switch (topology) {
+    case Maxwell::PrimitiveTopology::Points:
+        return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+    case Maxwell::PrimitiveTopology::Lines:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+    case Maxwell::PrimitiveTopology::LineLoop:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case Maxwell::PrimitiveTopology::LineStrip:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+    case Maxwell::PrimitiveTopology::Triangles:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case Maxwell::PrimitiveTopology::TriangleStrip:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
+    case Maxwell::PrimitiveTopology::TriangleFan:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
+    case Maxwell::PrimitiveTopology::LinesAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::LineStripAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::TrianglesAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::Quads:
+    case Maxwell::PrimitiveTopology::QuadStrip:
+        // TODO: Use VK_PRIMITIVE_TOPOLOGY_QUAD_LIST_EXT/VK_PRIMITIVE_TOPOLOGY_QUAD_STRIP_EXT
+        // whenever it releases
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case Maxwell::PrimitiveTopology::Patches:
+        return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
+    case Maxwell::PrimitiveTopology::Polygon:
+        LOG_WARNING(Render_Vulkan, "Draw mode is Polygon with a polygon mode of lines should be a "
+                                   "single body and not a bunch of triangles.");
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
+    }
+    UNIMPLEMENTED_MSG("Unimplemented topology={}", topology);
+    return {};
 }
 
 VkFormat VertexFormat(const Device& device, Maxwell::VertexAttribute::Type type,

src/video_core/renderer_vulkan/maxwell_to_vk.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,52 +15,6 @@ namespace Vulkan::MaxwellToVK {
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 using PixelFormat = VideoCore::Surface::PixelFormat;
 
-namespace detail {
-constexpr VkPrimitiveTopology PrimitiveTopologyNoDevice(Maxwell::PrimitiveTopology topology,
-                                                        Maxwell::PolygonMode polygon_mode) {
-    switch (topology) {
-    case Maxwell::PrimitiveTopology::Points:
-        return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
-    case Maxwell::PrimitiveTopology::Lines:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
-    case Maxwell::PrimitiveTopology::LineLoop:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
-    case Maxwell::PrimitiveTopology::LineStrip:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
-    case Maxwell::PrimitiveTopology::Triangles:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case Maxwell::PrimitiveTopology::TriangleStrip:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
-    case Maxwell::PrimitiveTopology::TriangleFan:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
-    case Maxwell::PrimitiveTopology::LinesAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::LineStripAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::TrianglesAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::Quads:
-    case Maxwell::PrimitiveTopology::QuadStrip:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case Maxwell::PrimitiveTopology::Patches:
-        return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
-    case Maxwell::PrimitiveTopology::Polygon:
-        switch (polygon_mode) {
-        case Maxwell::PolygonMode::Fill:
-            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
-        case Maxwell::PolygonMode::Line:
-            return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
-        case Maxwell::PolygonMode::Point:
-            return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
-        }
-        break;
-    }
-    return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-}
-} // namespace detail
-
 namespace Sampler {
 
 VkFilter Filter(Tegra::Texture::TextureFilter filter);
@@ -95,8 +46,7 @@ struct FormatInfo {
 
 VkShaderStageFlagBits ShaderStage(Shader::Stage stage);
 
-VkPrimitiveTopology PrimitiveTopology(const Device& device, Maxwell::PrimitiveTopology topology,
-                                      Maxwell::PolygonMode polygon_mode);
+VkPrimitiveTopology PrimitiveTopology(const Device& device, Maxwell::PrimitiveTopology topology);
 
 VkFormat VertexFormat(const Device& device, Maxwell::VertexAttribute::Type type,
                       Maxwell::VertexAttribute::Size size);

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <iostream>
 #include <span>
-#include <string_view>
 
 #include <boost/container/small_vector.hpp>
 #include <boost/container/static_vector.hpp>
@@ -23,7 +22,6 @@
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
-#include "video_core/polygon_mode_utils.h"
 #include "video_core/shader_notify.h"
 #include "video_core/texture_cache/texture_cache.h"
 #include "video_core/vulkan_common/vulkan_device.h"
@@ -616,10 +614,7 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         vertex_input_ci.pNext = &input_divisor_ci;
     }
     const bool has_tess_stages = spv_modules[1] || spv_modules[2];
-    const auto polygon_mode =
-        FixedPipelineState::UnpackPolygonMode(key.state.polygon_mode.Value());
-    auto input_assembly_topology =
-        MaxwellToVK::PrimitiveTopology(device, key.state.topology, polygon_mode);
+    auto input_assembly_topology = MaxwellToVK::PrimitiveTopology(device, key.state.topology);
     if (input_assembly_topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST) {
         if (!has_tess_stages) {
             LOG_WARNING(Render_Vulkan, "Patch topology used without tessellation, using points");
@@ -634,33 +629,6 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
             input_assembly_topology = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
         }
     }
-    if (key.state.topology == Maxwell::PrimitiveTopology::Polygon) {
-        const auto polygon_mode_name = [polygon_mode]() -> std::string_view {
-            switch (polygon_mode) {
-            case Maxwell::PolygonMode::Fill:
-                return "Fill";
-            case Maxwell::PolygonMode::Line:
-                return "Line";
-            case Maxwell::PolygonMode::Point:
-                return "Point";
-            }
-            return "Unknown";
-        }();
-        const auto vk_topology_name = [input_assembly_topology]() -> std::string_view {
-            switch (input_assembly_topology) {
-            case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
-                return "TriangleFan";
-            case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
-                return "LineStrip";
-            case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
-                return "PointList";
-            default:
-                return "Unexpected";
-            }
-        }();
-        LOG_DEBUG(Render_Vulkan, "Polygon primitive in {} mode mapped to {}", polygon_mode_name,
-                  vk_topology_name);
-    }
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
         .pNext = nullptr,

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -37,7 +37,6 @@
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/shader_cache.h"
 #include "video_core/texture_cache/texture_cache_base.h"
-#include "video_core/polygon_mode_utils.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
@@ -109,7 +108,7 @@ VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t in
 
 VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u32 down_shift = 0) {
     const auto& src = regs.scissor_test[index];
-    VkRect2D scissor;
+    VkRect2D scissor{};
     const auto scale_up = [&](s32 value) -> s32 {
         if (value == 0) {
             return 0U;
@@ -149,8 +148,7 @@ VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u3
     return scissor;
 }
 
-DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances, bool is_indexed,
-                          Maxwell::PolygonMode polygon_mode) {
+DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances, bool is_indexed) {
     DrawParams params{
         .base_instance = draw_state.base_instance,
         .num_instances = num_instances,
@@ -170,21 +168,6 @@ DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances,
         params.base_vertex = 0;
         params.is_indexed = true;
     }
-    const bool polygon_line =
-        draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
-        polygon_mode == Maxwell::PolygonMode::Line;
-    if (polygon_line) {
-        if (params.is_indexed) {
-            if (draw_state.index_buffer.count > 1) {
-                params.num_vertices = draw_state.index_buffer.count + 1;
-            }
-        } else if (draw_state.vertex_buffer.count > 1) {
-            params.num_vertices = draw_state.vertex_buffer.count + 1;
-            params.is_indexed = true;
-            params.first_index = 0;
-            params.base_vertex = draw_state.vertex_buffer.first;
-        }
-    }
     return params;
 }
 } // Anonymous namespace
@@ -250,8 +233,7 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
     PrepareDraw(is_indexed, [this, is_indexed, instance_count] {
         const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
         const u32 num_instances{instance_count};
-        const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
-        const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed, polygon_mode)};
+        const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed)};
         scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
             if (draw_params.is_indexed) {
                 cmdbuf.DrawIndexed(draw_params.num_vertices, draw_params.num_instances,
@@ -392,7 +374,7 @@ void RasterizerVulkan::Clear(u32 layer_count) {
     }
     UpdateViewportsState(regs);
 
-    VkRect2D default_scissor;
+    VkRect2D default_scissor{};
     default_scissor.offset.x = 0;
     default_scissor.offset.y = 0;
     default_scissor.extent.width = (std::numeric_limits<s32>::max)();

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

src/yuzu/configuration/configure_input.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2016 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -71,11 +74,11 @@ private:
 
     std::unique_ptr<InputProfiles> profiles;
 
-    std::array<ConfigureInputPlayer*, 8> player_controllers;
-    std::array<QWidget*, 8> player_tabs;
+    std::array<ConfigureInputPlayer*, 8> player_controllers{};
+    std::array<QWidget*, 8> player_tabs{};
     // Checkboxes representing the "Connected Controllers".
-    std::array<QCheckBox*, 8> connected_controller_checkboxes;
-    ConfigureInputAdvanced* advanced;
+    std::array<QCheckBox*, 8> connected_controller_checkboxes{};
+    ConfigureInputAdvanced* advanced = nullptr;
 
     Core::System& system;
 };

src/yuzu/configuration/configure_input_player_widget.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -689,10 +692,10 @@ void PlayerControlPreview::DrawHandheldController(QPainter& p, const QPointF cen
     {
         // Draw joysticks
         using namespace Settings::NativeAnalog;
-        const auto l_stick = QPointF(stick_values[LStick].x.value, stick_values[LStick].y.value);
-        const auto l_button = button_values[Settings::NativeButton::LStick];
-        const auto r_stick = QPointF(stick_values[RStick].x.value, stick_values[RStick].y.value);
-        const auto r_button = button_values[Settings::NativeButton::RStick];
+        const auto& l_stick = QPointF(stick_values[LStick].x.value, stick_values[LStick].y.value);
+        const auto& l_button = button_values[Settings::NativeButton::LStick];
+        const auto& r_stick = QPointF(stick_values[RStick].x.value, stick_values[RStick].y.value);
+        const auto& r_button = button_values[Settings::NativeButton::RStick];
 
         DrawJoystick(p, center + QPointF(-171, -41) + (l_stick * 4), 1.0f, l_button);
         DrawJoystick(p, center + QPointF(171, 8) + (r_stick * 4), 1.0f, r_button);

src/yuzu/configuration/configure_input_player_widget.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -214,7 +217,7 @@ private:
 
     bool mapping_active{};
     int blink_counter{};
-    int callback_key;
+    int callback_key{};
     QColor button_color{};
     ColorMapping colors{};
     Core::HID::LedPattern led_pattern{0, 0, 0, 0};

src/yuzu/main_window.cpp

@@ -1495,7 +1495,7 @@ void MainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
             (state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
             auto_paused = true;
             OnPauseGame();
-        } else if (!emu_thread->IsRunning() && auto_paused && state == Qt::ApplicationActive) {
+        } else if (!emu_thread->IsRunning() && auto_paused && (state & Qt::ApplicationActive)) {
             auto_paused = false;
             OnStartGame();
         }
@@ -1505,7 +1505,7 @@ void MainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
             (state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
             Settings::values.audio_muted = true;
             auto_muted = true;
-        } else if (auto_muted && state == Qt::ApplicationActive) {
+        } else if (auto_muted && (state & Qt::ApplicationActive)) {
             Settings::values.audio_muted = false;
             auto_muted = false;
         }

src/yuzu/main_window.h

@@ -482,13 +482,13 @@ private:
 
     MultiplayerState* multiplayer_state = nullptr;
 
-    GRenderWindow* render_window;
-    GameList* game_list;
-    LoadingScreen* loading_screen;
+    GRenderWindow* render_window = nullptr;
+    GameList* game_list = nullptr;
+    LoadingScreen* loading_screen = nullptr;
     QTimer shutdown_timer;
     OverlayDialog* shutdown_dialog{};
 
-    GameListPlaceholder* game_list_placeholder;
+    GameListPlaceholder* game_list_placeholder = nullptr;
 
     std::vector<VkDeviceInfo::Record> vk_device_records;
 
@@ -531,7 +531,7 @@ private:
     QString startup_icon_theme;
 
     // Debugger panes
-    ControllerDialog* controller_dialog;
+    ControllerDialog* controller_dialog = nullptr;
 
     QAction* actions_recent_files[max_recent_files_item];
 
@@ -543,7 +543,7 @@ private:
     QTranslator translator;
 
     // Install progress dialog
-    QProgressDialog* install_progress;
+    QProgressDialog* install_progress = nullptr;
 
     // Last game booted, used for multi-process apps
     QString last_filename_booted;

src/yuzu/multiplayer/lobby_p.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -175,7 +178,7 @@ public:
 private:
     QString username;
     QString nickname;
-    u64 title_id;
+    u64 title_id{};
     QString game_name;
 };
 

tools/windows/install-vulkan-sdk.ps1

@@ -14,7 +14,7 @@ try {
     Exit 1
 }
 
-$VulkanSDKVer = "1.4.328.1"
+$VulkanSDKVer = "1.4.335.0"
 $VULKAN_SDK = "C:/VulkanSDK/$VulkanSDKVer"
 $ExeFile = "vulkansdk-windows-X64-$VulkanSDKVer.exe"
 $Uri = "https://sdk.lunarg.com/sdk/download/$VulkanSDKVer/windows/$ExeFile"

tools/windows/install-vulkan-sdk.sh

@@ -2,7 +2,7 @@
 # SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-: "${VULKAN_SDK_VER:=1.4.328.1}"
+: "${VULKAN_SDK_VER:=1.4.335.0}"
 : "${VULKAN_ROOT:=C:/VulkanSDK/$VULKAN_SDK_VER}"
 EXE_FILE="vulkansdk-windows-X64-$VULKAN_SDK_VER.exe"
 URI="https://sdk.lunarg.com/sdk/download/$VULKAN_SDK_VER/windows/$EXE_FILE"