refactor: Convert ENUM macros to explicit enum class definitions

- Convert ENUM() macro calls to standard C++ enum class syntax
- Add explicit numeric values to each enum member for clarity
- Manually define EnumMetadata<T>::Canonicalizations() specializations
- Manually define EnumMetadata<T>::Index() specializations
- Special handling for ResolutionSetup which requires signed (s32) values

Benefits:
- Improved type safety and compiler error messages
- Better IDE support for navigation and refactoring
- More explicit and self-documenting code
- Easier to debug enum-related issues
- Eliminates macro expansion complexity

Signed-off-by: Zephyron <zephyron@citron-emu.org>

src/common/settings_enums.h

@@ -103,65 +103,755 @@ inline u32 EnumMetadata<AudioEngine>::Index() {
     return 100;
 }
 
-ENUM(AudioMode, Mono, Stereo, Surround);
+enum class AudioMode : u32 {
+    Mono = 0,
+    Stereo = 1,
+    Surround = 2,
+};
 
-ENUM(Language, Japanese, EnglishAmerican, French, German, Italian, Spanish, Chinese, Korean, Dutch,
+template <>
-     Portuguese, Russian, Taiwanese, EnglishBritish, FrenchCanadian, SpanishLatin,
+inline std::vector<std::pair<std::string, AudioMode>>
-     ChineseSimplified, ChineseTraditional, PortugueseBrazilian);
+EnumMetadata<AudioMode>::Canonicalizations() {
+    return {
+        {"Mono", AudioMode::Mono},
+        {"Stereo", AudioMode::Stereo},
+        {"Surround", AudioMode::Surround},
+    };
+}
 
-ENUM(Region, Japan, Usa, Europe, Australia, China, Korea, Taiwan);
+template <>
+inline u32 EnumMetadata<AudioMode>::Index() {
+    return 0;
+}
 
-ENUM(TimeZone, Auto, Default, Cet, Cst6Cdt, Cuba, Eet, Egypt, Eire, Est, Est5Edt, Gb, GbEire, Gmt,
+enum class Language : u32 {
-     GmtPlusZero, GmtMinusZero, GmtZero, Greenwich, Hongkong, Hst, Iceland, Iran, Israel, Jamaica,
+    Japanese = 0,
-     Japan, Kwajalein, Libya, Met, Mst, Mst7Mdt, Navajo, Nz, NzChat, Poland, Portugal, Prc, Pst8Pdt,
+    EnglishAmerican = 1,
-     Roc, Rok, Singapore, Turkey, Uct, Universal, Utc, WSu, Wet, Zulu);
+    French = 2,
+    German = 3,
+    Italian = 4,
+    Spanish = 5,
+    Chinese = 6,
+    Korean = 7,
+    Dutch = 8,
+    Portuguese = 9,
+    Russian = 10,
+    Taiwanese = 11,
+    EnglishBritish = 12,
+    FrenchCanadian = 13,
+    SpanishLatin = 14,
+    ChineseSimplified = 15,
+    ChineseTraditional = 16,
+    PortugueseBrazilian = 17,
+};
 
-ENUM(AnisotropyMode, Automatic, Default, X2, X4, X8, X16);
+template <>
+inline std::vector<std::pair<std::string, Language>>
+EnumMetadata<Language>::Canonicalizations() {
+    return {
+        {"Japanese", Language::Japanese},
+        {"EnglishAmerican", Language::EnglishAmerican},
+        {"French", Language::French},
+        {"German", Language::German},
+        {"Italian", Language::Italian},
+        {"Spanish", Language::Spanish},
+        {"Chinese", Language::Chinese},
+        {"Korean", Language::Korean},
+        {"Dutch", Language::Dutch},
+        {"Portuguese", Language::Portuguese},
+        {"Russian", Language::Russian},
+        {"Taiwanese", Language::Taiwanese},
+        {"EnglishBritish", Language::EnglishBritish},
+        {"FrenchCanadian", Language::FrenchCanadian},
+        {"SpanishLatin", Language::SpanishLatin},
+        {"ChineseSimplified", Language::ChineseSimplified},
+        {"ChineseTraditional", Language::ChineseTraditional},
+        {"PortugueseBrazilian", Language::PortugueseBrazilian},
+    };
+}
 
