Add test sources to mingw release artifact

(cherry picked from commit c46bec009b)

.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@v4
+      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@v4
+      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 }}"

.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@v4
+      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 }}
+      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 }}
+      uses: actions/cache/save@v4
+      with:
+        path: '${{ runner.temp }}/${{ steps.calc.outputs.archive }}'
+        key: ${{ steps.calc.outputs.cache-key }}
+    - name: 'Extract libusb'
+      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

.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@v4
+      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@v4
+      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

.github/workflows/android.yml

@@ -1,81 +0,0 @@
-name: Build (Android)
-
-on: [push, pull_request]
-
-jobs:
-  android:
-    name: ${{ matrix.platform.name }}
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - { name: Android.mk  }
-          - { name: CMake, cmake: 1, android_abi: "arm64-v8a", android_platform: 23, arch: "aarch64" }
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: nttld/setup-ndk@v1
-        id: setup_ndk
-        with:
-          ndk-version: r21e
-      - name: Build (Android.mk)
-        if: ${{ matrix.platform.name == 'Android.mk' }}
-        run: |
-          ./build-scripts/androidbuildlibs.sh
-      - name: Setup (CMake)
-        if: ${{ matrix.platform.name == 'CMake' }}
-        run: |
-          sudo apt-get update
-          sudo apt-get install ninja-build pkg-config
-      - name: Configure (CMake)
-        if: ${{ matrix.platform.name == 'CMake' }}
-        run: |
-          cmake -B build \
-            -DCMAKE_TOOLCHAIN_FILE=${{ steps.setup_ndk.outputs.ndk-path }}/build/cmake/android.toolchain.cmake \
-            -DSDL_WERROR=ON \
-            -DANDROID_PLATFORM=${{ matrix.platform.android_platform }} \
-            -DANDROID_ABI=${{ matrix.platform.android_abi }} \
-            -DSDL_STATIC_PIC=ON \
-            -DSDL_VENDOR_INFO="Github Workflow" \
-            -DCMAKE_INSTALL_PREFIX=prefix \
-            -DCMAKE_BUILD_TYPE=Release \
-            -GNinja
-      - name: Build (CMake)
-        if: ${{ matrix.platform.name == 'CMake' }}
-        run: |
-          cmake --build build --config Release --parallel --verbose
-      - name: Install (CMake)
-        if: ${{ matrix.platform.name == 'CMake' }}
-        run: |
-          cmake --install build --config Release
-          echo "SDL2_DIR=$(pwd)/prefix" >> $GITHUB_ENV
-          ( cd prefix; find ) | LC_ALL=C sort -u
-      - name: Verify CMake configuration files
-        if: ${{ matrix.platform.name == 'CMake' }}
-        run: |
-          cmake -S cmake/test -B cmake_config_build -G Ninja \
-            -DCMAKE_TOOLCHAIN_FILE=${{ steps.setup_ndk.outputs.ndk-path }}/build/cmake/android.toolchain.cmake \
-            -DANDROID_PLATFORM=${{ matrix.platform.android_platform }} \
-            -DANDROID_ABI=${{ matrix.platform.android_abi }} \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }}
-          cmake --build cmake_config_build --verbose
-      - name: Verify sdl2-config
-        if: ${{ matrix.platform.name == 'CMake' }}
-        run: |
-          export CC="${{ steps.setup_ndk.outputs.ndk-path }}/toolchains/llvm/prebuilt/linux-x86_64/bin/clang --target=${{ matrix.platform.arch }}-none-linux-androideabi${{ matrix.platform.android_platform }}"
-          export PATH=${{ env.SDL2_DIR }}/bin:$PATH
-          cmake/test/test_sdlconfig.sh
-      - name: Verify sdl2.pc
-        if: ${{ matrix.platform.name == 'CMake' }}
-        run: |
-          export CC="${{ steps.setup_ndk.outputs.ndk-path }}/toolchains/llvm/prebuilt/linux-x86_64/bin/clang --target=${{ matrix.platform.arch }}-none-linux-androideabi${{ matrix.platform.android_platform }}"
-          export PKG_CONFIG_PATH=${{ env.SDL2_DIR }}/lib/pkgconfig
-          cmake/test/test_pkgconfig.sh
-      - name: Verify Android.mk
-        if: ${{ matrix.platform.name == 'CMake' }}
-        run: |
-          export NDK_MODULE_PATH=${{ env.SDL2_DIR }}/share/ndk-modules
-          ndk-build -C ${{ github.workspace }}/cmake/test APP_PLATFORM=android-${{ matrix.platform.android_platform }} APP_ABI=${{ matrix.platform.android_abi }} NDK_OUT=$PWD NDK_LIBS_OUT=$PWD V=1

.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 }}

.github/workflows/cpactions.yml

@@ -1,51 +0,0 @@
-name: Build (C/P Actions)
-
-on: [push, pull_request]
-
-jobs:
-  freebsd:
-    runs-on: ubuntu-latest
-    name: FreeBSD
-    timeout-minutes: 30
-    steps:
-    - uses: actions/checkout@v4
-    - name: Build
-      uses: cross-platform-actions/action@v0.23.0
-      with:
-        operating_system: freebsd
-        version: '13.2'
-        shell: bash
-        run: |
-          sudo pkg update
-          sudo pkg install -y \
-              gmake \
-              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
-          mkdir build_autotools
-          export CPPFLAGS="-I/usr/local/include"
-          export LDFLAGS="-L/usr/local/lib"
-          (cd build_autotools && ../configure --disable-static)
-          gmake -C build_autotools -j`sysctl -n hw.ncpu` V=1

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

@@ -0,0 +1,803 @@
+#!/usr/bin/env python
+import argparse
+import dataclasses
+import fnmatch
+from enum import Enum
+import json
+import logging
+import os
+import re
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class AppleArch(Enum):
+    ARM64 = "arm64"
+    X86_64 = "x86_64"
+
+
+class MsvcArch(Enum):
+    X86 = "x86"
+    X64 = "x64"
+    Arm32 = "arm"
+    Arm64 = "arm64"
+
+
+class JobOs(Enum):
+    WindowsLatest = "windows-latest"
+    UbuntuLatest = "ubuntu-latest"
+    MacosLatest = "macos-latest"
+    Ubuntu20_04 = "ubuntu-20.04"
+    Ubuntu22_04 = "ubuntu-22.04"
+    Ubuntu24_04 = "ubuntu-24.04"
+    Macos13 = "macos-13"
+
+
+class SdlPlatform(Enum):
+    Android = "android"
+    Emscripten = "emscripten"
+    Haiku = "haiku"
+    Msys2 = "msys2"
+    Linux = "linux"
+    MacOS = "macos"
+    Ios = "ios"
+    Tvos = "tvos"
+    Msvc = "msvc"
+    N3ds = "n3ds"
+    Ps2 = "ps2"
+    Psp = "psp"
+    Vita = "vita"
+    Riscos = "riscos"
+    FreeBSD = "freebsd"
+    NetBSD = "netbsd"
+    Watcom = "watcom"
+
+
+class Msys2Platform(Enum):
+    Mingw32 = "mingw32"
+    Mingw64 = "mingw64"
+    Clang32 = "clang32"
+    Clang64 = "clang64"
+    Ucrt64 = "ucrt64"
+
+
+class IntelCompiler(Enum):
+    Icc = "icc"
+    Icx = "icx"
+
+
+class VitaGLES(Enum):
+    Pib = "pib"
+    Pvr = "pvr"
+
+class WatcomPlatform(Enum):
+    Windows = "windows"
+    OS2 = "OS/2"
+
+
+@dataclasses.dataclass(slots=True)
+class JobSpec:
+    name: str
+    os: JobOs
+    platform: SdlPlatform
+    artifact: Optional[str]
+    container: Optional[str] = None
+    autotools: bool = False
+    no_cmake: bool = False
+    xcode: bool = False
+    android_mk: 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_archs: Optional[set[AppleArch]] = None
+    msvc_project: Optional[str] = None
+    msvc_arch: Optional[MsvcArch] = None
+    msvc_static_crt: bool = False
+    clang_cl: bool = False
+    gdk: bool = False
+    uwp: bool = False
+    vita_gles: Optional[VitaGLES] = None
+    watcom_platform: Optional[WatcomPlatform] = None
+
+
+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-clang32": JobSpec(name="Windows (msys2, clang32)",               os=JobOs.WindowsLatest, platform=SdlPlatform.Msys2,       artifact="SDL-mingw32-clang",      msys2_platform=Msys2Platform.Clang32, ),
+    "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-arm64": JobSpec(name="Windows (MSVC, ARM64)",                     os=JobOs.WindowsLatest, platform=SdlPlatform.Msvc,        artifact="SDL-VC-arm64",           msvc_arch=MsvcArch.Arm64, ),
+    "msvc-arm32": JobSpec(name="Windows (MSVC, ARM)",                       os=JobOs.WindowsLatest, platform=SdlPlatform.Msvc,        artifact="SDL-VC-arm32",           msvc_arch=MsvcArch.Arm32, ),
+    "msvc-static-x64": JobSpec(name="Windows (MSVC, static VCRT, x64)",     os=JobOs.WindowsLatest, platform=SdlPlatform.Msvc,        artifact="SDL-VC-x64",             msvc_arch=MsvcArch.X64,   msvc_static_crt=True, ),
+    "msvc-static-x86": JobSpec(name="Windows (MSVC, static VCRT, x86)",     os=JobOs.WindowsLatest, platform=SdlPlatform.Msvc,        artifact="SDL-VC-x86",             msvc_arch=MsvcArch.X86,   msvc_static_crt=True, ),
+    "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-uwp-x64": JobSpec(name="UWP (MSVC, x64)",                         os=JobOs.WindowsLatest, platform=SdlPlatform.Msvc,        artifact="SDL-VC-UWP",             msvc_arch=MsvcArch.X64,   msvc_project="VisualC-WinRT/SDL-UWP.sln", uwp=True, ),
+    "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-20.04": JobSpec(name="Ubuntu 20.04",                            os=JobOs.Ubuntu20_04,   platform=SdlPlatform.Linux,       artifact="SDL-ubuntu20.04",        autotools=True),
+    "ubuntu-22.04": JobSpec(name="Ubuntu 22.04",                            os=JobOs.Ubuntu22_04,   platform=SdlPlatform.Linux,       artifact="SDL-ubuntu22.04",        autotools=True),
+    "steamrt-sniper": JobSpec(name="Steam Linux Runtime (Sniper)",          os=JobOs.UbuntuLatest,  platform=SdlPlatform.Linux,       artifact="SDL-slrsniper",          container="registry.gitlab.steamos.cloud/steamrt/sniper/sdk:beta", ),
+    "ubuntu-intel-icx": JobSpec(name="Ubuntu 20.04 (Intel oneAPI)",         os=JobOs.Ubuntu20_04,   platform=SdlPlatform.Linux,       artifact="SDL-ubuntu20.04-oneapi", intel=IntelCompiler.Icx, ),
+    "ubuntu-intel-icc": JobSpec(name="Ubuntu 20.04 (Intel Compiler)",       os=JobOs.Ubuntu20_04,   platform=SdlPlatform.Linux,       artifact="SDL-ubuntu20.04-icc",    intel=IntelCompiler.Icc, ),
+    "macos-gnu-arm64-x64": JobSpec(name="MacOS (GNU prefix)",               os=JobOs.MacosLatest,   platform=SdlPlatform.MacOS,       artifact="SDL-macos-arm64-x64-gnu",autotools=True, apple_archs={AppleArch.X86_64, AppleArch.ARM64, },  ),
+    "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-mk": JobSpec(name="Android (Android.mk)",                      os=JobOs.UbuntuLatest,  platform=SdlPlatform.Android,     artifact=None,                     no_cmake=True, android_mk=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", ),
+    "n3ds": JobSpec(name="Nintendo 3DS",                                    os=JobOs.UbuntuLatest,  platform=SdlPlatform.N3ds,        artifact="SDL-n3ds",               container="devkitpro/devkitarm: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",  autotools=True, ),
+    "freebsd": JobSpec(name="FreeBSD",                                      os=JobOs.UbuntuLatest,  platform=SdlPlatform.FreeBSD,     artifact="SDL-freebsd-x64", autotools=True, ),
+    "watcom-win32": JobSpec(name="Watcom (Windows)",                        os=JobOs.WindowsLatest, platform=SdlPlatform.Watcom,      artifact="SDL-watcom-win32",  no_cmake=True, watcom_platform=WatcomPlatform.Windows ),
+    "watcom-os2": JobSpec(name="Watcom (OS/2)",                             os=JobOs.WindowsLatest, platform=SdlPlatform.Watcom,      artifact="SDL-watcom-win32",  no_cmake=True, watcom_platform=WatcomPlatform.OS2 ),
+    # "watcom-win32"
+    # "watcom-os2"
+}
+
+
+class StaticLibType(Enum):
+    MSVC = "SDL2-static.lib"
+    A = "libSDL2.a"
+
+
+class SharedLibType(Enum):
+    WIN32 = "SDL2.dll"
+    SO_0 = "libSDL2-2.0.so.0"
+    SO = "libSDL2.so"
+    DYLIB = "libSDL2-2.0.0.dylib"
+    FRAMEWORK = "SDL2.framework/Versions/A/SDL2"
+
+
+@dataclasses.dataclass(slots=True)
+class JobDetails:
+    name: str
+    key: str
+    os: str
+    platform: str
+    artifact: str
+    no_autotools: bool
+    no_cmake: bool
+    build_autotools_tests: bool = True
+    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_build_arguments: list[str] = dataclasses.field(default_factory=list)
+    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 = ""
+    android_apks: list[str] = dataclasses.field(default_factory=list)
+    android_ndk: bool = False
+    android_mk: bool = False
+    minidump: bool = False
+    intel: bool = False
+    msys2_msystem: str = ""
+    msys2_env: str = ""
+    msys2_no_perl: bool = False
+    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 = ""
+    xcode_target: str = ""
+    setup_gdk_folder: str = ""
+    cpactions: bool = False
+    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
+    watcom_makefile: str = ""
+
+    def to_workflow(self, enable_artifacts: bool) -> dict[str, str|bool]:
+        data = {
+            "name": self.name,
+            "key": self.key,
+            "os": self.os,
+            "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-env": self.msys2_env,
+            "msys2-no-perl": self.msys2_no_perl,
+            "android-ndk": self.android_ndk,
+            "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-autotools": self.no_autotools,
+            "no-cmake": self.no_cmake,
+            "build-autotools-tests": self.build_autotools_tests,
+            "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-toolchain-file": self.cmake_toolchain_file,
+            "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-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,
+            "xcode-target": self.xcode_target,
+            "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,
+            "watcom-makefile": self.watcom_makefile,
+        }
+        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")):
+            s = s.replace("\\", "\\\\").replace("\"", "\\\"")
+            return f'"{s}"'
+        return s
+
+    return " ".join(escape(e) for e in s)
+
+
+def spec_to_job(spec: JobSpec, key: str, trackmem_symbol_names: bool) -> 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_autotools=not spec.autotools,
+        no_cmake=spec.no_cmake,
+    )
+    if job.os.startswith("ubuntu"):
+        job.apt_packages.extend([
+            "ninja-build",
+            "pkg-config",
+        ])
+    if spec.msvc_static_crt:
+        job.cmake_arguments.append("-DSDL_FORCE_STATIC_VCRT=ON")
+    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"
+                job.cppflags.append("-diag-disable=10441")
+            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.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.MSVC
+            job.cmake_arguments.extend((
+                "-DCMAKE_MSVC_DEBUG_INFORMATION_FORMAT=ProgramDatabase",
+                "-DCMAKE_EXE_LINKER_FLAGS=-DEBUG",
+                "-DCMAKE_SHARED_LINKER_FLAGS=-DEBUG",
+            ))
+            if spec.uwp:
+                job.cmake_arguments.append("'-DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded$<$<CONFIG:Debug>:Debug>DLL'")
+            else:
+                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 _:
+                        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.Arm32:
+                    job.msvc_vcvars_arch = "x64_arm"
+                    job.msvc_vcvars_sdk = "10.0.22621.0"  # 10.0.26100.0 dropped ARM32 um and ucrt libraries
+                    job.run_tests = False
+                case MsvcArch.Arm64:
+                    job.msvc_vcvars_arch = "x64_arm64"
+                    job.run_tests = False
+            if spec.uwp:
+                job.build_tests = False
+                job.cmake_arguments.extend((
+                    "-DCMAKE_SYSTEM_NAME=WindowsStore",
+                    "-DCMAKE_SYSTEM_VERSION=10.0",
+                ))
+                job.msvc_project_flags.append("-p:WindowsTargetPlatformVersion=10.0.17763.0")
+            elif 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((
+                    "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",
+                    "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",
+                ))
+                ubuntu_year, ubuntu_month = [int(v) for v in spec.os.value.removeprefix("ubuntu-").split(".", 1)]
+                if 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
+                ))
+            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
+        case SdlPlatform.Ios | SdlPlatform.Tvos:
+            job.brew_packages.extend([
+                "ninja",
+            ])
+            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.xcode_target = "Static Library-iOS"
+                    job.cmake_arguments.extend([
+                        "-DCMAKE_SYSTEM_NAME=iOS",
+                        "-DCMAKE_OSX_ARCHITECTURES=\"arm64\"",
+                        "-DCMAKE_OSX_DEPLOYMENT_TARGET=9.0",
+                    ])
+                case SdlPlatform.Tvos:
+                    if spec.xcode:
+                        job.xcode_sdk = "appletvos"
+                        job.xcode_target = "Static Library-tvOS"
+                    job.cmake_arguments.extend([
+                        "-DCMAKE_SYSTEM_NAME=tvOS",
+                        "-DCMAKE_OSX_ARCHITECTURES=\"arm64\"",
+                        "-DCMAKE_OSX_DEPLOYMENT_TARGET=9.0",
+                    ])
+        case SdlPlatform.MacOS:
+            osx_arch = ";".join(e.value for e in spec.apple_archs) if spec.apple_archs else "arm64"
+            job.cmake_arguments.extend((
+                f"'-DCMAKE_OSX_ARCHITECTURES={osx_arch}'",
+                "-DCMAKE_OSX_DEPLOYMENT_TARGET=10.11",
+            ))
+            job.build_autotools_tests = False
+            job.shared_lib = SharedLibType.DYLIB
+            job.static_lib = StaticLibType.A
+            job.apt_packages = []
+            job.brew_packages.extend((
+                "autoconf",
+                "ninja",
+            ))
+            if spec.xcode:
+                job.xcode_sdk = "macosx"
+        case SdlPlatform.Android:
+            job.android_mk = spec.android_mk
+            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_mk:
+                job.apt_packages = []
+            if not spec.no_cmake:
+                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",
+                ]
+        case SdlPlatform.Emscripten:
+            job.run_tests = False
+            job.shared = False
+            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.static_lib = StaticLibType.A
+        case SdlPlatform.Ps2:
+            build_parallel = False
+            job.shared = False
+            job.sudo = ""
+            job.apt_packages = []
+            job.apk_packages = ["cmake", "gmp", "mpc1", "mpfr4", "ninja", "pkgconf", "git", ]
+            job.cmake_toolchain_file = "${PS2DEV}/ps2sdk/ps2dev.cmake"
+            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:
+            build_parallel = False
+            job.sudo = ""
+            job.apt_packages = []
+            job.apk_packages = ["cmake", "gmp", "mpc1", "mpfr4", "ninja", "pkgconf", ]
+            job.cmake_toolchain_file = "${PSPDEV}/psp/share/pspdev.cmake"
+            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.sudo = ""
+            job.apt_packages = []
+            job.apk_packages = ["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.run_tests = False
+            job.shared = False
+            job.cc = "arm-vita-eabi-gcc"
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.Haiku:
+            fpic = False
+            job.build_autotools_tests = False
+            job.run_tests = False
+            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}",
+                "-DSDL_UNIX_CONSOLE_BUILD=ON",
+            ))
+            job.shared_lib = SharedLibType.SO_0
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.N3ds:
+            job.shared = False
+            job.apt_packages = ["ninja-build", "binutils"]
+            job.run_tests = False
+            job.cc_from_cmake = True
+            job.cmake_toolchain_file = "${DEVKITPRO}/cmake/3DS.cmake"
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.Msys2:
+            job.shell = "msys2 {0}"
+            assert spec.msys2_platform
+            job.msys2_msystem = spec.msys2_platform.value
+            job.msys2_env = {
+                "mingw32": "mingw-w64-i686",
+                "mingw64": "mingw-w64-x86_64",
+                "clang32": "mingw-w64-clang-i686",
+                "clang64": "mingw-w64-clang-x86_64",
+                "ucrt64": "mingw-w64-ucrt-x86_64",
+            }[spec.msys2_platform.value]
+            job.msys2_no_perl = spec.msys2_platform in (Msys2Platform.Mingw32, Msys2Platform.Clang32)
+            job.shared_lib = SharedLibType.WIN32
+            job.static_lib = StaticLibType.A
+        case SdlPlatform.Riscos:
+            # FIXME: Enable SDL_WERROR
+            job.werror = False
+            job.build_autotools_tests = False
+            job.apt_packages = ["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:
+            job.build_autotools_tests = False
+            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 = "13.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.0"
+                    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.Watcom:
+            match spec.watcom_platform:
+                case WatcomPlatform.OS2:
+                    job.watcom_makefile = "Makefile.os2"
+                    job.run_tests = False
+                case WatcomPlatform.Windows:
+                    job.watcom_makefile = "Makefile.w32"
+                    job.run_tests = True
+                case _:
+                    raise ValueError(f"Unsupported watcom_platform=${spec.watcom_platform}")
+        case _:
+            raise ValueError(f"Unsupported platform={spec.platform}")
+
+    if "ubuntu" in spec.name.lower():
+        job.check_sources = True
+
+    if not build_parallel:
+        job.cmake_build_arguments.append("-j1")
+    if job.cflags:
+        job.cmake_arguments.append(f"-DCMAKE_C_FLAGS={my_shlex_join(job.cflags)}")
+    if job.cxxflags:
+        job.cmake_arguments.append(f"-DCMAKE_CXX_FLAGS={my_shlex_join(job.cxxflags)}")
+    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) -> dict[str, str|bool]:
+    logger.info("spec=%r", spec)
+    job = spec_to_job(spec, key=key, trackmem_symbol_names=trackmem_symbol_names)
+    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 = []
+    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
+
+    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) 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())

.github/workflows/emscripten.yml

@@ -1,45 +0,0 @@
-name: Build (Emscripten)
-
-on: [push, pull_request]
-
-jobs:
-  emscripten:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: mymindstorm/setup-emsdk@v14
-        with:
-          version: 3.1.35
-      - name: Install ninja
-        run: |
-          sudo apt-get -y update
-          sudo apt-get install -y ninja-build
-      - name: Configure CMake
-        run: |
-          emcmake cmake -S . -B build \
-            -DSDL_WERROR=ON \
-            -DSDL_TESTS=ON \
-            -DSDL_INSTALL_TESTS=ON \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_INSTALL_PREFIX=prefix \
-            -GNinja
-      - name: Build
-        run: cmake --build build/ --verbose
-      - name: Run build-time tests
-        run: |
-          set -eu
-          export SDL_TESTS_QUICK=1
-          # FIXME: enable Emscripten build time tests
-          # ctest -VV --test-dir build/
-      - name: Install
-        run: |
-          echo "SDL2_DIR=$(pwd)/prefix" >> $GITHUB_ENV
-          cmake --install build/
-      - name: Verify CMake configuration files
-        run: |
-          emcmake cmake -S cmake/test -B cmake_config_build \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DSDL_VENDOR_INFO="Github Workflow" \
-            -DTEST_SHARED=FALSE \
-            -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }}
-          cmake --build cmake_config_build --verbose

.github/workflows/generic.yml

