Fix configstring replacement causing the model to be referenced twice on base MOHAA clients (#779 )

Move third party code to code/thirdparty
Co-authored-by: smallmodel <15067410+smallmodel@users.noreply.github.com>
2026-10-23 22:00:25 +02:00 · 2025-08-03 02:21:35 +02:00 · 2025-08-02 23:19:02 +02:00 · 2025-08-02 23:00:57 +02:00 · 2025-08-02 22:58:22 +02:00 · 2025-08-02 22:53:13 +02:00
1938 changed files with 339363 additions and 269987 deletions
@@ -0,0 +1,39 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots (OPTIONAL)**
+If applicable, add screenshots to help explain your problem.
+
+**Logs**
+- Paste the output of the console window in a text file, and attach the text file.
+- If applicable (`logfile` set to 2), attach the `qconsole.log` file. On Windows, it can be found in **%APPDATA%\...\qconsole.log** and on Linux, it can be found on the home directory **~/.openmohaa/.../qconsole.log**.
+
+**Version information (please complete the following information):**
+ - OS: [e.g. `Debian`]
+ - OS Version [e.g `12`]
+ - OpenMoHAA Version: [e.g `0.70.0-alpha+0.0b1a20dcf win_msvc64-x86_64-debug`, can be found below **Common Initialization** in the console, or by typing `version`]
+
+**Dump (OPTIONAL)**
+You can include a core dump generated by the OS (`.dmp` file). If you compiled OpenMoHAA yourself, also add all output openmohaa binaries (except libopenal and libSDL).
+
+**Additional context (OPTIONAL)**
+Add any other context about the problem here.
@@ -0,0 +1,77 @@
+name: "Builds"
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: write
+
+jobs:
+  build-all:
+   uses: ./.github/workflows/shared-build.yml
+   with:
+      environment: 'testing'
+
+  # Initially create a release with 1 job
+  # so multiple files can be uploaded at the same time afterwards
+  create-release:
+    if: github.event_name != 'pull_request' && github.ref_name == 'main'
+    runs-on: ubuntu-24.04
+    environment: 'testing'
+    needs: [build-all]
+
+    steps:
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        prerelease: true
+        name: '${{github.ref_name}}-${{github.sha}}'
+        tag_name: 'dev'
+
+  deploy-release:
+    if: github.event_name != 'pull_request' && github.ref_name == 'main'
+    strategy:
+      matrix:
+        target_os: [
+          'linux-amd64',
+          'linux-i686',
+          'linux-arm64',
+          'linux-armhf',
+          'linux-powerpc',
+          'linux-ppc64',
+          'linux-ppc64el',
+          'windows-x64-pdb',
+          'windows-x86-pdb',
+          'windows-arm64-pdb',
+          'macos-multiarch-arm64-x86_64',
+        ]
+
+    runs-on: ubuntu-24.04
+    environment: 'testing'
+    needs: [create-release]
+
+    env:
+      RELEASE_NAME: ${{github.event.repository.name}}-dev-${{matrix.target_os}}
+
+    steps:
+    - uses: actions/download-artifact@v4
+      with:
+        name: 'out-${{matrix.target_os}}'
+        path: ${{github.workspace}}/${{matrix.target_os}}
+
+    - name: Zip
+      working-directory: '${{github.workspace}}/${{matrix.target_os}}'
+      run: zip -r "../${{env.RELEASE_NAME}}.zip" ./
+
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        tag_name: 'dev'
+        files: ${{github.workspace}}/${{env.RELEASE_NAME}}.zip
@@ -1,192 +0,0 @@
-name: Build
-
-on:
-  push:
-  pull_request:
-  workflow_call:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-env:
-  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
-  BUILD_TYPE: RelWithDebInfo
-
-jobs:
-  build-platform-linux:
-    strategy:
-      matrix:
-        architecture: [
-          {name: 'amd64',   triple: 'x86_64-linux-gnu'},
-          {name: 'i686',    triple: 'i686-linux-gnu'},
-          {name: 'aarch64', triple: 'aarch64-linux-gnu'},
-          {name: 'armhf',   triple: 'arm-linux-gnueabihf'}
-        ]
-
-    name: "Building for platform linux-${{matrix.architecture.name}}"
-    runs-on: ubuntu-22.04
-
-    steps:
-    - name: Settings
-      working-directory: ${{github.workspace}}
-      run: |
-        echo "CMAKE_BUILD_PARALLEL_LEVEL=$(($(nproc) * 16))" >> $GITHUB_ENV
-#       echo "CMAKE_GENERATOR=Ninja" >> $GITHUB_ENV
-
-    - name: Install required packages
-      run: |
-        sudo apt update && sudo apt install -y flex bison
-  
-    - name: Install required cross-platform packages (${{ matrix.architecture.triple }})
-      if: matrix.architecture.name != 'amd64'
-      run: sudo apt install -y gcc-12-${{ matrix.architecture.triple }} g++-12-${{ matrix.architecture.triple }}
-
-    # Setup SDL
-    - name: Set up SDL
-      id: sdl
-      uses: libsdl-org/setup-sdl@main
-      with:
-        version: sdl2-latest
-        build-type: Release
-        cmake-arguments: "-DCMAKE_C_COMPILER=clang
-          -DCMAKE_CXX_COMPILER=clang++
-          -DCMAKE_C_FLAGS=--target=${{ matrix.architecture.triple }}
-          -DCMAKE_CXX_FLAGS=--target=${{ matrix.architecture.triple }}"
-
-    - uses: actions/checkout@v3
-      with:
-        path: 'source'
-
-    - name: CMake Settings
-      run: |
-        echo "CMAKE_PARAM=--log-level=VERBOSE \
-        -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} \
-        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' \
-        -DCMAKE_C_COMPILER=clang \
-        -DCMAKE_CXX_COMPILER=clang++ \
-        -DCMAKE_C_FLAGS=--target=${{ matrix.architecture.triple }} \
-        -DCMAKE_CXX_FLAGS=--target=${{ matrix.architecture.triple }} \
-        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }}" >> $GITHUB_ENV
-
-    - name: Configure CMake
-      working-directory: ${{github.workspace}}
-      run: |
-        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
-
-    - name: Build
-      working-directory: ${{github.workspace}}
-      run: |
-        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
-
-    - name: Test
-      working-directory: ${{github.workspace}}
-      # Execute tests defined by the CMake configuration.
-      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
-      run: |
-        cd "${{github.workspace}}/build"
-        ctest -C ${{env.BUILD_TYPE}}
-
-    - name: Install
-      working-directory: ${{github.workspace}}
-      # Install to the directory defined in CMAKE_INSTALL_PREFIX
-      run: |
-        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
-        cp '${{steps.sdl.outputs.prefix}}/lib/libSDL2.so' '${{github.workspace}}/install'
-
-    - uses: actions/upload-artifact@v3
-      with:
-        name: out-linux-${{matrix.architecture.name}}
-        if-no-files-found: error
-        path:
-          ${{github.workspace}}/install
-
-  build-platform-windows:
-    strategy:
-      matrix:
-        architecture: [
-          {name: 'x64',   config: 'x64' },
-          {name: 'x86',   config: 'Win32' },
-          {name: 'arm64', config: 'ARM64' }
-        ]
-
-    name: "Building for platform windows-${{matrix.architecture.name}}"
-    runs-on: windows-2022
-
-    steps:
-    - name: Settings
-      working-directory: ${{github.workspace}}
-      run: |
-        echo "CMAKE_BUILD_PARALLEL_LEVEL=$((Get-CimInstance Win32_ComputerSystem).NumberOfLogicalProcessors * 16)" >> $GITHUB_ENV
-
-        # Setup SDL
-    - name: Set up SDL
-      id: sdl
-      uses: libsdl-org/setup-sdl@main
-      with:
-        version: sdl2-latest
-        build-type: Release
-        cmake-arguments: "-A ${{ matrix.architecture.config }}"
-
-    - name: Install Flex/Bison
-      working-directory: ${{github.workspace}}
-      run: |
-        mkdir thirdparties && cd thirdparties
-        git clone --depth 1 --single-branch --branch v2.5.25 https://github.com/lexxmark/winflexbison.git
-        cmake -B winflexbison-build -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/winflexbison-install' ./winflexbison
-        cmake --build winflexbison-build --config Release --parallel
-        cmake --install winflexbison-build
-
-    - uses: actions/checkout@v3
-      with:
-        path: 'source'
-
-    - name: CMake Settings
-      run: |
-        echo "CMAKE_PARAM=-A ${{ matrix.architecture.config }} `
-        --log-level=VERBOSE `
-        -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} `
-        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' `
-        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }} `
-        -DBISON_EXECUTABLE='${{github.workspace}}/thirdparties/winflexbison-install/win_bison.exe' `
-        -DFLEX_EXECUTABLE='${{github.workspace}}/thirdparties/winflexbison-install/win_flex.exe'".Replace("`r", "").Replace("`n", "") >> $env:GITHUB_ENV
-
-    - name: Configure CMake
-      working-directory: ${{github.workspace}}
-      run: |
-        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
-
-    - name: Build
-      working-directory: ${{github.workspace}}
-      run: |
-        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
-
-    - name: Test
-      working-directory: ${{github.workspace}}
-      # Execute tests defined by the CMake configuration.
-      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
-      run: |
-        cd "${{github.workspace}}/build"
-        ctest -C ${{env.BUILD_TYPE}}
-
-    - name: Install
-      working-directory: ${{github.workspace}}
-      # Install to the directory defined in CMAKE_INSTALL_PREFIX
-      run: |
-        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
-        Copy-Item '${{steps.sdl.outputs.prefix}}/bin/*.dll' -Destination '${{github.workspace}}/install'
-
-    - uses: actions/upload-artifact@v3
-      with:
-        name: out-windows-${{matrix.architecture.name}}
-        if-no-files-found: error
-        path: |
-          ${{github.workspace}}/install
-          !${{github.workspace}}/install/**/*.pdb
-
-    - uses: actions/upload-artifact@v3
-      with:
-        name: out-windows-${{matrix.architecture.name}}-pdb
-        if-no-files-found: error
-        path: |
-          ${{github.workspace}}/install
@@ -0,0 +1,60 @@
+name: "Generate Documentation"
+
+on:
+    push:
+      branches:
+        - 'main'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get and install Doxygen
+        run: |
+            wget https://github.com/doxygen/doxygen/releases/download/Release_1_13_2/doxygen-1.13.2.linux.bin.tar.gz -O doxygen.tar.gz
+            tar xzf doxygen.tar.gz
+            cd doxygen-*
+            sudo cp bin/doxygen /usr/local/bin/
+
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          path: 'source'
+
+      - name: Generate Documentation (Doxygen)
+        working-directory: ${{github.workspace}}/source
+        run: |
+            version_file=$(cat code/qcommon/q_version.h)
+            PRODUCT_VERSION_MAJOR=$(echo "$version_file" | grep -E "define[ \t]+PRODUCT_VERSION_MAJOR" | awk -F'[ \t]+' '{print $3""}' | tr -d '\r\n')
+            PRODUCT_VERSION_MINOR=$(echo "$version_file" | grep -E "define[ \t]+PRODUCT_VERSION_MINOR" | awk -F'[ \t]+' '{print $3""}' | tr -d '\r\n')
+            PRODUCT_VERSION_PATCH=$(echo "$version_file" | grep -E "define[ \t]+PRODUCT_VERSION_PATCH" | awk -F'[ \t]+' '{print $3""}' | tr -d '\r\n')
+            export PROJECT_VERSION_NUMBER="$PRODUCT_VERSION_MAJOR.$PRODUCT_VERSION_MINOR.$PRODUCT_VERSION_PATCH"
+            doxygen docs/Doxyfile
+
+      - name: Upload static files as artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ${{github.workspace}}/source/docs/doxygen/html
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    runs-on: ubuntu-latest
+    needs: build
+
+    # Permissions for deploying the page
+    permissions:
+      pages: write
+      id-token: write
+
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+
@@ -20,6 +20,10 @@ on:
  schedule:
    - cron: '42 8 * * 1'

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  analyze:
    name: Analyze
@@ -41,7 +45,13 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
+
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required packages
+      with:
+        packages: libopenal-dev libpulse-dev portaudio19-dev libasound2-dev libjack-dev libpipewire-0.3-dev qtbase5-dev libdbus-1-dev
+        version: "0.1"

    # Setup SDL
    - name: Set up SDL
@@ -52,7 +62,7 @@ jobs:

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v3
      with:
        languages: ${{ matrix.language }}
        # If you wish to specify custom queries, you can do so here or in a config file.
@@ -66,7 +76,7 @@ jobs:
    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
+      uses: github/codeql-action/autobuild@v3

    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
@@ -79,6 +89,6 @@ jobs:
    #     ./location_of_script_within_repo/buildscript.sh

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v3
      with:
        category: "/language:${{matrix.language}}"
@@ -1,60 +0,0 @@
-name: Publish artifacts
-
-on:
-  push:
-    tags:
-        - "v*.*.*"
-
-env:
-  RELEASE_TYPE: ${{ vars.RELEASE_TYPE || 'test' }}
-  RELEASE_IS_PRERELEASE: ${{ vars.RELEASE_IS_PRELEASE }}
-
-permissions:
-  contents: write
-
-jobs:
-  build-all:
-   uses: ./.github/workflows/build-cmake.yml
-
-  deploy_all:
-    strategy:
-      # Set the maximum number of parallel jobs to 1, to avoid a race-condition
-      # while creating a new release
-      max-parallel: 1
-      matrix:
-        target_os: [
-          'linux-amd64',
-          'linux-i686',
-          'linux-aarch64',
-          'linux-armhf',
-          'windows-x64',
-          'windows-x86',
-          'windows-x64-pdb',
-          'windows-x86-pdb',
-          'windows-arm64',
-          'windows-arm64-pdb'
-        ]
-
-    runs-on: ubuntu-22.04
-    environment: release
-    needs: [build-all]
-
-    env:
-      RELEASE_NAME: ${{ github.event.repository.name }}-${{github.ref_name}}-${{matrix.target_os}}
-
-    steps:
-    - uses: actions/download-artifact@v3
-      with:
-        name: 'out-${{matrix.target_os}}'
-        path: ${{github.workspace}}/${{matrix.target_os}}
-
-    - name: Zip
-      working-directory: ${{github.workspace}}/${{matrix.target_os}}
-      run: zip -r ../${{ env.RELEASE_NAME }}.zip ./
-
-    - name: Release
-      uses: softprops/action-gh-release@v1
-      with:
-        name: '${{github.ref_name}}-${{env.RELEASE_TYPE}}'
-        prerelease: ${{env.RELEASE_IS_PRERELEASE}}
-        files: ${{github.workspace}}/${{ env.RELEASE_NAME }}.zip
@@ -0,0 +1,256 @@
+##########################
+#
+# Linux
+# Ubuntu 22.04
+#
+# Using this version instead of 24.04 to use a lower GLIBC version (2.34).
+# ARM is used for more efficiency, and x64 is used for legacy architectures like PowerPC.
+##########################
+name: "Linux Builds"
+
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+        
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: RelWithDebInfo
+  RELEASE_STAGE: ${{ vars.RELEASE_STAGE || 'unstable' }}
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        architecture: [
+          {name: 'amd64',   os: "ubuntu-22.04-arm", package: 'x86-64-linux-gnu',      triple: 'x86_64-linux-gnu',      arch_option: 'linux-x86_64'},
+          {name: 'i686',    os: "ubuntu-22.04-arm", package: 'i686-linux-gnu',        triple: 'i686-linux-gnu',        arch_option: 'linux-x86'},
+          {name: 'arm64',   os: "ubuntu-22.04-arm", package: 'aarch64-linux-gnu',     triple: 'aarch64-linux-gnu',     arch_option: 'linux-aarch64'},
+          {name: 'armhf',   os: "ubuntu-22.04-arm", package: 'arm-linux-gnueabihf',   triple: 'arm-linux-gnueabihf',   arch_option: 'linux-armv4'},
+          {name: 'powerpc', os: "ubuntu-22.04",     package: 'powerpc-linux-gnu',     triple: 'powerpc-linux-gnu',     arch_option: 'linux-ppc'},
+          {name: 'ppc64',   os: "ubuntu-22.04",     package: 'powerpc64-linux-gnu',   triple: 'powerpc64-linux-gnu',   arch_option: 'linux-ppc64'},
+          {name: 'ppc64el', os: "ubuntu-22.04-arm", package: 'powerpc64le-linux-gnu', triple: 'powerpc64le-linux-gnu', arch_option: 'linux-ppc64le'}
+        ]
+
+    name: "Building for platform linux-${{matrix.architecture.name}}"
+    runs-on: ${{ matrix.architecture.os }}
+    environment: ${{ inputs.environment }}
+    env:
+        wolfssl-version: 'v5.7.6-stable'
+        curl-version: '8_12_1'
+        openal-soft-branch: '1.24.3'
+        sdl2-branch: 'release-2.32.8'
+
+    steps:
+    ###
+    # Packages
+    ###
+
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required packages
+      with:
+        packages: flex bison ninja-build cmake clang libpulse-dev portaudio19-dev libasound2-dev libjack-dev libpipewire-0.3-dev qtbase5-dev libdbus-1-dev
+        version: "${{ runner.os }}-${{ runner.arch }}-v1"
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "HOST_TRIPLE=$(gcc -dumpmachine)" >> $GITHUB_ENV
+
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required cross-platform packages (${{ matrix.architecture.package }})
+      if: env.HOST_TRIPLE != matrix.architecture.triple
+      with:
+        packages: gcc-12-${{ matrix.architecture.package }} g++-12-${{ matrix.architecture.package }}
+        version: "${{ runner.os }}-${{ runner.arch }}-v1"
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "CMAKE_GENERATOR=Ninja Multi-Config" >> $GITHUB_ENV
+        echo "CC=clang" >> $GITHUB_ENV
+        echo "CXX=clang++" >> $GITHUB_ENV
+        echo "CFLAGS='--target=${{ matrix.architecture.triple }}'" >> $GITHUB_ENV
+        echo "CXXFLAGS='--target=${{ matrix.architecture.triple }}'" >> $GITHUB_ENV
+
+    ###
+    # SDL
+    ###
+
+    # Cache SDL
+    - name: Cache SDL2
+      id: cache-sdl2
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/SDL2/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-sdl2-${{ env.sdl2-branch }}-v1
+
+    # SDL2 setup
+    - name: Checkout SDL2
+      if: steps.cache-sdl2.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'libsdl-org/SDL'
+        path: 'thirdparties/SDL2'
+        ref: '${{ env.sdl2-branch }}'
+
+    - name: Configure and install SDL2
+      if: steps.cache-sdl2.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/SDL2
+      run: |
+        cmake -B ./build \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/SDL2/install'
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # OpenAL
+    ###
+    - name: Cache OpenAL
+      id: cache-openal-soft
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/soft-oal/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-openal-soft-${{ env.openal-soft-branch }}-v1
+
+    # soft-oal setup
+    - name: Checkout soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: '${{ env.openal-soft-branch }}'
+
+    - name: Configure and install soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/soft-oal
+      run: |
+        cmake -B ./build \
+        -DALSOFT_UTILS=OFF \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/soft-oal/install'
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # WolfSSL
+    ###
+    - name: Cache WolfSSL
+      id: cache-wolfssl
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/wolfssl/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-wolfssl-${{ env.wolfssl-version }}-v1
+
+    # WolfSSL setup
+    - name: Checkout WolfSSL
+      if: steps.cache-wolfssl.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'wolfssl/wolfssl'
+        path: 'thirdparties/wolfssl'
+        ref: '${{ env.wolfssl-version }}'
+
+    # WolfSSL build
+    - name: Configure and install wolfssl
+      if: steps.cache-wolfssl.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/wolfssl
+      run: |
+        cmake -B ./build \
+            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/wolfssl/install' \
+            -DCMAKE_C_FLAGS="$CFLAGS -fPIC" \
+            -DCMAKE_CXX_FLAGS="$CFLAGS -fPIC" \
+            -DBUILD_SHARED_LIBS=OFF -DWOLFSSL_OPENSSLEXTRA=ON -DWOLFSSL_ASM=OFF -DWOLFSSL_EXAMPLES=OFF -DWOLFSSL_CURL=ON
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # cURL
+    ###
+    - name: Cache cURL
+      id: cache-curl
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/curl/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-curl-${{ env.curl-version }}-v1
+
+    # cURL setup
+    - name: Checkout cURL
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'curl/curl'
+        path: 'thirdparties/curl'
+        ref: 'curl-${{ env.curl-version }}'
+
+    # cURL build
+    - name: Configure and install curl
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/curl
+      run: |
+        cmake -B ./build \
+            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/curl/install' \
+            -DCURL_USE_LIBPSL=OFF \
+            -DCURL_USE_WOLFSSL=ON \
+            -DCURL_ZLIB="" \
+            -DCURL_BROTLI="" \
+            -DCURL_ZSTD="" \
+            -DCMAKE_SHARED_LINKER_FLAGS="-lm" \
+            -DWolfSSL_ROOT='${{github.workspace}}/thirdparties/wolfssl/install'
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # Project
+    ###
+
+    - uses: actions/checkout@v4
+      with:
+        path: 'source'
+
+    - name: CMake Settings
+      run: |
+        echo "CMAKE_PARAM=--log-level=VERBOSE \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' \
+        -DSDL2_DIR='${{github.workspace}}/thirdparties/SDL2/install/lib/cmake/SDL2' \
+        -DOPENAL_LIBRARY='${{github.workspace}}/thirdparties/soft-oal' \
+        -DOPENAL_INCLUDE_DIR='${{github.workspace}}/thirdparties/soft-oal/install/include' \
+        -DCURL_ROOT='${{github.workspace}}/thirdparties/curl/install' \
+        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }} \
+        -DPRODUCT_VERSION_STAGE='${{ env.RELEASE_STAGE }}'" >> $GITHUB_ENV
+
+    - name: Configure CMake
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
+
+    - name: Build
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Install
+      working-directory: ${{github.workspace}}
+      # Install to the directory defined in CMAKE_INSTALL_PREFIX
+      run: |
+        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+        # Copy libraries
+        mkdir ${{github.workspace}}/package
+        cp -l ${{github.workspace}}/thirdparties/SDL2/install/lib/libSDL2-2.0.so.0 '${{github.workspace}}/package/'
+        cp -l ${{github.workspace}}/thirdparties/soft-oal/install/lib/libopenal.so.1 '${{github.workspace}}/package/'
+        cp -l ${{github.workspace}}/thirdparties/curl/install/lib*/libcurl.so.4 '${{github.workspace}}/package/'
+        if [ -d ${{github.workspace}}/install/bin ]; then cp -r ${{github.workspace}}/install/bin/openmohaa/. '${{github.workspace}}/package'; fi
+        if [ -d ${{github.workspace}}/install/lib ]; then cp -r ${{github.workspace}}/install/lib/openmohaa/. '${{github.workspace}}/package'; fi
+
+    ###
+    # Artifacts
+    ###
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-linux-${{matrix.architecture.name}}
+        if-no-files-found: error
+        path:
+          ${{github.workspace}}/package
@@ -0,0 +1,250 @@
+##########################
+#
+# Apple macOS
+# macOS 15
+#
+# This version is used as the OS, as it's faster than other versions.
+##########################
+name: "macOS Builds"
+
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+        
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: RelWithDebInfo
+  RELEASE_STAGE: ${{ vars.RELEASE_STAGE || 'unstable' }}
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        architecture: [
+          #{name: 'x86_64',   triple: 'x86_64-apple-macos10.8'},
+          #{name: 'arm64',    triple: 'arm64-apple-macos11'}
+          #{name: 'x86_64',    build_name: 'x86_64'},
+          #{name: 'arm64',     build_name: 'arm64'},
+          # Compile into an universal binary
+          {name: 'multiarch-arm64-x86_64', build_name: 'arm64;x86_64' }
+        ]
+
+    name: "Building for platform macos-${{matrix.architecture.name}}"
+    runs-on: "macos-15"
+    env:
+        openal-soft-branch: '1.24.3'
+        wolfssl-version: 'v5.7.6-stable'
+        curl-version: '8_12_1'
+        sdl2-branch: 'release-2.32.8'
+
+    steps:
+    ###
+    # Packages
+    ###
+
+    - name: Install required packages
+      run: |
+        brew install git flex bison ninja cmake llvm perl
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "CMAKE_GENERATOR=Ninja Multi-Config" >> $GITHUB_ENV
+        echo "CC=clang" >> $GITHUB_ENV
+        echo "CXX=clang++" >> $GITHUB_ENV
+        echo "MACOSX_DEPLOYMENT_TARGET=10.15" >> $GITHUB_ENV
+
+    ###
+    # SDL
+    ###
+
+    # Cache SDL
+    - name: Cache SDL2
+      id: cache-sdl2
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/SDL2/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-sdl2-${{ env.sdl2-branch }}-v1
+
+    # SDL2 setup
+    - name: Checkout SDL2
+      if: steps.cache-sdl2.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'libsdl-org/SDL'
+        path: 'thirdparties/SDL2'
+        ref: '${{ env.sdl2-branch }}'
+
+    - name: Configure and install SDL2
+      if: steps.cache-sdl2.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/SDL2
+      run: |
+        cmake -B ./build \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/SDL2/install' \
+        -DCMAKE_OSX_ARCHITECTURES='${{ matrix.architecture.build_name }}'
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # OpenAL
+    ###
+    - name: Cache OpenAL
+      id: cache-openal-soft
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/soft-oal/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-openal-soft-${{ env.openal-soft-branch }}-v1
+
+    # soft-oal setup
+    # Use GCC instead of Clang because of missing SSE intrinsics
+    # It also doesn't enable altivec support on PowerPC by default
+    - name: Checkout soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: '${{ env.openal-soft-branch }}'
+
+    # soft-oal build
+    - name: Configure and install soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/soft-oal
+      run: |
+        cmake -B ./build \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/soft-oal/install' \
+        -DCMAKE_OSX_ARCHITECTURES='${{ matrix.architecture.build_name }}' \
+        -DCMAKE_VERBOSE_MAKEFILE=on
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # WolfSSL
+    ###
+# FIXME: Figure out how to compile WolfSSL cross-architecture
+#
+#    - name: Cache WolfSSL
+#      id: cache-wolfssl
+#      uses: actions/cache@v4
+#      with:
+#        path: 'thirdparties/wolfssl_install'
+#        key: ${{ runner.os }}-${{ matrix.architecture.name }}-wolfssl-${{ env.wolfssl-version }}-v1
+#
+#    # WolfSSL setup
+#    - name: Checkout WolfSSL
+#      if: steps.cache-wolfssl.outputs.cache-hit != 'true'
+#      uses: actions/checkout@v4
+#      with:
+#        repository: 'wolfssl/wolfssl'
+#        path: 'thirdparties/wolfssl'
+#        ref: '${{ env.wolfssl-version }}'
+#
+#    # WolfSSL build
+#    - name: Configure and install wolfssl
+#      if: steps.cache-wolfssl.outputs.cache-hit != 'true'
+#      working-directory: ${{github.workspace}}/thirdparties/wolfssl
+#      run: |
+#        cmake -B ./build \
+#            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/wolfssl_install' \
+#            -DCMAKE_OSX_ARCHITECTURES='${{ matrix.architecture.build_name }}' \
+#            -DBUILD_SHARED_LIBS=OFF -DWOLFSSL_OPENSSLEXTRA=ON -DWOLFSSL_ASM=OFF -DWOLFSSL_EXAMPLES=OFF -DWOLFSSL_CURL=ON
+#        cmake --build ./build --config Release --parallel
+#        cmake --install ./build --config Release
+
+    ###
+    # cURL
+    ###
+    - name: Cache cURL
+      id: cache-curl
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/curl/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-curl-${{ env.curl-version }}-v1
+
+    # cURL setup
+    - name: Checkout cURL
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'curl/curl'
+        path: 'thirdparties/curl'
+        ref: 'curl-${{ env.curl-version }}'
+
+    # cURL build
+    - name: Configure and install curl
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/curl
+      run: |
+        cmake -B ./build \
+            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/curl/install' \
+            -DCMAKE_OSX_ARCHITECTURES='${{ matrix.architecture.build_name }}' \
+            -DCURL_USE_LIBPSL=OFF \
+            -DCURL_USE_WOLFSSL=OFF \
+            -DCURL_USE_LIBSSH2=OFF \
+            -DUSE_LIBIDN2=OFF \
+            -DUSE_NGHTTP2=OFF \
+            -DCURL_ENABLE_SSL=OFF \
+            -DCURL_ZLIB="" \
+            -DCURL_BROTLI="" \
+            -DCURL_ZSTD="" \
+            -DWolfSSL_ROOT='${{github.workspace}}/thirdparties/wolfssl_install'
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # Project
+    ###
+
+    - uses: actions/checkout@v4
+      with:
+        path: 'source'
+
+    - name: CMake Settings
+      run: |
+        echo "CMAKE_PARAM=--log-level=VERBOSE \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' \
+        -DCMAKE_VERBOSE_MAKEFILE=on \
+        -DCMAKE_OSX_ARCHITECTURES='${{ matrix.architecture.build_name }}' \
+        -DSDL2_DIR='${{github.workspace}}/thirdparties/SDL2/install/lib/cmake/SDL2' \
+        -DOPENAL_LIBRARY='${{github.workspace}}/thirdparties/soft-oal/install' \
+        -DOPENAL_INCLUDE_DIR='${{github.workspace}}/thirdparties/soft-oal/install/include/AL' \
+        -DCURL_ROOT='${{github.workspace}}/thirdparties/curl/install' \
+        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }} \
+        -DPRODUCT_VERSION_STAGE='${{ env.RELEASE_STAGE }}'" >> $GITHUB_ENV
+
+    - name: Configure CMake
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
+
+    - name: Build
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Install
+      working-directory: ${{github.workspace}}
+      # Install to the directory defined in CMAKE_INSTALL_PREFIX
+      run: |
+        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+        # Create hard-link and copy symbolic links
+        mkdir ${{github.workspace}}/package
+        cp -l ${{github.workspace}}/thirdparties/SDL2/install/lib/libSDL2-2.0.0.dylib '${{github.workspace}}/package/'
+        cp -l ${{github.workspace}}/thirdparties/soft-oal/install/lib/libopenal.1.dylib '${{github.workspace}}/package/'
+        cp -l ${{github.workspace}}/thirdparties/curl/install/lib*/libcurl.4.dylib '${{github.workspace}}/package/'
+        if [ -d ${{github.workspace}}/install/bin ]; then cp -r ${{github.workspace}}/install/bin/openmohaa/. '${{github.workspace}}/package'; fi
+        if [ -d ${{github.workspace}}/install/lib ]; then cp -r ${{github.workspace}}/install/lib/openmohaa/. '${{github.workspace}}/package'; fi
+
+    ###
+    # Artifacts
+    ###
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-macos-${{matrix.architecture.name}}
+        if-no-files-found: error
+        path:
+          ${{github.workspace}}/package
@@ -0,0 +1,289 @@
+##########################
+#
+# Microsoft Windows
+# Windows Server 2025
+#
+##########################
+name: "Windows Builds"
+
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+        
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: RelWithDebInfo
+  RELEASE_STAGE: ${{ vars.RELEASE_STAGE || 'unstable' }}
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        architecture: [
+          {name: 'x64',   os: 'windows-2025',   config: 'x64',    toolset: 'x64',        arch_option: 'VC-WIN64A'    },
+          {name: 'x86',   os: 'windows-2025',   config: 'Win32',  toolset: 'x64_x86',    arch_option: 'VC-WIN32'     },
+          {name: 'arm64', os: 'windows-11-arm', config: 'ARM64',  toolset: 'x64_arm64',  arch_option: 'VC-WIN64-ARM' }
+        ]
+
+    name: "Building for platform windows-${{matrix.architecture.name}}"
+    runs-on: ${{ matrix.architecture.os }}
+    environment: ${{ inputs.environment }}
+    env:
+        flexbison-branch: 'v2.5.25'
+        wolfssl-version: 'v5.7.6-stable'
+        curl-version: '8_12_1'
+        openal-soft-branch: '1.24.3'
+        sdl2-branch: 'release-2.32.8'
+
+    steps:
+    ###
+    # Packages
+    ###
+
+    - name: Cache Flex/Bison
+      id: cache-flexbison
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/winflexbison-install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-flexbison-${{ env.flexbison-branch }}-v1
+
+    - name: Install Flex/Bison
+      if: steps.cache-flexbison.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}
+      run: |
+        mkdir thirdparties && cd thirdparties
+        git clone --depth 1 --single-branch --branch ${{ env.flexbison-branch }} https://github.com/lexxmark/winflexbison.git
+        cmake -B winflexbison-build -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/winflexbison-install' ./winflexbison
+        cmake --build winflexbison-build --config Release --parallel
+        cmake --install winflexbison-build --config Release
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "CMAKE_GENERATOR=Ninja Multi-Config" >> $env:GITHUB_ENV
+        echo "CC=cl.exe" >> $env:GITHUB_ENV
+        echo "CXX=cl.exe" >> $env:GITHUB_ENV
+        pushd "$($env:PROGRAMFILES)\Microsoft Visual Studio\*\*\VC\Auxiliary\Build"
+        cmd /c "vcvarsall.bat ${{ matrix.architecture.toolset }} & set" | ForEach-Object {
+          if ($_ -match "=") {
+            # Split into key=value
+            $var = $_.split("=", 2);
+            echo "$($var[0])=$($var[1])" >> $env:GITHUB_ENV
+          }
+        }
+        popd
+
+    - name: Cache Required Packages
+      id: cache-required-packages
+      uses: actions/cache@v4
+      with:
+        path: 'C:\Packages'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-required-packages-v1
+
+    - name: Install required packages
+      if: steps.cache-required-packages.outputs.cache-hit != 'true'
+      run: |
+        $DownloadPath="$($env:USERPROFILE)\Downloads"
+        if ("${{ matrix.architecture.config }}" -ieq "ARM64") {
+          Invoke-WebRequest "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-winarm64.zip" -OutFile "$DownloadPath\ninja-win.zip"
+        } else {
+          Invoke-WebRequest "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-win.zip" -OutFile "$DownloadPath\ninja-win.zip"
+        }
+        Expand-Archive -Path "$DownloadPath\ninja-win.zip" -DestinationPath "C:\Packages\ninja"
+        Invoke-WebRequest "https://download.qt.io/official_releases/jom/jom.zip" -OutFile "$DownloadPath\jom.zip"
+        Expand-Archive -Path "$DownloadPath\jom.zip" -DestinationPath "C:\Packages\jom"
+
+    - name: Setup required packages path
+      run: |
+        $env:PATH += ";C:\Packages\ninja;C:\Packages\jom;"
+        echo "PATH=$($env:PATH)" >> $env:GITHUB_ENV
+        if ("${{ matrix.architecture.config }}" -ieq "ARM64") {
+            # Workaround against linking errors related to interlocked functions
+            echo "CFLAGS=/forceInterlockedFunctions-" >> $env:GITHUB_ENV
+        }
+
+    ###
+    # SDL
+    ###
+
+    # Cache SDL
+    - name: Cache SDL2
+      id: cache-sdl2
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/SDL2/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-sdl2-${{ env.sdl2-branch }}-v1
+
+    # SDL2 setup
+    - name: Checkout SDL2
+      if: steps.cache-sdl2.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'libsdl-org/SDL'
+        path: 'thirdparties/SDL2'
+        ref: '${{ env.sdl2-branch }}'
+
+    - name: Configure and install SDL2
+      if: steps.cache-sdl2.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/SDL2
+      run: |
+        cmake -B ./build `
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/SDL2/install'
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # OpenAL
+    ###
+    - name: Cache OpenAL
+      id: cache-openal-soft
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/soft-oal/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-openal-soft-${{ env.openal-soft-branch }}-v1
+
+    # soft-oal setup
+    - name: Checkout soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'kcat/openal-soft'
+        path: 'thirdparties/soft-oal'
+        ref: '${{ env.openal-soft-branch }}'
+
+    # soft-oal build
+    # Statically link the CRT runtime into OAL as a workaround to prevent crashes
+    - name: Configure and install soft-oal
+      if: steps.cache-openal-soft.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/soft-oal
+      run: |
+        cmake -B ./build `
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/soft-oal/install' `
+        -DALSOFT_BUILD_ROUTER=OFF `
+        -DALSOFT_REQUIRE_WINMM=ON `
+        -DALSOFT_REQUIRE_DSOUND=ON `
+        -DALSOFT_REQUIRE_WASAPI=ON `
+        -DCMAKE_C_FLAGS_RELEASE="/MT /O2 /Ob2 /DNDEBUG" `
+        -DCMAKE_CXX_FLAGS_RELEASE="/MT /O2 /Ob2 /DNDEBUG" `
+        -DCMAKE_C_FLAGS_MINSIZEREL="/MT /O2 /Ob2 /DNDEBUG" `
+        -DCMAKE_CXX_FLAGS_MINSIZEREL="/MT /O1 /Ob1 /DNDEBUG" `
+        -DCMAKE_C_FLAGS_RELWITHDEBINFO="/MT /Zi /O2 /Ob1 /DNDEBUG" `
+        -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="/MT /Zi /O2 /Ob1 /DNDEBUG"
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+        # Unfortunately soft-oal produces a binary called OpenAL32 even in 64-bit
+        if (("x64", "ARM64") -icontains "${{ matrix.architecture.config }}") { Rename-Item -Path '.\install\bin\OpenAL32.dll' -NewName 'OpenAL64.dll' }
+
+    ###
+    # cURL
+    #
+    # Uses Schannel as SSL backend, native CAs are used
+    ###
+    - name: Cache cURL
+      id: cache-curl
+      uses: actions/cache@v4
+      with:
+        path: 'thirdparties/curl/install'
+        key: ${{ runner.os }}-${{ matrix.architecture.name }}-curl-${{ env.curl-version }}-v1
+
+    # cURL setup
+    - name: Checkout cURL
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      uses: actions/checkout@v4
+      with:
+        repository: 'curl/curl'
+        path: 'thirdparties/curl'
+        ref: 'curl-${{ env.curl-version }}'
+
+    # cURL build
+    - name: Configure and install curl
+      if: steps.cache-curl.outputs.cache-hit != 'true'
+      working-directory: ${{github.workspace}}/thirdparties/curl
+      run: |
+        cmake -B ./build `
+            -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/thirdparties/curl/install' `
+            -DCURL_USE_LIBPSL=OFF `
+            -DCURL_USE_SCHANNEL=ON
+        cmake --build ./build --config Release --parallel
+        cmake --install ./build --config Release
+
+    ###
+    # Project
+    ###
+
+    - uses: actions/checkout@v4
+      with:
+        path: 'source'
+
+    - name: CMake Settings
+      run: |
+        echo "CMAKE_PARAM= `
+        --log-level=VERBOSE `
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install' `
+        -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=true `
+        -DGIT_REVISION_BUILD_NUMBER=${{ github.run_number }} `
+        -DBISON_EXECUTABLE='${{github.workspace}}/thirdparties/winflexbison-install/win_bison.exe' `
+        -DSDL2_DIR='${{github.workspace}}/thirdparties/SDL2/install/cmake' `
+        -DOPENAL_LIBRARY='${{github.workspace}}/thirdparties/soft-oal' `
+        -DOPENAL_INCLUDE_DIR='${{github.workspace}}/thirdparties/soft-oal/install/include' `
+        -DCURL_ROOT='${{github.workspace}}/thirdparties/curl/install' `
+        -DFLEX_EXECUTABLE='${{github.workspace}}/thirdparties/winflexbison-install/win_flex.exe' `
+        -DPRODUCT_VERSION_STAGE='${{ env.RELEASE_STAGE }}'".Replace("`r", "").Replace("`n", "") >> $env:GITHUB_ENV
+
+    - name: Configure CMake
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
+
+    - name: Build
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel
+
+    - name: Install
+      working-directory: ${{github.workspace}}
+      # Install to the directory defined in CMAKE_INSTALL_PREFIX
+      run: |
+        cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+        New-Item -ItemType Directory '${{github.workspace}}/package'
+        Copy-Item '${{github.workspace}}/thirdparties/SDL2/install/bin/*.dll' -Destination '${{github.workspace}}/package'
+        Copy-Item '${{github.workspace}}/thirdparties/soft-oal/install/bin/*.dll' -Destination '${{github.workspace}}/package'
+        Copy-Item '${{github.workspace}}/thirdparties/curl/install/bin/*.dll' -Destination '${{github.workspace}}/package'
+        if (Test-Path ${{github.workspace}}/install/bin) { Copy-Item '${{github.workspace}}/install/bin/*' -Include '*.dll','*.exe','*.pdb' -Destination '${{github.workspace}}/package' }
+        if (Test-Path ${{github.workspace}}/install/lib) { Copy-Item '${{github.workspace}}/install/lib/*' -Include '*.dll','*.exe','*.pdb' -Destination '${{github.workspace}}/package' }
+
+    - name: Generate setup files
+      working-directory: ${{github.workspace}}
+      run: |
+        Copy-Item -Path '${{github.workspace}}/package' -Destination 'source/misc/setup/windows/app/files' -Recurse
+        dotnet build -p Platform=${{matrix.architecture.config}} -c Release -o out source/misc/setup/windows/app
+
+    ###
+    # Artifact
+    ###
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-windows-${{matrix.architecture.name}}
+        if-no-files-found: error
+        path: |
+          ${{github.workspace}}/package
+          !${{github.workspace}}/package/**/*.pdb
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-windows-${{matrix.architecture.name}}-pdb
+        if-no-files-found: error
+        path: |
+          ${{github.workspace}}/package
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: out-windows-${{matrix.architecture.name}}-installer
+        if-no-files-found: error
+        path: |
+          ${{github.workspace}}/out/en-us/Setup.msi
+          ${{github.workspace}}/out/en-us/Setup.wixpdb
@@ -0,0 +1,24 @@
+name: Shared build workflow
+
+on:
+  workflow_call:
+    inputs:
+      environment:
+        required: true
+        type: string
+
+jobs:
+  build-platform-linux:
+    uses: ./.github/workflows/shared-build-linux.yml
+    with:
+      environment: ${{inputs.environment}}
+
+  build-platform-windows:
+    uses: ./.github/workflows/shared-build-windows.yml
+    with:
+      environment: ${{inputs.environment}}
+
+  build-platform-macos:
+    uses: ./.github/workflows/shared-build-macos.yml
+    with:
+      environment: ${{inputs.environment}}
@@ -0,0 +1,109 @@
+name: "Publish Release"
+
+on:
+  push:
+    tags:
+        - "v*.*.*"
+
+env:
+  RELEASE_STAGE: ${{ vars.RELEASE_STAGE || 'unstable' }}
+  RELEASE_IS_PRERELEASE: ${{ vars.RELEASE_IS_PRELEASE }}
+
+permissions:
+  contents: write
+
+jobs:
+  build-all:
+   uses: ./.github/workflows/shared-build.yml
+   with:
+      environment: "release"
+
+  # Initially create a release with 1 job
+  # so multiple files can be uploaded at the same time afterwards
+  create-release:
+    runs-on: ubuntu-24.04
+    environment: 'release'
+    needs: [build-all]
+
+    steps:
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        name: '${{github.ref_name}}-${{env.RELEASE_STAGE}}'
+        prerelease: ${{env.RELEASE_IS_PRERELEASE}}
+
+  deploy-all:
+    strategy:
+      matrix:
+        target_os: [
+          'linux-amd64',
+          'linux-i686',
+          'linux-arm64',
+          'linux-armhf',
+          'linux-powerpc',
+          'linux-ppc64',
+          'linux-ppc64el',
+          'windows-x64',
+          'windows-x64-pdb',
+          'windows-x86',
+          'windows-x86-pdb',
+          'windows-arm64',
+          'windows-arm64-pdb',
+          #'macos-x86_64',
+          #'macos-arm64',
+          'macos-multiarch-arm64-x86_64',
+        ]
+
+    runs-on: ubuntu-24.04
+    environment: 'release'
+    needs: [create-release]
+
+    env:
+      RELEASE_NAME: ${{ github.event.repository.name }}-${{github.ref_name}}-${{matrix.target_os}}
+
+    steps:
+    - uses: actions/download-artifact@v4
+      with:
+        name: 'out-${{matrix.target_os}}'
+        path: ${{github.workspace}}/${{matrix.target_os}}
+
+    - name: Zip
+      working-directory: '${{github.workspace}}/${{matrix.target_os}}'
+      run: zip -r "../${{ env.RELEASE_NAME }}.zip" ./
+
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        files: ${{github.workspace}}/${{ env.RELEASE_NAME }}.zip
+
+  deploy_installer_windows:
+    strategy:
+      matrix:
+        target_os: [
+          'windows-x64',
+          'windows-x86',
+          'windows-arm64',
+        ]
+    
+    runs-on: ubuntu-24.04
+    environment: "release"
+    needs: [create-release]
+
+    env:
+      RELEASE_NAME: ${{ github.event.repository.name }}-${{github.ref_name}}-${{matrix.target_os}}
+
+    steps:
+    - uses: actions/download-artifact@v4
+      with:
+        name: 'out-${{matrix.target_os}}-installer'
+        path: ${{github.workspace}}/${{matrix.target_os}}
+
+    - name: Setup
+      working-directory: '${{github.workspace}}/${{matrix.target_os}}'
+      run:
+        cp Setup.msi ../${{ env.RELEASE_NAME }}.msi
+
+    - name: Release
+      uses: softprops/action-gh-release@v2.3.2
+      with:
+        files: ${{github.workspace}}/${{ env.RELEASE_NAME }}.msi
@@ -0,0 +1,53 @@
+name: "Unit Tests"
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: "Running unit tests"
+    runs-on: ubuntu-latest
+    environment: "testing"
+
+    steps:
+    - uses: awalsh128/cache-apt-pkgs-action@latest
+      name: Install required packages
+      with:
+        packages: flex bison ninja-build cmake clang libsdl2-dev libopenal-dev
+        version: "${{ runner.os }}-${{ runner.arch }}-unittest-v1"
+
+    - uses: actions/checkout@v4
+      with:
+        path: 'source'
+
+    - name: Settings
+      working-directory: ${{github.workspace}}
+      run: |
+        echo "CMAKE_GENERATOR=Ninja Multi-Config" >> $GITHUB_ENV
+        echo "CC=clang" >> $GITHUB_ENV
+        echo "CXX=clang++" >> $GITHUB_ENV
+        echo "CMAKE_PARAM=--log-level=VERBOSE \
+        -DCMAKE_INSTALL_PREFIX='${{github.workspace}}/install'" >> $GITHUB_ENV
+
+    - name: Configure CMake
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake -B ./build ${{ env.CMAKE_PARAM }} ./source
+
+    - name: Build
+      working-directory: ${{github.workspace}}
+      run: |
+        cmake --build ${{github.workspace}}/build --config Debug --parallel
+
+    - name: Test
+      working-directory: ${{github.workspace}}
+      run: |
+        cd "${{github.workspace}}/build"
+        ctest -C Debug --output-on-failure
@@ -5,6 +5,8 @@ Makefile.local
 *.swp
 *tags
 *~
+/.vscode/
+/baseq3

 # OS X
 ####################
@@ -44,5 +46,6 @@ profile
 *.suo

 .vs
-out
 code_unfinished/*
+thirdparties/
+code/parser/generated/*
@@ -1,27 +1,57 @@
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.12)
 project(openmohaa)

-include(TargetArch.cmake)
+include(misc/cmake/TargetArch.cmake)

 target_architecture(TARGET_ARCH)
+list(LENGTH TARGET_ARCH TARGET_ARCH_COUNT)

+set(USE_INTERNAL_LIBS ON)
+if(USE_SYSTEM_LIBS)
+	set(USE_INTERNAL_LIBS OFF)
+endif()
+
+option(USE_INTERNAL_JPEG "If set, use bundled libjpeg." ${USE_INTERNAL_LIBS})
+option(USE_INTERNAL_MAD  "If set, use bundled libmad."  ${USE_INTERNAL_LIBS})
+option(USE_INTERNAL_ZLIB "If set, use bundled zlib."    ${USE_INTERNAL_LIBS})
+option(USE_RENDERER_DLOPEN "Whether to compile the renderer as separate pluggable modules" OFF)

 if(TARGET_GAME_TYPE)
 	message(SEND_ERROR "TARGET_GAME_TYPE is now unsupported, it is now done at runtime.")
 endif()

-
 set(TARGET_BASE_GAME "./")
 set(CMAKE_DEBUG_POSTFIX "-dbg")

+#
+# Microsoft compiler specific parameters
+#
 if(MSVC)
 	add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE)
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+	# Treat no return type as error
+	add_compile_options(/we4715)
+endif()
+
+#
+# Clang and GCC specific parameters
+#
+if(CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	add_compile_options(-Wno-comment)
+	# Treat no return type as error
+	add_compile_options(-Werror=return-type)
+endif()
+
+#
+# Clang specific parameters
+#
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 	# Ignore warnings for code like 'assert("Assert string")'
 	add_compile_options(-Wno-pointer-bool-conversion)
 endif()

+#
+# GCC specific parameters
+#
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 	# Add this option on gcc to prevent functions from having the STB_GNU_UNIQUE binding
 	# Otherwise, it would prevent libraries from being unloaded
@@ -33,26 +63,22 @@ if(DEBUG_MEMORY)
 	add_definitions(-D_DEBUG_MEM)
 endif()

-IF("${TARGET_ARCH}" STREQUAL "i386")
-	set(TARGET_ARCH_SUFFIX "x86")
-ELSE()
-	set(TARGET_ARCH_SUFFIX ${TARGET_ARCH})
-ENDIF()
+message(STATUS "Architecture detected: ${TARGET_ARCH}")

-message(STATUS "Architecture detected: ${TARGET_ARCH}, suffix set to ${TARGET_ARCH_SUFFIX}.")
+set(TARGET_BIN_SUFFIX "")

-IF(WIN32)
+if(WIN32)
 	set(TARGET_PLATFORM_PREFIX "")
 	message(STATUS "Using Win32 naming convention")
-ELSEIF(UNIX)
+elseif(UNIX)
 	set(TARGET_PLATFORM_PREFIX "")
 	message(STATUS "Using Unix naming convention")
-ELSE()
+else()
 	set(TARGET_PLATFORM_PREFIX "")
-ENDIF()
+endif()

-IF(CMAKE_BUILD_TYPE MATCHES Debug)
-	add_definitions(-D_DEBUG)
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+	add_compile_definitions(_DEBUG)

 	# NOTE: The following may mess up function importation
 	#if(UNIX)
@@ -60,18 +86,62 @@ IF(CMAKE_BUILD_TYPE MATCHES Debug)
 	#	set(CMAKE_ENABLE_EXPORTS ON)
 	#	message(STATUS "Enabling exports on Unix for backtrace")
 	#endif()
-ENDIF()
+else()
+	# Non-debug builds
+	add_compile_definitions(NDEBUG)
+endif()

+if(APPLE)
+	# macOS doesn't search the executable path by default
+	# so, locate libraries like SDL in the executable path
+	set(CMAKE_INSTALL_RPATH "@executable_path")
+	set(CMAKE_BUILD_WITH_INSTALL_RPATH ON)
+
+	if(CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID STREQUAL "GNU")
+		# Set the visibility to hidden on macOS to prevent shared libraries from
+		# using functions in the executable
+		# it's ok to hide them because the backtrace on macOS will still print the name of the functions
+		add_compile_options(-fvisibility=hidden)
+	endif()
+endif()
+
+#
+# Setup the installation directory
+#
+if(WIN32)
+	# By default, both DLLs and EXEs are in the same directory
+	set(CMAKE_DEFAULT_INSTALL_RUNTIME_DIR bin)
+	set(BIN_INSTALL_SUBDIR ".")
+	set(LIB_INSTALL_SUBDIR ".")
+else()
+	# Unix
+	set(CMAKE_DEFAULT_INSTALL_RUNTIME_DIR lib${CMAKE_LIB_SUFFIX})
+	set(BIN_INSTALL_SUBDIR ${CMAKE_PROJECT_NAME})
+	set(LIB_INSTALL_SUBDIR ${CMAKE_PROJECT_NAME})
+endif()
+
+# By default, put both binaries and shared libraries in the same directory
+# the game uses internal shared libraries that must be in the same folder as the binaries
+set(CMAKE_INSTALL_BINDIR ${CMAKE_DEFAULT_INSTALL_RUNTIME_DIR} CACHE PATH "Binary dir")
+set(CMAKE_INSTALL_LIBDIR ${CMAKE_INSTALL_BINDIR} CACHE PATH "Library dir")
+include(GNUInstallDirs)
+# Enable unit testing
+include(CTest)
+
+#
 # Common stuff
-
+#
 add_subdirectory("code/qcommon")
 add_subdirectory("code/gamespy")

+#
 # Application
-
+#
 add_subdirectory("code/sys")

+##
 ## Server app
+##
 add_subdirectory("code/server")

 add_executable(omohaaded "code/null/null_client.c" "code/null/null_input.c" "code/null/null_snddma.c")
@@ -82,57 +152,90 @@ target_link_libraries(omohaaded PRIVATE omohserver)
 target_link_libraries(omohaaded PRIVATE syslib)
 target_link_libraries(omohaaded PRIVATE qcommon qcommon_standalone)

-# Gamespy dependency
+# Add the gamespy dependency
 target_include_directories(omohaaded PUBLIC "code/qcommon" "code/script" "code/gamespy" "code/server")
-set_target_properties(omohaaded PROPERTIES OUTPUT_NAME "omohaaded${TARGET_BASE_SUFFIX}${TARGET_ARCH_SUFFIX}")
+set_target_properties(omohaaded PROPERTIES OUTPUT_NAME "omohaaded${TARGET_BIN_SUFFIX}")
 set_target_properties(omohaaded PROPERTIES DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})

+INSTALL(TARGETS omohaaded DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR})
+
 if (MSVC)
 	target_link_options(omohaaded PRIVATE "/MANIFEST:NO")
-	INSTALL(FILES $<TARGET_PDB_FILE:omohaaded> DESTINATION "./" OPTIONAL)
+	INSTALL(FILES $<TARGET_PDB_FILE:omohaaded> DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR} OPTIONAL)
 endif()

-INSTALL(TARGETS omohaaded DESTINATION "./")
-
 if (NOT BUILD_NO_CLIENT)
+	##
 	## Client app
+	##
+	option(NO_MODERN_DMA "Use older sound-system" FALSE)

-	add_subdirectory("code/renderer")
-	add_subdirectory("code/sdl")
 	add_subdirectory("code/client")
-
-	#include("code/renderergl2/glsl/shaders.cmake")
-	#file(GLOB_RECURSE SOURCES_RENDERER "code/sdl/*.c" "code/renderercommon/*.c" "code/renderergl2/*.c" "code/renderergl2/*.cpp")
-	#list(FILTER SOURCES_RENDERER EXCLUDE REGEX "code/renderergl2/tr_subs.c")
-	#list(FILTER SOURCES_RENDERER EXCLUDE REGEX "code/renderergl2/tr_model.c")
+	add_subdirectory("code/renderercommon")
+	add_subdirectory("code/sdl")

 	add_executable(openmohaa "misc/dummy.c")
 	target_link_libraries(openmohaa PRIVATE syslib)
 	target_link_libraries(openmohaa PRIVATE omohserver)
 	target_link_libraries(openmohaa PRIVATE omohclient)
-	target_link_libraries(openmohaa PRIVATE omohrenderer omohsdl)
+	target_link_libraries(openmohaa PRIVATE omohrenderer)
 	target_link_libraries(openmohaa PRIVATE qcommon qcommon_standalone)

-	### Gamespy dependency
-	target_include_directories(openmohaa PUBLIC "code/qcommon" "code/script" "code/gamespy" "code/server" "code/client" "code/uilib" "code/jpeg-8c")
-	set_target_properties(openmohaa PROPERTIES OUTPUT_NAME "openmohaa${TARGET_BASE_SUFFIX}${TARGET_ARCH_SUFFIX}")
+	# Add the gamespy dependency
+	target_include_directories(openmohaa PUBLIC "code/qcommon" "code/script" "code/gamespy" "code/server" "code/client" "code/uilib")
+	set_target_properties(openmohaa PROPERTIES OUTPUT_NAME "openmohaa${TARGET_BIN_SUFFIX}")
 	set_target_properties(openmohaa PROPERTIES DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})

-	target_link_libraries(openmohaa PRIVATE jpeg8)
-	if (USE_OPENAL)
-		# Try to use OpenAL
-		find_package(OpenAL)
-		if (OPENAL_FOUND)
-			target_compile_definitions(openmohaa PRIVATE USE_OPENAL=1)
-			target_include_directories(openmohaa PRIVATE ${OPENAL_INCLUDE_DIR})
-			target_link_libraries(openmohaa PRIVATE ${OPENAL_LIBRARY})
-		endif()
-	endif()
+	INSTALL(TARGETS openmohaa DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR})

 	if (MSVC)
 		target_link_options(openmohaa PRIVATE "/MANIFEST:NO")
-		INSTALL(FILES $<TARGET_PDB_FILE:openmohaa> DESTINATION "./" OPTIONAL)
+		INSTALL(FILES $<TARGET_PDB_FILE:openmohaa> DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR} OPTIONAL)
 	endif()

-	INSTALL(TARGETS openmohaa DESTINATION "./")
+	if(UNIX AND NOT APPLE)
+		# Configure the .desktop entries with the arch suffix
+		configure_file(
+			misc/linux/org.openmoh.openmohaa.desktop.in
+			${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaa.desktop
+			@ONLY
+		)
+		configure_file(
+			misc/linux/org.openmoh.openmohaab.desktop.in
+			${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaab.desktop
+			@ONLY
+		)
+		configure_file(
+			misc/linux/org.openmoh.openmohaas.desktop.in
+			${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaas.desktop
+			@ONLY
+		)
+
+		# Install .desktop entries
+		install(FILES ${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaa.desktop  DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
+		install(FILES ${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaab.desktop DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
+		install(FILES ${CMAKE_BINARY_DIR}/misc/linux/org.openmoh.openmohaas.desktop DESTINATION ${CMAKE_INSTALL_DATADIR}/applications)
+
+		install(FILES misc/linux/org.openmoh.openmohaa.metainfo.xml DESTINATION ${CMAKE_INSTALL_DATADIR}/metainfo)
+
+		install(FILES misc/openmohaa.svg DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/symbolic/apps/ RENAME org.openmoh.openmohaa.svg)
+	endif()
+endif()
+
+#
+# Launcher
+#
+add_subdirectory(code/Launcher)
+
+#
+# uninstall target
+#
+if(NOT TARGET uninstall)
+  configure_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+    IMMEDIATE @ONLY)
+
+  add_custom_target(uninstall
+    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
 endif()
@@ -1,237 +1,109 @@
 # OpenMoHAA

-![Build](https://github.com/openmoh/openmohaa/actions/workflows/build-cmake.yml/badge.svg?branch=main) [![Release](https://img.shields.io/github/v/release/openmoh/openmohaa)](https://github.com/openmoh/openmohaa/releases) [![Downloads](https://img.shields.io/github/downloads/openmoh/openmohaa/total)](https://github.com/openmoh/openmohaa/releases)
+[![Build](https://github.com/openmoh/openmohaa/actions/workflows/branches-build.yml/badge.svg?branch=main)](https://github.com/openmoh/openmohaa/actions/workflows/branches-build.yml) [![Release](https://img.shields.io/github/v/release/openmoh/openmohaa)](https://github.com/openmoh/openmohaa/releases) [![Downloads](https://img.shields.io/github/downloads/openmoh/openmohaa/total)](https://github.com/openmoh/openmohaa/releases)

 ![License](https://img.shields.io/github/license/openmoh/openmohaa) ![Commits](https://img.shields.io/github/commit-activity/t/openmoh/openmohaa)

 ![Discord](https://img.shields.io/discord/596049712579215361?logo=discord&logoColor=white&color=5865F2)

+![logo](misc/openmohaa-text-sm.png)

-```
-     / _ \ _ __   ___ _ __ |  \/  |/ _ \| | | |  / \      / \
-    | | | | '_ \ / _ \ '_ \| |\/| | | | | |_| | / _ \    / _ \
-    | |_| | |_) |  __/ | | | |  | | |_| |  _  |/ ___ \  / ___ \
-     \___/| .__/ \___|_| |_|_|  |_|\___/|_| |_/_/   \_\/_/   \_\
-          |_|
-```
+## What is OpenMoHAA?

-## Current State
+OpenMoHAA is an open-source project aimed at preserving and enhancing **Medal of Honor: Allied Assault** (including Spearhead and Breakthrough expansions) by providing more features and bugfixes, across modern platforms and architectures.

-OpenMoHAA is still under development. The single-player campaign is not yet functional due to AI not being fully stable. But the `training` map can be played from start to end. The current focus is on multiplayer.
+Powered by [ioquake3](https://github.com/ioquake/ioq3) and the [F.A.K.K SDK](https://code.idtech.space/ritual/fakk2-sdk), OpenMoHAA provides:
+- Full compatibility with the original game: assets, scripts and multiplayer
+- Better support for modern systems
+- Cross-platform support (Linux, Windows, macOS)
+- Support for both single-player and multiplayer modes
+- Includes all fixes from Spearhead 2.15 and Breakthrough 2.40b
+- More fixes and features, such as bots and a ban system

-## Intro
+*OpenMoHAA is an independent project and is not affiliated with or endorsed by Electronic Arts.*

-The main goal of OpenMoHAA is to ensure the future and continuity of **Medal of Honor: Allied Assault**. It has always been a dream in the community to provide patches and security fixes for the game. Thanks to the ioquake3 project, F.A.K.K SDK and other quality tools, OpenMoHAA has already reached more than half of its goal: to create an open-source version of MoH:AA (based on version 2.40) that is fully compatible with the original game (in terms of protocol, assets, and scripts).
+## Getting started

-## Running
+- 📦 [Installing OpenMoHAA](docs/markdown/01-intro/01-installation.md)
+- ▶️ [How to play: Launching the game, expansions & file locations](docs/markdown/02-running/01-running.md)
+- ❓ [FAQ & Troubleshooting](docs/markdown/02-running/03-faq.md)
+- 🌐 [Setting up a game server](docs/markdown/02-running/02-running-server.md)

-Ensure that you download the binaries compatible with your platform.
+## Reporting Issues

-### Requirements
+> [!NOTE]
+> OpenMoHAA hasn't hit version 1.0.0 yet. Think of it like a beta build from the golden age of LAN parties. Features are being added, bugs are getting squashed, and more things are being tweaked. Things might change, break, or get even better over time.
+> 
+> If that sounds like your kind of mission, gear up, frag some bots, and help level up OpenMoHAA!

-You may need to install Microsoft Visual C++ 2015/2017/2019/2022 Redistributable from https://learn.microsoft.com/en-US/cpp/windows/latest-supported-vc-redist?view=msvc-170
+If you encounter a bug or a problem, you can do one of the following:
+- Submit an [issue](https://github.com/openmoh/openmohaa/issues) on GitHub (use the template).
+- Join the [OpenMoHAA Discord](https://discord.gg/NYtH58R) for a quick help.

-### Client
+## Additional documentation

-a) extract archive to your MOHAA installation directory.
+- 📖 [Documentation](https://openmoh.github.io/openmohaa)
+- ⚙️ [Game settings & configuration](docs/markdown/03-configuration/01-configuration.md)
+- 📝 [Code & Scripting reference](docs/markdown/04-coding/02-coding.md)
+- 📜 [Contributing guidelines](docs/markdown/05-contributing/01-guidelines.md)

-or-
+## Current state

-b) extract archive somewhere on your hard drive, create a shortcut to openmohaa (or omohaaded), and set the start directory to your MOHAA installation directory.
+- 🧰 [Feature list](docs/markdown/01-intro/04-features.md)

-### Server
+### Single-player

-Extract the archive to your MOHAA server installation directory. Then proceed like you would do with mohaa server:
+The entire single-player campaign should work (Allied Assault, Spearhead and Breakthrough). If you encounter any bug, please create a new [GitHub issue](https://github.com/openmoh/openmohaa/issues) describing them.

- `.\omohaaded.exe +exec server.cfg` on Windows
- `./omohaaded +exec server.cfg` on Linux
+### Multiplayer

-Only `omohaaded*` and `game*` binaries are required for the server version, other binaries can be omitted.
+- Almost fully stable
+- All official game modes are supported, including those from Spearhead and Breakthrough:
+  - Free-For-All
+  - Team-Deathmatch
+  - Round-based match
+  - Objective match
+  - Tug-of-War (Spearhead)
+  - Liberation (Breakthrough)
+- Popular mods like **Freeze-Tag** are supported
+- Built-in bots for offline practice and for testing
+  - 🔧 [Setting up bots](docs/markdown/02-running/01-running.md#Playing-with-bots)

-### Config file
-
-The config file can be found in different locations depending on the platform:
-
- `%APPDATA%\openmohaa\<game_name>\configs\omconfig.cfg` on Windows
- `~/.openmohaa/<game_name>/configs/omconfig.cfg` on Linux
-
-This has two advantages:
- On a multi-user system, each user will have their own configuration file
- It doesn't overwrite the existing MOHAA configuration in the MOHAA installation directory.
-
-### Game selection
-
-**Medal of Honor: Allied Assault Spearhead** and **Medal of Honor: Allied Assault Breakthrough** are supported in OpenMoHAA using the `com_target_game` variable. To play an expansion, append the following command-line arguments to the executable:
-
- `+set com_target_game 1` for Spearhead (mohaas/mohta)
- `+set com_target_game 2` for Breakthrough (mohaab/mohtt)
-
-On Windows, you can create a shortcut to OpenMoHAA with these command-line arguments.
-The default value of `com_target_game` is 0 for the base game (main).
-
-With `com_target_game`, OpenMoHAA will support the network protocol accordingly.
-
-You can now start a local OpenMOHAA server or play on a server.
-
-### Playing with bots
-
-OpenMoHAA has a basic bot system that emulates real players. The maximum number of bots is defined by the `sv_maxbots` variable, and the number of initial bots is defined by the `sv_numbots` variable. Bots can also be added or removed using the `addbot` and `removebot` commands.
-
-This feature is a great way to test the gameplay and mods.
-
-## Builds
-
-### Server
-
-The server version can be built successfully, but some features are not functional. For example, the Actor system is almost fully implemented, but it is not yet stable. This means that Actor may not work as expected and could cause crashes.
-
-Overall, the server and the fgame components are almost fully implemented, but they may not be completely stable. There could be some minor bugs (and rare crashes), but the game should be playable.
-
-### Client
-
-The client version of OpenMoHAA has undergone partial implementation, with the cgame module being nearly completed. Credits to the SDK of **Heavy Metal: F.A.K.K. 2** both the cgame and fgame modules.
-
-The current operational status for each component is as follow:
-
-| Component               | Full | Almost | Half | Early | Bad | Not working | Comment                                                           |
-|-------------------------|------|--------|------|-------|-----|-------------|-------------------------------------------------------------------|
-| Audio                   |      |        |      |       | x   |             | Very basic implementation from Quake III                          |
-| CG Module               |      | x      |      |       |     |             | Missing FX, Marks and decals                                      |
-| Client                  |      | x      |      |       |     |             | Missing GameSpy, server list, binds, map picker, ...              |
-| Collision               | x    |        |      |       |     |             |                                                                   |
-| Model/TIKI/Skeletor     | x    |        |      |       |     |             |                                                                   |
-| Renderer                |      | x      |      |       |     |             | Missing ghost, marks, sphere lights, sky portal, sun flare, swipe |
-| Server                  |      | x      |      |       |     |             | Probably a few bugs remaining                                     |
-| Server module (fgame)   |      | x      |      |       |     |             | Actor, and few gameplay bugs                                      |
-| UI                      |      |        | x    |       |     |             | Has core features only (menu, widgets, console, hud, urc loading) |
-
-## Compiling
-
-OpenMoHAA supports any architecture, thanks to the CMake build system and cross-platform code/libraries. While the most common little-Endian architectures (arm, aarch64, x86, x86_64) have been tested and confirmed to work, big-Endian architectures should be supported as well; however, they remain untested.
-
-The following tools are required for all platforms:
- CMake >= 3.5
- Flex (>= 2.6.4) and Bison (>= 3.5.1)
- A C++11 compiler is also required.
-
-The installation directory can be set to the MOHAA directory.
-
-By default, the build will produce both the client and dedicated server versions. The client can be omitted from the build by appending `-DBUILD_NO_CLIENT=1` to the CMake command-line arguments. Using this parameter will result in only the server portion being built.
-
-### Linux
-
-These are the tools required on Linux :
- Clang >= 3.3 or GCC >= 4.8.5
- libsdl2-dev
-
-**clang-3.5** and **gcc-4.8.5** should work (tested on Ubuntu 16.04), but the latest version should be used.
-
-Ubuntu 20.04 is the minimum version required to fully compile the project successfully.
-
-1 line install command with clang:
-```sh
-sudo apt-get install -y cmake ninja-build clang lld flex bison libsdl2-dev
-```
-
-Example with **CMake** and **ninja-build** installed:
-```sh
-mkdir .cmake && cd .cmake
-cmake -G Ninja ../
-```
-
-Other compilers can be specified by appending `-DCMAKE_C_COMPILER=/path/to/compiler -DCMAKE_CXX_COMPILER=path/to/compiler` to the CMake command-line.
-
-### Windows
-
-Visual Studio (2019 or 2022) is generally preferred.
-
-Flex and Bison can be downloaded from here: https://github.com/lexxmark/winflexbison/releases/tag/v2.5.25
-
-Append `-DFLEX_EXECUTABLE=...\win_flex.exe -DBISON_EXECUTABLE=...\win_bison.exe` to the CMake command-line to use the package from the link above.
+You can host your own [OpenMoHAA server](docs/markdown/02-running/02-running-server.md#) or join others using OpenMoHAA.

 ## Screenshots

 |                                                                                   |                                                                            |
 |-----------------------------------------------------------------------------------|----------------------------------------------------------------------------|
-| ![](docs/images/v0.60.0-x86_64/mohdm1_1.png)                                      | ![](docs/images/v0.60.0-x86_64/training_1.png)                               |
-| ![](docs/images/v0.60.0-x86_64/flughafen_1.png)                                   | ![](docs/images/v0.60.0-x86_64/flughafen_2.png)                            |
-| ![](docs/images/v0.60.0-x86_64/mohdm2_1.png "Playing Freeze-Tag mode with bots")  | ![](docs/images/v0.60.0-x86_64/training_3.png "Single-Player training")    |
+| ![](docs/assets/images/v0.60.0-x86_64/mohdm1_1.png)                                      | ![](docs/assets/images/v0.60.0-x86_64/training_1.png)                               |
+| ![](docs/assets/images/v0.60.0-x86_64/flughafen_1.png)                                   | ![](docs/assets/images/v0.60.0-x86_64/flughafen_2.png)                            |
+| ![](docs/assets/images/v0.60.0-x86_64/mohdm2_1.png "Playing Freeze-Tag mode with bots")  | ![](docs/assets/images/v0.60.0-x86_64/training_3.png "Single-Player training")    |

-*More screenshots [here](docs/images)*
+*More screenshots [here](docs/assets/images)*

-## Features
+## Development & Compiling

-### Features added and not present in MOH:AA
+- 💻 [Building from source](docs/markdown/04-coding/01-compiling.md)

-#### Server-side
+## Third party librairies

- Bots
- Spectate players in first-person
- Demo recording
- More script commands for mods
- Non-PVS optimization
+The following third party tools and libraries are used by the project

-##### Non-PVS optimization
+- [Flex](https://github.com/westes/flex)
+- [Bison](https://savannah.gnu.org/projects/bison/)
+- [SDL](http://www.libsdl.org/)
+- [OpenAL](https://www.openal.org/)
+- [LibMAD](http://www.underbit.com/products/mad/)
+- [cURL](https://curl.se/)
+- [Libogg](https://github.com/gcp/libogg)
+- [Libvorbis](https://xiph.org/vorbis/)
+- [Libopus](https://opus-codec.org/)

-For each client, the server optimizes by only sending them information about other players that they can see. Clients won't see other players they can't see.
+## Resources

-Enable this feature with `set sv_netoptimize 2`.
-
-#### Client-side and server-side
-
- Security fixes and features from ioquake3
- IPv6 support (from ioquake3)
-
-### Objectives / planned features
-
-This is a non-exhaustive list of objectives and planned features.
-
-#### Server-side
-
- 100% compatibility with mohaa content
- More feature for mods
- Anticheat
- Stats system
- Multiple roles/abilities for server admins to reduce password-stealing
-
-## Third party
-
-### SDL
-
-http://www.libsdl.org/
-
-### OpenAL
-
-https://www.openal.org/
-
-### LibMAD
-
-http://www.underbit.com/products/mad/
-
-### cURL
-
-https://curl.se/
-
-### Libogg
-
-https://github.com/gcp/libogg
-
-### Libvorbis
-
-https://xiph.org/vorbis/
-
-### Libopus
-
-https://opus-codec.org/
-
-## Communities
-
-### URLs
-
- https://github.com/openmoh/openmohaa/
- https://mohaaaa.co.uk/AAAAMOHAA/index.php
- https://x-null.net/
-
-### Discord
-
-[![Discord Banner 1](https://discordapp.com/api/guilds/596049712579215361/widget.png?style=banner2)](https://discord.gg/NYtH58R)
+- 🔗 [GitHub Repository](https://github.com/openmoh/openmohaa/)
+- 🌐 [MOHAAAA Amalgamated Allied Assault Alliance](https://mohaaaa.co.uk/AAAAMOHAA/index.php)
+- 🕹️ [333networks](https://333networks.com/)
+- 📂 [ModDB](https://www.moddb.com/games/medal-of-honor-allied-assault)
+- 📂 [GameBanana](https://gamebanana.com/games/720)
+- 💬 [Join us on Discord](https://discord.gg/NYtH58R)
@@ -0,0 +1,21 @@
+if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
+endif()
+
+file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    execute_process(
+      COMMAND "@CMAKE_COMMAND@" -E remove "$ENV{DESTDIR}${file}"
+      OUTPUT_VARIABLE rm_out
+      RESULT_VARIABLE rm_retval
+      )
+    if(NOT "${rm_retval}" STREQUAL 0)
+      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+    endif()
+  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+  endif()
+endforeach()
@@ -1,5 +0,0 @@
-This file identifies the version of the AL headers in this directory. If you
-change or update the AL headers in any way, please make sure you also update
-this file.
-
-openal-soft-1.15.1
@@ -1,355 +0,0 @@
-/**
- * OpenAL cross platform audio library
- * Copyright (C) 2008 by authors.
- * This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- *  License along with this library; if not, write to the
- *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- *  Boston, MA  02111-1307, USA.
- * Or go to http://www.gnu.org/copyleft/lgpl.html
- */
-
-#ifndef AL_ALEXT_H
-#define AL_ALEXT_H
-
-#include <stddef.h>
-/* Define int64_t and uint64_t types */
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#include <inttypes.h>
-#elif defined(_WIN32) && defined(__GNUC__)
-#include <stdint.h>
-#elif defined(_WIN32)
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#else
-/* Fallback if nothing above works */
-#include <inttypes.h>
-#endif
-
-#include "alc.h"
-#include "al.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef AL_LOKI_IMA_ADPCM_format
-#define AL_LOKI_IMA_ADPCM_format 1
-#define AL_FORMAT_IMA_ADPCM_MONO16_EXT           0x10000
-#define AL_FORMAT_IMA_ADPCM_STEREO16_EXT         0x10001
-#endif
-
-#ifndef AL_LOKI_WAVE_format
-#define AL_LOKI_WAVE_format 1
-#define AL_FORMAT_WAVE_EXT                       0x10002
-#endif
-
-#ifndef AL_EXT_vorbis
-#define AL_EXT_vorbis 1
-#define AL_FORMAT_VORBIS_EXT                     0x10003
-#endif
-
-#ifndef AL_LOKI_quadriphonic
-#define AL_LOKI_quadriphonic 1
-#define AL_FORMAT_QUAD8_LOKI                     0x10004
-#define AL_FORMAT_QUAD16_LOKI                    0x10005
-#endif
-
-#ifndef AL_EXT_float32
-#define AL_EXT_float32 1
-#define AL_FORMAT_MONO_FLOAT32                   0x10010
-#define AL_FORMAT_STEREO_FLOAT32                 0x10011
-#endif
-
-#ifndef AL_EXT_double
-#define AL_EXT_double 1
-#define AL_FORMAT_MONO_DOUBLE_EXT                0x10012
-#define AL_FORMAT_STEREO_DOUBLE_EXT              0x10013
-#endif
-
-#ifndef AL_EXT_MULAW
-#define AL_EXT_MULAW 1
-#define AL_FORMAT_MONO_MULAW_EXT                 0x10014
-#define AL_FORMAT_STEREO_MULAW_EXT               0x10015
-#endif
-
-#ifndef AL_EXT_ALAW
-#define AL_EXT_ALAW 1
-#define AL_FORMAT_MONO_ALAW_EXT                  0x10016
-#define AL_FORMAT_STEREO_ALAW_EXT                0x10017
-#endif
-
-#ifndef ALC_LOKI_audio_channel
-#define ALC_LOKI_audio_channel 1
-#define ALC_CHAN_MAIN_LOKI                       0x500001
-#define ALC_CHAN_PCM_LOKI                        0x500002
-#define ALC_CHAN_CD_LOKI                         0x500003
-#endif
-
-#ifndef AL_EXT_MCFORMATS
-#define AL_EXT_MCFORMATS 1
-#define AL_FORMAT_QUAD8                          0x1204
-#define AL_FORMAT_QUAD16                         0x1205
-#define AL_FORMAT_QUAD32                         0x1206
-#define AL_FORMAT_REAR8                          0x1207
-#define AL_FORMAT_REAR16                         0x1208
-#define AL_FORMAT_REAR32                         0x1209
-#define AL_FORMAT_51CHN8                         0x120A
-#define AL_FORMAT_51CHN16                        0x120B
-#define AL_FORMAT_51CHN32                        0x120C
-#define AL_FORMAT_61CHN8                         0x120D
-#define AL_FORMAT_61CHN16                        0x120E
-#define AL_FORMAT_61CHN32                        0x120F
-#define AL_FORMAT_71CHN8                         0x1210
-#define AL_FORMAT_71CHN16                        0x1211
-#define AL_FORMAT_71CHN32                        0x1212
-#endif
-
-#ifndef AL_EXT_MULAW_MCFORMATS
-#define AL_EXT_MULAW_MCFORMATS 1
-#define AL_FORMAT_MONO_MULAW                     0x10014
-#define AL_FORMAT_STEREO_MULAW                   0x10015
-#define AL_FORMAT_QUAD_MULAW                     0x10021
-#define AL_FORMAT_REAR_MULAW                     0x10022
-#define AL_FORMAT_51CHN_MULAW                    0x10023
-#define AL_FORMAT_61CHN_MULAW                    0x10024
-#define AL_FORMAT_71CHN_MULAW                    0x10025
-#endif
-
-#ifndef AL_EXT_IMA4
-#define AL_EXT_IMA4 1
-#define AL_FORMAT_MONO_IMA4                      0x1300
-#define AL_FORMAT_STEREO_IMA4                    0x1301
-#endif
-
-#ifndef AL_EXT_STATIC_BUFFER
-#define AL_EXT_STATIC_BUFFER 1
-typedef ALvoid (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALint,ALenum,ALvoid*,ALsizei,ALsizei);
-#ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alBufferDataStatic(const ALint buffer, ALenum format, ALvoid *data, ALsizei len, ALsizei freq);
-#endif
-#endif
-
-#ifndef ALC_EXT_EFX
-#define ALC_EXT_EFX 1
-#include "efx.h"
-#endif
-
-#ifndef ALC_EXT_disconnect
-#define ALC_EXT_disconnect 1
-#define ALC_CONNECTED                            0x313
-#endif
-
-#ifndef ALC_EXT_thread_local_context
-#define ALC_EXT_thread_local_context 1
-typedef ALCboolean  (ALC_APIENTRY*PFNALCSETTHREADCONTEXTPROC)(ALCcontext *context);
-typedef ALCcontext* (ALC_APIENTRY*PFNALCGETTHREADCONTEXTPROC)(void);
-#ifdef AL_ALEXT_PROTOTYPES
-ALC_API ALCboolean  ALC_APIENTRY alcSetThreadContext(ALCcontext *context);
-ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void);
-#endif
-#endif
-
-#ifndef AL_EXT_source_distance_model
-#define AL_EXT_source_distance_model 1
-#define AL_SOURCE_DISTANCE_MODEL                 0x200
-#endif
-
-#ifndef AL_SOFT_buffer_sub_data
-#define AL_SOFT_buffer_sub_data 1
-#define AL_BYTE_RW_OFFSETS_SOFT                  0x1031
-#define AL_SAMPLE_RW_OFFSETS_SOFT                0x1032
-typedef ALvoid (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei);
-#ifdef AL_ALEXT_PROTOTYPES
-AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length);
-#endif
-#endif
-
-#ifndef AL_SOFT_loop_points
-#define AL_SOFT_loop_points 1
-#define AL_LOOP_POINTS_SOFT                      0x2015
-#endif
-
-#ifndef AL_EXT_FOLDBACK
-#define AL_EXT_FOLDBACK 1
-#define AL_EXT_FOLDBACK_NAME                     "AL_EXT_FOLDBACK"
-#define AL_FOLDBACK_EVENT_BLOCK                  0x4112
-#define AL_FOLDBACK_EVENT_START                  0x4111
-#define AL_FOLDBACK_EVENT_STOP                   0x4113
-#define AL_FOLDBACK_MODE_MONO                    0x4101
-#define AL_FOLDBACK_MODE_STEREO                  0x4102
-typedef void (AL_APIENTRY*LPALFOLDBACKCALLBACK)(ALenum,ALsizei);
-typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTART)(ALenum,ALsizei,ALsizei,ALfloat*,LPALFOLDBACKCALLBACK);
-typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTOP)(void);
-#ifdef AL_ALEXT_PROTOTYPES
-AL_API void AL_APIENTRY alRequestFoldbackStart(ALenum mode,ALsizei count,ALsizei length,ALfloat *mem,LPALFOLDBACKCALLBACK callback);
-AL_API void AL_APIENTRY alRequestFoldbackStop(void);
-#endif
-#endif
-
-#ifndef ALC_EXT_DEDICATED
-#define ALC_EXT_DEDICATED 1
-#define AL_DEDICATED_GAIN                        0x0001
-#define AL_EFFECT_DEDICATED_DIALOGUE             0x9001
-#define AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT 0x9000
-#endif
-
-#ifndef AL_SOFT_buffer_samples
-#define AL_SOFT_buffer_samples 1
-/* Channel configurations */
-#define AL_MONO_SOFT                             0x1500
-#define AL_STEREO_SOFT                           0x1501
-#define AL_REAR_SOFT                             0x1502
-#define AL_QUAD_SOFT                             0x1503
-#define AL_5POINT1_SOFT                          0x1504
-#define AL_6POINT1_SOFT                          0x1505
-#define AL_7POINT1_SOFT                          0x1506
-
-/* Sample types */
-#define AL_BYTE_SOFT                             0x1400
-#define AL_UNSIGNED_BYTE_SOFT                    0x1401
-#define AL_SHORT_SOFT                            0x1402
-#define AL_UNSIGNED_SHORT_SOFT                   0x1403
-#define AL_INT_SOFT                              0x1404
-#define AL_UNSIGNED_INT_SOFT                     0x1405
-#define AL_FLOAT_SOFT                            0x1406
-#define AL_DOUBLE_SOFT                           0x1407
-#define AL_BYTE3_SOFT                            0x1408
-#define AL_UNSIGNED_BYTE3_SOFT                   0x1409
-
-/* Storage formats */
-#define AL_MONO8_SOFT                            0x1100
-#define AL_MONO16_SOFT                           0x1101
-#define AL_MONO32F_SOFT                          0x10010
-#define AL_STEREO8_SOFT                          0x1102
-#define AL_STEREO16_SOFT                         0x1103
-#define AL_STEREO32F_SOFT                        0x10011
-#define AL_QUAD8_SOFT                            0x1204
-#define AL_QUAD16_SOFT                           0x1205
-#define AL_QUAD32F_SOFT                          0x1206
-#define AL_REAR8_SOFT                            0x1207
-#define AL_REAR16_SOFT                           0x1208
-#define AL_REAR32F_SOFT                          0x1209
-#define AL_5POINT1_8_SOFT                        0x120A
-#define AL_5POINT1_16_SOFT                       0x120B
-#define AL_5POINT1_32F_SOFT                      0x120C
-#define AL_6POINT1_8_SOFT                        0x120D
-#define AL_6POINT1_16_SOFT                       0x120E
-#define AL_6POINT1_32F_SOFT                      0x120F
-#define AL_7POINT1_8_SOFT                        0x1210
-#define AL_7POINT1_16_SOFT                       0x1211
-#define AL_7POINT1_32F_SOFT                      0x1212
-
-/* Buffer attributes */
-#define AL_INTERNAL_FORMAT_SOFT                  0x2008
-#define AL_BYTE_LENGTH_SOFT                      0x2009
-#define AL_SAMPLE_LENGTH_SOFT                    0x200A
-#define AL_SEC_LENGTH_SOFT                       0x200B
-
-typedef void (AL_APIENTRY*LPALBUFFERSAMPLESSOFT)(ALuint,ALuint,ALenum,ALsizei,ALenum,ALenum,const ALvoid*);
-typedef void (AL_APIENTRY*LPALBUFFERSUBSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,const ALvoid*);
-typedef void (AL_APIENTRY*LPALGETBUFFERSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,ALvoid*);
-typedef ALboolean (AL_APIENTRY*LPALISBUFFERFORMATSUPPORTEDSOFT)(ALenum);
-#ifdef AL_ALEXT_PROTOTYPES
-AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer, ALuint samplerate, ALenum internalformat, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data);
-AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data);
-AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, ALvoid *data);
-AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format);
-#endif
-#endif
-
-#ifndef AL_SOFT_direct_channels
-#define AL_SOFT_direct_channels 1
-#define AL_DIRECT_CHANNELS_SOFT                  0x1033
-#endif
-
-#ifndef ALC_SOFT_loopback
-#define ALC_SOFT_loopback 1
-#define ALC_FORMAT_CHANNELS_SOFT                 0x1990
-#define ALC_FORMAT_TYPE_SOFT                     0x1991
-
-/* Sample types */
-#define ALC_BYTE_SOFT                            0x1400
-#define ALC_UNSIGNED_BYTE_SOFT                   0x1401
-#define ALC_SHORT_SOFT                           0x1402
-#define ALC_UNSIGNED_SHORT_SOFT                  0x1403
-#define ALC_INT_SOFT                             0x1404
-#define ALC_UNSIGNED_INT_SOFT                    0x1405
-#define ALC_FLOAT_SOFT                           0x1406
-
-/* Channel configurations */
-#define ALC_MONO_SOFT                            0x1500
-#define ALC_STEREO_SOFT                          0x1501
-#define ALC_QUAD_SOFT                            0x1503
-#define ALC_5POINT1_SOFT                         0x1504
-#define ALC_6POINT1_SOFT                         0x1505
-#define ALC_7POINT1_SOFT                         0x1506
-
-typedef ALCdevice* (ALC_APIENTRY*LPALCLOOPBACKOPENDEVICESOFT)(const ALCchar*);
-typedef ALCboolean (ALC_APIENTRY*LPALCISRENDERFORMATSUPPORTEDSOFT)(ALCdevice*,ALCsizei,ALCenum,ALCenum);
-typedef void (ALC_APIENTRY*LPALCRENDERSAMPLESSOFT)(ALCdevice*,ALCvoid*,ALCsizei);
-#ifdef AL_ALEXT_PROTOTYPES
-ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName);
-ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type);
-ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
-#endif
-#endif
-
-#ifndef AL_EXT_STEREO_ANGLES
-#define AL_EXT_STEREO_ANGLES 1
-#define AL_STEREO_ANGLES                         0x1030
-#endif
-
-#ifndef AL_EXT_SOURCE_RADIUS
-#define AL_EXT_SOURCE_RADIUS 1
-#define AL_SOURCE_RADIUS                         0x1031
-#endif
-
-#ifndef AL_SOFT_source_latency
-#define AL_SOFT_source_latency 1
-#define AL_SAMPLE_OFFSET_LATENCY_SOFT            0x1200
-#define AL_SEC_OFFSET_LATENCY_SOFT               0x1201
-typedef int64_t ALint64SOFT;
-typedef uint64_t ALuint64SOFT;
-typedef void (AL_APIENTRY*LPALSOURCEDSOFT)(ALuint,ALenum,ALdouble);
-typedef void (AL_APIENTRY*LPALSOURCE3DSOFT)(ALuint,ALenum,ALdouble,ALdouble,ALdouble);
-typedef void (AL_APIENTRY*LPALSOURCEDVSOFT)(ALuint,ALenum,const ALdouble*);
-typedef void (AL_APIENTRY*LPALGETSOURCEDSOFT)(ALuint,ALenum,ALdouble*);
-typedef void (AL_APIENTRY*LPALGETSOURCE3DSOFT)(ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*);
-typedef void (AL_APIENTRY*LPALGETSOURCEDVSOFT)(ALuint,ALenum,ALdouble*);
-typedef void (AL_APIENTRY*LPALSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT);
-typedef void (AL_APIENTRY*LPALSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT,ALint64SOFT,ALint64SOFT);
-typedef void (AL_APIENTRY*LPALSOURCEI64VSOFT)(ALuint,ALenum,const ALint64SOFT*);
-typedef void (AL_APIENTRY*LPALGETSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT*);
-typedef void (AL_APIENTRY*LPALGETSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*);
-typedef void (AL_APIENTRY*LPALGETSOURCEI64VSOFT)(ALuint,ALenum,ALint64SOFT*);
-#ifdef AL_ALEXT_PROTOTYPES
-AL_API void AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value);
-AL_API void AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3);
-AL_API void AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values);
-AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value);
-AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3);
-AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values);
-AL_API void AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value);
-AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3);
-AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values);
-AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value);
-AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3);
-AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values);
-#endif
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.12)
+
+project(Launcher)
+
+set(LAUNCHER_SOURCES "${CMAKE_SOURCE_DIR}/code/Launcher/launch_main.cpp")
+
+if (WIN32)
+    set(LAUNCHER_SOURCES ${LAUNCHER_SOURCES}
+    "${CMAKE_SOURCE_DIR}/code/Launcher/launch_win32.cpp"
+    "${CMAKE_SOURCE_DIR}/code/sys/win_resource.rc")
+else()
+    set(LAUNCHER_SOURCES ${LAUNCHER_SOURCES}
+    "${CMAKE_SOURCE_DIR}/code/Launcher/launch_linux.cpp")
+endif()
+
+function (create_launcher name type)
+    if (NOT BUILD_NO_CLIENT)
+        add_executable(openmohaa_launcher_${name} ${LAUNCHER_SOURCES})
+        target_include_directories(openmohaa_launcher_${name} PUBLIC "../qcommon")
+        target_compile_definitions(openmohaa_launcher_${name} PRIVATE NO_RC_MANIFEST=1 TARGET_GAME=${type})
+        target_compile_features(openmohaa_launcher_${name} PRIVATE cxx_std_17)
+        set_target_properties(openmohaa_launcher_${name} PROPERTIES OUTPUT_NAME "launch_openmohaa_${name}${TARGET_BIN_SUFFIX}")
+        set_target_properties(openmohaa_launcher_${name} PROPERTIES DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
+
+        INSTALL(TARGETS openmohaa_launcher_${name} DESTINATION ${CMAKE_INSTALL_BINDIR}/${BIN_INSTALL_SUBDIR})
+    endif()
+
+    #add_executable(omohaaded_launcher_${name} ${LAUNCHER_SOURCES})
+    #target_include_directories(omohaaded_launcher_${name} PUBLIC "../qcommon")
+    #target_compile_definitions(omohaaded_launcher_${name} PRIVATE NO_RC_MANIFEST=1 TARGET_GAME=${type} DEDICATED=1)
+    #target_compile_features(omohaaded_launcher_${name} PRIVATE cxx_std_17)
+    #set_target_properties(omohaaded_launcher_${name} PROPERTIES OUTPUT_NAME "launch_omohaaded_${name}${TARGET_BIN_SUFFIX}")
+    #set_target_properties(omohaaded_launcher_${name} PROPERTIES DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
+    #
+    #INSTALL(TARGETS omohaaded_launcher_${name} DESTINATION ${CMAKE_INSTALL_BINDIR}/${PROJECT_INSTALL_SUBDIR})
+endfunction()
+
+create_launcher(base 0)
+create_launcher(spearhead 1)
+create_launcher(breakthrough 2)
@@ -1,6 +1,6 @@
 /*
 ===========================================================================
-Copyright (C) 2023 the OpenMoHAA team
+Copyright (C) 2025 the OpenMoHAA team

 This file is part of OpenMoHAA source code.

@@ -20,15 +20,13 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */

-// tr_vis.cpp: visibility culling
+// launch.h: Base interface for starting programs

-#include "tr_local.h"
-#include "tr_vis.h"
+#include "q_platform.h"

-void R_VisDebug() {
-    // FIXME: unimplemented
-}
+#include <filesystem>
+#include <string>
+#include <vector>

-void R_VisDebugLoad(const char* szBSPName) {
-    // FIXME: unimplemented
-}
+std::filesystem::path GetProgramLocation();
+void                  LaunchProgram(const std::filesystem::path& path, const std::vector<std::string>& argumentList);
@@ -0,0 +1,80 @@
+/*
+===========================================================================
+Copyright (C) 2025 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+// main.cpp: Windows implementation of the launcher
+
+#include "launch.h"
+
+#include <unistd.h>
+#include <spawn.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+
+#include <string>
+#include <iostream>
+
+extern "C" char **environ;
+
+std::filesystem::path GetProgramLocation()
+{
+    char    path[FILENAME_MAX];
+    ssize_t count = readlink("/proc/self/exe", path, FILENAME_MAX);
+
+    return std::filesystem::path(std::string(path, (count > 0) ? count : 0)).parent_path();
+}
+
+void LaunchProgram(const std::filesystem::path& path, const std::vector<std::string>& argumentList)
+{
+    pid_t       pid;
+    std::string pathString = path.string();
+    size_t      argCount   = argumentList.size();
+    char      **argv;
+    int         status;
+
+    argv    = new char *[argCount + 2];
+    argv[0] = (char *)pathString.c_str();
+
+    for (size_t i = 0; i < argCount; i++) {
+        argv[i + 1] = (char *)argumentList[i].c_str();
+    }
+    argv[argCount + 1] = NULL;
+
+    //status = posix_spawn(&pid, pathString.c_str(), NULL, NULL, argv, environ);
+    //delete[] argv;
+    //if (status != 0) {
+    //    std::cout << "posix_spawn returned error: " << status << std::endl;
+    //    return;
+    //}
+
+    //
+    // Using execve rather than posix_spawn
+    //  This replaces the current process that is not needed anyway
+    //
+    status = execve(pathString.c_str(), argv, environ);
+    delete[] argv;
+    if (status == -1) {
+        std::cout << "posix_spawn returned error: " << errno << std::endl;
+        return;
+    }
+
+    waitpid(pid, NULL, 0);
+}
@@ -0,0 +1,63 @@
+/*
+===========================================================================
+Copyright (C) 2025 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+// main.cpp: The launcher
+
+#include "launch.h"
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+const char *targetGameList[] = {"Base", "Spearhead", "Breakthrough"};
+
+int main(int argc, const char *argv[])
+{
+    std::vector<std::string> argumentList;
+#if !defined(DEDICATED) || !DEDICATED
+    const char *programName = "openmohaa" DLL_SUFFIX EXE_EXT;
+#else
+    const char *programName = "omohaaded" DLL_SUFFIX EXE_EXT;
+#endif
+
+    argumentList.push_back("+set");
+    argumentList.push_back("com_target_game");
+    argumentList.push_back(std::to_string(TARGET_GAME));
+
+    for (size_t i = 1; i < argc; i++) {
+        argumentList.push_back(argv[i]);
+    }
+
+    std::cout << "Using the target game: " << targetGameList[TARGET_GAME] << std::endl;
+    std::cout << std::endl;
+    std::cout << "Expected program name: " << programName << std::endl;
+
+    const std::filesystem::path programLocation = GetProgramLocation();
+    const std::filesystem::path programPath     = programLocation / programName;
+
+    std::cout << "Program location: " << programLocation << std::endl;
+    std::cout << "Expected path: " << programPath << std::endl;
+
+    LaunchProgram(programPath, argumentList);
+
+    return 0;
+}
@@ -0,0 +1,87 @@
+/*
+===========================================================================
+Copyright (C) 2025 the OpenMoHAA team
+
+This file is part of OpenMoHAA source code.
+
+OpenMoHAA source code is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+OpenMoHAA source code is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with OpenMoHAA source code; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+===========================================================================
+*/
+
+// main.cpp: Windows implementation of the launcher
+
+#include "launch.h"
+
+#include <Windows.h>
+#include <string>
+#include <iostream>
+
+std::filesystem::path GetProgramLocation()
+{
+    wchar_t path[FILENAME_MAX] = {0};
+    GetModuleFileNameW(nullptr, path, FILENAME_MAX);
+
+    return std::filesystem::path(path).parent_path();
+}
+
+void LaunchProgram(const std::filesystem::path& path, const std::vector<std::string>& argumentList)
+{
+    PROCESS_INFORMATION processInfo;
+    STARTUPINFOW        startupInfo;
+    BOOL                returnValue;
+    std::wstring        osCommandLine;
+    std::wstring        commandLine;
+    size_t              argCount = argumentList.size();
+
+    memset(&processInfo, 0, sizeof(processInfo));
+    memset(&startupInfo, 0, sizeof(startupInfo));
+    startupInfo.cb = sizeof(startupInfo);
+
+    for (size_t i = 0; i < argCount; i++) {
+        commandLine += L"\"";
+        commandLine += std::wstring(argumentList[i].begin(), argumentList[i].end());
+        commandLine += L"\"";
+        if (i != argCount - 1) {
+            commandLine += L" ";
+        }
+    }
+
+    osCommandLine = L"\"" + path.wstring() + L"\"";
+    osCommandLine += L" ";
+    osCommandLine += commandLine;
+
+    returnValue = CreateProcessW(
+        path.wstring().c_str(),
+        (LPWSTR)osCommandLine.c_str(),
+        NULL,
+        NULL,
+        FALSE,
+        0,
+        NULL,
+        std::filesystem::current_path().wstring().c_str(),
+        &startupInfo,
+        &processInfo
+    );
+
+    if (!returnValue) {
+        std::cout << "Error in CreateProcess: " << GetLastError() << std::endl;
+        return;
+    }
+
+    WaitForSingleObject(processInfo.hProcess, INFINITE);
+
+    CloseHandle(processInfo.hProcess);
+    CloseHandle(processInfo.hThread);
+}
@@ -1,232 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL.h
- *
- *  Main include header for the SDL library
- */
-
-
-#ifndef SDL_h_
-#define SDL_h_
-
-#include "SDL_main.h"
-#include "SDL_stdinc.h"
-#include "SDL_assert.h"
-#include "SDL_atomic.h"
-#include "SDL_audio.h"
-#include "SDL_clipboard.h"
-#include "SDL_cpuinfo.h"
-#include "SDL_endian.h"
-#include "SDL_error.h"
-#include "SDL_events.h"
-#include "SDL_filesystem.h"
-#include "SDL_gamecontroller.h"
-#include "SDL_haptic.h"
-#include "SDL_hidapi.h"
-#include "SDL_hints.h"
-#include "SDL_joystick.h"
-#include "SDL_loadso.h"
-#include "SDL_log.h"
-#include "SDL_messagebox.h"
-#include "SDL_metal.h"
-#include "SDL_mutex.h"
-#include "SDL_power.h"
-#include "SDL_render.h"
-#include "SDL_rwops.h"
-#include "SDL_sensor.h"
-#include "SDL_shape.h"
-#include "SDL_system.h"
-#include "SDL_thread.h"
-#include "SDL_timer.h"
-#include "SDL_version.h"
-#include "SDL_video.h"
-#include "SDL_locale.h"
-#include "SDL_misc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* As of version 0.5, SDL is loaded dynamically into the application */
-
-/**
- *  \name SDL_INIT_*
- *
- *  These are the flags which may be passed to SDL_Init().  You should
- *  specify the subsystems which you will be using in your application.
- */
-/* @{ */
-#define SDL_INIT_TIMER          0x00000001u
-#define SDL_INIT_AUDIO          0x00000010u
-#define SDL_INIT_VIDEO          0x00000020u  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-#define SDL_INIT_JOYSTICK       0x00000200u  /**< SDL_INIT_JOYSTICK implies SDL_INIT_EVENTS */
-#define SDL_INIT_HAPTIC         0x00001000u
-#define SDL_INIT_GAMECONTROLLER 0x00002000u  /**< SDL_INIT_GAMECONTROLLER implies SDL_INIT_JOYSTICK */
-#define SDL_INIT_EVENTS         0x00004000u
-#define SDL_INIT_SENSOR         0x00008000u
-#define SDL_INIT_NOPARACHUTE    0x00100000u  /**< compatibility; this flag is ignored. */
-#define SDL_INIT_EVERYTHING ( \
-                SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_EVENTS | \
-                SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER | SDL_INIT_SENSOR \
-            )
-/* @} */
-
-/**
- * Initialize the SDL library.
- *
- * SDL_Init() simply forwards to calling SDL_InitSubSystem(). Therefore, the
- * two may be used interchangeably. Though for readability of your code
- * SDL_InitSubSystem() might be preferred.
- *
- * The file I/O (for example: SDL_RWFromFile) and threading (SDL_CreateThread)
- * subsystems are initialized by default. Message boxes
- * (SDL_ShowSimpleMessageBox) also attempt to work without initializing the
- * video subsystem, in hopes of being useful in showing an error dialog when
- * SDL_Init fails. You must specifically initialize other subsystems if you
- * use them in your application.
- *
- * Logging (such as SDL_Log) works without initialization, too.
- *
- * `flags` may be any of the following OR'd together:
- *
- * - `SDL_INIT_TIMER`: timer subsystem
- * - `SDL_INIT_AUDIO`: audio subsystem
- * - `SDL_INIT_VIDEO`: video subsystem; automatically initializes the events
- *   subsystem
- * - `SDL_INIT_JOYSTICK`: joystick subsystem; automatically initializes the
- *   events subsystem
- * - `SDL_INIT_HAPTIC`: haptic (force feedback) subsystem
- * - `SDL_INIT_GAMECONTROLLER`: controller subsystem; automatically
- *   initializes the joystick subsystem
- * - `SDL_INIT_EVENTS`: events subsystem
- * - `SDL_INIT_EVERYTHING`: all of the above subsystems
- * - `SDL_INIT_NOPARACHUTE`: compatibility; this flag is ignored
- *
- * Subsystem initialization is ref-counted, you must call SDL_QuitSubSystem()
- * for each SDL_InitSubSystem() to correctly shutdown a subsystem manually (or
- * call SDL_Quit() to force shutdown). If a subsystem is already loaded then
- * this call will increase the ref-count and return.
- *
- * \param flags subsystem initialization flags
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_InitSubSystem
- * \sa SDL_Quit
- * \sa SDL_SetMainReady
- * \sa SDL_WasInit
- */
-extern DECLSPEC int SDLCALL SDL_Init(Uint32 flags);
-
-/**
- * Compatibility function to initialize the SDL library.
- *
- * In SDL2, this function and SDL_Init() are interchangeable.
- *
- * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Init
- * \sa SDL_Quit
- * \sa SDL_QuitSubSystem
- */
-extern DECLSPEC int SDLCALL SDL_InitSubSystem(Uint32 flags);
-
-/**
- * Shut down specific SDL subsystems.
- *
- * If you start a subsystem using a call to that subsystem's init function
- * (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),
- * SDL_QuitSubSystem() and SDL_WasInit() will not work. You will need to use
- * that subsystem's quit function (SDL_VideoQuit()) directly instead. But
- * generally, you should not be using those functions directly anyhow; use
- * SDL_Init() instead.
- *
- * You still need to call SDL_Quit() even if you close all open subsystems
- * with SDL_QuitSubSystem().
- *
- * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_InitSubSystem
- * \sa SDL_Quit
- */
-extern DECLSPEC void SDLCALL SDL_QuitSubSystem(Uint32 flags);
-
-/**
- * Get a mask of the specified subsystems which are currently initialized.
- *
- * \param flags any of the flags used by SDL_Init(); see SDL_Init for details.
- * \returns a mask of all initialized subsystems if `flags` is 0, otherwise it
- *          returns the initialization status of the specified subsystems.
- *
- *          The return value does not include SDL_INIT_NOPARACHUTE.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Init
- * \sa SDL_InitSubSystem
- */
-extern DECLSPEC Uint32 SDLCALL SDL_WasInit(Uint32 flags);
-
-/**
- * Clean up all initialized subsystems.
- *
- * You should call this function even if you have already shutdown each
- * initialized subsystem with SDL_QuitSubSystem(). It is safe to call this
- * function even in the case of errors in initialization.
- *
- * If you start a subsystem using a call to that subsystem's init function
- * (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),
- * then you must use that subsystem's quit function (SDL_VideoQuit()) to shut
- * it down before calling SDL_Quit(). But generally, you should not be using
- * those functions directly anyhow; use SDL_Init() instead.
- *
- * You can use this function with atexit() to ensure that it is run when your
- * application is shutdown, but it is not wise to do this from a library or
- * other dynamically loaded code.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Init
- * \sa SDL_QuitSubSystem
- */
-extern DECLSPEC void SDLCALL SDL_Quit(void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,324 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_assert_h_
-#define SDL_assert_h_
-
-#include "SDL_config.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef SDL_ASSERT_LEVEL
-#ifdef SDL_DEFAULT_ASSERT_LEVEL
-#define SDL_ASSERT_LEVEL SDL_DEFAULT_ASSERT_LEVEL
-#elif defined(_DEBUG) || defined(DEBUG) || \
-      (defined(__GNUC__) && !defined(__OPTIMIZE__))
-#define SDL_ASSERT_LEVEL 2
-#else
-#define SDL_ASSERT_LEVEL 1
-#endif
-#endif /* SDL_ASSERT_LEVEL */
-
-/*
-These are macros and not first class functions so that the debugger breaks
-on the assertion line and not in some random guts of SDL, and so each
-assert can have unique static variables associated with it.
-*/
-
-#if defined(_MSC_VER)
-/* Don't include intrin.h here because it contains C++ code */
-    extern void __cdecl __debugbreak(void);
-    #define SDL_TriggerBreakpoint() __debugbreak()
-#elif ( (!defined(__NACL__)) && ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))) )
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" )
-#elif ( defined(__APPLE__) && (defined(__arm64__) || defined(__aarch64__)) )  /* this might work on other ARM targets, but this is a known quantity... */
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "brk #22\n\t" )
-#elif defined(__APPLE__) && defined(__arm__)
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "bkpt #22\n\t" )
-#elif defined(__386__) && defined(__WATCOMC__)
-    #define SDL_TriggerBreakpoint() { _asm { int 0x03 } }
-#elif defined(HAVE_SIGNAL_H) && !defined(__WATCOMC__)
-    #include <signal.h>
-    #define SDL_TriggerBreakpoint() raise(SIGTRAP)
-#else
-    /* How do we trigger breakpoints on this platform? */
-    #define SDL_TriggerBreakpoint()
-#endif
-
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 supports __func__ as a standard. */
-#   define SDL_FUNCTION __func__
-#elif ((__GNUC__ >= 2) || defined(_MSC_VER) || defined (__WATCOMC__))
-#   define SDL_FUNCTION __FUNCTION__
-#else
-#   define SDL_FUNCTION "???"
-#endif
-#define SDL_FILE    __FILE__
-#define SDL_LINE    __LINE__
-
-/*
-sizeof (x) makes the compiler still parse the expression even without
-assertions enabled, so the code is always checked at compile time, but
-doesn't actually generate code for it, so there are no side effects or
-expensive checks at run time, just the constant size of what x WOULD be,
-which presumably gets optimized out as unused.
-This also solves the problem of...
-
-    int somevalue = blah();
-    SDL_assert(somevalue == 1);
-
-...which would cause compiles to complain that somevalue is unused if we
-disable assertions.
-*/
-
-/* "while (0,0)" fools Microsoft's compiler's /W4 warning level into thinking
-    this condition isn't constant. And looks like an owl's face! */
-#ifdef _MSC_VER  /* stupid /W4 warnings. */
-#define SDL_NULL_WHILE_LOOP_CONDITION (0,0)
-#else
-#define SDL_NULL_WHILE_LOOP_CONDITION (0)
-#endif
-
-#define SDL_disabled_assert(condition) \
-    do { (void) sizeof ((condition)); } while (SDL_NULL_WHILE_LOOP_CONDITION)
-
-typedef enum
-{
-    SDL_ASSERTION_RETRY,  /**< Retry the assert immediately. */
-    SDL_ASSERTION_BREAK,  /**< Make the debugger trigger a breakpoint. */
-    SDL_ASSERTION_ABORT,  /**< Terminate the program. */
-    SDL_ASSERTION_IGNORE,  /**< Ignore the assert. */
-    SDL_ASSERTION_ALWAYS_IGNORE  /**< Ignore the assert from now on. */
-} SDL_AssertState;
-
-typedef struct SDL_AssertData
-{
-    int always_ignore;
-    unsigned int trigger_count;
-    const char *condition;
-    const char *filename;
-    int linenum;
-    const char *function;
-    const struct SDL_AssertData *next;
-} SDL_AssertData;
-
-#if (SDL_ASSERT_LEVEL > 0)
-
-/* Never call this directly. Use the SDL_assert* macros. */
-extern DECLSPEC SDL_AssertState SDLCALL SDL_ReportAssertion(SDL_AssertData *,
-                                                             const char *,
-                                                             const char *, int)
-#if defined(__clang__)
-#if __has_feature(attribute_analyzer_noreturn)
-/* this tells Clang's static analysis that we're a custom assert function,
-   and that the analyzer should assume the condition was always true past this
-   SDL_assert test. */
-   __attribute__((analyzer_noreturn))
-#endif
-#endif
-;
-
-/* the do {} while(0) avoids dangling else problems:
-    if (x) SDL_assert(y); else blah();
-       ... without the do/while, the "else" could attach to this macro's "if".
-   We try to handle just the minimum we need here in a macro...the loop,
-   the static vars, and break points. The heavy lifting is handled in
-   SDL_ReportAssertion(), in SDL_assert.c.
-*/
-#define SDL_enabled_assert(condition) \
-    do { \
-        while ( !(condition) ) { \
-            static struct SDL_AssertData sdl_assert_data = { \
-                0, 0, #condition, 0, 0, 0, 0 \
-            }; \
-            const SDL_AssertState sdl_assert_state = SDL_ReportAssertion(&sdl_assert_data, SDL_FUNCTION, SDL_FILE, SDL_LINE); \
-            if (sdl_assert_state == SDL_ASSERTION_RETRY) { \
-                continue; /* go again. */ \
-            } else if (sdl_assert_state == SDL_ASSERTION_BREAK) { \
-                SDL_TriggerBreakpoint(); \
-            } \
-            break; /* not retrying. */ \
-        } \
-    } while (SDL_NULL_WHILE_LOOP_CONDITION)
-
-#endif  /* enabled assertions support code */
-
-/* Enable various levels of assertions. */
-#if SDL_ASSERT_LEVEL == 0   /* assertions disabled */
-#   define SDL_assert(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 1  /* release settings. */
-#   define SDL_assert(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 2  /* normal settings. */
-#   define SDL_assert(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 3  /* paranoid settings. */
-#   define SDL_assert(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_enabled_assert(condition)
-#else
-#   error Unknown assertion level.
-#endif
-
-/* this assertion is never disabled at any level. */
-#define SDL_assert_always(condition) SDL_enabled_assert(condition)
-
-
-/**
- * A callback that fires when an SDL assertion fails.
- *
- * \param data a pointer to the SDL_AssertData structure corresponding to the
- *             current assertion
- * \param userdata what was passed as `userdata` to SDL_SetAssertionHandler()
- * \returns an SDL_AssertState value indicating how to handle the failure.
- */
-typedef SDL_AssertState (SDLCALL *SDL_AssertionHandler)(
-                                 const SDL_AssertData* data, void* userdata);
-
-/**
- * Set an application-defined assertion handler.
- *
- * This function allows an application to show its own assertion UI and/or
- * force the response to an assertion failure. If the application doesn't
- * provide this, SDL will try to do the right thing, popping up a
- * system-specific GUI dialog, and probably minimizing any fullscreen windows.
- *
- * This callback may fire from any thread, but it runs wrapped in a mutex, so
- * it will only fire from one thread at a time.
- *
- * This callback is NOT reset to SDL's internal handler upon SDL_Quit()!
- *
- * \param handler the SDL_AssertionHandler function to call when an assertion
- *                fails or NULL for the default handler
- * \param userdata a pointer that is passed to `handler`
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetAssertionHandler
- */
-extern DECLSPEC void SDLCALL SDL_SetAssertionHandler(
-                                            SDL_AssertionHandler handler,
-                                            void *userdata);
-
-/**
- * Get the default assertion handler.
- *
- * This returns the function pointer that is called by default when an
- * assertion is triggered. This is an internal function provided by SDL, that
- * is used for assertions when SDL_SetAssertionHandler() hasn't been used to
- * provide a different function.
- *
- * \returns the default SDL_AssertionHandler that is called when an assert
- *          triggers.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_GetAssertionHandler
- */
-extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetDefaultAssertionHandler(void);
-
-/**
- * Get the current assertion handler.
- *
- * This returns the function pointer that is called when an assertion is
- * triggered. This is either the value last passed to
- * SDL_SetAssertionHandler(), or if no application-specified function is set,
- * is equivalent to calling SDL_GetDefaultAssertionHandler().
- *
- * The parameter `puserdata` is a pointer to a void*, which will store the
- * "userdata" pointer that was passed to SDL_SetAssertionHandler(). This value
- * will always be NULL for the default handler. If you don't care about this
- * data, it is safe to pass a NULL pointer to this function to ignore it.
- *
- * \param puserdata pointer which is filled with the "userdata" pointer that
- *                  was passed to SDL_SetAssertionHandler()
- * \returns the SDL_AssertionHandler that is called when an assert triggers.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_SetAssertionHandler
- */
-extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetAssertionHandler(void **puserdata);
-
-/**
- * Get a list of all assertion failures.
- *
- * This function gets all assertions triggered since the last call to
- * SDL_ResetAssertionReport(), or the start of the program.
- *
- * The proper way to examine this data looks something like this:
- *
- * ```c
- * const SDL_AssertData *item = SDL_GetAssertionReport();
- * while (item) {
- *    printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\n",
- *           item->condition, item->function, item->filename,
- *           item->linenum, item->trigger_count,
- *           item->always_ignore ? "yes" : "no");
- *    item = item->next;
- * }
- * ```
- *
- * \returns a list of all failed assertions or NULL if the list is empty. This
- *          memory should not be modified or freed by the application.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ResetAssertionReport
- */
-extern DECLSPEC const SDL_AssertData * SDLCALL SDL_GetAssertionReport(void);
-
-/**
- * Clear the list of all assertion failures.
- *
- * This function will clear the list of all assertions triggered up to that
- * point. Immediately following this call, SDL_GetAssertionReport will return
- * no items. In addition, any previously-triggered assertions will be reset to
- * a trigger_count of zero, and their always_ignore state will be false.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetAssertionReport
- */
-extern DECLSPEC void SDLCALL SDL_ResetAssertionReport(void);
-
-
-/* these had wrong naming conventions until 2.0.4. Please update your app! */
-#define SDL_assert_state SDL_AssertState
-#define SDL_assert_data SDL_AssertData
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_assert_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,395 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * \file SDL_atomic.h
- *
- * Atomic operations.
- *
- * IMPORTANT:
- * If you are not an expert in concurrent lockless programming, you should
- * only be using the atomic lock and reference counting functions in this
- * file.  In all other cases you should be protecting your data structures
- * with full mutexes.
- *
- * The list of "safe" functions to use are:
- *  SDL_AtomicLock()
- *  SDL_AtomicUnlock()
- *  SDL_AtomicIncRef()
- *  SDL_AtomicDecRef()
- *
- * Seriously, here be dragons!
- * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
- *
- * You can find out a little more about lockless programming and the
- * subtle issues that can arise here:
- * http://msdn.microsoft.com/en-us/library/ee418650%28v=vs.85%29.aspx
- *
- * There's also lots of good information here:
- * http://www.1024cores.net/home/lock-free-algorithms
- * http://preshing.com/
- *
- * These operations may or may not actually be implemented using
- * processor specific atomic operations. When possible they are
- * implemented as true processor specific atomic operations. When that
- * is not possible the are implemented using locks that *do* use the
- * available atomic operations.
- *
- * All of the atomic operations that modify memory are full memory barriers.
- */
-
-#ifndef SDL_atomic_h_
-#define SDL_atomic_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_platform.h"
-
-#include "begin_code.h"
-
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \name SDL AtomicLock
- *
- * The atomic locks are efficient spinlocks using CPU instructions,
- * but are vulnerable to starvation and can spin forever if a thread
- * holding a lock has been terminated.  For this reason you should
- * minimize the code executed inside an atomic lock and never do
- * expensive things like API or system calls while holding them.
- *
- * The atomic locks are not safe to lock recursively.
- *
- * Porting Note:
- * The spin lock functions and type are required and can not be
- * emulated because they are used in the atomic emulation code.
- */
-/* @{ */
-
-typedef int SDL_SpinLock;
-
-/**
- * Try to lock a spin lock by setting it to a non-zero value.
- *
- * ***Please note that spinlocks are dangerous if you don't know what you're
- * doing. Please be careful using any sort of spinlock!***
- *
- * \param lock a pointer to a lock variable
- * \returns SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already
- *          held.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicLock
- * \sa SDL_AtomicUnlock
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTryLock(SDL_SpinLock *lock);
-
-/**
- * Lock a spin lock by setting it to a non-zero value.
- *
- * ***Please note that spinlocks are dangerous if you don't know what you're
- * doing. Please be careful using any sort of spinlock!***
- *
- * \param lock a pointer to a lock variable
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicTryLock
- * \sa SDL_AtomicUnlock
- */
-extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
-
-/**
- * Unlock a spin lock by setting it to 0.
- *
- * Always returns immediately.
- *
- * ***Please note that spinlocks are dangerous if you don't know what you're
- * doing. Please be careful using any sort of spinlock!***
- *
- * \param lock a pointer to a lock variable
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicLock
- * \sa SDL_AtomicTryLock
- */
-extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
-
-/* @} *//* SDL AtomicLock */
-
-
-/**
- * The compiler barrier prevents the compiler from reordering
- * reads and writes to globally visible variables across the call.
- */
-#if defined(_MSC_VER) && (_MSC_VER > 1200) && !defined(__clang__)
-void _ReadWriteBarrier(void);
-#pragma intrinsic(_ReadWriteBarrier)
-#define SDL_CompilerBarrier()   _ReadWriteBarrier()
-#elif (defined(__GNUC__) && !defined(__EMSCRIPTEN__)) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x5120))
-/* This is correct for all CPUs when using GCC or Solaris Studio 12.1+. */
-#define SDL_CompilerBarrier()   __asm__ __volatile__ ("" : : : "memory")
-#elif defined(__WATCOMC__)
-extern __inline void SDL_CompilerBarrier(void);
-#pragma aux SDL_CompilerBarrier = "" parm [] modify exact [];
-#else
-#define SDL_CompilerBarrier()   \
-{ SDL_SpinLock _tmp = 0; SDL_AtomicLock(&_tmp); SDL_AtomicUnlock(&_tmp); }
-#endif
-
-/**
- * Memory barriers are designed to prevent reads and writes from being
- * reordered by the compiler and being seen out of order on multi-core CPUs.
- *
- * A typical pattern would be for thread A to write some data and a flag, and
- * for thread B to read the flag and get the data. In this case you would
- * insert a release barrier between writing the data and the flag,
- * guaranteeing that the data write completes no later than the flag is
- * written, and you would insert an acquire barrier between reading the flag
- * and reading the data, to ensure that all the reads associated with the flag
- * have completed.
- *
- * In this pattern you should always see a release barrier paired with an
- * acquire barrier and you should gate the data reads/writes with a single
- * flag variable.
- *
- * For more information on these semantics, take a look at the blog post:
- * http://preshing.com/20120913/acquire-and-release-semantics
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC void SDLCALL SDL_MemoryBarrierReleaseFunction(void);
-extern DECLSPEC void SDLCALL SDL_MemoryBarrierAcquireFunction(void);
-
-#if defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("lwsync" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("lwsync" : : : "memory")
-#elif defined(__GNUC__) && defined(__aarch64__)
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#elif defined(__GNUC__) && defined(__arm__)
-#if 0 /* defined(__LINUX__) || defined(__ANDROID__) */
-/* Information from:
-   https://chromium.googlesource.com/chromium/chromium/+/trunk/base/atomicops_internals_arm_gcc.h#19
-
-   The Linux kernel provides a helper function which provides the right code for a memory barrier,
-   hard-coded at address 0xffff0fa0
-*/
-typedef void (*SDL_KernelMemoryBarrierFunc)();
-#define SDL_MemoryBarrierRelease()	((SDL_KernelMemoryBarrierFunc)0xffff0fa0)()
-#define SDL_MemoryBarrierAcquire()	((SDL_KernelMemoryBarrierFunc)0xffff0fa0)()
-#elif 0 /* defined(__QNXNTO__) */
-#include <sys/cpuinline.h>
-
-#define SDL_MemoryBarrierRelease()   __cpu_membarrier()
-#define SDL_MemoryBarrierAcquire()   __cpu_membarrier()
-#else
-#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) || defined(__ARM_ARCH_8A__)
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_5TE__)
-#ifdef __thumb__
-/* The mcr instruction isn't available in thumb mode, use real functions */
-#define SDL_MEMORY_BARRIER_USES_FUNCTION
-#define SDL_MemoryBarrierRelease()   SDL_MemoryBarrierReleaseFunction()
-#define SDL_MemoryBarrierAcquire()   SDL_MemoryBarrierAcquireFunction()
-#else
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("mcr p15, 0, %0, c7, c10, 5" : : "r"(0) : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("mcr p15, 0, %0, c7, c10, 5" : : "r"(0) : "memory")
-#endif /* __thumb__ */
-#else
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("" : : : "memory")
-#endif /* __LINUX__ || __ANDROID__ */
-#endif /* __GNUC__ && __arm__ */
-#else
-#if (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x5120))
-/* This is correct for all CPUs on Solaris when using Solaris Studio 12.1+. */
-#include <mbarrier.h>
-#define SDL_MemoryBarrierRelease()  __machine_rel_barrier()
-#define SDL_MemoryBarrierAcquire()  __machine_acq_barrier()
-#else
-/* This is correct for the x86 and x64 CPUs, and we'll expand this over time. */
-#define SDL_MemoryBarrierRelease()  SDL_CompilerBarrier()
-#define SDL_MemoryBarrierAcquire()  SDL_CompilerBarrier()
-#endif
-#endif
-
-/**
- * \brief A type representing an atomic integer value.  It is a struct
- *        so people don't accidentally use numeric operations on it.
- */
-typedef struct { int value; } SDL_atomic_t;
-
-/**
- * Set an atomic variable to a new value if it is currently an old value.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to an SDL_atomic_t variable to be modified
- * \param oldval the old value
- * \param newval the new value
- * \returns SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicCASPtr
- * \sa SDL_AtomicGet
- * \sa SDL_AtomicSet
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval);
-
-/**
- * Set an atomic variable to a value.
- *
- * This function also acts as a full memory barrier.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to an SDL_atomic_t variable to be modified
- * \param v the desired value
- * \returns the previous value of the atomic variable.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicGet
- */
-extern DECLSPEC int SDLCALL SDL_AtomicSet(SDL_atomic_t *a, int v);
-
-/**
- * Get the value of an atomic variable.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to an SDL_atomic_t variable
- * \returns the current value of an atomic variable.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicSet
- */
-extern DECLSPEC int SDLCALL SDL_AtomicGet(SDL_atomic_t *a);
-
-/**
- * Add to an atomic variable.
- *
- * This function also acts as a full memory barrier.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to an SDL_atomic_t variable to be modified
- * \param v the desired value to add
- * \returns the previous value of the atomic variable.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicDecRef
- * \sa SDL_AtomicIncRef
- */
-extern DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_atomic_t *a, int v);
-
-/**
- * \brief Increment an atomic variable used as a reference count.
- */
-#ifndef SDL_AtomicIncRef
-#define SDL_AtomicIncRef(a)    SDL_AtomicAdd(a, 1)
-#endif
-
-/**
- * \brief Decrement an atomic variable used as a reference count.
- *
- * \return SDL_TRUE if the variable reached zero after decrementing,
- *         SDL_FALSE otherwise
- */
-#ifndef SDL_AtomicDecRef
-#define SDL_AtomicDecRef(a)    (SDL_AtomicAdd(a, -1) == 1)
-#endif
-
-/**
- * Set a pointer to a new value if it is currently an old value.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to a pointer
- * \param oldval the old pointer value
- * \param newval the new pointer value
- * \returns SDL_TRUE if the pointer was set, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AtomicCAS
- * \sa SDL_AtomicGetPtr
- * \sa SDL_AtomicSetPtr
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCASPtr(void **a, void *oldval, void *newval);
-
-/**
- * Set a pointer to a value atomically.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to a pointer
- * \param v the desired pointer value
- * \returns the previous value of the pointer.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicCASPtr
- * \sa SDL_AtomicGetPtr
- */
-extern DECLSPEC void* SDLCALL SDL_AtomicSetPtr(void **a, void* v);
-
-/**
- * Get the value of a pointer atomically.
- *
- * ***Note: If you don't know what this function is for, you shouldn't use
- * it!***
- *
- * \param a a pointer to a pointer
- * \returns the current value of a pointer.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_AtomicCASPtr
- * \sa SDL_AtomicSetPtr
- */
-extern DECLSPEC void* SDLCALL SDL_AtomicGetPtr(void **a);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-
-#include "close_code.h"
-
-#endif /* SDL_atomic_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,94 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * \file SDL_clipboard.h
- *
- * Include file for SDL clipboard handling
- */
-
-#ifndef SDL_clipboard_h_
-#define SDL_clipboard_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Function prototypes */
-
-/**
- * Put UTF-8 text into the clipboard.
- *
- * \param text the text to store in the clipboard
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetClipboardText
- * \sa SDL_HasClipboardText
- */
-extern DECLSPEC int SDLCALL SDL_SetClipboardText(const char *text);
-
-/**
- * Get UTF-8 text from the clipboard, which must be freed with SDL_free().
- *
- * This functions returns empty string if there was not enough memory left for
- * a copy of the clipboard's content.
- *
- * \returns the clipboard text on success or an empty string on failure; call
- *          SDL_GetError() for more information. Caller must call SDL_free()
- *          on the returned pointer when done with it (even if there was an
- *          error).
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_HasClipboardText
- * \sa SDL_SetClipboardText
- */
-extern DECLSPEC char * SDLCALL SDL_GetClipboardText(void);
-
-/**
- * Query whether the clipboard exists and contains a non-empty text string.
- *
- * \returns SDL_TRUE if the clipboard has text, or SDL_FALSE if it does not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetClipboardText
- * \sa SDL_SetClipboardText
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasClipboardText(void);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_clipboard_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,55 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/**
- *  \file SDL_config.h
- */
-
-/* Add any platform that doesn't build using the configure system. */
-#if defined(__WIN32__)
-#include "SDL_config_windows.h"
-#elif defined(__WINRT__)
-#include "SDL_config_winrt.h"
-#elif defined(__MACOSX__)
-#include "SDL_config_macosx.h"
-#elif defined(__IPHONEOS__)
-#include "SDL_config_iphoneos.h"
-#elif defined(__ANDROID__)
-#include "SDL_config_android.h"
-#elif defined(__OS2__)
-#include "SDL_config_os2.h"
-#elif defined(__EMSCRIPTEN__)
-#include "SDL_config_emscripten.h"
-#else
-/* This is a minimal configuration just to get SDL running on new platforms. */
-#include "SDL_config_minimal.h"
-#endif /* platform config */
-
-#ifdef USING_GENERATED_CONFIG_H
-#error Wrong SDL_config.h, check your include path?
-#endif
-
-#endif /* SDL_config_h_ */
@@ -1,585 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_h_
-#define SDL_config_h_
-
-/**
- *  \file SDL_config.h.in
- *
- *  This is a set of defines to configure the SDL features
- */
-
-/* General platform specific identifiers */
-#include "SDL_platform.h"
-
-/* C language features */
-#cmakedefine const @HAVE_CONST@
-#cmakedefine inline @HAVE_INLINE@
-#cmakedefine volatile @HAVE_VOLATILE@
-
-/* C datatypes */
-/* Define SIZEOF_VOIDP for 64/32 architectures */
-#if defined(__LP64__) || defined(_LP64) || defined(_WIN64)
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#cmakedefine HAVE_GCC_ATOMICS @HAVE_GCC_ATOMICS@
-#cmakedefine HAVE_GCC_SYNC_LOCK_TEST_AND_SET @HAVE_GCC_SYNC_LOCK_TEST_AND_SET@
-
-/* Comment this if you want to build without any C library requirements */
-#cmakedefine HAVE_LIBC 1
-#if HAVE_LIBC
-
-/* Useful headers */
-#cmakedefine STDC_HEADERS 1
-#cmakedefine HAVE_ALLOCA_H 1
-#cmakedefine HAVE_CTYPE_H 1
-#cmakedefine HAVE_FLOAT_H 1
-#cmakedefine HAVE_ICONV_H 1
-#cmakedefine HAVE_INTTYPES_H 1
-#cmakedefine HAVE_LIMITS_H 1
-#cmakedefine HAVE_MALLOC_H 1
-#cmakedefine HAVE_MATH_H 1
-#cmakedefine HAVE_MEMORY_H 1
-#cmakedefine HAVE_SIGNAL_H 1
-#cmakedefine HAVE_STDARG_H 1
-#cmakedefine HAVE_STDINT_H 1
-#cmakedefine HAVE_STDIO_H 1
-#cmakedefine HAVE_STDLIB_H 1
-#cmakedefine HAVE_STRINGS_H 1
-#cmakedefine HAVE_STRING_H 1
-#cmakedefine HAVE_SYS_TYPES_H 1
-#cmakedefine HAVE_WCHAR_H 1
-#cmakedefine HAVE_PTHREAD_NP_H 1
-#cmakedefine HAVE_LIBUNWIND_H 1
-
-/* C library functions */
-#cmakedefine HAVE_DLOPEN 1
-#cmakedefine HAVE_MALLOC 1
-#cmakedefine HAVE_CALLOC 1
-#cmakedefine HAVE_REALLOC 1
-#cmakedefine HAVE_FREE 1
-#cmakedefine HAVE_ALLOCA 1
-#ifndef __WIN32__ /* Don't use C runtime versions of these on Windows */
-#cmakedefine HAVE_GETENV 1
-#cmakedefine HAVE_SETENV 1
-#cmakedefine HAVE_PUTENV 1
-#cmakedefine HAVE_UNSETENV 1
-#endif
-#cmakedefine HAVE_QSORT 1
-#cmakedefine HAVE_ABS 1
-#cmakedefine HAVE_BCOPY 1
-#cmakedefine HAVE_MEMSET 1
-#cmakedefine HAVE_MEMCPY 1
-#cmakedefine HAVE_MEMMOVE 1
-#cmakedefine HAVE_MEMCMP 1
-#cmakedefine HAVE_WCSLEN 1
-#cmakedefine HAVE_WCSLCPY 1
-#cmakedefine HAVE_WCSLCAT 1
-#cmakedefine HAVE__WCSDUP 1
-#cmakedefine HAVE_WCSDUP 1
-#cmakedefine HAVE_WCSSTR 1
-#cmakedefine HAVE_WCSCMP 1
-#cmakedefine HAVE_WCSNCMP 1
-#cmakedefine HAVE_WCSCASECMP 1
-#cmakedefine HAVE__WCSICMP 1
-#cmakedefine HAVE_WCSNCASECMP 1
-#cmakedefine HAVE__WCSNICMP 1
-#cmakedefine HAVE_STRLEN 1
-#cmakedefine HAVE_STRLCPY 1
-#cmakedefine HAVE_STRLCAT 1
-#cmakedefine HAVE__STRREV 1
-#cmakedefine HAVE__STRUPR 1
-#cmakedefine HAVE__STRLWR 1
-#cmakedefine HAVE_INDEX 1
-#cmakedefine HAVE_RINDEX 1
-#cmakedefine HAVE_STRCHR 1
-#cmakedefine HAVE_STRRCHR 1
-#cmakedefine HAVE_STRSTR 1
-#cmakedefine HAVE_STRTOK_R 1
-#cmakedefine HAVE_ITOA 1
-#cmakedefine HAVE__LTOA 1
-#cmakedefine HAVE__UITOA 1
-#cmakedefine HAVE__ULTOA 1
-#cmakedefine HAVE_STRTOL 1
-#cmakedefine HAVE_STRTOUL 1
-#cmakedefine HAVE__I64TOA 1
-#cmakedefine HAVE__UI64TOA 1
-#cmakedefine HAVE_STRTOLL 1
-#cmakedefine HAVE_STRTOULL 1
-#cmakedefine HAVE_STRTOD 1
-#cmakedefine HAVE_ATOI 1
-#cmakedefine HAVE_ATOF 1
-#cmakedefine HAVE_STRCMP 1
-#cmakedefine HAVE_STRNCMP 1
-#cmakedefine HAVE__STRICMP 1
-#cmakedefine HAVE_STRCASECMP 1
-#cmakedefine HAVE__STRNICMP 1
-#cmakedefine HAVE_STRNCASECMP 1
-#cmakedefine HAVE_SSCANF 1
-#cmakedefine HAVE_VSSCANF 1
-#cmakedefine HAVE_VSNPRINTF 1
-#cmakedefine HAVE_M_PI 1
-#cmakedefine HAVE_ACOS 1
-#cmakedefine HAVE_ACOSF 1
-#cmakedefine HAVE_ASIN 1
-#cmakedefine HAVE_ASINF 1
-#cmakedefine HAVE_ATAN 1
-#cmakedefine HAVE_ATANF 1
-#cmakedefine HAVE_ATAN2 1
-#cmakedefine HAVE_ATAN2F 1
-#cmakedefine HAVE_CEIL 1
-#cmakedefine HAVE_CEILF 1
-#cmakedefine HAVE_COPYSIGN 1
-#cmakedefine HAVE_COPYSIGNF 1
-#cmakedefine HAVE_COS 1
-#cmakedefine HAVE_COSF 1
-#cmakedefine HAVE_EXP 1
-#cmakedefine HAVE_EXPF 1
-#cmakedefine HAVE_FABS 1
-#cmakedefine HAVE_FABSF 1
-#cmakedefine HAVE_FLOOR 1
-#cmakedefine HAVE_FLOORF 1
-#cmakedefine HAVE_FMOD 1
-#cmakedefine HAVE_FMODF 1
-#cmakedefine HAVE_LOG 1
-#cmakedefine HAVE_LOGF 1
-#cmakedefine HAVE_LOG10 1
-#cmakedefine HAVE_LOG10F 1
-#cmakedefine HAVE_LROUND 1
-#cmakedefine HAVE_LROUNDF 1
-#cmakedefine HAVE_POW 1
-#cmakedefine HAVE_POWF 1
-#cmakedefine HAVE_ROUND 1
-#cmakedefine HAVE_ROUNDF 1
-#cmakedefine HAVE_SCALBN 1
-#cmakedefine HAVE_SCALBNF 1
-#cmakedefine HAVE_SIN 1
-#cmakedefine HAVE_SINF 1
-#cmakedefine HAVE_SQRT 1
-#cmakedefine HAVE_SQRTF 1
-#cmakedefine HAVE_TAN 1
-#cmakedefine HAVE_TANF 1
-#cmakedefine HAVE_TRUNC 1
-#cmakedefine HAVE_TRUNCF 1
-#cmakedefine HAVE_FOPEN64 1
-#cmakedefine HAVE_FSEEKO 1
-#cmakedefine HAVE_FSEEKO64 1
-#cmakedefine HAVE_SIGACTION 1
-#cmakedefine HAVE_SA_SIGACTION 1
-#cmakedefine HAVE_SETJMP 1
-#cmakedefine HAVE_NANOSLEEP 1
-#cmakedefine HAVE_SYSCONF 1
-#cmakedefine HAVE_SYSCTLBYNAME 1
-#cmakedefine HAVE_CLOCK_GETTIME 1
-#cmakedefine HAVE_GETPAGESIZE 1
-#cmakedefine HAVE_MPROTECT 1
-#cmakedefine HAVE_ICONV 1
-#cmakedefine HAVE_PTHREAD_SETNAME_NP 1
-#cmakedefine HAVE_PTHREAD_SET_NAME_NP 1
-#cmakedefine HAVE_SEM_TIMEDWAIT 1
-#cmakedefine HAVE_GETAUXVAL 1
-#cmakedefine HAVE_ELF_AUX_INFO 1
-#cmakedefine HAVE_POLL 1
-#cmakedefine HAVE__EXIT 1
-
-#elif defined(__WIN32__)
-#cmakedefine HAVE_STDARG_H 1
-#cmakedefine HAVE_STDDEF_H 1
-#cmakedefine HAVE_FLOAT_H 1
-
-#else
-/* We may need some replacement for stdarg.h here */
-#include <stdarg.h>
-#endif /* HAVE_LIBC */
-
-#cmakedefine HAVE_ALTIVEC_H 1
-#cmakedefine HAVE_DBUS_DBUS_H 1
-#cmakedefine HAVE_FCITX 1
-#cmakedefine HAVE_IBUS_IBUS_H 1
-#cmakedefine HAVE_SYS_INOTIFY_H 1
-#cmakedefine HAVE_INOTIFY_INIT 1
-#cmakedefine HAVE_INOTIFY_INIT1 1
-#cmakedefine HAVE_INOTIFY 1
-#cmakedefine HAVE_O_CLOEXEC 1
-
-/* Apple platforms might be building universal binaries, where Intel builds
-   can use immintrin.h but other architectures can't. */
-#ifdef __APPLE__
-#  if defined(__has_include) && (defined(__i386__) || defined(__x86_64))
-#    if __has_include(<immintrin.h>)
-#       define HAVE_IMMINTRIN_H 1
-#    endif
-#  endif
-#else  /* non-Apple platforms can use the normal CMake check for this. */
-#cmakedefine HAVE_IMMINTRIN_H 1
-#endif
-
-#cmakedefine HAVE_LIBUDEV_H 1
-#cmakedefine HAVE_LIBSAMPLERATE_H 1
-#cmakedefine HAVE_LIBDECOR_H  1
-
-#cmakedefine HAVE_D3D_H @HAVE_D3D_H@
-#cmakedefine HAVE_D3D11_H @HAVE_D3D11_H@
-#cmakedefine HAVE_DDRAW_H @HAVE_DDRAW_H@
-#cmakedefine HAVE_DSOUND_H @HAVE_DSOUND_H@
-#cmakedefine HAVE_DINPUT_H @HAVE_DINPUT_H@
-#cmakedefine HAVE_XINPUT_H @HAVE_XINPUT_H@
-#cmakedefine HAVE_WINDOWS_GAMING_INPUT_H @HAVE_WINDOWS_GAMING_INPUT_H@
-#cmakedefine HAVE_DXGI_H @HAVE_DXGI_H@
-
-#cmakedefine HAVE_MMDEVICEAPI_H @HAVE_MMDEVICEAPI_H@
-#cmakedefine HAVE_AUDIOCLIENT_H @HAVE_AUDIOCLIENT_H@
-#cmakedefine HAVE_TPCSHRD_H @HAVE_TPCSHRD_H@
-#cmakedefine HAVE_SENSORSAPI_H @HAVE_SENSORSAPI_H@
-#cmakedefine HAVE_ROAPI_H @HAVE_ROAPI_H@
-
-#cmakedefine HAVE_XINPUT_GAMEPAD_EX @HAVE_XINPUT_GAMEPAD_EX@
-#cmakedefine HAVE_XINPUT_STATE_EX @HAVE_XINPUT_STATE_EX@
-
-/* SDL internal assertion support */
-#cmakedefine SDL_DEFAULT_ASSERT_LEVEL @SDL_DEFAULT_ASSERT_LEVEL@
-
-/* Allow disabling of core subsystems */
-#cmakedefine SDL_ATOMIC_DISABLED @SDL_ATOMIC_DISABLED@
-#cmakedefine SDL_AUDIO_DISABLED @SDL_AUDIO_DISABLED@
-#cmakedefine SDL_CPUINFO_DISABLED @SDL_CPUINFO_DISABLED@
-#cmakedefine SDL_EVENTS_DISABLED @SDL_EVENTS_DISABLED@
-#cmakedefine SDL_FILE_DISABLED @SDL_FILE_DISABLED@
-#cmakedefine SDL_JOYSTICK_DISABLED @SDL_JOYSTICK_DISABLED@
-#cmakedefine SDL_HAPTIC_DISABLED @SDL_HAPTIC_DISABLED@
-#cmakedefine SDL_HIDAPI_DISABLED @SDL_HIDAPI_DISABLED@
-#cmakedefine SDL_SENSOR_DISABLED @SDL_SENSOR_DISABLED@
-#cmakedefine SDL_LOADSO_DISABLED @SDL_LOADSO_DISABLED@
-#cmakedefine SDL_RENDER_DISABLED @SDL_RENDER_DISABLED@
-#cmakedefine SDL_THREADS_DISABLED @SDL_THREADS_DISABLED@
-#cmakedefine SDL_TIMERS_DISABLED @SDL_TIMERS_DISABLED@
-#cmakedefine SDL_VIDEO_DISABLED @SDL_VIDEO_DISABLED@
-#cmakedefine SDL_POWER_DISABLED @SDL_POWER_DISABLED@
-#cmakedefine SDL_FILESYSTEM_DISABLED @SDL_FILESYSTEM_DISABLED@
-#cmakedefine SDL_LOCALE_DISABLED @SDL_LOCALE_DISABLED@
-#cmakedefine SDL_MISC_DISABLED @SDL_MISC_DISABLED@
-
-/* Enable various audio drivers */
-#cmakedefine SDL_AUDIO_DRIVER_ALSA @SDL_AUDIO_DRIVER_ALSA@
-#cmakedefine SDL_AUDIO_DRIVER_ALSA_DYNAMIC @SDL_AUDIO_DRIVER_ALSA_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_ANDROID @SDL_AUDIO_DRIVER_ANDROID@
-#cmakedefine SDL_AUDIO_DRIVER_OPENSLES @SDL_AUDIO_DRIVER_OPENSLES@
-#cmakedefine SDL_AUDIO_DRIVER_AAUDIO @SDL_AUDIO_DRIVER_AAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_ARTS @SDL_AUDIO_DRIVER_ARTS@
-#cmakedefine SDL_AUDIO_DRIVER_ARTS_DYNAMIC @SDL_AUDIO_DRIVER_ARTS_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_COREAUDIO @SDL_AUDIO_DRIVER_COREAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_DISK @SDL_AUDIO_DRIVER_DISK@
-#cmakedefine SDL_AUDIO_DRIVER_DSOUND @SDL_AUDIO_DRIVER_DSOUND@
-#cmakedefine SDL_AUDIO_DRIVER_DUMMY @SDL_AUDIO_DRIVER_DUMMY@
-#cmakedefine SDL_AUDIO_DRIVER_EMSCRIPTEN @SDL_AUDIO_DRIVER_EMSCRIPTEN@
-#cmakedefine SDL_AUDIO_DRIVER_ESD @SDL_AUDIO_DRIVER_ESD@
-#cmakedefine SDL_AUDIO_DRIVER_ESD_DYNAMIC @SDL_AUDIO_DRIVER_ESD_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_FUSIONSOUND @SDL_AUDIO_DRIVER_FUSIONSOUND@
-#cmakedefine SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC @SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_HAIKU @SDL_AUDIO_DRIVER_HAIKU@
-#cmakedefine SDL_AUDIO_DRIVER_JACK @SDL_AUDIO_DRIVER_JACK@
-#cmakedefine SDL_AUDIO_DRIVER_JACK_DYNAMIC @SDL_AUDIO_DRIVER_JACK_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_NAS @SDL_AUDIO_DRIVER_NAS@
-#cmakedefine SDL_AUDIO_DRIVER_NAS_DYNAMIC @SDL_AUDIO_DRIVER_NAS_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_NETBSD @SDL_AUDIO_DRIVER_NETBSD@
-#cmakedefine SDL_AUDIO_DRIVER_OSS @SDL_AUDIO_DRIVER_OSS@
-#cmakedefine SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H @SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H@
-#cmakedefine SDL_AUDIO_DRIVER_PAUDIO @SDL_AUDIO_DRIVER_PAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_PIPEWIRE @SDL_AUDIO_DRIVER_PIPEWIRE@
-#cmakedefine SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC @SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_PULSEAUDIO @SDL_AUDIO_DRIVER_PULSEAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC @SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_QSA @SDL_AUDIO_DRIVER_QSA@
-#cmakedefine SDL_AUDIO_DRIVER_SNDIO @SDL_AUDIO_DRIVER_SNDIO@
-#cmakedefine SDL_AUDIO_DRIVER_SNDIO_DYNAMIC @SDL_AUDIO_DRIVER_SNDIO_DYNAMIC@
-#cmakedefine SDL_AUDIO_DRIVER_SUNAUDIO @SDL_AUDIO_DRIVER_SUNAUDIO@
-#cmakedefine SDL_AUDIO_DRIVER_WASAPI @SDL_AUDIO_DRIVER_WASAPI@
-#cmakedefine SDL_AUDIO_DRIVER_WINMM @SDL_AUDIO_DRIVER_WINMM@
-#cmakedefine SDL_AUDIO_DRIVER_OS2 @SDL_AUDIO_DRIVER_OS2@
-#cmakedefine SDL_AUDIO_DRIVER_VITA @SDL_AUDIO_DRIVER_VITA@
-#cmakedefine SDL_AUDIO_DRIVER_PSP @SDL_AUDIO_DRIVER_PSP@
-
-/* Enable various input drivers */
-#cmakedefine SDL_INPUT_LINUXEV @SDL_INPUT_LINUXEV@
-#cmakedefine SDL_INPUT_LINUXKD @SDL_INPUT_LINUXKD@
-#cmakedefine SDL_INPUT_FBSDKBIO @SDL_INPUT_FBSDKBIO@
-#cmakedefine SDL_JOYSTICK_ANDROID @SDL_JOYSTICK_ANDROID@
-#cmakedefine SDL_JOYSTICK_HAIKU @SDL_JOYSTICK_HAIKU@
-#cmakedefine SDL_JOYSTICK_WGI @SDL_JOYSTICK_WGI@
-#cmakedefine SDL_JOYSTICK_DINPUT @SDL_JOYSTICK_DINPUT@
-#cmakedefine SDL_JOYSTICK_XINPUT @SDL_JOYSTICK_XINPUT@
-#cmakedefine SDL_JOYSTICK_DUMMY @SDL_JOYSTICK_DUMMY@
-#cmakedefine SDL_JOYSTICK_IOKIT @SDL_JOYSTICK_IOKIT@
-#cmakedefine SDL_JOYSTICK_MFI @SDL_JOYSTICK_MFI@
-#cmakedefine SDL_JOYSTICK_LINUX @SDL_JOYSTICK_LINUX@
-#cmakedefine SDL_JOYSTICK_OS2 @SDL_JOYSTICK_OS2@
-#cmakedefine SDL_JOYSTICK_USBHID @SDL_JOYSTICK_USBHID@
-#cmakedefine SDL_HAVE_MACHINE_JOYSTICK_H @SDL_HAVE_MACHINE_JOYSTICK_H@
-#cmakedefine SDL_JOYSTICK_HIDAPI @SDL_JOYSTICK_HIDAPI@
-#cmakedefine SDL_JOYSTICK_RAWINPUT @SDL_JOYSTICK_RAWINPUT@
-#cmakedefine SDL_JOYSTICK_EMSCRIPTEN @SDL_JOYSTICK_EMSCRIPTEN@
-#cmakedefine SDL_JOYSTICK_VIRTUAL @SDL_JOYSTICK_VIRTUAL@
-#cmakedefine SDL_JOYSTICK_VITA @SDL_JOYSTICK_VITA@
-#cmakedefine SDL_JOYSTICK_PSP @SDL_JOYSTICK_PSP@
-#cmakedefine SDL_HAPTIC_DUMMY @SDL_HAPTIC_DUMMY@
-#cmakedefine SDL_HAPTIC_LINUX @SDL_HAPTIC_LINUX@
-#cmakedefine SDL_HAPTIC_IOKIT @SDL_HAPTIC_IOKIT@
-#cmakedefine SDL_HAPTIC_DINPUT @SDL_HAPTIC_DINPUT@
-#cmakedefine SDL_HAPTIC_XINPUT @SDL_HAPTIC_XINPUT@
-#cmakedefine SDL_HAPTIC_ANDROID @SDL_HAPTIC_ANDROID@
-#cmakedefine SDL_LIBUSB_DYNAMIC @SDL_LIBUSB_DYNAMIC@
-
-/* Enable various sensor drivers */
-#cmakedefine SDL_SENSOR_ANDROID @SDL_SENSOR_ANDROID@
-#cmakedefine SDL_SENSOR_COREMOTION @SDL_SENSOR_COREMOTION@
-#cmakedefine SDL_SENSOR_WINDOWS @SDL_SENSOR_WINDOWS@
-#cmakedefine SDL_SENSOR_DUMMY @SDL_SENSOR_DUMMY@
-#cmakedefine SDL_SENSOR_VITA @SDL_SENSOR_VITA@
-
-/* Enable various shared object loading systems */
-#cmakedefine SDL_LOADSO_DLOPEN @SDL_LOADSO_DLOPEN@
-#cmakedefine SDL_LOADSO_DUMMY @SDL_LOADSO_DUMMY@
-#cmakedefine SDL_LOADSO_LDG @SDL_LOADSO_LDG@
-#cmakedefine SDL_LOADSO_WINDOWS @SDL_LOADSO_WINDOWS@
-#cmakedefine SDL_LOADSO_OS2 @SDL_LOADSO_OS2@
-
-/* Enable various threading systems */
-#cmakedefine SDL_THREAD_GENERIC_COND_SUFFIX @SDL_THREAD_GENERIC_COND_SUFFIX@
-#cmakedefine SDL_THREAD_PTHREAD @SDL_THREAD_PTHREAD@
-#cmakedefine SDL_THREAD_PTHREAD_RECURSIVE_MUTEX @SDL_THREAD_PTHREAD_RECURSIVE_MUTEX@
-#cmakedefine SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP @SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP@
-#cmakedefine SDL_THREAD_WINDOWS @SDL_THREAD_WINDOWS@
-#cmakedefine SDL_THREAD_OS2 @SDL_THREAD_OS2@
-#cmakedefine SDL_THREAD_VITA @SDL_THREAD_VITA@
-#cmakedefine SDL_THREAD_PSP @SDL_THREAD_PSP@
-
-/* Enable various timer systems */
-#cmakedefine SDL_TIMER_HAIKU @SDL_TIMER_HAIKU@
-#cmakedefine SDL_TIMER_DUMMY @SDL_TIMER_DUMMY@
-#cmakedefine SDL_TIMER_UNIX @SDL_TIMER_UNIX@
-#cmakedefine SDL_TIMER_WINDOWS @SDL_TIMER_WINDOWS@
-#cmakedefine SDL_TIMER_OS2 @SDL_TIMER_OS2@
-#cmakedefine SDL_TIMER_VITA @SDL_TIMER_VITA@
-#cmakedefine SDL_TIMER_PSP @SDL_TIMER_PSP@
-
-/* Enable various video drivers */
-#cmakedefine SDL_VIDEO_DRIVER_ANDROID @SDL_VIDEO_DRIVER_ANDROID@
-#cmakedefine SDL_VIDEO_DRIVER_EMSCRIPTEN @SDL_VIDEO_DRIVER_EMSCRIPTEN@
-#cmakedefine SDL_VIDEO_DRIVER_HAIKU @SDL_VIDEO_DRIVER_HAIKU@
-#cmakedefine SDL_VIDEO_DRIVER_COCOA @SDL_VIDEO_DRIVER_COCOA@
-#cmakedefine SDL_VIDEO_DRIVER_UIKIT @SDL_VIDEO_DRIVER_UIKIT@
-#cmakedefine SDL_VIDEO_DRIVER_DIRECTFB @SDL_VIDEO_DRIVER_DIRECTFB@
-#cmakedefine SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC @SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC@
-#cmakedefine SDL_VIDEO_DRIVER_DUMMY @SDL_VIDEO_DRIVER_DUMMY@
-#cmakedefine SDL_VIDEO_DRIVER_OFFSCREEN @SDL_VIDEO_DRIVER_OFFSCREEN@
-#cmakedefine SDL_VIDEO_DRIVER_WINDOWS @SDL_VIDEO_DRIVER_WINDOWS@
-#cmakedefine SDL_VIDEO_DRIVER_WINRT @SDL_VIDEO_DRIVER_WINRT@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND @SDL_VIDEO_DRIVER_WAYLAND@
-#cmakedefine SDL_VIDEO_DRIVER_RPI @SDL_VIDEO_DRIVER_RPI@
-#cmakedefine SDL_VIDEO_DRIVER_VIVANTE @SDL_VIDEO_DRIVER_VIVANTE@
-#cmakedefine SDL_VIDEO_DRIVER_VIVANTE_VDK @SDL_VIDEO_DRIVER_VIVANTE_VDK@
-#cmakedefine SDL_VIDEO_DRIVER_OS2 @SDL_VIDEO_DRIVER_OS2@
-#cmakedefine SDL_VIDEO_DRIVER_QNX @SDL_VIDEO_DRIVER_QNX@
-#cmakedefine SDL_VIDEO_DRIVER_RISCOS @SDL_VIDEO_DRIVER_RISCOS@
-#cmakedefine SDL_VIDEO_DRIVER_PSP @SDL_VIDEO_DRIVER_PSP@
-
-#cmakedefine SDL_VIDEO_DRIVER_KMSDRM @SDL_VIDEO_DRIVER_KMSDRM@
-#cmakedefine SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC @SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC@
-#cmakedefine SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM @SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM@
-
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH @SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON@
-#cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR@
-
-#cmakedefine SDL_VIDEO_DRIVER_X11 @SDL_VIDEO_DRIVER_X11@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC @SDL_VIDEO_DRIVER_X11_DYNAMIC@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT @SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 @SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES @SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR @SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS @SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS@
-#cmakedefine SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE @SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XCURSOR @SDL_VIDEO_DRIVER_X11_XCURSOR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XDBE @SDL_VIDEO_DRIVER_X11_XDBE@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XINERAMA @SDL_VIDEO_DRIVER_X11_XINERAMA@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2 @SDL_VIDEO_DRIVER_X11_XINPUT2@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH @SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XFIXES @SDL_VIDEO_DRIVER_X11_XFIXES@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XRANDR @SDL_VIDEO_DRIVER_X11_XRANDR@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XSCRNSAVER @SDL_VIDEO_DRIVER_X11_XSCRNSAVER@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XSHAPE @SDL_VIDEO_DRIVER_X11_XSHAPE@
-#cmakedefine SDL_VIDEO_DRIVER_X11_XVIDMODE @SDL_VIDEO_DRIVER_X11_XVIDMODE@
-#cmakedefine SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS @SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS@
-#cmakedefine SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM @SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM@
-#cmakedefine SDL_VIDEO_DRIVER_VITA @SDL_VIDEO_DRIVER_VITA@
-
-#cmakedefine SDL_VIDEO_RENDER_D3D @SDL_VIDEO_RENDER_D3D@
-#cmakedefine SDL_VIDEO_RENDER_D3D11 @SDL_VIDEO_RENDER_D3D11@
-#cmakedefine SDL_VIDEO_RENDER_OGL @SDL_VIDEO_RENDER_OGL@
-#cmakedefine SDL_VIDEO_RENDER_OGL_ES @SDL_VIDEO_RENDER_OGL_ES@
-#cmakedefine SDL_VIDEO_RENDER_OGL_ES2 @SDL_VIDEO_RENDER_OGL_ES2@
-#cmakedefine SDL_VIDEO_RENDER_DIRECTFB @SDL_VIDEO_RENDER_DIRECTFB@
-#cmakedefine SDL_VIDEO_RENDER_METAL @SDL_VIDEO_RENDER_METAL@
-#cmakedefine SDL_VIDEO_RENDER_VITA_GXM @SDL_VIDEO_RENDER_VITA_GXM@
-#cmakedefine SDL_VIDEO_RENDER_PSP @SDL_VIDEO_RENDER_PSP@
-
-/* Enable OpenGL support */
-#cmakedefine SDL_VIDEO_OPENGL @SDL_VIDEO_OPENGL@
-#cmakedefine SDL_VIDEO_OPENGL_ES @SDL_VIDEO_OPENGL_ES@
-#cmakedefine SDL_VIDEO_OPENGL_ES2 @SDL_VIDEO_OPENGL_ES2@
-#cmakedefine SDL_VIDEO_OPENGL_BGL @SDL_VIDEO_OPENGL_BGL@
-#cmakedefine SDL_VIDEO_OPENGL_CGL @SDL_VIDEO_OPENGL_CGL@
-#cmakedefine SDL_VIDEO_OPENGL_GLX @SDL_VIDEO_OPENGL_GLX@
-#cmakedefine SDL_VIDEO_OPENGL_WGL @SDL_VIDEO_OPENGL_WGL@
-#cmakedefine SDL_VIDEO_OPENGL_EGL @SDL_VIDEO_OPENGL_EGL@
-#cmakedefine SDL_VIDEO_OPENGL_OSMESA @SDL_VIDEO_OPENGL_OSMESA@
-#cmakedefine SDL_VIDEO_OPENGL_OSMESA_DYNAMIC @SDL_VIDEO_OPENGL_OSMESA_DYNAMIC@
-
-/* Enable Vulkan support */
-#cmakedefine SDL_VIDEO_VULKAN @SDL_VIDEO_VULKAN@
-
-/* Enable Metal support */
-#cmakedefine SDL_VIDEO_METAL @SDL_VIDEO_METAL@
-
-/* Enable system power support */
-#cmakedefine SDL_POWER_ANDROID @SDL_POWER_ANDROID@
-#cmakedefine SDL_POWER_LINUX @SDL_POWER_LINUX@
-#cmakedefine SDL_POWER_WINDOWS @SDL_POWER_WINDOWS@
-#cmakedefine SDL_POWER_WINRT @SDL_POWER_WINRT@
-#cmakedefine SDL_POWER_MACOSX @SDL_POWER_MACOSX@
-#cmakedefine SDL_POWER_UIKIT @SDL_POWER_UIKIT@
-#cmakedefine SDL_POWER_HAIKU @SDL_POWER_HAIKU@
-#cmakedefine SDL_POWER_EMSCRIPTEN @SDL_POWER_EMSCRIPTEN@
-#cmakedefine SDL_POWER_HARDWIRED @SDL_POWER_HARDWIRED@
-#cmakedefine SDL_POWER_VITA @SDL_POWER_VITA@
-#cmakedefine SDL_POWER_PSP @SDL_POWER_PSP@
-
-/* Enable system filesystem support */
-#cmakedefine SDL_FILESYSTEM_ANDROID @SDL_FILESYSTEM_ANDROID@
-#cmakedefine SDL_FILESYSTEM_HAIKU @SDL_FILESYSTEM_HAIKU@
-#cmakedefine SDL_FILESYSTEM_COCOA @SDL_FILESYSTEM_COCOA@
-#cmakedefine SDL_FILESYSTEM_DUMMY @SDL_FILESYSTEM_DUMMY@
-#cmakedefine SDL_FILESYSTEM_RISCOS @SDL_FILESYSTEM_RISCOS@
-#cmakedefine SDL_FILESYSTEM_UNIX @SDL_FILESYSTEM_UNIX@
-#cmakedefine SDL_FILESYSTEM_WINDOWS @SDL_FILESYSTEM_WINDOWS@
-#cmakedefine SDL_FILESYSTEM_EMSCRIPTEN @SDL_FILESYSTEM_EMSCRIPTEN@
-#cmakedefine SDL_FILESYSTEM_OS2 @SDL_FILESYSTEM_OS2@
-#cmakedefine SDL_FILESYSTEM_VITA @SDL_FILESYSTEM_VITA@
-#cmakedefine SDL_FILESYSTEM_PSP @SDL_FILESYSTEM_PSP@
-
-/* Enable misc subsystem */
-#cmakedefine SDL_MISC_DUMMY @SDL_MISC_DUMMY@
-
-/* Enable locale subsystem */
-#cmakedefine SDL_LOCALE_DUMMY @SDL_LOCALE_DUMMY@
-
-/* Enable assembly routines */
-#cmakedefine SDL_ASSEMBLY_ROUTINES @SDL_ASSEMBLY_ROUTINES@
-#cmakedefine SDL_ALTIVEC_BLITTERS @SDL_ALTIVEC_BLITTERS@
-#cmakedefine SDL_ARM_SIMD_BLITTERS @SDL_ARM_SIMD_BLITTERS@
-#cmakedefine SDL_ARM_NEON_BLITTERS @SDL_ARM_NEON_BLITTERS@
-
-/* Whether SDL_DYNAMIC_API needs dlopen */
-#cmakedefine DYNAPI_NEEDS_DLOPEN  @DYNAPI_NEEDS_DLOPEN@
-
-/* Enable dynamic libsamplerate support */
-#cmakedefine SDL_LIBSAMPLERATE_DYNAMIC @SDL_LIBSAMPLERATE_DYNAMIC@
-
-/* Enable ime support */
-#cmakedefine SDL_USE_IME @SDL_USE_IME@
-
-/* Platform specific definitions */
-#cmakedefine SDL_IPHONE_KEYBOARD @SDL_IPHONE_KEYBOARD@
-#cmakedefine SDL_IPHONE_LAUNCHSCREEN @SDL_IPHONE_LAUNCHSCREEN@
-
-#cmakedefine SDL_VIDEO_VITA_PIB @SDL_VIDEO_VITA_PIB@
-#cmakedefine SDL_VIDEO_VITA_PVR @SDL_VIDEO_VITA_PVR@
-#cmakedefine SDL_VIDEO_VITA_PVR_OGL @SDL_VIDEO_VITA_PVR_OGL@
-
-#if !defined(__WIN32__) && !defined(__WINRT__)
-#  if !defined(_STDINT_H_) && !defined(_STDINT_H) && !defined(HAVE_STDINT_H) && !defined(_HAVE_STDINT_H)
-typedef unsigned int size_t;
-typedef signed char int8_t;
-typedef unsigned char uint8_t;
-typedef signed short int16_t;
-typedef unsigned short uint16_t;
-typedef signed int int32_t;
-typedef unsigned int uint32_t;
-typedef signed long long int64_t;
-typedef unsigned long long uint64_t;
-typedef unsigned long uintptr_t;
-#  endif /* if (stdint.h isn't available) */
-#else /* __WIN32__ */
-#  if !defined(_STDINT_H_) && !defined(HAVE_STDINT_H) && !defined(_HAVE_STDINT_H)
-#    if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__) || defined(__BORLANDC__) || defined(__CODEGEARC__)
-#define HAVE_STDINT_H	1
-#    elif defined(_MSC_VER)
-typedef signed __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef signed __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef signed __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef signed __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#      ifndef _UINTPTR_T_DEFINED
-#        ifdef  _WIN64
-typedef unsigned __int64 uintptr_t;
-#          else
-typedef unsigned int uintptr_t;
-#        endif
-#define _UINTPTR_T_DEFINED
-#      endif
-/* Older Visual C++ headers don't have the Win64-compatible typedefs... */
-#      if ((_MSC_VER <= 1200) && (!defined(DWORD_PTR)))
-#define DWORD_PTR DWORD
-#      endif
-#      if ((_MSC_VER <= 1200) && (!defined(LONG_PTR)))
-#define LONG_PTR LONG
-#      endif
-#    else /* !__GNUC__ && !_MSC_VER */
-typedef signed char int8_t;
-typedef unsigned char uint8_t;
-typedef signed short int16_t;
-typedef unsigned short uint16_t;
-typedef signed int int32_t;
-typedef unsigned int uint32_t;
-typedef signed long long int64_t;
-typedef unsigned long long uint64_t;
-#      ifndef _SIZE_T_DEFINED_
-#define _SIZE_T_DEFINED_
-typedef unsigned int size_t;
-#      endif
-typedef unsigned int uintptr_t;
-#    endif /* __GNUC__ || _MSC_VER */
-#  endif /* !_STDINT_H_ && !HAVE_STDINT_H */
-#endif /* __WIN32__ */
-
-#endif /* SDL_config_h_ */
@@ -1,491 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_h_
-#define SDL_config_h_
-
-/**
- *  \file SDL_config.h.in
- *
- *  This is a set of defines to configure the SDL features
- */
-
-/* General platform specific identifiers */
-#include "SDL_platform.h"
-
-/* Make sure that this isn't included by Visual C++ */
-#ifdef _MSC_VER
-#error You should run git checkout -f include/SDL_config.h
-#endif
-
-/* C language features */
-#undef const
-#undef inline
-#undef volatile
-
-/* C datatypes */
-#if defined(__LP64__) || defined(_LP64) || defined(_WIN64)
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#undef HAVE_GCC_ATOMICS
-#undef HAVE_GCC_SYNC_LOCK_TEST_AND_SET
-
-/* Comment this if you want to build without any C library requirements */
-#undef HAVE_LIBC
-#if HAVE_LIBC
-
-/* Useful headers */
-#undef STDC_HEADERS
-#undef HAVE_ALLOCA_H
-#undef HAVE_CTYPE_H
-#undef HAVE_FLOAT_H
-#undef HAVE_ICONV_H
-#undef HAVE_INTTYPES_H
-#undef HAVE_LIMITS_H
-#undef HAVE_MALLOC_H
-#undef HAVE_MATH_H
-#undef HAVE_MEMORY_H
-#undef HAVE_SIGNAL_H
-#undef HAVE_STDARG_H
-#undef HAVE_STDINT_H
-#undef HAVE_STDIO_H
-#undef HAVE_STDLIB_H
-#undef HAVE_STRINGS_H
-#undef HAVE_STRING_H
-#undef HAVE_SYS_TYPES_H
-#undef HAVE_WCHAR_H
-#undef HAVE_PTHREAD_NP_H
-#undef HAVE_LIBUNWIND_H
-
-/* C library functions */
-#undef HAVE_DLOPEN
-#undef HAVE_MALLOC
-#undef HAVE_CALLOC
-#undef HAVE_REALLOC
-#undef HAVE_FREE
-#undef HAVE_ALLOCA
-#ifndef __WIN32__ /* Don't use C runtime versions of these on Windows */
-#undef HAVE_GETENV
-#undef HAVE_SETENV
-#undef HAVE_PUTENV
-#undef HAVE_UNSETENV
-#endif
-#undef HAVE_QSORT
-#undef HAVE_ABS
-#undef HAVE_BCOPY
-#undef HAVE_MEMSET
-#undef HAVE_MEMCPY
-#undef HAVE_MEMMOVE
-#undef HAVE_MEMCMP
-#undef HAVE_WCSLEN
-#undef HAVE_WCSLCPY
-#undef HAVE_WCSLCAT
-#undef HAVE__WCSDUP
-#undef HAVE_WCSDUP
-#undef HAVE_WCSSTR
-#undef HAVE_WCSCMP
-#undef HAVE_WCSNCMP
-#undef HAVE_WCSCASECMP
-#undef HAVE__WCSICMP
-#undef HAVE_WCSNCASECMP
-#undef HAVE__WCSNICMP
-#undef HAVE_STRLEN
-#undef HAVE_STRLCPY
-#undef HAVE_STRLCAT
-#undef HAVE__STRREV
-#undef HAVE__STRUPR
-#undef HAVE__STRLWR
-#undef HAVE_INDEX
-#undef HAVE_RINDEX
-#undef HAVE_STRCHR
-#undef HAVE_STRRCHR
-#undef HAVE_STRSTR
-#undef HAVE_STRTOK_R
-#undef HAVE_ITOA
-#undef HAVE__LTOA
-#undef HAVE__UITOA
-#undef HAVE__ULTOA
-#undef HAVE_STRTOL
-#undef HAVE_STRTOUL
-#undef HAVE__I64TOA
-#undef HAVE__UI64TOA
-#undef HAVE_STRTOLL
-#undef HAVE_STRTOULL
-#undef HAVE_STRTOD
-#undef HAVE_ATOI
-#undef HAVE_ATOF
-#undef HAVE_STRCMP
-#undef HAVE_STRNCMP
-#undef HAVE__STRICMP
-#undef HAVE_STRCASECMP
-#undef HAVE__STRNICMP
-#undef HAVE_STRNCASECMP
-#undef HAVE_SSCANF
-#undef HAVE_VSSCANF
-#undef HAVE_SNPRINTF
-#undef HAVE_VSNPRINTF
-#undef HAVE_M_PI
-#undef HAVE_ACOS
-#undef HAVE_ACOSF
-#undef HAVE_ASIN
-#undef HAVE_ASINF
-#undef HAVE_ATAN
-#undef HAVE_ATANF
-#undef HAVE_ATAN2
-#undef HAVE_ATAN2F
-#undef HAVE_CEIL
-#undef HAVE_CEILF
-#undef HAVE_COPYSIGN
-#undef HAVE_COPYSIGNF
-#undef HAVE_COS
-#undef HAVE_COSF
-#undef HAVE_EXP
-#undef HAVE_EXPF
-#undef HAVE_FABS
-#undef HAVE_FABSF
-#undef HAVE_FLOOR
-#undef HAVE_FLOORF
-#undef HAVE_FMOD
-#undef HAVE_FMODF
-#undef HAVE_LOG
-#undef HAVE_LOGF
-#undef HAVE_LOG10
-#undef HAVE_LOG10F
-#undef HAVE_LROUND
-#undef HAVE_LROUNDF
-#undef HAVE_POW
-#undef HAVE_POWF
-#undef HAVE_ROUND
-#undef HAVE_ROUNDF
-#undef HAVE_SCALBN
-#undef HAVE_SCALBNF
-#undef HAVE_SIN
-#undef HAVE_SINF
-#undef HAVE_SQRT
-#undef HAVE_SQRTF
-#undef HAVE_TAN
-#undef HAVE_TANF
-#undef HAVE_TRUNC
-#undef HAVE_TRUNCF
-#undef HAVE_FOPEN64
-#undef HAVE_FSEEKO
-#undef HAVE_FSEEKO64
-#undef HAVE_SIGACTION
-#undef HAVE_SA_SIGACTION
-#undef HAVE_SETJMP
-#undef HAVE_NANOSLEEP
-#undef HAVE_SYSCONF
-#undef HAVE_SYSCTLBYNAME
-#undef HAVE_CLOCK_GETTIME
-#undef HAVE_GETPAGESIZE
-#undef HAVE_MPROTECT
-#undef HAVE_ICONV
-#undef HAVE_PTHREAD_SETNAME_NP
-#undef HAVE_PTHREAD_SET_NAME_NP
-#undef HAVE_SEM_TIMEDWAIT
-#undef HAVE_GETAUXVAL
-#undef HAVE_ELF_AUX_INFO
-#undef HAVE_POLL
-#undef HAVE__EXIT
-
-#else
-#define HAVE_STDARG_H 1
-#define HAVE_STDDEF_H 1
-#define HAVE_STDINT_H 1
-#endif /* HAVE_LIBC */
-
-#undef HAVE_O_CLOEXEC
-#undef HAVE_ALTIVEC_H
-#undef HAVE_DBUS_DBUS_H
-#undef HAVE_FCITX
-#undef HAVE_SYS_INOTIFY_H
-#undef HAVE_INOTIFY_INIT
-#undef HAVE_INOTIFY_INIT1
-#undef HAVE_INOTIFY
-#undef HAVE_IBUS_IBUS_H
-#undef HAVE_IMMINTRIN_H
-#undef HAVE_LIBUDEV_H
-#undef HAVE_LIBSAMPLERATE_H
-#undef HAVE_LIBDECOR_H
-
-#undef HAVE_DDRAW_H
-#undef HAVE_DINPUT_H
-#undef HAVE_DSOUND_H
-#undef HAVE_DXGI_H
-#undef HAVE_WINDOWS_GAMING_INPUT_H
-#undef HAVE_XINPUT_H
-#undef HAVE_XINPUT_GAMEPAD_EX
-#undef HAVE_XINPUT_STATE_EX
-
-#undef HAVE_MMDEVICEAPI_H
-#undef HAVE_AUDIOCLIENT_H
-#undef HAVE_TPCSHRD_H
-#undef HAVE_SENSORSAPI_H
-#undef HAVE_ROAPI_H
-
-/* SDL internal assertion support */
-#undef SDL_DEFAULT_ASSERT_LEVEL
-
-/* Allow disabling of core subsystems */
-#undef SDL_ATOMIC_DISABLED
-#undef SDL_AUDIO_DISABLED
-#undef SDL_CPUINFO_DISABLED
-#undef SDL_EVENTS_DISABLED
-#undef SDL_FILE_DISABLED
-#undef SDL_JOYSTICK_DISABLED
-#undef SDL_HAPTIC_DISABLED
-#undef SDL_HIDAPI_DISABLED
-#undef SDL_SENSOR_DISABLED
-#undef SDL_LOADSO_DISABLED
-#undef SDL_RENDER_DISABLED
-#undef SDL_THREADS_DISABLED
-#undef SDL_TIMERS_DISABLED
-#undef SDL_VIDEO_DISABLED
-#undef SDL_POWER_DISABLED
-#undef SDL_FILESYSTEM_DISABLED
-#undef SDL_LOCALE_DISABLED
-#undef SDL_MISC_DISABLED
-
-/* Enable various audio drivers */
-#undef SDL_AUDIO_DRIVER_AAUDIO
-#undef SDL_AUDIO_DRIVER_ALSA
-#undef SDL_AUDIO_DRIVER_ALSA_DYNAMIC
-#undef SDL_AUDIO_DRIVER_ANDROID
-#undef SDL_AUDIO_DRIVER_ARTS
-#undef SDL_AUDIO_DRIVER_ARTS_DYNAMIC
-#undef SDL_AUDIO_DRIVER_COREAUDIO
-#undef SDL_AUDIO_DRIVER_DISK
-#undef SDL_AUDIO_DRIVER_DSOUND
-#undef SDL_AUDIO_DRIVER_DUMMY
-#undef SDL_AUDIO_DRIVER_EMSCRIPTEN
-#undef SDL_AUDIO_DRIVER_ESD
-#undef SDL_AUDIO_DRIVER_ESD_DYNAMIC
-#undef SDL_AUDIO_DRIVER_FUSIONSOUND
-#undef SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC
-#undef SDL_AUDIO_DRIVER_HAIKU
-#undef SDL_AUDIO_DRIVER_JACK
-#undef SDL_AUDIO_DRIVER_JACK_DYNAMIC
-#undef SDL_AUDIO_DRIVER_NACL
-#undef SDL_AUDIO_DRIVER_NAS
-#undef SDL_AUDIO_DRIVER_NAS_DYNAMIC
-#undef SDL_AUDIO_DRIVER_NETBSD
-#undef SDL_AUDIO_DRIVER_OPENSLES
-#undef SDL_AUDIO_DRIVER_OSS
-#undef SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H
-#undef SDL_AUDIO_DRIVER_PAUDIO
-#undef SDL_AUDIO_DRIVER_PIPEWIRE
-#undef SDL_AUDIO_DRIVER_PIPEWIRE_DYNAMIC
-#undef SDL_AUDIO_DRIVER_PULSEAUDIO
-#undef SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC
-#undef SDL_AUDIO_DRIVER_QSA
-#undef SDL_AUDIO_DRIVER_SNDIO
-#undef SDL_AUDIO_DRIVER_SNDIO_DYNAMIC
-#undef SDL_AUDIO_DRIVER_SUNAUDIO
-#undef SDL_AUDIO_DRIVER_WASAPI
-#undef SDL_AUDIO_DRIVER_WINMM
-#undef SDL_AUDIO_DRIVER_OS2
-
-/* Enable various input drivers */
-#undef SDL_INPUT_LINUXEV
-#undef SDL_INPUT_FBSDKBIO
-#undef SDL_INPUT_LINUXKD
-#undef SDL_INPUT_WSCONS
-#undef SDL_JOYSTICK_HAIKU
-#undef SDL_JOYSTICK_DINPUT
-#undef SDL_JOYSTICK_WGI
-#undef SDL_JOYSTICK_XINPUT
-#undef SDL_JOYSTICK_DUMMY
-#undef SDL_JOYSTICK_IOKIT
-#undef SDL_JOYSTICK_MFI
-#undef SDL_JOYSTICK_LINUX
-#undef SDL_JOYSTICK_ANDROID
-#undef SDL_JOYSTICK_OS2
-#undef SDL_JOYSTICK_USBHID
-#undef SDL_HAVE_MACHINE_JOYSTICK_H
-#undef SDL_JOYSTICK_HIDAPI
-#undef SDL_JOYSTICK_RAWINPUT
-#undef SDL_JOYSTICK_EMSCRIPTEN
-#undef SDL_JOYSTICK_VIRTUAL
-#undef SDL_HAPTIC_DUMMY
-#undef SDL_HAPTIC_ANDROID
-#undef SDL_HAPTIC_LINUX
-#undef SDL_HAPTIC_IOKIT
-#undef SDL_HAPTIC_DINPUT
-#undef SDL_HAPTIC_XINPUT
-
-/* Enable various sensor drivers */
-#undef SDL_SENSOR_ANDROID
-#undef SDL_SENSOR_COREMOTION
-#undef SDL_SENSOR_WINDOWS
-#undef SDL_SENSOR_DUMMY
-
-/* Enable various shared object loading systems */
-#undef SDL_LOADSO_DLOPEN
-#undef SDL_LOADSO_DUMMY
-#undef SDL_LOADSO_LDG
-#undef SDL_LOADSO_WINDOWS
-#undef SDL_LOADSO_OS2
-
-/* Enable various threading systems */
-#undef SDL_THREAD_GENERIC_COND_SUFFIX
-#undef SDL_THREAD_PTHREAD
-#undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX
-#undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
-#undef SDL_THREAD_WINDOWS
-#undef SDL_THREAD_OS2
-
-/* Enable various timer systems */
-#undef SDL_TIMER_HAIKU
-#undef SDL_TIMER_DUMMY
-#undef SDL_TIMER_UNIX
-#undef SDL_TIMER_WINDOWS
-#undef SDL_TIMER_OS2
-
-/* Enable various video drivers */
-#undef SDL_VIDEO_DRIVER_HAIKU
-#undef SDL_VIDEO_DRIVER_COCOA
-#undef SDL_VIDEO_DRIVER_DIRECTFB
-#undef SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC
-#undef SDL_VIDEO_DRIVER_DUMMY
-#undef SDL_VIDEO_DRIVER_WINDOWS
-#undef SDL_VIDEO_DRIVER_WAYLAND
-#undef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON
-#undef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_LIBDECOR
-#undef SDL_VIDEO_DRIVER_X11
-#undef SDL_VIDEO_DRIVER_RPI
-#undef SDL_VIDEO_DRIVER_KMSDRM
-#undef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC
-#undef SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM
-#undef SDL_VIDEO_DRIVER_ANDROID
-#undef SDL_VIDEO_DRIVER_EMSCRIPTEN
-#undef SDL_VIDEO_DRIVER_OFFSCREEN
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XFIXES
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS
-#undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE
-#undef SDL_VIDEO_DRIVER_X11_XCURSOR
-#undef SDL_VIDEO_DRIVER_X11_XDBE
-#undef SDL_VIDEO_DRIVER_X11_XINERAMA
-#undef SDL_VIDEO_DRIVER_X11_XINPUT2
-#undef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
-#undef SDL_VIDEO_DRIVER_X11_XFIXES
-#undef SDL_VIDEO_DRIVER_X11_XRANDR
-#undef SDL_VIDEO_DRIVER_X11_XSCRNSAVER
-#undef SDL_VIDEO_DRIVER_X11_XSHAPE
-#undef SDL_VIDEO_DRIVER_X11_XVIDMODE
-#undef SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS
-#undef SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM
-#undef SDL_VIDEO_DRIVER_NACL
-#undef SDL_VIDEO_DRIVER_VIVANTE
-#undef SDL_VIDEO_DRIVER_VIVANTE_VDK
-#undef SDL_VIDEO_DRIVER_OS2
-#undef SDL_VIDEO_DRIVER_QNX
-#undef SDL_VIDEO_DRIVER_RISCOS
-
-#undef SDL_VIDEO_RENDER_D3D
-#undef SDL_VIDEO_RENDER_D3D11
-#undef SDL_VIDEO_RENDER_OGL
-#undef SDL_VIDEO_RENDER_OGL_ES
-#undef SDL_VIDEO_RENDER_OGL_ES2
-#undef SDL_VIDEO_RENDER_DIRECTFB
-#undef SDL_VIDEO_RENDER_METAL
-
-/* Enable OpenGL support */
-#undef SDL_VIDEO_OPENGL
-#undef SDL_VIDEO_OPENGL_ES
-#undef SDL_VIDEO_OPENGL_ES2
-#undef SDL_VIDEO_OPENGL_BGL
-#undef SDL_VIDEO_OPENGL_CGL
-#undef SDL_VIDEO_OPENGL_EGL
-#undef SDL_VIDEO_OPENGL_GLX
-#undef SDL_VIDEO_OPENGL_WGL
-#undef SDL_VIDEO_OPENGL_OSMESA
-#undef SDL_VIDEO_OPENGL_OSMESA_DYNAMIC
-
-/* Enable Vulkan support */
-#undef SDL_VIDEO_VULKAN
-
-/* Enable Metal support */
-#undef SDL_VIDEO_METAL
-
-/* Enable system power support */
-#undef SDL_POWER_LINUX
-#undef SDL_POWER_WINDOWS
-#undef SDL_POWER_MACOSX
-#undef SDL_POWER_HAIKU
-#undef SDL_POWER_ANDROID
-#undef SDL_POWER_EMSCRIPTEN
-#undef SDL_POWER_HARDWIRED
-
-/* Enable system filesystem support */
-#undef SDL_FILESYSTEM_ANDROID
-#undef SDL_FILESYSTEM_HAIKU
-#undef SDL_FILESYSTEM_COCOA
-#undef SDL_FILESYSTEM_DUMMY
-#undef SDL_FILESYSTEM_RISCOS
-#undef SDL_FILESYSTEM_UNIX
-#undef SDL_FILESYSTEM_WINDOWS
-#undef SDL_FILESYSTEM_NACL
-#undef SDL_FILESYSTEM_EMSCRIPTEN
-#undef SDL_FILESYSTEM_OS2
-#undef SDL_FILESYSTEM_VITA
-#undef SDL_FILESYSTEM_PSP
-
-/* Enable misc subsystem */
-#undef SDL_MISC_DUMMY
-
-/* Enable locale subsystem */
-#undef SDL_LOCALE_DUMMY
-
-/* Enable assembly routines */
-#undef SDL_ASSEMBLY_ROUTINES
-#undef SDL_ALTIVEC_BLITTERS
-#undef SDL_ARM_SIMD_BLITTERS
-#undef SDL_ARM_NEON_BLITTERS
-
-/* Whether SDL_DYNAMIC_API needs dlopen() */
-#undef DYNAPI_NEEDS_DLOPEN
-
-/* Enable ime support */
-#undef SDL_USE_IME
-
-/* Enable dynamic udev support */
-#undef SDL_UDEV_DYNAMIC
-
-/* Enable dynamic libusb support */
-#undef SDL_LIBUSB_DYNAMIC
-
-/* Enable dynamic libsamplerate support */
-#undef SDL_LIBSAMPLERATE_DYNAMIC
-
-#endif /* SDL_config_h_ */
@@ -1,192 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_android_h_
-#define SDL_config_android_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/**
- *  \file SDL_config_android.h
- *
- *  This is a configuration that can be used to build SDL for Android
- */
-
-#include <stdarg.h>
-
-#define HAVE_GCC_ATOMICS    1
-
-#define STDC_HEADERS    1
-#define HAVE_ALLOCA_H       1
-#define HAVE_CTYPE_H    1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H   1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDINT_H   1
-#define HAVE_STDIO_H    1
-#define HAVE_STRING_H   1
-#define HAVE_SYS_TYPES_H    1
-
-/* C library functions */
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_SETENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF  1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE_COPYSIGN   1
-#define HAVE_COPYSIGNF  1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_ROUND  1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF    1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC    1
-#define HAVE_TRUNCF   1
-#define HAVE_SIGACTION 1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-#define HAVE_CLOCK_GETTIME  1
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_ANDROID    1
-#define SDL_AUDIO_DRIVER_OPENSLES   1
-#define SDL_AUDIO_DRIVER_AAUDIO     1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_ANDROID    1
-#define SDL_JOYSTICK_HIDAPI     1
-#define SDL_JOYSTICK_VIRTUAL    1
-#define SDL_HAPTIC_ANDROID  1
-
-/* Enable sensor driver */
-#define SDL_SENSOR_ANDROID  1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_DLOPEN   1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_ANDROID 1
-
-/* Enable OpenGL ES */
-#define SDL_VIDEO_OPENGL_ES 1
-#define SDL_VIDEO_OPENGL_ES2 1
-#define SDL_VIDEO_OPENGL_EGL 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-
-/* Enable Vulkan support */
-/* Android does not support Vulkan in native code using the "armeabi" ABI. */
-#if defined(__ARM_ARCH) && __ARM_ARCH < 7
-#define SDL_VIDEO_VULKAN 0
-#else
-#define SDL_VIDEO_VULKAN 1
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_ANDROID 1
-
-/* Enable the filesystem driver */
-#define SDL_FILESYSTEM_ANDROID   1
-
-#endif /* SDL_config_android_h_ */
@@ -1,217 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef _SDL_config_emscripten_h_
-#define _SDL_config_emscripten_h_
-
-#include "SDL_platform.h"
-
-/**
- *  \file SDL_config_emscripten.h
- *
- *  This is a configuration that can be used to build SDL for Emscripten.
- */
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-#define HAVE_GCC_ATOMICS 1
-
-/* Useful headers */
-#define STDC_HEADERS 1
-#define HAVE_ALLOCA_H 1
-#define HAVE_CTYPE_H 1
-#define HAVE_ICONV_H 1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MALLOC_H 1
-#define HAVE_MATH_H 1
-#define HAVE_MEMORY_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDARG_H 1
-#define HAVE_STDINT_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STDLIB_H 1
-#define HAVE_STRINGS_H 1
-#define HAVE_STRING_H 1
-#define HAVE_SYS_TYPES_H 1
-#define HAVE_WCHAR_H 1
-
-/* C library functions */
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_UNSETENV 1
-#define HAVE_QSORT 1
-#define HAVE_ABS 1
-#define HAVE_BCOPY 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_WCSLEN 1
-#define HAVE_WCSDUP 1
-#define HAVE_WCSSTR 1
-#define HAVE_WCSCMP 1
-#define HAVE_WCSNCMP 1
-#define HAVE_WCSCASECMP 1
-#define HAVE_WCSNCASECMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY 1
-#define HAVE_STRLCAT 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_SSCANF 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF 1
-#define HAVE_M_PI 1
-#define HAVE_ACOS 1
-#define HAVE_ACOSF 1
-#define HAVE_ASIN 1
-#define HAVE_ASINF 1
-#define HAVE_ATAN 1
-#define HAVE_ATANF 1
-#define HAVE_ATAN2 1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL 1
-#define HAVE_CEILF 1
-#define HAVE_COPYSIGN 1
-#define HAVE_COPYSIGNF 1
-#define HAVE_COS 1
-#define HAVE_COSF 1
-#define HAVE_EXP 1
-#define HAVE_EXPF 1
-#define HAVE_FABS 1
-#define HAVE_FABSF 1
-#define HAVE_FLOOR 1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD 1
-#define HAVE_FMODF 1
-#define HAVE_LOG 1
-#define HAVE_LOGF 1
-#define HAVE_LOG10 1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW 1
-#define HAVE_POWF 1
-#define HAVE_ROUND  1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF 1
-#define HAVE_SIN 1
-#define HAVE_SINF 1
-#define HAVE_SQRT 1
-#define HAVE_SQRTF 1
-#define HAVE_TAN 1
-#define HAVE_TANF 1
-#define HAVE_TRUNC 1
-#define HAVE_TRUNCF 1
-#define HAVE_FSEEKO 1
-#define HAVE_FSEEKO64 1
-#define HAVE_SIGACTION 1
-#define HAVE_SA_SIGACTION 1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP 1
-#define HAVE_SYSCONF 1
-#define HAVE_CLOCK_GETTIME 1
-/* #undef HAVE_GETPAGESIZE */
-#define HAVE_MPROTECT 1
-#define HAVE_ICONV 1
-
-/* SDL internal assertion support */
-/* #undef SDL_DEFAULT_ASSERT_LEVEL */
-
-#define SDL_CPUINFO_DISABLED 1
-#define SDL_HAPTIC_DISABLED 1
-#define SDL_HIDAPI_DISABLED 1
-#ifndef __EMSCRIPTEN_PTHREADS__
-#define SDL_THREADS_DISABLED 1
-#endif
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_DISK 1
-#define SDL_AUDIO_DRIVER_DUMMY 1
-#define SDL_AUDIO_DRIVER_EMSCRIPTEN 1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_EMSCRIPTEN 1
-
-/* Enable various sensor drivers */
-#define SDL_SENSOR_DUMMY 1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_DLOPEN 1
-
-/* Enable various threading systems */
-#ifdef __EMSCRIPTEN_PTHREADS__
-#define SDL_THREAD_PTHREAD 1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX 1
-#endif
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX 1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_EMSCRIPTEN 1
-
-#define SDL_VIDEO_RENDER_OGL_ES2 1
-
-/* Enable OpenGL support */
-/* #undef SDL_VIDEO_OPENGL */
-/* #undef SDL_VIDEO_OPENGL_ES */
-#define SDL_VIDEO_OPENGL_ES2 1
-/* #undef SDL_VIDEO_OPENGL_BGL */
-/* #undef SDL_VIDEO_OPENGL_CGL */
-/* #undef SDL_VIDEO_OPENGL_GLX */
-/* #undef SDL_VIDEO_OPENGL_WGL */
-#define SDL_VIDEO_OPENGL_EGL 1
-/* #undef SDL_VIDEO_OPENGL_OSMESA */
-/* #undef SDL_VIDEO_OPENGL_OSMESA_DYNAMIC */
-
-/* Enable system power support */
-#define SDL_POWER_EMSCRIPTEN 1
-
-/* Enable system filesystem support */
-#define SDL_FILESYSTEM_EMSCRIPTEN 1
-
-#endif /* _SDL_config_emscripten_h_ */
@@ -1,215 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_iphoneos_h_
-#define SDL_config_iphoneos_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#define HAVE_GCC_ATOMICS    1
-
-#define STDC_HEADERS    1
-#define HAVE_ALLOCA_H       1
-#define HAVE_CTYPE_H    1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H   1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H   1
-#define HAVE_STDINT_H   1
-#define HAVE_STDIO_H    1
-#define HAVE_STRING_H   1
-#define HAVE_SYS_TYPES_H    1
-/* The libunwind functions are only available on x86 */
-/* #undef HAVE_LIBUNWIND_H */
-
-/* C library functions */
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_SETENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF   1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF  1
-#define HAVE_M_PI   1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE_COPYSIGN   1
-#define HAVE_COPYSIGNF  1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF    1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC  1
-#define HAVE_TRUNCF 1
-#define HAVE_SIGACTION  1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-#define HAVE_SYSCTLBYNAME 1
-#define HAVE_O_CLOEXEC 1
-
-/* enable iPhone version of Core Audio driver */
-#define SDL_AUDIO_DRIVER_COREAUDIO 1
-/* Enable the dummy audio driver (src/audio/dummy/\*.c) */
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable the stub haptic driver (src/haptic/dummy/\*.c) */
-#define SDL_HAPTIC_DUMMY 1
-
-/* Enable joystick support */
-/* Only enable HIDAPI support if you want to support Steam Controllers on iOS and tvOS */
-/*#define SDL_JOYSTICK_HIDAPI 1*/
-#define SDL_JOYSTICK_MFI 1
-#define SDL_JOYSTICK_VIRTUAL    1
-
-#ifdef __TVOS__
-#define SDL_SENSOR_DUMMY    1
-#else
-/* Enable the CoreMotion sensor driver */
-#define SDL_SENSOR_COREMOTION   1
-#endif
-
-/* Enable Unix style SO loading */
-#define SDL_LOADSO_DLOPEN 1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Supported video drivers */
-#define SDL_VIDEO_DRIVER_UIKIT  1
-#define SDL_VIDEO_DRIVER_DUMMY  1
-
-/* Enable OpenGL ES */
-#if !TARGET_OS_MACCATALYST
-#define SDL_VIDEO_OPENGL_ES2 1
-#define SDL_VIDEO_OPENGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-#endif
-
-/* Metal supported on 64-bit devices running iOS 8.0 and tvOS 9.0 and newer
-   Also supported in simulator from iOS 13.0 and tvOS 13.0
- */
-#if (TARGET_OS_SIMULATOR && ((__IPHONE_OS_VERSION_MIN_REQUIRED >= 130000) || (__TV_OS_VERSION_MIN_REQUIRED >= 130000))) || (!TARGET_CPU_ARM && ((__IPHONE_OS_VERSION_MIN_REQUIRED >= 80000) || (__TV_OS_VERSION_MIN_REQUIRED >= 90000)))
-#define SDL_PLATFORM_SUPPORTS_METAL	1
-#else
-#define SDL_PLATFORM_SUPPORTS_METAL	0
-#endif
-
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_RENDER_METAL  1
-#endif
-
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_VULKAN 1
-#endif
-
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_METAL 1
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_UIKIT 1
-
-/* enable iPhone keyboard support */
-#define SDL_IPHONE_KEYBOARD 1
-
-/* enable iOS extended launch screen */
-#define SDL_IPHONE_LAUNCHSCREEN 1
-
-/* enable filesystem support */
-#define SDL_FILESYSTEM_COCOA   1
-
-#endif /* SDL_config_iphoneos_h_ */
@@ -1,280 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_macosx_h_
-#define SDL_config_macosx_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* This gets us MAC_OS_X_VERSION_MIN_REQUIRED... */
-#include <AvailabilityMacros.h>
-
-/* This is a set of defines to configure the SDL features */
-
-#ifdef __LP64__
-    #define SIZEOF_VOIDP 8
-#else
-    #define SIZEOF_VOIDP 4
-#endif
-
-/* Useful headers */
-#define STDC_HEADERS    1
-#define HAVE_ALLOCA_H       1
-#define HAVE_CTYPE_H    1
-#define HAVE_FLOAT_H    1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H   1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H   1
-#define HAVE_STDINT_H   1
-#define HAVE_STDIO_H    1
-#define HAVE_STRING_H   1
-#define HAVE_SYS_TYPES_H    1
-#define HAVE_LIBUNWIND_H    1
-
-/* C library functions */
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOK_R 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF   1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF  1
-#define HAVE_M_PI   1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE_COPYSIGN   1
-#define HAVE_COPYSIGNF  1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF    1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC    1
-#define HAVE_TRUNCF   1
-#define HAVE_SIGACTION  1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-#define HAVE_SYSCTLBYNAME 1
-
-#if defined(__has_include) && (defined(__i386__) || defined(__x86_64))
-# if __has_include(<immintrin.h>)
-#   define HAVE_IMMINTRIN_H 1
-# endif
-#endif
-
-#if (MAC_OS_X_VERSION_MAX_ALLOWED >= 1070)
-#define HAVE_O_CLOEXEC 1
-#endif
-
-#define HAVE_GCC_ATOMICS 1
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_COREAUDIO  1
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_HIDAPI 1
-#define SDL_JOYSTICK_IOKIT  1
-#define SDL_JOYSTICK_VIRTUAL    1
-#define SDL_HAPTIC_IOKIT    1
-
-/* The MFI controller support requires ARC Objective C runtime */
-#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1080 && !defined(__i386__)
-#define SDL_JOYSTICK_MFI 1
-#endif
-
-/* Enable the dummy sensor driver */
-#define SDL_SENSOR_DUMMY  1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_DLOPEN   1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_COCOA  1
-#define SDL_VIDEO_DRIVER_DUMMY  1
-#undef SDL_VIDEO_DRIVER_X11
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC "/opt/X11/lib/libX11.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT "/opt/X11/lib/libXext.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA "/opt/X11/lib/libXinerama.1.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 "/opt/X11/lib/libXi.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR "/opt/X11/lib/libXrandr.2.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS "/opt/X11/lib/libXss.1.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE "/opt/X11/lib/libXxf86vm.1.dylib"
-#define SDL_VIDEO_DRIVER_X11_XDBE 1
-#define SDL_VIDEO_DRIVER_X11_XINERAMA 1
-#define SDL_VIDEO_DRIVER_X11_XRANDR 1
-#define SDL_VIDEO_DRIVER_X11_XSCRNSAVER 1
-#define SDL_VIDEO_DRIVER_X11_XSHAPE 1
-#define SDL_VIDEO_DRIVER_X11_XVIDMODE 1
-#define SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM 1
-
-#ifdef MAC_OS_X_VERSION_10_8
-/*
- * No matter the versions targeted, this is the 10.8 or later SDK, so you have
- *  to use the external Xquartz, which is a more modern Xlib. Previous SDKs
- *  used an older Xlib.
- */
-#define SDL_VIDEO_DRIVER_X11_XINPUT2 1
-#define SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS 1
-#endif
-
-#ifndef SDL_VIDEO_RENDER_OGL
-#define SDL_VIDEO_RENDER_OGL    1
-#endif
-
-#ifndef SDL_VIDEO_RENDER_OGL_ES2
-#define SDL_VIDEO_RENDER_OGL_ES2 1
-#endif
-
-/* Metal only supported on 64-bit architectures with 10.11+ */
-#if TARGET_RT_64_BIT && (MAC_OS_X_VERSION_MAX_ALLOWED >= 101100)
-#define SDL_PLATFORM_SUPPORTS_METAL    1
-#else
-#define SDL_PLATFORM_SUPPORTS_METAL    0
-#endif
-
-#ifndef SDL_VIDEO_RENDER_METAL
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_RENDER_METAL    1
-#else
-#define SDL_VIDEO_RENDER_METAL    0
-#endif
-#endif
-
-/* Enable OpenGL support */
-#ifndef SDL_VIDEO_OPENGL
-#define SDL_VIDEO_OPENGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_ES2
-#define SDL_VIDEO_OPENGL_ES2    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_EGL
-#define SDL_VIDEO_OPENGL_EGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_CGL
-#define SDL_VIDEO_OPENGL_CGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_GLX
-#define SDL_VIDEO_OPENGL_GLX    1
-#endif
-
-/* Enable Vulkan and Metal support */
-#ifndef SDL_VIDEO_VULKAN
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_VULKAN 1
-#else
-#define SDL_VIDEO_VULKAN 0
-#endif
-#endif
-
-#ifndef SDL_VIDEO_METAL
-#if SDL_PLATFORM_SUPPORTS_METAL
-#define SDL_VIDEO_METAL 1
-#else
-#define SDL_VIDEO_METAL 0
-#endif
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_MACOSX 1
-
-/* enable filesystem support */
-#define SDL_FILESYSTEM_COCOA   1
-
-/* Enable assembly routines */
-#define SDL_ASSEMBLY_ROUTINES   1
-#ifdef __ppc__
-#define SDL_ALTIVEC_BLITTERS    1
-#endif
-
-#endif /* SDL_config_macosx_h_ */
@@ -1,205 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_os2_h_
-#define SDL_config_os2_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-#define SIZEOF_VOIDP 4
-
-#define SDL_AUDIO_DRIVER_DUMMY 1
-#define SDL_AUDIO_DRIVER_DISK 1
-#define SDL_AUDIO_DRIVER_OS2 1
-
-#define SDL_POWER_DISABLED  1
-#define SDL_HAPTIC_DISABLED 1
-
-#define SDL_SENSOR_DUMMY 1
-#define SDL_VIDEO_DRIVER_DUMMY 1
-#define SDL_VIDEO_DRIVER_OS2 1
-#define SDL_JOYSTICK_OS2 1
-#ifndef HAVE_LIBUSB_H  /* see Makefile */
-#define SDL_HIDAPI_DISABLED 1
-/*#undef SDL_JOYSTICK_HIDAPI */
-#else
-#define SDL_JOYSTICK_HIDAPI 1
-/* dynamically loaded libusb-1.0 dll: */
-#define SDL_LIBUSB_DYNAMIC "usb100.dll"
-#endif
-/*#undef SDL_JOYSTICK_VIRTUAL */
-
-/* Enable OpenGL support */
-/* #undef SDL_VIDEO_OPENGL */
-
-#define SDL_THREAD_OS2 1
-#define SDL_LOADSO_OS2 1
-#define SDL_TIMER_OS2 1
-#define SDL_FILESYSTEM_OS2 1
-
-/* Enable assembly routines */
-#define SDL_ASSEMBLY_ROUTINES 1
-
-/* use libsamplerate for audio rate conversion. */
-/*#define HAVE_LIBSAMPLERATE_H 1 */
-
-/* Enable dynamic libsamplerate support */
-#define SDL_LIBSAMPLERATE_DYNAMIC "SAMPRATE.DLL"
-
-#define HAVE_LIBC 1
-
-#define HAVE_STDARG_H 1
-#define HAVE_STDDEF_H 1
-#define HAVE_STDINT_H 1
-
-#define HAVE_SYS_TYPES_H 1
-#define HAVE_STDIO_H 1
-#define STDC_HEADERS 1
-#define HAVE_STDLIB_H 1
-#define HAVE_MALLOC_H 1
-#define HAVE_MEMORY_H 1
-#define HAVE_STRING_H 1
-#define HAVE_STRINGS_H 1
-#define HAVE_WCHAR_H 1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_CTYPE_H 1
-#define HAVE_MATH_H 1
-#define HAVE_FLOAT_H 1
-#define HAVE_SIGNAL_H 1
-
-#if 0 /* see Makefile */
-#define HAVE_ICONV 1
-#define HAVE_ICONV_H 1
-#endif
-
-/* #undef HAVE_DLOPEN */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#if defined(__WATCOMC__)
-#define HAVE__FSEEKI64 1
-#define HAVE__FTELLI64 1
-#endif
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_QSORT 1
-#define HAVE_ABS 1
-#define HAVE_BCOPY 1
-#define HAVE_MEMSET 1
-#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
-#define HAVE_WCSLEN 1
-#define HAVE_WCSLCPY 1
-#define HAVE_WCSLCAT 1
-/* #undef HAVE_WCSDUP */
-#define HAVE__WCSDUP 1
-#define HAVE_WCSSTR 1
-#define HAVE_WCSCMP 1
-#define HAVE_WCSNCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY 1
-#define HAVE_STRLCAT 1
-#define HAVE__STRREV 1
-#define HAVE__STRUPR 1
-#define HAVE__STRLWR 1
-/* #undef HAVE_INDEX */
-/* #undef HAVE_RINDEX */
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-/* #undef HAVE_STRTOK_R */
-#define HAVE_ITOA 1
-#define HAVE__LTOA 1
-#define HAVE__ULTOA 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE__I64TOA 1
-#define HAVE__UI64TOA 1
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE_STRICMP 1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_SSCANF  1
-#define HAVE_VSSCANF 1
-#define HAVE_SNPRINTF 1
-#define HAVE_VSNPRINTF 1
-#define HAVE_SETJMP 1
-#define HAVE_ACOS 1
-/* #undef HAVE_ACOSF */
-#define HAVE_ASIN 1
-/* #undef HAVE_ASINF */
-#define HAVE_ATAN 1
-#define HAVE_ATAN2 1
-/* #undef HAVE_ATAN2F */
-#define HAVE_CEIL 1
-/* #undef HAVE_CEILF */
-/* #undef HAVE_COPYSIGN */
-/* #undef HAVE_COPYSIGNF */
-#define HAVE_COS 1
-/* #undef HAVE_COSF */
-#define HAVE_EXP 1
-/* #undef HAVE_EXPF */
-#define HAVE_FABS 1
-/* #undef HAVE_FABSF */
-#define HAVE_FLOOR 1
-/* #undef HAVE_FLOORF */
-#define HAVE_FMOD 1
-/* #undef HAVE_FMODF */
-#define HAVE_LOG 1
-/* #undef HAVE_LOGF */
-#define HAVE_LOG10 1
-/* #undef HAVE_LOG10F */
-#define HAVE_POW 1
-/* #undef HAVE_POWF */
-#define HAVE_SIN 1
-/* #undef HAVE_SINF */
-/* #undef HAVE_SCALBN */
-/* #undef HAVE_SCALBNF */
-#define HAVE_SQRT 1
-/* #undef HAVE_SQRTF */
-#define HAVE_TAN 1
-/* #undef HAVE_TANF */
-/* #undef HAVE_TRUNC */
-/* #undef HAVE_TRUNCF */
-/* #undef HAVE_LROUND */
-/* #undef HAVE_LROUNDF */
-/* #undef HAVE_ROUND */
-/* #undef HAVE_ROUNDF */
-
-#endif /* SDL_config_os2_h_ */
@@ -1,140 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_pandora_h_
-#define SDL_config_pandora_h_
-#define SDL_config_h_
-
-/* This is a set of defines to configure the SDL features */
-
-/* General platform specific identifiers */
-#include "SDL_platform.h"
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#define SDL_BYTEORDER 1234
-
-#define STDC_HEADERS 1
-#define HAVE_ALLOCA_H 1
-#define HAVE_CTYPE_H 1
-#define HAVE_ICONV_H 1
-#define HAVE_INTTYPES_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MALLOC_H 1
-#define HAVE_MATH_H 1
-#define HAVE_MEMORY_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDARG_H 1
-#define HAVE_STDINT_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STDLIB_H 1
-#define HAVE_STRINGS_H 1
-#define HAVE_STRING_H 1
-#define HAVE_SYS_TYPES_H 1
-
-#define HAVE_DLOPEN 1
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_UNSETENV 1
-#define HAVE_QSORT 1
-#define HAVE_ABS 1
-#define HAVE_BCOPY 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_STRLEN 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_VSSCANF 1
-#define HAVE_VSNPRINTF 1
-#define HAVE_M_PI 1
-#define HAVE_CEIL 1
-#define HAVE_COPYSIGN 1
-#define HAVE_COS 1
-#define HAVE_COSF 1
-#define HAVE_EXP 1
-#define HAVE_FABS 1
-#define HAVE_FLOOR 1
-#define HAVE_LOG 1
-#define HAVE_LOG10 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SIN 1
-#define HAVE_SINF 1
-#define HAVE_SQRT 1
-#define HAVE_SQRTF 1
-#define HAVE_TAN 1
-#define HAVE_TANF 1
-#define HAVE_TRUNC 1
-#define HAVE_TRUNCF 1
-#define HAVE_SIGACTION 1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP 1
-
-#define SDL_AUDIO_DRIVER_DUMMY 1
-#define SDL_AUDIO_DRIVER_OSS 1
-
-#define SDL_INPUT_LINUXEV 1
-#define SDL_JOYSTICK_LINUX 1
-#define SDL_JOYSTICK_VIRTUAL 1
-#define SDL_HAPTIC_LINUX 1
-
-#define SDL_SENSOR_DUMMY 1
-
-#define SDL_LOADSO_DLOPEN 1
-
-#define SDL_THREAD_PTHREAD 1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP 1
-
-#define SDL_TIMER_UNIX 1
-#define SDL_FILESYSTEM_UNIX 1
-
-#define SDL_VIDEO_DRIVER_DUMMY 1
-#define SDL_VIDEO_DRIVER_X11 1
-#define SDL_VIDEO_DRIVER_PANDORA 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_OPENGL_ES 1
-
-#endif /* SDL_config_pandora_h_ */
@@ -1,310 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_windows_h_
-#define SDL_config_windows_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* winsdkver.h defines _WIN32_MAXVER for SDK version detection. It is present since at least the Windows 7 SDK,
- * but out of caution we'll only use it if the compiler supports __has_include() to confirm its presence.
- * If your compiler doesn't support __has_include() but you have winsdkver.h, define HAVE_WINSDKVER_H.  */
-#if !defined(HAVE_WINSDKVER_H) && defined(__has_include)
-#if __has_include(<winsdkver.h>)
-#define HAVE_WINSDKVER_H 1
-#endif
-#endif
-
-#ifdef HAVE_WINSDKVER_H
-#include <winsdkver.h>
-#endif
-
-/* This is a set of defines to configure the SDL features */
-
-#if !defined(_STDINT_H_) && (!defined(HAVE_STDINT_H) || !_HAVE_STDINT_H)
-#if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__) || defined(__clang__) || defined(__BORLANDC__) || defined(__CODEGEARC__)
-#define HAVE_STDINT_H   1
-#elif defined(_MSC_VER)
-typedef signed __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef signed __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef signed __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef signed __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#ifndef _UINTPTR_T_DEFINED
-#ifdef  _WIN64
-typedef unsigned __int64 uintptr_t;
-#else
-typedef unsigned int uintptr_t;
-#endif
-#define _UINTPTR_T_DEFINED
-#endif
-/* Older Visual C++ headers don't have the Win64-compatible typedefs... */
-#if ((_MSC_VER <= 1200) && (!defined(DWORD_PTR)))
-#define DWORD_PTR DWORD
-#endif
-#if ((_MSC_VER <= 1200) && (!defined(LONG_PTR)))
-#define LONG_PTR LONG
-#endif
-#else /* !__GNUC__ && !_MSC_VER */
-typedef signed char int8_t;
-typedef unsigned char uint8_t;
-typedef signed short int16_t;
-typedef unsigned short uint16_t;
-typedef signed int int32_t;
-typedef unsigned int uint32_t;
-typedef signed long long int64_t;
-typedef unsigned long long uint64_t;
-#ifndef _SIZE_T_DEFINED_
-#define _SIZE_T_DEFINED_
-typedef unsigned int size_t;
-#endif
-typedef unsigned int uintptr_t;
-#endif /* __GNUC__ || _MSC_VER */
-#endif /* !_STDINT_H_ && !HAVE_STDINT_H */
-
-#ifdef _WIN64
-# define SIZEOF_VOIDP 8
-#else
-# define SIZEOF_VOIDP 4
-#endif
-
-#ifdef __clang__
-# define HAVE_GCC_ATOMICS 1
-#endif
-
-#define HAVE_DDRAW_H 1
-#define HAVE_DINPUT_H 1
-#define HAVE_DSOUND_H 1
-#define HAVE_DXGI_H 1
-#define HAVE_XINPUT_H 1
-#if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0A00  /* Windows 10 SDK */
-#define HAVE_WINDOWS_GAMING_INPUT_H 1
-#endif
-#if defined(_WIN32_MAXVER) && _WIN32_MAXVER >= 0x0602  /* Windows 8 SDK */
-#define HAVE_D3D11_H 1
-#define HAVE_ROAPI_H 1
-#endif
-#define HAVE_MMDEVICEAPI_H 1
-#define HAVE_AUDIOCLIENT_H 1
-#define HAVE_TPCSHRD_H 1
-#define HAVE_SENSORSAPI_H 1
-#if (defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)) && (defined(_MSC_VER) && _MSC_VER >= 1600)
-#define HAVE_IMMINTRIN_H 1
-#elif defined(__has_include) && (defined(__i386__) || defined(__x86_64))
-# if __has_include(<immintrin.h>)
-#   define HAVE_IMMINTRIN_H 1
-# endif
-#endif
-
-/* This is disabled by default to avoid C runtime dependencies and manifest requirements */
-#ifdef HAVE_LIBC
-/* Useful headers */
-#define STDC_HEADERS 1
-#define HAVE_CTYPE_H 1
-#define HAVE_FLOAT_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STRING_H 1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_QSORT 1
-#define HAVE_ABS 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE__STRREV 1
-/* These functions have security warnings, so we won't use them */
-/* #undef HAVE__STRUPR */
-/* #undef HAVE__STRLWR */
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-/* #undef HAVE_STRTOK_R */
-/* These functions have security warnings, so we won't use them */
-/* #undef HAVE__LTOA */
-/* #undef HAVE__ULTOA */
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE__STRICMP 1
-#define HAVE__STRNICMP 1
-#define HAVE__WCSICMP 1
-#define HAVE__WCSNICMP 1
-#define HAVE__WCSDUP 1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEILF  1
-#define HAVE__COPYSIGN 1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#if defined(_MSC_VER)
-/* These functions were added with the VC++ 2013 C runtime library */
-#if _MSC_VER >= 1800
-#define HAVE_STRTOLL 1
-#define HAVE_STRTOULL 1
-#define HAVE_VSSCANF 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE_SCALBN 1
-#define HAVE_SCALBNF 1
-#define HAVE_TRUNC  1
-#define HAVE_TRUNCF 1
-#endif
-/* This function is available with at least the VC++ 2008 C runtime library */
-#if _MSC_VER >= 1400
-#define HAVE__FSEEKI64 1
-#endif
-#endif
-#if !defined(_MSC_VER) || defined(_USE_MATH_DEFINES)
-#define HAVE_M_PI 1
-#endif
-#else
-#define HAVE_STDARG_H   1
-#define HAVE_STDDEF_H   1
-#endif
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_WASAPI 1
-#define SDL_AUDIO_DRIVER_DSOUND 1
-#define SDL_AUDIO_DRIVER_WINMM  1
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_DINPUT 1
-#define SDL_JOYSTICK_HIDAPI 1
-#ifndef __WINRT__
-#define SDL_JOYSTICK_RAWINPUT   1
-#endif
-#define SDL_JOYSTICK_VIRTUAL    1
-#ifdef HAVE_WINDOWS_GAMING_INPUT_H
-#define SDL_JOYSTICK_WGI    1
-#endif
-#define SDL_JOYSTICK_XINPUT 1
-#define SDL_HAPTIC_DINPUT   1
-#define SDL_HAPTIC_XINPUT   1
-
-/* Enable the sensor driver */
-#define SDL_SENSOR_WINDOWS  1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_WINDOWS  1
-
-/* Enable various threading systems */
-#define SDL_THREAD_GENERIC_COND_SUFFIX 1
-#define SDL_THREAD_WINDOWS  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_WINDOWS   1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_DUMMY  1
-#define SDL_VIDEO_DRIVER_WINDOWS    1
-
-#ifndef SDL_VIDEO_RENDER_D3D
-#define SDL_VIDEO_RENDER_D3D    1
-#endif
-#if !defined(SDL_VIDEO_RENDER_D3D11) && defined(HAVE_D3D11_H)
-#define SDL_VIDEO_RENDER_D3D11  1
-#endif
-
-/* Enable OpenGL support */
-#ifndef SDL_VIDEO_OPENGL
-#define SDL_VIDEO_OPENGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_WGL
-#define SDL_VIDEO_OPENGL_WGL    1
-#endif
-#ifndef SDL_VIDEO_RENDER_OGL
-#define SDL_VIDEO_RENDER_OGL    1
-#endif
-#ifndef SDL_VIDEO_RENDER_OGL_ES2
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_ES2
-#define SDL_VIDEO_OPENGL_ES2    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_EGL
-#define SDL_VIDEO_OPENGL_EGL    1
-#endif
-
-/* Enable Vulkan support */
-#define SDL_VIDEO_VULKAN 1
-
-/* Enable system power support */
-#define SDL_POWER_WINDOWS 1
-
-/* Enable filesystem support */
-#define SDL_FILESYSTEM_WINDOWS  1
-
-/* Enable assembly routines (Win64 doesn't have inline asm) */
-#ifndef _WIN64
-#define SDL_ASSEMBLY_ROUTINES   1
-#endif
-
-#endif /* SDL_config_windows_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,264 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_config_winrt_h_
-#define SDL_config_winrt_h_
-#define SDL_config_h_
-
-#include "SDL_platform.h"
-
-/* Make sure the Windows SDK's NTDDI_VERSION macro gets defined.  This is used
-   by SDL to determine which version of the Windows SDK is being used.
-*/
-#include <sdkddkver.h>
-
-/* Define possibly-undefined NTDDI values (used when compiling SDL against
-   older versions of the Windows SDK.
-*/
-#ifndef NTDDI_WINBLUE
-#define NTDDI_WINBLUE 0x06030000
-#endif
-#ifndef NTDDI_WIN10
-#define NTDDI_WIN10 0x0A000000
-#endif
-
-/* This is a set of defines to configure the SDL features */
-
-#if !defined(_STDINT_H_) && (!defined(HAVE_STDINT_H) || !_HAVE_STDINT_H)
-#if defined(__GNUC__) || defined(__DMC__) || defined(__WATCOMC__)
-#define HAVE_STDINT_H   1
-#elif defined(_MSC_VER)
-typedef signed __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef signed __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef signed __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef signed __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#ifndef _UINTPTR_T_DEFINED
-#ifdef  _WIN64
-typedef unsigned __int64 uintptr_t;
-#else
-typedef unsigned int uintptr_t;
-#endif
-#define _UINTPTR_T_DEFINED
-#endif
-/* Older Visual C++ headers don't have the Win64-compatible typedefs... */
-#if ((_MSC_VER <= 1200) && (!defined(DWORD_PTR)))
-#define DWORD_PTR DWORD
-#endif
-#if ((_MSC_VER <= 1200) && (!defined(LONG_PTR)))
-#define LONG_PTR LONG
-#endif
-#else /* !__GNUC__ && !_MSC_VER */
-typedef signed char int8_t;
-typedef unsigned char uint8_t;
-typedef signed short int16_t;
-typedef unsigned short uint16_t;
-typedef signed int int32_t;
-typedef unsigned int uint32_t;
-typedef signed long long int64_t;
-typedef unsigned long long uint64_t;
-#ifndef _SIZE_T_DEFINED_
-#define _SIZE_T_DEFINED_
-typedef unsigned int size_t;
-#endif
-typedef unsigned int uintptr_t;
-#endif /* __GNUC__ || _MSC_VER */
-#endif /* !_STDINT_H_ && !HAVE_STDINT_H */
-
-#ifdef _WIN64
-# define SIZEOF_VOIDP 8
-#else
-# define SIZEOF_VOIDP 4
-#endif
-
-#ifdef __clang__
-# define HAVE_GCC_ATOMICS 1
-#endif
-
-/* Useful headers */
-#define HAVE_DXGI_H 1
-#if WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP
-#define HAVE_XINPUT_H 1
-#endif
-
-#define HAVE_MMDEVICEAPI_H 1
-#define HAVE_AUDIOCLIENT_H 1
-#define HAVE_TPCSHRD_H 1
-
-#define HAVE_LIBC 1
-#define STDC_HEADERS 1
-#define HAVE_CTYPE_H 1
-#define HAVE_FLOAT_H 1
-#define HAVE_LIMITS_H 1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H 1
-#define HAVE_STDIO_H 1
-#define HAVE_STRING_H 1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC 1
-#define HAVE_FREE 1
-#define HAVE_ALLOCA 1
-#define HAVE_QSORT 1
-#define HAVE_ABS 1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE 1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE__STRREV 1
-#define HAVE__STRUPR 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR 1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL 1
-/* #undef HAVE_STRTOLL */
-/* #undef HAVE_STRTOULL */
-#define HAVE_STRTOD 1
-#define HAVE_ATOI 1
-#define HAVE_ATOF 1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP 1
-#define HAVE__STRICMP 1
-#define HAVE__STRNICMP 1
-#define HAVE_VSNPRINTF 1
-/* TODO, WinRT: consider using ??_s versions of the following */
-/* #undef HAVE__STRLWR */
-/* #undef HAVE_ITOA */
-/* #undef HAVE__LTOA */
-/* #undef HAVE__ULTOA */
-/* #undef HAVE_SSCANF */
-#define HAVE_M_PI 1
-#define HAVE_ACOS   1
-#define HAVE_ACOSF  1
-#define HAVE_ASIN   1
-#define HAVE_ASINF  1
-#define HAVE_ATAN   1
-#define HAVE_ATANF  1
-#define HAVE_ATAN2  1
-#define HAVE_ATAN2F 1
-#define HAVE_CEIL   1
-#define HAVE_CEILF  1
-#define HAVE__COPYSIGN 1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_EXP    1
-#define HAVE_EXPF   1
-#define HAVE_FABS   1
-#define HAVE_FABSF  1
-#define HAVE_FLOOR  1
-#define HAVE_FLOORF 1
-#define HAVE_FMOD   1
-#define HAVE_FMODF  1
-#define HAVE_LOG    1
-#define HAVE_LOGF   1
-#define HAVE_LOG10  1
-#define HAVE_LOG10F 1
-#define HAVE_LROUND 1
-#define HAVE_LROUNDF 1
-#define HAVE_POW    1
-#define HAVE_POWF   1
-#define HAVE_ROUND 1
-#define HAVE_ROUNDF 1
-#define HAVE__SCALB 1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SQRTF  1
-#define HAVE_TAN    1
-#define HAVE_TANF   1
-#define HAVE_TRUNC  1
-#define HAVE_TRUNCF 1
-#define HAVE__FSEEKI64 1
-
-#define HAVE_ROAPI_H  1
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_WASAPI 1
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
-#define SDL_JOYSTICK_DISABLED 1
-#define SDL_HAPTIC_DISABLED 1
-#else
-#define SDL_JOYSTICK_VIRTUAL    1
-#if (NTDDI_VERSION >= NTDDI_WIN10)
-#define SDL_JOYSTICK_WGI    1
-#define SDL_HAPTIC_DISABLED 1
-#else
-#define SDL_JOYSTICK_XINPUT 1
-#define SDL_HAPTIC_XINPUT   1
-#endif /* WIN10 */
-#endif
-
-/* WinRT doesn't have HIDAPI available */
-#define SDL_HIDAPI_DISABLED    1
-
-/* Enable the dummy sensor driver */
-#define SDL_SENSOR_DUMMY  1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_WINDOWS  1
-
-/* Enable various threading systems */
-#if (NTDDI_VERSION >= NTDDI_WINBLUE)
-#define SDL_THREAD_GENERIC_COND_SUFFIX 1
-#define SDL_THREAD_WINDOWS  1
-#else
-/* WinRT on Windows 8.0 and Windows Phone 8.0 don't support CreateThread() */
-#define SDL_THREAD_STDCPP   1
-#endif
-
-/* Enable various timer systems */
-#define SDL_TIMER_WINDOWS   1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_WINRT  1
-#define SDL_VIDEO_DRIVER_DUMMY  1
-
-/* Enable OpenGL ES 2.0 (via a modified ANGLE library) */
-#define SDL_VIDEO_OPENGL_ES2 1
-#define SDL_VIDEO_OPENGL_EGL 1
-
-/* Enable appropriate renderer(s) */
-#define SDL_VIDEO_RENDER_D3D11  1
-
-#if SDL_VIDEO_OPENGL_ES2
-#define SDL_VIDEO_RENDER_OGL_ES2 1
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_WINRT 1
-
-/* Enable assembly routines (Win64 doesn't have inline asm) */
-#ifndef _WIN64
-#define SDL_ASSEMBLY_ROUTINES   1
-#endif
-
-#endif /* SDL_config_winrt_h_ */
@@ -1,559 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_cpuinfo.h
- *
- *  CPU feature detection for SDL.
- */
-
-#ifndef SDL_cpuinfo_h_
-#define SDL_cpuinfo_h_
-
-#include "SDL_stdinc.h"
-
-/* Need to do this here because intrin.h has C++ code in it */
-/* Visual Studio 2005 has a bug where intrin.h conflicts with winnt.h */
-#if defined(_MSC_VER) && (_MSC_VER >= 1500) && (defined(_M_IX86) || defined(_M_X64))
-#ifdef __clang__
-/* As of Clang 11, '_m_prefetchw' is conflicting with the winnt.h's version,
-   so we define the needed '_m_prefetch' here as a pseudo-header, until the issue is fixed. */
-
-#ifndef __PRFCHWINTRIN_H
-#define __PRFCHWINTRIN_H
-
-static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_m_prefetch(void *__P)
-{
-  __builtin_prefetch (__P, 0, 3 /* _MM_HINT_T0 */);
-}
-
-#endif /* __PRFCHWINTRIN_H */
-#endif /* __clang__ */
-#include <intrin.h>
-#ifndef _WIN64
-#ifndef __MMX__
-#define __MMX__
-#endif
-#ifndef __3dNOW__
-#define __3dNOW__
-#endif
-#endif
-#ifndef __SSE__
-#define __SSE__
-#endif
-#ifndef __SSE2__
-#define __SSE2__
-#endif
-#ifndef __SSE3__
-#define __SSE3__
-#endif
-#elif defined(__MINGW64_VERSION_MAJOR)
-#include <intrin.h>
-#if !defined(SDL_DISABLE_ARM_NEON_H) && defined(__ARM_NEON)
-#  include <arm_neon.h>
-#endif
-#else
-/* altivec.h redefining bool causes a number of problems, see bugs 3993 and 4392, so you need to explicitly define SDL_ENABLE_ALTIVEC_H to have it included. */
-#if defined(HAVE_ALTIVEC_H) && defined(__ALTIVEC__) && !defined(__APPLE_ALTIVEC__) && defined(SDL_ENABLE_ALTIVEC_H)
-#include <altivec.h>
-#endif
-#if !defined(SDL_DISABLE_ARM_NEON_H)
-#  if defined(__ARM_NEON)
-#    include <arm_neon.h>
-#  elif defined(__WINDOWS__) || defined(__WINRT__)
-/* Visual Studio doesn't define __ARM_ARCH, but _M_ARM (if set, always 7), and _M_ARM64 (if set, always 1). */
-#    if defined(_M_ARM)
-#      include <armintr.h>
-#      include <arm_neon.h>
-#      define __ARM_NEON 1 /* Set __ARM_NEON so that it can be used elsewhere, at compile time */
-#    endif
-#    if defined (_M_ARM64)
-#      include <arm64intr.h>
-#      include <arm64_neon.h>
-#      define __ARM_NEON 1 /* Set __ARM_NEON so that it can be used elsewhere, at compile time */
-#    endif
-#  endif
-#endif
-#endif /* compiler version */
-
-#if defined(__3dNOW__) && !defined(SDL_DISABLE_MM3DNOW_H)
-#include <mm3dnow.h>
-#endif
-#if defined(HAVE_IMMINTRIN_H) && !defined(SDL_DISABLE_IMMINTRIN_H)
-#include <immintrin.h>
-#else
-#if defined(__MMX__) && !defined(SDL_DISABLE_MMINTRIN_H)
-#include <mmintrin.h>
-#endif
-#if defined(__SSE__) && !defined(SDL_DISABLE_XMMINTRIN_H)
-#include <xmmintrin.h>
-#endif
-#if defined(__SSE2__) && !defined(SDL_DISABLE_EMMINTRIN_H)
-#include <emmintrin.h>
-#endif
-#if defined(__SSE3__) && !defined(SDL_DISABLE_PMMINTRIN_H)
-#include <pmmintrin.h>
-#endif
-#endif /* HAVE_IMMINTRIN_H */
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* This is a guess for the cacheline size used for padding.
- * Most x86 processors have a 64 byte cache line.
- * The 64-bit PowerPC processors have a 128 byte cache line.
- * We'll use the larger value to be generally safe.
- */
-#define SDL_CACHELINE_SIZE  128
-
-/**
- * Get the number of CPU cores available.
- *
- * \returns the total number of logical CPU cores. On CPUs that include
- *          technologies such as hyperthreading, the number of logical cores
- *          may be more than the number of physical cores.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_GetCPUCount(void);
-
-/**
- * Determine the L1 cache line size of the CPU.
- *
- * This is useful for determining multi-threaded structure padding or SIMD
- * prefetch sizes.
- *
- * \returns the L1 cache line size of the CPU, in bytes.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_GetCPUCacheLineSize(void);
-
-/**
- * Determine whether the CPU has the RDTSC instruction.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has the RDTSC instruction or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasRDTSC(void);
-
-/**
- * Determine whether the CPU has AltiVec features.
- *
- * This always returns false on CPUs that aren't using PowerPC instruction
- * sets.
- *
- * \returns SDL_TRUE if the CPU has AltiVec features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasAltiVec(void);
-
-/**
- * Determine whether the CPU has MMX features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has MMX features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasMMX(void);
-
-/**
- * Determine whether the CPU has 3DNow! features.
- *
- * This always returns false on CPUs that aren't using AMD instruction sets.
- *
- * \returns SDL_TRUE if the CPU has 3DNow! features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_Has3DNow(void);
-
-/**
- * Determine whether the CPU has SSE features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE(void);
-
-/**
- * Determine whether the CPU has SSE2 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE2 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE2(void);
-
-/**
- * Determine whether the CPU has SSE3 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE3 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE3(void);
-
-/**
- * Determine whether the CPU has SSE4.1 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE4.1 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE41(void);
-
-/**
- * Determine whether the CPU has SSE4.2 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has SSE4.2 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSSE42(void);
-
-/**
- * Determine whether the CPU has AVX features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has AVX features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX2
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX(void);
-
-/**
- * Determine whether the CPU has AVX2 features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has AVX2 features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.4.
- *
- * \sa SDL_Has3DNow
- * \sa SDL_HasAltiVec
- * \sa SDL_HasAVX
- * \sa SDL_HasMMX
- * \sa SDL_HasRDTSC
- * \sa SDL_HasSSE
- * \sa SDL_HasSSE2
- * \sa SDL_HasSSE3
- * \sa SDL_HasSSE41
- * \sa SDL_HasSSE42
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX2(void);
-
-/**
- * Determine whether the CPU has AVX-512F (foundation) features.
- *
- * This always returns false on CPUs that aren't using Intel instruction sets.
- *
- * \returns SDL_TRUE if the CPU has AVX-512F features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.9.
- *
- * \sa SDL_HasAVX
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasAVX512F(void);
-
-/**
- * Determine whether the CPU has ARM SIMD (ARMv6) features.
- *
- * This is different from ARM NEON, which is a different instruction set.
- *
- * This always returns false on CPUs that aren't using ARM instruction sets.
- *
- * \returns SDL_TRUE if the CPU has ARM SIMD features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.12.
- *
- * \sa SDL_HasNEON
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasARMSIMD(void);
-
-/**
- * Determine whether the CPU has NEON (ARM SIMD) features.
- *
- * This always returns false on CPUs that aren't using ARM instruction sets.
- *
- * \returns SDL_TRUE if the CPU has ARM NEON features or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasNEON(void);
-
-/**
- * Get the amount of RAM configured in the system.
- *
- * \returns the amount of RAM configured in the system in MB.
- *
- * \since This function is available since SDL 2.0.1.
- */
-extern DECLSPEC int SDLCALL SDL_GetSystemRAM(void);
-
-/**
- * Report the alignment this system needs for SIMD allocations.
- *
- * This will return the minimum number of bytes to which a pointer must be
- * aligned to be compatible with SIMD instructions on the current machine. For
- * example, if the machine supports SSE only, it will return 16, but if it
- * supports AVX-512F, it'll return 64 (etc). This only reports values for
- * instruction sets SDL knows about, so if your SDL build doesn't have
- * SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and
- * not 64 for the AVX-512 instructions that exist but SDL doesn't know about.
- * Plan accordingly.
- *
- * \returns the alignment in bytes needed for available, known SIMD
- *          instructions.
- *
- * \since This function is available since SDL 2.0.10.
- */
-extern DECLSPEC size_t SDLCALL SDL_SIMDGetAlignment(void);
-
-/**
- * Allocate memory in a SIMD-friendly way.
- *
- * This will allocate a block of memory that is suitable for use with SIMD
- * instructions. Specifically, it will be properly aligned and padded for the
- * system's supported vector instructions.
- *
- * The memory returned will be padded such that it is safe to read or write an
- * incomplete vector at the end of the memory block. This can be useful so you
- * don't have to drop back to a scalar fallback at the end of your SIMD
- * processing loop to deal with the final elements without overflowing the
- * allocated buffer.
- *
- * You must free this memory with SDL_FreeSIMD(), not free() or SDL_free() or
- * delete[], etc.
- *
- * Note that SDL will only deal with SIMD instruction sets it is aware of; for
- * example, SDL 2.0.8 knows that SSE wants 16-byte vectors (SDL_HasSSE()), and
- * AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't know that AVX-512 wants
- * 64. To be clear: if you can't decide to use an instruction set with an
- * SDL_Has*() function, don't use that instruction set with memory allocated
- * through here.
- *
- * SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't
- * out of memory, but you are not allowed to dereference it (because you only
- * own zero bytes of that buffer).
- *
- * \param len The length, in bytes, of the block to allocate. The actual
- *            allocated block might be larger due to padding, etc.
- * \returns a pointer to the newly-allocated block, NULL if out of memory.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_SIMDAlignment
- * \sa SDL_SIMDRealloc
- * \sa SDL_SIMDFree
- */
-extern DECLSPEC void * SDLCALL SDL_SIMDAlloc(const size_t len);
-
-/**
- * Reallocate memory obtained from SDL_SIMDAlloc
- *
- * It is not valid to use this function on a pointer from anything but
- * SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,
- * SDL_malloc, memalign, new[], etc.
- *
- * \param mem The pointer obtained from SDL_SIMDAlloc. This function also
- *            accepts NULL, at which point this function is the same as
- *            calling SDL_SIMDAlloc with a NULL pointer.
- * \param len The length, in bytes, of the block to allocated. The actual
- *            allocated block might be larger due to padding, etc. Passing 0
- *            will return a non-NULL pointer, assuming the system isn't out of
- *            memory.
- * \returns a pointer to the newly-reallocated block, NULL if out of memory.
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_SIMDAlignment
- * \sa SDL_SIMDAlloc
- * \sa SDL_SIMDFree
- */
-extern DECLSPEC void * SDLCALL SDL_SIMDRealloc(void *mem, const size_t len);
-
-/**
- * Deallocate memory obtained from SDL_SIMDAlloc
- *
- * It is not valid to use this function on a pointer from anything but
- * SDL_SIMDAlloc() or SDL_SIMDRealloc(). It can't be used on pointers from
- * malloc, realloc, SDL_malloc, memalign, new[], etc.
- *
- * However, SDL_SIMDFree(NULL) is a legal no-op.
- *
- * The memory pointed to by `ptr` is no longer valid for access upon return,
- * and may be returned to the system or reused by a future allocation. The
- * pointer passed to this function is no longer safe to dereference once this
- * function returns, and should be discarded.
- *
- * \param ptr The pointer, returned from SDL_SIMDAlloc or SDL_SIMDRealloc, to
- *            deallocate. NULL is a legal no-op.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_SIMDAlloc
- * \sa SDL_SIMDRealloc
- */
-extern DECLSPEC void SDLCALL SDL_SIMDFree(void *ptr);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_cpuinfo_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,326 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_endian.h
- *
- *  Functions for reading and writing endian-specific values
- */
-
-#ifndef SDL_endian_h_
-#define SDL_endian_h_
-
-#include "SDL_stdinc.h"
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
-/* As of Clang 11, '_m_prefetchw' is conflicting with the winnt.h's version,
-   so we define the needed '_m_prefetch' here as a pseudo-header, until the issue is fixed. */
-#ifdef __clang__
-#ifndef __PRFCHWINTRIN_H
-#define __PRFCHWINTRIN_H
-static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_m_prefetch(void *__P)
-{
-  __builtin_prefetch (__P, 0, 3 /* _MM_HINT_T0 */);
-}
-#endif /* __PRFCHWINTRIN_H */
-#endif /* __clang__ */
-
-#include <intrin.h>
-#endif
-
-/**
- *  \name The two types of endianness
- */
-/* @{ */
-#define SDL_LIL_ENDIAN  1234
-#define SDL_BIG_ENDIAN  4321
-/* @} */
-
-#ifndef SDL_BYTEORDER           /* Not defined in SDL_config.h? */
-#ifdef __linux__
-#include <endian.h>
-#define SDL_BYTEORDER  __BYTE_ORDER
-#elif defined(__OpenBSD__)
-#include <endian.h>
-#define SDL_BYTEORDER  BYTE_ORDER
-#elif defined(__FreeBSD__) || defined(__NetBSD__)
-#include <sys/endian.h>
-#define SDL_BYTEORDER  BYTE_ORDER
-/* predefs from newer gcc and clang versions: */
-#elif defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__) && defined(__BYTE_ORDER__)
-#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#define SDL_BYTEORDER   SDL_LIL_ENDIAN
-#elif (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#define SDL_BYTEORDER   SDL_BIG_ENDIAN
-#else
-#error Unsupported endianness
-#endif /**/
-#else
-#if defined(__hppa__) || \
-    defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
-    (defined(__MIPS__) && defined(__MIPSEB__)) || \
-    defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \
-    defined(__sparc__)
-#define SDL_BYTEORDER   SDL_BIG_ENDIAN
-#else
-#define SDL_BYTEORDER   SDL_LIL_ENDIAN
-#endif
-#endif /* __linux__ */
-#endif /* !SDL_BYTEORDER */
-
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \file SDL_endian.h
- */
-
-/* various modern compilers may have builtin swap */
-#if defined(__GNUC__) || defined(__clang__)
-#   define HAS_BUILTIN_BSWAP16 (_SDL_HAS_BUILTIN(__builtin_bswap16)) || \
-        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
-#   define HAS_BUILTIN_BSWAP32 (_SDL_HAS_BUILTIN(__builtin_bswap32)) || \
-        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-#   define HAS_BUILTIN_BSWAP64 (_SDL_HAS_BUILTIN(__builtin_bswap64)) || \
-        (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-
-    /* this one is broken */
-#   define HAS_BROKEN_BSWAP (__GNUC__ == 2 && __GNUC_MINOR__ <= 95)
-#else
-#   define HAS_BUILTIN_BSWAP16 0
-#   define HAS_BUILTIN_BSWAP32 0
-#   define HAS_BUILTIN_BSWAP64 0
-#   define HAS_BROKEN_BSWAP 0
-#endif
-
-#if HAS_BUILTIN_BSWAP16
-#define SDL_Swap16(x) __builtin_bswap16(x)
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
-#pragma intrinsic(_byteswap_ushort)
-#define SDL_Swap16(x) _byteswap_ushort(x)
-#elif defined(__i386__) && !HAS_BROKEN_BSWAP
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-  __asm__("xchgb %b0,%h0": "=q"(x):"0"(x));
-    return x;
-}
-#elif defined(__x86_64__)
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-  __asm__("xchgb %b0,%h0": "=Q"(x):"0"(x));
-    return x;
-}
-#elif (defined(__powerpc__) || defined(__ppc__))
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-    int result;
-
-  __asm__("rlwimi %0,%2,8,16,23": "=&r"(result):"0"(x >> 8), "r"(x));
-    return (Uint16)result;
-}
-#elif (defined(__m68k__) && !defined(__mcoldfire__))
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-  __asm__("rorw #8,%0": "=d"(x): "0"(x):"cc");
-    return x;
-}
-#elif defined(__WATCOMC__) && defined(__386__)
-extern __inline Uint16 SDL_Swap16(Uint16);
-#pragma aux SDL_Swap16 = \
-  "xchg al, ah" \
-  parm   [ax]   \
-  modify [ax];
-#else
-SDL_FORCE_INLINE Uint16
-SDL_Swap16(Uint16 x)
-{
-    return SDL_static_cast(Uint16, ((x << 8) | (x >> 8)));
-}
-#endif
-
-#if HAS_BUILTIN_BSWAP32
-#define SDL_Swap32(x) __builtin_bswap32(x)
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
-#pragma intrinsic(_byteswap_ulong)
-#define SDL_Swap32(x) _byteswap_ulong(x)
-#elif defined(__i386__) && !HAS_BROKEN_BSWAP
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-  __asm__("bswap %0": "=r"(x):"0"(x));
-    return x;
-}
-#elif defined(__x86_64__)
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-  __asm__("bswapl %0": "=r"(x):"0"(x));
-    return x;
-}
-#elif (defined(__powerpc__) || defined(__ppc__))
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-    Uint32 result;
-
-  __asm__("rlwimi %0,%2,24,16,23": "=&r"(result): "0" (x>>24),  "r"(x));
-  __asm__("rlwimi %0,%2,8,8,15"  : "=&r"(result): "0" (result), "r"(x));
-  __asm__("rlwimi %0,%2,24,0,7"  : "=&r"(result): "0" (result), "r"(x));
-    return result;
-}
-#elif (defined(__m68k__) && !defined(__mcoldfire__))
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-  __asm__("rorw #8,%0\n\tswap %0\n\trorw #8,%0": "=d"(x): "0"(x):"cc");
-    return x;
-}
-#elif defined(__WATCOMC__) && defined(__386__)
-extern __inline Uint32 SDL_Swap32(Uint32);
-#pragma aux SDL_Swap32 = \
-  "bswap eax"  \
-  parm   [eax] \
-  modify [eax];
-#else
-SDL_FORCE_INLINE Uint32
-SDL_Swap32(Uint32 x)
-{
-    return SDL_static_cast(Uint32, ((x << 24) | ((x << 8) & 0x00FF0000) |
-                                    ((x >> 8) & 0x0000FF00) | (x >> 24)));
-}
-#endif
-
-#if HAS_BUILTIN_BSWAP64
-#define SDL_Swap64(x) __builtin_bswap64(x)
-#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
-#pragma intrinsic(_byteswap_uint64)
-#define SDL_Swap64(x) _byteswap_uint64(x)
-#elif defined(__i386__) && !HAS_BROKEN_BSWAP
-SDL_FORCE_INLINE Uint64
-SDL_Swap64(Uint64 x)
-{
-    union {
-        struct {
-            Uint32 a, b;
-        } s;
-        Uint64 u;
-    } v;
-    v.u = x;
-  __asm__("bswapl %0 ; bswapl %1 ; xchgl %0,%1"
-          : "=r"(v.s.a), "=r"(v.s.b)
-          : "0" (v.s.a),  "1"(v.s.b));
-    return v.u;
-}
-#elif defined(__x86_64__)
-SDL_FORCE_INLINE Uint64
-SDL_Swap64(Uint64 x)
-{
-  __asm__("bswapq %0": "=r"(x):"0"(x));
-    return x;
-}
-#elif defined(__WATCOMC__) && defined(__386__)
-extern __inline Uint64 SDL_Swap64(Uint64);
-#pragma aux SDL_Swap64 = \
-  "bswap eax"     \
-  "bswap edx"     \
-  "xchg eax,edx"  \
-  parm [eax edx]  \
-  modify [eax edx];
-#else
-SDL_FORCE_INLINE Uint64
-SDL_Swap64(Uint64 x)
-{
-    Uint32 hi, lo;
-
-    /* Separate into high and low 32-bit values and swap them */
-    lo = SDL_static_cast(Uint32, x & 0xFFFFFFFF);
-    x >>= 32;
-    hi = SDL_static_cast(Uint32, x & 0xFFFFFFFF);
-    x = SDL_Swap32(lo);
-    x <<= 32;
-    x |= SDL_Swap32(hi);
-    return (x);
-}
-#endif
-
-
-SDL_FORCE_INLINE float
-SDL_SwapFloat(float x)
-{
-    union {
-        float f;
-        Uint32 ui32;
-    } swapper;
-    swapper.f = x;
-    swapper.ui32 = SDL_Swap32(swapper.ui32);
-    return swapper.f;
-}
-
-/* remove extra macros */
-#undef HAS_BROKEN_BSWAP
-#undef HAS_BUILTIN_BSWAP16
-#undef HAS_BUILTIN_BSWAP32
-#undef HAS_BUILTIN_BSWAP64
-
-/**
- *  \name Swap to native
- *  Byteswap item from the specified endianness to the native endianness.
- */
-/* @{ */
-#if SDL_BYTEORDER == SDL_LIL_ENDIAN
-#define SDL_SwapLE16(X)     (X)
-#define SDL_SwapLE32(X)     (X)
-#define SDL_SwapLE64(X)     (X)
-#define SDL_SwapFloatLE(X)  (X)
-#define SDL_SwapBE16(X)     SDL_Swap16(X)
-#define SDL_SwapBE32(X)     SDL_Swap32(X)
-#define SDL_SwapBE64(X)     SDL_Swap64(X)
-#define SDL_SwapFloatBE(X)  SDL_SwapFloat(X)
-#else
-#define SDL_SwapLE16(X)     SDL_Swap16(X)
-#define SDL_SwapLE32(X)     SDL_Swap32(X)
-#define SDL_SwapLE64(X)     SDL_Swap64(X)
-#define SDL_SwapFloatLE(X)  SDL_SwapFloat(X)
-#define SDL_SwapBE16(X)     (X)
-#define SDL_SwapBE32(X)     (X)
-#define SDL_SwapBE64(X)     (X)
-#define SDL_SwapFloatBE(X)  (X)
-#endif
-/* @} *//* Swap to native */
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_endian_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,145 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_filesystem.h
- *
- *  \brief Include file for filesystem SDL API functions
- */
-
-#ifndef SDL_filesystem_h_
-#define SDL_filesystem_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Get the directory where the application was run from.
- *
- * This is not necessarily a fast call, so you should call this once near
- * startup and save the string if you need it.
- *
- * **Mac OS X and iOS Specific Functionality**: If the application is in a
- * ".app" bundle, this function returns the Resource directory (e.g.
- * MyApp.app/Contents/Resources/). This behaviour can be overridden by adding
- * a property to the Info.plist file. Adding a string key with the name
- * SDL_FILESYSTEM_BASE_DIR_TYPE with a supported value will change the
- * behaviour.
- *
- * Supported values for the SDL_FILESYSTEM_BASE_DIR_TYPE property (Given an
- * application in /Applications/SDLApp/MyApp.app):
- *
- * - `resource`: bundle resource directory (the default). For example:
- *   `/Applications/SDLApp/MyApp.app/Contents/Resources`
- * - `bundle`: the Bundle directory. For example:
- *   `/Applications/SDLApp/MyApp.app/`
- * - `parent`: the containing directory of the bundle. For example:
- *   `/Applications/SDLApp/`
- *
- * The returned path is guaranteed to end with a path separator ('\' on
- * Windows, '/' on most other platforms).
- *
- * The pointer returned is owned by the caller. Please call SDL_free() on the
- * pointer when done with it.
- *
- * \returns an absolute path in UTF-8 encoding to the application data
- *          directory. NULL will be returned on error or when the platform
- *          doesn't implement this functionality, call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.1.
- *
- * \sa SDL_GetPrefPath
- */
-extern DECLSPEC char *SDLCALL SDL_GetBasePath(void);
-
-/**
- * Get the user-and-app-specific path where files can be written.
- *
- * Get the "pref dir". This is meant to be where users can write personal
- * files (preferences and save games, etc) that are specific to your
- * application. This directory is unique per user, per application.
- *
- * This function will decide the appropriate location in the native
- * filesystem, create the directory if necessary, and return a string of the
- * absolute path to the directory in UTF-8 encoding.
- *
- * On Windows, the string might look like:
- *
- * `C:\\Users\\bob\\AppData\\Roaming\\My Company\\My Program Name\\`
- *
- * On Linux, the string might look like"
- *
- * `/home/bob/.local/share/My Program Name/`
- *
- * On Mac OS X, the string might look like:
- *
- * `/Users/bob/Library/Application Support/My Program Name/`
- *
- * You should assume the path returned by this function is the only safe place
- * to write files (and that SDL_GetBasePath(), while it might be writable, or
- * even the parent of the returned path, isn't where you should be writing
- * things).
- *
- * Both the org and app strings may become part of a directory name, so please
- * follow these rules:
- *
- * - Try to use the same org string (_including case-sensitivity_) for all
- *   your applications that use this function.
- * - Always use a unique app string for each one, and make sure it never
- *   changes for an app once you've decided on it.
- * - Unicode characters are legal, as long as it's UTF-8 encoded, but...
- * - ...only use letters, numbers, and spaces. Avoid punctuation like "Game
- *   Name 2: Bad Guy's Revenge!" ... "Game Name 2" is sufficient.
- *
- * The returned path is guaranteed to end with a path separator ('\' on
- * Windows, '/' on most other platforms).
- *
- * The pointer returned is owned by the caller. Please call SDL_free() on the
- * pointer when done with it.
- *
- * \param org the name of your organization
- * \param app the name of your application
- * \returns a UTF-8 string of the user directory in platform-dependent
- *          notation. NULL if there's a problem (creating directory failed,
- *          etc.).
- *
- * \since This function is available since SDL 2.0.1.
- *
- * \sa SDL_GetBasePath
- */
-extern DECLSPEC char *SDLCALL SDL_GetPrefPath(const char *org, const char *app);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_filesystem_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,117 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_gesture.h
- *
- *  Include file for SDL gesture event handling.
- */
-
-#ifndef SDL_gesture_h_
-#define SDL_gesture_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_video.h"
-
-#include "SDL_touch.h"
-
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef Sint64 SDL_GestureID;
-
-/* Function prototypes */
-
-/**
- * Begin recording a gesture on a specified touch device or all touch devices.
- *
- * If the parameter `touchId` is -1 (i.e., all devices), this function will
- * always return 1, regardless of whether there actually are any devices.
- *
- * \param touchId the touch device id, or -1 for all touch devices
- * \returns 1 on success or 0 if the specified device could not be found.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetTouchDevice
- */
-extern DECLSPEC int SDLCALL SDL_RecordGesture(SDL_TouchID touchId);
-
-
-/**
- * Save all currently loaded Dollar Gesture templates.
- *
- * \param dst a SDL_RWops to save to
- * \returns the number of saved templates on success or 0 on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LoadDollarTemplates
- * \sa SDL_SaveDollarTemplate
- */
-extern DECLSPEC int SDLCALL SDL_SaveAllDollarTemplates(SDL_RWops *dst);
-
-/**
- * Save a currently loaded Dollar Gesture template.
- *
- * \param gestureId a gesture id
- * \param dst a SDL_RWops to save to
- * \returns 1 on success or 0 on failure; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LoadDollarTemplates
- * \sa SDL_SaveAllDollarTemplates
- */
-extern DECLSPEC int SDLCALL SDL_SaveDollarTemplate(SDL_GestureID gestureId,SDL_RWops *dst);
-
-
-/**
- * Load Dollar Gesture templates from a file.
- *
- * \param touchId a touch id
- * \param src a SDL_RWops to load from
- * \returns the number of loaded templates on success or a negative error code
- *          (or 0) on failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SaveAllDollarTemplates
- * \sa SDL_SaveDollarTemplate
- */
-extern DECLSPEC int SDLCALL SDL_LoadDollarTemplates(SDL_TouchID touchId, SDL_RWops *src);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_gesture_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,451 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_hidapi.h
- *
- *  Header file for SDL HIDAPI functions.
- *
- *  This is an adaptation of the original HIDAPI interface by Alan Ott,
- *  and includes source code licensed under the following BSD license:
- *
-    Copyright (c) 2010, Alan Ott, Signal 11 Software
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of Signal 11 Software nor the names of its
-      contributors may be used to endorse or promote products derived from
-      this software without specific prior written permission.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-    POSSIBILITY OF SUCH DAMAGE.
- *
- * If you would like a version of SDL without this code, you can build SDL
- * with SDL_HIDAPI_DISABLED defined to 1. You might want to do this for example
- * on iOS or tvOS to avoid a dependency on the CoreBluetooth framework.
- */
-
-#ifndef SDL_hidapi_h_
-#define SDL_hidapi_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \brief  A handle representing an open HID device
- */
-struct SDL_hid_device_;
-typedef struct SDL_hid_device_ SDL_hid_device; /**< opaque hidapi structure */
-
-/** hidapi info structure */
-/**
- *  \brief  Information about a connected HID device
- */
-typedef struct SDL_hid_device_info
-{
-    /** Platform-specific device path */
-    char *path;
-    /** Device Vendor ID */
-    unsigned short vendor_id;
-    /** Device Product ID */
-    unsigned short product_id;
-    /** Serial Number */
-    wchar_t *serial_number;
-    /** Device Release Number in binary-coded decimal,
-        also known as Device Version Number */
-    unsigned short release_number;
-    /** Manufacturer String */
-    wchar_t *manufacturer_string;
-    /** Product string */
-    wchar_t *product_string;
-    /** Usage Page for this Device/Interface
-        (Windows/Mac only). */
-    unsigned short usage_page;
-    /** Usage for this Device/Interface
-        (Windows/Mac only).*/
-    unsigned short usage;
-    /** The USB interface which this logical device
-        represents.
-
-        * Valid on both Linux implementations in all cases.
-        * Valid on the Windows implementation only if the device
-          contains more than one interface. */
-    int interface_number;
-
-    /** Additional information about the USB interface.
-        Valid on libusb and Android implementations. */
-    int interface_class;
-    int interface_subclass;
-    int interface_protocol;
-
-    /** Pointer to the next device */
-    struct SDL_hid_device_info *next;
-} SDL_hid_device_info;
-
-
-/**
- * Initialize the HIDAPI library.
- *
- * This function initializes the HIDAPI library. Calling it is not strictly
- * necessary, as it will be called automatically by SDL_hid_enumerate() and
- * any of the SDL_hid_open_*() functions if it is needed. This function should
- * be called at the beginning of execution however, if there is a chance of
- * HIDAPI handles being opened by different threads simultaneously.
- *
- * Each call to this function should have a matching call to SDL_hid_exit()
- *
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_hid_exit
- */
-extern DECLSPEC int SDLCALL SDL_hid_init(void);
-
-/**
- * Finalize the HIDAPI library.
- *
- * This function frees all of the static data associated with HIDAPI. It
- * should be called at the end of execution to avoid memory leaks.
- *
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_hid_init
- */
-extern DECLSPEC int SDLCALL SDL_hid_exit(void);
-
-/**
- * Check to see if devices may have been added or removed.
- *
- * Enumerating the HID devices is an expensive operation, so you can call this
- * to see if there have been any system device changes since the last call to
- * this function. A change in the counter returned doesn't necessarily mean
- * that anything has changed, but you can call SDL_hid_enumerate() to get an
- * updated device list.
- *
- * Calling this function for the first time may cause a thread or other system
- * resource to be allocated to track device change notifications.
- *
- * \returns a change counter that is incremented with each potential device
- *          change, or 0 if device change detection isn't available.
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_hid_enumerate
- */
-extern DECLSPEC Uint32 SDLCALL SDL_hid_device_change_count(void);
-
-/**
- * Enumerate the HID Devices.
- *
- * This function returns a linked list of all the HID devices attached to the
- * system which match vendor_id and product_id. If `vendor_id` is set to 0
- * then any vendor matches. If `product_id` is set to 0 then any product
- * matches. If `vendor_id` and `product_id` are both set to 0, then all HID
- * devices will be returned.
- *
- * \param vendor_id The Vendor ID (VID) of the types of device to open.
- * \param product_id The Product ID (PID) of the types of device to open.
- * \returns a pointer to a linked list of type SDL_hid_device_info, containing
- *          information about the HID devices attached to the system, or NULL
- *          in the case of failure. Free this linked list by calling
- *          SDL_hid_free_enumeration().
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_hid_device_change_count
- */
-extern DECLSPEC SDL_hid_device_info * SDLCALL SDL_hid_enumerate(unsigned short vendor_id, unsigned short product_id);
-
-/**
- * Free an enumeration Linked List
- *
- * This function frees a linked list created by SDL_hid_enumerate().
- *
- * \param devs Pointer to a list of struct_device returned from
- *             SDL_hid_enumerate().
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC void SDLCALL SDL_hid_free_enumeration(SDL_hid_device_info *devs);
-
-/**
- * Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally
- * a serial number.
- *
- * If `serial_number` is NULL, the first device with the specified VID and PID
- * is opened.
- *
- * \param vendor_id The Vendor ID (VID) of the device to open.
- * \param product_id The Product ID (PID) of the device to open.
- * \param serial_number The Serial Number of the device to open (Optionally
- *                      NULL).
- * \returns a pointer to a SDL_hid_device object on success or NULL on
- *          failure.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC SDL_hid_device * SDLCALL SDL_hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);
-
-/**
- * Open a HID device by its path name.
- *
- * The path name be determined by calling SDL_hid_enumerate(), or a
- * platform-specific path name can be used (eg: /dev/hidraw0 on Linux).
- *
- * \param path The path name of the device to open
- * \returns a pointer to a SDL_hid_device object on success or NULL on
- *          failure.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC SDL_hid_device * SDLCALL SDL_hid_open_path(const char *path, int bExclusive /* = false */);
-
-/**
- * Write an Output report to a HID device.
- *
- * The first byte of `data` must contain the Report ID. For devices which only
- * support a single report, this must be set to 0x0. The remaining bytes
- * contain the report data. Since the Report ID is mandatory, calls to
- * SDL_hid_write() will always contain one more byte than the report contains.
- * For example, if a hid report is 16 bytes long, 17 bytes must be passed to
- * SDL_hid_write(), the Report ID (or 0x0, for devices with a single report),
- * followed by the report data (16 bytes). In this example, the length passed
- * in would be 17.
- *
- * SDL_hid_write() will send the data on the first OUT endpoint, if one
- * exists. If it does not, it will send the data through the Control Endpoint
- * (Endpoint 0).
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data The data to send, including the report number as the first
- *             byte.
- * \param length The length in bytes of the data to send.
- * \returns the actual number of bytes written and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_write(SDL_hid_device *dev, const unsigned char *data, size_t length);
-
-/**
- * Read an Input report from a HID device with timeout.
- *
- * Input reports are returned to the host through the INTERRUPT IN endpoint.
- * The first byte will contain the Report number if the device uses numbered
- * reports.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data A buffer to put the read data into.
- * \param length The number of bytes to read. For devices with multiple
- *               reports, make sure to read an extra byte for the report
- *               number.
- * \param milliseconds timeout in milliseconds or -1 for blocking wait.
- * \returns the actual number of bytes read and -1 on error. If no packet was
- *          available to be read within the timeout period, this function
- *          returns 0.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_read_timeout(SDL_hid_device *dev, unsigned char *data, size_t length, int milliseconds);
-
-/**
- * Read an Input report from a HID device.
- *
- * Input reports are returned to the host through the INTERRUPT IN endpoint.
- * The first byte will contain the Report number if the device uses numbered
- * reports.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data A buffer to put the read data into.
- * \param length The number of bytes to read. For devices with multiple
- *               reports, make sure to read an extra byte for the report
- *               number.
- * \returns the actual number of bytes read and -1 on error. If no packet was
- *          available to be read and the handle is in non-blocking mode, this
- *          function returns 0.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_read(SDL_hid_device *dev, unsigned char *data, size_t length);
-
-/**
- * Set the device handle to be non-blocking.
- *
- * In non-blocking mode calls to SDL_hid_read() will return immediately with a
- * value of 0 if there is no data to be read. In blocking mode, SDL_hid_read()
- * will wait (block) until there is data to read before returning.
- *
- * Nonblocking can be turned on and off at any time.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param nonblock enable or not the nonblocking reads - 1 to enable
- *                 nonblocking - 0 to disable nonblocking.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_set_nonblocking(SDL_hid_device *dev, int nonblock);
-
-/**
- * Send a Feature report to the device.
- *
- * Feature reports are sent over the Control endpoint as a Set_Report
- * transfer. The first byte of `data` must contain the Report ID. For devices
- * which only support a single report, this must be set to 0x0. The remaining
- * bytes contain the report data. Since the Report ID is mandatory, calls to
- * SDL_hid_send_feature_report() will always contain one more byte than the
- * report contains. For example, if a hid report is 16 bytes long, 17 bytes
- * must be passed to SDL_hid_send_feature_report(): the Report ID (or 0x0, for
- * devices which do not use numbered reports), followed by the report data (16
- * bytes). In this example, the length passed in would be 17.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data The data to send, including the report number as the first
- *             byte.
- * \param length The length in bytes of the data to send, including the report
- *               number.
- * \returns the actual number of bytes written and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_send_feature_report(SDL_hid_device *dev, const unsigned char *data, size_t length);
-
-/**
- * Get a feature report from a HID device.
- *
- * Set the first byte of `data` to the Report ID of the report to be read.
- * Make sure to allow space for this extra byte in `data`. Upon return, the
- * first byte will still contain the Report ID, and the report data will start
- * in data[1].
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param data A buffer to put the read data into, including the Report ID.
- *             Set the first byte of `data` to the Report ID of the report to
- *             be read, or set it to zero if your device does not use numbered
- *             reports.
- * \param length The number of bytes to read, including an extra byte for the
- *               report ID. The buffer can be longer than the actual report.
- * \returns the number of bytes read plus one for the report ID (which is
- *          still in the first byte), or -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_feature_report(SDL_hid_device *dev, unsigned char *data, size_t length);
-
-/**
- * Close a HID device.
- *
- * \param dev A device handle returned from SDL_hid_open().
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC void SDLCALL SDL_hid_close(SDL_hid_device *dev);
-
-/**
- * Get The Manufacturer String from a HID device.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param string A wide string buffer to put the data into.
- * \param maxlen The length of the buffer in multiples of wchar_t.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_manufacturer_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
-
-/**
- * Get The Product String from a HID device.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param string A wide string buffer to put the data into.
- * \param maxlen The length of the buffer in multiples of wchar_t.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_product_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
-
-/**
- * Get The Serial Number String from a HID device.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param string A wide string buffer to put the data into.
- * \param maxlen The length of the buffer in multiples of wchar_t.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_serial_number_string(SDL_hid_device *dev, wchar_t *string, size_t maxlen);
-
-/**
- * Get a string from a HID device, based on its string index.
- *
- * \param dev A device handle returned from SDL_hid_open().
- * \param string_index The index of the string to get.
- * \param string A wide string buffer to put the data into.
- * \param maxlen The length of the buffer in multiples of wchar_t.
- * \returns 0 on success and -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_hid_get_indexed_string(SDL_hid_device *dev, int string_index, wchar_t *string, size_t maxlen);
-
-/**
- * Start or stop a BLE scan on iOS and tvOS to pair Steam Controllers
- *
- * \param active SDL_TRUE to start the scan, SDL_FALSE to stop the scan
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC void SDLCALL SDL_hid_ble_scan(SDL_bool active);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_hidapi_h_ */
-
-/* vi: set sts=4 ts=4 sw=4 expandtab: */
@@ -1,946 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_joystick.h
- *
- *  Include file for SDL joystick event handling
- *
- * The term "device_index" identifies currently plugged in joystick devices between 0 and SDL_NumJoysticks(), with the exact joystick
- *   behind a device_index changing as joysticks are plugged and unplugged.
- *
- * The term "instance_id" is the current instantiation of a joystick device in the system, if the joystick is removed and then re-inserted
- *   then it will get a new instance_id, instance_id's are monotonically increasing identifiers of a joystick plugged in.
- *
- * The term "player_index" is the number assigned to a player on a specific
- *   controller. For XInput controllers this returns the XInput user index.
- *   Many joysticks will not be able to supply this information.
- *
- * The term JoystickGUID is a stable 128-bit identifier for a joystick device that does not change over time, it identifies class of
- *   the device (a X360 wired controller for example). This identifier is platform dependent.
- */
-
-#ifndef SDL_joystick_h_
-#define SDL_joystick_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \file SDL_joystick.h
- *
- *  In order to use these functions, SDL_Init() must have been called
- *  with the ::SDL_INIT_JOYSTICK flag.  This causes SDL to scan the system
- *  for joysticks, and load appropriate drivers.
- *
- *  If you would like to receive joystick updates while the application
- *  is in the background, you should set the following hint before calling
- *  SDL_Init(): SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS
- */
-
-/**
- * The joystick structure used to identify an SDL joystick
- */
-struct _SDL_Joystick;
-typedef struct _SDL_Joystick SDL_Joystick;
-
-/* A structure that encodes the stable unique id for a joystick device */
-typedef struct {
-    Uint8 data[16];
-} SDL_JoystickGUID;
-
-/**
- * This is a unique ID for a joystick for the time it is connected to the system,
- * and is never reused for the lifetime of the application. If the joystick is
- * disconnected and reconnected, it will get a new ID.
- *
- * The ID value starts at 0 and increments from there. The value -1 is an invalid ID.
- */
-typedef Sint32 SDL_JoystickID;
-
-typedef enum
-{
-    SDL_JOYSTICK_TYPE_UNKNOWN,
-    SDL_JOYSTICK_TYPE_GAMECONTROLLER,
-    SDL_JOYSTICK_TYPE_WHEEL,
-    SDL_JOYSTICK_TYPE_ARCADE_STICK,
-    SDL_JOYSTICK_TYPE_FLIGHT_STICK,
-    SDL_JOYSTICK_TYPE_DANCE_PAD,
-    SDL_JOYSTICK_TYPE_GUITAR,
-    SDL_JOYSTICK_TYPE_DRUM_KIT,
-    SDL_JOYSTICK_TYPE_ARCADE_PAD,
-    SDL_JOYSTICK_TYPE_THROTTLE
-} SDL_JoystickType;
-
-typedef enum
-{
-    SDL_JOYSTICK_POWER_UNKNOWN = -1,
-    SDL_JOYSTICK_POWER_EMPTY,   /* <= 5% */
-    SDL_JOYSTICK_POWER_LOW,     /* <= 20% */
-    SDL_JOYSTICK_POWER_MEDIUM,  /* <= 70% */
-    SDL_JOYSTICK_POWER_FULL,    /* <= 100% */
-    SDL_JOYSTICK_POWER_WIRED,
-    SDL_JOYSTICK_POWER_MAX
-} SDL_JoystickPowerLevel;
-
-/* Set max recognized G-force from accelerometer
-   See src/joystick/uikit/SDL_sysjoystick.m for notes on why this is needed
- */
-#define SDL_IPHONE_MAX_GFORCE 5.0
-
-
-/* Function prototypes */
-
-/**
- * Locking for multi-threaded access to the joystick API
- *
- * If you are using the joystick API or handling events from multiple threads
- * you should use these locking functions to protect access to the joysticks.
- *
- * In particular, you are guaranteed that the joystick list won't change, so
- * the API functions that take a joystick index will be valid, and joystick
- * and game controller events will not be delivered.
- *
- * \since This function is available since SDL 2.0.7.
- */
-extern DECLSPEC void SDLCALL SDL_LockJoysticks(void);
-
-
-/**
- * Unlocking for multi-threaded access to the joystick API
- *
- * If you are using the joystick API or handling events from multiple threads
- * you should use these locking functions to protect access to the joysticks.
- *
- * In particular, you are guaranteed that the joystick list won't change, so
- * the API functions that take a joystick index will be valid, and joystick
- * and game controller events will not be delivered.
- *
- * \since This function is available since SDL 2.0.7.
- */
-extern DECLSPEC void SDLCALL SDL_UnlockJoysticks(void);
-
-/**
- * Count the number of joysticks attached to the system.
- *
- * \returns the number of attached joysticks on success or a negative error
- *          code on failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickName
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC int SDLCALL SDL_NumJoysticks(void);
-
-/**
- * Get the implementation dependent name of a joystick.
- *
- * This can be called before any joysticks are opened.
- *
- * \param device_index the index of the joystick to query (the N'th joystick
- *                     on the system)
- * \returns the name of the selected joystick. If no name can be found, this
- *          function returns NULL; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickName
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC const char *SDLCALL SDL_JoystickNameForIndex(int device_index);
-
-/**
- * Get the player index of a joystick, or -1 if it's not available This can be
- * called before any joysticks are opened.
- *
- * \since This function is available since SDL 2.0.9.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickGetDevicePlayerIndex(int device_index);
-
-/**
- * Get the implementation-dependent GUID for the joystick at a given device
- * index.
- *
- * This function can be called before any joysticks are opened.
- *
- * \param device_index the index of the joystick to query (the N'th joystick
- *                     on the system
- * \returns the GUID of the selected joystick. If called on an invalid index,
- *          this function returns a zero GUID
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickGetGUID
- * \sa SDL_JoystickGetGUIDString
- */
-extern DECLSPEC SDL_JoystickGUID SDLCALL SDL_JoystickGetDeviceGUID(int device_index);
-
-/**
- * Get the USB vendor ID of a joystick, if available.
- *
- * This can be called before any joysticks are opened. If the vendor ID isn't
- * available this function returns 0.
- *
- * \param device_index the index of the joystick to query (the N'th joystick
- *                     on the system
- * \returns the USB vendor ID of the selected joystick. If called on an
- *          invalid index, this function returns zero
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetDeviceVendor(int device_index);
-
-/**
- * Get the USB product ID of a joystick, if available.
- *
- * This can be called before any joysticks are opened. If the product ID isn't
- * available this function returns 0.
- *
- * \param device_index the index of the joystick to query (the N'th joystick
- *                     on the system
- * \returns the USB product ID of the selected joystick. If called on an
- *          invalid index, this function returns zero
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetDeviceProduct(int device_index);
-
-/**
- * Get the product version of a joystick, if available.
- *
- * This can be called before any joysticks are opened. If the product version
- * isn't available this function returns 0.
- *
- * \param device_index the index of the joystick to query (the N'th joystick
- *                     on the system
- * \returns the product version of the selected joystick. If called on an
- *          invalid index, this function returns zero
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetDeviceProductVersion(int device_index);
-
-/**
- * Get the type of a joystick, if available.
- *
- * This can be called before any joysticks are opened.
- *
- * \param device_index the index of the joystick to query (the N'th joystick
- *                     on the system
- * \returns the SDL_JoystickType of the selected joystick. If called on an
- *          invalid index, this function returns `SDL_JOYSTICK_TYPE_UNKNOWN`
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC SDL_JoystickType SDLCALL SDL_JoystickGetDeviceType(int device_index);
-
-/**
- * Get the instance ID of a joystick.
- *
- * This can be called before any joysticks are opened. If the index is out of
- * range, this function will return -1.
- *
- * \param device_index the index of the joystick to query (the N'th joystick
- *                     on the system
- * \returns the instance id of the selected joystick. If called on an invalid
- *          index, this function returns zero
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC SDL_JoystickID SDLCALL SDL_JoystickGetDeviceInstanceID(int device_index);
-
-/**
- * Open a joystick for use.
- *
- * The `device_index` argument refers to the N'th joystick presently
- * recognized by SDL on the system. It is **NOT** the same as the instance ID
- * used to identify the joystick in future events. See
- * SDL_JoystickInstanceID() for more details about instance IDs.
- *
- * The joystick subsystem must be initialized before a joystick can be opened
- * for use.
- *
- * \param device_index the index of the joystick to query
- * \returns a joystick identifier or NULL if an error occurred; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickClose
- * \sa SDL_JoystickInstanceID
- */
-extern DECLSPEC SDL_Joystick *SDLCALL SDL_JoystickOpen(int device_index);
-
-/**
- * Get the SDL_Joystick associated with an instance id.
- *
- * \param instance_id the instance id to get the SDL_Joystick for
- * \returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()
- *          for more information.
- *
- * \since This function is available since SDL 2.0.4.
- */
-extern DECLSPEC SDL_Joystick *SDLCALL SDL_JoystickFromInstanceID(SDL_JoystickID instance_id);
-
-/**
- * Get the SDL_Joystick associated with a player index.
- *
- * \param player_index the player index to get the SDL_Joystick for
- * \returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()
- *          for more information.
- *
- * \since This function is available since SDL 2.0.12.
- */
-extern DECLSPEC SDL_Joystick *SDLCALL SDL_JoystickFromPlayerIndex(int player_index);
-
-/**
- * Attach a new virtual joystick.
- *
- * \returns the joystick's device index, or -1 if an error occurred.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickAttachVirtual(SDL_JoystickType type,
-                                                      int naxes,
-                                                      int nbuttons,
-                                                      int nhats);
-
-/**
- * Detach a virtual joystick.
- *
- * \param device_index a value previously returned from
- *                     SDL_JoystickAttachVirtual()
- * \returns 0 on success, or -1 if an error occurred.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickDetachVirtual(int device_index);
-
-/**
- * Query whether or not the joystick at a given device index is virtual.
- *
- * \param device_index a joystick device index.
- * \returns SDL_TRUE if the joystick is virtual, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_JoystickIsVirtual(int device_index);
-
-/**
- * Set values on an opened, virtual-joystick's axis.
- *
- * Please note that values set here will not be applied until the next call to
- * SDL_JoystickUpdate, which can either be called directly, or can be called
- * indirectly through various other SDL APIs, including, but not limited to
- * the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,
- * SDL_WaitEvent.
- *
- * \param joystick the virtual joystick on which to set state.
- * \param axis the specific axis on the virtual joystick to set.
- * \param value the new value for the specified axis.
- * \returns 0 on success, -1 on error.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualAxis(SDL_Joystick *joystick, int axis, Sint16 value);
-
-/**
- * Set values on an opened, virtual-joystick's button.
- *
- * Please note that values set here will not be applied until the next call to
- * SDL_JoystickUpdate, which can either be called directly, or can be called
- * indirectly through various other SDL APIs, including, but not limited to
- * the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,
- * SDL_WaitEvent.
- *
- * \param joystick the virtual joystick on which to set state.
- * \param button the specific button on the virtual joystick to set.
- * \param value the new value for the specified button.
- * \returns 0 on success, -1 on error.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualButton(SDL_Joystick *joystick, int button, Uint8 value);
-
-/**
- * Set values on an opened, virtual-joystick's hat.
- *
- * Please note that values set here will not be applied until the next call to
- * SDL_JoystickUpdate, which can either be called directly, or can be called
- * indirectly through various other SDL APIs, including, but not limited to
- * the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,
- * SDL_WaitEvent.
- *
- * \param joystick the virtual joystick on which to set state.
- * \param hat the specific hat on the virtual joystick to set.
- * \param value the new value for the specified hat.
- * \returns 0 on success, -1 on error.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickSetVirtualHat(SDL_Joystick *joystick, int hat, Uint8 value);
-
-/**
- * Get the implementation dependent name of a joystick.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \returns the name of the selected joystick. If no name can be found, this
- *          function returns NULL; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickNameForIndex
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC const char *SDLCALL SDL_JoystickName(SDL_Joystick *joystick);
-
-/**
- * Get the player index of an opened joystick.
- *
- * For XInput controllers this returns the XInput user index. Many joysticks
- * will not be able to supply this information.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \returns the player index, or -1 if it's not available.
- *
- * \since This function is available since SDL 2.0.9.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickGetPlayerIndex(SDL_Joystick *joystick);
-
-/**
- * Set the player index of an opened joystick.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \param player_index the player index to set.
- *
- * \since This function is available since SDL 2.0.12.
- */
-extern DECLSPEC void SDLCALL SDL_JoystickSetPlayerIndex(SDL_Joystick *joystick, int player_index);
-
-/**
- * Get the implementation-dependent GUID for the joystick.
- *
- * This function requires an open joystick.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \returns the GUID of the given joystick. If called on an invalid index,
- *          this function returns a zero GUID; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickGetDeviceGUID
- * \sa SDL_JoystickGetGUIDString
- */
-extern DECLSPEC SDL_JoystickGUID SDLCALL SDL_JoystickGetGUID(SDL_Joystick *joystick);
-
-/**
- * Get the USB vendor ID of an opened joystick, if available.
- *
- * If the vendor ID isn't available this function returns 0.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \returns the USB vendor ID of the selected joystick, or 0 if unavailable.
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetVendor(SDL_Joystick *joystick);
-
-/**
- * Get the USB product ID of an opened joystick, if available.
- *
- * If the product ID isn't available this function returns 0.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \returns the USB product ID of the selected joystick, or 0 if unavailable.
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetProduct(SDL_Joystick *joystick);
-
-/**
- * Get the product version of an opened joystick, if available.
- *
- * If the product version isn't available this function returns 0.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \returns the product version of the selected joystick, or 0 if unavailable.
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC Uint16 SDLCALL SDL_JoystickGetProductVersion(SDL_Joystick *joystick);
-
-/**
- * Get the serial number of an opened joystick, if available.
- *
- * Returns the serial number of the joystick, or NULL if it is not available.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \returns the serial number of the selected joystick, or NULL if
- *          unavailable.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC const char * SDLCALL SDL_JoystickGetSerial(SDL_Joystick *joystick);
-
-/**
- * Get the type of an opened joystick.
- *
- * \param joystick the SDL_Joystick obtained from SDL_JoystickOpen()
- * \returns the SDL_JoystickType of the selected joystick.
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC SDL_JoystickType SDLCALL SDL_JoystickGetType(SDL_Joystick *joystick);
-
-/**
- * Get an ASCII string representation for a given SDL_JoystickGUID.
- *
- * You should supply at least 33 bytes for pszGUID.
- *
- * \param guid the SDL_JoystickGUID you wish to convert to string
- * \param pszGUID buffer in which to write the ASCII string
- * \param cbGUID the size of pszGUID
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickGetDeviceGUID
- * \sa SDL_JoystickGetGUID
- * \sa SDL_JoystickGetGUIDFromString
- */
-extern DECLSPEC void SDLCALL SDL_JoystickGetGUIDString(SDL_JoystickGUID guid, char *pszGUID, int cbGUID);
-
-/**
- * Convert a GUID string into a SDL_JoystickGUID structure.
- *
- * Performs no error checking. If this function is given a string containing
- * an invalid GUID, the function will silently succeed, but the GUID generated
- * will not be useful.
- *
- * \param pchGUID string containing an ASCII representation of a GUID
- * \returns a SDL_JoystickGUID structure.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickGetGUIDString
- */
-extern DECLSPEC SDL_JoystickGUID SDLCALL SDL_JoystickGetGUIDFromString(const char *pchGUID);
-
-/**
- * Get the status of a specified joystick.
- *
- * \param joystick the joystick to query
- * \returns SDL_TRUE if the joystick has been opened, SDL_FALSE if it has not;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickClose
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_JoystickGetAttached(SDL_Joystick *joystick);
-
-/**
- * Get the instance ID of an opened joystick.
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \returns the instance ID of the specified joystick on success or a negative
- *          error code on failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC SDL_JoystickID SDLCALL SDL_JoystickInstanceID(SDL_Joystick *joystick);
-
-/**
- * Get the number of general axis controls on a joystick.
- *
- * Often, the directional pad on a game controller will either look like 4
- * separate buttons or a POV hat, and not axes, but all of this is up to the
- * device and platform.
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \returns the number of axis controls/number of axes on success or a
- *          negative error code on failure; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickGetAxis
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC int SDLCALL SDL_JoystickNumAxes(SDL_Joystick *joystick);
-
-/**
- * Get the number of trackballs on a joystick.
- *
- * Joystick trackballs have only relative motion events associated with them
- * and their state cannot be polled.
- *
- * Most joysticks do not have trackballs.
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \returns the number of trackballs on success or a negative error code on
- *          failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickGetBall
- */
-extern DECLSPEC int SDLCALL SDL_JoystickNumBalls(SDL_Joystick *joystick);
-
-/**
- * Get the number of POV hats on a joystick.
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \returns the number of POV hats on success or a negative error code on
- *          failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickGetHat
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC int SDLCALL SDL_JoystickNumHats(SDL_Joystick *joystick);
-
-/**
- * Get the number of buttons on a joystick.
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \returns the number of buttons on success or a negative error code on
- *          failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickGetButton
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC int SDLCALL SDL_JoystickNumButtons(SDL_Joystick *joystick);
-
-/**
- * Update the current state of the open joysticks.
- *
- * This is called automatically by the event loop if any joystick events are
- * enabled.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickEventState
- */
-extern DECLSPEC void SDLCALL SDL_JoystickUpdate(void);
-
-/**
- * Enable/disable joystick event polling.
- *
- * If joystick events are disabled, you must call SDL_JoystickUpdate()
- * yourself and manually check the state of the joystick when you want
- * joystick information.
- *
- * It is recommended that you leave joystick event handling enabled.
- *
- * **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.
- *
- *          If `state` is `SDL_QUERY` then the current state is returned,
- *          otherwise the new processing state is returned.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GameControllerEventState
- */
-extern DECLSPEC int SDLCALL SDL_JoystickEventState(int state);
-
-#define SDL_JOYSTICK_AXIS_MAX   32767
-#define SDL_JOYSTICK_AXIS_MIN   -32768
-
-/**
- * Get the current state of an axis control on a joystick.
- *
- * SDL makes no promises about what part of the joystick any given axis refers
- * to. Your game should have some sort of configuration UI to let users
- * specify what each axis should be bound to. Alternately, SDL's higher-level
- * Game Controller API makes a great effort to apply order to this lower-level
- * interface, so you know that a specific axis is the "left thumb stick," etc.
- *
- * The value returned by SDL_JoystickGetAxis() is a signed integer (-32768 to
- * 32767) representing the current position of the axis. It may be necessary
- * to impose certain tolerances on these values to account for jitter.
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \param axis the axis to query; the axis indices start at index 0
- * \returns a 16-bit signed integer representing the current position of the
- *          axis or 0 on failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickNumAxes
- */
-extern DECLSPEC Sint16 SDLCALL SDL_JoystickGetAxis(SDL_Joystick *joystick,
-                                                   int axis);
-
-/**
- * Get the initial state of an axis control on a joystick.
- *
- * The state is a value ranging from -32768 to 32767.
- *
- * The axis indices start at index 0.
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \param axis the axis to query; the axis indices start at index 0
- * \param state Upon return, the initial value is supplied here.
- * \return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_JoystickGetAxisInitialState(SDL_Joystick *joystick,
-                                                   int axis, Sint16 *state);
-
-/**
- *  \name Hat positions
- */
-/* @{ */
-#define SDL_HAT_CENTERED    0x00
-#define SDL_HAT_UP          0x01
-#define SDL_HAT_RIGHT       0x02
-#define SDL_HAT_DOWN        0x04
-#define SDL_HAT_LEFT        0x08
-#define SDL_HAT_RIGHTUP     (SDL_HAT_RIGHT|SDL_HAT_UP)
-#define SDL_HAT_RIGHTDOWN   (SDL_HAT_RIGHT|SDL_HAT_DOWN)
-#define SDL_HAT_LEFTUP      (SDL_HAT_LEFT|SDL_HAT_UP)
-#define SDL_HAT_LEFTDOWN    (SDL_HAT_LEFT|SDL_HAT_DOWN)
-/* @} */
-
-/**
- * Get the current state of a POV hat on a joystick.
- *
- * The returned value will be one of the following positions:
- *
- * - `SDL_HAT_CENTERED`
- * - `SDL_HAT_UP`
- * - `SDL_HAT_RIGHT`
- * - `SDL_HAT_DOWN`
- * - `SDL_HAT_LEFT`
- * - `SDL_HAT_RIGHTUP`
- * - `SDL_HAT_RIGHTDOWN`
- * - `SDL_HAT_LEFTUP`
- * - `SDL_HAT_LEFTDOWN`
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \param hat the hat index to get the state from; indices start at index 0
- * \returns the current hat position.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickNumHats
- */
-extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetHat(SDL_Joystick *joystick,
-                                                 int hat);
-
-/**
- * Get the ball axis change since the last poll.
- *
- * Trackballs can only return relative motion since the last call to
- * SDL_JoystickGetBall(), these motion deltas are placed into `dx` and `dy`.
- *
- * Most joysticks do not have trackballs.
- *
- * \param joystick the SDL_Joystick to query
- * \param ball the ball index to query; ball indices start at index 0
- * \param dx stores the difference in the x axis position since the last poll
- * \param dy stores the difference in the y axis position since the last poll
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickNumBalls
- */
-extern DECLSPEC int SDLCALL SDL_JoystickGetBall(SDL_Joystick *joystick,
-                                                int ball, int *dx, int *dy);
-
-/**
- * Get the current state of a button on a joystick.
- *
- * \param joystick an SDL_Joystick structure containing joystick information
- * \param button the button index to get the state from; indices start at
- *               index 0
- * \returns 1 if the specified button is pressed, 0 otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickNumButtons
- */
-extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetButton(SDL_Joystick *joystick,
-                                                    int button);
-
-/**
- * Start a rumble effect.
- *
- * Each call to this function cancels any previous rumble effect, and calling
- * it with 0 intensity stops any rumbling.
- *
- * \param joystick The joystick to vibrate
- * \param low_frequency_rumble The intensity of the low frequency (left)
- *                             rumble motor, from 0 to 0xFFFF
- * \param high_frequency_rumble The intensity of the high frequency (right)
- *                              rumble motor, from 0 to 0xFFFF
- * \param duration_ms The duration of the rumble effect, in milliseconds
- * \returns 0, or -1 if rumble isn't supported on this joystick
- *
- * \since This function is available since SDL 2.0.9.
- *
- * \sa SDL_JoystickHasRumble
- */
-extern DECLSPEC int SDLCALL SDL_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble, Uint32 duration_ms);
-
-/**
- * Start a rumble effect in the joystick's triggers
- *
- * Each call to this function cancels any previous trigger rumble effect, and
- * calling it with 0 intensity stops any rumbling.
- *
- * Note that this is rumbling of the _triggers_ and not the game controller as
- * a whole. This is currently only supported on Xbox One controllers. If you
- * want the (more common) whole-controller rumble, use SDL_JoystickRumble()
- * instead.
- *
- * \param joystick The joystick to vibrate
- * \param left_rumble The intensity of the left trigger rumble motor, from 0
- *                    to 0xFFFF
- * \param right_rumble The intensity of the right trigger rumble motor, from 0
- *                     to 0xFFFF
- * \param duration_ms The duration of the rumble effect, in milliseconds
- * \returns 0, or -1 if trigger rumble isn't supported on this joystick
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_JoystickHasRumbleTriggers
- */
-extern DECLSPEC int SDLCALL SDL_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble, Uint32 duration_ms);
-
-/**
- * Query whether a joystick has an LED.
- *
- * An example of a joystick LED is the light on the back of a PlayStation 4's
- * DualShock 4 controller.
- *
- * \param joystick The joystick to query
- * \return SDL_TRUE if the joystick has a modifiable LED, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_JoystickHasLED(SDL_Joystick *joystick);
-
-/**
- * Query whether a joystick has rumble support.
- *
- * \param joystick The joystick to query
- * \return SDL_TRUE if the joystick has rumble, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_JoystickRumble
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_JoystickHasRumble(SDL_Joystick *joystick);
-
-/**
- * Query whether a joystick has rumble support on triggers.
- *
- * \param joystick The joystick to query
- * \return SDL_TRUE if the joystick has trigger rumble, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.18.
- *
- * \sa SDL_JoystickRumbleTriggers
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_JoystickHasRumbleTriggers(SDL_Joystick *joystick);
-
-/**
- * Update a joystick's LED color.
- *
- * An example of a joystick LED is the light on the back of a PlayStation 4's
- * DualShock 4 controller.
- *
- * \param joystick The joystick to update
- * \param red The intensity of the red LED
- * \param green The intensity of the green LED
- * \param blue The intensity of the blue LED
- * \returns 0 on success, -1 if this joystick does not have a modifiable LED
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue);
-
-/**
- * Send a joystick specific effect packet
- *
- * \param joystick The joystick to affect
- * \param data The data to send to the joystick
- * \param size The size of the data to send to the joystick
- * \returns 0, or -1 if this joystick or driver doesn't support effect packets
- *
- * \since This function is available since SDL 2.0.16.
- */
-extern DECLSPEC int SDLCALL SDL_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size);
-
-/**
- * Close a joystick previously opened with SDL_JoystickOpen().
- *
- * \param joystick The joystick device to close
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_JoystickOpen
- */
-extern DECLSPEC void SDLCALL SDL_JoystickClose(SDL_Joystick *joystick);
-
-/**
- * Get the battery level of a joystick as SDL_JoystickPowerLevel.
- *
- * \param joystick the SDL_Joystick to query
- * \returns the current battery level as SDL_JoystickPowerLevel on success or
- *          `SDL_JOYSTICK_POWER_UNKNOWN` if it is unknown
- *
- * \since This function is available since SDL 2.0.4.
- */
-extern DECLSPEC SDL_JoystickPowerLevel SDLCALL SDL_JoystickCurrentPowerLevel(SDL_Joystick *joystick);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_joystick_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,337 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_keyboard.h
- *
- *  Include file for SDL keyboard event handling
- */
-
-#ifndef SDL_keyboard_h_
-#define SDL_keyboard_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_keycode.h"
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \brief The SDL keysym structure, used in key events.
- *
- *  \note  If you are looking for translated character input, see the ::SDL_TEXTINPUT event.
- */
-typedef struct SDL_Keysym
-{
-    SDL_Scancode scancode;      /**< SDL physical key code - see ::SDL_Scancode for details */
-    SDL_Keycode sym;            /**< SDL virtual key code - see ::SDL_Keycode for details */
-    Uint16 mod;                 /**< current key modifiers */
-    Uint32 unused;
-} SDL_Keysym;
-
-/* Function prototypes */
-
-/**
- * Query the window which currently has keyboard focus.
- *
- * \returns the window with keyboard focus.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC SDL_Window * SDLCALL SDL_GetKeyboardFocus(void);
-
-/**
- * Get a snapshot of the current state of the keyboard.
- *
- * The pointer returned is a pointer to an internal SDL array. It will be
- * valid for the whole lifetime of the application and should not be freed by
- * the caller.
- *
- * A array element with a value of 1 means that the key is pressed and a value
- * of 0 means that it is not. Indexes into this array are obtained by using
- * SDL_Scancode values.
- *
- * Use SDL_PumpEvents() to update the state array.
- *
- * This function gives you the current state after all events have been
- * processed, so if a key or button has been pressed and released before you
- * process events, then the pressed state will never show up in the
- * SDL_GetKeyboardState() calls.
- *
- * Note: This function doesn't take into account whether shift has been
- * pressed or not.
- *
- * \param numkeys if non-NULL, receives the length of the returned array
- * \returns a pointer to an array of key states.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_PumpEvents
- */
-extern DECLSPEC const Uint8 *SDLCALL SDL_GetKeyboardState(int *numkeys);
-
-/**
- * Get the current key modifier state for the keyboard.
- *
- * \returns an OR'd combination of the modifier keys for the keyboard. See
- *          SDL_Keymod for details.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyboardState
- * \sa SDL_SetModState
- */
-extern DECLSPEC SDL_Keymod SDLCALL SDL_GetModState(void);
-
-/**
- * Set the current key modifier state for the keyboard.
- *
- * The inverse of SDL_GetModState(), SDL_SetModState() allows you to impose
- * modifier key states on your application. Simply pass your desired modifier
- * states into `modstate`. This value may be a bitwise, OR'd combination of
- * SDL_Keymod values.
- *
- * This does not change the keyboard state, only the key modifier flags that
- * SDL reports.
- *
- * \param modstate the desired SDL_Keymod for the keyboard
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetModState
- */
-extern DECLSPEC void SDLCALL SDL_SetModState(SDL_Keymod modstate);
-
-/**
- * Get the key code corresponding to the given scancode according to the
- * current keyboard layout.
- *
- * See SDL_Keycode for details.
- *
- * \param scancode the desired SDL_Scancode to query
- * \returns the SDL_Keycode that corresponds to the given SDL_Scancode.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyName
- * \sa SDL_GetScancodeFromKey
- */
-extern DECLSPEC SDL_Keycode SDLCALL SDL_GetKeyFromScancode(SDL_Scancode scancode);
-
-/**
- * Get the scancode corresponding to the given key code according to the
- * current keyboard layout.
- *
- * See SDL_Scancode for details.
- *
- * \param key the desired SDL_Keycode to query
- * \returns the SDL_Scancode that corresponds to the given SDL_Keycode.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyFromScancode
- * \sa SDL_GetScancodeName
- */
-extern DECLSPEC SDL_Scancode SDLCALL SDL_GetScancodeFromKey(SDL_Keycode key);
-
-/**
- * Get a human-readable name for a scancode.
- *
- * See SDL_Scancode for details.
- *
- * **Warning**: The returned name is by design not stable across platforms,
- * e.g. the name for `SDL_SCANCODE_LGUI` is "Left GUI" under Linux but "Left
- * Windows" under Microsoft Windows, and some scancodes like
- * `SDL_SCANCODE_NONUSBACKSLASH` don't have any name at all. There are even
- * scancodes that share names, e.g. `SDL_SCANCODE_RETURN` and
- * `SDL_SCANCODE_RETURN2` (both called "Return"). This function is therefore
- * unsuitable for creating a stable cross-platform two-way mapping between
- * strings and scancodes.
- *
- * \param scancode the desired SDL_Scancode to query
- * \returns a pointer to the name for the scancode. If the scancode doesn't
- *          have a name this function returns an empty string ("").
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetScancodeFromKey
- * \sa SDL_GetScancodeFromName
- */
-extern DECLSPEC const char *SDLCALL SDL_GetScancodeName(SDL_Scancode scancode);
-
-/**
- * Get a scancode from a human-readable name.
- *
- * \param name the human-readable scancode name
- * \returns the SDL_Scancode, or `SDL_SCANCODE_UNKNOWN` if the name wasn't
- *          recognized; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyFromName
- * \sa SDL_GetScancodeFromKey
- * \sa SDL_GetScancodeName
- */
-extern DECLSPEC SDL_Scancode SDLCALL SDL_GetScancodeFromName(const char *name);
-
-/**
- * Get a human-readable name for a key.
- *
- * See SDL_Scancode and SDL_Keycode for details.
- *
- * \param key the desired SDL_Keycode to query
- * \returns a pointer to a UTF-8 string that stays valid at least until the
- *          next call to this function. If you need it around any longer, you
- *          must copy it. If the key doesn't have a name, this function
- *          returns an empty string ("").
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyFromName
- * \sa SDL_GetKeyFromScancode
- * \sa SDL_GetScancodeFromKey
- */
-extern DECLSPEC const char *SDLCALL SDL_GetKeyName(SDL_Keycode key);
-
-/**
- * Get a key code from a human-readable name.
- *
- * \param name the human-readable key name
- * \returns key code, or `SDLK_UNKNOWN` if the name wasn't recognized; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetKeyFromScancode
- * \sa SDL_GetKeyName
- * \sa SDL_GetScancodeFromName
- */
-extern DECLSPEC SDL_Keycode SDLCALL SDL_GetKeyFromName(const char *name);
-
-/**
- * Start accepting Unicode text input events.
- *
- * This function will start accepting Unicode text input events in the focused
- * SDL window, and start emitting SDL_TextInputEvent (SDL_TEXTINPUT) and
- * SDL_TextEditingEvent (SDL_TEXTEDITING) events. Please use this function in
- * pair with SDL_StopTextInput().
- *
- * On some platforms using this function activates the screen keyboard.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SetTextInputRect
- * \sa SDL_StopTextInput
- */
-extern DECLSPEC void SDLCALL SDL_StartTextInput(void);
-
-/**
- * Check whether or not Unicode text input events are enabled.
- *
- * \returns SDL_TRUE if text input events are enabled else SDL_FALSE.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_StartTextInput
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsTextInputActive(void);
-
-/**
- * Stop receiving any text input events.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_StartTextInput
- */
-extern DECLSPEC void SDLCALL SDL_StopTextInput(void);
-
-/**
- * Dismiss the composition window/IME without disabling the subsystem.
- *
- * \since This function is available since SDL 2.0.22.
- *
- * \sa SDL_StartTextInput
- * \sa SDL_StopTextInput
- */
-extern DECLSPEC void SDLCALL SDL_ClearComposition(void);
-
-/**
- * Returns if an IME Composite or Candidate window is currently shown.
- *
- * \since This function is available since SDL 2.0.22.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsTextInputShown(void);
-
-/**
- * Set the rectangle used to type Unicode text inputs.
- *
- * Note: If you want use system native IME window, try to set hint
- * **SDL_HINT_IME_SHOW_UI** to **1**, otherwise this function won't give you
- * any feedback.
- *
- * \param rect the SDL_Rect structure representing the rectangle to receive
- *             text (ignored if NULL)
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_StartTextInput
- */
-extern DECLSPEC void SDLCALL SDL_SetTextInputRect(SDL_Rect *rect);
-
-/**
- * Check whether the platform has screen keyboard support.
- *
- * \returns SDL_TRUE if the platform has some screen keyboard support or
- *          SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_StartTextInput
- * \sa SDL_IsScreenKeyboardShown
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasScreenKeyboardSupport(void);
-
-/**
- * Check whether the screen keyboard is shown for given window.
- *
- * \param window the window for which screen keyboard should be queried
- * \returns SDL_TRUE if screen keyboard is shown or SDL_FALSE if not.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_HasScreenKeyboardSupport
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsScreenKeyboardShown(SDL_Window *window);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_keyboard_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,353 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_keycode.h
- *
- *  Defines constants which identify keyboard keys and modifiers.
- */
-
-#ifndef SDL_keycode_h_
-#define SDL_keycode_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_scancode.h"
-
-/**
- *  \brief The SDL virtual key representation.
- *
- *  Values of this type are used to represent keyboard keys using the current
- *  layout of the keyboard.  These values include Unicode values representing
- *  the unmodified character that would be generated by pressing the key, or
- *  an SDLK_* constant for those keys that do not generate characters.
- *
- *  A special exception is the number keys at the top of the keyboard which
- *  always map to SDLK_0...SDLK_9, regardless of layout.
- */
-typedef Sint32 SDL_Keycode;
-
-#define SDLK_SCANCODE_MASK (1<<30)
-#define SDL_SCANCODE_TO_KEYCODE(X)  (X | SDLK_SCANCODE_MASK)
-
-typedef enum
-{
-    SDLK_UNKNOWN = 0,
-
-    SDLK_RETURN = '\r',
-    SDLK_ESCAPE = '\x1B',
-    SDLK_BACKSPACE = '\b',
-    SDLK_TAB = '\t',
-    SDLK_SPACE = ' ',
-    SDLK_EXCLAIM = '!',
-    SDLK_QUOTEDBL = '"',
-    SDLK_HASH = '#',
-    SDLK_PERCENT = '%',
-    SDLK_DOLLAR = '$',
-    SDLK_AMPERSAND = '&',
-    SDLK_QUOTE = '\'',
-    SDLK_LEFTPAREN = '(',
-    SDLK_RIGHTPAREN = ')',
-    SDLK_ASTERISK = '*',
-    SDLK_PLUS = '+',
-    SDLK_COMMA = ',',
-    SDLK_MINUS = '-',
-    SDLK_PERIOD = '.',
-    SDLK_SLASH = '/',
-    SDLK_0 = '0',
-    SDLK_1 = '1',
-    SDLK_2 = '2',
-    SDLK_3 = '3',
-    SDLK_4 = '4',
-    SDLK_5 = '5',
-    SDLK_6 = '6',
-    SDLK_7 = '7',
-    SDLK_8 = '8',
-    SDLK_9 = '9',
-    SDLK_COLON = ':',
-    SDLK_SEMICOLON = ';',
-    SDLK_LESS = '<',
-    SDLK_EQUALS = '=',
-    SDLK_GREATER = '>',
-    SDLK_QUESTION = '?',
-    SDLK_AT = '@',
-
-    /*
-       Skip uppercase letters
-     */
-
-    SDLK_LEFTBRACKET = '[',
-    SDLK_BACKSLASH = '\\',
-    SDLK_RIGHTBRACKET = ']',
-    SDLK_CARET = '^',
-    SDLK_UNDERSCORE = '_',
-    SDLK_BACKQUOTE = '`',
-    SDLK_a = 'a',
-    SDLK_b = 'b',
-    SDLK_c = 'c',
-    SDLK_d = 'd',
-    SDLK_e = 'e',
-    SDLK_f = 'f',
-    SDLK_g = 'g',
-    SDLK_h = 'h',
-    SDLK_i = 'i',
-    SDLK_j = 'j',
-    SDLK_k = 'k',
-    SDLK_l = 'l',
-    SDLK_m = 'm',
-    SDLK_n = 'n',
-    SDLK_o = 'o',
-    SDLK_p = 'p',
-    SDLK_q = 'q',
-    SDLK_r = 'r',
-    SDLK_s = 's',
-    SDLK_t = 't',
-    SDLK_u = 'u',
-    SDLK_v = 'v',
-    SDLK_w = 'w',
-    SDLK_x = 'x',
-    SDLK_y = 'y',
-    SDLK_z = 'z',
-
-    SDLK_CAPSLOCK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CAPSLOCK),
-
-    SDLK_F1 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F1),
-    SDLK_F2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F2),
-    SDLK_F3 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F3),
-    SDLK_F4 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F4),
-    SDLK_F5 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F5),
-    SDLK_F6 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F6),
-    SDLK_F7 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F7),
-    SDLK_F8 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F8),
-    SDLK_F9 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F9),
-    SDLK_F10 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F10),
-    SDLK_F11 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F11),
-    SDLK_F12 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F12),
-
-    SDLK_PRINTSCREEN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PRINTSCREEN),
-    SDLK_SCROLLLOCK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SCROLLLOCK),
-    SDLK_PAUSE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAUSE),
-    SDLK_INSERT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_INSERT),
-    SDLK_HOME = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_HOME),
-    SDLK_PAGEUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAGEUP),
-    SDLK_DELETE = '\x7F',
-    SDLK_END = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_END),
-    SDLK_PAGEDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PAGEDOWN),
-    SDLK_RIGHT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RIGHT),
-    SDLK_LEFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LEFT),
-    SDLK_DOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DOWN),
-    SDLK_UP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_UP),
-
-    SDLK_NUMLOCKCLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_NUMLOCKCLEAR),
-    SDLK_KP_DIVIDE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DIVIDE),
-    SDLK_KP_MULTIPLY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MULTIPLY),
-    SDLK_KP_MINUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MINUS),
-    SDLK_KP_PLUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PLUS),
-    SDLK_KP_ENTER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_ENTER),
-    SDLK_KP_1 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_1),
-    SDLK_KP_2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_2),
-    SDLK_KP_3 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_3),
-    SDLK_KP_4 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_4),
-    SDLK_KP_5 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_5),
-    SDLK_KP_6 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_6),
-    SDLK_KP_7 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_7),
-    SDLK_KP_8 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_8),
-    SDLK_KP_9 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_9),
-    SDLK_KP_0 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_0),
-    SDLK_KP_PERIOD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PERIOD),
-
-    SDLK_APPLICATION = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_APPLICATION),
-    SDLK_POWER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_POWER),
-    SDLK_KP_EQUALS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EQUALS),
-    SDLK_F13 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F13),
-    SDLK_F14 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F14),
-    SDLK_F15 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F15),
-    SDLK_F16 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F16),
-    SDLK_F17 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F17),
-    SDLK_F18 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F18),
-    SDLK_F19 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F19),
-    SDLK_F20 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F20),
-    SDLK_F21 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F21),
-    SDLK_F22 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F22),
-    SDLK_F23 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F23),
-    SDLK_F24 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_F24),
-    SDLK_EXECUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EXECUTE),
-    SDLK_HELP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_HELP),
-    SDLK_MENU = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MENU),
-    SDLK_SELECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SELECT),
-    SDLK_STOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_STOP),
-    SDLK_AGAIN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AGAIN),
-    SDLK_UNDO = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_UNDO),
-    SDLK_CUT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CUT),
-    SDLK_COPY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_COPY),
-    SDLK_PASTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PASTE),
-    SDLK_FIND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_FIND),
-    SDLK_MUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MUTE),
-    SDLK_VOLUMEUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_VOLUMEUP),
-    SDLK_VOLUMEDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_VOLUMEDOWN),
-    SDLK_KP_COMMA = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_COMMA),
-    SDLK_KP_EQUALSAS400 =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EQUALSAS400),
-
-    SDLK_ALTERASE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_ALTERASE),
-    SDLK_SYSREQ = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SYSREQ),
-    SDLK_CANCEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CANCEL),
-    SDLK_CLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CLEAR),
-    SDLK_PRIOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_PRIOR),
-    SDLK_RETURN2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RETURN2),
-    SDLK_SEPARATOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SEPARATOR),
-    SDLK_OUT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_OUT),
-    SDLK_OPER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_OPER),
-    SDLK_CLEARAGAIN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CLEARAGAIN),
-    SDLK_CRSEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CRSEL),
-    SDLK_EXSEL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EXSEL),
-
-    SDLK_KP_00 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_00),
-    SDLK_KP_000 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_000),
-    SDLK_THOUSANDSSEPARATOR =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_THOUSANDSSEPARATOR),
-    SDLK_DECIMALSEPARATOR =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DECIMALSEPARATOR),
-    SDLK_CURRENCYUNIT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CURRENCYUNIT),
-    SDLK_CURRENCYSUBUNIT =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CURRENCYSUBUNIT),
-    SDLK_KP_LEFTPAREN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LEFTPAREN),
-    SDLK_KP_RIGHTPAREN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_RIGHTPAREN),
-    SDLK_KP_LEFTBRACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LEFTBRACE),
-    SDLK_KP_RIGHTBRACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_RIGHTBRACE),
-    SDLK_KP_TAB = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_TAB),
-    SDLK_KP_BACKSPACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_BACKSPACE),
-    SDLK_KP_A = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_A),
-    SDLK_KP_B = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_B),
-    SDLK_KP_C = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_C),
-    SDLK_KP_D = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_D),
-    SDLK_KP_E = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_E),
-    SDLK_KP_F = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_F),
-    SDLK_KP_XOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_XOR),
-    SDLK_KP_POWER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_POWER),
-    SDLK_KP_PERCENT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PERCENT),
-    SDLK_KP_LESS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_LESS),
-    SDLK_KP_GREATER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_GREATER),
-    SDLK_KP_AMPERSAND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_AMPERSAND),
-    SDLK_KP_DBLAMPERSAND =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DBLAMPERSAND),
-    SDLK_KP_VERTICALBAR =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_VERTICALBAR),
-    SDLK_KP_DBLVERTICALBAR =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DBLVERTICALBAR),
-    SDLK_KP_COLON = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_COLON),
-    SDLK_KP_HASH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_HASH),
-    SDLK_KP_SPACE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_SPACE),
-    SDLK_KP_AT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_AT),
-    SDLK_KP_EXCLAM = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_EXCLAM),
-    SDLK_KP_MEMSTORE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMSTORE),
-    SDLK_KP_MEMRECALL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMRECALL),
-    SDLK_KP_MEMCLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMCLEAR),
-    SDLK_KP_MEMADD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMADD),
-    SDLK_KP_MEMSUBTRACT =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMSUBTRACT),
-    SDLK_KP_MEMMULTIPLY =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMMULTIPLY),
-    SDLK_KP_MEMDIVIDE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_MEMDIVIDE),
-    SDLK_KP_PLUSMINUS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_PLUSMINUS),
-    SDLK_KP_CLEAR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_CLEAR),
-    SDLK_KP_CLEARENTRY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_CLEARENTRY),
-    SDLK_KP_BINARY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_BINARY),
-    SDLK_KP_OCTAL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_OCTAL),
-    SDLK_KP_DECIMAL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_DECIMAL),
-    SDLK_KP_HEXADECIMAL =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KP_HEXADECIMAL),
-
-    SDLK_LCTRL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LCTRL),
-    SDLK_LSHIFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LSHIFT),
-    SDLK_LALT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LALT),
-    SDLK_LGUI = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_LGUI),
-    SDLK_RCTRL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RCTRL),
-    SDLK_RSHIFT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RSHIFT),
-    SDLK_RALT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RALT),
-    SDLK_RGUI = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_RGUI),
-
-    SDLK_MODE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MODE),
-
-    SDLK_AUDIONEXT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIONEXT),
-    SDLK_AUDIOPREV = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOPREV),
-    SDLK_AUDIOSTOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOSTOP),
-    SDLK_AUDIOPLAY = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOPLAY),
-    SDLK_AUDIOMUTE = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOMUTE),
-    SDLK_MEDIASELECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MEDIASELECT),
-    SDLK_WWW = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_WWW),
-    SDLK_MAIL = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_MAIL),
-    SDLK_CALCULATOR = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_CALCULATOR),
-    SDLK_COMPUTER = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_COMPUTER),
-    SDLK_AC_SEARCH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_SEARCH),
-    SDLK_AC_HOME = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_HOME),
-    SDLK_AC_BACK = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_BACK),
-    SDLK_AC_FORWARD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_FORWARD),
-    SDLK_AC_STOP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_STOP),
-    SDLK_AC_REFRESH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_REFRESH),
-    SDLK_AC_BOOKMARKS = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AC_BOOKMARKS),
-
-    SDLK_BRIGHTNESSDOWN =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_BRIGHTNESSDOWN),
-    SDLK_BRIGHTNESSUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_BRIGHTNESSUP),
-    SDLK_DISPLAYSWITCH = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_DISPLAYSWITCH),
-    SDLK_KBDILLUMTOGGLE =
-        SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMTOGGLE),
-    SDLK_KBDILLUMDOWN = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMDOWN),
-    SDLK_KBDILLUMUP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_KBDILLUMUP),
-    SDLK_EJECT = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_EJECT),
-    SDLK_SLEEP = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_SLEEP),
-    SDLK_APP1 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_APP1),
-    SDLK_APP2 = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_APP2),
-
-    SDLK_AUDIOREWIND = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOREWIND),
-    SDLK_AUDIOFASTFORWARD = SDL_SCANCODE_TO_KEYCODE(SDL_SCANCODE_AUDIOFASTFORWARD)
-} SDL_KeyCode;
-
-/**
- * \brief Enumeration of valid key mods (possibly OR'd together).
- */
-typedef enum
-{
-    KMOD_NONE = 0x0000,
-    KMOD_LSHIFT = 0x0001,
-    KMOD_RSHIFT = 0x0002,
-    KMOD_LCTRL = 0x0040,
-    KMOD_RCTRL = 0x0080,
-    KMOD_LALT = 0x0100,
-    KMOD_RALT = 0x0200,
-    KMOD_LGUI = 0x0400,
-    KMOD_RGUI = 0x0800,
-    KMOD_NUM = 0x1000,
-    KMOD_CAPS = 0x2000,
-    KMOD_MODE = 0x4000,
-    KMOD_SCROLL = 0x8000,
-
-    KMOD_CTRL = KMOD_LCTRL | KMOD_RCTRL,
-    KMOD_SHIFT = KMOD_LSHIFT | KMOD_RSHIFT,
-    KMOD_ALT = KMOD_LALT | KMOD_RALT,
-    KMOD_GUI = KMOD_LGUI | KMOD_RGUI,
-
-    KMOD_RESERVED = KMOD_SCROLL /* This is for source-level compatibility with SDL 2.0.0. */
-} SDL_Keymod;
-
-#endif /* SDL_keycode_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,103 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_locale.h
- *
- *  Include file for SDL locale services
- */
-
-#ifndef _SDL_locale_h
-#define _SDL_locale_h
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-/* *INDENT-OFF* */
-extern "C" {
-/* *INDENT-ON* */
-#endif
-
-
-typedef struct SDL_Locale
-{
-    const char *language;  /**< A language name, like "en" for English. */
-    const char *country;  /**< A country, like "US" for America. Can be NULL. */
-} SDL_Locale;
-
-/**
- * Report the user's preferred locale.
- *
- * This returns an array of SDL_Locale structs, the final item zeroed out.
- * When the caller is done with this array, it should call SDL_free() on the
- * returned value; all the memory involved is allocated in a single block, so
- * a single SDL_free() will suffice.
- *
- * Returned language strings are in the format xx, where 'xx' is an ISO-639
- * language specifier (such as "en" for English, "de" for German, etc).
- * Country strings are in the format YY, where "YY" is an ISO-3166 country
- * code (such as "US" for the United States, "CA" for Canada, etc). Country
- * might be NULL if there's no specific guidance on them (so you might get {
- * "en", "US" } for American English, but { "en", NULL } means "English
- * language, generically"). Language strings are never NULL, except to
- * terminate the array.
- *
- * Please note that not all of these strings are 2 characters; some are three
- * or more.
- *
- * The returned list of locales are in the order of the user's preference. For
- * example, a German citizen that is fluent in US English and knows enough
- * Japanese to navigate around Tokyo might have a list like: { "de", "en_US",
- * "jp", NULL }. Someone from England might prefer British English (where
- * "color" is spelled "colour", etc), but will settle for anything like it: {
- * "en_GB", "en", NULL }.
- *
- * This function returns NULL on error, including when the platform does not
- * supply this information at all.
- *
- * This might be a "slow" call that has to query the operating system. It's
- * best to ask for this once and save the results. However, this list can
- * change, usually because the user has changed a system preference outside of
- * your program; SDL will send an SDL_LOCALECHANGED event in this case, if
- * possible, and you can call this function again to get an updated copy of
- * preferred locales.
- *
- * \return array of locales, terminated with a locale with a NULL language
- *         field. Will return NULL on error.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC SDL_Locale * SDLCALL SDL_GetPreferredLocales(void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-/* *INDENT-OFF* */
-}
-/* *INDENT-ON* */
-#endif
-#include "close_code.h"
-
-#endif /* _SDL_locale_h */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,235 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_main_h_
-#define SDL_main_h_
-
-#include "SDL_stdinc.h"
-
-/**
- *  \file SDL_main.h
- *
- *  Redefine main() on some platforms so that it is called by SDL.
- */
-
-#ifndef SDL_MAIN_HANDLED
-#if defined(__WIN32__)
-/* On Windows SDL provides WinMain(), which parses the command line and passes
-   the arguments to your main function.
-
-   If you provide your own WinMain(), you may define SDL_MAIN_HANDLED
- */
-#define SDL_MAIN_AVAILABLE
-
-#elif defined(__WINRT__)
-/* On WinRT, SDL provides a main function that initializes CoreApplication,
-   creating an instance of IFrameworkView in the process.
-
-   Please note that #include'ing SDL_main.h is not enough to get a main()
-   function working.  In non-XAML apps, the file,
-   src/main/winrt/SDL_WinRT_main_NonXAML.cpp, or a copy of it, must be compiled
-   into the app itself.  In XAML apps, the function, SDL_WinRTRunApp must be
-   called, with a pointer to the Direct3D-hosted XAML control passed in.
-*/
-#define SDL_MAIN_NEEDED
-
-#elif defined(__IPHONEOS__)
-/* On iOS SDL provides a main function that creates an application delegate
-   and starts the iOS application run loop.
-
-   If you link with SDL dynamically on iOS, the main function can't be in a
-   shared library, so you need to link with libSDLmain.a, which includes a
-   stub main function that calls into the shared library to start execution.
-
-   See src/video/uikit/SDL_uikitappdelegate.m for more details.
- */
-#define SDL_MAIN_NEEDED
-
-#elif defined(__ANDROID__)
-/* On Android SDL provides a Java class in SDLActivity.java that is the
-   main activity entry point.
-
-   See docs/README-android.md for more details on extending that class.
- */
-#define SDL_MAIN_NEEDED
-
-/* We need to export SDL_main so it can be launched from Java */
-#define SDLMAIN_DECLSPEC    DECLSPEC
-
-#elif defined(__NACL__)
-/* On NACL we use ppapi_simple to set up the application helper code,
-   then wait for the first PSE_INSTANCE_DIDCHANGEVIEW event before 
-   starting the user main function.
-   All user code is run in a separate thread by ppapi_simple, thus 
-   allowing for blocking io to take place via nacl_io
-*/
-#define SDL_MAIN_NEEDED
-
-#elif defined(__PSP__)
-/* On PSP SDL provides a main function that sets the module info,
-   activates the GPU and starts the thread required to be able to exit
-   the software.
-
-   If you provide this yourself, you may define SDL_MAIN_HANDLED
- */
-#define SDL_MAIN_AVAILABLE
-
-#endif
-#endif /* SDL_MAIN_HANDLED */
-
-#ifndef SDLMAIN_DECLSPEC
-#define SDLMAIN_DECLSPEC
-#endif
-
-/**
- *  \file SDL_main.h
- *
- *  The application's main() function must be called with C linkage,
- *  and should be declared like this:
- *  \code
- *  #ifdef __cplusplus
- *  extern "C"
- *  #endif
- *  int main(int argc, char *argv[])
- *  {
- *  }
- *  \endcode
- */
-
-#if defined(SDL_MAIN_NEEDED) || defined(SDL_MAIN_AVAILABLE)
-#define main    SDL_main
-#endif
-
-#include "begin_code.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  The prototype for the application's main() function
- */
-typedef int (*SDL_main_func)(int argc, char *argv[]);
-extern SDLMAIN_DECLSPEC int SDL_main(int argc, char *argv[]);
-
-
-/**
- * Circumvent failure of SDL_Init() when not using SDL_main() as an entry
- * point.
- *
- * This function is defined in SDL_main.h, along with the preprocessor rule to
- * redefine main() as SDL_main(). Thus to ensure that your main() function
- * will not be changed it is necessary to define SDL_MAIN_HANDLED before
- * including SDL.h.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_Init
- */
-extern DECLSPEC void SDLCALL SDL_SetMainReady(void);
-
-#ifdef __WIN32__
-
-/**
- * Register a win32 window class for SDL's use.
- *
- * This can be called to set the application window class at startup. It is
- * safe to call this multiple times, as long as every call is eventually
- * paired with a call to SDL_UnregisterApp, but a second registration attempt
- * while a previous registration is still active will be ignored, other than
- * to increment a counter.
- *
- * Most applications do not need to, and should not, call this directly; SDL
- * will call it when initializing the video subsystem.
- *
- * \param name the window class name, in UTF-8 encoding. If NULL, SDL
- *             currently uses "SDL_app" but this isn't guaranteed.
- * \param style the value to use in WNDCLASSEX::style. If `name` is NULL, SDL
- *              currently uses `(CS_BYTEALIGNCLIENT | CS_OWNDC)` regardless of
- *              what is specified here.
- * \param hInst the HINSTANCE to use in WNDCLASSEX::hInstance. If zero, SDL
- *              will use `GetModuleHandle(NULL)` instead.
- * \returns 0 on success, -1 on error. SDL_GetError() may have details.
- *
- * \since This function is available since SDL 2.0.2.
- */
-extern DECLSPEC int SDLCALL SDL_RegisterApp(const char *name, Uint32 style, void *hInst);
-
-/**
- * Deregister the win32 window class from an SDL_RegisterApp call.
- *
- * This can be called to undo the effects of SDL_RegisterApp.
- *
- * Most applications do not need to, and should not, call this directly; SDL
- * will call it when deinitializing the video subsystem.
- *
- * It is safe to call this multiple times, as long as every call is eventually
- * paired with a prior call to SDL_RegisterApp. The window class will only be
- * deregistered when the registration counter in SDL_RegisterApp decrements to
- * zero through calls to this function.
- *
- * \since This function is available since SDL 2.0.2.
- */
-extern DECLSPEC void SDLCALL SDL_UnregisterApp(void);
-
-#endif /* __WIN32__ */
-
-
-#ifdef __WINRT__
-
-/**
- * Initialize and launch an SDL/WinRT application.
- *
- * \param mainFunction the SDL app's C-style main(), an SDL_main_func
- * \param reserved reserved for future use; should be NULL
- * \returns 0 on success or -1 on failure; call SDL_GetError() to retrieve
- *          more information on the failure.
- *
- * \since This function is available since SDL 2.0.3.
- */
-extern DECLSPEC int SDLCALL SDL_WinRTRunApp(SDL_main_func mainFunction, void * reserved);
-
-#endif /* __WINRT__ */
-
-#if defined(__IPHONEOS__)
-
-/**
- * Initializes and launches an SDL application.
- *
- * \param argc The argc parameter from the application's main() function
- * \param argv The argv parameter from the application's main() function
- * \param mainFunction The SDL app's C-style main(), an SDL_main_func
- * \return the return value from mainFunction
- *
- * \since This function is available since SDL 2.0.10.
- */
-extern DECLSPEC int SDLCALL SDL_UIKitRunApp(int argc, char *argv[], SDL_main_func mainFunction);
-
-#endif /* __IPHONEOS__ */
-
-
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_main_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,113 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_metal.h
- *
- *  Header file for functions to creating Metal layers and views on SDL windows.
- */
-
-#ifndef SDL_metal_h_
-#define SDL_metal_h_
-
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \brief A handle to a CAMetalLayer-backed NSView (macOS) or UIView (iOS/tvOS).
- *
- *  \note This can be cast directly to an NSView or UIView.
- */
-typedef void *SDL_MetalView;
-
-/**
- *  \name Metal support functions
- */
-/* @{ */
-
-/**
- * Create a CAMetalLayer-backed NSView/UIView and attach it to the specified
- * window.
- *
- * On macOS, this does *not* associate a MTLDevice with the CAMetalLayer on
- * its own. It is up to user code to do that.
- *
- * The returned handle can be casted directly to a NSView or UIView. To access
- * the backing CAMetalLayer, call SDL_Metal_GetLayer().
- *
- * \since This function is available since SDL 2.0.12.
- *
- * \sa SDL_Metal_DestroyView
- * \sa SDL_Metal_GetLayer
- */
-extern DECLSPEC SDL_MetalView SDLCALL SDL_Metal_CreateView(SDL_Window * window);
-
-/**
- * Destroy an existing SDL_MetalView object.
- *
- * This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was
- * called after SDL_CreateWindow.
- *
- * \since This function is available since SDL 2.0.12.
- *
- * \sa SDL_Metal_CreateView
- */
-extern DECLSPEC void SDLCALL SDL_Metal_DestroyView(SDL_MetalView view);
-
-/**
- * Get a pointer to the backing CAMetalLayer for the given view.
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_MetalCreateView
- */
-extern DECLSPEC void *SDLCALL SDL_Metal_GetLayer(SDL_MetalView view);
-
-/**
- * Get the size of a window's underlying drawable in pixels (for use with
- * setting viewport, scissor & etc).
- *
- * \param window SDL_Window from which the drawable size should be queried
- * \param w Pointer to variable for storing the width in pixels, may be NULL
- * \param h Pointer to variable for storing the height in pixels, may be NULL
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_GetWindowSize
- * \sa SDL_CreateWindow
- */
-extern DECLSPEC void SDLCALL SDL_Metal_GetDrawableSize(SDL_Window* window, int *w,
-                                                       int *h);
-
-/* @} *//* Metal support functions */
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_metal_h_ */
@@ -1,79 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_misc.h
- *
- *  \brief Include file for SDL API functions that don't fit elsewhere.
- */
-
-#ifndef SDL_misc_h_
-#define SDL_misc_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Open a URL/URI in the browser or other appropriate external application.
- *
- * Open a URL in a separate, system-provided application. How this works will
- * vary wildly depending on the platform. This will likely launch what makes
- * sense to handle a specific URL's protocol (a web browser for `http://`,
- * etc), but it might also be able to launch file managers for directories and
- * other things.
- *
- * What happens when you open a URL varies wildly as well: your game window
- * may lose focus (and may or may not lose focus if your game was fullscreen
- * or grabbing input at the time). On mobile devices, your app will likely
- * move to the background or your process might be paused. Any given platform
- * may or may not handle a given URL.
- *
- * If this is unimplemented (or simply unavailable) for a platform, this will
- * fail with an error. A successful result does not mean the URL loaded, just
- * that we launched _something_ to handle it (or at least believe we did).
- *
- * All this to say: this function can be useful, but you should definitely
- * test it on every platform you target.
- *
- * \param url A valid URL/URI to open. Use `file:///full/path/to/file` for
- *            local files, if supported.
- * \returns 0 on success, or -1 on error; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC int SDLCALL SDL_OpenURL(const char *url);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_misc_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,454 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_mouse.h
- *
- *  Include file for SDL mouse event handling.
- */
-
-#ifndef SDL_mouse_h_
-#define SDL_mouse_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct SDL_Cursor SDL_Cursor;   /**< Implementation dependent */
-
-/**
- * \brief Cursor types for SDL_CreateSystemCursor().
- */
-typedef enum
-{
-    SDL_SYSTEM_CURSOR_ARROW,     /**< Arrow */
-    SDL_SYSTEM_CURSOR_IBEAM,     /**< I-beam */
-    SDL_SYSTEM_CURSOR_WAIT,      /**< Wait */
-    SDL_SYSTEM_CURSOR_CROSSHAIR, /**< Crosshair */
-    SDL_SYSTEM_CURSOR_WAITARROW, /**< Small wait cursor (or Wait if not available) */
-    SDL_SYSTEM_CURSOR_SIZENWSE,  /**< Double arrow pointing northwest and southeast */
-    SDL_SYSTEM_CURSOR_SIZENESW,  /**< Double arrow pointing northeast and southwest */
-    SDL_SYSTEM_CURSOR_SIZEWE,    /**< Double arrow pointing west and east */
-    SDL_SYSTEM_CURSOR_SIZENS,    /**< Double arrow pointing north and south */
-    SDL_SYSTEM_CURSOR_SIZEALL,   /**< Four pointed arrow pointing north, south, east, and west */
-    SDL_SYSTEM_CURSOR_NO,        /**< Slashed circle or crossbones */
-    SDL_SYSTEM_CURSOR_HAND,      /**< Hand */
-    SDL_NUM_SYSTEM_CURSORS
-} SDL_SystemCursor;
-
-/**
- * \brief Scroll direction types for the Scroll event
- */
-typedef enum
-{
-    SDL_MOUSEWHEEL_NORMAL,    /**< The scroll direction is normal */
-    SDL_MOUSEWHEEL_FLIPPED    /**< The scroll direction is flipped / natural */
-} SDL_MouseWheelDirection;
-
-/* Function prototypes */
-
-/**
- * Get the window which currently has mouse focus.
- *
- * \returns the window with mouse focus.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC SDL_Window * SDLCALL SDL_GetMouseFocus(void);
-
-/**
- * Retrieve the current state of the mouse.
- *
- * The current button state is returned as a button bitmask, which can be
- * tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the
- * left, 2 for middle, 3 for the right button), and `x` and `y` are set to the
- * mouse cursor position relative to the focus window. You can pass NULL for
- * either `x` or `y`.
- *
- * \param x the x coordinate of the mouse cursor position relative to the
- *          focus window
- * \param y the y coordinate of the mouse cursor position relative to the
- *          focus window
- * \returns a 32-bit button bitmask of the current button state.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetGlobalMouseState
- * \sa SDL_GetRelativeMouseState
- * \sa SDL_PumpEvents
- */
-extern DECLSPEC Uint32 SDLCALL SDL_GetMouseState(int *x, int *y);
-
-/**
- * Get the current state of the mouse in relation to the desktop.
- *
- * This works similarly to SDL_GetMouseState(), but the coordinates will be
- * reported relative to the top-left of the desktop. This can be useful if you
- * need to track the mouse outside of a specific window and SDL_CaptureMouse()
- * doesn't fit your needs. For example, it could be useful if you need to
- * track the mouse while dragging a window, where coordinates relative to a
- * window might not be in sync at all times.
- *
- * Note: SDL_GetMouseState() returns the mouse position as SDL understands it
- * from the last pump of the event queue. This function, however, queries the
- * OS for the current mouse position, and as such, might be a slightly less
- * efficient function. Unless you know what you're doing and have a good
- * reason to use this function, you probably want SDL_GetMouseState() instead.
- *
- * \param x filled in with the current X coord relative to the desktop; can be
- *          NULL
- * \param y filled in with the current Y coord relative to the desktop; can be
- *          NULL
- * \returns the current button state as a bitmask which can be tested using
- *          the SDL_BUTTON(X) macros.
- *
- * \since This function is available since SDL 2.0.4.
- *
- * \sa SDL_CaptureMouse
- */
-extern DECLSPEC Uint32 SDLCALL SDL_GetGlobalMouseState(int *x, int *y);
-
-/**
- * Retrieve the relative state of the mouse.
- *
- * The current button state is returned as a button bitmask, which can be
- * tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the
- * left, 2 for middle, 3 for the right button), and `x` and `y` are set to the
- * mouse deltas since the last call to SDL_GetRelativeMouseState() or since
- * event initialization. You can pass NULL for either `x` or `y`.
- *
- * \param x a pointer filled with the last recorded x coordinate of the mouse
- * \param y a pointer filled with the last recorded y coordinate of the mouse
- * \returns a 32-bit button bitmask of the relative button state.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetMouseState
- */
-extern DECLSPEC Uint32 SDLCALL SDL_GetRelativeMouseState(int *x, int *y);
-
-/**
- * Move the mouse cursor to the given position within the window.
- *
- * This function generates a mouse motion event.
- *
- * Note that this function will appear to succeed, but not actually move the
- * mouse when used over Microsoft Remote Desktop.
- *
- * \param window the window to move the mouse into, or NULL for the current
- *               mouse focus
- * \param x the x coordinate within the window
- * \param y the y coordinate within the window
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WarpMouseGlobal
- */
-extern DECLSPEC void SDLCALL SDL_WarpMouseInWindow(SDL_Window * window,
-                                                   int x, int y);
-
-/**
- * Move the mouse to the given position in global screen space.
- *
- * This function generates a mouse motion event.
- *
- * A failure of this function usually means that it is unsupported by a
- * platform.
- *
- * Note that this function will appear to succeed, but not actually move the
- * mouse when used over Microsoft Remote Desktop.
- *
- * \param x the x coordinate
- * \param y the y coordinate
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.4.
- *
- * \sa SDL_WarpMouseInWindow
- */
-extern DECLSPEC int SDLCALL SDL_WarpMouseGlobal(int x, int y);
-
-/**
- * Set relative mouse mode.
- *
- * While the mouse is in relative mode, the cursor is hidden, and the driver
- * will try to report continuous motion in the current window. Only relative
- * motion events will be delivered, the mouse position will not change.
- *
- * Note that this function will not be able to provide continuous relative
- * motion when used over Microsoft Remote Desktop, instead motion is limited
- * to the bounds of the screen.
- *
- * This function will flush any pending mouse motion.
- *
- * \param enabled SDL_TRUE to enable relative mode, SDL_FALSE to disable.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- *          If relative mode is not supported, this returns -1.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetRelativeMouseMode
- */
-extern DECLSPEC int SDLCALL SDL_SetRelativeMouseMode(SDL_bool enabled);
-
-/**
- * Capture the mouse and to track input outside an SDL window.
- *
- * Capturing enables your app to obtain mouse events globally, instead of just
- * within your window. Not all video targets support this function. When
- * capturing is enabled, the current window will get all mouse events, but
- * unlike relative mode, no change is made to the cursor and it is not
- * restrained to your window.
- *
- * This function may also deny mouse input to other windows--both those in
- * your application and others on the system--so you should use this function
- * sparingly, and in small bursts. For example, you might want to track the
- * mouse while the user is dragging something, until the user releases a mouse
- * button. It is not recommended that you capture the mouse for long periods
- * of time, such as the entire time your app is running. For that, you should
- * probably use SDL_SetRelativeMouseMode() or SDL_SetWindowGrab(), depending
- * on your goals.
- *
- * While captured, mouse events still report coordinates relative to the
- * current (foreground) window, but those coordinates may be outside the
- * bounds of the window (including negative values). Capturing is only allowed
- * for the foreground window. If the window loses focus while capturing, the
- * capture will be disabled automatically.
- *
- * While capturing is enabled, the current window will have the
- * `SDL_WINDOW_MOUSE_CAPTURE` flag set.
- *
- * \param enabled SDL_TRUE to enable capturing, SDL_FALSE to disable.
- * \returns 0 on success or -1 if not supported; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.4.
- *
- * \sa SDL_GetGlobalMouseState
- */
-extern DECLSPEC int SDLCALL SDL_CaptureMouse(SDL_bool enabled);
-
-/**
- * Query whether relative mouse mode is enabled.
- *
- * \returns SDL_TRUE if relative mode is enabled or SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SetRelativeMouseMode
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_GetRelativeMouseMode(void);
-
-/**
- * Create a cursor using the specified bitmap data and mask (in MSB format).
- *
- * `mask` has to be in MSB (Most Significant Bit) format.
- *
- * The cursor width (`w`) must be a multiple of 8 bits.
- *
- * The cursor is created in black and white according to the following:
- *
- * - data=0, mask=1: white
- * - data=1, mask=1: black
- * - data=0, mask=0: transparent
- * - data=1, mask=0: inverted color if possible, black if not.
- *
- * Cursors created with this function must be freed with SDL_FreeCursor().
- *
- * If you want to have a color cursor, or create your cursor from an
- * SDL_Surface, you should use SDL_CreateColorCursor(). Alternately, you can
- * hide the cursor and draw your own as part of your game's rendering, but it
- * will be bound to the framerate.
- *
- * Also, since SDL 2.0.0, SDL_CreateSystemCursor() is available, which
- * provides twelve readily available system cursors to pick from.
- *
- * \param data the color value for each pixel of the cursor
- * \param mask the mask value for each pixel of the cursor
- * \param w the width of the cursor
- * \param h the height of the cursor
- * \param hot_x the X-axis location of the upper left corner of the cursor
- *              relative to the actual mouse position
- * \param hot_y the Y-axis location of the upper left corner of the cursor
- *              relative to the actual mouse position
- * \returns a new cursor with the specified parameters on success or NULL on
- *          failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_FreeCursor
- * \sa SDL_SetCursor
- * \sa SDL_ShowCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateCursor(const Uint8 * data,
-                                                     const Uint8 * mask,
-                                                     int w, int h, int hot_x,
-                                                     int hot_y);
-
-/**
- * Create a color cursor.
- *
- * \param surface an SDL_Surface structure representing the cursor image
- * \param hot_x the x position of the cursor hot spot
- * \param hot_y the y position of the cursor hot spot
- * \returns the new cursor on success or NULL on failure; call SDL_GetError()
- *          for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateCursor
- * \sa SDL_FreeCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateColorCursor(SDL_Surface *surface,
-                                                          int hot_x,
-                                                          int hot_y);
-
-/**
- * Create a system cursor.
- *
- * \param id an SDL_SystemCursor enum value
- * \returns a cursor on success or NULL on failure; call SDL_GetError() for
- *          more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_FreeCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_CreateSystemCursor(SDL_SystemCursor id);
-
-/**
- * Set the active cursor.
- *
- * This function sets the currently active cursor to the specified one. If the
- * cursor is currently visible, the change will be immediately represented on
- * the display. SDL_SetCursor(NULL) can be used to force cursor redraw, if
- * this is desired for any reason.
- *
- * \param cursor a cursor to make active
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateCursor
- * \sa SDL_GetCursor
- * \sa SDL_ShowCursor
- */
-extern DECLSPEC void SDLCALL SDL_SetCursor(SDL_Cursor * cursor);
-
-/**
- * Get the active cursor.
- *
- * This function returns a pointer to the current cursor which is owned by the
- * library. It is not necessary to free the cursor with SDL_FreeCursor().
- *
- * \returns the active cursor or NULL if there is no mouse.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SetCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_GetCursor(void);
-
-/**
- * Get the default cursor.
- *
- * \returns the default cursor on success or NULL on failure.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateSystemCursor
- */
-extern DECLSPEC SDL_Cursor *SDLCALL SDL_GetDefaultCursor(void);
-
-/**
- * Free a previously-created cursor.
- *
- * Use this function to free cursor resources created with SDL_CreateCursor(),
- * SDL_CreateColorCursor() or SDL_CreateSystemCursor().
- *
- * \param cursor the cursor to free
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateColorCursor
- * \sa SDL_CreateCursor
- * \sa SDL_CreateSystemCursor
- */
-extern DECLSPEC void SDLCALL SDL_FreeCursor(SDL_Cursor * cursor);
-
-/**
- * Toggle whether or not the cursor is shown.
- *
- * The cursor starts off displayed but can be turned off. Passing `SDL_ENABLE`
- * displays the cursor and passing `SDL_DISABLE` hides it.
- *
- * The current state of the mouse cursor can be queried by passing
- * `SDL_QUERY`; either `SDL_DISABLE` or `SDL_ENABLE` will be returned.
- *
- * \param toggle `SDL_ENABLE` to show the cursor, `SDL_DISABLE` to hide it,
- *               `SDL_QUERY` to query the current state without changing it.
- * \returns `SDL_ENABLE` if the cursor is shown, or `SDL_DISABLE` if the
- *          cursor is hidden, or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateCursor
- * \sa SDL_SetCursor
- */
-extern DECLSPEC int SDLCALL SDL_ShowCursor(int toggle);
-
-/**
- * Used as a mask when testing buttons in buttonstate.
- *
- * - Button 1:  Left mouse button
- * - Button 2:  Middle mouse button
- * - Button 3:  Right mouse button
- */
-#define SDL_BUTTON(X)       (1 << ((X)-1))
-#define SDL_BUTTON_LEFT     1
-#define SDL_BUTTON_MIDDLE   2
-#define SDL_BUTTON_RIGHT    3
-#define SDL_BUTTON_X1       4
-#define SDL_BUTTON_X2       5
-#define SDL_BUTTON_LMASK    SDL_BUTTON(SDL_BUTTON_LEFT)
-#define SDL_BUTTON_MMASK    SDL_BUTTON(SDL_BUTTON_MIDDLE)
-#define SDL_BUTTON_RMASK    SDL_BUTTON(SDL_BUTTON_RIGHT)
-#define SDL_BUTTON_X1MASK   SDL_BUTTON(SDL_BUTTON_X1)
-#define SDL_BUTTON_X2MASK   SDL_BUTTON(SDL_BUTTON_X2)
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_mouse_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,33 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDLname_h_
-#define SDLname_h_
-
-#if defined(__STDC__) || defined(__cplusplus)
-#define NeedFunctionPrototypes 1
-#endif
-
-#define SDL_NAME(X) SDL_##X
-
-#endif /* SDLname_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,52 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_opengles2.h
- *
- *  This is a simple file to encapsulate the OpenGL ES 2.0 API headers.
- */
-#include "SDL_config.h"
-
-#if !defined(_MSC_VER) && !defined(SDL_USE_BUILTIN_OPENGL_DEFINITIONS)
-
-#ifdef __IPHONEOS__
-#include <OpenGLES/ES2/gl.h>
-#include <OpenGLES/ES2/glext.h>
-#else
-#include <GLES2/gl2platform.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#endif
-
-#else /* _MSC_VER */
-
-/* OpenGL ES2 headers for Visual Studio */
-#include "SDL_opengles2_khrplatform.h"
-#include "SDL_opengles2_gl2platform.h"
-#include "SDL_opengles2_gl2.h"
-#include "SDL_opengles2_gl2ext.h"
-
-#endif /* _MSC_VER */
-
-#ifndef APIENTRY
-#define APIENTRY GL_APIENTRY
-#endif
@@ -1,621 +0,0 @@
-#ifndef __gl2_h_
-#define __gl2_h_
-
-/* $Revision: 20555 $ on $Date:: 2013-02-12 14:32:47 -0800 #$ */
-
-/*#include <GLES2/gl2platform.h>*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * This document is licensed under the SGI Free Software B License Version
- * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ .
- */
-
-/*-------------------------------------------------------------------------
- * Data type definitions
- *-----------------------------------------------------------------------*/
-
-typedef void             GLvoid;
-typedef char             GLchar;
-typedef unsigned int     GLenum;
-typedef unsigned char    GLboolean;
-typedef unsigned int     GLbitfield;
-typedef khronos_int8_t   GLbyte;
-typedef short            GLshort;
-typedef int              GLint;
-typedef int              GLsizei;
-typedef khronos_uint8_t  GLubyte;
-typedef unsigned short   GLushort;
-typedef unsigned int     GLuint;
-typedef khronos_float_t  GLfloat;
-typedef khronos_float_t  GLclampf;
-typedef khronos_int32_t  GLfixed;
-
-/* GL types for handling large vertex buffer objects */
-typedef khronos_intptr_t GLintptr;
-typedef khronos_ssize_t  GLsizeiptr;
-
-/* OpenGL ES core versions */
-#define GL_ES_VERSION_2_0                 1
-
-/* ClearBufferMask */
-#define GL_DEPTH_BUFFER_BIT               0x00000100
-#define GL_STENCIL_BUFFER_BIT             0x00000400
-#define GL_COLOR_BUFFER_BIT               0x00004000
-
-/* Boolean */
-#define GL_FALSE                          0
-#define GL_TRUE                           1
-
-/* BeginMode */
-#define GL_POINTS                         0x0000
-#define GL_LINES                          0x0001
-#define GL_LINE_LOOP                      0x0002
-#define GL_LINE_STRIP                     0x0003
-#define GL_TRIANGLES                      0x0004
-#define GL_TRIANGLE_STRIP                 0x0005
-#define GL_TRIANGLE_FAN                   0x0006
-
-/* AlphaFunction (not supported in ES20) */
-/*      GL_NEVER */
-/*      GL_LESS */
-/*      GL_EQUAL */
-/*      GL_LEQUAL */
-/*      GL_GREATER */
-/*      GL_NOTEQUAL */
-/*      GL_GEQUAL */
-/*      GL_ALWAYS */
-
-/* BlendingFactorDest */
-#define GL_ZERO                           0
-#define GL_ONE                            1
-#define GL_SRC_COLOR                      0x0300
-#define GL_ONE_MINUS_SRC_COLOR            0x0301
-#define GL_SRC_ALPHA                      0x0302
-#define GL_ONE_MINUS_SRC_ALPHA            0x0303
-#define GL_DST_ALPHA                      0x0304
-#define GL_ONE_MINUS_DST_ALPHA            0x0305
-
-/* BlendingFactorSrc */
-/*      GL_ZERO */
-/*      GL_ONE */
-#define GL_DST_COLOR                      0x0306
-#define GL_ONE_MINUS_DST_COLOR            0x0307
-#define GL_SRC_ALPHA_SATURATE             0x0308
-/*      GL_SRC_ALPHA */
-/*      GL_ONE_MINUS_SRC_ALPHA */
-/*      GL_DST_ALPHA */
-/*      GL_ONE_MINUS_DST_ALPHA */
-
-/* BlendEquationSeparate */
-#define GL_FUNC_ADD                       0x8006
-#define GL_BLEND_EQUATION                 0x8009
-#define GL_BLEND_EQUATION_RGB             0x8009    /* same as BLEND_EQUATION */
-#define GL_BLEND_EQUATION_ALPHA           0x883D
-
-/* BlendSubtract */
-#define GL_FUNC_SUBTRACT                  0x800A
-#define GL_FUNC_REVERSE_SUBTRACT          0x800B
-
-/* Separate Blend Functions */
-#define GL_BLEND_DST_RGB                  0x80C8
-#define GL_BLEND_SRC_RGB                  0x80C9
-#define GL_BLEND_DST_ALPHA                0x80CA
-#define GL_BLEND_SRC_ALPHA                0x80CB
-#define GL_CONSTANT_COLOR                 0x8001
-#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
-#define GL_CONSTANT_ALPHA                 0x8003
-#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
-#define GL_BLEND_COLOR                    0x8005
-
-/* Buffer Objects */
-#define GL_ARRAY_BUFFER                   0x8892
-#define GL_ELEMENT_ARRAY_BUFFER           0x8893
-#define GL_ARRAY_BUFFER_BINDING           0x8894
-#define GL_ELEMENT_ARRAY_BUFFER_BINDING   0x8895
-
-#define GL_STREAM_DRAW                    0x88E0
-#define GL_STATIC_DRAW                    0x88E4
-#define GL_DYNAMIC_DRAW                   0x88E8
-
-#define GL_BUFFER_SIZE                    0x8764
-#define GL_BUFFER_USAGE                   0x8765
-
-#define GL_CURRENT_VERTEX_ATTRIB          0x8626
-
-/* CullFaceMode */
-#define GL_FRONT                          0x0404
-#define GL_BACK                           0x0405
-#define GL_FRONT_AND_BACK                 0x0408
-
-/* DepthFunction */
-/*      GL_NEVER */
-/*      GL_LESS */
-/*      GL_EQUAL */
-/*      GL_LEQUAL */
-/*      GL_GREATER */
-/*      GL_NOTEQUAL */
-/*      GL_GEQUAL */
-/*      GL_ALWAYS */
-
-/* EnableCap */
-#define GL_TEXTURE_2D                     0x0DE1
-#define GL_CULL_FACE                      0x0B44
-#define GL_BLEND                          0x0BE2
-#define GL_DITHER                         0x0BD0
-#define GL_STENCIL_TEST                   0x0B90
-#define GL_DEPTH_TEST                     0x0B71
-#define GL_SCISSOR_TEST                   0x0C11
-#define GL_POLYGON_OFFSET_FILL            0x8037
-#define GL_SAMPLE_ALPHA_TO_COVERAGE       0x809E
-#define GL_SAMPLE_COVERAGE                0x80A0
-
-/* ErrorCode */
-#define GL_NO_ERROR                       0
-#define GL_INVALID_ENUM                   0x0500
-#define GL_INVALID_VALUE                  0x0501
-#define GL_INVALID_OPERATION              0x0502
-#define GL_OUT_OF_MEMORY                  0x0505
-
-/* FrontFaceDirection */
-#define GL_CW                             0x0900
-#define GL_CCW                            0x0901
-
-/* GetPName */
-#define GL_LINE_WIDTH                     0x0B21
-#define GL_ALIASED_POINT_SIZE_RANGE       0x846D
-#define GL_ALIASED_LINE_WIDTH_RANGE       0x846E
-#define GL_CULL_FACE_MODE                 0x0B45
-#define GL_FRONT_FACE                     0x0B46
-#define GL_DEPTH_RANGE                    0x0B70
-#define GL_DEPTH_WRITEMASK                0x0B72
-#define GL_DEPTH_CLEAR_VALUE              0x0B73
-#define GL_DEPTH_FUNC                     0x0B74
-#define GL_STENCIL_CLEAR_VALUE            0x0B91
-#define GL_STENCIL_FUNC                   0x0B92
-#define GL_STENCIL_FAIL                   0x0B94
-#define GL_STENCIL_PASS_DEPTH_FAIL        0x0B95
-#define GL_STENCIL_PASS_DEPTH_PASS        0x0B96
-#define GL_STENCIL_REF                    0x0B97
-#define GL_STENCIL_VALUE_MASK             0x0B93
-#define GL_STENCIL_WRITEMASK              0x0B98
-#define GL_STENCIL_BACK_FUNC              0x8800
-#define GL_STENCIL_BACK_FAIL              0x8801
-#define GL_STENCIL_BACK_PASS_DEPTH_FAIL   0x8802
-#define GL_STENCIL_BACK_PASS_DEPTH_PASS   0x8803
-#define GL_STENCIL_BACK_REF               0x8CA3
-#define GL_STENCIL_BACK_VALUE_MASK        0x8CA4
-#define GL_STENCIL_BACK_WRITEMASK         0x8CA5
-#define GL_VIEWPORT                       0x0BA2
-#define GL_SCISSOR_BOX                    0x0C10
-/*      GL_SCISSOR_TEST */
-#define GL_COLOR_CLEAR_VALUE              0x0C22
-#define GL_COLOR_WRITEMASK                0x0C23
-#define GL_UNPACK_ALIGNMENT               0x0CF5
-#define GL_PACK_ALIGNMENT                 0x0D05
-#define GL_MAX_TEXTURE_SIZE               0x0D33
-#define GL_MAX_VIEWPORT_DIMS              0x0D3A
-#define GL_SUBPIXEL_BITS                  0x0D50
-#define GL_RED_BITS                       0x0D52
-#define GL_GREEN_BITS                     0x0D53
-#define GL_BLUE_BITS                      0x0D54
-#define GL_ALPHA_BITS                     0x0D55
-#define GL_DEPTH_BITS                     0x0D56
-#define GL_STENCIL_BITS                   0x0D57
-#define GL_POLYGON_OFFSET_UNITS           0x2A00
-/*      GL_POLYGON_OFFSET_FILL */
-#define GL_POLYGON_OFFSET_FACTOR          0x8038
-#define GL_TEXTURE_BINDING_2D             0x8069
-#define GL_SAMPLE_BUFFERS                 0x80A8
-#define GL_SAMPLES                        0x80A9
-#define GL_SAMPLE_COVERAGE_VALUE          0x80AA
-#define GL_SAMPLE_COVERAGE_INVERT         0x80AB
-
-/* GetTextureParameter */
-/*      GL_TEXTURE_MAG_FILTER */
-/*      GL_TEXTURE_MIN_FILTER */
-/*      GL_TEXTURE_WRAP_S */
-/*      GL_TEXTURE_WRAP_T */
-
-#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
-#define GL_COMPRESSED_TEXTURE_FORMATS     0x86A3
-
-/* HintMode */
-#define GL_DONT_CARE                      0x1100
-#define GL_FASTEST                        0x1101
-#define GL_NICEST                         0x1102
-
-/* HintTarget */
-#define GL_GENERATE_MIPMAP_HINT            0x8192
-
-/* DataType */
-#define GL_BYTE                           0x1400
-#define GL_UNSIGNED_BYTE                  0x1401
-#define GL_SHORT                          0x1402
-#define GL_UNSIGNED_SHORT                 0x1403
-#define GL_INT                            0x1404
-#define GL_UNSIGNED_INT                   0x1405
-#define GL_FLOAT                          0x1406
-#define GL_FIXED                          0x140C
-
-/* PixelFormat */
-#define GL_DEPTH_COMPONENT                0x1902
-#define GL_ALPHA                          0x1906
-#define GL_RGB                            0x1907
-#define GL_RGBA                           0x1908
-#define GL_LUMINANCE                      0x1909
-#define GL_LUMINANCE_ALPHA                0x190A
-
-/* PixelType */
-/*      GL_UNSIGNED_BYTE */
-#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
-#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
-#define GL_UNSIGNED_SHORT_5_6_5           0x8363
-
-/* Shaders */
-#define GL_FRAGMENT_SHADER                  0x8B30
-#define GL_VERTEX_SHADER                    0x8B31
-#define GL_MAX_VERTEX_ATTRIBS               0x8869
-#define GL_MAX_VERTEX_UNIFORM_VECTORS       0x8DFB
-#define GL_MAX_VARYING_VECTORS              0x8DFC
-#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
-#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS   0x8B4C
-#define GL_MAX_TEXTURE_IMAGE_UNITS          0x8872
-#define GL_MAX_FRAGMENT_UNIFORM_VECTORS     0x8DFD
-#define GL_SHADER_TYPE                      0x8B4F
-#define GL_DELETE_STATUS                    0x8B80
-#define GL_LINK_STATUS                      0x8B82
-#define GL_VALIDATE_STATUS                  0x8B83
-#define GL_ATTACHED_SHADERS                 0x8B85
-#define GL_ACTIVE_UNIFORMS                  0x8B86
-#define GL_ACTIVE_UNIFORM_MAX_LENGTH        0x8B87
-#define GL_ACTIVE_ATTRIBUTES                0x8B89
-#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH      0x8B8A
-#define GL_SHADING_LANGUAGE_VERSION         0x8B8C
-#define GL_CURRENT_PROGRAM                  0x8B8D
-
-/* StencilFunction */
-#define GL_NEVER                          0x0200
-#define GL_LESS                           0x0201
-#define GL_EQUAL                          0x0202
-#define GL_LEQUAL                         0x0203
-#define GL_GREATER                        0x0204
-#define GL_NOTEQUAL                       0x0205
-#define GL_GEQUAL                         0x0206
-#define GL_ALWAYS                         0x0207
-
-/* StencilOp */
-/*      GL_ZERO */
-#define GL_KEEP                           0x1E00
-#define GL_REPLACE                        0x1E01
-#define GL_INCR                           0x1E02
-#define GL_DECR                           0x1E03
-#define GL_INVERT                         0x150A
-#define GL_INCR_WRAP                      0x8507
-#define GL_DECR_WRAP                      0x8508
-
-/* StringName */
-#define GL_VENDOR                         0x1F00
-#define GL_RENDERER                       0x1F01
-#define GL_VERSION                        0x1F02
-#define GL_EXTENSIONS                     0x1F03
-
-/* TextureMagFilter */
-#define GL_NEAREST                        0x2600
-#define GL_LINEAR                         0x2601
-
-/* TextureMinFilter */
-/*      GL_NEAREST */
-/*      GL_LINEAR */
-#define GL_NEAREST_MIPMAP_NEAREST         0x2700
-#define GL_LINEAR_MIPMAP_NEAREST          0x2701
-#define GL_NEAREST_MIPMAP_LINEAR          0x2702
-#define GL_LINEAR_MIPMAP_LINEAR           0x2703
-
-/* TextureParameterName */
-#define GL_TEXTURE_MAG_FILTER             0x2800
-#define GL_TEXTURE_MIN_FILTER             0x2801
-#define GL_TEXTURE_WRAP_S                 0x2802
-#define GL_TEXTURE_WRAP_T                 0x2803
-
-/* TextureTarget */
-/*      GL_TEXTURE_2D */
-#define GL_TEXTURE                        0x1702
-
-#define GL_TEXTURE_CUBE_MAP               0x8513
-#define GL_TEXTURE_BINDING_CUBE_MAP       0x8514
-#define GL_TEXTURE_CUBE_MAP_POSITIVE_X    0x8515
-#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X    0x8516
-#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y    0x8517
-#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    0x8518
-#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z    0x8519
-#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z    0x851A
-#define GL_MAX_CUBE_MAP_TEXTURE_SIZE      0x851C
-
-/* TextureUnit */
-#define GL_TEXTURE0                       0x84C0
-#define GL_TEXTURE1                       0x84C1
-#define GL_TEXTURE2                       0x84C2
-#define GL_TEXTURE3                       0x84C3
-#define GL_TEXTURE4                       0x84C4
-#define GL_TEXTURE5                       0x84C5
-#define GL_TEXTURE6                       0x84C6
-#define GL_TEXTURE7                       0x84C7
-#define GL_TEXTURE8                       0x84C8
-#define GL_TEXTURE9                       0x84C9
-#define GL_TEXTURE10                      0x84CA
-#define GL_TEXTURE11                      0x84CB
-#define GL_TEXTURE12                      0x84CC
-#define GL_TEXTURE13                      0x84CD
-#define GL_TEXTURE14                      0x84CE
-#define GL_TEXTURE15                      0x84CF
-#define GL_TEXTURE16                      0x84D0
-#define GL_TEXTURE17                      0x84D1
-#define GL_TEXTURE18                      0x84D2
-#define GL_TEXTURE19                      0x84D3
-#define GL_TEXTURE20                      0x84D4
-#define GL_TEXTURE21                      0x84D5
-#define GL_TEXTURE22                      0x84D6
-#define GL_TEXTURE23                      0x84D7
-#define GL_TEXTURE24                      0x84D8
-#define GL_TEXTURE25                      0x84D9
-#define GL_TEXTURE26                      0x84DA
-#define GL_TEXTURE27                      0x84DB
-#define GL_TEXTURE28                      0x84DC
-#define GL_TEXTURE29                      0x84DD
-#define GL_TEXTURE30                      0x84DE
-#define GL_TEXTURE31                      0x84DF
-#define GL_ACTIVE_TEXTURE                 0x84E0
-
-/* TextureWrapMode */
-#define GL_REPEAT                         0x2901
-#define GL_CLAMP_TO_EDGE                  0x812F
-#define GL_MIRRORED_REPEAT                0x8370
-
-/* Uniform Types */
-#define GL_FLOAT_VEC2                     0x8B50
-#define GL_FLOAT_VEC3                     0x8B51
-#define GL_FLOAT_VEC4                     0x8B52
-#define GL_INT_VEC2                       0x8B53
-#define GL_INT_VEC3                       0x8B54
-#define GL_INT_VEC4                       0x8B55
-#define GL_BOOL                           0x8B56
-#define GL_BOOL_VEC2                      0x8B57
-#define GL_BOOL_VEC3                      0x8B58
-#define GL_BOOL_VEC4                      0x8B59
-#define GL_FLOAT_MAT2                     0x8B5A
-#define GL_FLOAT_MAT3                     0x8B5B
-#define GL_FLOAT_MAT4                     0x8B5C
-#define GL_SAMPLER_2D                     0x8B5E
-#define GL_SAMPLER_CUBE                   0x8B60
-
-/* Vertex Arrays */
-#define GL_VERTEX_ATTRIB_ARRAY_ENABLED        0x8622
-#define GL_VERTEX_ATTRIB_ARRAY_SIZE           0x8623
-#define GL_VERTEX_ATTRIB_ARRAY_STRIDE         0x8624
-#define GL_VERTEX_ATTRIB_ARRAY_TYPE           0x8625
-#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED     0x886A
-#define GL_VERTEX_ATTRIB_ARRAY_POINTER        0x8645
-#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
-
-/* Read Format */
-#define GL_IMPLEMENTATION_COLOR_READ_TYPE   0x8B9A
-#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
-
-/* Shader Source */
-#define GL_COMPILE_STATUS                 0x8B81
-#define GL_INFO_LOG_LENGTH                0x8B84
-#define GL_SHADER_SOURCE_LENGTH           0x8B88
-#define GL_SHADER_COMPILER                0x8DFA
-
-/* Shader Binary */
-#define GL_SHADER_BINARY_FORMATS          0x8DF8
-#define GL_NUM_SHADER_BINARY_FORMATS      0x8DF9
-
-/* Shader Precision-Specified Types */
-#define GL_LOW_FLOAT                      0x8DF0
-#define GL_MEDIUM_FLOAT                   0x8DF1
-#define GL_HIGH_FLOAT                     0x8DF2
-#define GL_LOW_INT                        0x8DF3
-#define GL_MEDIUM_INT                     0x8DF4
-#define GL_HIGH_INT                       0x8DF5
-
-/* Framebuffer Object. */
-#define GL_FRAMEBUFFER                    0x8D40
-#define GL_RENDERBUFFER                   0x8D41
-
-#define GL_RGBA4                          0x8056
-#define GL_RGB5_A1                        0x8057
-#define GL_RGB565                         0x8D62
-#define GL_DEPTH_COMPONENT16              0x81A5
-#define GL_STENCIL_INDEX8                 0x8D48
-
-#define GL_RENDERBUFFER_WIDTH             0x8D42
-#define GL_RENDERBUFFER_HEIGHT            0x8D43
-#define GL_RENDERBUFFER_INTERNAL_FORMAT   0x8D44
-#define GL_RENDERBUFFER_RED_SIZE          0x8D50
-#define GL_RENDERBUFFER_GREEN_SIZE        0x8D51
-#define GL_RENDERBUFFER_BLUE_SIZE         0x8D52
-#define GL_RENDERBUFFER_ALPHA_SIZE        0x8D53
-#define GL_RENDERBUFFER_DEPTH_SIZE        0x8D54
-#define GL_RENDERBUFFER_STENCIL_SIZE      0x8D55
-
-#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           0x8CD0
-#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           0x8CD1
-#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         0x8CD2
-#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
-
-#define GL_COLOR_ATTACHMENT0              0x8CE0
-#define GL_DEPTH_ATTACHMENT               0x8D00
-#define GL_STENCIL_ATTACHMENT             0x8D20
-
-#define GL_NONE                           0
-
-#define GL_FRAMEBUFFER_COMPLETE                      0x8CD5
-#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT         0x8CD6
-#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
-#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS         0x8CD9
-#define GL_FRAMEBUFFER_UNSUPPORTED                   0x8CDD
-
-#define GL_FRAMEBUFFER_BINDING            0x8CA6
-#define GL_RENDERBUFFER_BINDING           0x8CA7
-#define GL_MAX_RENDERBUFFER_SIZE          0x84E8
-
-#define GL_INVALID_FRAMEBUFFER_OPERATION  0x0506
-
-/*-------------------------------------------------------------------------
- * GL core functions.
- *-----------------------------------------------------------------------*/
-
-GL_APICALL void         GL_APIENTRY glActiveTexture (GLenum texture);
-GL_APICALL void         GL_APIENTRY glAttachShader (GLuint program, GLuint shader);
-GL_APICALL void         GL_APIENTRY glBindAttribLocation (GLuint program, GLuint index, const GLchar* name);
-GL_APICALL void         GL_APIENTRY glBindBuffer (GLenum target, GLuint buffer);
-GL_APICALL void         GL_APIENTRY glBindFramebuffer (GLenum target, GLuint framebuffer);
-GL_APICALL void         GL_APIENTRY glBindRenderbuffer (GLenum target, GLuint renderbuffer);
-GL_APICALL void         GL_APIENTRY glBindTexture (GLenum target, GLuint texture);
-GL_APICALL void         GL_APIENTRY glBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-GL_APICALL void         GL_APIENTRY glBlendEquation ( GLenum mode );
-GL_APICALL void         GL_APIENTRY glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
-GL_APICALL void         GL_APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor);
-GL_APICALL void         GL_APIENTRY glBlendFuncSeparate (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-GL_APICALL void         GL_APIENTRY glBufferData (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
-GL_APICALL void         GL_APIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
-GL_APICALL GLenum       GL_APIENTRY glCheckFramebufferStatus (GLenum target);
-GL_APICALL void         GL_APIENTRY glClear (GLbitfield mask);
-GL_APICALL void         GL_APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-GL_APICALL void         GL_APIENTRY glClearDepthf (GLclampf depth);
-GL_APICALL void         GL_APIENTRY glClearStencil (GLint s);
-GL_APICALL void         GL_APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-GL_APICALL void         GL_APIENTRY glCompileShader (GLuint shader);
-GL_APICALL void         GL_APIENTRY glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data);
-GL_APICALL void         GL_APIENTRY glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data);
-GL_APICALL void         GL_APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-GL_APICALL void         GL_APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-GL_APICALL GLuint       GL_APIENTRY glCreateProgram (void);
-GL_APICALL GLuint       GL_APIENTRY glCreateShader (GLenum type);
-GL_APICALL void         GL_APIENTRY glCullFace (GLenum mode);
-GL_APICALL void         GL_APIENTRY glDeleteBuffers (GLsizei n, const GLuint* buffers);
-GL_APICALL void         GL_APIENTRY glDeleteFramebuffers (GLsizei n, const GLuint* framebuffers);
-GL_APICALL void         GL_APIENTRY glDeleteProgram (GLuint program);
-GL_APICALL void         GL_APIENTRY glDeleteRenderbuffers (GLsizei n, const GLuint* renderbuffers);
-GL_APICALL void         GL_APIENTRY glDeleteShader (GLuint shader);
-GL_APICALL void         GL_APIENTRY glDeleteTextures (GLsizei n, const GLuint* textures);
-GL_APICALL void         GL_APIENTRY glDepthFunc (GLenum func);
-GL_APICALL void         GL_APIENTRY glDepthMask (GLboolean flag);
-GL_APICALL void         GL_APIENTRY glDepthRangef (GLclampf zNear, GLclampf zFar);
-GL_APICALL void         GL_APIENTRY glDetachShader (GLuint program, GLuint shader);
-GL_APICALL void         GL_APIENTRY glDisable (GLenum cap);
-GL_APICALL void         GL_APIENTRY glDisableVertexAttribArray (GLuint index);
-GL_APICALL void         GL_APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
-GL_APICALL void         GL_APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
-GL_APICALL void         GL_APIENTRY glEnable (GLenum cap);
-GL_APICALL void         GL_APIENTRY glEnableVertexAttribArray (GLuint index);
-GL_APICALL void         GL_APIENTRY glFinish (void);
-GL_APICALL void         GL_APIENTRY glFlush (void);
-GL_APICALL void         GL_APIENTRY glFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-GL_APICALL void         GL_APIENTRY glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-GL_APICALL void         GL_APIENTRY glFrontFace (GLenum mode);
-GL_APICALL void         GL_APIENTRY glGenBuffers (GLsizei n, GLuint* buffers);
-GL_APICALL void         GL_APIENTRY glGenerateMipmap (GLenum target);
-GL_APICALL void         GL_APIENTRY glGenFramebuffers (GLsizei n, GLuint* framebuffers);
-GL_APICALL void         GL_APIENTRY glGenRenderbuffers (GLsizei n, GLuint* renderbuffers);
-GL_APICALL void         GL_APIENTRY glGenTextures (GLsizei n, GLuint* textures);
-GL_APICALL void         GL_APIENTRY glGetActiveAttrib (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
-GL_APICALL void         GL_APIENTRY glGetActiveUniform (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
-GL_APICALL void         GL_APIENTRY glGetAttachedShaders (GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-GL_APICALL GLint        GL_APIENTRY glGetAttribLocation (GLuint program, const GLchar* name);
-GL_APICALL void         GL_APIENTRY glGetBooleanv (GLenum pname, GLboolean* params);
-GL_APICALL void         GL_APIENTRY glGetBufferParameteriv (GLenum target, GLenum pname, GLint* params);
-GL_APICALL GLenum       GL_APIENTRY glGetError (void);
-GL_APICALL void         GL_APIENTRY glGetFloatv (GLenum pname, GLfloat* params);
-GL_APICALL void         GL_APIENTRY glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint* params);
-GL_APICALL void         GL_APIENTRY glGetIntegerv (GLenum pname, GLint* params);
-GL_APICALL void         GL_APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint* params);
-GL_APICALL void         GL_APIENTRY glGetProgramInfoLog (GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);
-GL_APICALL void         GL_APIENTRY glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params);
-GL_APICALL void         GL_APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint* params);
-GL_APICALL void         GL_APIENTRY glGetShaderInfoLog (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog);
-GL_APICALL void         GL_APIENTRY glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
-GL_APICALL void         GL_APIENTRY glGetShaderSource (GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
-GL_APICALL const GLubyte* GL_APIENTRY glGetString (GLenum name);
-GL_APICALL void         GL_APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat* params);
-GL_APICALL void         GL_APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint* params);
-GL_APICALL void         GL_APIENTRY glGetUniformfv (GLuint program, GLint location, GLfloat* params);
-GL_APICALL void         GL_APIENTRY glGetUniformiv (GLuint program, GLint location, GLint* params);
-GL_APICALL GLint        GL_APIENTRY glGetUniformLocation (GLuint program, const GLchar* name);
-GL_APICALL void         GL_APIENTRY glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat* params);
-GL_APICALL void         GL_APIENTRY glGetVertexAttribiv (GLuint index, GLenum pname, GLint* params);
-GL_APICALL void         GL_APIENTRY glGetVertexAttribPointerv (GLuint index, GLenum pname, GLvoid** pointer);
-GL_APICALL void         GL_APIENTRY glHint (GLenum target, GLenum mode);
-GL_APICALL GLboolean    GL_APIENTRY glIsBuffer (GLuint buffer);
-GL_APICALL GLboolean    GL_APIENTRY glIsEnabled (GLenum cap);
-GL_APICALL GLboolean    GL_APIENTRY glIsFramebuffer (GLuint framebuffer);
-GL_APICALL GLboolean    GL_APIENTRY glIsProgram (GLuint program);
-GL_APICALL GLboolean    GL_APIENTRY glIsRenderbuffer (GLuint renderbuffer);
-GL_APICALL GLboolean    GL_APIENTRY glIsShader (GLuint shader);
-GL_APICALL GLboolean    GL_APIENTRY glIsTexture (GLuint texture);
-GL_APICALL void         GL_APIENTRY glLineWidth (GLfloat width);
-GL_APICALL void         GL_APIENTRY glLinkProgram (GLuint program);
-GL_APICALL void         GL_APIENTRY glPixelStorei (GLenum pname, GLint param);
-GL_APICALL void         GL_APIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
-GL_APICALL void         GL_APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
-GL_APICALL void         GL_APIENTRY glReleaseShaderCompiler (void);
-GL_APICALL void         GL_APIENTRY glRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-GL_APICALL void         GL_APIENTRY glSampleCoverage (GLclampf value, GLboolean invert);
-GL_APICALL void         GL_APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
-GL_APICALL void         GL_APIENTRY glShaderBinary (GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length);
-GL_APICALL void         GL_APIENTRY glShaderSource (GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);
-GL_APICALL void         GL_APIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask);
-GL_APICALL void         GL_APIENTRY glStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask);
-GL_APICALL void         GL_APIENTRY glStencilMask (GLuint mask);
-GL_APICALL void         GL_APIENTRY glStencilMaskSeparate (GLenum face, GLuint mask);
-GL_APICALL void         GL_APIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
-GL_APICALL void         GL_APIENTRY glStencilOpSeparate (GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-GL_APICALL void         GL_APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
-GL_APICALL void         GL_APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param);
-GL_APICALL void         GL_APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat* params);
-GL_APICALL void         GL_APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
-GL_APICALL void         GL_APIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint* params);
-GL_APICALL void         GL_APIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
-GL_APICALL void         GL_APIENTRY glUniform1f (GLint location, GLfloat x);
-GL_APICALL void         GL_APIENTRY glUniform1fv (GLint location, GLsizei count, const GLfloat* v);
-GL_APICALL void         GL_APIENTRY glUniform1i (GLint location, GLint x);
-GL_APICALL void         GL_APIENTRY glUniform1iv (GLint location, GLsizei count, const GLint* v);
-GL_APICALL void         GL_APIENTRY glUniform2f (GLint location, GLfloat x, GLfloat y);
-GL_APICALL void         GL_APIENTRY glUniform2fv (GLint location, GLsizei count, const GLfloat* v);
-GL_APICALL void         GL_APIENTRY glUniform2i (GLint location, GLint x, GLint y);
-GL_APICALL void         GL_APIENTRY glUniform2iv (GLint location, GLsizei count, const GLint* v);
-GL_APICALL void         GL_APIENTRY glUniform3f (GLint location, GLfloat x, GLfloat y, GLfloat z);
-GL_APICALL void         GL_APIENTRY glUniform3fv (GLint location, GLsizei count, const GLfloat* v);
-GL_APICALL void         GL_APIENTRY glUniform3i (GLint location, GLint x, GLint y, GLint z);
-GL_APICALL void         GL_APIENTRY glUniform3iv (GLint location, GLsizei count, const GLint* v);
-GL_APICALL void         GL_APIENTRY glUniform4f (GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-GL_APICALL void         GL_APIENTRY glUniform4fv (GLint location, GLsizei count, const GLfloat* v);
-GL_APICALL void         GL_APIENTRY glUniform4i (GLint location, GLint x, GLint y, GLint z, GLint w);
-GL_APICALL void         GL_APIENTRY glUniform4iv (GLint location, GLsizei count, const GLint* v);
-GL_APICALL void         GL_APIENTRY glUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-GL_APICALL void         GL_APIENTRY glUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-GL_APICALL void         GL_APIENTRY glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-GL_APICALL void         GL_APIENTRY glUseProgram (GLuint program);
-GL_APICALL void         GL_APIENTRY glValidateProgram (GLuint program);
-GL_APICALL void         GL_APIENTRY glVertexAttrib1f (GLuint indx, GLfloat x);
-GL_APICALL void         GL_APIENTRY glVertexAttrib1fv (GLuint indx, const GLfloat* values);
-GL_APICALL void         GL_APIENTRY glVertexAttrib2f (GLuint indx, GLfloat x, GLfloat y);
-GL_APICALL void         GL_APIENTRY glVertexAttrib2fv (GLuint indx, const GLfloat* values);
-GL_APICALL void         GL_APIENTRY glVertexAttrib3f (GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-GL_APICALL void         GL_APIENTRY glVertexAttrib3fv (GLuint indx, const GLfloat* values);
-GL_APICALL void         GL_APIENTRY glVertexAttrib4f (GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-GL_APICALL void         GL_APIENTRY glVertexAttrib4fv (GLuint indx, const GLfloat* values);
-GL_APICALL void         GL_APIENTRY glVertexAttribPointer (GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr);
-GL_APICALL void         GL_APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __gl2_h_ */
-
@@ -1,30 +0,0 @@
-#ifndef __gl2platform_h_
-#define __gl2platform_h_
-
-/* $Revision: 10602 $ on $Date:: 2010-03-04 22:35:34 -0800 #$ */
-
-/*
- * This document is licensed under the SGI Free Software B License Version
- * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ .
- */
-
-/* Platform-specific types and definitions for OpenGL ES 2.X  gl2.h
- *
- * Adopters may modify khrplatform.h and this file to suit their platform.
- * You are encouraged to submit all modifications to the Khronos group so that
- * they can be included in future versions of this file.  Please submit changes
- * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
- * by filing a bug against product "OpenGL-ES" component "Registry".
- */
-
-/*#include <KHR/khrplatform.h>*/
-
-#ifndef GL_APICALL
-#define GL_APICALL  KHRONOS_APICALL
-#endif
-
-#ifndef GL_APIENTRY
-#define GL_APIENTRY KHRONOS_APIENTRY
-#endif
-
-#endif /* __gl2platform_h_ */
@@ -1,282 +0,0 @@
-#ifndef __khrplatform_h_
-#define __khrplatform_h_
-
-/*
-** Copyright (c) 2008-2009 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a
-** copy of this software and/or associated documentation files (the
-** "Materials"), to deal in the Materials without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Materials, and to
-** permit persons to whom the Materials are furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be included
-** in all copies or substantial portions of the Materials.
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-*/
-
-/* Khronos platform-specific types and definitions.
- *
- * $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
- *
- * Adopters may modify this file to suit their platform. Adopters are
- * encouraged to submit platform specific modifications to the Khronos
- * group so that they can be included in future versions of this file.
- * Please submit changes by sending them to the public Khronos Bugzilla
- * (http://khronos.org/bugzilla) by filing a bug against product
- * "Khronos (general)" component "Registry".
- *
- * A predefined template which fills in some of the bug fields can be
- * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
- * must create a Bugzilla login first.
- *
- *
- * See the Implementer's Guidelines for information about where this file
- * should be located on your system and for more details of its use:
- *    http://www.khronos.org/registry/implementers_guide.pdf
- *
- * This file should be included as
- *        #include <KHR/khrplatform.h>
- * by Khronos client API header files that use its types and defines.
- *
- * The types in khrplatform.h should only be used to define API-specific types.
- *
- * Types defined in khrplatform.h:
- *    khronos_int8_t              signed   8  bit
- *    khronos_uint8_t             unsigned 8  bit
- *    khronos_int16_t             signed   16 bit
- *    khronos_uint16_t            unsigned 16 bit
- *    khronos_int32_t             signed   32 bit
- *    khronos_uint32_t            unsigned 32 bit
- *    khronos_int64_t             signed   64 bit
- *    khronos_uint64_t            unsigned 64 bit
- *    khronos_intptr_t            signed   same number of bits as a pointer
- *    khronos_uintptr_t           unsigned same number of bits as a pointer
- *    khronos_ssize_t             signed   size
- *    khronos_usize_t             unsigned size
- *    khronos_float_t             signed   32 bit floating point
- *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
- *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
- *                                         nanoseconds
- *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
- *    khronos_boolean_enum_t      enumerated boolean type. This should
- *      only be used as a base type when a client API's boolean type is
- *      an enum. Client APIs which use an integer or other type for
- *      booleans cannot use this as the base type for their boolean.
- *
- * Tokens defined in khrplatform.h:
- *
- *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
- *
- *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
- *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
- *
- * Calling convention macros defined in this file:
- *    KHRONOS_APICALL
- *    KHRONOS_APIENTRY
- *    KHRONOS_APIATTRIBUTES
- *
- * These may be used in function prototypes as:
- *
- *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
- *                                  int arg1,
- *                                  int arg2) KHRONOS_APIATTRIBUTES;
- */
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APICALL
- *-------------------------------------------------------------------------
- * This precedes the return type of the function in the function prototype.
- */
-#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
-#   define KHRONOS_APICALL __declspec(dllimport)
-#elif defined (__SYMBIAN32__)
-#   define KHRONOS_APICALL IMPORT_C
-#else
-#   define KHRONOS_APICALL
-#endif
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APIENTRY
- *-------------------------------------------------------------------------
- * This follows the return type of the function  and precedes the function
- * name in the function prototype.
- */
-#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
-    /* Win32 but not WinCE */
-#   define KHRONOS_APIENTRY __stdcall
-#else
-#   define KHRONOS_APIENTRY
-#endif
-
-/*-------------------------------------------------------------------------
- * Definition of KHRONOS_APIATTRIBUTES
- *-------------------------------------------------------------------------
- * This follows the closing parenthesis of the function prototype arguments.
- */
-#if defined (__ARMCC_2__)
-#define KHRONOS_APIATTRIBUTES __softfp
-#else
-#define KHRONOS_APIATTRIBUTES
-#endif
-
-/*-------------------------------------------------------------------------
- * basic type definitions
- *-----------------------------------------------------------------------*/
-#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
-
-
-/*
- * Using <stdint.h>
- */
-#include <stdint.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(__VMS ) || defined(__sgi)
-
-/*
- * Using <inttypes.h>
- */
-#include <inttypes.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
-
-/*
- * Win32
- */
-typedef __int32                 khronos_int32_t;
-typedef unsigned __int32        khronos_uint32_t;
-typedef __int64                 khronos_int64_t;
-typedef unsigned __int64        khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif defined(__sun__) || defined(__digital__)
-
-/*
- * Sun or Digital
- */
-typedef int                     khronos_int32_t;
-typedef unsigned int            khronos_uint32_t;
-#if defined(__arch64__) || defined(_LP64)
-typedef long int                khronos_int64_t;
-typedef unsigned long int       khronos_uint64_t;
-#else
-typedef long long int           khronos_int64_t;
-typedef unsigned long long int  khronos_uint64_t;
-#endif /* __arch64__ */
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#elif 0
-
-/*
- * Hypothetical platform with no float or int64 support
- */
-typedef int                     khronos_int32_t;
-typedef unsigned int            khronos_uint32_t;
-#define KHRONOS_SUPPORT_INT64   0
-#define KHRONOS_SUPPORT_FLOAT   0
-
-#else
-
-/*
- * Generic fallback
- */
-#include <stdint.h>
-typedef int32_t                 khronos_int32_t;
-typedef uint32_t                khronos_uint32_t;
-typedef int64_t                 khronos_int64_t;
-typedef uint64_t                khronos_uint64_t;
-#define KHRONOS_SUPPORT_INT64   1
-#define KHRONOS_SUPPORT_FLOAT   1
-
-#endif
-
-
-/*
- * Types that are (so far) the same on all platforms
- */
-typedef signed   char          khronos_int8_t;
-typedef unsigned char          khronos_uint8_t;
-typedef signed   short int     khronos_int16_t;
-typedef unsigned short int     khronos_uint16_t;
-
-/*
- * Types that differ between LLP64 and LP64 architectures - in LLP64, 
- * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
- * to be the only LLP64 architecture in current use.
- */
-#ifdef _WIN64
-typedef signed   long long int khronos_intptr_t;
-typedef unsigned long long int khronos_uintptr_t;
-typedef signed   long long int khronos_ssize_t;
-typedef unsigned long long int khronos_usize_t;
-#else
-typedef signed   long  int     khronos_intptr_t;
-typedef unsigned long  int     khronos_uintptr_t;
-typedef signed   long  int     khronos_ssize_t;
-typedef unsigned long  int     khronos_usize_t;
-#endif
-
-#if KHRONOS_SUPPORT_FLOAT
-/*
- * Float type
- */
-typedef          float         khronos_float_t;
-#endif
-
-#if KHRONOS_SUPPORT_INT64
-/* Time types
- *
- * These types can be used to represent a time interval in nanoseconds or
- * an absolute Unadjusted System Time.  Unadjusted System Time is the number
- * of nanoseconds since some arbitrary system event (e.g. since the last
- * time the system booted).  The Unadjusted System Time is an unsigned
- * 64 bit value that wraps back to 0 every 584 years.  Time intervals
- * may be either signed or unsigned.
- */
-typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
-typedef khronos_int64_t        khronos_stime_nanoseconds_t;
-#endif
-
-/*
- * Dummy value used to pad enum types to 32 bits.
- */
-#ifndef KHRONOS_MAX_ENUM
-#define KHRONOS_MAX_ENUM 0x7FFFFFFF
-#endif
-
-/*
- * Enumerated boolean type
- *
- * Values other than zero should be considered to be true.  Therefore
- * comparisons should not be made against KHRONOS_TRUE.
- */
-typedef enum {
-    KHRONOS_FALSE = 0,
-    KHRONOS_TRUE  = 1,
-    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
-} khronos_boolean_enum_t;
-
-#endif /* __khrplatform_h_ */
@@ -1,235 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_platform.h
- *
- *  Try to get a standard set of platform defines.
- */
-
-#ifndef SDL_platform_h_
-#define SDL_platform_h_
-
-#if defined(_AIX)
-#undef __AIX__
-#define __AIX__     1
-#endif
-#if defined(__HAIKU__)
-#undef __HAIKU__
-#define __HAIKU__   1
-#endif
-#if defined(bsdi) || defined(__bsdi) || defined(__bsdi__)
-#undef __BSDI__
-#define __BSDI__    1
-#endif
-#if defined(_arch_dreamcast)
-#undef __DREAMCAST__
-#define __DREAMCAST__   1
-#endif
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
-#undef __FREEBSD__
-#define __FREEBSD__ 1
-#endif
-#if defined(hpux) || defined(__hpux) || defined(__hpux__)
-#undef __HPUX__
-#define __HPUX__    1
-#endif
-#if defined(sgi) || defined(__sgi) || defined(__sgi__) || defined(_SGI_SOURCE)
-#undef __IRIX__
-#define __IRIX__    1
-#endif
-#if (defined(linux) || defined(__linux) || defined(__linux__))
-#undef __LINUX__
-#define __LINUX__   1
-#endif
-#if defined(ANDROID) || defined(__ANDROID__)
-#undef __ANDROID__
-#undef __LINUX__ /* do we need to do this? */
-#define __ANDROID__ 1
-#endif
-
-#if defined(__APPLE__)
-/* lets us know what version of Mac OS X we're compiling on */
-#include "AvailabilityMacros.h"
-#include "TargetConditionals.h"
-
-/* Fix building with older SDKs that don't define these
-   See this for more information:
-   https://stackoverflow.com/questions/12132933/preprocessor-macro-for-os-x-targets
-*/
-#ifndef TARGET_OS_MACCATALYST
-#define TARGET_OS_MACCATALYST 0
-#endif
-#ifndef TARGET_OS_IOS
-#define TARGET_OS_IOS 0
-#endif
-#ifndef TARGET_OS_IPHONE
-#define TARGET_OS_IPHONE 0
-#endif
-#ifndef TARGET_OS_TV
-#define TARGET_OS_TV 0
-#endif
-#ifndef TARGET_OS_SIMULATOR
-#define TARGET_OS_SIMULATOR 0
-#endif
-
-#if TARGET_OS_TV
-#undef __TVOS__
-#define __TVOS__ 1
-#endif
-#if TARGET_OS_IPHONE
-/* if compiling for iOS */
-#undef __IPHONEOS__
-#define __IPHONEOS__ 1
-#undef __MACOSX__
-#else
-/* if not compiling for iOS */
-#undef __MACOSX__
-#define __MACOSX__  1
-#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060
-# error SDL for Mac OS X only supports deploying on 10.6 and above.
-#endif /* MAC_OS_X_VERSION_MIN_REQUIRED < 1060 */
-#endif /* TARGET_OS_IPHONE */
-#endif /* defined(__APPLE__) */
-
-#if defined(__NetBSD__)
-#undef __NETBSD__
-#define __NETBSD__  1
-#endif
-#if defined(__OpenBSD__)
-#undef __OPENBSD__
-#define __OPENBSD__ 1
-#endif
-#if defined(__OS2__) || defined(__EMX__)
-#undef __OS2__
-#define __OS2__     1
-#endif
-#if defined(osf) || defined(__osf) || defined(__osf__) || defined(_OSF_SOURCE)
-#undef __OSF__
-#define __OSF__     1
-#endif
-#if defined(__QNXNTO__)
-#undef __QNXNTO__
-#define __QNXNTO__  1
-#endif
-#if defined(riscos) || defined(__riscos) || defined(__riscos__)
-#undef __RISCOS__
-#define __RISCOS__  1
-#endif
-#if defined(__sun) && defined(__SVR4)
-#undef __SOLARIS__
-#define __SOLARIS__ 1
-#endif
-
-#if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
-/* Try to find out if we're compiling for WinRT or non-WinRT */
-#if defined(_MSC_VER) && defined(__has_include)
-#if __has_include(<winapifamily.h>)
-#define HAVE_WINAPIFAMILY_H 1
-#else
-#define HAVE_WINAPIFAMILY_H 0
-#endif
-
-/* If _USING_V110_SDK71_ is defined it means we are using the Windows XP toolset. */
-#elif defined(_MSC_VER) && (_MSC_VER >= 1700 && !_USING_V110_SDK71_)    /* _MSC_VER == 1700 for Visual Studio 2012 */
-#define HAVE_WINAPIFAMILY_H 1
-#else
-#define HAVE_WINAPIFAMILY_H 0
-#endif
-
-#if HAVE_WINAPIFAMILY_H
-#include <winapifamily.h>
-#define WINAPI_FAMILY_WINRT (!WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP))
-#else
-#define WINAPI_FAMILY_WINRT 0
-#endif /* HAVE_WINAPIFAMILY_H */
-
-#if WINAPI_FAMILY_WINRT
-#undef __WINRT__
-#define __WINRT__ 1
-#else
-#undef __WINDOWS__
-#define __WINDOWS__ 1
-#endif
-#endif /* defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) */
-
-#if defined(__WINDOWS__)
-#undef __WIN32__
-#define __WIN32__ 1
-#endif
-#if defined(__PSP__)
-#undef __PSP__
-#define __PSP__ 1
-#endif
-
-/* The NACL compiler defines __native_client__ and __pnacl__
- * Ref: http://www.chromium.org/nativeclient/pnacl/stability-of-the-pnacl-bitcode-abi
- */
-#if defined(__native_client__)
-#undef __LINUX__
-#undef __NACL__
-#define __NACL__ 1
-#endif
-#if defined(__pnacl__)
-#undef __LINUX__
-#undef __PNACL__
-#define __PNACL__ 1
-/* PNACL with newlib supports static linking only */
-#define __SDL_NOGETPROCADDR__
-#endif
-
-#if defined(__vita__)
-#define __VITA__ 1
-#endif
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Get the name of the platform.
- *
- * Here are the names returned for some (but not all) supported platforms:
- *
- * - "Windows"
- * - "Mac OS X"
- * - "Linux"
- * - "iOS"
- * - "Android"
- *
- * \returns the name of the platform. If the correct platform name is not
- *          available, returns a string beginning with the text "Unknown".
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC const char * SDLCALL SDL_GetPlatform (void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_platform_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,88 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_power_h_
-#define SDL_power_h_
-
-/**
- *  \file SDL_power.h
- *
- *  Header for the SDL power management routines.
- */
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  The basic state for the system's power supply.
- */
-typedef enum
-{
-    SDL_POWERSTATE_UNKNOWN,      /**< cannot determine power status */
-    SDL_POWERSTATE_ON_BATTERY,   /**< Not plugged in, running on the battery */
-    SDL_POWERSTATE_NO_BATTERY,   /**< Plugged in, no battery available */
-    SDL_POWERSTATE_CHARGING,     /**< Plugged in, charging battery */
-    SDL_POWERSTATE_CHARGED       /**< Plugged in, battery charged */
-} SDL_PowerState;
-
-
-/**
- * Get the current power supply details.
- *
- * You should never take a battery status as absolute truth. Batteries
- * (especially failing batteries) are delicate hardware, and the values
- * reported here are best estimates based on what that hardware reports. It's
- * not uncommon for older batteries to lose stored power much faster than it
- * reports, or completely drain when reporting it has 20 percent left, etc.
- *
- * Battery status can change at any time; if you are concerned with power
- * state, you should call this function frequently, and perhaps ignore changes
- * until they seem to be stable for a few seconds.
- *
- * It's possible a platform can only report battery percentage or time left
- * but not both.
- *
- * \param secs seconds of battery life left, you can pass a NULL here if you
- *             don't care, will return -1 if we can't determine a value, or
- *             we're not running on a battery
- * \param pct percentage of battery life left, between 0 and 100, you can pass
- *            a NULL here if you don't care, will return -1 if we can't
- *            determine a value, or we're not running on a battery
- * \returns an SDL_PowerState enum representing the current battery state.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC SDL_PowerState SDLCALL SDL_GetPowerInfo(int *secs, int *pct);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_power_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,376 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_rect.h
- *
- *  Header file for SDL_rect definition and management functions.
- */
-
-#ifndef SDL_rect_h_
-#define SDL_rect_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_pixels.h"
-#include "SDL_rwops.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * The structure that defines a point (integer)
- *
- * \sa SDL_EnclosePoints
- * \sa SDL_PointInRect
- */
-typedef struct SDL_Point
-{
-    int x;
-    int y;
-} SDL_Point;
-
-/**
- * The structure that defines a point (floating point)
- *
- * \sa SDL_EncloseFPoints
- * \sa SDL_PointInFRect
- */
-typedef struct SDL_FPoint
-{
-    float x;
-    float y;
-} SDL_FPoint;
-
-
-/**
- * A rectangle, with the origin at the upper left (integer).
- *
- * \sa SDL_RectEmpty
- * \sa SDL_RectEquals
- * \sa SDL_HasIntersection
- * \sa SDL_IntersectRect
- * \sa SDL_IntersectRectAndLine
- * \sa SDL_UnionRect
- * \sa SDL_EnclosePoints
- */
-typedef struct SDL_Rect
-{
-    int x, y;
-    int w, h;
-} SDL_Rect;
-
-
-/**
- * A rectangle, with the origin at the upper left (floating point).
- *
- * \sa SDL_FRectEmpty
- * \sa SDL_FRectEquals
- * \sa SDL_FRectEqualsEpsilon
- * \sa SDL_HasIntersectionF
- * \sa SDL_IntersectFRect
- * \sa SDL_IntersectFRectAndLine
- * \sa SDL_UnionFRect
- * \sa SDL_EncloseFPoints
- * \sa SDL_PointInFRect
- */
-typedef struct SDL_FRect
-{
-    float x;
-    float y;
-    float w;
-    float h;
-} SDL_FRect;
-
-
-/**
- * Returns true if point resides inside a rectangle.
- */
-SDL_FORCE_INLINE SDL_bool SDL_PointInRect(const SDL_Point *p, const SDL_Rect *r)
-{
-    return ( (p->x >= r->x) && (p->x < (r->x + r->w)) &&
-             (p->y >= r->y) && (p->y < (r->y + r->h)) ) ? SDL_TRUE : SDL_FALSE;
-}
-
-/**
- * Returns true if the rectangle has no area.
- */
-SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
-{
-    return ((!r) || (r->w <= 0) || (r->h <= 0)) ? SDL_TRUE : SDL_FALSE;
-}
-
-/**
- * Returns true if the two rectangles are equal.
- */
-SDL_FORCE_INLINE SDL_bool SDL_RectEquals(const SDL_Rect *a, const SDL_Rect *b)
-{
-    return (a && b && (a->x == b->x) && (a->y == b->y) &&
-            (a->w == b->w) && (a->h == b->h)) ? SDL_TRUE : SDL_FALSE;
-}
-
-/**
- * Determine whether two rectangles intersect.
- *
- * If either pointer is NULL the function will return SDL_FALSE.
- *
- * \param A an SDL_Rect structure representing the first rectangle
- * \param B an SDL_Rect structure representing the second rectangle
- * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_IntersectRect
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersection(const SDL_Rect * A,
-                                                     const SDL_Rect * B);
-
-/**
- * Calculate the intersection of two rectangles.
- *
- * If `result` is NULL then this function will return SDL_FALSE.
- *
- * \param A an SDL_Rect structure representing the first rectangle
- * \param B an SDL_Rect structure representing the second rectangle
- * \param result an SDL_Rect structure filled in with the intersection of
- *               rectangles `A` and `B`
- * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_HasIntersection
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRect(const SDL_Rect * A,
-                                                   const SDL_Rect * B,
-                                                   SDL_Rect * result);
-
-/**
- * Calculate the union of two rectangles.
- *
- * \param A an SDL_Rect structure representing the first rectangle
- * \param B an SDL_Rect structure representing the second rectangle
- * \param result an SDL_Rect structure filled in with the union of rectangles
- *               `A` and `B`
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC void SDLCALL SDL_UnionRect(const SDL_Rect * A,
-                                           const SDL_Rect * B,
-                                           SDL_Rect * result);
-
-/**
- * Calculate a minimal rectangle enclosing a set of points.
- *
- * If `clip` is not NULL then only points inside of the clipping rectangle are
- * considered.
- *
- * \param points an array of SDL_Point structures representing points to be
- *               enclosed
- * \param count the number of structures in the `points` array
- * \param clip an SDL_Rect used for clipping or NULL to enclose all points
- * \param result an SDL_Rect structure filled in with the minimal enclosing
- *               rectangle
- * \returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the
- *          points were outside of the clipping rectangle.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_EnclosePoints(const SDL_Point * points,
-                                                   int count,
-                                                   const SDL_Rect * clip,
-                                                   SDL_Rect * result);
-
-/**
- * Calculate the intersection of a rectangle and line segment.
- *
- * This function is used to clip a line segment to a rectangle. A line segment
- * contained entirely within the rectangle or that does not intersect will
- * remain unchanged. A line segment that crosses the rectangle at either or
- * both ends will be clipped to the boundary of the rectangle and the new
- * coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary.
- *
- * \param rect an SDL_Rect structure representing the rectangle to intersect
- * \param X1 a pointer to the starting X-coordinate of the line
- * \param Y1 a pointer to the starting Y-coordinate of the line
- * \param X2 a pointer to the ending X-coordinate of the line
- * \param Y2 a pointer to the ending Y-coordinate of the line
- * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IntersectRectAndLine(const SDL_Rect *
-                                                          rect, int *X1,
-                                                          int *Y1, int *X2,
-                                                          int *Y2);
-
-
-/* SDL_FRect versions... */
-
-/**
- * Returns true if point resides inside a rectangle.
- */
-SDL_FORCE_INLINE SDL_bool SDL_PointInFRect(const SDL_FPoint *p, const SDL_FRect *r)
-{
-    return ( (p->x >= r->x) && (p->x < (r->x + r->w)) &&
-             (p->y >= r->y) && (p->y < (r->y + r->h)) ) ? SDL_TRUE : SDL_FALSE;
-}
-
-/**
- * Returns true if the rectangle has no area.
- */
-SDL_FORCE_INLINE SDL_bool SDL_FRectEmpty(const SDL_FRect *r)
-{
-    return ((!r) || (r->w <= 0.0f) || (r->h <= 0.0f)) ? SDL_TRUE : SDL_FALSE;
-}
-
-/**
- * Returns true if the two rectangles are equal, within some given epsilon.
- *
- * \since This function is available since SDL 2.0.22.
- */
-SDL_FORCE_INLINE SDL_bool SDL_FRectEqualsEpsilon(const SDL_FRect *a, const SDL_FRect *b, const float epsilon)
-{
-    return (a && b && ((a == b) ||
-            ((SDL_fabs(a->x - b->x) <= epsilon) &&
-            (SDL_fabs(a->y - b->y) <= epsilon) &&
-            (SDL_fabs(a->w - b->w) <= epsilon) &&
-            (SDL_fabs(a->h - b->h) <= epsilon))))
-            ? SDL_TRUE : SDL_FALSE;
-}
-
-/**
- * Returns true if the two rectangles are equal, using a default epsilon.
- *
- * \since This function is available since SDL 2.0.22.
- */
-SDL_FORCE_INLINE SDL_bool SDL_FRectEquals(const SDL_FRect *a, const SDL_FRect *b)
-{
-    return SDL_FRectEqualsEpsilon(a, b, SDL_FLT_EPSILON);
-}
-
-/**
- * Determine whether two rectangles intersect with float precision.
- *
- * If either pointer is NULL the function will return SDL_FALSE.
- *
- * \param A an SDL_FRect structure representing the first rectangle
- * \param B an SDL_FRect structure representing the second rectangle
- * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.22.
- *
- * \sa SDL_IntersectRect
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasIntersectionF(const SDL_FRect * A,
-                                                      const SDL_FRect * B);
-
-/**
- * Calculate the intersection of two rectangles with float precision.
- *
- * If `result` is NULL then this function will return SDL_FALSE.
- *
- * \param A an SDL_FRect structure representing the first rectangle
- * \param B an SDL_FRect structure representing the second rectangle
- * \param result an SDL_FRect structure filled in with the intersection of
- *               rectangles `A` and `B`
- * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.22.
- *
- * \sa SDL_HasIntersectionF
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IntersectFRect(const SDL_FRect * A,
-                                                    const SDL_FRect * B,
-                                                    SDL_FRect * result);
-
-/**
- * Calculate the union of two rectangles with float precision.
- *
- * \param A an SDL_FRect structure representing the first rectangle
- * \param B an SDL_FRect structure representing the second rectangle
- * \param result an SDL_FRect structure filled in with the union of rectangles
- *               `A` and `B`
- *
- * \since This function is available since SDL 2.0.22.
- */
-extern DECLSPEC void SDLCALL SDL_UnionFRect(const SDL_FRect * A,
-                                            const SDL_FRect * B,
-                                            SDL_FRect * result);
-
-/**
- * Calculate a minimal rectangle enclosing a set of points with float
- * precision.
- *
- * If `clip` is not NULL then only points inside of the clipping rectangle are
- * considered.
- *
- * \param points an array of SDL_FPoint structures representing points to be
- *               enclosed
- * \param count the number of structures in the `points` array
- * \param clip an SDL_FRect used for clipping or NULL to enclose all points
- * \param result an SDL_FRect structure filled in with the minimal enclosing
- *               rectangle
- * \returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the
- *          points were outside of the clipping rectangle.
- *
- * \since This function is available since SDL 2.0.22.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_EncloseFPoints(const SDL_FPoint * points,
-                                                    int count,
-                                                    const SDL_FRect * clip,
-                                                    SDL_FRect * result);
-
-/**
- * Calculate the intersection of a rectangle and line segment with float
- * precision.
- *
- * This function is used to clip a line segment to a rectangle. A line segment
- * contained entirely within the rectangle or that does not intersect will
- * remain unchanged. A line segment that crosses the rectangle at either or
- * both ends will be clipped to the boundary of the rectangle and the new
- * coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary.
- *
- * \param rect an SDL_FRect structure representing the rectangle to intersect
- * \param X1 a pointer to the starting X-coordinate of the line
- * \param Y1 a pointer to the starting Y-coordinate of the line
- * \param X2 a pointer to the ending X-coordinate of the line
- * \param Y2 a pointer to the ending Y-coordinate of the line
- * \returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.22.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IntersectFRectAndLine(const SDL_FRect *
-                                                           rect, float *X1,
-                                                           float *Y1, float *X2,
-                                                           float *Y2);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_rect_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,2 +0,0 @@
-#define SDL_REVISION ""
-#define SDL_REVISION_NUMBER 0
@@ -1,6 +0,0 @@
-#cmakedefine SDL_REVISION "@SDL_REVISION@"
-#define SDL_REVISION_NUMBER 0
-
-#ifndef SDL_REVISION
-#define SDL_REVISION ""
-#endif
@@ -1,855 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_rwops.h
- *
- *  This file provides a general interface for SDL to read and write
- *  data streams.  It can easily be extended to files, memory, etc.
- */
-
-#ifndef SDL_rwops_h_
-#define SDL_rwops_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* RWops Types */
-#define SDL_RWOPS_UNKNOWN   0U  /**< Unknown stream type */
-#define SDL_RWOPS_WINFILE   1U  /**< Win32 file */
-#define SDL_RWOPS_STDFILE   2U  /**< Stdio file */
-#define SDL_RWOPS_JNIFILE   3U  /**< Android asset */
-#define SDL_RWOPS_MEMORY    4U  /**< Memory stream */
-#define SDL_RWOPS_MEMORY_RO 5U  /**< Read-Only memory stream */
-#if defined(__VITA__)
-#define SDL_RWOPS_VITAFILE  6U  /**< Vita file */
-#endif
-
-/**
- * This is the read/write operation structure -- very basic.
- */
-typedef struct SDL_RWops
-{
-    /**
-     *  Return the size of the file in this rwops, or -1 if unknown
-     */
-    Sint64 (SDLCALL * size) (struct SDL_RWops * context);
-
-    /**
-     *  Seek to \c offset relative to \c whence, one of stdio's whence values:
-     *  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
-     *
-     *  \return the final offset in the data stream, or -1 on error.
-     */
-    Sint64 (SDLCALL * seek) (struct SDL_RWops * context, Sint64 offset,
-                             int whence);
-
-    /**
-     *  Read up to \c maxnum objects each of size \c size from the data
-     *  stream to the area pointed at by \c ptr.
-     *
-     *  \return the number of objects read, or 0 at error or end of file.
-     */
-    size_t (SDLCALL * read) (struct SDL_RWops * context, void *ptr,
-                             size_t size, size_t maxnum);
-
-    /**
-     *  Write exactly \c num objects each of size \c size from the area
-     *  pointed at by \c ptr to data stream.
-     *
-     *  \return the number of objects written, or 0 at error or end of file.
-     */
-    size_t (SDLCALL * write) (struct SDL_RWops * context, const void *ptr,
-                              size_t size, size_t num);
-
-    /**
-     *  Close and free an allocated SDL_RWops structure.
-     *
-     *  \return 0 if successful or -1 on write error when flushing data.
-     */
-    int (SDLCALL * close) (struct SDL_RWops * context);
-
-    Uint32 type;
-    union
-    {
-#if defined(__ANDROID__)
-        struct
-        {
-            void *asset;
-        } androidio;
-#elif defined(__WIN32__)
-        struct
-        {
-            SDL_bool append;
-            void *h;
-            struct
-            {
-                void *data;
-                size_t size;
-                size_t left;
-            } buffer;
-        } windowsio;
-#elif defined(__VITA__)
-        struct
-        {
-            int h;
-            struct
-            {
-                void *data;
-                size_t size;
-                size_t left;
-            } buffer;
-        } vitaio;
-#endif
-
-#ifdef HAVE_STDIO_H
-        struct
-        {
-            SDL_bool autoclose;
-            FILE *fp;
-        } stdio;
-#endif
-        struct
-        {
-            Uint8 *base;
-            Uint8 *here;
-            Uint8 *stop;
-        } mem;
-        struct
-        {
-            void *data1;
-            void *data2;
-        } unknown;
-    } hidden;
-
-} SDL_RWops;
-
-
-/**
- *  \name RWFrom functions
- *
- *  Functions to create SDL_RWops structures from various data streams.
- */
-/* @{ */
-
-/**
- * Use this function to create a new SDL_RWops structure for reading from
- * and/or writing to a named file.
- *
- * The `mode` string is treated roughly the same as in a call to the C
- * library's fopen(), even if SDL doesn't happen to use fopen() behind the
- * scenes.
- *
- * Available `mode` strings:
- *
- * - "r": Open a file for reading. The file must exist.
- * - "w": Create an empty file for writing. If a file with the same name
- *   already exists its content is erased and the file is treated as a new
- *   empty file.
- * - "a": Append to a file. Writing operations append data at the end of the
- *   file. The file is created if it does not exist.
- * - "r+": Open a file for update both reading and writing. The file must
- *   exist.
- * - "w+": Create an empty file for both reading and writing. If a file with
- *   the same name already exists its content is erased and the file is
- *   treated as a new empty file.
- * - "a+": Open a file for reading and appending. All writing operations are
- *   performed at the end of the file, protecting the previous content to be
- *   overwritten. You can reposition (fseek, rewind) the internal pointer to
- *   anywhere in the file for reading, but writing operations will move it
- *   back to the end of file. The file is created if it does not exist.
- *
- * **NOTE**: In order to open a file as a binary file, a "b" character has to
- * be included in the `mode` string. This additional "b" character can either
- * be appended at the end of the string (thus making the following compound
- * modes: "rb", "wb", "ab", "r+b", "w+b", "a+b") or be inserted between the
- * letter and the "+" sign for the mixed modes ("rb+", "wb+", "ab+").
- * Additional characters may follow the sequence, although they should have no
- * effect. For example, "t" is sometimes appended to make explicit the file is
- * a text file.
- *
- * This function supports Unicode filenames, but they must be encoded in UTF-8
- * format, regardless of the underlying operating system.
- *
- * As a fallback, SDL_RWFromFile() will transparently open a matching filename
- * in an Android app's `assets`.
- *
- * Closing the SDL_RWops will close the file handle SDL is holding internally.
- *
- * \param file a UTF-8 string representing the filename to open
- * \param mode an ASCII string representing the mode to be used for opening
- *             the file.
- * \returns a pointer to the SDL_RWops structure that is created, or NULL on
- *          failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_RWclose
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFP
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWseek
- * \sa SDL_RWtell
- * \sa SDL_RWwrite
- */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFile(const char *file,
-                                                  const char *mode);
-
-#ifdef HAVE_STDIO_H
-
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFP(FILE * fp, SDL_bool autoclose);
-
-#else
-
-/**
- * Use this function to create an SDL_RWops structure from a standard I/O file
- * pointer (stdio.h's `FILE*`).
- *
- * This function is not available on Windows, since files opened in an
- * application on that platform cannot be used by a dynamically linked
- * library.
- *
- * On some platforms, the first parameter is a `void*`, on others, it's a
- * `FILE*`, depending on what system headers are available to SDL. It is
- * always intended to be the `FILE*` type from the C runtime's stdio.h.
- *
- * \param fp the `FILE*` that feeds the SDL_RWops stream
- * \param autoclose SDL_TRUE to close the `FILE*` when closing the SDL_RWops,
- *                  SDL_FALSE to leave the `FILE*` open when the RWops is
- *                  closed
- * \returns a pointer to the SDL_RWops structure that is created, or NULL on
- *          failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_RWclose
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWseek
- * \sa SDL_RWtell
- * \sa SDL_RWwrite
- */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFP(void * fp,
-                                                SDL_bool autoclose);
-#endif
-
-/**
- * Use this function to prepare a read-write memory buffer for use with
- * SDL_RWops.
- *
- * This function sets up an SDL_RWops struct based on a memory area of a
- * certain size, for both read and write access.
- *
- * This memory buffer is not copied by the RWops; the pointer you provide must
- * remain valid until you close the stream. Closing the stream will not free
- * the original buffer.
- *
- * If you need to make sure the RWops never writes to the memory buffer, you
- * should use SDL_RWFromConstMem() with a read-only buffer of memory instead.
- *
- * \param mem a pointer to a buffer to feed an SDL_RWops stream
- * \param size the buffer size, in bytes
- * \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_RWclose
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromFP
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWseek
- * \sa SDL_RWtell
- * \sa SDL_RWwrite
- */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromMem(void *mem, int size);
-
-/**
- * Use this function to prepare a read-only memory buffer for use with RWops.
- *
- * This function sets up an SDL_RWops struct based on a memory area of a
- * certain size. It assumes the memory area is not writable.
- *
- * Attempting to write to this RWops stream will report an error without
- * writing to the memory buffer.
- *
- * This memory buffer is not copied by the RWops; the pointer you provide must
- * remain valid until you close the stream. Closing the stream will not free
- * the original buffer.
- *
- * If you need to write to a memory buffer, you should use SDL_RWFromMem()
- * with a writable buffer of memory instead.
- *
- * \param mem a pointer to a read-only buffer to feed an SDL_RWops stream
- * \param size the buffer size, in bytes
- * \returns a pointer to a new SDL_RWops structure, or NULL if it fails; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_RWclose
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromFP
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWseek
- * \sa SDL_RWtell
- */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromConstMem(const void *mem,
-                                                      int size);
-
-/* @} *//* RWFrom functions */
-
-
-/**
- * Use this function to allocate an empty, unpopulated SDL_RWops structure.
- *
- * Applications do not need to use this function unless they are providing
- * their own SDL_RWops implementation. If you just need a SDL_RWops to
- * read/write a common data source, you should use the built-in
- * implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc.
- *
- * You must free the returned pointer with SDL_FreeRW(). Depending on your
- * operating system and compiler, there may be a difference between the
- * malloc() and free() your program uses and the versions SDL calls
- * internally. Trying to mix the two can cause crashing such as segmentation
- * faults. Since all SDL_RWops must free themselves when their **close**
- * method is called, all SDL_RWops must be allocated through this function, so
- * they can all be freed correctly with SDL_FreeRW().
- *
- * \returns a pointer to the allocated memory on success, or NULL on failure;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_FreeRW
- */
-extern DECLSPEC SDL_RWops *SDLCALL SDL_AllocRW(void);
-
-/**
- * Use this function to free an SDL_RWops structure allocated by
- * SDL_AllocRW().
- *
- * Applications do not need to use this function unless they are providing
- * their own SDL_RWops implementation. If you just need a SDL_RWops to
- * read/write a common data source, you should use the built-in
- * implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc, and
- * call the **close** method on those SDL_RWops pointers when you are done
- * with them.
- *
- * Only use SDL_FreeRW() on pointers returned by SDL_AllocRW(). The pointer is
- * invalid as soon as this function returns. Any extra memory allocated during
- * creation of the SDL_RWops is not freed by SDL_FreeRW(); the programmer must
- * be responsible for managing that memory in their **close** method.
- *
- * \param area the SDL_RWops structure to be freed
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AllocRW
- */
-extern DECLSPEC void SDLCALL SDL_FreeRW(SDL_RWops * area);
-
-#define RW_SEEK_SET 0       /**< Seek from the beginning of data */
-#define RW_SEEK_CUR 1       /**< Seek relative to current read point */
-#define RW_SEEK_END 2       /**< Seek relative to the end of data */
-
-/**
- * Use this function to get the size of the data stream in an SDL_RWops.
- *
- * Prior to SDL 2.0.10, this function was a macro.
- *
- * \param context the SDL_RWops to get the size of the data stream from
- * \returns the size of the data stream in the SDL_RWops on success, -1 if
- *          unknown or a negative error code on failure; call SDL_GetError()
- *          for more information.
- *
- * \since This function is available since SDL 2.0.10.
- */
-extern DECLSPEC Sint64 SDLCALL SDL_RWsize(SDL_RWops *context);
-
-/**
- * Seek within an SDL_RWops data stream.
- *
- * This function seeks to byte `offset`, relative to `whence`.
- *
- * `whence` may be any of the following values:
- *
- * - `RW_SEEK_SET`: seek from the beginning of data
- * - `RW_SEEK_CUR`: seek relative to current read point
- * - `RW_SEEK_END`: seek relative to the end of data
- *
- * If this stream can not seek, it will return -1.
- *
- * SDL_RWseek() is actually a wrapper function that calls the SDL_RWops's
- * `seek` method appropriately, to simplify application development.
- *
- * Prior to SDL 2.0.10, this function was a macro.
- *
- * \param context a pointer to an SDL_RWops structure
- * \param offset an offset in bytes, relative to **whence** location; can be
- *               negative
- * \param whence any of `RW_SEEK_SET`, `RW_SEEK_CUR`, `RW_SEEK_END`
- * \returns the final offset in the data stream after the seek or -1 on error.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_RWclose
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromFP
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWtell
- * \sa SDL_RWwrite
- */
-extern DECLSPEC Sint64 SDLCALL SDL_RWseek(SDL_RWops *context,
-                                          Sint64 offset, int whence);
-
-/**
- * Determine the current read/write offset in an SDL_RWops data stream.
- *
- * SDL_RWtell is actually a wrapper function that calls the SDL_RWops's `seek`
- * method, with an offset of 0 bytes from `RW_SEEK_CUR`, to simplify
- * application development.
- *
- * Prior to SDL 2.0.10, this function was a macro.
- *
- * \param context a SDL_RWops data stream object from which to get the current
- *                offset
- * \returns the current offset in the stream, or -1 if the information can not
- *          be determined.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_RWclose
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromFP
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWseek
- * \sa SDL_RWwrite
- */
-extern DECLSPEC Sint64 SDLCALL SDL_RWtell(SDL_RWops *context);
-
-/**
- * Read from a data source.
- *
- * This function reads up to `maxnum` objects each of size `size` from the
- * data source to the area pointed at by `ptr`. This function may read less
- * objects than requested. It will return zero when there has been an error or
- * the data stream is completely read.
- *
- * SDL_RWread() is actually a function wrapper that calls the SDL_RWops's
- * `read` method appropriately, to simplify application development.
- *
- * Prior to SDL 2.0.10, this function was a macro.
- *
- * \param context a pointer to an SDL_RWops structure
- * \param ptr a pointer to a buffer to read data into
- * \param size the size of each object to read, in bytes
- * \param maxnum the maximum number of objects to be read
- * \returns the number of objects read, or 0 at error or end of file; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_RWclose
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromFP
- * \sa SDL_RWFromMem
- * \sa SDL_RWseek
- * \sa SDL_RWwrite
- */
-extern DECLSPEC size_t SDLCALL SDL_RWread(SDL_RWops *context,
-                                          void *ptr, size_t size,
-                                          size_t maxnum);
-
-/**
- * Write to an SDL_RWops data stream.
- *
- * This function writes exactly `num` objects each of size `size` from the
- * area pointed at by `ptr` to the stream. If this fails for any reason, it'll
- * return less than `num` to demonstrate how far the write progressed. On
- * success, it returns `num`.
- *
- * SDL_RWwrite is actually a function wrapper that calls the SDL_RWops's
- * `write` method appropriately, to simplify application development.
- *
- * Prior to SDL 2.0.10, this function was a macro.
- *
- * \param context a pointer to an SDL_RWops structure
- * \param ptr a pointer to a buffer containing data to write
- * \param size the size of an object to write, in bytes
- * \param num the number of objects to write
- * \returns the number of objects written, which will be less than **num** on
- *          error; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_RWclose
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromFP
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWseek
- */
-extern DECLSPEC size_t SDLCALL SDL_RWwrite(SDL_RWops *context,
-                                           const void *ptr, size_t size,
-                                           size_t num);
-
-/**
- * Close and free an allocated SDL_RWops structure.
- *
- * SDL_RWclose() closes and cleans up the SDL_RWops stream. It releases any
- * resources used by the stream and frees the SDL_RWops itself with
- * SDL_FreeRW(). This returns 0 on success, or -1 if the stream failed to
- * flush to its output (e.g. to disk).
- *
- * Note that if this fails to flush the stream to disk, this function reports
- * an error, but the SDL_RWops is still invalid once this function returns.
- *
- * Prior to SDL 2.0.10, this function was a macro.
- *
- * \param context SDL_RWops structure to close
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.10.
- *
- * \sa SDL_RWFromConstMem
- * \sa SDL_RWFromFile
- * \sa SDL_RWFromFP
- * \sa SDL_RWFromMem
- * \sa SDL_RWread
- * \sa SDL_RWseek
- * \sa SDL_RWwrite
- */
-extern DECLSPEC int SDLCALL SDL_RWclose(SDL_RWops *context);
-
-/**
- * Load all the data from an SDL data stream.
- *
- * The data is allocated with a zero byte at the end (null terminated) for
- * convenience. This extra byte is not included in the value reported via
- * `datasize`.
- *
- * The data should be freed with SDL_free().
- *
- * \param src the SDL_RWops to read all available data from
- * \param datasize if not NULL, will store the number of bytes read
- * \param freesrc if non-zero, calls SDL_RWclose() on `src` before returning
- * \returns the data, or NULL if there was an error.
- *
- * \since This function is available since SDL 2.0.6.
- */
-extern DECLSPEC void *SDLCALL SDL_LoadFile_RW(SDL_RWops *src,
-                                              size_t *datasize,
-                                              int freesrc);
-
-/**
- * Load all the data from a file path.
- *
- * The data is allocated with a zero byte at the end (null terminated) for
- * convenience. This extra byte is not included in the value reported via
- * `datasize`.
- *
- * The data should be freed with SDL_free().
- *
- * Prior to SDL 2.0.10, this function was a macro wrapping around
- * SDL_LoadFile_RW.
- *
- * \param file the path to read all available data from
- * \param datasize if not NULL, will store the number of bytes read
- * \returns the data, or NULL if there was an error.
- *
- * \since This function is available since SDL 2.0.10.
- */
-extern DECLSPEC void *SDLCALL SDL_LoadFile(const char *file, size_t *datasize);
-
-/**
- *  \name Read endian functions
- *
- *  Read an item of the specified endianness and return in native format.
- */
-/* @{ */
-
-/**
- * Use this function to read a byte from an SDL_RWops.
- *
- * \param src the SDL_RWops to read from
- * \returns the read byte on success or 0 on failure; call SDL_GetError() for
- *          more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WriteU8
- */
-extern DECLSPEC Uint8 SDLCALL SDL_ReadU8(SDL_RWops * src);
-
-/**
- * Use this function to read 16 bits of little-endian data from an SDL_RWops
- * and return in native format.
- *
- * SDL byteswaps the data only if necessary, so the data returned will be in
- * the native byte order.
- *
- * \param src the stream from which to read data
- * \returns 16 bits of data in the native byte order of the platform.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ReadBE16
- */
-extern DECLSPEC Uint16 SDLCALL SDL_ReadLE16(SDL_RWops * src);
-
-/**
- * Use this function to read 16 bits of big-endian data from an SDL_RWops and
- * return in native format.
- *
- * SDL byteswaps the data only if necessary, so the data returned will be in
- * the native byte order.
- *
- * \param src the stream from which to read data
- * \returns 16 bits of data in the native byte order of the platform.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ReadLE16
- */
-extern DECLSPEC Uint16 SDLCALL SDL_ReadBE16(SDL_RWops * src);
-
-/**
- * Use this function to read 32 bits of little-endian data from an SDL_RWops
- * and return in native format.
- *
- * SDL byteswaps the data only if necessary, so the data returned will be in
- * the native byte order.
- *
- * \param src the stream from which to read data
- * \returns 32 bits of data in the native byte order of the platform.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ReadBE32
- */
-extern DECLSPEC Uint32 SDLCALL SDL_ReadLE32(SDL_RWops * src);
-
-/**
- * Use this function to read 32 bits of big-endian data from an SDL_RWops and
- * return in native format.
- *
- * SDL byteswaps the data only if necessary, so the data returned will be in
- * the native byte order.
- *
- * \param src the stream from which to read data
- * \returns 32 bits of data in the native byte order of the platform.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ReadLE32
- */
-extern DECLSPEC Uint32 SDLCALL SDL_ReadBE32(SDL_RWops * src);
-
-/**
- * Use this function to read 64 bits of little-endian data from an SDL_RWops
- * and return in native format.
- *
- * SDL byteswaps the data only if necessary, so the data returned will be in
- * the native byte order.
- *
- * \param src the stream from which to read data
- * \returns 64 bits of data in the native byte order of the platform.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ReadBE64
- */
-extern DECLSPEC Uint64 SDLCALL SDL_ReadLE64(SDL_RWops * src);
-
-/**
- * Use this function to read 64 bits of big-endian data from an SDL_RWops and
- * return in native format.
- *
- * SDL byteswaps the data only if necessary, so the data returned will be in
- * the native byte order.
- *
- * \param src the stream from which to read data
- * \returns 64 bits of data in the native byte order of the platform.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ReadLE64
- */
-extern DECLSPEC Uint64 SDLCALL SDL_ReadBE64(SDL_RWops * src);
-/* @} *//* Read endian functions */
-
-/**
- *  \name Write endian functions
- *
- *  Write an item of native format to the specified endianness.
- */
-/* @{ */
-
-/**
- * Use this function to write a byte to an SDL_RWops.
- *
- * \param dst the SDL_RWops to write to
- * \param value the byte value to write
- * \returns 1 on success or 0 on failure; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ReadU8
- */
-extern DECLSPEC size_t SDLCALL SDL_WriteU8(SDL_RWops * dst, Uint8 value);
-
-/**
- * Use this function to write 16 bits in native format to a SDL_RWops as
- * little-endian data.
- *
- * SDL byteswaps the data only if necessary, so the application always
- * specifies native format, and the data written will be in little-endian
- * format.
- *
- * \param dst the stream to which data will be written
- * \param value the data to be written, in native format
- * \returns 1 on successful write, 0 on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WriteBE16
- */
-extern DECLSPEC size_t SDLCALL SDL_WriteLE16(SDL_RWops * dst, Uint16 value);
-
-/**
- * Use this function to write 16 bits in native format to a SDL_RWops as
- * big-endian data.
- *
- * SDL byteswaps the data only if necessary, so the application always
- * specifies native format, and the data written will be in big-endian format.
- *
- * \param dst the stream to which data will be written
- * \param value the data to be written, in native format
- * \returns 1 on successful write, 0 on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WriteLE16
- */
-extern DECLSPEC size_t SDLCALL SDL_WriteBE16(SDL_RWops * dst, Uint16 value);
-
-/**
- * Use this function to write 32 bits in native format to a SDL_RWops as
- * little-endian data.
- *
- * SDL byteswaps the data only if necessary, so the application always
- * specifies native format, and the data written will be in little-endian
- * format.
- *
- * \param dst the stream to which data will be written
- * \param value the data to be written, in native format
- * \returns 1 on successful write, 0 on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WriteBE32
- */
-extern DECLSPEC size_t SDLCALL SDL_WriteLE32(SDL_RWops * dst, Uint32 value);
-
-/**
- * Use this function to write 32 bits in native format to a SDL_RWops as
- * big-endian data.
- *
- * SDL byteswaps the data only if necessary, so the application always
- * specifies native format, and the data written will be in big-endian format.
- *
- * \param dst the stream to which data will be written
- * \param value the data to be written, in native format
- * \returns 1 on successful write, 0 on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WriteLE32
- */
-extern DECLSPEC size_t SDLCALL SDL_WriteBE32(SDL_RWops * dst, Uint32 value);
-
-/**
- * Use this function to write 64 bits in native format to a SDL_RWops as
- * little-endian data.
- *
- * SDL byteswaps the data only if necessary, so the application always
- * specifies native format, and the data written will be in little-endian
- * format.
- *
- * \param dst the stream to which data will be written
- * \param value the data to be written, in native format
- * \returns 1 on successful write, 0 on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WriteBE64
- */
-extern DECLSPEC size_t SDLCALL SDL_WriteLE64(SDL_RWops * dst, Uint64 value);
-
-/**
- * Use this function to write 64 bits in native format to a SDL_RWops as
- * big-endian data.
- *
- * SDL byteswaps the data only if necessary, so the application always
- * specifies native format, and the data written will be in big-endian format.
- *
- * \param dst the stream to which data will be written
- * \param value the data to be written, in native format
- * \returns 1 on successful write, 0 on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WriteLE64
- */
-extern DECLSPEC size_t SDLCALL SDL_WriteBE64(SDL_RWops * dst, Uint64 value);
-/* @} *//* Write endian functions */
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_rwops_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,413 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_scancode.h
- *
- *  Defines keyboard scancodes.
- */
-
-#ifndef SDL_scancode_h_
-#define SDL_scancode_h_
-
-#include "SDL_stdinc.h"
-
-/**
- *  \brief The SDL keyboard scancode representation.
- *
- *  Values of this type are used to represent keyboard keys, among other places
- *  in the \link SDL_Keysym::scancode key.keysym.scancode \endlink field of the
- *  SDL_Event structure.
- *
- *  The values in this enumeration are based on the USB usage page standard:
- *  https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf
- */
-typedef enum
-{
-    SDL_SCANCODE_UNKNOWN = 0,
-
-    /**
-     *  \name Usage page 0x07
-     *
-     *  These values are from usage page 0x07 (USB keyboard page).
-     */
-    /* @{ */
-
-    SDL_SCANCODE_A = 4,
-    SDL_SCANCODE_B = 5,
-    SDL_SCANCODE_C = 6,
-    SDL_SCANCODE_D = 7,
-    SDL_SCANCODE_E = 8,
-    SDL_SCANCODE_F = 9,
-    SDL_SCANCODE_G = 10,
-    SDL_SCANCODE_H = 11,
-    SDL_SCANCODE_I = 12,
-    SDL_SCANCODE_J = 13,
-    SDL_SCANCODE_K = 14,
-    SDL_SCANCODE_L = 15,
-    SDL_SCANCODE_M = 16,
-    SDL_SCANCODE_N = 17,
-    SDL_SCANCODE_O = 18,
-    SDL_SCANCODE_P = 19,
-    SDL_SCANCODE_Q = 20,
-    SDL_SCANCODE_R = 21,
-    SDL_SCANCODE_S = 22,
-    SDL_SCANCODE_T = 23,
-    SDL_SCANCODE_U = 24,
-    SDL_SCANCODE_V = 25,
-    SDL_SCANCODE_W = 26,
-    SDL_SCANCODE_X = 27,
-    SDL_SCANCODE_Y = 28,
-    SDL_SCANCODE_Z = 29,
-
-    SDL_SCANCODE_1 = 30,
-    SDL_SCANCODE_2 = 31,
-    SDL_SCANCODE_3 = 32,
-    SDL_SCANCODE_4 = 33,
-    SDL_SCANCODE_5 = 34,
-    SDL_SCANCODE_6 = 35,
-    SDL_SCANCODE_7 = 36,
-    SDL_SCANCODE_8 = 37,
-    SDL_SCANCODE_9 = 38,
-    SDL_SCANCODE_0 = 39,
-
-    SDL_SCANCODE_RETURN = 40,
-    SDL_SCANCODE_ESCAPE = 41,
-    SDL_SCANCODE_BACKSPACE = 42,
-    SDL_SCANCODE_TAB = 43,
-    SDL_SCANCODE_SPACE = 44,
-
-    SDL_SCANCODE_MINUS = 45,
-    SDL_SCANCODE_EQUALS = 46,
-    SDL_SCANCODE_LEFTBRACKET = 47,
-    SDL_SCANCODE_RIGHTBRACKET = 48,
-    SDL_SCANCODE_BACKSLASH = 49, /**< Located at the lower left of the return
-                                  *   key on ISO keyboards and at the right end
-                                  *   of the QWERTY row on ANSI keyboards.
-                                  *   Produces REVERSE SOLIDUS (backslash) and
-                                  *   VERTICAL LINE in a US layout, REVERSE
-                                  *   SOLIDUS and VERTICAL LINE in a UK Mac
-                                  *   layout, NUMBER SIGN and TILDE in a UK
-                                  *   Windows layout, DOLLAR SIGN and POUND SIGN
-                                  *   in a Swiss German layout, NUMBER SIGN and
-                                  *   APOSTROPHE in a German layout, GRAVE
-                                  *   ACCENT and POUND SIGN in a French Mac
-                                  *   layout, and ASTERISK and MICRO SIGN in a
-                                  *   French Windows layout.
-                                  */
-    SDL_SCANCODE_NONUSHASH = 50, /**< ISO USB keyboards actually use this code
-                                  *   instead of 49 for the same key, but all
-                                  *   OSes I've seen treat the two codes
-                                  *   identically. So, as an implementor, unless
-                                  *   your keyboard generates both of those
-                                  *   codes and your OS treats them differently,
-                                  *   you should generate SDL_SCANCODE_BACKSLASH
-                                  *   instead of this code. As a user, you
-                                  *   should not rely on this code because SDL
-                                  *   will never generate it with most (all?)
-                                  *   keyboards.
-                                  */
-    SDL_SCANCODE_SEMICOLON = 51,
-    SDL_SCANCODE_APOSTROPHE = 52,
-    SDL_SCANCODE_GRAVE = 53, /**< Located in the top left corner (on both ANSI
-                              *   and ISO keyboards). Produces GRAVE ACCENT and
-                              *   TILDE in a US Windows layout and in US and UK
-                              *   Mac layouts on ANSI keyboards, GRAVE ACCENT
-                              *   and NOT SIGN in a UK Windows layout, SECTION
-                              *   SIGN and PLUS-MINUS SIGN in US and UK Mac
-                              *   layouts on ISO keyboards, SECTION SIGN and
-                              *   DEGREE SIGN in a Swiss German layout (Mac:
-                              *   only on ISO keyboards), CIRCUMFLEX ACCENT and
-                              *   DEGREE SIGN in a German layout (Mac: only on
-                              *   ISO keyboards), SUPERSCRIPT TWO and TILDE in a
-                              *   French Windows layout, COMMERCIAL AT and
-                              *   NUMBER SIGN in a French Mac layout on ISO
-                              *   keyboards, and LESS-THAN SIGN and GREATER-THAN
-                              *   SIGN in a Swiss German, German, or French Mac
-                              *   layout on ANSI keyboards.
-                              */
-    SDL_SCANCODE_COMMA = 54,
-    SDL_SCANCODE_PERIOD = 55,
-    SDL_SCANCODE_SLASH = 56,
-
-    SDL_SCANCODE_CAPSLOCK = 57,
-
-    SDL_SCANCODE_F1 = 58,
-    SDL_SCANCODE_F2 = 59,
-    SDL_SCANCODE_F3 = 60,
-    SDL_SCANCODE_F4 = 61,
-    SDL_SCANCODE_F5 = 62,
-    SDL_SCANCODE_F6 = 63,
-    SDL_SCANCODE_F7 = 64,
-    SDL_SCANCODE_F8 = 65,
-    SDL_SCANCODE_F9 = 66,
-    SDL_SCANCODE_F10 = 67,
-    SDL_SCANCODE_F11 = 68,
-    SDL_SCANCODE_F12 = 69,
-
-    SDL_SCANCODE_PRINTSCREEN = 70,
-    SDL_SCANCODE_SCROLLLOCK = 71,
-    SDL_SCANCODE_PAUSE = 72,
-    SDL_SCANCODE_INSERT = 73, /**< insert on PC, help on some Mac keyboards (but
-                                   does send code 73, not 117) */
-    SDL_SCANCODE_HOME = 74,
-    SDL_SCANCODE_PAGEUP = 75,
-    SDL_SCANCODE_DELETE = 76,
-    SDL_SCANCODE_END = 77,
-    SDL_SCANCODE_PAGEDOWN = 78,
-    SDL_SCANCODE_RIGHT = 79,
-    SDL_SCANCODE_LEFT = 80,
-    SDL_SCANCODE_DOWN = 81,
-    SDL_SCANCODE_UP = 82,
-
-    SDL_SCANCODE_NUMLOCKCLEAR = 83, /**< num lock on PC, clear on Mac keyboards
-                                     */
-    SDL_SCANCODE_KP_DIVIDE = 84,
-    SDL_SCANCODE_KP_MULTIPLY = 85,
-    SDL_SCANCODE_KP_MINUS = 86,
-    SDL_SCANCODE_KP_PLUS = 87,
-    SDL_SCANCODE_KP_ENTER = 88,
-    SDL_SCANCODE_KP_1 = 89,
-    SDL_SCANCODE_KP_2 = 90,
-    SDL_SCANCODE_KP_3 = 91,
-    SDL_SCANCODE_KP_4 = 92,
-    SDL_SCANCODE_KP_5 = 93,
-    SDL_SCANCODE_KP_6 = 94,
-    SDL_SCANCODE_KP_7 = 95,
-    SDL_SCANCODE_KP_8 = 96,
-    SDL_SCANCODE_KP_9 = 97,
-    SDL_SCANCODE_KP_0 = 98,
-    SDL_SCANCODE_KP_PERIOD = 99,
-
-    SDL_SCANCODE_NONUSBACKSLASH = 100, /**< This is the additional key that ISO
-                                        *   keyboards have over ANSI ones,
-                                        *   located between left shift and Y.
-                                        *   Produces GRAVE ACCENT and TILDE in a
-                                        *   US or UK Mac layout, REVERSE SOLIDUS
-                                        *   (backslash) and VERTICAL LINE in a
-                                        *   US or UK Windows layout, and
-                                        *   LESS-THAN SIGN and GREATER-THAN SIGN
-                                        *   in a Swiss German, German, or French
-                                        *   layout. */
-    SDL_SCANCODE_APPLICATION = 101, /**< windows contextual menu, compose */
-    SDL_SCANCODE_POWER = 102, /**< The USB document says this is a status flag,
-                               *   not a physical key - but some Mac keyboards
-                               *   do have a power key. */
-    SDL_SCANCODE_KP_EQUALS = 103,
-    SDL_SCANCODE_F13 = 104,
-    SDL_SCANCODE_F14 = 105,
-    SDL_SCANCODE_F15 = 106,
-    SDL_SCANCODE_F16 = 107,
-    SDL_SCANCODE_F17 = 108,
-    SDL_SCANCODE_F18 = 109,
-    SDL_SCANCODE_F19 = 110,
-    SDL_SCANCODE_F20 = 111,
-    SDL_SCANCODE_F21 = 112,
-    SDL_SCANCODE_F22 = 113,
-    SDL_SCANCODE_F23 = 114,
-    SDL_SCANCODE_F24 = 115,
-    SDL_SCANCODE_EXECUTE = 116,
-    SDL_SCANCODE_HELP = 117,
-    SDL_SCANCODE_MENU = 118,
-    SDL_SCANCODE_SELECT = 119,
-    SDL_SCANCODE_STOP = 120,
-    SDL_SCANCODE_AGAIN = 121,   /**< redo */
-    SDL_SCANCODE_UNDO = 122,
-    SDL_SCANCODE_CUT = 123,
-    SDL_SCANCODE_COPY = 124,
-    SDL_SCANCODE_PASTE = 125,
-    SDL_SCANCODE_FIND = 126,
-    SDL_SCANCODE_MUTE = 127,
-    SDL_SCANCODE_VOLUMEUP = 128,
-    SDL_SCANCODE_VOLUMEDOWN = 129,
-/* not sure whether there's a reason to enable these */
-/*     SDL_SCANCODE_LOCKINGCAPSLOCK = 130,  */
-/*     SDL_SCANCODE_LOCKINGNUMLOCK = 131, */
-/*     SDL_SCANCODE_LOCKINGSCROLLLOCK = 132, */
-    SDL_SCANCODE_KP_COMMA = 133,
-    SDL_SCANCODE_KP_EQUALSAS400 = 134,
-
-    SDL_SCANCODE_INTERNATIONAL1 = 135, /**< used on Asian keyboards, see
-                                            footnotes in USB doc */
-    SDL_SCANCODE_INTERNATIONAL2 = 136,
-    SDL_SCANCODE_INTERNATIONAL3 = 137, /**< Yen */
-    SDL_SCANCODE_INTERNATIONAL4 = 138,
-    SDL_SCANCODE_INTERNATIONAL5 = 139,
-    SDL_SCANCODE_INTERNATIONAL6 = 140,
-    SDL_SCANCODE_INTERNATIONAL7 = 141,
-    SDL_SCANCODE_INTERNATIONAL8 = 142,
-    SDL_SCANCODE_INTERNATIONAL9 = 143,
-    SDL_SCANCODE_LANG1 = 144, /**< Hangul/English toggle */
-    SDL_SCANCODE_LANG2 = 145, /**< Hanja conversion */
-    SDL_SCANCODE_LANG3 = 146, /**< Katakana */
-    SDL_SCANCODE_LANG4 = 147, /**< Hiragana */
-    SDL_SCANCODE_LANG5 = 148, /**< Zenkaku/Hankaku */
-    SDL_SCANCODE_LANG6 = 149, /**< reserved */
-    SDL_SCANCODE_LANG7 = 150, /**< reserved */
-    SDL_SCANCODE_LANG8 = 151, /**< reserved */
-    SDL_SCANCODE_LANG9 = 152, /**< reserved */
-
-    SDL_SCANCODE_ALTERASE = 153, /**< Erase-Eaze */
-    SDL_SCANCODE_SYSREQ = 154,
-    SDL_SCANCODE_CANCEL = 155,
-    SDL_SCANCODE_CLEAR = 156,
-    SDL_SCANCODE_PRIOR = 157,
-    SDL_SCANCODE_RETURN2 = 158,
-    SDL_SCANCODE_SEPARATOR = 159,
-    SDL_SCANCODE_OUT = 160,
-    SDL_SCANCODE_OPER = 161,
-    SDL_SCANCODE_CLEARAGAIN = 162,
-    SDL_SCANCODE_CRSEL = 163,
-    SDL_SCANCODE_EXSEL = 164,
-
-    SDL_SCANCODE_KP_00 = 176,
-    SDL_SCANCODE_KP_000 = 177,
-    SDL_SCANCODE_THOUSANDSSEPARATOR = 178,
-    SDL_SCANCODE_DECIMALSEPARATOR = 179,
-    SDL_SCANCODE_CURRENCYUNIT = 180,
-    SDL_SCANCODE_CURRENCYSUBUNIT = 181,
-    SDL_SCANCODE_KP_LEFTPAREN = 182,
-    SDL_SCANCODE_KP_RIGHTPAREN = 183,
-    SDL_SCANCODE_KP_LEFTBRACE = 184,
-    SDL_SCANCODE_KP_RIGHTBRACE = 185,
-    SDL_SCANCODE_KP_TAB = 186,
-    SDL_SCANCODE_KP_BACKSPACE = 187,
-    SDL_SCANCODE_KP_A = 188,
-    SDL_SCANCODE_KP_B = 189,
-    SDL_SCANCODE_KP_C = 190,
-    SDL_SCANCODE_KP_D = 191,
-    SDL_SCANCODE_KP_E = 192,
-    SDL_SCANCODE_KP_F = 193,
-    SDL_SCANCODE_KP_XOR = 194,
-    SDL_SCANCODE_KP_POWER = 195,
-    SDL_SCANCODE_KP_PERCENT = 196,
-    SDL_SCANCODE_KP_LESS = 197,
-    SDL_SCANCODE_KP_GREATER = 198,
-    SDL_SCANCODE_KP_AMPERSAND = 199,
-    SDL_SCANCODE_KP_DBLAMPERSAND = 200,
-    SDL_SCANCODE_KP_VERTICALBAR = 201,
-    SDL_SCANCODE_KP_DBLVERTICALBAR = 202,
-    SDL_SCANCODE_KP_COLON = 203,
-    SDL_SCANCODE_KP_HASH = 204,
-    SDL_SCANCODE_KP_SPACE = 205,
-    SDL_SCANCODE_KP_AT = 206,
-    SDL_SCANCODE_KP_EXCLAM = 207,
-    SDL_SCANCODE_KP_MEMSTORE = 208,
-    SDL_SCANCODE_KP_MEMRECALL = 209,
-    SDL_SCANCODE_KP_MEMCLEAR = 210,
-    SDL_SCANCODE_KP_MEMADD = 211,
-    SDL_SCANCODE_KP_MEMSUBTRACT = 212,
-    SDL_SCANCODE_KP_MEMMULTIPLY = 213,
-    SDL_SCANCODE_KP_MEMDIVIDE = 214,
-    SDL_SCANCODE_KP_PLUSMINUS = 215,
-    SDL_SCANCODE_KP_CLEAR = 216,
-    SDL_SCANCODE_KP_CLEARENTRY = 217,
-    SDL_SCANCODE_KP_BINARY = 218,
-    SDL_SCANCODE_KP_OCTAL = 219,
-    SDL_SCANCODE_KP_DECIMAL = 220,
-    SDL_SCANCODE_KP_HEXADECIMAL = 221,
-
-    SDL_SCANCODE_LCTRL = 224,
-    SDL_SCANCODE_LSHIFT = 225,
-    SDL_SCANCODE_LALT = 226, /**< alt, option */
-    SDL_SCANCODE_LGUI = 227, /**< windows, command (apple), meta */
-    SDL_SCANCODE_RCTRL = 228,
-    SDL_SCANCODE_RSHIFT = 229,
-    SDL_SCANCODE_RALT = 230, /**< alt gr, option */
-    SDL_SCANCODE_RGUI = 231, /**< windows, command (apple), meta */
-
-    SDL_SCANCODE_MODE = 257,    /**< I'm not sure if this is really not covered
-                                 *   by any of the above, but since there's a
-                                 *   special KMOD_MODE for it I'm adding it here
-                                 */
-
-    /* @} *//* Usage page 0x07 */
-
-    /**
-     *  \name Usage page 0x0C
-     *
-     *  These values are mapped from usage page 0x0C (USB consumer page).
-     */
-    /* @{ */
-
-    SDL_SCANCODE_AUDIONEXT = 258,
-    SDL_SCANCODE_AUDIOPREV = 259,
-    SDL_SCANCODE_AUDIOSTOP = 260,
-    SDL_SCANCODE_AUDIOPLAY = 261,
-    SDL_SCANCODE_AUDIOMUTE = 262,
-    SDL_SCANCODE_MEDIASELECT = 263,
-    SDL_SCANCODE_WWW = 264,
-    SDL_SCANCODE_MAIL = 265,
-    SDL_SCANCODE_CALCULATOR = 266,
-    SDL_SCANCODE_COMPUTER = 267,
-    SDL_SCANCODE_AC_SEARCH = 268,
-    SDL_SCANCODE_AC_HOME = 269,
-    SDL_SCANCODE_AC_BACK = 270,
-    SDL_SCANCODE_AC_FORWARD = 271,
-    SDL_SCANCODE_AC_STOP = 272,
-    SDL_SCANCODE_AC_REFRESH = 273,
-    SDL_SCANCODE_AC_BOOKMARKS = 274,
-
-    /* @} *//* Usage page 0x0C */
-
-    /**
-     *  \name Walther keys
-     *
-     *  These are values that Christian Walther added (for mac keyboard?).
-     */
-    /* @{ */
-
-    SDL_SCANCODE_BRIGHTNESSDOWN = 275,
-    SDL_SCANCODE_BRIGHTNESSUP = 276,
-    SDL_SCANCODE_DISPLAYSWITCH = 277, /**< display mirroring/dual display
-                                           switch, video mode switch */
-    SDL_SCANCODE_KBDILLUMTOGGLE = 278,
-    SDL_SCANCODE_KBDILLUMDOWN = 279,
-    SDL_SCANCODE_KBDILLUMUP = 280,
-    SDL_SCANCODE_EJECT = 281,
-    SDL_SCANCODE_SLEEP = 282,
-
-    SDL_SCANCODE_APP1 = 283,
-    SDL_SCANCODE_APP2 = 284,
-
-    /* @} *//* Walther keys */
-
-    /**
-     *  \name Usage page 0x0C (additional media keys)
-     *
-     *  These values are mapped from usage page 0x0C (USB consumer page).
-     */
-    /* @{ */
-
-    SDL_SCANCODE_AUDIOREWIND = 285,
-    SDL_SCANCODE_AUDIOFASTFORWARD = 286,
-
-    /* @} *//* Usage page 0x0C (additional media keys) */
-
-    /* Add any other keys here. */
-
-    SDL_NUM_SCANCODES = 512 /**< not a key, just marks the number of scancodes
-                                 for array bounds */
-} SDL_Scancode;
-
-#endif /* SDL_scancode_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,155 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_shape_h_
-#define SDL_shape_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_pixels.h"
-#include "SDL_rect.h"
-#include "SDL_surface.h"
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** \file SDL_shape.h
- *
- * Header file for the shaped window API.
- */
-
-#define SDL_NONSHAPEABLE_WINDOW -1
-#define SDL_INVALID_SHAPE_ARGUMENT -2
-#define SDL_WINDOW_LACKS_SHAPE -3
-
-/**
- * Create a window that can be shaped with the specified position, dimensions,
- * and flags.
- *
- * \param title The title of the window, in UTF-8 encoding.
- * \param x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or
- *          ::SDL_WINDOWPOS_UNDEFINED.
- * \param y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or
- *          ::SDL_WINDOWPOS_UNDEFINED.
- * \param w The width of the window.
- * \param h The height of the window.
- * \param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with
- *              any of the following: ::SDL_WINDOW_OPENGL,
- *              ::SDL_WINDOW_INPUT_GRABBED, ::SDL_WINDOW_HIDDEN,
- *              ::SDL_WINDOW_RESIZABLE, ::SDL_WINDOW_MAXIMIZED,
- *              ::SDL_WINDOW_MINIMIZED, ::SDL_WINDOW_BORDERLESS is always set,
- *              and ::SDL_WINDOW_FULLSCREEN is always unset.
- * \return the window created, or NULL if window creation failed.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_DestroyWindow
- */
-extern DECLSPEC SDL_Window * SDLCALL SDL_CreateShapedWindow(const char *title,unsigned int x,unsigned int y,unsigned int w,unsigned int h,Uint32 flags);
-
-/**
- * Return whether the given window is a shaped window.
- *
- * \param window The window to query for being shaped.
- * \return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if
- *         the window is unshaped or NULL.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateShapedWindow
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsShapedWindow(const SDL_Window *window);
-
-/** \brief An enum denoting the specific type of contents present in an SDL_WindowShapeParams union. */
-typedef enum {
-    /** \brief The default mode, a binarized alpha cutoff of 1. */
-    ShapeModeDefault,
-    /** \brief A binarized alpha cutoff with a given integer value. */
-    ShapeModeBinarizeAlpha,
-    /** \brief A binarized alpha cutoff with a given integer value, but with the opposite comparison. */
-    ShapeModeReverseBinarizeAlpha,
-    /** \brief A color key is applied. */
-    ShapeModeColorKey
-} WindowShapeMode;
-
-#define SDL_SHAPEMODEALPHA(mode) (mode == ShapeModeDefault || mode == ShapeModeBinarizeAlpha || mode == ShapeModeReverseBinarizeAlpha)
-
-/** \brief A union containing parameters for shaped windows. */
-typedef union {
-    /** \brief A cutoff alpha value for binarization of the window shape's alpha channel. */
-    Uint8 binarizationCutoff;
-    SDL_Color colorKey;
-} SDL_WindowShapeParams;
-
-/** \brief A struct that tags the SDL_WindowShapeParams union with an enum describing the type of its contents. */
-typedef struct SDL_WindowShapeMode {
-    /** \brief The mode of these window-shape parameters. */
-    WindowShapeMode mode;
-    /** \brief Window-shape parameters. */
-    SDL_WindowShapeParams parameters;
-} SDL_WindowShapeMode;
-
-/**
- * Set the shape and parameters of a shaped window.
- *
- * \param window The shaped window whose parameters should be set.
- * \param shape A surface encoding the desired shape for the window.
- * \param shape_mode The parameters to set for the shaped window.
- * \return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape
- *         argument, or SDL_NONSHAPEABLE_WINDOW if the SDL_Window given does
- *         not reference a valid shaped window.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WindowShapeMode
- * \sa SDL_GetShapedWindowMode
- */
-extern DECLSPEC int SDLCALL SDL_SetWindowShape(SDL_Window *window,SDL_Surface *shape,SDL_WindowShapeMode *shape_mode);
-
-/**
- * Get the shape parameters of a shaped window.
- *
- * \param window The shaped window whose parameters should be retrieved.
- * \param shape_mode An empty shape-mode structure to fill, or NULL to check
- *                   whether the window has a shape.
- * \return 0 if the window has a shape and, provided shape_mode was not NULL,
- *         shape_mode has been filled with the mode data,
- *         SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped
- *         window, or SDL_WINDOW_LACKS_SHAPE if the SDL_Window given is a
- *         shapeable window currently lacking a shape.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_WindowShapeMode
- * \sa SDL_SetWindowShape
- */
-extern DECLSPEC int SDLCALL SDL_GetShapedWindowMode(SDL_Window *window,SDL_WindowShapeMode *shape_mode);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_shape_h_ */
@@ -1,738 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_stdinc.h
- *
- *  This is a general header that includes C language support.
- */
-
-#ifndef SDL_stdinc_h_
-#define SDL_stdinc_h_
-
-#include "SDL_config.h"
-
-#ifdef __APPLE__
-#ifndef _DARWIN_C_SOURCE
-#define _DARWIN_C_SOURCE 1 /* for memset_pattern4() */
-#endif
-#endif
-
-#ifdef HAVE_SYS_TYPES_H
-#include <sys/types.h>
-#endif
-#ifdef HAVE_STDIO_H
-#include <stdio.h>
-#endif
-#if defined(STDC_HEADERS)
-# include <stdlib.h>
-# include <stddef.h>
-# include <stdarg.h>
-#else
-# if defined(HAVE_STDLIB_H)
-#  include <stdlib.h>
-# elif defined(HAVE_MALLOC_H)
-#  include <malloc.h>
-# endif
-# if defined(HAVE_STDDEF_H)
-#  include <stddef.h>
-# endif
-# if defined(HAVE_STDARG_H)
-#  include <stdarg.h>
-# endif
-#endif
-#ifdef HAVE_STRING_H
-# if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
-#  include <memory.h>
-# endif
-# include <string.h>
-#endif
-#ifdef HAVE_STRINGS_H
-# include <strings.h>
-#endif
-#ifdef HAVE_WCHAR_H
-# include <wchar.h>
-#endif
-#if defined(HAVE_INTTYPES_H)
-# include <inttypes.h>
-#elif defined(HAVE_STDINT_H)
-# include <stdint.h>
-#endif
-#ifdef HAVE_CTYPE_H
-# include <ctype.h>
-#endif
-#ifdef HAVE_MATH_H
-# if defined(__WINRT__)
-/* Defining _USE_MATH_DEFINES is required to get M_PI to be defined on
-   WinRT.  See http://msdn.microsoft.com/en-us/library/4hwaceh6.aspx
-   for more information.
-*/
-#  define _USE_MATH_DEFINES
-# endif
-# include <math.h>
-#endif
-#ifdef HAVE_FLOAT_H
-# include <float.h>
-#endif
-#if defined(HAVE_ALLOCA) && !defined(alloca)
-# if defined(HAVE_ALLOCA_H)
-#  include <alloca.h>
-# elif defined(__GNUC__)
-#  define alloca __builtin_alloca
-# elif defined(_MSC_VER)
-#  include <malloc.h>
-#  define alloca _alloca
-# elif defined(__WATCOMC__)
-#  include <malloc.h>
-# elif defined(__BORLANDC__)
-#  include <malloc.h>
-# elif defined(__DMC__)
-#  include <stdlib.h>
-# elif defined(__AIX__)
-#pragma alloca
-# elif defined(__MRC__)
-void *alloca(unsigned);
-# else
-char *alloca();
-# endif
-#endif
-
-/**
- * Check if the compiler supports a given builtin.
- * Supported by virtually all clang versions and recent gcc. Use this
- * instead of checking the clang version if possible.
- */
-#ifdef __has_builtin
-#define _SDL_HAS_BUILTIN(x) __has_builtin(x)
-#else
-#define _SDL_HAS_BUILTIN(x) 0
-#endif
-
-/**
- *  The number of elements in an array.
- */
-#define SDL_arraysize(array)    (sizeof(array)/sizeof(array[0]))
-#define SDL_TABLESIZE(table)    SDL_arraysize(table)
-
-/**
- *  Macro useful for building other macros with strings in them
- *
- *  e.g. #define LOG_ERROR(X) OutputDebugString(SDL_STRINGIFY_ARG(__FUNCTION__) ": " X "\n")
- */
-#define SDL_STRINGIFY_ARG(arg)  #arg
-
-/**
- *  \name Cast operators
- *
- *  Use proper C++ casts when compiled as C++ to be compatible with the option
- *  -Wold-style-cast of GCC (and -Werror=old-style-cast in GCC 4.2 and above).
- */
-/* @{ */
-#ifdef __cplusplus
-#define SDL_reinterpret_cast(type, expression) reinterpret_cast<type>(expression)
-#define SDL_static_cast(type, expression) static_cast<type>(expression)
-#define SDL_const_cast(type, expression) const_cast<type>(expression)
-#else
-#define SDL_reinterpret_cast(type, expression) ((type)(expression))
-#define SDL_static_cast(type, expression) ((type)(expression))
-#define SDL_const_cast(type, expression) ((type)(expression))
-#endif
-/* @} *//* Cast operators */
-
-/* Define a four character code as a Uint32 */
-#define SDL_FOURCC(A, B, C, D) \
-    ((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \
-     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \
-     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \
-     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24))
-
-/**
- *  \name Basic data types
- */
-/* @{ */
-
-#ifdef __CC_ARM
-/* ARM's compiler throws warnings if we use an enum: like "SDL_bool x = a < b;" */
-#define SDL_FALSE 0
-#define SDL_TRUE 1
-typedef int SDL_bool;
-#else
-typedef enum
-{
-    SDL_FALSE = 0,
-    SDL_TRUE = 1
-} SDL_bool;
-#endif
-
-/**
- * \brief A signed 8-bit integer type.
- */
-#define SDL_MAX_SINT8   ((Sint8)0x7F)           /* 127 */
-#define SDL_MIN_SINT8   ((Sint8)(~0x7F))        /* -128 */
-typedef int8_t Sint8;
-/**
- * \brief An unsigned 8-bit integer type.
- */
-#define SDL_MAX_UINT8   ((Uint8)0xFF)           /* 255 */
-#define SDL_MIN_UINT8   ((Uint8)0x00)           /* 0 */
-typedef uint8_t Uint8;
-/**
- * \brief A signed 16-bit integer type.
- */
-#define SDL_MAX_SINT16  ((Sint16)0x7FFF)        /* 32767 */
-#define SDL_MIN_SINT16  ((Sint16)(~0x7FFF))     /* -32768 */
-typedef int16_t Sint16;
-/**
- * \brief An unsigned 16-bit integer type.
- */
-#define SDL_MAX_UINT16  ((Uint16)0xFFFF)        /* 65535 */
-#define SDL_MIN_UINT16  ((Uint16)0x0000)        /* 0 */
-typedef uint16_t Uint16;
-/**
- * \brief A signed 32-bit integer type.
- */
-#define SDL_MAX_SINT32  ((Sint32)0x7FFFFFFF)    /* 2147483647 */
-#define SDL_MIN_SINT32  ((Sint32)(~0x7FFFFFFF)) /* -2147483648 */
-typedef int32_t Sint32;
-/**
- * \brief An unsigned 32-bit integer type.
- */
-#define SDL_MAX_UINT32  ((Uint32)0xFFFFFFFFu)   /* 4294967295 */
-#define SDL_MIN_UINT32  ((Uint32)0x00000000)    /* 0 */
-typedef uint32_t Uint32;
-
-/**
- * \brief A signed 64-bit integer type.
- */
-#define SDL_MAX_SINT64  ((Sint64)0x7FFFFFFFFFFFFFFFll)      /* 9223372036854775807 */
-#define SDL_MIN_SINT64  ((Sint64)(~0x7FFFFFFFFFFFFFFFll))   /* -9223372036854775808 */
-typedef int64_t Sint64;
-/**
- * \brief An unsigned 64-bit integer type.
- */
-#define SDL_MAX_UINT64  ((Uint64)0xFFFFFFFFFFFFFFFFull)     /* 18446744073709551615 */
-#define SDL_MIN_UINT64  ((Uint64)(0x0000000000000000ull))   /* 0 */
-typedef uint64_t Uint64;
-
-/* @} *//* Basic data types */
-
-/**
- *  \name Floating-point constants
- */
-/* @{ */
-
-#ifdef FLT_EPSILON
-#define SDL_FLT_EPSILON FLT_EPSILON
-#else
-#define SDL_FLT_EPSILON 1.1920928955078125e-07F /* 0x0.000002p0 */
-#endif
-
-/* @} *//* Floating-point constants */
-
-/* Make sure we have macros for printing width-based integers.
- * <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__)
-#define SDL_PRIs64 "I64d"
-#elif defined(__LINUX__) && defined(__LP64__)
-#define SDL_PRIs64 "ld"
-#else
-#define SDL_PRIs64 "lld"
-#endif
-#endif
-#ifndef SDL_PRIu64
-#ifdef PRIu64
-#define SDL_PRIu64 PRIu64
-#elif defined(__WIN32__)
-#define SDL_PRIu64 "I64u"
-#elif defined(__LINUX__) && defined(__LP64__)
-#define SDL_PRIu64 "lu"
-#else
-#define SDL_PRIu64 "llu"
-#endif
-#endif
-#ifndef SDL_PRIx64
-#ifdef PRIx64
-#define SDL_PRIx64 PRIx64
-#elif defined(__WIN32__)
-#define SDL_PRIx64 "I64x"
-#elif defined(__LINUX__) && defined(__LP64__)
-#define SDL_PRIx64 "lx"
-#else
-#define SDL_PRIx64 "llx"
-#endif
-#endif
-#ifndef SDL_PRIX64
-#ifdef PRIX64
-#define SDL_PRIX64 PRIX64
-#elif defined(__WIN32__)
-#define SDL_PRIX64 "I64X"
-#elif defined(__LINUX__) && defined(__LP64__)
-#define SDL_PRIX64 "lX"
-#else
-#define SDL_PRIX64 "llX"
-#endif
-#endif
-#ifndef SDL_PRIs32
-#ifdef PRId32
-#define SDL_PRIs32 PRId32
-#else
-#define SDL_PRIs32 "d"
-#endif
-#endif
-#ifndef SDL_PRIu32
-#ifdef PRIu32
-#define SDL_PRIu32 PRIu32
-#else
-#define SDL_PRIu32 "u"
-#endif
-#endif
-#ifndef SDL_PRIx32
-#ifdef PRIx32
-#define SDL_PRIx32 PRIx32
-#else
-#define SDL_PRIx32 "x"
-#endif
-#endif
-#ifndef SDL_PRIX32
-#ifdef PRIX32
-#define SDL_PRIX32 PRIX32
-#else
-#define SDL_PRIX32 "X"
-#endif
-#endif
-
-/* Annotations to help code analysis tools */
-#ifdef SDL_DISABLE_ANALYZE_MACROS
-#define SDL_IN_BYTECAP(x)
-#define SDL_INOUT_Z_CAP(x)
-#define SDL_OUT_Z_CAP(x)
-#define SDL_OUT_CAP(x)
-#define SDL_OUT_BYTECAP(x)
-#define SDL_OUT_Z_BYTECAP(x)
-#define SDL_PRINTF_FORMAT_STRING
-#define SDL_SCANF_FORMAT_STRING
-#define SDL_PRINTF_VARARG_FUNC( fmtargnumber )
-#define SDL_SCANF_VARARG_FUNC( fmtargnumber )
-#else
-#if defined(_MSC_VER) && (_MSC_VER >= 1600) /* VS 2010 and above */
-#include <sal.h>
-
-#define SDL_IN_BYTECAP(x) _In_bytecount_(x)
-#define SDL_INOUT_Z_CAP(x) _Inout_z_cap_(x)
-#define SDL_OUT_Z_CAP(x) _Out_z_cap_(x)
-#define SDL_OUT_CAP(x) _Out_cap_(x)
-#define SDL_OUT_BYTECAP(x) _Out_bytecap_(x)
-#define SDL_OUT_Z_BYTECAP(x) _Out_z_bytecap_(x)
-
-#define SDL_PRINTF_FORMAT_STRING _Printf_format_string_
-#define SDL_SCANF_FORMAT_STRING _Scanf_format_string_impl_
-#else
-#define SDL_IN_BYTECAP(x)
-#define SDL_INOUT_Z_CAP(x)
-#define SDL_OUT_Z_CAP(x)
-#define SDL_OUT_CAP(x)
-#define SDL_OUT_BYTECAP(x)
-#define SDL_OUT_Z_BYTECAP(x)
-#define SDL_PRINTF_FORMAT_STRING
-#define SDL_SCANF_FORMAT_STRING
-#endif
-#if defined(__GNUC__)
-#define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __printf__, fmtargnumber, fmtargnumber+1 )))
-#define SDL_SCANF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __scanf__, fmtargnumber, fmtargnumber+1 )))
-#else
-#define SDL_PRINTF_VARARG_FUNC( fmtargnumber )
-#define SDL_SCANF_VARARG_FUNC( fmtargnumber )
-#endif
-#endif /* SDL_DISABLE_ANALYZE_MACROS */
-
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
-#define SDL_COMPILE_TIME_ASSERT(name, x) _Static_assert(x, #x)
-#elif defined(__cplusplus) && (__cplusplus >= 201103L)
-#define SDL_COMPILE_TIME_ASSERT(name, x)  static_assert(x, #x)
-#else /* universal, but may trigger -Wunused-local-typedefs */
-#define SDL_COMPILE_TIME_ASSERT(name, x)               \
-       typedef int SDL_compile_time_assert_ ## name[(x) * 2 - 1]
-#endif
-/** \cond */
-#ifndef DOXYGEN_SHOULD_IGNORE_THIS
-SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
-SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
-SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
-SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
-SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
-SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
-SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
-SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
-#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
-/** \endcond */
-
-/* Check to make sure enums are the size of ints, for structure packing.
-   For both Watcom C/C++ and Borland C/C++ the compiler option that makes
-   enums having the size of an int must be enabled.
-   This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11).
-*/
-
-/** \cond */
-#ifndef DOXYGEN_SHOULD_IGNORE_THIS
-#if !defined(__ANDROID__) && !defined(__VITA__)
-   /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */
-typedef enum
-{
-    DUMMY_ENUM_VALUE
-} SDL_DUMMY_ENUM;
-
-SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
-#endif
-#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
-/** \endcond */
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef HAVE_ALLOCA
-#define SDL_stack_alloc(type, count)    (type*)alloca(sizeof(type)*(count))
-#define SDL_stack_free(data)
-#else
-#define SDL_stack_alloc(type, count)    (type*)SDL_malloc(sizeof(type)*(count))
-#define SDL_stack_free(data)            SDL_free(data)
-#endif
-
-extern DECLSPEC void *SDLCALL SDL_malloc(size_t size);
-extern DECLSPEC void *SDLCALL SDL_calloc(size_t nmemb, size_t size);
-extern DECLSPEC void *SDLCALL SDL_realloc(void *mem, size_t size);
-extern DECLSPEC void SDLCALL SDL_free(void *mem);
-
-typedef void *(SDLCALL *SDL_malloc_func)(size_t size);
-typedef void *(SDLCALL *SDL_calloc_func)(size_t nmemb, size_t size);
-typedef void *(SDLCALL *SDL_realloc_func)(void *mem, size_t size);
-typedef void (SDLCALL *SDL_free_func)(void *mem);
-
-/**
- * Get the current set of SDL memory functions
- *
- * \since This function is available since SDL 2.0.7.
- */
-extern DECLSPEC void SDLCALL SDL_GetMemoryFunctions(SDL_malloc_func *malloc_func,
-                                                    SDL_calloc_func *calloc_func,
-                                                    SDL_realloc_func *realloc_func,
-                                                    SDL_free_func *free_func);
-
-/**
- * Replace SDL's memory allocation functions with a custom set
- *
- * \since This function is available since SDL 2.0.7.
- */
-extern DECLSPEC int SDLCALL SDL_SetMemoryFunctions(SDL_malloc_func malloc_func,
-                                                   SDL_calloc_func calloc_func,
-                                                   SDL_realloc_func realloc_func,
-                                                   SDL_free_func free_func);
-
-/**
- * Get the number of outstanding (unfreed) allocations
- *
- * \since This function is available since SDL 2.0.7.
- */
-extern DECLSPEC int SDLCALL SDL_GetNumAllocations(void);
-
-extern DECLSPEC char *SDLCALL SDL_getenv(const char *name);
-extern DECLSPEC int SDLCALL SDL_setenv(const char *name, const char *value, int overwrite);
-
-extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size, int (*compare) (const void *, const void *));
-
-extern DECLSPEC int SDLCALL SDL_abs(int x);
-
-/* NOTE: these double-evaluate their arguments, so you should never have side effects in the parameters */
-#define SDL_min(x, y) (((x) < (y)) ? (x) : (y))
-#define SDL_max(x, y) (((x) > (y)) ? (x) : (y))
-#define SDL_clamp(x, a, b) (((x) < (a)) ? (a) : (((x) > (b)) ? (b) : (x)))
-
-extern DECLSPEC int SDLCALL SDL_isalpha(int x);
-extern DECLSPEC int SDLCALL SDL_isalnum(int x);
-extern DECLSPEC int SDLCALL SDL_isblank(int x);
-extern DECLSPEC int SDLCALL SDL_iscntrl(int x);
-extern DECLSPEC int SDLCALL SDL_isdigit(int x);
-extern DECLSPEC int SDLCALL SDL_isxdigit(int x);
-extern DECLSPEC int SDLCALL SDL_ispunct(int x);
-extern DECLSPEC int SDLCALL SDL_isspace(int x);
-extern DECLSPEC int SDLCALL SDL_isupper(int x);
-extern DECLSPEC int SDLCALL SDL_islower(int x);
-extern DECLSPEC int SDLCALL SDL_isprint(int x);
-extern DECLSPEC int SDLCALL SDL_isgraph(int x);
-extern DECLSPEC int SDLCALL SDL_toupper(int x);
-extern DECLSPEC int SDLCALL SDL_tolower(int x);
-
-extern DECLSPEC Uint32 SDLCALL SDL_crc32(Uint32 crc, const void *data, size_t len);
-
-extern DECLSPEC void *SDLCALL SDL_memset(SDL_OUT_BYTECAP(len) void *dst, int c, size_t len);
-
-#define SDL_zero(x) SDL_memset(&(x), 0, sizeof((x)))
-#define SDL_zerop(x) SDL_memset((x), 0, sizeof(*(x)))
-#define SDL_zeroa(x) SDL_memset((x), 0, sizeof((x)))
-
-/* Note that memset() is a byte assignment and this is a 32-bit assignment, so they're not directly equivalent. */
-SDL_FORCE_INLINE void SDL_memset4(void *dst, Uint32 val, size_t dwords)
-{
-#ifdef __APPLE__
-    memset_pattern4(dst, &val, dwords * 4);
-#elif defined(__GNUC__) && defined(__i386__)
-    int u0, u1, u2;
-    __asm__ __volatile__ (
-        "cld \n\t"
-        "rep ; stosl \n\t"
-        : "=&D" (u0), "=&a" (u1), "=&c" (u2)
-        : "0" (dst), "1" (val), "2" (SDL_static_cast(Uint32, dwords))
-        : "memory"
-    );
-#else
-    size_t _n = (dwords + 3) / 4;
-    Uint32 *_p = SDL_static_cast(Uint32 *, dst);
-    Uint32 _val = (val);
-    if (dwords == 0) {
-        return;
-    }
-    switch (dwords % 4) {
-        case 0: do {    *_p++ = _val;   SDL_FALLTHROUGH;
-        case 3:         *_p++ = _val;   SDL_FALLTHROUGH;
-        case 2:         *_p++ = _val;   SDL_FALLTHROUGH;
-        case 1:         *_p++ = _val;
-        } while ( --_n );
-    }
-#endif
-}
-
-extern DECLSPEC void *SDLCALL SDL_memcpy(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len);
-
-extern DECLSPEC void *SDLCALL SDL_memmove(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len);
-extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2, size_t len);
-
-extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t *wstr);
-extern DECLSPEC size_t SDLCALL SDL_wcslcpy(SDL_OUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen);
-extern DECLSPEC size_t SDLCALL SDL_wcslcat(SDL_INOUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen);
-extern DECLSPEC wchar_t *SDLCALL SDL_wcsdup(const wchar_t *wstr);
-extern DECLSPEC wchar_t *SDLCALL SDL_wcsstr(const wchar_t *haystack, const wchar_t *needle);
-
-extern DECLSPEC int SDLCALL SDL_wcscmp(const wchar_t *str1, const wchar_t *str2);
-extern DECLSPEC int SDLCALL SDL_wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t maxlen);
-extern DECLSPEC int SDLCALL SDL_wcscasecmp(const wchar_t *str1, const wchar_t *str2);
-extern DECLSPEC int SDLCALL SDL_wcsncasecmp(const wchar_t *str1, const wchar_t *str2, size_t len);
-
-extern DECLSPEC size_t SDLCALL SDL_strlen(const char *str);
-extern DECLSPEC size_t SDLCALL SDL_strlcpy(SDL_OUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen);
-extern DECLSPEC size_t SDLCALL SDL_utf8strlcpy(SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_bytes);
-extern DECLSPEC size_t SDLCALL SDL_strlcat(SDL_INOUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen);
-extern DECLSPEC char *SDLCALL SDL_strdup(const char *str);
-extern DECLSPEC char *SDLCALL SDL_strrev(char *str);
-extern DECLSPEC char *SDLCALL SDL_strupr(char *str);
-extern DECLSPEC char *SDLCALL SDL_strlwr(char *str);
-extern DECLSPEC char *SDLCALL SDL_strchr(const char *str, int c);
-extern DECLSPEC char *SDLCALL SDL_strrchr(const char *str, int c);
-extern DECLSPEC char *SDLCALL SDL_strstr(const char *haystack, const char *needle);
-extern DECLSPEC char *SDLCALL SDL_strtokr(char *s1, const char *s2, char **saveptr);
-extern DECLSPEC size_t SDLCALL SDL_utf8strlen(const char *str);
-
-extern DECLSPEC char *SDLCALL SDL_itoa(int value, char *str, int radix);
-extern DECLSPEC char *SDLCALL SDL_uitoa(unsigned int value, char *str, int radix);
-extern DECLSPEC char *SDLCALL SDL_ltoa(long value, char *str, int radix);
-extern DECLSPEC char *SDLCALL SDL_ultoa(unsigned long value, char *str, int radix);
-extern DECLSPEC char *SDLCALL SDL_lltoa(Sint64 value, char *str, int radix);
-extern DECLSPEC char *SDLCALL SDL_ulltoa(Uint64 value, char *str, int radix);
-
-extern DECLSPEC int SDLCALL SDL_atoi(const char *str);
-extern DECLSPEC double SDLCALL SDL_atof(const char *str);
-extern DECLSPEC long SDLCALL SDL_strtol(const char *str, char **endp, int base);
-extern DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *str, char **endp, int base);
-extern DECLSPEC Sint64 SDLCALL SDL_strtoll(const char *str, char **endp, int base);
-extern DECLSPEC Uint64 SDLCALL SDL_strtoull(const char *str, char **endp, int base);
-extern DECLSPEC double SDLCALL SDL_strtod(const char *str, char **endp);
-
-extern DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2);
-extern DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2, size_t maxlen);
-extern DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1, const char *str2);
-extern DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1, const char *str2, size_t len);
-
-extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, SDL_SCANF_FORMAT_STRING const char *fmt, ...) SDL_SCANF_VARARG_FUNC(2);
-extern DECLSPEC int SDLCALL SDL_vsscanf(const char *text, const char *fmt, va_list ap);
-extern DECLSPEC int SDLCALL SDL_snprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ... ) SDL_PRINTF_VARARG_FUNC(3);
-extern DECLSPEC int SDLCALL SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap);
-extern DECLSPEC int SDLCALL SDL_asprintf(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2);
-extern DECLSPEC int SDLCALL SDL_vasprintf(char **strp, const char *fmt, va_list ap);
-
-#ifndef HAVE_M_PI
-#ifndef M_PI
-#define M_PI    3.14159265358979323846264338327950288   /**< pi */
-#endif
-#endif
-
-/**
- * Use this function to compute arc cosine of `x`.
- *
- * The definition of `y = acos(x)` is `x = cos(y)`.
- *
- * Domain: `-1 <= x <= 1`
- *
- * Range: `0 <= y <= Pi`
- *
- * \param x floating point value, in radians.
- * \returns arc cosine of `x`.
- *
- * \since This function is available since SDL 2.0.2.
- */
-extern DECLSPEC double SDLCALL SDL_acos(double x);
-extern DECLSPEC float SDLCALL SDL_acosf(float x);
-extern DECLSPEC double SDLCALL SDL_asin(double x);
-extern DECLSPEC float SDLCALL SDL_asinf(float x);
-extern DECLSPEC double SDLCALL SDL_atan(double x);
-extern DECLSPEC float SDLCALL SDL_atanf(float x);
-extern DECLSPEC double SDLCALL SDL_atan2(double y, double x);
-extern DECLSPEC float SDLCALL SDL_atan2f(float y, float x);
-extern DECLSPEC double SDLCALL SDL_ceil(double x);
-extern DECLSPEC float SDLCALL SDL_ceilf(float x);
-extern DECLSPEC double SDLCALL SDL_copysign(double x, double y);
-extern DECLSPEC float SDLCALL SDL_copysignf(float x, float y);
-extern DECLSPEC double SDLCALL SDL_cos(double x);
-extern DECLSPEC float SDLCALL SDL_cosf(float x);
-extern DECLSPEC double SDLCALL SDL_exp(double x);
-extern DECLSPEC float SDLCALL SDL_expf(float x);
-extern DECLSPEC double SDLCALL SDL_fabs(double x);
-extern DECLSPEC float SDLCALL SDL_fabsf(float x);
-extern DECLSPEC double SDLCALL SDL_floor(double x);
-extern DECLSPEC float SDLCALL SDL_floorf(float x);
-extern DECLSPEC double SDLCALL SDL_trunc(double x);
-extern DECLSPEC float SDLCALL SDL_truncf(float x);
-extern DECLSPEC double SDLCALL SDL_fmod(double x, double y);
-extern DECLSPEC float SDLCALL SDL_fmodf(float x, float y);
-extern DECLSPEC double SDLCALL SDL_log(double x);
-extern DECLSPEC float SDLCALL SDL_logf(float x);
-extern DECLSPEC double SDLCALL SDL_log10(double x);
-extern DECLSPEC float SDLCALL SDL_log10f(float x);
-extern DECLSPEC double SDLCALL SDL_pow(double x, double y);
-extern DECLSPEC float SDLCALL SDL_powf(float x, float y);
-extern DECLSPEC double SDLCALL SDL_round(double x);
-extern DECLSPEC float SDLCALL SDL_roundf(float x);
-extern DECLSPEC long SDLCALL SDL_lround(double x);
-extern DECLSPEC long SDLCALL SDL_lroundf(float x);
-extern DECLSPEC double SDLCALL SDL_scalbn(double x, int n);
-extern DECLSPEC float SDLCALL SDL_scalbnf(float x, int n);
-extern DECLSPEC double SDLCALL SDL_sin(double x);
-extern DECLSPEC float SDLCALL SDL_sinf(float x);
-extern DECLSPEC double SDLCALL SDL_sqrt(double x);
-extern DECLSPEC float SDLCALL SDL_sqrtf(float x);
-extern DECLSPEC double SDLCALL SDL_tan(double x);
-extern DECLSPEC float SDLCALL SDL_tanf(float x);
-
-/* The SDL implementation of iconv() returns these error codes */
-#define SDL_ICONV_ERROR     (size_t)-1
-#define SDL_ICONV_E2BIG     (size_t)-2
-#define SDL_ICONV_EILSEQ    (size_t)-3
-#define SDL_ICONV_EINVAL    (size_t)-4
-
-/* SDL_iconv_* are now always real symbols/types, not macros or inlined. */
-typedef struct _SDL_iconv_t *SDL_iconv_t;
-extern DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode,
-                                                   const char *fromcode);
-extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd);
-extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, const char **inbuf,
-                                         size_t * inbytesleft, char **outbuf,
-                                         size_t * outbytesleft);
-
-/**
- * This function converts a string between encodings in one pass, returning a
- * string that must be freed with SDL_free() or NULL on error.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC char *SDLCALL SDL_iconv_string(const char *tocode,
-                                               const char *fromcode,
-                                               const char *inbuf,
-                                               size_t inbytesleft);
-#define SDL_iconv_utf8_locale(S)    SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1)
-#define SDL_iconv_utf8_ucs2(S)      (Uint16 *)SDL_iconv_string("UCS-2-INTERNAL", "UTF-8", S, SDL_strlen(S)+1)
-#define SDL_iconv_utf8_ucs4(S)      (Uint32 *)SDL_iconv_string("UCS-4-INTERNAL", "UTF-8", S, SDL_strlen(S)+1)
-#define SDL_iconv_wchar_utf8(S)     SDL_iconv_string("UTF-8", "WCHAR_T", (char *)S, (SDL_wcslen(S)+1)*sizeof(wchar_t))
-
-/* force builds using Clang's static analysis tools to use literal C runtime
-   here, since there are possibly tests that are ineffective otherwise. */
-#if defined(__clang_analyzer__) && !defined(SDL_DISABLE_ANALYZE_MACROS)
-
-/* The analyzer knows about strlcpy even when the system doesn't provide it */
-#ifndef HAVE_STRLCPY
-size_t strlcpy(char* dst, const char* src, size_t size);
-#endif
-
-/* The analyzer knows about strlcat even when the system doesn't provide it */
-#ifndef HAVE_STRLCAT
-size_t strlcat(char* dst, const char* src, size_t size);
-#endif
-
-#define SDL_malloc malloc
-#define SDL_calloc calloc
-#define SDL_realloc realloc
-#define SDL_free free
-#define SDL_memset memset
-#define SDL_memcpy memcpy
-#define SDL_memmove memmove
-#define SDL_memcmp memcmp
-#define SDL_strlcpy strlcpy
-#define SDL_strlcat strlcat
-#define SDL_strlen strlen
-#define SDL_wcslen wcslen
-#define SDL_wcslcpy wcslcpy
-#define SDL_wcslcat wcslcat
-#define SDL_strdup strdup
-#define SDL_wcsdup wcsdup
-#define SDL_strchr strchr
-#define SDL_strrchr strrchr
-#define SDL_strstr strstr
-#define SDL_wcsstr wcsstr
-#define SDL_strtokr strtok_r
-#define SDL_strcmp strcmp
-#define SDL_wcscmp wcscmp
-#define SDL_strncmp strncmp
-#define SDL_wcsncmp wcsncmp
-#define SDL_strcasecmp strcasecmp
-#define SDL_strncasecmp strncasecmp
-#define SDL_sscanf sscanf
-#define SDL_vsscanf vsscanf
-#define SDL_snprintf snprintf
-#define SDL_vsnprintf vsnprintf
-#endif
-
-SDL_FORCE_INLINE void *SDL_memcpy4(SDL_OUT_BYTECAP(dwords*4) void *dst, SDL_IN_BYTECAP(dwords*4) const void *src, size_t dwords)
-{
-    return SDL_memcpy(dst, src, dwords * 4);
-}
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_stdinc_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,995 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_surface.h
- *
- *  Header file for ::SDL_Surface definition and management functions.
- */
-
-#ifndef SDL_surface_h_
-#define SDL_surface_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_pixels.h"
-#include "SDL_rect.h"
-#include "SDL_blendmode.h"
-#include "SDL_rwops.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \name Surface flags
- *
- *  These are the currently supported flags for the ::SDL_Surface.
- *
- *  \internal
- *  Used internally (read-only).
- */
-/* @{ */
-#define SDL_SWSURFACE       0           /**< Just here for compatibility */
-#define SDL_PREALLOC        0x00000001  /**< Surface uses preallocated memory */
-#define SDL_RLEACCEL        0x00000002  /**< Surface is RLE encoded */
-#define SDL_DONTFREE        0x00000004  /**< Surface is referenced internally */
-#define SDL_SIMD_ALIGNED    0x00000008  /**< Surface uses aligned memory */
-/* @} *//* Surface flags */
-
-/**
- *  Evaluates to true if the surface needs to be locked before access.
- */
-#define SDL_MUSTLOCK(S) (((S)->flags & SDL_RLEACCEL) != 0)
-
-/**
- * \brief A collection of pixels used in software blitting.
- *
- * \note  This structure should be treated as read-only, except for \c pixels,
- *        which, if not NULL, contains the raw pixel data for the surface.
- */
-typedef struct SDL_Surface
-{
-    Uint32 flags;               /**< Read-only */
-    SDL_PixelFormat *format;    /**< Read-only */
-    int w, h;                   /**< Read-only */
-    int pitch;                  /**< Read-only */
-    void *pixels;               /**< Read-write */
-
-    /** Application data associated with the surface */
-    void *userdata;             /**< Read-write */
-
-    /** information needed for surfaces requiring locks */
-    int locked;                 /**< Read-only */
-
-    /** list of BlitMap that hold a reference to this surface */
-    void *list_blitmap;         /**< Private */
-
-    /** clipping information */
-    SDL_Rect clip_rect;         /**< Read-only */
-
-    /** info for fast blit mapping to other surfaces */
-    struct SDL_BlitMap *map;    /**< Private */
-
-    /** Reference count -- used when freeing surface */
-    int refcount;               /**< Read-mostly */
-} SDL_Surface;
-
-/**
- * \brief The type of function used for surface blitting functions.
- */
-typedef int (SDLCALL *SDL_blit) (struct SDL_Surface * src, SDL_Rect * srcrect,
-                                 struct SDL_Surface * dst, SDL_Rect * dstrect);
-
-/**
- * \brief The formula used for converting between YUV and RGB
- */
-typedef enum
-{
-    SDL_YUV_CONVERSION_JPEG,        /**< Full range JPEG */
-    SDL_YUV_CONVERSION_BT601,       /**< BT.601 (the default) */
-    SDL_YUV_CONVERSION_BT709,       /**< BT.709 */
-    SDL_YUV_CONVERSION_AUTOMATIC    /**< BT.601 for SD content, BT.709 for HD content */
-} SDL_YUV_CONVERSION_MODE;
-
-/**
- * Allocate a new RGB surface.
- *
- * If `depth` is 4 or 8 bits, an empty palette is allocated for the surface.
- * If `depth` is greater than 8 bits, the pixel format is set using the
- * [RGBA]mask parameters.
- *
- * The [RGBA]mask parameters are the bitmasks used to extract that color from
- * a pixel. For instance, `Rmask` being 0xFF000000 means the red data is
- * stored in the most significant byte. Using zeros for the RGB masks sets a
- * default value, based on the depth. For example:
- *
- * ```c++
- * SDL_CreateRGBSurface(0,w,h,32,0,0,0,0);
- * ```
- *
- * However, using zero for the Amask results in an Amask of 0.
- *
- * By default surfaces with an alpha mask are set up for blending as with:
- *
- * ```c++
- * SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND)
- * ```
- *
- * You can change this by calling SDL_SetSurfaceBlendMode() and selecting a
- * different `blendMode`.
- *
- * \param flags the flags are unused and should be set to 0
- * \param width the width of the surface
- * \param height the height of the surface
- * \param depth the depth of the surface in bits
- * \param Rmask the red mask for the pixels
- * \param Gmask the green mask for the pixels
- * \param Bmask the blue mask for the pixels
- * \param Amask the alpha mask for the pixels
- * \returns the new SDL_Surface structure that is created or NULL if it fails;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateRGBSurfaceFrom
- * \sa SDL_CreateRGBSurfaceWithFormat
- * \sa SDL_FreeSurface
- */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurface
-    (Uint32 flags, int width, int height, int depth,
-     Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask);
-
-
-/* !!! FIXME for 2.1: why does this ask for depth? Format provides that. */
-
-/**
- * Allocate a new RGB surface with a specific pixel format.
- *
- * This function operates mostly like SDL_CreateRGBSurface(), except instead
- * of providing pixel color masks, you provide it with a predefined format
- * from SDL_PixelFormatEnum.
- *
- * \param flags the flags are unused and should be set to 0
- * \param width the width of the surface
- * \param height the height of the surface
- * \param depth the depth of the surface in bits
- * \param format the SDL_PixelFormatEnum for the new surface's pixel format.
- * \returns the new SDL_Surface structure that is created or NULL if it fails;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.5.
- *
- * \sa SDL_CreateRGBSurface
- * \sa SDL_CreateRGBSurfaceFrom
- * \sa SDL_FreeSurface
- */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormat
-    (Uint32 flags, int width, int height, int depth, Uint32 format);
-
-/**
- * Allocate a new RGB surface with existing pixel data.
- *
- * This function operates mostly like SDL_CreateRGBSurface(), except it does
- * not allocate memory for the pixel data, instead the caller provides an
- * existing buffer of data for the surface to use.
- *
- * No copy is made of the pixel data. Pixel data is not managed automatically;
- * you must free the surface before you free the pixel data.
- *
- * \param pixels a pointer to existing pixel data
- * \param width the width of the surface
- * \param height the height of the surface
- * \param depth the depth of the surface in bits
- * \param pitch the pitch of the surface in bytes
- * \param Rmask the red mask for the pixels
- * \param Gmask the green mask for the pixels
- * \param Bmask the blue mask for the pixels
- * \param Amask the alpha mask for the pixels
- * \returns the new SDL_Surface structure that is created or NULL if it fails;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateRGBSurface
- * \sa SDL_CreateRGBSurfaceWithFormat
- * \sa SDL_FreeSurface
- */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
-                                                              int width,
-                                                              int height,
-                                                              int depth,
-                                                              int pitch,
-                                                              Uint32 Rmask,
-                                                              Uint32 Gmask,
-                                                              Uint32 Bmask,
-                                                              Uint32 Amask);
-
-/* !!! FIXME for 2.1: why does this ask for depth? Format provides that. */
-
-/**
- * Allocate a new RGB surface with with a specific pixel format and existing
- * pixel data.
- *
- * This function operates mostly like SDL_CreateRGBSurfaceFrom(), except
- * instead of providing pixel color masks, you provide it with a predefined
- * format from SDL_PixelFormatEnum.
- *
- * No copy is made of the pixel data. Pixel data is not managed automatically;
- * you must free the surface before you free the pixel data.
- *
- * \param pixels a pointer to existing pixel data
- * \param width the width of the surface
- * \param height the height of the surface
- * \param depth the depth of the surface in bits
- * \param pitch the pitch of the surface in bytes
- * \param format the SDL_PixelFormatEnum for the new surface's pixel format.
- * \returns the new SDL_Surface structure that is created or NULL if it fails;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.5.
- *
- * \sa SDL_CreateRGBSurfaceFrom
- * \sa SDL_CreateRGBSurfaceWithFormat
- * \sa SDL_FreeSurface
- */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceWithFormatFrom
-    (void *pixels, int width, int height, int depth, int pitch, Uint32 format);
-
-/**
- * Free an RGB surface.
- *
- * It is safe to pass NULL to this function.
- *
- * \param surface the SDL_Surface to free.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateRGBSurface
- * \sa SDL_CreateRGBSurfaceFrom
- * \sa SDL_LoadBMP
- * \sa SDL_LoadBMP_RW
- */
-extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface);
-
-/**
- * Set the palette used by a surface.
- *
- * A single palette can be shared with many surfaces.
- *
- * \param surface the SDL_Surface structure to update
- * \param palette the SDL_Palette structure to use
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_SetSurfacePalette(SDL_Surface * surface,
-                                                  SDL_Palette * palette);
-
-/**
- * Set up a surface for directly accessing the pixels.
- *
- * Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to
- * and read from `surface->pixels`, using the pixel format stored in
- * `surface->format`. Once you are done accessing the surface, you should use
- * SDL_UnlockSurface() to release it.
- *
- * Not all surfaces require locking. If `SDL_MUSTLOCK(surface)` evaluates to
- * 0, then you can read and write to the surface at any time, and the pixel
- * format of the surface will not change.
- *
- * \param surface the SDL_Surface structure to be locked
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_MUSTLOCK
- * \sa SDL_UnlockSurface
- */
-extern DECLSPEC int SDLCALL SDL_LockSurface(SDL_Surface * surface);
-
-/**
- * Release a surface after directly accessing the pixels.
- *
- * \param surface the SDL_Surface structure to be unlocked
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LockSurface
- */
-extern DECLSPEC void SDLCALL SDL_UnlockSurface(SDL_Surface * surface);
-
-/**
- * Load a BMP image from a seekable SDL data stream.
- *
- * The new surface should be freed with SDL_FreeSurface(). Not doing so will
- * result in a memory leak.
- *
- * src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile.
- * Alternitavely, you might also use the macro SDL_LoadBMP to load a bitmap
- * from a file, convert it to an SDL_Surface and then close the file.
- *
- * \param src the data stream for the surface
- * \param freesrc non-zero to close the stream after being read
- * \returns a pointer to a new SDL_Surface structure or NULL if there was an
- *          error; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_FreeSurface
- * \sa SDL_RWFromFile
- * \sa SDL_LoadBMP
- * \sa SDL_SaveBMP_RW
- */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_LoadBMP_RW(SDL_RWops * src,
-                                                    int freesrc);
-
-/**
- * Load a surface from a file.
- *
- * Convenience macro.
- */
-#define SDL_LoadBMP(file)   SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1)
-
-/**
- * Save a surface to a seekable SDL data stream in BMP format.
- *
- * Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the
- * BMP directly. Other RGB formats with 8-bit or higher get converted to a
- * 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit
- * surface before they are saved. YUV and paletted 1-bit and 4-bit formats are
- * not supported.
- *
- * \param surface the SDL_Surface structure containing the image to be saved
- * \param dst a data stream to save to
- * \param freedst non-zero to close the stream after being written
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_LoadBMP_RW
- * \sa SDL_SaveBMP
- */
-extern DECLSPEC int SDLCALL SDL_SaveBMP_RW
-    (SDL_Surface * surface, SDL_RWops * dst, int freedst);
-
-/**
- *  Save a surface to a file.
- *
- *  Convenience macro.
- */
-#define SDL_SaveBMP(surface, file) \
-        SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1)
-
-/**
- * Set the RLE acceleration hint for a surface.
- *
- * If RLE is enabled, color key and alpha blending blits are much faster, but
- * the surface must be locked before directly accessing the pixels.
- *
- * \param surface the SDL_Surface structure to optimize
- * \param flag 0 to disable, non-zero to enable RLE acceleration
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitSurface
- * \sa SDL_LockSurface
- * \sa SDL_UnlockSurface
- */
-extern DECLSPEC int SDLCALL SDL_SetSurfaceRLE(SDL_Surface * surface,
-                                              int flag);
-
-/**
- * Returns whether the surface is RLE enabled
- *
- * It is safe to pass a NULL `surface` here; it will return SDL_FALSE.
- *
- * \param surface the SDL_Surface structure to query
- * \returns SDL_TRUE if the surface is RLE enabled, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.14.
- *
- * \sa SDL_SetSurfaceRLE
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasSurfaceRLE(SDL_Surface * surface);
-
-/**
- * Set the color key (transparent pixel) in a surface.
- *
- * The color key defines a pixel value that will be treated as transparent in
- * a blit. For example, one can use this to specify that cyan pixels should be
- * considered transparent, and therefore not rendered.
- *
- * It is a pixel of the format used by the surface, as generated by
- * SDL_MapRGB().
- *
- * RLE acceleration can substantially speed up blitting of images with large
- * horizontal runs of transparent pixels. See SDL_SetSurfaceRLE() for details.
- *
- * \param surface the SDL_Surface structure to update
- * \param flag SDL_TRUE to enable color key, SDL_FALSE to disable color key
- * \param key the transparent pixel
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitSurface
- * \sa SDL_GetColorKey
- */
-extern DECLSPEC int SDLCALL SDL_SetColorKey(SDL_Surface * surface,
-                                            int flag, Uint32 key);
-
-/**
- * Returns whether the surface has a color key
- *
- * It is safe to pass a NULL `surface` here; it will return SDL_FALSE.
- *
- * \param surface the SDL_Surface structure to query
- * \return SDL_TRUE if the surface has a color key, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.9.
- *
- * \sa SDL_SetColorKey
- * \sa SDL_GetColorKey
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasColorKey(SDL_Surface * surface);
-
-/**
- * Get the color key (transparent pixel) for a surface.
- *
- * The color key is a pixel of the format used by the surface, as generated by
- * SDL_MapRGB().
- *
- * If the surface doesn't have color key enabled this function returns -1.
- *
- * \param surface the SDL_Surface structure to query
- * \param key a pointer filled in with the transparent pixel
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitSurface
- * \sa SDL_SetColorKey
- */
-extern DECLSPEC int SDLCALL SDL_GetColorKey(SDL_Surface * surface,
-                                            Uint32 * key);
-
-/**
- * Set an additional color value multiplied into blit operations.
- *
- * When this surface is blitted, during the blit operation each source color
- * channel is modulated by the appropriate color value according to the
- * following formula:
- *
- * `srcC = srcC * (color / 255)`
- *
- * \param surface the SDL_Surface structure to update
- * \param r the red color value multiplied into blit operations
- * \param g the green color value multiplied into blit operations
- * \param b the blue color value multiplied into blit operations
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetSurfaceColorMod
- * \sa SDL_SetSurfaceAlphaMod
- */
-extern DECLSPEC int SDLCALL SDL_SetSurfaceColorMod(SDL_Surface * surface,
-                                                   Uint8 r, Uint8 g, Uint8 b);
-
-
-/**
- * Get the additional color value multiplied into blit operations.
- *
- * \param surface the SDL_Surface structure to query
- * \param r a pointer filled in with the current red color value
- * \param g a pointer filled in with the current green color value
- * \param b a pointer filled in with the current blue color value
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetSurfaceAlphaMod
- * \sa SDL_SetSurfaceColorMod
- */
-extern DECLSPEC int SDLCALL SDL_GetSurfaceColorMod(SDL_Surface * surface,
-                                                   Uint8 * r, Uint8 * g,
-                                                   Uint8 * b);
-
-/**
- * Set an additional alpha value used in blit operations.
- *
- * When this surface is blitted, during the blit operation the source alpha
- * value is modulated by this alpha value according to the following formula:
- *
- * `srcA = srcA * (alpha / 255)`
- *
- * \param surface the SDL_Surface structure to update
- * \param alpha the alpha value multiplied into blit operations
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetSurfaceAlphaMod
- * \sa SDL_SetSurfaceColorMod
- */
-extern DECLSPEC int SDLCALL SDL_SetSurfaceAlphaMod(SDL_Surface * surface,
-                                                   Uint8 alpha);
-
-/**
- * Get the additional alpha value used in blit operations.
- *
- * \param surface the SDL_Surface structure to query
- * \param alpha a pointer filled in with the current alpha value
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetSurfaceColorMod
- * \sa SDL_SetSurfaceAlphaMod
- */
-extern DECLSPEC int SDLCALL SDL_GetSurfaceAlphaMod(SDL_Surface * surface,
-                                                   Uint8 * alpha);
-
-/**
- * Set the blend mode used for blit operations.
- *
- * To copy a surface to another surface (or texture) without blending with the
- * existing data, the blendmode of the SOURCE surface should be set to
- * `SDL_BLENDMODE_NONE`.
- *
- * \param surface the SDL_Surface structure to update
- * \param blendMode the SDL_BlendMode to use for blit blending
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetSurfaceBlendMode
- */
-extern DECLSPEC int SDLCALL SDL_SetSurfaceBlendMode(SDL_Surface * surface,
-                                                    SDL_BlendMode blendMode);
-
-/**
- * Get the blend mode used for blit operations.
- *
- * \param surface the SDL_Surface structure to query
- * \param blendMode a pointer filled in with the current SDL_BlendMode
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_SetSurfaceBlendMode
- */
-extern DECLSPEC int SDLCALL SDL_GetSurfaceBlendMode(SDL_Surface * surface,
-                                                    SDL_BlendMode *blendMode);
-
-/**
- * Set the clipping rectangle for a surface.
- *
- * When `surface` is the destination of a blit, only the area within the clip
- * rectangle is drawn into.
- *
- * Note that blits are automatically clipped to the edges of the source and
- * destination surfaces.
- *
- * \param surface the SDL_Surface structure to be clipped
- * \param rect the SDL_Rect structure representing the clipping rectangle, or
- *             NULL to disable clipping
- * \returns SDL_TRUE if the rectangle intersects the surface, otherwise
- *          SDL_FALSE and blits will be completely clipped.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitSurface
- * \sa SDL_GetClipRect
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_SetClipRect(SDL_Surface * surface,
-                                                 const SDL_Rect * rect);
-
-/**
- * Get the clipping rectangle for a surface.
- *
- * When `surface` is the destination of a blit, only the area within the clip
- * rectangle is drawn into.
- *
- * \param surface the SDL_Surface structure representing the surface to be
- *                clipped
- * \param rect an SDL_Rect structure filled in with the clipping rectangle for
- *             the surface
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitSurface
- * \sa SDL_SetClipRect
- */
-extern DECLSPEC void SDLCALL SDL_GetClipRect(SDL_Surface * surface,
-                                             SDL_Rect * rect);
-
-/*
- * Creates a new surface identical to the existing surface.
- *
- * The returned surface should be freed with SDL_FreeSurface().
- *
- * \param surface the surface to duplicate.
- * \returns a copy of the surface, or NULL on failure; call SDL_GetError() for
- *          more information.
- */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_DuplicateSurface(SDL_Surface * surface);
-
-/**
- * Copy an existing surface to a new surface of the specified format.
- *
- * This function is used to optimize images for faster *repeat* blitting. This
- * is accomplished by converting the original and storing the result as a new
- * surface. The new, optimized surface can then be used as the source for
- * future blits, making them faster.
- *
- * \param src the existing SDL_Surface structure to convert
- * \param fmt the SDL_PixelFormat structure that the new surface is optimized
- *            for
- * \param flags the flags are unused and should be set to 0; this is a
- *              leftover from SDL 1.2's API
- * \returns the new SDL_Surface structure that is created or NULL if it fails;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AllocFormat
- * \sa SDL_ConvertSurfaceFormat
- * \sa SDL_CreateRGBSurface
- */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurface
-    (SDL_Surface * src, const SDL_PixelFormat * fmt, Uint32 flags);
-
-/**
- * Copy an existing surface to a new surface of the specified format enum.
- *
- * This function operates just like SDL_ConvertSurface(), but accepts an
- * SDL_PixelFormatEnum value instead of an SDL_PixelFormat structure. As such,
- * it might be easier to call but it doesn't have access to palette
- * information for the destination surface, in case that would be important.
- *
- * \param src the existing SDL_Surface structure to convert
- * \param pixel_format the SDL_PixelFormatEnum that the new surface is
- *                     optimized for
- * \param flags the flags are unused and should be set to 0; this is a
- *              leftover from SDL 1.2's API
- * \returns the new SDL_Surface structure that is created or NULL if it fails;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AllocFormat
- * \sa SDL_ConvertSurface
- * \sa SDL_CreateRGBSurface
- */
-extern DECLSPEC SDL_Surface *SDLCALL SDL_ConvertSurfaceFormat
-    (SDL_Surface * src, Uint32 pixel_format, Uint32 flags);
-
-/**
- * Copy a block of pixels of one format to another format.
- *
- * \param width the width of the block to copy, in pixels
- * \param height the height of the block to copy, in pixels
- * \param src_format an SDL_PixelFormatEnum value of the `src` pixels format
- * \param src a pointer to the source pixels
- * \param src_pitch the pitch of the source pixels, in bytes
- * \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format
- * \param dst a pointer to be filled in with new pixel data
- * \param dst_pitch the pitch of the destination pixels, in bytes
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_ConvertPixels(int width, int height,
-                                              Uint32 src_format,
-                                              const void * src, int src_pitch,
-                                              Uint32 dst_format,
-                                              void * dst, int dst_pitch);
-
-/**
- * Premultiply the alpha on a block of pixels.
- *
- * This is safe to use with src == dst, but not for other overlapping areas.
- *
- * This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888.
- *
- * \param width the width of the block to convert, in pixels
- * \param height the height of the block to convert, in pixels
- * \param src_format an SDL_PixelFormatEnum value of the `src` pixels format
- * \param src a pointer to the source pixels
- * \param src_pitch the pitch of the source pixels, in bytes
- * \param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format
- * \param dst a pointer to be filled in with premultiplied pixel data
- * \param dst_pitch the pitch of the destination pixels, in bytes
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_PremultiplyAlpha(int width, int height,
-                                                 Uint32 src_format,
-                                                 const void * src, int src_pitch,
-                                                 Uint32 dst_format,
-                                                 void * dst, int dst_pitch);
-
-/**
- * Perform a fast fill of a rectangle with a specific color.
- *
- * `color` should be a pixel of the format used by the surface, and can be
- * generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an
- * alpha component then the destination is simply filled with that alpha
- * information, no blending takes place.
- *
- * If there is a clip rectangle set on the destination (set via
- * SDL_SetClipRect()), then this function will fill based on the intersection
- * of the clip rectangle and `rect`.
- *
- * \param dst the SDL_Surface structure that is the drawing target
- * \param rect the SDL_Rect structure representing the rectangle to fill, or
- *             NULL to fill the entire surface
- * \param color the color to fill with
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_FillRects
- */
-extern DECLSPEC int SDLCALL SDL_FillRect
-    (SDL_Surface * dst, const SDL_Rect * rect, Uint32 color);
-
-/**
- * Perform a fast fill of a set of rectangles with a specific color.
- *
- * `color` should be a pixel of the format used by the surface, and can be
- * generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an
- * alpha component then the destination is simply filled with that alpha
- * information, no blending takes place.
- *
- * If there is a clip rectangle set on the destination (set via
- * SDL_SetClipRect()), then this function will fill based on the intersection
- * of the clip rectangle and `rect`.
- *
- * \param dst the SDL_Surface structure that is the drawing target
- * \param rects an array of SDL_Rects representing the rectangles to fill.
- * \param count the number of rectangles in the array
- * \param color the color to fill with
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_FillRect
- */
-extern DECLSPEC int SDLCALL SDL_FillRects
-    (SDL_Surface * dst, const SDL_Rect * rects, int count, Uint32 color);
-
-/* !!! FIXME: merge this documentation with the wiki */
-/**
- *  Performs a fast blit from the source surface to the destination surface.
- *
- *  This assumes that the source and destination rectangles are
- *  the same size.  If either \c srcrect or \c dstrect are NULL, the entire
- *  surface (\c src or \c dst) is copied.  The final blit rectangles are saved
- *  in \c srcrect and \c dstrect after all clipping is performed.
- *
- *  \returns 0 if the blit is successful, otherwise it returns -1.
- *
- *  The blit function should not be called on a locked surface.
- *
- *  The blit semantics for surfaces with and without blending and colorkey
- *  are defined as follows:
- *  \verbatim
-    RGBA->RGB:
-      Source surface blend mode set to SDL_BLENDMODE_BLEND:
-        alpha-blend (using the source alpha-channel and per-surface alpha)
-        SDL_SRCCOLORKEY ignored.
-      Source surface blend mode set to SDL_BLENDMODE_NONE:
-        copy RGB.
-        if SDL_SRCCOLORKEY set, only copy the pixels matching the
-        RGB values of the source color key, ignoring alpha in the
-        comparison.
-
-    RGB->RGBA:
-      Source surface blend mode set to SDL_BLENDMODE_BLEND:
-        alpha-blend (using the source per-surface alpha)
-      Source surface blend mode set to SDL_BLENDMODE_NONE:
-        copy RGB, set destination alpha to source per-surface alpha value.
-      both:
-        if SDL_SRCCOLORKEY set, only copy the pixels matching the
-        source color key.
-
-    RGBA->RGBA:
-      Source surface blend mode set to SDL_BLENDMODE_BLEND:
-        alpha-blend (using the source alpha-channel and per-surface alpha)
-        SDL_SRCCOLORKEY ignored.
-      Source surface blend mode set to SDL_BLENDMODE_NONE:
-        copy all of RGBA to the destination.
-        if SDL_SRCCOLORKEY set, only copy the pixels matching the
-        RGB values of the source color key, ignoring alpha in the
-        comparison.
-
-    RGB->RGB:
-      Source surface blend mode set to SDL_BLENDMODE_BLEND:
-        alpha-blend (using the source per-surface alpha)
-      Source surface blend mode set to SDL_BLENDMODE_NONE:
-        copy RGB.
-      both:
-        if SDL_SRCCOLORKEY set, only copy the pixels matching the
-        source color key.
-    \endverbatim
- *
- *  You should call SDL_BlitSurface() unless you know exactly how SDL
- *  blitting works internally and how to use the other blit functions.
- */
-#define SDL_BlitSurface SDL_UpperBlit
-
-/**
- * Perform a fast blit from the source surface to the destination surface.
- *
- * SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a
- * macro for this function with a less confusing name.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitSurface
- */
-extern DECLSPEC int SDLCALL SDL_UpperBlit
-    (SDL_Surface * src, const SDL_Rect * srcrect,
-     SDL_Surface * dst, SDL_Rect * dstrect);
-
-/**
- * Perform low-level surface blitting only.
- *
- * This is a semi-private blit function and it performs low-level surface
- * blitting, assuming the input rectangles have already been clipped.
- *
- * Unless you know what you're doing, you should be using SDL_BlitSurface()
- * instead.
- *
- * \param src the SDL_Surface structure to be copied from
- * \param srcrect the SDL_Rect structure representing the rectangle to be
- *                copied, or NULL to copy the entire surface
- * \param dst the SDL_Surface structure that is the blit target
- * \param dstrect the SDL_Rect structure representing the rectangle that is
- *                copied into
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitSurface
- */
-extern DECLSPEC int SDLCALL SDL_LowerBlit
-    (SDL_Surface * src, SDL_Rect * srcrect,
-     SDL_Surface * dst, SDL_Rect * dstrect);
-
-
-/**
- * Perform a fast, low quality, stretch blit between two surfaces of the same
- * format.
- *
- * Please use SDL_BlitScaled() instead.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_SoftStretch(SDL_Surface * src,
-                                            const SDL_Rect * srcrect,
-                                            SDL_Surface * dst,
-                                            const SDL_Rect * dstrect);
-
-/**
- * Perform bilinear scaling between two surfaces of the same format, 32BPP.
- *
- * \since This function is available since SDL 2.0.16.
- */
-extern DECLSPEC int SDLCALL SDL_SoftStretchLinear(SDL_Surface * src,
-                                            const SDL_Rect * srcrect,
-                                            SDL_Surface * dst,
-                                            const SDL_Rect * dstrect);
-
-
-#define SDL_BlitScaled SDL_UpperBlitScaled
-
-/**
- * Perform a scaled surface copy to a destination surface.
- *
- * SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is
- * merely a macro for this function with a less confusing name.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitScaled
- */
-extern DECLSPEC int SDLCALL SDL_UpperBlitScaled
-    (SDL_Surface * src, const SDL_Rect * srcrect,
-    SDL_Surface * dst, SDL_Rect * dstrect);
-
-/**
- * Perform low-level surface scaled blitting only.
- *
- * This is a semi-private function and it performs low-level surface blitting,
- * assuming the input rectangles have already been clipped.
- *
- * \param src the SDL_Surface structure to be copied from
- * \param srcrect the SDL_Rect structure representing the rectangle to be
- *                copied
- * \param dst the SDL_Surface structure that is the blit target
- * \param dstrect the SDL_Rect structure representing the rectangle that is
- *                copied into
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_BlitScaled
- */
-extern DECLSPEC int SDLCALL SDL_LowerBlitScaled
-    (SDL_Surface * src, SDL_Rect * srcrect,
-    SDL_Surface * dst, SDL_Rect * dstrect);
-
-/**
- * Set the YUV conversion mode
- *
- * \since This function is available since SDL 2.0.8.
- */
-extern DECLSPEC void SDLCALL SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_MODE mode);
-
-/**
- * Get the YUV conversion mode
- *
- * \since This function is available since SDL 2.0.8.
- */
-extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionMode(void);
-
-/**
- * Get the YUV conversion mode, returning the correct mode for the resolution
- * when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC
- *
- * \since This function is available since SDL 2.0.8.
- */
-extern DECLSPEC SDL_YUV_CONVERSION_MODE SDLCALL SDL_GetYUVConversionModeForResolution(int width, int height);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_surface_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,575 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_system.h
- *
- *  Include file for platform specific SDL API functions
- */
-
-#ifndef SDL_system_h_
-#define SDL_system_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_keyboard.h"
-#include "SDL_render.h"
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Platform specific functions for Windows */
-#ifdef __WIN32__
-	
-typedef void (SDLCALL * SDL_WindowsMessageHook)(void *userdata, void *hWnd, unsigned int message, Uint64 wParam, Sint64 lParam);
-
-/**
- * Set a callback for every Windows message, run before TranslateMessage().
- *
- * \param callback The SDL_WindowsMessageHook function to call.
- * \param userdata a pointer to pass to every iteration of `callback`
- *
- * \since This function is available since SDL 2.0.4.
- */
-extern DECLSPEC void SDLCALL SDL_SetWindowsMessageHook(SDL_WindowsMessageHook callback, void *userdata);
-
-/**
- * Get the D3D9 adapter index that matches the specified display index.
- *
- * The returned adapter index can be passed to `IDirect3D9::CreateDevice` and
- * controls on which monitor a full screen application will appear.
- *
- * \param displayIndex the display index for which to get the D3D9 adapter
- *                     index
- * \returns the D3D9 adapter index on success or a negative error code on
- *          failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.1.
- */
-extern DECLSPEC int SDLCALL SDL_Direct3D9GetAdapterIndex( int displayIndex );
-
-typedef struct IDirect3DDevice9 IDirect3DDevice9;
-
-/**
- * Get the D3D9 device associated with a renderer.
- *
- * Once you are done using the device, you should release it to avoid a
- * resource leak.
- *
- * \param renderer the renderer from which to get the associated D3D device
- * \returns the D3D9 device associated with given renderer or NULL if it is
- *          not a D3D9 renderer; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.1.
- */
-extern DECLSPEC IDirect3DDevice9* SDLCALL SDL_RenderGetD3D9Device(SDL_Renderer * renderer);
-
-typedef struct ID3D11Device ID3D11Device;
-
-/**
- * Get the D3D11 device associated with a renderer.
- *
- * Once you are done using the device, you should release it to avoid a
- * resource leak.
- *
- * \param renderer the renderer from which to get the associated D3D11 device
- * \returns the D3D11 device associated with given renderer or NULL if it is
- *          not a D3D11 renderer; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.16.
- */
-extern DECLSPEC ID3D11Device* SDLCALL SDL_RenderGetD3D11Device(SDL_Renderer * renderer);
-
-/**
- * Get the DXGI Adapter and Output indices for the specified display index.
- *
- * The DXGI Adapter and Output indices can be passed to `EnumAdapters` and
- * `EnumOutputs` respectively to get the objects required to create a DX10 or
- * DX11 device and swap chain.
- *
- * Before SDL 2.0.4 this function did not return a value. Since SDL 2.0.4 it
- * returns an SDL_bool.
- *
- * \param displayIndex the display index for which to get both indices
- * \param adapterIndex a pointer to be filled in with the adapter index
- * \param outputIndex a pointer to be filled in with the output index
- * \returns SDL_TRUE on success or SDL_FALSE on failure; call SDL_GetError()
- *          for more information.
- *
- * \since This function is available since SDL 2.0.2.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_DXGIGetOutputInfo( int displayIndex, int *adapterIndex, int *outputIndex );
-
-#endif /* __WIN32__ */
-
-
-/* Platform specific functions for Linux */
-#ifdef __LINUX__
-
-/**
- * Sets the UNIX nice value for a thread.
- *
- * This uses setpriority() if possible, and RealtimeKit if available.
- *
- * \param threadID the Unix thread ID to change priority of.
- * \param priority The new, Unix-specific, priority value.
- * \returns 0 on success, or -1 on error.
- *
- * \since This function is available since SDL 2.0.9.
- */
-extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriority(Sint64 threadID, int priority);
-
-/**
- * Sets the priority (not nice level) and scheduling policy for a thread.
- *
- * This uses setpriority() if possible, and RealtimeKit if available.
- *
- * \param threadID The Unix thread ID to change priority of.
- * \param sdlPriority The new SDL_ThreadPriority value.
- * \param schedPolicy The new scheduling policy (SCHED_FIFO, SCHED_RR,
- *                    SCHED_OTHER, etc...)
- * \returns 0 on success, or -1 on error.
- *
- * \since This function is available since SDL 2.0.18.
- */
-extern DECLSPEC int SDLCALL SDL_LinuxSetThreadPriorityAndPolicy(Sint64 threadID, int sdlPriority, int schedPolicy);
- 
-#endif /* __LINUX__ */
-	
-/* Platform specific functions for iOS */
-#ifdef __IPHONEOS__
-
-#define SDL_iOSSetAnimationCallback(window, interval, callback, callbackParam) SDL_iPhoneSetAnimationCallback(window, interval, callback, callbackParam)
-
-/**
- * Use this function to set the animation callback on Apple iOS.
- *
- * The function prototype for `callback` is:
- *
- * ```c
- * void callback(void* callbackParam);
- * ```
- *
- * Where its parameter, `callbackParam`, is what was passed as `callbackParam`
- * to SDL_iPhoneSetAnimationCallback().
- *
- * This function is only available on Apple iOS.
- *
- * For more information see:
- * [README-ios.md](https://hg.libsdl.org/SDL/file/default/docs/README-ios.md)
- *
- * This functions is also accessible using the macro
- * SDL_iOSSetAnimationCallback() since SDL 2.0.4.
- *
- * \param window the window for which the animation callback should be set
- * \param interval the number of frames after which **callback** will be
- *                 called
- * \param callback the function to call for every frame.
- * \param callbackParam a pointer that is passed to `callback`.
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_iPhoneSetEventPump
- */
-extern DECLSPEC int SDLCALL SDL_iPhoneSetAnimationCallback(SDL_Window * window, int interval, void (*callback)(void*), void *callbackParam);
-
-#define SDL_iOSSetEventPump(enabled) SDL_iPhoneSetEventPump(enabled)
-
-/**
- * Use this function to enable or disable the SDL event pump on Apple iOS.
- *
- * This function is only available on Apple iOS.
- *
- * This functions is also accessible using the macro SDL_iOSSetEventPump()
- * since SDL 2.0.4.
- *
- * \param enabled SDL_TRUE to enable the event pump, SDL_FALSE to disable it
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_iPhoneSetAnimationCallback
- */
-extern DECLSPEC void SDLCALL SDL_iPhoneSetEventPump(SDL_bool enabled);
-
-#endif /* __IPHONEOS__ */
-
-
-/* Platform specific functions for Android */
-#ifdef __ANDROID__
-
-/**
- * Get the Android Java Native Interface Environment of the current thread.
- *
- * This is the JNIEnv one needs to access the Java virtual machine from native
- * code, and is needed for many Android APIs to be usable from C.
- *
- * The prototype of the function in SDL's code actually declare a void* return
- * type, even if the implementation returns a pointer to a JNIEnv. The
- * rationale being that the SDL headers can avoid including jni.h.
- *
- * \returns a pointer to Java native interface object (JNIEnv) to which the
- *          current thread is attached, or 0 on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AndroidGetActivity
- */
-extern DECLSPEC void * SDLCALL SDL_AndroidGetJNIEnv(void);
-
-/**
- * Retrieve the Java instance of the Android activity class.
- *
- * The prototype of the function in SDL's code actually declares a void*
- * return type, even if the implementation returns a jobject. The rationale
- * being that the SDL headers can avoid including jni.h.
- *
- * The jobject returned by the function is a local reference and must be
- * released by the caller. See the PushLocalFrame() and PopLocalFrame() or
- * DeleteLocalRef() functions of the Java native interface:
- *
- * https://docs.oracle.com/javase/1.5.0/docs/guide/jni/spec/functions.html
- *
- * \returns the jobject representing the instance of the Activity class of the
- *          Android application, or NULL on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AndroidGetJNIEnv
- */
-extern DECLSPEC void * SDLCALL SDL_AndroidGetActivity(void);
-
-/**
- * Query Android API level of the current device.
- *
- * - API level 31: Android 12
- * - API level 30: Android 11
- * - API level 29: Android 10
- * - API level 28: Android 9
- * - API level 27: Android 8.1
- * - API level 26: Android 8.0
- * - API level 25: Android 7.1
- * - API level 24: Android 7.0
- * - API level 23: Android 6.0
- * - API level 22: Android 5.1
- * - API level 21: Android 5.0
- * - API level 20: Android 4.4W
- * - API level 19: Android 4.4
- * - API level 18: Android 4.3
- * - API level 17: Android 4.2
- * - API level 16: Android 4.1
- * - API level 15: Android 4.0.3
- * - API level 14: Android 4.0
- * - API level 13: Android 3.2
- * - API level 12: Android 3.1
- * - API level 11: Android 3.0
- * - API level 10: Android 2.3.3
- *
- * \returns the Android API level.
- *
- * \since This function is available since SDL 2.0.12.
- */
-extern DECLSPEC int SDLCALL SDL_GetAndroidSDKVersion(void);
-
-/**
- * Query if the application is running on Android TV.
- *
- * \returns SDL_TRUE if this is Android TV, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.8.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsAndroidTV(void);
-
-/**
- * Query if the application is running on a Chromebook.
- *
- * \returns SDL_TRUE if this is a Chromebook, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.9.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsChromebook(void);
-
-/**
- * Query if the application is running on a Samsung DeX docking station.
- *
- * \returns SDL_TRUE if this is a DeX docking station, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.9.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsDeXMode(void);
-
-/**
- * Trigger the Android system back button behavior.
- *
- * \since This function is available since SDL 2.0.9.
- */
-extern DECLSPEC void SDLCALL SDL_AndroidBackButton(void);
-
-/**
-   See the official Android developer guide for more information:
-   http://developer.android.com/guide/topics/data/data-storage.html
-*/
-#define SDL_ANDROID_EXTERNAL_STORAGE_READ   0x01
-#define SDL_ANDROID_EXTERNAL_STORAGE_WRITE  0x02
-
-/**
- * Get the path used for internal storage for this application.
- *
- * This path is unique to your application and cannot be written to by other
- * applications.
- *
- * Your internal storage path is typically:
- * `/data/data/your.app.package/files`.
- *
- * \returns the path used for internal storage or NULL on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AndroidGetExternalStorageState
- */
-extern DECLSPEC const char * SDLCALL SDL_AndroidGetInternalStoragePath(void);
-
-/**
- * Get the current state of external storage.
- *
- * The current state of external storage, a bitmask of these values:
- * `SDL_ANDROID_EXTERNAL_STORAGE_READ`, `SDL_ANDROID_EXTERNAL_STORAGE_WRITE`.
- *
- * If external storage is currently unavailable, this will return 0.
- *
- * \returns the current state of external storage on success or 0 on failure;
- *          call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AndroidGetExternalStoragePath
- */
-extern DECLSPEC int SDLCALL SDL_AndroidGetExternalStorageState(void);
-
-/**
- * Get the path used for external storage for this application.
- *
- * This path is unique to your application, but is public and can be written
- * to by other applications.
- *
- * Your external storage path is typically:
- * `/storage/sdcard0/Android/data/your.app.package/files`.
- *
- * \returns the path used for external storage for this application on success
- *          or NULL on failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_AndroidGetExternalStorageState
- */
-extern DECLSPEC const char * SDLCALL SDL_AndroidGetExternalStoragePath(void);
-
-/**
- * Request permissions at runtime.
- *
- * This blocks the calling thread until the permission is granted or denied.
- *
- * \param permission The permission to request.
- * \returns SDL_TRUE if the permission was granted, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.14.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AndroidRequestPermission(const char *permission);
-
-/**
- * Shows an Android toast notification.
- *
- * Toasts are a sort of lightweight notification that are unique to Android.
- *
- * https://developer.android.com/guide/topics/ui/notifiers/toasts
- *
- * Shows toast in UI thread.
- *
- * For the `gravity` parameter, choose a value from here, or -1 if you don't
- * have a preference:
- *
- * https://developer.android.com/reference/android/view/Gravity
- *
- * \param message text message to be shown
- * \param duration 0=short, 1=long
- * \param gravity where the notification should appear on the screen.
- * \param xoffset set this parameter only when gravity >=0
- * \param yoffset set this parameter only when gravity >=0
- * \returns 0 if success, -1 if any error occurs.
- *
- * \since This function is available since SDL 2.0.16.
- */
-extern DECLSPEC int SDLCALL SDL_AndroidShowToast(const char* message, int duration, int gravity, int xoffset, int yoffset);
-
-/**
- * Send a user command to SDLActivity.
- *
- * Override "boolean onUnhandledMessage(Message msg)" to handle the message.
- *
- * \param command user command that must be greater or equal to 0x8000
- * \param param user parameter
- *
- * \since This function is available since SDL 2.0.22.
- */
-extern DECLSPEC int SDLCALL SDL_AndroidSendMessage(Uint32 command, int param);
-
-#endif /* __ANDROID__ */
-
-/* Platform specific functions for WinRT */
-#ifdef __WINRT__
-
-/**
- *  \brief WinRT / Windows Phone path types
- */
-typedef enum
-{
-    /** \brief The installed app's root directory.
-        Files here are likely to be read-only. */
-    SDL_WINRT_PATH_INSTALLED_LOCATION,
-
-    /** \brief The app's local data store.  Files may be written here */
-    SDL_WINRT_PATH_LOCAL_FOLDER,
-
-    /** \brief The app's roaming data store.  Unsupported on Windows Phone.
-        Files written here may be copied to other machines via a network
-        connection.
-    */
-    SDL_WINRT_PATH_ROAMING_FOLDER,
-
-    /** \brief The app's temporary data store.  Unsupported on Windows Phone.
-        Files written here may be deleted at any time. */
-    SDL_WINRT_PATH_TEMP_FOLDER
-} SDL_WinRT_Path;
-
-
-/**
- *  \brief WinRT Device Family
- */
-typedef enum
-{
-    /** \brief Unknown family  */
-    SDL_WINRT_DEVICEFAMILY_UNKNOWN,
-
-    /** \brief Desktop family*/
-    SDL_WINRT_DEVICEFAMILY_DESKTOP,
-
-    /** \brief Mobile family (for example smartphone) */
-    SDL_WINRT_DEVICEFAMILY_MOBILE,
-
-    /** \brief XBox family */
-    SDL_WINRT_DEVICEFAMILY_XBOX,
-} SDL_WinRT_DeviceFamily;
-
-
-/**
- * Retrieve a WinRT defined path on the local file system.
- *
- * Not all paths are available on all versions of Windows. This is especially
- * true on Windows Phone. Check the documentation for the given SDL_WinRT_Path
- * for more information on which path types are supported where.
- *
- * Documentation on most app-specific path types on WinRT can be found on
- * MSDN, at the URL:
- *
- * https://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx
- *
- * \param pathType the type of path to retrieve, one of SDL_WinRT_Path
- * \returns a UCS-2 string (16-bit, wide-char) containing the path, or NULL if
- *          the path is not available for any reason; call SDL_GetError() for
- *          more information.
- *
- * \since This function is available since SDL 2.0.3.
- *
- * \sa SDL_WinRTGetFSPathUTF8
- */
-extern DECLSPEC const wchar_t * SDLCALL SDL_WinRTGetFSPathUNICODE(SDL_WinRT_Path pathType);
-
-/**
- * Retrieve a WinRT defined path on the local file system.
- *
- * Not all paths are available on all versions of Windows. This is especially
- * true on Windows Phone. Check the documentation for the given SDL_WinRT_Path
- * for more information on which path types are supported where.
- *
- * Documentation on most app-specific path types on WinRT can be found on
- * MSDN, at the URL:
- *
- * https://msdn.microsoft.com/en-us/library/windows/apps/hh464917.aspx
- *
- * \param pathType the type of path to retrieve, one of SDL_WinRT_Path
- * \returns a UTF-8 string (8-bit, multi-byte) containing the path, or NULL if
- *          the path is not available for any reason; call SDL_GetError() for
- *          more information.
- *
- * \since This function is available since SDL 2.0.3.
- *
- * \sa SDL_WinRTGetFSPathUNICODE
- */
-extern DECLSPEC const char * SDLCALL SDL_WinRTGetFSPathUTF8(SDL_WinRT_Path pathType);
-
-/**
- * Detects the device family of WinRT plattform at runtime.
- *
- * \returns a value from the SDL_WinRT_DeviceFamily enum.
- *
- * \since This function is available since SDL 2.0.8.
- */
-extern DECLSPEC SDL_WinRT_DeviceFamily SDLCALL SDL_WinRTGetDeviceFamily();
-
-#endif /* __WINRT__ */
-
-/**
- * Query if the current device is a tablet.
- *
- * If SDL can't determine this, it will return SDL_FALSE.
- *
- * \returns SDL_TRUE if the device is a tablet, SDL_FALSE otherwise.
- *
- * \since This function is available since SDL 2.0.9.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_IsTablet(void);
-
-/* Functions used by iOS application delegates to notify SDL about state changes */
-extern DECLSPEC void SDLCALL SDL_OnApplicationWillTerminate(void);
-extern DECLSPEC void SDLCALL SDL_OnApplicationDidReceiveMemoryWarning(void);
-extern DECLSPEC void SDLCALL SDL_OnApplicationWillResignActive(void);
-extern DECLSPEC void SDLCALL SDL_OnApplicationDidEnterBackground(void);
-extern DECLSPEC void SDLCALL SDL_OnApplicationWillEnterForeground(void);
-extern DECLSPEC void SDLCALL SDL_OnApplicationDidBecomeActive(void);
-#ifdef __IPHONEOS__
-extern DECLSPEC void SDLCALL SDL_OnApplicationDidChangeStatusBarOrientation(void);
-#endif
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_system_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,69 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_test.h
- *
- *  Include file for SDL test framework.
- *
- *  This code is a part of the SDL2_test library, not the main SDL library.
- */
-
-#ifndef SDL_test_h_
-#define SDL_test_h_
-
-#include "SDL.h"
-#include "SDL_test_assert.h"
-#include "SDL_test_common.h"
-#include "SDL_test_compare.h"
-#include "SDL_test_crc32.h"
-#include "SDL_test_font.h"
-#include "SDL_test_fuzzer.h"
-#include "SDL_test_harness.h"
-#include "SDL_test_images.h"
-#include "SDL_test_log.h"
-#include "SDL_test_md5.h"
-#include "SDL_test_memory.h"
-#include "SDL_test_random.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Global definitions */
-
-/*
- * Note: Maximum size of SDLTest log message is less than SDL's limit
- * to ensure we can fit additional information such as the timestamp.
- */
-#define SDLTEST_MAX_LOGMESSAGE_LENGTH   3584
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_test_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,235 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_test_common.h
- *
- *  Include file for SDL test framework.
- *
- *  This code is a part of the SDL2_test library, not the main SDL library.
- */
-
-/* Ported from original test\common.h file. */
-
-#ifndef SDL_test_common_h_
-#define SDL_test_common_h_
-
-#include "SDL.h"
-
-#if defined(__PSP__)
-#define DEFAULT_WINDOW_WIDTH  480
-#define DEFAULT_WINDOW_HEIGHT 272
-#elif defined(__VITA__)
-#define DEFAULT_WINDOW_WIDTH  960
-#define DEFAULT_WINDOW_HEIGHT 544
-#else
-#define DEFAULT_WINDOW_WIDTH  640
-#define DEFAULT_WINDOW_HEIGHT 480
-#endif
-
-#define VERBOSE_VIDEO   0x00000001
-#define VERBOSE_MODES   0x00000002
-#define VERBOSE_RENDER  0x00000004
-#define VERBOSE_EVENT   0x00000008
-#define VERBOSE_AUDIO   0x00000010
-
-typedef struct
-{
-    /* SDL init flags */
-    char **argv;
-    Uint32 flags;
-    Uint32 verbose;
-
-    /* Video info */
-    const char *videodriver;
-    int display;
-    const char *window_title;
-    const char *window_icon;
-    Uint32 window_flags;
-    SDL_bool flash_on_focus_loss;
-    int window_x;
-    int window_y;
-    int window_w;
-    int window_h;
-    int window_minW;
-    int window_minH;
-    int window_maxW;
-    int window_maxH;
-    int logical_w;
-    int logical_h;
-    float scale;
-    int depth;
-    int refresh_rate;
-    int num_windows;
-    SDL_Window **windows;
-
-    /* Renderer info */
-    const char *renderdriver;
-    Uint32 render_flags;
-    SDL_bool skip_renderer;
-    SDL_Renderer **renderers;
-    SDL_Texture **targets;
-
-    /* Audio info */
-    const char *audiodriver;
-    SDL_AudioSpec audiospec;
-
-    /* GL settings */
-    int gl_red_size;
-    int gl_green_size;
-    int gl_blue_size;
-    int gl_alpha_size;
-    int gl_buffer_size;
-    int gl_depth_size;
-    int gl_stencil_size;
-    int gl_double_buffer;
-    int gl_accum_red_size;
-    int gl_accum_green_size;
-    int gl_accum_blue_size;
-    int gl_accum_alpha_size;
-    int gl_stereo;
-    int gl_multisamplebuffers;
-    int gl_multisamplesamples;
-    int gl_retained_backing;
-    int gl_accelerated;
-    int gl_major_version;
-    int gl_minor_version;
-    int gl_debug;
-    int gl_profile_mask;
-
-    /* Additional fields added in 2.0.18 */
-    SDL_Rect confine;
-
-} SDLTest_CommonState;
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Function prototypes */
-
-/**
- * \brief Parse command line parameters and create common state.
- *
- * \param argv Array of command line parameters
- * \param flags Flags indicating which subsystem to initialize (i.e. SDL_INIT_VIDEO | SDL_INIT_AUDIO)
- *
- * \returns a newly allocated common state object.
- */
-SDLTest_CommonState *SDLTest_CommonCreateState(char **argv, Uint32 flags);
-
-/**
- * \brief Process one common argument.
- *
- * \param state The common state describing the test window to create.
- * \param index The index of the argument to process in argv[].
- *
- * \returns the number of arguments processed (i.e. 1 for --fullscreen, 2 for --video [videodriver], or -1 on error.
- */
-int SDLTest_CommonArg(SDLTest_CommonState * state, int index);
-
-
-/**
- * \brief Logs command line usage info.
- *
- * This logs the appropriate command line options for the subsystems in use
- *  plus other common options, and then any application-specific options.
- *  This uses the SDL_Log() function and splits up output to be friendly to
- *  80-character-wide terminals.
- *
- * \param state The common state describing the test window for the app.
- * \param argv0 argv[0], as passed to main/SDL_main.
- * \param options an array of strings for application specific options. The last element of the array should be NULL.
- */
-void SDLTest_CommonLogUsage(SDLTest_CommonState * state, const char *argv0, const char **options);
-
-/**
- * \brief Returns common usage information
- *
- * You should (probably) be using SDLTest_CommonLogUsage() instead, but this
- *  function remains for binary compatibility. Strings returned from this
- *  function are valid until SDLTest_CommonQuit() is called, in which case
- *  those strings' memory is freed and can no longer be used.
- *
- * \param state The common state describing the test window to create.
- * \returns a string with usage information
- */
-const char *SDLTest_CommonUsage(SDLTest_CommonState * state);
-
-/**
- * \brief Open test window.
- *
- * \param state The common state describing the test window to create.
- *
- * \returns SDL_TRUE if initialization succeeded, false otherwise
- */
-SDL_bool SDLTest_CommonInit(SDLTest_CommonState * state);
-
-/**
- * \brief Easy argument handling when test app doesn't need any custom args.
- *
- * \param state The common state describing the test window to create.
- * \param argc argc, as supplied to SDL_main
- * \param argv argv, as supplied to SDL_main
- *
- * \returns SDL_FALSE if app should quit, true otherwise.
- */
-SDL_bool SDLTest_CommonDefaultArgs(SDLTest_CommonState * state, const int argc, char **argv);
-
-/**
- * \brief Common event handler for test windows.
- *
- * \param state The common state used to create test window.
- * \param event The event to handle.
- * \param done Flag indicating we are done.
- *
- */
-void SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done);
-
-/**
- * \brief Close test window.
- *
- * \param state The common state used to create test window.
- *
- */
-void SDLTest_CommonQuit(SDLTest_CommonState * state);
-
-/**
- * \brief Draws various window information (position, size, etc.) to the renderer.
- *
- * \param renderer The renderer to draw to.
- * \param window The window whose information should be displayed.
- * \param usedHeight Returns the height used, so the caller can draw more below.
- *
- */
-void SDLTest_CommonDrawWindowInfo(SDL_Renderer * renderer, SDL_Window * window, int * usedHeight);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_test_common_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,69 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_test_compare.h
- *
- *  Include file for SDL test framework.
- *
- *  This code is a part of the SDL2_test library, not the main SDL library.
- */
-
-/*
-
- Defines comparison functions (i.e. for surfaces).
-
-*/
-
-#ifndef SDL_test_compare_h_
-#define SDL_test_compare_h_
-
-#include "SDL.h"
-
-#include "SDL_test_images.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief Compares a surface and with reference image data for equality
- *
- * \param surface Surface used in comparison
- * \param referenceSurface Test Surface used in comparison
- * \param allowable_error Allowable difference (=sum of squared difference for each RGB component) in blending accuracy.
- *
- * \returns 0 if comparison succeeded, >0 (=number of pixels for which the comparison failed) if comparison failed, -1 if any of the surfaces were NULL, -2 if the surface sizes differ.
- */
-int SDLTest_CompareSurfaces(SDL_Surface *surface, SDL_Surface *referenceSurface, int allowable_error);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_test_compare_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,124 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_test_crc32.h
- *
- *  Include file for SDL test framework.
- *
- *  This code is a part of the SDL2_test library, not the main SDL library.
- */
-
-/*
-
- Implements CRC32 calculations (default output is Perl String::CRC32 compatible).
-
-*/
-
-#ifndef SDL_test_crc32_h_
-#define SDL_test_crc32_h_
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* ------------ Definitions --------- */
-
-/* Definition shared by all CRC routines */
-
-#ifndef CrcUint32
- #define CrcUint32  unsigned int
-#endif
-#ifndef CrcUint8
- #define CrcUint8   unsigned char
-#endif
-
-#ifdef ORIGINAL_METHOD
- #define CRC32_POLY 0x04c11db7   /* AUTODIN II, Ethernet, & FDDI */
-#else
- #define CRC32_POLY 0xEDB88320   /* Perl String::CRC32 compatible */
-#endif
-
-/**
- * Data structure for CRC32 (checksum) computation
- */
-  typedef struct {
-    CrcUint32    crc32_table[256]; /* CRC table */
-  } SDLTest_Crc32Context;
-
-/* ---------- Function Prototypes ------------- */
-
-/**
- * \brief Initialize the CRC context
- *
- * Note: The function initializes the crc table required for all crc calculations.
- *
- * \param crcContext        pointer to context variable
- *
- * \returns 0 for OK, -1 on error
- *
- */
- int SDLTest_Crc32Init(SDLTest_Crc32Context * crcContext);
-
-
-/**
- * \brief calculate a crc32 from a data block
- *
- * \param crcContext         pointer to context variable
- * \param inBuf              input buffer to checksum
- * \param inLen              length of input buffer
- * \param crc32              pointer to Uint32 to store the final CRC into
- *
- * \returns 0 for OK, -1 on error
- *
- */
-int SDLTest_Crc32Calc(SDLTest_Crc32Context * crcContext, CrcUint8 *inBuf, CrcUint32 inLen, CrcUint32 *crc32);
-
-/* Same routine broken down into three steps */
-int SDLTest_Crc32CalcStart(SDLTest_Crc32Context * crcContext, CrcUint32 *crc32);
-int SDLTest_Crc32CalcEnd(SDLTest_Crc32Context * crcContext, CrcUint32 *crc32);
-int SDLTest_Crc32CalcBuffer(SDLTest_Crc32Context * crcContext, CrcUint8 *inBuf, CrcUint32 inLen, CrcUint32 *crc32);
-
-
-/**
- * \brief clean up CRC context
- *
- * \param crcContext        pointer to context variable
- *
- * \returns 0 for OK, -1 on error
- *
-*/
-
-int SDLTest_Crc32Done(SDLTest_Crc32Context * crcContext);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_test_crc32_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,81 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_test_font.h
- *
- *  Include file for SDL test framework.
- *
- *  This code is a part of the SDL2_test library, not the main SDL library.
- */
-
-#ifndef SDL_test_font_h_
-#define SDL_test_font_h_
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Function prototypes */
-
-#define FONT_CHARACTER_SIZE  8
-
-/**
- *  \brief Draw a string in the currently set font.
- *
- *  \param renderer The renderer to draw on.
- *  \param x The X coordinate of the upper left corner of the character.
- *  \param y The Y coordinate of the upper left corner of the character.
- *  \param c The character to draw.
- *
- *  \returns 0 on success, -1 on failure.
- */
-int SDLTest_DrawCharacter(SDL_Renderer *renderer, int x, int y, char c);
-
-/**
- *  \brief Draw a string in the currently set font.
- *
- *  \param renderer The renderer to draw on.
- *  \param x The X coordinate of the upper left corner of the string.
- *  \param y The Y coordinate of the upper left corner of the string.
- *  \param s The string to draw.
- *
- *  \returns 0 on success, -1 on failure.
- */
-int SDLTest_DrawString(SDL_Renderer *renderer, int x, int y, const char *s);
-
-
-/**
- *  \brief Cleanup textures used by font drawing functions.
- */
-void SDLTest_CleanupTextDrawing(void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_test_font_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,134 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_test_harness.h
- *
- *  Include file for SDL test framework.
- *
- *  This code is a part of the SDL2_test library, not the main SDL library.
- */
-
-/*
-  Defines types for test case definitions and the test execution harness API.
-
-  Based on original GSOC code by Markus Kauppila <markus.kauppila@gmail.com>
-*/
-
-#ifndef SDL_test_h_arness_h
-#define SDL_test_h_arness_h
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* ! Definitions for test case structures */
-#define TEST_ENABLED  1
-#define TEST_DISABLED 0
-
-/* ! Definition of all the possible test return values of the test case method */
-#define TEST_ABORTED        -1
-#define TEST_STARTED         0
-#define TEST_COMPLETED       1
-#define TEST_SKIPPED         2
-
-/* ! Definition of all the possible test results for the harness */
-#define TEST_RESULT_PASSED              0
-#define TEST_RESULT_FAILED              1
-#define TEST_RESULT_NO_ASSERT           2
-#define TEST_RESULT_SKIPPED             3
-#define TEST_RESULT_SETUP_FAILURE       4
-
-/* !< Function pointer to a test case setup function (run before every test) */
-typedef void (*SDLTest_TestCaseSetUpFp)(void *arg);
-
-/* !< Function pointer to a test case function */
-typedef int (*SDLTest_TestCaseFp)(void *arg);
-
-/* !< Function pointer to a test case teardown function (run after every test) */
-typedef void  (*SDLTest_TestCaseTearDownFp)(void *arg);
-
-/**
- * Holds information about a single test case.
- */
-typedef struct SDLTest_TestCaseReference {
-    /* !< Func2Stress */
-    SDLTest_TestCaseFp testCase;
-    /* !< Short name (or function name) "Func2Stress" */
-    const char *name;
-    /* !< Long name or full description "This test pushes func2() to the limit." */
-    const char *description;
-    /* !< Set to TEST_ENABLED or TEST_DISABLED (test won't be run) */
-    int enabled;
-} SDLTest_TestCaseReference;
-
-/**
- * Holds information about a test suite (multiple test cases).
- */
-typedef struct SDLTest_TestSuiteReference {
-    /* !< "PlatformSuite" */
-    const char *name;
-    /* !< The function that is run before each test. NULL skips. */
-    SDLTest_TestCaseSetUpFp testSetUp;
-    /* !< The test cases that are run as part of the suite. Last item should be NULL. */
-    const SDLTest_TestCaseReference **testCases;
-    /* !< The function that is run after each test. NULL skips. */
-    SDLTest_TestCaseTearDownFp testTearDown;
-} SDLTest_TestSuiteReference;
-
-
-/**
- * \brief Generates a random run seed string for the harness. The generated seed will contain alphanumeric characters (0-9A-Z).
- *
- * Note: The returned string needs to be deallocated by the caller.
- *
- * \param length The length of the seed string to generate
- *
- * \returns the generated seed string
- */
-char *SDLTest_GenerateRunSeed(const int length);
-
-/**
- * \brief Execute a test suite using the given run seed and execution key.
- *
- * \param testSuites Suites containing the test case.
- * \param userRunSeed Custom run seed provided by user, or NULL to autogenerate one.
- * \param userExecKey Custom execution key provided by user, or 0 to autogenerate one.
- * \param filter Filter specification. NULL disables. Case sensitive.
- * \param testIterations Number of iterations to run each test case.
- *
- * \returns the test run result: 0 when all tests passed, 1 if any tests failed.
- */
-int SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites[], const char *userRunSeed, Uint64 userExecKey, const char *filter, int testIterations);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_test_h_arness_h */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,67 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_test_log.h
- *
- *  Include file for SDL test framework.
- *
- *  This code is a part of the SDL2_test library, not the main SDL library.
- */
-
-/*
- *
- *  Wrapper to log in the TEST category
- *
- */
-
-#ifndef SDL_test_log_h_
-#define SDL_test_log_h_
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \brief Prints given message with a timestamp in the TEST category and INFO priority.
- *
- * \param fmt Message to be logged
- */
-void SDLTest_Log(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1);
-
-/**
- * \brief Prints given message with a timestamp in the TEST category and the ERROR priority.
- *
- * \param fmt Message to be logged
- */
-void SDLTest_LogError(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(1);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_test_log_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,115 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_test_random.h
- *
- *  Include file for SDL test framework.
- *
- *  This code is a part of the SDL2_test library, not the main SDL library.
- */
-
-/*
-
- A "32-bit Multiply with carry random number generator. Very fast.
- Includes a list of recommended multipliers.
-
- multiply-with-carry generator: x(n) = a*x(n-1) + carry mod 2^32.
- period: (a*2^31)-1
-
-*/
-
-#ifndef SDL_test_random_h_
-#define SDL_test_random_h_
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* --- Definitions */
-
-/*
- * Macros that return a random number in a specific format.
- */
-#define SDLTest_RandomInt(c)        ((int)SDLTest_Random(c))
-
-/*
- * Context structure for the random number generator state.
- */
-  typedef struct {
-    unsigned int a;
-    unsigned int x;
-    unsigned int c;
-    unsigned int ah;
-    unsigned int al;
-  } SDLTest_RandomContext;
-
-
-/* --- Function prototypes */
-
-/**
- *  \brief Initialize random number generator with two integers.
- *
- *  Note: The random sequence of numbers returned by ...Random() is the
- *  same for the same two integers and has a period of 2^31.
- *
- *  \param rndContext     pointer to context structure
- *  \param xi         integer that defines the random sequence
- *  \param ci         integer that defines the random sequence
- *
- */
- void SDLTest_RandomInit(SDLTest_RandomContext * rndContext, unsigned int xi,
-                  unsigned int ci);
-
-/**
- *  \brief Initialize random number generator based on current system time.
- *
- *  \param rndContext     pointer to context structure
- *
- */
- void SDLTest_RandomInitTime(SDLTest_RandomContext *rndContext);
-
-
-/**
- *  \brief Initialize random number generator based on current system time.
- *
- *  Note: ...RandomInit() or ...RandomInitTime() must have been called
- *  before using this function.
- *
- *  \param rndContext     pointer to context structure
- *
- *  \returns a random number (32bit unsigned integer)
- *
- */
- unsigned int SDLTest_Random(SDLTest_RandomContext *rndContext);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_test_random_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,464 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef SDL_thread_h_
-#define SDL_thread_h_
-
-/**
- *  \file SDL_thread.h
- *
- *  Header for the SDL thread management routines.
- */
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-
-/* Thread synchronization primitives */
-#include "SDL_atomic.h"
-#include "SDL_mutex.h"
-
-#if defined(__WIN32__)
-#include <process.h> /* _beginthreadex() and _endthreadex() */
-#endif
-#if defined(__OS2__) /* for _beginthread() and _endthread() */
-#ifndef __EMX__
-#include <process.h>
-#else
-#include <stdlib.h>
-#endif
-#endif
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* The SDL thread structure, defined in SDL_thread.c */
-struct SDL_Thread;
-typedef struct SDL_Thread SDL_Thread;
-
-/* The SDL thread ID */
-typedef unsigned long SDL_threadID;
-
-/* Thread local storage ID, 0 is the invalid ID */
-typedef unsigned int SDL_TLSID;
-
-/**
- *  The SDL thread priority.
- *
- *  SDL will make system changes as necessary in order to apply the thread priority.
- *  Code which attempts to control thread state related to priority should be aware
- *  that calling SDL_SetThreadPriority may alter such state.
- *  SDL_HINT_THREAD_PRIORITY_POLICY can be used to control aspects of this behavior.
- *
- *  \note On many systems you require special privileges to set high or time critical priority.
- */
-typedef enum {
-    SDL_THREAD_PRIORITY_LOW,
-    SDL_THREAD_PRIORITY_NORMAL,
-    SDL_THREAD_PRIORITY_HIGH,
-    SDL_THREAD_PRIORITY_TIME_CRITICAL
-} SDL_ThreadPriority;
-
-/**
- * The function passed to SDL_CreateThread().
- *
- * \param data what was passed as `data` to SDL_CreateThread()
- * \returns a value that can be reported through SDL_WaitThread().
- */
-typedef int (SDLCALL * SDL_ThreadFunction) (void *data);
-
-
-#if defined(__WIN32__)
-/**
- *  \file SDL_thread.h
- *
- *  We compile SDL into a DLL. This means, that it's the DLL which
- *  creates a new thread for the calling process with the SDL_CreateThread()
- *  API. There is a problem with this, that only the RTL of the SDL2.DLL will
- *  be initialized for those threads, and not the RTL of the calling
- *  application!
- *
- *  To solve this, we make a little hack here.
- *
- *  We'll always use the caller's _beginthread() and _endthread() APIs to
- *  start a new thread. This way, if it's the SDL2.DLL which uses this API,
- *  then the RTL of SDL2.DLL will be used to create the new thread, and if it's
- *  the application, then the RTL of the application will be used.
- *
- *  So, in short:
- *  Always use the _beginthread() and _endthread() of the calling runtime
- *  library!
- */
-#define SDL_PASSED_BEGINTHREAD_ENDTHREAD
-
-typedef uintptr_t (__cdecl * pfnSDL_CurrentBeginThread)
-                   (void *, unsigned, unsigned (__stdcall *func)(void *),
-                    void * /*arg*/, unsigned, unsigned * /* threadID */);
-typedef void (__cdecl * pfnSDL_CurrentEndThread) (unsigned code);
-
-#ifndef SDL_beginthread
-#define SDL_beginthread _beginthreadex
-#endif
-#ifndef SDL_endthread
-#define SDL_endthread _endthreadex
-#endif
-
-extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data,
-                 pfnSDL_CurrentBeginThread pfnBeginThread,
-                 pfnSDL_CurrentEndThread pfnEndThread);
-
-extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThreadWithStackSize(int (SDLCALL * fn) (void *),
-                 const char *name, const size_t stacksize, void *data,
-                 pfnSDL_CurrentBeginThread pfnBeginThread,
-                 pfnSDL_CurrentEndThread pfnEndThread);
-
-
-#if defined(SDL_CreateThread) && SDL_DYNAMIC_API
-#undef SDL_CreateThread
-#define SDL_CreateThread(fn, name, data) SDL_CreateThread_REAL(fn, name, data, (pfnSDL_CurrentBeginThread)SDL_beginthread, (pfnSDL_CurrentEndThread)SDL_endthread)
-#undef SDL_CreateThreadWithStackSize
-#define SDL_CreateThreadWithStackSize(fn, name, stacksize, data) SDL_CreateThreadWithStackSize_REAL(fn, name, stacksize, data, (pfnSDL_CurrentBeginThread)SDL_beginthread, (pfnSDL_CurrentEndThread)SDL_endthread)
-#else
-#define SDL_CreateThread(fn, name, data) SDL_CreateThread(fn, name, data, (pfnSDL_CurrentBeginThread)SDL_beginthread, (pfnSDL_CurrentEndThread)SDL_endthread)
-#define SDL_CreateThreadWithStackSize(fn, name, stacksize, data) SDL_CreateThreadWithStackSize(fn, name, data, (pfnSDL_CurrentBeginThread)_beginthreadex, (pfnSDL_CurrentEndThread)SDL_endthread)
-#endif
-
-#elif defined(__OS2__)
-/*
- * just like the windows case above:  We compile SDL2
- * into a dll with Watcom's runtime statically linked.
- */
-#define SDL_PASSED_BEGINTHREAD_ENDTHREAD
-
-typedef int (*pfnSDL_CurrentBeginThread)(void (*func)(void *), void *, unsigned, void * /*arg*/);
-typedef void (*pfnSDL_CurrentEndThread)(void);
-
-#ifndef SDL_beginthread
-#define SDL_beginthread _beginthread
-#endif
-#ifndef SDL_endthread
-#define SDL_endthread _endthread
-#endif
-
-extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data,
-                 pfnSDL_CurrentBeginThread pfnBeginThread,
-                 pfnSDL_CurrentEndThread pfnEndThread);
-extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn, const char *name, const size_t stacksize, void *data,
-                 pfnSDL_CurrentBeginThread pfnBeginThread,
-                 pfnSDL_CurrentEndThread pfnEndThread);
-
-#if defined(SDL_CreateThread) && SDL_DYNAMIC_API
-#undef SDL_CreateThread
-#define SDL_CreateThread(fn, name, data) SDL_CreateThread_REAL(fn, name, data, (pfnSDL_CurrentBeginThread)SDL_beginthread, (pfnSDL_CurrentEndThread)SDL_endthread)
-#undef SDL_CreateThreadWithStackSize
-#define SDL_CreateThreadWithStackSize(fn, name, stacksize, data) SDL_CreateThreadWithStackSize_REAL(fn, name, data, (pfnSDL_CurrentBeginThread)SDL_beginthread, (pfnSDL_CurrentEndThread)SDL_endthread)
-#else
-#define SDL_CreateThread(fn, name, data) SDL_CreateThread(fn, name, data, (pfnSDL_CurrentBeginThread)SDL_beginthread, (pfnSDL_CurrentEndThread)SDL_endthread)
-#define SDL_CreateThreadWithStackSize(fn, name, stacksize, data) SDL_CreateThreadWithStackSize(fn, name, stacksize, data, (pfnSDL_CurrentBeginThread)SDL_beginthread, (pfnSDL_CurrentEndThread)SDL_endthread)
-#endif
-
-#else
-
-/**
- * Create a new thread with a default stack size.
- *
- * This is equivalent to calling:
- *
- * ```c
- * SDL_CreateThreadWithStackSize(fn, name, 0, data);
- * ```
- *
- * \param fn the SDL_ThreadFunction function to call in the new thread
- * \param name the name of the thread
- * \param data a pointer that is passed to `fn`
- * \returns an opaque pointer to the new thread object on success, NULL if the
- *          new thread could not be created; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateThreadWithStackSize
- * \sa SDL_WaitThread
- */
-extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data);
-
-/**
- * Create a new thread with a specific stack size.
- *
- * SDL makes an attempt to report `name` to the system, so that debuggers can
- * display it. Not all platforms support this.
- *
- * Thread naming is a little complicated: Most systems have very small limits
- * for the string length (Haiku has 32 bytes, Linux currently has 16, Visual
- * C++ 6.0 has _nine_!), and possibly other arbitrary rules. You'll have to
- * see what happens with your system's debugger. The name should be UTF-8 (but
- * using the naming limits of C identifiers is a better bet). There are no
- * requirements for thread naming conventions, so long as the string is
- * null-terminated UTF-8, but these guidelines are helpful in choosing a name:
- *
- * https://stackoverflow.com/questions/149932/naming-conventions-for-threads
- *
- * If a system imposes requirements, SDL will try to munge the string for it
- * (truncate, etc), but the original string contents will be available from
- * SDL_GetThreadName().
- *
- * The size (in bytes) of the new stack can be specified. Zero means "use the
- * system default" which might be wildly different between platforms. x86
- * Linux generally defaults to eight megabytes, an embedded device might be a
- * few kilobytes instead. You generally need to specify a stack that is a
- * multiple of the system's page size (in many cases, this is 4 kilobytes, but
- * check your system documentation).
- *
- * In SDL 2.1, stack size will be folded into the original SDL_CreateThread
- * function, but for backwards compatibility, this is currently a separate
- * function.
- *
- * \param fn the SDL_ThreadFunction function to call in the new thread
- * \param name the name of the thread
- * \param stacksize the size, in bytes, to allocate for the new thread stack.
- * \param data a pointer that is passed to `fn`
- * \returns an opaque pointer to the new thread object on success, NULL if the
- *          new thread could not be created; call SDL_GetError() for more
- *          information.
- *
- * \since This function is available since SDL 2.0.9.
- *
- * \sa SDL_WaitThread
- */
-extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn, const char *name, const size_t stacksize, void *data);
-
-#endif
-
-/**
- * Get the thread name as it was specified in SDL_CreateThread().
- *
- * This is internal memory, not to be freed by the caller, and remains valid
- * until the specified thread is cleaned up by SDL_WaitThread().
- *
- * \param thread the thread to query
- * \returns a pointer to a UTF-8 string that names the specified thread, or
- *          NULL if it doesn't have a name.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateThread
- */
-extern DECLSPEC const char *SDLCALL SDL_GetThreadName(SDL_Thread *thread);
-
-/**
- * Get the thread identifier for the current thread.
- *
- * This thread identifier is as reported by the underlying operating system.
- * If SDL is running on a platform that does not support threads the return
- * value will always be zero.
- *
- * This function also returns a valid thread ID when called from the main
- * thread.
- *
- * \returns the ID of the current thread.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetThreadID
- */
-extern DECLSPEC SDL_threadID SDLCALL SDL_ThreadID(void);
-
-/**
- * Get the thread identifier for the specified thread.
- *
- * This thread identifier is as reported by the underlying operating system.
- * If SDL is running on a platform that does not support threads the return
- * value will always be zero.
- *
- * \param thread the thread to query
- * \returns the ID of the specified thread, or the ID of the current thread if
- *          `thread` is NULL.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_ThreadID
- */
-extern DECLSPEC SDL_threadID SDLCALL SDL_GetThreadID(SDL_Thread * thread);
-
-/**
- * Set the priority for the current thread.
- *
- * Note that some platforms will not let you alter the priority (or at least,
- * promote the thread to a higher priority) at all, and some require you to be
- * an administrator account. Be prepared for this to fail.
- *
- * \param priority the SDL_ThreadPriority to set
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- */
-extern DECLSPEC int SDLCALL SDL_SetThreadPriority(SDL_ThreadPriority priority);
-
-/**
- * Wait for a thread to finish.
- *
- * Threads that haven't been detached will remain (as a "zombie") until this
- * function cleans them up. Not doing so is a resource leak.
- *
- * Once a thread has been cleaned up through this function, the SDL_Thread
- * that references it becomes invalid and should not be referenced again. As
- * such, only one thread may call SDL_WaitThread() on another.
- *
- * The return code for the thread function is placed in the area pointed to by
- * `status`, if `status` is not NULL.
- *
- * You may not wait on a thread that has been used in a call to
- * SDL_DetachThread(). Use either that function or this one, but not both, or
- * behavior is undefined.
- *
- * It is safe to pass a NULL thread to this function; it is a no-op.
- *
- * Note that the thread pointer is freed by this function and is not valid
- * afterward.
- *
- * \param thread the SDL_Thread pointer that was returned from the
- *               SDL_CreateThread() call that started this thread
- * \param status pointer to an integer that will receive the value returned
- *               from the thread function by its 'return', or NULL to not
- *               receive such value back.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_CreateThread
- * \sa SDL_DetachThread
- */
-extern DECLSPEC void SDLCALL SDL_WaitThread(SDL_Thread * thread, int *status);
-
-/**
- * Let a thread clean up on exit without intervention.
- *
- * A thread may be "detached" to signify that it should not remain until
- * another thread has called SDL_WaitThread() on it. Detaching a thread is
- * useful for long-running threads that nothing needs to synchronize with or
- * further manage. When a detached thread is done, it simply goes away.
- *
- * There is no way to recover the return code of a detached thread. If you
- * need this, don't detach the thread and instead use SDL_WaitThread().
- *
- * Once a thread is detached, you should usually assume the SDL_Thread isn't
- * safe to reference again, as it will become invalid immediately upon the
- * detached thread's exit, instead of remaining until someone has called
- * SDL_WaitThread() to finally clean it up. As such, don't detach the same
- * thread more than once.
- *
- * If a thread has already exited when passed to SDL_DetachThread(), it will
- * stop waiting for a call to SDL_WaitThread() and clean up immediately. It is
- * not safe to detach a thread that might be used with SDL_WaitThread().
- *
- * You may not call SDL_WaitThread() on a thread that has been detached. Use
- * either that function or this one, but not both, or behavior is undefined.
- *
- * It is safe to pass NULL to this function; it is a no-op.
- *
- * \param thread the SDL_Thread pointer that was returned from the
- *               SDL_CreateThread() call that started this thread
- *
- * \since This function is available since SDL 2.0.2.
- *
- * \sa SDL_CreateThread
- * \sa SDL_WaitThread
- */
-extern DECLSPEC void SDLCALL SDL_DetachThread(SDL_Thread * thread);
-
-/**
- * Create a piece of thread-local storage.
- *
- * This creates an identifier that is globally visible to all threads but
- * refers to data that is thread-specific.
- *
- * \returns the newly created thread local storage identifier or 0 on error.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_TLSGet
- * \sa SDL_TLSSet
- */
-extern DECLSPEC SDL_TLSID SDLCALL SDL_TLSCreate(void);
-
-/**
- * Get the current thread's value associated with a thread local storage ID.
- *
- * \param id the thread local storage ID
- * \returns the value associated with the ID for the current thread or NULL if
- *          no value has been set; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_TLSCreate
- * \sa SDL_TLSSet
- */
-extern DECLSPEC void * SDLCALL SDL_TLSGet(SDL_TLSID id);
-
-/**
- * Set the current thread's value associated with a thread local storage ID.
- *
- * The function prototype for `destructor` is:
- *
- * ```c
- * void destructor(void *value)
- * ```
- *
- * where its parameter `value` is what was passed as `value` to SDL_TLSSet().
- *
- * \param id the thread local storage ID
- * \param value the value to associate with the ID for the current thread
- * \param destructor a function called when the thread exits, to free the
- *                   value
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_TLSCreate
- * \sa SDL_TLSGet
- */
-extern DECLSPEC int SDLCALL SDL_TLSSet(SDL_TLSID id, const void *value, void (SDLCALL *destructor)(void*));
-
-/**
- * Cleanup all TLS data for this thread.
- *
- * \since This function is available since SDL 2.0.16.
- */
-extern DECLSPEC void SDLCALL SDL_TLSCleanup(void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_thread_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,150 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_touch.h
- *
- *  Include file for SDL touch event handling.
- */
-
-#ifndef SDL_touch_h_
-#define SDL_touch_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef Sint64 SDL_TouchID;
-typedef Sint64 SDL_FingerID;
-
-typedef enum
-{
-    SDL_TOUCH_DEVICE_INVALID = -1,
-    SDL_TOUCH_DEVICE_DIRECT,            /* touch screen with window-relative coordinates */
-    SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE, /* trackpad with absolute device coordinates */
-    SDL_TOUCH_DEVICE_INDIRECT_RELATIVE  /* trackpad with screen cursor-relative coordinates */
-} SDL_TouchDeviceType;
-
-typedef struct SDL_Finger
-{
-    SDL_FingerID id;
-    float x;
-    float y;
-    float pressure;
-} SDL_Finger;
-
-/* Used as the device ID for mouse events simulated with touch input */
-#define SDL_TOUCH_MOUSEID ((Uint32)-1)
-
-/* Used as the SDL_TouchID for touch events simulated with mouse input */
-#define SDL_MOUSE_TOUCHID ((Sint64)-1)
-
-
-/**
- * Get the number of registered touch devices.
- *
- * On some platforms SDL first sees the touch device if it was actually used.
- * Therefore SDL_GetNumTouchDevices() may return 0 although devices are
- * available. After using all devices at least once the number will be
- * correct.
- *
- * This was fixed for Android in SDL 2.0.1.
- *
- * \returns the number of registered touch devices.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetTouchDevice
- */
-extern DECLSPEC int SDLCALL SDL_GetNumTouchDevices(void);
-
-/**
- * Get the touch ID with the given index.
- *
- * \param index the touch device index
- * \returns the touch ID with the given index on success or 0 if the index is
- *          invalid; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetNumTouchDevices
- */
-extern DECLSPEC SDL_TouchID SDLCALL SDL_GetTouchDevice(int index);
-
-/**
- * Get the touch device name as reported from the driver or NULL if the index
- * is invalid.
- *
- * \since This function is available since SDL 2.0.22.
- */
-extern DECLSPEC const char* SDLCALL SDL_GetTouchName(int index);
-
-/**
- * Get the type of the given touch device.
- *
- * \since This function is available since SDL 2.0.10.
- */
-extern DECLSPEC SDL_TouchDeviceType SDLCALL SDL_GetTouchDeviceType(SDL_TouchID touchID);
-
-/**
- * Get the number of active fingers for a given touch device.
- *
- * \param touchID the ID of a touch device
- * \returns the number of active fingers for a given touch device on success
- *          or 0 on failure; call SDL_GetError() for more information.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetTouchFinger
- */
-extern DECLSPEC int SDLCALL SDL_GetNumTouchFingers(SDL_TouchID touchID);
-
-/**
- * Get the finger object for specified touch device ID and finger index.
- *
- * The returned resource is owned by SDL and should not be deallocated.
- *
- * \param touchID the ID of the requested touch device
- * \param index the index of the requested finger
- * \returns a pointer to the SDL_Finger object or NULL if no object at the
- *          given ID and index could be found.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_RecordGesture
- */
-extern DECLSPEC SDL_Finger * SDLCALL SDL_GetTouchFinger(SDL_TouchID touchID, int index);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_touch_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,29 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_types.h
- *
- *  \deprecated
- */
-
-/* DEPRECATED */
-#include "SDL_stdinc.h"
@@ -1,188 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_version.h
- *
- *  This header defines the current SDL version.
- */
-
-#ifndef SDL_version_h_
-#define SDL_version_h_
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Information about the version of SDL in use.
- *
- * Represents the library's version as three levels: major revision
- * (increments with massive changes, additions, and enhancements),
- * minor revision (increments with backwards-compatible changes to the
- * major revision), and patchlevel (increments with fixes to the minor
- * revision).
- *
- * \sa SDL_VERSION
- * \sa SDL_GetVersion
- */
-typedef struct SDL_version
-{
-    Uint8 major;        /**< major version */
-    Uint8 minor;        /**< minor version */
-    Uint8 patch;        /**< update version */
-} SDL_version;
-
-/* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
-*/
-#define SDL_MAJOR_VERSION   2
-#define SDL_MINOR_VERSION   0
-#define SDL_PATCHLEVEL      22
-
-/**
- * Macro to determine SDL version program was compiled against.
- *
- * This macro fills in a SDL_version structure with the version of the
- * library you compiled against. This is determined by what header the
- * compiler uses. Note that if you dynamically linked the library, you might
- * have a slightly newer or older version at runtime. That version can be
- * determined with SDL_GetVersion(), which, unlike SDL_VERSION(),
- * is not a macro.
- *
- * \param x A pointer to a SDL_version struct to initialize.
- *
- * \sa SDL_version
- * \sa SDL_GetVersion
- */
-#define SDL_VERSION(x)                          \
-{                                   \
-    (x)->major = SDL_MAJOR_VERSION;                 \
-    (x)->minor = SDL_MINOR_VERSION;                 \
-    (x)->patch = SDL_PATCHLEVEL;                    \
-}
-
-/**
- *  This macro turns the version numbers into a numeric value:
- *  \verbatim
-    (1,2,3) -> (1203)
-    \endverbatim
- *
- *  This assumes that there will never be more than 100 patchlevels.
- */
-#define SDL_VERSIONNUM(X, Y, Z)                     \
-    ((X)*1000 + (Y)*100 + (Z))
-
-/**
- *  This is the version number macro for the current SDL version.
- */
-#define SDL_COMPILEDVERSION \
-    SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL)
-
-/**
- *  This macro will evaluate to true if compiled with SDL at least X.Y.Z.
- */
-#define SDL_VERSION_ATLEAST(X, Y, Z) \
-    (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
-
-/**
- * Get the version of SDL that is linked against your program.
- *
- * If you are linking to SDL dynamically, then it is possible that the current
- * version will be different than the version you compiled against. This
- * function returns the current version, while SDL_VERSION() is a macro that
- * tells you what version you compiled with.
- *
- * This function may be called safely at any time, even before SDL_Init().
- *
- * \param ver the SDL_version structure that contains the version information
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetRevision
- */
-extern DECLSPEC void SDLCALL SDL_GetVersion(SDL_version * ver);
-
-/**
- * Get the code revision of SDL that is linked against your program.
- *
- * This value is the revision of the code you are linked with and may be
- * different from the code you are compiling with, which is found in the
- * constant SDL_REVISION.
- *
- * The revision is arbitrary string (a hash value) uniquely identifying the
- * exact revision of the SDL library in use, and is only useful in comparing
- * against other revisions. It is NOT an incrementing number.
- *
- * If SDL wasn't built from a git repository with the appropriate tools, this
- * will return an empty string.
- *
- * Prior to SDL 2.0.16, before development moved to GitHub, this returned a
- * hash for a Mercurial repository.
- *
- * You shouldn't use this function for anything but logging it for debugging
- * purposes. The string is not intended to be reliable in any way.
- *
- * \returns an arbitrary string, uniquely identifying the exact revision of
- *          the SDL library in use.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetVersion
- */
-extern DECLSPEC const char *SDLCALL SDL_GetRevision(void);
-
-/**
- * Obsolete function, do not use.
- *
- * When SDL was hosted in a Mercurial repository, and was built carefully,
- * this would return the revision number that the build was created from. This
- * number was not reliable for several reasons, but more importantly, SDL is
- * now hosted in a git repository, which does not offer numbers at all, only
- * hashes. This function only ever returns zero now. Don't use it.
- *
- * Before SDL 2.0.16, this might have returned an unreliable, but non-zero
- * number.
- *
- * \deprecated Use SDL_GetRevision() instead; if SDL was carefully built, it
- *             will return a git hash.
- *
- * \returns zero, always, in modern SDL releases.
- *
- * \since This function is available since SDL 2.0.0.
- *
- * \sa SDL_GetRevision
- */
-extern SDL_DEPRECATED DECLSPEC int SDLCALL SDL_GetRevisionNumber(void);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* SDL_version_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,187 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file begin_code.h
- *
- *  This file sets things up for C dynamic library function definitions,
- *  static inlined functions, and structures aligned at 4-byte alignment.
- *  If you don't like ugly C preprocessor code, don't look at this file. :)
- */
-
-/* This shouldn't be nested -- included it around code only. */
-#ifdef _begin_code_h
-#error Nested inclusion of begin_code.h
-#endif
-#define _begin_code_h
-
-#ifndef SDL_DEPRECATED
-#  if (__GNUC__ >= 4)  /* technically, this arrived in gcc 3.1, but oh well. */
-#    define SDL_DEPRECATED __attribute__((deprecated))
-#  else
-#    define SDL_DEPRECATED
-#  endif
-#endif
-
-#ifndef SDL_UNUSED
-#  ifdef __GNUC__
-#    define SDL_UNUSED __attribute__((unused))
-#  else
-#    define SDL_UNUSED
-#  endif
-#endif
-
-/* Some compilers use a special export keyword */
-#ifndef DECLSPEC
-# if defined(__WIN32__) || defined(__WINRT__) || defined(__CYGWIN__)
-#  ifdef DLL_EXPORT
-#   define DECLSPEC __declspec(dllexport)
-#  else
-#   define DECLSPEC
-#  endif
-# elif defined(__OS2__)
-#   ifdef BUILD_SDL
-#    define DECLSPEC    __declspec(dllexport)
-#   else
-#    define DECLSPEC
-#   endif
-# else
-#  if defined(__GNUC__) && __GNUC__ >= 4
-#   define DECLSPEC __attribute__ ((visibility("default")))
-#  else
-#   define DECLSPEC
-#  endif
-# endif
-#endif
-
-/* By default SDL uses the C calling convention */
-#ifndef SDLCALL
-#if (defined(__WIN32__) || defined(__WINRT__)) && !defined(__GNUC__)
-#define SDLCALL __cdecl
-#elif defined(__OS2__) || defined(__EMX__)
-#define SDLCALL _System
-# if defined (__GNUC__) && !defined(_System)
-#  define _System /* for old EMX/GCC compat.  */
-# endif
-#else
-#define SDLCALL
-#endif
-#endif /* SDLCALL */
-
-/* Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC */
-#ifdef __SYMBIAN32__
-#undef DECLSPEC
-#define DECLSPEC
-#endif /* __SYMBIAN32__ */
-
-/* Force structure packing at 4 byte alignment.
-   This is necessary if the header is included in code which has structure
-   packing set to an alternate value, say for loading structures from disk.
-   The packing is reset to the previous value in close_code.h
- */
-#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__BORLANDC__)
-#ifdef _MSC_VER
-#pragma warning(disable: 4103)
-#endif
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wpragma-pack"
-#endif
-#ifdef __BORLANDC__
-#pragma nopackwarning
-#endif
-#ifdef _WIN64
-/* Use 8-byte alignment on 64-bit architectures, so pointers are aligned */
-#pragma pack(push,8)
-#else
-#pragma pack(push,4)
-#endif
-#endif /* Compiler needs structure packing set */
-
-#ifndef SDL_INLINE
-#if defined(__GNUC__)
-#define SDL_INLINE __inline__
-#elif defined(_MSC_VER) || defined(__BORLANDC__) || \
-      defined(__DMC__) || defined(__SC__) || \
-      defined(__WATCOMC__) || defined(__LCC__) || \
-      defined(__DECC) || defined(__CC_ARM)
-#define SDL_INLINE __inline
-#ifndef __inline__
-#define __inline__ __inline
-#endif
-#else
-#define SDL_INLINE inline
-#ifndef __inline__
-#define __inline__ inline
-#endif
-#endif
-#endif /* SDL_INLINE not defined */
-
-#ifndef SDL_FORCE_INLINE
-#if defined(_MSC_VER)
-#define SDL_FORCE_INLINE __forceinline
-#elif ( (defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__) )
-#define SDL_FORCE_INLINE __attribute__((always_inline)) static __inline__
-#else
-#define SDL_FORCE_INLINE static SDL_INLINE
-#endif
-#endif /* SDL_FORCE_INLINE not defined */
-
-#ifndef SDL_NORETURN
-#if defined(__GNUC__)
-#define SDL_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define SDL_NORETURN __declspec(noreturn)
-#else
-#define SDL_NORETURN
-#endif
-#endif /* SDL_NORETURN not defined */
-
-/* Apparently this is needed by several Windows compilers */
-#if !defined(__MACH__)
-#ifndef NULL
-#ifdef __cplusplus
-#define NULL 0
-#else
-#define NULL ((void *)0)
-#endif
-#endif /* NULL */
-#endif /* ! Mac OS X - breaks precompiled headers */
-
-#ifndef SDL_FALLTHROUGH
-#if (defined(__cplusplus) && __cplusplus >= 201703L) || \
-    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L)
-#define SDL_FALLTHROUGH [[fallthrough]]
-#else
-#if defined(__has_attribute)
-#define _HAS_FALLTHROUGH __has_attribute(__fallthrough__)
-#else
-#define _HAS_FALLTHROUGH 0
-#endif /* __has_attribute */
-#if _HAS_FALLTHROUGH && \
-   ((defined(__GNUC__) && __GNUC__ >= 7) || \
-    (defined(__clang_major__) && __clang_major__ >= 10))
-#define SDL_FALLTHROUGH __attribute__((__fallthrough__))
-#else
-#define SDL_FALLTHROUGH do {} while (0) /* fallthrough */
-#endif /* _HAS_FALLTHROUGH */
-#undef _HAS_FALLTHROUGH
-#endif /* C++17 or C2x */
-#endif /* SDL_FALLTHROUGH not defined */
@@ -1,40 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file close_code.h
- *
- *  This file reverses the effects of begin_code.h and should be included
- *  after you finish any function and structure declarations in your headers
- */
-
-#ifndef _begin_code_h
-#error close_code.h included without matching begin_code.h
-#endif
-#undef _begin_code_h
-
-/* Reset structure packing at previous byte alignment */
-#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__BORLANDC__)
-#ifdef __BORLANDC__
-#pragma nopackwarning
-#endif
-#pragma pack(pop)
-#endif /* Compiler needs structure packing set */
@@ -1,163 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL.h
- *
- *  Main include header for the SDL library
- */
-
-/**
- *  \mainpage Simple DirectMedia Layer (SDL)
- *
- *  http://www.libsdl.org/
- *
- *  \section intro_sec Introduction
- *
- *  Simple DirectMedia Layer is a cross-platform development library designed
- *  to provide low level access to audio, keyboard, mouse, joystick, and
- *  graphics hardware via OpenGL and Direct3D. It is used by video playback
- *  software, emulators, and popular games including Valve's award winning
- *  catalog and many Humble Bundle games.
- *
- *  SDL officially supports Windows, Mac OS X, Linux, iOS, and Android.
- *  Support for other platforms may be found in the source code.
- *
- *  SDL is written in C, works natively with C++, and there are bindings 
- *  available for several other languages, including C# and Python.
- *
- *  This library is distributed under the zlib license, which can be found
- *  in the file "COPYING.txt".
- *
- *  The best way to learn how to use SDL is to check out the header files in
- *  the "include" subdirectory and the programs in the "test" subdirectory.
- *  The header files and test programs are well commented and always up to date.
- *  More documentation and FAQs are available online at:
- *      http://wiki.libsdl.org/
- *
- *  If you need help with the library, or just want to discuss SDL related
- *  issues, you can join the developers mailing list:
- *      http://www.libsdl.org/mailing-list.php
- *
- *  Enjoy!
- *      Sam Lantinga                (slouken@libsdl.org)
- */
-
-#ifndef _SDL_H
-#define _SDL_H
-
-#include "SDL_main.h"
-#include "SDL_stdinc.h"
-#include "SDL_assert.h"
-#include "SDL_atomic.h"
-#include "SDL_audio.h"
-#include "SDL_clipboard.h"
-#include "SDL_cpuinfo.h"
-#include "SDL_endian.h"
-#include "SDL_error.h"
-#include "SDL_events.h"
-#include "SDL_filesystem.h"
-#include "SDL_joystick.h"
-#include "SDL_gamecontroller.h"
-#include "SDL_haptic.h"
-#include "SDL_hints.h"
-#include "SDL_loadso.h"
-#include "SDL_log.h"
-#include "SDL_messagebox.h"
-#include "SDL_mutex.h"
-#include "SDL_power.h"
-#include "SDL_render.h"
-#include "SDL_rwops.h"
-#include "SDL_system.h"
-#include "SDL_thread.h"
-#include "SDL_timer.h"
-#include "SDL_version.h"
-#include "SDL_video.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* As of version 0.5, SDL is loaded dynamically into the application */
-
-/**
- *  \name SDL_INIT_*
- *
- *  These are the flags which may be passed to SDL_Init().  You should
- *  specify the subsystems which you will be using in your application.
- */
-/* @{ */
-#define SDL_INIT_TIMER          0x00000001
-#define SDL_INIT_AUDIO          0x00000010
-#define SDL_INIT_VIDEO          0x00000020  /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
-#define SDL_INIT_JOYSTICK       0x00000200  /**< SDL_INIT_JOYSTICK implies SDL_INIT_EVENTS */
-#define SDL_INIT_HAPTIC         0x00001000
-#define SDL_INIT_GAMECONTROLLER 0x00002000  /**< SDL_INIT_GAMECONTROLLER implies SDL_INIT_JOYSTICK */
-#define SDL_INIT_EVENTS         0x00004000
-#define SDL_INIT_NOPARACHUTE    0x00100000  /**< Don't catch fatal signals */
-#define SDL_INIT_EVERYTHING ( \
-                SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO | SDL_INIT_EVENTS | \
-                SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER \
-            )
-/* @} */
-
-/**
- *  This function initializes  the subsystems specified by \c flags
- *  Unless the ::SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
- *  signal handlers for some commonly ignored fatal signals (like SIGSEGV).
- */
-extern DECLSPEC int SDLCALL SDL_Init(Uint32 flags);
-
-/**
- *  This function initializes specific SDL subsystems
- */
-extern DECLSPEC int SDLCALL SDL_InitSubSystem(Uint32 flags);
-
-/**
- *  This function cleans up specific SDL subsystems
- */
-extern DECLSPEC void SDLCALL SDL_QuitSubSystem(Uint32 flags);
-
-/**
- *  This function returns a mask of the specified subsystems which have
- *  previously been initialized.
- *
- *  If \c flags is 0, it returns a mask of all initialized subsystems.
- */
-extern DECLSPEC Uint32 SDLCALL SDL_WasInit(Uint32 flags);
-
-/**
- *  This function cleans up all initialized subsystems. You should
- *  call it upon all exit conditions.
- */
-extern DECLSPEC void SDLCALL SDL_Quit(void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* _SDL_H */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,246 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef _SDL_assert_h
-#define _SDL_assert_h
-
-#include "SDL_config.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef SDL_ASSERT_LEVEL
-#ifdef SDL_DEFAULT_ASSERT_LEVEL
-#define SDL_ASSERT_LEVEL SDL_DEFAULT_ASSERT_LEVEL
-#elif defined(_DEBUG) || defined(DEBUG) || \
-      (defined(__GNUC__) && !defined(__OPTIMIZE__))
-#define SDL_ASSERT_LEVEL 2
-#else
-#define SDL_ASSERT_LEVEL 1
-#endif
-#endif /* SDL_ASSERT_LEVEL */
-
-/*
-These are macros and not first class functions so that the debugger breaks
-on the assertion line and not in some random guts of SDL, and so each
-assert can have unique static variables associated with it.
-*/
-
-#if defined(_MSC_VER)
-/* Don't include intrin.h here because it contains C++ code */
-    extern void __cdecl __debugbreak(void);
-    #define SDL_TriggerBreakpoint() __debugbreak()
-#elif (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)))
-    #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" )
-#elif defined(HAVE_SIGNAL_H)
-    #include <signal.h>
-    #define SDL_TriggerBreakpoint() raise(SIGTRAP)
-#else
-    /* How do we trigger breakpoints on this platform? */
-    #define SDL_TriggerBreakpoint()
-#endif
-
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 supports __func__ as a standard. */
-#   define SDL_FUNCTION __func__
-#elif ((__GNUC__ >= 2) || defined(_MSC_VER))
-#   define SDL_FUNCTION __FUNCTION__
-#else
-#   define SDL_FUNCTION "???"
-#endif
-#define SDL_FILE    __FILE__
-#define SDL_LINE    __LINE__
-
-/*
-sizeof (x) makes the compiler still parse the expression even without
-assertions enabled, so the code is always checked at compile time, but
-doesn't actually generate code for it, so there are no side effects or
-expensive checks at run time, just the constant size of what x WOULD be,
-which presumably gets optimized out as unused.
-This also solves the problem of...
-
-    int somevalue = blah();
-    SDL_assert(somevalue == 1);
-
-...which would cause compiles to complain that somevalue is unused if we
-disable assertions.
-*/
-
-#ifdef _MSC_VER  /* stupid /W4 warnings. */
-#define SDL_NULL_WHILE_LOOP_CONDITION (-1 == __LINE__)
-#else
-#define SDL_NULL_WHILE_LOOP_CONDITION (0)
-#endif
-
-#define SDL_disabled_assert(condition) \
-    do { (void) sizeof ((condition)); } while (SDL_NULL_WHILE_LOOP_CONDITION)
-
-typedef enum
-{
-    SDL_ASSERTION_RETRY,  /**< Retry the assert immediately. */
-    SDL_ASSERTION_BREAK,  /**< Make the debugger trigger a breakpoint. */
-    SDL_ASSERTION_ABORT,  /**< Terminate the program. */
-    SDL_ASSERTION_IGNORE,  /**< Ignore the assert. */
-    SDL_ASSERTION_ALWAYS_IGNORE  /**< Ignore the assert from now on. */
-} SDL_assert_state;
-
-typedef struct SDL_assert_data
-{
-    int always_ignore;
-    unsigned int trigger_count;
-    const char *condition;
-    const char *filename;
-    int linenum;
-    const char *function;
-    const struct SDL_assert_data *next;
-} SDL_assert_data;
-
-#if (SDL_ASSERT_LEVEL > 0)
-
-/* Never call this directly. Use the SDL_assert* macros. */
-extern DECLSPEC SDL_assert_state SDLCALL SDL_ReportAssertion(SDL_assert_data *,
-                                                             const char *,
-                                                             const char *, int);
-
-/* the do {} while(0) avoids dangling else problems:
-    if (x) SDL_assert(y); else blah();
-       ... without the do/while, the "else" could attach to this macro's "if".
-   We try to handle just the minimum we need here in a macro...the loop,
-   the static vars, and break points. The heavy lifting is handled in
-   SDL_ReportAssertion(), in SDL_assert.c.
-*/
-#define SDL_enabled_assert(condition) \
-    do { \
-        while ( !(condition) ) { \
-            static struct SDL_assert_data assert_data = { \
-                0, 0, #condition, 0, 0, 0, 0 \
-            }; \
-            const SDL_assert_state state = SDL_ReportAssertion(&assert_data, \
-                                                               SDL_FUNCTION, \
-                                                               SDL_FILE, \
-                                                               SDL_LINE); \
-            if (state == SDL_ASSERTION_RETRY) { \
-                continue; /* go again. */ \
-            } else if (state == SDL_ASSERTION_BREAK) { \
-                SDL_TriggerBreakpoint(); \
-            } \
-            break; /* not retrying. */ \
-        } \
-    } while (SDL_NULL_WHILE_LOOP_CONDITION)
-
-#endif  /* enabled assertions support code */
-
-/* Enable various levels of assertions. */
-#if SDL_ASSERT_LEVEL == 0   /* assertions disabled */
-#   define SDL_assert(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 1  /* release settings. */
-#   define SDL_assert(condition) SDL_disabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 2  /* normal settings. */
-#   define SDL_assert(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_disabled_assert(condition)
-#elif SDL_ASSERT_LEVEL == 3  /* paranoid settings. */
-#   define SDL_assert(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_release(condition) SDL_enabled_assert(condition)
-#   define SDL_assert_paranoid(condition) SDL_enabled_assert(condition)
-#else
-#   error Unknown assertion level.
-#endif
-
-/* this assertion is never disabled at any level. */
-#define SDL_assert_always(condition) SDL_enabled_assert(condition)
-
-
-typedef SDL_assert_state (SDLCALL *SDL_AssertionHandler)(
-                                 const SDL_assert_data* data, void* userdata);
-
-/**
- *  \brief Set an application-defined assertion handler.
- *
- *  This allows an app to show its own assertion UI and/or force the
- *  response to an assertion failure. If the app doesn't provide this, SDL
- *  will try to do the right thing, popping up a system-specific GUI dialog,
- *  and probably minimizing any fullscreen windows.
- *
- *  This callback may fire from any thread, but it runs wrapped in a mutex, so
- *  it will only fire from one thread at a time.
- *
- *  Setting the callback to NULL restores SDL's original internal handler.
- *
- *  This callback is NOT reset to SDL's internal handler upon SDL_Quit()!
- *
- *  \return SDL_assert_state value of how to handle the assertion failure.
- *
- *  \param handler Callback function, called when an assertion fails.
- *  \param userdata A pointer passed to the callback as-is.
- */
-extern DECLSPEC void SDLCALL SDL_SetAssertionHandler(
-                                            SDL_AssertionHandler handler,
-                                            void *userdata);
-
-/**
- *  \brief Get a list of all assertion failures.
- *
- *  Get all assertions triggered since last call to SDL_ResetAssertionReport(),
- *  or the start of the program.
- *
- *  The proper way to examine this data looks something like this:
- *
- *  <code>
- *  const SDL_assert_data *item = SDL_GetAssertionReport();
- *  while (item) {
- *      printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\n",
- *             item->condition, item->function, item->filename,
- *             item->linenum, item->trigger_count,
- *             item->always_ignore ? "yes" : "no");
- *      item = item->next;
- *  }
- *  </code>
- *
- *  \return List of all assertions.
- *  \sa SDL_ResetAssertionReport
- */
-extern DECLSPEC const SDL_assert_data * SDLCALL SDL_GetAssertionReport(void);
-
-/**
- *  \brief Reset the list of all assertion failures.
- *
- *  Reset list of all assertions triggered.
- *
- *  \sa SDL_GetAssertionReport
- */
-extern DECLSPEC void SDLCALL SDL_ResetAssertionReport(void);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* _SDL_assert_h */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,359 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * \file SDL_atomic.h
- *
- * Atomic operations.
- *
- * IMPORTANT:
- * If you are not an expert in concurrent lockless programming, you should
- * only be using the atomic lock and reference counting functions in this
- * file.  In all other cases you should be protecting your data structures
- * with full mutexes.
- *
- * The list of "safe" functions to use are:
- *  SDL_AtomicLock()
- *  SDL_AtomicUnlock()
- *  SDL_AtomicIncRef()
- *  SDL_AtomicDecRef()
- *
- * Seriously, here be dragons!
- * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
- *
- * You can find out a little more about lockless programming and the
- * subtle issues that can arise here:
- * http://msdn.microsoft.com/en-us/library/ee418650%28v=vs.85%29.aspx
- *
- * There's also lots of good information here:
- * http://www.1024cores.net/home/lock-free-algorithms
- * http://preshing.com/
- *
- * These operations may or may not actually be implemented using
- * processor specific atomic operations. When possible they are
- * implemented as true processor specific atomic operations. When that
- * is not possible the are implemented using locks that *do* use the
- * available atomic operations.
- *
- * All of the atomic operations that modify memory are full memory barriers.
- */
-
-#ifndef _SDL_atomic_h_
-#define _SDL_atomic_h_
-
-#include "SDL_stdinc.h"
-#include "SDL_platform.h"
-
-#include "begin_code.h"
-
-/* Need to do this here because intrin.h has C++ code in it */
-/* Visual Studio 2005 has a bug where intrin.h conflicts with winnt.h */
-#if defined(_MSC_VER) && (_MSC_VER >= 1500)
-#include <intrin.h>
-#define HAVE_MSC_ATOMICS 1
-#endif
-
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * \name SDL AtomicLock
- *
- * The atomic locks are efficient spinlocks using CPU instructions,
- * but are vulnerable to starvation and can spin forever if a thread
- * holding a lock has been terminated.  For this reason you should
- * minimize the code executed inside an atomic lock and never do
- * expensive things like API or system calls while holding them.
- *
- * The atomic locks are not safe to lock recursively.
- *
- * Porting Note:
- * The spin lock functions and type are required and can not be
- * emulated because they are used in the atomic emulation code.
- */
-/* @{ */
-
-typedef int SDL_SpinLock;
-
-/**
- * \brief Try to lock a spin lock by setting it to a non-zero value.
- *
- * \param lock Points to the lock.
- *
- * \return SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already held.
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTryLock(SDL_SpinLock *lock);
-
-/**
- * \brief Lock a spin lock by setting it to a non-zero value.
- *
- * \param lock Points to the lock.
- */
-extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock);
-
-/**
- * \brief Unlock a spin lock by setting it to 0. Always returns immediately
- *
- * \param lock Points to the lock.
- */
-extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock);
-
-/* @} *//* SDL AtomicLock */
-
-
-/**
- * The compiler barrier prevents the compiler from reordering
- * reads and writes to globally visible variables across the call.
- */
-#if defined(_MSC_VER) && (_MSC_VER > 1200)
-void _ReadWriteBarrier(void);
-#pragma intrinsic(_ReadWriteBarrier)
-#define SDL_CompilerBarrier()   _ReadWriteBarrier()
-#elif defined(__GNUC__)
-#define SDL_CompilerBarrier()   __asm__ __volatile__ ("" : : : "memory")
-#else
-#define SDL_CompilerBarrier()   \
-{ SDL_SpinLock _tmp = 0; SDL_AtomicLock(&_tmp); SDL_AtomicUnlock(&_tmp); }
-#endif
-
-/**
- * Memory barriers are designed to prevent reads and writes from being
- * reordered by the compiler and being seen out of order on multi-core CPUs.
- *
- * A typical pattern would be for thread A to write some data and a flag,
- * and for thread B to read the flag and get the data. In this case you
- * would insert a release barrier between writing the data and the flag,
- * guaranteeing that the data write completes no later than the flag is
- * written, and you would insert an acquire barrier between reading the
- * flag and reading the data, to ensure that all the reads associated
- * with the flag have completed.
- *
- * In this pattern you should always see a release barrier paired with
- * an acquire barrier and you should gate the data reads/writes with a
- * single flag variable.
- *
- * For more information on these semantics, take a look at the blog post:
- * http://preshing.com/20120913/acquire-and-release-semantics
- */
-#if defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("lwsync" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("lwsync" : : : "memory")
-#elif defined(__GNUC__) && defined(__arm__)
-#if defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("dmb ish" : : : "memory")
-#elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__)
-#ifdef __thumb__
-/* The mcr instruction isn't available in thumb mode, use real functions */
-extern DECLSPEC void SDLCALL SDL_MemoryBarrierRelease();
-extern DECLSPEC void SDLCALL SDL_MemoryBarrierAcquire();
-#else
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("mcr p15, 0, %0, c7, c10, 5" : : "r"(0) : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("mcr p15, 0, %0, c7, c10, 5" : : "r"(0) : "memory")
-#endif /* __thumb__ */
-#else
-#define SDL_MemoryBarrierRelease()   __asm__ __volatile__ ("" : : : "memory")
-#define SDL_MemoryBarrierAcquire()   __asm__ __volatile__ ("" : : : "memory")
-#endif /* __GNUC__ && __arm__ */
-#else
-/* This is correct for the x86 and x64 CPUs, and we'll expand this over time. */
-#define SDL_MemoryBarrierRelease()  SDL_CompilerBarrier()
-#define SDL_MemoryBarrierAcquire()  SDL_CompilerBarrier()
-#endif
-
-
-/* Platform specific optimized versions of the atomic functions,
- * you can disable these by defining SDL_DISABLE_ATOMIC_INLINE
- */
-#if defined(SDL_ATOMIC_DISABLED) && SDL_ATOMIC_DISABLED
-#define SDL_DISABLE_ATOMIC_INLINE
-#endif
-#ifndef SDL_DISABLE_ATOMIC_INLINE
-
-#ifdef HAVE_MSC_ATOMICS
-
-#define SDL_AtomicSet(a, v)     _InterlockedExchange((long*)&(a)->value, (v))
-#define SDL_AtomicAdd(a, v)     _InterlockedExchangeAdd((long*)&(a)->value, (v))
-#define SDL_AtomicCAS(a, oldval, newval) (_InterlockedCompareExchange((long*)&(a)->value, (newval), (oldval)) == (oldval))
-#define SDL_AtomicSetPtr(a, v)  _InterlockedExchangePointer((a), (v))
-#if _M_IX86
-#define SDL_AtomicCASPtr(a, oldval, newval) (_InterlockedCompareExchange((long*)(a), (long)(newval), (long)(oldval)) == (long)(oldval))
-#else
-#define SDL_AtomicCASPtr(a, oldval, newval) (_InterlockedCompareExchangePointer((a), (newval), (oldval)) == (oldval))
-#endif
-
-#elif defined(__MACOSX__)
-#include <libkern/OSAtomic.h>
-
-#define SDL_AtomicCAS(a, oldval, newval) OSAtomicCompareAndSwap32Barrier((oldval), (newval), &(a)->value)
-#ifdef __LP64__
-#define SDL_AtomicCASPtr(a, oldval, newval) OSAtomicCompareAndSwap64Barrier((int64_t)(oldval), (int64_t)(newval), (int64_t*)(a))
-#else
-#define SDL_AtomicCASPtr(a, oldval, newval) OSAtomicCompareAndSwap32Barrier((int32_t)(oldval), (int32_t)(newval), (int32_t*)(a))
-#endif
-
-#elif defined(HAVE_GCC_ATOMICS)
-
-#define SDL_AtomicSet(a, v)     __sync_lock_test_and_set(&(a)->value, v)
-#define SDL_AtomicAdd(a, v)     __sync_fetch_and_add(&(a)->value, v)
-#define SDL_AtomicSetPtr(a, v)  __sync_lock_test_and_set(a, v)
-#define SDL_AtomicCAS(a, oldval, newval) __sync_bool_compare_and_swap(&(a)->value, oldval, newval)
-#define SDL_AtomicCASPtr(a, oldval, newval) __sync_bool_compare_and_swap(a, oldval, newval)
-
-#endif
-
-#endif /* !SDL_DISABLE_ATOMIC_INLINE */
-
-
-/**
- * \brief A type representing an atomic integer value.  It is a struct
- *        so people don't accidentally use numeric operations on it.
- */
-#ifndef SDL_atomic_t_defined
-typedef struct { int value; } SDL_atomic_t;
-#endif
-
-/**
- * \brief Set an atomic variable to a new value if it is currently an old value.
- *
- * \return SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.
- *
- * \note If you don't know what this function is for, you shouldn't use it!
-*/
-#ifndef SDL_AtomicCAS
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval);
-#endif
-
-/**
- * \brief Set an atomic variable to a value.
- *
- * \return The previous value of the atomic variable.
- */
-#ifndef SDL_AtomicSet
-SDL_FORCE_INLINE int SDL_AtomicSet(SDL_atomic_t *a, int v)
-{
-    int value;
-    do {
-        value = a->value;
-    } while (!SDL_AtomicCAS(a, value, v));
-    return value;
-}
-#endif
-
-/**
- * \brief Get the value of an atomic variable
- */
-#ifndef SDL_AtomicGet
-SDL_FORCE_INLINE int SDL_AtomicGet(SDL_atomic_t *a)
-{
-    int value = a->value;
-    SDL_CompilerBarrier();
-    return value;
-}
-#endif
-
-/**
- * \brief Add to an atomic variable.
- *
- * \return The previous value of the atomic variable.
- *
- * \note This same style can be used for any number operation
- */
-#ifndef SDL_AtomicAdd
-SDL_FORCE_INLINE int SDL_AtomicAdd(SDL_atomic_t *a, int v)
-{
-    int value;
-    do {
-        value = a->value;
-    } while (!SDL_AtomicCAS(a, value, (value + v)));
-    return value;
-}
-#endif
-
-/**
- * \brief Increment an atomic variable used as a reference count.
- */
-#ifndef SDL_AtomicIncRef
-#define SDL_AtomicIncRef(a)    SDL_AtomicAdd(a, 1)
-#endif
-
-/**
- * \brief Decrement an atomic variable used as a reference count.
- *
- * \return SDL_TRUE if the variable reached zero after decrementing,
- *         SDL_FALSE otherwise
- */
-#ifndef SDL_AtomicDecRef
-#define SDL_AtomicDecRef(a)    (SDL_AtomicAdd(a, -1) == 1)
-#endif
-
-/**
- * \brief Set a pointer to a new value if it is currently an old value.
- *
- * \return SDL_TRUE if the pointer was set, SDL_FALSE otherwise.
- *
- * \note If you don't know what this function is for, you shouldn't use it!
-*/
-#ifndef SDL_AtomicCASPtr
-extern DECLSPEC SDL_bool SDLCALL SDL_AtomicCASPtr(void* *a, void *oldval, void *newval);
-#endif
-
-/**
- * \brief Set a pointer to a value atomically.
- *
- * \return The previous value of the pointer.
- */
-#ifndef SDL_AtomicSetPtr
-SDL_FORCE_INLINE void* SDL_AtomicSetPtr(void* *a, void* v)
-{
-    void* value;
-    do {
-        value = *a;
-    } while (!SDL_AtomicCASPtr(a, value, v));
-    return value;
-}
-#endif
-
-/**
- * \brief Get the value of a pointer atomically.
- */
-#ifndef SDL_AtomicGetPtr
-SDL_FORCE_INLINE void* SDL_AtomicGetPtr(void* *a)
-{
-    void* value = *a;
-    SDL_CompilerBarrier();
-    return value;
-}
-#endif
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-
-#include "close_code.h"
-
-#endif /* _SDL_atomic_h_ */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,506 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_audio.h
- *
- *  Access to the raw audio mixing buffer for the SDL library.
- */
-
-#ifndef _SDL_audio_h
-#define _SDL_audio_h
-
-#include "SDL_stdinc.h"
-#include "SDL_error.h"
-#include "SDL_endian.h"
-#include "SDL_mutex.h"
-#include "SDL_thread.h"
-#include "SDL_rwops.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \brief Audio format flags.
- *
- *  These are what the 16 bits in SDL_AudioFormat currently mean...
- *  (Unspecified bits are always zero).
- *
- *  \verbatim
-    ++-----------------------sample is signed if set
-    ||
-    ||       ++-----------sample is bigendian if set
-    ||       ||
-    ||       ||          ++---sample is float if set
-    ||       ||          ||
-    ||       ||          || +---sample bit size---+
-    ||       ||          || |                     |
-    15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
-    \endverbatim
- *
- *  There are macros in SDL 2.0 and later to query these bits.
- */
-typedef Uint16 SDL_AudioFormat;
-
-/**
- *  \name Audio flags
- */
-/* @{ */
-
-#define SDL_AUDIO_MASK_BITSIZE       (0xFF)
-#define SDL_AUDIO_MASK_DATATYPE      (1<<8)
-#define SDL_AUDIO_MASK_ENDIAN        (1<<12)
-#define SDL_AUDIO_MASK_SIGNED        (1<<15)
-#define SDL_AUDIO_BITSIZE(x)         (x & SDL_AUDIO_MASK_BITSIZE)
-#define SDL_AUDIO_ISFLOAT(x)         (x & SDL_AUDIO_MASK_DATATYPE)
-#define SDL_AUDIO_ISBIGENDIAN(x)     (x & SDL_AUDIO_MASK_ENDIAN)
-#define SDL_AUDIO_ISSIGNED(x)        (x & SDL_AUDIO_MASK_SIGNED)
-#define SDL_AUDIO_ISINT(x)           (!SDL_AUDIO_ISFLOAT(x))
-#define SDL_AUDIO_ISLITTLEENDIAN(x)  (!SDL_AUDIO_ISBIGENDIAN(x))
-#define SDL_AUDIO_ISUNSIGNED(x)      (!SDL_AUDIO_ISSIGNED(x))
-
-/**
- *  \name Audio format flags
- *
- *  Defaults to LSB byte order.
- */
-/* @{ */
-#define AUDIO_U8        0x0008  /**< Unsigned 8-bit samples */
-#define AUDIO_S8        0x8008  /**< Signed 8-bit samples */
-#define AUDIO_U16LSB    0x0010  /**< Unsigned 16-bit samples */
-#define AUDIO_S16LSB    0x8010  /**< Signed 16-bit samples */
-#define AUDIO_U16MSB    0x1010  /**< As above, but big-endian byte order */
-#define AUDIO_S16MSB    0x9010  /**< As above, but big-endian byte order */
-#define AUDIO_U16       AUDIO_U16LSB
-#define AUDIO_S16       AUDIO_S16LSB
-/* @} */
-
-/**
- *  \name int32 support
- */
-/* @{ */
-#define AUDIO_S32LSB    0x8020  /**< 32-bit integer samples */
-#define AUDIO_S32MSB    0x9020  /**< As above, but big-endian byte order */
-#define AUDIO_S32       AUDIO_S32LSB
-/* @} */
-
-/**
- *  \name float32 support
- */
-/* @{ */
-#define AUDIO_F32LSB    0x8120  /**< 32-bit floating point samples */
-#define AUDIO_F32MSB    0x9120  /**< As above, but big-endian byte order */
-#define AUDIO_F32       AUDIO_F32LSB
-/* @} */
-
-/**
- *  \name Native audio byte ordering
- */
-/* @{ */
-#if SDL_BYTEORDER == SDL_LIL_ENDIAN
-#define AUDIO_U16SYS    AUDIO_U16LSB
-#define AUDIO_S16SYS    AUDIO_S16LSB
-#define AUDIO_S32SYS    AUDIO_S32LSB
-#define AUDIO_F32SYS    AUDIO_F32LSB
-#else
-#define AUDIO_U16SYS    AUDIO_U16MSB
-#define AUDIO_S16SYS    AUDIO_S16MSB
-#define AUDIO_S32SYS    AUDIO_S32MSB
-#define AUDIO_F32SYS    AUDIO_F32MSB
-#endif
-/* @} */
-
-/**
- *  \name Allow change flags
- *
- *  Which audio format changes are allowed when opening a device.
- */
-/* @{ */
-#define SDL_AUDIO_ALLOW_FREQUENCY_CHANGE    0x00000001
-#define SDL_AUDIO_ALLOW_FORMAT_CHANGE       0x00000002
-#define SDL_AUDIO_ALLOW_CHANNELS_CHANGE     0x00000004
-#define SDL_AUDIO_ALLOW_ANY_CHANGE          (SDL_AUDIO_ALLOW_FREQUENCY_CHANGE|SDL_AUDIO_ALLOW_FORMAT_CHANGE|SDL_AUDIO_ALLOW_CHANNELS_CHANGE)
-/* @} */
-
-/* @} *//* Audio flags */
-
-/**
- *  This function is called when the audio device needs more data.
- *
- *  \param userdata An application-specific parameter saved in
- *                  the SDL_AudioSpec structure
- *  \param stream A pointer to the audio data buffer.
- *  \param len    The length of that buffer in bytes.
- *
- *  Once the callback returns, the buffer will no longer be valid.
- *  Stereo samples are stored in a LRLRLR ordering.
- */
-typedef void (SDLCALL * SDL_AudioCallback) (void *userdata, Uint8 * stream,
-                                            int len);
-
-/**
- *  The calculated values in this structure are calculated by SDL_OpenAudio().
- */
-typedef struct SDL_AudioSpec
-{
-    int freq;                   /**< DSP frequency -- samples per second */
-    SDL_AudioFormat format;     /**< Audio data format */
-    Uint8 channels;             /**< Number of channels: 1 mono, 2 stereo */
-    Uint8 silence;              /**< Audio buffer silence value (calculated) */
-    Uint16 samples;             /**< Audio buffer size in samples (power of 2) */
-    Uint16 padding;             /**< Necessary for some compile environments */
-    Uint32 size;                /**< Audio buffer size in bytes (calculated) */
-    SDL_AudioCallback callback;
-    void *userdata;
-} SDL_AudioSpec;
-
-
-struct SDL_AudioCVT;
-typedef void (SDLCALL * SDL_AudioFilter) (struct SDL_AudioCVT * cvt,
-                                          SDL_AudioFormat format);
-
-/**
- *  A structure to hold a set of audio conversion filters and buffers.
- */
-#ifdef __GNUC__
-/* This structure is 84 bytes on 32-bit architectures, make sure GCC doesn't
-   pad it out to 88 bytes to guarantee ABI compatibility between compilers.
-   vvv
-   The next time we rev the ABI, make sure to size the ints and add padding.
-*/
-#define SDL_AUDIOCVT_PACKED __attribute__((packed))
-#else
-#define SDL_AUDIOCVT_PACKED
-#endif
-/* */
-typedef struct SDL_AudioCVT
-{
-    int needed;                 /**< Set to 1 if conversion possible */
-    SDL_AudioFormat src_format; /**< Source audio format */
-    SDL_AudioFormat dst_format; /**< Target audio format */
-    double rate_incr;           /**< Rate conversion increment */
-    Uint8 *buf;                 /**< Buffer to hold entire audio data */
-    int len;                    /**< Length of original audio buffer */
-    int len_cvt;                /**< Length of converted audio buffer */
-    int len_mult;               /**< buffer must be len*len_mult big */
-    double len_ratio;           /**< Given len, final size is len*len_ratio */
-    SDL_AudioFilter filters[10];        /**< Filter list */
-    int filter_index;           /**< Current audio conversion function */
-} SDL_AUDIOCVT_PACKED SDL_AudioCVT;
-
-
-/* Function prototypes */
-
-/**
- *  \name Driver discovery functions
- *
- *  These functions return the list of built in audio drivers, in the
- *  order that they are normally initialized by default.
- */
-/* @{ */
-extern DECLSPEC int SDLCALL SDL_GetNumAudioDrivers(void);
-extern DECLSPEC const char *SDLCALL SDL_GetAudioDriver(int index);
-/* @} */
-
-/**
- *  \name Initialization and cleanup
- *
- *  \internal These functions are used internally, and should not be used unless
- *            you have a specific need to specify the audio driver you want to
- *            use.  You should normally use SDL_Init() or SDL_InitSubSystem().
- */
-/* @{ */
-extern DECLSPEC int SDLCALL SDL_AudioInit(const char *driver_name);
-extern DECLSPEC void SDLCALL SDL_AudioQuit(void);
-/* @} */
-
-/**
- *  This function returns the name of the current audio driver, or NULL
- *  if no driver has been initialized.
- */
-extern DECLSPEC const char *SDLCALL SDL_GetCurrentAudioDriver(void);
-
-/**
- *  This function opens the audio device with the desired parameters, and
- *  returns 0 if successful, placing the actual hardware parameters in the
- *  structure pointed to by \c obtained.  If \c obtained is NULL, the audio
- *  data passed to the callback function will be guaranteed to be in the
- *  requested format, and will be automatically converted to the hardware
- *  audio format if necessary.  This function returns -1 if it failed
- *  to open the audio device, or couldn't set up the audio thread.
- *
- *  When filling in the desired audio spec structure,
- *    - \c desired->freq should be the desired audio frequency in samples-per-
- *      second.
- *    - \c desired->format should be the desired audio format.
- *    - \c desired->samples is the desired size of the audio buffer, in
- *      samples.  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 the
- *      application and CPU speed.  Smaller values yield faster response time,
- *      but can lead to underflow if the application is doing heavy processing
- *      and cannot fill the audio buffer in time.  A stereo sample consists of
- *      both right and left channels in LR ordering.
- *      Note that the number of samples is directly related to time by the
- *      following formula:  \code ms = (samples*1000)/freq \endcode
- *    - \c desired->size is the size in bytes of the audio buffer, and is
- *      calculated by SDL_OpenAudio().
- *    - \c desired->silence is the value used to set the buffer to silence,
- *      and is calculated by SDL_OpenAudio().
- *    - \c desired->callback should be set to a function that will be called
- *      when the audio device is ready for more data.  It is passed a pointer
- *      to the audio buffer, and the length in bytes of the audio buffer.
- *      This function usually runs in a separate thread, and so you should
- *      protect data structures that it accesses by calling SDL_LockAudio()
- *      and SDL_UnlockAudio() in your code.
- *    - \c desired->userdata is passed as the first parameter to your callback
- *      function.
- *
- *  The audio device starts out playing silence when it's opened, and should
- *  be enabled for playing by calling \c SDL_PauseAudio(0) when you are ready
- *  for your audio callback function to be called.  Since the audio driver
- *  may modify the requested size of the audio buffer, you should allocate
- *  any local mixing buffers after you open the audio device.
- */
-extern DECLSPEC int SDLCALL SDL_OpenAudio(SDL_AudioSpec * desired,
-                                          SDL_AudioSpec * obtained);
-
-/**
- *  SDL Audio Device IDs.
- *
- *  A successful call to SDL_OpenAudio() is always device id 1, and legacy
- *  SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls
- *  always returns devices >= 2 on success. The legacy calls are good both
- *  for backwards compatibility and when you don't care about multiple,
- *  specific, or capture devices.
- */
-typedef Uint32 SDL_AudioDeviceID;
-
-/**
- *  Get the number of available devices exposed by the current driver.
- *  Only valid after a successfully initializing the audio subsystem.
- *  Returns -1 if an explicit list of devices can't be determined; this is
- *  not an error. For example, if SDL is set up to talk to a remote audio
- *  server, it can't list every one available on the Internet, but it will
- *  still allow a specific host to be specified to SDL_OpenAudioDevice().
- *
- *  In many common cases, when this function returns a value <= 0, it can still
- *  successfully open the default device (NULL for first argument of
- *  SDL_OpenAudioDevice()).
- */
-extern DECLSPEC int SDLCALL SDL_GetNumAudioDevices(int iscapture);
-
-/**
- *  Get the human-readable name of a specific audio device.
- *  Must be a value between 0 and (number of audio devices-1).
- *  Only valid after a successfully initializing the audio subsystem.
- *  The values returned by this function reflect the latest call to
- *  SDL_GetNumAudioDevices(); recall that function to redetect available
- *  hardware.
- *
- *  The string returned by this function is UTF-8 encoded, read-only, and
- *  managed internally. You are not to free it. If you need to keep the
- *  string for any length of time, you should make your own copy of it, as it
- *  will be invalid next time any of several other SDL functions is called.
- */
-extern DECLSPEC const char *SDLCALL SDL_GetAudioDeviceName(int index,
-                                                           int iscapture);
-
-
-/**
- *  Open a specific audio device. Passing in a device name of NULL requests
- *  the most reasonable default (and is equivalent to calling SDL_OpenAudio()).
- *
- *  The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
- *  some drivers allow arbitrary and driver-specific strings, such as a
- *  hostname/IP address for a remote audio server, or a filename in the
- *  diskaudio driver.
- *
- *  \return 0 on error, a valid device ID that is >= 2 on success.
- *
- *  SDL_OpenAudio(), unlike this function, always acts on device ID 1.
- */
-extern DECLSPEC SDL_AudioDeviceID SDLCALL SDL_OpenAudioDevice(const char
-                                                              *device,
-                                                              int iscapture,
-                                                              const
-                                                              SDL_AudioSpec *
-                                                              desired,
-                                                              SDL_AudioSpec *
-                                                              obtained,
-                                                              int
-                                                              allowed_changes);
-
-
-
-/**
- *  \name Audio state
- *
- *  Get the current audio state.
- */
-/* @{ */
-typedef enum
-{
-    SDL_AUDIO_STOPPED = 0,
-    SDL_AUDIO_PLAYING,
-    SDL_AUDIO_PAUSED
-} SDL_AudioStatus;
-extern DECLSPEC SDL_AudioStatus SDLCALL SDL_GetAudioStatus(void);
-
-extern DECLSPEC SDL_AudioStatus SDLCALL
-SDL_GetAudioDeviceStatus(SDL_AudioDeviceID dev);
-/* @} *//* Audio State */
-
-/**
- *  \name Pause audio functions
- *
- *  These functions pause and unpause the audio callback processing.
- *  They should be called with a parameter of 0 after opening the audio
- *  device to start playing sound.  This is so you can safely initialize
- *  data for your callback function after opening the audio device.
- *  Silence will be written to the audio device during the pause.
- */
-/* @{ */
-extern DECLSPEC void SDLCALL SDL_PauseAudio(int pause_on);
-extern DECLSPEC void SDLCALL SDL_PauseAudioDevice(SDL_AudioDeviceID dev,
-                                                  int pause_on);
-/* @} *//* Pause audio functions */
-
-/**
- *  This function loads a WAVE from the data source, automatically freeing
- *  that source if \c freesrc is non-zero.  For example, to load a WAVE file,
- *  you could do:
- *  \code
- *      SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
- *  \endcode
- *
- *  If this function succeeds, it returns the given SDL_AudioSpec,
- *  filled with the audio data format of the wave data, and sets
- *  \c *audio_buf to a malloc()'d buffer containing the audio data,
- *  and sets \c *audio_len to the length of that audio buffer, in bytes.
- *  You need to free the audio buffer with SDL_FreeWAV() when you are
- *  done with it.
- *
- *  This function returns NULL and sets the SDL error message if the
- *  wave file cannot be opened, uses an unknown data format, or is
- *  corrupt.  Currently raw and MS-ADPCM WAVE files are supported.
- */
-extern DECLSPEC SDL_AudioSpec *SDLCALL SDL_LoadWAV_RW(SDL_RWops * src,
-                                                      int freesrc,
-                                                      SDL_AudioSpec * spec,
-                                                      Uint8 ** audio_buf,
-                                                      Uint32 * audio_len);
-
-/**
- *  Loads a WAV from a file.
- *  Compatibility convenience function.
- */
-#define SDL_LoadWAV(file, spec, audio_buf, audio_len) \
-    SDL_LoadWAV_RW(SDL_RWFromFile(file, "rb"),1, spec,audio_buf,audio_len)
-
-/**
- *  This function frees data previously allocated with SDL_LoadWAV_RW()
- */
-extern DECLSPEC void SDLCALL SDL_FreeWAV(Uint8 * audio_buf);
-
-/**
- *  This function takes a source format and rate and a destination format
- *  and rate, and initializes the \c cvt structure with information needed
- *  by SDL_ConvertAudio() to convert a buffer of audio data from one format
- *  to the other.
- *
- *  \return -1 if the format conversion is not supported, 0 if there's
- *  no conversion needed, or 1 if the audio filter is set up.
- */
-extern DECLSPEC int SDLCALL SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
-                                              SDL_AudioFormat src_format,
-                                              Uint8 src_channels,
-                                              int src_rate,
-                                              SDL_AudioFormat dst_format,
-                                              Uint8 dst_channels,
-                                              int dst_rate);
-
-/**
- *  Once you have initialized the \c cvt structure using SDL_BuildAudioCVT(),
- *  created an audio buffer \c cvt->buf, and filled it with \c cvt->len bytes of
- *  audio data in the source format, this function will convert it in-place
- *  to the desired format.
- *
- *  The data conversion may expand the size of the audio data, so the buffer
- *  \c cvt->buf should be allocated after the \c cvt structure is initialized by
- *  SDL_BuildAudioCVT(), and should be \c cvt->len*cvt->len_mult bytes long.
- */
-extern DECLSPEC int SDLCALL SDL_ConvertAudio(SDL_AudioCVT * cvt);
-
-#define SDL_MIX_MAXVOLUME 128
-/**
- *  This takes two audio buffers of the playing audio format and mixes
- *  them, performing addition, volume adjustment, and overflow clipping.
- *  The volume ranges from 0 - 128, and should be set to ::SDL_MIX_MAXVOLUME
- *  for full audio volume.  Note this does not change hardware volume.
- *  This is provided for convenience -- you can mix your own audio data.
- */
-extern DECLSPEC void SDLCALL SDL_MixAudio(Uint8 * dst, const Uint8 * src,
-                                          Uint32 len, int volume);
-
-/**
- *  This works like SDL_MixAudio(), but you specify the audio format instead of
- *  using the format of audio device 1. Thus it can be used when no audio
- *  device is open at all.
- */
-extern DECLSPEC void SDLCALL SDL_MixAudioFormat(Uint8 * dst,
-                                                const Uint8 * src,
-                                                SDL_AudioFormat format,
-                                                Uint32 len, int volume);
-
-/**
- *  \name Audio lock functions
- *
- *  The lock manipulated by these functions protects the callback function.
- *  During a SDL_LockAudio()/SDL_UnlockAudio() pair, you can be guaranteed that
- *  the callback function is not running.  Do not call these from the callback
- *  function or you will cause deadlock.
- */
-/* @{ */
-extern DECLSPEC void SDLCALL SDL_LockAudio(void);
-extern DECLSPEC void SDLCALL SDL_LockAudioDevice(SDL_AudioDeviceID dev);
-extern DECLSPEC void SDLCALL SDL_UnlockAudio(void);
-extern DECLSPEC void SDLCALL SDL_UnlockAudioDevice(SDL_AudioDeviceID dev);
-/* @} *//* Audio lock functions */
-
-/**
- *  This function shuts down audio processing and closes the audio device.
- */
-extern DECLSPEC void SDLCALL SDL_CloseAudio(void);
-extern DECLSPEC void SDLCALL SDL_CloseAudioDevice(SDL_AudioDeviceID dev);
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* _SDL_audio_h */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,97 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_bits.h
- *
- *  Functions for fiddling with bits and bitmasks.
- */
-
-#ifndef _SDL_bits_h
-#define _SDL_bits_h
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \file SDL_bits.h
- */
-
-/**
- *  Get the index of the most significant bit. Result is undefined when called
- *  with 0. This operation can also be stated as "count leading zeroes" and
- *  "log base 2".
- *
- *  \return Index of the most significant bit, or -1 if the value is 0.
- */
-SDL_FORCE_INLINE int
-SDL_MostSignificantBitIndex32(Uint32 x)
-{
-#if defined(__GNUC__) && __GNUC__ >= 4
-    /* Count Leading Zeroes builtin in GCC.
-     * http://gcc.gnu.org/onlinedocs/gcc-4.3.4/gcc/Other-Builtins.html
-     */
-    if (x == 0) {
-        return -1;
-    }
-    return 31 - __builtin_clz(x);
-#else
-    /* Based off of Bit Twiddling Hacks by Sean Eron Anderson
-     * <seander@cs.stanford.edu>, released in the public domain.
-     * http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
-     */
-    const Uint32 b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
-    const int    S[] = {1, 2, 4, 8, 16};
-
-    int msbIndex = 0;
-    int i;
-
-    if (x == 0) {
-        return -1;
-    }
-
-    for (i = 4; i >= 0; i--)
-    {
-        if (x & b[i])
-        {
-            x >>= S[i];
-            msbIndex |= S[i];
-        }
-    }
-
-    return msbIndex;
-#endif
-}
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* _SDL_bits_h */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,63 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- *  \file SDL_blendmode.h
- *
- *  Header file declaring the SDL_BlendMode enumeration
- */
-
-#ifndef _SDL_blendmode_h
-#define _SDL_blendmode_h
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  \brief The blend mode used in SDL_RenderCopy() and drawing operations.
- */
-typedef enum
-{
-    SDL_BLENDMODE_NONE = 0x00000000,     /**< no blending
-                                              dstRGBA = srcRGBA */
-    SDL_BLENDMODE_BLEND = 0x00000001,    /**< alpha blending
-                                              dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA))
-                                              dstA = srcA + (dstA * (1-srcA)) */
-    SDL_BLENDMODE_ADD = 0x00000002,      /**< additive blending
-                                              dstRGB = (srcRGB * srcA) + dstRGB
-                                              dstA = dstA */
-    SDL_BLENDMODE_MOD = 0x00000004       /**< color modulate
-                                              dstRGB = srcRGB * dstRGB
-                                              dstA = dstA */
-} SDL_BlendMode;
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* _SDL_video_h */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,71 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-/**
- * \file SDL_clipboard.h
- *
- * Include file for SDL clipboard handling
- */
-
-#ifndef _SDL_clipboard_h
-#define _SDL_clipboard_h
-
-#include "SDL_stdinc.h"
-
-#include "begin_code.h"
-/* Set up for C function definitions, even when using C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Function prototypes */
-
-/**
- * \brief Put UTF-8 text into the clipboard
- *
- * \sa SDL_GetClipboardText()
- */
-extern DECLSPEC int SDLCALL SDL_SetClipboardText(const char *text);
-
-/**
- * \brief Get UTF-8 text from the clipboard, which must be freed with SDL_free()
- *
- * \sa SDL_SetClipboardText()
- */
-extern DECLSPEC char * SDLCALL SDL_GetClipboardText(void);
-
-/**
- * \brief Returns a flag indicating whether the clipboard exists and contains a text string that is non-empty
- *
- * \sa SDL_GetClipboardText()
- */
-extern DECLSPEC SDL_bool SDLCALL SDL_HasClipboardText(void);
-
-
-/* Ends C function definitions when using C++ */
-#ifdef __cplusplus
-}
-#endif
-#include "close_code.h"
-
-#endif /* _SDL_clipboard_h */
-
-/* vi: set ts=4 sw=4 expandtab: */
@@ -1,51 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef _SDL_config_h
-#define _SDL_config_h
-
-#include "SDL_platform.h"
-
-/**
- *  \file SDL_config.h
- */
-
-/* Add any platform that doesn't build using the configure system. */
-#if defined(__WIN32__)
-#include "SDL_config_windows.h"
-#elif defined(__MACOSX__)
-#include "SDL_config_macosx.h"
-#elif defined(__IPHONEOS__)
-#include "SDL_config_iphoneos.h"
-#elif defined(__ANDROID__)
-#include "SDL_config_android.h"
-#elif defined(__PSP__)
-#include "SDL_config_psp.h"
-#else
-/* This is a minimal configuration just to get SDL running on new platforms */
-#include "SDL_config_minimal.h"
-#endif /* platform config */
-
-#ifdef USING_GENERATED_CONFIG_H
-#error Wrong SDL_config.h, check your include path?
-#endif
-
-#endif /* _SDL_config_h */
@@ -1,142 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef _SDL_config_android_h
-#define _SDL_config_android_h
-
-#include "SDL_platform.h"
-
-/**
- *  \file SDL_config_android.h
- *
- *  This is a configuration that can be used to build SDL for Android
- */
-
-#include <stdarg.h>
-
-#define HAVE_GCC_ATOMICS    1
-
-#define HAVE_ALLOCA_H       1
-#define HAVE_SYS_TYPES_H    1
-#define HAVE_STDIO_H    1
-#define STDC_HEADERS    1
-#define HAVE_STRING_H   1
-#define HAVE_INTTYPES_H 1
-#define HAVE_STDINT_H   1
-#define HAVE_CTYPE_H    1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H   1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_SETENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRDUP 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF   1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_SSCANF 1
-#define HAVE_SNPRINTF   1
-#define HAVE_VSNPRINTF  1
-#define HAVE_M_PI   1
-#define HAVE_ATAN   1
-#define HAVE_ATAN2  1
-#define HAVE_CEIL   1
-#define HAVE_COPYSIGN   1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_FABS   1
-#define HAVE_FLOOR  1
-#define HAVE_LOG    1
-#define HAVE_POW    1
-#define HAVE_SCALBN 1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SIGACTION  1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-
-#define SIZEOF_VOIDP 4
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_ANDROID    1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_ANDROID    1
-#define SDL_HAPTIC_DUMMY    1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_DLOPEN   1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_ANDROID 1
-
-/* Enable OpenGL ES */
-#define SDL_VIDEO_OPENGL_ES 1
-#define SDL_VIDEO_OPENGL_EGL 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-
-/* Enable system power support */
-#define SDL_POWER_ANDROID 1
-
-/* !!! FIXME: what does Android do for filesystem stuff? */
-#define SDL_FILESYSTEM_DUMMY   1
-
-#endif /* _SDL_config_android_h */
@@ -1,154 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef _SDL_config_iphoneos_h
-#define _SDL_config_iphoneos_h
-
-#include "SDL_platform.h"
-
-#ifdef __LP64__
-#define SIZEOF_VOIDP 8
-#else
-#define SIZEOF_VOIDP 4
-#endif
-
-#define HAVE_GCC_ATOMICS    1
-
-#define HAVE_ALLOCA_H       1
-#define HAVE_SYS_TYPES_H    1
-#define HAVE_STDIO_H    1
-#define STDC_HEADERS    1
-#define HAVE_STRING_H   1
-#define HAVE_INTTYPES_H 1
-#define HAVE_STDINT_H   1
-#define HAVE_CTYPE_H    1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H   1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_SETENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRDUP 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF   1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_SSCANF 1
-#define HAVE_SNPRINTF   1
-#define HAVE_VSNPRINTF  1
-#define HAVE_M_PI   1
-#define HAVE_ATAN   1
-#define HAVE_ATAN2  1
-#define HAVE_CEIL   1
-#define HAVE_COPYSIGN   1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_FABS   1
-#define HAVE_FLOOR  1
-#define HAVE_LOG    1
-#define HAVE_POW    1
-#define HAVE_SCALBN 1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SIGACTION  1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-#define HAVE_SYSCTLBYNAME 1
-
-/* enable iPhone version of Core Audio driver */
-#define SDL_AUDIO_DRIVER_COREAUDIO 1
-/* Enable the dummy audio driver (src/audio/dummy/\*.c) */
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable the stub haptic driver (src/haptic/dummy/\*.c) */
-#define SDL_HAPTIC_DISABLED 1
-
-/* Enable Unix style SO loading */
-/* Technically this works, but it violates the iPhone developer agreement */
-/* #define SDL_LOADSO_DLOPEN 1 */
-
-/* Enable the stub shared object loader (src/loadso/dummy/\*.c) */
-#define SDL_LOADSO_DISABLED 1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Supported video drivers */
-#define SDL_VIDEO_DRIVER_UIKIT  1
-#define SDL_VIDEO_DRIVER_DUMMY  1
-
-/* enable OpenGL ES */
-#define SDL_VIDEO_OPENGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES 1
-#define SDL_VIDEO_RENDER_OGL_ES2    1
-
-/* Enable system power support */
-#define SDL_POWER_UIKIT 1
-
-/* enable iPhone keyboard support */
-#define SDL_IPHONE_KEYBOARD 1
-
-/* enable joystick subsystem */
-#define SDL_JOYSTICK_DISABLED 0
-
-/* Set max recognized G-force from accelerometer
-   See src/joystick/uikit/SDLUIAccelerationDelegate.m for notes on why this is needed
- */
-#define SDL_IPHONE_MAX_GFORCE 5.0
-
-/* enable filesystem support */
-#define SDL_FILESYSTEM_COCOA   1
-
-#endif /* _SDL_config_iphoneos_h */
@@ -1,183 +0,0 @@
-/*
-  Simple DirectMedia Layer
-  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef _SDL_config_macosx_h
-#define _SDL_config_macosx_h
-
-#include "SDL_platform.h"
-
-/* This gets us MAC_OS_X_VERSION_MIN_REQUIRED... */
-#include <AvailabilityMacros.h>
-
-/* This is a set of defines to configure the SDL features */
-
-#ifdef __LP64__
-    #define SIZEOF_VOIDP 8
-#else
-    #define SIZEOF_VOIDP 4
-#endif
-
-/* Useful headers */
-#define HAVE_ALLOCA_H       1
-#define HAVE_SYS_TYPES_H    1
-#define HAVE_STDIO_H    1
-#define STDC_HEADERS    1
-#define HAVE_STRING_H   1
-#define HAVE_INTTYPES_H 1
-#define HAVE_STDINT_H   1
-#define HAVE_CTYPE_H    1
-#define HAVE_MATH_H 1
-#define HAVE_SIGNAL_H   1
-
-/* C library functions */
-#define HAVE_MALLOC 1
-#define HAVE_CALLOC 1
-#define HAVE_REALLOC    1
-#define HAVE_FREE   1
-#define HAVE_ALLOCA 1
-#define HAVE_GETENV 1
-#define HAVE_SETENV 1
-#define HAVE_PUTENV 1
-#define HAVE_UNSETENV   1
-#define HAVE_QSORT  1
-#define HAVE_ABS    1
-#define HAVE_BCOPY  1
-#define HAVE_MEMSET 1
-#define HAVE_MEMCPY 1
-#define HAVE_MEMMOVE    1
-#define HAVE_MEMCMP 1
-#define HAVE_STRLEN 1
-#define HAVE_STRLCPY    1
-#define HAVE_STRLCAT    1
-#define HAVE_STRDUP 1
-#define HAVE_STRCHR 1
-#define HAVE_STRRCHR    1
-#define HAVE_STRSTR 1
-#define HAVE_STRTOL 1
-#define HAVE_STRTOUL    1
-#define HAVE_STRTOLL    1
-#define HAVE_STRTOULL   1
-#define HAVE_STRTOD 1
-#define HAVE_ATOI   1
-#define HAVE_ATOF   1
-#define HAVE_STRCMP 1
-#define HAVE_STRNCMP    1
-#define HAVE_STRCASECMP 1
-#define HAVE_STRNCASECMP 1
-#define HAVE_SSCANF 1
-#define HAVE_SNPRINTF   1
-#define HAVE_VSNPRINTF  1
-#define HAVE_CEIL   1
-#define HAVE_COPYSIGN   1
-#define HAVE_COS    1
-#define HAVE_COSF   1
-#define HAVE_FABS   1
-#define HAVE_FLOOR  1
-#define HAVE_LOG    1
-#define HAVE_POW    1
-#define HAVE_SCALBN 1
-#define HAVE_SIN    1
-#define HAVE_SINF   1
-#define HAVE_SQRT   1
-#define HAVE_SIGACTION  1
-#define HAVE_SETJMP 1
-#define HAVE_NANOSLEEP  1
-#define HAVE_SYSCONF    1
-#define HAVE_SYSCTLBYNAME 1
-#define HAVE_ATAN 1
-#define HAVE_ATAN2 1
-
-/* Enable various audio drivers */
-#define SDL_AUDIO_DRIVER_COREAUDIO  1
-#define SDL_AUDIO_DRIVER_DISK   1
-#define SDL_AUDIO_DRIVER_DUMMY  1
-
-/* Enable various input drivers */
-#define SDL_JOYSTICK_IOKIT  1
-#define SDL_HAPTIC_IOKIT    1
-
-/* Enable various shared object loading systems */
-#define SDL_LOADSO_DLOPEN   1
-
-/* Enable various threading systems */
-#define SDL_THREAD_PTHREAD  1
-#define SDL_THREAD_PTHREAD_RECURSIVE_MUTEX  1
-
-/* Enable various timer systems */
-#define SDL_TIMER_UNIX  1
-
-/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_COCOA  1
-#define SDL_VIDEO_DRIVER_DUMMY  1
-#undef SDL_VIDEO_DRIVER_X11
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC "/usr/X11R6/lib/libX11.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT "/usr/X11R6/lib/libXext.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA "/usr/X11R6/lib/libXinerama.1.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2 "/usr/X11R6/lib/libXi.6.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR "/usr/X11R6/lib/libXrandr.2.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS "/usr/X11R6/lib/libXss.1.dylib"
-#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE "/usr/X11R6/lib/libXxf86vm.1.dylib"
-#define SDL_VIDEO_DRIVER_X11_XINERAMA 1
-#define SDL_VIDEO_DRIVER_X11_XRANDR 1
-#define SDL_VIDEO_DRIVER_X11_XSCRNSAVER 1
-#define SDL_VIDEO_DRIVER_X11_XSHAPE 1
-#define SDL_VIDEO_DRIVER_X11_XVIDMODE 1
-#define SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM 1
-
-#ifdef MAC_OS_X_VERSION_10_8
-/*
- * No matter the versions targeted, this is the 10.8 or later SDK, so you have
- *  to use the external Xquartz, which is a more modern Xlib. Previous SDKs
- *  used an older Xlib.
- */
-#define SDL_VIDEO_DRIVER_X11_XINPUT2 1
-#define SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS 1
-#define SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY 1
-#endif
-
-#ifndef SDL_VIDEO_RENDER_OGL
-#define SDL_VIDEO_RENDER_OGL    1
-#endif
-
-/* Enable OpenGL support */
-#ifndef SDL_VIDEO_OPENGL
-#define SDL_VIDEO_OPENGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_CGL
-#define SDL_VIDEO_OPENGL_CGL    1
-#endif
-#ifndef SDL_VIDEO_OPENGL_GLX
-#define SDL_VIDEO_OPENGL_GLX    1
-#endif
-
-/* Enable system power support */
-#define SDL_POWER_MACOSX 1
-
-/* enable filesystem support */
-#define SDL_FILESYSTEM_COCOA   1
-
-/* Enable assembly routines */
-#define SDL_ASSEMBLY_ROUTINES   1
-#ifdef __ppc__
-#define SDL_ALTIVEC_BLITTERS    1
-#endif
-
-#endif /* _SDL_config_macosx_h */