-ENUM(AstcDecodeMode, Cpu, Gpu, CpuAsynchronous);
+template <>
+inline u32 EnumMetadata<Language>::Index() {
+    return 1;
+}
 
-ENUM(AstcRecompression, Uncompressed, Bc1, Bc3);
+enum class Region : u32 {
+    Japan = 0,
+    Usa = 1,
+    Europe = 2,
+    Australia = 3,
+    China = 4,
+    Korea = 5,
+    Taiwan = 6,
+};
 
-ENUM(VSyncMode, Immediate, Mailbox, Fifo, FifoRelaxed);
+template <>
+inline std::vector<std::pair<std::string, Region>>
+EnumMetadata<Region>::Canonicalizations() {
+    return {
+        {"Japan", Region::Japan},
+        {"Usa", Region::Usa},
+        {"Europe", Region::Europe},
+        {"Australia", Region::Australia},
+        {"China", Region::China},
+        {"Korea", Region::Korea},
+        {"Taiwan", Region::Taiwan},
+    };
+}
 
-ENUM(VramUsageMode, Conservative, Aggressive, HighEnd, Insane);
+template <>
+inline u32 EnumMetadata<Region>::Index() {
+    return 2;
+}
 
-ENUM(RendererBackend, OpenGL, Vulkan, Null);
+enum class TimeZone : u32 {
+    Auto = 0,
+    Default = 1,
+    Cet = 2,
+    Cst6Cdt = 3,
+    Cuba = 4,
+    Eet = 5,
+    Egypt = 6,
+    Eire = 7,
+    Est = 8,
+    Est5Edt = 9,
+    Gb = 10,
+    GbEire = 11,
+    Gmt = 12,
+    GmtPlusZero = 13,
+    GmtMinusZero = 14,
+    GmtZero = 15,
+    Greenwich = 16,
+    Hongkong = 17,
+    Hst = 18,
+    Iceland = 19,
+    Iran = 20,
+    Israel = 21,
+    Jamaica = 22,
+    Japan = 23,
+    Kwajalein = 24,
+    Libya = 25,
+    Met = 26,
+    Mst = 27,
+    Mst7Mdt = 28,
+    Navajo = 29,
+    Nz = 30,
+    NzChat = 31,
+    Poland = 32,
+    Portugal = 33,
+    Prc = 34,
+    Pst8Pdt = 35,
+    Roc = 36,
+    Rok = 37,
+    Singapore = 38,
+    Turkey = 39,
+    Uct = 40,
+    Universal = 41,
+    Utc = 42,
+    WSu = 43,
+    Wet = 44,
+    Zulu = 45,
+};
 