@@ -0,0 +1,352 @@
+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-env }}-cc
+            ${{ matrix.platform.msys2-env }}-cmake
+            ${{ matrix.platform.msys2-env }}-ninja
+            ${{ (!matrix.platform.msys2-no-perl && format('{0}-perl', matrix.platform.msys2-env)) || '' }}
+            ${{ matrix.platform.msys2-env }}-pkg-config
+            ${{ matrix.platform.msys2-env }}-clang-tools-extra
+      - 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@v4
+      - name: 'Set up ninja'
+        if: ${{ matrix.platform.setup-ninja }}
+        uses: ./.github/actions/setup-ninja
+      - uses: mymindstorm/setup-emsdk@v14
+        if: ${{ matrix.platform.platform == 'emscripten' }}
+        with:
+          version: 3.1.35
+      - uses: nttld/setup-ndk@v1
+        if: ${{ matrix.platform.android-ndk }}
+        id: setup-ndk
+        with:
+          local-cache: true
+          ndk-version: r21e
+      - uses: ilammy/msvc-dev-cmd@v1
+        if: ${{ matrix.platform.platform == 'msvc' }}
+        with:
+          arch: ${{ matrix.platform.msvc-vcvars-arch }}
+          sdk: ${{ matrix.platform.msvc-vcvars-sdk }}
+      - 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: '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: '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: 'Configure (Autotools)'
+        if: ${{ !matrix.platform.no-autotools }}
+        run: |
+          ${{ matrix.platform.source_cmd }}
+          set -eu
+          rm -rf build-autotools
+          mkdir build-autotools
+          ./autogen.sh
+          (
+            cd build-autotools
+            ../configure \
+              --enable-vendor-info="Github Workflow" \
+              --enable-werror \
+              --prefix=${{ github.workspace }}/autotools_prefix \
+          )
+          if test "x${{ (matrix.platform.build-autotools-tests && 'yes') || 'no' }}" = "xyes" ; then
+            curdir="$(pwd)"
+            multiarch="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
+            (
+              mkdir -p build-autotools/test
+              cd build-autotools/test
+              ../../test/configure \
+                --enable-werror \
+                --x-includes=/usr/include \
+                --x-libraries="/usr/lib/${multiarch}" \
+                --prefix=${{ github.workspace }}/autotools_prefix \
+                SDL_CFLAGS="-I${curdir}/include" \
+                SDL_LIBS="-L${curdir}/build-autotools/build/.libs -lSDL2" \
+                ac_cv_lib_SDL2_ttf_TTF_Init=no \
+                ${NULL+}
+          )
+          fi
+      - name: 'Build (Autotools)'
+        if: ${{ !matrix.platform.no-autotools }}
+        run: |
+          ${{ matrix.platform.source_cmd }}
+          set -eu
+          parallel="$(getconf _NPROCESSORS_ONLN)"
+          make -j"${parallel}" -C build-autotools V=1
+          if test "x${{ (matrix.platform.build-autotools-tests && 'yes') || 'no' }}" = "xyes" ; then
+            make -j"${parallel}" -C build-autotools/test V=1
+          fi
+      - name: 'Run build-time tests (Autotools)'
+        if: ${{ !matrix.platform.no-autotools && matrix.platform.build-autotools-tests && matrix.platform.run-tests }}
+        run: |
+          ${{ matrix.platform.source_cmd }}
+          set -eu
+          curdir="$(pwd)"
+          parallel="$(getconf _NPROCESSORS_ONLN)"
+          export SDL_TESTS_QUICK=1
+          make -j"${parallel}" -C build-autotools/test check LD_LIBRARY_PATH="${curdir}/build-autotools/build/.libs"
+          if test "${{ runner.os }}" = "Linux"; then
+            # This should show us the SDL_REVISION
+            strings "${curdir}/build-autotools/build/.libs/libSDL2-2.0.so.0" | grep SDL-
+          fi
+      - name: 'Install (Autotools)'
+        if: ${{ !matrix.platform.no-autotools }}
+        run: |
+          ${{ matrix.platform.source_cmd }}
+          set -eu
+          curdir="$(pwd)"
+          parallel="$(getconf _NPROCESSORS_ONLN)"
+          make -j"${parallel}" -C build-autotools install V=1
+          if test "x${{ (matrix.platform.build-autotools-tests && 'yes') || 'no' }}" = "xyes" ; then
+            make -j"${parallel}" -C build-autotools/test install V=1
+          fi
+          ( cd autotools_prefix; find . ) | LC_ALL=C sort -u
+          echo "prefix=$(pwd)/autotools_prefix" >> $GITHUB_OUTPUT
+
+      - 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 -GNinja \
+            -Wdeprecated -Wdev -Werror \
+            ${{ matrix.platform.cmake-toolchain-file != '' && format('-DCMAKE_TOOLCHAIN_FILE={0}', matrix.platform.cmake-toolchain-file) || '' }} \
+            -DSDL_WERROR=${{ matrix.platform.werror }} \
+            -DSDL_TESTS=${{ matrix.platform.build-tests }} \
+            -DSDLTEST_TRACKMEM=OFF \
+            -DSDL_INSTALL_TESTS=${{ matrix.platform.build-tests }} \
+            -DSDL_DISABLE_INSTALL_DOCS=OFF \
+            -DSDL_DISABLE_INSTALL_DOCS=OFF \
+            ${{ matrix.platform.cmake-arguments }} \
+            -DSDL_SHARED=${{ matrix.platform.shared }} \
+            -DSDL_STATIC=${{ matrix.platform.static  }} \
+            -DSDL_TEST=ON \
+            -DSDL_VENDOR_INFO="Github Workflow" \
+            -DCMAKE_INSTALL_PREFIX=prefix \
+            -DCMAKE_INSTALL_LIBDIR=lib \
+            -DSDL_CMAKE_DEBUG_POSTFIX="" \
+            -DCMAKE_BUILD_TYPE=${{ matrix.platform.cmake-build-type }}
+      - name: 'Build (CMake)'
+        id: cmake-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('strings build/{0} | grep "Github Workflow"', matrix.platform.shared-lib)) || 'echo "<Shared library not supported by platform>"' }}
+          echo "Static library:"
+          ${{ (matrix.platform.static-lib && format('strings build/{0} | grep "Github Workflow"', matrix.platform.static-lib)) || 'echo "<Static library not supported by platform>"' }}
+      - name: 'Run build-time tests (CMake)'
+        id: cmake-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 -VV --test-dir build/ -j2
+      - name: 'Install (CMake)'
+        id: cmake-install
+        if: ${{ 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: 'Verify CMake configuration files (CMake)'
+        if: ${{ steps.cmake-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.cmake-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.cmake-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 sdl2.pc (CMake)'
+#        shell: ${{ matrix.platform.shell }}
+        if: ${{ steps.cmake-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.cmake-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@v0.25.0
+        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_DISABLE_INSTALL_DOCS=OFF \
+              ${{ matrix.platform.cmake-arguments }} \
+              -DSDL_SHARED=${{ matrix.platform.shared }} \
+              -DSDL_STATIC=${{ matrix.platform.static  }} \
+              -DSDL_TEST=ON \
+              -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 clean
+            rm -rf build/CMakeFiles
+            rm -rf build/docs
+      - name: 'Set up Watcom'
+        uses: open-watcom/setup-watcom@v0
+        if: ${{ matrix.platform.watcom-makefile != '' }}
+      - name: 'Build (Watcom)'
+        if: ${{ matrix.platform.watcom-makefile != '' }}
+        run: |
+          wmake -f ${{ matrix.platform.watcom-makefile }} ENABLE_WERROR=1
+      - name: 'Build tests (Watcom)'
+        if: ${{ matrix.platform.watcom-makefile != '' }}
+        run: |
+          cd test
+          wmake -f ${{ matrix.platform.watcom-makefile }} ENABLE_WERROR=1
+      - name: 'Run tests (Watcom)'
+        if: ${{ matrix.platform.watcom-makefile != '' && matrix.platform.run-tests }}
+        run: |
+          cd test
+          wmake -f ${{ matrix.platform.watcom-makefile }} check-quick
+      - name: 'Distclean (Watcom)'
+        if: ${{ matrix.platform.watcom-makefile != '' }}
+        run: |
+          wmake -f ${{ matrix.platform.watcom-makefile }} distclean
+          cd test
+          wmake -f ${{ matrix.platform.watcom-makefile }} distclean
+      - name: 'Add msbuild to PATH'
+        id: setup-msbuild
+        if: ${{ matrix.platform.msvc-project != '' }}
+        uses: microsoft/setup-msbuild@v2
+      - 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: 'Build (xcode)'
+        if: ${{ matrix.platform.xcode-sdk != '' }}
+        run: |
+          xcodebuild -project Xcode/SDL/SDL.xcodeproj -target "${{ matrix.platform.xcode-target }}" -configuration Release -sdk ${{ matrix.platform.xcode-sdk }} clean build
+      - name: 'Setup Python'
+        uses: 'actions/setup-python@main'
+        if: ${{ matrix.platform.check-sources }}
+        with:
+          python-version: '3.x'
+      - name: 'Check Sources'
+        if: ${{ matrix.platform.check-sources }}
+        run: |
+          set -e
+          build-scripts/test-versioning.sh
+      - name: 'Upload binary package'
+        uses: actions/upload-artifact@v4
+        if: ${{ always() && steps.cmake-tests.outcome == 'failure' }}
+        with:
+          if-no-files-found: ignore
+          name: '${{ matrix.platform.artifact }}-minidumps'
+          path: |
+            build/**/*.dmp
+            build/**/*.exe
+            build/**/*.dll
+            build/**/*.pdb

.github/workflows/ios.yml

@@ -1,20 +0,0 @@
-name: Build (iOS/tvOS)
-
-on: [push, pull_request]
-
-jobs:
-  Build:
-    name: ${{ matrix.platform.name }}
-    runs-on: macos-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-        - { name: iOS, target: Static Library-iOS, sdk: iphoneos }
-        - { name: tvOS, target: Static Library-tvOS, sdk: appletvos }
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build
-        run: xcodebuild -project Xcode/SDL/SDL.xcodeproj -target '${{ matrix.platform.target }}' -configuration Release -sdk ${{ matrix.platform.sdk }} clean build

.github/workflows/main.yml

@@ -1,240 +0,0 @@
-name: Build
-
-on: [push, pull_request]
-
-jobs:
-  Build:
-    name: ${{ matrix.platform.name }}
-    runs-on: ${{ matrix.platform.os }}
-
-    defaults:
-      run:
-        shell: ${{ matrix.platform.shell }}
-
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-        - { name: Windows (mingw32),              os: windows-latest, shell: 'msys2 {0}', msystem: mingw32, msys-env: mingw-w64-i686 }
-        - { name: Windows (mingw64),              os: windows-latest, shell: 'msys2 {0}', msystem: mingw64, msys-env: mingw-w64-x86_64 }
-        - { name: Windows (clang32),              os: windows-latest, shell: 'msys2 {0}', msystem: clang32, msys-env: mingw-w64-clang-i686 }
-        - { name: Windows (clang64),              os: windows-latest, shell: 'msys2 {0}', msystem: clang64, msys-env: mingw-w64-clang-x86_64 }
-        - { name: Windows (ucrt64),               os: windows-latest, shell: 'msys2 {0}', msystem: ucrt64,  msys-env: mingw-w64-ucrt-x86_64 }
-        - { name: Ubuntu 20.04 (CMake),           os: ubuntu-20.04,   shell: sh }
-        - { name: Ubuntu 20.04 (autotools),       os: ubuntu-20.04,   shell: sh,    autotools: true }
-        - { name: Intel oneAPI (Ubuntu 20.04),    os: ubuntu-20.04,   shell: bash, artifact: 'SDL-ubuntu20.04-oneapi', intel: true,
-            source_cmd: 'source /opt/intel/oneapi/setvars.sh; export CC=icx; export CXX=icx;'}
-        - { name: Intel Compiler (Ubuntu 20.04),  os: ubuntu-20.04,   shell: bash, artifact: 'SDL-ubuntu20.04-icc', intel: true, cmake: '-DSDL_CLANG_TIDY=OFF',
-             source_cmd: 'source /opt/intel/oneapi/setvars.sh; export CC=icc; export CXX=icpc; export CFLAGS=-diag-disable=10441; export CXXFLAGS=-diag-disable=10441; '}
-
-        - { name: Ubuntu 22.04 (CMake),           os: ubuntu-22.04,   shell: sh }
-        - { name: Ubuntu 22.04 (autotools),       os: ubuntu-22.04,   shell: sh,    autotools: true }
-        - { name: MacOS (CMake),                  os: macos-latest,   shell: sh,    cmake: '-DCMAKE_OSX_ARCHITECTURES="x86_64;arm64"' }
-        - { name: MacOS (autotools),              os: macos-latest,   shell: sh,    autotools: true }
-
-    steps:
-    - name: Set up MSYS2
-      if: matrix.platform.shell == 'msys2 {0}'
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: ${{ matrix.platform.msystem }}
-        install: >-
-          ${{ matrix.platform.msys-env }}-cc
-          ${{ matrix.platform.msys-env }}-cmake
-          ${{ matrix.platform.msys-env }}-ninja
-          ${{ matrix.platform.msys-env }}-pkg-config
-
-    - name: Setup Linux dependencies
-      if: runner.os == 'Linux'
-      run: |
-        sudo apt-get update
-        sudo apt-get install build-essential git make autoconf automake libtool \
-            pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
-            libaudio-dev libjack-dev libsndio-dev libsamplerate0-dev libx11-dev libxext-dev \
-            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-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: Setup extra Ubuntu 22.04 dependencies
-      if: matrix.platform.os == 'ubuntu-22.04'
-      run: |
-        sudo apt-get install libpipewire-0.3-dev libdecor-0-dev
-
-    - name: Setup Macos dependencies
-      if: runner.os == 'macOS'
-      run: |
-        brew install \
-          ninja \
-          pkg-config
-
-    - name: Setup Intel oneAPI
-      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
-
-    - uses: actions/checkout@v4
-    - name: Check that versioning is consistent
-      # We only need to run this once: arbitrarily use the Linux/CMake build
-      if: "runner.os == 'Linux' && ! matrix.platform.autotools"
-      run: ./build-scripts/test-versioning.sh
-    - name: Configure (CMake)
-      if: "! matrix.platform.autotools"
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        cmake -S . -B build -G Ninja \
-        -DSDL_TESTS=ON \
-        -DSDL_WERROR=ON \
-        -DSDL_INSTALL_TESTS=ON \
-        -DSDL_VENDOR_INFO="Github Workflow" \
-        -DCMAKE_INSTALL_PREFIX=cmake_prefix \
-        -DCMAKE_BUILD_TYPE=Release \
-        ${{ matrix.platform.cmake }}
-    - name: Build (CMake)
-      if: "! matrix.platform.autotools"
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        cmake --build build/ --config Release --verbose --parallel
-    - name: Run build-time tests (CMake)
-      if: "! matrix.platform.autotools"
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        set -eu
-        export SDL_TESTS_QUICK=1
-        ctest -VV --test-dir build/ -j2
-        if test "${{ runner.os }}" = "Linux"; then
-          # This should show us the SDL_REVISION
-          strings build/libSDL2-2.0.so.0 | grep SDL-
-        fi
-    - name: Install (CMake)
-      if: "! matrix.platform.autotools"
-      run: |
-        set -eu
-        cmake --install build/ --config Release
-        echo "SDL2_DIR=$(pwd)/cmake_prefix" >> $GITHUB_ENV
-        ( cd cmake_prefix; find ) | LC_ALL=C sort -u
-    - name: Configure (Autotools)
-      if: matrix.platform.autotools
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        set -eu
-        rm -fr build-autotools
-        mkdir build-autotools
-        ./autogen.sh
-        (
-          cd build-autotools
-          ${{ github.workspace }}/configure \
-            --enable-vendor-info="Github Workflow" \
-            --enable-werror \
-            --prefix=${{ github.workspace }}/autotools_prefix \
-        )
-        if test "${{ runner.os }}" != "macOS" ; then
-          curdir="$(pwd)"
-          multiarch="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
-          (
-            mkdir -p build-autotools/test
-            cd build-autotools/test
-            ${{ github.workspace }}/test/configure \
-              --enable-werror \
-              --x-includes=/usr/include \
-              --x-libraries="/usr/lib/${multiarch}" \
-              --prefix=${{ github.workspace }}/autotools_prefix \
-              SDL_CFLAGS="-I${curdir}/include" \
-              SDL_LIBS="-L${curdir}/build-autotools/build/.libs -lSDL2" \
-              ac_cv_lib_SDL2_ttf_TTF_Init=no \
-              ${NULL+}
-          )
-        fi
-    - name: Build (Autotools)
-      if: matrix.platform.autotools
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        set -eu
-        parallel="$(getconf _NPROCESSORS_ONLN)"
-        make -j"${parallel}" -C build-autotools V=1
-        if test "${{ runner.os }}" != "macOS" ; then
-          make -j"${parallel}" -C build-autotools/test V=1
-        fi
-    - name: Run build-time tests (Autotools)
-      if: ${{ matrix.platform.autotools && (runner.os != 'macOS') }}
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        set -eu
-        curdir="$(pwd)"
-        parallel="$(getconf _NPROCESSORS_ONLN)"
-        export SDL_TESTS_QUICK=1
-        make -j"${parallel}" -C build-autotools/test check LD_LIBRARY_PATH="${curdir}/build-autotools/build/.libs"
-        if test "${{ runner.os }}" = "Linux"; then
-          # This should show us the SDL_REVISION
-          strings "${curdir}/build-autotools/build/.libs/libSDL2-2.0.so.0" | grep SDL-
-        fi
-    - name: Install (Autotools)
-      if: matrix.platform.autotools
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        set -eu
-        curdir="$(pwd)"
-        parallel="$(getconf _NPROCESSORS_ONLN)"
-        make -j"${parallel}" -C build-autotools install V=1
-        if test "${{ runner.os }}" != "macOS" ; then
-          make -j"${parallel}" -C build-autotools/test install V=1
-        fi
-        ( cd autotools_prefix; find . ) | LC_ALL=C sort -u
-        echo "SDL2_DIR=$(pwd)/autotools_prefix" >> $GITHUB_ENV
-    - name: Verify CMake configuration files
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        cmake -S cmake/test -B cmake_config_build -G Ninja \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }}
-        cmake --build cmake_config_build --verbose
-    - name: Verify sdl2-config
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        export PATH=${{ env.SDL2_DIR }}/bin:$PATH
-        cmake/test/test_sdlconfig.sh
-    - name: Verify sdl2.pc
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        export PKG_CONFIG_PATH=${{ env.SDL2_DIR }}/lib/pkgconfig
-        cmake/test/test_pkgconfig.sh
-    - name: Distcheck (Autotools)
-      if: matrix.platform.autotools
-      run: |
-        set -eu
-        parallel="$(getconf _NPROCESSORS_ONLN)"
-        make -j"${parallel}" -C build-autotools dist V=1
-        # Similar to Automake `make distcheck`: check that the tarball
-        # release is sufficient to do a new build
-        mkdir distcheck
-        tar -C distcheck -zxf build-autotools/SDL2-*.tar.gz
-        ( cd distcheck/SDL2-* && ./configure )
-        make -j"${parallel}" -C distcheck/SDL2-*
-    - name: Run installed-tests (Autotools)
-      if: "runner.os == 'Linux' && matrix.platform.autotools"
-      run: |
-        ${{ matrix.platform.source_cmd }}
-        set -eu
-        parallel="$(getconf _NPROCESSORS_ONLN)"
-        sudo make -j"${parallel}" -C build-autotools install
-        sudo make -j"${parallel}" -C build-autotools/test install
-        export SDL_TESTS_QUICK=1
-        # We need to set LD_LIBRARY_PATH because it isn't in the default
-        # linker search path. We don't need to set XDG_DATA_DIRS for
-        # ginsttest-runner, because /usr/local/share *is* in the default
-        # search path for that.
-        env --chdir=/ \
-            LD_LIBRARY_PATH=/usr/local/lib \
-            SDL_AUDIODRIVER=dummy \
-            SDL_VIDEODRIVER=dummy \
-            ginsttest-runner --tap SDL2

.github/workflows/msvc.yml

@@ -1,80 +0,0 @@
-name: Build (MSVC)
-
-on: [push, pull_request]
-
-jobs:
-  Build:
-    name: ${{ matrix.platform.name }}
-    runs-on: windows-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-        - { name: Windows (x64),          flags: -A x64,   project: VisualC/SDL.sln, projectflags: '/p:Platform=x64' }
-        - { name: Windows (x86),          flags: -A Win32, project: VisualC/SDL.sln, projectflags: '/p:Platform=Win32' }
-        - { name: Windows static VCRT (x64), flags: -A x64 -DSDL_FORCE_STATIC_VCRT=ON }
-        - { name: Windows static VCRT (x86), flags: -A Win32 -DSDL_FORCE_STATIC_VCRT=ON }
-        - { name: Windows (clang-cl x64), flags: -T ClangCL -A x64 }
-        - { name: Windows (clang-cl x86), flags: -T ClangCL -A Win32 }
-        - { name: Windows (ARM),          flags: -A ARM }
-        - { name: Windows (ARM64),        flags: -A ARM64 }
-        - { name: UWP (x64),              flags: -A x64 -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0" -DSDL_TESTS=OFF, nowerror: true,
-            project: VisualC-WinRT/SDL-UWP.sln, projectflags: '/p:Platform=x64 /p:WindowsTargetPlatformVersion=10.0.17763.0' }
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Create CMake project using SDL as a subproject
-      shell: python
-      run: |
-        import os
-        import textwrap
-        srcdir = r"${{ github.workspace }}".replace("\\", "/")
-        builddir = f"{ srcdir }/build"
-        os.makedirs(builddir)
-        with open(f"{ builddir }/CMakeLists.txt", "w") as f:
-          f.write(textwrap.dedent(f"""\
-            # Always build .PDB symbol file
-            set(CMAKE_POLICY_DEFAULT_CMP0141 "NEW" CACHE STRING "MSVC debug information format flags are selected by an abstraction")
-            set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "ProgramDatabase" CACHE STRING "MSVC debug information format")
-            set(CMAKE_EXE_LINKER_FLAGS "-DEBUG" CACHE STRING "Linker flags for executables")
-            set(CMAKE_SHARED_LINKER_FLAGS "-DEBUG" CACHE STRING "Linker flag for shared libraries")
-            cmake_minimum_required(VERSION 3.0...3.25)
-            project(sdl_user)
-            enable_testing()
-            add_subdirectory("{ srcdir }" SDL)
-          """))
-    - name: Configure (CMake)
-      run: cmake -S build -B build `
-        -DSDL_WERROR=${{ !matrix.platform.nowerror }} `
-        -DSDL_TESTS=ON `
-        -DSDL_INSTALL_TESTS=ON `
-        -DSDL_VENDOR_INFO="Github Workflow" `
-        -DSDL2_DISABLE_INSTALL=OFF `
-        ${{ matrix.platform.flags }} `
-        -DCMAKE_INSTALL_PREFIX=prefix
-    - name: Build (CMake)
-      run: cmake --build build/ --config Release --parallel
-    - name: Run build-time tests
-      if: "! contains(matrix.platform.name, 'ARM')"
-      run: |
-        $env:SDL_TESTS_QUICK=1
-        ctest -VV --test-dir build/ -C Release -j2
-    - name: Install (CMake)
-      run: |
-        echo "SDL2_DIR=$Env:GITHUB_WORKSPACE/prefix" >> $Env:GITHUB_ENV
-        cmake --install build/
-    - name: Verify CMake configuration files
-      if: ${{ !contains(matrix.platform.name, 'UWP') }}  # FIXME: cmake/test/CMakeLists.txt should support UWP
-      run: |
-        cmake -S cmake/test -B cmake_config_build `
-          -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }} `
-          ${{ matrix.platform.flags }}
-        cmake --build cmake_config_build --config Release
-
-    - name: Add msbuild to PATH
-      if: ${{ matrix.platform.project != '' }}
-      uses: microsoft/setup-msbuild@v2
-    - name: Build msbuild
-      if: ${{ matrix.platform.project != '' }}
-      run: msbuild ${{ matrix.platform.project }} /m /p:BuildInParallel=true /p:Configuration=Release ${{ matrix.platform.projectflags }}

.github/workflows/n3ds.yml

@@ -1,55 +0,0 @@
-name: Build (Nintendo 3DS)
-
-on: [push, pull_request]
-
-jobs:
-  n3ds:
-    runs-on: ubuntu-latest
-    container:
-      image: devkitpro/devkitarm:latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install build requirements
-        run: |
-          apt update
-          apt install ninja-build
-      - name: Configure CMake
-        run: |
-          cmake -S . -B build -G Ninja \
-            -DCMAKE_TOOLCHAIN_FILE=${DEVKITPRO}/cmake/3DS.cmake \
-            -DSDL_WERROR=ON \
-            -DSDL_TESTS=ON \
-            -DSDL_INSTALL_TESTS=ON \
-            -DSDL_VENDOR_INFO="Github Workflow" \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_INSTALL_PREFIX=prefix
-      - name: Build
-        run: cmake --build build --verbose
-      - name: Install CMake
-        run: |
-          echo "SDL2_DIR=$(pwd)/prefix" >> $GITHUB_ENV
-          cmake --install build/
-          ( cd prefix; find ) | LC_ALL=C sort -u
-      - name: Verify CMake configuration files
-        run: |
-          cmake -S cmake/test -B cmake_config_build -G Ninja \
-            -DCMAKE_TOOLCHAIN_FILE=${DEVKITPRO}/cmake/3DS.cmake \
-            -DTEST_SHARED=FALSE \
-            -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }} \
-            -DCMAKE_BUILD_TYPE=Release
-          cmake --build cmake_config_build --verbose
-      - name: Extract CC/CXX/CFLAGS/CXXFLAGS from CMake toolchain
-        run: |
-          cmake -S .github/cmake -B /tmp/cmake_extract \
-            -DCMAKE_TOOLCHAIN_FILE=${DEVKITPRO}/cmake/3DS.cmake \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DVAR_PATH=/tmp/n3ds_env.txt
-          cat /tmp/n3ds_env.txt >> $GITHUB_ENV
-      - name: Verify sdl2-config
-        run: |
-          export PATH=${{ env.SDL2_DIR }}/bin:$PATH
-          cmake/test/test_sdlconfig.sh
-      - name: Verify sdl2.pc
-        run: |
-          export PKG_CONFIG_PATH=${{ env.SDL2_DIR }}/lib/pkgconfig
-          cmake/test/test_pkgconfig.sh

.github/workflows/ps2.yaml

@@ -1,73 +0,0 @@
-name: Build (Sony Playstation 2)
-
-on: [push, pull_request]
-
-jobs:
-  ps2:
-    runs-on: ubuntu-latest
-    container: ps2dev/ps2dev:latest
-    steps:
-    - uses: actions/checkout@v4
-    - name: Setup dependencies
-      run: |
-        apk update 
-        apk add cmake gmp mpc1 mpfr4 ninja pkgconf make git
-
-    # To be removed once ps2_drivers is part of PS2DEV
-    - name: Install ps2_drivers lib
-      run: |
-        git clone https://github.com/fjtrujy/ps2_drivers.git
-        cd ps2_drivers
-        make -j $(getconf _NPROCESSORS_ONLN) clean
-        make -j $(getconf _NPROCESSORS_ONLN)
-        make -j $(getconf _NPROCESSORS_ONLN) install
-
-    - name: Configure (CMake)
-      run: |
-        cmake -S . -B build -G Ninja \
-          -DCMAKE_TOOLCHAIN_FILE=$PS2DEV/ps2sdk/ps2dev.cmake \
-          -DSDL_WERROR=ON \
-          -DSDL_TESTS=ON \
-          -DCMAKE_INSTALL_PREFIX=cmake_prefix \
-          -DCMAKE_BUILD_TYPE=Release
-    - name: Build
-      run: cmake --build build --config Release --verbose --parallel
-    - name: Install (CMake)
-      run: |
-        set -eu
-        cmake --install build/ --config Release
-        echo "SDL2_DIR=$(pwd)/cmake_prefix" >> $GITHUB_ENV
-        ( cd cmake_prefix; find ) | LC_ALL=C sort -u
-
-    - name: Verify CMake configuration files
-      run: |
-        cmake -S cmake/test -B cmake_config_build -G Ninja \
-          -DCMAKE_TOOLCHAIN_FILE=$PS2DEV/ps2sdk/ps2dev.cmake \
-          -DTEST_SHARED=FALSE \
-          -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }} \
-          -DCMAKE_BUILD_TYPE=Release
-        cmake --build cmake_config_build --verbose
-    - name: Verify sdl2-config
-      run: |
-        export CC=mips64r5900el-ps2-elf-gcc
-        export LDFLAGS="-L$PS2DEV/ps2sdk/ee/lib -L$PS2DEV/gsKit/lib -L$PS2DEV/ps2sdk/ports/lib"
-        export PATH=${{ env.SDL2_DIR }}/bin:$PATH
-        cmake/test/test_sdlconfig.sh
-    - name: Verify sdl2.pc
-      run: |
-        export CC=mips64r5900el-ps2-elf-gcc
-        export LDFLAGS="-L$PS2DEV/ps2sdk/ee/lib -L$PS2DEV/gsKit/lib -L$PS2DEV/ps2sdk/ports/lib"
-        export PKG_CONFIG_PATH=${{ env.SDL2_DIR }}/lib/pkgconfig
-        cmake/test/test_pkgconfig.sh
-    
-    - name: Get short SHA
-      id: slug
-      run: echo "::set-output name=sha8::$(echo ${GITHUB_SHA} | cut -c1-8)"
-
-    - name: Upload artifacts
-      if: ${{ success() }}
-      uses: actions/upload-artifact@v3
-      with:
-        name: tests-${{ steps.slug.outputs.sha8 }}
-        path: |
-          build/test

.github/workflows/psp.yaml

@@ -1,50 +0,0 @@
-name: Build (Sony Playstation Portable)
-
-on: [push, pull_request]
-
-jobs:
-  psp:
-    runs-on: ubuntu-latest
-    container: pspdev/pspdev:latest
-    steps:
-    - uses: actions/checkout@v4
-    - name: Setup dependencies
-      run: |
-        apk update 
-        apk add cmake gmp mpc1 mpfr4 make pkgconf
-    - name: Configure CMake
-      run: |
-        cmake -S . -B build \
-          -DCMAKE_TOOLCHAIN_FILE=$PSPDEV/psp/share/pspdev.cmake \
-          -DSDL_WERROR=ON \
-          -DSDL_TESTS=ON \
-          -DSDL_INSTALL_TESTS=ON \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_INSTALL_PREFIX=prefix
-    - name: Build
-      run: cmake --build build --config Release
-    - name: Install
-      run: |
-        echo "SDL2_DIR=$(pwd)/prefix" >> $GITHUB_ENV
-        cmake --install build --config Release
-        ( cd prefix; find ) | LC_ALL=C sort -u
-    - name: Verify CMake configuration files
-      run: |
-        cmake -S cmake/test -B cmake_config_build \
-          -DCMAKE_TOOLCHAIN_FILE=$PSPDEV/psp/share/pspdev.cmake \
-          -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }} \
-          -DTEST_SHARED=FALSE \
-          -DCMAKE_BUILD_TYPE=Release
-        cmake --build cmake_config_build --verbose
-    - name: Verify sdl2-config
-      run: |
-        export CC=psp-gcc
-        export LDFLAGS="-L$PSPDEV/lib -L$PSPDEV/psp/lib -L$PSPDEV/psp/sdk/lib"
-        export PATH=${{ env.SDL2_DIR }}/bin:$PATH
-        cmake/test/test_sdlconfig.sh
-    - name: Verify sdl2.pc
-      run: |
-        export CC=psp-gcc
-        export LDFLAGS="-L$PSPDEV/lib -L$PSPDEV/psp/lib -L$PSPDEV/psp/sdk/lib"
-        export PKG_CONFIG_PATH=${{ env.SDL2_DIR }}/lib/pkgconfig
-        cmake/test/test_pkgconfig.sh

.github/workflows/release.yml

@@ -0,0 +1,403 @@
+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@v5
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: 'build-scripts/build-release.py'
+      - name: 'Set up SDL sources'
+        uses: actions/checkout@v4
+        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@v4
+        with:
+          name: sources
+          path: '${{ github.workspace}}/dist'
+
+  linux-verify:
+    needs: [src]
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v4
+        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: 'CMake (configure + build + tests + examples)'
+        run: |
+          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
+
+  dmg:
+    needs: [src]
+    runs-on: macos-latest
+    outputs:
+      dmg: ${{ steps.releaser.outputs.dmg }}
+    steps:
+      - name: 'Set up Python'
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: 'build-scripts/build-release.py'
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v4
+        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 SDL2.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@v4
+        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@v4
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Download ${{ needs.dmg.outputs.dmg }}'
+        uses: actions/download-artifact@v4
+        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 }}.framework" ]; then
+            echo "Cannot find ${{ needs.src.outputs.project }}.framework!"
+            exit 1
+          fi
+          echo "mount_point=$mount_point">>$GITHUB_OUTPUT
+      - name: 'CMake (configure + build) Darwin'
+        run: |
+          set -e
+          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"                      \
+              -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 }}"  \
+              -DCMAKE_SYSTEM_NAME=Darwin                                    \
+              -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"                      \
+              -Werror=dev                                                   \
+              -B build_darwin_2
+          cmake --build build_darwin --config Release --verbose
+
+  msvc:
+    needs: [src]
+    runs-on: windows-2019
+    outputs:
+      VC-x86: ${{ steps.releaser.outputs.VC-x86 }}
+      VC-x64: ${{ steps.releaser.outputs.VC-x64 }}
+      VC-devel: ${{ steps.releaser.outputs.VC-devel }}
+    steps:
+      - name: 'Set up Python'
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: 'build-scripts/build-release.py'
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v4
+        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@v4
+        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@v4
+        with:
+          sparse-checkout: '.github/actions/setup-ninja/action.yml'
+      - name: 'Download source archives'
+        uses: actions/download-artifact@v4
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Download MSVC binaries'
+        uses: actions/download-artifact@v4
+        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: ilammy/msvc-dev-cmd@v1
+        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=FALSE                                   `
+              -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: ilammy/msvc-dev-cmd@v1
+        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=FALSE                                   `
+              -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
+
+  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@v5
+        with:
+          python-version: '3.11'
+      - name: 'Fetch build-release.py'
+        uses: actions/checkout@v4
+        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@v4
+        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@v4
+        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@v4
+        with:
+          name: sources
+          path: '${{ github.workspace }}'
+      - name: 'Download MinGW binaries'
+        uses: actions/download-artifact@v4
+        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 and install ${{ 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 }}"
+          make -C /tmp/mingw-tardir/${{ needs.src.outputs.project }}-${{ needs.src.outputs.version }} cross CROSS_PATH=/tmp/deps-mingw
+          echo "path=/tmp/deps-mingw" >>$GITHUB_OUTPUT
+      - name: 'CMake (configure + build) i686'
+        run: |
+          set -e
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                                           \
+              -DCMAKE_BUILD_TYPE="Release"                                                                              \
+              -DTEST_FULL=FALSE                                                                                         \
+              -DTEST_STATIC=TRUE                                                                                        \
+              -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: |
+          set -e
+          cmake -S "${{ steps.src.outputs.path }}/cmake/test"                                                           \
+              -DCMAKE_BUILD_TYPE="Release"                                                                              \
+              -DTEST_FULL=FALSE                                                                                         \
+              -DTEST_STATIC=TRUE                                                                                        \
+              -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

.github/workflows/riscos.yml

@@ -1,68 +0,0 @@
-name: Build (RISC OS)
-
-on: [push, pull_request]
-
-jobs:
-  Build:
-    name: ${{ matrix.platform.name }}
-    runs-on: ubuntu-latest
-    container: riscosdotinfo/riscos-gccsdk-4.7:latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - { name: autotools, test_args: '-DTEST_SHARED=FALSE' } # FIXME: autotools should build and install shared libraries
-          - { name: CMake }
-
-    steps:
-    - name: Setup dependencies
-      run: apt-get update && apt-get install -y cmake ninja-build
-    - uses: actions/checkout@v4
-    - name: Configure (autotools)
-      if: ${{ contains(matrix.platform.name, 'autotools') }}
-      run: |
-        mkdir build_autotools
-        cd build_autotools
-        ../configure \
-          --host=arm-unknown-riscos \
-          --disable-gcc-atomics \
-          --prefix=${{ github.workspace }}/prefix_autotools
-    - name: Build (autotools)
-      if: ${{ contains(matrix.platform.name, 'autotools') }}
-      run: make -C build_autotools -j`nproc` V=1
-    - name: Install (autotools)
-      if: ${{ contains(matrix.platform.name, 'autotools') }}
-      run: |
-        echo "SDL2_DIR=${{ github.workspace }}/prefix_autotools" >> $GITHUB_ENV
-        make -C build_autotools install
-        ( cd ${{ github.workspace }}/prefix_autotools; find ) | LC_ALL=C sort -u
-    - name: Configure (CMake)
-      if: ${{ contains(matrix.platform.name, 'CMake') }}
-      run: |
-        cmake -S . -B build -G Ninja \
-          -DCMAKE_TOOLCHAIN_FILE=/home/riscos/env/toolchain-riscos.cmake \
-          -DRISCOS=ON \
-          -DSDL_GCC_ATOMICS=OFF \
-          -DSDL_TESTS=ON \
-          -DSDL_INSTALL_TESTS=ON \
-          -DSDL_VENDOR_INFO="Github Workflow" \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/prefix_cmake
-    - name: Build (CMake)
-      if: ${{ contains(matrix.platform.name, 'CMake') }}
-      run: cmake --build build --verbose
-    - name: Install (CMake)
-      if: ${{ contains(matrix.platform.name, 'CMake') }}
-      run: |
-        echo "SDL2_DIR=${{ github.workspace }}/prefix_cmake" >> $GITHUB_ENV
-        cmake --install build/
-        ( cd ${{ github.workspace }}/prefix_cmake; find ) | LC_ALL=C sort -u
-    - name: Verify CMake configuration files
-      run: |
-        cmake -S cmake/test -B cmake_config_build -G Ninja \
-          -DCMAKE_TOOLCHAIN_FILE=/home/riscos/env/toolchain-riscos.cmake \
-          -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }} \
-          -DCMAKE_BUILD_TYPE=Release \
-          ${{ matrix.platform.test_args }}
-        cmake --build cmake_config_build --verbose

.github/workflows/vita.yaml

@@ -1,95 +0,0 @@
-name: Build (Sony Playstation Vita)
-
-on: [push, pull_request]
-
-defaults:
-  run:
-    shell: sh
-
-jobs:
-  vita:
-    name: ${{ matrix.platform.name }}
-    runs-on: ubuntu-latest
-    container: 
-      image: vitasdk/vitasdk:latest
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - { name: GLES (pib),                    os: windows-latest, pib: true }
-          - { name: GLES (PVR_PSP2 + gl4es4vita),  os: windows-latest, pvr: true }
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install build requirements
-      run: |
-        apk update 
-        apk add cmake ninja pkgconf bash
-
-    - name: Configure PVR_PSP2 (GLES)
-      if: ${{ !!matrix.platform.pvr }}
-      run: |
-        pvr_psp2_version=3.9
-
-        # 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/* ${VITASDK}/arm-vita-eabi/include
-        rm /tmp/v$pvr_psp2_version.zip
-
-        # 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 {} ${VITASDK}/arm-vita-eabi/lib \;
-        rm /tmp/vitasdk_stubs.zip
-        rm -rf /tmp/pvr_psp2_stubs
-
-    - name: Configure gl4es4vita (OpenGL)
-      if: ${{ !!matrix.platform.pvr }}
-      run: |
-        gl4es4vita_version=1.1.4
-
-        # 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${VITASDK}/arm-vita-eabi/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${VITASDK}/arm-vita-eabi/lib
-
-    - name: Configure CMake
-      run: |
-        cmake -S . -B build -G Ninja \
-          -DCMAKE_TOOLCHAIN_FILE=${VITASDK}/share/vita.toolchain.cmake \
-          -DVIDEO_VITA_PIB=${{ !!matrix.platform.pib }} \
-          -DVIDEO_VITA_PVR=${{ !!matrix.platform.pvr }} \
-          -DSDL_WERROR=ON \
-          -DSDL_TESTS=ON \
-          -DSDL_INSTALL_TESTS=ON \
-          -DCMAKE_BUILD_TYPE=Release \
-          -DCMAKE_INSTALL_PREFIX=prefix
-    - name: Build
-      run: cmake --build build --verbose
-    - name: Install CMake
-      run: |
-        echo "SDL2_DIR=$(pwd)/prefix" >> $GITHUB_ENV
-        cmake --install build/
-        ( cd prefix; find ) | LC_ALL=C sort -u
-    - name: Verify CMake configuration files
-      run: |
-        cmake -S cmake/test -B cmake_config_build -G Ninja \
-          -DCMAKE_TOOLCHAIN_FILE=${VITASDK}/share/vita.toolchain.cmake \
-          -DTEST_SHARED=FALSE \
-          -DCMAKE_PREFIX_PATH=${{ env.SDL2_DIR }} \
-          -DCMAKE_BUILD_TYPE=Release
-        cmake --build cmake_config_build --verbose
-    - name: Verify sdl2-config
-      run: |
-        export CC=arm-vita-eabi-gcc
-        export PATH=${{ env.SDL2_DIR }}/bin:$PATH
-        cmake/test/test_sdlconfig.sh
-    - name: Verify sdl2.pc
-      run: |
-        export CC=arm-vita-eabi-gcc
-        export PKG_CONFIG_PATH=${{ env.SDL2_DIR }}/lib/pkgconfig
-        cmake/test/test_pkgconfig.sh

.github/workflows/watcom.yml

@@ -1,35 +0,0 @@
-name: Build (OpenWatcom)
-
-on: [push, pull_request]
-
-jobs:
-  os2:
-    name: ${{ matrix.platform.name }}
-    runs-on: windows-latest
-
-    strategy:
-      matrix:
-        platform:
-        - { name: Windows, makefile: Makefile.w32 }
-        - { name: OS/2,    makefile: Makefile.os2 }
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: open-watcom/setup-watcom@v0
-      - name: Build SDL2
-        run: |
-          wmake -f ${{ matrix.platform.makefile }} ENABLE_WERROR=1
-      - name: Build tests
-        run: |
-          cd test && wmake -f ${{ matrix.platform.makefile }} ENABLE_WERROR=1
-          cd ..
-      - name: Run tests
-        if: "matrix.platform.makefile == 'Makefile.w32'"
-        run: |
-          cd test && wmake -f ${{ matrix.platform.makefile }} check-quick
-          cd ..
-      - name: distclean
-        run: |
-          wmake -f ${{ matrix.platform.makefile }} distclean
-          cd test && wmake -f ${{ matrix.platform.makefile }} distclean
-          cd ..

.gitignore

@@ -16,6 +16,7 @@ gen
 Build
 buildbot
 /VERSION.txt
+dist
 
 *.so
 *.so.*

CMakeLists.txt

@@ -5,7 +5,7 @@ endif()
 # MSVC runtime library flags are selected by an abstraction.
 set(CMAKE_POLICY_DEFAULT_CMP0091 NEW)
 
-cmake_minimum_required(VERSION 3.0.0...3.5)
+cmake_minimum_required(VERSION 3.0.0...3.10)
 project(SDL2 C CXX)
 
 if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
@@ -33,8 +33,8 @@ set(PKGCONFIG_DEPENDS)
 add_library(sdl-build-options INTERFACE)
 
 if(WINDOWS_STORE)
-  target_compile_definitions(sdl-build-options INTERFACE "-DSDL_BUILDING_WINRT=1")
-  target_compile_options(sdl-build-options INTERFACE "-ZW")
+  target_compile_definitions(sdl-build-options INTERFACE "-DSDL_BUILDING_WINRT=1" "WINAPI_FAMILY=WINAPI_FAMILY_APP")
+  target_compile_options(sdl-build-options INTERFACE "$<$<COMPILE_LANGUAGE:CXX>:-ZW>" "$<$<COMPILE_LANGUAGE:CXX>:-EHsc>")
 endif()
 
 # CMake 3.0 expands the "if(${A})" in "set(OFF 1);set(A OFF);if(${A})" to "if(1)"
@@ -87,7 +87,7 @@ endif()
 # See docs/release_checklist.md
 set(SDL_MAJOR_VERSION 2)
 set(SDL_MINOR_VERSION 30)
-set(SDL_MICRO_VERSION 1)
+set(SDL_MICRO_VERSION 10)
 set(SDL_VERSION "${SDL_MAJOR_VERSION}.${SDL_MINOR_VERSION}.${SDL_MICRO_VERSION}")
 
 # Set defaults preventing destination file conflicts
@@ -241,7 +241,7 @@ endif()
 if(UNIX OR MINGW OR MSYS OR (USE_CLANG AND NOT WINDOWS) OR VITA OR PSP OR PS2 OR N3DS)
   set(OPT_DEF_LIBC ON)
 endif()
-if(WINDOWS OR IOS OR TVOS)
+if(WINDOWS OR DARWIN OR MACOSX OR IOS OR TVOS)
   set(SDL_SYSTEM_ICONV_DEFAULT OFF)
 else()
   set(SDL_SYSTEM_ICONV_DEFAULT ON)
@@ -409,7 +409,7 @@ dep_option(SDL_SSE                 "Use SSE assembly routines" ON "SDL_ASSEMBLY;
 dep_option(SDL_SSE2                "Use SSE2 assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF)
 dep_option(SDL_SSE3                "Use SSE3 assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF)
 dep_option(SDL_MMX                 "Use MMX assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF)
-dep_option(SDL_3DNOW               "Use 3Dnow! MMX assembly routines" ON "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF)
+dep_option(SDL_3DNOW               "Use 3Dnow! MMX assembly routines" OFF "SDL_ASSEMBLY;SDL_CPU_X86 OR SDL_CPU_X64" OFF)
 dep_option(SDL_ALTIVEC             "Use Altivec assembly routines" ON "SDL_ASSEMBLY" OFF)
 dep_option(SDL_ARMSIMD             "Use SIMD assembly blitters on ARM" OFF "SDL_ASSEMBLY;SDL_CPU_ARM32" OFF)
 dep_option(SDL_ARMNEON             "Use NEON assembly blitters on ARM" OFF "SDL_ASSEMBLY;SDL_CPU_ARM32" OFF)
@@ -926,22 +926,6 @@ if(SDL_ASSEMBLY)
       endif()
     endif()
 
-    if(SDL_LASX)
-      cmake_push_check_state()
-      set(CMAKE_REQUIRED_FLAGS "-mlasx")
-      check_c_source_compiles("
-          #ifndef __loongarch_asx
-          #error Assembler CPP flag not enabled
-          #endif
-          int main(int argc, char **argv) { return 0; }" CPU_SUPPORTS_LASX)
-      check_include_file("lasxintrin.h" HAVE_LASXINTRIN_H)
-      cmake_pop_check_state()
-      if(CPU_SUPPORTS_LASX AND HAVE_LASXINTRIN_H)
-        list(APPEND EXTRA_CFLAGS "-mlasx")
-        set(HAVE_LASX TRUE)
-      endif()
-    endif()
-
     if(SDL_ARMSIMD)
       set(ORIG_CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS}")
       set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -x assembler-with-cpp")
@@ -1107,6 +1091,8 @@ if(SDL_LIBC)
     check_symbol_exists(getauxval "sys/auxv.h" HAVE_GETAUXVAL)
     check_symbol_exists(elf_aux_info "sys/auxv.h" HAVE_ELF_AUX_INFO)
     check_symbol_exists(poll "poll.h" HAVE_POLL)
+    check_symbol_exists(memfd_create "sys/mman.h" HAVE_MEMFD_CREATE)
+    check_symbol_exists(posix_fallocate "fcntl.h" HAVE_POSIX_FALLOCATE)
 
     check_library_exists(m pow "" HAVE_LIBM)
     if(HAVE_LIBM)
@@ -1688,7 +1674,7 @@ elseif(UNIX AND NOT APPLE AND NOT RISCOS AND NOT HAIKU)
     if(FREEBSD OR NETBSD OR OPENBSD OR BSDI)
       CheckUSBHID()
     endif()
-    if(LINUX AND HAVE_LINUX_INPUT_H AND NOT ANDROID)
+    if((LINUX OR FREEBSD) AND HAVE_LINUX_INPUT_H AND NOT ANDROID)
       set(SDL_JOYSTICK_LINUX 1)
       file(GLOB JOYSTICK_SOURCES ${SDL2_SOURCE_DIR}/src/joystick/linux/*.c ${SDL2_SOURCE_DIR}/src/joystick/steam/*.c)
       list(APPEND SOURCE_FILES ${JOYSTICK_SOURCES})
@@ -1791,14 +1777,6 @@ elseif(WINDOWS)
     list(APPEND SOURCE_FILES ${WINRT_SOURCE_FILES})
   endif()
 
-  if(MSVC AND NOT SDL_LIBC)
-    # Prevent codegen that would use the VC runtime libraries.
-    set_property(DIRECTORY . APPEND PROPERTY COMPILE_OPTIONS "/GS-;/Gs1048576")
-    if(NOT ARCH_64 AND NOT CMAKE_GENERATOR_PLATFORM STREQUAL "ARM")
-      set_property(DIRECTORY . APPEND PROPERTY COMPILE_OPTIONS "/arch:SSE")
-    endif()
-  endif()
-
   if(SDL_MISC)
     if(WINDOWS_STORE)
       file(GLOB MISC_SOURCES ${SDL2_SOURCE_DIR}/src/misc/winrt/*.cpp)
@@ -1824,13 +1802,11 @@ elseif(WINDOWS)
     check_include_file(d3d9.h HAVE_D3D_H)
     check_include_file(d3d11_1.h HAVE_D3D11_H)
     check_c_source_compiles("
-      #include <winsdkver.h>
-      #include <sdkddkver.h>
       #include <d3d12.h>
+      #include <d3d12sdklayers.h>
       ID3D12Device1 *device;
-      #if WDK_NTDDI_VERSION > 0x0A000008
-      int main(int argc, char **argv) { return 0; }
-      #endif" HAVE_D3D12_H)
+      int main(int argc, char **argv) {return 0; }
+      " HAVE_D3D12_H)
     check_include_file(ddraw.h HAVE_DDRAW_H)
     check_include_file(dsound.h HAVE_DSOUND_H)
     check_include_file(dinput.h HAVE_DINPUT_H)
@@ -2689,6 +2665,11 @@ elseif(PSP)
     list(APPEND SOURCE_FILES ${PSP_THREAD_SOURCES})
     set(HAVE_SDL_THREADS TRUE)
   endif()
+  if(SDL_LOCALE)
+    file(GLOB PSP_LOCALE_SOURCES ${SDL2_SOURCE_DIR}/src/locale/psp/*.c)
+    list(APPEND SOURCE_FILES ${PSP_LOCALE_SOURCES})
+    set(HAVE_SDL_LOCALE TRUE)
+  endif()
   if(SDL_TIMERS)
     set(SDL_TIMER_PSP 1)
     file(GLOB PSP_TIMER_SOURCES ${SDL2_SOURCE_DIR}/src/timer/psp/*.c)
@@ -3077,8 +3058,8 @@ endif()
 
 # Compat helpers for the configuration files
 
-if(EXISTS "${PROJECT_SOURCE_DIR}/VERSION.txt")
-  file(READ "${PROJECT_SOURCE_DIR}/VERSION.txt" SDL_SOURCE_VERSION)
+if(EXISTS "${PROJECT_SOURCE_DIR}/REVISION.txt")
+  file(READ "${PROJECT_SOURCE_DIR}/REVISION.txt" SDL_SOURCE_VERSION)
   string(STRIP "${SDL_SOURCE_VERSION}" SDL_SOURCE_VERSION)
 endif()
 
@@ -3543,6 +3524,23 @@ if(SDL_TEST)
   set_property(TARGET SDL2_test PROPERTY INTERFACE_SDL_VERSION "SDL2")
 endif()
 
+if(MSVC AND NOT SDL_LIBC)
+  set(targets )
+  if(TARGET SDL2)
+    list(APPEND targets SDL2)
+  endif()
+  if(TARGET SDL2-static)
+    list(APPEND targets SDL2-static)
+  endif()
+  if(TARGET SDL2_test)
+    list(APPEND targets SDL2_test)
+  endif()
+  set_property(TARGET ${targets} APPEND PROPERTY COMPILE_OPTIONS "/GS-;/Gs1048576")
+  if(NOT ARCH_64 AND NOT CMAKE_GENERATOR_PLATFORM STREQUAL "ARM")
+    set_property(TARGET ${targets} APPEND PROPERTY COMPILE_OPTIONS "/arch:SSE")
+  endif()
+endif()
+
 ##### Installation targets #####
 if(NOT SDL2_DISABLE_INSTALL)
   if(SDL_SHARED)

Makefile.in

@@ -52,7 +52,7 @@ WAYLAND_SCANNER_CODE_MODE = @WAYLAND_SCANNER_CODE_MODE@
 
 INSTALL_SDL2_CONFIG = @INSTALL_SDL2_CONFIG@
 
-SRC_DIST = *.md *.txt acinclude Android.mk autogen.sh android-project build-scripts cmake cmake_uninstall.cmake.in configure configure.ac docs include Makefile.* mingw sdl2-config.cmake.in sdl2-config-version.cmake.in sdl2-config.in sdl2.m4 sdl2.pc.in SDL2.spec.in SDL2Config.cmake.in src test VisualC VisualC-WinRT Xcode Xcode-iOS wayland-protocols
+SRC_DIST = *.md *.txt acinclude Android.mk autogen.sh android-project build-scripts cmake cmake_uninstall.cmake.in configure configure.ac docs include Makefile.* mingw sdl2-config.cmake.in sdl2-config-version.cmake.in sdl2-config.in sdl2.m4 sdl2.pc.in SDL2.spec.in SDL2Config.cmake.in src test VisualC VisualC-GDK VisualC-WinRT Xcode Xcode-iOS wayland-protocols
 GEN_DIST = SDL2.spec
 
 ifneq ($V,1)

Makefile.os2

@@ -15,7 +15,7 @@
 LIBNAME = SDL2
 MAJOR_VERSION = 2
 MINOR_VERSION = 30
-MICRO_VERSION = 1
+MICRO_VERSION = 10
 VERSION = $(MAJOR_VERSION).$(MINOR_VERSION).$(MICRO_VERSION)
 DESCRIPTION = Simple DirectMedia Layer 2
 

Makefile.w32

@@ -6,7 +6,7 @@
 LIBNAME = SDL2
 MAJOR_VERSION = 2
 MINOR_VERSION = 30
-MICRO_VERSION = 1
+MICRO_VERSION = 10
 VERSION = $(MAJOR_VERSION).$(MINOR_VERSION).$(MICRO_VERSION)
 
 LIBHOME = .

VisualC-GDK/SDL/SDL.vcxproj

@@ -174,7 +174,7 @@
       <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
     </Link>
     <PreBuildEvent>
-      <Command>$(SolutionDir)\shaders\buildshaders.bat $(SolutionDir)</Command>
+      <Command>$(ProjectDir)..\shaders\buildshaders.bat $(ProjectDir)..\</Command>
     </PreBuildEvent>
     <PreBuildEvent>
       <Message>Building shader blobs (Xbox Series)</Message>
@@ -208,7 +208,7 @@
       <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
     </Link>
     <PreBuildEvent>
-      <Command>$(SolutionDir)\shaders\buildshaders.bat $(SolutionDir) one</Command>
+      <Command>$(ProjectDir)..\shaders\buildshaders.bat $(ProjectDir)..\ one</Command>
     </PreBuildEvent>
     <PreBuildEvent>
       <Message>Building shader blobs (Xbox One)</Message>
@@ -272,7 +272,7 @@
       <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
     </Link>
     <PreBuildEvent>
-      <Command>$(SolutionDir)\shaders\buildshaders.bat $(SolutionDir)</Command>
+      <Command>$(ProjectDir)..\shaders\buildshaders.bat $(ProjectDir)..\</Command>
     </PreBuildEvent>
     <PreBuildEvent>
       <Message>Building shader blobs (Xbox Series)</Message>
@@ -307,7 +307,7 @@
       <IgnoreAllDefaultLibraries>true</IgnoreAllDefaultLibraries>
     </Link>
     <PreBuildEvent>
-      <Command>$(SolutionDir)\shaders\buildshaders.bat $(SolutionDir) one</Command>
+      <Command>$(ProjectDir)..\shaders\buildshaders.bat $(ProjectDir)..\ one</Command>
     </PreBuildEvent>
     <PreBuildEvent>
       <Message>Building shader blobs (Xbox One)</Message>
@@ -499,7 +499,6 @@
     <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.hpp" />
     <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" />

VisualC-GDK/SDL/SDL.vcxproj.filters

@@ -780,9 +780,6 @@
     <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan.h">
       <Filter>video\khronos\vulkan</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan.hpp">
-      <Filter>video\khronos\vulkan</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_android.h">
       <Filter>video\khronos\vulkan</Filter>
     </ClInclude>

VisualC-GDK/tests/testgamecontroller/testgamecontroller.vcxproj

@@ -139,7 +139,7 @@
     </ResourceCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
-      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.141.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Gaming.Xbox.Scarlett.x64'">
@@ -211,7 +211,7 @@
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
-      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.141.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Gaming.Xbox.Scarlett.x64'">
@@ -409,7 +409,7 @@
     <CopyFileToFolders Include="..\..\logos\Logo480x480.png" />
   </ItemGroup>
   <ItemGroup>
-    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.141.GDK.C.Thunks.dll">
+    <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>

VisualC-GDK/tests/testgamecontroller/testgamecontroller.vcxproj.filters

@@ -21,7 +21,7 @@
     <CopyFileToFolders Include="..\..\logos\Logo480x480.png">
       <Filter>logos</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.141.GDK.C.Thunks.dll">
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
       <Filter>wingdk</Filter>
     </CopyFileToFolders>
     <CopyFileToFolders Include="wingdk\MicrosoftGame.config">
@@ -52,4 +52,4 @@
       <UniqueIdentifier>{e704dcb9-c83c-4c94-a139-b0f3e3f428f2}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
-</Project>
+</Project>

VisualC-GDK/tests/testgdk/testgdk.vcxproj

@@ -139,7 +139,7 @@
     </ResourceCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
-      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.141.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <PostBuildEvent>
       <Command>
@@ -223,7 +223,7 @@
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
-      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.141.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <PostBuildEvent>
       <Command>
@@ -352,7 +352,7 @@ copy "%(FullPath)" "$(OutDir)\"</Command>
     </CopyFileToFolders>
   </ItemGroup>
   <ItemGroup>
-    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.141.GDK.C.Thunks.dll">
+    <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>
@@ -398,4 +398,4 @@ copy "%(FullPath)" "$(OutDir)\"</Command>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

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

@@ -18,7 +18,7 @@
     <CopyFileToFolders Include="..\..\logos\Logo480x480.png">
       <Filter>logos</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.141.GDK.C.Thunks.dll">
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
       <Filter>wingdk</Filter>
     </CopyFileToFolders>
     <CopyFileToFolders Include="wingdk\MicrosoftGame.config">
@@ -50,4 +50,4 @@
       <UniqueIdentifier>{ac7aa2d5-f0f7-46eb-a548-5b6316f3b63b}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
-</Project>
+</Project>

VisualC-GDK/tests/testsprite2/testsprite2.vcxproj

@@ -139,7 +139,7 @@
     </ResourceCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
-      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.141.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <PostBuildEvent>
       <Command>
@@ -223,7 +223,7 @@
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <SubSystem>Windows</SubSystem>
-      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.141.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>xgameruntime.lib;../Microsoft.Xbox.Services.GDK.C.Thunks.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <PostBuildEvent>
       <Command>
@@ -352,7 +352,7 @@ copy "%(FullPath)" "$(OutDir)\"</Command>
     </CopyFileToFolders>
   </ItemGroup>
   <ItemGroup>
-    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.141.GDK.C.Thunks.dll">
+    <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>
@@ -392,4 +392,4 @@ copy "%(FullPath)" "$(OutDir)\"</Command>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

VisualC-GDK/tests/testsprite2/testsprite2.vcxproj.filters

@@ -18,7 +18,7 @@
     <CopyFileToFolders Include="..\..\logos\Logo480x480.png">
       <Filter>logos</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.141.GDK.C.Thunks.dll">
+    <CopyFileToFolders Include="$(Console_GRDKExtLibRoot)Xbox.Services.API.C\DesignTime\CommonConfiguration\Neutral\Lib\Release\Microsoft.Xbox.Services.GDK.C.Thunks.dll">
       <Filter>wingdk</Filter>
     </CopyFileToFolders>
     <CopyFileToFolders Include="xboxseries\MicrosoftGame.config">
@@ -49,4 +49,4 @@
       <UniqueIdentifier>{9bf62acf-6661-43f9-bde3-0de9e1db4290}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
-</Project>
+</Project>

VisualC/SDL/SDL.vcxproj

@@ -44,22 +44,6 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
   </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" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC70.props" />
-  </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" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC70.props" />
-  </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" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC70.props" />
-  </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" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC70.props" />
-  </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
     <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
@@ -394,7 +378,6 @@
     <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.hpp" />
     <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" />

VisualC/SDL/SDL.vcxproj.filters

@@ -780,9 +780,6 @@
     <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan.h">
       <Filter>video\khronos\vulkan</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan.hpp">
-      <Filter>video\khronos\vulkan</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\src\video\khronos\vulkan\vulkan_android.h">
       <Filter>video\khronos\vulkan</Filter>
     </ClInclude>

VisualC/pkg-support/cmake/sdl2-config.cmake

@@ -1,7 +1,7 @@
 # SDL2 CMake configuration file:
 # This file is meant to be placed in a cmake subfolder of SDL2-devel-2.x.y-VC
 
-cmake_minimum_required(VERSION 3.0...3.5)
+cmake_minimum_required(VERSION 3.0...3.28)
 
 include(FeatureSummary)
 set_package_properties(SDL2 PROPERTIES
@@ -79,6 +79,8 @@ endif()
 unset(_sdl2_library)
 unset(_sdl2_dll_library)
 
+set(SDL2_SDL2-static_FOUND FALSE)
+
 set(_sdl2main_library "${SDL2_LIBDIR}/SDL2main.lib")
 if(EXISTS "${_sdl2main_library}")
     if(NOT TARGET SDL2::SDL2main)
@@ -92,7 +94,7 @@ if(EXISTS "${_sdl2main_library}")
     endif()
     set(SDL2_SDL2main_FOUND TRUE)
 else()
-    set(SDL2_SDL2_FOUND FALSE)
+    set(SDL2_SDL2main_FOUND FALSE)
 endif()
 unset(_sdl2main_library)
 
@@ -110,7 +112,7 @@ if(EXISTS "${_sdl2test_library}")
     endif()
     set(SDL2_SDL2test_FOUND TRUE)
 else()
-    set(SDL2_SDL2_FOUND FALSE)
+    set(SDL2_SDL2test_FOUND FALSE)
 endif()
 unset(_sdl2test_library)
 

Xcode-iOS/Demos/src/fireworks.c

@@ -52,9 +52,9 @@ void spawnTrailFromEmitter(struct particle *emitter);
 void spawnEmitterParticle(GLfloat x, GLfloat y);
 void explodeEmitter(struct particle *emitter);
 void initializeParticles(void);
-void initializeTexture();
+void initializeTexture(void);
 int nextPowerOfTwo(int x);
-void drawParticles();
+void drawParticles(void);
 void stepParticles(double deltaTime);
 
 /*  helper function (used in texture loading)
@@ -159,7 +159,7 @@ stepParticles(double deltaTime)
     This draws all the particles shown on screen
 */
 void
-drawParticles()
+drawParticles(void)
 {
 
     /* draw the background */
@@ -324,7 +324,7 @@ initializeParticles(void)
     loads the particle texture
  */
 void
-initializeTexture()
+initializeTexture(void)
 {
 
     int bpp;                    /* texture bits per pixel */

Xcode-iOS/Demos/src/keyboard.c

@@ -196,7 +196,7 @@ loadFont(void)
 }
 
 void
-draw()
+draw(void)
 {
     SDL_SetRenderDrawColor(renderer, bg_color.r, bg_color.g, bg_color.b, bg_color.a);
     SDL_RenderClear(renderer);

Xcode/SDL/Info-Framework.plist

@@ -19,10 +19,10 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>2.30.1</string>
+	<string>2.30.10</string>
 	<key>CFBundleSignature</key>
 	<string>SDLX</string>
 	<key>CFBundleVersion</key>
-	<string>2.30.1</string>
+	<string>2.30.10</string>
 </dict>
 </plist>

Xcode/SDL/SDL.xcodeproj/project.pbxproj

@@ -206,7 +206,6 @@
 		A75FCD4823E25AB700529352 /* SDL_keycode.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557DB1595D4D800BBD41B /* SDL_keycode.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD4A23E25AB700529352 /* SDL_cocoakeyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68023E2513E00DCD162 /* SDL_cocoakeyboard.h */; };
 		A75FCD4B23E25AB700529352 /* SDL_uikitvulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A63323E2513D00DCD162 /* SDL_uikitvulkan.h */; };
-		A75FCD4E23E25AB700529352 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
 		A75FCD4F23E25AB700529352 /* SDL_loadso.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557DC1595D4D800BBD41B /* SDL_loadso.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCD5023E25AB700529352 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
 		A75FCD5123E25AB700529352 /* SDL_clipboardevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93923E2514000DCD162 /* SDL_clipboardevents_c.h */; };
@@ -282,7 +281,6 @@
 		A75FCDA123E25AB700529352 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
 		A75FCDA223E25AB700529352 /* SDL_uikitwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62723E2513D00DCD162 /* SDL_uikitwindow.h */; };
 		A75FCDA323E25AB700529352 /* vulkan_vi.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72F23E2513E00DCD162 /* vulkan_vi.h */; };
-		A75FCDA423E25AB700529352 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
 		A75FCDA523E25AB700529352 /* SDL_quit.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557E81595D4D800BBD41B /* SDL_quit.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCDA623E25AB700529352 /* default_cursor.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93323E2514000DCD162 /* default_cursor.h */; };
 		A75FCDA723E25AB700529352 /* SDL_render_sw_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8F523E2514000DCD162 /* SDL_render_sw_c.h */; };
@@ -580,7 +578,6 @@
 		A75FCF0123E25AC700529352 /* SDL_keycode.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557DB1595D4D800BBD41B /* SDL_keycode.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCF0323E25AC700529352 /* SDL_cocoakeyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68023E2513E00DCD162 /* SDL_cocoakeyboard.h */; };
 		A75FCF0423E25AC700529352 /* SDL_uikitvulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A63323E2513D00DCD162 /* SDL_uikitvulkan.h */; };
-		A75FCF0723E25AC700529352 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
 		A75FCF0823E25AC700529352 /* SDL_loadso.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557DC1595D4D800BBD41B /* SDL_loadso.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCF0923E25AC700529352 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
 		A75FCF0A23E25AC700529352 /* SDL_clipboardevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93923E2514000DCD162 /* SDL_clipboardevents_c.h */; };
@@ -656,7 +653,6 @@
 		A75FCF5A23E25AC700529352 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
 		A75FCF5B23E25AC700529352 /* SDL_uikitwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62723E2513D00DCD162 /* SDL_uikitwindow.h */; };
 		A75FCF5C23E25AC700529352 /* vulkan_vi.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72F23E2513E00DCD162 /* vulkan_vi.h */; };
-		A75FCF5D23E25AC700529352 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
 		A75FCF5E23E25AC700529352 /* SDL_quit.h in Headers */ = {isa = PBXBuildFile; fileRef = AA7557E81595D4D800BBD41B /* SDL_quit.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		A75FCF5F23E25AC700529352 /* default_cursor.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93323E2514000DCD162 /* default_cursor.h */; };
 		A75FCF6023E25AC700529352 /* SDL_render_sw_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8F523E2514000DCD162 /* SDL_render_sw_c.h */; };
@@ -974,7 +970,6 @@
 		A769B0CD23E259AE00872273 /* SDL_systhread_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A78423E2513E00DCD162 /* SDL_systhread_c.h */; };
 		A769B0D023E259AE00872273 /* SDL_cocoakeyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A68023E2513E00DCD162 /* SDL_cocoakeyboard.h */; };
 		A769B0D123E259AE00872273 /* SDL_uikitvulkan.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A63323E2513D00DCD162 /* SDL_uikitvulkan.h */; };
-		A769B0D423E259AE00872273 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
 		A769B0D623E259AE00872273 /* gl2ext.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72323E2513E00DCD162 /* gl2ext.h */; };
 		A769B0D723E259AE00872273 /* SDL_clipboardevents_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93923E2514000DCD162 /* SDL_clipboardevents_c.h */; };
 		A769B0D923E259AE00872273 /* SDL_syshaptic_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A5CF23E2513D00DCD162 /* SDL_syshaptic_c.h */; };
@@ -1036,7 +1031,6 @@
 		A769B12923E259AE00872273 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
 		A769B12A23E259AE00872273 /* SDL_uikitwindow.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A62723E2513D00DCD162 /* SDL_uikitwindow.h */; };
 		A769B12B23E259AE00872273 /* vulkan_vi.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A72F23E2513E00DCD162 /* vulkan_vi.h */; };
-		A769B12C23E259AE00872273 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
 		A769B12E23E259AE00872273 /* default_cursor.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A93323E2514000DCD162 /* default_cursor.h */; };
 		A769B12F23E259AE00872273 /* SDL_render_sw_c.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A8F523E2514000DCD162 /* SDL_render_sw_c.h */; };
 		A769B13223E259AE00872273 /* SDL_nullvideo.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A60A23E2513D00DCD162 /* SDL_nullvideo.h */; };
@@ -2110,12 +2104,6 @@
 		A7D8B26923E2514200DCD162 /* vk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73123E2513E00DCD162 /* vk_platform.h */; };
 		A7D8B26A23E2514200DCD162 /* vk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73123E2513E00DCD162 /* vk_platform.h */; };
 		A7D8B26B23E2514200DCD162 /* vk_platform.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73123E2513E00DCD162 /* vk_platform.h */; };
-		A7D8B26C23E2514200DCD162 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
-		A7D8B26D23E2514200DCD162 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
-		A7D8B26E23E2514200DCD162 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
-		A7D8B26F23E2514200DCD162 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
-		A7D8B27023E2514200DCD162 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
-		A7D8B27123E2514200DCD162 /* vulkan.hpp in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73223E2513E00DCD162 /* vulkan.hpp */; };
 		A7D8B27223E2514200DCD162 /* vulkan_fuchsia.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73323E2513E00DCD162 /* vulkan_fuchsia.h */; };
 		A7D8B27323E2514200DCD162 /* vulkan_fuchsia.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73323E2513E00DCD162 /* vulkan_fuchsia.h */; };
 		A7D8B27423E2514200DCD162 /* vulkan_fuchsia.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73323E2513E00DCD162 /* vulkan_fuchsia.h */; };
@@ -2152,12 +2140,6 @@
 		A7D8B29323E2514200DCD162 /* vulkan_xcb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73823E2513E00DCD162 /* vulkan_xcb.h */; };
 		A7D8B29423E2514200DCD162 /* vulkan_xcb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73823E2513E00DCD162 /* vulkan_xcb.h */; };
 		A7D8B29523E2514200DCD162 /* vulkan_xcb.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73823E2513E00DCD162 /* vulkan_xcb.h */; };
-		A7D8B29623E2514200DCD162 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
-		A7D8B29723E2514200DCD162 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
-		A7D8B29823E2514200DCD162 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
-		A7D8B29923E2514200DCD162 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
-		A7D8B29A23E2514200DCD162 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
-		A7D8B29B23E2514200DCD162 /* vulkan_mir.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73923E2513E00DCD162 /* vulkan_mir.h */; };
 		A7D8B29C23E2514200DCD162 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
 		A7D8B29D23E2514200DCD162 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
 		A7D8B29E23E2514200DCD162 /* vulkan_xlib.h in Headers */ = {isa = PBXBuildFile; fileRef = A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */; };
@@ -3968,14 +3950,12 @@
 		A7D8A72F23E2513E00DCD162 /* vulkan_vi.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_vi.h; sourceTree = "<group>"; };
 		A7D8A73023E2513E00DCD162 /* vulkan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan.h; sourceTree = "<group>"; };
 		A7D8A73123E2513E00DCD162 /* vk_platform.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vk_platform.h; sourceTree = "<group>"; };
-		A7D8A73223E2513E00DCD162 /* vulkan.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = vulkan.hpp; sourceTree = "<group>"; };
 		A7D8A73323E2513E00DCD162 /* vulkan_fuchsia.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_fuchsia.h; sourceTree = "<group>"; };
 		A7D8A73423E2513E00DCD162 /* vulkan_wayland.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_wayland.h; sourceTree = "<group>"; };
 		A7D8A73523E2513E00DCD162 /* vulkan_win32.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_win32.h; sourceTree = "<group>"; };
 		A7D8A73623E2513E00DCD162 /* vulkan_macos.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_macos.h; sourceTree = "<group>"; };
 		A7D8A73723E2513E00DCD162 /* vulkan_xlib_xrandr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_xlib_xrandr.h; sourceTree = "<group>"; };
 		A7D8A73823E2513E00DCD162 /* vulkan_xcb.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_xcb.h; sourceTree = "<group>"; };
-		A7D8A73923E2513E00DCD162 /* vulkan_mir.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_mir.h; sourceTree = "<group>"; };
 		A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_xlib.h; sourceTree = "<group>"; };
 		A7D8A73B23E2513E00DCD162 /* vulkan_ios.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_ios.h; sourceTree = "<group>"; };
 		A7D8A73C23E2513E00DCD162 /* vulkan_core.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vulkan_core.h; sourceTree = "<group>"; };
@@ -5003,7 +4983,6 @@
 				A7D8A73323E2513E00DCD162 /* vulkan_fuchsia.h */,
 				A7D8A73B23E2513E00DCD162 /* vulkan_ios.h */,
 				A7D8A73623E2513E00DCD162 /* vulkan_macos.h */,
-				A7D8A73923E2513E00DCD162 /* vulkan_mir.h */,
 				A7D8A72F23E2513E00DCD162 /* vulkan_vi.h */,
 				A7D8A73423E2513E00DCD162 /* vulkan_wayland.h */,
 				A7D8A73523E2513E00DCD162 /* vulkan_win32.h */,
@@ -5011,7 +4990,6 @@
 				A7D8A73723E2513E00DCD162 /* vulkan_xlib_xrandr.h */,
 				A7D8A73A23E2513E00DCD162 /* vulkan_xlib.h */,
 				A7D8A73023E2513E00DCD162 /* vulkan.h */,
-				A7D8A73223E2513E00DCD162 /* vulkan.hpp */,
 			);
 			path = vulkan;
 			sourceTree = "<group>";
@@ -5596,7 +5574,6 @@
 				5616CA63252BB35F005D5928 /* SDL_sysurl.h in Headers */,
 				A75FCD4A23E25AB700529352 /* SDL_cocoakeyboard.h in Headers */,
 				A75FCD4B23E25AB700529352 /* SDL_uikitvulkan.h in Headers */,
-				A75FCD4E23E25AB700529352 /* vulkan.hpp in Headers */,
 				A75FCD4F23E25AB700529352 /* SDL_loadso.h in Headers */,
 				A75FCD5023E25AB700529352 /* gl2ext.h in Headers */,
 				A75FCD5123E25AB700529352 /* SDL_clipboardevents_c.h in Headers */,
@@ -5680,7 +5657,6 @@
 				A75FCDA123E25AB700529352 /* vulkan_xlib.h in Headers */,
 				A75FCDA223E25AB700529352 /* SDL_uikitwindow.h in Headers */,
 				A75FCDA323E25AB700529352 /* vulkan_vi.h in Headers */,
-				A75FCDA423E25AB700529352 /* vulkan_mir.h in Headers */,
 				A75FCDA523E25AB700529352 /* SDL_quit.h in Headers */,
 				A75FCDA623E25AB700529352 /* default_cursor.h in Headers */,
 				A75FCDA723E25AB700529352 /* SDL_render_sw_c.h in Headers */,
@@ -5833,7 +5809,6 @@
 				5616CA66252BB361005D5928 /* SDL_sysurl.h in Headers */,
 				A75FCF0323E25AC700529352 /* SDL_cocoakeyboard.h in Headers */,
 				A75FCF0423E25AC700529352 /* SDL_uikitvulkan.h in Headers */,
-				A75FCF0723E25AC700529352 /* vulkan.hpp in Headers */,
 				A75FCF0823E25AC700529352 /* SDL_loadso.h in Headers */,
 				A75FCF0923E25AC700529352 /* gl2ext.h in Headers */,
 				A75FCF0A23E25AC700529352 /* SDL_clipboardevents_c.h in Headers */,
@@ -5917,7 +5892,6 @@
 				A75FCF5A23E25AC700529352 /* vulkan_xlib.h in Headers */,
 				A75FCF5B23E25AC700529352 /* SDL_uikitwindow.h in Headers */,
 				A75FCF5C23E25AC700529352 /* vulkan_vi.h in Headers */,
-				A75FCF5D23E25AC700529352 /* vulkan_mir.h in Headers */,
 				A75FCF5E23E25AC700529352 /* SDL_quit.h in Headers */,
 				A75FCF5F23E25AC700529352 /* default_cursor.h in Headers */,
 				A75FCF6023E25AC700529352 /* SDL_render_sw_c.h in Headers */,
@@ -6043,7 +6017,6 @@
 				A769B0D023E259AE00872273 /* SDL_cocoakeyboard.h in Headers */,
 				5616CA5D252BB35E005D5928 /* SDL_sysurl.h in Headers */,
 				A769B0D123E259AE00872273 /* SDL_uikitvulkan.h in Headers */,
-				A769B0D423E259AE00872273 /* vulkan.hpp in Headers */,
 				A769B0D623E259AE00872273 /* gl2ext.h in Headers */,
 				A769B0D723E259AE00872273 /* SDL_clipboardevents_c.h in Headers */,
 				A769B0D923E259AE00872273 /* SDL_syshaptic_c.h in Headers */,
@@ -6114,7 +6087,6 @@
 				F386F6F52884663E001840AA /* SDL_utils_c.h in Headers */,
 				A769B12A23E259AE00872273 /* SDL_uikitwindow.h in Headers */,
 				A769B12B23E259AE00872273 /* vulkan_vi.h in Headers */,
-				A769B12C23E259AE00872273 /* vulkan_mir.h in Headers */,
 				A769B12E23E259AE00872273 /* default_cursor.h in Headers */,
 				A769B12F23E259AE00872273 /* SDL_render_sw_c.h in Headers */,
 				A769B13223E259AE00872273 /* SDL_nullvideo.h in Headers */,
@@ -6387,13 +6359,11 @@
 				A7D8B26723E2514200DCD162 /* vk_platform.h in Headers */,
 				A7D8B2AF23E2514200DCD162 /* vk_sdk_platform.h in Headers */,
 				A7D8B26123E2514200DCD162 /* vulkan.h in Headers */,
-				A7D8B26D23E2514200DCD162 /* vulkan.hpp in Headers */,
 				A7D8B2B523E2514200DCD162 /* vulkan_android.h in Headers */,
 				A7D8B2A923E2514200DCD162 /* vulkan_core.h in Headers */,
 				A7D8B27323E2514200DCD162 /* vulkan_fuchsia.h in Headers */,
 				A7D8B2A323E2514200DCD162 /* vulkan_ios.h in Headers */,
 				A7D8B28523E2514200DCD162 /* vulkan_macos.h in Headers */,
-				A7D8B29723E2514200DCD162 /* vulkan_mir.h in Headers */,
 				A7D8B25B23E2514200DCD162 /* vulkan_vi.h in Headers */,
 				A7D8B27923E2514200DCD162 /* vulkan_wayland.h in Headers */,
 				A7D8B27F23E2514200DCD162 /* vulkan_win32.h in Headers */,
@@ -6629,13 +6599,11 @@
 				A7D8B26823E2514200DCD162 /* vk_platform.h in Headers */,
 				A7D8B2B023E2514200DCD162 /* vk_sdk_platform.h in Headers */,
 				A7D8B26223E2514200DCD162 /* vulkan.h in Headers */,
-				A7D8B26E23E2514200DCD162 /* vulkan.hpp in Headers */,
 				A7D8B2B623E2514200DCD162 /* vulkan_android.h in Headers */,
 				A7D8B2AA23E2514200DCD162 /* vulkan_core.h in Headers */,
 				A7D8B27423E2514200DCD162 /* vulkan_fuchsia.h in Headers */,
 				A7D8B2A423E2514200DCD162 /* vulkan_ios.h in Headers */,
 				A7D8B28623E2514200DCD162 /* vulkan_macos.h in Headers */,
-				A7D8B29823E2514200DCD162 /* vulkan_mir.h in Headers */,
 				A7D8B25C23E2514200DCD162 /* vulkan_vi.h in Headers */,
 				A7D8B27A23E2514200DCD162 /* vulkan_wayland.h in Headers */,
 				A7D8B28023E2514200DCD162 /* vulkan_win32.h in Headers */,
@@ -6704,7 +6672,6 @@
 				A7D8AE9223E2514100DCD162 /* SDL_cocoakeyboard.h in Headers */,
 				5616CA5A252BB35D005D5928 /* SDL_sysurl.h in Headers */,
 				A7D8ACE523E2514100DCD162 /* SDL_uikitvulkan.h in Headers */,
-				A7D8B27023E2514200DCD162 /* vulkan.hpp in Headers */,
 				A7D8B22823E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8BB7323E2514500DCD162 /* SDL_clipboardevents_c.h in Headers */,
 				A7D8AAE423E2514100DCD162 /* SDL_syshaptic_c.h in Headers */,
@@ -6775,7 +6742,6 @@
 				F386F6F42884663E001840AA /* SDL_utils_c.h in Headers */,
 				A7D8AC9D23E2514100DCD162 /* SDL_uikitwindow.h in Headers */,
 				A7D8B25E23E2514200DCD162 /* vulkan_vi.h in Headers */,
-				A7D8B29A23E2514200DCD162 /* vulkan_mir.h in Headers */,
 				A7D8BB4F23E2514500DCD162 /* default_cursor.h in Headers */,
 				A7D8B9FF23E2514400DCD162 /* SDL_render_sw_c.h in Headers */,
 				A7D8ABFB23E2514100DCD162 /* SDL_nullvideo.h in Headers */,
@@ -7048,13 +7014,11 @@
 				A7D8B26623E2514200DCD162 /* vk_platform.h in Headers */,
 				A7D8B2AE23E2514200DCD162 /* vk_sdk_platform.h in Headers */,
 				A7D8B26023E2514200DCD162 /* vulkan.h in Headers */,
-				A7D8B26C23E2514200DCD162 /* vulkan.hpp in Headers */,
 				A7D8B2B423E2514200DCD162 /* vulkan_android.h in Headers */,
 				A7D8B2A823E2514200DCD162 /* vulkan_core.h in Headers */,
 				A7D8B27223E2514200DCD162 /* vulkan_fuchsia.h in Headers */,
 				A7D8B2A223E2514200DCD162 /* vulkan_ios.h in Headers */,
 				A7D8B28423E2514200DCD162 /* vulkan_macos.h in Headers */,
-				A7D8B29623E2514200DCD162 /* vulkan_mir.h in Headers */,
 				A7D8B25A23E2514200DCD162 /* vulkan_vi.h in Headers */,
 				A7D8B27823E2514200DCD162 /* vulkan_wayland.h in Headers */,
 				A7D8B27E23E2514200DCD162 /* vulkan_win32.h in Headers */,
@@ -7118,7 +7082,6 @@
 				A7D8BA7623E2514400DCD162 /* SDL_shaders_gl.h in Headers */,
 				A7D8B42B23E2514300DCD162 /* SDL_systhread_c.h in Headers */,
 				A7D8AE9123E2514100DCD162 /* SDL_cocoakeyboard.h in Headers */,
-				A7D8B26F23E2514200DCD162 /* vulkan.hpp in Headers */,
 				A7D8B22723E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8BB7223E2514500DCD162 /* SDL_clipboardevents_c.h in Headers */,
 				A7D8AAE323E2514100DCD162 /* SDL_syshaptic_c.h in Headers */,
@@ -7189,7 +7152,6 @@
 				A7D8B29F23E2514200DCD162 /* vulkan_xlib.h in Headers */,
 				A7D8B25D23E2514200DCD162 /* vulkan_vi.h in Headers */,
 				F316AB882B5A02C3002EF551 /* yuv_rgb_common.h in Headers */,
-				A7D8B29923E2514200DCD162 /* vulkan_mir.h in Headers */,
 				A1BB8B6F27F6CF330057CFA8 /* SDL_list.h in Headers */,
 				A7D8BB4E23E2514500DCD162 /* default_cursor.h in Headers */,
 				A7D8B9FE23E2514400DCD162 /* SDL_render_sw_c.h in Headers */,
@@ -7325,7 +7287,6 @@
 				DB313FDB17554B71006C0E22 /* SDL_keycode.h in Headers */,
 				A7D8AE9323E2514100DCD162 /* SDL_cocoakeyboard.h in Headers */,
 				A7D8ACE623E2514100DCD162 /* SDL_uikitvulkan.h in Headers */,
-				A7D8B27123E2514200DCD162 /* vulkan.hpp in Headers */,
 				DB313FDC17554B71006C0E22 /* SDL_loadso.h in Headers */,
 				A7D8B22923E2514200DCD162 /* gl2ext.h in Headers */,
 				A7D8BB7423E2514500DCD162 /* SDL_clipboardevents_c.h in Headers */,
@@ -7409,7 +7370,6 @@
 				A7D8B2A123E2514200DCD162 /* vulkan_xlib.h in Headers */,
 				A7D8AC9E23E2514100DCD162 /* SDL_uikitwindow.h in Headers */,
 				A7D8B25F23E2514200DCD162 /* vulkan_vi.h in Headers */,
-				A7D8B29B23E2514200DCD162 /* vulkan_mir.h in Headers */,
 				DB313FE817554B71006C0E22 /* SDL_quit.h in Headers */,
 				A7D8BB5023E2514500DCD162 /* default_cursor.h in Headers */,
 				A7D8BA0023E2514400DCD162 /* SDL_render_sw_c.h in Headers */,
@@ -9769,7 +9729,7 @@
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEPLOYMENT_POSTPROCESSING = YES;
 				DYLIB_COMPATIBILITY_VERSION = 3001.0.0;
-				DYLIB_CURRENT_VERSION = 3001.1.0;
+				DYLIB_CURRENT_VERSION = 3001.10.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				GCC_ALTIVEC_EXTENSIONS = YES;
@@ -9810,7 +9770,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CLANG_LINK_OBJC_RUNTIME = NO;
-				MARKETING_VERSION = 2.30.1;
+				MARKETING_VERSION = 2.30.10;
 				OTHER_LDFLAGS = "-liconv";
 			};
 			name = Release;
@@ -9854,7 +9814,7 @@
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DYLIB_COMPATIBILITY_VERSION = 3001.0.0;
-				DYLIB_CURRENT_VERSION = 3001.1.0;
+				DYLIB_CURRENT_VERSION = 3001.10.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
@@ -9896,7 +9856,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				CLANG_LINK_OBJC_RUNTIME = NO;
-				MARKETING_VERSION = 2.30.1;
+				MARKETING_VERSION = 2.30.10;
 				OTHER_LDFLAGS = "-liconv";
 			};
 			name = Debug;
@@ -10103,7 +10063,7 @@
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = "";
 				DYLIB_COMPATIBILITY_VERSION = 3001.0.0;
-				DYLIB_CURRENT_VERSION = 3001.1.0;
+				DYLIB_CURRENT_VERSION = 3001.10.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_DYNAMIC_NO_PIC = NO;
@@ -10155,7 +10115,7 @@
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = "";
 				DYLIB_COMPATIBILITY_VERSION = 3001.0.0;
-				DYLIB_CURRENT_VERSION = 3001.1.0;
+				DYLIB_CURRENT_VERSION = 3001.10.0;
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_NS_ASSERTIONS = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu11;

Xcode/SDL/pkg-support/SDL.info

@@ -1,4 +1,4 @@
-Title SDL 2.30.1
+Title SDL 2.30.10
 Version 1
 Description SDL Library for Mac OS X (http://www.libsdl.org)
 DefaultLocation /Library/Frameworks

android-project/app/src/main/AndroidManifest.xml

@@ -62,7 +62,7 @@
     <application android:label="@string/app_name"
         android:icon="@mipmap/ic_launcher"
         android:allowBackup="true"
-        android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
+        android:theme="@style/AppTheme"
         android:hardwareAccelerated="true" >
 
         <!-- Example of setting SDL hints from AndroidManifest.xml:

android-project/app/src/main/java/org/libsdl/app/HIDDeviceManager.java

@@ -277,6 +277,7 @@ public class HIDDeviceManager {
             0x044f, // Thrustmaster
             0x045e, // Microsoft
             0x0738, // Mad Catz
+            0x0b05, // ASUS
             0x0e6f, // PDP
             0x0f0d, // Hori
             0x10f5, // Turtle Beach
@@ -590,7 +591,13 @@ public class HIDDeviceManager {
                 } else {
                     flags = 0;
                 }
-                mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, new Intent(HIDDeviceManager.ACTION_USB_PERMISSION), flags));
+                if (Build.VERSION.SDK_INT >= 33 /* Android 14.0 (U) */) {
+                   Intent intent = new Intent(HIDDeviceManager.ACTION_USB_PERMISSION);
+                   intent.setPackage(mContext.getPackageName());
+                   mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, intent, flags));
+               } else {
+                   mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, new Intent(HIDDeviceManager.ACTION_USB_PERMISSION), flags));
+               }
             } catch (Exception e) {
                 Log.v(TAG, "Couldn't request permission for USB device " + usbDevice);
                 HIDDeviceOpenResult(deviceID, false);

android-project/app/src/main/java/org/libsdl/app/SDL.java

@@ -38,6 +38,10 @@ public class SDL {
     }
 
     public static void loadLibrary(String libraryName) throws UnsatisfiedLinkError, SecurityException, NullPointerException {
+        loadLibrary(libraryName, mContext);
+    }
+
+    public static void loadLibrary(String libraryName, Context context) throws UnsatisfiedLinkError, SecurityException, NullPointerException {
 
         if (libraryName == null) {
             throw new NullPointerException("No library name provided.");
@@ -53,10 +57,10 @@ public class SDL {
             // To use ReLinker, just add it as a dependency.  For more information, see 
             // https://github.com/KeepSafe/ReLinker for ReLinker's repository.
             //
-            Class<?> relinkClass = mContext.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker");
-            Class<?> relinkListenerClass = mContext.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker$LoadListener");
-            Class<?> contextClass = mContext.getClassLoader().loadClass("android.content.Context");
-            Class<?> stringClass = mContext.getClassLoader().loadClass("java.lang.String");
+            Class<?> relinkClass = context.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker");
+            Class<?> relinkListenerClass = context.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker$LoadListener");
+            Class<?> contextClass = context.getClassLoader().loadClass("android.content.Context");
+            Class<?> stringClass = context.getClassLoader().loadClass("java.lang.String");
 
             // Get a 'force' instance of the ReLinker, so we can ensure libraries are reinstalled if 
             // they've changed during updates.
@@ -66,7 +70,7 @@ public class SDL {
 
             // Actually load the library!
             Method loadMethod = relinkInstanceClass.getDeclaredMethod("loadLibrary", contextClass, stringClass, stringClass, relinkListenerClass);
-            loadMethod.invoke(relinkInstance, mContext, libraryName, null, null);
+            loadMethod.invoke(relinkInstance, context, libraryName, null, null);
         }
         catch (final Throwable e) {
             // Fall back

android-project/app/src/main/java/org/libsdl/app/SDLActivity.java

@@ -61,7 +61,7 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
     private static final String TAG = "SDL";
     private static final int SDL_MAJOR_VERSION = 2;
     private static final int SDL_MINOR_VERSION = 30;
-    private static final int SDL_MICRO_VERSION = 1;
+    private static final int SDL_MICRO_VERSION = 10;
 /*
     // Display InputType.SOURCE/CLASS of events and devices
     //
@@ -89,7 +89,7 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
                 | InputDevice.SOURCE_CLASS_POSITION
                 | InputDevice.SOURCE_CLASS_TRACKBALL);
 
-        if (s2 != 0) cls += "Some_Unkown";
+        if (s2 != 0) cls += "Some_Unknown";
 
         s2 = s_copy & InputDevice.SOURCE_ANY; // keep source only, no class;
 
@@ -163,7 +163,7 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
         if (s == FLAG_TAINTED) src += " FLAG_TAINTED";
         s2 &= ~FLAG_TAINTED;
 
-        if (s2 != 0) src += " Some_Unkown";
+        if (s2 != 0) src += " Some_Unknown";
 
         Log.v(TAG, prefix + "int=" + s_copy + " CLASS={" + cls + " } source(s):" + src);
     }
@@ -281,7 +281,7 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
     // Load the .so
     public void loadLibraries() {
        for (String lib : getLibraries()) {
-          SDL.loadLibrary(lib);
+          SDL.loadLibrary(lib, this);
        }
     }
 
@@ -995,8 +995,8 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
         /* No valid hint, nothing is explicitly allowed */
         if (!is_portrait_allowed && !is_landscape_allowed) {
             if (resizable) {
-                /* All orientations are allowed */
-                req = ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR;
+                /* All orientations are allowed, respecting user orientation lock setting */
+                req = ActivityInfo.SCREEN_ORIENTATION_FULL_USER;
             } else {
                 /* Fixed window and nothing specified. Get orientation from w/h of created window */
                 req = (w > h ? ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE : ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
@@ -1005,8 +1005,8 @@ public class SDLActivity extends Activity implements View.OnSystemUiVisibilityCh
             /* At least one orientation is allowed */
             if (resizable) {
                 if (is_portrait_allowed && is_landscape_allowed) {
-                    /* hint allows both landscape and portrait, promote to full sensor */
-                    req = ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR;
+                    /* hint allows both landscape and portrait, promote to full user */
+                    req = ActivityInfo.SCREEN_ORIENTATION_FULL_USER;
                 } else {
                     /* Use the only one allowed "orientation" */
                     req = (is_landscape_allowed ? orientation_landscape : orientation_portrait);

android-project/app/src/main/java/org/libsdl/app/SDLControllerManager.java

@@ -546,13 +546,15 @@ class SDLHapticHandler {
             if (haptic == null) {
                 InputDevice device = InputDevice.getDevice(deviceIds[i]);
                 Vibrator vib = device.getVibrator();
-                if (vib.hasVibrator()) {
-                    haptic = new SDLHaptic();
-                    haptic.device_id = deviceIds[i];
-                    haptic.name = device.getName();
-                    haptic.vib = vib;
-                    mHaptics.add(haptic);
-                    SDLControllerManager.nativeAddHaptic(haptic.device_id, haptic.name);
+                if (vib != null) {
+                    if (vib.hasVibrator()) {
+                        haptic = new SDLHaptic();
+                        haptic.device_id = deviceIds[i];
+                        haptic.name = device.getName();
+                        haptic.vib = vib;
+                        mHaptics.add(haptic);
+                        SDLControllerManager.nativeAddHaptic(haptic.device_id, haptic.name);
+                    }
                 }
             }
         }

android-project/app/src/main/res/values/styles.xml

@@ -1,8 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
 <resources>
-
     <!-- Base application theme. -->
-    <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar">
+    <style name="AppTheme" parent="android:Theme.NoTitleBar.Fullscreen">
         <!-- Customize your theme here. -->
     </style>
-
 </resources>

build-scripts/cmake-toolchain-mingw64-i686.cmake

@@ -0,0 +1,18 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR x86)
+
+find_program(CMAKE_C_COMPILER NAMES i686-w64-mingw32-gcc)
+find_program(CMAKE_CXX_COMPILER NAMES i686-w64-mingw32-g++)
+find_program(CMAKE_RC_COMPILER NAMES i686-w64-mingw32-windres windres)
+
+if(NOT CMAKE_C_COMPILER)
+	message(FATAL_ERROR "Failed to find CMAKE_C_COMPILER.")
+endif()
+
+if(NOT CMAKE_CXX_COMPILER)
+	message(FATAL_ERROR "Failed to find CMAKE_CXX_COMPILER.")
+endif()
+
+if(NOT CMAKE_RC_COMPILER)
+        message(FATAL_ERROR "Failed to find CMAKE_RC_COMPILER.")
+endif()

build-scripts/cmake-toolchain-mingw64-x86_64.cmake

@@ -0,0 +1,18 @@
+set(CMAKE_SYSTEM_NAME Windows)
+set(CMAKE_SYSTEM_PROCESSOR x86_64)
+
+find_program(CMAKE_C_COMPILER NAMES x86_64-w64-mingw32-gcc)
+find_program(CMAKE_CXX_COMPILER NAMES x86_64-w64-mingw32-g++)
+find_program(CMAKE_RC_COMPILER NAMES x86_64-w64-mingw32-windres windres)
+
+if(NOT CMAKE_C_COMPILER)
+	message(FATAL_ERROR "Failed to find CMAKE_C_COMPILER.")
+endif()
+
+if(NOT CMAKE_CXX_COMPILER)
+	message(FATAL_ERROR "Failed to find CMAKE_CXX_COMPILER.")
+endif()
+
+if(NOT CMAKE_RC_COMPILER)
+        message(FATAL_ERROR "Failed to find CMAKE_RC_COMPILER.")
+endif()

build-scripts/create-release.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+import argparse
+from pathlib import Path
+import json
+import logging
+import re
+import subprocess
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def determine_remote() -> str:
+    text = (ROOT / "build-scripts/release-info.json").read_text()
+    release_info = json.loads(text)
+    if "remote" in release_info:
+        return release_info["remote"]
+    project_with_version = release_info["name"]
+    project, _ = re.subn("([^a-zA-Z_])", "", project_with_version)
+    return f"libsdl-org/{project}"
+
+
+def main():
+    default_remote = determine_remote()
+
+    current_commit = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=ROOT, text=True).strip()
+
+    parser = argparse.ArgumentParser(allow_abbrev=False)
+    parser.add_argument("--ref", required=True, help=f"Name of branch or tag containing release.yml")
+    parser.add_argument("--remote", "-R", default=default_remote, help=f"Remote repo (default={default_remote})")
+    parser.add_argument("--commit", default=current_commit, help=f"Commit (default={current_commit})")
+    args = parser.parse_args()
+
+
+    print(f"Running release.yml workflow:")
+    print(f"  commit = {args.commit}")
+    print(f"  remote = {args.remote}")
+
+    subprocess.check_call(["gh", "-R", args.remote, "workflow", "run", "release.yml", "--ref", args.ref, "-f", f"commit={args.commit}"], cwd=ROOT)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

build-scripts/release-info.json

@@ -0,0 +1,108 @@
+{
+  "name": "SDL2",
+  "remote": "libsdl-org/SDL",
+  "version": {
+    "file": "include/SDL_version.h",
+    "re_major": "^#define SDL_MAJOR_VERSION\\s+([0-9]+)$",
+    "re_minor": "^#define SDL_MINOR_VERSION\\s+([0-9]+)$",
+    "re_micro": "^#define SDL_PATCHLEVEL\\s+([0-9]+)$"
+  },
+  "source": {
+    "checks": [
+      "src/SDL.c",
+      "include/SDL.h",
+      "test/testsprite2.c",
+      "android-project/app/src/main/java/org/libsdl/app/SDLActivity.java"
+    ]
+  },
+  "dmg": {
+    "project": "Xcode/SDL/SDL.xcodeproj",
+    "path": "Xcode/SDL/build/SDL2.dmg",
+    "target": "Standard DMG"
+  },
+  "mingw": {
+    "autotools": {
+      "archs": ["x86", "x64"],
+      "args": [
+      ],
+      "files": {
+        "@<@TRIPLET@>@/include/SDL2": [
+          "include/SDL_config*.h"
+        ]
+      }
+    },
+    "files": {
+      "": [
+        "mingw/pkg-support/INSTALL.txt",
+        "mingw/pkg-support/Makefile",
+        "BUGS.txt",
+        "CREDITS.txt",
+        "README-SDL.txt",
+        "WhatsNew.txt",
+        "LICENSE.txt",
+        "README.md"
+      ],
+      "cmake": [
+        "mingw/pkg-support/cmake/sdl2-config.cmake",
+        "mingw/pkg-support/cmake/sdl2-config-version.cmake"
+      ],
+      "docs": [
+        "docs/*"
+      ],
+      "test": [
+        "test/*"
+      ]
+    }
+  },
+  "msvc": {
+    "msbuild": {
+      "archs": [
+        "x86",
+        "x64"
+      ],
+      "projects": [
+        "VisualC/SDL/SDL.vcxproj",
+        "VisualC/SDLmain/SDLmain.vcxproj",
+        "VisualC/SDLtest/SDLtest.vcxproj"
+      ],
+      "files-lib": {
+        "": [
+          "VisualC/SDL/@<@PLATFORM@>@/@<@CONFIGURATION@>@/SDL2.dll"
+        ]
+      },
+      "files-devel": {
+        "lib/@<@ARCH@>@": [
+          "VisualC/SDL/@<@PLATFORM@>@/@<@CONFIGURATION@>@/SDL2.dll",
+          "VisualC/SDL/@<@PLATFORM@>@/@<@CONFIGURATION@>@/SDL2.lib",
+          "VisualC/SDL/@<@PLATFORM@>@/@<@CONFIGURATION@>@/SDL2.pdb",
+          "VisualC/SDLmain/@<@PLATFORM@>@/@<@CONFIGURATION@>@/SDL2main.lib",
+          "VisualC/SDLtest/@<@PLATFORM@>@/@<@CONFIGURATION@>@/SDL2test.lib"
+        ]
+      }
+    },
+    "files-lib": {
+      "": [
+        "README-SDL.txt"
+      ]
+    },
+    "files-devel": {
+      "": [
+        "README-SDL.txt",
+        "BUGS.txt",
+        "LICENSE.txt",
+        "README.md",
+        "WhatsNew.txt"
+      ],
+      "cmake": [
+        "VisualC/pkg-support/cmake/sdl2-config.cmake",
+        "VisualC/pkg-support/cmake/sdl2-config-version.cmake"
+      ],
+      "docs": [
+        "docs/*"
+      ],
+      "include": [
+        "include/*.h"
+      ]
+    }
+  }
+}

build-scripts/setup-gdk-desktop.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python
+
+import argparse
+import functools
+import logging
+import os
+from pathlib import Path
+import re
+import shutil
+import subprocess
+import tempfile
+import textwrap
+import urllib.request
+import zipfile
+
+# Update both variables when updating the GDK
+GIT_REF = "June_2024_Update_1"
+GDK_EDITION = "240601"  # YYMMUU
+
+logger = logging.getLogger(__name__)
+
+class GdDesktopConfigurator:
+    def __init__(self, gdk_path, arch, vs_folder, vs_version=None, vs_toolset=None, temp_folder=None, git_ref=None, gdk_edition=None):
+        self.git_ref = git_ref or GIT_REF
+        self.gdk_edition = gdk_edition or GDK_EDITION
+        self.gdk_path = gdk_path
+        self.temp_folder = temp_folder or Path(tempfile.gettempdir())
+        self.dl_archive_path = Path(self.temp_folder) / f"{ self.git_ref }.zip"
+        self.gdk_extract_path = Path(self.temp_folder) / f"GDK-{ self.git_ref }"
+        self.arch = arch
+        self.vs_folder = vs_folder
+        self._vs_version = vs_version
+        self._vs_toolset = vs_toolset
+
+    def download_archive(self) -> None:
+        gdk_url = f"https://github.com/microsoft/GDK/archive/refs/tags/{ GIT_REF }.zip"
+        logger.info("Downloading %s to %s", gdk_url, self.dl_archive_path)
+        urllib.request.urlretrieve(gdk_url, self.dl_archive_path)
+        assert self.dl_archive_path.is_file()
+
+    def extract_zip_archive(self) -> None:
+        extract_path = self.gdk_extract_path.parent
+        assert self.dl_archive_path.is_file()
+        logger.info("Extracting %s to %s", self.dl_archive_path, extract_path)
+        with zipfile.ZipFile(self.dl_archive_path) as zf:
+            zf.extractall(extract_path)
+        assert self.gdk_extract_path.is_dir(), f"{self.gdk_extract_path} must exist"
+
+    def extract_development_kit(self) -> None:
+        extract_dks_cmd = self.gdk_extract_path / "SetupScripts/ExtractXboxOneDKs.cmd"
+        assert extract_dks_cmd.is_file()
+        logger.info("Extracting GDK Development Kit: running %s", extract_dks_cmd)
+        cmd = ["cmd.exe", "/C", str(extract_dks_cmd), str(self.gdk_extract_path), str(self.gdk_path)]
+        logger.debug("Running %r", cmd)
+        subprocess.check_call(cmd)
+
+    def detect_vs_version(self) -> str:
+        vs_regex = re.compile("VS([0-9]{4})")
+        supported_vs_versions = []
+        for p in self.gaming_grdk_build_path.iterdir():
+            if not p.is_dir():
+                continue
+            if m := vs_regex.match(p.name):
+                supported_vs_versions.append(m.group(1))
+        logger.info(f"Supported Visual Studio versions: {supported_vs_versions}")
+        vs_versions = set(self.vs_folder.parts).intersection(set(supported_vs_versions))
+        if not vs_versions:
+            raise RuntimeError("Visual Studio version is incompatible")
+        if len(vs_versions) > 1:
+            raise RuntimeError(f"Too many compatible VS versions found ({vs_versions})")
+        vs_version = vs_versions.pop()
+        logger.info(f"Used Visual Studio version: {vs_version}")
+        return vs_version
+
+    def detect_vs_toolset(self) -> str:
+        toolset_paths = []
+        for ts_path in self.gdk_toolset_parent_path.iterdir():
+            if not ts_path.is_dir():
+                continue
+            ms_props = ts_path / "Microsoft.Cpp.props"
+            if not ms_props.is_file():
+                continue
+            toolset_paths.append(ts_path.name)
+        logger.info("Detected Visual Studio toolsets: %s", toolset_paths)
+        assert toolset_paths, "Have we detected at least one toolset?"
+
+        def toolset_number(toolset: str) -> int:
+            if m:= re.match("[^0-9]*([0-9]+).*", toolset):
+                return int(m.group(1))
+            return -9
+
+        return max(toolset_paths, key=toolset_number)
+
+    @property
+    def vs_version(self) -> str:
+        if self._vs_version is None:
+            self._vs_version = self.detect_vs_version()
+        return self._vs_version
+
+    @property
+    def vs_toolset(self) -> str:
+        if self._vs_toolset is None:
+            self._vs_toolset = self.detect_vs_toolset()
+        return self._vs_toolset
+
+    @staticmethod
+    def copy_files_and_merge_into(srcdir: Path, dstdir: Path) -> None:
+        logger.info(f"Copy {srcdir} to {dstdir}")
+        for root, _, files in os.walk(srcdir):
+            dest_root = dstdir / Path(root).relative_to(srcdir)
+            if not dest_root.is_dir():
+                dest_root.mkdir()
+            for file in files:
+                srcfile = Path(root) / file
+                dstfile = dest_root / file
+                shutil.copy(srcfile, dstfile)
+
+    def copy_msbuild(self) -> None:
+        vc_toolset_parent_path = self.vs_folder / "MSBuild/Microsoft/VC"
+        if 1:
+            logger.info(f"Detected compatible Visual Studio version: {self.vs_version}")
+            srcdir = vc_toolset_parent_path
+            dstdir = self.gdk_toolset_parent_path
+            assert srcdir.is_dir(), "Source directory must exist"
+            assert dstdir.is_dir(), "Destination directory must exist"
+
+            self.copy_files_and_merge_into(srcdir=srcdir, dstdir=dstdir)
+
+    @property
+    def game_dk_path(self) -> Path:
+        return self.gdk_path / "Microsoft GDK"
+
+    @property
+    def game_dk_latest_path(self) -> Path:
+        return self.game_dk_path / self.gdk_edition
+
+    @property
+    def windows_sdk_path(self) -> Path:
+        return self.gdk_path / "Windows Kits/10"
+
+    @property
+    def gaming_grdk_build_path(self) -> Path:
+        return self.game_dk_latest_path / "GRDK"
+
+    @property
+    def gdk_toolset_parent_path(self) -> Path:
+        return self.gaming_grdk_build_path / f"VS{self.vs_version}/flatDeployment/MSBuild/Microsoft/VC"
+
+    @property
+    def env(self) -> dict[str, str]:
+        game_dk = self.game_dk_path
+        game_dk_latest = self.game_dk_latest_path
+        windows_sdk_dir = self.windows_sdk_path
+        gaming_grdk_build = self.gaming_grdk_build_path
+
+        return {
+            "GRDKEDITION": f"{self.gdk_edition}",
+            "GameDK": f"{game_dk}\\",
+            "GameDKLatest": f"{ game_dk_latest }\\",
+            "WindowsSdkDir": f"{ windows_sdk_dir }\\",
+            "GamingGRDKBuild": f"{ gaming_grdk_build }\\",
+            "VSInstallDir": f"{ self.vs_folder }\\",
+        }
+
+    def create_user_props(self, path: Path) -> None:
+        vc_targets_path = self.gaming_grdk_build_path / f"VS{ self.vs_version }/flatDeployment/MSBuild/Microsoft/VC/{ self.vs_toolset }"
+        vc_targets_path16 = self.gaming_grdk_build_path / f"VS2019/flatDeployment/MSBuild/Microsoft/VC/{ self.vs_toolset }"
+        vc_targets_path17 = self.gaming_grdk_build_path / f"VS2022/flatDeployment/MSBuild/Microsoft/VC/{ self.vs_toolset }"
+        additional_include_directories = ";".join(str(p) for p in self.gdk_include_paths)
+        additional_library_directories = ";".join(str(p) for p in self.gdk_library_paths)
+        durango_xdk_install_path = self.gdk_path / "Microsoft GDK"
+        with path.open("w") as f:
+            f.write(textwrap.dedent(f"""\
+                <?xml version="1.0" encoding="utf-8"?>
+                <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+                  <PropertyGroup>
+                    <VCTargetsPath>{ vc_targets_path }\\</VCTargetsPath>
+                    <VCTargetsPath16>{ vc_targets_path16 }\\</VCTargetsPath16>
+                    <VCTargetsPath17>{ vc_targets_path17 }\\</VCTargetsPath17>
+                    <BWOI_GDK_Path>{ self.gaming_grdk_build_path }\\</BWOI_GDK_Path>
+                    <Platform Condition="'$(Platform)' == ''">Gaming.Desktop.x64</Platform>
+                    <Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>
+                    <XdkEditionTarget>{ self.gdk_edition }</XdkEditionTarget>
+                    <DurangoXdkInstallPath>{ durango_xdk_install_path }</DurangoXdkInstallPath>
+
+                    <DefaultXdkEditionRootVS2019>$(DurangoXdkInstallPath)\\{self.gdk_edition}\\GRDK\\VS2019\\flatDeployment\\MSBuild\\Microsoft\\VC\\{self.vs_toolset}\\Platforms\\$(Platform)\\</DefaultXdkEditionRootVS2019>
+                    <XdkEditionRootVS2019>$(DurangoXdkInstallPath)\\{self.gdk_edition}\\GRDK\\VS2019\\flatDeployment\\MSBuild\\Microsoft\\VC\\{self.vs_toolset}\\Platforms\\$(Platform)\\</XdkEditionRootVS2019>
+                    <DefaultXdkEditionRootVS2022>$(DurangoXdkInstallPath)\\{self.gdk_edition}\\GRDK\\VS2022\\flatDeployment\\MSBuild\\Microsoft\\VC\\{self.vs_toolset}\\Platforms\\$(Platform)\\</DefaultXdkEditionRootVS2022>
+                    <XdkEditionRootVS2022>$(DurangoXdkInstallPath)\\{self.gdk_edition}\\GRDK\\VS2022\\flatDeployment\\MSBuild\\Microsoft\\VC\\{self.vs_toolset}\\Platforms\\$(Platform)\\</XdkEditionRootVS2022>
+
+                    <Deterministic>true</Deterministic>
+                    <DisableInstalledVCTargetsUse>true</DisableInstalledVCTargetsUse>
+                    <ClearDevCommandPromptEnvVars>true</ClearDevCommandPromptEnvVars>
+                  </PropertyGroup>
+                  <ItemDefinitionGroup Condition="'$(Platform)' == 'Gaming.Desktop.x64'">
+                    <ClCompile>
+                      <AdditionalIncludeDirectories>{ additional_include_directories };%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+                    </ClCompile>
+                    <Link>
+                      <AdditionalLibraryDirectories>{ additional_library_directories };%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+                    </Link>
+                  </ItemDefinitionGroup>
+                </Project>
+            """))
+
+    @property
+    def gdk_include_paths(self) -> list[Path]:
+        return [
+            self.gaming_grdk_build_path / "gamekit/include",
+        ]
+
+    @property
+    def gdk_library_paths(self) -> list[Path]:
+        return [
+            self.gaming_grdk_build_path / f"gamekit/lib/{self.arch}",
+        ]
+
+    @property
+    def gdk_binary_path(self) -> list[Path]:
+        return [
+            self.gaming_grdk_build_path / "bin",
+            self.game_dk_path / "bin",
+        ]
+
+    @property
+    def build_env(self) -> dict[str, str]:
+        gdk_include = ";".join(str(p) for p in self.gdk_include_paths)
+        gdk_lib = ";".join(str(p) for p in self.gdk_library_paths)
+        gdk_path = ";".join(str(p) for p in self.gdk_binary_path)
+        return {
+            "GDK_INCLUDE": gdk_include,
+            "GDK_LIB": gdk_lib,
+            "GDK_PATH": gdk_path,
+        }
+
+    def print_env(self) -> None:
+        for k, v in self.env.items():
+            print(f"set \"{k}={v}\"")
+        print()
+        for k, v in self.build_env.items():
+            print(f"set \"{k}={v}\"")
+        print()
+        print(f"set \"PATH=%GDK_PATH%;%PATH%\"")
+        print(f"set \"LIB=%GDK_LIB%;%LIB%\"")
+        print(f"set \"INCLUDE=%GDK_INCLUDE%;%INCLUDE%\"")
+
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+    parser = argparse.ArgumentParser(allow_abbrev=False)
+    parser.add_argument("--arch", choices=["amd64"], default="amd64", help="Architecture")
+    parser.add_argument("--download", action="store_true", help="Download GDK")
+    parser.add_argument("--extract", action="store_true", help="Extract downloaded GDK")
+    parser.add_argument("--copy-msbuild", action="store_true", help="Copy MSBuild files")
+    parser.add_argument("--temp-folder", help="Temporary folder where to download and extract GDK")
+    parser.add_argument("--gdk-path", required=True, type=Path, help="Folder where to store the GDK")
+    parser.add_argument("--ref-edition", type=str, help="Git ref and GDK edition separated by comma")
+    parser.add_argument("--vs-folder", required=True, type=Path, help="Installation folder of Visual Studio")
+    parser.add_argument("--vs-version", required=False, type=int, help="Visual Studio version")
+    parser.add_argument("--vs-toolset", required=False, help="Visual Studio toolset (e.g. v150)")
+    parser.add_argument("--props-folder", required=False, type=Path, default=Path(), help="Visual Studio toolset (e.g. v150)")
+    parser.add_argument("--no-user-props", required=False, dest="user_props", action="store_false", help="Don't ")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO)
+
+    git_ref = None
+    gdk_edition = None
+    if args.ref_edition is not None:
+        git_ref, gdk_edition = args.ref_edition.split(",", 1)
+        try:
+            int(gdk_edition)
+        except ValueError:
+            parser.error("Edition should be an integer (YYMMUU) (Y=year M=month U=update)")
+
+    configurator = GdDesktopConfigurator(
+        arch=args.arch,
+        git_ref=git_ref,
+        gdk_edition=gdk_edition,
+        vs_folder=args.vs_folder,
+        vs_version=args.vs_version,
+        vs_toolset=args.vs_toolset,
+        gdk_path=args.gdk_path,
+        temp_folder=args.temp_folder,
+    )
+
+    if args.download:
+        configurator.download_archive()
+
+    if args.extract:
+        configurator.extract_zip_archive()
+
+        configurator.extract_development_kit()
+
+    if args.copy_msbuild:
+        configurator.copy_msbuild()
+
+    if args.user_props:
+        configurator.print_env()
+        configurator.create_user_props(args.props_folder / "Directory.Build.props")
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cmake/sdlchecks.cmake

@@ -1352,12 +1352,13 @@ endmacro()
 
 macro(CheckLibUDev)
   if(SDL_LIBUDEV)
-    check_include_file("libudev.h" have_libudev_header)
-    if(have_libudev_header)
+    check_include_file("libudev.h" HAVE_LIBUDEV_HEADER)
+    if(HAVE_LIBUDEV_HEADER)
       set(HAVE_LIBUDEV_H TRUE)
       FindLibraryAndSONAME(udev)
       if(UDEV_LIB_SONAME)
         set(SDL_UDEV_DYNAMIC "\"${UDEV_LIB_SONAME}\"")
+        set(HAVE_LIBUDEV TRUE)
       endif()
     endif()
   endif()

cmake/test/CMakeLists.txt

@@ -27,6 +27,12 @@ add_feature_info("TEST_SHARED" TEST_SHARED "Test linking with shared library")
 option(TEST_STATIC "Test linking to static SDL2 library" ON)
 add_feature_info("TEST_STATIC" TEST_STATIC "Test linking with static library")
 
+option(TEST_TEST "Test linking to SDL3_test library" ON)
+add_feature_info("TEST_TEST" TEST_STATIC "Test linking to SDL test library")
+
+option(TEST_FULL "Run complete SDL test suite" OFF)
+add_feature_info("TEST_FULL" TEST_FULL "Build full SDL testsuite")
+
 if(TEST_SHARED)
     find_package(SDL2 REQUIRED CONFIG COMPONENTS SDL2)
     if(EMSCRIPTEN OR (WIN32 AND NOT WINDOWS_STORE))
@@ -75,6 +81,11 @@ if(TEST_SHARED)
     generate_export_header(sharedlib-shared-vars EXPORT_MACRO_NAME MYLIBRARY_EXPORT)
     target_compile_definitions(sharedlib-shared-vars PRIVATE "EXPORT_HEADER=\"${CMAKE_CURRENT_BINARY_DIR}/sharedlib-shared-vars_export.h\"")
     set_target_properties(sharedlib-shared-vars PROPERTIES C_VISIBILITY_PRESET "hidden")
+
+    if(TEST_TEST)
+        add_executable(sdltest-shared sdltest.c)
+        target_link_libraries(sdltest-shared PRIVATE SDL2::SDL2main SDL2::SDL2test SDL2::SDL2)
+    endif()
 endif()
 
 if(TEST_STATIC)
@@ -111,6 +122,21 @@ if(TEST_STATIC)
         target_link_libraries(cli-static-vars PRIVATE ${SDL2_STATIC_LIBRARIES})
         target_include_directories(cli-static-vars PRIVATE ${SDL2_INCLUDE_DIRS})
     endif()
+
+    if(CMAKE_Swift_COMPILER)
+        add_executable(swift-static main.swift)
+        target_include_directories(swift-static PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/swift")
+        target_link_libraries(swift-static PRIVATE SDL2::SDL2-static)
+    endif()
+endif()
+
+if(TEST_FULL)
+    enable_testing()
+    set(SDL_TESTS_TIMEOUT_MULTIPLIER "1" CACHE STRING "Test timeout multiplier")
+    set(SDL_TESTS_LINK_SHARED ${TEST_SHARED})
+
+    add_definitions(-DNO_BUILD_CONFIG)
+    add_subdirectory("${CMAKE_CURRENT_LIST_DIR}/../../test" SDL_test)
 endif()
 
 message(STATUS "SDL2_PREFIX:            ${SDL2_PREFIX}")

cmake/test/sdltest.c

@@ -0,0 +1,9 @@
+#include "SDL.h"
+#include "SDL_test.h"
+
+
+int main(int argc, char *argv[]) {
+    SDLTest_CommonState state;
+    SDLTest_CommonDefaultArgs(&state, argc, argv);
+    return 0;
+}

configure

@@ -873,7 +873,6 @@ enable_sse2
 enable_sse3
 enable_altivec
 enable_lsx
-enable_lasx
 enable_oss
 enable_alsa
 with_alsa_prefix
@@ -1669,13 +1668,12 @@ Optional Features:
   --enable-ssemath        Allow GCC to use SSE floating point math
                           [default=maybe]
   --enable-mmx            use MMX assembly routines [default=yes]
-  --enable-3dnow          use 3DNow! assembly routines [default=yes]
+  --enable-3dnow          use 3DNow! assembly routines [default=no]
   --enable-sse            use SSE assembly routines [default=yes]
   --enable-sse2           use SSE2 assembly routines [default=maybe]
   --enable-sse3           use SSE3 assembly routines [default=maybe]
   --enable-altivec        use Altivec assembly routines [default=yes]
   --enable-lsx            use LSX assembly routines [default=yes]
-  --enable-lasx           use LASX assembly routines [default=yes]
   --enable-oss            support the OSS audio API [default=maybe]
   --enable-alsa           support the ALSA audio API [default=yes]
   --disable-alsatest      Do not try to compile and run a test Alsa program
@@ -3510,7 +3508,7 @@ orig_CFLAGS="$CFLAGS"
 # See docs/release_checklist.md
 SDL_MAJOR_VERSION=2
 SDL_MINOR_VERSION=30
-SDL_MICRO_VERSION=1
+SDL_MICRO_VERSION=10
 SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
 
 SDL_BINARY_AGE=`expr $SDL_MINOR_VERSION \* 100 + $SDL_MICRO_VERSION`
@@ -18818,7 +18816,7 @@ fi
 
 enable_system_iconv_default=yes
 case "$host" in
-  *-*-cygwin*|*-*-mingw*)
+  *-*-cygwin*|*-*-mingw*|*-*-darwin*|*-ios-*)
     enable_system_iconv_default=no
     ;;
 esac
@@ -19749,6 +19747,18 @@ if test "x$ac_cv_func_poll" = xyes
 then :
   printf "%s\n" "#define HAVE_POLL 1" >>confdefs.h
 
+fi
+ac_fn_c_check_func "$LINENO" "memfd_create" "ac_cv_func_memfd_create"
+if test "x$ac_cv_func_memfd_create" = xyes
+then :
+  printf "%s\n" "#define HAVE_MEMFD_CREATE 1" >>confdefs.h
+
+fi
+ac_fn_c_check_func "$LINENO" "posix_fallocate" "ac_cv_func_posix_fallocate"
+if test "x$ac_cv_func_posix_fallocate" = xyes
+then :
+  printf "%s\n" "#define HAVE_POSIX_FALLOCATE 1" >>confdefs.h
+
 fi
 ac_fn_c_check_func "$LINENO" "_Exit" "ac_cv_func__Exit"
 if test "x$ac_cv_func__Exit" = xyes
@@ -20637,7 +20647,7 @@ if test ${enable_3dnow+y}
 then :
   enableval=$enable_3dnow;
 else $as_nop
-  enable_3dnow=yes
+  enable_3dnow=no
 fi
 
     if test x$enable_3dnow = xyes; then
@@ -21026,7 +21036,7 @@ printf "%s\n" "#define HAVE_ALTIVEC_H 1" >>confdefs.h
     fi
 fi
 
-    # Check whether --enable-lsx was given.
+# Check whether --enable-lsx was given.
 if test ${enable_lsx+y}
 then :
   enableval=$enable_lsx;
@@ -21034,20 +21044,20 @@ else $as_nop
   enable_lsx=yes
 fi
 
-    if test x$enable_lsx = xyes; then
-        save_CFLAGS="$CFLAGS"
-        have_gcc_lsx=no
-        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GCC -mlsx option" >&5
+if test x$enable_lsx = xyes; then
+    save_CFLAGS="$CFLAGS"
+    have_gcc_lsx=no
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GCC -mlsx option" >&5
 printf %s "checking for GCC -mlsx option... " >&6; }
-        lsx_CFLAGS="-mlsx"
-        CFLAGS="$save_CFLAGS $lsx_CFLAGS"
+    lsx_CFLAGS="-mlsx"
+    CFLAGS="$save_CFLAGS $lsx_CFLAGS"
 
-        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-        #ifndef __loongarch_sx
-        #error Assembler CPP flag not enabled
-        #endif
+    #ifndef __loongarch_sx
+    #error Assembler CPP flag not enabled
+    #endif
 
 int
 main (void)
@@ -21062,19 +21072,19 @@ then :
   have_gcc_lsx=yes
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_gcc_lsx" >&5
+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_gcc_lsx" >&5
 printf "%s\n" "$have_gcc_lsx" >&6; }
-        CFLAGS="$save_CFLAGS"
+    CFLAGS="$save_CFLAGS"
 
-        if test x$have_gcc_lsx = xyes; then
-            EXTRA_CFLAGS="$EXTRA_CFLAGS $lsx_CFLAGS"
-            SUMMARY_math="${SUMMARY_math} lsx"
-        fi
+    if test x$have_gcc_lsx = xyes; then
+       EXTRA_CFLAGS="$EXTRA_CFLAGS $lsx_CFLAGS"
+       SUMMARY_math="${SUMMARY_math} lsx"
     fi
+fi
 
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for lsxintrin.h" >&5
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for lsxintrin.h" >&5
 printf %s "checking for lsxintrin.h... " >&6; }
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 #include <lsxintrin.h>
 int
@@ -21092,88 +21102,14 @@ else $as_nop
   have_lsxintrin_h_hdr=no
 fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_lsxintrin_h_hdr" >&5
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_lsxintrin_h_hdr" >&5
 printf "%s\n" "$have_lsxintrin_h_hdr" >&6; }
-    if test x$have_lsxintrin_h_hdr = xyes; then
+if test x$have_lsxintrin_h_hdr = xyes; then
 
 printf "%s\n" "#define HAVE_LSXINTRIN_H 1" >>confdefs.h
 
-    fi
-
-    # Check whether --enable-lasx was given.
-if test ${enable_lasx+y}
-then :
-  enableval=$enable_lasx;
-else $as_nop
-  enable_LASX=yes
 fi
 
-    if test x$enable_LASX = xyes; then
-        save_CFLAGS="$CFLAGS"
-        have_gcc_lasx=no
-        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GCC -mlasx option" >&5
-printf %s "checking for GCC -mlasx option... " >&6; }
-        lasx_CFLAGS="-mlasx"
-        CFLAGS="$save_CFLAGS $lasx_CFLAGS"
-
-        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-        #ifndef __loongarch_asx
-        #error Assembler CPP flag not enabled
-        #endif
-
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  have_gcc_lasx=yes
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_gcc_lasx" >&5
-printf "%s\n" "$have_gcc_lasx" >&6; }
-        CFLAGS="$save_CFLAGS"
-
-        if test x$have_gcc_lasx = xyes; then
-            EXTRA_CFLAGS="$EXTRA_CFLAGS $lasx_CFLAGS"
-            SUMMARY_math="${SUMMARY_math} lasx"
-        fi
-    fi
-
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for lasxintrin.h" >&5
-printf %s "checking for lasxintrin.h... " >&6; }
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <lasxintrin.h>
-int
-main (void)
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_compile "$LINENO"
-then :
-  have_lasxintrin_h_hdr=yes
-else $as_nop
-  have_lasxintrin_h_hdr=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_lasxintrin_h_hdr" >&5
-printf "%s\n" "$have_lasxintrin_h_hdr" >&6; }
-    if test x$have_lasxintrin_h_hdr = xyes; then
-
-printf "%s\n" "#define HAVE_LASXINTRIN_H 1" >>confdefs.h
-
-    fi
-
 CheckOSS()
 {
     # Check whether --enable-oss was given.
@@ -27577,18 +27513,14 @@ then :
   have_d3d11=yes
 fi
 
-        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for d3d12 Windows SDK version" >&5
-printf %s "checking for d3d12 Windows SDK version... " >&6; }
+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for compatible d3d12 headers" >&5
+printf %s "checking for compatible d3d12 headers... " >&6; }
         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
 
-#include <winsdkver.h>
-#include <sdkddkver.h>
 #include <d3d12.h>
+#include <d3d12sdklayers.h>
 ID3D12Device1 *device;
-#if WDK_NTDDI_VERSION <= 0x0A000008
-asdf
-#endif
 
 int
 main (void)
@@ -27607,6 +27539,7 @@ fi
 rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
         { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_d3d12" >&5
 printf "%s\n" "$have_d3d12" >&6; }
+
         ac_fn_c_check_header_compile "$LINENO" "ddraw.h" "ac_cv_header_ddraw_h" "$ac_includes_default"
 if test "x$ac_cv_header_ddraw_h" = xyes
 then :

configure.ac

@@ -13,7 +13,7 @@ dnl Set various version strings - taken gratefully from the GTk sources
 # See docs/release_checklist.md
 SDL_MAJOR_VERSION=2
 SDL_MINOR_VERSION=30
-SDL_MICRO_VERSION=1
+SDL_MICRO_VERSION=10
 SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
 
 SDL_BINARY_AGE=`expr $SDL_MINOR_VERSION \* 100 + $SDL_MICRO_VERSION`
@@ -322,7 +322,7 @@ AC_ARG_ENABLE(libc,
 dnl See whether we are allowed to use system iconv
 enable_system_iconv_default=yes
 case "$host" in
-  *-*-cygwin*|*-*-mingw*)
+  *-*-cygwin*|*-*-mingw*|*-*-darwin*|*-ios-*)
     enable_system_iconv_default=no
     ;;
 esac
@@ -359,7 +359,7 @@ dnl Checks for library functions.
         AC_DEFINE(HAVE_MPROTECT, 1, [ ])
         ],[]),
     )
-    AC_CHECK_FUNCS(malloc calloc realloc free getenv setenv putenv unsetenv bsearch qsort abs bcopy memset memcmp memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtod strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp strcasestr vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll _Exit)
+    AC_CHECK_FUNCS(malloc calloc realloc free getenv setenv putenv unsetenv bsearch qsort abs bcopy memset memcmp memcpy memmove wcslen wcslcpy wcslcat _wcsdup wcsdup wcsstr wcscmp wcsncmp wcscasecmp _wcsicmp wcsncasecmp _wcsnicmp strlen strlcpy strlcat _strrev _strupr _strlwr index rindex strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtod strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp strcasestr vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval elf_aux_info poll memfd_create posix_fallocate _Exit)
 
     AC_CHECK_LIB(m, pow, [LIBS="$LIBS -lm"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"])
     AC_CHECK_FUNCS(acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf copysign copysignf cos cosf exp expf fabs fabsf floor floorf trunc truncf fmod fmodf log logf log10 log10f lround lroundf pow powf round roundf scalbn scalbnf sin sinf sqrt sqrtf tan tanf)
@@ -698,8 +698,8 @@ dnl Check for various instruction support
     fi
 
     AC_ARG_ENABLE(3dnow,
-[AS_HELP_STRING([--enable-3dnow], [use 3DNow! assembly routines [default=yes]])],
-                  , enable_3dnow=yes)
+[AS_HELP_STRING([--enable-3dnow], [use 3DNow! assembly routines [default=no]])],
+                  , enable_3dnow=no)
     if test x$enable_3dnow = xyes; then
         save_CFLAGS="$CFLAGS"
         have_gcc_3dnow=no
@@ -906,69 +906,37 @@ dnl Check for various instruction support
     fi
 fi
 
-    AC_ARG_ENABLE(lsx,
+AC_ARG_ENABLE(lsx,
 [AS_HELP_STRING([--enable-lsx], [use LSX assembly routines [default=yes]])],
                   , enable_lsx=yes)
-    if test x$enable_lsx = xyes; then
-        save_CFLAGS="$CFLAGS"
-        have_gcc_lsx=no
-        AC_MSG_CHECKING(for GCC -mlsx option)
-        lsx_CFLAGS="-mlsx"
-        CFLAGS="$save_CFLAGS $lsx_CFLAGS"
+if test x$enable_lsx = xyes; then
+    save_CFLAGS="$CFLAGS"
+    have_gcc_lsx=no
+    AC_MSG_CHECKING(for GCC -mlsx option)
+    lsx_CFLAGS="-mlsx"
+    CFLAGS="$save_CFLAGS $lsx_CFLAGS"
 
-        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-        #ifndef __loongarch_sx
-        #error Assembler CPP flag not enabled
-        #endif
-        ]], [])], [have_gcc_lsx=yes], [])
-        AC_MSG_RESULT($have_gcc_lsx)
-        CFLAGS="$save_CFLAGS"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
+    #ifndef __loongarch_sx
+    #error Assembler CPP flag not enabled
+    #endif
+    ]], [])], [have_gcc_lsx=yes], [])
+    AC_MSG_RESULT($have_gcc_lsx)
+    CFLAGS="$save_CFLAGS"
 
-        if test x$have_gcc_lsx = xyes; then
-            EXTRA_CFLAGS="$EXTRA_CFLAGS $lsx_CFLAGS"
-            SUMMARY_math="${SUMMARY_math} lsx"
-        fi
+    if test x$have_gcc_lsx = xyes; then
+       EXTRA_CFLAGS="$EXTRA_CFLAGS $lsx_CFLAGS"
+       SUMMARY_math="${SUMMARY_math} lsx"
     fi
+fi
 
-    AC_MSG_CHECKING(for lsxintrin.h)
-    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <lsxintrin.h>]])],
-       [have_lsxintrin_h_hdr=yes],[have_lsxintrin_h_hdr=no])
-    AC_MSG_RESULT($have_lsxintrin_h_hdr)
-    if test x$have_lsxintrin_h_hdr = xyes; then
-        AC_DEFINE(HAVE_LSXINTRIN_H, 1, [ ])
-    fi
-
-    AC_ARG_ENABLE(lasx,
-[AS_HELP_STRING([--enable-lasx], [use LASX assembly routines [default=yes]])],
-                  , enable_LASX=yes)
-    if test x$enable_LASX = xyes; then
-        save_CFLAGS="$CFLAGS"
-        have_gcc_lasx=no
-        AC_MSG_CHECKING(for GCC -mlasx option)
-        lasx_CFLAGS="-mlasx"
-        CFLAGS="$save_CFLAGS $lasx_CFLAGS"
-
-        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-        #ifndef __loongarch_asx
-        #error Assembler CPP flag not enabled
-        #endif
-        ]], [])], [have_gcc_lasx=yes], [])
-        AC_MSG_RESULT($have_gcc_lasx)
-        CFLAGS="$save_CFLAGS"
-
-        if test x$have_gcc_lasx = xyes; then
-            EXTRA_CFLAGS="$EXTRA_CFLAGS $lasx_CFLAGS"
-            SUMMARY_math="${SUMMARY_math} lasx"
-        fi
-    fi
-
-    AC_MSG_CHECKING(for lasxintrin.h)
-    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <lasxintrin.h>]])],
-       [have_lasxintrin_h_hdr=yes],[have_lasxintrin_h_hdr=no])
-    AC_MSG_RESULT($have_lasxintrin_h_hdr)
-    if test x$have_lasxintrin_h_hdr = xyes; then
-        AC_DEFINE(HAVE_LASXINTRIN_H, 1, [ ])
-    fi
+AC_MSG_CHECKING(for lsxintrin.h)
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <lsxintrin.h>]])],
+   [have_lsxintrin_h_hdr=yes],[have_lsxintrin_h_hdr=no])
+AC_MSG_RESULT($have_lsxintrin_h_hdr)
+if test x$have_lsxintrin_h_hdr = xyes; then
+   AC_DEFINE(HAVE_LSXINTRIN_H, 1, [ ])
+fi
 
 dnl See if the OSS audio interface is supported
 CheckOSS()
@@ -3375,17 +3343,14 @@ CheckDIRECTX()
     if test x$enable_directx = xyes; then
         AC_CHECK_HEADER(d3d9.h, have_d3d=yes)
         AC_CHECK_HEADER(d3d11_1.h, have_d3d11=yes)
-        AC_MSG_CHECKING(for d3d12 Windows SDK version)
+        AC_MSG_CHECKING(for compatible d3d12 headers)
         AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-#include <winsdkver.h>
-#include <sdkddkver.h>
 #include <d3d12.h>
+#include <d3d12sdklayers.h>
 ID3D12Device1 *device;
-#if WDK_NTDDI_VERSION <= 0x0A000008
-asdf
-#endif
             ]])], [have_d3d12=yes],[have_d3d12=no])
         AC_MSG_RESULT($have_d3d12)
+
         AC_CHECK_HEADER(ddraw.h, have_ddraw=yes)
         AC_CHECK_HEADER(dsound.h, have_dsound=yes)
         AC_CHECK_HEADER(dinput.h, have_dinput=yes)

docs/README-macos.md

@@ -261,10 +261,10 @@ Some things that may be of interest about how it all works...
 ## Working directory
 
 In SDL 1.2, the working directory of your SDL app is by default set to its
-parent, but this is no longer the case in SDL 2.0. SDL2 does change the
-working directory, which means it'll be whatever the command line prompt
-that launched the program was using, or if launched by double-clicking in
-the finger, it will be "/", the _root of the filesystem_. Plan accordingly!
+parent, but this is no longer the case in SDL 2.0 and later. SDL2 does not
+change the working directory, which means it'll be whatever the command line
+prompt that launched the program was using, or if launched by double-clicking
+in the Finder, it will be "/", the _root of the filesystem_. Plan accordingly!
 You can use SDL_GetBasePath() to find where the program is running from and
 chdir() there directly.
 

include/SDL_audio.h

@@ -594,7 +594,7 @@ extern DECLSPEC int SDLCALL SDL_GetDefaultAudioInfo(char **name,
  *   frames_ (with stereo output, two samples--left and right--would make a
  *   single sample frame). This number should be a power of two, and may be
  *   adjusted by the audio driver to a value more suitable for the hardware.
- *   Good values seem to range between 512 and 8096 inclusive, depending on
+ *   Good values seem to range between 512 and 4096 inclusive, depending on
  *   the application and CPU speed. Smaller values reduce latency, but can
  *   lead to underflow if the application is doing heavy processing and cannot
  *   fill the audio buffer in time. Note that the number of sample frames is

include/SDL_config.h.cmake

@@ -190,6 +190,8 @@
 #cmakedefine HAVE_FOPEN64 1
 #cmakedefine HAVE_FSEEKO 1
 #cmakedefine HAVE_FSEEKO64 1
+#cmakedefine HAVE_MEMFD_CREATE 1
+#cmakedefine HAVE_POSIX_FALLOCATE 1
 #cmakedefine HAVE_SIGACTION 1
 #cmakedefine HAVE_SA_SIGACTION 1
 #cmakedefine HAVE_SETJMP 1

include/SDL_config.h.in

@@ -211,6 +211,8 @@
 #undef HAVE_GETAUXVAL
 #undef HAVE_ELF_AUX_INFO
 #undef HAVE_POLL
+#undef HAVE_MEMFD_CREATE
+#undef HAVE_POSIX_FALLOCATE
 #undef HAVE__EXIT
 
 #else

include/SDL_config_os2.h

@@ -114,9 +114,6 @@
 #define HAVE_MEMCPY 1
 #define HAVE_MEMMOVE 1
 #define HAVE_MEMCMP 1
-#define HAVE_WCSLEN 1
-#define HAVE_WCSLCPY 1
-#define HAVE_WCSLCAT 1
 #define HAVE_WCSCMP 1
 #define HAVE__WCSICMP 1
 #define HAVE__WCSNICMP 1

include/SDL_config_windows.h

@@ -99,9 +99,11 @@ typedef unsigned int uintptr_t;
 #define HAVE_D3D11_H 1
 #define HAVE_ROAPI_H 1
 #endif
-#if defined(WDK_NTDDI_VERSION) && WDK_NTDDI_VERSION > 0x0A000008 /* 10.0.19041.0 */
+#if defined(__has_include)
+#if __has_include(<d3d12.h>) && __has_include(<d3d12sdklayers.h>)
 #define HAVE_D3D12_H 1
 #endif
+#endif
 #if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0603  /* Windows 8.1 SDK */
 #define HAVE_SHELLSCALINGAPI_H 1
 #endif

include/SDL_cpuinfo.h

@@ -53,9 +53,11 @@ _m_prefetch(void *__P)
 #ifndef __MMX__
 #define __MMX__
 #endif
+/*
 #ifndef __3dNOW__
 #define __3dNOW__
 #endif
+*/
 #endif
 #ifndef __SSE__
 #define __SSE__

include/SDL_hints.h

@@ -1424,7 +1424,19 @@ extern "C" {
 #define SDL_HINT_MOUSE_RELATIVE_WARP_MOTION  "SDL_MOUSE_RELATIVE_WARP_MOTION"
 
 /**
- *  \brief  A variable controlling whether mouse events should generate synthetic touch events
+ *  \brief  A variable controlling whether the hardware cursor stays visible when relative mode is active.
+ *
+ *  This variable can be set to the following values:
+ *    "0"       - The cursor will be hidden while relative mode is active (default)
+ *    "1"       - The cursor will remain visible while relative mode is active
+ *
+ *  Note that for systems without raw hardware inputs, relative mode is implemented using warping, so the hardware cursor will visibly warp between frames if this is enabled on those systems.
+ */
+#define SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE  "SDL_MOUSE_RELATIVE_CURSOR_VISIBLE"
+
+/**
+ * A variable controlling whether mouse events should generate synthetic touch
+ * events
  *
  *  This variable can be set to the following values:
  *    "0"       - Mouse events will not generate touch events (default for desktop platforms)
@@ -1900,6 +1912,7 @@ extern "C" {
  * Since it's driver-specific, it's only supported where possible and
  * implemented. Currently supported the following drivers:
  *
+ * - Wayland (wayland)
  * - KMSDRM (kmsdrm)
  * - Raspberry Pi (raspberrypi)
  */

include/SDL_joystick.h

@@ -790,12 +790,17 @@ extern DECLSPEC void SDLCALL SDL_JoystickUpdate(void);
  * **WARNING**: Calling this function may delete all events currently in SDL's
  * event queue.
  *
- * \param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`
- * \returns 1 if enabled, 0 if disabled, or a negative error code on failure;
- *          call SDL_GetError() for more information.
+ * While `param` is meant to be one of `SDL_QUERY`, `SDL_IGNORE`, or
+ * `SDL_ENABLE`, this function accepts any value, with any non-zero value that
+ * isn't `SDL_QUERY` being treated as `SDL_ENABLE`.
  *
- *          If `state` is `SDL_QUERY` then the current state is returned,
- *          otherwise the new processing state is returned.
+ * If SDL was built with events disabled (extremely uncommon!), this will
+ * do nothing and always return `SDL_IGNORE`.
+ *
+ * \param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`
+ * \returns If `state` is `SDL_QUERY` then the current state is returned,
+ *          otherwise `state` is returned (even if it was not one of the
+ *          allowed values).
  *
  * \since This function is available since SDL 2.0.0.
  *

include/SDL_platform.h

@@ -73,7 +73,13 @@
 #if defined(__APPLE__)
 /* lets us know what version of Mac OS X we're compiling on */
 #include <AvailabilityMacros.h>
+#ifndef __has_extension /* Older compilers don't support this */
+#define __has_extension(x) 0
 #include <TargetConditionals.h>
+#undef __has_extension
+#else
+#include <TargetConditionals.h>
+#endif
 
 /* Fix building with older SDKs that don't define these
    See this for more information:
@@ -199,8 +205,10 @@
 #undef __GDK__
 #define __GDK__ 1
 #endif
-#if defined(__PSP__)
+#if defined(__PSP__) || defined(__psp__)
+#ifdef __PSP__
 #undef __PSP__
+#endif
 #define __PSP__ 1
 #endif
 #if defined(PS2)

include/SDL_stdinc.h

@@ -107,7 +107,7 @@
 # elif defined(__MRC__)
 void *alloca(unsigned);
 # else
-char *alloca();
+void *alloca(size_t);
 # endif
 #endif
 
@@ -253,21 +253,21 @@ typedef uint64_t Uint64;
  * <stdint.h> should define these but this is not true all platforms.
  * (for example win32) */
 #ifndef SDL_PRIs64
-#ifdef PRIs64
-#define SDL_PRIs64 PRIs64
-#elif defined(__WIN32__) || defined(__GDK__)
+#if defined(__WIN32__) || defined(__GDK__)
 #define SDL_PRIs64 "I64d"
-#elif defined(__LP64__) && !defined(__APPLE__)
+#elif defined(PRId64)
+#define SDL_PRIs64 PRId64
+#elif defined(__LP64__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__)
 #define SDL_PRIs64 "ld"
 #else
 #define SDL_PRIs64 "lld"
 #endif
 #endif
 #ifndef SDL_PRIu64
-#ifdef PRIu64
-#define SDL_PRIu64 PRIu64
-#elif defined(__WIN32__) || defined(__GDK__)
+#if defined(__WIN32__) || defined(__GDK__)
 #define SDL_PRIu64 "I64u"
+#elif defined(PRIu64)
+#define SDL_PRIu64 PRIu64
 #elif defined(__LP64__) && !defined(__APPLE__)
 #define SDL_PRIu64 "lu"
 #else
@@ -275,10 +275,10 @@ typedef uint64_t Uint64;
 #endif
 #endif
 #ifndef SDL_PRIx64
-#ifdef PRIx64
-#define SDL_PRIx64 PRIx64
-#elif defined(__WIN32__) || defined(__GDK__)
+#if defined(__WIN32__) || defined(__GDK__)
 #define SDL_PRIx64 "I64x"
+#elif defined(PRIx64)
+#define SDL_PRIx64 PRIx64
 #elif defined(__LP64__) && !defined(__APPLE__)
 #define SDL_PRIx64 "lx"
 #else
@@ -286,10 +286,10 @@ typedef uint64_t Uint64;
 #endif
 #endif
 #ifndef SDL_PRIX64
-#ifdef PRIX64
-#define SDL_PRIX64 PRIX64
-#elif defined(__WIN32__) || defined(__GDK__)
+#if defined(__WIN32__) || defined(__GDK__)
 #define SDL_PRIX64 "I64X"
+#elif defined(PRIX64)
+#define SDL_PRIX64 PRIX64
 #elif defined(__LP64__) && !defined(__APPLE__)
 #define SDL_PRIX64 "lX"
 #else
@@ -377,9 +377,12 @@ typedef uint64_t Uint64;
 
 #ifndef SDL_COMPILE_TIME_ASSERT
 #if defined(__cplusplus)
+/* Keep C++ case alone: Some versions of gcc will define __STDC_VERSION__ even when compiling in C++ mode. */
 #if (__cplusplus >= 201103L)
 #define SDL_COMPILE_TIME_ASSERT(name, x)  static_assert(x, #x)
 #endif
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 202311L)
+#define SDL_COMPILE_TIME_ASSERT(name, x)  static_assert(x, #x)
 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
 #define SDL_COMPILE_TIME_ASSERT(name, x) _Static_assert(x, #x)
 #endif

include/SDL_version.h

@@ -59,7 +59,7 @@ typedef struct SDL_version
 */
 #define SDL_MAJOR_VERSION   2
 #define SDL_MINOR_VERSION   30
-#define SDL_PATCHLEVEL      1
+#define SDL_PATCHLEVEL      10
 
 /**
  * Macro to determine SDL version program was compiled against.

include/SDL_vulkan.h

@@ -52,6 +52,10 @@ extern "C" {
 VK_DEFINE_HANDLE(VkInstance)
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
 
+/* Make sure to undef to avoid issues in case of later vulkan include */
+#undef VK_DEFINE_HANDLE
+#undef VK_DEFINE_NON_DISPATCHABLE_HANDLE
+
 #endif /* !NO_SDL_VULKAN_TYPEDEFS */
 
 typedef VkInstance SDL_vulkanInstance;

mingw/pkg-support/INSTALL.txt

@@ -0,0 +1,18 @@
+
+The 32-bit files are in i686-w64-mingw32
+The 64-bit files are in x86_64-w64-mingw32
+
+To install SDL for native development:
+    make native
+
+To install SDL for cross-compiling development:
+    make cross
+
+Look at the example programs in ./test, and check out online documentation:
+    http://wiki.libsdl.org/
+
+Join the SDL developer mailing list if you want to join the community:
+    http://www.libsdl.org/mailing-list.php
+
+That's it!
+Sam Lantinga <slouken@libsdl.org>

mingw/pkg-support/Makefile

@@ -0,0 +1,37 @@
+#
+# Makefile for installing the mingw32 version of the SDL library
+
+CROSS_PATH := /usr/local
+ARCHITECTURES := i686-w64-mingw32 x86_64-w64-mingw32
+
+all install:
+	@echo "Type \"make native\" to install 32-bit to /usr"
+	@echo "Type \"make cross\" to install 32-bit and 64-bit to $(CROSS_PATH)"
+
+native:
+	make install-package arch=i686-w64-mingw32 prefix=/usr
+
+cross:
+	mkdir -p $(CROSS_PATH)/cmake
+	cp -rv cmake/* $(CROSS_PATH)/cmake
+	for arch in $(ARCHITECTURES); do \
+	    mkdir -p $(CROSS_PATH)/$$arch; \
+	    make install-package arch=$$arch prefix=$(CROSS_PATH)/$$arch; \
+	done
+
+install-package:
+	@if test -d $(arch) && test -d $(prefix); then \
+	    (cd $(arch) && cp -rv bin include lib share $(prefix)/); \
+	    sed "s|^prefix=.*|prefix=$(prefix)|" <$(arch)/bin/sdl2-config >$(prefix)/bin/sdl2-config; \
+	    chmod 755 $(prefix)/bin/sdl2-config; \
+	    sed "s|^libdir=.*|libdir=\'$(prefix)/lib\'|" <$(arch)/lib/libSDL2.la >$(prefix)/lib/libSDL2.la; \
+	    sed -e "s|^set[(]bindir \".*|set(bindir \"$(prefix)/bin\")|" \
+	    	-e "s|^set[(]includedir \".*|set(includedir \"$(prefix)/include\")|" \
+	    	-e "s|^set[(]libdir \".*|set(libdir \"$(prefix)/lib\")|" <$(arch)/lib/cmake/SDL2/sdl2-config.cmake >$(prefix)/lib/cmake/SDL2/sdl2-config.cmake; \
+	    sed -e "s|^prefix=.*|prefix=$(prefix)|" \
+	    	-e "s|^includedir=.*|includedir=$(prefix)/include|" \
+	    	-e "s|^libdir=.*|prefix=$(prefix)/lib|" <$(arch)/lib/pkgconfig/sdl2.pc >$(prefix)/lib/pkgconfig/sdl2.pc; \
+	else \
+	    echo "*** ERROR: $(arch) or $(prefix) does not exist!"; \
+	    exit 1; \
+	fi

src/SDL.c

@@ -29,9 +29,6 @@
 #endif
 #if defined(__OS2__)
 #include "core/os2/SDL_os2.h"
-#ifdef SDL_THREAD_OS2
-#include "thread/os2/SDL_systls_c.h"
-#endif
 #endif
 
 /* this checks for HAVE_DBUS_DBUS_H internally. */
@@ -52,6 +49,7 @@
 #include "haptic/SDL_haptic_c.h"
 #include "joystick/SDL_joystick_c.h"
 #include "sensor/SDL_sensor_c.h"
+#include "thread/SDL_thread_c.h"
 
 /* Initialization/Cleanup routines */
 #ifndef SDL_TIMERS_DISABLED
@@ -116,6 +114,7 @@ static SDL_bool SDL_MainIsReady = SDL_FALSE;
 #else
 static SDL_bool SDL_MainIsReady = SDL_TRUE;
 #endif
+static SDL_bool SDL_main_thread_initialized = SDL_FALSE;
 static SDL_bool SDL_bInMainQuit = SDL_FALSE;
 static Uint8 SDL_SubsystemRefCount[32];
 
@@ -181,6 +180,36 @@ void SDL_SetMainReady(void)
     SDL_MainIsReady = SDL_TRUE;
 }
 
+void SDL_InitMainThread(void)
+{
+    if (SDL_main_thread_initialized) {
+        return;
+    }
+
+    SDL_InitTLSData();
+#ifndef SDL_TIMERS_DISABLED
+    SDL_TicksInit();
+#endif
+    SDL_LogInit();
+
+    SDL_main_thread_initialized = SDL_TRUE;
+}
+
+static void SDL_QuitMainThread(void)
+{
+    if (!SDL_main_thread_initialized) {
+        return;
+    }
+
+    SDL_LogQuit();
+#ifndef SDL_TIMERS_DISABLED
+    SDL_TicksQuit();
+#endif
+    SDL_QuitTLSData();
+
+    SDL_main_thread_initialized = SDL_FALSE;
+}
+
 int SDL_InitSubSystem(Uint32 flags)
 {
     Uint32 flags_initialized = 0;
@@ -189,8 +218,6 @@ int SDL_InitSubSystem(Uint32 flags)
         return SDL_SetError("Application didn't initialize properly, did you include SDL_main.h in the file containing your main() function?");
     }
 
-    SDL_LogInit();
-
     /* Clear the error message */
     SDL_ClearError();
 
@@ -198,10 +225,6 @@ int SDL_InitSubSystem(Uint32 flags)
     SDL_DBus_Init();
 #endif
 
-#ifdef SDL_THREAD_OS2
-    SDL_OS2TLSAlloc(); /* thread/os2/SDL_systls.c */
-#endif
-
 #ifdef SDL_VIDEO_DRIVER_WINDOWS
     if (flags & (SDL_INIT_HAPTIC | SDL_INIT_JOYSTICK)) {
         if (SDL_HelperWindowCreate() < 0) {
@@ -210,10 +233,6 @@ int SDL_InitSubSystem(Uint32 flags)
     }
 #endif
 
-#ifndef SDL_TIMERS_DISABLED
-    SDL_TicksInit();
-#endif
-
     /* Initialize the event subsystem */
     if (flags & SDL_INIT_EVENTS) {
 #ifndef SDL_EVENTS_DISABLED
@@ -378,9 +397,6 @@ int SDL_Init(Uint32 flags)
 void SDL_QuitSubSystem(Uint32 flags)
 {
 #if defined(__OS2__)
-#ifdef SDL_THREAD_OS2
-    SDL_OS2TLSFree(); /* thread/os2/SDL_systls.c */
-#endif
     SDL_OS2Quit();
 #endif
 
@@ -504,10 +520,6 @@ void SDL_Quit(void)
 #endif
     SDL_QuitSubSystem(SDL_INIT_EVERYTHING);
 
-#ifndef SDL_TIMERS_DISABLED
-    SDL_TicksQuit();
-#endif
-
 #ifdef SDL_USE_LIBDBUS
     SDL_DBus_Quit();
 #endif
@@ -515,14 +527,12 @@ void SDL_Quit(void)
     SDL_ClearHints();
     SDL_AssertionsQuit();
 
-    SDL_LogQuit();
-
     /* Now that every subsystem has been quit, we reset the subsystem refcount
      * and the list of initialized subsystems.
      */
     SDL_memset(SDL_SubsystemRefCount, 0x0, sizeof(SDL_SubsystemRefCount));
 
-    SDL_TLSCleanup();
+    SDL_QuitMainThread();
 
     SDL_bInMainQuit = SDL_FALSE;
 }

src/SDL_assert.c

@@ -292,7 +292,7 @@ static SDL_assert_state SDLCALL SDL_PromptAssertion(const SDL_assert_data *data,
                 break;
             }
         }
-#elif defined(HAVE_STDIO_H)
+#elif defined(HAVE_STDIO_H) && !defined(__3DS__)
         /* this is a little hacky. */
         for (;;) {
             char buf[32];
@@ -319,6 +319,8 @@ static SDL_assert_state SDLCALL SDL_PromptAssertion(const SDL_assert_data *data,
                 break;
             }
         }
+#else
+        SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_WARNING, "Assertion Failed", message, window);
 #endif /* HAVE_STDIO_H */
     }
 

src/SDL_hints.c

@@ -161,6 +161,10 @@ const char *SDL_GetHint(const char *name)
     const char *env;
     SDL_Hint *hint;
 
+    if (!name) {
+        return NULL;
+    }
+
     env = SDL_getenv(name);
     for (hint = SDL_hints; hint; hint = hint->next) {
         if (SDL_strcmp(name, hint->name) == 0) {

src/SDL_internal.h

@@ -208,6 +208,8 @@
 #include "SDL_assert.h"
 #include "SDL_log.h"
 
+extern void SDL_InitMainThread(void);
+
 #endif /* SDL_internal_h_ */
 
 /* vi: set ts=4 sw=4 expandtab: */

src/audio/SDL_audio.c

@@ -93,12 +93,12 @@ static const AudioBootStrap *const bootstrap[] = {
 #ifdef SDL_AUDIO_DRIVER_FUSIONSOUND
     &FUSIONSOUND_bootstrap,
 #endif
-#ifdef SDL_AUDIO_DRIVER_AAUDIO
-    &aaudio_bootstrap,
-#endif
 #ifdef SDL_AUDIO_DRIVER_OPENSLES
     &openslES_bootstrap,
 #endif
+#ifdef SDL_AUDIO_DRIVER_AAUDIO
+    &aaudio_bootstrap,
+#endif
 #ifdef SDL_AUDIO_DRIVER_ANDROID
     &ANDROIDAUDIO_bootstrap,
 #endif
@@ -700,8 +700,6 @@ static int SDLCALL SDL_RunAudio(void *userdata)
 
     /* Loop, filling the audio buffers */
     while (!SDL_AtomicGet(&device->shutdown)) {
-        data_len = device->callbackspec.size;
-
         /* Fill the current buffer with sound */
         if (!device->stream && SDL_AtomicGet(&device->enabled)) {
             data = current_audio.impl.GetDeviceBuf(device);
@@ -728,6 +726,8 @@ static int SDLCALL SDL_RunAudio(void *userdata)
             data = device->work_buffer;
         }
 
+        data_len = device->callbackspec.size;
+
         /* !!! FIXME: this should be LockDevice. */
         SDL_LockMutex(device->mixer_lock);
         if (SDL_AtomicGet(&device->paused)) {

src/audio/aaudio/SDL_aaudio.c

@@ -116,7 +116,6 @@ static int aaudio_OpenDevice(_THIS, const char *devname)
     }
 
     ctx.AAudioStreamBuilder_setErrorCallback(ctx.builder, aaudio_errorCallback, private);
-    ctx.AAudioStreamBuilder_setPerformanceMode(ctx.builder, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
 
     LOGI("AAudio Try to open %u hz %u bit chan %u %s samples %u",
          this->spec.freq, SDL_AUDIO_BITSIZE(this->spec.format),
@@ -239,7 +238,6 @@ static int RebuildAAudioStream(SDL_AudioDevice *device)
     }
 
     ctx.AAudioStreamBuilder_setErrorCallback(ctx.builder, aaudio_errorCallback, hidden);
-    ctx.AAudioStreamBuilder_setPerformanceMode(ctx.builder, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
 
     LOGI("AAudio Try to reopen %u hz %u bit chan %u %s samples %u",
          device->spec.freq, SDL_AUDIO_BITSIZE(device->spec.format),

src/audio/aaudio/SDL_aaudiofuncs.h

@@ -32,7 +32,7 @@ SDL_PROC(void, AAudioStreamBuilder_setFormat, (AAudioStreamBuilder * builder, aa
 SDL_PROC_UNUSED(void, AAudioStreamBuilder_setSharingMode, (AAudioStreamBuilder * builder, aaudio_sharing_mode_t sharingMode))
 SDL_PROC(void, AAudioStreamBuilder_setDirection, (AAudioStreamBuilder * builder, aaudio_direction_t direction))
 SDL_PROC_UNUSED(void, AAudioStreamBuilder_setBufferCapacityInFrames, (AAudioStreamBuilder * builder, int32_t numFrames))
-SDL_PROC(void, AAudioStreamBuilder_setPerformanceMode, (AAudioStreamBuilder * builder, aaudio_performance_mode_t mode))
+SDL_PROC_UNUSED(void, AAudioStreamBuilder_setPerformanceMode, (AAudioStreamBuilder * builder, aaudio_performance_mode_t mode))
 SDL_PROC_UNUSED(void, AAudioStreamBuilder_setUsage, (AAudioStreamBuilder * builder, aaudio_usage_t usage))                                         /* API 28 */
 SDL_PROC_UNUSED(void, AAudioStreamBuilder_setContentType, (AAudioStreamBuilder * builder, aaudio_content_type_t contentType))                      /* API 28 */
 SDL_PROC_UNUSED(void, AAudioStreamBuilder_setInputPreset, (AAudioStreamBuilder * builder, aaudio_input_preset_t inputPreset))                      /* API 28 */

src/audio/arts/SDL_artsaudio.c

@@ -86,7 +86,7 @@ static struct
 
 #undef SDL_ARTS_SYM
 
-static void UnloadARTSLibrary()
+static void UnloadARTSLibrary(void)
 {
     if (arts_handle) {
         SDL_UnloadObject(arts_handle);
@@ -119,7 +119,7 @@ static int LoadARTSLibrary(void)
 
 #else
 
-static void UnloadARTSLibrary()
+static void UnloadARTSLibrary(void)
 {
     return;
 }

src/audio/coreaudio/SDL_coreaudio.m

@@ -455,12 +455,13 @@ static BOOL update_audio_session(_THIS, SDL_bool open, SDL_bool allow_playandrec
 
         if ((open_playback_devices || open_capture_devices) && !session_active) {
             if (![session setActive:YES error:&err]) {
+                NSString *desc;
                 if ([err code] == AVAudioSessionErrorCodeResourceNotAvailable &&
                     category == AVAudioSessionCategoryPlayAndRecord) {
                     return update_audio_session(this, open, SDL_FALSE);
                 }
 
-                NSString *desc = err.description;
+                desc = err.description;
                 SDL_SetError("Could not activate Audio Session: %s", desc.UTF8String);
                 return NO;
             }

src/audio/emscripten/SDL_emscriptenaudio.c

@@ -39,6 +39,12 @@ static void FeedAudioDevice(_THIS, const void *buf, const int buflen)
     /* *INDENT-OFF* */ /* clang-format off */
     MAIN_THREAD_EM_ASM({
         var SDL2 = Module['SDL2'];
+        /* Convert incoming buf pointer to a HEAPF32 offset. */
+#ifdef __wasm64__
+        var buf = $0 / 4;
+#else
+        var buf = $0 >>> 2;
+#endif
         var numChannels = SDL2.audio.currentOutputBuffer['numberOfChannels'];
         for (var c = 0; c < numChannels; ++c) {
             var channelData = SDL2.audio.currentOutputBuffer['getChannelData'](c);
@@ -47,7 +53,7 @@ static void FeedAudioDevice(_THIS, const void *buf, const int buflen)
             }
 
             for (var j = 0; j < $1; ++j) {
-                channelData[j] = HEAPF32[$0 + ((j*numChannels + c) << 2) >> 2];  /* !!! FIXME: why are these shifts here? */
+                channelData[j] = HEAPF32[buf + (j*numChannels + c)];
             }
         }
     }, buf, buflen / framelen);

src/audio/esd/SDL_esdaudio.c

@@ -64,7 +64,7 @@ static struct
 
 #undef SDL_ESD_SYM
 
-static void UnloadESDLibrary()
+static void UnloadESDLibrary(void)
 {
     if (esd_handle) {
         SDL_UnloadObject(esd_handle);
@@ -96,7 +96,7 @@ static int LoadESDLibrary(void)
 
 #else
 
-static void UnloadESDLibrary()
+static void UnloadESDLibrary(void)
 {
     return;
 }

src/audio/fusionsound/SDL_fsaudio.c

@@ -77,7 +77,7 @@ static struct
 
 #undef SDL_FS_SYM
 
-static void UnloadFusionSoundLibrary()
+static void UnloadFusionSoundLibrary(void)
 {
     if (fs_handle) {
         SDL_UnloadObject(fs_handle);
@@ -110,7 +110,7 @@ static int LoadFusionSoundLibrary(void)
 
 #else
 
-static void UnloadFusionSoundLibrary()
+static void UnloadFusionSoundLibrary(void)
 {
     return;
 }

src/audio/pipewire/SDL_pipewire.c

@@ -142,13 +142,13 @@ static int pipewire_dlsym(const char *fn, void **addr)
         return -1;                                             \
     }
 
-static int load_pipewire_library()
+static int load_pipewire_library(void)
 {
     pipewire_handle = SDL_LoadObject(pipewire_library);
     return pipewire_handle ? 0 : -1;
 }
 
-static void unload_pipewire_library()
+static void unload_pipewire_library(void)
 {
     if (pipewire_handle) {
         SDL_UnloadObject(pipewire_handle);
@@ -160,18 +160,18 @@ static void unload_pipewire_library()
 
 #define SDL_PIPEWIRE_SYM(x) PIPEWIRE_##x = x
 
-static int load_pipewire_library()
+static int load_pipewire_library(void)
 {
     return 0;
 }
 
-static void unload_pipewire_library()
+static void unload_pipewire_library(void)
 { /* Nothing to do */
 }
 
 #endif /* SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC */
 
-static int load_pipewire_syms()
+static int load_pipewire_syms(void)
 {
     SDL_PIPEWIRE_SYM(pw_get_library_version);
     SDL_PIPEWIRE_SYM(pw_init);
@@ -212,7 +212,7 @@ SDL_FORCE_INLINE SDL_bool pipewire_version_at_least(int major, int minor, int pa
            (pipewire_version_major > major || pipewire_version_minor > minor || pipewire_version_patch >= patch);
 }
 
-static int init_pipewire_library()
+static int init_pipewire_library(void)
 {
     if (!load_pipewire_library()) {
         if (!load_pipewire_syms()) {
@@ -234,7 +234,7 @@ static int init_pipewire_library()
     return -1;
 }
 
-static void deinit_pipewire_library()
+static void deinit_pipewire_library(void)
 {
     PIPEWIRE_pw_deinit();
     unload_pipewire_library();
@@ -340,7 +340,7 @@ static void io_list_remove(Uint32 id)
     }
 }
 
-static void io_list_sort()
+static void io_list_sort(void)
 {
     struct io_node *default_sink = NULL, *default_source = NULL;
     struct io_node *n, *temp;
@@ -365,7 +365,7 @@ static void io_list_sort()
     }
 }
 
-static void io_list_clear()
+static void io_list_clear(void)
 {
     struct io_node *n, *temp;
 
@@ -426,7 +426,7 @@ static void pending_list_remove(Uint32 id)
     }
 }
 
-static void pending_list_clear()
+static void pending_list_clear(void)
 {
     struct node_object *node, *temp;
 
@@ -751,7 +751,7 @@ static const struct pw_registry_events registry_events = { PW_VERSION_REGISTRY_E
                                                            .global_remove = registry_event_remove_callback };
 
 /* The hotplug thread */
-static int hotplug_loop_init()
+static int hotplug_loop_init(void)
 {
     int res;
 
@@ -794,7 +794,7 @@ static int hotplug_loop_init()
     return 0;
 }
 
-static void hotplug_loop_destroy()
+static void hotplug_loop_destroy(void)
 {
     if (hotplug_loop) {
         PIPEWIRE_pw_thread_loop_stop(hotplug_loop);
@@ -836,7 +836,7 @@ static void hotplug_loop_destroy()
     }
 }
 
-static void PIPEWIRE_DetectDevices()
+static void PIPEWIRE_DetectDevices(void)
 {
     struct io_node *io;
 
@@ -1342,7 +1342,7 @@ failed:
     return ret;
 }
 
-static void PIPEWIRE_Deinitialize()
+static void PIPEWIRE_Deinitialize(void)
 {
     if (pipewire_initialized) {
         hotplug_loop_destroy();

src/audio/pulseaudio/SDL_pulseaudio.c

@@ -885,7 +885,7 @@ static int SDLCALL HotplugThread(void *data)
     return 0;
 }
 
-static void PULSEAUDIO_DetectDevices()
+static void PULSEAUDIO_DetectDevices(void)
 {
     SDL_sem *ready_sem = SDL_CreateSemaphore(0);
 
@@ -897,8 +897,12 @@ static void PULSEAUDIO_DetectDevices()
 
     /* ok, we have a sane list, let's set up hotplug notifications now... */
     SDL_AtomicSet(&pulseaudio_hotplug_thread_active, 1);
-    pulseaudio_hotplug_thread = SDL_CreateThreadInternal(HotplugThread, "PulseHotplug", 256 * 1024, ready_sem);  /* !!! FIXME: this can probably survive in significantly less stack space. */
-    SDL_SemWait(ready_sem);
+    pulseaudio_hotplug_thread = SDL_CreateThreadInternal(HotplugThread, "PulseHotplug", 0, ready_sem);
+    if (pulseaudio_hotplug_thread) {
+        SDL_SemWait(ready_sem);
+    } else {
+        SDL_AtomicSet(&pulseaudio_hotplug_thread_active, 0);  // thread failed to start, we'll go on without hotplug.
+    }
     SDL_DestroySemaphore(ready_sem);
 }
 

src/audio/wasapi/SDL_wasapi.c

@@ -111,6 +111,12 @@ static int UpdateAudioStream(_THIS, const SDL_AudioSpec *oldspec)
         }
     }
 
+    /* if the device sample size changed, make sure we're asking for enough data. */
+    if (this->callbackspec.samples != this->spec.samples) {
+        this->callbackspec.samples = this->spec.samples;
+        SDL_CalculateAudioSpec(&this->callbackspec);
+    }
+
     /* make sure our scratch buffer can cover the new device spec. */
     if (this->spec.size > this->work_buffer_len) {
         Uint8 *ptr = (Uint8 *)SDL_realloc(this->work_buffer, this->spec.size);

src/core/android/SDL_android.c

@@ -842,18 +842,18 @@ JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
 }
 
 /* Lock / Unlock Mutex */
-void Android_ActivityMutex_Lock()
+void Android_ActivityMutex_Lock(void)
 {
     SDL_LockMutex(Android_ActivityMutex);
 }
 
-void Android_ActivityMutex_Unlock()
+void Android_ActivityMutex_Unlock(void)
 {
     SDL_UnlockMutex(Android_ActivityMutex);
 }
 
 /* Lock the Mutex when the Activity is in its 'Running' state */
-void Android_ActivityMutex_Lock_Running()
+void Android_ActivityMutex_Lock_Running(void)
 {
     int pauseSignaled = 0;
     int resumeSignaled = 0;
@@ -1439,13 +1439,13 @@ void Android_JNI_SetOrientation(int w, int h, int resizable, const char *hint)
     (*env)->DeleteLocalRef(env, jhint);
 }
 
-void Android_JNI_MinizeWindow()
+void Android_JNI_MinizeWindow(void)
 {
     JNIEnv *env = Android_JNI_GetEnv();
     (*env)->CallStaticVoidMethod(env, mActivityClass, midMinimizeWindow);
 }
 
-SDL_bool Android_JNI_ShouldMinimizeOnFocusLoss()
+SDL_bool Android_JNI_ShouldMinimizeOnFocusLoss(void)
 {
     JNIEnv *env = Android_JNI_GetEnv();
     return (*env)->CallStaticBooleanMethod(env, mActivityClass, midShouldMinimizeOnFocusLoss);
@@ -1879,7 +1879,7 @@ static SDL_bool Android_JNI_ExceptionOccurred(SDL_bool silent)
     return SDL_FALSE;
 }
 
-static void Internal_Android_Create_AssetManager()
+static void Internal_Android_Create_AssetManager(void)
 {
 
     struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
@@ -1918,7 +1918,7 @@ static void Internal_Android_Create_AssetManager()
     LocalReferenceHolder_Cleanup(&refs);
 }
 
-static void Internal_Android_Destroy_AssetManager()
+static void Internal_Android_Destroy_AssetManager(void)
 {
     JNIEnv *env = Android_JNI_GetEnv();
 
@@ -2153,7 +2153,7 @@ int Android_JNI_GetPowerInfo(int *plugged, int *charged, int *battery, int *seco
 }
 
 /* Add all touch devices */
-void Android_JNI_InitTouch()
+void Android_JNI_InitTouch(void)
 {
     JNIEnv *env = Android_JNI_GetEnv();
     (*env)->CallStaticVoidMethod(env, mActivityClass, midInitTouch);

src/core/freebsd/SDL_evdev_kbd_freebsd.c

@@ -134,7 +134,7 @@ static void kbd_cleanup_signal_action(int signum, siginfo_t *info, void *ucontex
     SDL_EVDEV_kbd_reraise_signal(signum);
 }
 
-static void kbd_unregister_emerg_cleanup()
+static void kbd_unregister_emerg_cleanup(void)
 {
     int tabidx, signum;
 

src/core/gdk/SDL_gdk.cpp

@@ -36,6 +36,7 @@ extern "C" {
 static XTaskQueueHandle GDK_GlobalTaskQueue;
 
 PAPPSTATE_REGISTRATION hPLM = {};
+PAPPCONSTRAIN_REGISTRATION hCPLM = {};
 HANDLE plmSuspendComplete = nullptr;
 
 extern "C" DECLSPEC int
@@ -177,6 +178,23 @@ SDL_GDKRunApp(SDL_main_func mainFunction, void *reserved)
             return -1;
         }
 
+        /* Register constrain/unconstrain handling */
+        auto raccn = [](BOOLEAN constrained, PVOID context) {
+            SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "[GDK] in RegisterAppConstrainedChangeNotification handler");
+            SDL_VideoDevice *_this = SDL_GetVideoDevice();
+            if (_this) {
+                if (constrained) {
+                    SDL_SetKeyboardFocus(NULL);
+                } else {
+                    SDL_SetKeyboardFocus(_this->windows);
+                }
+            }
+        };
+        if (RegisterAppConstrainedChangeNotification(raccn, NULL, &hCPLM)) {
+            SDL_SetError("[GDK] Unable to call RegisterAppConstrainedChangeNotification");
+            return -1;
+        }
+
         /* Run the application main() code */
         result = mainFunction(argc, argv);
 
@@ -184,6 +202,9 @@ SDL_GDKRunApp(SDL_main_func mainFunction, void *reserved)
         UnregisterAppStateChangeNotification(hPLM);
         CloseHandle(plmSuspendComplete);
 
+        /* Unregister constrain/unconstrain handling */
+        UnregisterAppConstrainedChangeNotification(hCPLM);
+
         /* !!! FIXME: This follows the docs exactly, but for some reason still leaks handles on exit? */
         /* Terminate the task queue and dispatch any pending tasks */
         XTaskQueueTerminate(taskQueue, false, nullptr, nullptr);

src/core/linux/SDL_evdev_kbd.c

@@ -214,7 +214,7 @@ static void kbd_cleanup_signal_action(int signum, siginfo_t *info, void *ucontex
     SDL_EVDEV_kbd_reraise_signal(signum);
 }
 
-static void kbd_unregister_emerg_cleanup()
+static void kbd_unregister_emerg_cleanup(void)
 {
     int tabidx, signum;
 

src/core/linux/SDL_fcitx.c

@@ -55,7 +55,7 @@ typedef struct _FcitxClient
 
 static FcitxClient fcitx_client;
 
-static char *GetAppName()
+static char *GetAppName(void)
 {
 #if defined(__LINUX__) || defined(__FREEBSD__)
     char *spot;
@@ -368,7 +368,7 @@ static Uint32 Fcitx_ModState(void)
     return fcitx_mods;
 }
 
-SDL_bool SDL_Fcitx_Init()
+SDL_bool SDL_Fcitx_Init(void)
 {
     fcitx_client.dbus = SDL_DBus_GetContext();
 
@@ -380,7 +380,7 @@ SDL_bool SDL_Fcitx_Init()
     return FcitxClientCreateIC(&fcitx_client);
 }
 
-void SDL_Fcitx_Quit()
+void SDL_Fcitx_Quit(void)
 {
     FcitxClientICCallMethod(&fcitx_client, "DestroyIC");
     if (fcitx_client.ic_path) {
@@ -485,7 +485,6 @@ void SDL_Fcitx_PumpEvents(void)
 
     while (dbus->connection_dispatch(conn) == DBUS_DISPATCH_DATA_REMAINS) {
         /* Do nothing, actual work happens in DBus_MessageFilter */
-        usleep(10);
     }
 }
 

src/core/linux/SDL_ime.c

@@ -40,7 +40,7 @@ static _SDL_IME_ProcessKeyEvent SDL_IME_ProcessKeyEvent_Real = NULL;
 static _SDL_IME_UpdateTextRect SDL_IME_UpdateTextRect_Real = NULL;
 static _SDL_IME_PumpEvents SDL_IME_PumpEvents_Real = NULL;
 
-static void InitIME()
+static void InitIME(void)
 {
     static SDL_bool inited = SDL_FALSE;
 #ifdef HAVE_FCITX
@@ -142,7 +142,7 @@ void SDL_IME_UpdateTextRect(const SDL_Rect *rect)
     }
 }
 
-void SDL_IME_PumpEvents()
+void SDL_IME_PumpEvents(void)
 {
     if (SDL_IME_PumpEvents_Real) {
         SDL_IME_PumpEvents_Real();

src/core/linux/SDL_threadprio.c

@@ -79,7 +79,7 @@ static SDL_bool realtime_portal_supported(DBusConnection *conn)
                                               "RTTimeUSecMax", DBUS_TYPE_INT64, &res);
 }
 
-static void set_rtkit_interface()
+static void set_rtkit_interface(void)
 {
     SDL_DBusContext *dbus = SDL_DBus_GetContext();
 
@@ -108,7 +108,7 @@ static DBusConnection *get_rtkit_dbus_connection()
     return NULL;
 }
 
-static void rtkit_initialize()
+static void rtkit_initialize(void)
 {
     DBusConnection *dbus_conn;
 
@@ -134,7 +134,7 @@ static void rtkit_initialize()
     }
 }
 
-static SDL_bool rtkit_initialize_realtime_thread()
+static SDL_bool rtkit_initialize_realtime_thread(void)
 {
     // Following is an excerpt from rtkit README that outlines the requirements
     // a thread must meet before making rtkit requests:

src/core/linux/SDL_udev.c

@@ -31,6 +31,7 @@
 #ifdef SDL_USE_LIBUDEV
 
 #include <linux/input.h>
+#include <sys/stat.h>
 
 #include "SDL_assert.h"
 #include "SDL_evdev_capabilities.h"
@@ -227,61 +228,59 @@ void SDL_UDEV_Scan(void)
 
 SDL_bool SDL_UDEV_GetProductInfo(const char *device_path, Uint16 *vendor, Uint16 *product, Uint16 *version, int *class)
 {
-    struct udev_enumerate *enumerate = NULL;
-    struct udev_list_entry *devs = NULL;
-    struct udev_list_entry *item = NULL;
-    SDL_bool found = SDL_FALSE;
+    struct stat statbuf;
+    char type;
+    struct udev_device *dev;
+    const char* val;
+    int class_temp;
 
     if (!_this) {
         return SDL_FALSE;
     }
 
-    enumerate = _this->syms.udev_enumerate_new(_this->udev);
-    if (!enumerate) {
-        SDL_SetError("udev_enumerate_new() failed");
+    if (stat(device_path, &statbuf) == -1) {
         return SDL_FALSE;
     }
 
-    _this->syms.udev_enumerate_scan_devices(enumerate);
-    devs = _this->syms.udev_enumerate_get_list_entry(enumerate);
-    for (item = devs; item && !found; item = _this->syms.udev_list_entry_get_next(item)) {
-        const char *path = _this->syms.udev_list_entry_get_name(item);
-        struct udev_device *dev = _this->syms.udev_device_new_from_syspath(_this->udev, path);
-        if (dev) {
-            const char *val = NULL;
-            const char *existing_path;
-
-            existing_path = _this->syms.udev_device_get_devnode(dev);
-            if (existing_path && SDL_strcmp(device_path, existing_path) == 0) {
-                int class_temp;
-                found = SDL_TRUE;
-
-                val = _this->syms.udev_device_get_property_value(dev, "ID_VENDOR_ID");
-                if (val) {
-                    *vendor = (Uint16)SDL_strtol(val, NULL, 16);
-                }
-
-                val = _this->syms.udev_device_get_property_value(dev, "ID_MODEL_ID");
-                if (val) {
-                    *product = (Uint16)SDL_strtol(val, NULL, 16);
-                }
-
-                val = _this->syms.udev_device_get_property_value(dev, "ID_REVISION");
-                if (val) {
-                    *version = (Uint16)SDL_strtol(val, NULL, 16);
-                }
-
-                class_temp = device_class(dev);
-                if (class_temp) {
-                    *class = class_temp;
-                }
-            }
-            _this->syms.udev_device_unref(dev);
-        }
+    if (S_ISBLK(statbuf.st_mode)) {
+        type = 'b';
+    }
+    else if (S_ISCHR(statbuf.st_mode)) {
+        type = 'c';
+    }
+    else {
+        return SDL_FALSE;
     }
-    _this->syms.udev_enumerate_unref(enumerate);
 
-    return found;
+    dev = _this->syms.udev_device_new_from_devnum(_this->udev, type, statbuf.st_rdev);
+
+    if (!dev) {
+        return SDL_FALSE;
+    }
+
+    val = _this->syms.udev_device_get_property_value(dev, "ID_VENDOR_ID");
+    if (val) {
+        *vendor = (Uint16)SDL_strtol(val, NULL, 16);
+    }
+
+    val = _this->syms.udev_device_get_property_value(dev, "ID_MODEL_ID");
+    if (val) {
+        *product = (Uint16)SDL_strtol(val, NULL, 16);
+    }
+
+    val = _this->syms.udev_device_get_property_value(dev, "ID_REVISION");
+    if (val) {
+        *version = (Uint16)SDL_strtol(val, NULL, 16);
+    }
+
+    class_temp = device_class(dev);
+    if (class_temp) {
+        *class = class_temp;
+    }
+
+    _this->syms.udev_device_unref(dev);
+
+    return SDL_TRUE;
 }
 
 void SDL_UDEV_UnloadLibrary(void)

src/core/openbsd/SDL_wscons_kbd.c

@@ -449,7 +449,7 @@ static SDL_WSCONS_input_data *SDL_WSCONS_Init_Keyboard(const char *dev)
     return input;
 }
 
-void SDL_WSCONS_Init()
+void SDL_WSCONS_Init(void)
 {
     inputs[0] = SDL_WSCONS_Init_Keyboard("/dev/wskbd0");
     inputs[1] = SDL_WSCONS_Init_Keyboard("/dev/wskbd1");
@@ -460,7 +460,7 @@ void SDL_WSCONS_Init()
     return;
 }
 
-void SDL_WSCONS_Quit()
+void SDL_WSCONS_Quit(void)
 {
     int i = 0;
     SDL_WSCONS_input_data *input = NULL;
@@ -921,7 +921,7 @@ static void updateKeyboard(SDL_WSCONS_input_data *input)
     }
 }
 
-void SDL_WSCONS_PumpEvents()
+void SDL_WSCONS_PumpEvents(void)
 {
     int i = 0;
     for (i = 0; i < 4; i++) {

src/cpuinfo/SDL_cpuinfo.c

@@ -1239,7 +1239,7 @@ void SDL_SIMDFree(void *ptr)
 
 #include <stdio.h>
 
-int main()
+int main(void)
 {
     printf("CPU count: %d\n", SDL_GetCPUCount());
     printf("CPU type: %s\n", SDL_GetCPUType());

src/dynapi/gendynapi.pl

@@ -50,8 +50,13 @@ open(SDL_DYNAPI_PROCS_H, '>>', $sdl_dynapi_procs_h) or die("Can't open $sdl_dyna
 open(SDL_DYNAPI_OVERRIDES_H, '>>', $sdl_dynapi_overrides_h) or die("Can't open $sdl_dynapi_overrides_h: $!\n");
 open(SDL2_EXPORTS, '>>', $sdl2_exports) or die("Can't open $sdl2_exports: $!\n");
 
+# Ordered for reproducible builds
 opendir(HEADERS, 'include') or die("Can't open include dir: $!\n");
-while (my $d = readdir(HEADERS)) {
+my @entries = readdir(HEADERS);
+closedir(HEADERS);
+# Sort the entries
+@entries = sort @entries;
+foreach my $d (@entries) {
     next if not $d =~ /\.h\Z/;
     my $header = "include/$d";
     open(HEADER, '<', $header) or die("Can't open $header: $!\n");
@@ -143,8 +148,6 @@ while (my $d = readdir(HEADERS)) {
     close(HEADER);
 }
 
-closedir(HEADERS);
-
 close(SDL_DYNAPI_PROCS_H);
 close(SDL_DYNAPI_OVERRIDES_H);
 close(SDL2_EXPORTS);

src/events/SDL_events.c

@@ -34,13 +34,6 @@
 #include "../video/SDL_sysvideo.h"
 #include "SDL_syswm.h"
 
-#undef SDL_PRIs64
-#if (defined(__WIN32__) || defined(__GDK__)) && !defined(__CYGWIN__)
-#define SDL_PRIs64 "I64d"
-#else
-#define SDL_PRIs64 "lld"
-#endif
-
 /* An arbitrary limit so we don't have unbounded growth */
 #define SDL_MAX_QUEUED_EVENTS 65535
 
@@ -454,8 +447,8 @@ static void SDL_LogEvent(const SDL_Event *event)
 
 #define PRINT_FINGER_EVENT(event)                                                                                                                      \
     (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u touchid=%" SDL_PRIs64 " fingerid=%" SDL_PRIs64 " x=%f y=%f dx=%f dy=%f pressure=%f)", \
-                       (uint)event->tfinger.timestamp, (long long)event->tfinger.touchId,                                                              \
-                       (long long)event->tfinger.fingerId, event->tfinger.x, event->tfinger.y,                                                         \
+                       (uint)event->tfinger.timestamp, event->tfinger.touchId,                                                                         \
+                       event->tfinger.fingerId, event->tfinger.x, event->tfinger.y,                                                                    \
                        event->tfinger.dx, event->tfinger.dy, event->tfinger.pressure)
         SDL_EVENT_CASE(SDL_FINGERDOWN)
         PRINT_FINGER_EVENT(event);
@@ -470,8 +463,8 @@ static void SDL_LogEvent(const SDL_Event *event)
 
 #define PRINT_DOLLAR_EVENT(event)                                                                                                                      \
     (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u touchid=%" SDL_PRIs64 " gestureid=%" SDL_PRIs64 " numfingers=%u error=%f x=%f y=%f)", \
-                       (uint)event->dgesture.timestamp, (long long)event->dgesture.touchId,                                                            \
-                       (long long)event->dgesture.gestureId, (uint)event->dgesture.numFingers,                                                         \
+                       (uint)event->dgesture.timestamp, event->dgesture.touchId,                                                                       \
+                       event->dgesture.gestureId, (uint)event->dgesture.numFingers,                                                                    \
                        event->dgesture.error, event->dgesture.x, event->dgesture.y)
         SDL_EVENT_CASE(SDL_DOLLARGESTURE)
         PRINT_DOLLAR_EVENT(event);
@@ -483,7 +476,7 @@ static void SDL_LogEvent(const SDL_Event *event)
 
         SDL_EVENT_CASE(SDL_MULTIGESTURE)
         (void)SDL_snprintf(details, sizeof(details), " (timestamp=%u touchid=%" SDL_PRIs64 " dtheta=%f ddist=%f x=%f y=%f numfingers=%u)",
-                           (uint)event->mgesture.timestamp, (long long)event->mgesture.touchId,
+                           (uint)event->mgesture.timestamp, event->mgesture.touchId,
                            event->mgesture.dTheta, event->mgesture.dDist,
                            event->mgesture.x, event->mgesture.y, (uint)event->mgesture.numFingers);
         break;

src/events/SDL_mouse.c

@@ -170,6 +170,13 @@ static void SDLCALL SDL_MouseRelativeWarpMotionChanged(void *userdata, const cha
     mouse->relative_mode_warp_motion = SDL_GetStringBoolean(hint, SDL_FALSE);
 }
 
+static void SDLCALL SDL_MouseRelativeCursorVisibleChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_Mouse *mouse = (SDL_Mouse *)userdata;
+
+    mouse->relative_mode_cursor_visible = SDL_GetStringBoolean(hint, SDL_FALSE);
+}
+
 /* Public functions */
 int SDL_MousePreInit(void)
 {
@@ -209,6 +216,9 @@ int SDL_MousePreInit(void)
     SDL_AddHintCallback(SDL_HINT_MOUSE_RELATIVE_WARP_MOTION,
                         SDL_MouseRelativeWarpMotionChanged, mouse);
 
+    SDL_AddHintCallback(SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE,
+                        SDL_MouseRelativeCursorVisibleChanged, mouse);
+
     mouse->was_touch_mouse_events = SDL_FALSE; /* no touch to mouse movement event pending */
 
     mouse->cursor_shown = SDL_TRUE;
@@ -992,6 +1002,9 @@ void SDL_MouseQuit(void)
 
     SDL_DelHintCallback(SDL_HINT_MOUSE_RELATIVE_WARP_MOTION,
                         SDL_MouseRelativeWarpMotionChanged, mouse);
+
+    SDL_DelHintCallback(SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE,
+                        SDL_MouseRelativeCursorVisibleChanged, mouse);
 }
 
 Uint32 SDL_GetMouseState(int *x, int *y)
@@ -1412,7 +1425,7 @@ void SDL_SetCursor(SDL_Cursor *cursor)
         }
     }
 
-    if (cursor && mouse->cursor_shown && !mouse->relative_mode) {
+    if (cursor && mouse->cursor_shown && (!mouse->relative_mode || mouse->relative_mode_cursor_visible)) {
         if (mouse->ShowCursor) {
             mouse->ShowCursor(cursor);
         }