i should implement DSP DMA...

d611a21e5 imma stop using size_t

git-subtree-dir: external/ircolib
git-subtree-split: d611a21e50fcfdfb5f34a7f79c4c690c50d85c5f

CMakeLists.txt

@@ -9,19 +9,31 @@ option(BUILD_SHARED_LIBS OFF)
 include_directories(external/ELFIO)
 include_directories(external/capstone/include)
 include_directories(external/cflags/include)
+include_directories(external/SDL/include)
+include_directories(external/xbyak)
 include_directories(external)
 
 if(WIN32)
     add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
+    add_compile_definitions(NOMINMAX)
 endif()
+add_compile_options(-fno-operator-names)
 
 set(CAPSTONE_ARCHITECTURE_DEFAULT OFF)
 set(CAPSTONE_PPC_SUPPORT ON)
 add_subdirectory(external/capstone)
+add_subdirectory(external/SDL)
 
 add_executable(weee main.cpp core/mem.cpp core/loaders/elf.cpp
     core/loaders/dol.cpp
     core/broadway.cpp
-    core/broadway/instructions.cpp)
+    core/broadway/instructions.cpp
-target_link_libraries(weee PUBLIC capstone)
+    core/broadway/mmio/vi.cpp
+    core/broadway/mmio/pi.cpp
+    core/broadway/mmio/mi.cpp
+    core/broadway/mmio/dsp.cpp
+    core/broadway/mmio/ai.cpp
+    core/broadway/mmio/exi.cpp
+    core/broadway/mmio/si.cpp)
+target_link_libraries(weee PUBLIC SDL3::SDL3 capstone)
 target_include_directories(weee PUBLIC core)

README.md

@@ -2,5 +2,8 @@
 
 - [x] ELF
 - [x] DOL
-- [ ] panda.dol
+- [x] panda.dol
 - [ ] libogc simple examples
+  
+## Cool people
+- [layle](https://github.com/ioncodes/), thanks for the IDA plugins and resources. Check out [*his* Wii emulator](https://github.com/ioncodes/gecko)

core/broadway.cpp

@@ -1,4 +1,4 @@
-#include <broadway.hpp>
+#include <broadway/utils.hpp>
 #include <mem.hpp>
 #include <print>
 #include <ircolib/log.hpp>
@@ -16,29 +16,252 @@ broadway::broadway() {
 void broadway::set_pc(ircolib::u32 value) { pc = value; }
 
 void broadway::run(mem &mem) {
-    for (int i = 0; i < 100000; i++) {
+    std::println("pc: 0x{:08X}", pc);
-        execute(fetch(mem), mem);
+    for (int i = 0; i < 1000000; i++) {
+        ircolib::u32 instr = fetch(mem);
+        execute(instr, mem);
     }
 }
 
 ircolib::u32 broadway::fetch(mem &mem) {
-    ircolib::u32 val = mem.read(pc);
+    ircolib::u32 val = mem.read32(pc)
+                       .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                       .or_else([&](std::string e) {
+                           ircolib::panic("broadway read failed. Reason {} (pc: 0x{:08X})", e, pc);
+                           return std::expected<ircolib::u32, std::string>();
+                       })
+                       .value();
     pc += 4;
 
     return val;
 }
 
-void broadway::execute(ircolib::u32 instr, mem &mem) {
+void broadway::decode_special3(ircolib::u32 instr, mem &mem) {
-    ircolib::u8 primary = (instr >> 26) & 0x3f;
+    auto secondary = utils::secondary(instr);
-    switch (primary) {
+    switch (secondary) {
-    case 15: // addis rd, ra, simm
+    case 38:
-        addis(instr);
+        mtfsb1(instr);
+        break;
+    case 711:
+        mtfsf(instr);
         break;
     default:
-        std::println("broadway::execute unimplemented instruction 0x{:08X} / 0b{:032b}", instr, instr);
+        std::println("broadway unknown special3 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
         std::println("disassembly:");
         print_disasm(instr);
-        ircolib::panic("");
+        ircolib::panic("LR: 0x{:08X}", lr);
+    }
+}
+
+void broadway::decode_special2(ircolib::u32 instr, mem &mem) {
+    auto secondary = utils::secondary(instr);
+    switch (secondary) {
+    case 0x000:
+        cmp(instr);
+        break;
+    case 0x008:
+        subfc(instr);
+        break;
+    case 0x00A:
+        addc(instr);
+        break;
+    case 0x013:
+        mfcr(instr);
+        break;
+    case 0x017:
+        lwzx(instr, mem);
+        break;
+    case 0x01C:
+        and(instr);
+        break;
+    case 0x020:
+        cmpl(instr);
+        break;
+    case 0x028:
+        subf(instr);
+        break;
+    case 0x053:
+        mfmsr(instr);
+        break;
+    case 0x088:
+        subfe(instr);
+        break;
+    case 0x08A:
+        adde(instr);
+        break;
+    case 0x090:
+        mtcrf(instr);
+        break;
+    case 0x092:
+        mtmsr(instr);
+        break;
+    case 0x097:
+        stwx(instr, mem);
+        break;
+    case 0x0CA:
+        addze(instr);
+        break;
+    case 0x0D2:
+        ircolib::warn("broadway TODO mtsr (pc 0x{:08X})", pc - 4);
+        break;
+    case 0x0EB:
+        mullw(instr);
+        break;
+    case 0x117:
+        lhzx(instr, mem);
+        break;
+    case 0x173:
+        mftb(instr);
+        break;
+    case 0x1BC:
+        or (instr);
+        break;
+    case 0x153:
+    case 0x1D3:
+        mftspr(ircolib::is_bit_set<ircolib::u32, 7>(secondary), instr);
+        break;
+    case 0x1DC:
+        nand(instr);
+        break;
+    case 0x10A:
+        add(instr);
+        break;
+    case 0x1CB:
+        divwu(instr);
+        break;
+    case 0x256: // sync
+        break;
+    case 0x318:
+        sraw(instr);
+        break;
+    default:
+        std::println("broadway unknown special2 {} (0x{:04X}) (pc 0x{:08X})", secondary, secondary, pc - 4);
+        std::println("disassembly:");
+        print_disasm(instr);
+        ircolib::panic("LR: 0x{:08X}", lr);
+    }
+}
+
+void broadway::decode_special1(ircolib::u32 instr, mem &mem) {
+    switch (utils::secondary(instr)) {
+    case 0x10:
+        bclrx(instr);
+        break;
+    case 0x32:
+        rfi(instr);
+        break;
+    case 0x96: // isync
+        break;
+    default:
+        std::println("broadway unknown special1 {} (0x{:04X}) (pc 0x{:08X})", utils::secondary(instr),
+                     utils::secondary(instr), pc - 4);
+        std::println("disassembly:");
+        print_disasm(instr);
+        ircolib::panic("LR: 0x{:08X}", lr);
+    }
+}
+
+void broadway::execute(ircolib::u32 instr, mem &mem) {
+    const auto primary = utils::primary(instr);
+    switch (primary) {
+    case 7:
+        mulli(instr);
+        break;
+    case 8:
+        subfic(instr);
+        break;
+    case 10:
+        cmpli(instr);
+        break;
+    case 11:
+        cmpi(instr);
+        break;
+    case 12:
+        addic(instr);
+        break;
+    case 13:
+        addicr(instr);
+        break;
+    case 14:
+        addi(instr);
+        break;
+    case 15:
+        addis(instr);
+        break;
+    case 16:
+        bcx(instr);
+        break;
+    case 18:
+        bx(instr);
+        break;
+    case 19:
+        decode_special1(instr, mem);
+        break;
+    case 20:
+        rlwimi(instr);
+        break;
+    case 21:
+        rlwinm(instr);
+        break;
+    case 24:
+        ori(instr);
+        break;
+    case 25:
+        oris(instr);
+        break;
+    case 26:
+        xori(instr);
+        break;
+    case 28:
+        andi(instr);
+        break;
+    case 29:
+        andis(instr);
+        break;
+    case 31:
+        decode_special2(instr, mem);
+        break;
+    case 32:
+        lwz(instr, mem);
+        break;
+    case 33:
+        lwzu(instr, mem);
+        break;
+    case 34:
+        lbz(instr, mem);
+        break;
+    case 36:
+        stw(instr, mem);
+        break;
+    case 37:
+        stwu(instr, mem);
+        break;
+    case 38:
+        stb(instr, mem);
+        break;
+    case 39:
+        stbu(instr, mem);
+        break;
+    case 40:
+        lhz(instr, mem);
+        break;
+    case 44:
+        sth(instr, mem);
+        break;
+    case 45:
+        sthu(instr, mem);
+        break;
+    case 50:
+        lfd(instr, mem);
+        break;
+    case 63:
+        decode_special3(instr, mem);
+        break;
+    default:
+        std::println("broadway::execute unimplemented instruction 0x{:08X} / 0b{:032b} ({})", instr, instr, primary);
+        std::println("disassembly:");
+        print_disasm(instr);
+        ircolib::panic("LR: 0x{:08X}", lr);
     }
 }
 
@@ -48,13 +271,13 @@ void broadway::print_disasm(ircolib::u32 instr) {
 
     cs_insn *insn;
     auto instr_buff = ircolib::integral_to_slice(std::byteswap(instr));
-    size_t count = cs_disasm(capstone, instr_buff.data(), instr_buff.size(), pc - 4, 1, &insn);
+    ircolib::u32 count = cs_disasm(capstone, instr_buff.data(), instr_buff.size(), pc - 4, 1, &insn);
     if (count <= 0)
         return;
 
-    size_t j;
+    ircolib::u32 j;
     for (j = 0; j < count; j++) {
-        printf("0x%" PRIx64 ":\t%s\t\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str);
+        std::println("\t0x{:x}:\t{}\t\t{}", insn[j].address, insn[j].mnemonic, insn[j].op_str);
     }
 
     cs_free(insn, count);

core/broadway.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <ircolib/types.hpp>
 #include <capstone/capstone.h>
+#include <xbyak/xbyak.h>
 #include <array>
 
 namespace weee::core {
@@ -16,11 +17,124 @@ struct broadway {
     void execute(ircolib::u32, mem &);
 
     bool disasm_available = true;
-    ircolib::u32 pc = 0;
+    ircolib::u32 pc = 0, lr = 0, ctr = 0, cr = 0, srr0 = 0, fpscr = 0, msr = 0, tbl = 0, tbu = 0;
+    union {
+        struct {
+            unsigned bytecount : 7;
+            unsigned : 22;
+            unsigned ca : 1;
+            unsigned ov : 1;
+            unsigned so : 1;
+        };
+
+        ircolib::u32 raw;
+    } xer;
+
+    void set_cr(ircolib::u8 value, ircolib::u8 index) {
+        cr &= ~(0xffff << index * 4);
+        cr |= (value << index * 4);
+    }
+
+    bool get_cr_bit(ircolib::u8 index, ircolib::u8 bit) { return (cr >> index * 4) & (1 << (4 - bit)); }
+
+    // bat registers indexes
+    static constexpr ircolib::u32 BAT_LOWER_OFFSET = 0;
+    static constexpr ircolib::u32 BAT_UPPER_OFFSET = 8;
+
+    std::array<ircolib::u32, 16> ibat, dbat;
     std::array<ircolib::u32, 32> gpr{};
+
+    struct Fgr {
+        ircolib::u64 ps0, ps1;
+    };
+
+    std::array<Fgr, 32> fgrs{};
+
+    // ircolib::u32 const_gpr_lookup{};
     csh capstone;
+    // Xbyak::CodeGenerator code;
 
     // instructions
+    void decode_special1(ircolib::u32, mem &);
+    void decode_special2(ircolib::u32, mem &);
+    void decode_special3(ircolib::u32, mem &);
+
+    void branch(bool, bool, ircolib::u32);
+    bool test_cond_and_ctr(ircolib::u32);
+
+    void andi(ircolib::u32);
+    void andis(ircolib::u32);
+    void and(ircolib::u32);
+    void add(ircolib::u32);
+    void addc(ircolib::u32);
+    void adde(ircolib::u32);
+    void addze(ircolib::u32);
     void addis(ircolib::u32);
+    void addi(ircolib::u32);
+    void addic(ircolib::u32);
+    void addicr(ircolib::u32);
+    void ori(ircolib::u32);
+    void oris(ircolib::u32);
+    void bx(ircolib::u32);
+    void bcx(ircolib::u32);
+    void mftspr(bool, ircolib::u32);
+    void mtcrf(ircolib::u32);
+    void stw(ircolib::u32, mem &);
+    void stb(ircolib::u32, mem &);
+    void stwu(ircolib::u32, mem &);
+    void sthu(ircolib::u32, mem &);
+    void stwx(ircolib::u32, mem &);
+    void stbu(ircolib::u32, mem &);
+    void sth(ircolib::u32, mem &);
+    void lbz(ircolib::u32, mem &);
+    void lwz(ircolib::u32, mem &);
+    void lwzx(ircolib::u32, mem &);
+    void lhz(ircolib::u32, mem &);
+    void lhzx(ircolib::u32, mem &);
+    void lfd(ircolib::u32, mem &);
+    void bclrx(ircolib::u32);
+    void cmpi(ircolib::u32);
+    void cmpli(ircolib::u32);
+    void cmp(ircolib::u32);
+    void cmpl(ircolib::u32);
+    void rlwinm(ircolib::u32);
+    void rlwimi(ircolib::u32);
+    void lwzu(ircolib::u32, mem &);
+    void rfi(ircolib::u32);
+    void mfcr(ircolib::u32);
+    void mtfsf(ircolib::u32);
+    void mtfsb1(ircolib::u32);
+    void mtfsb0(ircolib::u32);
+    void mfmsr(ircolib::u32);
+    void mtmsr(ircolib::u32);
+    void mullw(ircolib::u32);
+    void mulli(ircolib::u32);
+    void nand(ircolib::u32);
+    void subf(ircolib::u32);
+    void subfc(ircolib::u32);
+    void subfic(ircolib::u32);
+    void subfe(ircolib::u32);
+    void or (ircolib::u32);
+    void xori(ircolib::u32);
+    void divwu(ircolib::u32);
+    void mftb(ircolib::u32);
+    void sraw(ircolib::u32);
+
+    inline void cr0_update(bool condition, ircolib::s32 result) {
+        if (condition) {
+            const bool b0 = result < 0;
+            const bool b1 = result >= 0;
+            const bool b2 = result == 0;
+            const bool b3 = xer.so;
+            set_cr((b0 << 3) | (b1 << 2) | (b2 << 1) | (b3 << 0), 0);
+        }
+    }
+
+    inline void cr1_update(bool condition) {
+        if (condition) {
+            const ircolib::u8 field = (fpscr >> 28) & 0xf;
+            set_cr(field, 1);
+        }
+    }
 };
 } // namespace weee::core

core/broadway/instructions.cpp

@@ -1,7 +1,660 @@
-#include <broadway.hpp>
+#include "ircolib/log.hpp"
+#include <broadway/utils.hpp>
+#include <mem.hpp>
 
 namespace weee::core {
-void broadway::addis(ircolib::u32 instr) {
+void broadway::add(ircolib::u32 instr) {
+    gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + gpr[utils::RB(instr)];
+    cr0_update(instr & 1, gpr[utils::RD(instr)]);
+}
 
+void broadway::addc(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = carry;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::adde(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c0 = __builtin_add_overflow(gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
+    bool c1 = __builtin_add_overflow(sum, xer.ca, &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = c0 | c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::addze(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c1 = __builtin_add_overflow(gpr[utils::RA(instr)], xer.ca, &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::addi(ircolib::u32 instr) {
+    if (utils::RA(instr) == 0) { // li
+        gpr[utils::RD(instr)] = ircolib::s32(utils::SIMM(instr));
+        return;
+    }
+
+    gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + (ircolib::s32(utils::SIMM(instr)));
+}
+
+void broadway::addic(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], ircolib::s32(utils::SIMM(instr)), &sum);
+    gpr[utils::RD(instr)] = sum;
+    xer.ca = carry;
+}
+
+void broadway::addicr(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool carry = __builtin_add_overflow(gpr[utils::RA(instr)], ircolib::s32(utils::SIMM(instr)), &sum);
+    cr0_update(true, sum);
+    gpr[utils::RD(instr)] = sum;
+    xer.ca = carry;
+}
+
+void broadway::addis(ircolib::u32 instr) {
+    if (utils::RA(instr) == 0) { // lis
+        gpr[utils::RD(instr)] = ircolib::s32(utils::SIMM(instr)) << 16;
+        return;
+    }
+
+    gpr[utils::RD(instr)] = gpr[utils::RA(instr)] + (ircolib::s32(utils::SIMM(instr)) << 16);
+}
+
+void broadway::ori(ircolib::u32 instr) { gpr[utils::RA(instr)] = gpr[utils::RS(instr)] | utils::UIMM(instr); }
+void broadway::oris(ircolib::u32 instr) {
+    gpr[utils::RA(instr)] = gpr[utils::RS(instr)] | ((ircolib::u32)utils::UIMM(instr) << 16);
+}
+
+void broadway::branch(bool aa, bool lk, ircolib::u32 bd) {
+    if (!aa)
+        bd += pc - 4;
+
+    if (lk)
+        lr = pc;
+
+    pc = bd;
+}
+
+void broadway::bx(ircolib::u32 instr) {
+    const bool link = instr & 1;
+    const bool absolute = instr & 2;
+
+    ircolib::s32 li = (ircolib::s32(instr << 6) >> 6) & 0xFFFFFFFC;
+    branch(absolute, link, li);
+}
+
+bool broadway::test_cond_and_ctr(ircolib::u32 instr) {
+    const ircolib::u8 bo = (instr >> 21) & 0x1f;
+    const ircolib::u8 bi = (instr >> 16) & 0x1f;
+
+    const bool ctr_ok = ircolib::is_bit_set(bo, 2) || ((--ctr == 0) == (ircolib::is_bit_set(bo, 1)));
+    const bool cond_ok = ircolib::is_bit_set(bo, 4) || (get_cr_bit(0, bi) == ircolib::is_bit_set(bo, 3));
+
+    return cond_ok && ctr_ok;
+}
+
+void broadway::bcx(ircolib::u32 instr) {
+    const bool link = instr & 1;
+    const bool absolute = instr & 2;
+
+    ircolib::s32 bd = (ircolib::s32(instr << 16) >> 16) & 0xFFFFFFFC;
+    if (test_cond_and_ctr(instr)) {
+        branch(absolute, link, bd);
+    }
+}
+
+void broadway::mftspr(bool dir, ircolib::u32 instr) {
+    const ircolib::u32 spr_field = (instr >> 11) & 0x3FF;
+
+    auto move_to_or_from_spr = [&](ircolib::u32 &spr) {
+        if (dir) { // mtspr
+            spr = gpr[utils::RS(instr)];
+            return;
+        }
+        // mfspr
+        gpr[utils::RD(instr)] = spr;
+    };
+
+    switch (spr_field) {
+    case 0b0000100000:
+        move_to_or_from_spr(xer.raw);
+        break;
+    case 0b0100000000:
+        move_to_or_from_spr(lr);
+        break;
+    case 0b0100100000:
+        move_to_or_from_spr(ctr);
+        break;
+    case 0b1101000000:
+        move_to_or_from_spr(srr0);
+        break;
+    case 0b1101100000: // srr1
+        break;
+    case 0b1000011111: // hid0
+        break;
+    case 0b1100011100: // hid2
+        break;
+    case 0b1100111111: // l2cr
+        break;
+    case 0b1000110000:
+        move_to_or_from_spr(ibat[BAT_LOWER_OFFSET + 0]);
+        break;
+    case 0b1000010000:
+        move_to_or_from_spr(ibat[BAT_UPPER_OFFSET + 0]);
+        break;
+    case 0b1001010000:
+        move_to_or_from_spr(ibat[BAT_UPPER_OFFSET + 1]);
+        break;
+    case 0b1010010000:
+        move_to_or_from_spr(ibat[BAT_UPPER_OFFSET + 2]);
+        break;
+    case 0b1011010000:
+        move_to_or_from_spr(ibat[BAT_UPPER_OFFSET + 3]);
+        break;
+    case 0b1100110000:
+        move_to_or_from_spr(dbat[BAT_LOWER_OFFSET + 0]);
+        break;
+    case 0b1101110000:
+        move_to_or_from_spr(dbat[BAT_LOWER_OFFSET + 1]);
+        break;
+    case 0b1100010000:
+        move_to_or_from_spr(dbat[BAT_UPPER_OFFSET + 0]);
+        break;
+    case 0b1101010000:
+        move_to_or_from_spr(dbat[BAT_UPPER_OFFSET + 1]);
+        break;
+    case 0b1110010000:
+        move_to_or_from_spr(dbat[BAT_UPPER_OFFSET + 2]);
+        break;
+    case 0b1111010000:
+        move_to_or_from_spr(dbat[BAT_UPPER_OFFSET + 3]);
+        break;
+    default:
+        ircolib::warn("broadway::m{}spr with unimplemented spr field of value "
+                      "0b{:010b} (0x{:04X}) (pc 0x{:08X})",
+                      dir ? 't' : 'f', spr_field, spr_field, pc - 4);
+    }
+}
+
+void broadway::stwu(ircolib::u32 instr, mem &mem) {
+    if (utils::RA(instr) == 0)
+        ircolib::panic("broadway::stwu with ra == 0");
+
+    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
+    auto _ = mem.write32(EA, gpr[utils::RS(instr)])
+             .and_then([&] {
+                 gpr[utils::RA(instr)] = EA;
+                 return std::expected<void, std::string>();
+             })
+             .or_else([&](std::string e) {
+                 ircolib::panic("stwu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
+void broadway::sthu(ircolib::u32 instr, mem &mem) {
+    if (utils::RA(instr) == 0)
+        ircolib::panic("broadway::sthu with ra == 0");
+
+    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
+    auto _ = mem.write16(EA, gpr[utils::RS(instr)])
+             .and_then([&] {
+                 gpr[utils::RA(instr)] = EA;
+                 return std::expected<void, std::string>();
+             })
+             .or_else([&](std::string e) {
+                 ircolib::panic("sthu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
+void broadway::stbu(ircolib::u32 instr, mem &mem) {
+    if (utils::RA(instr) == 0)
+        ircolib::panic("broadway::stbu with ra == 0");
+
+    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
+    auto _ = mem.write8(EA, gpr[utils::RS(instr)])
+             .and_then([&] {
+                 gpr[utils::RA(instr)] = EA;
+                 return std::expected<void, std::string>();
+             })
+             .or_else([&](std::string e) {
+                 ircolib::panic("stbu broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
+void broadway::stw(ircolib::u32 instr, mem &mem) {
+    ircolib::s32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    const ircolib::u32 EA = b + utils::SIMM(instr);
+    auto _ = mem.write32(EA, gpr[utils::RS(instr)])
+             .and_then([&] { return std::expected<void, std::string>(); })
+             .or_else([&](std::string e) {
+                 ircolib::panic("stw broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
+void broadway::stb(ircolib::u32 instr, mem &mem) {
+    ircolib::s32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    const ircolib::u32 EA = b + utils::SIMM(instr);
+    auto _ = mem.write8(EA, gpr[utils::RS(instr)])
+             .and_then([&] { return std::expected<void, std::string>(); })
+             .or_else([&](std::string e) {
+                 ircolib::panic("stw broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
+void broadway::sth(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    const ircolib::u32 EA = b + utils::SIMM(instr);
+
+    auto _ = mem.write16(EA, ircolib::u16(gpr[utils::RS(instr)]))
+             .and_then([&] { return std::expected<void, std::string>(); })
+             .or_else([&](std::string e) {
+                 ircolib::panic("sth broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
+void broadway::stwx(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    const ircolib::u32 EA = b + gpr[utils::RB(instr)];
+    auto _ = mem.write32(EA, gpr[utils::RS(instr)])
+             .and_then([&] { return std::expected<void, std::string>(); })
+             .or_else([&](std::string e) {
+                 ircolib::panic("stwx broadway write failed. Reason: {} (pc: 0x{:08X})", e, pc - 4);
+                 return std::expected<void, std::string>();
+             });
+}
+
+void broadway::lwz(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);
+
+    gpr[utils::RD(instr)] = mem.read32(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lwz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lwzx(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + gpr[utils::RB(instr)];
+
+    gpr[utils::RD(instr)] = mem.read32(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lwz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lhz(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);
+
+    gpr[utils::RD(instr)] = mem.read16(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lhz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lhzx(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + gpr[utils::RB(instr)];
+
+    gpr[utils::RD(instr)] = mem.read16(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lhzx broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lbz(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);
+
+    gpr[utils::RD(instr)] = mem.read8(ea)
+                            .and_then([&](ircolib::u32 val) { return std::expected<ircolib::u32, std::string>(val); })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lbz broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::lfd(ircolib::u32 instr, mem &mem) {
+    ircolib::u32 b = gpr[utils::RA(instr)];
+    if (utils::RA(instr) == 0)
+        b = 0;
+
+    ircolib::u32 ea = ircolib::s32(b) + utils::SIMM(instr);
+
+    fgrs[utils::RD(instr)].ps0 =
+    mem.read64(ea)
+    .and_then([&](ircolib::u64 val) { return std::expected<ircolib::u64, std::string>(val); })
+    .or_else([&](std::string e) {
+        ircolib::panic("lfd broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+        return std::expected<ircolib::u64, std::string>();
+    })
+    .value();
+}
+
+void broadway::bclrx(ircolib::u32 instr) {
+    const bool link = instr & 1;
+
+    ircolib::s32 bd = lr & 0xFFFFFFFC;
+    if (test_cond_and_ctr(instr)) {
+        branch(true, link, bd);
+    }
+}
+
+void broadway::cmpi(ircolib::u32 instr) {
+    const ircolib::s32 a = gpr[utils::RA(instr)];
+    const ircolib::s32 simm = utils::SIMM(instr);
+    ircolib::u8 c;
+    if (a < simm)
+        c = 0b001;
+    else if (a > simm)
+        c = 0b010;
+    else
+        c = 0b100;
+
+    const ircolib::u8 result = (xer.so << 3) | c;
+    set_cr(result, utils::crfD(instr));
+}
+
+void broadway::cmpli(ircolib::u32 instr) {
+    const ircolib::u32 a = gpr[utils::RA(instr)];
+    const ircolib::u32 uimm = utils::UIMM(instr);
+    ircolib::u8 c;
+    if (a < uimm)
+        c = 0b001;
+    else if (a > uimm)
+        c = 0b010;
+    else
+        c = 0b100;
+
+    const ircolib::u8 result = (xer.so << 3) | c;
+    set_cr(result, utils::crfD(instr));
+}
+
+void broadway::cmp(ircolib::u32 instr) {
+    const ircolib::s32 a = gpr[utils::RA(instr)];
+    const ircolib::s32 b = gpr[utils::RB(instr)];
+    ircolib::u8 c;
+    if (a < b)
+        c = 0b001;
+    else if (a > b)
+        c = 0b010;
+    else
+        c = 0b100;
+
+    const ircolib::u8 result = (xer.so << 3) | c;
+    set_cr(result, utils::crfD(instr));
+}
+
+void broadway::cmpl(ircolib::u32 instr) {
+    const ircolib::u32 a = gpr[utils::RA(instr)];
+    const ircolib::u32 b = gpr[utils::RB(instr)];
+    ircolib::u8 c;
+    if (a < b)
+        c = 0b001;
+    else if (a > b)
+        c = 0b010;
+    else
+        c = 0b100;
+
+    const ircolib::u8 result = (xer.so << 3) | c;
+    set_cr(result, utils::crfD(instr));
+}
+
+void broadway::rlwinm(ircolib::u32 instr) {
+    const ircolib::u8 sh = (instr >> 11) & 0x1f;
+    ircolib::u32 r = std::rotl(gpr[utils::RS(instr)], sh);
+    const ircolib::u8 mb = (instr >> 6) & 0x1f;
+    const ircolib::u8 me = (instr >> 1) & 0x1f;
+    const ircolib::u32 start = 0xffffffff >> mb;
+    const ircolib::u32 end = 0x7fffffff >> me;
+    ircolib::u32 mask = start ^ end;
+    if (mb > me)
+        mask = ~mask;
+
+    r &= mask;
+    gpr[utils::RA(instr)] = r;
+    cr0_update(instr & 1, r);
+}
+
+void broadway::rlwimi(ircolib::u32 instr) {
+    const ircolib::u8 sh = (instr >> 11) & 0x1f;
+    ircolib::u32 r = std::rotl(gpr[utils::RS(instr)], sh);
+    const ircolib::u8 mb = (instr >> 6) & 0x1f;
+    const ircolib::u8 me = (instr >> 1) & 0x1f;
+    const ircolib::u32 start = 0xffffffff >> mb;
+    const ircolib::u32 end = 0x7fffffff >> me;
+    ircolib::u32 mask = start ^ end;
+    if (mb > me)
+        mask = ~mask;
+
+    r &= mask;
+    r |= (gpr[utils::RA(instr)] & ~mask);
+    gpr[utils::RA(instr)] = r;
+    cr0_update(instr & 1, r);
+}
+
+void broadway::lwzu(ircolib::u32 instr, mem &mem) {
+    if (utils::RA(instr) == 0 || utils::RA(instr) == utils::RD(instr))
+        ircolib::panic("broadway::lwzu with ra == 0");
+
+    const ircolib::u32 EA = ircolib::s32(gpr[utils::RA(instr)]) + utils::SIMM(instr);
+    gpr[utils::RD(instr)] = mem.read32(EA)
+                            .and_then([&](ircolib::u32 val) {
+                                gpr[utils::RA(instr)] = EA;
+                                return std::expected<ircolib::u32, std::string>(val);
+                            })
+                            .or_else([&](std::string e) {
+                                ircolib::panic("lwzu broadway read failed. Reason {} (pc: 0x{:08X})", e, pc - 4);
+                                return std::expected<ircolib::u32, std::string>();
+                            })
+                            .value();
+}
+
+void broadway::rfi(ircolib::u32 instr) {
+    pc = srr0;
+    ircolib::clear_bit(msr, 13);
+}
+
+void broadway::andi(ircolib::u32 instr) {
+    const ircolib::s32 result = gpr[utils::RS(instr)] & utils::UIMM(instr);
+    gpr[utils::RA(instr)] = result;
+    cr0_update(true, result);
+}
+
+void broadway::andis(ircolib::u32 instr) {
+    const ircolib::s32 result = gpr[utils::RS(instr)] & (ircolib::u32(utils::UIMM(instr)) << 16);
+    gpr[utils::RA(instr)] = result;
+    cr0_update(true, result);
+}
+
+void broadway::and(ircolib::u32 instr) {
+    const ircolib::s32 result = gpr[utils::RS(instr)] & gpr[utils::RB(instr)];
+    gpr[utils::RA(instr)] = result;
+    cr0_update(instr & 1, result);
+}
+
+void broadway::mtfsf(ircolib::u32 instr) {
+    const ircolib::u8 fm = (instr >> 17) & 0xff;
+    ircolib::u8 mask = 0;
+    for (int i = 0; i < 8; i++) {
+        if (ircolib::is_bit_set(fm, i)) {
+            mask |= 0xf << (i * 4);
+        }
+    }
+
+    ircolib::u32 frb = fgrs[utils::RB(instr)].ps0;
+    fpscr = (fpscr & ~mask) | (frb & mask);
+    cr1_update(instr & 1);
+}
+
+void broadway::mtfsb0(ircolib::u32 instr) {
+    ircolib::u32 mask = ~(1 << utils::RD(instr));
+
+    fpscr = fpscr & mask;
+    cr1_update(instr & 1);
+}
+
+void broadway::mtfsb1(ircolib::u32 instr) {
+    ircolib::u32 bit = 1 << utils::RD(instr);
+    ircolib::u32 mask = ~bit;
+
+    fpscr = (fpscr & mask) | bit;
+    cr1_update(instr & 1);
+}
+
+void broadway::mfmsr(ircolib::u32 instr) { gpr[utils::RS(instr)] = msr; }
+void broadway::mtmsr(ircolib::u32 instr) { msr = gpr[utils::RS(instr)]; }
+
+void broadway::nand(ircolib::u32 instr) {
+    gpr[utils::RA(instr)] = ~(gpr[utils::RS(instr)] & gpr[utils::RB(instr)]);
+    cr0_update(instr & 1, gpr[utils::RA(instr)]);
+}
+
+void broadway::subf(ircolib::u32 instr) {
+    gpr[utils::RD(instr)] = ~gpr[utils::RA(instr)] + gpr[utils::RB(instr)];
+    cr0_update(instr & 1, gpr[utils::RD(instr)]);
+}
+
+void broadway::subfc(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], 1, &sum);
+    bool c1 = __builtin_add_overflow(sum, gpr[utils::RB(instr)], &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = !c0 | c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::subfic(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], 1, &sum);
+    bool c1 = __builtin_add_overflow(sum, utils::SIMM(instr), &sum);
+    xer.ca = !c0 | c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway::subfe(ircolib::u32 instr) {
+    ircolib::u32 sum;
+    bool c0 = __builtin_add_overflow(~gpr[utils::RA(instr)], gpr[utils::RB(instr)], &sum);
+    bool c1 = __builtin_add_overflow(sum, xer.ca, &sum);
+    cr0_update(instr & 1, sum);
+    xer.ca = c0 | c1;
+    gpr[utils::RD(instr)] = sum;
+}
+
+void broadway:: or (ircolib::u32 instr) {
+    gpr[utils::RA(instr)] = gpr[utils::RS(instr)] | gpr[utils::RB(instr)];
+    cr0_update(instr & 1, gpr[utils::RA(instr)]);
+}
+
+void broadway::xori(ircolib::u32 instr) { gpr[utils::RA(instr)] = gpr[utils::RS(instr)] ^ utils::UIMM(instr); }
+
+void broadway::mullw(ircolib::u32 instr) {
+    gpr[utils::RD(instr)] = ircolib::u64(gpr[utils::RA(instr)]) * ircolib::u64(gpr[utils::RB(instr)]);
+}
+
+void broadway::mulli(ircolib::u32 instr) {
+    gpr[utils::RD(instr)] = ircolib::u64(gpr[utils::RA(instr)]) * ircolib::u64(utils::SIMM(instr));
+}
+
+void broadway::mfcr(ircolib::u32 instr) { gpr[utils::RD(instr)] = cr; }
+
+void broadway::mtcrf(ircolib::u32 instr) {
+    ircolib::u32 mask = 0;
+    const ircolib::u8 crm = (instr >> 13) & 0xff;
+    for (int i = 0; i < 7; i++) {
+        if (ircolib::is_bit_set(crm, i)) {
+            set_cr(gpr[utils::RS(instr)] & (0xffff << i * 4), i);
+        }
+    }
+}
+
+void broadway::divwu(ircolib::u32 instr) {
+    ircolib::u32 dividend = gpr[utils::RA(instr)];
+    ircolib::u32 divisor = gpr[utils::RB(instr)];
+    if (divisor == 0) {
+        if ((instr >> 11) & 1)
+            xer.ov = true;
+
+        return;
+    }
+
+    gpr[utils::RD(instr)] = dividend / divisor;
+    cr0_update(instr & 1, gpr[utils::RD(instr)]);
+}
+
+void broadway::mftb(ircolib::u32 instr) {
+    const ircolib::u32 tbr = (instr >> 11) & 0x3FF;
+
+    if (tbr != 392 && tbr != 424)
+        ircolib::panic("broadway::mftb with tbr != 268 && != 269 ({})", tbr);
+
+    if (tbr == 392)
+        gpr[utils::RD(instr)] = tbl;
+
+    if (tbr == 424)
+        gpr[utils::RD(instr)] = tbu;
+}
+
+void broadway::sraw(ircolib::u32 instr) {
+    ircolib::u8 shift = std::min(gpr[utils::RB(instr)] & 0x3f, ircolib::u32(31));
+    ircolib::s32 rs = gpr[utils::RS(instr)];
+    ircolib::s32 result = rs >> shift;
+    ircolib::u32 mask = (1 << shift) - 1;
+    cr0_update(instr & 1, result);
+    xer.ca = (rs < 0) & ((ircolib::u32(rs) & mask) != 0);
+    gpr[utils::RA(instr)] = result;
 }
 } // namespace weee::core

core/broadway/mmio/ai.cpp

@@ -0,0 +1,31 @@
+#include <broadway/mmio/ai.hpp>
+#include <mem.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+audio_interface::audio_interface(mem &mem) {
+    mem.register_read32_handler(0x0c006c00, 0x0c006c1f, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write32_handler(0x0c006c00, 0x0c006c1f,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+}
+
+ircolib::u32 audio_interface::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0:
+        return ctrl.raw;
+    default:
+        ircolib::panic("audio_interface::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void audio_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0:
+        ctrl.raw = value;
+        break;
+    default:
+        ircolib::panic("audio_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/ai.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+struct audio_interface {
+    audio_interface(mem &);
+
+    ircolib::u32 read32(ircolib::u32);
+    void write32(ircolib::u32, ircolib::u32);
+
+    union {
+        struct {
+            unsigned pstat : 1;
+            unsigned afr : 1;
+            unsigned aiintmsk : 1;
+            unsigned aiint : 1;
+            unsigned aiintvld : 1;
+            unsigned screset : 1;
+            unsigned dsp_sr : 1;
+            unsigned : 25;
+        };
+        ircolib::u32 raw;
+    } ctrl;
+};
+} // namespace weee::core

core/broadway/mmio/dsp.cpp

@@ -0,0 +1,152 @@
+#include <broadway/mmio/dsp.hpp>
+#include <mem.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+dsp::dsp(mem &mem) {
+    mem.register_read16_handler(0x0c005000, 0x0c0051ff, [&](ircolib::u32 addr) { return read16(addr); });
+    mem.register_write16_handler(0x0c005000, 0x0c0051ff,
+                                 [&](ircolib::u32 addr, ircolib::u16 value) { return write16(addr, value); });
+
+    mem.register_read32_handler(0x0c005000, 0x0c0051ff, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write32_handler(0x0c005000, 0x0c0051ff,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+}
+
+ircolib::u32 dsp::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x20:
+        return ar_dma_mmaddr.whole;
+    case 0x24:
+        return ar_dma_araddr.whole;
+    case 0x28:
+        return ar_dma_cnt.whole;
+    case 0x30:
+        return dma_start_addr.whole;
+    default:
+        ircolib::panic("dsp::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void dsp::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0x20:
+        ar_dma_mmaddr.whole = value;
+        break;
+    case 0x24:
+        ar_dma_araddr.whole = value;
+        break;
+    case 0x28:
+        ar_dma_cnt.whole = value;
+        break;
+    case 0x30:
+        dma_start_addr.whole = value;
+        break;
+    default:
+        ircolib::panic("dsp::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+
+ircolib::u16 dsp::read16(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x00:
+        return dsp_mail_hi;
+    case 0x02:
+        return dsp_mail_lo;
+    case 0x04:
+        return cpu_mail_hi;
+    case 0x06:
+        return cpu_mail_lo;
+    case 0x0a:
+        return csr.raw;
+    case 0x12:
+        return ar_size;
+    case 0x20:
+        return ar_dma_mmaddr.hi;
+    case 0x22:
+        return ar_dma_mmaddr.lo;
+    case 0x24:
+        return ar_dma_araddr.hi;
+    case 0x26:
+        return ar_dma_araddr.lo;
+    case 0x28:
+        return ar_dma_cnt.hi;
+    case 0x2a:
+        return ar_dma_cnt.lo;
+    case 0x30:
+        return dma_start_addr.hi;
+    case 0x32:
+        return dma_start_addr.lo;
+    default:
+        ircolib::panic("dsp::read16 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void dsp::write16(ircolib::u32 addr, ircolib::u16 value) {
+    switch (addr) {
+    case 0x00:
+        dsp_mail_hi = value;
+        break;
+    case 0x02:
+        dsp_mail_lo = value;
+        break;
+    case 0x0a:
+        {
+            Csr ccsr = {.raw = value};
+            Csr ocsr = csr;
+            csr = ccsr;
+            if (csr.res || (ocsr.boot_mode != ccsr.boot_mode && ccsr.boot_mode)) {
+                cpu_mail_hi = 0;
+                cpu_mail_lo = 0;
+                dsp_mail_hi = 0;
+                dsp_mail_lo = 0;
+            }
+
+            if (csr.piint)
+                csr.piint = false;
+
+            if (csr.aidint)
+                csr.aidint = false;
+
+            if (csr.arint)
+                csr.arint = false;
+
+            if (csr.dspint)
+                csr.dspint = false;
+        }
+        break;
+    case 0x12:
+        ar_size = value;
+        break;
+    case 0x20:
+        ar_dma_mmaddr.hi = value;
+        break;
+    case 0x22:
+        ar_dma_mmaddr.lo = value;
+        break;
+    case 0x24:
+        ar_dma_araddr.hi = value;
+        break;
+    case 0x26:
+        ar_dma_araddr.lo = value;
+        break;
+    case 0x28:
+        ar_dma_cnt.hi = value;
+        break;
+    case 0x2a:
+        ar_dma_cnt.lo = value;
+        csr.arint = true;
+        break;
+    case 0x30:
+        dma_start_addr.hi = value;
+        break;
+    case 0x32:
+        dma_start_addr.lo = value;
+        break;
+    default:
+        ircolib::panic("dsp::write16 from unimplemented addr 0x{:08X} with value 0x{:04X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/dsp.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+struct dsp {
+    dsp(mem &);
+    ircolib::u16 read16(ircolib::u32);
+    void write16(ircolib::u32, ircolib::u16);
+    ircolib::u32 read32(ircolib::u32);
+    void write32(ircolib::u32, ircolib::u32);
+
+    union Csr {
+        struct {
+            unsigned res : 1;
+            unsigned piint : 1;
+            unsigned halt : 1;
+            unsigned aidint : 1;
+            unsigned aidint_mask : 1;
+            unsigned arint : 1;
+            unsigned arint_mask : 1;
+            unsigned dspint : 1;
+            unsigned dspint_mask : 1;
+            unsigned int_status : 1;
+            unsigned : 1;
+            unsigned boot_mode : 1;
+            unsigned : 4;
+        };
+        ircolib::u16 raw;
+    } csr;
+
+    union {
+        struct {
+            ircolib::u32 lo;
+            ircolib::u32 hi;
+        };
+        ircolib::u64 whole;
+    } ar_dma_mmaddr, ar_dma_araddr, ar_dma_cnt, dma_start_addr;
+
+    ircolib::u16 ar_size;
+    ircolib::u16 dsp_mail_hi = 0, dsp_mail_lo = 0, cpu_mail_hi = 0, cpu_mail_lo = 0;
+};
+} // namespace weee::core

core/broadway/mmio/exi.cpp

@@ -0,0 +1,41 @@
+#include <broadway/mmio/exi.hpp>
+#include <mem.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+exi::exi(mem &mem) {
+    mem.register_read32_handler(0x0c006800, 0x0c00683f, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write32_handler(0x0c006800, 0x0c00683f,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+}
+
+ircolib::u32 exi::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0:
+        return param0.raw;
+    case 0x14:
+        return param1.raw;
+    case 0x28:
+        return param2.raw;
+    default:
+        ircolib::panic("exi::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void exi::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0:
+        param0.raw = value;
+        break;
+    case 0x14:
+        param1.raw = value;
+        break;
+    case 0x28:
+        param2.raw = value;
+        break;
+    default:
+        ircolib::panic("exi::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/exi.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+struct exi {
+    exi(mem &);
+
+    ircolib::u32 read32(ircolib::u32);
+    void write32(ircolib::u32, ircolib::u32);
+
+    union {
+        struct {
+            unsigned ext_int_mask : 1;
+            unsigned ext_int : 1;
+            unsigned tc_int_mask : 1;
+            unsigned tc_int : 1;
+            unsigned clk : 3;
+            unsigned cs : 3;
+            unsigned ext_int_mask2 : 1;
+            unsigned ext_int2 : 1;
+            unsigned ext : 1;
+            unsigned romdis : 1;
+            unsigned : 18;
+        };
+
+        ircolib::u32 raw;
+    } param0, param1, param2;
+};
+} // namespace weee::core

core/broadway/mmio/mi.cpp

@@ -0,0 +1,20 @@
+#include <mem.hpp>
+#include <broadway/mmio/mi.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+memory_interface::memory_interface(mem &mem) {
+    mem.register_write16_handler(0x0c004000, 0x0c00407f,
+                                 [&](ircolib::u32 addr, ircolib::u16 value) { write16(addr, value); });
+}
+
+void memory_interface::write16(ircolib::u32 addr, ircolib::u16 value) {
+    switch (addr) {
+    case 0x1C:
+        int_mask.raw = value;
+        break;
+    default:
+        ircolib::panic("memory_interface::write16 to unimplemented addr 0x{:08X} with value 0x{:04X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/mi.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+
+struct memory_interface {
+    union {
+        struct {
+            unsigned mem0 : 1;
+            unsigned mem1 : 1;
+            unsigned mem2 : 1;
+            unsigned mem3 : 1;
+            unsigned all : 1;
+            unsigned : 27;
+        };
+        ircolib::u32 raw;
+    } int_mask;
+
+    memory_interface(mem &);
+    void write16(ircolib::u32, ircolib::u16);
+};
+} // namespace weee::core

core/broadway/mmio/pi.cpp

@@ -0,0 +1,31 @@
+#include <mem.hpp>
+#include <broadway/mmio/pi.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+processor_interface::processor_interface(mem &mem) {
+    mem.register_write32_handler(0x0c003000, 0x0c0030ff,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+    mem.register_read32_handler(0x0c003000, 0x0c0030ff, [&](ircolib::u32 addr) { return read32(addr); });
+}
+
+void processor_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0x04:
+        intmr.raw = value;
+        break;
+    default:
+        ircolib::panic("processor_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+
+ircolib::u32 processor_interface::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x2c:
+        return 2;
+    default:
+        ircolib::panic("processor_interface::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+} // namespace weee::core

core/broadway/mmio/pi.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+
+struct processor_interface {
+    union {
+        struct {
+            unsigned error : 1;
+            unsigned rsw : 1;
+            unsigned di : 1;
+            unsigned si : 1;
+            unsigned exi : 1;
+            unsigned ai : 1;
+            unsigned dsp : 1;
+            unsigned mem : 1;
+            unsigned vi : 1;
+            unsigned pe_token : 1;
+            unsigned pe_finish : 1;
+            unsigned cp : 1;
+            unsigned debug : 1;
+            unsigned hsp : 1;
+            unsigned : 18;
+        };
+        ircolib::u32 raw;
+    } intmr;
+
+    processor_interface(mem &);
+    void write32(ircolib::u32, ircolib::u32);
+    ircolib::u32 read32(ircolib::u32);
+};
+} // namespace weee::core

core/broadway/mmio/si.cpp

@@ -0,0 +1,46 @@
+#include <broadway/mmio/si.hpp>
+#include <mem.hpp>
+#include <ircolib/log.hpp>
+
+namespace weee::core {
+serial_interface::serial_interface(mem &mem) {
+    mem.register_read32_handler(0x0c006400, 0x0c0064ff, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write32_handler(0x0c006400, 0x0c0064ff,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { return write32(addr, value); });
+}
+
+ircolib::u32 serial_interface::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x30:
+        return sipoll.raw;
+    case 0x34:
+        return sicomcsr.raw;
+    case 0x38:
+        return sisr.raw;
+    case 0x3C:
+        return clock_lk.raw;
+    default:
+        ircolib::panic("serial_interface::read32 from unimplemented addr 0x{:08X}", addr);
+        return 0;
+    }
+}
+
+void serial_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0x30:
+        sipoll.raw = value;
+        break;
+    case 0x34:
+        sicomcsr.raw = value;
+        break;
+    case 0x38:
+        sisr.raw = value;
+        break;
+    case 0x3C:
+        clock_lk.raw = value;
+        break;
+    default:
+        ircolib::panic("serial_interface::write32 to unimplemented addr 0x{:08X} with value 0x{:08X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/si.hpp

@@ -0,0 +1,75 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+struct serial_interface {
+    serial_interface(mem &);
+
+    ircolib::u32 read32(ircolib::u32);
+    void write32(ircolib::u32, ircolib::u32);
+
+    union {
+        struct {
+            unsigned vbcpy : 4;
+            unsigned en : 4;
+            unsigned y : 8;
+            unsigned x : 8;
+            unsigned : 8;
+        };
+
+        ircolib::u32 raw;
+    } sipoll;
+
+    union {
+        struct {
+            unsigned tstart : 1;
+            unsigned channel : 2;
+            unsigned cben : 1;
+            unsigned cmden : 1;
+            unsigned inlength : 7;
+            unsigned : 1;
+            unsigned outlength : 7;
+            unsigned : 1;
+            unsigned chen : 1;
+            unsigned chnum : 2;
+            unsigned rdstintmsk : 1;
+            unsigned rdstint : 1;
+            unsigned comerr : 1;
+            unsigned tcintmsk : 1;
+            unsigned tcint : 1;
+        };
+        ircolib::u32 raw;
+    } sicomcsr;
+
+    union {
+        struct {
+            unsigned : 31;
+            unsigned lock : 1;
+        };
+
+        ircolib::u32 raw;
+    } clock_lk;
+
+    union {
+        struct {
+            unsigned joy3 : 6;
+            unsigned : 2;
+            unsigned joy2 : 6;
+            unsigned : 2;
+            unsigned joy1 : 6;
+            unsigned : 2;
+            unsigned unrun : 1;
+            unsigned ovrun0 : 1;
+            unsigned coll0 : 1;
+            unsigned norep0 : 1;
+            unsigned wrst0 : 1;
+            unsigned rdst0 : 1;
+            unsigned : 1;
+            unsigned wr : 1;
+        };
+
+        ircolib::u32 raw;
+    } sisr;
+};
+} // namespace weee::core

core/broadway/mmio/vi.cpp

@@ -0,0 +1,133 @@
+#include <broadway/mmio/vi.hpp>
+#include <ircolib/log.hpp>
+#include <mem.hpp>
+
+namespace weee::core {
+video_interface::video_interface(mem &mem) {
+    mem.register_read16_handler(0x0c002000, 0x0c0020ff, [&](ircolib::u32 addr) { return read16(addr); });
+    mem.register_read32_handler(0x0c002000, 0x0c0020ff, [&](ircolib::u32 addr) { return read32(addr); });
+    mem.register_write16_handler(0x0c002000, 0x0c0020ff,
+                                 [&](ircolib::u32 addr, ircolib::u16 value) { write16(addr, value); });
+    mem.register_write32_handler(0x0c002000, 0x0c0020ff,
+                                 [&](ircolib::u32 addr, ircolib::u32 value) { write32(addr, value); });
+}
+
+ircolib::u16 video_interface::read16(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x00:
+        return vtr.raw;
+    case 0x02:
+        return dcr.raw;
+    case 0x4a:
+        return hsr.raw;
+    case 0x6c:
+        return viclk & 1;
+    case 0x70:
+        return 0x0280;
+    default:
+        ircolib::panic("video_interface::read16 from unimplemented addr 0x{:04X}", addr);
+        return 0;
+    }
+}
+
+ircolib::u32 video_interface::read32(ircolib::u32 addr) {
+    switch (addr) {
+    case 0x02:
+        return dcr.raw;
+    case 0x04:
+        return htr0.raw;
+    case 0x08:
+        return htr1.raw;
+    case 0x0c:
+        return vto.raw;
+    case 0x10:
+        return vte.raw;
+    case 0x14:
+        return bbei.raw;
+    case 0x18:
+        return bboi.raw;
+    case 0x1c:
+        return tfbl.raw & 0x1ffffe00;
+    case 0x24:
+        return bfbl.raw & 0x10fffe00;
+    case 0x4c:
+    case 0x50:
+    case 0x54:
+        return fct0[addr - 0x4c].raw;
+    case 0x58:
+    case 0x5c:
+    case 0x60:
+    case 0x64:
+        return fct1[addr - 0x58].raw;
+    default:
+        ircolib::panic("video_interface::read32 from unimplemented addr 0x{:04X}", addr);
+        return 0;
+    }
+}
+
+void video_interface::write16(ircolib::u32 addr, ircolib::u16 value) {
+    switch (addr) {
+    case 0x00:
+        vtr.raw = value;
+        break;
+    case 0x02:
+        dcr.raw = value;
+        break;
+    case 0x4a:
+        hsr.raw = value;
+        break;
+    case 0x6c:
+        viclk = value & 1;
+        break;
+    case 0x70:
+        break;
+    default:
+        ircolib::panic("video_interface::write16 to unimplemented addr 0x{:04X} with value 0x{:04X}", addr, value);
+    }
+}
+
+void video_interface::write32(ircolib::u32 addr, ircolib::u32 value) {
+    switch (addr) {
+    case 0x02:
+        dcr.raw = value;
+        break;
+    case 0x04:
+        htr0.raw = value;
+        break;
+    case 0x08:
+        htr1.raw = value;
+        break;
+    case 0x0c:
+        vto.raw = value;
+        break;
+    case 0x10:
+        vte.raw = value;
+        break;
+    case 0x14:
+        bbei.raw = value;
+        break;
+    case 0x18:
+        bboi.raw = value;
+        break;
+    case 0x1c:
+        tfbl.raw = value & 0x1ffffe00;
+        break;
+    case 0x24:
+        bfbl.raw = value & 0x10fffe00;
+        break;
+    case 0x4c:
+    case 0x50:
+    case 0x54:
+        fct0[addr - 0x4c].raw = value;
+        break;
+    case 0x58:
+    case 0x5c:
+    case 0x60:
+    case 0x64:
+        fct1[addr - 0x58].raw = value;
+        break;
+    default:
+        ircolib::panic("video_interface::write32 to unimplemented addr 0x{:04X} with value 0x{:08X}", addr, value);
+    }
+}
+} // namespace weee::core

core/broadway/mmio/vi.hpp

@@ -0,0 +1,139 @@
+#pragma once
+#include <ircolib/types.hpp>
+
+namespace weee::core {
+struct mem;
+
+struct video_interface {
+    video_interface(mem &);
+    void write16(ircolib::u32, ircolib::u16);
+    void write32(ircolib::u32, ircolib::u32);
+    ircolib::u16 read16(ircolib::u32);
+    ircolib::u32 read32(ircolib::u32);
+
+    ircolib::u32 xfb_top_addr() {
+        auto addr = tfbl.fbb;
+        if (tfbl.page) {
+            addr <<= 5;
+        }
+
+        return addr + tfbl.xof;
+    }
+
+    union DCR {
+        struct {
+            unsigned e : 1;
+            unsigned r : 1;
+            unsigned i : 1;
+            unsigned d : 1;
+            unsigned le0 : 2;
+            unsigned le1 : 2;
+            unsigned fmt : 2;
+            unsigned : 6;
+        };
+
+        ircolib::u16 raw;
+    } dcr;
+
+    union HTR0 {
+        struct {
+            unsigned hlw : 9;
+            unsigned : 7;
+            unsigned hce : 7;
+            unsigned : 1;
+            unsigned hcs : 7;
+            unsigned : 1;
+        };
+
+        ircolib::u32 raw;
+    } htr0;
+
+    union HTR1 {
+        struct {
+            unsigned hsy : 7;
+            unsigned hbe : 10;
+            unsigned hbs : 10;
+            unsigned : 5;
+        };
+
+        ircolib::u32 raw;
+    } htr1;
+
+    union VTR {
+        struct {
+            unsigned equ : 4;
+            unsigned acv : 10;
+            unsigned : 2;
+        };
+
+        ircolib::u16 raw;
+    } vtr;
+
+    union VTO {
+        struct {
+            unsigned prb : 10;
+            unsigned : 6;
+            unsigned psb : 10;
+            unsigned : 6;
+        };
+
+        ircolib::u32 raw;
+    } vto, vte;
+
+    union BBI {
+        struct {
+            unsigned bs1 : 5;
+            unsigned be1 : 11;
+            unsigned bs3 : 5;
+            unsigned be3 : 11;
+        };
+
+        ircolib::u32 raw;
+    } bbei, bboi;
+
+    union FBR {
+        struct {
+            unsigned : 3;
+            unsigned page : 1;
+            unsigned xof : 4;
+            unsigned fbb : 24;
+        };
+        ircolib::u32 raw;
+    } tfbl{}, bfbl{};
+
+    union FCT012 {
+        struct {
+            unsigned tap0 : 10;
+            unsigned tap1 : 10;
+            unsigned tap2 : 10;
+            unsigned : 2;
+        };
+
+        ircolib::u32 raw;
+    } fct0[3];
+
+    union FCT3456 {
+        struct {
+            unsigned tap0 : 8;
+            unsigned tap1 : 8;
+            unsigned tap2 : 8;
+            unsigned tap3 : 8;
+        };
+
+        ircolib::u32 raw;
+    } fct1[4];
+
+    union HSR {
+        struct {
+            unsigned stp : 9;
+            unsigned : 3;
+            unsigned hs_en : 1;
+            unsigned : 3;
+        };
+
+        ircolib::u16 raw;
+    } hsr;
+
+    bool viclk;
+};
+} // namespace weee::core

core/broadway/utils.hpp

@@ -0,0 +1,14 @@
+#pragma once
+#include <broadway.hpp>
+
+namespace weee::core::utils {
+static inline ircolib::u8 primary(ircolib::u32 instr) { return (instr >> 26) & 0x3f; }
+static inline ircolib::u16 secondary(ircolib::u32 instr) { return (instr >> 1) & 0x3ff; }
+static inline ircolib::u8 RD(ircolib::u32 instr) { return (instr >> 21) & 0x1f; }
+static inline ircolib::u8 RB(ircolib::u32 instr) { return (instr >> 11) & 0x1f; }
+static inline ircolib::u8 RS(ircolib::u32 instr) { return RD(instr); }
+static inline ircolib::u8 RA(ircolib::u32 instr) { return (instr >> 16) & 0x1f; }
+static inline ircolib::u16 UIMM(ircolib::u32 instr) { return instr & 0xffff; }
+static inline ircolib::s16 SIMM(ircolib::u32 instr) { return UIMM(instr); }
+static inline ircolib::u8 crfD(ircolib::u32 instr) { return (instr >> 23) & 7; }
+} // namespace weee::core::utils

core/loaders/dol.cpp

@@ -4,7 +4,6 @@
 #include <ircolib/file.hpp>
 #include <ircolib/mem_access.hpp>
 #include <array>
-#include <print>
 
 namespace weee::core {
 bool load_dol(const std::string &path, mem &mem, broadway &broadway) {
@@ -21,23 +20,23 @@ bool load_dol(const std::string &path, mem &mem, broadway &broadway) {
         ircolib::u32 bss_address, bss_size, entry_point;
     } hdr;
 
-    for (size_t bin_index = 0; bin_index < 0xD8; bin_index += 4) {
+    for (ircolib::u32 bin_index = 0; bin_index < 0xD8; bin_index += 4) {
-        if (ircolib::is_inside_range_ext(bin_index, 0, 0x1c)) // text file offsets
+        if (ircolib::is_inside_range(bin_index, 0, 0x1b)) // text file offsets
             hdr.text[bin_index / 4].offset = std::byteswap(ircolib::read_access<ircolib::u32>(bin, bin_index));
 
-        if (ircolib::is_inside_range_ext(bin_index, 0x1c, 0x48)) // data file offsets
+        if (ircolib::is_inside_range(bin_index, 0x1c, 0x47)) // data file offsets
             hdr.data[(bin_index - 0x1c) / 4].offset = std::byteswap(ircolib::read_access<ircolib::u32>(bin, bin_index));
 
-        if (ircolib::is_inside_range_ext(bin_index, 0x48, 0x64)) // text loading addresses
+        if (ircolib::is_inside_range(bin_index, 0x48, 0x63)) // text loading addresses
             hdr.text[(bin_index - 0x48) / 4].addr = std::byteswap(ircolib::read_access<ircolib::u32>(bin, bin_index));
 
-        if (ircolib::is_inside_range_ext(bin_index, 0x64, 0x90)) // data loading addresses
+        if (ircolib::is_inside_range(bin_index, 0x64, 0x8f)) // data loading addresses
             hdr.data[(bin_index - 0x64) / 4].addr = std::byteswap(ircolib::read_access<ircolib::u32>(bin, bin_index));
 
-        if (ircolib::is_inside_range_ext(bin_index, 0x90, 0xac)) // text sizes
+        if (ircolib::is_inside_range(bin_index, 0x90, 0xab)) // text sizes
             hdr.text[(bin_index - 0x90) / 4].size = std::byteswap(ircolib::read_access<ircolib::u32>(bin, bin_index));
 
-        if (ircolib::is_inside_range_ext(bin_index, 0xac, 0xd8)) // data sizes
+        if (ircolib::is_inside_range(bin_index, 0xac, 0xd7)) // data sizes
             hdr.data[(bin_index - 0xac) / 4].size = std::byteswap(ircolib::read_access<ircolib::u32>(bin, bin_index));
     }
 

core/loaders/elf.cpp

@@ -10,7 +10,7 @@ bool load_elf(const std::string &path, mem &mem, broadway &broadway) {
     if (!reader.load(path))
         return false;
 
-    size_t sanity_bss_check_count = 0;
+    ircolib::u32 sanity_bss_check_count = 0;
 
     for (const auto &segment : reader.segments) {
         const auto segment_type = segment->get_type();

core/mem.cpp

@@ -1,12 +1,64 @@
 #include <cstring>
 #include <mem.hpp>
 #include <ircolib/log.hpp>
-#include "ircolib/mem_access.hpp"
+#include <ircolib/mem_access.hpp>
 
 namespace weee::core {
-mem::mem() {
+mem::mem() : vi(*this), pi(*this), mi(*this), dsp(*this), ai(*this), exi(*this), si(*this) {
     mem1.resize(24_mib);
     std::fill(mem1.begin(), mem1.end(), 0);
+    ipl.resize(1_mib);
+    std::fill(ipl.begin(), ipl.end(), 0);
+
+    register_read8_handler(0x00000000, 0x017fffff, [&](ircolib::u32 addr) { return mem1[addr]; });
+
+    register_read16_handler(0x00000000, 0x017fffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u16>(mem1, addr); });
+
+    register_read32_handler(0x00000000, 0x017fffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u32>(mem1, addr); });
+
+    register_read64_handler(0x00000000, 0x017fffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u64>(mem1, addr); });
+
+    register_write8_handler(0x00000000, 0x017fffff, [&](ircolib::u32 addr, ircolib::u8 value) { mem1[addr] = value; });
+
+    register_write16_handler(0x00000000, 0x017fffff, [&](ircolib::u32 addr, ircolib::u16 value) {
+        ircolib::write_access<ircolib::u16>(mem1, addr, value);
+    });
+
+    register_write32_handler(0x00000000, 0x017fffff, [&](ircolib::u32 addr, ircolib::u32 value) {
+        ircolib::write_access<ircolib::u32>(mem1, addr, value);
+    });
+
+    register_write64_handler(0x00000000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
+        ircolib::write_access<ircolib::u64>(mem1, addr, value);
+    });
+
+    register_read8_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr) { return ipl[addr]; });
+
+    register_read16_handler(0x0ff00000, 0x0fffffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u16>(ipl, addr); });
+
+    register_read32_handler(0x0ff00000, 0x0fffffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u32>(ipl, addr); });
+
+    register_read64_handler(0x0ff00000, 0x0fffffff,
+                            [&](ircolib::u32 addr) { return ircolib::read_access<ircolib::u64>(ipl, addr); });
+
+    register_write8_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u8 value) { ipl[addr] = value; });
+
+    register_write16_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u16 value) {
+        ircolib::write_access<ircolib::u16>(ipl, addr, value);
+    });
+
+    register_write32_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
+        ircolib::write_access<ircolib::u32>(ipl, addr, value);
+    });
+
+    register_write64_handler(0x0ff00000, 0x0fffffff, [&](ircolib::u32 addr, ircolib::u32 value) {
+        ircolib::write_access<ircolib::u64>(ipl, addr, value);
+    });
 }
 
 void mem::copy(std::vector<ircolib::u8> &src, const ircolib::u32 offset) {
@@ -14,7 +66,6 @@ void mem::copy(std::vector<ircolib::u8> &src, const ircolib::u32 offset) {
         ircolib::panic("mem::copy outside mem1 range (src @ 0x{:08} for size 0x{:08X})", offset, src.size());
 
     ircolib::swap_buffer<ircolib::u32>(src);
-    std::println("Copying {} bytes to mem1[{}]", src.size(), offset);
     std::copy(src.begin(), src.end(), mem1.begin() + offset);
 }
 
@@ -23,7 +74,6 @@ void mem::copy(ircolib::u8 *src, const ircolib::u32 size, const ircolib::u32 off
         ircolib::panic("mem::copy outside mem1 range (src @ 0x{:08} for size 0x{:08X})", offset, size);
 
     ircolib::swap_buffer<ircolib::u32>(src, size);
-    std::println("Copying {} bytes to mem1[{}]", size, offset);
     memcpy(&mem1[offset], src, size);
 }
 
@@ -31,23 +81,98 @@ void mem::set(const ircolib::u8 val, const ircolib::u32 size, const ircolib::u32
     if (offset + size >= mem1.size())
         ircolib::panic("mem::set outside mem1 range (@ 0x{:08} for size 0x{:08X})", offset, size);
 
-    std::println("Setting {} bytes to {} from mem1[{}]", size, val, offset);
     memset(&mem1[offset], val, size);
 }
 
-ircolib::u32 mem::read(ircolib::u32 addr) {
+std::expected<ircolib::u8, std::string> mem::read8(ircolib::u32 addr) {
     addr &= 0x0FFFFFFF;
-    if (addr > 0x017FFFFF)
+    for (const auto &handler : read8_handlers) {
-        ircolib::panic("mem::read unimplemented outside mem1 (0x{:08X})", addr);
+        if (ircolib::is_inside_range(addr, handler.start, handler.end)) {
-
+            return handler.func(addr - handler.start);
-    return ircolib::read_access<ircolib::u32>(mem1, addr);
+        }
     }
 
-void mem::write(ircolib::u32 addr, ircolib::u32 value) {
+    return std::unexpected(std::format("mem::read8 unimplemented addr 0x{:08X}", addr));
-    addr &= 0x0FFFFFFF;
+}
-    if (addr > 0x017FFFFF)
-        ircolib::panic("mem::write unimplemented outside mem1 (0x{:08X} = 0x{:08X})", addr, value);
 
-    ircolib::write_access<ircolib::u32>(mem1, addr, value);
+std::expected<ircolib::u16, std::string> mem::read16(ircolib::u32 addr) {
+    addr &= 0x0FFFFFFF;
+    for (const auto &handler : read16_handlers) {
+        if (ircolib::is_inside_range(addr, handler.start, handler.end)) {
+            return handler.func(addr - handler.start);
+        }
+    }
+
+    return std::unexpected(std::format("mem::read16 unimplemented addr 0x{:08X}", addr));
+}
+
+std::expected<ircolib::u32, std::string> mem::read32(ircolib::u32 addr) {
+    addr &= 0x0FFFFFFF;
+    for (const auto &handler : read32_handlers) {
+        if (ircolib::is_inside_range(addr, handler.start, handler.end)) {
+            return handler.func(addr - handler.start);
+        }
+    }
+
+    return std::unexpected(std::format("mem::read32 unimplemented addr 0x{:08X}", addr));
+}
+
+std::expected<ircolib::u64, std::string> mem::read64(ircolib::u32 addr) {
+    addr &= 0x0FFFFFFF;
+    for (const auto &handler : read64_handlers) {
+        if (ircolib::is_inside_range(addr, handler.start, handler.end)) {
+            return handler.func(addr - handler.start);
+        }
+    }
+
+    return std::unexpected(std::format("mem::read64 unimplemented addr 0x{:08X}", addr));
+}
+
+std::expected<void, std::string> mem::write8(ircolib::u32 addr, ircolib::u8 value) {
+    addr &= 0x0FFFFFFF;
+    for (const auto &handler : write8_handlers) {
+        if (ircolib::is_inside_range(addr, handler.start, handler.end)) {
+            handler.func(addr - handler.start, value);
+            return std::expected<void, std::string>();
+        }
+    }
+
+    return std::unexpected(std::format("mem::write8 unimplemented addr 0x{:08X} = 0x{:02X}", addr, value));
+}
+
+std::expected<void, std::string> mem::write16(ircolib::u32 addr, ircolib::u16 value) {
+    addr &= 0x0FFFFFFF;
+    for (const auto &handler : write16_handlers) {
+        if (ircolib::is_inside_range(addr, handler.start, handler.end)) {
+            handler.func(addr - handler.start, value);
+            return std::expected<void, std::string>();
+        }
+    }
+
+    return std::unexpected(std::format("mem::write16 unimplemented addr 0x{:08X} = 0x{:04X}", addr, value));
+}
+
+std::expected<void, std::string> mem::write32(ircolib::u32 addr, ircolib::u32 value) {
+    addr &= 0x0FFFFFFF;
+    for (const auto &handler : write32_handlers) {
+        if (ircolib::is_inside_range(addr, handler.start, handler.end)) {
+            handler.func(addr - handler.start, value);
+            return std::expected<void, std::string>();
+        }
+    }
+
+    return std::unexpected(std::format("mem::write32 unimplemented addr 0x{:08X} = 0x{:08X}", addr, value));
+}
+
+std::expected<void, std::string> mem::write64(ircolib::u32 addr, ircolib::u64 value) {
+    addr &= 0x0FFFFFFF;
+    for (const auto &handler : write64_handlers) {
+        if (ircolib::is_inside_range(addr, handler.start, handler.end)) {
+            handler.func(addr - handler.start, value);
+            return std::expected<void, std::string>();
+        }
+    }
+
+    return std::unexpected(std::format("mem::write64 unimplemented addr 0x{:08X} = 0x{:016X}", addr, value));
 }
 } // namespace weee::core

core/mem.hpp

@@ -1,18 +1,99 @@
 #pragma once
+#include <string>
 #include <vector>
 #include <ircolib/types.hpp>
+#include <broadway/mmio/vi.hpp>
+#include <broadway/mmio/pi.hpp>
+#include <broadway/mmio/mi.hpp>
+#include <broadway/mmio/dsp.hpp>
+#include <broadway/mmio/ai.hpp>
+#include <broadway/mmio/exi.hpp>
+#include <broadway/mmio/si.hpp>
+#include <functional>
+#include <expected>
 
 namespace weee::core {
+template <typename T>
+struct read_handler {
+    std::function<T(ircolib::u32)> func;
+    ircolib::u32 start, end;
+};
+
+template <typename T>
+struct write_handler {
+    std::function<void(ircolib::u32, T)> func;
+    ircolib::u32 start, end;
+};
+
 struct mem {
     mem();
 
-    ircolib::u32 read(ircolib::u32);
+    void register_read8_handler(ircolib::u32 start, ircolib::u32 end,
-    void write(ircolib::u32, ircolib::u32);
+                                const std::function<ircolib::u8(ircolib::u32)> &func) {
+        read8_handlers.push_back({std::move(func), start, end});
+    }
+    void register_read16_handler(ircolib::u32 start, ircolib::u32 end,
+                                 const std::function<ircolib::u16(ircolib::u32)> &func) {
+        read16_handlers.push_back({std::move(func), start, end});
+    }
+    void register_read32_handler(ircolib::u32 start, ircolib::u32 end,
+                                 const std::function<ircolib::u32(ircolib::u32)> &func) {
+        read32_handlers.push_back({std::move(func), start, end});
+    }
+    void register_read64_handler(ircolib::u32 start, ircolib::u32 end,
+                                 const std::function<ircolib::u64(ircolib::u32)> &func) {
+        read64_handlers.push_back({std::move(func), start, end});
+    }
+    void register_write8_handler(ircolib::u32 start, ircolib::u32 end,
+                                 const std::function<void(ircolib::u32, ircolib::u8)> &func) {
+        write8_handlers.push_back({std::move(func), start, end});
+    }
+    void register_write16_handler(ircolib::u32 start, ircolib::u32 end,
+                                  const std::function<void(ircolib::u32, ircolib::u16)> &func) {
+        write16_handlers.push_back({std::move(func), start, end});
+    }
+    void register_write32_handler(ircolib::u32 start, ircolib::u32 end,
+                                  const std::function<void(ircolib::u32, ircolib::u32)> &func) {
+        write32_handlers.push_back({std::move(func), start, end});
+    }
+    void register_write64_handler(ircolib::u32 start, ircolib::u32 end,
+                                  const std::function<void(ircolib::u32, ircolib::u64)> &func) {
+        write64_handlers.push_back({std::move(func), start, end});
+    }
+
+    std::expected<ircolib::u8, std::string> read8(ircolib::u32);
+    std::expected<ircolib::u16, std::string> read16(ircolib::u32);
+    std::expected<ircolib::u32, std::string> read32(ircolib::u32);
+    std::expected<ircolib::u64, std::string> read64(ircolib::u32);
+    std::expected<void, std::string> write8(ircolib::u32, ircolib::u8);
+    std::expected<void, std::string> write16(ircolib::u32, ircolib::u16);
+    std::expected<void, std::string> write32(ircolib::u32, ircolib::u32);
+    std::expected<void, std::string> write64(ircolib::u32, ircolib::u64);
+
     void copy(std::vector<ircolib::u8> &src, const ircolib::u32 offset);
     void copy(ircolib::u8 *src, const ircolib::u32 size, const ircolib::u32 offset);
     void set(const ircolib::u8 val, const ircolib::u32 size, const ircolib::u32 offset);
 
-    private:
     std::vector<ircolib::u8> mem1;
+    std::vector<ircolib::u8> ipl{};
+
+    private:
+    std::vector<read_handler<ircolib::u8>> read8_handlers{};
+    std::vector<read_handler<ircolib::u16>> read16_handlers{};
+    std::vector<read_handler<ircolib::u32>> read32_handlers{};
+    std::vector<read_handler<ircolib::u64>> read64_handlers{};
+    std::vector<write_handler<ircolib::u8>> write8_handlers{};
+    std::vector<write_handler<ircolib::u16>> write16_handlers{};
+    std::vector<write_handler<ircolib::u32>> write32_handlers{};
+    std::vector<write_handler<ircolib::u64>> write64_handlers{};
+
+    public:
+    video_interface vi;
+    processor_interface pi;
+    memory_interface mi;
+    dsp dsp;
+    exi exi;
+    audio_interface ai;
+    serial_interface si;
 };
 } // namespace weee::core

external/SDL/.clang-format

@@ -0,0 +1,96 @@
+---
+AlignConsecutiveMacros: Consecutive
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignConsecutiveDeclarations: None
+AlignEscapedNewlines: Right
+AlignOperands: Align
+AlignTrailingComments: true
+
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+
+# Custom brace breaking
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: true
+  AfterClass: true
+  AfterControlStatement: Never
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: true
+  AfterStruct: true
+  AfterUnion: true
+  AfterExternBlock: false
+  BeforeElse: false
+  BeforeWhile: false
+  IndentBraces: false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+
+# Make the closing brace of container literals go to a new line
+Cpp11BracedListStyle: false
+
+# Never format includes
+IncludeBlocks: Preserve
+# clang-format version 4.0 through 12.0:
+#SortIncludes: false
+# clang-format version 13.0+:
+#SortIncludes: Never
+
+# No length limit, in case it breaks macros, you can
+# disable it with /* clang-format off/on */ comments
+ColumnLimit: 0
+
+IndentWidth: 4
+ContinuationIndentWidth: 4
+IndentCaseLabels: false
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: NoIndent
+
+PointerAlignment: Right
+SpaceAfterCStyleCast: false
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeParens: ControlStatements
+SpaceAroundPointerQualifiers: Default
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+
+UseCRLF: false
+UseTab: Never
+
+IfMacros:
+  [
+    "CHECK_PARAM",
+  ]
+
+ForEachMacros:
+  [
+    "spa_list_for_each",
+    "spa_list_for_each_safe",
+    "wl_list_for_each",
+    "wl_list_for_each_safe",
+    "wl_array_for_each",
+    "udev_list_entry_foreach",
+  ]
+
+---
+

external/SDL/.clang-tidy

@@ -0,0 +1,59 @@
+---
+Checks: >
+  -*,
+  bugprone-assert-side-effect,
+  bugprone-assignment-in-if-condition,
+  bugprone-bool-pointer-implicit-conversion,
+  bugprone-dangling-handle,
+  bugprone-dynamic-static-initializers,
+  bugprone-infinite-loop,
+  bugprone-integer-division,
+  bugprone-macro-repeated-side-effects,
+  bugprone-misplaced-operator-in-strlen-in-alloc,
+  bugprone-misplaced-pointer-arithmetic-in-alloc,
+  bugprone-misplaced-widening-cast,
+  bugprone-not-null-terminated-result,
+  bugprone-posix-return,
+  bugprone-redundant-branch-condition,
+  bugprone-string-literal-with-embedded-nul,
+  bugprone-suspicious-memset-usage,
+  bugprone-suspicious-semicolon,
+  bugprone-suspicious-string-compare,
+  bugprone-too-small-loop-variable,
+  bugprone-unused-return-value,
+  cert-err33-c,
+  clang-analyzer-core.*,
+  clang-analyzer-valist.*,
+  clang-analyzer-unix.Malloc,
+  clang-diagnostic-*,
+  google-readability-casting,
+  misc-misleading-bidirectional,
+  misc-misleading-identifier,
+  misc-misplaced-const,
+  misc-redundant-expression,
+  objc-*,
+  performance-type-promotion-in-math-fn,
+  readability-avoid-const-params-in-decls,
+  readability-braces-around-statements,
+  readability-const-return-type,
+  readability-duplicate-include,
+  readability-inconsistent-declaration-parameter-name,
+  readability-misplaced-array-index,
+  readability-non-const-parameter,
+  readability-redundant-control-flow,
+  readability-redundant-declaration,
+  readability-redundant-function-ptr-dereference,
+  readability-redundant-preprocessor,
+  readability-simplify-boolean-expr
+
+CheckOptions:
+  - key:   bugprone-assert-side-effect.AssertMacros
+    value: "SDL_assert, SDL_assert_release, SDL_assert_paranoid, SDL_assert_always, SDL_COMPILE_TIME_ASSERT"
+  - key:   bugprone-misplaced-widening-cast.CheckImplicitCasts
+    value: true
+  - key:   bugprone-not-null-terminated-result.WantToUseSafeFunctions
+    value: false # Do not recommend _s functions
+
+FormatStyle: "file"
+HeaderFilterRegex: "*.h$"
+WarningsAsErrors: ""

external/SDL/.editorconfig

@@ -0,0 +1,69 @@
+# For format see editorconfig.org
+# Copyright 2022 Collabora Ltd.
+# SPDX-License-Identifier: Zlib
+
+root = true
+
+[*.{c,cc,cg,cpp,gradle,h,java,m,metal,pl,py,S,sh,txt}]
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{html,js,json,m4,yml,yaml,vcxproj,vcxproj.filters}]
+indent_size = 2
+indent_style = space
+trim_tailing_whitespace = true
+
+[*.xml]
+indent_size = 4
+indent_style = space
+
+[{CMakeLists.txt,cmake/*.cmake}]
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[{cmake/cmake_uninstall.cmake.in,test/CMakeLists.txt,cmake/SDL3Config.cmake.in}]
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[{Makefile.*,*.mk,*.sln,*.pbxproj,*.plist}]
+indent_size = 8
+indent_style = tab
+tab_width = 8
+
+[src/joystick/controller_type.*]
+indent_style = tab
+
+[src/joystick/hidapi/steam/*.h]
+indent_style = tab
+
+[src/libm/*.c]
+indent_style = tab
+
+[src/test/SDL_test_{crc32,md5,random}.c]
+indent_size = 2
+indent_style = space
+
+[src/video/yuv2rgb/*.{c,h}]
+indent_style = tab
+
+[wayland-protocols/*.xml]
+indent_size = 2
+indent_style = space
+
+[*.{markdown,md}]
+indent_size = 4
+indent_style = space
+# Markdown syntax treats tabs as 4 spaces
+tab_width = 4
+
+[{*.bat,*.rc}]
+end_of_line = crlf
+
+[*.cocci]
+insert_final_newline = true

external/SDL/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,9 @@
+- [ ] I confirm that I am the author of this code and release it to the SDL project under the Zlib license. This contribution does not contain code from other sources, including code generated by a Large Language Model ("AI").
+
+<!--- Provide a general summary of your changes in the Title above -->
+
+## Description
+<!--- Describe your changes in detail -->
+
+## Existing Issue(s)
+<!--- If it fixes an open issue, please link to the issue here. -->

external/SDL/.github/actions/setup-djgpp-toolchain/action.yml

@@ -0,0 +1,66 @@
+name: 'Setup DJGPP toolchain'
+description: 'Download DJGPP and setup CMake toolchain'
+runs:
+  using: 'composite'
+  steps:
+    - name: 'Calculate variables'
+      id: calc
+      shell: sh
+      run: |
+        version="12.2.0"
+        case "${{ runner.os }}-${{ runner.arch }}" in
+          "Linux-X86")
+            archive="djgpp-linux32-gcc1220.tar.bz2"
+            ;;
+          "Linux-X64")
+            archive="djgpp-linux64-gcc1220.tar.bz2"
+            ;;
+          "macOS-X86" | "macOS-X64" | "macOS-ARM64")
+            archive="djgpp-osx-gcc1220.tar.bz2"
+            ;;
+          "Windows-X86" | "Windows-X64")
+            archive="djgpp-mingw-gcc1220.zip"
+            ;;
+          *)
+            echo "Unsupported ${{ runner.os }}-${{ runner.arch }}"
+            exit 1;
+            ;;
+        esac
+        echo "url=https://github.com/andrewwutw/build-djgpp/releases/download/v3.4/${archive}" >> ${GITHUB_OUTPUT}
+        echo "archive=${archive}" >> ${GITHUB_OUTPUT}
+        echo "version=${version}" >> ${GITHUB_OUTPUT}
+        echo "cache-key=${archive}-${{ inputs.version }}-${{ runner.os }}-${{ runner.arch }}" >> ${GITHUB_OUTPUT}
+    - name: 'Restore cached ${{ steps.calc.outputs.archive }}'
+      id: cache-restore
+      uses: actions/cache/restore@v5
+      with:
+        path: '${{ runner.temp }}/${{ steps.calc.outputs.archive }}'
+        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Download DJGPP ${{ steps.calc.outputs.version }} for ${{ runner.os }} (${{ runner.arch }})'
+      if: ${{ !steps.cache-restore.outputs.cache-hit || steps.cache-restore.outputs.cache-hit == 'false' }}
+      shell: pwsh
+      run: |
+        Invoke-WebRequest "${{ steps.calc.outputs.url }}" -OutFile "${{ runner.temp }}/${{ steps.calc.outputs.archive }}"
+    - name: 'Cache ${{ steps.calc.outputs.archive }}'
+      if: ${{ !steps.cache-restore.outputs.cache-hit || steps.cache-restore.outputs.cache-hit == 'false' }}
+      uses: actions/cache/save@v5
+      with:
+        path: '${{ runner.temp }}/${{ steps.calc.outputs.archive }}'
+        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Extract DJGPP archive'
+      shell: pwsh
+      run: |
+        $archive = "${{ steps.calc.outputs.archive }}";
+        if ($archive.EndsWith(".bz2")) {
+          # Remove ".bz2" suffix
+          $tar_archive = $archive.Substring(0, $archive.Length - 4)
+          7z "-o${{ runner.temp }}" x "${{ runner.temp }}/${{ steps.calc.outputs.archive }}"
+          7z "-o${{ runner.temp }}" x "${{ runner.temp }}/$tar_archive"
+        } else {
+          7z "-o${{ runner.temp }}" x "${{ runner.temp }}/${{ steps.calc.outputs.archive }}"
+        }
+    - name: 'Set output variables'
+      id: final
+      shell: pwsh
+      run: |
+        echo "${{ runner.temp }}/djgpp/bin" >> $env:GITHUB_PATH

external/SDL/.github/actions/setup-gdk-desktop/action.yml

@@ -0,0 +1,82 @@
+name: 'Setup GDK (Game Development Kit) for Windows Desktop'
+description: 'Download GDK and install into MSBuild'
+inputs:
+  # Keep edition and ref in sync!
+  edition:
+    description: 'GDK edition'
+    default: '240601'  # YYMMUU (Year Month Update)
+  ref:
+    description: 'Git reference'
+    default: 'June_2024_Update_1'
+  folder:
+    description: 'Folder where to create Directory.Build.props'
+    required: true
+    default: '${{ github.workspace }}'
+runs:
+  using: 'composite'
+  steps:
+    - uses: actions/setup-python@main
+      with:
+        python-version: 3.x
+    - name: 'Calculate variables'
+      id: calc
+      shell: pwsh
+      run: |
+        $vs_folder=@(vswhere -latest -property installationPath)
+        echo "vs-folder=${vs_folder}" >> $Env:GITHUB_OUTPUT
+        
+        echo "gdk-path=${{ runner.temp }}\GDK-${{ inputs.edition }}" >> $Env:GITHUB_OUTPUT
+
+        echo "cache-key=gdk-${{ inputs.ref }}-${{ inputs.edition }}" >> $Env:GITHUB_OUTPUT
+    - name: 'Restore cached GDK'
+      id: cache-restore
+      uses: actions/cache/restore@v5
+      with:
+        path: '${{ steps.calc.outputs.gdk-path }}'
+        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Download GDK'
+      if: ${{ !steps.cache-restore.outputs.cache-hit }}
+      shell: pwsh
+      run: |
+        python build-scripts/setup-gdk-desktop.py                 `
+          --download                                              `
+          --temp-folder "${{ runner.temp }}"                      `
+          --gdk-path="${{ steps.calc.outputs.gdk-path }}"         `
+          --ref-edition "${{ inputs.ref }},${{ inputs.edition }}" `
+          --vs-folder="${{ steps.calc.outputs.vs-folder }}"       `
+          --no-user-props
+    - name: 'Extract GDK'
+      if: ${{ !steps.cache-restore.outputs.cache-hit }}
+      shell: pwsh
+      run: |
+        python build-scripts/setup-gdk-desktop.py                 `
+          --extract                                               `
+          --ref-edition "${{ inputs.ref }},${{ inputs.edition }}" `
+          --temp-folder "${{ runner.temp }}"                      `
+          --gdk-path="${{ steps.calc.outputs.gdk-path }}"         `
+          --vs-folder="${{ steps.calc.outputs.vs-folder }}"       `
+          --no-user-props
+    - name: 'Cache GDK'
+      if: ${{ !steps.cache-restore.outputs.cache-hit }}
+      uses: actions/cache/save@v5
+      with:
+        path: '${{ steps.calc.outputs.gdk-path }}'
+        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Copy MSBuild files into GDK'
+      shell: pwsh
+      run: |
+        python build-scripts/setup-gdk-desktop.py                 `
+          --ref-edition "${{ inputs.ref }},${{ inputs.edition }}" `
+          --gdk-path="${{ steps.calc.outputs.gdk-path }}"         `
+          --vs-folder="${{ steps.calc.outputs.vs-folder }}"       `
+          --copy-msbuild                                          `
+          --no-user-props
+    - name: 'Write user props'
+      shell: pwsh
+      run: |
+        python build-scripts/setup-gdk-desktop.py                 `
+          --ref-edition "${{ inputs.ref }},${{ inputs.edition }}" `
+          --temp-folder "${{ runner.temp }}"                      `
+          --vs-folder="${{ steps.calc.outputs.vs-folder }}"       `
+          --gdk-path="${{ steps.calc.outputs.gdk-path }}"         `
+          "--props-folder=${{ inputs.folder }}"

external/SDL/.github/actions/setup-loongarch64-toolchain/action.yml

@@ -0,0 +1,53 @@
+name: 'Setup LoongArch64 toolchain'
+description: 'Download Linux LoongArch64 toolchain and set output variables'
+inputs:
+  version:
+    description: 'LoongArch64 version'
+    default: '2023.08.08'
+outputs:
+  prefix:
+    description: "LoongArch toolchain prefix"
+    value: ${{ steps.final.outputs.prefix }}
+  cc:
+    description: "LoongArch C compiler"
+    value: ${{ steps.final.outputs.cc }}
+  cxx:
+    description: "LoongArch C++ compiler"
+    value: ${{ steps.final.outputs.cxx }}
+runs:
+  using: 'composite'
+  steps:
+    - uses: actions/cache/restore@v5
+      id: restore-cache
+      with:
+        path: /opt/cross-tools
+        key: loongarch64-${{ inputs.version }}
+
+    - name: 'Download LoongArch64 gcc+glibc toolchain'
+      if: ${{ !steps.restore-cache.outputs.cache-hit }}
+      shell: bash
+      run: |
+        url="https://github.com/loongson/build-tools/releases/download/${{ inputs.version }}/CLFS-loongarch64-8.1-x86_64-cross-tools-gcc-glibc.tar.xz"
+        
+        wget "$url" -O /tmp/toolchain.tar.xz
+        
+        mkdir -p /opt
+        tar -C /opt -x -f /tmp/toolchain.tar.xz
+
+    - uses: actions/cache/save@v5
+      if: ${{ !steps.restore-cache.outputs.cache-hit }}
+      with:
+        path: /opt/cross-tools
+        key: loongarch64-${{ inputs.version }}
+    - name: 'Set output vars'
+      id: final
+      shell: bash
+      run: |
+        prefix=/opt/cross-tools
+        echo "prefix=${prefix}" >> $GITHUB_OUTPUT
+        cc="${prefix}/bin/loongarch64-unknown-linux-gnu-gcc"
+        cxx="${prefix}/bin/loongarch64-unknown-linux-gnu-g++"
+        echo "cc=${cc}" >> $GITHUB_OUTPUT
+        echo "cxx=${cxx}" >> $GITHUB_OUTPUT
+        echo "LOONGARCH64_CC=${cc}" >>$GITHUB_ENV
+        echo "LOONGARCH64_CXX=${cxx}" >>$GITHUB_ENV

external/SDL/.github/actions/setup-msvc-libusb/action.yml

@@ -0,0 +1,71 @@
+name: 'Setup libusb for MSVC'
+description: 'Download libusb sdk for MSVC, and set output/environment variables'
+inputs:
+  version:
+    description: 'libusb version'
+    required: true
+    default: '1.0.27'
+  arch:
+    description: "libusb architecture (x86 or x64)"
+    rqeuired: true
+outputs:
+  root:
+    description: "libusb root directory"
+    value: ${{ steps.final.outputs.root }}
+runs:
+  using: 'composite'
+  steps:
+    - name: 'Restore cached libusb-${{ inputs.version }}.7z'
+      id: cache-restore
+      uses: actions/cache/restore@v5
+      with:
+        path: 'C:\temp\libusb-${{ inputs.version }}.7z'
+        key: libusb-msvc-${{ inputs.version }}
+    - name: 'Download libusb ${{ inputs.version }}'
+      if: ${{ !steps.cache-restore.outputs.cache-hit }}
+      shell: pwsh
+      run: |
+        Invoke-WebRequest "https://github.com/libusb/libusb/releases/download/v${{ inputs.version }}/libusb-${{ inputs.version }}.7z" -OutFile "C:\temp\libusb-${{ inputs.version }}.7z"
+    - name: 'Cache libusb-${{ inputs.version }}.7z'
+      if: ${{ !steps.cache-restore.outputs.cache-hit }}
+      uses: actions/cache/save@v5
+      with:
+        path: 'C:\temp\libusb-${{ inputs.version }}.7z'
+        key: libusb-msvc-${{ inputs.version }}
+    - name: 'Extract libusb'
+      shell: pwsh
+      run: |
+        7z "-oC:\temp\libusb-${{ inputs.version }}" x "C:\temp\libusb-${{ inputs.version }}.7z"
+    - name: 'Set output vars'
+      id: final
+      shell: pwsh
+      run: |
+        if ('${{ inputs.arch }}' -eq 'x86') {
+          $archdir = "MS32";
+        } elseif ('${{ inputs.arch }}' -eq 'x64') {
+          $archdir = "MS64";
+        } else {
+          write-host "Invalid arch=${{ inputs.arch }}"
+          exit 1
+        }
+        $libusb_incdir = "C:\temp\libusb-${{ inputs.version }}\include";
+        $libusb_libdir = "C:\temp\libusb-${{ inputs.version }}\VS2022\${archdir}\dll";
+        
+        $libusb_header = "${libusb_incdir}\libusb.h";
+        $libusb_implib = "${libusb_libdir}\libusb-1.0.lib";
+        $libusb_dll = "${libusb_libdir}\libusb-1.0.dll";
+        
+        if (!(Test-Path "${libusb_header}")) {
+          write-host "${libusb_header} does not exist!"
+          exit 1
+        }
+        if (!(Test-Path "${libusb_implib}")){
+          write-host "${libusb_implib} does not exist!"
+          exit 1
+        }
+        if (!(Test-Path "${libusb_dll}")) {
+          write-host "${libusb_dll} does not exist!"
+          exit 1
+        }
+        echo "root=${libusb_incdir};${libusb_libdir}" >> $env:GITHUB_OUTPUT
+        echo "LibUSB_ROOT=${libusb_incdir};${libusb_libdir}" >> $env:GITHUB_ENV

external/SDL/.github/actions/setup-ngage-sdk/action.yml

@@ -0,0 +1,102 @@
+name: 'Setup Nonka N-Gage SDK'
+description: 'Download and setup Nokia N-Gage SDK'
+inputs:
+  path:
+    description: 'Installation path'
+    default: 'default'
+runs:
+  using: 'composite'
+  steps:
+    - uses: actions/setup-python@v6
+      with:
+        python-version: '3.x'
+    - name: 'Verify platform'
+      id: calc
+      shell: sh
+      run: |
+        case "${{ runner.os }}-${{ runner.arch }}" in
+          "Windows-X86" | "Windows-X64")
+            echo "ok!"
+            echo "cache-key=ngage-sdk-windows" >> ${GITHUB_OUTPUT}
+            default_install_path="C:/ngagesdk"
+            ;;
+          *)
+            echo "Unsupported ${{ runner.os }}-${{ runner.arch }}"
+            exit 1;
+            ;;
+        esac
+        install_path="${{ inputs.path }}"
+        if [ "x$install_path" = "xdefault" ]; then
+          install_path="$default_install_path"
+        fi
+        echo "install-path=$install_path" >> ${GITHUB_OUTPUT}
+
+        toolchain_repo="https://github.com/ngagesdk/ngage-toolchain"
+        toolchain_branch="main"
+        echo "toolchain-repo=${toolchain_repo}"     >> ${GITHUB_OUTPUT}
+        echo "toolchain-branch=${toolchain_branch}" >> ${GITHUB_OUTPUT}
+
+        sdk_repo="https://github.com/ngagesdk/sdk"
+        sdk_branch="main"
+        echo "sdk-repo=${sdk_repo}"       >> ${GITHUB_OUTPUT}
+        echo "sdk-branch=${sdk_branch}"   >> ${GITHUB_OUTPUT}
+
+        tools_repo="https://github.com/ngagesdk/tools"
+        tools_branch="main"
+        echo "tools-repo=${tools_repo}"       >> ${GITHUB_OUTPUT}
+        echo "tools-branch=${tools_branch}"   >> ${GITHUB_OUTPUT}
+
+        extras_repo="https://github.com/ngagesdk/extras"
+        extras_branch="main"
+        echo "extras-repo=${extras_repo}"       >> ${GITHUB_OUTPUT}
+        echo "extras-branch=${extras_branch}"   >> ${GITHUB_OUTPUT}
+#    - name: 'Restore cached ${{ steps.calc.outputs.archive }}'
+#      id: cache-restore
+#      uses: actions/cache/restore@v5
+#      with:
+#        path: '${{ runner.temp }}'
+#        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Download N-Gage SDK'
+#      if: ${{ !steps.cache-restore.outputs.cache-hit || steps.cache-restore.outputs.cache-hit == 'false' }}
+      shell: pwsh
+      run: |
+
+        Invoke-WebRequest "${{ steps.calc.outputs.toolchain-repo }}/archive/refs/heads/${{ steps.calc.outputs.toolchain-branch }}.zip"  -OutFile "${{ runner.temp }}/ngage-toolchain.zip"
+        Invoke-WebRequest "${{ steps.calc.outputs.sdk-repo }}/archive/refs/heads/${{ steps.calc.outputs.sdk-branch }}.zip"              -OutFile "${{ runner.temp }}/sdk.zip"
+        Invoke-WebRequest "${{ steps.calc.outputs.tools-repo }}/archive/refs/heads/${{ steps.calc.outputs.tools-branch }}.zip"          -OutFile "${{ runner.temp }}/tools.zip"
+        Invoke-WebRequest "${{ steps.calc.outputs.extras-repo }}/archive/refs/heads/${{ steps.calc.outputs.extras-branch }}.zip"        -OutFile "${{ runner.temp }}/extras.zip"
+
+#    - name: 'Cache ${{ steps.calc.outputs.archive }}'
+#      if: ${{ !steps.cache-restore.outputs.cache-hit || steps.cache-restore.outputs.cache-hit == 'false' }}
+#      uses: actions/cache/save@v5
+#      with:
+#        path: |
+#          ${{ runner.temp }}/apps.zip
+#          ${{ runner.temp }}/sdk.zip
+#          ${{ runner.temp }}/tools.zip
+#        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Extract N-Gage SDK'
+      shell: pwsh
+      run: |
+        New-Item -ItemType Directory -Path "${{ steps.calc.outputs.install-path }}" -Force
+
+        New-Item -ItemType Directory -Path "${{ runner.temp }}/ngage-toolchain-temp" -Force 
+        7z "-o${{ runner.temp }}/ngage-toolchain-temp"      x "${{ runner.temp }}/ngage-toolchain.zip"
+        Move-Item -Path "${{ runner.temp }}/ngage-toolchain-temp/ngage-toolchain-${{ steps.calc.outputs.toolchain-branch }}/*" -Destination "${{ steps.calc.outputs.install-path }}"
+
+        7z "-o${{ steps.calc.outputs.install-path }}/sdk"   x "${{ runner.temp }}/sdk.zip"
+        Move-Item -Path "${{ steps.calc.outputs.install-path }}/sdk/sdk-${{ steps.calc.outputs.sdk-branch }}"       -Destination "${{ steps.calc.outputs.install-path }}/sdk/sdk"
+
+        7z "-o${{ steps.calc.outputs.install-path }}/sdk"   x "${{ runner.temp }}/tools.zip"
+        Move-Item -Path "${{ steps.calc.outputs.install-path }}/sdk/tools-${{ steps.calc.outputs.tools-branch }}"   -Destination "${{ steps.calc.outputs.install-path }}/sdk/tools"
+
+        7z "-o${{ steps.calc.outputs.install-path }}/sdk"   x "${{ runner.temp }}/extras.zip"
+        Move-Item -Path "${{ steps.calc.outputs.install-path }}/sdk/extras-${{ steps.calc.outputs.extras-branch }}" -Destination "${{ steps.calc.outputs.install-path }}/sdk/extras"
+    - name: 'Set output variables'
+      id: final
+      shell: sh
+      run: |
+        echo "${{ steps.calc.outputs.install-path }}/sdk/sdk/6.1/Shared/EPOC32/gcc/bin" >> $GITHUB_PATH
+        echo "${{ steps.calc.outputs.install-path }}/sdk/sdk/6.1/Shared/EPOC32/ngagesdk/bin" >> $GITHUB_PATH
+        echo "NGAGESDK=${{ steps.calc.outputs.install-path }}" >> $GITHUB_ENV
+        echo "CMAKE_TOOLCHAIN_FILE=${{ steps.calc.outputs.install-path }}/cmake/ngage-toolchain.cmake" >> $GITHUB_ENV

external/SDL/.github/actions/setup-ninja/action.yml

@@ -0,0 +1,62 @@
+name: 'Setup ninja'
+description: 'Download ninja and add it to the PATH environment variable'
+inputs:
+  version:
+    description: 'Ninja version'
+    default: '1.12.1'
+runs:
+  using: 'composite'
+  steps:
+    - name: 'Calculate variables'
+      id: calc
+      shell: sh
+      run: |
+        case "${{ runner.os }}-${{ runner.arch }}" in
+          "Linux-X86" | "Linux-X64")
+            archive="ninja-linux.zip"
+            ;;
+          "Linux-ARM64")
+            archive="ninja-linux-aarch64.zip"
+            ;;
+          "macOS-X86" | "macOS-X64" | "macOS-ARM64")
+            archive="ninja-mac.zip"
+            ;;
+          "Windows-X86" | "Windows-X64")
+            archive="ninja-win.zip"
+            ;;
+          "Windows-ARM64")
+            archive="ninja-winarm64.zip"
+            ;;
+          *)
+            echo "Unsupported ${{ runner.os }}-${{ runner.arch }}"
+            exit 1;
+            ;;
+        esac
+        echo "archive=${archive}" >> ${GITHUB_OUTPUT}
+        echo "cache-key=${archive}-${{ inputs.version }}-${{ runner.os }}-${{ runner.arch }}" >> ${GITHUB_OUTPUT}
+    - name: 'Restore cached ${{ steps.calc.outputs.archive }}'
+      id: cache-restore
+      uses: actions/cache/restore@v5
+      with:
+        path: '${{ runner.temp }}/${{ steps.calc.outputs.archive }}'
+        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Download ninja ${{ inputs.version }} for ${{ runner.os }} (${{ runner.arch }})'
+      if: ${{ !steps.cache-restore.outputs.cache-hit || steps.cache-restore.outputs.cache-hit == 'false' }}
+      shell: pwsh
+      run: |
+        Invoke-WebRequest "https://github.com/ninja-build/ninja/releases/download/v${{ inputs.version }}/${{ steps.calc.outputs.archive }}" -OutFile "${{ runner.temp }}/${{ steps.calc.outputs.archive }}"
+    - name: 'Cache ${{ steps.calc.outputs.archive }}'
+      if: ${{ !steps.cache-restore.outputs.cache-hit || steps.cache-restore.outputs.cache-hit == 'false' }}
+      uses: actions/cache/save@v5
+      with:
+        path: '${{ runner.temp }}/${{ steps.calc.outputs.archive }}'
+        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Extract ninja'
+      shell: pwsh
+      run: |
+        7z "-o${{ runner.temp }}/ninja-${{ inputs.version }}-${{ runner.arch }}" x "${{ runner.temp }}/${{ steps.calc.outputs.archive }}"
+    - name: 'Set output variables'
+      id: final
+      shell: pwsh
+      run: |
+        echo "${{ runner.temp }}/ninja-${{ inputs.version }}-${{ runner.arch }}" >> $env:GITHUB_PATH

external/SDL/.github/actions/setup-vita-gles/action.yml

@@ -0,0 +1,93 @@
+name: 'Setup GLES for PlayStation Vita'
+description: 'Download GLES for VITA (PVR or PIB), and copy it into the vita sdk'
+inputs:
+  pib-version:
+    description: 'PIB version'
+    default: '1.1.4'
+  pvr-version:
+    description: 'PVR_PSP2 version'
+    default: '3.9'
+  type:
+    description: '"pib" or "pvr"'
+    default: ''
+runs:
+  using: 'composite'
+  steps:
+    - name: 'Calculate variables'
+      id: calc
+      shell: sh
+      run: |
+        if test "x${VITASDK}" = "x"; then
+          echo "VITASDK must be defined"
+          exit 1;
+        fi
+        case "x${{ inputs.type }}" in
+          "xpvr")
+            echo "cache-key=SDL-vita-gles-pvr-${{ inputs.pvr-version}}" >> ${GITHUB_OUTPUT}
+            ;;
+          "xpib")
+            echo "cache-key=SDL-vita-gles-pib-${{ inputs.pib-version}}" >> ${GITHUB_OUTPUT}
+            ;;
+          *)
+            echo "Invalid type. Must be 'pib' or 'pvr'."
+            exit 1
+            ;;
+        esac
+    - uses: actions/cache/restore@v5
+      id: restore-cache
+      with:
+        path: /vita/dependencies
+        key: '${{ steps.calc.outputs.cache-key }}'
+    - name: 'Download PVR_PSP2 (GLES)'
+      if: ${{ !steps.restore-cache.outputs.cache-hit && inputs.type == 'pvr' }}
+      shell: sh
+      run: |
+        pvr_psp2_version=${{ inputs.pvr-version }}
+        
+        mkdir -p /vita/dependencies/include
+        mkdir -p /vita/dependencies/lib
+        
+        # Configure PVR_PSP2 headers
+        wget https://github.com/GrapheneCt/PVR_PSP2/archive/refs/tags/v$pvr_psp2_version.zip -P/tmp
+        unzip /tmp/v$pvr_psp2_version.zip -d/tmp
+        cp -r /tmp/PVR_PSP2-$pvr_psp2_version/include/* /vita/dependencies/include
+        rm /tmp/v$pvr_psp2_version.zip
+        
+        # include guard of PVR_PSP2's khrplatform.h does not match the usual one
+        sed -i -e s/__drvkhrplatform_h_/__khrplatform_h_/ /vita/dependencies/include/KHR/khrplatform.h
+        
+        # Configure PVR_PSP2 stub libraries
+        wget https://github.com/GrapheneCt/PVR_PSP2/releases/download/v$pvr_psp2_version/vitasdk_stubs.zip -P/tmp
+        unzip /tmp/vitasdk_stubs.zip -d/tmp/pvr_psp2_stubs
+        find /tmp/pvr_psp2_stubs -type f -name "*.a" -exec cp {} /vita/dependencies/lib \;
+        rm /tmp/vitasdk_stubs.zip
+        rm -rf /tmp/pvr_psp2_stubs
+
+    - name: 'Download gl4es4vita (OpenGL)'
+      if: ${{ !steps.restore-cache.outputs.cache-hit && inputs.type == 'pib' }}
+      shell: sh
+      run: |
+        gl4es4vita_version=${{ inputs.pib-version }}
+        
+        mkdir -p /vita/dependencies/include
+        mkdir -p /vita/dependencies/lib
+        
+        # Configure gl4es4vita headers
+        wget https://github.com/SonicMastr/gl4es4vita/releases/download/v$gl4es4vita_version-vita/include.zip -P/tmp
+        unzip -o /tmp/include.zip -d/vita/dependencies/include
+        rm /tmp/include.zip
+        
+        # Configure gl4es4vita stub libraries
+        wget https://github.com/SonicMastr/gl4es4vita/releases/download/v$gl4es4vita_version-vita/vitasdk_stubs.zip -P/tmp
+        unzip /tmp/vitasdk_stubs.zip -d/vita/dependencies/lib
+
+    - uses: actions/cache/save@v5
+      if: ${{ !steps.restore-cache.outputs.cache-hit }}
+      with:
+        path: /vita/dependencies
+        key: '${{ steps.calc.outputs.cache-key }}'
+
+    - name: Copy PVR_PSP2 (GLES) or gl4es4vita (OpenGL) to vita toolchain dir
+      shell: sh
+      run: |
+        cp -rv /vita/dependencies/* ${VITASDK}/arm-vita-eabi

external/SDL/.github/cmake/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.0...3.5)
+project(ci_utils C CXX)
+
+set(txt "CC=${CMAKE_C_COMPILER}
+CXX=${CMAKE_CXX_COMPILER}
+CFLAGS=${CMAKE_C_FLAGS}
+CXXFLAGS=${CMAKE_CXX_FLAGS}
+LDFLAGS=${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_C_STANDARD_LIBRARIES}
+")
+
+message("${txt}")
+
+set(VAR_PATH "/tmp/env.txt" CACHE PATH "Where to write environment file")
+message(STATUS "Writing CC/CXX/CFLAGS/CXXFLAGS/LDFLAGS environment to ${VAR_PATH}")
+
+file(WRITE "${VAR_PATH}" "${txt}")

external/SDL/.github/workflows/build.yml

@@ -0,0 +1,48 @@
+name: 'Build (All)'
+
+on: [push, pull_request]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  controller:
+    name: 'Create test plan'
+    runs-on: 'ubuntu-latest'
+    outputs:
+      platforms-level1: ${{ steps.plan.outputs.platforms-level1 }}
+      platforms-others: ${{ steps.plan.outputs.platforms-others }}
+    steps:
+      - uses: actions/setup-python@main
+        with:
+          python-version: 3.x
+      - uses: actions/checkout@main
+        with:
+          sparse-checkout: '.github/workflows/create-test-plan.py'
+      - name: 'Create plan'
+        id: plan
+        run: |
+          # Adding [sdl-ci-filter GLOB] to the commit message will limit the jobs
+          # e.g. [sdl-ci-filter msvc-*]
+          EOF=$(openssl rand -hex 32)
+          cat >/tmp/commit_message.txt <<$EOF
+          ${{ github.event.head_commit.message }}
+          $EOF
+
+          python .github/workflows/create-test-plan.py \
+            --github-variable-prefix platforms \
+            --github-ci \
+            --verbose \
+            ${{ (github.repository_owner != 'libsdl-org' && '--no-artifact') || '' }} \
+            --commit-message-file /tmp/commit_message.txt
+  level1:
+    needs: [controller]
+    uses: './.github/workflows/generic.yml'
+    with:
+      platforms: ${{ needs.controller.outputs.platforms-level1 }}
+  level2:
+    needs: [controller, level1]
+    uses: './.github/workflows/generic.yml'
+    with:
+      platforms: ${{ needs.controller.outputs.platforms-others }}

external/SDL/.github/workflows/create-test-plan.py

@@ -0,0 +1,973 @@
+#!/usr/bin/env python
+import argparse
+import dataclasses
+import fnmatch
+from enum import Enum
+import json
+import logging
+import os
+import re
+import shlex
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class AppleArch(Enum):
+    Aarch64 = "aarch64"
+    X86_64 = "x86_64"
+
+
+class MsvcArch(Enum):
+    X86 = "x86"
+    X64 = "x64"
+    Arm64 = "arm64"
+
+
+class JobOs(Enum):
+    WindowsLatest = "windows-latest"
+    UbuntuLatest = "ubuntu-latest"
+    MacosLatest = "macos-latest"
+    Ubuntu22_04 = "ubuntu-22.04"
+    Ubuntu24_04 = "ubuntu-24.04"
+    Ubuntu24_04_arm = "ubuntu-24.04-arm"
+    Macos14 = "macos-14"  # macOS Sonoma (2023)
+    Macos15 = "macos-15"  # macOS Sequoia (2024)
+    Macos26 = "macos-26"  # macOS Tahoe (2025)
+
+
+class SdlPlatform(Enum):
+    Android = "android"
+    Emscripten = "emscripten"
+    Haiku = "haiku"
+    LoongArch64 = "loongarch64"
+    Msys2 = "msys2"
+    Linux = "linux"
+    MacOS = "macos"
+    Ios = "ios"
+    Tvos = "tvos"
+    Msvc = "msvc"
+    N3ds = "n3ds"
+    PowerPC = "powerpc"
+    PowerPC64 = "powerpc64"
+    Ps2 = "ps2"
+    Psp = "psp"
+    Vita = "vita"
+    Riscos = "riscos"
+    FreeBSD = "freebsd"
+    NetBSD = "netbsd"
+    OpenBSD = "openbsd"
+    NGage = "ngage"
+    DJGPP = "djgpp"
+
+
+class Msys2Platform(Enum):
+    Mingw32 = "mingw32"
+    Mingw64 = "mingw64"
+    Clang64 = "clang64"
+    Ucrt64 = "ucrt64"
+
+
+class IntelCompiler(Enum):
+    Icc = "icc"
+    Icx = "icx"
+
+
+class VitaGLES(Enum):
+    Pib = "pib"
+    Pvr = "pvr"
+
+
+@dataclasses.dataclass(slots=True)
+class JobSpec:
+    name: str
+    os: JobOs
+    platform: SdlPlatform
+    artifact: Optional[str]
+    container: Optional[str] = None
+    no_cmake: bool = False
+    xcode: bool = False
+    android_mk: bool = False
+    android_gradle: bool = False
+    lean: bool = False
+    android_arch: Optional[str] = None
+    android_abi: Optional[str] = None
+    android_platform: Optional[int] = None
+    msys2_platform: Optional[Msys2Platform] = None
+    intel: Optional[IntelCompiler] = None
+    apple_framework: Optional[bool] = None
+    apple_archs: Optional[set[AppleArch]] = None
+    msvc_project: Optional[str] = None
+    msvc_arch: Optional[MsvcArch] = None
+    clang_cl: bool = False
+    gdk: bool = False
+    vita_gles: Optional[VitaGLES] = None
+    more_hard_deps: bool = False
+
+
+JOB_SPECS = {
+    "msys2-mingw32": JobSpec(name="Windows (msys2, mingw32)",               os=JobOs.WindowsLatest,     platform=SdlPlatform.Msys2,       artifact="SDL-mingw32",            msys2_platform=Msys2Platform.Mingw32, ),
+    "msys2-mingw64": JobSpec(name="Windows (msys2, mingw64)",               os=JobOs.WindowsLatest,     platform=SdlPlatform.Msys2,       artifact="SDL-mingw64",            msys2_platform=Msys2Platform.Mingw64, ),
+    "msys2-clang64": JobSpec(name="Windows (msys2, clang64)",               os=JobOs.WindowsLatest,     platform=SdlPlatform.Msys2,       artifact="SDL-mingw64-clang",      msys2_platform=Msys2Platform.Clang64, ),
+    "msys2-ucrt64": JobSpec(name="Windows (msys2, ucrt64)",                 os=JobOs.WindowsLatest,     platform=SdlPlatform.Msys2,       artifact="SDL-mingw64-ucrt",       msys2_platform=Msys2Platform.Ucrt64, ),
+    "msvc-x64": JobSpec(name="Windows (MSVC, x64)",                         os=JobOs.WindowsLatest,     platform=SdlPlatform.Msvc,        artifact="SDL-VC-x64",             msvc_arch=MsvcArch.X64,   msvc_project="VisualC/SDL.sln", ),
+    "msvc-x86": JobSpec(name="Windows (MSVC, x86)",                         os=JobOs.WindowsLatest,     platform=SdlPlatform.Msvc,        artifact="SDL-VC-x86",             msvc_arch=MsvcArch.X86,   msvc_project="VisualC/SDL.sln", ),
+    "msvc-clang-x64": JobSpec(name="Windows (MSVC, clang-cl x64)",          os=JobOs.WindowsLatest,     platform=SdlPlatform.Msvc,        artifact="SDL-clang-cl-x64",       msvc_arch=MsvcArch.X64,   clang_cl=True, ),
+    "msvc-clang-x86": JobSpec(name="Windows (MSVC, clang-cl x86)",          os=JobOs.WindowsLatest,     platform=SdlPlatform.Msvc,        artifact="SDL-clang-cl-x86",       msvc_arch=MsvcArch.X86,   clang_cl=True, ),
+    "msvc-arm64": JobSpec(name="Windows (MSVC, ARM64)",                     os=JobOs.WindowsLatest,     platform=SdlPlatform.Msvc,        artifact="SDL-VC-arm64",           msvc_arch=MsvcArch.Arm64, msvc_project="VisualC/SDL.sln", ),
+    "msvc-gdk-x64": JobSpec(name="GDK (MSVC, x64)",                         os=JobOs.WindowsLatest,     platform=SdlPlatform.Msvc,        artifact="SDL-VC-GDK",             msvc_arch=MsvcArch.X64,   msvc_project="VisualC-GDK/SDL.sln", gdk=True, no_cmake=True, ),
+    "ubuntu-22.04": JobSpec(name="Ubuntu 22.04",                            os=JobOs.Ubuntu22_04,       platform=SdlPlatform.Linux,       artifact="SDL-ubuntu22.04", ),
+    "ubuntu-latest": JobSpec(name="Ubuntu (latest)",                        os=JobOs.UbuntuLatest,      platform=SdlPlatform.Linux,       artifact="SDL-ubuntu-latest", ),
+    "ubuntu-24.04-arm64": JobSpec(name="Ubuntu 24.04 (ARM64)",              os=JobOs.Ubuntu24_04_arm,   platform=SdlPlatform.Linux,       artifact="SDL-ubuntu24.04-arm64", ),
+    "steamrt3": JobSpec(name="Steam Linux Runtime 3.0 (x86_64)",            os=JobOs.UbuntuLatest,      platform=SdlPlatform.Linux,       artifact="SDL-steamrt3",           container="registry.gitlab.steamos.cloud/steamrt/sniper/sdk:latest" ),
+    "steamrt3-arm64": JobSpec(name="Steam Linux Runtime 3.0 (arm64)",       os=JobOs.Ubuntu24_04_arm,   platform=SdlPlatform.Linux,       artifact="SDL-steamrt3-arm64",     container="registry.gitlab.steamos.cloud/steamrt/sniper/sdk/arm64:latest" ),
+    "steamrt4": JobSpec(name="Steam Linux Runtime 4.0 (x86_64)",            os=JobOs.UbuntuLatest,      platform=SdlPlatform.Linux,       artifact="SDL-steamrt4",           container="registry.gitlab.steamos.cloud/steamrt/steamrt4/sdk:latest", more_hard_deps = True, ),
+    "steamrt4-arm64": JobSpec(name="Steam Linux Runtime 4.0 (arm64)",       os=JobOs.Ubuntu24_04_arm,   platform=SdlPlatform.Linux,       artifact="SDL-steamrt4-arm64",     container="registry.gitlab.steamos.cloud/steamrt/steamrt4/sdk/arm64:latest", more_hard_deps = True, ),
+    "ubuntu-intel-icx": JobSpec(name="Ubuntu 22.04 (Intel oneAPI)",         os=JobOs.Ubuntu22_04,       platform=SdlPlatform.Linux,       artifact="SDL-ubuntu22.04-oneapi", intel=IntelCompiler.Icx, ),
+    "ubuntu-intel-icc": JobSpec(name="Ubuntu 22.04 (Intel Compiler)",       os=JobOs.Ubuntu22_04,       platform=SdlPlatform.Linux,       artifact="SDL-ubuntu22.04-icc",    intel=IntelCompiler.Icc, ),
+    "macos-framework-x64":  JobSpec(name="MacOS (Framework) (x64)",         os=JobOs.Macos14,           platform=SdlPlatform.MacOS,       artifact="SDL-macos-framework",    apple_framework=True,  apple_archs={AppleArch.Aarch64, AppleArch.X86_64, }, xcode=True, ),
+    "macos-framework-arm64": JobSpec(name="MacOS (Framework) (arm64)",      os=JobOs.MacosLatest,       platform=SdlPlatform.MacOS,       artifact=None,                     apple_framework=True,  apple_archs={AppleArch.Aarch64, AppleArch.X86_64, }, ),
+    "macos-26-framework-arm64": JobSpec(name="MacOS 26 (Framework) (arm64)",os=JobOs.Macos26,           platform=SdlPlatform.MacOS,       artifact=None,                     apple_framework=True,  apple_archs={AppleArch.Aarch64, AppleArch.X86_64, }, ),
+    "macos-gnu-arm64": JobSpec(name="MacOS (GNU prefix)",                   os=JobOs.MacosLatest,       platform=SdlPlatform.MacOS,       artifact="SDL-macos-arm64-gnu",    apple_framework=False, apple_archs={AppleArch.Aarch64, },  ),
+    "ios": JobSpec(name="iOS (CMake & xcode)",                              os=JobOs.MacosLatest,       platform=SdlPlatform.Ios,         artifact="SDL-ios-arm64",          xcode=True, ),
+    "tvos": JobSpec(name="tvOS (CMake & xcode)",                            os=JobOs.MacosLatest,       platform=SdlPlatform.Tvos,        artifact="SDL-tvos-arm64",         xcode=True, ),
+    "android-cmake": JobSpec(name="Android (CMake)",                        os=JobOs.UbuntuLatest,      platform=SdlPlatform.Android,     artifact="SDL-android-arm64",      android_abi="arm64-v8a", android_arch="aarch64", android_platform=23, ),
+    "android-cmake-lean": JobSpec(name="Android (CMake, lean)",             os=JobOs.UbuntuLatest,      platform=SdlPlatform.Android,     artifact="SDL-lean-android-arm64", android_abi="arm64-v8a", android_arch="aarch64", android_platform=23, lean=True, ),
+    "android-mk": JobSpec(name="Android (Android.mk)",                      os=JobOs.UbuntuLatest,      platform=SdlPlatform.Android,     artifact=None,                     no_cmake=True, android_mk=True, ),
+    "android-gradle": JobSpec(name="Android (Gradle)",                      os=JobOs.UbuntuLatest,      platform=SdlPlatform.Android,     artifact=None,                     no_cmake=True, android_gradle=True, ),
+    "emscripten": JobSpec(name="Emscripten",                                os=JobOs.UbuntuLatest,      platform=SdlPlatform.Emscripten,  artifact="SDL-emscripten", ),
+    "haiku": JobSpec(name="Haiku",                                          os=JobOs.UbuntuLatest,      platform=SdlPlatform.Haiku,       artifact="SDL-haiku-x64",          container="ghcr.io/haiku/cross-compiler:x86_64-r1beta5", ),
+    "loongarch64": JobSpec(name="LoongArch64",                              os=JobOs.UbuntuLatest,      platform=SdlPlatform.LoongArch64, artifact="SDL-loongarch64", ),
+    "n3ds": JobSpec(name="Nintendo 3DS",                                    os=JobOs.UbuntuLatest,      platform=SdlPlatform.N3ds,        artifact="SDL-n3ds",               container="devkitpro/devkitarm:latest", ),
+    "ppc": JobSpec(name="PowerPC",                                          os=JobOs.UbuntuLatest,      platform=SdlPlatform.PowerPC,     artifact="SDL-ppc",                container="dockcross/linux-ppc:latest", ),
+    "ppc64": JobSpec(name="PowerPC64",                                      os=JobOs.UbuntuLatest,      platform=SdlPlatform.PowerPC64,   artifact="SDL-ppc64le",            container="dockcross/linux-ppc64le:latest", ),
+    "ps2": JobSpec(name="Sony PlayStation 2",                               os=JobOs.UbuntuLatest,      platform=SdlPlatform.Ps2,         artifact="SDL-ps2",                container="ps2dev/ps2dev:latest", ),
+    "psp": JobSpec(name="Sony PlayStation Portable",                        os=JobOs.UbuntuLatest,      platform=SdlPlatform.Psp,         artifact="SDL-psp",                container="pspdev/pspdev:latest", ),
+    "vita-pib": JobSpec(name="Sony PlayStation Vita (GLES w/ pib)",         os=JobOs.UbuntuLatest,      platform=SdlPlatform.Vita,        artifact="SDL-vita-pib",           container="vitasdk/vitasdk:latest", vita_gles=VitaGLES.Pib,  ),
+    "vita-pvr": JobSpec(name="Sony PlayStation Vita (GLES w/ PVR_PSP2)",    os=JobOs.UbuntuLatest,      platform=SdlPlatform.Vita,        artifact="SDL-vita-pvr",           container="vitasdk/vitasdk:latest", vita_gles=VitaGLES.Pvr, ),
+    "riscos": JobSpec(name="RISC OS",                                       os=JobOs.UbuntuLatest,      platform=SdlPlatform.Riscos,      artifact="SDL-riscos",             container="riscosdotinfo/riscos-gccsdk-4.7:latest", ),
+    "netbsd": JobSpec(name="NetBSD",                                        os=JobOs.UbuntuLatest,      platform=SdlPlatform.NetBSD,      artifact="SDL-netbsd-x64", ),
+    "openbsd": JobSpec(name="OpenBSD",                                      os=JobOs.UbuntuLatest,      platform=SdlPlatform.OpenBSD,     artifact="SDL-openbsd-x64", ),
+    "freebsd": JobSpec(name="FreeBSD",                                      os=JobOs.UbuntuLatest,      platform=SdlPlatform.FreeBSD,     artifact="SDL-freebsd-x64", ),
+    "ngage": JobSpec(name="N-Gage",                                         os=JobOs.WindowsLatest,     platform=SdlPlatform.NGage,       artifact="SDL-ngage", ),
+    "djgpp": JobSpec(name="DOS (DJGPP)",                                    os=JobOs.UbuntuLatest,      platform=SdlPlatform.DJGPP,       artifact="SDL-djgpp", ),
+}
+
+
+class StaticLibType(Enum):
+    STATIC_LIB = "SDL3-static.lib"
+    A = "libSDL3.a"
+
+
+class SharedLibType(Enum):
+    WIN32 = "SDL3.dll"
+    SO_0 = "libSDL3.so.0"
+    SO = "libSDL3.so"
+    DYLIB = "libSDL3.0.dylib"
+    FRAMEWORK = "SDL3.framework/Versions/A/SDL3"
+
+
+@dataclasses.dataclass(slots=True)
+class JobDetails:
+    name: str
+    key: str
+    os: str
+    platform: str
+    artifact: str
+    no_cmake: bool
+    ccache: bool = False
+    build_tests: bool = True
+    container: str = ""
+    cmake_build_type: str = "RelWithDebInfo"
+    shell: str = "sh"
+    sudo: str = "sudo"
+    cmake_config_emulator: str = ""
+    apk_packages: list[str] = dataclasses.field(default_factory=list)
+    apt_packages: list[str] = dataclasses.field(default_factory=list)
+    brew_packages: list[str] = dataclasses.field(default_factory=list)
+    cmake_toolchain_file: str = ""
+    cmake_arguments: list[str] = dataclasses.field(default_factory=list)
+    cmake_generator: str = "Ninja"
+    cmake_build_arguments: list[str] = dataclasses.field(default_factory=list)
+    clang_tidy: bool = True
+    cppflags: list[str] = dataclasses.field(default_factory=list)
+    cc: str = ""
+    cxx: str = ""
+    cflags: list[str] = dataclasses.field(default_factory=list)
+    cxxflags: list[str] = dataclasses.field(default_factory=list)
+    ldflags: list[str] = dataclasses.field(default_factory=list)
+    pollute_directories: list[str] = dataclasses.field(default_factory=list)
+    use_cmake: bool = True
+    shared: bool = True
+    static: bool = True
+    shared_lib: Optional[SharedLibType] = None
+    static_lib: Optional[StaticLibType] = None
+    run_tests: bool = True
+    test_pkg_config: bool = True
+    cc_from_cmake: bool = False
+    source_cmd: str = ""
+    pretest_cmd: str = ""
+    java: bool = False
+    android_apks: list[str] = dataclasses.field(default_factory=list)
+    android_ndk: bool = False
+    android_mk: bool = False
+    android_gradle: bool = False
+    minidump: bool = False
+    intel: bool = False
+    msys2_msystem: str = ""
+    msys2_packages: list[str] = dataclasses.field(default_factory=list)
+    werror: bool = True
+    msvc_vcvars_arch: str = ""
+    msvc_vcvars_sdk: str = ""
+    msvc_project: str = ""
+    msvc_project_flags: list[str] = dataclasses.field(default_factory=list)
+    setup_ninja: bool = False
+    setup_libusb_arch: str = ""
+    xcode_sdk: str = ""
+    cpactions: bool = False
+    setup_gdk_folder: str = ""
+    cpactions_os: str = ""
+    cpactions_version: str = ""
+    cpactions_arch: str = ""
+    cpactions_setup_cmd: str = ""
+    cpactions_install_cmd: str = ""
+    setup_vita_gles_type: str = ""
+    check_sources: bool = False
+    setup_python: bool = False
+    pypi_packages: list[str] = dataclasses.field(default_factory=list)
+    setup_gage_sdk_path: str = ""
+    binutils_strings: str = "strings"
+    ctest_args: str = ""
+
+    def to_workflow(self, enable_artifacts: bool) -> dict[str, str|bool]:
+        data = {
+            "name": self.name,
+            "key": self.key,
+            "os": self.os,
+            "ccache": self.ccache,
+            "container": self.container if self.container else "",
+            "platform": self.platform,
+            "artifact": self.artifact,
+            "enable-artifacts": enable_artifacts,
+            "shell": self.shell,
+            "msys2-msystem": self.msys2_msystem,
+            "msys2-packages": my_shlex_join(self.msys2_packages),
+            "android-ndk": self.android_ndk,
+            "java": self.java,
+            "intel": self.intel,
+            "apk-packages": my_shlex_join(self.apk_packages),
+            "apt-packages": my_shlex_join(self.apt_packages),
+            "test-pkg-config": self.test_pkg_config,
+            "brew-packages": my_shlex_join(self.brew_packages),
+            "pollute-directories": my_shlex_join(self.pollute_directories),
+            "no-cmake": self.no_cmake,
+            "build-tests": self.build_tests,
+            "source-cmd": self.source_cmd,
+            "pretest-cmd": self.pretest_cmd,
+            "cmake-config-emulator": self.cmake_config_emulator,
+            "cc": self.cc,
+            "cxx": self.cxx,
+            "cflags": my_shlex_join(self.cppflags + self.cflags),
+            "cxxflags": my_shlex_join(self.cppflags + self.cxxflags),
+            "ldflags": my_shlex_join(self.ldflags),
+            "cmake-generator": self.cmake_generator,
+            "cmake-toolchain-file": self.cmake_toolchain_file,
+            "clang-tidy": self.clang_tidy,
+            "cmake-arguments": my_shlex_join(self.cmake_arguments),
+            "cmake-build-arguments": my_shlex_join(self.cmake_build_arguments),
+            "shared": self.shared,
+            "static": self.static,
+            "shared-lib": self.shared_lib.value if self.shared_lib else None,
+            "static-lib": self.static_lib.value if self.static_lib else None,
+            "cmake-build-type": self.cmake_build_type,
+            "run-tests": self.run_tests,
+            "android-apks": my_shlex_join(self.android_apks),
+            "android-gradle": self.android_gradle,
+            "android-mk": self.android_mk,
+            "werror": self.werror,
+            "sudo": self.sudo,
+            "msvc-vcvars-arch": self.msvc_vcvars_arch,
+            "msvc-vcvars-sdk": self.msvc_vcvars_sdk,
+            "msvc-project": self.msvc_project,
+            "msvc-project-flags": my_shlex_join(self.msvc_project_flags),
+            "setup-ninja": self.setup_ninja,
+            "setup-libusb-arch": self.setup_libusb_arch,
+            "cc-from-cmake": self.cc_from_cmake,
+            "xcode-sdk": self.xcode_sdk,
+            "cpactions": self.cpactions,
+            "cpactions-os": self.cpactions_os,
+            "cpactions-version": self.cpactions_version,
+            "cpactions-arch": self.cpactions_arch,
+            "cpactions-setup-cmd": self.cpactions_setup_cmd,
+            "cpactions-install-cmd": self.cpactions_install_cmd,
+            "setup-vita-gles-type": self.setup_vita_gles_type,
+            "setup-gdk-folder": self.setup_gdk_folder,
+            "check-sources": self.check_sources,
+            "setup-python": self.setup_python,
+            "pypi-packages": my_shlex_join(self.pypi_packages),
+            "setup-ngage-sdk-path": self.setup_gage_sdk_path,
+            "binutils-strings": self.binutils_strings,
+            "ctest-args": self.ctest_args,
+        }
+        return {k: v for k, v in data.items() if v != ""}
+
+
+def my_shlex_join(s):
+    def escape(s):
+        if s[:1] == "'" and s[-1:] == "'":
+            return s
+        if set(s).intersection(set("; \t")):
+            return f'"{s}"'
+        return s
+
+    return " ".join(escape(s))
+
+
+def spec_to_job(spec: JobSpec, key: str, trackmem_symbol_names: bool, ctest_args: list[str]) -> JobDetails:
+    job = JobDetails(
+        name=spec.name,
+        key=key,
+        os=spec.os.value,
+        artifact=spec.artifact or "",
+        container=spec.container or "",
+        platform=spec.platform.value,
+        sudo="sudo",
+        no_cmake=spec.no_cmake,
+    )
+    if job.os.startswith("ubuntu"):
+        job.apt_packages.extend([
+            "ninja-build",
+            "pkg-config",
+        ])
+    pretest_cmd = []
+    if trackmem_symbol_names:
+        pretest_cmd.append("export SDL_TRACKMEM_SYMBOL_NAMES=1")
+    else:
+        pretest_cmd.append("export SDL_TRACKMEM_SYMBOL_NAMES=0")
+    win32 = spec.platform in (SdlPlatform.Msys2, SdlPlatform.Msvc)
+    fpic = None
+    build_parallel = True
+    if spec.lean:
+        job.cppflags.append("-DSDL_LEAN_AND_MEAN=1")
+    if win32:
+        job.cmake_arguments.append("-DSDLTEST_PROCDUMP=ON")
+        job.minidump = True
+    if spec.intel is not None:
+        match spec.intel:
+            case IntelCompiler.Icx:
+                job.cc = "icx"
+                job.cxx = "icpx"
+            case IntelCompiler.Icc:
+                job.cc = "icc"
+                job.cxx = "icpc"
+                # Disable deprecation warning
+                job.cppflags.append("-diag-disable=10441")
+                # Avoid 'Catastrophic error: cannot open precompiled header file'
+                job.cmake_arguments.append("-DCMAKE_DISABLE_PRECOMPILE_HEADERS:BOOL=ON")
+                job.clang_tidy = False
+            case _:
+                raise ValueError(f"Invalid intel={spec.intel}")
+        job.source_cmd = f"source /opt/intel/oneapi/setvars.sh;"
+        job.intel = True
+        job.shell = "bash"
+        job.cmake_arguments.extend((
+            f"-DCMAKE_C_COMPILER={job.cc}",
+            f"-DCMAKE_CXX_COMPILER={job.cxx}",
+            "-DCMAKE_SYSTEM_NAME=Linux",
+        ))
+    match spec.platform:
+        case SdlPlatform.Msvc:
+            job.setup_ninja = not spec.gdk
+            job.clang_tidy = False  # complains about \threadsafety: "unknown command tag name [clang-diagnostic-documentation-unknown-command]"
+            job.msvc_project = spec.msvc_project if spec.msvc_project else ""
+            job.msvc_project_flags.append("-p:TreatWarningsAsError=true")
+            job.test_pkg_config = False
+            job.shared_lib = SharedLibType.WIN32
+            job.static_lib = StaticLibType.STATIC_LIB
+            job.cmake_arguments.extend((
+                "-DCMAKE_MSVC_DEBUG_INFORMATION_FORMAT=ProgramDatabase",
+                "-DCMAKE_EXE_LINKER_FLAGS=-DEBUG",
+                "-DCMAKE_SHARED_LINKER_FLAGS=-DEBUG",
+            ))
+
+            job.cmake_arguments.append("'-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded$<$<CONFIG:Debug>:Debug>'")
+
+            if spec.clang_cl:
+                job.cmake_arguments.extend((
+                    "-DCMAKE_C_COMPILER=clang-cl",
+                    "-DCMAKE_CXX_COMPILER=clang-cl",
+                ))
+                match spec.msvc_arch:
+                    case MsvcArch.X86:
+                        job.cflags.append("/clang:-m32")
+                        job.cxxflags.append("/clang:-m32")
+                        job.ldflags.append("/MACHINE:X86")
+                    case MsvcArch.X64:
+                        job.cflags.append("/clang:-m64")
+                        job.cxxflags.append("/clang:-m64")
+                        job.ldflags.append("/MACHINE:X64")
+                    case _:
+                        raise ValueError(f"Unsupported clang-cl architecture (arch={spec.msvc_arch})")
+            if spec.msvc_project:
+                match spec.msvc_arch:
+                    case MsvcArch.X86:
+                        msvc_platform = "Win32"
+                    case MsvcArch.X64:
+                        msvc_platform = "x64"
+                    case MsvcArch.Arm64:
+                        msvc_platform = "ARM64"
+                    case _:
+                        raise ValueError(f"Unsupported vcxproj architecture (arch={spec.msvc_arch})")
+                if spec.gdk:
+                    msvc_platform = f"Gaming.Desktop.{msvc_platform}"
+                job.msvc_project_flags.append(f"-p:Platform={msvc_platform}")
+            match spec.msvc_arch:
+                case MsvcArch.X86:
+                    job.msvc_vcvars_arch = "x64_x86"
+                case MsvcArch.X64:
+                    job.msvc_vcvars_arch = "x64"
+                case MsvcArch.Arm64:
+                    job.msvc_vcvars_arch = "x64_arm64"
+                    job.run_tests = False
+            if spec.gdk:
+                job.setup_gdk_folder = "VisualC-GDK"
+            else:
+                match spec.msvc_arch:
+                    case MsvcArch.X86:
+                        job.setup_libusb_arch = "x86"
+                    case MsvcArch.X64:
+                        job.setup_libusb_arch = "x64"
+        case SdlPlatform.Linux:
+            if spec.name.startswith("Ubuntu"):
+                assert spec.os.value.startswith("ubuntu-")
+                job.apt_packages.extend((
+                    "ccache",
+                    "gnome-desktop-testing",
+                    "libasound2-dev",
+                    "libpulse-dev",
+                    "libaudio-dev",
+                    "libjack-dev",
+                    "libsndio-dev",
+                    "libusb-1.0-0-dev",
+                    "libx11-dev",
+                    "libxext-dev",
+                    "libxrandr-dev",
+                    "libxcursor-dev",
+                    "libxfixes-dev",
+                    "libxi-dev",
+                    "libxss-dev",
+                    "libxtst-dev",
+                    "libwayland-dev",
+                    "libxkbcommon-dev",
+                    "libdrm-dev",
+                    "libgbm-dev",
+                    "libgl1-mesa-dev",
+                    "libgles2-mesa-dev",
+                    "libegl1-mesa-dev",
+                    "libdbus-1-dev",
+                    "libibus-1.0-dev",
+                    "libudev-dev",
+                    "fcitx-libs-dev",
+                    "libfribidi-dev",
+                    # testffmpeg
+                    "libavcodec-dev",
+                    "libavfilter-dev",
+                    "libavutil-dev",
+                    "libswresample-dev",
+                    "libswscale-dev",
+                ))
+                match = re.match(r"ubuntu-(?P<year>[0-9]+)\.(?P<month>[0-9]+|latest).*", spec.os.value)
+                ubuntu_ge_22 = True
+                if match and match["month"] != "latest":
+                    ubuntu_year, ubuntu_month = [int(match["year"]), int(match["month"])]
+                    ubuntu_ge_22 = ubuntu_year >= 22
+                    job.apt_packages.extend(("libpipewire-0.3-dev", "libdecor-0-dev"))
+                job.apt_packages.extend((
+                    "libunwind-dev",  # For SDL_test memory tracking
+                ))
+            job.ccache = True
+            if trackmem_symbol_names:
+                # older libunwind is slow
+                job.cmake_arguments.append("-DSDLTEST_TIMEOUT_MULTIPLIER=2")
+            job.shared_lib = SharedLibType.SO_0
+            job.static_lib = StaticLibType.A
+            fpic = True
+            job.cmake_arguments.append("-DSDLTEST_GDB=ON")
+            job.apt_packages.append("gdb")
+            if spec.more_hard_deps:
+                # Some distros prefer to make important dependencies
+                # mandatory, so that SDL won't start up but lack expected
+                # functionality if they're missing
+                job.cmake_arguments.extend([
+                    "-DSDL_ALSA_SHARED=OFF",
+                    "-DSDL_FRIBIDI_SHARED=OFF",
+                    "-DSDL_HIDAPI_LIBUSB_SHARED=OFF",
+                    "-DSDL_PULSEAUDIO_SHARED=OFF",
+                    "-DSDL_X11_SHARED=OFF",
+                    "-DSDL_WAYLAND_LIBDECOR_SHARED=OFF",
+                    "-DSDL_WAYLAND_SHARED=OFF",
+                ])
+        case SdlPlatform.Ios | SdlPlatform.Tvos:
+            job.brew_packages.extend([
+                "ccache",
+                "ninja",
+            ])
+            job.ccache = True
+            job.clang_tidy = False
+            job.run_tests = False
+            job.test_pkg_config = False
+            job.shared_lib = SharedLibType.DYLIB
+            job.static_lib = StaticLibType.A
+            match spec.platform:
+                case SdlPlatform.Ios:
+                    if spec.xcode:
+                        job.xcode_sdk = 'iphoneos'
+                    job.cmake_arguments.extend([
+                        "-DCMAKE_SYSTEM_NAME=iOS",
+                        "-DCMAKE_OSX_ARCHITECTURES=\"arm64\"",
+                        "-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0",
+                    ])
+                case SdlPlatform.Tvos:
+                    if spec.xcode:
+                        job.xcode_sdk = 'appletvos'
+                    job.cmake_arguments.extend([
+                        "-DCMAKE_SYSTEM_NAME=tvOS",
+                        "-DCMAKE_OSX_ARCHITECTURES=\"arm64\"",
+                        "-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0",
+                    ])
+        case SdlPlatform.MacOS:
+            if spec.apple_framework:
+                job.static = False
+                job.clang_tidy = False
+                job.test_pkg_config = False
+                job.cmake_arguments.extend((
+                    "'-DCMAKE_OSX_ARCHITECTURES=x86_64;arm64'",
+                    "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13",
+                    "-DSDL_FRAMEWORK=ON",
+                ))
+                job.shared_lib = SharedLibType.FRAMEWORK
+            else:
+                job.clang_tidy = True
+                job.cmake_arguments.extend((
+                    "-DCMAKE_OSX_ARCHITECTURES=arm64",
+                    "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.13",
+                    "-DCLANG_TIDY_BINARY=$(brew --prefix llvm)/bin/clang-tidy",
+                ))
+                job.brew_packages.extend((
+                    # Brew provides a single architecture (aarch64), so it's not usable for fat libraries
+                    "ffmpeg",  # testffmpeg
+                ))
+                job.shared_lib = SharedLibType.DYLIB
+                job.static_lib = StaticLibType.A
+            job.ccache = True
+            job.apt_packages = []
+            job.brew_packages.extend((
+                "ninja",
+            ))
+            if job.ccache:
+                job.brew_packages.append("ccache")
+            if job.clang_tidy:
+                job.brew_packages.append("llvm")
+            if spec.xcode:
+                job.xcode_sdk = "macosx"
+        case SdlPlatform.Android:
+            job.android_gradle = spec.android_gradle
+            job.android_mk = spec.android_mk
+            job.apt_packages.append("ccache")
+            job.run_tests = False
+            job.shared_lib = SharedLibType.SO
+            job.static_lib = StaticLibType.A
+            if spec.android_mk or not spec.no_cmake:
+                job.android_ndk = True
+            if spec.android_gradle or not spec.no_cmake:
+                job.java = True
+            if spec.android_mk or spec.android_gradle:
+                job.apt_packages = []
+            if not spec.no_cmake:
+                job.ccache = True
+                job.cmake_arguments.extend((
+                    f"-DANDROID_PLATFORM={spec.android_platform}",
+                    f"-DANDROID_ABI={spec.android_abi}",
+                ))
+                job.cmake_toolchain_file = "${ANDROID_NDK_HOME}/build/cmake/android.toolchain.cmake"
+                job.cc = f"${{ANDROID_NDK_HOME}}/toolchains/llvm/prebuilt/linux-x86_64/bin/clang --target={spec.android_arch}-none-linux-androideabi{spec.android_platform}"
+
+                job.android_apks = [
+                    "testaudiorecording-apk",
+                    "testautomation-apk",
+                    "testcontroller-apk",
+                    "testmultiaudio-apk",
+                    "testsprite-apk",
+                ]
+
+                # -fPIC is required after updating NDK from 21 to 28
+                job.cflags.append("-fPIC")
+                job.cxxflags.append("-fPIC")
+        case SdlPlatform.Emscripten:
+            job.clang_tidy = False  # clang-tidy does not understand -gsource-map
+            job.shared = False
+            job.ccache = True
+            job.apt_packages.append("ccache")
+            job.cmake_config_emulator = "emcmake"
+            job.cmake_build_type = "Debug"
+            job.test_pkg_config = False
+            job.cmake_arguments.extend((
+                "-DSDLTEST_BROWSER=chrome",
+                "-DSDLTEST_TIMEOUT_MULTIPLIER=4",
+                "-DSDLTEST_CHROME_BINARY=${CHROME_BINARY}",
+            ))
+            job.cflags.extend((
+                "-gsource-map",
+                "-ffile-prefix-map=${PWD}=/SDL",
+            ))
+            job.ldflags.extend((
+                "--source-map-base", "/",
+            ))
+            pretest_cmd.extend((
+                "# Start local HTTP server",
+                "cmake --build build --target serve-sdl-tests --verbose &",
+                "chrome --version",
+                "chromedriver --version",
+            ))
+            job.static_lib = StaticLibType.A
+            job.setup_python = True
+            job.pypi_packages.append("selenium")
+        case SdlPlatform.Ps2:
+            job.ccache = False  #  actions/ccache does not work in psp container (incompatible tar of busybox)
+            build_parallel = False
+            job.shared = False
+            job.sudo = ""
+            job.apt_packages = []
+            job.apk_packages = ["ccache", "cmake", "gmp", "mpc1", "mpfr4", "ninja", "pkgconf", "git", ]
+            job.cmake_toolchain_file = "${PS2DEV}/ps2sdk/ps2dev.cmake"
+            job.clang_tidy = False
+            job.run_tests = False
+            job.shared = False
+            job.cc = "mips64r5900el-ps2-elf-gcc"
+            job.ldflags = ["-L${PS2DEV}/ps2sdk/ee/lib", "-L${PS2DEV}/gsKit/lib", "-L${PS2DEV}/ps2sdk/ports/lib", ]
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.Psp:
+            job.ccache = False  #  actions/ccache does not work in psp container (incompatible tar of busybox)
+            build_parallel = False
+            job.sudo = ""
+            job.apt_packages = []
+            job.apk_packages = ["ccache", "cmake", "gmp", "mpc1", "mpfr4", "ninja", "pkgconf", ]
+            job.cmake_toolchain_file = "${PSPDEV}/psp/share/pspdev.cmake"
+            job.clang_tidy = False
+            job.run_tests = False
+            job.shared = False
+            job.cc = "psp-gcc"
+            job.ldflags = ["-L${PSPDEV}/lib", "-L${PSPDEV}/psp/lib", "-L${PSPDEV}/psp/sdk/lib", ]
+            job.pollute_directories = ["${PSPDEV}/include", "${PSPDEV}/psp/include", "${PSPDEV}/psp/sdk/include", ]
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.Vita:
+            job.ccache = True
+            job.sudo = ""
+            job.apt_packages = []
+            job.apk_packages = ["ccache", "cmake", "ninja", "pkgconf", "bash", "tar"]
+            job.cmake_toolchain_file = "${VITASDK}/share/vita.toolchain.cmake"
+            assert spec.vita_gles is not None
+            job.setup_vita_gles_type = {
+                VitaGLES.Pib: "pib",
+                VitaGLES.Pvr: "pvr",
+            }[spec.vita_gles]
+            job.cmake_arguments.extend((
+                f"-DVIDEO_VITA_PIB={ 'true' if spec.vita_gles == VitaGLES.Pib else 'false' }",
+                f"-DVIDEO_VITA_PVR={ 'true' if spec.vita_gles == VitaGLES.Pvr else 'false' }",
+                "-DSDL_ARMNEON=ON",
+                "-DSDL_ARMSIMD=ON",
+                ))
+            # Fix vita.toolchain.cmake (https://github.com/vitasdk/vita-toolchain/pull/253)
+            job.source_cmd = r"""sed -i -E "s#set\\( PKG_CONFIG_EXECUTABLE \"\\$\\{VITASDK}/bin/arm-vita-eabi-pkg-config\" \\)#set\\( PKG_CONFIG_EXECUTABLE \"${VITASDK}/bin/arm-vita-eabi-pkg-config\" CACHE PATH \"Path of pkg-config executable\" \\)#" ${VITASDK}/share/vita.toolchain.cmake"""
+            job.clang_tidy = False
+            job.run_tests = False
+            job.shared = False
+            job.cc = "arm-vita-eabi-gcc"
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.Haiku:
+            job.ccache = True
+            fpic = False
+            job.run_tests = False
+            job.apt_packages.append("ccache")
+            job.cc = "x86_64-unknown-haiku-gcc"
+            job.cxx = "x86_64-unknown-haiku-g++"
+            job.sudo = ""
+            job.cmake_arguments.extend((
+                f"-DCMAKE_C_COMPILER={job.cc}",
+                f"-DCMAKE_CXX_COMPILER={job.cxx}",
+                "-DCMAKE_SYSTEM_NAME=Haiku",
+            ))
+            job.shared_lib = SharedLibType.SO_0
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.PowerPC64 | SdlPlatform.PowerPC:
+            job.ccache = True
+            # FIXME: Enable SDL_WERROR
+            job.werror = False
+            job.clang_tidy = False
+            job.run_tests = False
+            job.sudo = ""
+            job.apt_packages = ["ccache"]
+            job.shared_lib = SharedLibType.SO_0
+            job.static_lib = StaticLibType.A
+            job.cmake_arguments.extend((
+                "-DSDL_UNIX_CONSOLE_BUILD=ON",
+            ))
+        case SdlPlatform.LoongArch64:
+            job.ccache = True
+            fpic = True
+            job.run_tests = False
+            job.apt_packages.append("ccache")
+            job.cc = "${LOONGARCH64_CC}"
+            job.cxx = "${LOONGARCH64_CXX}"
+            job.cmake_arguments.extend((
+                f"-DCMAKE_C_COMPILER={job.cc}",
+                f"-DCMAKE_CXX_COMPILER={job.cxx}",
+                "-DSDL_UNIX_CONSOLE_BUILD=ON",
+                "-DCMAKE_SYSTEM_NAME=Linux",
+            ))
+            job.shared_lib = SharedLibType.SO_0
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.N3ds:
+            job.cmake_generator = "Unix Makefiles"
+            job.cmake_build_arguments.append("-j$(nproc)")
+            job.ccache = False
+            job.shared = False
+            job.apt_packages = []
+            job.clang_tidy = False
+            job.run_tests = False
+            job.cc_from_cmake = True
+            job.cmake_toolchain_file = "${DEVKITPRO}/cmake/3DS.cmake"
+            job.binutils_strings = "/opt/devkitpro/devkitARM/bin/arm-none-eabi-strings"
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.Msys2:
+            job.ccache = True
+            job.shell = "msys2 {0}"
+            assert spec.msys2_platform
+            job.msys2_msystem = spec.msys2_platform.value
+            job.shared_lib = SharedLibType.WIN32
+            job.static_lib = StaticLibType.A
+            msys2_env = {
+                "mingw32": "mingw-w64-i686",
+                "mingw64": "mingw-w64-x86_64",
+                "clang64": "mingw-w64-clang-x86_64",
+                "ucrt64": "mingw-w64-ucrt-x86_64",
+            }[spec.msys2_platform.value]
+            job.msys2_packages.extend([
+                f"{msys2_env}-cc",
+                f"{msys2_env}-cmake",
+                f"{msys2_env}-ffmpeg",
+                f"{msys2_env}-ninja",
+                f"{msys2_env}-pkg-config",
+            ])
+            if spec.msys2_platform not in (Msys2Platform.Mingw32, ):
+                job.msys2_packages.append(f"{msys2_env}-perl")
+                job.msys2_packages.append(f"{msys2_env}-clang-tools-extra")
+            if job.ccache:
+                job.msys2_packages.append(f"{msys2_env}-ccache")
+        case SdlPlatform.Riscos:
+            job.ccache = False  # FIXME: enable when container gets upgrade
+            # FIXME: Enable SDL_WERROR
+            job.werror = False
+            job.apt_packages = ["ccache", "cmake", "ninja-build"]
+            job.test_pkg_config = False
+            job.shared = False
+            job.run_tests = False
+            job.sudo = ""
+            job.cmake_arguments.extend((
+                "-DRISCOS:BOOL=ON",
+                "-DCMAKE_DISABLE_PRECOMPILE_HEADERS:BOOL=ON",
+                "-DSDL_GCC_ATOMICS:BOOL=OFF",
+            ))
+            job.cmake_toolchain_file = "/home/riscos/env/toolchain-riscos.cmake"
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.FreeBSD | SdlPlatform.NetBSD | SdlPlatform.OpenBSD:
+            job.cpactions = True
+            job.no_cmake = True
+            job.run_tests = False
+            job.apt_packages = []
+            job.shared_lib = SharedLibType.SO_0
+            job.static_lib = StaticLibType.A
+            match spec.platform:
+                case SdlPlatform.FreeBSD:
+                    job.cpactions_os = "freebsd"
+                    job.cpactions_version = "14.3"
+                    job.cpactions_arch = "x86-64"
+                    job.cpactions_setup_cmd = "sudo pkg update"
+                    job.cpactions_install_cmd = "sudo pkg install -y cmake ninja pkgconf libXcursor libXext libXinerama libXi libXfixes libXrandr libXScrnSaver libXxf86vm wayland wayland-protocols libxkbcommon mesa-libs libglvnd evdev-proto libinotify alsa-lib jackit pipewire pulseaudio sndio dbus zh-fcitx ibus libudev-devd"
+                    job.cmake_arguments.extend((
+                        "-DSDL_CHECK_REQUIRED_INCLUDES=/usr/local/include",
+                        "-DSDL_CHECK_REQUIRED_LINK_OPTIONS=-L/usr/local/lib",
+                    ))
+                case SdlPlatform.NetBSD:
+                    job.cpactions_os = "netbsd"
+                    job.cpactions_version = "10.1"
+                    job.cpactions_arch = "x86-64"
+                    job.cpactions_setup_cmd = "export PATH=\"/usr/pkg/sbin:/usr/pkg/bin:/sbin:$PATH\"; export PKG_CONFIG_PATH=\"/usr/pkg/lib/pkgconfig\";export PKG_PATH=\"https://cdn.netBSD.org/pub/pkgsrc/packages/NetBSD/$(uname -p)/$(uname -r|cut -f \"1 2\" -d.)/All/\";echo \"PKG_PATH=$PKG_PATH\";echo \"uname -a -> \"$(uname -a)\"\";sudo -E sysctl -w security.pax.aslr.enabled=0;sudo -E sysctl -w security.pax.aslr.global=0;sudo -E pkgin clean;sudo -E pkgin update"
+                    job.cpactions_install_cmd = "sudo -E pkgin -y install cmake dbus pkgconf ninja-build pulseaudio libxkbcommon wayland wayland-protocols libinotify libusb1"
+                case SdlPlatform.OpenBSD:
+                    job.cpactions_os = "openbsd"
+                    job.cpactions_version = "7.7"
+                    job.cpactions_arch = "x86-64"
+                    job.cpactions_setup_cmd = "sudo pkg_add -u"
+                    job.cpactions_install_cmd = "sudo pkg_add cmake ninja pkgconf wayland wayland-protocols libxkbcommon libinotify pulseaudio dbus ibus"
+        case SdlPlatform.NGage:
+            build_parallel = False
+            job.cmake_build_type = "Release"
+            job.setup_ninja = True
+            job.static_lib = StaticLibType.STATIC_LIB
+            job.shared_lib = None
+            job.clang_tidy = False
+            job.werror = False  # FIXME: enable SDL_WERROR
+            job.shared = False
+            job.run_tests = False
+            job.setup_gage_sdk_path = "C:/ngagesdk"
+            job.cmake_toolchain_file = "C:/ngagesdk/cmake/ngage-toolchain.cmake"
+            job.test_pkg_config = False
+        case SdlPlatform.DJGPP:
+            build_parallel = False
+            job.ccache = True
+            job.apt_packages = ["ccache", "libfl-dev"]  # djgpp needs libfl.so.2
+            job.cmake_build_type = "Release"
+            job.setup_ninja = True
+            job.static_lib = StaticLibType.A
+            job.shared_lib = None
+            job.clang_tidy = False
+            job.werror = False  # FIXME: enable SDL_WERROR
+            job.shared = False
+            job.run_tests = False
+            job.test_pkg_config = False
+            job.cmake_toolchain_file = "$GITHUB_WORKSPACE/build-scripts/i586-pc-msdosdjgpp.cmake"
+        case _:
+            raise ValueError(f"Unsupported platform={spec.platform}")
+
+    if "ubuntu" in spec.name.lower():
+        job.check_sources = True
+        job.setup_python = True
+
+    if job.ccache:
+        job.cmake_arguments.extend((
+            "-DCMAKE_C_COMPILER_LAUNCHER=ccache",
+            "-DCMAKE_CXX_COMPILER_LAUNCHER=ccache",
+        ))
+    job.ctest_args = shlex.join(ctest_args)
+    if not build_parallel:
+        job.cmake_build_arguments.append("-j1")
+    if job.cflags or job.cppflags:
+        job.cmake_arguments.append(f"-DCMAKE_C_FLAGS=\"{my_shlex_join(job.cflags + job.cppflags)}\"")
+    if job.cxxflags or job.cppflags:
+        job.cmake_arguments.append(f"-DCMAKE_CXX_FLAGS=\"{my_shlex_join(job.cxxflags + job.cppflags)}\"")
+    if job.ldflags:
+        job.cmake_arguments.append(f"-DCMAKE_SHARED_LINKER_FLAGS=\"{my_shlex_join(job.ldflags)}\"")
+        job.cmake_arguments.append(f"-DCMAKE_EXE_LINKER_FLAGS=\"{my_shlex_join(job.ldflags)}\"")
+    job.pretest_cmd = "\n".join(pretest_cmd)
+    def tf(b):
+        return "ON" if b else "OFF"
+
+    if fpic is not None:
+        job.cmake_arguments.append(f"-DCMAKE_POSITION_INDEPENDENT_CODE={tf(fpic)}")
+
+    if job.no_cmake:
+        job.cmake_arguments = []
+
+    return job
+
+
+def spec_to_platform(spec: JobSpec, key: str, enable_artifacts: bool, trackmem_symbol_names: bool, ctest_args:list[str]) -> dict[str, str|bool]:
+    logger.info("spec=%r", spec)
+    job = spec_to_job(
+        spec,
+        key=key,
+        trackmem_symbol_names=trackmem_symbol_names,
+        ctest_args=ctest_args,
+    )
+    logger.info("job=%r", job)
+    platform = job.to_workflow(enable_artifacts=enable_artifacts)
+    logger.info("platform=%r", platform)
+    return platform
+
+
+def main():
+    parser = argparse.ArgumentParser(allow_abbrev=False)
+    parser.add_argument("--github-variable-prefix", default="platforms")
+    parser.add_argument("--github-ci", action="store_true")
+    parser.add_argument("--verbose", action="store_true")
+    parser.add_argument("--commit-message-file")
+    parser.add_argument("--no-artifact", dest="enable_artifacts", action="store_false")
+    parser.add_argument("--trackmem-symbol-names", dest="trackmem_symbol_names", action="store_true")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO if args.verbose else logging.WARNING)
+
+    remaining_keys = set(JOB_SPECS.keys())
+
+    all_level_keys = (
+        # Level 1
+        (
+            "haiku",
+        ),
+    )
+
+    filters = []
+    ctest_args = []
+    if args.commit_message_file:
+        with open(args.commit_message_file, "r") as f:
+            commit_message = f.read()
+            for m in re.finditer(r"\[sdl-ci-filter (.*)]", commit_message, flags=re.M):
+                filters.append(m.group(1).strip(" \t\n\r\t'\""))
+
+            if re.search(r"\[sdl-ci-artifacts?]", commit_message, flags=re.M):
+                args.enable_artifacts = True
+
+            if re.search(r"\[sdl-ci-(full-)?trackmem(-symbol-names)?]", commit_message, flags=re.M):
+                args.trackmem_symbol_names = True
+
+            for m in re.finditer(r"\[sdl-ci-ctest-args? (.*)]", commit_message, flags=re.M):
+                ctest_args.extend(shlex.split(m.group(1)))
+
+    if not filters:
+        filters.append("*")
+
+    logger.info("filters: %r", filters)
+
+    all_level_platforms = {}
+
+    all_platforms = {key: spec_to_platform(spec, key=key, enable_artifacts=args.enable_artifacts, trackmem_symbol_names=args.trackmem_symbol_names, ctest_args=ctest_args) for key, spec in JOB_SPECS.items()}
+
+    for level_i, level_keys in enumerate(all_level_keys, 1):
+        level_key = f"level{level_i}"
+        logger.info("Level %d: keys=%r", level_i, level_keys)
+        assert all(k in remaining_keys for k in level_keys)
+        level_platforms = tuple(all_platforms[key] for key in level_keys)
+        remaining_keys.difference_update(level_keys)
+        all_level_platforms[level_key] = level_platforms
+        logger.info("=" * 80)
+
+    logger.info("Keys before filter: %r", remaining_keys)
+
+    filtered_remaining_keys = set()
+    for filter in filters:
+        filtered_remaining_keys.update(fnmatch.filter(remaining_keys, filter))
+
+    logger.info("Keys after filter: %r", filtered_remaining_keys)
+
+    remaining_keys = filtered_remaining_keys
+
+    logger.info("Remaining: %r", remaining_keys)
+    all_level_platforms["others"] = tuple(all_platforms[key] for key in remaining_keys)
+
+    if args.github_ci:
+        for level, platforms in all_level_platforms.items():
+            platforms_json = json.dumps(platforms)
+            txt = f"{args.github_variable_prefix}-{level}={platforms_json}"
+            logger.info("%s", txt)
+            if "GITHUB_OUTPUT" in os.environ:
+                with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+                    f.write(txt)
+                    f.write("\n")
+            else:
+                logger.warning("GITHUB_OUTPUT not defined")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

external/SDL/.github/workflows/generic.yml

@@ -0,0 +1,441 @@
+name: 'Build'
+run-name: 'Configure, Build and Test SDL'
+
+on:
+  workflow_call:
+    inputs:
+      platforms:
+        description: 'JSON-encoded test properties'
+        type: string
+        required: true
+
+jobs:
+  build:
+    name: ${{ matrix.platform.name }}
+    runs-on: ${{ matrix.platform.os }}
+    container: ${{ matrix.platform.container }}
+    defaults:
+      run:
+        shell: ${{ matrix.platform.shell }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: ${{ fromJSON(inputs.platforms) }}
+    steps:
+      - name: 'Set up MSYS2'
+        if: ${{ matrix.platform.platform == 'msys2' }}
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.platform.msys2-msystem }}
+          install: ${{ matrix.platform.msys2-packages }}
+      - name: 'About this job'
+        run: |
+          echo "key=${{ matrix.platform.key }}"
+          echo "name=${{ matrix.platform.name }}"
+          echo "os=${{ matrix.platform.os }}"
+          echo ""
+          echo "Add [sdl-ci-filter ${{ matrix.platform.key }}] to your commit message to reduce the number of jobs."
+      - uses: actions/checkout@v6
+      - name: 'Set up ninja'
+        if: ${{ matrix.platform.setup-ninja }}
+        uses: ./.github/actions/setup-ninja
+      - name: 'Set up libusb for MSVC'
+        if: ${{ matrix.platform.setup-libusb-arch != '' }}
+        uses: ./.github/actions/setup-msvc-libusb
+        with:
+          arch: ${{ matrix.platform.setup-libusb-arch }}
+      - uses: mymindstorm/setup-emsdk@v15
+        if: ${{ matrix.platform.platform == 'emscripten' }}
+        with:
+          version: 3.1.35
+      - uses: browser-actions/setup-chrome@v2
+        id: setup-chrome
+        if: ${{ matrix.platform.platform == 'emscripten' }}
+        with:
+          install-chromedriver: true
+      - name: 'Add chrome to PATH'
+        if: ${{ matrix.platform.platform == 'emscripten' }}
+        run: |
+          chrome_dir="$(dirname "${{ steps.setup-chrome.outputs.chrome-path }}")"
+          chromedriver_dir="$(dirname "${{ steps.setup-chrome.outputs.chromedriver-path }}")"
+          echo "CHROME_BINARY=${{ steps.setup-chrome.outputs.chrome-path }}" >>$GITHUB_ENV
+          echo "CHROMEDRIVER_BINARY=${{ steps.setup-chrome.outputs.chromedriver-path }}" >>$GITHUB_ENV
+          echo "chrome_dir=${chrome_dir}"
+          echo "chromedriver_dir=${chromedriver_dir}"
+          echo "${chrome_dir}" >>${GITHUB_PATH}
+          echo "${chromedriver_dir}" >>${GITHUB_PATH}
+      - uses: nttld/setup-ndk@v1
+        if: ${{ matrix.platform.android-ndk }}
+        id: setup-ndk
+        with:
+          local-cache: false
+          ndk-version: r28c
+      - name: 'Configure Android NDK variables'
+        if: ${{ matrix.platform.android-ndk }}
+        shell: sh
+        run: |
+          # We cannot use GitHub expressions in the controller job
+          echo "ANDROID_NDK_HOME=${{ steps.setup-ndk.outputs.ndk-path }}" >>$GITHUB_ENV
+      - uses: actions/setup-java@v5
+        if: ${{ matrix.platform.java }}
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+      - uses: TheMrMilchmann/setup-msvc-dev@v4
+        if: ${{ matrix.platform.platform == 'msvc' }}
+        with:
+          arch: ${{ matrix.platform.msvc-vcvars-arch }}
+          sdk: ${{ matrix.platform.msvc-vcvars-sdk }}
+      - name: 'Set up Nokia N-Gage SDK'
+        uses: ./.github/actions/setup-ngage-sdk
+        if: ${{ matrix.platform.setup-ngage-sdk-path != '' }}
+        with:
+          path: '${{ matrix.platform.setup-ngage-sdk-path }}'
+      - name: 'Set up Windows GDK Desktop'
+        uses: ./.github/actions/setup-gdk-desktop
+        if: ${{ matrix.platform.setup-gdk-folder != '' }}
+        with:
+          folder: '${{ matrix.platform.setup-gdk-folder }}'
+      - name: 'Set up LoongArch64 toolchain'
+        uses: ./.github/actions/setup-loongarch64-toolchain
+        id: setup-loongarch64-toolchain
+        if: ${{ matrix.platform.platform == 'loongarch64' }}
+      - name: 'Set up DJGPP toolchain'
+        uses: ./.github/actions/setup-djgpp-toolchain
+        id: setup-djgpp-toolchain
+        if: ${{ matrix.platform.platform == 'djgpp' }}
+      - name: 'Setup Intel oneAPI toolchain'
+        id: intel
+        if: ${{ matrix.platform.intel }}
+        run: |
+          # Download the key to system keyring
+          wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB \
+            | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
+          
+          # Add signed entry to apt sources and configure the APT client to use Intel repository:
+          echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list
+          
+          # Update package list
+          sudo apt-get update -y
+          
+          # Install oneAPI
+          sudo apt-get install -y intel-oneapi-compiler-dpcpp-cpp-and-cpp-classic
+      - name: 'Install apk packages'
+        if: ${{ matrix.platform.apk-packages != '' }}
+        run: |
+          ${{ matrix.platform.sudo }} apk update
+          ${{ matrix.platform.sudo }} apk add ${{ matrix.platform.apk-packages }}
+      - name: 'Install apt packages'
+        if: ${{ matrix.platform.apt-packages != '' }}
+        run: |
+          ${{ matrix.platform.sudo }} apt-get update
+          ${{ matrix.platform.sudo }} apt-get install -y ${{ matrix.platform.apt-packages }}
+      - name: 'Install brew packages'
+        if: ${{ matrix.platform.brew-packages != '' }}
+        run: |
+          export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1
+          brew update
+          brew install ${{ matrix.platform.brew-packages }}
+      - name: 'Setup Python'
+        uses: 'actions/setup-python@main'
+        if: ${{ matrix.platform.setup-python }}
+        with:
+          python-version: '3.x'
+      - name: 'Install PyPI packages'
+        if: ${{ matrix.platform.pypi-packages != '' }}
+        run: |
+          python -m pip install --user ${{ matrix.platform.pypi-packages }}
+      - name: 'Set up GLES for VITA'  # Must be after apk
+        if: ${{ matrix.platform.setup-vita-gles-type != '' }}
+        uses: ./.github/actions/setup-vita-gles
+        with:
+          type: ${{ matrix.platform.setup-vita-gles-type }}
+
+      - name: 'Pollute toolchain with "bad" SDL headers'
+        if: ${{ matrix.platform.pollute-directories != '' }}
+        #shell: ${{ matrix.platform.shell }}
+        run: |
+          # Create "bad" SDL headers in the toolchain.
+          # SDL sources should not use these.
+          for include in ${{ matrix.platform.pollute-directories }}; do
+            toolchain_directory="${include}/SDL3"
+            echo "Creating directory ${toolchain_directory}"
+            mkdir -p "${toolchain_directory}/SDL3"
+            for header in include/SDL3/*.h; do
+              dest="${toolchain_directory}/SDL3/$(basename "${header}")"
+              echo "Creating ${dest}"
+              echo '#error "System SDL headers must not be used by build system"' >"$dest"
+            done
+          done
+
+      - name: 'Calculate ccache key'
+        if: ${{ matrix.platform.ccache }}
+        id: prepare-restore-ccache
+        run: |
+          echo "timestamp=$(date -u "+%Y%m%d%H%M_%S")" >> "$GITHUB_OUTPUT"
+      - name: 'Restore ccache'
+        if: ${{ matrix.platform.ccache }}
+        uses: actions/cache/restore@v5
+        id: restore-ccache
+        with:
+          path: ${{ runner.temp }}/ccache
+          key: ccache-${{ matrix.platform.key }}-${{ steps.prepare-restore-ccache.outputs.timestamp }}
+          restore-keys: |
+            ccache-${{matrix.platform.key}}
+      - name: 'Configure ccache'
+        if: ${{ matrix.platform.ccache }}
+        run: |
+          echo 'CCACHE_DIR=${{ runner.temp }}/ccache' >>${GITHUB_ENV}
+      - name: 'Prepare ccache'
+        if: ${{ matrix.platform.ccache && steps.restore-ccache.outputs.cache-hit }}
+        run: |
+          if [ "x${{ runner.os }}" = "xmacOS" ]; then
+            touch_date="2025-02-01T12:00:00Z"
+          else
+            touch_date="2025-02-01"
+          fi
+          find "${CCACHE_DIR}" -type f -exec touch -a -m -d "$touch_date" {} +
+          ccache -s
+          ccache -z
+
+      - name: 'Configure (CMake)'
+        if: ${{ !matrix.platform.no-cmake }}
+        #shell: ${{ matrix.platform.shell }}
+        run: |
+          ${{ matrix.platform.source-cmd }}
+          ${{ matrix.platform.cmake-config-emulator }} cmake -S . -B build -G "${{ matrix.platform.cmake-generator }}" \
+            -Wdeprecated -Wdev -Werror \
+            ${{ matrix.platform.cmake-toolchain-file != '' && format('-DCMAKE_TOOLCHAIN_FILE={0}', matrix.platform.cmake-toolchain-file) || '' }} \
+            -DSDL_WERROR=${{ matrix.platform.werror }} \
+            -DSDL_EXAMPLES=${{ matrix.platform.build-tests }} \
+            -DSDL_TESTS=${{ matrix.platform.build-tests }} \
+            -DSDLTEST_TRACKMEM=ON \
+            -DSDL_INSTALL_TESTS=${{ matrix.platform.build-tests }} \
+            -DSDL_CLANG_TIDY=${{ matrix.platform.clang-tidy }} \
+            -DSDL_INSTALL_DOCS=ON \
+            -DSDL_INSTALL_CPACK=ON \
+            -DSDL_INSTALL_DOCS=ON \
+            ${{ matrix.platform.cmake-arguments }} \
+            -DSDL_SHARED=${{ matrix.platform.shared }} \
+            -DSDL_STATIC=${{ matrix.platform.static  }} \
+            -DSDL_VENDOR_INFO="Github Workflow" \
+            -DCMAKE_INSTALL_PREFIX=prefix \
+            -DCMAKE_INSTALL_LIBDIR=lib \
+            -DCMAKE_BUILD_TYPE=${{ matrix.platform.cmake-build-type }}
+      - name: 'Build (CMake)'
+        id: build
+        if: ${{ !matrix.platform.no-cmake }}
+#        shell: ${{ matrix.platform.shell }}
+        run: |
+          ${{ matrix.platform.source-cmd }}
+          cmake --build build --config ${{ matrix.platform.cmake-build-type }} --verbose -- ${{ matrix.platform.cmake-build-arguments }}
+      - name: 'Verify SDL_REVISION'
+        if: ${{ !matrix.platform.no-cmake }}
+        run: |
+          echo "This should show us the SDL_REVISION"
+          echo "Shared library:"
+          ${{ (matrix.platform.shared-lib && format('{0} build/{1} | grep "Github Workflow"', matrix.platform.binutils-strings, matrix.platform.shared-lib)) || 'echo "<Shared library not supported by platform>"' }}
+          echo "Static library:"
+          ${{ (matrix.platform.static-lib && format('{0} build/{1} | grep "Github Workflow"', matrix.platform.binutils-strings, matrix.platform.static-lib)) || 'echo "<Static library not supported by platform>"' }}
+      - name: 'Run build-time tests (CMake)'
+        id: tests
+        if: ${{ !matrix.platform.no-cmake && matrix.platform.run-tests }}
+#        shell: ${{ matrix.platform.shell }}
+        run: |
+          ${{ matrix.platform.source-cmd }}
+          ${{ matrix.platform.pretest-cmd }}
+          set -eu
+          export SDL_TESTS_QUICK=1
+          ctest --test-dir build/ ${{ matrix.platform.ctest-args || '-VV -j2' }}
+      - name: "Build test apk's (CMake)"
+        id: apks
+        if: ${{ always() && steps.build.outcome == 'success' && matrix.platform.android-apks != '' }}
+#        shell: ${{ matrix.platform.shell }}
+        run: |
+          ${{ matrix.platform.source-cmd }}
+          cmake --build build --config ${{ matrix.platform.cmake-build-type }} \
+            --target \
+              ${{ matrix.platform.android-apks }} \
+            --verbose \
+            -- ${{ matrix.platform.cmake-build-arguments }}
+      - name: 'Install (CMake)'
+        id: install
+        if: ${{ always() && steps.build.outcome == 'success' }}
+#        shell: ${{ matrix.platform.shell }}
+        run: |
+          ${{ matrix.platform.source-cmd }}
+          cmake --install build --config ${{ matrix.platform.cmake-build-type }}
+          echo "prefix=$(pwd)/prefix" >> $GITHUB_OUTPUT
+          ( cd prefix; find . ) | LC_ALL=C sort -u
+      - name: 'Package (CPack)'
+        id: package
+        if: ${{ always() && steps.build.outcome == 'success' }}
+#        shell: ${{ matrix.platform.shell }}
+        run: |
+          # DMG creation on macOS occasionally fails, so try multiple times
+          # https://gitlab.kitware.com/cmake/cmake/-/issues/25671
+          success=0
+          max_tries=10
+          for i in $(seq $max_tries); do
+           cmake --build build/ --config ${{ matrix.platform.cmake-build-type }} --target package -- ${{ matrix.platform.cmake-build-arguments }} && success=1
+           if test $success = 1; then
+            break
+           fi
+           echo "Package creation failed. Sleep 1 second and try again."
+           sleep 1
+          done
+          if test $success = 0; then
+           echo "Package creation failed after $max_tries attempts."
+           exit 1
+          fi
+      - name: 'Verify CMake configuration files'
+        if: ${{ steps.install.outcome == 'success' }}
+#        shell: ${{ matrix.platform.shell }}
+        run: |
+          ${{ matrix.platform.source-cmd }}
+          ${{ matrix.platform.cmake-config-emulator }} cmake -S cmake/test -B cmake_test_build -GNinja \
+            ${{ matrix.platform.cmake-toolchain-file != '' && format('-DCMAKE_TOOLCHAIN_FILE={0}', matrix.platform.cmake-toolchain-file) || '' }} \
+            -DTEST_SHARED=${{ matrix.platform.shared }} \
+            -DTEST_STATIC=${{ matrix.platform.static }} \
+            ${{ matrix.platform.cmake-arguments }} \
+            -DCMAKE_BUILD_TYPE=${{ matrix.platform.cmake-build-type }} \
+            -DCMAKE_PREFIX_PATH="${{ steps.install.outputs.prefix }}"
+          cmake --build cmake_test_build --verbose --config ${{ matrix.platform.cmake-build-type }} -- ${{ matrix.platform.cmake-build-arguments }}
+      - name: 'Extract CC/CXX/CFLAGS/CXXFLAGS from CMake toolchain'
+        if: ${{ steps.install.outcome == 'success' && matrix.platform.cc-from-cmake }}
+#        shell: ${{ matrix.platform.shell }}
+        run: |
+          cmake -S .github/cmake -B /tmp/cmake_extract \
+            ${{ matrix.platform.cmake-toolchain-file != '' && format('-DCMAKE_TOOLCHAIN_FILE={0}', matrix.platform.cmake-toolchain-file) || '' }} \
+            -DCMAKE_BUILD_TYPE=${{ matrix.platform.cmake-build-type }} \
+            -DVAR_PATH=/tmp/env.txt
+          cat /tmp/env.txt >> $GITHUB_ENV
+      - name: 'Verify sdl3.pc'
+#        shell: ${{ matrix.platform.shell }}
+        if: ${{ steps.install.outcome == 'success' && matrix.platform.test-pkg-config }}
+        run: |
+          ${{ matrix.platform.source-cmd }}
+          ${{ matrix.platform.cc && format('export CC="{0}"', matrix.platform.cc) || '' }}
+          ${{ matrix.platform.cflags && format('export CFLAGS="{0}"', matrix.platform.cflags) || '' }}
+          ${{ matrix.platform.ldflags && format('export LDFLAGS="{0}"', matrix.platform.ldflags) || '' }}
+          export PKG_CONFIG_PATH=${{ steps.install.outputs.prefix }}/lib/pkgconfig
+          cmake/test/test_pkgconfig.sh
+      - name: 'Build (cross-platform-actions, BSD)'
+        id: cpactions
+        if: ${{ matrix.platform.cpactions }}
+        uses: cross-platform-actions/action@v1
+        with:
+          operating_system: '${{ matrix.platform.cpactions-os }}'
+          architecture: '${{ matrix.platform.cpactions-arch }}'
+          version: '${{ matrix.platform.cpactions-version }}'
+          run: |
+            ${{ matrix.platform.cpactions-setup-cmd }}
+            ${{ matrix.platform.cpactions-install-cmd }}
+            cmake -S . -B build -GNinja  \
+              ${{ matrix.platform.cmake-toolchain-file != '' && format('-DCMAKE_TOOLCHAIN_FILE={0}', matrix.platform.cmake-toolchain-file) || '' }} \
+              -Wdeprecated -Wdev -Werror \
+              -DSDL_WERROR=${{ matrix.platform.werror }} \
+              -DSDL_INSTALL_DOCS=ON \
+              ${{ matrix.platform.cmake-arguments }} \
+              -DSDL_SHARED=${{ matrix.platform.shared }} \
+              -DSDL_STATIC=${{ matrix.platform.static  }} \
+              -DSDL_VENDOR_INFO="Github Workflow" \
+              -DCMAKE_INSTALL_PREFIX=prefix \
+              -DCMAKE_INSTALL_LIBDIR=lib \
+              -DCMAKE_BUILD_TYPE=${{ matrix.platform.cmake-build-type }}
+            cmake --build build/ --config ${{ matrix.platform.cmake-build-type }} --verbose
+            cmake --build build/ --config ${{ matrix.platform.cmake-build-type }} --target package
+
+            cmake --build build/ --config ${{ matrix.platform.cmake-build-type }} --target clean
+            rm -rf build/dist/_CPack_Packages
+            rm -rf build/CMakeFiles
+            rm -rf build/docs
+      - name: Add msbuild to PATH
+        id: setup-msbuild
+        if: ${{ matrix.platform.msvc-project != '' }}
+        uses: microsoft/setup-msbuild@v3
+      - name: Build msbuild
+        if: ${{ matrix.platform.msvc-project != '' }}
+        run: |
+          "$(cygpath -u '${{ steps.setup-msbuild.outputs.msbuildPath }}\msbuild.exe')" ${{ matrix.platform.msvc-project }} -m -p:BuildInParallel=true -p:Configuration=Release ${{ matrix.platform.msvc-project-flags }}
+      - name: 'Build (Android.mk)'
+        if: ${{ matrix.platform.android-mk }}
+        run: |
+          ./build-scripts/androidbuildlibs.sh
+      - name: 'Create Gradle project (Android)'
+        if: ${{ matrix.platform.android-gradle }}
+        run: |
+          for folder in build-ndk-build build-cmake; do
+            python build-scripts/create-android-project.py \
+              --output "${folder}" \
+              --variant copy \
+              org.libsdl.testspriteminimal \
+              test/testspriteminimal.c test/icon.h
+          done
+          echo ""
+          echo "Project contents:"
+          echo ""
+          find "build-ndk-build/org.libsdl.testspriteminimal"
+      - name: 'Build Android app (Gradle & ndk-build)'
+        if: ${{ matrix.platform.android-gradle }}
+        run: |
+          cd build-ndk-build/org.libsdl.testspriteminimal
+          ./gradlew -i assembleRelease
+      - name: 'Build Android app (Gradle & CMake)'
+        if: ${{ matrix.platform.android-gradle }}
+        run: |
+          cd build-cmake/org.libsdl.testspriteminimal
+          ./gradlew -i assembleRelease -PBUILD_WITH_CMAKE=1
+      - name: 'Build (xcode)'
+        if: ${{ matrix.platform.xcode-sdk != '' }}
+        run: |
+          xcodebuild -project Xcode/SDL/SDL.xcodeproj -target SDL3 -configuration Release -sdk ${{ matrix.platform.xcode-sdk }} clean build
+      - name: 'Prune old ccache files'
+        if: ${{ matrix.platform.ccache }}
+        run: |
+          ccache --evict-older-than=1d
+          ccache -s
+      - name: 'Save ccache'
+        if: ${{ matrix.platform.ccache }}
+        uses: actions/cache/save@v5
+        with:
+          path: ${{ runner.temp }}/ccache
+          key: ${{ steps.restore-ccache.outputs.cache-primary-key }}
+      - name: 'Check Sources'
+        if: ${{ matrix.platform.check-sources }}
+        run: |
+          set -e
+          build-scripts/test-versioning.sh
+          python build-scripts/check_android_jni.py
+          python build-scripts/check_stdlib_usage.py
+      - name: 'Verify alignment of Android test apks'
+        if: ${{ matrix.platform.android-ndk && !matrix.platform.no-cmake }}
+        run: |
+          find ./ -iname '*.apk' | xargs -L1 ./build-scripts/check_elf_alignment.sh
+      - name: 'Verify alignment of Android .so files'
+        if: ${{ matrix.platform.android-ndk && !matrix.platform.no-cmake }}
+        run: |
+          find ./ -iname '*.so' | xargs -L1 ./build-scripts/check_elf_alignment.sh
+      - name: 'Upload binary package'
+        uses: actions/upload-artifact@v7
+        if: ${{ always() && matrix.platform.artifact != '' && (steps.package.outcome == 'success' || steps.cpactions.outcome == 'success') && (matrix.platform.enable-artifacts || steps.tests.outcome == 'failure') }}
+        with:
+          if-no-files-found: error
+          name: '${{ matrix.platform.artifact }}'
+          path: |
+            build/dist/SDL3*
+            build/include*
+      - name: 'Upload minidumps'
+        uses: actions/upload-artifact@v7
+        if: ${{ always() && steps.tests.outcome == 'failure' && (matrix.platform.platform == 'msvc' || matrix.platform.platform == 'msys2') }}
+        with:
+          if-no-files-found: ignore
+          name: '${{ matrix.platform.artifact }}-minidumps'
+          path: build/**/*.dmp
+      - name: "Upload Android test apk's"
+        uses: actions/upload-artifact@v7
+        if: ${{ matrix.platform.enable-artifacts && always() && matrix.platform.artifact != '' && steps.apks.outcome == 'success' }}
+        with:
+          if-no-files-found: error
+          name: '${{ matrix.platform.artifact }}-apks'
+          path: build/test/*.apk

external/SDL/.github/workflows/release.yml

@@ -0,0 +1,720 @@
+name: 'release'
+run-name: 'Create SDL release artifacts for ${{ inputs.commit }}'
+
+on:
+  workflow_dispatch:
+    inputs:
+      commit:
+        description: 'Commit of SDL'
+        required: true
+
+jobs:
+
+  src:
+    runs-on: ubuntu-latest
+    outputs:
+      project: ${{ steps.releaser.outputs.project }}
+      version: ${{ steps.releaser.outputs.version }}
+      src-tar-gz: ${{ steps.releaser.outputs.src-tar-gz }}
+      src-tar-xz: ${{ steps.releaser.outputs.src-tar-xz }}
+      src-zip: ${{ steps.releaser.outputs.src-zip }}
+    steps:
+      - name: 'Set up Python'
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: 'build-scripts/build-release.py'
+      - name: 'Set up SDL sources'
+        uses: actions/checkout@v6
+        with:
+          path: 'SDL'
+          fetch-depth: 0
+      - name: 'Build Source archive'
+        id: releaser
+        shell: bash
+        run: |
+          python build-scripts/build-release.py \
+            --actions source \
+            --commit ${{ inputs.commit }} \
+            --root "${{ github.workspace }}/SDL" \
+            --github \
+            --debug
+      - name: 'Store source archives'
+        uses: actions/upload-artifact@v7
+        with:
+          name: sources
+          path: '${{ github.workspace}}/dist'
+      - name: 'Generate summary'
+        run: |
+          echo "Run the following commands to download all artifacts:" >> $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          echo "mkdir -p /tmp/${{ steps.releaser.outputs.project }}-${{ steps.releaser.outputs.version }}" >> $GITHUB_STEP_SUMMARY
+          echo "cd /tmp/${{ steps.releaser.outputs.project }}-${{ steps.releaser.outputs.version }}" >> $GITHUB_STEP_SUMMARY
+          echo "gh run -R ${{ github.repository }} download ${{ github.run_id }}" >> $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+
+  linux-verify:
+    needs: [src]
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Unzip ${{ needs.src.outputs.src-zip }}'
+        id: zip
+        run: |
+          mkdir /tmp/zipdir
+          cd /tmp/zipdir
+          unzip "${{ github.workspace }}/${{ needs.src.outputs.src-zip }}"
+          echo "path=/tmp/zipdir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'Untar ${{ needs.src.outputs.src-tar-gz }}'
+        id: tar
+        run: |
+          mkdir -p /tmp/tardir
+          tar -C /tmp/tardir -v -x -f "${{ github.workspace }}/${{ needs.src.outputs.src-tar-gz }}"
+          echo "path=/tmp/tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'Compare contents of ${{ needs.src.outputs.src-zip }} and  ${{ needs.src.outputs.src-tar-gz }}'
+        run: |
+          diff /tmp/zipdir /tmp/tardir
+      - name: 'Test versioning'
+        shell: bash
+        run: |
+          ${{ steps.tar.outputs.path }}/build-scripts/test-versioning.sh
+      - name: 'Install Linux dependencies'
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y \
+            gnome-desktop-testing libasound2-dev libpulse-dev libaudio-dev libjack-dev libsndio-dev \
+            libusb-1.0-0-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev \
+            libxss-dev libxtst-dev libwayland-dev libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev \
+            libgles2-mesa-dev libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev
+      - name: 'CMake (configure + build + tests + examples)'
+        run: |
+          set -e
+          cmake -S ${{ steps.tar.outputs.path }} -B /tmp/build -DSDL_TEST_LIBRARY=TRUE -DSDL_TESTS=TRUE -DSDL_EXAMPLES=TRUE
+          cmake --build /tmp/build --verbose
+          ctest --test-dir /tmp/build --no-tests=error --output-on-failure
+      - name: 'Verify SDL_REVISION contains SDL-'
+        run: |
+          set -e
+          if test "x$(strings /tmp/build/libSDL3.so.0 | grep SDL- | wc -l)" != x1; then
+            echo "SDL- string not found: must be present in SDL_REVISION"
+            exit 1
+          fi
+
+  dmg:
+    needs: [src]
+    runs-on: macos-latest
+    outputs:
+      dmg: ${{ steps.releaser.outputs.dmg }}
+    steps:
+      - name: 'Set up Python'
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: 'build-scripts/build-release.py'
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Untar ${{ needs.src.outputs.src-tar-gz }}'
+        id: tar
+        run: |
+          mkdir -p "${{ github.workspace }}/tardir"
+          tar -C "${{ github.workspace }}/tardir" -v -x -f "${{ github.workspace }}/${{ needs.src.outputs.src-tar-gz }}"
+          echo "path=${{ github.workspace }}/tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'Build SDL3.dmg'
+        id: releaser
+        shell: bash
+        run: |
+          python build-scripts/build-release.py \
+            --actions dmg \
+            --commit ${{ inputs.commit }} \
+            --root "${{ steps.tar.outputs.path }}" \
+            --github \
+            --debug
+      - name: 'Store DMG image file'
+        uses: actions/upload-artifact@v7
+        with:
+          name: dmg
+          path: '${{ github.workspace }}/dist'
+
+  dmg-verify:
+    needs: [dmg, src]
+    runs-on: macos-latest
+    steps:
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Download ${{ needs.dmg.outputs.dmg }}'
+        uses: actions/download-artifact@v8
+        with:
+          name: dmg
+          path: '${{ github.workspace }}'
+      - name: 'Untar ${{ needs.src.outputs.src-tar-gz }}'
+        id: src
+        run: |
+          mkdir -p /tmp/tardir
+          tar -C /tmp/tardir -v -x -f "${{ github.workspace }}/${{ needs.src.outputs.src-tar-gz }}"
+          echo "path=/tmp/tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'Mount ${{ needs.dmg.outputs.dmg }}'
+        id: mount
+        run: |
+          hdiutil attach '${{ github.workspace }}/${{ needs.dmg.outputs.dmg }}'
+          mount_point="/Volumes/${{ needs.src.outputs.project }}"
+          if [ ! -d "$mount_point/${{ needs.src.outputs.project }}.xcframework" ]; then
+            echo "Cannot find ${{ needs.src.outputs.project }}.xcframework!"
+            exit 1
+          fi
+          echo "mount_point=$mount_point">>$GITHUB_OUTPUT
+      - name: 'CMake (configure + build) Darwin'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"               \
+              -DTEST_FULL=FALSE                                             \
+              -DTEST_STATIC=FALSE                                           \
+              -DTEST_TEST=FALSE                                             \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}"  \
+              -DCMAKE_SYSTEM_NAME=Darwin                                    \
+              -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"                      \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13                           \
+              -Werror=dev                                                   \
+              -B build_darwin
+          cmake --build build_darwin --config Release --verbose
+
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                                   \
+              -DTEST_FULL=FALSE                                                                                 \
+              -DTEST_STATIC=FALSE                                                                               \
+              -DTEST_TEST=FALSE                                                                                 \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}/SDL3.xcframework/macos-arm64_x86_64"  \
+              -DCMAKE_SYSTEM_NAME=Darwin                                                                        \
+              -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"                                                          \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13                                                               \
+              -Werror=dev                                                                                       \
+              -B build_darwin_2
+          cmake --build build_darwin --config Release --verbose
+      - name: 'CMake (configure + build) iOS'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"               \
+              -DTEST_FULL=FALSE                                             \
+              -DTEST_STATIC=FALSE                                           \
+              -DTEST_TEST=FALSE                                             \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}"  \
+              -DCMAKE_SYSTEM_NAME=iOS                                       \
+              -DCMAKE_OSX_ARCHITECTURES="arm64"                             \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0                            \
+              -Werror=dev                                                   \
+              -B build_ios
+          cmake --build build_ios --config Release --verbose
+
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                          \
+              -DTEST_FULL=FALSE                                                                        \
+              -DTEST_STATIC=FALSE                                                                      \
+              -DTEST_TEST=FALSE                                                                        \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}/SDL3.xcframework/ios-arm64"  \
+              -DCMAKE_SYSTEM_NAME=iOS                                                                  \
+              -DCMAKE_OSX_ARCHITECTURES="arm64"                                                        \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0                                                       \
+              -Werror=dev                                                                              \
+              -B build_ios2
+          cmake --build build_ios2 --config Release --verbose
+      - name: 'CMake (configure + build) tvOS'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"               \
+              -DTEST_FULL=FALSE                                             \
+              -DTEST_STATIC=FALSE                                           \
+              -DTEST_TEST=FALSE                                             \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}"  \
+              -DCMAKE_SYSTEM_NAME=tvOS                                      \
+              -DCMAKE_OSX_ARCHITECTURES="arm64"                             \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0                            \
+              -Werror=dev                                                   \
+              -B build_tvos
+          cmake --build build_tvos --config Release --verbose
+
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                          \
+              -DTEST_FULL=FALSE                                                                        \
+              -DTEST_STATIC=FALSE                                                                      \
+              -DTEST_TEST=FALSE                                                                        \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}/SDL3.xcframework/tvos-arm64" \
+              -DCMAKE_SYSTEM_NAME=tvOS                                                                 \
+              -DCMAKE_OSX_ARCHITECTURES="arm64"                                                        \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0                                                       \
+              -Werror=dev                                                                              \
+              -B build_tvos2
+          cmake --build build_tvos2 --config Release --verbose
+      - name: 'CMake (configure + build) iOS simulator'
+        run: |
+          sysroot=$(xcodebuild -version -sdk iphonesimulator Path)
+          echo "sysroot=$sysroot"
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"               \
+              -DTEST_FULL=FALSE                                             \
+              -DTEST_STATIC=FALSE                                           \
+              -DTEST_TEST=FALSE                                             \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}"  \
+              -DCMAKE_SYSTEM_NAME=iOS                                       \
+              -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"                      \
+              -DCMAKE_OSX_SYSROOT="${sysroot}"                              \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0                            \
+              -Werror=dev                                                   \
+              -B build_ios_simulator
+          cmake --build build_ios_simulator --config Release --verbose
+
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                                          \
+              -DTEST_FULL=FALSE                                                                                        \
+              -DTEST_STATIC=FALSE                                                                                      \
+              -DTEST_TEST=FALSE                                                                                        \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}/SDL3.xcframework/ios-arm64_x86_64-simulator" \
+              -DCMAKE_SYSTEM_NAME=iOS                                                                                  \
+              -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"                                                                 \
+              -DCMAKE_OSX_SYSROOT="${sysroot}"                                                                         \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0                                                                       \
+              -Werror=dev                                                                                              \
+              -B build_ios_simulator2
+          cmake --build build_ios_simulator2 --config Release --verbose
+      - name: 'CMake (configure + build) tvOS simulator'
+        run: |
+          sysroot=$(xcodebuild -version -sdk appletvsimulator Path)
+          echo "sysroot=$sysroot"
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"               \
+              -DTEST_FULL=FALSE                                             \
+              -DTEST_STATIC=FALSE                                           \
+              -DTEST_TEST=FALSE                                             \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}"  \
+              -DCMAKE_SYSTEM_NAME=tvOS                                      \
+              -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"                      \
+              -DCMAKE_OSX_SYSROOT="${sysroot}"                              \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0                            \
+              -Werror=dev                                                   \
+              -B build_tvos_simulator
+          cmake --build build_tvos_simulator --config Release --verbose
+
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                                           \
+              -DTEST_FULL=FALSE                                                                                         \
+              -DTEST_STATIC=FALSE                                                                                       \
+              -DTEST_TEST=FALSE                                                                                         \
+              -DCMAKE_PREFIX_PATH="${{ steps.mount.outputs.mount_point }}/SDL3.xcframework/tvos-arm64_x86_64-simulator" \
+              -DCMAKE_SYSTEM_NAME=tvOS                                                                                  \
+              -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"                                                                  \
+              -DCMAKE_OSX_SYSROOT="${sysroot}"                                                                          \
+              -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0                                                                        \
+              -Werror=dev                                                                                               \
+              -B build_tvos_simulator2
+          cmake --build build_tvos_simulator2 --config Release --verbose
+
+  msvc:
+    needs: [src]
+    runs-on: windows-2025
+    outputs:
+      VC-x86: ${{ steps.releaser.outputs.VC-x86 }}
+      VC-x64: ${{ steps.releaser.outputs.VC-x64 }}
+      VC-arm64: ${{ steps.releaser.outputs.VC-arm64 }}
+      VC-devel: ${{ steps.releaser.outputs.VC-devel }}
+    steps:
+      - name: 'Set up Python'
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: 'build-scripts/build-release.py'
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Unzip ${{ needs.src.outputs.src-zip }}'
+        id: zip
+        run: |
+          New-Item C:\temp -ItemType Directory -ErrorAction SilentlyContinue
+          cd C:\temp
+          unzip "${{ github.workspace }}/${{ needs.src.outputs.src-zip }}"
+          echo "path=C:\temp\${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$Env:GITHUB_OUTPUT
+      - name: 'Build MSVC binary archives'
+        id: releaser
+        run: |
+          python build-scripts/build-release.py `
+            --actions msvc `
+            --commit ${{ inputs.commit }} `
+            --root "${{ steps.zip.outputs.path }}" `
+            --github `
+            --debug
+      - name: 'Store MSVC archives'
+        uses: actions/upload-artifact@v7
+        with:
+          name: win32
+          path: '${{ github.workspace }}/dist'
+
+  msvc-verify:
+    needs: [msvc, src]
+    runs-on: windows-latest
+    steps:
+      - name: 'Fetch .github/actions/setup-ninja/action.yml'
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: '.github/actions/setup-ninja/action.yml'
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Download MSVC binaries'
+        uses: actions/download-artifact@v8
+        with:
+          name: win32
+          path: '${{ github.workspace }}'
+      - name: 'Unzip ${{ needs.src.outputs.src-zip }}'
+        id: src
+        run: |
+          mkdir '${{ github.workspace }}/sources'
+          cd '${{ github.workspace }}/sources'
+          unzip "${{ github.workspace }}/${{ needs.src.outputs.src-zip }}"
+          echo "path=${{ github.workspace }}/sources/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$env:GITHUB_OUTPUT
+      - name: 'Unzip ${{ needs.msvc.outputs.VC-devel }}'
+        id: bin
+        run: |
+          mkdir '${{ github.workspace }}/vc'
+          cd '${{ github.workspace }}/vc'
+          unzip "${{ github.workspace }}/${{ needs.msvc.outputs.VC-devel }}"
+          echo "path=${{ github.workspace }}/vc/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$env:GITHUB_OUTPUT
+      - name: Set up ninja
+        uses: ./.github/actions/setup-ninja
+      - name: 'Configure vcvars x86'
+        uses: TheMrMilchmann/setup-msvc-dev@v4
+        with:
+          arch: x64_x86
+      - name: 'CMake (configure + build + tests) x86'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"     `
+              -B build_x86                                        `
+              -GNinja                                             `
+              -DCMAKE_BUILD_TYPE=Debug                            `
+              -Werror=dev                                         `
+              -DTEST_FULL=TRUE                                    `
+              -DTEST_STATIC=FALSE                                 `
+              -DTEST_SHARED=TRUE                                  `
+              -DTEST_TEST=TRUE                                    `
+              -DCMAKE_SUPPRESS_REGENERATION=TRUE                  `
+              -DCMAKE_PREFIX_PATH="${{ steps.bin.outputs.path }}"
+          Start-Sleep -Seconds 2
+          cmake --build build_x86 --config Release --verbose
+          ctest --test-dir build_x86 --no-tests=error -C Release --output-on-failure
+      - name: 'Configure vcvars x64'
+        uses: TheMrMilchmann/setup-msvc-dev@v4
+        with:
+          arch: x64
+      - name: 'CMake (configure + build + tests) x64'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"     `
+              -B build_x64                                        `
+              -GNinja                                             `
+              -DCMAKE_BUILD_TYPE=Debug                            `
+              -Werror=dev                                         `
+              -DTEST_FULL=TRUE                                    `
+              -DTEST_STATIC=FALSE                                 `
+              -DTEST_SHARED=TRUE                                  `
+              -DTEST_TEST=TRUE                                    `
+              -DCMAKE_SUPPRESS_REGENERATION=TRUE                  `
+              -DCMAKE_PREFIX_PATH="${{ steps.bin.outputs.path }}"
+          Start-Sleep -Seconds 2
+          cmake --build build_x64 --config Release --verbose
+          ctest --test-dir build_x64 --no-tests=error -C Release --output-on-failure
+      - name: 'Configure vcvars arm64'
+        uses: TheMrMilchmann/setup-msvc-dev@v4
+        with:
+          arch: x64_arm64
+      - name: 'CMake (configure + build) arm64'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"     `
+              -B build_arm64                                      `
+              -GNinja                                             `
+              -DCMAKE_BUILD_TYPE=Debug                            `
+              -Werror=dev                                         `
+              -DTEST_FULL=TRUE                                    `
+              -DTEST_STATIC=FALSE                                 `
+              -DTEST_SHARED=TRUE                                  `
+              -DTEST_TEST=TRUE                                    `
+              -DCMAKE_SUPPRESS_REGENERATION=TRUE                  `
+              -DCMAKE_PREFIX_PATH="${{ steps.bin.outputs.path }}"
+          Start-Sleep -Seconds 2
+          cmake --build build_arm64 --config Release --verbose
+      - name: 'CMake (configure + build) arm64ec'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"     `
+              -B build_arm64ec                                    `
+              -GNinja                                             `
+              -DCMAKE_BUILD_TYPE=Debug                            `
+              -Werror=dev                                         `
+              -DTEST_FULL=TRUE                                    `
+              -DTEST_STATIC=FALSE                                 `
+              -DTEST_SHARED=TRUE                                  `
+              -DTEST_TEST=TRUE                                    `
+              -DSDL_DISABLE_AVX=TRUE                              `
+              -DSDL_DISABLE_AVX2=TRUE                             `
+              -DSDL_DISABLE_AVX512F=TRUE                          `
+              -DCMAKE_SUPPRESS_REGENERATION=TRUE                  `
+              -DCMAKE_C_FLAGS="/arm64EC" `
+              -DCMAKE_CXX_FLAGS="/arm64EC" `
+              -DCMAKE_EXE_LINKER_FLAGS="/MACHINE:ARM64EC"         `
+              -DCMAKE_SHARED_LINKER_FLAGS="/MACHINE:ARM64EC"      `
+              -DCMAKE_STATIC_LINKER_FLAGS="/MACHINE:ARM64EC"      `
+              -DCMAKE_PREFIX_PATH="${{ steps.bin.outputs.path }}"
+          Start-Sleep -Seconds 2
+          cmake --build build_arm64ec --config Release --verbose
+
+  mingw:
+    needs: [src]
+    runs-on: ubuntu-24.04  # FIXME: current ubuntu-latest ships an outdated mingw, replace with ubuntu-latest once 24.04 becomes the new default
+    outputs:
+      mingw-devel-tar-gz: ${{ steps.releaser.outputs.mingw-devel-tar-gz }}
+      mingw-devel-tar-xz: ${{ steps.releaser.outputs.mingw-devel-tar-xz }}
+    steps:
+      - name: 'Set up Python'
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: 'build-scripts/build-release.py'
+      - name: 'Install Mingw toolchain'
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y gcc-mingw-w64 g++-mingw-w64 ninja-build
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Untar ${{ needs.src.outputs.src-tar-gz }}'
+        id: tar
+        run: |
+          mkdir -p /tmp/tardir
+          tar -C /tmp/tardir -v -x -f "${{ github.workspace }}/${{ needs.src.outputs.src-tar-gz }}"
+          echo "path=/tmp/tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'Build MinGW binary archives'
+        id: releaser
+        run: |
+          python build-scripts/build-release.py \
+            --actions mingw \
+            --commit ${{ inputs.commit }} \
+            --root "${{ steps.tar.outputs.path }}" \
+            --github \
+            --debug
+      - name: 'Store MinGW archives'
+        uses: actions/upload-artifact@v7
+        with:
+          name: mingw
+          path: '${{ github.workspace }}/dist'
+
+  mingw-verify:
+    needs: [mingw, src]
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Install Mingw toolchain'
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y gcc-mingw-w64 g++-mingw-w64 ninja-build
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Download MinGW binaries'
+        uses: actions/download-artifact@v8
+        with:
+          name: mingw
+          path: '${{ github.workspace }}'
+      - name: 'Untar ${{ needs.src.outputs.src-tar-gz }}'
+        id: src
+        run: |
+          mkdir -p /tmp/tardir
+          tar -C /tmp/tardir -v -x -f "${{ github.workspace }}/${{ needs.src.outputs.src-tar-gz }}"
+          echo "path=/tmp/tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'Untar ${{ needs.mingw.outputs.mingw-devel-tar-gz }}'
+        id: bin
+        run: |
+          mkdir -p /tmp/mingw-tardir
+          tar -C /tmp/mingw-tardir -v -x -f "${{ github.workspace }}/${{ needs.mingw.outputs.mingw-devel-tar-gz }}"
+          echo "path=/tmp/mingw-tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'CMake (configure + build) i686'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                                           \
+              -DCMAKE_BUILD_TYPE="Release"                                                                              \
+              -DTEST_FULL=TRUE                                                                                          \
+              -DTEST_STATIC=FALSE                                                                                       \
+              -DTEST_TEST=TRUE                                                                                          \
+              -DCMAKE_PREFIX_PATH="${{ steps.bin.outputs.path }}"                                                       \
+              -DCMAKE_TOOLCHAIN_FILE="${{ steps.src.outputs.path }}/build-scripts/cmake-toolchain-mingw64-i686.cmake"   \
+              -DCMAKE_C_FLAGS="-DSDL_DISABLE_SSE4_2"                                                                    \
+              -Werror=dev                                                                                               \
+              -B build_x86
+          cmake --build build_x86 --config Release --verbose
+      - name: 'CMake (configure + build) x86_64'
+        run: |
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                                           \
+              -DCMAKE_BUILD_TYPE="Release"                                                                              \
+              -DTEST_FULL=TRUE                                                                                          \
+              -DTEST_STATIC=false                                                                                       \
+              -DTEST_TEST=TRUE                                                                                          \
+              -DCMAKE_PREFIX_PATH="${{ steps.bin.outputs.path }}"                                                       \
+              -DCMAKE_TOOLCHAIN_FILE="${{ steps.src.outputs.path }}/build-scripts/cmake-toolchain-mingw64-x86_64.cmake" \
+              -DCMAKE_C_FLAGS="-DSDL_DISABLE_SSE4_2"                                                                    \
+              -Werror=dev                                                                                               \
+              -B build_x64
+          cmake --build build_x64 --config Release --verbose
+
+  android:
+    needs: [src]
+    runs-on: ubuntu-latest
+    outputs:
+      android-aar: ${{ steps.releaser.outputs.android-aar }}
+    steps:
+      - name: 'Set up Python'
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: 'build-scripts/build-release.py'
+      - name: 'Setup Android NDK'
+        id: setup-ndk
+        uses: nttld/setup-ndk@v1
+        with:
+          local-cache: false
+          ndk-version: r28c
+      - name: 'Setup Java JDK'
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: '11'
+      - name: 'Install ninja'
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y ninja-build
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Untar ${{ needs.src.outputs.src-tar-gz }}'
+        id: tar
+        run: |
+          mkdir -p /tmp/tardir
+          tar -C /tmp/tardir -v -x -f "${{ github.workspace }}/${{ needs.src.outputs.src-tar-gz }}"
+          echo "path=/tmp/tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'Build Android prefab binary archive(s)'
+        id: releaser
+        run: |
+          python build-scripts/build-release.py \
+            --actions android \
+            --android-api 21 \
+            --android-ndk-home "${{ steps.setup-ndk.outputs.ndk-path }}" \
+            --commit ${{ inputs.commit }} \
+            --root "${{ steps.tar.outputs.path }}" \
+            --github \
+            --debug
+      - name: 'Store Android archive(s)'
+        uses: actions/upload-artifact@v7
+        with:
+          name: android
+          path: '${{ github.workspace }}/dist'
+
+  android-verify:
+    needs: [android, src]
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Set up Python'
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+      - uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v8
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Download Android .aar archive'
+        uses: actions/download-artifact@v8
+        with:
+          name: android
+          path: '${{ github.workspace }}'
+      - name: 'Untar ${{ needs.src.outputs.src-tar-gz }}'
+        id: src
+        run: |
+          mkdir -p /tmp/tardir
+          tar -C /tmp/tardir -v -x -f "${{ github.workspace }}/${{ needs.src.outputs.src-tar-gz }}"
+          echo "path=/tmp/tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}" >>$GITHUB_OUTPUT
+      - name: 'Extract Android SDK from AAR'
+        id: sdk
+        run: |
+          cd /tmp
+          unzip "${{ github.workspace }}/${{ needs.android.outputs.android-aar }}"
+          python "${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}.aar" -o /tmp/SDL3-android
+          echo "prefix=/tmp/SDL3-android" >>$GITHUB_OUTPUT
+          echo "sdl3-aar=/tmp/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }}.aar" >>$GITHUB_OUTPUT
+      - name: 'Verify alignment of libSDL3.so (arm64-v8a/x86_64)'
+        run: |
+          set -e
+          ${{ steps.src.outputs.path }}/build-scripts/check_elf_alignment.sh ${{ steps.sdk.outputs.prefix }}/lib/arm64-v8a/libSDL3.so
+          ${{ steps.src.outputs.path }}/build-scripts/check_elf_alignment.sh ${{ steps.sdk.outputs.prefix }}/lib/x86_64/libSDL3.so
+      - name: 'CMake (configure + build) x86, x64, arm32, arm64'
+        run: |
+          set -e
+          android_abis="x86 x86_64 armeabi-v7a arm64-v8a"
+          for android_abi in ${android_abis}; do
+            echo "Configuring ${android_abi}..."
+            cmake -S "${{ steps.src.outputs.path }}/cmake/test" \
+              -DTEST_FULL=TRUE \
+              -DTEST_STATIC=FALSE \
+              -DTEST_TEST=TRUE \
+              -DCMAKE_PREFIX_PATH="${{ steps.sdk.outputs.prefix }}" \
+              -DCMAKE_TOOLCHAIN_FILE=${ANDROID_NDK_HOME}/build/cmake/android.toolchain.cmake \
+              -DANDROID_USE_LEGACY_TOOLCHAIN=0 \
+              -DANDROID_ABI=${android_abi} \
+              -DCMAKE_BUILD_TYPE=Release \
+              -B "${android_abi}"
+            echo "Building ${android_abi}..."
+            cmake --build "${android_abi}" --config Release --verbose
+          done
+      - name: 'Create gradle project'
+        id: create-gradle-project
+        run: |
+          python ${{ steps.src.outputs.path }}/build-scripts/create-android-project.py \
+            org.libsdl.testspriteminimal \
+            ${{ steps.src.outputs.path }}/test/testspriteminimal.c \
+            ${{ steps.src.outputs.path }}/test/icon.h \
+            --variant aar \
+            --output "/tmp/projects"
+          echo "path=/tmp/projects/org.libsdl.testspriteminimal" >>$GITHUB_OUTPUT
+      - name: 'Copy SDL3 aar into Gradle project'
+        run: |
+          cp "${{ steps.sdk.outputs.sdl3-aar }}" "${{ steps.create-gradle-project.outputs.path }}/app/libs"
+
+          echo ""
+          echo "Project contents:"
+          echo ""
+          find "${{ steps.create-gradle-project.outputs.path }}"
+      - name: 'Build app (Gradle & CMake)'
+        run: |
+          cd "${{ steps.create-gradle-project.outputs.path }}"
+          ./gradlew -i assembleRelease -Pandroid.native.buildOutput=verbose -PBUILD_WITH_CMAKE=1
+      - name: 'Build app (Gradle & ndk-build)'
+        run: |
+          cd "${{ steps.create-gradle-project.outputs.path }}"
+          ./gradlew -i assembleRelease -Pandroid.native.buildOutput=verbose

external/SDL/.gitignore

@@ -0,0 +1,173 @@
+build/
+build-*/
+!build-scripts/
+buildbot/
+/VERSION.txt
+__pycache__
+
+*.so
+*.so.*
+*.dll
+*.exe
+*.o
+*.obj
+*.res
+*.lib
+*.a
+*.la
+*.dSYM
+*,e1f
+*,ff8
+*.lnk
+*.err
+*.exp
+*.map
+*.orig
+*~
+*.swp
+*.tmp
+*.rej
+
+# for CMake
+.cmake
+CMakeFiles/
+CMakeCache.txt
+cmake_install.cmake
+cmake_uninstall.cmake
+install_manifest.txt
+*Targets.cmake
+*Config.cmake
+*ConfigVersion.cmake
+CTestTestfile.cmake
+Testing
+compile_commands.json
+.cache/
+/include-config-*
+/include-revision
+/Makefile
+.ninja_*
+*.ninja
+*.pc
+test/*.test
+wayland-generated-protocols
+CMakeSettings.json
+
+# for CLion
+.idea
+cmake-build-*
+
+# for Xcode
+*.mode1*
+*.perspective*
+*.pbxuser
+(^|/)build($|/)
+.DS_Store
+xcuserdata
+*.xcworkspace
+Xcode/build.xcconfig
+
+# for Visual Studio Code
+.vscode/
+
+# for Visual C++
+.vs
+Debug
+Release
+*.user
+*.ncb
+*.suo
+*.sdf
+VisualC/tests/loopwave/sample.wav
+VisualC/tests/testautomation/*.bmp
+VisualC/tests/testautomation/*.png
+VisualC/tests/testcontroller/*.png
+VisualC/tests/testoverlay/moose.dat
+VisualC/tests/testrendertarget/icon.png
+VisualC/tests/testrendertarget/sample.png
+VisualC/tests/testscale/icon.png
+VisualC/tests/testscale/sample.png
+VisualC/tests/testsprite/icon.png
+VisualC/tests/testyuv/testyuv.png
+VisualC-GDK/**/Layout
+src/render/direct3d12/D3D12_*_One.h
+src/render/direct3d12/D3D12_*_Series.h
+src/gpu/d3d12/D3D12_*_One.h
+src/gpu/d3d12/D3D12_*_Series.h
+out/
+
+# for Android
+android-project/local.properties
+android-project/.gradle/
+
+test/checkkeys
+test/checkkeysthreads
+test/gamepadmap
+test/loopwave
+test/loopwavequeue
+test/testatomic
+test/testaudiorecording
+test/testaudiohotplug
+test/testaudioinfo
+test/testautomation
+test/testbounds
+test/testcustomcursor
+test/testdisplayinfo
+test/testdraw
+test/testdrawchessboard
+test/testdropfile
+test/testerror
+test/testevdev
+test/testfile
+test/testfilesystem
+test/testgamepad
+test/testgeometry
+test/testgesture
+test/testgl
+test/testgles
+test/testgles2
+test/testhaptic
+test/testhittesting
+test/testhotplug
+test/testiconv
+test/testime
+test/testintersections
+test/testjoystick
+test/testkeys
+test/testloadso
+test/testlocale
+test/testlock
+test/testmessage
+test/testmouse
+test/testmultiaudio
+test/testnative
+test/testoverlay
+test/testplatform
+test/testpower
+test/testqsort
+test/testrelative
+test/testrendercopyex
+test/testrendertarget
+test/testresample
+test/testrumble
+test/testscale
+test/testsem
+test/testsensor
+test/testshader
+test/testshape
+test/testsprite
+test/testspriteminimal
+test/testsurround
+test/testthread
+test/testtimer
+test/testurl
+test/testver
+test/testviewport
+test/testvulkan
+test/testwm
+test/testyuv
+test/torturethread
+
+# for Doxygen
+docs/output
+SDL.tag
+doxygen_warn.txt

external/SDL/.wikiheaders-options

@@ -0,0 +1,41 @@
+projectfullname = Simple Directmedia Layer
+projectshortname = SDL
+incsubdir = include/SDL3
+wikisubdir =
+readmesubdir = docs
+apiprefixregex = (SDL_|SDLK_|[US]int\d+)
+mainincludefname = SDL3/SDL.h
+versionfname = include/SDL3/SDL_version.h
+versionmajorregex = \A\#define\s+SDL_MAJOR_VERSION\s+(\d+)\Z
+versionminorregex = \A\#define\s+SDL_MINOR_VERSION\s+(\d+)\Z
+versionmicroregex = \A\#define\s+SDL_MICRO_VERSION\s+(\d+)\Z
+apipropertyregex = \A\s*\#\s*define\s+SDL_PROP_
+selectheaderregex = \ASDL.*?\.h\Z
+projecturl = https://libsdl.org/
+wikiurl = https://wiki.libsdl.org
+bugreporturl = https://github.com/libsdl-org/sdlwiki/issues/new
+warn_about_missing = 0
+#wikipreamble = (This is the documentation for SDL3, which is the current stable version. [SDL2](https://wiki.libsdl.org/SDL2/) was the previous version!)
+wikiheaderfiletext = Defined in [<SDL3/%fname%>](https://github.com/libsdl-org/SDL/blob/main/include/SDL3/%fname%)
+
+manpageheaderfiletext = Defined in SDL3/%fname%
+manpagesymbolfilterregex = \A[US]int\d+\Z
+
+# All SDL_test_* headers become undefined categories, everything else just converts like SDL_audio.h -> Audio
+# A handful of others we fix up in the header itself with /* WIKI CATEGORY: x */ comments.
+headercategoryeval = s/\ASDL_test_?.*?\.h\Z//; s/\ASDL_?(.*?)\.h\Z/$1/; ucfirst();
+
+quickrefenabled = 1
+quickrefcategoryorder = Init,Hints,Error,Version,Properties,Log,Video,Events,Keyboard,Mouse,Touch,Gamepad,Joystick,Haptic,Audio,Time,Timer,Render,SharedObject,Thread,Mutex,Atomic,Filesystem,IOStream,AsyncIO,Storage,Pixels,Surface,Blendmode,Rect,Camera,Clipboard,Dialog,Tray,Messagebox,GPU,Vulkan,Metal,Platform,Power,Sensor,Process,Bits,Endian,Assert,CPUInfo,Intrinsics,Locale,System,Misc,GUID,Main,Stdinc
+quickreftitle = SDL3 API Quick Reference
+quickrefurl = https://libsdl.org/
+quickrefdesc = The latest version of this document can be found at https://wiki.libsdl.org/SDL3/QuickReference
+quickrefmacroregex = \A(SDL_PLATFORM_.*|SDL_.*_INTRINSICS|SDL_Atomic...Ref|SDL_assert.*?|SDL_COMPILE_TIME_ASSERT|SDL_arraysize|SDL_Swap[BL]E\d\d|SDL_[a-z]+_cast)\Z
+
+envvarenabled = 1
+envvartitle = SDL3 Environment Variables
+envvardesc = SDL3 can be controlled by the user, externally, with environment variables. They are all operate exactly like the [hints you can get and set programmatically](CategoryHints), but named without the `_HINT` part (so `"SDL_HINT_A"` would be environment variable `"SDL_A"`).\n\nThis list matches the latest in SDL3's revision control.
+envvarsymregex = \ASDL_HINT_(.*)\Z
+envvarsymreplace = SDL_$1
+
+

external/SDL/AGENTS.md

@@ -0,0 +1,20 @@
+AI must not be used to generate code for contributions to this project.
+
+"AI" in this case means a Large Language Model ("LLM"), such as ChatGPT,
+Claude, Copilot, Grok, etc.
+
+AI-generated code is based upon sources of unknown origins and may not be
+compatible with the Zlib license, or may introduce conflicting license terms
+if they include code from other projects.
+
+AI can be used to identify issues with contributions to this project, but the
+solutions to those issues should be authored by humans.
+
+We have found that AI will frequently hallucinate issues that are not actually
+problems in practice, report incorrect information, and describe problems that
+are actually not issues at all. If AI identifies a problem with this codebase,
+please make sure you understand what it is saying and have independently
+confirmed that the issue exists before submitting a bug report or pull request.
+
+Any pull request to this project will ask you to confirm that you are the
+author and that you are contributing your changes under the Zlib license.

external/SDL/Android.mk

@@ -0,0 +1,146 @@
+LOCAL_PATH := $(call my-dir)
+
+###########################
+#
+# SDL shared library
+#
+###########################
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := SDL3
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/include $(LOCAL_PATH)/include/build_config $(LOCAL_PATH)/src
+
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
+
+LOCAL_SRC_FILES := \
+	$(subst $(LOCAL_PATH)/,, \
+	$(wildcard $(LOCAL_PATH)/src/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/audio/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/audio/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/audio/dummy/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/audio/aaudio/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/audio/openslES/*.c) \
+	$(LOCAL_PATH)/src/atomic/SDL_atomic.c.arm \
+	$(LOCAL_PATH)/src/atomic/SDL_spinlock.c.arm \
+	$(wildcard $(LOCAL_PATH)/src/camera/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/camera/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/camera/dummy/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/core/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/core/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/cpuinfo/*.c) \
+	$(LOCAL_PATH)/src/dialog/SDL_dialog.c \
+	$(LOCAL_PATH)/src/dialog/SDL_dialog_utils.c \
+	$(LOCAL_PATH)/src/dialog/android/SDL_androiddialog.c \
+	$(wildcard $(LOCAL_PATH)/src/dynapi/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/events/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/io/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/io/generic/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/gpu/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/gpu/vulkan/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/gpu/xr/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/haptic/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/haptic/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/haptic/dummy/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/haptic/hidapi/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/hidapi/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/hidapi/android/*.cpp) \
+	$(wildcard $(LOCAL_PATH)/src/joystick/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/joystick/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/joystick/dummy/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/joystick/hidapi/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/joystick/steam/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/joystick/virtual/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/loadso/dlopen/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/locale/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/locale/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/main/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/main/generic/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/misc/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/misc/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/power/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/power/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/process/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/process/dummy/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/filesystem/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/filesystem/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/filesystem/posix/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/sensor/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/sensor/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/sensor/dummy/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/render/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/render/*/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/stdlib/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/storage/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/storage/generic/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/thread/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/thread/pthread/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/time/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/time/unix/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/timer/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/timer/unix/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/tray/dummy/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/tray/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/video/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/video/android/*.c) \
+	$(wildcard $(LOCAL_PATH)/src/video/yuv2rgb/*.c))
+
+LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
+LOCAL_CFLAGS += \
+	-Wall -Wextra \
+	-Wmissing-prototypes \
+	-Wunreachable-code-break \
+	-Wunneeded-internal-declaration \
+	-Wmissing-variable-declarations \
+	-Wfloat-conversion \
+	-Wshorten-64-to-32 \
+	-Wunreachable-code-return \
+	-Wshift-sign-overflow \
+	-Wstrict-prototypes \
+	-Wkeyword-macro \
+
+# Warnings we haven't fixed (yet)
+LOCAL_CFLAGS += -Wno-unused-parameter -Wno-sign-compare
+
+LOCAL_CXXFLAGS += -std=gnu++11
+
+LOCAL_LDLIBS := -ldl -lGLESv1_CM -lGLESv2 -lOpenSLES -llog -landroid
+
+LOCAL_LDFLAGS := -Wl,--no-undefined -Wl,--no-undefined-version -Wl,--version-script=$(LOCAL_PATH)/src/dynapi/SDL_dynapi.sym
+
+ifeq ($(NDK_DEBUG),1)
+    cmd-strip :=
+endif
+
+include $(BUILD_SHARED_LIBRARY)
+
+
+###########################
+#
+# SDL_test static library
+#
+###########################
+
+include $(CLEAR_VARS)
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/include $(LOCAL_PATH)/src
+
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include
+
+LOCAL_MODULE := SDL3_test
+
+LOCAL_MODULE_FILENAME := libSDL3_test
+
+LOCAL_SRC_FILES := \
+	$(subst $(LOCAL_PATH)/,, \
+	$(wildcard $(LOCAL_PATH)/src/test/*.c))
+
+LOCAL_LDLIBS :=
+
+LOCAL_LDFLAGS :=
+
+LOCAL_EXPORT_LDLIBS :=
+
+include $(BUILD_STATIC_LIBRARY)
+

external/SDL/BUGS.txt

@@ -0,0 +1,19 @@
+
+Bugs are now managed in the SDL issue tracker, here:
+
+    https://github.com/libsdl-org/SDL/issues
+
+You may report bugs there, and search to see if a given issue has already
+ been reported, discussed, and maybe even fixed.
+
+
+You may also find help at the SDL forums/mailing list:
+
+    https://discourse.libsdl.org/
+
+or on Discord:
+
+    https://discord.com/invite/BwpFGBWsv8
+
+Bug reports are welcome here, but we really appreciate if you use the issue tracker, as bugs discussed on the mailing list or Discord may be forgotten or missed.
+

external/SDL/CLAUDE.md

@@ -0,0 +1,22 @@
+AI must not be used to generate code for contributions to this project.
+
+"AI" in this case means a Large Language Model ("LLM"), such as ChatGPT,
+Claude, Copilot, Grok, etc.
+
+AI-generated code is based upon sources of unknown origins and may not be
+compatible with the Zlib license, or may introduce conflicting license terms
+if they include code from other projects.
+
+AI can be used to identify issues with contributions to this project, but the
+solutions to those issues should be authored by humans.
+
+We have found that AI will frequently hallucinate issues that are not actually
+problems in practice, report incorrect information, and describe problems that
+are actually not issues at all. If AI identifies a problem with this codebase,
+please make sure you understand what it is saying and have independently
+confirmed that the issue exists before submitting a bug report or pull request.
+
+Any pull request to this project will ask you to confirm that you are the
+author and that you are contributing your changes under the Zlib license.
+
+

external/SDL/CREDITS.md

@@ -0,0 +1,38 @@
+# Simple DirectMedia Layer CREDITS
+
+Thanks to everyone who made this possible, including:
+
+- Cliff Matthews, for giving me a reason to start this project. :)  -- Executor rocks!  *grin*
+- Ryan Gordon for helping everybody out and keeping the dream alive. :)
+- Frank Praznik for his Wayland support and general windowing development.
+- Ozkan Sezer for sanity checks and make sure the i's are dotted and t's are crossed.
+- Anonymous Maarten for CMake support and build system development.
+- Evan Hemsley, Caleb Cornett, and Ethan Lee for SDL GPU development.
+- Gabriel Jacobo for his work on the Android port and generally helping out all around.
+- Philipp Wiesemann for his attention to detail reviewing the entire SDL code base and proposes patches.
+- Andreas Schiffler for his dedication to unit tests, Visual Studio projects, and managing the Google Summer of Code.
+- Mike Sartain for incorporating SDL into Team Fortress 2 and cheering me on at Valve.
+- Alfred Reynolds for the game controller API and general (in)sanity
+- Jørgen Tjernø¸ for numerous magical macOS fixes.
+- Pierre-Loup Griffais for his deep knowledge of OpenGL drivers.
+- Julian Winter for the SDL 2.0 website.
+- Sheena Smith for many months of great work on the SDL wiki creating the API documentation and style guides.
+- Paul Hunkin for his port of SDL to Android during the Google Summer of Code 2010.
+- Eli Gottlieb for his work on shaped windows during the Google Summer of Code 2010.
+- Jim Grandpre for his work on multi-touch and gesture recognition during
+  the Google Summer of Code 2010.
+- Edgar "bobbens" Simo for his force feedback API development during the
+  Google Summer of Code 2008.
+- Aaron Wishnick for his work on audio resampling and pitch shifting during
+  the Google Summer of Code 2008.
+- Holmes Futrell for his port of SDL to the iPhone and iPod Touch during the
+  Google Summer of Code 2008.
+- Jon Atkins for SDL_image, SDL_mixer and SDL_net documentation.
+- Everybody at Loki Software, Inc. and Valve Corporation for their great contributions!
+
+ And a big hand to everyone else who has contributed over the years.
+
+THANKS! :)
+
+    -- Sam Lantinga <slouken@libsdl.org>
+

external/SDL/INSTALL.md

@@ -0,0 +1,48 @@
+# To build and use SDL:
+
+SDL supports a number of development environments:
+- [CMake](docs/INTRO-cmake.md)
+- [Visual Studio on Windows](docs/INTRO-visualstudio.md)
+- [gcc on Windows](docs/INTRO-mingw.md)
+- [Xcode on Apple platforms](docs/INTRO-xcode.md)
+- [Android Studio](docs/INTRO-androidstudio.md)
+- [Emscripten for web](docs/INTRO-emscripten.md)
+
+SDL is also usable in other environments. The basic steps are to use CMake to build the library and then use the headers and library that you built in your project. You can search online to see if anyone has specific steps for your setup.
+
+# Documentation
+
+An API reference, tutorials, and additional documentation is available at:
+
+https://wiki.libsdl.org/SDL3
+
+# Example code
+
+There are simple example programs in the examples directory, and you can view them online at:
+
+https://examples.libsdl.org/SDL3
+
+More in-depth test programs are available in the tests directory and can be built by adding `-DSDL_TESTS=ON` to the CMake command line when building SDL.
+
+# Discussions
+
+## Discord
+
+You can join the official Discord server at:
+
+https://discord.com/invite/BwpFGBWsv8
+
+## Forums/mailing lists
+
+You can join SDL development discussions at:
+
+https://discourse.libsdl.org/
+
+Once you sign up, you can use the forum through the website or as a mailing list from your email client.
+
+## Announcement list
+
+You can sign up for the low traffic announcement list at:
+
+https://www.libsdl.org/mailing-list.php
+

external/SDL/LICENSE.txt

@@ -0,0 +1,18 @@
+Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
+  
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+  
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required. 
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+

external/SDL/README.md

@@ -0,0 +1,17 @@
+
+Simple DirectMedia Layer (SDL for short) is a cross-platform library
+designed to make it easy to write multi-media software, such as games
+and emulators.
+
+You can find the latest release and additional information at:
+https://www.libsdl.org/
+
+Installation instructions and a quick introduction is available in
+[INSTALL.md](INSTALL.md)
+
+This library is distributed under the terms of the zlib license,
+available in [LICENSE.txt](LICENSE.txt).
+
+Enjoy!
+
+Sam Lantinga (slouken@libsdl.org)

external/SDL/VisualC-GDK/SDL.sln

@@ -0,0 +1,120 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32414.318
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{D69D5741-611F-4E14-8541-1FEE94F50B5A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SDL3", "SDL\SDL.vcxproj", "{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testsprite", "tests\testsprite\testsprite.vcxproj", "{40FB7794-D3C3-4CFE-BCF4-A80C96635682}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SDL3_test", "SDL_test\SDL_test.vcxproj", "{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testcontroller", "tests\testcontroller\testcontroller.vcxproj", "{55812185-D13C-4022-9C81-32E0F4A08305}"
+	ProjectSection(ProjectDependencies) = postProject
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A} = {DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testgdk", "tests\testgdk\testgdk.vcxproj", "{1C9A3F71-35A5-4C56-B292-F4375B3C3649}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Gaming.Desktop.x64 = Debug|Gaming.Desktop.x64
+		Debug|Gaming.Xbox.Scarlett.x64 = Debug|Gaming.Xbox.Scarlett.x64
+		Debug|Gaming.Xbox.XboxOne.x64 = Debug|Gaming.Xbox.XboxOne.x64
+		Release|Gaming.Desktop.x64 = Release|Gaming.Desktop.x64
+		Release|Gaming.Xbox.Scarlett.x64 = Release|Gaming.Xbox.Scarlett.x64
+		Release|Gaming.Xbox.XboxOne.x64 = Release|Gaming.Xbox.XboxOne.x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|Gaming.Desktop.x64.ActiveCfg = Debug|Gaming.Desktop.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|Gaming.Desktop.x64.Build.0 = Debug|Gaming.Desktop.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|Gaming.Xbox.Scarlett.x64.ActiveCfg = Debug|Gaming.Xbox.Scarlett.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|Gaming.Xbox.Scarlett.x64.Build.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|Gaming.Xbox.XboxOne.x64.ActiveCfg = Debug|Gaming.Xbox.XboxOne.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|Gaming.Xbox.XboxOne.x64.Build.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|Gaming.Desktop.x64.ActiveCfg = Release|Gaming.Desktop.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|Gaming.Desktop.x64.Build.0 = Release|Gaming.Desktop.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|Gaming.Xbox.Scarlett.x64.ActiveCfg = Release|Gaming.Xbox.Scarlett.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|Gaming.Xbox.Scarlett.x64.Build.0 = Release|Gaming.Xbox.Scarlett.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|Gaming.Xbox.XboxOne.x64.ActiveCfg = Release|Gaming.Xbox.XboxOne.x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|Gaming.Xbox.XboxOne.x64.Build.0 = Release|Gaming.Xbox.XboxOne.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Desktop.x64.ActiveCfg = Debug|Gaming.Desktop.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Desktop.x64.Build.0 = Debug|Gaming.Desktop.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Desktop.x64.Deploy.0 = Debug|Gaming.Desktop.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Xbox.Scarlett.x64.ActiveCfg = Debug|Gaming.Xbox.Scarlett.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Xbox.Scarlett.x64.Build.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Xbox.Scarlett.x64.Deploy.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Xbox.XboxOne.x64.ActiveCfg = Debug|Gaming.Xbox.XboxOne.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Xbox.XboxOne.x64.Build.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Gaming.Xbox.XboxOne.x64.Deploy.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Desktop.x64.ActiveCfg = Release|Gaming.Desktop.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Desktop.x64.Build.0 = Release|Gaming.Desktop.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Desktop.x64.Deploy.0 = Release|Gaming.Desktop.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Xbox.Scarlett.x64.ActiveCfg = Release|Gaming.Xbox.Scarlett.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Xbox.Scarlett.x64.Build.0 = Release|Gaming.Xbox.Scarlett.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Xbox.Scarlett.x64.Deploy.0 = Release|Gaming.Xbox.Scarlett.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Xbox.XboxOne.x64.ActiveCfg = Release|Gaming.Xbox.XboxOne.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Xbox.XboxOne.x64.Build.0 = Release|Gaming.Xbox.XboxOne.x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Gaming.Xbox.XboxOne.x64.Deploy.0 = Release|Gaming.Xbox.XboxOne.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|Gaming.Desktop.x64.ActiveCfg = Debug|Gaming.Desktop.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|Gaming.Desktop.x64.Build.0 = Debug|Gaming.Desktop.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|Gaming.Xbox.Scarlett.x64.ActiveCfg = Debug|Gaming.Xbox.Scarlett.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|Gaming.Xbox.Scarlett.x64.Build.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|Gaming.Xbox.XboxOne.x64.ActiveCfg = Debug|Gaming.Xbox.XboxOne.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|Gaming.Xbox.XboxOne.x64.Build.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|Gaming.Desktop.x64.ActiveCfg = Release|Gaming.Desktop.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|Gaming.Desktop.x64.Build.0 = Release|Gaming.Desktop.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|Gaming.Xbox.Scarlett.x64.ActiveCfg = Release|Gaming.Xbox.Scarlett.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|Gaming.Xbox.Scarlett.x64.Build.0 = Release|Gaming.Xbox.Scarlett.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|Gaming.Xbox.XboxOne.x64.ActiveCfg = Release|Gaming.Xbox.XboxOne.x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|Gaming.Xbox.XboxOne.x64.Build.0 = Release|Gaming.Xbox.XboxOne.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Desktop.x64.ActiveCfg = Debug|Gaming.Desktop.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Desktop.x64.Build.0 = Debug|Gaming.Desktop.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Desktop.x64.Deploy.0 = Debug|Gaming.Desktop.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Xbox.Scarlett.x64.ActiveCfg = Debug|Gaming.Xbox.Scarlett.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Xbox.Scarlett.x64.Build.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Xbox.Scarlett.x64.Deploy.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Xbox.XboxOne.x64.ActiveCfg = Debug|Gaming.Xbox.XboxOne.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Xbox.XboxOne.x64.Build.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Gaming.Xbox.XboxOne.x64.Deploy.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Desktop.x64.ActiveCfg = Release|Gaming.Desktop.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Desktop.x64.Build.0 = Release|Gaming.Desktop.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Desktop.x64.Deploy.0 = Release|Gaming.Desktop.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Xbox.Scarlett.x64.ActiveCfg = Release|Gaming.Xbox.Scarlett.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Xbox.Scarlett.x64.Build.0 = Release|Gaming.Xbox.Scarlett.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Xbox.Scarlett.x64.Deploy.0 = Release|Gaming.Xbox.Scarlett.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Xbox.XboxOne.x64.ActiveCfg = Release|Gaming.Xbox.XboxOne.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Xbox.XboxOne.x64.Build.0 = Release|Gaming.Xbox.XboxOne.x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Gaming.Xbox.XboxOne.x64.Deploy.0 = Release|Gaming.Xbox.XboxOne.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Desktop.x64.ActiveCfg = Debug|Gaming.Desktop.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Desktop.x64.Build.0 = Debug|Gaming.Desktop.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Desktop.x64.Deploy.0 = Debug|Gaming.Desktop.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Xbox.Scarlett.x64.ActiveCfg = Debug|Gaming.Xbox.Scarlett.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Xbox.Scarlett.x64.Build.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Xbox.Scarlett.x64.Deploy.0 = Debug|Gaming.Xbox.Scarlett.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Xbox.XboxOne.x64.ActiveCfg = Debug|Gaming.Xbox.XboxOne.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Xbox.XboxOne.x64.Build.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Debug|Gaming.Xbox.XboxOne.x64.Deploy.0 = Debug|Gaming.Xbox.XboxOne.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Desktop.x64.ActiveCfg = Release|Gaming.Desktop.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Desktop.x64.Build.0 = Release|Gaming.Desktop.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Desktop.x64.Deploy.0 = Release|Gaming.Desktop.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Xbox.Scarlett.x64.ActiveCfg = Release|Gaming.Xbox.Scarlett.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Xbox.Scarlett.x64.Build.0 = Release|Gaming.Xbox.Scarlett.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Xbox.Scarlett.x64.Deploy.0 = Release|Gaming.Xbox.Scarlett.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Xbox.XboxOne.x64.ActiveCfg = Release|Gaming.Xbox.XboxOne.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Xbox.XboxOne.x64.Build.0 = Release|Gaming.Xbox.XboxOne.x64
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649}.Release|Gaming.Xbox.XboxOne.x64.Deploy.0 = Release|Gaming.Xbox.XboxOne.x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{55812185-D13C-4022-9C81-32E0F4A08305} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{1C9A3F71-35A5-4C56-B292-F4375B3C3649} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C320C9F2-1A8F-41D7-B02B-6338F872BCAD}
+	EndGlobalSection
+EndGlobal

external/SDL/VisualC-GDK/SDL/SDL.vcxproj

@@ -0,0 +1,945 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Gaming.Desktop.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Desktop.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectName>SDL3</ProjectName>
+    <ProjectGuid>{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}</ProjectGuid>
+    <RootNamespace>SDL</RootNamespace>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(VCTargetsPath)\BuildCustomizations\masm.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">
+    <IncludePath>$(ProjectDir)../../src;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">
+    <IncludePath>$(ProjectDir)../../src;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/SDL.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\include\build_config;$(ProjectDir)\..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>DLL_EXPORT;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>SDL_internal.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>setupapi.lib;winmm.lib;imm32.lib;version.lib;xgameruntime.lib;vcruntimed.lib;msvcrtd.lib;ucrtd.lib;msvcprtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/SDL.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\include\build_config;$(ProjectDir)\..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>DLL_EXPORT;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>setupapi.lib;winmm.lib;imm32.lib;version.lib;xgameruntime.lib;d3d12_xs.lib;uuid.lib;vcruntimed.lib;msvcrtd.lib;ucrtd.lib;msvcprtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
+    </Link>
+    <PreBuildEvent>
+      <Command>
+        call "$(ProjectDir)..\..\src\render\direct3d12\compile_shaders_xbox.bat" "$(ProjectDir)..\"
+        call "$(ProjectDir)..\..\src\gpu\d3d12\compile_shaders_xbox.bat" "$(ProjectDir)..\"
+      </Command>
+    </PreBuildEvent>
+    <PreBuildEvent>
+      <Message>Building shader blobs (Xbox Series)</Message>
+    </PreBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/SDL.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\include\build_config;$(ProjectDir)\..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>DLL_EXPORT;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>setupapi.lib;winmm.lib;imm32.lib;version.lib;xgameruntime.lib;d3d12_x.lib;uuid.lib;vcruntimed.lib;msvcrtd.lib;ucrtd.lib;msvcprtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
+    </Link>
+    <PreBuildEvent>
+      <Command>
+        call $(ProjectDir)..\..\src\render\direct3d12\compile_shaders_xbox.bat $(ProjectDir)..\ one
+        call $(ProjectDir)..\..\src\gpu\d3d12\compile_shaders_xbox.bat $(ProjectDir)..\ one
+      </Command>
+    </PreBuildEvent>
+    <PreBuildEvent>
+      <Message>Building shader blobs (Xbox One)</Message>
+    </PreBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/SDL.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\include\build_config;$(ProjectDir)\..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>DLL_EXPORT;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>SDL_internal.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>setupapi.lib;winmm.lib;imm32.lib;version.lib;xgameruntime.lib;vcruntime.lib;msvcrt.lib;ucrt.lib;msvcprt.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/SDL.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\include\build_config;$(ProjectDir)\..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>DLL_EXPORT;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>setupapi.lib;winmm.lib;imm32.lib;version.lib;xgameruntime.lib;d3d12_xs.lib;uuid.lib;vcruntime.lib;msvcrt.lib;ucrt.lib;msvcprt.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
+    </Link>
+    <PreBuildEvent>
+      <Command>
+        call $(ProjectDir)..\..\src\render\direct3d12\compile_shaders_xbox.bat $(ProjectDir)..\
+        call $(ProjectDir)..\..\src\gpu\d3d12\compile_shaders_xbox.bat $(ProjectDir)..\
+      </Command>
+    </PreBuildEvent>
+    <PreBuildEvent>
+      <Message>Building shader blobs (Xbox Series)</Message>
+    </PreBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/SDL.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)\..\..\include;$(ProjectDir)\..\..\include\build_config;$(ProjectDir)\..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>DLL_EXPORT;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>setupapi.lib;winmm.lib;imm32.lib;version.lib;xgameruntime.lib;d3d12_x.lib;uuid.lib;vcruntime.lib;msvcrt.lib;ucrt.lib;msvcprt.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
+    </Link>
+    <PreBuildEvent>
+      <Command>
+        call $(ProjectDir)..\..\src\render\direct3d12\compile_shaders_xbox.bat $(ProjectDir)..\ one
+        call $(ProjectDir)..\..\src\gpu\d3d12\compile_shaders_xbox.bat $(ProjectDir)..\ one
+      </Command>
+    </PreBuildEvent>
+    <PreBuildEvent>
+      <Message>Building shader blobs (Xbox One)</Message>
+    </PreBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(TreatWarningsAsError)'!=''">
+    <ClCompile>
+      <TreatWarningAsError>$(TreatWarningsAsError)</TreatWarningAsError>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\SDL3\SDL.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_assert.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_asyncio.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_atomic.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_audio.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_begin_code.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_bits.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_blendmode.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_camera.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_clipboard.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_close_code.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_copying.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_cpuinfo.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_dialog.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_dlopennote.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_egl.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_endian.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_error.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_events.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_filesystem.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_gamepad.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_gpu.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_guid.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_haptic.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_hidapi.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_hints.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_init.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_intrin.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_iostream.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_joystick.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_keyboard.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_keycode.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_loadso.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_locale.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_log.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_main.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_main_impl.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_messagebox.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_metal.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_misc.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_mouse.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_mutex.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_oldnames.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengl.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengl_glext.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2_gl2.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2_gl2ext.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2_gl2platform.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2_khrplatform.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_pen.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_pixels.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_platform.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_platform_defines.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_power.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_process.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_properties.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_rect.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_render.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_revision.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_scancode.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_sensor.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_stdinc.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_storage.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_surface.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_system.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_assert.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_common.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_compare.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_crc32.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_font.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_fuzzer.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_harness.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_log.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_md5.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_memory.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_thread.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_time.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_timer.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_touch.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_tray.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_version.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_video.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_vulkan.h" />
+    <ClInclude Include="..\..\src\audio\directsound\SDL_directsound.h" />
+    <ClInclude Include="..\..\src\audio\disk\SDL_diskaudio.h" />
+    <ClInclude Include="..\..\src\audio\dummy\SDL_dummyaudio.h" />
+    <ClInclude Include="..\..\src\audio\SDL_audio_c.h" />
+    <ClInclude Include="..\..\src\audio\SDL_audiodev_c.h" />
+    <ClInclude Include="..\..\src\audio\SDL_sysaudio.h" />
+    <ClInclude Include="..\..\src\audio\SDL_audioqueue.h" />
+    <ClInclude Include="..\..\src\audio\SDL_audioresample.h" />
+    <ClInclude Include="..\..\src\audio\SDL_wave.h" />
+    <ClInclude Include="..\..\src\audio\wasapi\SDL_wasapi.h" />
+    <ClInclude Include="..\..\src\camera\SDL_camera_c.h" />
+    <ClInclude Include="..\..\src\camera\SDL_syscamera.h" />
+    <ClInclude Include="..\..\src\core\gdk\SDL_gdk.h" />
+    <ClInclude Include="..\..\src\core\SDL_core_unsupported.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_directx.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_gameinput.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_hid.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_immdevice.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_windows.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_xinput.h" />
+    <ClInclude Include="..\..\src\cpuinfo\SDL_cpuinfo_c.h" />
+    <ClInclude Include="..\..\src\dynapi\SDL_dynapi.h" />
+    <ClInclude Include="..\..\src\dynapi\SDL_dynapi_overrides.h" />
+    <ClInclude Include="..\..\src\dynapi\SDL_dynapi_procs.h" />
+    <ClInclude Include="..\..\src\events\blank_cursor.h" />
+    <ClInclude Include="..\..\src\events\default_cursor.h" />
+    <ClInclude Include="..\..\src\events\scancodes_windows.h" />
+    <ClInclude Include="..\..\src\events\SDL_categories_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_clipboardevents_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_displayevents_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_dropevents_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_events_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_eventwatch_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_keyboard_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_keymap_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_mouse_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_touch_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_windowevents_c.h" />
+    <ClInclude Include="..\..\src\filesystem\SDL_sysfilesystem.h" />
+    <ClInclude Include="..\..\src\gpu\SDL_sysgpu.h" />
+    <ClInclude Include="..\..\src\io\SDL_asyncio_c.h" />
+    <ClInclude Include="..\..\src\io\SDL_sysasyncio.h" />
+    <ClInclude Include="..\..\src\haptic\SDL_haptic_c.h" />
+    <ClInclude Include="..\..\src\haptic\SDL_syshaptic.h" />
+    <ClInclude Include="..\..\src\haptic\SDL_hidapihaptic.h" />
+    <ClInclude Include="..\..\src\haptic\windows\SDL_dinputhaptic_c.h" />
+    <ClInclude Include="..\..\src\haptic\windows\SDL_windowshaptic_c.h" />
+    <ClInclude Include="..\..\src\haptic\hidapi\SDL_hidapihaptic_c.h" />
+    <ClInclude Include="..\..\src\hidapi\hidapi\hidapi.h" />
+    <ClInclude Include="..\..\src\hidapi\SDL_hidapi_c.h" />
+    <ClInclude Include="..\..\src\joystick\controller_type.h" />
+    <ClInclude Include="..\..\src\joystick\hidapi\SDL_hidapijoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\hidapi\SDL_hidapi_rumble.h" />
+    <ClInclude Include="..\..\src\joystick\hidapi\SDL_report_descriptor.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_gamepad_c.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_gamepad_db.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_joystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_steam_virtual_gamepad.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_sysjoystick.h" />
+    <ClInclude Include="..\..\src\joystick\usb_ids.h" />
+    <ClInclude Include="..\..\src\joystick\virtual\SDL_virtualjoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\windows\SDL_dinputjoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\windows\SDL_rawinputjoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\windows\SDL_windowsjoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\windows\SDL_xinputjoystick_c.h" />
+    <ClInclude Include="..\..\src\libm\math_libm.h" />
+    <ClInclude Include="..\..\src\libm\math_private.h" />
+    <ClInclude Include="..\..\src\locale\SDL_syslocale.h" />
+    <ClInclude Include="..\..\src\main\SDL_main_callbacks.h" />
+    <ClInclude Include="..\..\src\misc\SDL_sysurl.h" />
+    <ClInclude Include="..\..\src\power\SDL_syspower.h" />
+    <ClInclude Include="..\..\src\render\direct3d11\SDL_shaders_d3d11.h" />
+    <ClInclude Include="..\..\src\render\direct3d12\SDL_render_d3d12_xbox.h" />
+    <ClInclude Include="..\..\src\render\direct3d12\SDL_shaders_d3d12.h" />
+    <ClInclude Include="..\..\src\render\direct3d\SDL_shaders_d3d.h" />
+    <ClInclude Include="..\..\src\render\opengles2\SDL_gles2funcs.h" />
+    <ClInclude Include="..\..\src\render\opengles2\SDL_shaders_gles2.h" />
+    <ClInclude Include="..\..\src\render\opengl\SDL_glfuncs.h" />
+    <ClInclude Include="..\..\src\render\opengl\SDL_shaders_gl.h" />
+    <ClInclude Include="..\..\src\render\SDL_d3dmath.h" />
+    <ClInclude Include="..\..\src\render\SDL_sysrender.h" />
+    <ClInclude Include="..\..\src\render\SDL_yuv_sw_c.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_blendfillrect.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_blendline.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_blendpoint.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_draw.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_drawline.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_drawpoint.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_render_sw_c.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_triangle.h" />
+    <ClInclude Include="..\..\src\SDL_assert_c.h" />
+    <ClInclude Include="..\..\src\SDL_error_c.h" />
+    <ClCompile Include="..\..\src\core\gdk\SDL_gdk.cpp">
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+    </ClCompile>
+    <ClCompile Include="..\..\src\core\windows\pch.c">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="..\..\src\core\windows\pch_cpp.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">Create</PrecompiledHeader>
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">Create</PrecompiledHeader>
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+    </ClCompile>
+    <ClCompile Include="..\..\src\filesystem\windows\SDL_sysfilesystem.c">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_render_d3d12_xbox.cpp">
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+    </ClCompile>
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_shaders_d3d12_xboxone.cpp">
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+    </ClCompile>
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_shaders_d3d12_xboxseries.cpp">
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+    </ClCompile>
+    <ClCompile Include="..\..\src\camera\dummy\SDL_camera_dummy.c" />
+    <ClCompile Include="..\..\src\camera\SDL_camera.c" />
+    <ClCompile Include="..\..\src\dialog\SDL_dialog.c" />
+    <ClCompile Include="..\..\src\dialog\SDL_dialog_utils.c" />
+    <ClCompile Include="..\..\src\filesystem\SDL_filesystem.c" />
+    <ClCompile Include="..\..\src\filesystem\windows\SDL_sysfsops.c" />
+    <ClCompile Include="..\..\src\io\generic\SDL_asyncio_generic.c" />
+    <ClCompile Include="..\..\src\io\SDL_asyncio.c" />
+    <ClCompile Include="..\..\src\io\windows\SDL_asyncio_windows_ioring.c" />
+    <ClCompile Include="..\..\src\main\gdk\SDL_sysmain_runapp.cpp" />
+    <ClCompile Include="..\..\src\main\generic\SDL_sysmain_callbacks.c" />
+    <ClCompile Include="..\..\src\main\SDL_main_callbacks.c" />
+    <ClCompile Include="..\..\src\main\SDL_runapp.c" />
+    <ClCompile Include="..\..\src\SDL_guid.c" />
+    <ClInclude Include="..\..\src\SDL_hashtable.h" />
+    <ClInclude Include="..\..\src\SDL_hints_c.h" />
+    <ClInclude Include="..\..\src\SDL_internal.h" />
+    <ClInclude Include="..\..\src\SDL_list.h" />
+    <ClInclude Include="..\..\src\SDL_log_c.h" />
+    <ClInclude Include="..\..\src\SDL_properties_c.h" />
+    <ClInclude Include="..\..\src\sensor\dummy\SDL_dummysensor.h" />
+    <ClInclude Include="..\..\src\sensor\SDL_sensor_c.h" />
+    <ClInclude Include="..\..\src\sensor\SDL_syssensor.h" />
+    <ClInclude Include="..\..\src\sensor\windows\SDL_windowssensor.h" />
+    <ClInclude Include="..\..\src\thread\generic\SDL_sysrwlock_c.h" />
+    <ClInclude Include="..\..\src\thread\SDL_systhread.h" />
+    <ClInclude Include="..\..\src\thread\SDL_thread_c.h" />
+    <ClInclude Include="..\..\src\thread\generic\SDL_syscond_c.h" />
+    <ClInclude Include="..\..\src\thread\windows\SDL_sysmutex_c.h" />
+    <ClInclude Include="..\..\src\thread\windows\SDL_systhread_c.h" />
+    <ClInclude Include="..\..\src\timer\SDL_timer_c.h" />
+    <ClInclude Include="..\..\src\video\dummy\SDL_nullevents_c.h" />
+    <ClInclude Include="..\..\src\video\dummy\SDL_nullframebuffer_c.h" />
+    <ClInclude Include="..\..\src\video\dummy\SDL_nullvideo.h" />
+    <ClInclude Include="..\..\src\video\gdk\SDL_gdktextinput.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vk_icd.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vk_layer.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vk_platform.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vk_sdk_platform.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_android.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_beta.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_core.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_directfb.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_fuchsia.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_ggp.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_ios.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_macos.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_metal.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_vi.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_wayland.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_win32.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_xcb.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_xlib.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_xlib_xrandr.h" />
+    <ClInclude Include="..\..\src\video\SDL_blit.h" />
+    <ClInclude Include="..\..\src\video\SDL_blit_auto.h" />
+    <ClInclude Include="..\..\src\video\SDL_blit_copy.h" />
+    <ClInclude Include="..\..\src\video\SDL_blit_slow.h" />
+    <ClInclude Include="..\..\src\video\SDL_clipboard_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_egl_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_pixels_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_rect_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_RLEaccel_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_rotate.h" />
+    <ClInclude Include="..\..\src\video\SDL_stb_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_surface_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_sysvideo.h" />
+    <ClInclude Include="..\..\src\video\SDL_video_unsupported.h" />
+    <ClInclude Include="..\..\src\video\SDL_vulkan_internal.h" />
+    <ClInclude Include="..\..\src\video\SDL_yuv_c.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_msctf.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_surface_utils.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsclipboard.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsevents.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsframebuffer.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowskeyboard.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsgameinput.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsmessagebox.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsmodes.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsmouse.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsopengl.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsopengles.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsrawinput.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsshape.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsvideo.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsvulkan.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowswindow.h" />
+    <ClInclude Include="..\..\src\video\windows\wmmsg.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_common.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_internal.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_lsx.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_lsx_func.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_sse.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_std.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_sse_func.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_std_func.h" />
+    <ClCompile Include="..\..\src\atomic\SDL_atomic.c" />
+    <ClCompile Include="..\..\src\atomic\SDL_spinlock.c" />
+    <ClCompile Include="..\..\src\audio\directsound\SDL_directsound.c" />
+    <ClCompile Include="..\..\src\audio\disk\SDL_diskaudio.c" />
+    <ClCompile Include="..\..\src\audio\dummy\SDL_dummyaudio.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audio.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audiocvt.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audiodev.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audiotypecvt.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audioqueue.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audioresample.c" />
+    <ClCompile Include="..\..\src\audio\SDL_mixer.c" />
+    <ClCompile Include="..\..\src\audio\SDL_wave.c" />
+    <ClCompile Include="..\..\src\audio\wasapi\SDL_wasapi.c" />
+    <ClCompile Include="..\..\src\core\SDL_core_unsupported.c" />
+    <ClCompile Include="..\..\src\core\windows\SDL_gameinput.cpp"/>
+    <ClCompile Include="..\..\src\core\windows\SDL_hid.c" />
+    <ClCompile Include="..\..\src\core\windows\SDL_immdevice.c" />
+    <ClCompile Include="..\..\src\core\windows\SDL_windows.c" />
+    <ClCompile Include="..\..\src\core\windows\SDL_xinput.c">
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">stdcpp17</LanguageStandard>
+    </ClCompile>
+    <ClCompile Include="..\..\src\cpuinfo\SDL_cpuinfo.c" />
+    <ClCompile Include="..\..\src\dialog\dummy\SDL_dummydialog.c">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\src\dialog\windows\SDL_windowsdialog.c">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\src\dynapi\SDL_dynapi.c">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">NotUsing</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="..\..\src\events\SDL_categories.c" />
+    <ClCompile Include="..\..\src\events\SDL_clipboardevents.c" />
+    <ClCompile Include="..\..\src\events\SDL_displayevents.c" />
+    <ClCompile Include="..\..\src\events\SDL_dropevents.c" />
+    <ClCompile Include="..\..\src\events\SDL_events.c" />
+    <ClCompile Include="..\..\src\events\SDL_eventwatch.c" />
+    <ClCompile Include="..\..\src\events\SDL_keyboard.c" />
+    <ClCompile Include="..\..\src\events\SDL_keymap.c" />
+    <ClCompile Include="..\..\src\events\SDL_mouse.c" />
+    <ClCompile Include="..\..\src\events\SDL_pen.c" />
+    <ClCompile Include="..\..\src\events\SDL_quit.c" />
+    <ClCompile Include="..\..\src\events\SDL_touch.c" />
+    <ClCompile Include="..\..\src\events\SDL_windowevents.c" />
+    <ClCompile Include="..\..\src\io\SDL_iostream.c" />
+    <ClCompile Include="..\..\src\filesystem\gdk\SDL_sysfilesystem.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\src\haptic\dummy\SDL_syshaptic.c" />
+    <ClCompile Include="..\..\src\haptic\SDL_haptic.c" />
+    <ClCompile Include="..\..\src\haptic\windows\SDL_dinputhaptic.c" />
+    <ClCompile Include="..\..\src\haptic\windows\SDL_windowshaptic.c">
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">stdcpp17</LanguageStandard>
+    </ClCompile>
+    <ClCompile Include="..\..\src\haptic\hidapi\SDL_hidapihaptic.c" />
+    <ClCompile Include="..\..\src\haptic\hidapi\SDL_hidapihaptic_lg4ff.c" />
+    <ClCompile Include="..\..\src\hidapi\SDL_hidapi.c" />
+    <ClCompile Include="..\..\src\joystick\controller_type.c" />
+    <ClCompile Include="..\..\src\joystick\dummy\SDL_sysjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\gdk\SDL_gameinputjoystick.cpp" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapijoystick.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_8bitdo.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_flydigi.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_gamesir.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_combined.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_gamecube.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_gip.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_luna.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_ps3.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_ps4.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_ps5.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_rumble.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_shield.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_sinput.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_stadia.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_steam.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_steam_hori.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_steamdeck.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_steam_triton.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_switch.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_switch2.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_wii.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_xbox360.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_xbox360w.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_xboxone.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_lg4ff.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_zuiki.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_report_descriptor.c" />
+    <ClCompile Include="..\..\src\joystick\SDL_gamepad.c" />
+    <ClCompile Include="..\..\src\joystick\SDL_joystick.c" />
+    <ClCompile Include="..\..\src\joystick\SDL_steam_virtual_gamepad.c" />
+    <ClCompile Include="..\..\src\joystick\virtual\SDL_virtualjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_dinputjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_rawinputjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_windowsjoystick.c">
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">stdcpp17</LanguageStandard>
+    </ClCompile>
+    <ClCompile Include="..\..\src\joystick\windows\SDL_windows_gaming_input.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_xinputjoystick.c">
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">stdcpp17</LanguageStandard>
+      <LanguageStandard Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">stdcpp17</LanguageStandard>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+    </ClCompile>
+    <ClCompile Include="..\..\src\libm\s_modf.c" />
+    <ClCompile Include="..\..\src\loadso\windows\SDL_sysloadso.c" />
+    <ClCompile Include="..\..\src\locale\SDL_locale.c" />
+    <ClCompile Include="..\..\src\locale\windows\SDL_syslocale.c" />
+    <ClCompile Include="..\..\src\misc\SDL_libusb.c" />
+    <ClCompile Include="..\..\src\misc\SDL_url.c" />
+    <ClCompile Include="..\..\src\misc\windows\SDL_sysurl.c" />
+    <ClCompile Include="..\..\src\power\SDL_power.c" />
+    <ClCompile Include="..\..\src\power\windows\SDL_syspower.c" />
+    <ClCompile Include="..\..\src\process\SDL_process.c" />
+    <ClCompile Include="..\..\src\process\dummy\SDL_dummyprocess.c" />
+    <ClCompile Include="..\..\src\process\windows\SDL_windowsprocess.c" />
+    <ClCompile Include="..\..\src\render\direct3d11\SDL_shaders_d3d11.c" />
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_render_d3d12.c">
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+    </ClCompile>
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_shaders_d3d12.c" />
+    <ClCompile Include="..\..\src\render\direct3d\SDL_render_d3d.c" />
+    <ClCompile Include="..\..\src\render\direct3d11\SDL_render_d3d11.c" />
+    <ClCompile Include="..\..\src\render\direct3d\SDL_shaders_d3d.c" />
+    <ClCompile Include="..\..\src\render\gpu\SDL_pipeline_gpu.c" />
+    <ClCompile Include="..\..\src\render\gpu\SDL_render_gpu.c" />
+    <ClCompile Include="..\..\src\render\gpu\SDL_shaders_gpu.c" />
+    <ClCompile Include="..\..\src\render\opengl\SDL_render_gl.c" />
+    <ClCompile Include="..\..\src\render\opengl\SDL_shaders_gl.c" />
+    <ClCompile Include="..\..\src\render\opengles2\SDL_render_gles2.c" />
+    <ClCompile Include="..\..\src\render\opengles2\SDL_shaders_gles2.c" />
+    <ClCompile Include="..\..\src\render\SDL_render.c" />
+    <ClCompile Include="..\..\src\render\SDL_render_unsupported.c" />
+    <ClCompile Include="..\..\src\render\SDL_yuv_sw.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_blendfillrect.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_blendline.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_blendpoint.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_drawline.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_drawpoint.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_render_sw.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_triangle.c" />
+    <ClCompile Include="..\..\src\render\vulkan\SDL_render_vulkan.c" />
+    <ClCompile Include="..\..\src\render\vulkan\SDL_shaders_vulkan.c" />
+    <ClCompile Include="..\..\src\SDL.c" />
+    <ClCompile Include="..\..\src\SDL_assert.c" />
+    <ClCompile Include="..\..\src\SDL_list.c" />
+    <ClCompile Include="..\..\src\SDL_error.c" />
+    <ClCompile Include="..\..\src\SDL_hashtable.c" />
+    <ClCompile Include="..\..\src\SDL_hints.c" />
+    <ClCompile Include="..\..\src\SDL_log.c" />
+    <ClCompile Include="..\..\src\SDL_properties.c" />
+    <ClCompile Include="..\..\src\SDL_utils.c" />
+    <ClCompile Include="..\..\src\sensor\dummy\SDL_dummysensor.c" />
+    <ClCompile Include="..\..\src\sensor\SDL_sensor.c" />
+    <ClCompile Include="..\..\src\sensor\windows\SDL_windowssensor.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_crc16.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_crc32.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_getenv.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_iconv.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_malloc.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_memcpy.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_memmove.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_memset.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_mslibc.c" />
+    <MASM Condition="'$(Platform)'=='x64'" Include="..\..\src\stdlib\SDL_mslibc_x64.masm">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </MASM>
+    <ClCompile Include="..\..\src\stdlib\SDL_murmur3.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_qsort.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_random.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_stdlib.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_string.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_strtokr.c" />
+    <ClCompile Include="..\..\src\storage\generic\SDL_genericstorage.c" />
+    <ClCompile Include="..\..\src\storage\SDL_storage.c" />
+    <ClCompile Include="..\..\src\thread\generic\SDL_syscond.c" />
+    <ClCompile Include="..\..\src\thread\generic\SDL_sysrwlock.c" />
+    <ClCompile Include="..\..\src\thread\SDL_thread.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_syscond_cv.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_sysmutex.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_sysrwlock_srw.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_syssem.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_systhread.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_systls.c" />
+    <ClCompile Include="..\..\src\timer\SDL_timer.c" />
+    <ClCompile Include="..\..\src\timer\windows\SDL_systimer.c" />
+    <ClCompile Include="..\..\src\time\SDL_time.c" />
+    <ClCompile Include="..\..\src\time\windows\SDL_systime.c" />
+    <ClCompile Include="..\..\src\tray\dummy\SDL_tray.c">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\src\tray\windows\SDL_tray.c">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\src\tray\SDL_tray_utils.c" />
+    <ClCompile Include="..\..\src\video\dummy\SDL_nullevents.c" />
+    <ClCompile Include="..\..\src\video\dummy\SDL_nullframebuffer.c" />
+    <ClCompile Include="..\..\src\video\dummy\SDL_nullvideo.c" />
+    <ClCompile Include="..\..\src\video\gdk\SDL_gdktextinput.cpp">
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+      <PrecompiledHeaderOutputFile Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(IntDir)$(TargetName)_cpp.pch</PrecompiledHeaderOutputFile>
+    </ClCompile>
+    <ClCompile Include="..\..\src\video\SDL_blit.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_0.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_1.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_A.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_auto.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_copy.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_N.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_slow.c" />
+    <ClCompile Include="..\..\src\video\SDL_bmp.c" />
+    <ClCompile Include="..\..\src\video\SDL_clipboard.c" />
+    <ClCompile Include="..\..\src\video\SDL_egl.c" />
+    <ClCompile Include="..\..\src\video\SDL_fillrect.c" />
+    <ClCompile Include="..\..\src\video\SDL_pixels.c" />
+    <ClCompile Include="..\..\src\video\SDL_rect.c" />
+    <ClCompile Include="..\..\src\video\SDL_RLEaccel.c" />
+    <ClCompile Include="..\..\src\video\SDL_rotate.c" />
+    <ClCompile Include="..\..\src\video\SDL_stb.c" />
+    <ClCompile Include="..\..\src\video\SDL_stretch.c" />
+    <ClCompile Include="..\..\src\video\SDL_surface.c" />
+    <ClCompile Include="..\..\src\video\SDL_video.c" />
+    <ClCompile Include="..\..\src\video\SDL_video_unsupported.c" />
+    <ClCompile Include="..\..\src\video\SDL_vulkan_utils.c" />
+    <ClCompile Include="..\..\src\video\SDL_yuv.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsclipboard.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsevents.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsframebuffer.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowskeyboard.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsgameinput.cpp" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsmessagebox.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsmodes.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsmouse.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsopengl.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsopengles.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsrawinput.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsshape.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsvideo.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsvulkan.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowswindow.c" />
+    <ClCompile Include="..\..\src\video\yuv2rgb\yuv_rgb_lsx.c" />
+    <ClCompile Include="..\..\src\video\yuv2rgb\yuv_rgb_sse.c" />
+    <ClCompile Include="..\..\src\video\yuv2rgb\yuv_rgb_std.c" />
+    <ClCompile Include="..\..\src\gpu\SDL_gpu.c" />
+    <ClCompile Include="..\..\src\gpu\d3d12\SDL_gpu_d3d12.c">
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">CompileAsCpp</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">CompileAsCpp</CompileAs>
+    </ClCompile>
+    <ClCompile Include="..\..\src\gpu\vulkan\SDL_gpu_vulkan.c" />
+    <ClCompile Include="..\..\src\gpu\xr\SDL_gpu_openxr.c" />
+    <ClCompile Include="..\..\src\gpu\xr\SDL_openxrdyn.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\src\gpu\xr\SDL_gpu_openxr_c.h" />
+    <ClInclude Include="..\..\src\gpu\xr\SDL_openxr_internal.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="..\..\src\core\windows\version.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(VCTargetsPath)\BuildCustomizations\masm.targets" />
+  </ImportGroup>
+</Project>

external/SDL/VisualC-GDK/SDL/SDL.vcxproj.filters

@@ -0,0 +1,516 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\..\src\core\gdk\SDL_gdk.cpp" />
+    <ClCompile Include="..\..\src\core\windows\pch.c" />
+    <ClCompile Include="..\..\src\core\windows\pch_cpp.cpp" />
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_render_d3d12_xbox.cpp" />
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_shaders_d3d12_xboxone.cpp" />
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_shaders_d3d12_xboxseries.cpp" />
+    <ClCompile Include="..\..\src\main\generic\SDL_sysmain_callbacks.c" />
+    <ClCompile Include="..\..\src\main\SDL_main_callbacks.c" />
+    <ClCompile Include="..\..\src\main\gdk\SDL_sysmain_runapp.cpp" />
+    <ClCompile Include="..\..\src\main\SDL_runapp.c" />
+    <ClCompile Include="..\..\src\SDL_guid.c" />
+    <ClCompile Include="..\..\src\atomic\SDL_atomic.c" />
+    <ClCompile Include="..\..\src\atomic\SDL_spinlock.c" />
+    <ClCompile Include="..\..\src\audio\directsound\SDL_directsound.c" />
+    <ClCompile Include="..\..\src\audio\disk\SDL_diskaudio.c" />
+    <ClCompile Include="..\..\src\audio\dummy\SDL_dummyaudio.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audio.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audiocvt.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audiodev.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audiotypecvt.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audioqueue.c" />
+    <ClCompile Include="..\..\src\audio\SDL_audioresample.c" />
+    <ClCompile Include="..\..\src\audio\SDL_mixer.c" />
+    <ClCompile Include="..\..\src\audio\SDL_wave.c" />
+    <ClCompile Include="..\..\src\audio\wasapi\SDL_wasapi.c" />
+    <ClCompile Include="..\..\src\core\SDL_core_unsupported.c" />
+    <ClCompile Include="..\..\src\core\windows\SDL_gameinput.cpp" />
+    <ClCompile Include="..\..\src\core\windows\SDL_hid.c" />
+    <ClCompile Include="..\..\src\core\windows\SDL_immdevice.c" />
+    <ClCompile Include="..\..\src\core\windows\SDL_windows.c" />
+    <ClCompile Include="..\..\src\core\windows\SDL_xinput.c" />
+    <ClCompile Include="..\..\src\cpuinfo\SDL_cpuinfo.c" />
+    <ClCompile Include="..\..\src\dynapi\SDL_dynapi.c" />
+    <ClCompile Include="..\..\src\events\SDL_categories.c" />
+    <ClCompile Include="..\..\src\events\SDL_clipboardevents.c" />
+    <ClCompile Include="..\..\src\events\SDL_displayevents.c" />
+    <ClCompile Include="..\..\src\events\SDL_dropevents.c" />
+    <ClCompile Include="..\..\src\events\SDL_events.c" />
+    <ClCompile Include="..\..\src\events\SDL_eventwatch.c" />
+    <ClCompile Include="..\..\src\events\SDL_keyboard.c" />
+    <ClCompile Include="..\..\src\events\SDL_keymap.c" />
+    <ClCompile Include="..\..\src\events\SDL_mouse.c" />
+    <ClCompile Include="..\..\src\events\SDL_pen.c" />
+    <ClCompile Include="..\..\src\events\SDL_quit.c" />
+    <ClCompile Include="..\..\src\events\SDL_touch.c" />
+    <ClCompile Include="..\..\src\events\SDL_windowevents.c" />
+    <ClCompile Include="..\..\src\io\SDL_iostream.c" />
+    <ClCompile Include="..\..\src\filesystem\gdk\SDL_sysfilesystem.cpp" />
+    <ClCompile Include="..\..\src\gpu\SDL_gpu.c" />
+    <ClCompile Include="..\..\src\gpu\d3d12\SDL_gpu_d3d12.c" />
+    <ClCompile Include="..\..\src\gpu\vulkan\SDL_gpu_vulkan.c" />
+    <ClCompile Include="..\..\src\gpu\xr\SDL_gpu_openxr.c" />
+    <ClCompile Include="..\..\src\gpu\xr\SDL_openxrdyn.c" />
+    <ClInclude Include="..\..\src\gpu\xr\SDL_openxr_internal.h" />
+    <ClCompile Include="..\..\src\haptic\dummy\SDL_syshaptic.c" />
+    <ClCompile Include="..\..\src\haptic\SDL_haptic.c" />
+    <ClCompile Include="..\..\src\haptic\windows\SDL_dinputhaptic.c" />
+    <ClCompile Include="..\..\src\haptic\windows\SDL_windowshaptic.c" />
+    <ClCompile Include="..\..\src\haptic\hidapi\SDL_hidapihaptic.c" />
+    <ClCompile Include="..\..\src\haptic\hidapi\SDL_hidapihaptic_lg4ff.c" />
+    <ClCompile Include="..\..\src\hidapi\SDL_hidapi.c" />
+    <ClCompile Include="..\..\src\joystick\controller_type.c" />
+    <ClCompile Include="..\..\src\joystick\dummy\SDL_sysjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\gdk\SDL_gameinputjoystick.cpp" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapijoystick.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_8bitdo.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_flydigi.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_gamesir.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_combined.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_gamecube.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_gip.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_luna.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_ps3.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_ps4.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_ps5.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_rumble.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_shield.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_sinput.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_stadia.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_steam.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_steam_hori.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_steamdeck.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_steam_triton.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_switch.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_switch2.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_wii.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_xbox360.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_xbox360w.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_xboxone.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_lg4ff.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_hidapi_zuiki.c" />
+    <ClCompile Include="..\..\src\joystick\hidapi\SDL_report_descriptor.c" />
+    <ClCompile Include="..\..\src\joystick\SDL_gamepad.c" />
+    <ClCompile Include="..\..\src\joystick\SDL_joystick.c" />
+    <ClCompile Include="..\..\src\joystick\SDL_steam_virtual_gamepad.c" />
+    <ClCompile Include="..\..\src\joystick\virtual\SDL_virtualjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_dinputjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_rawinputjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_windowsjoystick.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_windows_gaming_input.c" />
+    <ClCompile Include="..\..\src\joystick\windows\SDL_xinputjoystick.c" />
+    <ClCompile Include="..\..\src\libm\s_modf.c" />
+    <ClCompile Include="..\..\src\loadso\windows\SDL_sysloadso.c" />
+    <ClCompile Include="..\..\src\locale\SDL_locale.c" />
+    <ClCompile Include="..\..\src\locale\windows\SDL_syslocale.c" />
+    <ClCompile Include="..\..\src\misc\SDL_libusb.c" />
+    <ClCompile Include="..\..\src\misc\SDL_url.c" />
+    <ClCompile Include="..\..\src\misc\windows\SDL_sysurl.c" />
+    <ClCompile Include="..\..\src\power\SDL_power.c" />
+    <ClCompile Include="..\..\src\process\SDL_process.c" />
+    <ClCompile Include="..\..\src\process\dummy\SDL_dummyprocess.c" />
+    <ClCompile Include="..\..\src\process\windows\SDL_windowsprocess.c" />
+    <ClCompile Include="..\..\src\power\windows\SDL_syspower.c" />
+    <ClCompile Include="..\..\src\render\direct3d11\SDL_shaders_d3d11.c" />
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_render_d3d12.c" />
+    <ClCompile Include="..\..\src\render\direct3d12\SDL_shaders_d3d12.c" />
+    <ClCompile Include="..\..\src\render\direct3d\SDL_render_d3d.c" />
+    <ClCompile Include="..\..\src\render\direct3d11\SDL_render_d3d11.c" />
+    <ClCompile Include="..\..\src\render\direct3d\SDL_shaders_d3d.c" />
+    <ClCompile Include="..\..\src\render\opengl\SDL_render_gl.c" />
+    <ClCompile Include="..\..\src\render\opengl\SDL_shaders_gl.c" />
+    <ClCompile Include="..\..\src\render\opengles2\SDL_render_gles2.c" />
+    <ClCompile Include="..\..\src\render\opengles2\SDL_shaders_gles2.c" />
+    <ClCompile Include="..\..\src\render\SDL_render.c" />
+    <ClCompile Include="..\..\src\render\SDL_render_unsupported.c" />
+    <ClCompile Include="..\..\src\render\SDL_yuv_sw.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_blendfillrect.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_blendline.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_blendpoint.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_drawline.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_drawpoint.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_render_sw.c" />
+    <ClCompile Include="..\..\src\render\software\SDL_triangle.c" />
+    <ClCompile Include="..\..\src\SDL.c" />
+    <ClCompile Include="..\..\src\SDL_assert.c" />
+    <ClCompile Include="..\..\src\SDL_list.c" />
+    <ClCompile Include="..\..\src\SDL_error.c" />
+    <ClCompile Include="..\..\src\SDL_hashtable.c" />
+    <ClCompile Include="..\..\src\SDL_hints.c" />
+    <ClCompile Include="..\..\src\SDL_log.c" />
+    <ClCompile Include="..\..\src\SDL_properties.c" />
+    <ClCompile Include="..\..\src\SDL_utils.c" />
+    <ClCompile Include="..\..\src\sensor\dummy\SDL_dummysensor.c" />
+    <ClCompile Include="..\..\src\sensor\SDL_sensor.c" />
+    <ClCompile Include="..\..\src\sensor\windows\SDL_windowssensor.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_crc16.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_crc32.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_getenv.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_iconv.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_malloc.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_memcpy.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_memmove.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_memset.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_mslibc.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_murmur3.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_qsort.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_random.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_stdlib.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_string.c" />
+    <ClCompile Include="..\..\src\stdlib\SDL_strtokr.c" />
+    <ClCompile Include="..\..\src\thread\generic\SDL_syscond.c" />
+    <ClCompile Include="..\..\src\thread\generic\SDL_sysrwlock.c" />
+    <ClCompile Include="..\..\src\thread\SDL_thread.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_syscond_cv.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_sysmutex.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_sysrwlock_srw.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_syssem.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_systhread.c" />
+    <ClCompile Include="..\..\src\thread\windows\SDL_systls.c" />
+    <ClCompile Include="..\..\src\timer\SDL_timer.c" />
+    <ClCompile Include="..\..\src\timer\windows\SDL_systimer.c" />
+    <ClCompile Include="..\..\src\video\dummy\SDL_nullevents.c" />
+    <ClCompile Include="..\..\src\video\dummy\SDL_nullframebuffer.c" />
+    <ClCompile Include="..\..\src\video\dummy\SDL_nullvideo.c" />
+    <ClCompile Include="..\..\src\video\gdk\SDL_gdktextinput.cpp" />
+    <ClCompile Include="..\..\src\video\SDL_blit.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_0.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_1.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_A.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_auto.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_copy.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_N.c" />
+    <ClCompile Include="..\..\src\video\SDL_blit_slow.c" />
+    <ClCompile Include="..\..\src\video\SDL_bmp.c" />
+    <ClCompile Include="..\..\src\video\SDL_clipboard.c" />
+    <ClCompile Include="..\..\src\video\SDL_egl.c" />
+    <ClCompile Include="..\..\src\video\SDL_fillrect.c" />
+    <ClCompile Include="..\..\src\video\SDL_pixels.c" />
+    <ClCompile Include="..\..\src\video\SDL_rect.c" />
+    <ClCompile Include="..\..\src\video\SDL_RLEaccel.c" />
+    <ClCompile Include="..\..\src\video\SDL_rotate.c" />
+    <ClCompile Include="..\..\src\video\SDL_stb.c" />
+    <ClCompile Include="..\..\src\video\SDL_stretch.c" />
+    <ClCompile Include="..\..\src\video\SDL_surface.c" />
+    <ClCompile Include="..\..\src\video\SDL_video.c" />
+    <ClCompile Include="..\..\src\video\SDL_video_unsupported.c" />
+    <ClCompile Include="..\..\src\video\SDL_vulkan_utils.c" />
+    <ClCompile Include="..\..\src\video\SDL_yuv.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsclipboard.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsevents.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsframebuffer.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowskeyboard.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsgameinput.cpp" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsmessagebox.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsmodes.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsmouse.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsopengl.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsopengles.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsrawinput.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsshape.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsvideo.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowsvulkan.c" />
+    <ClCompile Include="..\..\src\video\windows\SDL_windowswindow.c" />
+    <ClCompile Include="..\..\src\filesystem\windows\SDL_sysfilesystem.c" />
+    <ClCompile Include="..\..\src\camera\dummy\SDL_camera_dummy.c" />
+    <ClCompile Include="..\..\src\camera\SDL_camera.c" />
+    <ClCompile Include="..\..\src\dialog\SDL_dialog.c" />
+    <ClCompile Include="..\..\src\dialog\SDL_dialog_utils.c" />
+    <ClCompile Include="..\..\src\filesystem\SDL_filesystem.c" />
+    <ClCompile Include="..\..\src\filesystem\windows\SDL_sysfsops.c" />
+    <ClCompile Include="..\..\src\io\generic\SDL_asyncio_generic.c" />
+    <ClCompile Include="..\..\src\io\SDL_asyncio.c" />
+    <ClCompile Include="..\..\src\io\windows\SDL_asyncio_windows_ioring.c" />
+    <ClCompile Include="..\..\src\dialog\dummy\SDL_dummydialog.c" />
+    <ClCompile Include="..\..\src\dialog\windows\SDL_windowsdialog.c" />
+    <ClCompile Include="..\..\src\render\gpu\SDL_pipeline_gpu.c" />
+    <ClCompile Include="..\..\src\render\gpu\SDL_render_gpu.c" />
+    <ClCompile Include="..\..\src\render\gpu\SDL_shaders_gpu.c" />
+    <ClCompile Include="..\..\src\render\vulkan\SDL_render_vulkan.c" />
+    <ClCompile Include="..\..\src\render\vulkan\SDL_shaders_vulkan.c" />
+    <ClCompile Include="..\..\src\storage\generic\SDL_genericstorage.c" />
+    <ClCompile Include="..\..\src\storage\SDL_storage.c" />
+    <ClCompile Include="..\..\src\time\SDL_time.c" />
+    <ClCompile Include="..\..\src\time\windows\SDL_systime.c" />
+    <ClCompile Include="..\..\src\tray\dummy\SDL_tray.c" />
+    <ClCompile Include="..\..\src\tray\windows\SDL_tray.c" />
+    <ClCompile Include="..\..\src\tray\SDL_tray_utils.c" />
+    <ClCompile Include="..\..\src\video\yuv2rgb\yuv_rgb_lsx.c" />
+    <ClCompile Include="..\..\src\video\yuv2rgb\yuv_rgb_sse.c" />
+    <ClCompile Include="..\..\src\video\yuv2rgb\yuv_rgb_std.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\SDL3\SDL.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_assert.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_asyncio.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_atomic.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_audio.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_begin_code.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_bits.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_blendmode.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_camera.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_clipboard.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_close_code.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_copying.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_cpuinfo.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_dialog.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_dlopennote.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_egl.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_endian.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_error.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_events.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_filesystem.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_gamepad.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_gpu.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_guid.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_haptic.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_hidapi.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_hints.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_init.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_intrin.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_iostream.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_joystick.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_keyboard.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_keycode.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_loadso.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_locale.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_log.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_main.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_main_impl.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_messagebox.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_metal.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_misc.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_mouse.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_mutex.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_oldnames.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengl.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengl_glext.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2_gl2.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2_gl2ext.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2_gl2platform.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_opengles2_khrplatform.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_pen.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_pixels.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_platform.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_platform_defines.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_power.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_process.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_properties.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_rect.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_render.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_revision.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_scancode.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_sensor.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_stdinc.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_storage.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_surface.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_system.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_assert.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_common.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_compare.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_crc32.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_font.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_fuzzer.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_harness.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_log.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_md5.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_memory.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_thread.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_time.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_timer.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_touch.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_tray.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_version.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_video.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_vulkan.h" />
+    <ClInclude Include="..\..\src\audio\directsound\SDL_directsound.h" />
+    <ClInclude Include="..\..\src\audio\disk\SDL_diskaudio.h" />
+    <ClInclude Include="..\..\src\audio\dummy\SDL_dummyaudio.h" />
+    <ClInclude Include="..\..\src\audio\SDL_audio_c.h" />
+    <ClInclude Include="..\..\src\audio\SDL_audiodev_c.h" />
+    <ClInclude Include="..\..\src\audio\SDL_sysaudio.h" />
+    <ClInclude Include="..\..\src\audio\SDL_audioqueue.h" />
+    <ClInclude Include="..\..\src\audio\SDL_audioresample.h" />
+    <ClInclude Include="..\..\src\audio\SDL_wave.h" />
+    <ClInclude Include="..\..\src\audio\wasapi\SDL_wasapi.h" />
+    <ClInclude Include="..\..\src\core\gdk\SDL_gdk.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_directx.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_gameinput.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_hid.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_immdevice.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_windows.h" />
+    <ClInclude Include="..\..\src\core\windows\SDL_xinput.h" />
+    <ClInclude Include="..\..\src\core\SDL_core_unsupported.h" />
+    <ClInclude Include="..\..\src\cpuinfo\SDL_cpuinfo_c.h" />
+    <ClInclude Include="..\..\src\dynapi\SDL_dynapi.h" />
+    <ClInclude Include="..\..\src\dynapi\SDL_dynapi_overrides.h" />
+    <ClInclude Include="..\..\src\dynapi\SDL_dynapi_procs.h" />
+    <ClInclude Include="..\..\src\events\blank_cursor.h" />
+    <ClInclude Include="..\..\src\events\default_cursor.h" />
+    <ClInclude Include="..\..\src\events\scancodes_windows.h" />
+    <ClInclude Include="..\..\src\events\SDL_categories_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_clipboardevents_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_displayevents_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_dropevents_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_events_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_eventwatch_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_keyboard_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_keymap_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_mouse_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_touch_c.h" />
+    <ClInclude Include="..\..\src\events\SDL_windowevents_c.h" />
+    <ClInclude Include="..\..\src\gpu\SDL_sysgpu.h" />
+    <ClInclude Include="..\..\src\haptic\SDL_haptic_c.h" />
+    <ClInclude Include="..\..\src\haptic\SDL_syshaptic.h" />
+    <ClInclude Include="..\..\src\haptic\SDL_hidapihaptic.h" />
+    <ClInclude Include="..\..\src\haptic\windows\SDL_dinputhaptic_c.h" />
+    <ClInclude Include="..\..\src\haptic\windows\SDL_windowshaptic_c.h" />
+    <ClInclude Include="..\..\src\haptic\hidapi\SDL_hidapihaptic_c.h" />
+    <ClInclude Include="..\..\src\hidapi\hidapi\hidapi.h" />
+    <ClInclude Include="..\..\src\hidapi\SDL_hidapi_c.h" />
+    <ClInclude Include="..\..\src\joystick\controller_type.h" />
+    <ClInclude Include="..\..\src\joystick\hidapi\SDL_hidapijoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\hidapi\SDL_hidapi_rumble.h" />
+    <ClInclude Include="..\..\src\joystick\hidapi\SDL_report_descriptor.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_gamepad_c.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_gamepad_db.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_joystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_steam_virtual_gamepad.h" />
+    <ClInclude Include="..\..\src\joystick\SDL_sysjoystick.h" />
+    <ClInclude Include="..\..\src\joystick\usb_ids.h" />
+    <ClInclude Include="..\..\src\joystick\virtual\SDL_virtualjoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\windows\SDL_dinputjoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\windows\SDL_rawinputjoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\windows\SDL_windowsjoystick_c.h" />
+    <ClInclude Include="..\..\src\joystick\windows\SDL_xinputjoystick_c.h" />
+    <ClInclude Include="..\..\src\libm\math_libm.h" />
+    <ClInclude Include="..\..\src\libm\math_private.h" />
+    <ClInclude Include="..\..\src\locale\SDL_syslocale.h" />
+    <ClInclude Include="..\..\src\main\SDL_main_callbacks.h" />
+    <ClInclude Include="..\..\src\misc\SDL_sysurl.h" />
+    <ClInclude Include="..\..\src\power\SDL_syspower.h" />
+    <ClInclude Include="..\..\src\render\direct3d11\SDL_shaders_d3d11.h" />
+    <ClInclude Include="..\..\src\render\direct3d12\SDL_render_d3d12_xbox.h" />
+    <ClInclude Include="..\..\src\render\direct3d12\SDL_shaders_d3d12.h" />
+    <ClInclude Include="..\..\src\render\direct3d\SDL_shaders_d3d.h" />
+    <ClInclude Include="..\..\src\render\opengles2\SDL_gles2funcs.h" />
+    <ClInclude Include="..\..\src\render\opengles2\SDL_shaders_gles2.h" />
+    <ClInclude Include="..\..\src\render\opengl\SDL_glfuncs.h" />
+    <ClInclude Include="..\..\src\render\opengl\SDL_shaders_gl.h" />
+    <ClInclude Include="..\..\src\render\SDL_d3dmath.h" />
+    <ClInclude Include="..\..\src\render\SDL_sysrender.h" />
+    <ClInclude Include="..\..\src\render\SDL_yuv_sw_c.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_blendfillrect.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_blendline.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_blendpoint.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_draw.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_drawline.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_drawpoint.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_render_sw_c.h" />
+    <ClInclude Include="..\..\src\render\software\SDL_triangle.h" />
+    <ClInclude Include="..\..\src\SDL_assert_c.h" />
+    <ClInclude Include="..\..\src\SDL_error_c.h" />
+    <ClInclude Include="..\..\src\SDL_hashtable.h" />
+    <ClInclude Include="..\..\src\SDL_hints_c.h" />
+    <ClInclude Include="..\..\src\SDL_internal.h" />
+    <ClInclude Include="..\..\src\SDL_list.h" />
+    <ClInclude Include="..\..\src\SDL_log_c.h" />
+    <ClInclude Include="..\..\src\SDL_properties_c.h" />
+    <ClInclude Include="..\..\src\sensor\dummy\SDL_dummysensor.h" />
+    <ClInclude Include="..\..\src\sensor\SDL_sensor_c.h" />
+    <ClInclude Include="..\..\src\sensor\SDL_syssensor.h" />
+    <ClInclude Include="..\..\src\sensor\windows\SDL_windowssensor.h" />
+    <ClInclude Include="..\..\src\thread\generic\SDL_sysrwlock_c.h" />
+    <ClInclude Include="..\..\src\thread\SDL_systhread.h" />
+    <ClInclude Include="..\..\src\thread\SDL_thread_c.h" />
+    <ClInclude Include="..\..\src\thread\generic\SDL_syscond_c.h" />
+    <ClInclude Include="..\..\src\thread\windows\SDL_sysmutex_c.h" />
+    <ClInclude Include="..\..\src\thread\windows\SDL_systhread_c.h" />
+    <ClInclude Include="..\..\src\timer\SDL_timer_c.h" />
+    <ClInclude Include="..\..\src\video\dummy\SDL_nullevents_c.h" />
+    <ClInclude Include="..\..\src\video\dummy\SDL_nullframebuffer_c.h" />
+    <ClInclude Include="..\..\src\video\dummy\SDL_nullvideo.h" />
+    <ClInclude Include="..\..\src\video\gdk\SDL_gdktextinput.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vk_icd.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vk_layer.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vk_platform.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vk_sdk_platform.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_android.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_beta.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_core.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_directfb.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_fuchsia.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_ggp.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_ios.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_macos.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_metal.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_vi.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_wayland.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_win32.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_xcb.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_xlib.h" />
+    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_xlib_xrandr.h" />
+    <ClInclude Include="..\..\src\video\SDL_blit.h" />
+    <ClInclude Include="..\..\src\video\SDL_blit_auto.h" />
+    <ClInclude Include="..\..\src\video\SDL_blit_copy.h" />
+    <ClInclude Include="..\..\src\video\SDL_blit_slow.h" />
+    <ClInclude Include="..\..\src\video\SDL_clipboard_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_egl_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_pixels_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_rect_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_RLEaccel_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_rotate.h" />
+    <ClInclude Include="..\..\src\video\SDL_stb_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_surface_c.h" />
+    <ClInclude Include="..\..\src\video\SDL_sysvideo.h" />
+    <ClInclude Include="..\..\src\video\SDL_video_unsupported.h" />
+    <ClInclude Include="..\..\src\video\SDL_vulkan_internal.h" />
+    <ClInclude Include="..\..\src\video\SDL_yuv_c.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_msctf.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_surface_utils.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsclipboard.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsevents.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsframebuffer.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowskeyboard.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsgameinput.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsmessagebox.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsmodes.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsmouse.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsopengl.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsopengles.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsrawinput.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsshape.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsvideo.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowsvulkan.h" />
+    <ClInclude Include="..\..\src\video\windows\SDL_windowswindow.h" />
+    <ClInclude Include="..\..\src\video\windows\wmmsg.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_sse_func.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_std_func.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_camera.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_asyncio.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_storage.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_time.h" />
+    <ClInclude Include="..\..\src\camera\SDL_camera_c.h" />
+    <ClInclude Include="..\..\src\camera\SDL_syscamera.h" />
+    <ClInclude Include="..\..\src\filesystem\SDL_sysfilesystem.h" />
+    <ClInclude Include="..\..\src\io\SDL_asyncio_c.h" />
+    <ClInclude Include="..\..\src\io\SDL_sysasyncio.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_common.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_internal.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_lsx.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_lsx_func.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_sse.h" />
+    <ClInclude Include="..\..\src\video\yuv2rgb\yuv_rgb_std.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="..\..\src\core\windows\version.rc" />
+  </ItemGroup>
+</Project>

external/SDL/VisualC-GDK/SDL_test/SDL_test.vcxproj

@@ -0,0 +1,216 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Gaming.Desktop.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Desktop.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectName>SDL3_test</ProjectName>
+    <ProjectGuid>{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}</ProjectGuid>
+    <RootNamespace>SDL_test</RootNamespace>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">
+    <Midl />
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">
+    <Midl />
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">
+    <Midl />
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">
+    <Midl />
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">
+    <Midl />
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">
+    <Midl />
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(TreatWarningsAsError)'!=''">
+    <ClCompile>
+      <TreatWarningAsError>$(TreatWarningsAsError)</TreatWarningAsError>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\test\SDL_test_internal.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\test\SDL_test_assert.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_common.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_compare.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_crc32.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_font.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_fuzzer.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_harness.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_log.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_md5.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_memory.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

external/SDL/VisualC-GDK/clean.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+find . -type f \( -name '*.user' -o -name '*.sdf' -o -name '*.ncb' -o -name '*.suo' \) -print -delete
+find . -type f \( -name '*.bmp' -o -name '*.wav' -o -name '*.dat' \) -print -delete
+find . -depth -type d \( -name Gaming.Desktop.x64 \) -exec rm -rv {} \;
+find . -depth -type d \( -name Gaming.Xbox.Scarlett.x64 \) -exec rm -rv {} \;
+find . -depth -type d \( -name Gaming.Xbox.XboxOne.x64 \) -exec rm -rv {} \;
+rm shaders/*.h

external/SDL/VisualC-GDK/tests/testcontroller/PackageLayout.xml

@@ -0,0 +1,9 @@
+<Package>
+  <Chunk Id="1000" Marker="Launch">
+    <FileGroup DestinationPath="." SourcePath="." Include="testcontroller.exe" />
+    <FileGroup DestinationPath="." SourcePath="." Include="MicrosoftGame.config" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.bmp" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.png" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.dll" />
+  </Chunk>
+</Package>

external/SDL/VisualC-GDK/tests/testcontroller/testcontroller.vcxproj

@@ -0,0 +1,344 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Gaming.Desktop.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Desktop.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{55812185-D13C-4022-9C81-32E0F4A08305}</ProjectGuid>
+    <RootNamespace>testcontroller</RootNamespace>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testcontroller.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testcontroller.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testcontroller.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testcontroller.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testcontroller.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testcontroller.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(TreatWarningsAsError)'!=''">
+    <ClCompile>
+      <TreatWarningAsError>$(TreatWarningsAsError)</TreatWarningAsError>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\SDL\SDL.vcxproj">
+      <Project>{81ce8daf-ebb2-4761-8e45-b71abcca8c68}</Project>
+      <Private>false</Private>
+      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+    <ProjectReference Include="..\..\SDL_test\SDL_test.vcxproj">
+      <Project>{da956fd3-e143-46f2-9fe5-c77bebc56b1a}</Project>
+      <Private>false</Private>
+      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\test\gamepadutils.c" />
+    <ClCompile Include="..\..\..\test\testcontroller.c" />
+    <ClCompile Include="..\..\..\test\testutils.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="wingdk\MicrosoftGame.config">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="PackageLayout.xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\logos\Logo100x100.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo150x150.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo44x44.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo480x480.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="xboxseries\MicrosoftGame.config">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="xboxone\MicrosoftGame.config">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\logos\SplashScreenImage.png" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

external/SDL/VisualC-GDK/tests/testcontroller/testcontroller.vcxproj.filters

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\..\..\test\testcontroller.c" />
+    <ClCompile Include="..\..\..\test\testutils.c" />
+    <ClCompile Include="..\..\..\test\gamepadutils.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\logos\Logo44x44.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo100x100.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo150x150.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo480x480.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="wingdk\MicrosoftGame.config">
+      <Filter>wingdk</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="xboxseries\MicrosoftGame.config">
+      <Filter>xboxseries</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="xboxone\MicrosoftGame.config">
+      <Filter>xboxone</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\SplashScreenImage.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="PackageLayout.xml" />
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
+      <Filter>wingdk</Filter>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="logos">
+      <UniqueIdentifier>{5e858cf0-6fba-498d-b33d-11c8ecbb79c7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="xboxseries">
+      <UniqueIdentifier>{5790a250-283e-4f51-8f28-6a977d3c7a6c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="wingdk">
+      <UniqueIdentifier>{a4d235e4-4017-4193-af62-ecb2ac249be4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="xboxone">
+      <UniqueIdentifier>{e704dcb9-c83c-4c94-a139-b0f3e3f428f2}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

external/SDL/VisualC-GDK/tests/testcontroller/wingdk/MicrosoftGame.config

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testcontroller.exe"
+					TargetDeviceFamily="PC"
+					Id="Game" />
+	</ExecutableList>
+
+	<DesktopRegistration>
+		<DependencyList>
+			<KnownDependency Name="VC14"/>
+		</DependencyList>
+	</DesktopRegistration>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testcontroller"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					Description="testcontroller"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC-GDK/tests/testcontroller/xboxone/MicrosoftGame.config

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testcontroller.exe"
+					TargetDeviceFamily="XboxOne"
+					Id="Game" />
+	</ExecutableList>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testcontroller"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					SplashScreenImage="SplashScreenImage.png"
+					Description="testcontroller"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC-GDK/tests/testcontroller/xboxseries/MicrosoftGame.config

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testcontroller.exe"
+					TargetDeviceFamily="Scarlett"
+					Id="Game" />
+	</ExecutableList>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testcontroller"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					SplashScreenImage="SplashScreenImage.png"
+					Description="testcontroller"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC-GDK/tests/testgdk/PackageLayout.xml

@@ -0,0 +1,10 @@
+<Package>
+  <Chunk Id="1000" Marker="Launch">
+    <FileGroup DestinationPath="." SourcePath="." Include="testgdk.exe" />
+    <FileGroup DestinationPath="." SourcePath="." Include="MicrosoftGame.config" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.bmp" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.wav" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.png" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.dll" />
+  </Chunk>
+</Package>

external/SDL/VisualC-GDK/tests/testgdk/src/testgdk.cpp

@@ -0,0 +1,505 @@
+/*
+  Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely.
+*/
+/* testgdk:  Basic tests of using task queue/xbl (with simple drawing) in GDK.
+ * NOTE: As of June 2022 GDK, login will only work if MicrosoftGame.config is
+ * configured properly. See README-gdk.md.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <SDL3/SDL_test.h>
+#include <SDL3/SDL_test_common.h>
+#include "../src/core/windows/SDL_windows.h"
+#include <SDL3/SDL_main.h>
+
+extern "C" {
+#include "../test/testutils.h"
+}
+
+#include <XGameRuntime.h>
+
+#define NUM_SPRITES    100
+#define MAX_SPEED      1
+#define SUSPEND_CODE   0
+#define RESUME_CODE    1
+
+static SDLTest_CommonState *state;
+static int num_sprites;
+static SDL_Texture **sprites;
+static bool cycle_color;
+static bool cycle_alpha;
+static int cycle_direction = 1;
+static int current_alpha = 0;
+static int current_color = 0;
+static int sprite_w, sprite_h;
+static SDL_BlendMode blendMode = SDL_BLENDMODE_BLEND;
+
+int done;
+
+static struct
+{
+    SDL_AudioSpec spec;
+    Uint8 *sound;    /* Pointer to wave data */
+    Uint32 soundlen; /* Length of wave data */
+    int soundpos;    /* Current play position */
+} wave;
+
+static SDL_AudioStream *stream;
+
+/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
+static void quit(int rc)
+{
+    SDL_free(sprites);
+    SDL_DestroyAudioStream(stream);
+    SDL_free(wave.sound);
+    SDLTest_CommonQuit(state);
+    /* If rc is 0, just let main return normally rather than calling exit.
+     * This allows testing of platforms where SDL_main is required and does meaningful cleanup.
+     */
+    if (rc != 0) {
+        exit(rc);
+    }
+}
+
+static int fillerup(void)
+{
+    const int minimum = (wave.soundlen / SDL_AUDIO_FRAMESIZE(wave.spec)) / 2;
+    if (SDL_GetAudioStreamQueued(stream) < minimum) {
+        SDL_PutAudioStreamData(stream, wave.sound, wave.soundlen);
+    }
+    return 0;
+}
+
+static void UserLoggedIn(XUserHandle user)
+{
+    HRESULT hr;
+    char gamertag[128];
+    hr = XUserGetGamertag(user, XUserGamertagComponent::UniqueModern, sizeof(gamertag), gamertag, NULL);
+
+    if (SUCCEEDED(hr)) {
+        SDL_Log("User logged in: %s", gamertag);
+    } else {
+        SDL_Log("[GDK] UserLoggedIn -- XUserGetGamertag failed: 0x%08x.", hr);
+    }
+
+    XUserCloseHandle(user);
+}
+
+static void AddUserUICallback(XAsyncBlock *asyncBlock)
+{
+    HRESULT hr;
+    XUserHandle user = NULL;
+
+    hr = XUserAddResult(asyncBlock, &user);
+    if (SUCCEEDED(hr)) {
+        uint64_t userId;
+
+        hr = XUserGetId(user, &userId);
+        if (FAILED(hr)) {
+            /* If unable to get the user ID, it means the account is banned, etc. */
+            SDL_Log("[GDK] AddUserSilentCallback -- XUserGetId failed: 0x%08x.", hr);
+            XUserCloseHandle(user);
+
+            /* Per the docs, likely should call XUserResolveIssueWithUiAsync here. */
+        } else {
+            UserLoggedIn(user);
+        }
+    } else {
+        SDL_Log("[GDK] AddUserUICallback -- XUserAddAsync failed: 0x%08x.", hr);
+    }
+
+    delete asyncBlock;
+}
+
+static void AddUserUI()
+{
+    HRESULT hr;
+    XAsyncBlock *asyncBlock = new XAsyncBlock;
+
+    asyncBlock->context = NULL;
+    asyncBlock->queue = NULL; /* A null queue will use the global process task queue */
+    asyncBlock->callback = &AddUserUICallback;
+
+    hr = XUserAddAsync(XUserAddOptions::None, asyncBlock);
+
+    if (FAILED(hr)) {
+        delete asyncBlock;
+        SDL_Log("[GDK] AddUserSilent -- failed: 0x%08x", hr);
+    }
+}
+
+static void AddUserSilentCallback(XAsyncBlock *asyncBlock)
+{
+    HRESULT hr;
+    XUserHandle user = NULL;
+
+    hr = XUserAddResult(asyncBlock, &user);
+    if (SUCCEEDED(hr)) {
+        uint64_t userId;
+
+        hr = XUserGetId(user, &userId);
+        if (FAILED(hr)) {
+            /* If unable to get the user ID, it means the account is banned, etc. */
+            SDL_Log("[GDK] AddUserSilentCallback -- XUserGetId failed: 0x%08x. Trying with UI.", hr);
+            XUserCloseHandle(user);
+            AddUserUI();
+        } else {
+            UserLoggedIn(user);
+        }
+    } else {
+        SDL_Log("[GDK] AddUserSilentCallback -- XUserAddAsync failed: 0x%08x. Trying with UI.", hr);
+        AddUserUI();
+    }
+
+    delete asyncBlock;
+}
+
+static void AddUserSilent()
+{
+    HRESULT hr;
+    XAsyncBlock *asyncBlock = new XAsyncBlock;
+
+    asyncBlock->context = NULL;
+    asyncBlock->queue = NULL; /* A null queue will use the global process task queue */
+    asyncBlock->callback = &AddUserSilentCallback;
+
+    hr = XUserAddAsync(XUserAddOptions::AddDefaultUserSilently, asyncBlock);
+
+    if (FAILED(hr)) {
+        delete asyncBlock;
+        SDL_Log("[GDK] AddUserSilent -- failed: 0x%08x", hr);
+    }
+}
+
+static bool LoadSprite(const char *file)
+{
+    int i;
+
+    for (i = 0; i < state->num_windows; ++i) {
+        /* This does the SDL_LoadBMP step repeatedly, but that's OK for test code. */
+        sprites[i] = LoadTexture(state->renderers[i], file, true);
+        if (!sprites[i]) {
+            return false;
+        }
+        sprite_w = sprites[i]->w;
+        sprite_h = sprites[i]->h;
+
+        SDL_SetTextureBlendMode(sprites[i], blendMode);
+    }
+
+    /* We're ready to roll. :) */
+    return true;
+}
+
+static void DrawSprites(SDL_Renderer * renderer, SDL_Texture * sprite)
+{
+    SDL_Rect viewport;
+    SDL_FRect temp;
+
+    /* Query the sizes */
+    SDL_GetRenderViewport(renderer, &viewport);
+
+    /* Cycle the color and alpha, if desired */
+    if (cycle_color) {
+        current_color += cycle_direction;
+        if (current_color < 0) {
+            current_color = 0;
+            cycle_direction = -cycle_direction;
+        }
+        if (current_color > 255) {
+            current_color = 255;
+            cycle_direction = -cycle_direction;
+        }
+        SDL_SetTextureColorMod(sprite, 255, (Uint8) current_color,
+                               (Uint8) current_color);
+    }
+    if (cycle_alpha) {
+        current_alpha += cycle_direction;
+        if (current_alpha < 0) {
+            current_alpha = 0;
+            cycle_direction = -cycle_direction;
+        }
+        if (current_alpha > 255) {
+            current_alpha = 255;
+            cycle_direction = -cycle_direction;
+        }
+        SDL_SetTextureAlphaMod(sprite, (Uint8) current_alpha);
+    }
+
+    /* Draw a gray background */
+    SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+    SDL_RenderClear(renderer);
+
+    /* Test points */
+    SDL_SetRenderDrawColor(renderer, 0xFF, 0x00, 0x00, 0xFF);
+    SDL_RenderPoint(renderer, 0.0f, 0.0f);
+    SDL_RenderPoint(renderer, (float)(viewport.w - 1), 0.0f);
+    SDL_RenderPoint(renderer, 0.0f, (float)(viewport.h - 1));
+    SDL_RenderPoint(renderer, (float)(viewport.w - 1), (float)(viewport.h - 1));
+
+    /* Test horizontal and vertical lines */
+    SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
+    SDL_RenderLine(renderer, 1.0f, 0.0f, (float)(viewport.w - 2), 0.0f);
+    SDL_RenderLine(renderer, 1.0f, (float)(viewport.h - 1), (float)(viewport.w - 2), (float)(viewport.h - 1));
+    SDL_RenderLine(renderer, 0.0f, 1.0f, 0.0f, (float)(viewport.h - 2));
+    SDL_RenderLine(renderer, (float)(viewport.w - 1), 1, (float)(viewport.w - 1), (float)(viewport.h - 2));
+
+    /* Test fill and copy */
+    SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
+    temp.x = 1.0f;
+    temp.y = 1.0f;
+    temp.w = (float)sprite_w;
+    temp.h = (float)sprite_h;
+    SDL_RenderFillRect(renderer, &temp);
+    SDL_RenderTexture(renderer, sprite, NULL, &temp);
+    temp.x = (float)(viewport.w-sprite_w-1);
+    temp.y = 1.0f;
+    temp.w = (float)sprite_w;
+    temp.h = (float)sprite_h;
+    SDL_RenderFillRect(renderer, &temp);
+    SDL_RenderTexture(renderer, sprite, NULL, &temp);
+    temp.x = 1.0f;
+    temp.y = (float)(viewport.h-sprite_h-1);
+    temp.w = (float)sprite_w;
+    temp.h = (float)sprite_h;
+    SDL_RenderFillRect(renderer, &temp);
+    SDL_RenderTexture(renderer, sprite, NULL, &temp);
+    temp.x = (float)(viewport.w-sprite_w-1);
+    temp.y = (float)(viewport.h-sprite_h-1);
+    temp.w = (float)(sprite_w);
+    temp.h = (float)(sprite_h);
+    SDL_RenderFillRect(renderer, &temp);
+    SDL_RenderTexture(renderer, sprite, NULL, &temp);
+
+    /* Test diagonal lines */
+    SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
+    SDL_RenderLine(renderer, (float)sprite_w, (float)sprite_h,
+                   (float)(viewport.w-sprite_w-2), (float)(viewport.h-sprite_h-2));
+    SDL_RenderLine(renderer, (float)(viewport.w-sprite_w-2), (float)sprite_h,
+                   (float)sprite_w, (float)(viewport.h-sprite_h-2));
+
+    /* Update the screen! */
+    SDL_RenderPresent(renderer);
+}
+
+static void update(bool *suppressdraw)
+{
+    SDL_Event event;
+
+    /* Check for events */
+    while (SDL_PollEvent(&event)) {
+        if (event.type == SDL_EVENT_KEY_DOWN && !event.key.repeat) {
+            SDL_Log("Initial SDL_EVENT_KEY_DOWN: %s", SDL_GetScancodeName(event.key.scancode));
+        }
+#if defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)
+        /* On Xbox, ignore the keydown event because the features aren't supported */
+        if (event.type != SDL_EVENT_KEY_DOWN) {
+            SDLTest_CommonEvent(state, &event, &done);
+        }
+
+        if (event.type == SDL_EVENT_USER) {
+            if (event.user.code == SUSPEND_CODE) {
+                for (int i = 0; i < state->num_windows; ++i) {
+                    if (state->windows[i] != NULL) {
+                        SDL_GDKSuspendRenderer(state->renderers[i]);
+                    }
+                }
+                *suppressdraw = true;
+                SDL_GDKSuspendComplete();
+            } else if (event.user.code == RESUME_CODE) {
+                for (int i = 0; i < state->num_windows; ++i) {
+                    if (state->windows[i] != NULL) {
+                        SDL_GDKResumeRenderer(state->renderers[i]);
+                    }
+                }
+                *suppressdraw = false;
+            }
+        }
+#else
+        SDLTest_CommonEvent(state, &event, &done);
+#endif
+    }
+    fillerup();
+}
+
+static void draw()
+{
+    int i;
+    for (i = 0; i < state->num_windows; ++i) {
+        if (state->windows[i] != NULL) {
+            DrawSprites(state->renderers[i], sprites[i]);
+        }
+    }
+}
+
+static bool SDLCALL GDKEventWatch(void* userdata, SDL_Event* event)
+{
+    /* This callback may be on a different thread, so we'll
+     * push these events as USER events so they appear
+     * in the main thread's event loop.
+     *
+     * That allows us to cancel drawing before/after we finish
+     * drawing a frame, rather than mid-draw (which can crash).
+     */
+    if (event->type == SDL_EVENT_DID_ENTER_BACKGROUND) {
+        SDL_Event evt;
+        evt.type = SDL_EVENT_USER;
+        evt.user.code = 0;
+        SDL_PushEvent(&evt);
+    } else if (event->type == SDL_EVENT_WILL_ENTER_FOREGROUND) {
+        SDL_Event evt;
+        evt.type = SDL_EVENT_USER;
+        evt.user.code = 1;
+        SDL_PushEvent(&evt);
+    }
+    return false;
+}
+
+int main(int argc, char *argv[])
+{
+    int i;
+    const char *icon = "icon.png";
+    char *soundname = NULL;
+    bool suppressdraw = false;
+
+    /* Initialize parameters */
+    num_sprites = NUM_SPRITES;
+
+    /* Initialize test framework */
+    state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO | SDL_INIT_AUDIO);
+    if (!state) {
+        return 1;
+    }
+
+    for (i = 1; i < argc;) {
+        int consumed;
+
+        consumed = SDLTest_CommonArg(state, i);
+        if (consumed == 0) {
+            consumed = -1;
+            if (SDL_strcasecmp(argv[i], "--blend") == 0) {
+                if (argv[i + 1]) {
+                    if (SDL_strcasecmp(argv[i + 1], "none") == 0) {
+                        blendMode = SDL_BLENDMODE_NONE;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) {
+                        blendMode = SDL_BLENDMODE_BLEND;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "add") == 0) {
+                        blendMode = SDL_BLENDMODE_ADD;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) {
+                        blendMode = SDL_BLENDMODE_MOD;
+                        consumed = 2;
+                    } else if (SDL_strcasecmp(argv[i + 1], "sub") == 0) {
+                        blendMode = SDL_ComposeCustomBlendMode(SDL_BLENDFACTOR_SRC_ALPHA, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_SUBTRACT, SDL_BLENDFACTOR_ZERO, SDL_BLENDFACTOR_ONE, SDL_BLENDOPERATION_SUBTRACT);
+                        consumed = 2;
+                    }
+                }
+            } else if (SDL_strcasecmp(argv[i], "--cyclecolor") == 0) {
+                cycle_color = true;
+                consumed = 1;
+            } else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) {
+                cycle_alpha = true;
+                consumed = 1;
+            } else if (SDL_isdigit(*argv[i])) {
+                num_sprites = SDL_atoi(argv[i]);
+                consumed = 1;
+            } else if (argv[i][0] != '-') {
+                icon = argv[i];
+                consumed = 1;
+            }
+        }
+        if (consumed < 0) {
+            static const char *options[] = {
+                "[--blend none|blend|add|mod]",
+                "[--cyclecolor]",
+                "[--cyclealpha]",
+                "[num_sprites]",
+                "[icon.bmp]",
+                NULL };
+            SDLTest_CommonLogUsage(state, argv[0], options);
+            quit(1);
+        }
+        i += consumed;
+    }
+    if (!SDLTest_CommonInit(state)) {
+        quit(2);
+    }
+
+    /* Set up the lifecycle event watcher */
+    SDL_AddEventWatch(GDKEventWatch, NULL);
+
+    /* Create the windows, initialize the renderers, and load the textures */
+    sprites =
+        (SDL_Texture **) SDL_malloc(state->num_windows * sizeof(*sprites));
+    if (!sprites) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!");
+        quit(2);
+    }
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_Renderer *renderer = state->renderers[i];
+        SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+        SDL_RenderClear(renderer);
+    }
+    if (!LoadSprite(icon)) {
+        quit(2);
+    }
+
+    soundname = GetResourceFilename(argc > 1 ? argv[1] : NULL, "sample.wav");
+
+    if (!soundname) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "%s", SDL_GetError());
+        quit(1);
+    }
+
+    /* Load the wave file into memory */
+    if (!SDL_LoadWAV(soundname, &wave.spec, &wave.sound, &wave.soundlen)) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s", soundname, SDL_GetError());
+        quit(1);
+    }
+
+    /* Show the list of available drivers */
+    SDL_Log("Available audio drivers:");
+    for (i = 0; i < SDL_GetNumAudioDrivers(); ++i) {
+        SDL_Log("%i: %s", i, SDL_GetAudioDriver(i));
+    }
+
+    SDL_Log("Using audio driver: %s", SDL_GetCurrentAudioDriver());
+
+    stream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &wave.spec, NULL, NULL);
+    if (!stream) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create audio stream: %s", SDL_GetError());
+        return -1;
+    }
+    SDL_ResumeAudioDevice(SDL_GetAudioStreamDevice(stream));
+
+    /* Main render loop */
+    done = 0;
+
+    /* Try to add the default user silently */
+    AddUserSilent();
+
+    while (!done) {
+        update(&suppressdraw);
+        if (!suppressdraw) {
+            draw();
+        }
+    }
+
+    quit(0);
+
+    SDL_free(soundname);
+    return 0;
+}

external/SDL/VisualC-GDK/tests/testgdk/testgdk.vcxproj

@@ -0,0 +1,400 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Gaming.Desktop.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Desktop.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{1C9A3F71-35A5-4C56-B292-F4375B3C3649}</ProjectGuid>
+    <RootNamespace>testsprite</RootNamespace>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(TreatWarningsAsError)'!=''">
+    <ClCompile>
+      <TreatWarningAsError>$(TreatWarningsAsError)</TreatWarningAsError>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\SDL\SDL.vcxproj">
+      <Project>{81ce8daf-ebb2-4761-8e45-b71abcca8c68}</Project>
+      <Private>false</Private>
+      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+    <ProjectReference Include="..\..\SDL_test\SDL_test.vcxproj">
+      <Project>{da956fd3-e143-46f2-9fe5-c77bebc56b1a}</Project>
+      <Private>false</Private>
+      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\..\test\icon.png">
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">Copying %(Filename)%(Extension)</Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">Copying %(Filename)%(Extension)</Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">Copying %(Filename)%(Extension)</Message>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">Copying %(Filename)%(Extension)</Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">Copying %(Filename)%(Extension)</Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">Copying %(Filename)%(Extension)</Message>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\test\testutils.c" />
+    <ClCompile Include="src\testgdk.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="wingdk\MicrosoftGame.config">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\logos\Logo100x100.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo150x150.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo44x44.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo480x480.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="PackageLayout.xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="xboxseries\MicrosoftGame.config">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\..\test\sample.wav">
+      <FileType>Document</FileType>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="xboxone\MicrosoftGame.config">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\logos\SplashScreenImage.png" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

external/SDL/VisualC-GDK/tests/testgdk/testgdk.vcxproj.filters

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\..\..\test\testutils.c" />
+    <ClCompile Include="src\testgdk.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\..\test\icon.bmp" />
+    <CopyFileToFolders Include="..\..\logos\Logo44x44.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo100x100.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo150x150.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo480x480.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="wingdk\MicrosoftGame.config">
+      <Filter>wingdk</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="xboxseries\MicrosoftGame.config">
+      <Filter>xboxseries</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\..\test\sample.wav" />
+    <CopyFileToFolders Include="xboxone\MicrosoftGame.config">
+      <Filter>xboxone</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\SplashScreenImage.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="PackageLayout.xml" />
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
+      <Filter>wingdk</Filter>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="logos">
+      <UniqueIdentifier>{c3c871f2-c7b7-4025-8ba4-037dde717fe1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="wingdk">
+      <UniqueIdentifier>{1678a80d-0ee8-4f48-bf89-9462d82dd98a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="xboxseries">
+      <UniqueIdentifier>{1b47b96b-507e-40ec-9c25-99b1a4d5b575}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="xboxone">
+      <UniqueIdentifier>{ac7aa2d5-f0f7-46eb-a548-5b6316f3b63b}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

external/SDL/VisualC-GDK/tests/testgdk/wingdk/MicrosoftGame.config

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testgdk.exe"
+					TargetDeviceFamily="PC"
+					Id="Game" />
+	</ExecutableList>
+
+	<DesktopRegistration>
+		<DependencyList>
+			<KnownDependency Name="VC14"/>
+		</DependencyList>
+	</DesktopRegistration>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testgdk"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					Description="testgdk"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC-GDK/tests/testgdk/xboxone/MicrosoftGame.config

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testgdk.exe"
+					TargetDeviceFamily="XboxOne"
+					Id="Game" />
+	</ExecutableList>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testgdk"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					SplashScreenImage="SplashScreenImage.png"
+					Description="testgdk"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC-GDK/tests/testgdk/xboxseries/MicrosoftGame.config

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testgdk.exe"
+					TargetDeviceFamily="Scarlett"
+					Id="Game" />
+	</ExecutableList>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testgdk"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					SplashScreenImage="SplashScreenImage.png"
+					Description="testgdk"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC-GDK/tests/testsprite/PackageLayout.xml

@@ -0,0 +1,9 @@
+<Package>
+  <Chunk Id="1000" Marker="Launch">
+    <FileGroup DestinationPath="." SourcePath="." Include="testsprite.exe" />
+    <FileGroup DestinationPath="." SourcePath="." Include="MicrosoftGame.config" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.bmp" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.png" />
+    <FileGroup DestinationPath="." SourcePath="." Include="*.dll" />
+  </Chunk>
+</Package>

external/SDL/VisualC-GDK/tests/testsprite/testsprite.vcxproj

@@ -0,0 +1,394 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Gaming.Desktop.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Debug</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Desktop.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Desktop.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.Scarlett.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.Scarlett.x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Gaming.Xbox.XboxOne.x64">
+      <Configuration>Release</Configuration>
+      <Platform>Gaming.Xbox.XboxOne.x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{40FB7794-D3C3-4CFE-BCF4-A80C96635682}</ProjectGuid>
+    <RootNamespace>testsprite</RootNamespace>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(Platform)\$(Configuration)\</IntDir>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'" />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Release/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TypeLibraryName>.\Debug/testsprite.tlb</TypeLibraryName>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)/../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <AdditionalDependencies>xgameruntime.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <PostBuildEvent>
+      <Command>
+      </Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(TreatWarningsAsError)'!=''">
+    <ClCompile>
+      <TreatWarningAsError>$(TreatWarningsAsError)</TreatWarningAsError>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\SDL\SDL.vcxproj">
+      <Project>{81ce8daf-ebb2-4761-8e45-b71abcca8c68}</Project>
+      <Private>false</Private>
+      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+    <ProjectReference Include="..\..\SDL_test\SDL_test.vcxproj">
+      <Project>{da956fd3-e143-46f2-9fe5-c77bebc56b1a}</Project>
+      <Private>false</Private>
+      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\..\test\icon.png">
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">Copying %(Filename)%(Extension)</Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">Copying %(Filename)%(Extension)</Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">Copying %(Filename)%(Extension)</Message>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">Copying %(Filename)%(Extension)</Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">Copying %(Filename)%(Extension)</Message>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">Copying %(Filename)%(Extension)</Message>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">copy "%(FullPath)" "$(ProjectDir)\"
+copy "%(FullPath)" "$(OutDir)\"</Command>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">$(ProjectDir)\%(Filename)%(Extension);%(Outputs)</Outputs>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\test\testsprite.c" />
+    <ClCompile Include="..\..\..\test\testutils.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="wingdk/MicrosoftGame.config">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\logos\Logo100x100.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo150x150.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo44x44.png" />
+    <CopyFileToFolders Include="..\..\logos\Logo480x480.png" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="PackageLayout.xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="xboxseries\MicrosoftGame.config">
+      <FileType>Document</FileType>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.XboxOne.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="xboxone\MicrosoftGame.config">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Desktop.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">true</ExcludedFromBuild>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\logos\SplashScreenImage.png" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

external/SDL/VisualC-GDK/tests/testsprite/testsprite.vcxproj.filters

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\..\..\test\testsprite.c" />
+    <ClCompile Include="..\..\..\test\testutils.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="..\..\..\test\icon.bmp" />
+    <CopyFileToFolders Include="..\..\logos\Logo44x44.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo100x100.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo150x150.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\Logo480x480.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="xboxseries\MicrosoftGame.config">
+      <Filter>xboxseries</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="xboxone\MicrosoftGame.config">
+      <Filter>xboxone</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="wingdk/MicrosoftGame.config">
+      <Filter>wingdk</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="..\..\logos\SplashScreenImage.png">
+      <Filter>logos</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="PackageLayout.xml" />
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
+      <Filter>wingdk</Filter>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="logos">
+      <UniqueIdentifier>{c3c871f2-c7b7-4025-8ba4-037dde717fe1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="wingdk">
+      <UniqueIdentifier>{c862dfc3-7803-4359-a31e-9dcda37e641a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="xboxseries">
+      <UniqueIdentifier>{1671e83d-25b3-4eb5-bed0-5c52c80f4e49}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="xboxone">
+      <UniqueIdentifier>{9bf62acf-6661-43f9-bde3-0de9e1db4290}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+</Project>

external/SDL/VisualC-GDK/tests/testsprite/wingdk/MicrosoftGame.config

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testsprite.exe"
+					TargetDeviceFamily="PC"
+					Id="Game" />
+	</ExecutableList>
+
+	<DesktopRegistration>
+		<DependencyList>
+			<KnownDependency Name="VC14"/>
+		</DependencyList>
+	</DesktopRegistration>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testsprite"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					Description="testsprite"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC-GDK/tests/testsprite/xboxone/MicrosoftGame.config

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testsprite.exe"
+					TargetDeviceFamily="XboxOne"
+					Id="Game" />
+	</ExecutableList>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testsprite"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					SplashScreenImage="SplashScreenImage.png"
+					Description="testsprite"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC-GDK/tests/testsprite/xboxseries/MicrosoftGame.config

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Game configVersion="1">
+
+	<!-- Set these to the correct identifiers from Partner Center -->
+	<Identity Name="SDL"
+		Version="1.0.0.0"
+		Publisher="CN=Publisher"/>
+
+	<ExecutableList>
+		<Executable Name="testsprite.exe"
+					TargetDeviceFamily="Scarlett"
+					Id="Game" />
+	</ExecutableList>
+
+	<!-- Set these to the correct values from Partner Center -->
+	<MSAAppId>PleaseChangeMe</MSAAppId>
+	<TitleId>FFFFFFFF</TitleId>
+
+	<ShellVisuals DefaultDisplayName="testsprite"
+					PublisherDisplayName="SDL"
+					Square480x480Logo="Logo480x480.png"
+					Square150x150Logo="Logo150x150.png"
+					Square44x44Logo="Logo44x44.png"
+					Description="testsprite"
+					SplashScreenImage="SplashScreenImage.png"
+					ForegroundText="light"
+					BackgroundColor="#000000"
+					StoreLogo="Logo100x100.png"/>
+</Game>

external/SDL/VisualC/SDL.sln

@@ -0,0 +1,996 @@
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{D69D5741-611F-4E14-8541-1FEE94F50B5A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SDL3", "SDL\SDL.vcxproj", "{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "checkkeys", "tests\checkkeys\checkkeys.vcxproj", "{26828762-C95D-4637-9CB1-7F0979523813}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "loopwave", "tests\loopwave\loopwave.vcxproj", "{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testatomic", "tests\testatomic\testatomic.vcxproj", "{66B32F7E-5716-48D0-B5B9-D832FD052DD5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testautomation", "tests\testautomation\testautomation.vcxproj", "{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testdialog", "tests\testdialog\testdialog.vcxproj", "{97A3A89B-E023-48CD-905F-CDBDE8D951DE}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testdraw", "tests\testdraw\testdraw.vcxproj", "{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testfile", "tests\testfile\testfile.vcxproj", "{CAE4F1D0-314F-4B10-805B-0EFD670133A0}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testgl", "tests\testgl\testgl.vcxproj", "{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testoverlay", "tests\testoverlay\testoverlay.vcxproj", "{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testplatform", "tests\testplatform\testplatform.vcxproj", "{26932B24-EFC6-4E3A-B277-ED653DA37968}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testpower", "tests\testpower\testpower.vcxproj", "{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testrendertarget", "tests\testrendertarget\testrendertarget.vcxproj", "{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testrumble", "tests\testrumble\testrumble.vcxproj", "{BFF40245-E9A6-4297-A425-A554E5D767E8}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testscale", "tests\testscale\testscale.vcxproj", "{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testshape", "tests\testshape\testshape.vcxproj", "{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testsprite", "tests\testsprite\testsprite.vcxproj", "{40FB7794-D3C3-4CFE-BCF4-A80C96635682}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SDL3_test", "SDL_test\SDL_test.vcxproj", "{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testcontroller", "tests\testcontroller\testcontroller.vcxproj", "{55812185-D13C-4022-9C81-32E0F4A08305}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testgles2", "tests\testgles2\testgles2.vcxproj", "{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testvulkan", "tests\testvulkan\testvulkan.vcxproj", "{0D604DFD-AAB6-442C-9368-F91A344146AB}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testwm", "tests\testwm\testwm.vcxproj", "{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testyuv", "tests\testyuv\testyuv.vcxproj", "{40FB7794-D3C3-4CFE-BCF4-A80C97635682}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testsensor", "tests\testsensor\testsensor.vcxproj", "{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testsurround", "tests\testsurround\testsurround.vcxproj", "{70B894A9-E306-49E8-ABC2-932A952A5E5F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testpen", "tests\testpen\testpen.vcxproj", "{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testtray", "tests\testtray\testtray.vcxproj", "{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{1498F0CD-F4DA-4847-9CB2-FB18D48061D5}"
+	ProjectSection(SolutionItems) = preProject
+		examples\Directory.Build.props = examples\Directory.Build.props
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "audio", "audio", "{1B61A1B7-92DE-4C37-9151-D2928D6449AB}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01-simple-playback", "examples\audio\01-simple-playback\01-simple-playback.vcxproj", "{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02-simple-playback-callback", "examples\audio\02-simple-playback-callback\02-simple-playback-callback.vcxproj", "{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "camera", "camera", "{AAEC8338-4D33-4AF5-9A1F-B9FF027D4607}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01-read-and-draw", "examples\camera\01-read-and-draw\01-read-and-draw.vcxproj", "{510ACF0C-4012-4216-98EF-E4F155DE33CE}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "demo", "demo", "{D1BF59F6-22DC-493B-BDEB-451A50DA793D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01-snake", "examples\demo\01-snake\01-snake.vcxproj", "{7820969A-5B7B-4046-BB0A-82905D457FC5}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "pen", "pen", "{F2247885-8EE8-42F4-A702-4155587620E0}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01-drawing-lines", "examples\pen\01-drawing-lines\01-drawing-lines.vcxproj", "{5EDA1ED3-8213-4C12-B0DF-B631EB611804}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "renderer", "renderer", "{F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01-clear", "examples\renderer\01-clear\01-clear.vcxproj", "{896557AC-7575-480C-8FFD-AB08B5DA305D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02-primitives", "examples\renderer\02-primitives\02-primitives.vcxproj", "{504DC7EC-D82E-448E-9C7D-3BE7981592B3}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "03-lines", "examples\renderer\03-lines\03-lines.vcxproj", "{BDE7DBC0-DCE7-432E-8750-C4AE55463699}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "04-points", "examples\renderer\04-points\04-points.vcxproj", "{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "05-rectangles", "examples\renderer\05-rectangles\05-rectangles.vcxproj", "{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "06-textures", "examples\renderer\06-textures\06-textures.vcxproj", "{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "07-streaming-textures", "examples\renderer\07-streaming-textures\07-streaming-textures.vcxproj", "{540AE143-A58F-4D3B-B843-94EA8576522D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "08-rotating-textures", "examples\renderer\08-rotating-textures\08-rotating-textures.vcxproj", "{7091C001-3D71-47D4-B27B-E99271E5B987}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "09-scaling-textures", "examples\renderer\09-scaling-textures\09-scaling-textures.vcxproj", "{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "10-geometry", "examples\renderer\10-geometry\10-geometry.vcxproj", "{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "11-color-mods", "examples\renderer\11-color-mods\11-color-mods.vcxproj", "{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "14-viewport", "examples\renderer\14-viewport\14-viewport.vcxproj", "{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "15-cliprect", "examples\renderer\15-cliprect\15-cliprect.vcxproj", "{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "17-read-pixels", "examples\renderer\17-read-pixels\17-read-pixels.vcxproj", "{EEF00329-4598-4E34-B969-9DD4B0815E6C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "18-debug-text", "examples\renderer\18-debug-text\18-debug-text.vcxproj", "{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "03-load-wav", "examples\audio\03-load-wav\03-load-wav.vcxproj", "{608C6C67-7766-471F-BBFF-8B00086039AF}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02-woodeneye-008", "examples\demo\02-woodeneye-008\02-woodeneye-008.vcxproj", "{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "03-infinite-monkeys", "examples\demo\03-infinite-monkeys\03-infinite-monkeys.vcxproj", "{75AEE75A-C016-4497-960B-D767B822237D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "19-affine-textures", "examples\renderer\19-affine-textures\19-affine-textures.vcxproj", "{E21C50BF-54B4-434C-AA24-9A6469553987}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "04-multiple-streams", "examples\audio\04-multiple-streams\04-multiple-streams.vcxproj", "{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "asyncio", "asyncio", "{02EA681E-C7D8-13C7-8484-4AC65E1B71E8}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "input", "input", "{8DEAE483-FDE7-463F-9FD5-F597BBAED1F9}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01-load-bitmaps", "examples\asyncio\01-load-bitmaps\01-load-bitmaps.vcxproj", "{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "04-bytepusher", "examples\demo\04-bytepusher\04-bytepusher.vcxproj", "{3DB9B219-769E-43AC-8B8B-319DB6045DCF}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01-joystick-polling", "examples\input\01-joystick-polling\01-joystick-polling.vcxproj", "{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02-joystick-events", "examples\input\02-joystick-events\02-joystick-events.vcxproj", "{FCBDF2B2-1129-49AE-9406-3F219E65CA89}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testsoftwaretransparent", "tests\testsoftwaretransparent\testsoftwaretransparent.vcxproj", "{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "05-planar-data", "examples\audio\05-planar-data\05-planar-data.vcxproj", "{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "03-gamepad-polling", "examples\input\03-gamepad-polling\03-gamepad-polling.vcxproj", "{70B36605-D8E8-4679-A126-0869BA621778}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "04-gamepad-events", "examples\input\04-gamepad-events\04-gamepad-events.vcxproj", "{F4441527-0487-4743-ACF0-435D71C8DBE8}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "misc", "misc", "{FA68A4F2-2DB8-4C90-8809-6B9764C92E77}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01-power", "examples\misc\01-power\01-power.vcxproj", "{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02-clipboard", "examples\misc\02-clipboard\02-clipboard.vcxproj", "{40F19482-512F-4123-A57B-509679EC8F26}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "03-locale", "examples\misc\03-locale\03-locale.vcxproj", "{6381F9D3-BA5F-4E5C-80FF-9013964777EE}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM64 = Debug|ARM64
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|ARM64 = Release|ARM64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|ARM64.Build.0 = Debug|ARM64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|Win32.ActiveCfg = Debug|Win32
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|Win32.Build.0 = Debug|Win32
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|x64.ActiveCfg = Debug|x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Debug|x64.Build.0 = Debug|x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|ARM64.ActiveCfg = Release|ARM64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|ARM64.Build.0 = Release|ARM64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|Win32.ActiveCfg = Release|Win32
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|Win32.Build.0 = Release|Win32
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|x64.ActiveCfg = Release|x64
+		{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}.Release|x64.Build.0 = Release|x64
+		{26828762-C95D-4637-9CB1-7F0979523813}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{26828762-C95D-4637-9CB1-7F0979523813}.Debug|ARM64.Build.0 = Debug|ARM64
+		{26828762-C95D-4637-9CB1-7F0979523813}.Debug|Win32.ActiveCfg = Debug|Win32
+		{26828762-C95D-4637-9CB1-7F0979523813}.Debug|Win32.Build.0 = Debug|Win32
+		{26828762-C95D-4637-9CB1-7F0979523813}.Debug|x64.ActiveCfg = Debug|x64
+		{26828762-C95D-4637-9CB1-7F0979523813}.Debug|x64.Build.0 = Debug|x64
+		{26828762-C95D-4637-9CB1-7F0979523813}.Release|ARM64.ActiveCfg = Release|ARM64
+		{26828762-C95D-4637-9CB1-7F0979523813}.Release|ARM64.Build.0 = Release|ARM64
+		{26828762-C95D-4637-9CB1-7F0979523813}.Release|Win32.ActiveCfg = Release|Win32
+		{26828762-C95D-4637-9CB1-7F0979523813}.Release|Win32.Build.0 = Release|Win32
+		{26828762-C95D-4637-9CB1-7F0979523813}.Release|x64.ActiveCfg = Release|x64
+		{26828762-C95D-4637-9CB1-7F0979523813}.Release|x64.Build.0 = Release|x64
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Debug|ARM64.Build.0 = Debug|ARM64
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Debug|Win32.ActiveCfg = Debug|Win32
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Debug|Win32.Build.0 = Debug|Win32
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Debug|x64.ActiveCfg = Debug|x64
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Debug|x64.Build.0 = Debug|x64
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Release|ARM64.ActiveCfg = Release|ARM64
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Release|ARM64.Build.0 = Release|ARM64
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Release|Win32.ActiveCfg = Release|Win32
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Release|Win32.Build.0 = Release|Win32
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Release|x64.ActiveCfg = Release|x64
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB}.Release|x64.Build.0 = Release|x64
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Debug|ARM64.Build.0 = Debug|ARM64
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Debug|Win32.Build.0 = Debug|Win32
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Debug|x64.ActiveCfg = Debug|x64
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Debug|x64.Build.0 = Debug|x64
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Release|ARM64.ActiveCfg = Release|ARM64
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Release|ARM64.Build.0 = Release|ARM64
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Release|Win32.ActiveCfg = Release|Win32
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Release|Win32.Build.0 = Release|Win32
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Release|x64.ActiveCfg = Release|x64
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5}.Release|x64.Build.0 = Release|x64
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Debug|ARM64.Build.0 = Debug|ARM64
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Debug|Win32.Build.0 = Debug|Win32
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Debug|x64.ActiveCfg = Debug|x64
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Debug|x64.Build.0 = Debug|x64
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Release|ARM64.ActiveCfg = Release|ARM64
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Release|ARM64.Build.0 = Release|ARM64
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Release|Win32.ActiveCfg = Release|Win32
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Release|Win32.Build.0 = Release|Win32
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Release|x64.ActiveCfg = Release|x64
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA}.Release|x64.Build.0 = Release|x64
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Debug|ARM64.Build.0 = Debug|ARM64
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Debug|Win32.ActiveCfg = Debug|Win32
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Debug|Win32.Build.0 = Debug|Win32
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Debug|x64.ActiveCfg = Debug|x64
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Debug|x64.Build.0 = Debug|x64
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Release|ARM64.ActiveCfg = Release|ARM64
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Release|ARM64.Build.0 = Release|ARM64
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Release|Win32.ActiveCfg = Release|Win32
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Release|Win32.Build.0 = Release|Win32
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Release|x64.ActiveCfg = Release|x64
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE}.Release|x64.Build.0 = Release|x64
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Debug|ARM64.Build.0 = Debug|ARM64
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Debug|Win32.Build.0 = Debug|Win32
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Debug|x64.ActiveCfg = Debug|x64
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Debug|x64.Build.0 = Debug|x64
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Release|ARM64.ActiveCfg = Release|ARM64
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Release|ARM64.Build.0 = Release|ARM64
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Release|Win32.ActiveCfg = Release|Win32
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Release|Win32.Build.0 = Release|Win32
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Release|x64.ActiveCfg = Release|x64
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF}.Release|x64.Build.0 = Release|x64
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Debug|ARM64.Build.0 = Debug|ARM64
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Debug|Win32.Build.0 = Debug|Win32
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Debug|x64.ActiveCfg = Debug|x64
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Debug|x64.Build.0 = Debug|x64
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Release|ARM64.ActiveCfg = Release|ARM64
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Release|ARM64.Build.0 = Release|ARM64
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Release|Win32.ActiveCfg = Release|Win32
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Release|Win32.Build.0 = Release|Win32
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Release|x64.ActiveCfg = Release|x64
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0}.Release|x64.Build.0 = Release|x64
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Debug|ARM64.Build.0 = Debug|ARM64
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Debug|Win32.Build.0 = Debug|Win32
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Debug|x64.ActiveCfg = Debug|x64
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Debug|x64.Build.0 = Debug|x64
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Release|ARM64.ActiveCfg = Release|ARM64
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Release|ARM64.Build.0 = Release|ARM64
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Release|Win32.ActiveCfg = Release|Win32
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Release|Win32.Build.0 = Release|Win32
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Release|x64.ActiveCfg = Release|x64
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884}.Release|x64.Build.0 = Release|x64
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Debug|ARM64.Build.0 = Debug|ARM64
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Debug|Win32.Build.0 = Debug|Win32
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Debug|x64.ActiveCfg = Debug|x64
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Debug|x64.Build.0 = Debug|x64
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Release|ARM64.ActiveCfg = Release|ARM64
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Release|ARM64.Build.0 = Release|ARM64
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Release|Win32.ActiveCfg = Release|Win32
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Release|Win32.Build.0 = Release|Win32
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Release|x64.ActiveCfg = Release|x64
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A}.Release|x64.Build.0 = Release|x64
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Debug|ARM64.Build.0 = Debug|ARM64
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Debug|Win32.ActiveCfg = Debug|Win32
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Debug|Win32.Build.0 = Debug|Win32
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Debug|x64.ActiveCfg = Debug|x64
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Debug|x64.Build.0 = Debug|x64
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Release|ARM64.ActiveCfg = Release|ARM64
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Release|ARM64.Build.0 = Release|ARM64
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Release|Win32.ActiveCfg = Release|Win32
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Release|Win32.Build.0 = Release|Win32
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Release|x64.ActiveCfg = Release|x64
+		{26932B24-EFC6-4E3A-B277-ED653DA37968}.Release|x64.Build.0 = Release|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Debug|ARM64.Build.0 = Debug|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Debug|Win32.Build.0 = Debug|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Debug|x64.ActiveCfg = Debug|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Debug|x64.Build.0 = Debug|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Release|ARM64.ActiveCfg = Release|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Release|ARM64.Build.0 = Release|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Release|Win32.ActiveCfg = Release|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Release|Win32.Build.0 = Release|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Release|x64.ActiveCfg = Release|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3}.Release|x64.Build.0 = Release|x64
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Debug|ARM64.Build.0 = Debug|ARM64
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Debug|Win32.Build.0 = Debug|Win32
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Debug|x64.ActiveCfg = Debug|x64
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Debug|x64.Build.0 = Debug|x64
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Release|ARM64.ActiveCfg = Release|ARM64
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Release|ARM64.Build.0 = Release|ARM64
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Release|Win32.ActiveCfg = Release|Win32
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Release|Win32.Build.0 = Release|Win32
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Release|x64.ActiveCfg = Release|x64
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E}.Release|x64.Build.0 = Release|x64
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Debug|ARM64.Build.0 = Debug|ARM64
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Debug|Win32.ActiveCfg = Debug|Win32
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Debug|Win32.Build.0 = Debug|Win32
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Debug|x64.ActiveCfg = Debug|x64
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Debug|x64.Build.0 = Debug|x64
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Release|ARM64.ActiveCfg = Release|ARM64
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Release|ARM64.Build.0 = Release|ARM64
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Release|Win32.ActiveCfg = Release|Win32
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Release|Win32.Build.0 = Release|Win32
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Release|x64.ActiveCfg = Release|x64
+		{BFF40245-E9A6-4297-A425-A554E5D767E8}.Release|x64.Build.0 = Release|x64
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Debug|ARM64.Build.0 = Debug|ARM64
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Debug|Win32.ActiveCfg = Debug|Win32
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Debug|Win32.Build.0 = Debug|Win32
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Debug|x64.ActiveCfg = Debug|x64
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Debug|x64.Build.0 = Debug|x64
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Release|ARM64.ActiveCfg = Release|ARM64
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Release|ARM64.Build.0 = Release|ARM64
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Release|Win32.ActiveCfg = Release|Win32
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Release|Win32.Build.0 = Release|Win32
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Release|x64.ActiveCfg = Release|x64
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6}.Release|x64.Build.0 = Release|x64
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Debug|ARM64.Build.0 = Debug|ARM64
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Debug|Win32.Build.0 = Debug|Win32
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Debug|x64.ActiveCfg = Debug|x64
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Debug|x64.Build.0 = Debug|x64
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Release|ARM64.ActiveCfg = Release|ARM64
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Release|ARM64.Build.0 = Release|ARM64
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Release|Win32.ActiveCfg = Release|Win32
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Release|Win32.Build.0 = Release|Win32
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Release|x64.ActiveCfg = Release|x64
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2}.Release|x64.Build.0 = Release|x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|ARM64.Build.0 = Debug|ARM64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Win32.ActiveCfg = Debug|Win32
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|Win32.Build.0 = Debug|Win32
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|x64.ActiveCfg = Debug|x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Debug|x64.Build.0 = Debug|x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|ARM64.ActiveCfg = Release|ARM64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|ARM64.Build.0 = Release|ARM64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Win32.ActiveCfg = Release|Win32
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|Win32.Build.0 = Release|Win32
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|x64.ActiveCfg = Release|x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682}.Release|x64.Build.0 = Release|x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|ARM64.Build.0 = Debug|ARM64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|Win32.Build.0 = Debug|Win32
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|x64.ActiveCfg = Debug|x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Debug|x64.Build.0 = Debug|x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|ARM64.ActiveCfg = Release|ARM64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|ARM64.Build.0 = Release|ARM64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|Win32.ActiveCfg = Release|Win32
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|Win32.Build.0 = Release|Win32
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|x64.ActiveCfg = Release|x64
+		{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}.Release|x64.Build.0 = Release|x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|ARM64.Build.0 = Debug|ARM64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Win32.ActiveCfg = Debug|Win32
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|Win32.Build.0 = Debug|Win32
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|x64.ActiveCfg = Debug|x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Debug|x64.Build.0 = Debug|x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|ARM64.ActiveCfg = Release|ARM64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|ARM64.Build.0 = Release|ARM64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Win32.ActiveCfg = Release|Win32
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|Win32.Build.0 = Release|Win32
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|x64.ActiveCfg = Release|x64
+		{55812185-D13C-4022-9C81-32E0F4A08305}.Release|x64.Build.0 = Release|x64
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Debug|ARM64.Build.0 = Debug|ARM64
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Debug|Win32.Build.0 = Debug|Win32
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Debug|x64.ActiveCfg = Debug|x64
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Debug|x64.Build.0 = Debug|x64
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Release|ARM64.ActiveCfg = Release|ARM64
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Release|ARM64.Build.0 = Release|ARM64
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Release|Win32.ActiveCfg = Release|Win32
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Release|Win32.Build.0 = Release|Win32
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Release|x64.ActiveCfg = Release|x64
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315}.Release|x64.Build.0 = Release|x64
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Debug|ARM64.Build.0 = Debug|ARM64
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Debug|Win32.Build.0 = Debug|Win32
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Debug|x64.ActiveCfg = Debug|x64
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Debug|x64.Build.0 = Debug|x64
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Release|ARM64.ActiveCfg = Release|ARM64
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Release|ARM64.Build.0 = Release|ARM64
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Release|Win32.ActiveCfg = Release|Win32
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Release|Win32.Build.0 = Release|Win32
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Release|x64.ActiveCfg = Release|x64
+		{0D604DFD-AAB6-442C-9368-F91A344146AB}.Release|x64.Build.0 = Release|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Debug|ARM64.Build.0 = Debug|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Debug|Win32.Build.0 = Debug|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Debug|x64.ActiveCfg = Debug|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Debug|x64.Build.0 = Debug|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Release|ARM64.ActiveCfg = Release|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Release|ARM64.Build.0 = Release|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Release|Win32.ActiveCfg = Release|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Release|Win32.Build.0 = Release|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Release|x64.ActiveCfg = Release|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5}.Release|x64.Build.0 = Release|x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Debug|ARM64.Build.0 = Debug|ARM64
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Debug|Win32.ActiveCfg = Debug|Win32
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Debug|Win32.Build.0 = Debug|Win32
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Debug|x64.ActiveCfg = Debug|x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Debug|x64.Build.0 = Debug|x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Release|ARM64.ActiveCfg = Release|ARM64
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Release|ARM64.Build.0 = Release|ARM64
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Release|Win32.ActiveCfg = Release|Win32
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Release|Win32.Build.0 = Release|Win32
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Release|x64.ActiveCfg = Release|x64
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682}.Release|x64.Build.0 = Release|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Debug|ARM64.Build.0 = Debug|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Debug|Win32.Build.0 = Debug|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Debug|x64.ActiveCfg = Debug|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Debug|x64.Build.0 = Debug|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Release|ARM64.ActiveCfg = Release|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Release|ARM64.Build.0 = Release|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Release|Win32.ActiveCfg = Release|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Release|Win32.Build.0 = Release|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Release|x64.ActiveCfg = Release|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4}.Release|x64.Build.0 = Release|x64
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Debug|ARM64.Build.0 = Debug|ARM64
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Debug|Win32.ActiveCfg = Debug|Win32
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Debug|Win32.Build.0 = Debug|Win32
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Debug|x64.ActiveCfg = Debug|x64
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Debug|x64.Build.0 = Debug|x64
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Release|ARM64.ActiveCfg = Release|ARM64
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Release|ARM64.Build.0 = Release|ARM64
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Release|Win32.ActiveCfg = Release|Win32
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Release|Win32.Build.0 = Release|Win32
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Release|x64.ActiveCfg = Release|x64
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F}.Release|x64.Build.0 = Release|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Debug|ARM64.Build.0 = Debug|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Debug|Win32.Build.0 = Debug|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Debug|x64.ActiveCfg = Debug|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Debug|x64.Build.0 = Debug|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Release|ARM64.ActiveCfg = Release|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Release|ARM64.Build.0 = Release|ARM64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Release|Win32.ActiveCfg = Release|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Release|Win32.Build.0 = Release|Win32
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Release|x64.ActiveCfg = Release|x64
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3}.Release|x64.Build.0 = Release|x64
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Debug|ARM64.Build.0 = Debug|ARM64
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Debug|Win32.Build.0 = Debug|Win32
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Debug|x64.ActiveCfg = Debug|x64
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Debug|x64.Build.0 = Debug|x64
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Release|ARM64.ActiveCfg = Release|ARM64
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Release|ARM64.Build.0 = Release|ARM64
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Release|Win32.ActiveCfg = Release|Win32
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Release|Win32.Build.0 = Release|Win32
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Release|x64.ActiveCfg = Release|x64
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1}.Release|x64.Build.0 = Release|x64
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Debug|ARM64.Build.0 = Debug|ARM64
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Debug|Win32.Build.0 = Debug|Win32
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Debug|x64.ActiveCfg = Debug|x64
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Debug|x64.Build.0 = Debug|x64
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Release|ARM64.ActiveCfg = Release|ARM64
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Release|ARM64.Build.0 = Release|ARM64
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Release|Win32.ActiveCfg = Release|Win32
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Release|Win32.Build.0 = Release|Win32
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Release|x64.ActiveCfg = Release|x64
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}.Release|x64.Build.0 = Release|x64
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Debug|ARM64.Build.0 = Debug|ARM64
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Debug|Win32.ActiveCfg = Debug|Win32
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Debug|Win32.Build.0 = Debug|Win32
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Debug|x64.ActiveCfg = Debug|x64
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Debug|x64.Build.0 = Debug|x64
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Release|ARM64.ActiveCfg = Release|ARM64
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Release|ARM64.Build.0 = Release|ARM64
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Release|Win32.ActiveCfg = Release|Win32
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Release|Win32.Build.0 = Release|Win32
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Release|x64.ActiveCfg = Release|x64
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}.Release|x64.Build.0 = Release|x64
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Debug|ARM64.Build.0 = Debug|ARM64
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Debug|Win32.ActiveCfg = Debug|Win32
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Debug|Win32.Build.0 = Debug|Win32
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Debug|x64.ActiveCfg = Debug|x64
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Debug|x64.Build.0 = Debug|x64
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Release|ARM64.ActiveCfg = Release|ARM64
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Release|ARM64.Build.0 = Release|ARM64
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Release|Win32.ActiveCfg = Release|Win32
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Release|Win32.Build.0 = Release|Win32
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Release|x64.ActiveCfg = Release|x64
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE}.Release|x64.Build.0 = Release|x64
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Debug|ARM64.Build.0 = Debug|ARM64
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Debug|Win32.Build.0 = Debug|Win32
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Debug|x64.ActiveCfg = Debug|x64
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Debug|x64.Build.0 = Debug|x64
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Release|ARM64.ActiveCfg = Release|ARM64
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Release|ARM64.Build.0 = Release|ARM64
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Release|Win32.ActiveCfg = Release|Win32
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Release|Win32.Build.0 = Release|Win32
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Release|x64.ActiveCfg = Release|x64
+		{7820969A-5B7B-4046-BB0A-82905D457FC5}.Release|x64.Build.0 = Release|x64
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Debug|ARM64.Build.0 = Debug|ARM64
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Debug|Win32.ActiveCfg = Debug|Win32
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Debug|Win32.Build.0 = Debug|Win32
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Debug|x64.ActiveCfg = Debug|x64
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Debug|x64.Build.0 = Debug|x64
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Release|ARM64.ActiveCfg = Release|ARM64
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Release|ARM64.Build.0 = Release|ARM64
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Release|Win32.ActiveCfg = Release|Win32
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Release|Win32.Build.0 = Release|Win32
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Release|x64.ActiveCfg = Release|x64
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804}.Release|x64.Build.0 = Release|x64
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Debug|ARM64.Build.0 = Debug|ARM64
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Debug|Win32.Build.0 = Debug|Win32
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Debug|x64.ActiveCfg = Debug|x64
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Debug|x64.Build.0 = Debug|x64
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Release|ARM64.ActiveCfg = Release|ARM64
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Release|ARM64.Build.0 = Release|ARM64
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Release|Win32.ActiveCfg = Release|Win32
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Release|Win32.Build.0 = Release|Win32
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Release|x64.ActiveCfg = Release|x64
+		{896557AC-7575-480C-8FFD-AB08B5DA305D}.Release|x64.Build.0 = Release|x64
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Debug|ARM64.Build.0 = Debug|ARM64
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Debug|Win32.ActiveCfg = Debug|Win32
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Debug|Win32.Build.0 = Debug|Win32
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Debug|x64.ActiveCfg = Debug|x64
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Debug|x64.Build.0 = Debug|x64
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Release|ARM64.ActiveCfg = Release|ARM64
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Release|ARM64.Build.0 = Release|ARM64
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Release|Win32.ActiveCfg = Release|Win32
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Release|Win32.Build.0 = Release|Win32
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Release|x64.ActiveCfg = Release|x64
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3}.Release|x64.Build.0 = Release|x64
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Debug|ARM64.Build.0 = Debug|ARM64
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Debug|Win32.ActiveCfg = Debug|Win32
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Debug|Win32.Build.0 = Debug|Win32
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Debug|x64.ActiveCfg = Debug|x64
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Debug|x64.Build.0 = Debug|x64
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Release|ARM64.ActiveCfg = Release|ARM64
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Release|ARM64.Build.0 = Release|ARM64
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Release|Win32.ActiveCfg = Release|Win32
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Release|Win32.Build.0 = Release|Win32
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Release|x64.ActiveCfg = Release|x64
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699}.Release|x64.Build.0 = Release|x64
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Debug|ARM64.Build.0 = Debug|ARM64
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Debug|Win32.ActiveCfg = Debug|Win32
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Debug|Win32.Build.0 = Debug|Win32
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Debug|x64.ActiveCfg = Debug|x64
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Debug|x64.Build.0 = Debug|x64
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Release|ARM64.ActiveCfg = Release|ARM64
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Release|ARM64.Build.0 = Release|ARM64
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Release|Win32.ActiveCfg = Release|Win32
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Release|Win32.Build.0 = Release|Win32
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Release|x64.ActiveCfg = Release|x64
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB}.Release|x64.Build.0 = Release|x64
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Debug|ARM64.Build.0 = Debug|ARM64
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Debug|Win32.ActiveCfg = Debug|Win32
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Debug|Win32.Build.0 = Debug|Win32
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Debug|x64.ActiveCfg = Debug|x64
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Debug|x64.Build.0 = Debug|x64
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Release|ARM64.ActiveCfg = Release|ARM64
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Release|ARM64.Build.0 = Release|ARM64
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Release|Win32.ActiveCfg = Release|Win32
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Release|Win32.Build.0 = Release|Win32
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Release|x64.ActiveCfg = Release|x64
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17}.Release|x64.Build.0 = Release|x64
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Debug|ARM64.Build.0 = Debug|ARM64
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Debug|Win32.Build.0 = Debug|Win32
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Debug|x64.ActiveCfg = Debug|x64
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Debug|x64.Build.0 = Debug|x64
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Release|ARM64.ActiveCfg = Release|ARM64
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Release|ARM64.Build.0 = Release|ARM64
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Release|Win32.ActiveCfg = Release|Win32
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Release|Win32.Build.0 = Release|Win32
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Release|x64.ActiveCfg = Release|x64
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36}.Release|x64.Build.0 = Release|x64
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Debug|ARM64.Build.0 = Debug|ARM64
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Debug|Win32.Build.0 = Debug|Win32
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Debug|x64.ActiveCfg = Debug|x64
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Debug|x64.Build.0 = Debug|x64
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Release|ARM64.ActiveCfg = Release|ARM64
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Release|ARM64.Build.0 = Release|ARM64
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Release|Win32.ActiveCfg = Release|Win32
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Release|Win32.Build.0 = Release|Win32
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Release|x64.ActiveCfg = Release|x64
+		{540AE143-A58F-4D3B-B843-94EA8576522D}.Release|x64.Build.0 = Release|x64
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Debug|ARM64.Build.0 = Debug|ARM64
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Debug|Win32.ActiveCfg = Debug|Win32
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Debug|Win32.Build.0 = Debug|Win32
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Debug|x64.ActiveCfg = Debug|x64
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Debug|x64.Build.0 = Debug|x64
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Release|ARM64.ActiveCfg = Release|ARM64
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Release|ARM64.Build.0 = Release|ARM64
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Release|Win32.ActiveCfg = Release|Win32
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Release|Win32.Build.0 = Release|Win32
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Release|x64.ActiveCfg = Release|x64
+		{7091C001-3D71-47D4-B27B-E99271E5B987}.Release|x64.Build.0 = Release|x64
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Debug|ARM64.Build.0 = Debug|ARM64
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Debug|Win32.ActiveCfg = Debug|Win32
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Debug|Win32.Build.0 = Debug|Win32
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Debug|x64.ActiveCfg = Debug|x64
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Debug|x64.Build.0 = Debug|x64
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Release|ARM64.ActiveCfg = Release|ARM64
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Release|ARM64.Build.0 = Release|ARM64
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Release|Win32.ActiveCfg = Release|Win32
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Release|Win32.Build.0 = Release|Win32
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Release|x64.ActiveCfg = Release|x64
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F}.Release|x64.Build.0 = Release|x64
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Debug|ARM64.Build.0 = Debug|ARM64
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Debug|Win32.ActiveCfg = Debug|Win32
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Debug|Win32.Build.0 = Debug|Win32
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Debug|x64.ActiveCfg = Debug|x64
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Debug|x64.Build.0 = Debug|x64
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Release|ARM64.ActiveCfg = Release|ARM64
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Release|ARM64.Build.0 = Release|ARM64
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Release|Win32.ActiveCfg = Release|Win32
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Release|Win32.Build.0 = Release|Win32
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Release|x64.ActiveCfg = Release|x64
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72}.Release|x64.Build.0 = Release|x64
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Debug|ARM64.Build.0 = Debug|ARM64
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Debug|Win32.Build.0 = Debug|Win32
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Debug|x64.ActiveCfg = Debug|x64
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Debug|x64.Build.0 = Debug|x64
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Release|ARM64.ActiveCfg = Release|ARM64
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Release|ARM64.Build.0 = Release|ARM64
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Release|Win32.ActiveCfg = Release|Win32
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Release|Win32.Build.0 = Release|Win32
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Release|x64.ActiveCfg = Release|x64
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077}.Release|x64.Build.0 = Release|x64
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Debug|ARM64.Build.0 = Debug|ARM64
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Debug|Win32.Build.0 = Debug|Win32
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Debug|x64.ActiveCfg = Debug|x64
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Debug|x64.Build.0 = Debug|x64
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Release|ARM64.ActiveCfg = Release|ARM64
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Release|ARM64.Build.0 = Release|ARM64
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Release|Win32.ActiveCfg = Release|Win32
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Release|Win32.Build.0 = Release|Win32
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Release|x64.ActiveCfg = Release|x64
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73}.Release|x64.Build.0 = Release|x64
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Debug|ARM64.Build.0 = Debug|ARM64
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Debug|Win32.Build.0 = Debug|Win32
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Debug|x64.ActiveCfg = Debug|x64
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Debug|x64.Build.0 = Debug|x64
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Release|ARM64.ActiveCfg = Release|ARM64
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Release|ARM64.Build.0 = Release|ARM64
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Release|Win32.ActiveCfg = Release|Win32
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Release|Win32.Build.0 = Release|Win32
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Release|x64.ActiveCfg = Release|x64
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC}.Release|x64.Build.0 = Release|x64
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Debug|ARM64.Build.0 = Debug|ARM64
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Debug|Win32.ActiveCfg = Debug|Win32
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Debug|Win32.Build.0 = Debug|Win32
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Debug|x64.ActiveCfg = Debug|x64
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Debug|x64.Build.0 = Debug|x64
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Release|ARM64.ActiveCfg = Release|ARM64
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Release|ARM64.Build.0 = Release|ARM64
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Release|Win32.ActiveCfg = Release|Win32
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Release|Win32.Build.0 = Release|Win32
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Release|x64.ActiveCfg = Release|x64
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C}.Release|x64.Build.0 = Release|x64
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Debug|ARM64.Build.0 = Debug|ARM64
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Debug|Win32.Build.0 = Debug|Win32
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Debug|x64.ActiveCfg = Debug|x64
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Debug|x64.Build.0 = Debug|x64
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Release|ARM64.ActiveCfg = Release|ARM64
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Release|ARM64.Build.0 = Release|ARM64
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Release|Win32.ActiveCfg = Release|Win32
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Release|Win32.Build.0 = Release|Win32
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Release|x64.ActiveCfg = Release|x64
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE}.Release|x64.Build.0 = Release|x64
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Debug|ARM64.Build.0 = Debug|ARM64
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Debug|Win32.ActiveCfg = Debug|Win32
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Debug|Win32.Build.0 = Debug|Win32
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Debug|x64.ActiveCfg = Debug|x64
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Debug|x64.Build.0 = Debug|x64
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Release|ARM64.ActiveCfg = Release|ARM64
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Release|ARM64.Build.0 = Release|ARM64
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Release|Win32.ActiveCfg = Release|Win32
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Release|Win32.Build.0 = Release|Win32
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Release|x64.ActiveCfg = Release|x64
+		{608C6C67-7766-471F-BBFF-8B00086039AF}.Release|x64.Build.0 = Release|x64
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Debug|ARM64.Build.0 = Debug|ARM64
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Debug|Win32.ActiveCfg = Debug|Win32
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Debug|Win32.Build.0 = Debug|Win32
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Debug|x64.ActiveCfg = Debug|x64
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Debug|x64.Build.0 = Debug|x64
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Release|ARM64.ActiveCfg = Release|ARM64
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Release|ARM64.Build.0 = Release|ARM64
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Release|Win32.ActiveCfg = Release|Win32
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Release|Win32.Build.0 = Release|Win32
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Release|x64.ActiveCfg = Release|x64
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}.Release|x64.Build.0 = Release|x64
+		{75AEE75A-C016-4497-960B-D767B822237D}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{75AEE75A-C016-4497-960B-D767B822237D}.Debug|ARM64.Build.0 = Debug|ARM64
+		{75AEE75A-C016-4497-960B-D767B822237D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{75AEE75A-C016-4497-960B-D767B822237D}.Debug|Win32.Build.0 = Debug|Win32
+		{75AEE75A-C016-4497-960B-D767B822237D}.Debug|x64.ActiveCfg = Debug|x64
+		{75AEE75A-C016-4497-960B-D767B822237D}.Debug|x64.Build.0 = Debug|x64
+		{75AEE75A-C016-4497-960B-D767B822237D}.Release|ARM64.ActiveCfg = Release|ARM64
+		{75AEE75A-C016-4497-960B-D767B822237D}.Release|ARM64.Build.0 = Release|ARM64
+		{75AEE75A-C016-4497-960B-D767B822237D}.Release|Win32.ActiveCfg = Release|Win32
+		{75AEE75A-C016-4497-960B-D767B822237D}.Release|Win32.Build.0 = Release|Win32
+		{75AEE75A-C016-4497-960B-D767B822237D}.Release|x64.ActiveCfg = Release|x64
+		{75AEE75A-C016-4497-960B-D767B822237D}.Release|x64.Build.0 = Release|x64
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Debug|ARM64.Build.0 = Debug|ARM64
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Debug|Win32.Build.0 = Debug|Win32
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Debug|x64.ActiveCfg = Debug|x64
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Debug|x64.Build.0 = Debug|x64
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Release|ARM64.ActiveCfg = Release|ARM64
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Release|ARM64.Build.0 = Release|ARM64
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Release|Win32.ActiveCfg = Release|Win32
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Release|Win32.Build.0 = Release|Win32
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Release|x64.ActiveCfg = Release|x64
+		{E21C50BF-54B4-434C-AA24-9A6469553987}.Release|x64.Build.0 = Release|x64
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Debug|ARM64.Build.0 = Debug|ARM64
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Debug|Win32.ActiveCfg = Debug|Win32
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Debug|Win32.Build.0 = Debug|Win32
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Debug|x64.ActiveCfg = Debug|x64
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Debug|x64.Build.0 = Debug|x64
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Release|ARM64.ActiveCfg = Release|ARM64
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Release|ARM64.Build.0 = Release|ARM64
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Release|Win32.ActiveCfg = Release|Win32
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Release|Win32.Build.0 = Release|Win32
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Release|x64.ActiveCfg = Release|x64
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}.Release|x64.Build.0 = Release|x64
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Debug|ARM64.Build.0 = Debug|ARM64
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Debug|Win32.ActiveCfg = Debug|Win32
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Debug|Win32.Build.0 = Debug|Win32
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Debug|x64.ActiveCfg = Debug|x64
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Debug|x64.Build.0 = Debug|x64
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Release|ARM64.ActiveCfg = Release|ARM64
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Release|ARM64.Build.0 = Release|ARM64
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Release|Win32.ActiveCfg = Release|Win32
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Release|Win32.Build.0 = Release|Win32
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Release|x64.ActiveCfg = Release|x64
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}.Release|x64.Build.0 = Release|x64
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Debug|ARM64.Build.0 = Debug|ARM64
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Debug|Win32.Build.0 = Debug|Win32
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Debug|x64.ActiveCfg = Debug|x64
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Debug|x64.Build.0 = Debug|x64
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Release|ARM64.ActiveCfg = Release|ARM64
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Release|ARM64.Build.0 = Release|ARM64
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Release|Win32.ActiveCfg = Release|Win32
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Release|Win32.Build.0 = Release|Win32
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Release|x64.ActiveCfg = Release|x64
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF}.Release|x64.Build.0 = Release|x64
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Debug|ARM64.Build.0 = Debug|ARM64
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Debug|Win32.ActiveCfg = Debug|Win32
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Debug|Win32.Build.0 = Debug|Win32
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Debug|x64.ActiveCfg = Debug|x64
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Debug|x64.Build.0 = Debug|x64
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Release|ARM64.ActiveCfg = Release|ARM64
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Release|ARM64.Build.0 = Release|ARM64
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Release|Win32.ActiveCfg = Release|Win32
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Release|Win32.Build.0 = Release|Win32
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Release|x64.ActiveCfg = Release|x64
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C}.Release|x64.Build.0 = Release|x64
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Debug|ARM64.Build.0 = Debug|ARM64
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Debug|Win32.ActiveCfg = Debug|Win32
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Debug|Win32.Build.0 = Debug|Win32
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Debug|x64.ActiveCfg = Debug|x64
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Debug|x64.Build.0 = Debug|x64
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Release|ARM64.ActiveCfg = Release|ARM64
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Release|ARM64.Build.0 = Release|ARM64
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Release|Win32.ActiveCfg = Release|Win32
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Release|Win32.Build.0 = Release|Win32
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Release|x64.ActiveCfg = Release|x64
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89}.Release|x64.Build.0 = Release|x64
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Debug|ARM64.Build.0 = Debug|ARM64
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Debug|Win32.Build.0 = Debug|Win32
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Debug|x64.ActiveCfg = Debug|x64
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Debug|x64.Build.0 = Debug|x64
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Release|ARM64.ActiveCfg = Release|ARM64
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Release|ARM64.Build.0 = Release|ARM64
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Release|Win32.ActiveCfg = Release|Win32
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Release|Win32.Build.0 = Release|Win32
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Release|x64.ActiveCfg = Release|x64
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A}.Release|x64.Build.0 = Release|x64
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Debug|ARM64.Build.0 = Debug|ARM64
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Debug|Win32.ActiveCfg = Debug|Win32
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Debug|Win32.Build.0 = Debug|Win32
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Debug|x64.ActiveCfg = Debug|x64
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Debug|x64.Build.0 = Debug|x64
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Release|ARM64.ActiveCfg = Release|ARM64
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Release|ARM64.Build.0 = Release|ARM64
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Release|Win32.ActiveCfg = Release|Win32
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Release|Win32.Build.0 = Release|Win32
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Release|x64.ActiveCfg = Release|x64
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}.Release|x64.Build.0 = Release|x64
+		{70B36605-D8E8-4679-A126-0869BA621778}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{70B36605-D8E8-4679-A126-0869BA621778}.Debug|ARM64.Build.0 = Debug|ARM64
+		{70B36605-D8E8-4679-A126-0869BA621778}.Debug|Win32.ActiveCfg = Debug|Win32
+		{70B36605-D8E8-4679-A126-0869BA621778}.Debug|Win32.Build.0 = Debug|Win32
+		{70B36605-D8E8-4679-A126-0869BA621778}.Debug|x64.ActiveCfg = Debug|x64
+		{70B36605-D8E8-4679-A126-0869BA621778}.Debug|x64.Build.0 = Debug|x64
+		{70B36605-D8E8-4679-A126-0869BA621778}.Release|ARM64.ActiveCfg = Release|ARM64
+		{70B36605-D8E8-4679-A126-0869BA621778}.Release|ARM64.Build.0 = Release|ARM64
+		{70B36605-D8E8-4679-A126-0869BA621778}.Release|Win32.ActiveCfg = Release|Win32
+		{70B36605-D8E8-4679-A126-0869BA621778}.Release|Win32.Build.0 = Release|Win32
+		{70B36605-D8E8-4679-A126-0869BA621778}.Release|x64.ActiveCfg = Release|x64
+		{70B36605-D8E8-4679-A126-0869BA621778}.Release|x64.Build.0 = Release|x64
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Debug|ARM64.Build.0 = Debug|ARM64
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Debug|Win32.Build.0 = Debug|Win32
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Debug|x64.ActiveCfg = Debug|x64
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Debug|x64.Build.0 = Debug|x64
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Release|ARM64.ActiveCfg = Release|ARM64
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Release|ARM64.Build.0 = Release|ARM64
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Release|Win32.ActiveCfg = Release|Win32
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Release|Win32.Build.0 = Release|Win32
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Release|x64.ActiveCfg = Release|x64
+		{F4441527-0487-4743-ACF0-435D71C8DBE8}.Release|x64.Build.0 = Release|x64
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Debug|ARM64.Build.0 = Debug|ARM64
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Debug|Win32.ActiveCfg = Debug|Win32
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Debug|Win32.Build.0 = Debug|Win32
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Debug|x64.ActiveCfg = Debug|x64
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Debug|x64.Build.0 = Debug|x64
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Release|ARM64.ActiveCfg = Release|ARM64
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Release|ARM64.Build.0 = Release|ARM64
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Release|Win32.ActiveCfg = Release|Win32
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Release|Win32.Build.0 = Release|Win32
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Release|x64.ActiveCfg = Release|x64
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB}.Release|x64.Build.0 = Release|x64
+		{40F19482-512F-4123-A57B-509679EC8F26}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{40F19482-512F-4123-A57B-509679EC8F26}.Debug|ARM64.Build.0 = Debug|ARM64
+		{40F19482-512F-4123-A57B-509679EC8F26}.Debug|Win32.ActiveCfg = Debug|Win32
+		{40F19482-512F-4123-A57B-509679EC8F26}.Debug|Win32.Build.0 = Debug|Win32
+		{40F19482-512F-4123-A57B-509679EC8F26}.Debug|x64.ActiveCfg = Debug|x64
+		{40F19482-512F-4123-A57B-509679EC8F26}.Debug|x64.Build.0 = Debug|x64
+		{40F19482-512F-4123-A57B-509679EC8F26}.Release|ARM64.ActiveCfg = Release|ARM64
+		{40F19482-512F-4123-A57B-509679EC8F26}.Release|ARM64.Build.0 = Release|ARM64
+		{40F19482-512F-4123-A57B-509679EC8F26}.Release|Win32.ActiveCfg = Release|Win32
+		{40F19482-512F-4123-A57B-509679EC8F26}.Release|Win32.Build.0 = Release|Win32
+		{40F19482-512F-4123-A57B-509679EC8F26}.Release|x64.ActiveCfg = Release|x64
+		{40F19482-512F-4123-A57B-509679EC8F26}.Release|x64.Build.0 = Release|x64
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Debug|ARM64.Build.0 = Debug|ARM64
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Debug|Win32.ActiveCfg = Debug|Win32
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Debug|Win32.Build.0 = Debug|Win32
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Debug|x64.ActiveCfg = Debug|x64
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Debug|x64.Build.0 = Debug|x64
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Release|ARM64.ActiveCfg = Release|ARM64
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Release|ARM64.Build.0 = Release|ARM64
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Release|Win32.ActiveCfg = Release|Win32
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Release|Win32.Build.0 = Release|Win32
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Release|x64.ActiveCfg = Release|x64
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{26828762-C95D-4637-9CB1-7F0979523813} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{AAAD1CB5-7ADA-47AE-85A0-08A6EC48FAFB} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{66B32F7E-5716-48D0-B5B9-D832FD052DD5} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{9C7E8C03-3130-436D-A97E-E8F8ED1AC4EA} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{97A3A89B-E023-48CD-905F-CDBDE8D951DE} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{8682FE1E-0CF6-4EDD-9BB5-1733D8C8B4DF} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{CAE4F1D0-314F-4B10-805B-0EFD670133A0} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{8B5CFB38-CCBA-40A8-AD7A-89C57B070884} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{B51E0D74-F0A2-45A2-BD2A-8B7D95B8204A} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{26932B24-EFC6-4E3A-B277-ED653DA37968} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A3} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{2D17C1EB-1157-460E-9A99-A82BFC1F9D1E} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{BFF40245-E9A6-4297-A425-A554E5D767E8} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{5D0930C0-7C91-4ECE-9014-7B7DDE9502E6} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{31A3E4E1-AAE9-4EF3-9B23-18D0924BE4D2} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{40FB7794-D3C3-4CFE-BCF4-A80C96635682} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{55812185-D13C-4022-9C81-32E0F4A08305} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{E9558DFE-1961-4DD4-B09B-DD0EEFD5C315} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{0D604DFD-AAB6-442C-9368-F91A344146AB} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A5} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{40FB7794-D3C3-4CFE-BCF4-A80C97635682} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC0A4} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{70B894A9-E306-49E8-ABC2-932A952A5E5F} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{C4E04D18-EF76-4B42-B4C2-16A1BACDC1A3} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{E2AE0C33-D9C6-4B8E-BB65-6F8AF2F9EBD1} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{1B61A1B7-92DE-4C37-9151-D2928D6449AB} = {1498F0CD-F4DA-4847-9CB2-FB18D48061D5}
+		{EB448819-74BC-40C9-A61A-4D4ECD55F9D5} = {1B61A1B7-92DE-4C37-9151-D2928D6449AB}
+		{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0} = {1B61A1B7-92DE-4C37-9151-D2928D6449AB}
+		{AAEC8338-4D33-4AF5-9A1F-B9FF027D4607} = {1498F0CD-F4DA-4847-9CB2-FB18D48061D5}
+		{510ACF0C-4012-4216-98EF-E4F155DE33CE} = {AAEC8338-4D33-4AF5-9A1F-B9FF027D4607}
+		{D1BF59F6-22DC-493B-BDEB-451A50DA793D} = {1498F0CD-F4DA-4847-9CB2-FB18D48061D5}
+		{7820969A-5B7B-4046-BB0A-82905D457FC5} = {D1BF59F6-22DC-493B-BDEB-451A50DA793D}
+		{F2247885-8EE8-42F4-A702-4155587620E0} = {1498F0CD-F4DA-4847-9CB2-FB18D48061D5}
+		{5EDA1ED3-8213-4C12-B0DF-B631EB611804} = {F2247885-8EE8-42F4-A702-4155587620E0}
+		{F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A} = {1498F0CD-F4DA-4847-9CB2-FB18D48061D5}
+		{896557AC-7575-480C-8FFD-AB08B5DA305D} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{504DC7EC-D82E-448E-9C7D-3BE7981592B3} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{BDE7DBC0-DCE7-432E-8750-C4AE55463699} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{7B250AB1-92D3-4F1A-BEB4-19605A69CEDB} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{4C0E3A60-24F8-4D4C-81C0-C1777F5E7B17} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{B3D61611-BFA3-4B66-ADC7-A3CE578A6D36} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{540AE143-A58F-4D3B-B843-94EA8576522D} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{7091C001-3D71-47D4-B27B-E99271E5B987} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{AF8BC84E-0268-4D1F-9503-84D9EE84C65F} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{8B9AB23E-3F40-4145-BA1C-B2CEACFBBD72} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{E9C6A7A6-22C0-42E6-AC9C-8580A396D077} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{B85BC466-C7F0-4C6D-8ECF-ED57E775FC73} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{9DBD962F-EA4D-44E3-8E8E-31D7F060A2DC} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{EEF00329-4598-4E34-B969-9DD4B0815E6C} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{CC0714AA-8A81-4E29-BEC5-2E4FBC50E7FE} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{608C6C67-7766-471F-BBFF-8B00086039AF} = {1B61A1B7-92DE-4C37-9151-D2928D6449AB}
+		{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60} = {D1BF59F6-22DC-493B-BDEB-451A50DA793D}
+		{75AEE75A-C016-4497-960B-D767B822237D} = {D1BF59F6-22DC-493B-BDEB-451A50DA793D}
+		{E21C50BF-54B4-434C-AA24-9A6469553987} = {F91DDAF0-B74F-4516-A1A9-42ED8DFCBF6A}
+		{7117A55C-BE4E-41DB-A4FC-4070E35A8B28} = {1B61A1B7-92DE-4C37-9151-D2928D6449AB}
+		{02EA681E-C7D8-13C7-8484-4AC65E1B71E8} = {1498F0CD-F4DA-4847-9CB2-FB18D48061D5}
+		{8DEAE483-FDE7-463F-9FD5-F597BBAED1F9} = {1498F0CD-F4DA-4847-9CB2-FB18D48061D5}
+		{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{3DB9B219-769E-43AC-8B8B-319DB6045DCF} = {D1BF59F6-22DC-493B-BDEB-451A50DA793D}
+		{B3852DB7-E925-4026-8B9D-D2272EFEFF3C} = {8DEAE483-FDE7-463F-9FD5-F597BBAED1F9}
+		{FCBDF2B2-1129-49AE-9406-3F219E65CA89} = {8DEAE483-FDE7-463F-9FD5-F597BBAED1F9}
+		{D91C45E2-274E-4C0F-89C7-9986F9A7E85A} = {D69D5741-611F-4E14-8541-1FEE94F50B5A}
+		{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5} = {1B61A1B7-92DE-4C37-9151-D2928D6449AB}
+		{70B36605-D8E8-4679-A126-0869BA621778} = {8DEAE483-FDE7-463F-9FD5-F597BBAED1F9}
+		{F4441527-0487-4743-ACF0-435D71C8DBE8} = {8DEAE483-FDE7-463F-9FD5-F597BBAED1F9}
+		{FA68A4F2-2DB8-4C90-8809-6B9764C92E77} = {1498F0CD-F4DA-4847-9CB2-FB18D48061D5}
+		{6975730D-AFA0-4687-9B89-EC1FE0BDA8CB} = {FA68A4F2-2DB8-4C90-8809-6B9764C92E77}
+		{40F19482-512F-4123-A57B-509679EC8F26} = {FA68A4F2-2DB8-4C90-8809-6B9764C92E77}
+		{6381F9D3-BA5F-4E5C-80FF-9013964777EE} = {FA68A4F2-2DB8-4C90-8809-6B9764C92E77}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C320C9F2-1A8F-41D7-B02B-6338F872BCAD}
+	EndGlobalSection
+EndGlobal

external/SDL/VisualC/SDL/Directory.Build.props

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions>SDL_VENDOR_INFO="libsdl.org";%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+</Project>

external/SDL/VisualC/SDL_test/Directory.Build.props

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions>SDL_VENDOR_INFO="libsdl.org";%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+</Project>

external/SDL/VisualC/SDL_test/SDL_test.vcxproj

@@ -0,0 +1,259 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectName>SDL3_test</ProjectName>
+    <ProjectGuid>{DA956FD3-E143-46F2-9FE5-C77BEBC56B1A}</ProjectGuid>
+    <RootNamespace>SDL_test</RootNamespace>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">$(Platform)\$(Configuration)\</IntDir>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" />
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <PreBuildEvent>
+      <Command>
+      </Command>
+    </PreBuildEvent>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <EnableEnhancedInstructionSet>StreamingSIMDExtensions</EnableEnhancedInstructionSet>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <Midl />
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <PreBuildEvent>
+      <Command>
+      </Command>
+    </PreBuildEvent>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <EnableEnhancedInstructionSet>StreamingSIMDExtensions</EnableEnhancedInstructionSet>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Midl>
+      <TargetEnvironment>X64</TargetEnvironment>
+    </Midl>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <Midl />
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(ProjectDir)/../../include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalUsingDirectories>%(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <WarningLevel>Level3</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+      <OmitDefaultLibName>true</OmitDefaultLibName>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(TreatWarningsAsError)'!=''">
+    <ClCompile>
+      <TreatWarningAsError>$(TreatWarningsAsError)</TreatWarningAsError>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\test\SDL_test_internal.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\src\test\SDL_test_assert.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_common.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_compare.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_crc32.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_font.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_fuzzer.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_harness.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_log.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_md5.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_memory.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\SDL3\SDL_test.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_assert.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_common.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_compare.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_crc32.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_font.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_fuzzer.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_harness.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_log.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_md5.h" />
+    <ClInclude Include="..\..\include\SDL3\SDL_test_memory.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

external/SDL/VisualC/SDL_test/SDL_test.vcxproj.filters

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\..\src\test\SDL_test_internal.h" />
+    <ClCompile Include="..\..\src\test\SDL_test_assert.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_common.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_compare.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_crc32.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_font.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_fuzzer.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_harness.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_log.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_md5.c" />
+    <ClCompile Include="..\..\src\test\SDL_test_memory.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <Filter Include="API Headers">
+      <UniqueIdentifier>{7a277aa4-b043-46fe-bea1-f24da5d5ec5d}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\include\SDL3\SDL_test.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_assert.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_common.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_compare.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_crc32.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_font.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_fuzzer.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_harness.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_log.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_md5.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\include\SDL3\SDL_test_memory.h">
+      <Filter>API Headers</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>

external/SDL/VisualC/clean.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+find . -type f \( -name '*.user' -o -name '*.sdf' -o -name '*.ncb' -o -name '*.suo' \) -print -delete
+find . -type f \( -name '*.png' -o -name '*.wav' -o -name '*.dat' \) -print -delete
+find . -depth -type d \( -name Win32 -o -name x64 -o name ARM64 \) -exec rm -rv {} \;

external/SDL/VisualC/examples/Examples.props

@@ -0,0 +1,251 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PreferredToolArchitecture>x64</PreferredToolArchitecture>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset Condition="'$(VisualStudioVersion)' != '10.0'">$(DefaultPlatformToolset)</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Platform)\$(Configuration)\</IntDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalOptions>%(AdditionalOptions) /utf-8</AdditionalOptions>
+      <AdditionalIncludeDirectories>$(SolutionDir)\..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(SolutionDir)\SDL\SDL.vcxproj">
+      <Project>{81CE8DAF-EBB2-4761-8E45-B71ABCCA8C68}</Project>
+      <Private>false</Private>
+      <CopyLocalSatelliteAssemblies>false</CopyLocalSatelliteAssemblies>
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+    </ProjectReference>
+  </ItemGroup>
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

external/SDL/VisualC/examples/asyncio/01-load-bitmaps/01-load-bitmaps.vcxproj

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{6A2BFA8B-C027-400D-A18B-3E9E1CC4DDD0}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\asyncio\01-load-bitmaps\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\asyncio\01-load-bitmaps\load-bitmaps.c" />
+    <Content Include="$(SolutionDir)\..\test\sample.png" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="$(SolutionDir)\..\test\gamepad_front.png" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="$(SolutionDir)\..\test\speaker.png" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="$(SolutionDir)\..\test\icon2x.png" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/audio/01-simple-playback/01-simple-playback.vcxproj

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{EB448819-74BC-40C9-A61A-4D4ECD55F9D5}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\audio\01-simple-playback\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\audio\01-simple-playback\simple-playback.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/audio/02-simple-playback-callback/02-simple-playback-callback.vcxproj

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{6B710DFF-8A4A-40A2-BF2D-88D266F3D4F0}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\audio\02-simple-playback-callback\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\audio\02-simple-playback-callback\simple-playback-callback.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/audio/03-load-wav/03-load-wav.vcxproj

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{608C6C67-7766-471F-BBFF-8B00086039AF}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\audio\03-load-wav\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\audio\03-load-wav\load-wav.c" />
+    <Content Include="$(SolutionDir)\..\test\sample.wav" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/audio/04-multiple-streams/04-multiple-streams.vcxproj

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{7117A55C-BE4E-41DB-A4FC-4070E35A8B28}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\audio\04-multiple-streams\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\audio\04-multiple-streams\multiple-streams.c" />
+    <Content Include="$(SolutionDir)\..\test\sample.wav" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="$(SolutionDir)\..\test\sword.wav" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/audio/05-planar-data/05-planar-data.vcxproj

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{9D58F0C6-0A8E-4ACD-8EB5-0B76168BA8B5}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\audio\05-planar-data\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\audio\05-planar-data\planar-data.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/camera/01-read-and-draw/01-read-and-draw.vcxproj

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{510ACF0C-4012-4216-98EF-E4F155DE33CE}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\camera\01-read-and-draw\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\camera\01-read-and-draw\read-and-draw.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/demo/01-snake/01-snake.vcxproj

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{7820969A-5B7B-4046-BB0A-82905D457FC5}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\demo\01-snake\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\demo\01-snake\snake.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/demo/02-woodeneye-008/02-woodeneye-008.vcxproj

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{A3F601E0-B54C-4DD8-8A97-FDEF7624EE60}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\demo\02-woodeneye-008\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\demo\02-woodeneye-008\woodeneye-008.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/demo/03-infinite-monkeys/03-infinite-monkeys.vcxproj

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{75AEE75A-C016-4497-960B-D767B822237D}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\demo\03-infinite-monkeys\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\demo\03-infinite-monkeys\infinite-monkeys.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>

external/SDL/VisualC/examples/demo/04-bytepusher/04-bytepusher.vcxproj

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3DB9B219-769E-43AC-8B8B-319DB6045DCF}</ProjectGuid>
+  </PropertyGroup>
+  <Import Project="$(SolutionDir)\examples\Examples.props" />
+  <ItemGroup>
+    <None Include="$(SolutionDir)\..\examples\demo\04-bytepusher\README.txt" />
+    <ClCompile Include="$(SolutionDir)\..\examples\demo\04-bytepusher\bytepusher.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>