-ENUM(ShaderBackend, Glsl, Glasm, SpirV);
+template <>
+inline std::vector<std::pair<std::string, TimeZone>>
+EnumMetadata<TimeZone>::Canonicalizations() {
+    return {
+        {"Auto", TimeZone::Auto},
+        {"Default", TimeZone::Default},
+        {"Cet", TimeZone::Cet},
+        {"Cst6Cdt", TimeZone::Cst6Cdt},
+        {"Cuba", TimeZone::Cuba},
+        {"Eet", TimeZone::Eet},
+        {"Egypt", TimeZone::Egypt},
+        {"Eire", TimeZone::Eire},
+        {"Est", TimeZone::Est},
+        {"Est5Edt", TimeZone::Est5Edt},
+        {"Gb", TimeZone::Gb},
+        {"GbEire", TimeZone::GbEire},
+        {"Gmt", TimeZone::Gmt},
+        {"GmtPlusZero", TimeZone::GmtPlusZero},
+        {"GmtMinusZero", TimeZone::GmtMinusZero},
+        {"GmtZero", TimeZone::GmtZero},
+        {"Greenwich", TimeZone::Greenwich},
+        {"Hongkong", TimeZone::Hongkong},
+        {"Hst", TimeZone::Hst},
+        {"Iceland", TimeZone::Iceland},
+        {"Iran", TimeZone::Iran},
+        {"Israel", TimeZone::Israel},
+        {"Jamaica", TimeZone::Jamaica},
+        {"Japan", TimeZone::Japan},
+        {"Kwajalein", TimeZone::Kwajalein},
+        {"Libya", TimeZone::Libya},
+        {"Met", TimeZone::Met},
+        {"Mst", TimeZone::Mst},
+        {"Mst7Mdt", TimeZone::Mst7Mdt},
+        {"Navajo", TimeZone::Navajo},
+        {"Nz", TimeZone::Nz},
+        {"NzChat", TimeZone::NzChat},
+        {"Poland", TimeZone::Poland},
+        {"Portugal", TimeZone::Portugal},
+        {"Prc", TimeZone::Prc},
+        {"Pst8Pdt", TimeZone::Pst8Pdt},
+        {"Roc", TimeZone::Roc},
+        {"Rok", TimeZone::Rok},
+        {"Singapore", TimeZone::Singapore},
+        {"Turkey", TimeZone::Turkey},
+        {"Uct", TimeZone::Uct},
+        {"Universal", TimeZone::Universal},
+        {"Utc", TimeZone::Utc},
+        {"WSu", TimeZone::WSu},
+        {"Wet", TimeZone::Wet},
+        {"Zulu", TimeZone::Zulu},
+    };
+}
 
-ENUM(GpuAccuracy, Low, Normal, High, Extreme);
+template <>
+inline u32 EnumMetadata<TimeZone>::Index() {
+    return 3;
+}
 
-ENUM(CpuBackend, Dynarmic, Nce);
+enum class AnisotropyMode : u32 {
+    Automatic = 0,
+    Default = 1,
+    X2 = 2,
+    X4 = 3,
+    X8 = 4,
+    X16 = 5,
+};
 
-ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid);
+template <>
+inline std::vector<std::pair<std::string, AnisotropyMode>>
+EnumMetadata<AnisotropyMode>::Canonicalizations() {
+    return {
+        {"Automatic", AnisotropyMode::Automatic},
+        {"Default", AnisotropyMode::Default},
+        {"X2", AnisotropyMode::X2},
+        {"X4", AnisotropyMode::X4},
+        {"X8", AnisotropyMode::X8},
+        {"X16", AnisotropyMode::X16},
+    };
+}
 
-ENUM(MemoryLayout, Memory_4Gb, Memory_6Gb, Memory_8Gb, Memory_10Gb, Memory_12Gb, Memory_14Gb, Memory_16Gb);
+template <>
+inline u32 EnumMetadata<AnisotropyMode>::Index() {
+    return 4;
+}
 
-ENUM(ConfirmStop, Ask_Always, Ask_Based_On_Game, Ask_Never);
+enum class AstcDecodeMode : u32 {
+    Cpu = 0,
+    Gpu = 1,
+    CpuAsynchronous = 2,
+};
 
-ENUM(FullscreenMode, Borderless, Exclusive);
+template <>
+inline std::vector<std::pair<std::string, AstcDecodeMode>>
+EnumMetadata<AstcDecodeMode>::Canonicalizations() {
+    return {
+        {"Cpu", AstcDecodeMode::Cpu},
+        {"Gpu", AstcDecodeMode::Gpu},
+        {"CpuAsynchronous", AstcDecodeMode::CpuAsynchronous},
+    };
+}
 
-ENUM(NvdecEmulation, Off, Cpu, Gpu);
+template <>
+inline u32 EnumMetadata<AstcDecodeMode>::Index() {
+    return 5;
+}
 
-ENUM(ResolutionSetup, Res1_4X, Res1_2X, Res3_4X, Res1X, Res3_2X, Res2X, Res3X, Res4X, Res5X, Res6X, Res7X,
+enum class AstcRecompression : u32 {
-     Res8X);
+    Uncompressed = 0,
+    Bc1 = 1,
+    Bc3 = 2,
+};
 
-ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, ScaleForce, ScaleFx, Lanczos, Fsr, Fsr2, MaxEnum);
+template <>
+inline std::vector<std::pair<std::string, AstcRecompression>>
+EnumMetadata<AstcRecompression>::Canonicalizations() {
+    return {
+        {"Uncompressed", AstcRecompression::Uncompressed},
+        {"Bc1", AstcRecompression::Bc1},
+        {"Bc3", AstcRecompression::Bc3},
+    };
+}
 
-ENUM(AntiAliasing, None, Fxaa, Smaa, Taa, MaxEnum);
+template <>
+inline u32 EnumMetadata<AstcRecompression>::Index() {
+    return 6;
+}
 
-ENUM(FSR2QualityMode, Quality, Balanced, Performance, UltraPerformance);
+enum class VSyncMode : u32 {
+    Immediate = 0,
+    Mailbox = 1,
+    Fifo = 2,
+    FifoRelaxed = 3,
+};
 
-ENUM(FrameSkipping, Disabled, Enabled, MaxEnum);
+template <>
+inline std::vector<std::pair<std::string, VSyncMode>>
+EnumMetadata<VSyncMode>::Canonicalizations() {
+    return {
+        {"Immediate", VSyncMode::Immediate},
+        {"Mailbox", VSyncMode::Mailbox},
+        {"Fifo", VSyncMode::Fifo},
+        {"FifoRelaxed", VSyncMode::FifoRelaxed},
+    };
+}
 
-ENUM(FrameSkippingMode, Adaptive, Fixed, MaxEnum);
+template <>
+inline u32 EnumMetadata<VSyncMode>::Index() {
+    return 7;
+}
 
-ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, R32_9, Stretch);
+enum class VramUsageMode : u32 {
+    Conservative = 0,
+    Aggressive = 1,
+    HighEnd = 2,
+    Insane = 3,
+};
 
-ENUM(ConsoleMode, Handheld, Docked);
+template <>
+inline std::vector<std::pair<std::string, VramUsageMode>>
+EnumMetadata<VramUsageMode>::Canonicalizations() {
+    return {
+        {"Conservative", VramUsageMode::Conservative},
+        {"Aggressive", VramUsageMode::Aggressive},
+        {"HighEnd", VramUsageMode::HighEnd},
+        {"Insane", VramUsageMode::Insane},
+    };
+}
 
-ENUM(AppletMode, HLE, LLE);
+template <>
+inline u32 EnumMetadata<VramUsageMode>::Index() {
+    return 8;
+}
+
+enum class RendererBackend : u32 {
+    OpenGL = 0,
+    Vulkan = 1,
+    Null = 2,
+};
+
+template <>
+inline std::vector<std::pair<std::string, RendererBackend>>
+EnumMetadata<RendererBackend>::Canonicalizations() {
+    return {
+        {"OpenGL", RendererBackend::OpenGL},
+        {"Vulkan", RendererBackend::Vulkan},
+        {"Null", RendererBackend::Null},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<RendererBackend>::Index() {
+    return 9;
+}
+
+enum class ShaderBackend : u32 {
+    Glsl = 0,
+    Glasm = 1,
+    SpirV = 2,
+};
+
+template <>
+inline std::vector<std::pair<std::string, ShaderBackend>>
+EnumMetadata<ShaderBackend>::Canonicalizations() {
+    return {
+        {"Glsl", ShaderBackend::Glsl},
+        {"Glasm", ShaderBackend::Glasm},
+        {"SpirV", ShaderBackend::SpirV},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<ShaderBackend>::Index() {
+    return 10;
+}
+
+enum class GpuAccuracy : u32 {
+    Low = 0,
+    Normal = 1,
+    High = 2,
+    Extreme = 3,
+};
+
+template <>
+inline std::vector<std::pair<std::string, GpuAccuracy>>
+EnumMetadata<GpuAccuracy>::Canonicalizations() {
+    return {
+        {"Low", GpuAccuracy::Low},
+        {"Normal", GpuAccuracy::Normal},
+        {"High", GpuAccuracy::High},
+        {"Extreme", GpuAccuracy::Extreme},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<GpuAccuracy>::Index() {
+    return 11;
+}
+
+enum class CpuBackend : u32 {
+    Dynarmic = 0,
+    Nce = 1,
+};
+
+template <>
+inline std::vector<std::pair<std::string, CpuBackend>>
+EnumMetadata<CpuBackend>::Canonicalizations() {
+    return {
+        {"Dynarmic", CpuBackend::Dynarmic},
+        {"Nce", CpuBackend::Nce},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<CpuBackend>::Index() {
+    return 12;
+}
+
+enum class CpuAccuracy : u32 {
+    Auto = 0,
+    Accurate = 1,
+    Unsafe = 2,
+    Paranoid = 3,
+};
+
+template <>
+inline std::vector<std::pair<std::string, CpuAccuracy>>
+EnumMetadata<CpuAccuracy>::Canonicalizations() {
+    return {
+        {"Auto", CpuAccuracy::Auto},
+        {"Accurate", CpuAccuracy::Accurate},
+        {"Unsafe", CpuAccuracy::Unsafe},
+        {"Paranoid", CpuAccuracy::Paranoid},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<CpuAccuracy>::Index() {
+    return 13;
+}
+
+enum class MemoryLayout : u32 {
+    Memory_4Gb = 0,
+    Memory_6Gb = 1,
+    Memory_8Gb = 2,
+    Memory_10Gb = 3,
+    Memory_12Gb = 4,
+    Memory_14Gb = 5,
+    Memory_16Gb = 6,
+};
+
+template <>
+inline std::vector<std::pair<std::string, MemoryLayout>>
+EnumMetadata<MemoryLayout>::Canonicalizations() {
+    return {
+        {"Memory_4Gb", MemoryLayout::Memory_4Gb},
+        {"Memory_6Gb", MemoryLayout::Memory_6Gb},
+        {"Memory_8Gb", MemoryLayout::Memory_8Gb},
+        {"Memory_10Gb", MemoryLayout::Memory_10Gb},
+        {"Memory_12Gb", MemoryLayout::Memory_12Gb},
+        {"Memory_14Gb", MemoryLayout::Memory_14Gb},
+        {"Memory_16Gb", MemoryLayout::Memory_16Gb},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<MemoryLayout>::Index() {
+    return 14;
+}
+
+enum class ConfirmStop : u32 {
+    Ask_Always = 0,
+    Ask_Based_On_Game = 1,
+    Ask_Never = 2,
+};
+
+template <>
+inline std::vector<std::pair<std::string, ConfirmStop>>
+EnumMetadata<ConfirmStop>::Canonicalizations() {
+    return {
+        {"Ask_Always", ConfirmStop::Ask_Always},
+        {"Ask_Based_On_Game", ConfirmStop::Ask_Based_On_Game},
+        {"Ask_Never", ConfirmStop::Ask_Never},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<ConfirmStop>::Index() {
+    return 15;
+}
+
+enum class FullscreenMode : u32 {
+    Borderless = 0,
+    Exclusive = 1,
+};
+
+template <>
+inline std::vector<std::pair<std::string, FullscreenMode>>
+EnumMetadata<FullscreenMode>::Canonicalizations() {
+    return {
+        {"Borderless", FullscreenMode::Borderless},
+        {"Exclusive", FullscreenMode::Exclusive},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<FullscreenMode>::Index() {
+    return 16;
+}
+
+enum class NvdecEmulation : u32 {
+    Off = 0,
+    Cpu = 1,
+    Gpu = 2,
+};
+
+template <>
+inline std::vector<std::pair<std::string, NvdecEmulation>>
+EnumMetadata<NvdecEmulation>::Canonicalizations() {
+    return {
+        {"Off", NvdecEmulation::Off},
+        {"Cpu", NvdecEmulation::Cpu},
+        {"Gpu", NvdecEmulation::Gpu},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<NvdecEmulation>::Index() {
+    return 17;
+}
+
+// ResolutionSetup must be specified discretely due to needing signed values
+enum class ResolutionSetup : s32 {
+    Res1_4X = -1,
+    Res1_2X = 0,
+    Res3_4X = 1,
+    Res1X = 2,
+    Res3_2X = 3,
+    Res2X = 4,
+    Res3X = 5,
+    Res4X = 6,
+    Res5X = 7,
+    Res6X = 8,
+    Res7X = 9,
+    Res8X = 10,
+};
+
+template <>
+inline std::vector<std::pair<std::string, ResolutionSetup>>
+EnumMetadata<ResolutionSetup>::Canonicalizations() {
+    return {
+        {"Res1_4X", ResolutionSetup::Res1_4X},
+        {"Res1_2X", ResolutionSetup::Res1_2X},
+        {"Res3_4X", ResolutionSetup::Res3_4X},
+        {"Res1X", ResolutionSetup::Res1X},
+        {"Res3_2X", ResolutionSetup::Res3_2X},
+        {"Res2X", ResolutionSetup::Res2X},
+        {"Res3X", ResolutionSetup::Res3X},
+        {"Res4X", ResolutionSetup::Res4X},
+        {"Res5X", ResolutionSetup::Res5X},
+        {"Res6X", ResolutionSetup::Res6X},
+        {"Res7X", ResolutionSetup::Res7X},
+        {"Res8X", ResolutionSetup::Res8X},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<ResolutionSetup>::Index() {
+    return 101;
+}
+
+enum class ScalingFilter : u32 {
+    NearestNeighbor = 0,
+    Bilinear = 1,
+    Bicubic = 2,
+    Gaussian = 3,
+    ScaleForce = 4,
+    ScaleFx = 5,
+    Lanczos = 6,
+    Fsr = 7,
+    Fsr2 = 8,
+    MaxEnum = 9,
+};
+
+template <>
+inline std::vector<std::pair<std::string, ScalingFilter>>
+EnumMetadata<ScalingFilter>::Canonicalizations() {
+    return {
+        {"NearestNeighbor", ScalingFilter::NearestNeighbor},
+        {"Bilinear", ScalingFilter::Bilinear},
+        {"Bicubic", ScalingFilter::Bicubic},
+        {"Gaussian", ScalingFilter::Gaussian},
+        {"ScaleForce", ScalingFilter::ScaleForce},
+        {"ScaleFx", ScalingFilter::ScaleFx},
+        {"Lanczos", ScalingFilter::Lanczos},
+        {"Fsr", ScalingFilter::Fsr},
+        {"Fsr2", ScalingFilter::Fsr2},
+        {"MaxEnum", ScalingFilter::MaxEnum},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<ScalingFilter>::Index() {
+    return 18;
+}
+
+enum class AntiAliasing : u32 {
+    None = 0,
+    Fxaa = 1,
+    Smaa = 2,
+    Taa = 3,
+    MaxEnum = 4,
+};
+
+template <>
+inline std::vector<std::pair<std::string, AntiAliasing>>
+EnumMetadata<AntiAliasing>::Canonicalizations() {
+    return {
+        {"None", AntiAliasing::None},
+        {"Fxaa", AntiAliasing::Fxaa},
+        {"Smaa", AntiAliasing::Smaa},
+        {"Taa", AntiAliasing::Taa},
+        {"MaxEnum", AntiAliasing::MaxEnum},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<AntiAliasing>::Index() {
+    return 19;
+}
+
+enum class FSR2QualityMode : u32 {
+    Quality = 0,
+    Balanced = 1,
+    Performance = 2,
+    UltraPerformance = 3,
+};
+
+template <>
+inline std::vector<std::pair<std::string, FSR2QualityMode>>
+EnumMetadata<FSR2QualityMode>::Canonicalizations() {
+    return {
+        {"Quality", FSR2QualityMode::Quality},
+        {"Balanced", FSR2QualityMode::Balanced},
+        {"Performance", FSR2QualityMode::Performance},
+        {"UltraPerformance", FSR2QualityMode::UltraPerformance},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<FSR2QualityMode>::Index() {
+    return 20;
+}
+
+enum class FrameSkipping : u32 {
+    Disabled = 0,
+    Enabled = 1,
+    MaxEnum = 2,
+};
+
+template <>
+inline std::vector<std::pair<std::string, FrameSkipping>>
+EnumMetadata<FrameSkipping>::Canonicalizations() {
+    return {
+        {"Disabled", FrameSkipping::Disabled},
+        {"Enabled", FrameSkipping::Enabled},
+        {"MaxEnum", FrameSkipping::MaxEnum},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<FrameSkipping>::Index() {
+    return 21;
+}
+
+enum class FrameSkippingMode : u32 {
+    Adaptive = 0,
+    Fixed = 1,
+    MaxEnum = 2,
+};
+
+template <>
+inline std::vector<std::pair<std::string, FrameSkippingMode>>
+EnumMetadata<FrameSkippingMode>::Canonicalizations() {
+    return {
+        {"Adaptive", FrameSkippingMode::Adaptive},
+        {"Fixed", FrameSkippingMode::Fixed},
+        {"MaxEnum", FrameSkippingMode::MaxEnum},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<FrameSkippingMode>::Index() {
+    return 22;
+}
+
+enum class AspectRatio : u32 {
+    R16_9 = 0,
+    R4_3 = 1,
+    R21_9 = 2,
+    R16_10 = 3,
+    R32_9 = 4,
+    Stretch = 5,
+};
+
+template <>
+inline std::vector<std::pair<std::string, AspectRatio>>
+EnumMetadata<AspectRatio>::Canonicalizations() {
+    return {
+        {"R16_9", AspectRatio::R16_9},
+        {"R4_3", AspectRatio::R4_3},
+        {"R21_9", AspectRatio::R21_9},
+        {"R16_10", AspectRatio::R16_10},
+        {"R32_9", AspectRatio::R32_9},
+        {"Stretch", AspectRatio::Stretch},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<AspectRatio>::Index() {
+    return 23;
+}
+
+enum class ConsoleMode : u32 {
+    Handheld = 0,
+    Docked = 1,
+};
+
+template <>
+inline std::vector<std::pair<std::string, ConsoleMode>>
+EnumMetadata<ConsoleMode>::Canonicalizations() {
+    return {
+        {"Handheld", ConsoleMode::Handheld},
+        {"Docked", ConsoleMode::Docked},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<ConsoleMode>::Index() {
+    return 24;
+}
+
+enum class AppletMode : u32 {
+    HLE = 0,
+    LLE = 1,
+};
+
+template <>
+inline std::vector<std::pair<std::string, AppletMode>>
+EnumMetadata<AppletMode>::Canonicalizations() {
+    return {
+        {"HLE", AppletMode::HLE},
+        {"LLE", AppletMode::LLE},
+    };
+}
+
+template <>
+inline u32 EnumMetadata<AppletMode>::Index() {
+    return 25;
+}
 
 template <typename Type>
 inline std::string CanonicalizeEnum(Type id) {