made a copy

.circleci/config.yml

@@ -1,182 +0,0 @@
-version: 2
-
-references:
-  container_config: &container_config
-    docker:
-      - image: "debian:stretch"
-        working_directory: /root/build
-
-  restore_repo: &restore_repo
-    restore_cache:
-      keys:
-        - source-repo-{{ .Branch }}-{{ .Revision }}
-        - source-repo-{{ .Branch }}
-        - source-repo
-
-  cmake_configure: &cmake_configure
-    run:
-      name: Creating Build Files
-      command: |
-        mkdir build
-        cd build
-
-        CXXFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-        CFLAGS="-m64 -mtune=generic -mfpmath=sse -msse -msse2 -pipe -Wno-unknown-pragmas"
-
-        if [[ "$CC" =~ ^clang.*$ ]]; then
-            CXXFLAGS="$CXXFLAGS -stdlib=libc++"
-        fi
-
-        eval $CC --version
-
-        export CXXFLAGS
-        export CFLAGS
-        CMAKE="cmake -G Ninja -DFSO_FATAL_WARNINGS=ON $CMAKE_OPTIONS"
-        eval $CMAKE -DCMAKE_BUILD_TYPE=$CONFIGURATION -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON ..
-
-  compile: &compile
-    run:
-      name: Compiling Source code
-      command: |
-        cd build
-        ninja -k 20 all
-
-  run_tests: &run_tests
-    run:
-      name: Run unit tests
-      command: |
-        ./build/bin/unittests --gtest_shuffle
-
-  compile_steps: &compile_steps
-    steps:
-      - *restore_repo
-      - *cmake_configure
-      - *compile
-      - *run_tests
-jobs:
-  checkout_code:
-    <<: *container_config
-    steps:
-      - run:
-          name: Installing Git
-          command: 'apt-get update && apt-get -yq install git'
-      - *restore_repo
-      - checkout
-      - run:
-          name: Updating submodules
-          command: 'git submodule update --init --recursive'
-      - save_cache:
-          key: source-repo-{{ .Branch }}-{{ .Revision }}
-          paths:
-            - .
-
-  build_gcc_lowest_debug:
-    docker:
-      - image: asarium/fso_compile:gcc-lowest
-        working_directory: /root/build
-    environment:
-      CC: gcc
-      CXX: g++
-      CONFIGURATION: Debug
-    <<: *compile_steps
-
-  build_gcc_lowest_release:
-    docker:
-      - image: asarium/fso_compile:gcc-lowest
-        working_directory: /root/build
-    environment:
-      CC: gcc
-      CXX: g++
-      CONFIGURATION: Release
-    <<: *compile_steps
-
-  build_gcc_latest_debug:
-    docker:
-      - image: asarium/fso_compile:gcc-latest
-        working_directory: /root/build
-    environment:
-      CC: gcc
-      CXX: g++
-      CONFIGURATION: Debug
-    <<: *compile_steps
-
-  build_gcc_latest_release:
-    docker:
-      - image: asarium/fso_compile:gcc-latest
-        working_directory: /root/build
-    environment:
-      CC: gcc
-      CXX: g++
-      CONFIGURATION: Release
-    <<: *compile_steps
-
-  build_clang_latest_debug:
-    docker:
-      - image: asarium/fso_compile:clang-latest
-        working_directory: /root/build
-    environment:
-      CC: clang-8
-      CXX: clang++-8
-      CONFIGURATION: Debug
-    <<: *compile_steps
-
-  build_clang_latest_release:
-    docker:
-      - image: asarium/fso_compile:clang-latest
-        working_directory: /root/build
-    environment:
-      CC: clang-8
-      CXX: clang++-8
-      CONFIGURATION: Release
-    <<: *compile_steps
-
-  build_clang_lowest_debug:
-    docker:
-      - image: asarium/fso_compile:clang-lowest
-        working_directory: /root/build
-    environment:
-      CC: clang
-      CXX: clang++
-      CONFIGURATION: Debug
-    <<: *compile_steps
-
-  build_clang_lowest_release:
-    docker:
-      - image: asarium/fso_compile:clang-lowest
-        working_directory: /root/build
-    environment:
-      CC: clang
-      CXX: clang++
-      CONFIGURATION: Release
-    <<: *compile_steps
-
-workflows:
-  version: 2
-
-  build_test:
-    jobs:
-      - checkout_code
-      - build_gcc_lowest_debug:
-          requires:
-            - checkout_code
-      - build_gcc_lowest_release:
-          requires:
-            - checkout_code
-      - build_gcc_latest_debug:
-          requires:
-            - checkout_code
-      - build_gcc_latest_release:
-          requires:
-            - checkout_code
-      - build_clang_latest_debug:
-          requires:
-            - checkout_code
-      - build_clang_latest_release:
-          requires:
-            - checkout_code
-      - build_clang_lowest_debug:
-          requires:
-            - checkout_code
-      - build_clang_lowest_release:
-          requires:
-            - checkout_code

.clang-format

@@ -1,104 +0,0 @@
----
-Language:        Cpp
-Standard: Cpp11
-# BasedOnStyle:  LLVM
-AccessModifierOffset: -2
-AlignAfterOpenBracket: DontAlign
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Left
-AlignOperands:   true
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowAllArgumentsOnNextLine: false
-AllowShortBlocksOnASingleLine: Never
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortEnumsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Empty
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: Yes
-BinPackArguments: false
-BinPackParameters: false
-BraceWrapping:   
-  AfterClass:      false
-  AfterControlStatement: false
-  AfterEnum:       false
-  AfterFunction:   true
-  AfterNamespace:  false
-  AfterObjCDeclaration: false
-  AfterStruct:     false
-  AfterUnion:      false
-  BeforeCatch:     false
-  BeforeElse:      false
-  IndentBraces:    false
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Custom
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit:     120
-CommentPragmas:  '^ IWYU pragma:'
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat:   false
-ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-IncludeBlocks: Regroup
-IncludeCategories:
-  - Regex:           '^(<.*\.(h|hh|hpp)>)$' # Includes of external libraries
-    Priority:        5
-  - Regex:           '^(<.*>)$' # standard library includes (won't match deprecated C headers)
-    Priority:        6
-  - Regex:           '^"globalincs\/.*\.h"$' # globalincs always come first
-    Priority:        1
-  - Regex:           '^"[^/]*\.(h)"$' # Local includes
-    Priority:        2
-  - Regex:           '^".*\.(h)"$' # standard engine includes
-    Priority:        3
-  - Regex:           '.*' # Catch all in case something is unhandled above
-    Priority:        4
-IncludeIsMainRegex: '$'
-IndentCaseLabels: false
-IndentWidth:     4
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBlockIndentWidth: 2
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Left
-ReflowComments:  true
-SortIncludes:    true
-SpaceAfterCStyleCast: false
-SpaceAfterTemplateKeyword: true
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeParens: ControlStatements
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-TabWidth:        4
-UseTab:          ForContinuationAndIndentation
-...
-

.clang-tidy

@@ -1,54 +0,0 @@
----
-Checks: "-*,\
-modernize-*,\
--modernize-avoid-c-arrays,\
--modernize-make-unique,\
--modernize-raw-string-literal,\
--modernize-use-default-member-init,\
--modernize-use-nodiscard,\
--modernize-use-trailing-return-type,\
--modernize-use-using,\
-performance-*,\
--performance-no-int-to-ptr,\
--performance-type-promotion-in-math-fn,\
-misc-*,\
--misc-include-cleaner,\
--misc-macro-parentheses,\
--misc-misplaced-widening-cast,\
--misc-no-recursion,\
--misc-non-private-member-variables-in-classes,\
--misc-static-assert,\
--misc-unused-parameters,\
--misc-use-anonymous-namespace,\
-readability-*,\
--readability-avoid-const-params-in-decls,\
--readability-else-after-return,\
--readability-function-cognitive-complexity,\
--readability-function-size,\
--readability-identifier-length,\
--readability-identifier-naming,\
--readability-implicit-bool-conversion,\
--readability-inconsistent-declaration-parameter-name,\
--readability-isolate-declaration,\
--readability-magic-numbers,\
--readability-named-parameter,\
--readability-qualified-auto,\
--readability-uppercase-literal-suffix,\
-"
-WarningsAsErrors: ''
-HeaderFilterRegex: 'code/.*$|freespace2/.*$|qtfred/.*$|test/src/.*$|build/.*$'
-CheckOptions:
-  - key:          'misc-assert-side-effect.AssertMacros'
-    value:        'assert,Assert,Assertion'
-  - key:          'misc-const-correctness.AnalyzeValues'
-    value:        'false'
-  - key:          'misc-const-correctness.TransformValues'
-    value:        'false'
-  - key:          'modernize-use-emplace.ContainersWithPushBack'
-    value:        'std::vector;std::deque;std::list;SCP_vector;SCP_deque;SCP_list'
-  - key:          'readability-braces-around-statements.ShortStatementLines'
-    value:        '4' # Avoid flagging simple if (...) return false; statements
-  - key:          'performance-move-const-arg.CheckTriviallyCopyableMove' # This isn't actually performance relevant, but using move on trivially copyable types can well indicate that the variable should not be used anymore, such as when passing a builder type to the finialization function
-    value:        'false'
-...
-

.dockerignore

@@ -1,2 +0,0 @@
-/build
-/.git

.drone.yml

@@ -1,21 +0,0 @@
-
-build:
-  image: teaci/msys$$arch
-  pull: true
-  shell: mingw$$arch
-  commands:
-    - git submodule update --init --recursive
-    - if [ $$arch = 32 ]; then target=i686; fi
-    - if [ $$arch = 64 ]; then target=x86_64; fi
-    - pacman -S --needed --noconfirm --noprogressbar mingw-w64-${target}-pkg-config mingw-w64-${target}-cmake
-    - mkdir build && cd build
-    - cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=$$CONFIGURATION -DFSO_USE_SPEECH=OFF -DFSO_USE_VOICEREC=OFF -DFSO_FATAL_WARNINGS=ON -DFSO_BUILD_FRED2=OFF ..
-    - make -j$(nproc) all
-
-matrix:
-  arch:
-    - 64
-    - 32
-  CONFIGURATION:
-    - Debug
-    - Release

.editorconfig

@@ -1,15 +0,0 @@
-root = true
-
-[*.{h,cpp}]
-indent_style = tab
-
-[*.sdr]
-indent_style = tab
-
-[*.{yml,yaml}]
-indent_style = space
-indent_size = 2
-
-[*.sh]
-indent_style = space
-indent_size = 4

.gitattributes

@@ -1,7 +0,0 @@
-# Default for everything
-# * text=auto
-
-# For the test data and built-in files to make them consistent on all platforms
-*.tbl text eol=lf
-*.tbm text eol=lf
-*.sdr text eol=lf

.github/CODEOWNERS

@@ -1,6 +0,0 @@
-
-ci/ @asarium @z64555
-
-code/controlconfig/ @z64555
-
-code/model/modelanimation*.* @bmagnu

.github/workflows/build-nightly.yaml

@@ -1,386 +0,0 @@
-name: Build Nightly package
-
-on:
-  push:
-    tags:
-      - 'nightly_*'
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        os: [ubuntu-latest, ubuntu-24.04-arm]
-        include:
-          - os: ubuntu-latest
-            arch: x86_64
-          - os: ubuntu-24.04-arm
-            arch: arm64
-    name: Linux
-    runs-on: ${{ matrix.os }}
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-9
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        with:
-          name: linux-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Download Release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: linux-Release-${{ matrix.arch }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: linux-FastDebug-${{ matrix.arch }}
-          path: builds
-      - name: Fix permissions
-        working-directory: ./builds
-        shell: bash
-        run: chmod 755 *.AppImage
-      - name: Create Distribution package
-        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        os: [windows-2025, windows-11-arm]
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, ""]
-        exclude:
-          - arch: Win32
-            os: windows-11-arm
-          - arch: x64
-            os: windows-11-arm
-          - arch: ARM64
-            os: windows-2025
-          - os: windows-2025
-            simd: ""
-          - os: windows-11-arm
-            simd: SSE2
-    name: Windows
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Install v143 ATL/MFC
-        shell: pwsh
-        run: ci/windows/install_v143_atlmfc.ps1
-      # Tree A: static CRT (/MT) for FSO + FRED2 (no Qt dependency needed)
-      - name: Configure CMake (static CRT /MT - FSO + FRED2)
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build-mt
-          cd build-mt
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=ON -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DFSO_BUILD_QTFRED=OFF -G "Visual Studio 18 2026" -T "v143" \
-            -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile (static CRT)
-        working-directory: ./build-mt
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-          cmake --install . --config "$CONFIGURATION"
-          ls -alR "$(pwd)/install"
-      # Tree B: dynamic CRT (/MD) for QtFRED only (matches Qt's prebuilt /MD runtime)
-      # Skipped on Win32: Qt6 has no 32-bit Windows support, so CMake force-disables
-      # FSO_BUILD_QTFRED there and the qtfred target would not exist
-      - name: Configure CMake (dynamic CRT /MD - QtFRED)
-        if: matrix.arch != 'Win32'
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build-md
-          cd build-md
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=OFF -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_FRED2=OFF -DQT_USE_PRECOMPILED=ON \
-            -G "Visual Studio 18 2026" -T "v143" -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile (dynamic CRT)
-        if: matrix.arch != 'Win32'
-        working-directory: ./build-md
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target qtfred -- /verbosity:minimal
-          cmake --install . --config "$CONFIGURATION" --component qtFRED
-          ls -alR "$(pwd)/install"
-      # Merge both trees into the single install dir the zip job consumes
-      - name: Merge installs
-        shell: bash
-        run: |
-          mkdir -p build/install
-          # build-md does not exist on Win32 (no QtFRED there)
-          if [ -d build-md/install ]; then
-             cp -r build-md/install/. build/install/
-          fi
-          cp -r build-mt/install/. build/install/
-          ls -alR build/install
-      - name: Run Tests
-        working-directory: ./build-mt
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.configuration }}-${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        with:
-          name: windows-${{ env.artifact_id }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, ""]
-        exclude:
-          - arch: Win32
-            simd: ""
-          - arch: x64
-            simd: ""
-          - arch: ARM64
-            simd: SSE2
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
-      - name: Download Release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: windows-Release-${{ env.artifact_id }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: windows-FastDebug-${{ env.artifact_id }}
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ID: ${{ env.artifact_id }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        working-directory: ./builds
-        shell: bash
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        compiler: [clang]
-        arch: [x86_64, arm64]
-    name: Mac
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"]
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: ninja all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCH: ${{ matrix.arch }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Sign builds
-        working-directory: ./build/bin
-        run: |
-          # make sure OpenAL framework is signed
-          find . -name OpenAL -type f | while read xx; do codesign --force -s - $xx; done
-          find . -name OpenAL.framework -type d | while read xx; do codesign --force -s - $xx; done
-          # make sure dylibs are signed
-          find . -name \*.dylib -type f | while read xx; do codesign --force -s - $xx; done
-          # sign binaries
-          find . -perm +111 -type f | grep MacOS | while read xx; do codesign --force -s - $xx; done
-          # sign apps
-          find . -name \*.app -maxdepth 1 | while read xx; do codesign --force -s - $xx; done
-      - name: Package build result
-        working-directory: ./build/bin
-        # Use GNU tar here (part of runner image) to avoid weird corruption bug with bsdtar
-        # Ref: https://github.com/actions/runner-images/issues/2619
-        run: gtar -cvzf macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz *.app
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        with:
-          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
-  mac_zip:
-    name: Build Mac distribution zip
-    needs: build_mac
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Download Release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: mac-Release-${{ matrix.arch }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: mac-FastDebug-${{ matrix.arch }}
-          path: builds
-      - name: Unpack builds
-        working-directory: ./builds
-        run: |
-          tar -xvzf macos-build-Release-${{ matrix.arch }}.tgz
-          tar -xvzf macos-build-FastDebug-${{ matrix.arch }}.tgz
-      - name: Create Distribution package
-        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh nightly

.github/workflows/build-release.yaml

@@ -1,473 +0,0 @@
-name: Build Release package
-
-on:
-  push:
-    tags:
-      - 'release_*'
-
-jobs:
-  create_release:
-    name: Create GitHub release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Create Release
-        id: create_release
-        uses: actions/create-release@v1
-        # Creates a release package page on github
-        # create_release.inputs:      (notable inputs)
-        #   allowUpdates=false        if true, update an existing release if it exists
-        #   artifactErrorsFailBuild=false   if true, fails the build should artifact read/write errors occur
-        #   artifacts                 optional set of paths to artifacts to upload to the release. comma delimited.
-        #   removeArtifacts=false     if true, remove existing artifacts
-        #   replaceArtifacts=false    if true, replace/overwrite existing artifacts
-        # create_release.outputs:
-        #   id          id of the created release
-        #   html_url    HTML URL of the release
-        #   upload_url  FTP URL of the release where assets are uploaded
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
-        with:
-          tag_name: ${{ github.ref }}
-          release_name: Release ${{ github.ref }}
-          draft: false
-          prerelease: false
-
-  build_linux:
-    strategy:
-      matrix:
-        # Run this job for each configuration
-        # The current config running is accesible with `matrix.configuration`
-        configuration: [FastDebug, Release]
-        os: [ubuntu-latest, ubuntu-24.04-arm]
-        include:
-          - os: ubuntu-latest
-            arch: x86_64
-          - os: ubuntu-24.04-arm
-            arch: arm64
-    name: Linux
-    needs: create_release   # Don't run this job until create_release is done and successful
-    runs-on: ${{ matrix.os }}
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
-    steps:
-      - uses: actions/checkout@v7
-        # checks-out your repository under $GITHUB_WORKSPACE, so your workflow can access it.
-        name: Checkout
-        with:
-          submodules: true  # `true` to checkout submodules, `recursive` to recursively checkout submodules
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-9
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        # Upload the url file for use with other runners
-        # upload-artifact.inputs:
-        #   if-no-files-found=warn  What to do if path fails to find any files.
-        #       warn      Display a warning but do not fail the action
-        #       error     Display an error and fail the action
-        #       ignore    No display, No fail
-        #   retention-days=0    Days to keep the artifact.
-        #       0     Use default retention policy of the repo
-        #       1~90  Min 1, Max 90 days to keep the artifact unless changed by repo settings page
-        with:
-          name: linux-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'  # value 0 to fetch all history and tags for all branches
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Download Release builds
-        # Grab the release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: linux-Release-${{ matrix.arch }}
-          path: builds
-      - name: Download FastDebug builds
-        # Grab the debug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: linux-FastDebug-${{ matrix.arch }}
-          path: builds
-      - name: Fix permissions
-        working-directory: ./builds
-        shell: bash
-        run: chmod 755 *.AppImage
-      - name: Create Distribution package
-        # Zip both builds together
-        id: generate_package
-        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        # Stash the result to artifact filespace
-        uses: actions/upload-artifact@v7
-        with:
-          name: ${{ steps.generate_package.outputs.package_name }}
-          path: ${{ steps.generate_package.outputs.package_path }}
-      - name: Publish result package
-        # publish the zipped result
-        uses: softprops/action-gh-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          files: ${{ steps.generate_package.outputs.package_path }}
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        os: [windows-2025, windows-11-arm]
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, AVX, ""]
-        exclude:
-          - arch: Win32
-            os: windows-11-arm
-          - arch: x64
-            os: windows-11-arm
-          - arch: ARM64
-            os: windows-2025
-          - os: windows-2025
-            simd: ""
-          - os: windows-11-arm
-            simd: SSE2
-          - os: windows-11-arm
-            simd: AVX
-    needs: create_release
-    name: Windows
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v7
-        # Checkout repo
-        name: Checkout
-        with:
-          submodules: true
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Install v143 ATL/MFC
-        shell: pwsh
-        run: ci/windows/install_v143_atlmfc.ps1
-      # Tree A: static CRT (/MT) for FSO + FRED2 (no Qt dependency needed)
-      - name: Configure CMake (static CRT /MT - FSO + FRED2)
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build-mt
-          cd build-mt
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=ON -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DFSO_BUILD_QTFRED=OFF -G "Visual Studio 18 2026" -T "v143" \
-            -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile (static CRT)
-        working-directory: ./build-mt
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-          cmake --install . --config "$CONFIGURATION"
-          ls -alR "$(pwd)/install"
-      # Tree B: dynamic CRT (/MD) for QtFRED only (matches Qt's prebuilt /MD runtime)
-      # Skipped on Win32: Qt6 has no 32-bit Windows support, so CMake force-disables
-      # FSO_BUILD_QTFRED there and the qtfred target would not exist
-      - name: Configure CMake (dynamic CRT /MD - QtFRED)
-        if: matrix.arch != 'Win32'
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build-md
-          cd build-md
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=OFF -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DFSO_BUILD_QTFRED=ON -DFSO_BUILD_FRED2=OFF -DQT_USE_PRECOMPILED=ON \
-            -G "Visual Studio 18 2026" -T "v143" -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile (dynamic CRT)
-        if: matrix.arch != 'Win32'
-        working-directory: ./build-md
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target qtfred -- /verbosity:minimal
-          cmake --install . --config "$CONFIGURATION" --component qtFRED
-          ls -alR "$(pwd)/install"
-      # Merge both trees into the single install dir the zip job consumes
-      - name: Merge installs
-        shell: bash
-        run: |
-          mkdir -p build/install
-          # build-md does not exist on Win32 (no QtFRED there)
-          if [ -d build-md/install ]; then
-             cp -r build-md/install/. build/install/
-          fi
-          cp -r build-mt/install/. build/install/
-          ls -alR build/install
-      - name: Run Tests
-        working-directory: ./build-mt
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.configuration }}-${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        with:
-          name: windows-${{ env.artifact_id }}
-          path: ${{ github.workspace }}/build/install/*
-
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      fail-fast: false  # Run the other jobs in the matrix instead of failing them
-      matrix:
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, AVX, ""]
-        exclude:
-          - arch: Win32
-            simd: ""
-          - arch: x64
-            simd: ""
-          - arch: ARM64
-            simd: SSE2
-          - arch: ARM64
-            simd: AVX
-
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
-      - name: Download Release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: windows-Release-${{ env.artifact_id }}
-          path: builds
-
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: windows-FastDebug-${{ env.artifact_id }}
-          path: builds
-
-      - name: Create Distribution package
-        id: generate_package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ID: ${{ env.artifact_id }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-
-      - name: Upload result package
-        uses: actions/upload-artifact@v7
-        with:
-          name: ${{ steps.generate_package.outputs.package_name }}
-          path: ${{ steps.generate_package.outputs.package_path }}
-
-      - name: Upload debug package
-        uses: actions/upload-artifact@v7
-        with:
-          name: ${{ steps.generate_package.outputs.debug_name }}
-          path: ${{ steps.generate_package.outputs.debug_path }}
-
-      - name: Publish packages
-        uses: softprops/action-gh-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          files: |
-            ${{ steps.generate_package.outputs.package_path }}
-            ${{ steps.generate_package.outputs.debug_path }}
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        compiler: [clang]
-        arch: [x86_64, arm64]
-    name: Mac
-    needs: create_release
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: ninja all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCH: ${{ matrix.arch }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Sign builds
-        working-directory: ./build/bin
-        run: |
-          # make sure OpenAL framework is signed
-          find . -name OpenAL -type f | while read xx; do codesign --force -s - $xx; done
-          find . -name OpenAL.framework -type d | while read xx; do codesign --force -s - $xx; done
-          # make sure dylibs are signed
-          find . -name \*.dylib -type f | while read xx; do codesign --force -s - $xx; done
-          # sign binaries
-          find . -perm +111 -type f | grep MacOS | while read xx; do codesign --force -s - $xx; done
-          # sign apps
-          find . -name \*.app -maxdepth 1 | while read xx; do codesign --force -s - $xx; done
-      - name: Package build result
-        working-directory: ./build/bin
-        # Use GNU tar here (part of runner image) to avoid weird corruption bug with bsdtar
-        # Ref: https://github.com/actions/runner-images/issues/2619
-        run: gtar -cvzf macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz *.app
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        with:
-          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
-  mac_zip:
-    name: Build Mac distribution zip
-    needs: build_mac
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Download Release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: mac-Release-${{ matrix.arch }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: mac-FastDebug-${{ matrix.arch }}
-          path: builds
-      - name: Unpack builds
-        working-directory: ./builds
-        run: |
-          tar -xvzf macos-build-Release-${{ matrix.arch }}.tgz
-          tar -xvzf macos-build-FastDebug-${{ matrix.arch }}.tgz
-      - name: Create Distribution package
-        id: generate_package
-        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
-      - name: Upload result package
-        uses: actions/upload-artifact@v7
-        with:
-          name: ${{ steps.generate_package.outputs.package_name }}
-          path: ${{ steps.generate_package.outputs.package_path }}
-      - name: Publish result package
-        uses: softprops/action-gh-release@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          files: ${{ steps.generate_package.outputs.package_path }}
-
-  post_build:
-    name: Post builds to Nebula and Forum
-    needs: [linux_zip, windows_zip, mac_zip]
-    uses: ./.github/workflows/post-build-release.yaml
-    with:
-      linux_result: ${{ needs.linux_zip.result }}
-      windows_result: ${{ needs.windows_zip.result }}
-      mac_result: ${{ needs.mac_zip.result }}
-      releaseTag: ${{ github.ref_name }}
-    secrets: inherit

.github/workflows/build-test.yaml

@@ -1,357 +0,0 @@
-name: Build Test package
-
-on:
-  push:
-    branches:
-      - 'test/*'
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        os: [ubuntu-latest, ubuntu-24.04-arm]
-        include:
-          - os: ubuntu-latest
-            arch: x86_64
-          - os: ubuntu-24.04-arm
-            arch: arm64
-    name: Linux
-    runs-on: ${{ matrix.os }}
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: gcc-9
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Generate AppImage
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        run: $GITHUB_WORKSPACE/ci/linux/generate_appimage.sh $GITHUB_WORKSPACE/build/install
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        with:
-          name: linux-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/install/*.AppImage
-  linux_zip:
-    name: Build Linux distribution zip
-    needs: build_linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Download Release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: linux-Release-${{ matrix.arch }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: linux-FastDebug-${{ matrix.arch }}
-          path: builds
-      - name: Fix permissions
-        working-directory: ./builds
-        shell: bash
-        run: chmod 755 *.AppImage
-      - name: Create Distribution package
-        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Linux
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        os: [windows-2025, windows-11-arm]
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, ""]
-        exclude:
-          - arch: Win32
-            os: windows-11-arm
-          - arch: x64
-            os: windows-11-arm
-          - arch: ARM64
-            os: windows-2025
-          - os: windows-2025
-            simd: ""
-          - os: windows-11-arm
-            simd: SSE2
-    name: Windows
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Install v143 ATL/MFC
-        shell: pwsh
-        run: ci/windows/install_v143_atlmfc.ps1
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          SIMD: ${{ matrix.simd }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-          cmake -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_USE_SPEECH=ON \
-            -DFSO_USE_VOICEREC=ON -DFORCED_SIMD_INSTRUCTIONS="$SIMD" \
-            -DFSO_BUILD_TESTS=ON -DFSO_INSTALL_DEBUG_FILES=ON -A "$ARCHITECTURE" \
-            -DQT_USE_PRECOMPILED=ON -G "Visual Studio 18 2026" -T "v143" \
-            -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          cmake --build . --config "$CONFIGURATION" --target INSTALL -- /verbosity:minimal
-          ls -alR "$(pwd)/install"
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-        shell: bash
-        run: ./bin/$CONFIGURATION/unittests --gtest_shuffle
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.configuration }}-${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.configuration }}-${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        with:
-          name: windows-${{ env.artifact_id }}
-          path: ${{ github.workspace }}/build/install/*
-  windows_zip:
-    name: Build Windows distribution zip
-    needs: build_windows
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [Win32, x64, ARM64]
-        simd: [SSE2, ""]
-        exclude:
-          - arch: Win32
-            simd: ""
-          - arch: x64
-            simd: ""
-          - arch: ARM64
-            simd: SSE2
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set artifact id
-        shell: bash
-        run: |
-          id=
-          if [ -n "${{ matrix.simd }}" ]; then
-            id="${{ matrix.arch }}-${{ matrix.simd }}"
-          else
-            id="${{ matrix.arch }}"
-          fi
-          echo "artifact_id=${id}" >> $GITHUB_ENV
-      - name: Download Release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: windows-Release-${{ env.artifact_id }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: windows-FastDebug-${{ env.artifact_id }}
-          path: builds
-      - name: Create Distribution package
-        working-directory: ./builds
-        shell: bash
-        env:
-          ID: ${{ env.artifact_id }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Windows
-      - name: Upload result package
-        working-directory: ./builds
-        shell: bash
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [FastDebug, Release]
-        compiler: [clang]
-        arch: [x86_64, arm64]
-    name: Mac
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Set up test version
-        shell: bash
-        run: |
-          [[ "${{ github.ref }}" =~ ^refs\/heads\/test\/(.*)$ ]]
-          # Override the revision string so that the builds are named correctly
-          echo "set(FSO_VERSION_REVISION_STR ${BASH_REMATCH[1]})" > "version_override.cmake"
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: ninja all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCH: ${{ matrix.arch }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Sign builds
-        working-directory: ./build/bin
-        run: |
-          # make sure OpenAL framework is signed
-          find . -name OpenAL -type f | while read xx; do codesign --force -s - $xx; done
-          find . -name OpenAL.framework -type d | while read xx; do codesign --force -s - $xx; done
-          # make sure dylibs are signed
-          find . -name \*.dylib -type f | while read xx; do codesign --force -s - $xx; done
-          # sign binaries
-          find . -perm +111 -type f | grep MacOS | while read xx; do codesign --force -s - $xx; done
-          # sign apps
-          find . -name \*.app -maxdepth 1 | while read xx; do codesign --force -s - $xx; done
-      - name: Package build result
-        working-directory: ./build/bin
-        # Use GNU tar here (part of runner image) to avoid weird corruption bug with bsdtar
-        # Ref: https://github.com/actions/runner-images/issues/2619
-        run: gtar -cvzf macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz *.app
-      - name: Upload build result
-        uses: actions/upload-artifact@v7
-        with:
-          name: mac-${{ matrix.configuration }}-${{ matrix.arch }}
-          path: ${{ github.workspace }}/build/bin/macos-build-${{ matrix.configuration }}-${{ matrix.arch }}.tgz
-  mac_zip:
-    name: Build Mac distribution zip
-    needs: build_mac
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-ab87451
-    strategy:
-      matrix:
-        arch: [x86_64, arm64]
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: '0'
-          ref: '${{ github.ref }}'
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Download Release builds
-        uses: actions/download-artifact@v8
-        with:
-          name: mac-Release-${{ matrix.arch }}
-          path: builds
-      - name: Download FastDebug builds
-        uses: actions/download-artifact@v8
-        with:
-          name: mac-FastDebug-${{ matrix.arch }}
-          path: builds
-      - name: Unpack builds
-        working-directory: ./builds
-        run: |
-          tar -xvzf macos-build-Release-${{ matrix.arch }}.tgz
-          tar -xvzf macos-build-FastDebug-${{ matrix.arch }}.tgz
-      - name: Create Distribution package
-        working-directory: ./builds
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: $GITHUB_WORKSPACE/ci/linux/create_dist_pack.sh Mac
-      - name: Upload result package
-        working-directory: ./builds
-        env:
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          DATACORDER_USER: ${{ secrets.DATACORDER_USER }}
-          DATACORDER_SSHPASS: ${{ secrets.DATACORDER_PASSWORD }}
-        run: $GITHUB_WORKSPACE/ci/linux/upload_dist_package.sh test

.github/workflows/cache-master.yaml

@@ -1,98 +0,0 @@
-name: Build caches for master
-
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [gcc-9, gcc-13, clang-16]
-        arch: [x86_64]
-        cmake_options: [""]
-        include:
-          # Also include configurations that check if the code compiles without the graphics backends
-          - configuration: Debug
-            compiler: gcc-13
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-          - configuration: Release
-            compiler: gcc-13
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: ccache
-        uses: hendrikmuhs/[email protected]
-        with:
-          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}-${{ matrix.arch }}
-          max-size: 750MB
-      - name: Configure ccache
-        run: |
-          ccache --set-config=sloppiness=pch_defines,time_macros
-          ccache -p
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-          CCACHE_PATH: /usr/local/bin/ccache
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: ninja -k 20 all
-      - name: Show CCache statistics
-        run: ccache --show-stats
-
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [clang]
-        arch: [x86_64, arm64]
-        cmake_options: [""]
-    name: Mac
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: ccache
-        uses: hendrikmuhs/[email protected]
-        with:
-          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.arch }}
-          max-size: 750MB
-      - name: Configure ccache
-        run: |
-          ccache --set-config=sloppiness=pch_defines,time_macros
-          ccache -p
-
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-          CCACHE_PATH: /usr/local/bin/ccache
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: ninja -k 20 all
-      - name: Show CCache statistics
-        run: ccache --show-stats

.github/workflows/post-build-release.yaml

@@ -1,86 +0,0 @@
-name: Post Release builds
-
-on:
-  workflow_call:
-    # Trigger when called by other workflows
-    inputs:
-      linux_result:   # job.result; either success, failure, canceled or skipped
-        required: true
-        type: string
-      windows_result: # job.result
-        required: true
-        type: string
-      mac_result: # job.result
-        required: true
-        type: string
-      releaseTag:
-        required: true
-        type: string
-
-  workflow_dispatch:
-    # Trigger manually from Github
-    inputs:
-      releaseTag:
-        description: Release Tag
-        required: true
-        type: string
-
-env:
-  GITHUB_REPO: ${{ github.repository }} # repo this workflow was called from
-  INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-  INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-  NEBULA_USER: ${{ secrets.NEBULA_USER }}
-  NEBULA_PASSWORD: ${{ secrets.NEBULA_PASSWORD }}
-  HLP_API: ${{ secrets.HLP_API }}
-  HLP_KEY: ${{ secrets.HLP_KEY }}
-  FORUM_SECRET: ${{ secrets.FORUM_SECRET }}
-  RELEASE_TAG: ${{ inputs.releaseTag }}
-
-jobs:
-  post_builds:
-    name: Post builds on Nebula and the forums
-    runs-on: ubuntu-latest
-    steps:
-      - name: Caller
-        # Name of what called this yaml.  Used to debug auto/manual step being triggered
-        run: echo "github.event_name= ${{ github.event_name }}"
-
-      - name: Checkout
-        uses: actions/checkout@v7
-        with:
-          fetch-depth: '0'
-          ref: ${{ env.RELEASE_TAG }}
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Install Python dependencies
-        run: pip install -r ci/post/requirements.txt
-
-      - name: Post Builds (Auto trigger)
-        if: ${{ (github.event_name == 'workflow_call') || (github.event_name == 'push') }}
-        env:
-          LINUX_RESULT: ${{ inputs.linux_result }}
-          WINDOWS_RESULT: ${{ inputs.windows_result }}
-          MAC_RESULT: ${{ inputs.mac_result }}
-          GITHUB_REPO: ${{ github.repository }} # repo this workflow was called from
-          INDIEGAMES_USER: ${{ secrets.INDIEGAMES_USER }}
-          INDIEGAMES_SSHPASS: ${{ secrets.INDIEGAMES_PASSWORD }}
-          NEBULA_USER: ${{ secrets.NEBULA_USER }}
-          NEBULA_PASSWORD: ${{ secrets.NEBULA_PASSWORD }}
-          HLP_API: ${{ secrets.HLP_API }}
-          HLP_KEY: ${{ secrets.HLP_KEY }}
-          RELEASE_TAG: ${{ inputs.releaseTag }}
-          FORUM_SECRET: ${{ secrets.FORUM_SECRET }}
-        run: python ci/post/main.py release
-
-      - name: Post Builds (Manual trigger)
-        if: ${{ github.event_name == 'workflow_dispatch' }}
-        # assume user knows what they're doing...
-        env:
-          LINUX_RESULT: success
-          WINDOWS_RESULT: success
-          MAC_RESULT: success
-        run: |
-          echo "releaseTag= ${{ env.RELEASE_TAG }}"
-          echo "repository= ${{ github.repository }}"
-          python ci/post/main.py release

.github/workflows/test-pull_request.yaml

@@ -1,202 +0,0 @@
-name: Check a pull request
-
-on: [pull_request]
-
-jobs:
-  build_linux:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [gcc-9, gcc-13, clang-16]
-        cmake_options: [""]
-        include:
-          # Also include configurations that check if the code compiles without the graphics backends
-          - configuration: Debug
-            compiler: gcc-13
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-          - configuration: Release
-            compiler: gcc-13
-            cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=OFF
-          # - configuration: Debug
-          #   compiler: gcc-13
-          #   cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=ON
-          # - configuration: Release
-          #   compiler: gcc-13
-          #   cmake_options: -DFSO_BUILD_WITH_OPENGL=OFF -DFSO_BUILD_WITH_VULKAN=ON
-    name: Linux
-    runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: ccache
-        uses: hendrikmuhs/[email protected]
-        with:
-          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}
-          save: false # Caches are created by a separate job and only restored for PRs
-          verbose: 1
-      - name: Configure ccache
-        run: ccache --set-config=sloppiness=pch_defines,time_macros
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-          CCACHE_PATH: /usr/local/bin/ccache
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: ninja -k 20 all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Show CCache statistics
-        run: ccache --show-stats
-      - name: Run Clang Tidy
-        # Clang-tidy reuses the precompiled headers so this only makes sense for the clang compilers
-        if: startsWith(matrix.compiler, 'clang-')
-        run: $GITHUB_WORKSPACE/ci/linux/clang_tidy.sh ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}
-      - name: Process clang-tidy warnings
-        if: startsWith(matrix.compiler, 'clang-')
-        uses: asarium/clang-tidy-action@v1
-        with:
-          fixesFile: clang-fixes.yaml
-
-  build_windows:
-    strategy:
-      matrix:
-        configuration: [Debug, FastDebug, Release]
-        compiler: [MSVC]
-        arch: [Win32, x64]
-    name: Windows
-    runs-on: windows-2025
-    steps:
-      - name: Prepare Environment
-        run: choco install ninja
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: Install v143 ATL/MFC
-        if: matrix.compiler == 'MSVC'
-        shell: pwsh
-        run: ci/windows/install_v143_atlmfc.ps1
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-        shell: bash
-        run: |
-          mkdir build
-          cd build
-
-          if [ "$COMPILER" = "MinGW" ]; then
-              cmake -DFSO_USE_SPEECH=OFF -DFSO_FATAL_WARNINGS=ON -DFSO_USE_VOICEREC=OFF -DFSO_BUILD_TESTS=ON \
-                  -DFSO_BUILD_FRED2=OFF -DQT_USE_PRECOMPILED=ON -DCMAKE_BUILD_TYPE=$CONFIGURATION -G "Ninja" ..
-          else
-              cmake -DFSO_USE_SPEECH=ON -DFSO_FATAL_WARNINGS=ON -DFSO_USE_VOICEREC=OFF -DFSO_BUILD_TESTS=ON \
-                  -DFORCED_SIMD_INSTRUCTIONS=SSE2 -G "Visual Studio 18 2026" -T "v143"  -A "$ARCHITECTURE" \
-                  -DQT_USE_PRECOMPILED=ON -DCMAKE_BUILD_TYPE=$CONFIGURATION ..
-          fi
-      - name: Compile
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          if [ "$COMPILER" = "MinGW" ]; then
-              cmake --build . --config "$CONFIGURATION"
-          else
-              cmake --build . --config "$CONFIGURATION" -- /verbosity:minimal
-          fi
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-        shell: bash
-        run: |
-          if [ "$COMPILER" = "MinGW" ]; then
-             ./bin/unittests --gtest_shuffle
-          else
-              "./bin/$CONFIGURATION/unittests" --gtest_shuffle
-          fi
-
-  build_mac:
-    strategy:
-      matrix:
-        configuration: [Debug, Release]
-        compiler: [clang]
-        arch: [x86_64, arm64]
-        cmake_options: [""]
-    name: Mac
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v7
-        name: Checkout
-        with:
-          submodules: true
-          fetch-depth: 0
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-      - name: ccache
-        uses: hendrikmuhs/[email protected]
-        with:
-          key: ${{ runner.os }}-${{ matrix.configuration }}-${{ matrix.compiler }}-${{ matrix.arch }}
-          save: false # Caches are created by a separate job and only restored for PRs
-      - name: Configure ccache
-        run: ccache --set-config=sloppiness=pch_defines,time_macros
-      - name: Configure CMake
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          COMPILER: ${{ matrix.compiler }}
-          ARCHITECTURE: ${{ matrix.arch }}
-          JOB_CMAKE_OPTIONS: ${{ matrix.cmake_options }}
-          CCACHE_PATH: /usr/local/bin/ccache
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-      - name: Compile
-        working-directory: ./build
-        run: ninja all
-      - name: Run Tests
-        working-directory: ./build
-        env:
-          CONFIGURATION: ${{ matrix.configuration }}
-          ARCH: ${{ matrix.arch }}
-          XDG_RUNTIME_DIR: /root
-        run: $GITHUB_WORKSPACE/ci/linux/run_tests.sh
-      - name: Show CCache statistics
-        run: ccache --show-stats
-      - name: Install clang-tidy
-        # macOS runners don't ship clang-tidy; pin to the same version as the Linux
-        # container's clang-tidy-16 for consistent diagnostics. pyyaml is required
-        # too: clang-tidy-diff.py only accepts -export-fixes when it can import yaml.
-        # --break-system-packages is required since the runner's Homebrew Python
-        # is externally managed (PEP 668); the runner is ephemeral so this is safe.
-        if: startsWith(matrix.compiler, 'clang')
-        run: pip3 install --break-system-packages clang-tidy==16.0.4 pyyaml
-      - name: Run Clang Tidy
-        # Clang-tidy reuses the precompiled headers so this only makes sense for the clang compilers
-        if: startsWith(matrix.compiler, 'clang')
-        env:
-          CLANG_TIDY_BINARY: clang-tidy
-        run: $GITHUB_WORKSPACE/ci/linux/clang_tidy.sh ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}
-      - name: Process clang-tidy warnings
-        if: startsWith(matrix.compiler, 'clang')
-        uses: asarium/clang-tidy-action@v1
-        with:
-          fixesFile: clang-fixes.yaml

.github/workflows/weekly-coverity-scan.yaml

@@ -1,74 +0,0 @@
-name: Weekly Coverity Scan for Freespace Open
-# adapted from code by "albert-github" on the doxygen repository
-# many thanks for figuring this out first so it could be less painful for us!
-
-#This mode is for testing
-#on: [push, pull_request]
-
-# In production, push on a specific schedule
-on:
-  schedule:
-    - cron: "5 0 * * 5" # Run once per a week on Friday morning (midnight UTC, 4 AM EST), to avoid Coverity's submission limits
-
-env:
-  coverity_email: [email protected]
-  coverity_token: ${{ secrets.COVERITY_TOKEN }}
-
-jobs:
-  build:
-    name: Build FSO With Coverity Wrapper
-    if: github.repository == 'scp-fs2open/fs2open.github.com'
-    runs-on: ${{ matrix.config.os }}
-    container: ghcr.io/scp-fs2open/linux_build:sha-ab87451
-    strategy:
-      fail-fast: false
-      matrix:
-        config:
-          - { name: "GCC on ubuntu", os: ubuntu-latest, build_type: "Release" }
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v7
-        with:
-          submodules: recursive # `true` to checkout submodules, `recursive` to recursively checkout submodules
-      - name: Set workspace as safe
-        # This appears to be broken in current actions, so do it manually
-        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
-
-      # pipe results of wget to a log file because it's very verbose and rarely fails
-      - name: Install Coverity
-        run: |
-          wget -o wgetlog.txt -q https://scan.coverity.com/download/cxx/linux64 --post-data "token=${{ env.coverity_token }}&project=scp-fs2open/fs2open.github.com" -O coverity_tool.tgz
-          mkdir cov-scan
-          tar ax -f coverity_tool.tgz --strip-components=1 -C cov-scan
-
-      - name: Setup Environment
-        run: |
-          echo "$(pwd)/cov-scan/bin" >> $GITHUB_PATH
-          echo "NPROC=$(getconf _NPROCESSORS_ONLN)" >> $GITHUB_ENV
-
-      - name: Configure CMake for FSO
-        env:
-          CONFIGURATION: Release
-          COMPILER: gcc-9
-        run: $GITHUB_WORKSPACE/ci/linux/configure_cmake.sh
-
-      - name: Build FSO with Coverity Wrapper
-        working-directory: ./build
-        env:
-          CONFIGURATION: Release
-        run: cov-build --dir cov-int ninja -k 20 all
-
-      - name: Compress Results
-        working-directory: ./build
-        run: tar zcf cov-scan.tgz cov-int
-
-      #Comment this out when testing to keep from running into upload limits
-      - name: Upload to Coverity
-        run: |
-          cd build
-          curl -X POST -d token=${{ env.coverity_token }} -d email=${{ env.coverity_email }} -d file_name="'cov-scan.tgz'" -d version=${{ github.ref }} -d description="Automatic GHA scan" 'https://scan.coverity.com/projects/870/builds/init' | tee response
-          upload_url=$(jq -r '.url' response)
-          build_id=$(jq -r '.build_id' response)
-          curl -X PUT --header 'Content-Type: application/json' --upload-file cov-scan.tgz $upload_url
-          curl -X PUT -d token=${{ env.coverity_token }} https://scan.coverity.com/projects/870/builds/$build_id/enqueue

.gitignore

@@ -1,269 +0,0 @@
-#OS junk files
-[Tt]humbs.db
-*.DS_Store
-
-#Visual Studio files
-*.[Oo]bj
-*.user
-*.aps
-*.pch
-*.vspscc
-*.vssscc
-*_i.c
-*_p.c
-*.ncb
-*.suo
-*.tlb
-*.tlh
-*.bak
-*.[Cc]ache
-*.ilk
-*.log
-*.lib
-*.sbr
-*.sdf
-*.opensdf
-*.unsuccessfulbuild
-ipch/
-[Oo]bj/
-Ankh.NoLoad
-*.VC.db
-*.VC.VC.opendb
-
-#MonoDevelop
-*.pidb
-*.userprefs
-
-#Tooling
-_ReSharper*/
-*.resharper
-[Tt]est[Rr]esult*
-*.sass-cache
-
-#Project files
-[Bb]uild/
-[Oo]ut/
-
-#Subversion files
-.svn
-
-# Office Temp Files
-~$*
-
-# vim Temp Files
-*~
-
-#NuGet
-packages/
-*.nupkg
-
-#ncrunch
-*ncrunch*
-*crunch*.local.xml
-
-# visual studio database projects
-*.dbmdl
-
-#Test files
-*.testsettings
-
-#===========
-
-#########################
-# .gitignore file for Xcode4 and Xcode5 Source projects
-#
-# Apple bugs, waiting for Apple to fix/respond:
-#
-#    15564624 - what does the xccheckout file in Xcode5 do? Where's the documentation?
-#
-# Version 2.1
-# For latest version, see: http://stackoverflow.com/questions/49478/git-ignore-file-for-xcode-projects
-#
-# 2013 updates:
-# - fixed the broken "save personal Schemes"
-# - added line-by-line explanations for EVERYTHING (some were missing)
-#
-# NB: if you are storing "built" products, this WILL NOT WORK,
-# and you should use a different .gitignore (or none at all)
-# This file is for SOURCE projects, where there are many extra
-# files that we want to exclude
-#
-#########################
-
-#####
-# OS X temporary files that should never be committed
-#
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-.DS_Store
-
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-.Trashes
-
-# c.f. http://www.westwind.com/reference/os-x/invisibles.html
-
-*.swp
-
-# *.lock - this is used and abused by many editors for many different things.
-#    For the main ones I use (e.g. Eclipse), it should be excluded
-#    from source-control, but YMMV
-
-*.lock
-
-#
-# profile - REMOVED temporarily (on double-checking, this seems incorrect; I can't find it in OS X docs?)
-#profile
-
-
-####
-# Xcode temporary files that should never be committed
-#
-# NB: NIB/XIB files still exist even on Storyboard projects, so we want this...
-
-*~.nib
-
-
-####
-# Xcode build files -
-#
-# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "DerivedData"
-
-DerivedData/
-
-# NB: slash on the end, so we only remove the FOLDER, not any files that were badly named "build"
-
-build/
-
-
-#####
-# Xcode private settings (window sizes, bookmarks, breakpoints, custom executables, smart groups)
-#
-# This is complicated:
-#
-# SOMETIMES you need to put this file in version control.
-# Apple designed it poorly - if you use "custom executables", they are
-#  saved in this file.
-# 99% of projects do NOT use those, so they do NOT want to version control this file.
-#  ..but if you're in the 1%, comment out the line "*.pbxuser"
-
-# .pbxuser: http://lists.apple.com/archives/xcode-users/2004/Jan/msg00193.html
-
-*.pbxuser
-
-# .mode1v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
-
-*.mode1v3
-
-# .mode2v3: http://lists.apple.com/archives/xcode-users/2007/Oct/msg00465.html
-
-*.mode2v3
-
-# .perspectivev3: http://stackoverflow.com/questions/5223297/xcode-projects-what-is-a-perspectivev3-file
-
-*.perspectivev3
-
-#    NB: also, whitelist the default ones, some projects need to use these
-!default.pbxuser
-!default.mode1v3
-!default.mode2v3
-!default.perspectivev3
-
-
-####
-# Xcode 4 - semi-personal settings
-#
-#
-# OPTION 1: ---------------------------------
-#     throw away ALL personal settings (including custom schemes!
-#     - unless they are "shared")
-#
-# NB: this is exclusive with OPTION 2 below
-xcuserdata
-
-# OPTION 2: ---------------------------------
-#     get rid of ALL personal settings, but KEEP SOME OF THEM
-#     - NB: you must manually uncomment the bits you want to keep
-#
-# NB: this *requires* git v1.8.2 or above; you may need to upgrade to latest OS X,
-#    or manually install git over the top of the OS X version
-# NB: this is exclusive with OPTION 1 above
-#
-#xcuserdata/**/*
-
-#     (requires option 2 above): Personal Schemes
-#
-#!xcuserdata/**/xcschemes/*
-
-####
-# XCode 4 workspaces - more detailed
-#
-# Workspaces are important! They are a core feature of Xcode - don't exclude them :)
-#
-# Workspace layout is quite spammy. For reference:
-#
-# /(root)/
-#   /(project-name).xcodeproj/
-#     project.pbxproj
-#     /project.xcworkspace/
-#       contents.xcworkspacedata
-#       /xcuserdata/
-#         /(your name)/xcuserdatad/
-#           UserInterfaceState.xcuserstate
-#     /xcsshareddata/
-#       /xcschemes/
-#         (shared scheme name).xcscheme
-#     /xcuserdata/
-#       /(your name)/xcuserdatad/
-#         (private scheme).xcscheme
-#         xcschememanagement.plist
-#
-#
-
-####
-# Xcode 4 - Deprecated classes
-#
-# Allegedly, if you manually "deprecate" your classes, they get moved here.
-#
-# We're using source-control, so this is a "feature" that we do not want!
-
-*.moved-aside
-
-# .xccheckout
-#
-# Per http://stackoverflow.com/questions/18340453/should-xccheckout-files-in-xcode5-be-ignored-under-vcs
-#
-
-*.xccheckout
-
-####
-# Visual Studio Code
-.vscode
-
-####
-# Documentation
-#
-documentation/doxygen/*
-!documentation/doxygen/.gitkeep
-
-
-.idea/*
-projects/*
-/.vs
-CMakeSettings.json
-CMakePresets.json
-
-# Weird files created by Linux
-.fuse_hidden*
-
-# This gets ignored by one of the rules above for some reason...
-!/code/scripting/lua/LuaConvert.h
-!/code/debugconsole/
-!/docker/build
-CMakeFiles/cmake.check_cache
-CMakeCache.txt
-
-# Written by the unittests binary at runtime
-test/test_data/**/*_settings.ini
-test/test_data/data/players/presets/asdf.json
-test/test_data/pilotfile/data/asdf.hdp

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "lib/libRocket"]
-	path = lib/libRocket
-	url = https://github.com/scp-fs2open/libRocket.git

AUTHORS

@@ -0,0 +1,29 @@
+Original source (Freespace 2) by Volition, Inc.; see "credits.tbl"
+
+Modifications by the FreeSpace Source Code Project (FSSCP)
+http://fs2source.warpcore.org
+
+FS2_OPEN STAFF:
+
+Project leader:
+Edward "Inquisitor" Gardner
+
+Programmers:
+"Bobboau"
+Dennis "DTP" Pedersen
+Ian "Goober5000" Warfield
+Joe "Righteous1" Dowd
+Mike "penguin" Harris
+"Mysterial"
+"PhReAk"
+Thomas "Random Tiger" Whittaker
+Will "Unknown PLayer" Rousnel
+"WMCoolmon"
+
+Web support:
+Icefire and the staff at Volitionwatch.com
+Alex "Thunder" Avery and the staff at Hard Light Productions
+
+Special thanks to:
+Volition for making FS2 such a great game
+Dave Baranec for giving us the code and keeping us sanity checked

About.md

@@ -1,41 +0,0 @@
-## FreeSpace
-FreeSpace: The Great War (Released 1998) and FreeSpace 2 (1999) are mission-based space combat simulators, like X-Wing/TIE Fighter and Wing Commander. Among the greatest games of the genre, they were also effectively the last.
-
-The FreeSpace series follows humanity and their Vasudan allies as they fight to withstand the xenocidal, enigmatic Shivans, a species of unknown origin, vast technological capability, and seemingly limitless malice.
-
-## FreeSpace Open
-Thanks to Volition's generosity, we've continued development of FreeSpace 2 as FreeSpace Open, building graphical enhancements to bring the original games up to modern standards, telling new stories set in the FreeSpace universe and original worlds, and creating spectacular total conversions that let players fly in the beloved universes of Babylon 5, Battlestar Galactica, Wing Commander, and Star Wars.
-
-## Hard-Light Productions
-HLP is a fan community built on love and open-source code. We're dedicated to bringing modders together and giving them a place to share their own hard work and draw inspiration from the work of others. Thanks to Volition's generosity, we've continued development of FreeSpace 2 as FreeSpace Open, building graphical enhancements to bring the original games up to modern standards, telling new stories set in the FreeSpace universe and original worlds, and creating spectacular total conversions that let players fly in the beloved universes of Babylon 5, Battlestar Galactica, Wing Commander, and Star Wars.
-Find us at:
- - Our [website](http://www.hard-light.net/) and [forums](http://www.hard-light.net/forums/)
- - [Discord](https://discord.gg/YNVP3WR)
- - [Facebook](https://www.facebook.com/groups/Hardlightproductions/)
- - [Youtube](https://www.youtube.com/channel/UCxKkd609hDtY6yNetR1iT4w)
- - [Reddit](https://www.reddit.com/r/freespace/)
- - [Twitter](https://twitter.com/hardlightpro)
- - [IRC](irc://irc.esper.net/hard-light)
-
-
-## How to get the game
-FreeSpace Open requires a retail installation of FreeSpace 2, which is available at the following stores: 
- - [GOG.com](https://www.gog.com/game/freespace_2)
- - [Steam](https://store.steampowered.com/app/273620/Freespace_2/)  
-After installing retail FS2, use [Knossos](https://fsnebula.org/knossos/) to upgrade to the most recent release of FSO. Knossos is an advanced mod manager and launcher for FSO.
-
-## Improvements
-The new open source game engine has several distingushing features including:
- - Linux and Mac OS X support
- - OpenGL support
- - OpenAL audio support
- - Easy mod installation
- - OGG support
- - Hardware transform, clipping, and lighting
-
-## The FreeSpace Upgrade Project
-While the SCP improves the code of the game engine to enable new and exciting features, the FreeSpace Upgrade Project (FSU) creates material that takes advantage of the improved game engine.  
-The FSU improves the ships, effects, and background elements of FreeSpace 2. Every now and then these improvements are released as a pack called MediaVPs. These assorted improvements enhance the graphics of the game.  
-While the best way to experience the FSU is by playing the game with it, you can watch this [comparison video](https://www.youtube.com/watch?v=RM1YC_gK-qo) between 1999 and 2019 to have an idea of how much more beautiful FSU makes the game.
-
-^(Much of this content was pulled from existing sources, such as InsaneBaron's "What Is Hard Light Productions" [thread](https://www.hard-light.net/forums/index.php?topic=86650.0), the Wiki's [Getting Started article](https://wiki.hard-light.net/index.php/Getting_started) and more.) 

Authors.md

@@ -1,8 +0,0 @@
-Original source (Freespace 2) by Volition, Inc.; see "`credits.tbl`"
-
-Modifications by the FreeSpace 2 Source Code Project [(FSO SCP)](https://www.hard-light.net/forums/index.php?board=50.0)   
-[Project Contributors](https://github.com/scp-fs2open/fs2open.github.com/graphs/contributors)
-
-Special thanks to:
-Volition for making FS2 such a great game
-Dave Baranec for giving us the code and keeping us sanity checked

CMakeLists.txt

@@ -1,283 +0,0 @@
-
-CMAKE_MINIMUM_REQUIRED(VERSION 3.21)
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-
-# Make sure the source and binary directory are not the sample
-if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
-	message(FATAL_ERROR "Binary and source directory can not be the same! Choose another build directory.")
-endif()
-
-include(cmake/util.cmake)
-
-# Set a few policies
-set_policy(CMP0051 NEW)
-set_policy(CMP0053 NEW)
-set_policy(CMP0054 NEW)
-set_policy(CMP0091 NEW) # Enable use of CMAKE_MSVC_RUNTIME_LIBRARY
-
-SET(FSO_PROJECT_DESCRIPTION "Open source project based on the original FreeSpace 2 source code.")
-
-SET(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin CACHE PATH "Executable output path")
-SET(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin CACHE PATH "Library output path")
-
-# CMAKE_INSTALL_PREFIX is defined but also overwritten by the PROJECT command so we need to set it later
-IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
-	SET(RESET_INSTALL_PREFIX TRUE)
-ENDIF(NOT DEFINED CMAKE_INSTALL_PREFIX)
-
-# Reset this variable
-SET(TARGET_COPY_FILES "" CACHE INTERNAL "" FORCE)
-SET(TARGET_COPY_DIRS "" CACHE INTERNAL "" FORCE)
-
-get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-
-# Override standard CMake configurations
-set(FSO_BUILD_TYPES Debug Release FastDebug)
-
-if(is_multi_config)
-	set(CMAKE_CONFIGURATION_TYPES "${FSO_BUILD_TYPES}" CACHE STRING "Configuration types" FORCE)
-elseif(NOT CMAKE_BUILD_TYPE)
-	set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Default build configuration used." FORCE)
-	message(WARNING "CMAKE_BUILD_TYPE was not specified, defaulting to Release configuration.")
-	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "${FSO_BUILD_TYPES}")
-endif()
-
-set(FSO_LANGUAGES C CXX)
-
-if(APPLE)
-	set(FSO_LANGUAGES ${FSO_LANGUAGES} OBJC OBJCXX)
-
-	# 10.15 for c++17 std::filesystem
-	# NOTE: this must be set *before* the project() call to work properly!!
-	set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15" CACHE STRING "macOS deployment target")
-
-	# fix all targets in scheme (so it's not just qtfred)
-	set(CMAKE_XCODE_GENERATE_SCHEME TRUE)
-endif()
-
-PROJECT(FS2_Open LANGUAGES ${FSO_LANGUAGES})
-
-if (ANDROID)
-    message(STATUS "Building for Android (NDK)")
-	set(FSO_BUILD_INCLUDED_LIBS ON CACHE BOOL "" FORCE)
-	set(USING_PREBUILT_LIBS ON CACHE BOOL "" FORCE)
-	set(SDL3_USE_PRECOMPILED ON CACHE BOOL "" FORCE)
-	set(OPENAL_USE_PRECOMPILED ON CACHE BOOL "" FORCE)
-	set(USING_PREBUILT_VULKAN ON CACHE BOOL "" FORCE)
-endif()
-
-# Check if the external modules exists
-IF(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lib/libRocket/Build")
-	message(FATAL_ERROR "External submodules could not be found. Please make sure you have updated your submodules.")
-endif()
-
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-LIST(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/finder")
-
-# this must be set before include(toolchain)
-if(WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 4)
-	set(FSO_BUILD_QTFRED OFF CACHE INTERNAL "" FORCE)
-else()
-	OPTION(FSO_BUILD_QTFRED "Build qtFRED2 binary" ON)
-endif()
-
-INCLUDE(globals)
-INCLUDE(toolchain)
-include(embed_file)
-
-IF(RESET_INSTALL_PREFIX)
-	IF(NOT $ENV{FS2PATH} STREQUAL "")
-		IF(NOT IS_DIRECTORY $ENV{FS2PATH})
-			MESSAGE(WARNING "The path '$ENV{FS2PATH}' of the environment variable FS2PATH does not point to a directory! Install prefix wasn't set.")
-		ELSE(NOT IS_DIRECTORY $ENV{FS2PATH})
-			SET(CMAKE_INSTALL_PREFIX "$ENV{FS2PATH}" CACHE PATH "Install path" FORCE)
-			FILE(TO_CMAKE_PATH ${CMAKE_INSTALL_PREFIX} CMAKE_INSTALL_PREFIX)
-		ENDIF(NOT IS_DIRECTORY $ENV{FS2PATH})
-	ELSE(NOT $ENV{FS2PATH} STREQUAL "")
-		MESSAGE(STATUS "NO FS2PATH environment variable found, you can define this to point to your freespace install but it is not required.")
-	ENDIF(NOT $ENV{FS2PATH} STREQUAL "")
-ENDIF(RESET_INSTALL_PREFIX)
-
-IF(WIN32 OR APPLE OR ANDROID OR CMAKE_SYSTEM_NAME STREQUAL "Linux")
-	OPTION(FSO_USE_SPEECH "Use text-to-speach libraries" ON)
-ELSE()
-	OPTION(FSO_USE_SPEECH "Use text-to-speach libraries" OFF)
-ENDIF()
-
-IF (WIN32)
-	OPTION(FSO_USE_VOICEREC "Enable voice recognition support" ON)
-
-	OPTION(FSO_BUILD_FRED2 "Build FRED2 binary" ON)
-elseif(UNIX)
-	option(FSO_BUILD_APPIMAGE "Build an AppImage package" OFF)
-ENDIF(WIN32)
-
-OPTION(FSO_BUILD_TOOLS "Build tools related to FSO" OFF)
-
-OPTION(FSO_BUILD_TESTS "Build unit tests" OFF)
-
-OPTION(FSO_DEVELOPMENT_MODE "Generate binaries in development mode, only use if you know what you're doing!" OFF)
-
-IF(WIN32 OR APPLE OR ANDROID)
-	# On windows, mac and android the default should be to always build the included libraries
-	SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT ON)
-ELSE()
-	SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT OFF)
-ENDIF()
-
-OPTION(FSO_BUILD_INCLUDED_LIBS "Build and use the included libraries istead of using the system headers and libraries" ${FSO_BUILD_INCLUDED_LIBS_DEFAULT})
-
-OPTION(FSO_USE_LUAJIT "Use LuaJIT for Lua scripting, needs a working internet connection!" OFF)
-
-OPTION(FSO_USE_OPENALSOFT "Download and build OpenAL Soft instead of using the system libraries" OFF)
-
-OPTION(FSO_FATAL_WARNINGS "Determines if warnings in the build are considered fatal errors, primarily used for CI" OFF)
-
-SET(FSO_FREESPACE_PATH "${CMAKE_INSTALL_PREFIX}" CACHE PATH "The path of the FreeSpace directory you want to use. Please note that you will have to change CMAKE_INSTALL_PREFIX if you change this at some point.")
-
-SET(FSO_RUN_ARGUMENTS "" CACHE STRING "Additional arguments passed to a generated executable when run with the generated build files.")
-
-option(FSO_INSTALL_DEBUG_FILES "Install some debug files (currently only PDB files on windows)" OFF)
-
-option(FSO_RELEASE_LOGGING "Enable logging output for release builds" OFF)
-
-OPTION(FSO_BUILD_WITH_FFMPEG "Enable the usage of FFmpeg for sound and custscenes" ON)
-
-OPTION(FSO_BUILD_WITH_DISCORD "Build with Discord support" ON)
-
-OPTION(FSO_BUILD_WITH_OPENGL "Enable compilation of the OpenGL renderer" ON)
-OPTION(FSO_BUILD_WITH_OPENGL_DEBUG "Enables debug option for OpenGL" OFF)
-OPTION(FSO_BUILD_WITH_OPENGL_ES "When building OpenGL, use OpenGL ES compatibility layer" OFF)
-
-OPTION(FSO_BUILD_WITH_VULKAN "Enable compilation of the Vulkan renderer" ON)
-
-if(NOT FSO_BUILD_WITH_OPENGL AND FSO_BUILD_WITH_OPENGL_ES)
-	# Disable GLES if not building with OpenGL
-	set(FSO_BUILD_WITH_OPENGL_ES OFF CACHE BOOL "" FORCE)
-endif()
-
-
-if(FSO_BUILD_WITH_OPENGL_ES)
-	add_definitions(-DUSE_OPENGL_ES)
-	IF(FSO_BUILD_WITH_OPENXR)
-		MESSAGE(WARNING "FSO_BUILD_WITH_OPENXR is ON. But not supported on OpenGL ES for now - setting to OFF.")
-		SET(FSO_BUILD_WITH_OPENXR OFF CACHE BOOL "" FORCE)
-	endif()
-endif()
-
-IF(NOT APPLE AND NOT FSO_BUILD_WITH_OPENGL_ES)
-	SET(OPENXR_BUILD_DEFAULT ON)
-ELSE()
-	SET(OPENXR_BUILD_DEFAULT OFF)
-ENDIF()
-OPTION(FSO_BUILD_WITH_OPENXR "Build with OpenXR support" ${OPENXR_BUILD_DEFAULT})
-IF(FSO_BUILD_WITH_OPENXR AND APPLE)
-	MESSAGE(WARNING "FSO_BUILD_WITH_OPENXR is ON. Not supported on macOS - setting to OFF.")
-	SET(FSO_BUILD_WITH_OPENXR OFF CACHE BOOL "" FORCE)
-ENDIF()
-
-OPTION(FSO_BUILD_WITH_OPENXR_DEBUG "Enables debug option for OpenXR" OFF)
-
-OPTION(FSO_USE_LTO "Build using LTO (only for release builds)" ON)
-
-MARK_AS_ADVANCED(FORCE FSO_CMAKE_DEBUG)
-MARK_AS_ADVANCED(FORCE FSO_BUILD_INCLUDED_LIBS)
-MARK_AS_ADVANCED(FORCE FSO_USE_OPENALSOFT)
-MARK_AS_ADVANCED(FORCE FSO_USE_LUAJIT)
-MARK_AS_ADVANCED(FORCE FSO_DEVELOPMENT_MODE)
-MARK_AS_ADVANCED(FORCE FSO_FATAL_WARNINGS)
-mark_as_advanced(FORCE FSO_INSTALL_DEBUG_FILES)
-mark_as_advanced(FORCE FSO_RELEASE_LOGGING)
-mark_as_advanced(FORCE FSO_BUILD_WITH_FFMPEG)
-mark_as_advanced(FORCE FSO_BUILD_WITH_DISCORD)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL_DEBUG)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENGL_ES)
-mark_as_advanced(FORCE FSO_BUILD_WITH_VULKAN)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENXR)
-mark_as_advanced(FORCE FSO_BUILD_WITH_OPENXR_DEBUG)
-
-INCLUDE(platforms)
-include(version)
-
-INCLUDE(headers)
-
-SET(GENERATED_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/generated_source)
-
-include(generateHeaders)
-
-if(FSO_BUILD_APPIMAGE)
-	SET(BINARY_DESTINATION "bin")
-	SET(LIBRAY_DESTINATION "lib")
-endif()
-
-include(clang-tidy)
-
-include(CheckIPOSupported)
-check_ipo_supported(RESULT LTO_AVAILABLE)
-if (FSO_USE_LTO AND LTO_AVAILABLE)
-	set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
-	message("Enabled LTO for Release builds")
-	set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
-endif (FSO_USE_LTO AND LTO_AVAILABLE)
-
-# This includes source code for some tools, either used in the build or also for something else
-ADD_SUBDIRECTORY(tools)
-
-ADD_SUBDIRECTORY(lib)
-
-ADD_SUBDIRECTORY(parsers)
-
-ADD_SUBDIRECTORY(code)
-
-ADD_SUBDIRECTORY(freespace2)
-
-IF(FSO_BUILD_FRED2)
-	ADD_SUBDIRECTORY(fred2)
-ENDIF(FSO_BUILD_FRED2)
-
-IF(FSO_BUILD_QTFRED)
-	ADD_SUBDIRECTORY(qtfred)
-ENDIF()
-
-if(FSO_BUILD_TESTS)
-	add_subdirectory(test)
-endif()
-
-if ("${CMAKE_VERSION}" VERSION_GREATER "3.5")
-	# Default to using Freespace2 as startup project if CMake supports it.
-	set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT Freespace2)
-endif()
-
-IF(MSVC_USE_RUNTIME_DLL)
-	SET(CMAKE_INSTALL_SYSTEM_RUNTIME_DESTINATION "${BINARY_DESTINATION}")
-
-	IF(FSO_BUILD_FRED2)
-		SET(CMAKE_INSTALL_MFC_LIBRARIES ON)
-	ENDIF(FSO_BUILD_FRED2)
-
-	INCLUDE(InstallRequiredSystemLibraries)
-ENDIF(MSVC_USE_RUNTIME_DLL)
-
-include(package)
-
-include(doxygen)
-
-# Print used options to log
-message(STATUS "Using text to speech: ${FSO_USE_SPEECH}")
-IF (WIN32)
-	message(STATUS "Using voice recogition: ${FSO_USE_VOICEREC}")
-	message(STATUS "Building FRED2: ${FSO_BUILD_FRED2}")
-elseif(UNIX)
-	message(STATUS "Building AppImage: ${FSO_BUILD_APPIMAGE}")
-ENDIF()
-message(STATUS "Building FSO tools: ${FSO_BUILD_TOOLS}")
-message(STATUS "Building qtFRED: ${FSO_BUILD_QTFRED}")
-message(STATUS "Fatal warnings: ${FSO_FATAL_WARNINGS}")
-message(STATUS "Release logging: ${FSO_RELEASE_LOGGING}")
-message(STATUS "With FFmpeg: ${FSO_BUILD_WITH_FFMPEG}")
-message(STATUS "With Discord: ${FSO_BUILD_WITH_DISCORD}")
-message(STATUS "With OpenGL: ${FSO_BUILD_WITH_OPENGL}")
-message(STATUS "With OpenGL ES: ${FSO_BUILD_WITH_OPENGL_ES}")
-message(STATUS "With Vulkan: ${FSO_BUILD_WITH_VULKAN}")
-message(STATUS "With OpenXR: ${FSO_BUILD_WITH_OPENXR}")

COPYING

@@ -0,0 +1,14 @@
+Volition Copyright (applies to original FreeSpace2 source code
+developed and released by Volition):
+
+"Copyright (C) Volition, Inc. 1999.  All rights reserved.
+
+All source code herein is the property of Volition, Inc. You may not
+sell or otherwise commercially exploit the source or things you
+created based on the source."
+
+
+Modifications by members of the FreeSpace Source Code Project are
+released under whatever terms the individual authors choose, but the
+above notice continues to apply to all fs2_open code.
+

Copying.md

@@ -1,22 +0,0 @@
-Volition Copyright (applies to original FreeSpace2 source code
-developed and released by Volition):
-
->Copyright (C) Volition, Inc. 1999.  All rights reserved.
->
->All source code herein is the property of Volition, Inc. You may not
-sell or otherwise commercially exploit the source or things you
-created based on the source.
-
-
-Modifications by members of the FreeSpace Source Code Project are
-released under whatever terms the individual authors choose, but the
-above notice continues to apply to all fs2_open code.
-
-All modifications made on or after November 1, 2020, shall be released under 
-the terms within [Unlicense](Unlicense.md). Modifications made before said date are released 
-under the previous terms with the exception of modifications made by members 
-of the FreeSpace Source Code Project that opt-in to the terms of Unlicense. Additionally, 
-a list of contributors who have opted in to the Unlicense terms can be found 
-in [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing).
-
-See [**Licensing**](https://github.com/scp-fs2open/fs2open.github.com/wiki/Licensing) for more information.

INSTALL

@@ -0,0 +1,29 @@
+This is still in pretty rough form.
+
+
+=== for people building fs2_open:
+
+Win32-MSVC:
+Use the Freespace2.dsw workspace and build within the IDE.
+
+
+Win32-MinGW:
+  make
+
+
+Linux and other unix variants (NOT YET COMPLETE)
+  ./configure [options]
+  make
+
+
+
+=== for the project maintainers (people who need to 
+=== keep the makefiles up to date) and those building
+=== from CVS:
+
+./autogen.sh (should only has to be done once)
+./configure [options]
+make
+
+automake v1.6.1+ and
+autoconf v2.54+ are required

Makefile.am

@@ -0,0 +1,77 @@
+# Makefile.am for fs2_open (top level)
+#
+# This file uses GNU Automake to generate makefiles
+
+SUBDIRS = libjpeg lua code
+
+
+EXTRA_DIST =	\
+	FS2OpenSCPReadMe.doc	\
+	projects/MSVC_2005/Freespace2.sln	\
+	projects/MSVC_2005/Freespace2.vcproj	\
+	projects/MSVC_2005/code.vcproj	\
+	projects/MSVC_6/Fred2.dsp	\
+	projects/MSVC_6/Freespace2.dsp	\
+	projects/MSVC_6/Freespace2.dsw	\
+	projects/MSVC_6/code.dsp	\
+	projects/MSVC_6/libjpeg.dsp	\
+	projects/MSVC_6/liblua.dsp	\
+	projects/MSVC_6/wxFRED2.dsp	\
+	projects/Xcode/English.lproj/InfoPlist.strings	\
+	projects/Xcode/FS2_Open.icns	\
+	projects/Xcode/FS2_Open.xcodeproj/project.pbxproj	\
+	projects/Xcode/Frameworks.tgz	\
+	projects/Xcode/Info-debug.plist	\
+	projects/Xcode/Info.plist	\
+	projects/Xcode/README.Xcode	\
+	projects/Xcode/SDLMain.h	\
+	projects/Xcode/SDLMain.m
+
+
+# D_ variants are defaults and should always be used
+AM_CXXFLAGS = -I./code @D_CFLAGS@
+AM_LDFLAGS = @D_LDFLAGS@
+
+EXTRA_PROGRAMS = cfilearchiver cfileextractor cryptstring scramble
+
+###############################################################################
+##
+## Begin utilitites
+##
+
+# cfilearchiver -- to create VPs
+cfilearchiver_SOURCES =	\
+	code/cfilearchiver/cfilearchiver.cpp
+
+# cfileextractor -- to extract files from VPs
+cfileextractor_SOURCES = \
+	code/cfileextractor/cfileextractor.cpp
+
+# cryptstring -- to encrypt strings that are used as cheat codes
+cryptstring_SOURCES =	\
+	code/cryptstring/cryptstring.cpp
+
+# scramble -- to encrypt tables
+scramble_SOURCES =	\
+	code/parse/encrypt.cpp	\
+	code/scramble/scramble.cpp	\
+	code/scramble/scramble.h
+
+
+# catch all to build utilitites
+tools: cfilearchiver cfileextractor cryptstring scramble
+
+
+# cleaning
+clean-tools:
+	-test -z "$(EXTRA_PROGRAMS)" || rm -f $(EXTRA_PROGRAMS)
+
+##
+## End utilitites
+##
+###############################################################################
+
+
+# make sure we get this stuff cleaned up
+clean-generic: clean-tools
+

README

@@ -0,0 +1,8 @@
+The "projects" directory contains ready projects for:
+Microsoft Visual C++ 6
+Microsoft Visual C++ 2005
+Anjuta 1 (please see README with project before using)
+
+
+See the ChangeLog to see what's new.
+See the INSTALL file for instructions on how to build fs2_open.

Readme.md

@@ -1,9 +0,0 @@
-FreeSpace2 *S*ource *C*ode *P*roject
-==
-[![Coverity](https://img.shields.io/coverity/scan/870.svg)](https://scan.coverity.com/projects/870)
-
-Building
---
-Before you do anything, make sure you have updated your git submodules, either by running `git submodule update --init --recursive` or by cloning the repository with the `--recursive` flag.<br/>
-
-The main instructions for building can be found at our github wiki, on the [Building](https://github.com/scp-fs2open/fs2open.github.com/wiki/Building) page.

Unlicense.md

@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS 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 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 SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to [**Unlicense**](https://unlicense.org).

UpdatingDocumentation.md

@@ -1,18 +0,0 @@
-#Updating Documentation
-####The goal of this file is simply to offer a comprehensive checklist of things we must check when updating the documentation.
-
-1. Changelog: 
- - Is [Changelog.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Changelog.md) up-to-date with the latest release?
- - Is it in the proper [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format? 
-2. Build instructions:  
- - If a programmer who never built FSO before read the build instruction at [Readme.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Readme.md), would they manage to build FSO? 
- - Is the information in the file up-to-date regarding other matters (such as versions of tools mentioned, links to other guides, etc.)?
- - Is the information in the [Building](https://github.com/scp-fs2open/fs2open.github.com/wiki/Building) article, and its sub-articles, still up-to-date?
-3. Forums: 
- - Does the [Forum](https://www.hard-light.net/forums/index.php?board=50.0) contain enough clear information to help a new developer find their way into the up-to-date instructions?
- - Is there anything that might mislead a new developer to stumble onto old tools, dead links and/or old versions of the project?
-4. General documentation files: 
- - Is the information in the following files up-to-date? 
-   - [About.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/About.md) (Should contain general information about FS, FS2, HLP, FSO and FSU)
-   - [Authors.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Authors.md) (Should contain information about the original developers, a way to see FSO's contributors, and special thanks to Volition and Dave Baranec)
-   - [Copying.md](https://github.com/scp-fs2open/fs2open.github.com/blob/master/Copying.md) (Should contain Volition's Copyright terms and a way to check FSO's Licensing info)

acinclude.m4

@@ -0,0 +1,714 @@
+# Configure paths for SDL
+# Sam Lantinga 9/21/99
+# stolen from Manish Singh
+# stolen back from Frank Belew
+# stolen from Manish Singh
+# Shamelessly stolen from Owen Taylor
+
+dnl AM_PATH_SDL([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
+dnl Test for SDL, and define SDL_CFLAGS and SDL_LIBS
+dnl
+AC_DEFUN([AM_PATH_SDL],
+[dnl 
+dnl Get the cflags and libraries from the sdl-config script
+dnl
+AC_ARG_WITH(sdl-prefix,[  --with-sdl-prefix=PFX   Prefix where SDL is installed (optional)],
+            sdl_prefix="$withval", sdl_prefix="")
+AC_ARG_WITH(sdl-exec-prefix,[  --with-sdl-exec-prefix=PFX Exec prefix where SDL is installed (optional)],
+            sdl_exec_prefix="$withval", sdl_exec_prefix="")
+AC_ARG_ENABLE(sdltest, [  --disable-sdltest       Do not try to compile and run a test SDL program],
+		    , enable_sdltest=yes)
+
+  if test x$sdl_exec_prefix != x ; then
+     sdl_args="$sdl_args --exec-prefix=$sdl_exec_prefix"
+     if test x${SDL_CONFIG+set} != xset ; then
+        SDL_CONFIG=$sdl_exec_prefix/bin/sdl-config
+     fi
+  fi
+  if test x$sdl_prefix != x ; then
+     sdl_args="$sdl_args --prefix=$sdl_prefix"
+     if test x${SDL_CONFIG+set} != xset ; then
+        SDL_CONFIG=$sdl_prefix/bin/sdl-config
+     fi
+  fi
+
+  AC_REQUIRE([AC_CANONICAL_TARGET])
+  PATH="$prefix/bin:$prefix/usr/bin:$PATH"
+  AC_PATH_PROG(SDL_CONFIG, sdl-config, no, [$PATH])
+  min_sdl_version=ifelse([$1], ,0.11.0,$1)
+  AC_MSG_CHECKING(for SDL - version >= $min_sdl_version)
+  no_sdl=""
+  if test "$SDL_CONFIG" = "no" ; then
+    no_sdl=yes
+  else
+    SDL_CFLAGS=`$SDL_CONFIG $sdlconf_args --cflags`
+    SDL_LIBS=`$SDL_CONFIG $sdlconf_args --libs`
+
+    sdl_major_version=`$SDL_CONFIG $sdl_args --version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
+    sdl_minor_version=`$SDL_CONFIG $sdl_args --version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
+    sdl_micro_version=`$SDL_CONFIG $sdl_config_args --version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
+    if test "x$enable_sdltest" = "xyes" ; then
+      ac_save_CFLAGS="$CFLAGS"
+      ac_save_CXXFLAGS="$CXXFLAGS"
+      ac_save_LIBS="$LIBS"
+      CFLAGS="$CFLAGS $SDL_CFLAGS"
+      CXXFLAGS="$CXXFLAGS $SDL_CFLAGS"
+      LIBS="$LIBS $SDL_LIBS"
+dnl
+dnl Now check if the installed SDL is sufficiently new. (Also sanity
+dnl checks the results of sdl-config to some extent
+dnl
+      rm -f conf.sdltest
+      AC_TRY_RUN([
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "SDL.h"
+
+char*
+my_strdup (char *str)
+{
+  char *new_str;
+  
+  if (str)
+    {
+      new_str = (char *)malloc ((strlen (str) + 1) * sizeof(char));
+      strcpy (new_str, str);
+    }
+  else
+    new_str = NULL;
+  
+  return new_str;
+}
+
+int main (int argc, char *argv[])
+{
+  int major, minor, micro;
+  char *tmp_version;
+
+  /* This hangs on some systems (?)
+  system ("touch conf.sdltest");
+  */
+  { FILE *fp = fopen("conf.sdltest", "a"); if ( fp ) fclose(fp); }
+
+  /* HP/UX 9 (%@#!) writes to sscanf strings */
+  tmp_version = my_strdup("$min_sdl_version");
+  if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, &micro) != 3) {
+     printf("%s, bad version string\n", "$min_sdl_version");
+     exit(1);
+   }
+
+   if (($sdl_major_version > major) ||
+      (($sdl_major_version == major) && ($sdl_minor_version > minor)) ||
+      (($sdl_major_version == major) && ($sdl_minor_version == minor) && ($sdl_micro_version >= micro)))
+    {
+      return 0;
+    }
+  else
+    {
+      printf("\n*** 'sdl-config --version' returned %d.%d.%d, but the minimum version\n", $sdl_major_version, $sdl_minor_version, $sdl_micro_version);
+      printf("*** of SDL required is %d.%d.%d. If sdl-config is correct, then it is\n", major, minor, micro);
+      printf("*** best to upgrade to the required version.\n");
+      printf("*** If sdl-config was wrong, set the environment variable SDL_CONFIG\n");
+      printf("*** to point to the correct copy of sdl-config, and remove the file\n");
+      printf("*** config.cache before re-running configure\n");
+      return 1;
+    }
+}
+
+],, no_sdl=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+       CFLAGS="$ac_save_CFLAGS"
+       CXXFLAGS="$ac_save_CXXFLAGS"
+       LIBS="$ac_save_LIBS"
+     fi
+  fi
+  if test "x$no_sdl" = x ; then
+     AC_MSG_RESULT(yes)
+     ifelse([$2], , :, [$2])     
+  else
+     AC_MSG_RESULT(no)
+     if test "$SDL_CONFIG" = "no" ; then
+       echo "*** The sdl-config script installed by SDL could not be found"
+       echo "*** If SDL was installed in PREFIX, make sure PREFIX/bin is in"
+       echo "*** your path, or set the SDL_CONFIG environment variable to the"
+       echo "*** full path to sdl-config."
+     else
+       if test -f conf.sdltest ; then
+        :
+       else
+          echo "*** Could not run SDL test program, checking why..."
+          CFLAGS="$CFLAGS $SDL_CFLAGS"
+          CXXFLAGS="$CXXFLAGS $SDL_CFLAGS"
+          LIBS="$LIBS $SDL_LIBS"
+          AC_TRY_LINK([
+#include <stdio.h>
+#include "SDL.h"
+
+int main(int argc, char *argv[])
+{ return 0; }
+#undef  main
+#define main K_and_R_C_main
+],      [ return 0; ],
+        [ echo "*** The test program compiled, but did not run. This usually means"
+          echo "*** that the run-time linker is not finding SDL or finding the wrong"
+          echo "*** version of SDL. If it is not finding SDL, you'll need to set your"
+          echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"
+          echo "*** to the installed location  Also, make sure you have run ldconfig if that"
+          echo "*** is required on your system"
+	  echo "***"
+          echo "*** If you have an old version installed, it is best to remove it, although"
+          echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"],
+        [ echo "*** The test program failed to compile or link. See the file config.log for the"
+          echo "*** exact error that occured. This usually means SDL was incorrectly installed"
+          echo "*** or that you have moved SDL since it was installed. In the latter case, you"
+          echo "*** may want to edit the sdl-config script: $SDL_CONFIG" ])
+          CFLAGS="$ac_save_CFLAGS"
+          CXXFLAGS="$ac_save_CXXFLAGS"
+          LIBS="$ac_save_LIBS"
+       fi
+     fi
+     SDL_CFLAGS=""
+     SDL_LIBS=""
+     ifelse([$3], , :, [$3])
+  fi
+  AC_SUBST(SDL_CFLAGS)
+  AC_SUBST(SDL_LIBS)
+  rm -f conf.sdltest
+])
+
+
+dnl ---------------------------------------------------------------------------
+dnl Macros for wxWindows detection. Typically used in configure.in as:
+dnl
+dnl 	AC_ARG_ENABLE(...)
+dnl 	AC_ARG_WITH(...)
+dnl	...
+dnl	AM_OPTIONS_WXCONFIG
+dnl	...
+dnl	...
+dnl	AM_PATH_WXCONFIG(2.3.4, wxWin=1)
+dnl     if test "$wxWin" != 1; then
+dnl        AC_MSG_ERROR([
+dnl     	   wxWindows must be installed on your system
+dnl     	   but wx-config script couldn't be found.
+dnl     
+dnl     	   Please check that wx-config is in path, the directory
+dnl     	   where wxWindows libraries are installed (returned by
+dnl     	   'wx-config --libs' command) is in LD_LIBRARY_PATH or
+dnl     	   equivalent variable and wxWindows version is 2.3.4 or above.
+dnl        ])
+dnl     fi
+dnl     CPPFLAGS="$CPPFLAGS $WX_CPPFLAGS"
+dnl     CXXFLAGS="$CXXFLAGS $WX_CXXFLAGS_ONLY"
+dnl     CFLAGS="$CFLAGS $WX_CFLAGS_ONLY"
+dnl     
+dnl     LDFLAGS="$LDFLAGS $WX_LIBS"
+dnl ---------------------------------------------------------------------------
+
+dnl ---------------------------------------------------------------------------
+dnl AM_OPTIONS_WXCONFIG
+dnl
+dnl adds support for --wx-prefix, --wx-exec-prefix and --wx-config 
+dnl command line options
+dnl ---------------------------------------------------------------------------
+
+AC_DEFUN([AM_OPTIONS_WXCONFIG],
+[
+   AC_ARG_WITH(wx-prefix, [  --with-wx-prefix=PREFIX   Prefix where wxWindows is installed (optional)],
+               wx_config_prefix="$withval", wx_config_prefix="")
+   AC_ARG_WITH(wx-exec-prefix,[  --with-wx-exec-prefix=PREFIX Exec prefix where wxWindows is installed (optional)],
+               wx_config_exec_prefix="$withval", wx_config_exec_prefix="")
+   AC_ARG_WITH(wx-config,[  --with-wx-config=CONFIG   wx-config script to use (optional)],
+               wx_config_name="$withval", wx_config_name="")
+])
+
+dnl ---------------------------------------------------------------------------
+dnl AM_PATH_WXCONFIG(VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
+dnl
+dnl Test for wxWindows, and define WX_C*FLAGS, WX_LIBS and WX_LIBS_STATIC
+dnl (the latter is for static linking against wxWindows). Set WX_CONFIG_NAME
+dnl environment variable to override the default name of the wx-config script
+dnl to use. Set WX_CONFIG_PATH to specify the full path to wx-config - in this
+dnl case the macro won't even waste time on tests for its existence.
+dnl ---------------------------------------------------------------------------
+
+dnl
+dnl Get the cflags and libraries from the wx-config script
+dnl
+AC_DEFUN([AM_PATH_WXCONFIG],
+[
+  dnl do we have wx-config name: it can be wx-config or wxd-config or ...
+  if test x${WX_CONFIG_NAME+set} != xset ; then
+     WX_CONFIG_NAME=wx-config
+  fi
+  if test "x$wx_config_name" != x ; then
+     WX_CONFIG_NAME="$wx_config_name"
+  fi
+
+  dnl deal with optional prefixes
+  if test x$wx_config_exec_prefix != x ; then
+     wx_config_args="$wx_config_args --exec-prefix=$wx_config_exec_prefix"
+     WX_LOOKUP_PATH="$wx_config_exec_prefix/bin"
+  fi
+  if test x$wx_config_prefix != x ; then
+     wx_config_args="$wx_config_args --prefix=$wx_config_prefix"
+     WX_LOOKUP_PATH="$WX_LOOKUP_PATH:$wx_config_prefix/bin"
+  fi
+
+  dnl don't search the PATH if WX_CONFIG_NAME is absolute filename
+  if test -x "$WX_CONFIG_NAME" ; then
+     AC_MSG_CHECKING(for wx-config)
+     WX_CONFIG_PATH="$WX_CONFIG_NAME"
+     AC_MSG_RESULT($WX_CONFIG_PATH)
+  else
+     AC_PATH_PROG(WX_CONFIG_PATH, $WX_CONFIG_NAME, no, "$WX_LOOKUP_PATH:$PATH")
+  fi
+
+  if test "$WX_CONFIG_PATH" != "no" ; then
+    WX_VERSION=""
+    no_wx=""
+
+    min_wx_version=ifelse([$1], ,2.2.1,$1)
+    AC_MSG_CHECKING(for wxWindows version >= $min_wx_version)
+
+    WX_CONFIG_WITH_ARGS="$WX_CONFIG_PATH $wx_config_args"
+
+    WX_VERSION=`$WX_CONFIG_WITH_ARGS --version`
+    wx_config_major_version=`echo $WX_VERSION | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
+    wx_config_minor_version=`echo $WX_VERSION | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
+    wx_config_micro_version=`echo $WX_VERSION | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
+
+    wx_requested_major_version=`echo $min_wx_version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
+    wx_requested_minor_version=`echo $min_wx_version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
+    wx_requested_micro_version=`echo $min_wx_version | \
+           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
+
+    wx_ver_ok=""
+    if test $wx_config_major_version -gt $wx_requested_major_version; then
+      wx_ver_ok=yes
+    else
+      if test $wx_config_major_version -eq $wx_requested_major_version; then
+         if test $wx_config_minor_version -gt $wx_requested_minor_version; then
+            wx_ver_ok=yes
+         else
+            if test $wx_config_minor_version -eq $wx_requested_minor_version; then
+               if test $wx_config_micro_version -ge $wx_requested_micro_version; then
+                  wx_ver_ok=yes
+               fi
+            fi
+         fi
+      fi
+    fi
+
+    if test "x$wx_ver_ok" = x ; then
+      no_wx=yes
+    else
+      WX_LIBS=`$WX_CONFIG_WITH_ARGS --libs`
+      WX_LIBS_STATIC=`$WX_CONFIG_WITH_ARGS --static --libs`
+
+      dnl starting with version 2.2.6 wx-config has --cppflags argument
+      wx_has_cppflags=""
+      if test $wx_config_major_version -gt 2; then
+        wx_has_cppflags=yes
+      else
+        if test $wx_config_major_version -eq 2; then
+           if test $wx_config_minor_version -gt 2; then
+              wx_has_cppflags=yes
+           else
+              if test $wx_config_minor_version -eq 2; then
+                 if test $wx_config_micro_version -ge 6; then
+                    wx_has_cppflags=yes
+                 fi
+              fi
+           fi
+        fi
+      fi
+
+      if test "x$wx_has_cppflags" = x ; then
+         dnl no choice but to define all flags like CFLAGS
+         WX_CFLAGS=`$WX_CONFIG_WITH_ARGS --cflags`
+         WX_CPPFLAGS=$WX_CFLAGS
+         WX_CXXFLAGS=$WX_CFLAGS
+
+         WX_CFLAGS_ONLY=$WX_CFLAGS
+         WX_CXXFLAGS_ONLY=$WX_CFLAGS
+      else
+         dnl we have CPPFLAGS included in CFLAGS included in CXXFLAGS
+         WX_CPPFLAGS=`$WX_CONFIG_WITH_ARGS --cppflags`
+         WX_CXXFLAGS=`$WX_CONFIG_WITH_ARGS --cxxflags`
+         WX_CFLAGS=`$WX_CONFIG_WITH_ARGS --cflags`
+
+         WX_CFLAGS_ONLY=`echo $WX_CFLAGS | sed "s@^$WX_CPPFLAGS *@@"`
+         WX_CXXFLAGS_ONLY=`echo $WX_CXXFLAGS | sed "s@^$WX_CFLAGS *@@"`
+      fi
+    fi
+
+    if test "x$no_wx" = x ; then
+       AC_MSG_RESULT(yes (version $WX_VERSION))
+       ifelse([$2], , :, [$2])
+    else
+       if test "x$WX_VERSION" = x; then
+	  dnl no wx-config at all
+	  AC_MSG_RESULT(no)
+       else
+	  AC_MSG_RESULT(no (version $WX_VERSION is not new enough))
+       fi
+
+       WX_CFLAGS=""
+       WX_CPPFLAGS=""
+       WX_CXXFLAGS=""
+       WX_LIBS=""
+       WX_LIBS_STATIC=""
+       ifelse([$3], , :, [$3])
+    fi
+  fi
+
+  AC_SUBST(WX_CPPFLAGS)
+  AC_SUBST(WX_CFLAGS)
+  AC_SUBST(WX_CXXFLAGS)
+  AC_SUBST(WX_CFLAGS_ONLY)
+  AC_SUBST(WX_CXXFLAGS_ONLY)
+  AC_SUBST(WX_LIBS)
+  AC_SUBST(WX_LIBS_STATIC)
+  AC_SUBST(WX_VERSION)
+])
+
+# Configure paths for libogg
+# Jack Moffitt <[email protected]> 10-21-2000
+# Shamelessly stolen from Owen Taylor and Manish Singh
+
+dnl XIPH_PATH_OGG([ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
+dnl Test for libogg, and define OGG_CFLAGS and OGG_LIBS
+dnl
+AC_DEFUN([XIPH_PATH_OGG],
+[dnl 
+dnl Get the cflags and libraries
+dnl
+AC_ARG_WITH(ogg,[  --with-ogg=PFX   Prefix where libogg is installed (optional)], ogg_prefix="$withval", ogg_prefix="")
+AC_ARG_WITH(ogg-libraries,[  --with-ogg-libraries=DIR   Directory where libogg library is installed (optional)], ogg_libraries="$withval", ogg_libraries="")
+AC_ARG_WITH(ogg-includes,[  --with-ogg-includes=DIR   Directory where libogg header files are installed (optional)], ogg_includes="$withval", ogg_includes="")
+AC_ARG_ENABLE(oggtest, [  --disable-oggtest       Do not try to compile and run a test Ogg program],, enable_oggtest=yes)
+
+  if test "x$ogg_libraries" != "x" ; then
+    OGG_LIBS="-L$ogg_libraries"
+  elif test "x$ogg_prefix" != "x" ; then
+    OGG_LIBS="-L$ogg_prefix/lib"
+  elif test "x$prefix" != "xNONE" ; then
+    OGG_LIBS="-L$libdir"
+  fi
+
+  OGG_LIBS="$OGG_LIBS -logg"
+
+  if test "x$ogg_includes" != "x" ; then
+    OGG_CFLAGS="-I$ogg_includes"
+  elif test "x$ogg_prefix" != "x" ; then
+    OGG_CFLAGS="-I$ogg_prefix/include"
+  elif test "x$prefix" != "xNONE"; then
+    OGG_CFLAGS=""
+  fi
+
+  AC_MSG_CHECKING(for Ogg)
+  no_ogg=""
+
+
+  if test "x$enable_oggtest" = "xyes" ; then
+    ac_save_CFLAGS="$CFLAGS"
+    ac_save_LIBS="$LIBS"
+    CFLAGS="$CFLAGS $OGG_CFLAGS"
+    LIBS="$LIBS $OGG_LIBS"
+dnl
+dnl Now check if the installed Ogg is sufficiently new.
+dnl
+      rm -f conf.oggtest
+      AC_TRY_RUN([
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ogg/ogg.h>
+
+int main ()
+{
+  system("touch conf.oggtest");
+  return 0;
+}
+
+],, no_ogg=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+       CFLAGS="$ac_save_CFLAGS"
+       LIBS="$ac_save_LIBS"
+  fi
+
+  if test "x$no_ogg" = "x" ; then
+     AC_MSG_RESULT(yes)
+     ifelse([$1], , :, [$1])     
+  else
+     AC_MSG_RESULT(no)
+     if test -f conf.oggtest ; then
+       :
+     else
+       echo "*** Could not run Ogg test program, checking why..."
+       CFLAGS="$CFLAGS $OGG_CFLAGS"
+       LIBS="$LIBS $OGG_LIBS"
+       AC_TRY_LINK([
+#include <stdio.h>
+#include <ogg/ogg.h>
+],     [ return 0; ],
+       [ echo "*** The test program compiled, but did not run. This usually means"
+       echo "*** that the run-time linker is not finding Ogg or finding the wrong"
+       echo "*** version of Ogg. If it is not finding Ogg, you'll need to set your"
+       echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"
+       echo "*** to the installed location  Also, make sure you have run ldconfig if that"
+       echo "*** is required on your system"
+       echo "***"
+       echo "*** If you have an old version installed, it is best to remove it, although"
+       echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"],
+       [ echo "*** The test program failed to compile or link. See the file config.log for the"
+       echo "*** exact error that occured. This usually means Ogg was incorrectly installed"
+       echo "*** or that you have moved Ogg since it was installed." ])
+       CFLAGS="$ac_save_CFLAGS"
+       LIBS="$ac_save_LIBS"
+     fi
+     OGG_CFLAGS=""
+     OGG_LIBS=""
+     ifelse([$2], , :, [$2])
+  fi
+  AC_SUBST(OGG_CFLAGS)
+  AC_SUBST(OGG_LIBS)
+  rm -f conf.oggtest
+])
+
+# Configure paths for libvorbis
+# Jack Moffitt <[email protected]> 10-21-2000
+# Shamelessly stolen from Owen Taylor and Manish Singh
+# thomasvs added check for vorbis_bitrate_addblock which is new in rc3
+
+dnl XIPH_PATH_VORBIS([ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
+dnl Test for libvorbis, and define VORBIS_CFLAGS and VORBIS_LIBS
+dnl
+AC_DEFUN([XIPH_PATH_VORBIS],
+[dnl 
+dnl Get the cflags and libraries
+dnl
+AC_ARG_WITH(vorbis,[  --with-vorbis=PFX   Prefix where libvorbis is installed (optional)], vorbis_prefix="$withval", vorbis_prefix="")
+AC_ARG_WITH(vorbis-libraries,[  --with-vorbis-libraries=DIR   Directory where libvorbis library is installed (optional)], vorbis_libraries="$withval", vorbis_libraries="")
+AC_ARG_WITH(vorbis-includes,[  --with-vorbis-includes=DIR   Directory where libvorbis header files are installed (optional)], vorbis_includes="$withval", vorbis_includes="")
+AC_ARG_ENABLE(vorbistest, [  --disable-vorbistest       Do not try to compile and run a test Vorbis program],, enable_vorbistest=yes)
+
+  if test "x$vorbis_libraries" != "x" ; then
+    VORBIS_LIBS="-L$vorbis_libraries"
+  elif test "x$vorbis_prefix" != "x" ; then
+    VORBIS_LIBS="-L$vorbis_prefix/lib"
+  elif test "x$prefix" != "xNONE"; then
+    VORBIS_LIBS="-L$libdir"
+  fi
+
+  VORBIS_LIBS="$VORBIS_LIBS -lvorbis -lm"
+  VORBISFILE_LIBS="-lvorbisfile"
+  VORBISENC_LIBS="-lvorbisenc"
+
+  if test "x$vorbis_includes" != "x" ; then
+    VORBIS_CFLAGS="-I$vorbis_includes"
+  elif test "x$vorbis_prefix" != "x" ; then
+    VORBIS_CFLAGS="-I$vorbis_prefix/include"
+  elif test "x$prefix" != "xNONE"; then
+    VORBIS_CFLAGS=""
+  fi
+
+
+  AC_MSG_CHECKING(for Vorbis)
+  no_vorbis=""
+
+
+  if test "x$enable_vorbistest" = "xyes" ; then
+    ac_save_CFLAGS="$CFLAGS"
+    ac_save_LIBS="$LIBS"
+    CFLAGS="$CFLAGS $VORBIS_CFLAGS $OGG_CFLAGS"
+    LIBS="$LIBS $VORBIS_LIBS $VORBISENC_LIBS $OGG_LIBS"
+dnl
+dnl Now check if the installed Vorbis is sufficiently new.
+dnl
+      rm -f conf.vorbistest
+      AC_TRY_RUN([
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vorbis/codec.h>
+#include <vorbis/vorbisenc.h>
+
+int main ()
+{
+    vorbis_block 	vb;
+    vorbis_dsp_state	vd;
+    vorbis_info		vi;
+
+    vorbis_info_init (&vi);
+    vorbis_encode_init (&vi, 2, 44100, -1, 128000, -1);
+    vorbis_analysis_init (&vd, &vi);
+    vorbis_block_init (&vd, &vb);
+    /* this function was added in 1.0rc3, so this is what we're testing for */
+    vorbis_bitrate_addblock (&vb);
+
+    system("touch conf.vorbistest");
+    return 0;
+}
+
+],, no_vorbis=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+       CFLAGS="$ac_save_CFLAGS"
+       LIBS="$ac_save_LIBS"
+  fi
+
+  if test "x$no_vorbis" = "x" ; then
+     AC_MSG_RESULT(yes)
+     ifelse([$1], , :, [$1])     
+  else
+     AC_MSG_RESULT(no)
+     if test -f conf.vorbistest ; then
+       :
+     else
+       echo "*** Could not run Vorbis test program, checking why..."
+       CFLAGS="$CFLAGS $VORBIS_CFLAGS"
+       LIBS="$LIBS $VORBIS_LIBS $OGG_LIBS"
+       AC_TRY_LINK([
+#include <stdio.h>
+#include <vorbis/codec.h>
+],     [ return 0; ],
+       [ echo "*** The test program compiled, but did not run. This usually means"
+       echo "*** that the run-time linker is not finding Vorbis or finding the wrong"
+       echo "*** version of Vorbis. If it is not finding Vorbis, you'll need to set your"
+       echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"
+       echo "*** to the installed location  Also, make sure you have run ldconfig if that"
+       echo "*** is required on your system"
+       echo "***"
+       echo "*** If you have an old version installed, it is best to remove it, although"
+       echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"],
+       [ echo "*** The test program failed to compile or link. See the file config.log for the"
+       echo "*** exact error that occured. This usually means Vorbis was incorrectly installed"
+       echo "*** or that you have moved Vorbis since it was installed." ])
+       CFLAGS="$ac_save_CFLAGS"
+       LIBS="$ac_save_LIBS"
+     fi
+     VORBIS_CFLAGS=""
+     VORBIS_LIBS=""
+     VORBISFILE_LIBS=""
+     VORBISENC_LIBS=""
+     ifelse([$2], , :, [$2])
+  fi
+  AC_SUBST(VORBIS_CFLAGS)
+  AC_SUBST(VORBIS_LIBS)
+  AC_SUBST(VORBISFILE_LIBS)
+  AC_SUBST(VORBISENC_LIBS)
+  rm -f conf.vorbistest
+])
+
+dnl XIPH_PATH_THEORA([ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
+dnl Test for libtheora, and define THEORA_CFLAGS and THEORA_LIBS
+dnl
+AC_DEFUN([XIPH_PATH_THEORA],
+[dnl 
+dnl Get the cflags and libraries
+dnl
+AC_ARG_WITH(theora,[  --with-theora=PFX   Prefix where libtheora is installed (optional)], theora_prefix="$withval", theora_prefix="")
+AC_ARG_WITH(theora-libraries,[  --with-theora-libraries=DIR   Directory where libtheora library is installed (optional)], theora_libraries="$withval", theora_libraries="")
+AC_ARG_WITH(theora-includes,[  --with-theora-includes=DIR   Directory where libtheora header files are installed (optional)], theora_includes="$withval", theora_includes="")
+AC_ARG_ENABLE(theoratest, [  --disable-theoratest       Do not try to compile and run a test Theora program],, enable_theoratest=yes)
+
+  if test "x$theora_libraries" != "x" ; then
+    THEORA_LIBS="-L$theora_libraries"
+  elif test "x$theora_prefix" != "x" ; then
+    THEORA_LIBS="-L$theora_prefix/lib"
+  elif test "x$prefix" != "xNONE"; then
+    THEORA_LIBS="-L$libdir"
+  fi
+
+  THEORA_LIBS="$THEORA_LIBS -ltheora"
+
+  if test "x$theora_includes" != "x" ; then
+    THEORA_CFLAGS="-I$theora_includes"
+  elif test "x$theora_prefix" != "x" ; then
+    THEORA_CFLAGS="-I$theora_prefix/include"
+  elif test "x$prefix" != "xNONE"; then
+    THEORA_CFLAGS=""
+  fi
+
+
+  AC_MSG_CHECKING(for Theora)
+  no_theora=""
+
+
+  if test "x$enable_theoratest" = "xyes" ; then
+    ac_save_CFLAGS="$CFLAGS"
+    ac_save_LIBS="$LIBS"
+    CFLAGS="$CFLAGS $THEORA_CFLAGS $OGG_CFLAGS"
+    LIBS="$LIBS $THEORA_LIBS $OGG_LIBS"
+dnl
+dnl Now check if the installed Theora is sufficiently new.
+dnl
+      rm -f conf.theoratest
+      AC_TRY_RUN([
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <theora/theora.h>
+#include <vorbis/codec.h>
+
+int main ()
+{
+    theora_info		ti;
+    theora_state	ts;
+
+    theora_info_init(&ti);
+
+    system("touch conf.theoratest");
+    return 0;
+}
+
+],, no_theora=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"])
+       CFLAGS="$ac_save_CFLAGS"
+       LIBS="$ac_save_LIBS"
+  fi
+
+  if test "x$no_theora" = "x" ; then
+     AC_MSG_RESULT(yes)
+     ifelse([$1], , :, [$1])     
+  else
+     AC_MSG_RESULT(no)
+     if test -f conf.theoratest ; then
+       :
+     else
+       echo "*** Could not run Theora test program, checking why..."
+       CFLAGS="$CFLAGS $THEORA_CFLAGS"
+       LIBS="$LIBS $THEORA_LIBS $OGG_LIBS"
+       AC_TRY_LINK([
+#include <stdio.h>
+#include <vorbis/codec.h>
+],     [ return 0; ],
+       [ echo "*** The test program compiled, but did not run. This usually means"
+       echo "*** that the run-time linker is not finding Theora or finding the wrong"
+       echo "*** version of Theora. If it is not finding Theora, you'll need to set your"
+       echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point"
+       echo "*** to the installed location  Also, make sure you have run ldconfig if that"
+       echo "*** is required on your system"
+       echo "***"
+       echo "*** If you have an old version installed, it is best to remove it, although"
+       echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"],
+       [ echo "*** The test program failed to compile or link. See the file config.log for the"
+       echo "*** exact error that occured. This usually means Theora was incorrectly installed"
+       echo "*** or that you have moved Theora since it was installed." ])
+       CFLAGS="$ac_save_CFLAGS"
+       LIBS="$ac_save_LIBS"
+     fi
+     THEORA_CFLAGS=""
+     THEORA_LIBS=""
+     ifelse([$2], , :, [$2])
+  fi
+  AC_SUBST(THEORA_CFLAGS)
+  AC_SUBST(THEORA_LIBS)
+  rm -f conf.theoratest
+])

autogen.sh

@@ -0,0 +1,137 @@
+#!/bin/sh
+# Run this to generate all the initial makefiles, etc.
+
+srcdir=`dirname $0`
+PKG_NAME="fs2_open"
+
+# check the version of a package
+check_version() {
+  COMMAND=$1
+  MAJOR=$2
+  MINOR=$3
+  MICRO=$4
+
+  ($COMMAND --version) </dev/null >/dev/null 2>&1 || return 1
+
+  ver=`$COMMAND --version|head -n 1|sed 's/^.*) //'|sed 's/ (.*)//'`
+  major=`echo $ver | cut -d. -f1 | sed s/[a-zA-Z\-].*//g`
+  minor=`echo $ver | cut -d. -f2 | sed s/[a-zA-Z\-].*//g`
+  micro=`echo $ver | cut -d. -f3 | sed s/[a-zA-Z\-].*//g`
+  test -z "$major" && major=0
+  test -z "$minor" && minor=0
+  test -z "$micro" && micro=0
+
+  fail=0
+  if [ ! "$major" -gt "$MAJOR" ]; then
+    if [ "$major" -lt "$MAJOR" ]; then
+      fail=1
+    elif [ ! "$minor" -gt "$MINOR" ]; then
+      if [ "$minor" -lt "$MINOR" ]; then
+        fail=1
+      elif [ "$micro" -lt "$MICRO" ]; then
+        fail=1
+      fi
+    fi
+  fi
+
+  return "$fail"
+}
+
+AUTOMAKE=
+ACLOCAL=
+DIE=0
+
+(autoconf --version) < /dev/null > /dev/null 2>&1 || {
+  echo
+  echo "**Error**: You must have \`autoconf' installed to."
+  echo "Download the appropriate package for your distribution,"
+  echo "or get the source tarball at ftp://ftp.gnu.org/pub/gnu/"
+  DIE=1
+}
+
+for AM in automake-1.9 automake-1.8 automake-1.7 automake-1.6 automake; do
+  (check_version "$AM" 1 6 1) && {
+    AUTOMAKE="$AM"
+    break
+  }
+done
+
+if [ -z "$AUTOMAKE" ]; then
+  echo
+  echo "**Error**: You must have \`automake' version 1.6.1 or greater"
+  echo "installed to compile $PKG_NAME. Download the appropriate package"
+  echo "for your distribution, or get the source tarball at"
+  echo "ftp://ftp.gnu.org/pub/gnu/"
+  DIE=1
+fi
+
+# if no automake, don't bother testing for aclocal
+test -z "$AUTOMAKE" || {
+  for ACL in aclocal-1.9 aclocal-1.8 aclocal-1.7 aclocal-1.6 aclocal; do
+    (check_version "$ACL" 1 6 1) && {
+      ACLOCAL="$ACL"
+      break
+    }
+  done
+
+  if [ -z "$ACLOCAL" ]; then
+    echo
+    echo "**Error**: Missing \`aclocal'. The version of \`automake'"
+    echo "installed seems to be outdated. Get a recent package from"
+    echo "ftp://ftp.gnu.org/pub/gnu/"
+    DIE=1
+  fi
+}
+
+if test "$DIE" -eq 1; then
+  exit 1
+fi
+
+if test -z "$*"; then
+  echo "**Warning**: I am going to run \`configure' with no arguments."
+  echo "If you wish to pass any to it, please specify them on the"
+  echo \`$0\'" command line."
+  echo
+fi
+
+case $CC in
+xlc )
+  am_opt=--include-deps;;
+esac
+
+for coin in `find $srcdir -name configure.ac -print`
+do 
+  dr=`dirname $coin`
+  if test -f $dr/NO-AUTO-GEN; then
+    echo skipping $dr -- flagged as no auto-gen
+  else
+    echo processing $dr
+    macrodirs=`sed -n -e 's,AM_ACLOCAL_INCLUDE(\(.*\)),\1,gp' < $coin`
+    ( cd $dr
+      aclocalinclude="$ACLOCAL_FLAGS"
+      for k in $macrodirs; do
+  	if test -d $k; then
+          aclocalinclude="$aclocalinclude -I $k"
+  	##else 
+	##  echo "**Warning**: No such directory \`$k'.  Ignored."
+        fi
+      done
+      echo "Running $ACLOCAL $aclocalinclude ..."
+      "$ACLOCAL" $aclocalinclude
+      echo "Running $AUTOMAKE --add-missing --copy --foreign $am_opt ..."
+      "$AUTOMAKE" --add-missing --copy --foreign $am_opt
+      echo "Running autoconf..."
+      autoconf
+    )
+  fi
+done
+
+#conf_flags="--enable-maintainer-mode --enable-compile-warnings" #--enable-iso-c
+
+if test x$NOCONFIGURE = x; then
+  echo Running $srcdir/configure $conf_flags "$@" ...
+  $srcdir/configure $conf_flags "$@" \
+  && echo Now type \`make\' to compile $PKG_NAME.
+else
+  echo Skipping configure process.
+fi

ci/bintray.template.json

@@ -1,19 +0,0 @@
-{
-    "package": {
-        "subject": "scp-fs2open",
-        "repo": "FSO",
-        "name": "nightly"
-    },
-
-    "version": {
-        "name": "$VERSION_NAME"
-    },
-
-    "files": [
-        {
-            "includePattern": "/tmp/builds/(.*)",
-            "uploadPattern": "$1"
-        }
-    ],
-    "publish": true
-}

ci/linux/clang-tidy-diff.py

@@ -1,268 +0,0 @@
-#!/usr/bin/env python3
-#
-#===- clang-tidy-diff.py - ClangTidy Diff Checker ------------*- python -*--===#
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-#===------------------------------------------------------------------------===#
-
-r"""
-ClangTidy Diff Checker
-======================
-
-This script reads input from a unified diff, runs clang-tidy on all changed
-files and outputs clang-tidy warnings in changed lines only. This is useful to
-detect clang-tidy regressions in the lines touched by a specific patch.
-Example usage for git/svn users:
-
-  git diff -U0 HEAD^ | clang-tidy-diff.py -p1
-  svn diff --diff-cmd=diff -x-U0 | \
-      clang-tidy-diff.py -fix -checks=-*,modernize-use-override
-
-"""
-
-import argparse
-import glob
-import json
-import multiprocessing
-import os
-import re
-import shutil
-import subprocess
-import sys
-import tempfile
-import threading
-import traceback
-
-try:
-    import yaml
-except ImportError:
-    yaml = None
-
-is_py2 = sys.version[0] == '2'
-
-if is_py2:
-    import Queue as queue
-else:
-    import queue as queue
-
-
-def run_tidy(task_queue, lock, timeout):
-    watchdog = None
-    while True:
-        command = task_queue.get()
-        try:
-            proc = subprocess.Popen(command,
-                                    stdout=subprocess.PIPE,
-                                    stderr=subprocess.PIPE)
-
-            if timeout is not None:
-                watchdog = threading.Timer(timeout, proc.kill)
-                watchdog.start()
-
-            stdout, stderr = proc.communicate()
-
-            with lock:
-                sys.stdout.write(stdout.decode('utf-8'))
-                sys.stdout.flush()
-                if stderr:
-                    sys.stderr.write(stderr.decode('utf-8'))
-                    sys.stderr.flush()
-        except Exception as e:
-            with lock:
-                sys.stderr.write('Failed: ' + str(e) + ': '.join(command) + '\n')
-        finally:
-            with lock:
-                if (not timeout is None) and (not watchdog is None):
-                    if not watchdog.is_alive():
-                        sys.stderr.write('Terminated by timeout: ' +
-                                         ' '.join(command) + '\n')
-                    watchdog.cancel()
-            task_queue.task_done()
-
-
-def start_workers(max_tasks, tidy_caller, task_queue, lock, timeout):
-    for _ in range(max_tasks):
-        t = threading.Thread(target=tidy_caller, args=(task_queue, lock, timeout))
-        t.daemon = True
-        t.start()
-
-def merge_replacement_files(tmpdir, mergefile):
-    """Merge all replacement files in a directory into a single file"""
-    # The fixes suggested by clang-tidy >= 4.0.0 are given under
-    # the top level key 'Diagnostics' in the output yaml files
-    mergekey = "Diagnostics"
-    merged = []
-    for replacefile in glob.iglob(os.path.join(tmpdir, '*.yaml')):
-        content = yaml.safe_load(open(replacefile, 'r'))
-        if not content:
-            continue # Skip empty files.
-        merged.extend(content.get(mergekey, []))
-
-    if merged:
-        # MainSourceFile: The key is required by the definition inside
-        # include/clang/Tooling/ReplacementsYaml.h, but the value
-        # is actually never used inside clang-apply-replacements,
-        # so we set it to '' here.
-        output = { 'MainSourceFile': '', mergekey: merged }
-        with open(mergefile, 'w') as out:
-            yaml.safe_dump(output, out)
-    else:
-        # Empty the file:
-        open(mergefile, 'w').close()
-
-
-def main():
-    parser = argparse.ArgumentParser(description=
-                                     'Run clang-tidy against changed files, and '
-                                     'output diagnostics only for modified '
-                                     'lines.')
-    parser.add_argument('-clang-tidy-binary', metavar='PATH',
-                        default='clang-tidy',
-                        help='path to clang-tidy binary')
-    parser.add_argument('-p', metavar='NUM', default=0,
-                        help='strip the smallest prefix containing P slashes')
-    parser.add_argument('-regex', metavar='PATTERN', default=None,
-                        help='custom pattern selecting file paths to check '
-                             '(case sensitive, overrides -iregex)')
-    parser.add_argument('-iregex', metavar='PATTERN', default=
-    r'.*\.(cpp|cc|c\+\+|cxx|c|cl|h|hpp|m|mm|inc)',
-                        help='custom pattern selecting file paths to check '
-                             '(case insensitive, overridden by -regex)')
-    parser.add_argument('-j', type=int, default=1,
-                        help='number of tidy instances to be run in parallel.')
-    parser.add_argument('-timeout', type=int, default=None,
-                        help='timeout per each file in seconds.')
-    parser.add_argument('-fix', action='store_true', default=False,
-                        help='apply suggested fixes')
-    parser.add_argument('-checks',
-                        help='checks filter, when not specified, use clang-tidy '
-                             'default',
-                        default='')
-    parser.add_argument('-path', dest='build_path',
-                        help='Path used to read a compile command database.')
-    if yaml:
-        parser.add_argument('-export-fixes', metavar='FILE', dest='export_fixes',
-                            help='Create a yaml file to store suggested fixes in, '
-                                 'which can be applied with clang-apply-replacements.')
-    parser.add_argument('-extra-arg', dest='extra_arg',
-                        action='append', default=[],
-                        help='Additional argument to append to the compiler '
-                             'command line.')
-    parser.add_argument('-extra-arg-before', dest='extra_arg_before',
-                        action='append', default=[],
-                        help='Additional argument to prepend to the compiler '
-                             'command line.')
-    parser.add_argument('-quiet', action='store_true', default=False,
-                        help='Run clang-tidy in quiet mode')
-    clang_tidy_args = []
-    argv = sys.argv[1:]
-    if '--' in argv:
-        clang_tidy_args.extend(argv[argv.index('--'):])
-        argv = argv[:argv.index('--')]
-
-    args = parser.parse_args(argv)
-
-    # Extract changed lines for each file.
-    filename = None
-    lines_by_file = {}
-    for line in sys.stdin:
-        match = re.search('^\+\+\+\ \"?(.*?/){%s}([^ \t\n\"]*)' % args.p, line)
-        if match:
-            filename = match.group(2)
-        if filename is None:
-            continue
-
-        if args.regex is not None:
-            if not re.match('^%s$' % args.regex, filename):
-                continue
-        else:
-            if not re.match('^%s$' % args.iregex, filename, re.IGNORECASE):
-                continue
-
-        match = re.search('^@@.*\+(\d+)(,(\d+))?', line)
-        if match:
-            start_line = int(match.group(1))
-            line_count = 1
-            if match.group(3):
-                line_count = int(match.group(3))
-            if line_count == 0:
-                continue
-            end_line = start_line + line_count - 1
-            lines_by_file.setdefault(filename, []).append([start_line, end_line])
-
-    if not any(lines_by_file):
-        print("No relevant changes found.")
-        sys.exit(0)
-
-    max_task_count = args.j
-    if max_task_count == 0:
-        max_task_count = multiprocessing.cpu_count()
-    max_task_count = min(len(lines_by_file), max_task_count)
-
-    tmpdir = None
-    if yaml and args.export_fixes:
-        tmpdir = tempfile.mkdtemp()
-
-    # Tasks for clang-tidy.
-    task_queue = queue.Queue(max_task_count)
-    # A lock for console output.
-    lock = threading.Lock()
-
-    # Run a pool of clang-tidy workers.
-    start_workers(max_task_count, run_tidy, task_queue, lock, args.timeout)
-
-    # Form the common args list.
-    common_clang_tidy_args = []
-    if args.fix:
-        common_clang_tidy_args.append('-fix')
-    if args.checks != '':
-        common_clang_tidy_args.append('-checks=' + args.checks)
-    if args.quiet:
-        common_clang_tidy_args.append('-quiet')
-    if args.build_path is not None:
-        common_clang_tidy_args.append('-p=%s' % args.build_path)
-    for arg in args.extra_arg:
-        common_clang_tidy_args.append('-extra-arg=%s' % arg)
-    for arg in args.extra_arg_before:
-        common_clang_tidy_args.append('-extra-arg-before=%s' % arg)
-
-    for name in lines_by_file:
-        line_filter_json = json.dumps(
-            [{"name": name, "lines": lines_by_file[name]}],
-            separators=(',', ':'))
-
-        # Run clang-tidy on files containing changes.
-        command = [args.clang_tidy_binary]
-        command.append('-line-filter=' + line_filter_json)
-        if yaml and args.export_fixes:
-            # Get a temporary file. We immediately close the handle so clang-tidy can
-            # overwrite it.
-            (handle, tmp_name) = tempfile.mkstemp(suffix='.yaml', dir=tmpdir)
-            os.close(handle)
-            command.append('-export-fixes=' + tmp_name)
-        command.extend(common_clang_tidy_args)
-        command.append(name)
-        command.extend(clang_tidy_args)
-
-        task_queue.put(command)
-
-    # Wait for all threads to be done.
-    task_queue.join()
-
-    if yaml and args.export_fixes:
-        print('Writing fixes to ' + args.export_fixes + ' ...')
-        try:
-            merge_replacement_files(tmpdir, args.export_fixes)
-        except:
-            sys.stderr.write('Error exporting fixes.\n')
-            traceback.print_exc()
-
-    if tmpdir:
-        shutil.rmtree(tmpdir)
-
-
-if __name__ == '__main__':
-    main()

ci/linux/clang_tidy.sh

@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-git config --global --add safe.directory "$GITHUB_WORKSPACE"
-
-COMMIT_RANGE=$1..$2
-
-if ! git rev-list $COMMIT_RANGE 2>&1 >/dev/null; then
-    echo "\$COMMIT_RANGE ($COMMIT_RANGE) is not valid for this build (probably caused by a rebase)."
-    exit 0
-fi
-
-# In order to get a proper diff without irrelevant changes, we need to determine where we branched off from the base
-# branch
-BASE_COMMIT=$(git merge-base $1 $2)
-
-# Allow the caller to override the clang-tidy binary and job count, since neither
-# /usr/bin/clang-tidy-16 nor nproc are available outside the Linux CI container
-# (e.g. macOS runners install clang-tidy via pip and use sysctl for core count).
-CLANG_TIDY_BINARY="${CLANG_TIDY_BINARY:-/usr/bin/clang-tidy-16}"
-NUM_JOBS="${NUM_JOBS:-$( (command -v nproc >/dev/null 2>&1 && nproc) || sysctl -n hw.ncpu )}"
-
-# Note: Manually passing in the Vulkan flags that are normally provided by cmake (but are not so, here), to ensure
-# that the source files are checked with the actual configuration used.
-echo "Running clang-tidy on changed files"
-git diff -U0 --no-color "$BASE_COMMIT..$2" | \
-    $HERE/clang-tidy-diff.py -path "$(pwd)/build" -p1 \
-    -regex '(code(?!((\/graphics\/shaders\/compiled)|(\/globalincs\/windebug)|(\/def_files\/data)))|freespace2|qtfred|test\/src|build|tools)\/.*\.(cpp|h)' \
-    -clang-tidy-binary "$CLANG_TIDY_BINARY" -j"$NUM_JOBS" -export-fixes "$(pwd)/clang-fixes.yaml"

ci/linux/configure_cmake.sh

@@ -1,70 +0,0 @@
-#!/usr/bin/env bash
-
-if [ "$COMPILER" = "gcc-9" ]; then
-    export CC=gcc-9
-    export CXX=g++-9
-fi
-if [ "$COMPILER" = "gcc-13" ]; then
-    export CC=gcc-13
-    export CXX=g++-13
-fi
-if [ "$COMPILER" = "clang-16" ]; then
-    export CC=clang-16
-    export CXX=clang++-16
-fi
-
-if [ "$RUNNER_OS" = "macOS" ]; then
-    CXXFLAGS="-mtune=generic -pipe -Wno-unknown-pragmas"
-    CFLAGS="-mtune=generic -pipe -Wno-unknown-pragmas"
-    export CMAKE_OSX_ARCHITECTURES="$ARCHITECTURE"
-else
-    PLATFORM_CMAKE_OPTIONS="-DFSO_BUILD_APPIMAGE=ON -DFORCED_SIMD_INSTRUCTIONS=SSE2"
-
-    # Optionally use static libstdc++/libc++ on Linux, but default to off
-    # (Issue #5571 enabled it as a fix for 20.04 compatibility, but we've moved to 22.04)
-    PLATFORM_CMAKE_OPTIONS="$PLATFORM_CMAKE_OPTIONS -DUSE_STATIC_LIBCXX=${USE_STATIC_LIBCXX:-OFF}"
-fi
-
-CMAKE_OPTIONS="$JOB_CMAKE_OPTIONS"
-if [[ "$COMPILER" =~ ^clang.*$ ]]; then
-    # Default to allowing system standard c++ library be used. On Linux, which
-    # typically uses libstdc++ by default, using libc++ causes a conflict with
-    # Qt6 libs. So an error/warning is in place to catch that case when QtFRED
-    # is enabled.
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCLANG_USE_LIBCXX=${CLANG_USE_LIBCXX:-OFF}"
-fi
-
-if [ ! "$CCACHE_PATH" = "" ] && [ ! -x "$CCACHE_PATH" ]; then
-    # The configured path doesn't exist on this runner (e.g. macOS runners on Apple
-    # Silicon hosts install Homebrew under /opt/homebrew instead of /usr/local),
-    # so fall back to whatever ccache is actually on PATH.
-    CCACHE_PATH="$(command -v ccache || true)"
-fi
-
-if [ ! "$CCACHE_PATH" = "" ]; then
-    echo "Using ccache at $CCACHE_PATH"
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_C_COMPILER_LAUNCHER=$CCACHE_PATH -DCMAKE_CXX_COMPILER_LAUNCHER=$CCACHE_PATH"
-fi
-
-if [ -n "${ENABLE_QTFRED:-}" ]; then
-    CMAKE_OPTIONS="$CMAKE_OPTIONS -DFSO_BUILD_QTFRED=${ENABLE_QTFRED}"
-fi
-
-mkdir build
-cd build
-
-export CXXFLAGS
-export CFLAGS
-export LD_LIBRARY_PATH
-
-if [ "$RUNNER_OS" = "macOS" ] && [ ! -x "$(which ninja)" ]; then
-    brew install ninja
-fi
-
-# CMAKE_JOB_POOLS and CMAKE_JOB_POOL_LINK ensure that when using ninja, link operations are done sequentially
-# we have some build rules that do not play nice with parallel invocation and that fixes these issues
-
-cmake -G Ninja -DFSO_FATAL_WARNINGS=ON -DCMAKE_EXPORT_COMPILE_COMMANDS=ON $CMAKE_OPTIONS $PLATFORM_CMAKE_OPTIONS \
-    -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DCMAKE_BUILD_TYPE=$CONFIGURATION -DQT_USE_PRECOMPILED=ON \
-    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON \
-    -DCMAKE_JOB_POOLS=link=1 -DCMAKE_JOB_POOL_LINK=link ..

ci/linux/create_dist_pack.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-OS="$1"
-
-source $HERE/dist_functions.sh
-
-if [ "$OS" = "Linux" ]; then
-    tar -cvzf "$(get_package_name)-builds-Linux-$ARCH.tar.gz" *
-
-    echo "package_path=$(pwd)/$(get_package_name)-builds-Linux-$ARCH.tar.gz" >> $GITHUB_OUTPUT
-    echo "package_name=$(get_package_name)-builds-Linux-$ARCH.tar.gz" >> $GITHUB_OUTPUT
-    echo "package_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Linux-$ARCH.tar.gz")" >> $GITHUB_OUTPUT
-elif [ "$OS" = "Windows" ]; then
-    7z a -xr'!*.pdb' "$(get_package_name)-builds-$ID.zip" "*"
-
-    echo "package_path=$(pwd)/$(get_package_name)-builds-$ID.zip" >> $GITHUB_OUTPUT
-    echo "package_name=$(get_package_name)-builds-$ID.zip" >> $GITHUB_OUTPUT
-    echo "package_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-$ID.zip")" >> $GITHUB_OUTPUT
-
-    7z a "$(get_package_name)-debug-$ID.7z" "*.pdb"
-
-    echo "debug_path=$(pwd)/$(get_package_name)-debug-$ID.7z" >> $GITHUB_OUTPUT
-    echo "debug_name=$(get_package_name)-debug-$ID.7z" >> $GITHUB_OUTPUT
-    echo "debug_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-debug-$ID.7z")" >> $GITHUB_OUTPUT
-elif [ "$OS" = "Mac" ]; then
-    tar -cvzf "$(get_package_name)-builds-Mac-$ARCH.tar.gz" *.app
-
-    echo "package_path=$(pwd)/$(get_package_name)-builds-Mac-$ARCH.tar.gz" >> $GITHUB_OUTPUT
-    echo "package_name=$(get_package_name)-builds-Mac-$ARCH.tar.gz" >> $GITHUB_OUTPUT
-    echo "package_mime=$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Mac-$ARCH.tar.gz")" >> $GITHUB_OUTPUT
-else
-    echo "Invalid OS: $OS"
-fi

ci/linux/dist_functions.sh

@@ -1,70 +0,0 @@
-function get_package_name() {
-  if git describe --match 'nightly_*' --exact-match 2>/dev/null >/dev/null; then
-    echo -n "$(git describe --match "nightly_*" --exact-match)"
-    return
-  fi
-
-  if git describe --match 'release_*' --exact-match 2>/dev/null >/dev/null; then
-    echo -n "$(git describe --match "release_*" --exact-match | sed 's/release_/fs2_open_/i')"
-    return
-  fi
-
-  if [[ "$(git branch --show-current)" =~ ^test\/(.*)$ ]]; then
-    echo -n "test_${BASH_REMATCH[1]}"
-    return
-  fi
-
-  echo "unknown_config"
-}
-
-function get_version_name() {
-  if git describe --match 'nightly_*' --exact-match 2>/dev/null >/dev/null; then
-    local tag_name=$(git describe --match "nightly_*" --exact-match)
-
-    # Use the bash regex matching for getting the relevant part of the tag name
-    [[ $tag_name =~ ^nightly_(.*)$ ]]
-
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  if git describe --match 'release_*' --exact-match 2>/dev/null >/dev/null; then
-    local tag_name=$(git describe --match "release_*" --exact-match)
-
-    # Use the bash regex matching for getting the relevant part of the tag name
-    [[ $tag_name =~ ^release_(.*)$ ]]
-
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  if [[ "$(git branch --show-current)" =~ ^test\/(.*)$ ]]; then
-    echo -n "${BASH_REMATCH[1]}"
-    return
-  fi
-
-  echo "unknown_config"
-}
-
-function upload_files_to_sftp() {
-  # We need empty glob patterns to "disappear" in the for loop below since this will be run for different configurations
-  # where it may be possible that some of the file patterns will not be present
-  shopt -s nullglob
-
-  echo "cd $2/" > sftp_batch
-  echo "mkdir $(get_version_name)" >> sftp_batch
-  # Create directory but do not cause an error if it already exists
-  sshpass -e sftp -oBatchMode=no -o "StrictHostKeyChecking no" -b sftp_batch $1 || true
-
-  echo "cd $2/$(get_version_name)/" > sftp_batch
-  for file in *.tar.gz *.7z *.zip; do
-    echo "put $file" >> sftp_batch
-  done
-
-  echo "bye" >> sftp_batch
-
-  sshpass -e sftp -oBatchMode=no -o "StrictHostKeyChecking no" -b sftp_batch $1
-
-  rm sftp_batch
-}
-

ci/linux/generate_appimage.sh

@@ -1,49 +0,0 @@
-#!/usr/bin/env bash
-
-INSTALL_FOLDER=$1
-
-# safety check
-if [ ! -d bin -o ! -f cmake_install.cmake ]; then
-	echo "ERROR! This script must be run from within the build root!"
-	exit 1
-fi
-
-if [ ! -x "$(which wget)" ]; then
-	echo "ERROR! Required utility is not available: wget"
-	exit 1
-fi
-
-# install newest appimagetool if it's not already available
-if [ ! -x ./bin/appimagetool ]; then
-	APPIMAGE_TOOL_URL="https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-$(uname -m).AppImage"
-
-	wget -O ./bin/appimagetool "$APPIMAGE_TOOL_URL" || { echo "ERROR! Failed to get appimagetool!" && exit 1; }
-	chmod +x ./bin/appimagetool
-fi
-
-# This shouldn't be needed with newer runtimes, but they still generate an
-# error if fusermount is missing even though it works. So to skip error msg
-# and have max compatibility with runtimes and containers we'll use it.
-export APPIMAGE_EXTRACT_AND_RUN=1
-
-# Install Freespace2 targets
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER/Freespace2 -DCOMPONENT=Unspecified -P cmake_install.cmake
-cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER/Freespace2 -DCOMPONENT=Freespace2 -P cmake_install.cmake
-
-# We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-FILENAME="$(find $INSTALL_FOLDER/Freespace2/bin -maxdepth 1 -name 'fs2_open_*' -type f -executable -printf "%f\n").AppImage"
-./bin/appimagetool -n "$INSTALL_FOLDER/Freespace2" "$INSTALL_FOLDER/$FILENAME"
-chmod +x "$INSTALL_FOLDER/$FILENAME"
-
-# Maybe install qtFRED targets
-if [ -f qtfred/cmake_install.cmake ]; then
-	cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER/qtFRED -DCOMPONENT=Unspecified -P cmake_install.cmake
-	cmake -DCMAKE_INSTALL_PREFIX=$INSTALL_FOLDER/qtFRED -DCOMPONENT=qtFRED -P cmake_install.cmake
-
-	# We need to be a bit creative for determining the AppImage name since we don't want to hard-code the name
-	FILENAME="$(find $INSTALL_FOLDER/qtFRED/bin -maxdepth 1 -iname 'qtfred_*' -type f -executable -printf "%f\n").AppImage"
-	./bin/appimagetool -n "$INSTALL_FOLDER/qtFRED" "$INSTALL_FOLDER/$FILENAME"
-	chmod +x "$INSTALL_FOLDER/$FILENAME"
-fi
-
-ls -al $INSTALL_FOLDER

ci/linux/run_tests.sh

@@ -1,28 +0,0 @@
-#!/usr/bin/env bash
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-export LD_LIBRARY_PATH=$(pwd)/bin/lib:$LD_LIBRARY_PATH
-
-# The unit tests never open a window, but a few of them reach code that brings SDL's video
-# subsystem up (os_init() and resolution_default(), the latter via gr_init()). Left to itself SDL
-# probes its real backends and dlopens libX11, which leaks a handful of blocks per init/quit cycle
-# that SDL_QuitSubSystem() does not reclaim -- those are the "definitely lost" contexts memcheck
-# fails the Debug legs on. Pinning the dummy driver skips the probing entirely, so the leaks never
-# happen, and it makes the tests behave the same way whether or not the runner has a display.
-export SDL_VIDEODRIVER=dummy
-
-# if on mac and building for architecture that doesn't match host
-# then unittests will fail so we just need to skip it (for now)
-if [ "$RUNNER_OS" = "macOS" ] && [ "$ARCH" != "$(uname -m)" ]; then
-    echo "Skipping tests due to architecture mismatch!"
-    exit 0
-fi
-
-if [ "$CONFIGURATION" = "Debug" ] && [[ "$RUNNER_OS" != "macOS" ]] ; then
-    valgrind --leak-check=full --error-exitcode=1 --gen-suppressions=all \
-        --suppressions="$HERE/valgrind.supp" ./bin/unittests --gtest_shuffle
-else
-    ./bin/unittests --gtest_shuffle
-fi

ci/linux/upload_dist_package.sh

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-UPLOAD_TYPE=$1
-
-SCRIPT=$(readlink -f "$0")
-HERE=$(dirname "$SCRIPT")
-
-source $HERE/dist_functions.sh
-
-if [ "$UPLOAD_TYPE" = "nightly" ]; then
-    any_success=false
-    if SSHPASS=$INDIEGAMES_SSHPASS upload_files_to_sftp "$INDIEGAMES_USER@scp.indiegames.us" "public_html/builds/nightly"; then
-        any_success=true
-    fi
-
-    if SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@perses.feralhosting.com" "www/datacorder.perses.feralhosting.com/public_html/builds/nightly"; then
-        any_success=true
-    fi
-
-    if [ "$any_success" = "false" ]; then
-        echo "All uploads failed"
-        exit 1
-    fi
-elif [ "$UPLOAD_TYPE" = "test" ]; then
-    SSHPASS=$DATACORDER_SSHPASS upload_files_to_sftp "$DATACORDER_USER@perses.feralhosting.com" "www/datacorder.perses.feralhosting.com/public_html/builds/test"
-else
-    echo "Unknown upload type $UPLOAD_TYPE"
-    exit 1
-fi

ci/linux/valgrind.supp

@@ -1,139 +0,0 @@
-{
-   liblsan Invalid read
-   Memcheck:Addr8
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:/usr/lib64/liblsan.so.0.0.0
-   obj:*
-   obj:*
-   obj:*
-}
-{
-   CLang Lua unitialized value error
-   Memcheck:Cond
-   ...
-   fun:luaH_get
-   fun:lua_rawget
-   fun:_ZN12_GLOBAL__N_117ade_index_handlerEP9lua_State
-}
-{
-   False-positive uninitialized variable warning
-   Memcheck:Cond
-   fun:_Z23cf_check_location_flagsjj
-   fun:_Z29cf_create_default_path_stringPcjiPKcbj
-   ...
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initOSt10unique_ptrIN2os18GraphicsOperationsESt14default_deleteIS1_EEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing4Test3RunEv
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initOSt10unique_ptrIN2os18GraphicsOperationsESt14default_deleteIS1_EEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN8FontTest5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   <insert_a_suppression_name_here>
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   fun:_Znwm
-   obj:*
-   obj:*
-   obj:*
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   obj:/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0.4.0
-   fun:_Z7gr_initONSt3__110unique_ptrIN2os18GraphicsOperationsENS_14default_deleteIS2_EEEEiiii
-   fun:_ZN4test13FSTestFixture5SetUpEv
-   fun:_ZN7testing8internal38HandleSehExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-   fun:_ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS_4TestEvEET0_PT_MS4_FS3_vEPKc
-}
-{
-   SDL_Init one-time internal allocation via os_init
-   Memcheck:Leak
-   match-leak-kinds: definite
-   fun:malloc
-   obj:*
-   obj:*
-   obj:*
-   obj:*
-   fun:_Z7os_initPKcS0_S0_
-   fun:_ZN4test13FSTestFixture5SetUpEv
-}
-# Kept only as a backstop for running memcheck by hand. run_tests.sh pins SDL_VIDEODRIVER=dummy, so
-# the X11 backend is never created there; this block also cannot match the prebuilt libSDL3 anymore,
-# since that library is now stripped and X11_CreateDevice is a static symbol.
-{
-   SDL3 X11 video backend internal allocations, not freed by SDL_VideoQuit
-   Memcheck:Leak
-   match-leak-kinds: definite,possible
-   ...
-   fun:X11_CreateDevice
-}
-{
-   glibc loader bookkeeping and library constructor allocations retained across dlopen
-   Memcheck:Leak
-   match-leak-kinds: definite,possible
-   ...
-   fun:_dl_open
-}

ci/post/changelog.py

@@ -1,259 +0,0 @@
-# Retrives a log of commit messages and attempts to pretty them into a human-readbile format
-
-import argparse
-import os
-import re
-import requests
-import sys
-
-from datetime import datetime
-from subprocess import check_output
-
-MAX_PAGES = 100  # maximum number of PR pages to go through
-warnings = 0
-
-label_scores = {
-"fred" : 6,
-"qtfred" : 6,
-"vr" : 6,
-"multi" : 6,
-"Lab" : 6,
-"pilot file" : 6,
-"scripting" : 6,
-"sexps" : 6,
-"ai" : 6,
-"controls" : 6,
-"HUD" : 6,
-"models" : 6,
-"sound" : 6,
-"graphics" : 6,
-"physics" : 6,
-"ui" : 6,
-"localization / translation" : 6,
-"optimization" : 6,
-"gameplay" : 5,
-"general modding" : 4,
-"fix" : 3,
-"enhancement" : 2,
-"backport" : 1,
-"cleanup" : 0
-}
-
-label_to_category = {
-"fred" : "FRED",
-"qtfred" : "QtFRED",
-"vr" : "VR",
-"multi" : "Multiplayer",
-"Lab" : "Lab",
-"pilot file" : "Pilot File",
-"scripting" : "Scripting",
-"sexps" : "SEXPs",
-"ai" : "AI",
-"controls" : "Controls",
-"HUD" : "HUD",
-"models" : "Models",
-"sound" : "Sound",
-"graphics" : "Graphics",
-"physics" : "Physics",
-"ui" : "UI",
-"localization / translation" : "Localization",
-"optimization" : "Optimization",
-"gameplay" : "Gameplay",
-"general modding" : "General Modding",
-"fix" : "Fix",
-"enhancement" : "Enhancement",
-"backport" : "Backport",
-"cleanup" : "Cleanup",
-"misc" : "Misc."
-}
-
-def get_last_page(response: requests.Response) -> int:
-    """
-    @brief Extract the last page number from the response header
-
-    @param[in] response The response from a GET call
-
-    @returns The page number of the last page, or MAX_PAGES
-    """
-
-    # The link header is a dictionary in string form, and for that matter the
-    # value is in front of the key.  It is of the form '<<url1>>; rel=<key1>, <url2>, <key2>'
-    link = response.headers['link']
-    link = link.split(',')
-    for x in link:
-        y = x.split(';')        # <url>; rel=<key>
-        if "last" not in y[1]:  # look for rel='last'
-            continue
-        # grab the page number from the URL
-        # group(0) is `page=123`, group(1) is `123`
-        last_page = int( re.search(r'page=(\d+)', y[0]).group(1) )
-        if not last_page:
-            print("Error: Could not find page number in url!  URL: %s", y[0])
-            sys.exit(1)
-
-        if last_page > MAX_PAGES:
-            return MAX_PAGES
-        else:
-            return last_page
-
-def label_score(label):
-    try:
-        return label_scores[label['name']]
-    except KeyError:
-        return -1
-
-def get_label(labels) -> str:
-    """
-    @brief Get the primary label from a list of labels
-
-    @param[in] labels The list of labels from a pull request
-
-    @returns The primary label to be used for sorting in the changelog
-    """
-    if len(labels) < 1:
-        return "misc"
-
-    # Sort the labels based on their score and grab the highest valued label
-    name = sorted(labels, key=label_score, reverse=True)[0]['name']
-    
-    # If a label couldn't be found, toss it into a miscellaneous bin
-    if name not in label_scores:
-        name = "misc"
-    
-    return name
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Retrieves a log of commit messages and attempts to pretty them into a human-readable format")
-    parser.add_argument("start_date",
-                        help="Day of the earliest commit to add to the log.")
-    parser.add_argument("-u", "--user", nargs=2, metavar=("NAME", "TOKEN"), default=["", ""],
-                        help="Github username and token/password")
-
-    args = parser.parse_args()
-
-    os.chdir(os.path.dirname(__file__))	# Change working directory to this file's directory
-    start_date = datetime.strptime(args.start_date, "%Y-%m-%d")
-
-    print("start_date: {}".format(start_date))
-
-    # Retrive the git log for master, since start date, order by date, in ascending order, use YYYY-MM-DD date format,
-    #   each line is of the form "<author short date> | <message>", only grab commits from master,
-    #   output to `fsofordigest.txt`,
-    
-    # check_output(("git log master", "--after=2021-09-15", "--date-order", "--reverse", "--date=short",
-    # "--pretty=\"%as | %s\"",  "--first-parent",
-    # "--output fsofordigest.txt"), text=True)
-
-    # The commit messages are either of the form "<body> (#<PR_number>)" or "Merge pull request #<PR_number> from <source_repo>"
-    # For our purposes, we want them be all of the form "<body> (#<PR_number>)"
-    # Typically, the second form does not have a usable body, so we'll have to pull the PR title from github
-
-    # Github's REST API allows us to retrieve PR's, but due to it being HTTP requests it has to page in the data.
-    # We can loop over the GET request and check for a merge date.
-    # The GET request doesn't have sorting by merge date, but does have sorting by the last time it was updated... which is usually
-    # also the merge date but not always.
-
-    # Key attributes within the PR JSON objects:
-    #   "merged_at: <date>"     # Date the PR was merged in
-    #   "merged: <bool>"        # If the PR was merged yet
-    #   "html_url: <string>"    # URL of the PR's HEAD commit, used by some clients to pull in the PR branch
-    #   "number: <int>"         # The PR id number
-    #   "title: <string>"       # Title of the PR
-    #   "body: <string>"        # The body paragraph detailing the PR
-    #   "labels: [label_object]"    # All labels attached to this PR
-
-    changelog = {}
-    url = "https://api.github.com/repos/scp-fs2open/fs2open.github.com/pulls"
-    page = 1
-    last_page = MAX_PAGES
-    while page <= last_page:
-        # GET <url>?base=master&sort=updated&direction=desc&state=closed&page=1
-        response = requests.get(url,
-        auth=(args.user[0], args.user[1]),
-        params={
-            "base": "master",
-            "direction": "desc",
-            "page": page,
-            "state": "closed",
-            "sort": "updated"
-        })
-
-        # Check if good response
-        if (response.status_code != 200) :
-            print("Error: ", response.status_code)
-            print(response.json()['message'])
-            sys.exit(1)
-        else:
-            print("Request successful: 200")
-            print("page={}".format(page))
-
-        # Update the last_page index at first iteration and possibly last iteration
-        # This should cover the edge case of a new PR being added to the database before this script is finished
-        if (page == 1) or (page == last_page):
-            last_page = get_last_page(response)
-            print("last_page={}".format(last_page))
-
-        # assume pulls are organized from newest to oldest
-        for pull in response.json():
-            if (pull['state'] != 'closed'):
-                # This pull is not merged, so ignore
-                print("Found irrelevant pull, skipping...")
-                print("state: {}; number: {}".format(pull['state'], pull['number']))
-                continue
-            
-            if (pull['merged_at'] == None):
-                # This pull wasn't merged, skip
-                print("Found closed pull #{} ({}), skipping...".format(pull['number'], pull['closed_at']))
-                continue
-
-            merge_date = datetime.strptime(pull['merged_at'], "%Y-%m-%dT%H:%M:%SZ")
-            updated_date = datetime.strptime(pull['updated_at'], "%Y-%m-%dT%H:%M:%SZ")
-            if (merge_date < start_date) and (updated_date >= start_date):
-                # This pull is too old, but was updated within our timeframe. skip
-                print("Found old pull #{} ({}), skipping...".format(pull['number'], pull['merged_at']))
-                continue
-
-            if (updated_date < start_date):
-                # This pull is too old
-                print("Found old pull #{} ({}), stopping loop...".format(pull['number'], pull['updated_at']))
-                page = last_page + 1
-                break
-            
-            # If a label isn't in the changelog, create a bin for it
-            label = get_label(pull['labels'])
-            if label not in changelog:
-                changelog[label] = {}
-
-            # Add the pull to the changelog, indexed by its pull.number
-            if pull['number'] not in changelog[label]:
-                # only add if the key isn't there already
-                changelog[label][pull['number']] = {
-                    "date":     merge_date,
-                    "title":    pull['title'],
-                    "labels":   pull['labels'],
-                    "url":      pull['html_url']
-                }
-                print("Added pull #{} ({})".format(pull['number'], merge_date))
-            # Else, silently ignore duplicate (for now...)
-
-        page += 1 # iterate to next page
-
-
-    # Write the changelog to file
-    # 2021-09-28 | (#3661) Fix homing child weapons in niche circumstances 
-    print("Writing to change.log...")
-    str = ''
-    for label, pulls in dict(sorted(changelog.items())).items():
-        str += "[size=18pt]{}[/size]\n".format(label_to_category[label])
-        str += "[list]\n"
-        for key, value in pulls.items():
-            str += "[li](#{}) {} [/li]\n".format(key, value['title'])
-        str += "[/list]\n\n"
-
-    with open("change.log", "w") as file:
-        file.write(str)
-
-    print("Done!")
-
-main()

ci/post/file_list.py

@@ -1,232 +0,0 @@
-import re # regex module
-from ftplib import FTP, error_perm
-from itertools import groupby
-from typing import List, Tuple, Dict
-
-import requests  # HTTP requests module
-
-from util import retry_multi, GLOBAL_TIMEOUT	# from util.py
-
-
-class ReleaseFile:
-    """! Class representing a Released file on Nebula
-
-    `name`: str
-        Mod (or build) name,
-    `url`: str
-        Primary host URL,
-    `group`: str
-        Mod group string,
-    `subgroup`: str
-        Mod subgroup string,
-    `mirrors`: List[str]
-        List of URL's of FTP mirrors
-    """
-    def __init__(self, name, url, group, subgroup=None, mirrors=None):
-        if mirrors is None:
-            mirrors = []
-        self.mirrors = mirrors
-        self.subgroup = subgroup
-        self.group = group
-        self.url = url
-        self.name = name
-
-        self.base_url = "/".join(url.split('/')[0:-1]) + "/"
-        self.filename = url.split('/')[-1]
-
-        # A list of tuples of (filename, hash)
-        self.content_hashes = None
-
-        self.hash = None
-        self.size = 0
-    
-    def __repr__(self):
-        return repr((self.name))
-
-
-class SourceFile:
-    """! Class represeting a source file
-
-    `name`: str
-        File name,
-    `url`: str
-        FTP URL,
-    `group`
-        <unknown>
- 
-    @details More details
-    """
-    def __init__(self, name, url, group):
-        self.group = group
-        self.url = url
-        self.name = name
-
-
-class FileGroup:
-    """! Represents a file group
-
-    `name`: str
-        Name of this group
-    `files`: List[ReleaseFile]
-        List of files within this group
-    `mainFile`: str
-        If this FileGroup has a subgroup, `mainFile` is the head of that group
-    `subFiles`: List[ReleaseFile]
-        Files within a subgroup
-    """
-
-    def __init__(self, name, files: List[ReleaseFile]):
-        self.files = files
-        self.name = name
-
-        if len(files) == 1:
-            self.mainFile = files[0]
-            self.subFiles = {}
-        else:
-            self.mainFile = None
-            subFiles = []
-            for file in files:
-                # We only have subcategories for Windows where SSE2 is the main group
-                if file.subgroup == "SSE2":
-                    self.mainFile = file
-                else:
-                    subFiles.append(file)
-
-            self.subFiles = dict(((x[0], next(x[1])) for x in groupby(subFiles, lambda f: f.subgroup)))
-
-
-def get_release_files(tag_name, config) -> Tuple[List[ReleaseFile], Dict[str, SourceFile]]:
-    """! Brief Gets the binary and source files from the Github Release server
-
-    @param[in] `tag_name` Git tag of the current release
-    @param[in] `config`   confi metadata set in main.py
-
-    @returns `List[ReleaseFile]`        List of release files
-    @returns `Dict[str, SourceFile]`    Dictionary of source files
-
-    @details Sends an `HTTP GET` request to github using their REST API to retrieve metadata.  The files are not
-        actually downloaded here, just their metadata is gathered and organized in their respective container for later
-        use.
-    """
-
-    @retry_multi(5)	# retry at most 5 times
-    def execute_request(path):
-        """!
-        @brief Performs a GET request with the given path. To be used with Github's REST API.
-        @returns If successful, returns a .JSON object
-        """
-        headers = {
-            "Accept": "application/vnd.github.v3+json"
-        }
-        url = "https://api.github.com" + path
-
-        # GET https://api.github.com/<path> Accept: "application/vnd.github.v3+json"
-
-        response = requests.get(url, headers=headers, timeout=GLOBAL_TIMEOUT)
-
-        response.raise_for_status() # Raise a RequestException if we failed, and trigger retry
-
-        return response.json()
-
-    build_group_regex = re.compile("fs2_open_.*-builds-([^.-]*)(-([^.]*))?.*")  # regex for matching binary .zip's and .7z's
-    source_file_regex = re.compile("fs2_open_.*-source-([^.]*)?.*") # regex for matching source .zip's and .7z's
-
-    # Get the github release metadata of the given tag name
-    response = execute_request(
-        "/repos/{}/releases/tags/{}".format(config["github"]["repo"], tag_name))
-
-    # Extract the binary and source files from the response["asset"] metadata
-    binary_files = []
-    source_files = {}
-    for asset in response["assets"]:
-        url = asset["browser_download_url"]
-        name = asset["name"]
-
-        group_match = build_group_regex.match(name)
-
-        if group_match is not None:
-            platform = group_match.group(1)
-            # x64 is the Visual Studio name but for consistency we need Win64
-            if platform == "x64":
-                platform = "Win64"
-            elif platform == "ARM64":
-                platform = "WinARM64"
-
-            binary_files.append(ReleaseFile(name, url, platform, group_match.group(3)))
-        else:
-            group_match = source_file_regex.match(name)
-
-            if group_match is None:
-                continue
-
-            group = group_match.group(1)
-
-            source_files[group] = SourceFile(name, url, group)
-
-    binary_files.sort(key=lambda ReleaseFile: ReleaseFile.name)
-
-    return binary_files, source_files
-
-
-def get_ftp_files(build_type, tag_name, config) -> List[ReleaseFile] :
-    """!
-    @brief Gets file metadata for nightlies hosted on FTP, as determined by config["ftp"] attributes
-    
-    @param [in] `build_type` Unknown str
-    @param [in] `tag_name`   Github tag name of the release
-    @param [in] `config`     config metadata set in main.py
-    """
-
-    tag_regex = re.compile("nightly_(.*)")
-    build_group_regex = re.compile("nightly_.*-builds-([^.]+).*")
-
-    files = []
-    try:
-        with FTP(config["ftp"]["host"], config["ftp"]["user"], config["ftp"]["pass"]) as ftp:
-            # extract version
-            version_str = tag_regex.match(tag_name).group(1)
-
-            # extract filepath w/ version
-            # then list all ftp hits with that path
-            path_template = config["ftp"]["path"]
-            path = path_template.format(type=build_type, version=version_str)
-            file_entries = list(ftp.mlsd(path, ["type"]))
-
-            # get all ftp hits of type file
-            for entry in file_entries:
-                if entry[1]["type"] == "file":
-                    files.append(entry[0])
-    except error_perm:
-        print("Received permanent FTP error!")
-        return []
-
-    out_data = []
-    for file in files:
-        # from the file list, extract only nightly files
-        file_match = build_group_regex.match(file)
-        if file_match is None:
-            print("Ignoring non nightly file '{}'".format(file))
-            continue
-
-        group_match = file_match.group(1)
-        primary_url = None
-        mirrors = []
-
-        # x64 is the name Visual Studio uses but Win64 works better for us since that gets displayed in the nightly post
-        if "x64" in group_match:
-            group_match = group_match.replace("x64", "Win64")
-        elif "ARM64" in group_match:
-            group_match = group_match.replace("ARM64", "WinARM64")
-
-        # construct the download URL list for all mirrors.  The first listed ftp location is taken as the Primary
-        for mirror in config["ftp"]["mirrors"]:
-            download_url = mirror.format(type=build_type, version=version_str, file=file)
-            if primary_url is None:
-                primary_url = download_url
-            else:
-                mirrors.append(download_url)
-
-        # Form the List[ReleaseFile] list with the download URL links
-        out_data.append(ReleaseFile(file, primary_url, group_match, None, mirrors))
-
-    return out_data

ci/post/forum.py

@@ -1,106 +0,0 @@
-import os
-from typing import List
-
-import requests
-import semantic_version
-from mako.template import Template
-
-from file_list import ReleaseFile
-
-
-class ForumAPI:
-    POST_SIZE_MAX = 50000
-    """!
-    Maximum number of characters allowed in a post, including BBCode (03/17/2022)
-
-    Check with HLP admins occasionally to verify this limit, they can set it in the forum's admin panel
-    """
-
-    def __init__(self, config):
-        self.config = config
-
-    def create_post(self, title, content, board):
-        """!
-        @brief Create a post on the forums
-
-        @param[in] title    Title of the post
-        @param[in] content  Body of the post
-        @param[in] board    Which board/forum to post to
-
-        @returns { "thread_url": <url_of_created_thread> }
-        """
-
-        if (self.config["hlp"]["api"] == "") or (self.config["hlp"]["key"] == ""):
-            print("Post failed! No API or API_KEY given!")
-            return
-
-        resp = requests.post(self.config["hlp"]["api"],
-                             headers={"X-HLP-Bot": os.environ["FORUM_SECRET"]},
-                             data={
-                                "api_key": self.config["hlp"]["key"],
-                                "board": str(board),
-                                "subject": title,
-                                "body": content
-                            })
-
-        if resp.status_code != 200:
-            print("Post failed! Response: %s" %resp.text)
-        
-        return resp.json()
-
-    def post_nightly(self, date, revision, files, log, success):
-        """!
-        @brief Post a new Nightly topic on the forums using nightly.mako
-
-        @param[in] date         The date to use
-        @param[in] version      The build's version
-        @param[in] groups       dict[Any, file_list.FileGroup]; FileGroups of SSE2, AVX, etc.
-        @param[in] sources      URL's of builds on github or fs2net
-        """
-
-        print("Posting nightly thread...")
-
-        title = "Nightly: {} - Revision {}".format(date, revision)
-
-        template = Template(filename=self.config["templates"]["nightly"])
-        rendered = template.render_unicode(**{
-            "date": date,
-            "revision": revision,
-            "files": files,
-            "log": log,
-            "success": success
-        })
-
-        print("Creating post...")
-        self.create_post(title, rendered, self.config["nightly"]["hlp_board"])
-
-    def post_release(self, date, version: semantic_version.Version, groups, sources):
-        """!
-        @brief Post a new Release topic on the forums using release.mako.
-
-        @param[in] date         The date to use
-        @param[in] version      The build's version
-        @param[in] groups       dict[Any, file_list.FileGroup]; FileGroups of SSE2, AVX, etc.
-        @param[in] sources      URL's of builds on github or fs2net
-
-        @returns If Successful, the URL of the created post
-        """
-
-        print("Posting release thread...")
-
-        title = "Release: {}".format(version)
-
-        template = Template(
-            filename=self.config["templates"]["release"].format(major=version.major, minor=version.minor),
-            module_directory='/tmp/mako_modules')
-        rendered = template.render_unicode(**{
-            "date": date,
-            "version": version,
-            "groups": groups,
-            "sources": sources
-        }).strip("\n")
-
-        print("Creating post...")
-
-        json = self.create_post(title, rendered, self.config["release"]["hlp_board"])
-        return json["thread_url"]

ci/post/github.py

@@ -1,85 +0,0 @@
-# Class for use with interfacing with github via HTTP requests
-
-import requests
-
-from util import retry_multi, GLOBAL_TIMEOUT
-
-class GithubAPI:
-    headers = {
-        "Accept": "application/vnd.github.v3+json"
-    }
-    url_root = "https://api.github.com"
-
-    def __init__(self, config):
-        self.config = config
-
-    @retry_multi(5)
-    def get(self, path):
-        """!
-        @brief Performs a GET request with the given path. To be used with Github's REST API.
-        @returns If successful, returns a .JSON object
-        """
-        url = self.url_root + path
-
-        # GET https://api.github.com/<path> Accept: "application/vnd.github.v3+json"
-
-        response = requests.get(url, headers=self.headers, timeout=GLOBAL_TIMEOUT)
-
-        response.raise_for_status() # Raise a RequestException if we failed, and trigger retry
-
-        return response.json()
-    
-    def get_release(self, tag_name):
-        """!
-        @brief Retrieves the Github Release metadata as a JSON object
-        @see https://docs.github.com/en/rest/reference/releases#get-a-release-by-tag-name
-        """
-        return self.get("/repos/{}/releases/tags/{}".format(self.config["github"]["repo"], tag_name))
-
-
-    def patch(self, path, data):
-        """!
-        @brief Performs a PATCH request with the given path and body data (as dictionary)
-        @returns If successful, returns a .JSON object
-        """
-        url = self.url_root + path
-
-        response = requests.patch(url, headers=self.headers, timeout=GLOBAL_TIMEOUT, data=data)
-
-        response.raise_for_status()
-
-        return response.json()
-        
-    def update_release(self, release_id, tag_name="", name="", body="", draft=None, prerelease=None):
-        """!
-        @brief Updates a Github Release
-        @param[in] release_id   The id of the release, as obtained by get_release()
-        @param[in] tag_name     (optional) The git tag this release is associated with
-        @param[in] name         (optional) The name of the release
-        @param[in] body         (optional) Body text describing the release
-        @param[in] draft        (optional) If true, the release is marked as a "draft"
-        @param[in] prerelease   (optional) If true, the release is marked as a "prerelease"
-
-        @note If an optional argument is not provided, then its associated data is not changed
-        """
-        path = "/repos/{}/releases/{}".format(self.config["github"]["repo"], release_id)
-
-        # Add to the data JSON if options are specified
-        data = {}
-        if tag_name != "":
-            data["tag_name"] = tag_name
-        
-        if name != "":
-            data["name"] = name
-
-        if body != "":
-            data["body"] = body
-        
-        if draft != None:
-            data["draft"] = data
-
-        if prerelease != None:
-            data["prerelease"] = prerelease
-        
-        self.patch(path, data)
-

ci/post/installer.py

@@ -1,88 +0,0 @@
-import os
-import hashlib
-import tarfile
-import traceback
-import zipfile
-from tempfile import NamedTemporaryFile
-from zipfile import ZipFile
-
-import requests
-import sys
-from mako.template import Template
-
-from file_list import ReleaseFile
-from util import GLOBAL_TIMEOUT
-
-
-def _download_file(url, dest_file, session):
-    print("Downloading " + url)
-    # NOTE the stream=True parameter
-    r = session.get(url, stream=True, timeout=GLOBAL_TIMEOUT)
-    for chunk in r.iter_content(chunk_size=1024):
-        if chunk:  # filter out keep-alive new chunks
-            dest_file.write(chunk)
-    dest_file.flush()
-
-
-def _gen_hash(fileobj, hash_alg):
-    h = hashlib.new(hash_alg)
-    while True:
-        data = fileobj.read(4096)
-
-        if not data:
-            break
-
-        h.update(data)
-
-    return h.hexdigest()
-
-
-def get_hashed_file_list(file: ReleaseFile, session: requests.Session = None, hash_alg: str = "sha256"):
-    if session is None:
-        session = requests.Session()
-
-    with NamedTemporaryFile('w+b', suffix=file.filename) as local_file:
-        _download_file(file.url, local_file, session)
-
-        filename = local_file.name
-        hash_list = []
-
-        local_file.seek(0)
-        file.hash = _gen_hash(local_file, hash_alg)
-        file.size = os.stat(filename).st_size
-
-        try:
-            if tarfile.is_tarfile(filename):
-                with tarfile.open(filename) as archive:
-                    for entry in archive:
-                        if not entry.isfile():
-                            continue
-
-                        print("Computing hash for " + entry.name)
-                        fileobj = archive.extractfile(entry)
-                        hash_list.append((entry.path, _gen_hash(fileobj, hash_alg)))
-            elif zipfile.is_zipfile(filename):
-                with ZipFile(filename) as archive:
-                    for entry in archive.infolist():
-                        # Python 3.6 has is_dir but that version is relatively new so we'll use the "safe" version here
-                        if entry.filename.endswith('/'):
-                            continue
-
-                        print("Computing hash for " + entry.filename)
-                        with archive.open(entry) as fileobj:
-                            hash_list.append((entry.filename, _gen_hash(fileobj, hash_alg)))
-            else:
-                raise NotImplementedError("Unsupported archive type!")
-        except:
-            traceback.print_exception(*sys.exc_info())
-            return
-
-        file.content_hashes = hash_list
-
-
-def render_installer_config(version, groups, config):
-    template = Template(filename=config["templates"]["installer"], module_directory='/tmp/mako_modules')
-    return template.render(**{
-        "version": version,
-        "groups": groups,
-    }).strip("\n")

ci/post/main.py

@@ -1,314 +0,0 @@
-# Post-build python script
-# Uploads build packages to Nebula and creates a forum post on https://www.hard-light.net
-# Uses the following environment variables (Set by the github action workflow before execution)
-
-# FSO versioning
-# FSO_VERSION_MAJOR
-# FSO_VERSION_MINOR
-# FSO_VERSION_BUILD
-
-# Credentials into IndieGames file host
-# INDIEGAMES_USER:
-# INDIEGAMES_SSHPASS:
-
-# Credentials into Nebula Mod Database
-# NEBULA_USER:
-# NEBULA_PASSWORD:
-
-# Credentials into hard-light.net for forum post
-# HLP_API:
-# HLP_KEY:
-# FORUM_SECRET:
-
-# LINUX_RESULT: bool, if the linux builds were successfully uploaded
-# WINDOWS_RESULT: bool, if the windows builds were successfully uploaded
-
-import sys
-import os
-import re
-from subprocess import check_output
-from datetime import datetime
-from itertools import groupby
-
-import semantic_version
-
-# local .py files
-import file_list
-import installer
-import nebula
-import forum
-
-# Compile regexes for extracting version components
-MAJOR_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_MAJOR (\d+)\)")
-MINOR_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_MINOR (\d+)\)")
-BUILD_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_BUILD (\d+)\)")
-REVISION_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_REVISION (\d+)\)")
-REVISION_STR_VERSION_PATTERN = re.compile("(?:set_if_not_defined|set)\(FSO_VERSION_REVISION_STR (\w*)\)")
-
-LOG_FORMAT = """
-------------------------------------------------------------------------%n
-commit %h%nAuthor: %an <%ad>%n
-Commit: %cn <%cd>%n%n    %s
-"""
-DATEFORMAT_VERSION = "%Y%m%d"
-DATEFORMAT_FORUM = "%d %B %Y"
-
-def _match_version_number(text, regex):
-	"""! Extracts the version component represented by `regex` from `text`
-	
-	@param [in] `text`  Filename with version string 'MAJOR.MINOR.BUILD'
-	@param [in] `regex` Regex pattern of component to look for
-
-	@return The version component as integer
-	"""
-	match = regex.search(text)
-	return int(match.group(1))
-
-def _match_version_str(text, regex):
-	"""! Extracts the version component represented by `regex` from `text`
-	
-	@param [in] `text`  Filename with version string 'MAJOR.MINOR.BUILD'
-	@param [in] `regex` Regex pattern of component to look for
-
-	@return The version component as integer
-	"""
-	match = regex.search(text)
-	return match.group(1)
-	
-
-def get_source_version(date_version: datetime, tag_name: str) -> semantic_version.Version:
-	"""! Retrieves the version string from version_override.cmake (and version.cmake)
-
-	@param[in] `date_version` Date this build is published for release
-	@param[in] `tag_name`     Tag of this release, used to determine if release, rc, or nightly
-
-	@return If release: `FSO_VERSION_MAJOR.FSO_VERSION_MINOR.FSO_VERSION_BUILD`
-	@return If rc:      `FSO_VERSION_MAJOR.FSO_VERSION_MINOR.FSO_VERSION_BUILD-FSO_VERSION_REVISION_STR`
-	@return If nightly: `FSO_VERSION_MAJOR.FSO_VERSION_MINOR.FSO_VERSION_BUILD-FSO_VERSION_REVISION_STR` (uses both version_override.cmake and version.cmake)
-
-	@note This is the version used to identify in Nebula and the forums.  version_override.cmake is used for the builds
-	  made by CI tools and version.cmake is used for builds made by devs.
-	"""
-
-	with open(os.path.join("..", "..", "version_override.cmake"), "r") as f:
-		filetext = f.read()
-		major = _match_version_number(filetext, MAJOR_VERSION_PATTERN)
-		minor = _match_version_number(filetext, MINOR_VERSION_PATTERN)
-		build = _match_version_number(filetext, BUILD_VERSION_PATTERN)
-		# revision = _match_version_number(filetext, REVISION_VERSION_PATTERN)
-		revision_str = _match_version_str(filetext, REVISION_STR_VERSION_PATTERN)
-
-	print("Parsing version_override.cmake...")
-	if "rc" in tag_name.lower():
-		version = semantic_version.Version("{}.{}.{}-{}".format(major, minor, build, revision_str))
-
-	elif "release" in tag_name.lower():
-		version = semantic_version.Version("{}.{}.{}".format(major, minor, build))
-
-	elif "nightly" in tag_name.lower():
-		# Nightly's version_override.cmake only has FSO_VERSION_REVISION and FSO_VERSION_REVISION_STR set
-		# So, we have to pull the rest of the version string from version.cmake
-		print("Parsing version.cmake...")
-		with open(os.path.join("..", "..", "cmake", "version.cmake"), "r") as f:
-			major = _match_version_number(filetext, MAJOR_VERSION_PATTERN)
-			minor = _match_version_number(filetext, MINOR_VERSION_PATTERN)
-			build = _match_version_number(filetext, BUILD_VERSION_PATTERN)
-		version = semantic_version.Version("{}.{}.{}-{}".format(major, minor, build, revision_str))
-	
-	else:	
-		print("  ERROR: malformed tag_name %s" % tag_name)
-		sys.exit(1)
-
-	print("  version: {}".format(version))
-	print("  version.prerelease: {}".format(version.prerelease))
-	return version
-
-
-def main():
-	if "FORUM_SECRET" not in os.environ or not os.environ["FORUM_SECRET"]:
-		print("  ERROR: FORUM_SECRET environment variable not set")
-		sys.exit(1)
-
-	os.chdir(os.path.dirname(__file__))	# Change working directory to this file's directory
-
-	# Aggregate configuration data in a dictionary
-	config = {
-		"github": {
-			"repo": os.environ["GITHUB_REPO"],
-		},
-		"ftp": {
-			"host": "scp.indiegames.us",
-			"user": os.environ["INDIEGAMES_USER"],
-			"pass": os.environ["INDIEGAMES_SSHPASS"],
-			"path": "public_html/builds/{type}/{version}/",
-			"mirrors": (
-				"https://perses.feralhosting.com/datacorder/builds/{type}/{version}/{file}",
-				"https://scp.indiegames.us/builds/{type}/{version}/{file}",
-			),
-		},
-		"nebula": {
-			"user": os.environ["NEBULA_USER"],
-			"password": os.environ["NEBULA_PASSWORD"],
-		},
-		"hlp": {
-			"api": os.environ["HLP_API"],
-			"key": os.environ["HLP_KEY"],
-		},
-		"templates": {
-			"nightly": "nightly.mako",
-			"release": "release.mako",
-		},
-		"nightly": {
-			"hlp_board": 173,
-		},
-		"release": {
-			"hlp_board": 50,
-		},
-	}
-
-	# bail if this script is run from a workflow that doesn't identify as a release or nightly
-	if sys.argv[1] not in ("release", "nightly"):
-		print("ERROR: Invalid release mode %s passed. Expected release or nightly!" % sys.argv[1])
-		sys.exit(1)
-
-	linux_success = os.environ["LINUX_RESULT"] == "success"
-	windows_success = os.environ["WINDOWS_RESULT"] == "success"
-	if (sys.argv[1] == "release"):
-		if not (linux_success and windows_success):
-			# bail if this is a release and either build workflow failed
-			print("ERROR: One or more builds failed to publish! Cannot post release.")
-			sys.exit(1)
-	else:
-		if not (linux_success or windows_success):
-			# bail if this is a nightly build and both build workflows failed
-			print("ERROR: All builds failed to publish! Cannot post nightly.")
-			sys.exit(1)
-	
-	# bail if tag_name doesn't match with sys.argv[1]
-	tag_name = os.environ["RELEASE_TAG"]	##!< commit tag string
-	if (sys.argv[1] == "release") and (not tag_name.startswith("release_")):
-		print("ERROR: Invalid tag name detected. Expected release_ prefix for release builds but found %s (full ref = %s)" % tag_name, os.environ["GITHUB_REF"])
-		sys.exit(1)
-
-	if (sys.argv[1] == "nightly") and (not tag_name.startswith("nightly_")):
-		print("ERROR: Invalid tag name detected. Expected nightly_ prefix for nightly builds but found %s (full ref = %s)" % tag_name, os.environ["GITHUB_REF"])
-		sys.exit(1)
-
-	# bail if tag_name does not exist in the repo
-	if not check_output(("git", "show-ref", "--tags", "refs/tags/%s" % tag_name), text=True):
-		print("ERROR: Couldn't find tag %s in repo (git show-ref)!" % tag_name)
-		sys.exit(1)
-
-	# Populate version and date
-	date = datetime.now()	##!< current date
-	version = get_source_version(date.strftime(DATEFORMAT_VERSION), tag_name)	##!< form full version string
-	
-	# find the previous tag release (used by nightly)
-	tags = check_output(("git", "for-each-ref", "--sort=-taggerdate", "--format='%(tag)'", "refs/tags"), text=True).splitlines()	# retrieve all tags in the repo by using git on the shell
-	# NOTE: check_output returns canonical string representation. use repr() on strings its being compared to
-	previous_tag = None
-	found = False
-	for tag in tags:
-		if found:
-			# Look for the "previous" tag with the same configuration ('release_' or 'nightly_')
-			# Assumes older tags have a higher index than newer
-			if tag.startswith("\'" + sys.argv[1] + "_"):
-				previous_tag = tag
-				break
-		elif tag == repr(tag_name):
-			# Ok, found the tag
-			found = True
-
-	if not found:
-		# couldn't find tag, bail
-		print("ERROR: Couldn't find tag %s in repo! (git for-each-ref)" % tag_name)
-		sys.exit(1)
-
-	if (sys.argv[1] == "nightly") and (not previous_tag):
-		# couldn't find previous tag, bail
-		print("ERROR: Could not find a previous tag for %s!" % tag_name)
-		sys.exit(1)
-
-	if sys.argv[1] == "release":
-		# Release specific action
-		print("Retrieving file list...")
-		files, sources = file_list.get_release_files(tag_name, config)
-
-		print("Hashing files...")
-		for file in files:
-			installer.get_hashed_file_list(file)
-
-		# Construct the file groups
-		# split the file list into a dictionary of {group: files} pairs using `groupby()`
-		# Since `groupby()` returns a iterator reference to the original files list, we have to do a weird hand toss
-		# to save it as a dictionary
-		## NOTE z64: files need to be sorted or else key duplication will occur!
-		groups = {key: file_list.FileGroup(key, list(group)) for key, group in groupby(files, lambda g: g.group)}
-		
-		# Error check for all group keys and subkeys to be used in the mako.  Do this here for better debugging QoL
-		if "Win32" in groups.keys():
-			if "AVX" not in groups["Win32"].subFiles.keys():
-				print("ERROR: No Win32-AVX builds were detected!")
-				sys.exit(1)
-		else:
-			print("ERROR: No Win32 builds were detected!")
-			sys.exit(1)
-
-		if "Win64" in groups.keys():
-			if "AVX" not in groups["Win64"].subFiles.keys():
-				print("ERROR: No x64-AVX builds were detected!")
-				sys.exit(1)
-		else:
-			print("ERROR: No x64 builds were detected!")
-			sys.exit(1)
-		
-		if "Linux" not in groups.keys():
-			print("ERROR: No Linux builds were detected!")
-			sys.exit(1)
-
-		if "Mac" not in groups.keys():
-			print("ERROR: No Mac builds were detected!")
-			sys.exit(1)
-		
-		# z64: What dose this do???
-		# print(installer.render_installer_config(version, groups, config))
-
-		# Publish release builds to Nebula
-		print("Publishing to Nebula...")
-		nebula.submit_release(
-			nebula.render_nebula_release(version, "rc" if version.prerelease else "stable", files, config),
-			config)
-
-		# Publish forum post, using the release.mako template
-		print("Publishing to Hard-light.net...")
-		fapi = forum.ForumAPI(config)
-		fapi.post_release(date.strftime(DATEFORMAT_FORUM), version, groups, sources)
-
-	else:
-		# Dead for now, nightly publish is done elsewhere
-		# Nightly specific action
-		print("Retrieving file list...")
-		files = file_list.get_ftp_files("nightly", tag_name, config)
-
-		print("Hashing files...")
-		for file in files:
-			installer.get_hashed_file_list(file)
-
-		print("Publishing to Nebula...")
-		nebula.submit_release(
-			nebula.render_nebula_release(version, "nightly", files, config),
-			config)
-
-		# Compile commit messages into a log with all commits between this nightly and the previous nightly
-		log = check_output(("git", "log", "%s^..%s^" % (previous_tag, tag_name), "--no-merges", "--stat", "--pretty=format:\"%s\"" % LOG_FORMAT.strip()))
-
-		# Publish forum post, using the nighty.mako template
-		print("Publishing to Hard-light.net...")
-		fapi = forum.ForumAPI(config)
-		fapi.post_nightly(date.strftime(DATEFORMAT_FORUM), os.environ["GITHUB_SHA"], files, log, (linux_success and windows_success))
-
-	print("Done!")
-
-
-if __name__ == "__main__":
-	main()

ci/post/nebula.py

@@ -1,260 +0,0 @@
-import os.path
-import sys
-import traceback
-
-import requests
-
-from file_list import ReleaseFile
-from util import retry_multi, GLOBAL_TIMEOUT
-
-LINUX_X64_KEY = "Linux-x86_64"
-LINUX_ARM64_KEY = "Linux-arm64"
-MACOSX_X64_KEY = "Mac-x86_64"
-MACOSX_ARM64_KEY = "Mac-arm64"
-WIN32_SSE2_KEY = "Win32-SSE2"
-WIN64_SSE2_KEY = "Win64-SSE2"
-WIN32_AVX_KEY = "Win32-AVX"
-WIN64_AVX_KEY = "Win64-AVX"
-WINARM64_KEY = "WinARM64"
-
-metadata = {
-    'type': 'engine',
-    'title': 'FSO',
-    'notes': '',
-    'banner': 'https://fsnebula.org/storage/0d/e7/bf64bcdea9a9c115969cfb784e1ca457d24a7c2da4fc6f213521c3bb6abb.png',
-    'screenshots': [],
-    'videos': [],
-    'first_release': '2017-09-24',
-    'cmdline': '',
-    'mod_flag': ['FSO'],
-    'tile': 'https://fsnebula.org/storage/ec/cc/0bf23e028c26d5175ff52d003bff85b0a17b0ddfc1130d65bdf6d36f6324.png',
-    'logo': None,
-    'release_thread': None,
-    'description': '',
-    'id': 'FSO',
-    'packages': [],
-}
-
-platforms = {
-    LINUX_X64_KEY: 'linux',
-    LINUX_ARM64_KEY: 'linux',
-    MACOSX_X64_KEY: 'macosx',
-    MACOSX_ARM64_KEY: 'macosx',
-    WIN32_SSE2_KEY: 'windows',
-    WIN64_SSE2_KEY: 'windows',
-    WIN32_AVX_KEY: 'windows',
-    WIN64_AVX_KEY: 'windows',
-    WINARM64_KEY: 'windows',
-}
-
-envs = {
-    LINUX_X64_KEY: 'linux && x86_64',
-    LINUX_ARM64_KEY: 'linux && arm64',
-    MACOSX_X64_KEY: 'macosx && x86_64',
-    MACOSX_ARM64_KEY: 'macosx && arm64',
-    WIN32_SSE2_KEY: 'windows',
-    WIN64_SSE2_KEY: 'windows && x86_64',
-    WIN32_AVX_KEY: 'windows && avx',
-    WIN64_AVX_KEY: 'windows && avx && x86_64',
-    WINARM64_KEY: 'windows && arm64'
-}
-
-subdirs = {
-    WIN32_SSE2_KEY: 'x86',
-    WIN64_SSE2_KEY: 'x64',
-    WIN32_AVX_KEY: 'x86_avx',
-    WIN64_AVX_KEY: 'x64_avx'
-}
-
-
-def render_nebula_release(version, stability, files, config):
-    meta = metadata.copy()
-    meta['version'] = str(version)
-    meta['stability'] = stability  # This can be one of ('stable', 'rc', 'nightly')
-
-    for file in files:
-        if file.content_hashes is None:
-            # The extraction probably failed which is why we don't have any hashes
-            continue
-
-        group = file.group
-
-        # release.py sets subgroup but nightly.py doesn't which means we have to normalize group here.
-        if file.subgroup:
-            group += '-' + file.subgroup
-
-        pkg = {
-            'name': group,
-            'notes': '',
-            'is_vp': False,
-            'files': [{
-                'dest': platforms[group] + '/' + subdirs.get(group, ''),
-                'filesize': file.size,
-                'checksum': ['sha256', file.hash],
-                'urls': [file.url] + file.mirrors,
-                'filename': file.name
-            }],
-            'environment': envs.get(group),
-            'filelist': [],
-            'status': 'required',
-            'folder': None,
-            'dependencies': [],
-            'executables': []
-        }
-
-        for fn, checksum in file.content_hashes:
-            if group in subdirs:
-                dest_fn = subdirs[group] + '/' + fn
-            else:
-                dest_fn = fn
-
-            # If the group is a known platform then we put the binaries into a separate subfolder for each platform
-            if group in platforms:
-                dest_fn = platforms[group] + '/' + dest_fn
-
-            pkg['filelist'].append({
-                'orig_name': fn,
-                'checksum': ('sha256', checksum),
-                'archive': file.name,
-                'filename': dest_fn
-            })
-
-            if group.startswith('Linux') and fn.endswith('.AppImage'):
-                if 'qtfred' in fn:
-                    if '-FASTDBG' in fn:
-                        label = 'QtFRED Debug'
-                    else:
-                        label = 'QtFRED'
-
-                else:
-                    if '-FASTDBG' in fn:
-                        label = 'Fast Debug'
-                    else:
-                        label = None
-
-                props = {
-                    "arm64": "arm64" in fn,
-                    "x64": "x64" in fn,
-                    "sse2": True,  # Linux builds are forced to compile with SSE2 but not AVX
-                    "avx": False,
-                    "avx2": False,
-                }
-
-                pkg['executables'].append({
-                    'file': dest_fn,
-                    'label': label,
-                    'properties': props,
-                })
-            elif group.startswith('Mac') and fn.startswith(os.path.basename(fn) + '.app/'):
-                if 'qtfred' in fn:
-                    if '-FASTDBG' in fn:
-                        label = 'QtFRED Debug'
-                    else:
-                        label = 'QtFRED'
-                else:
-                    if '-FASTDBG' in fn:
-                        label = 'Fast Debug'
-                    else:
-                        label = None
-
-                props = {
-                    "arm64": "arm64" in fn,
-                    "x64": "x64" in fn,
-                    "sse2": True,  # There are no forced options on mac but 64-bit always implies SSE2 so we set that here
-                    "avx": False,
-                    "avx2": False,
-                }
-
-                pkg['executables'].append({
-                    'file': dest_fn,
-                    'label': label,
-                    'properties': props,
-                })
-            elif group.startswith('Win') and fn.endswith('.exe'):
-                if 'fred2' in fn:
-                    if '-FASTDBG' in fn:
-                        label = 'FRED2 Debug'
-                    else:
-                        label = 'FRED2'
-
-                elif 'qtfred' in fn:
-                    if '-FASTDBG' in fn:
-                        label = 'QtFRED Debug'
-                    else:
-                        label = 'QtFRED'
-
-                else:
-                    if '-FASTDBG' in fn:
-                        label = 'Fast Debug'
-                    else:
-                        label = None
-
-                props = {
-                    "x64": "x64" in fn,
-                    "sse2": "SSE2" in fn or "AVX" in fn,  # AVX implies SSE2
-                    "avx": "AVX" in fn,  # This conveniently also covers the AVX2 case since AVX2 implies AVX
-                    "avx2": "AVX2" in fn,
-                    "arm64": "arm64" in fn,
-                }
-
-                pkg['executables'].append({
-                    'file': dest_fn,
-                    'label': label,
-                    'properties': props,
-                })
-
-        meta["packages"].append(pkg)
-
-    return meta
-
-
-@retry_multi(5)
-def nebula_request(session, kind, path, **kwargs):
-    uri = "https://fsnebula.org/api/1/{}".format(path)
-
-    request_args = {
-        "timeout": GLOBAL_TIMEOUT
-    }
-    request_args.update(kwargs)
-
-    return session.request(kind, uri, **request_args)
-
-
-def submit_release(meta, config):
-    try:
-        with requests.Session() as session:
-            print('Logging into Nebula...')
-            result = nebula_request(session, 'post', 'login', data={
-                'user': config['nebula']['user'],
-                'password': config['nebula']['password']
-            })
-
-            if result.status_code != 200:
-                print('Login failed!')
-                return False
-
-            data = result.json()
-            if not data['result']:
-                print('Login failed!')
-                return False
-
-            print('Submitting release...')
-            result = nebula_request(session, 'post', 'mod/release', headers={
-                'X-KN-TOKEN': data['token']
-            }, json=meta)
-
-            if result.status_code != 200:
-                print('Request failed!')
-                return False
-
-            data = result.json()
-            if not data['result']:
-                print('ERROR: ' + data['reason'])
-                return False
-
-            print('Success!')
-            return True
-    except Exception:
-        exc_type, exc_value, exc_traceback = sys.exc_info()
-        traceback.print_exception(exc_type, exc_value, exc_traceback)
-        return False

ci/post/nightly.mako

@@ -1,27 +0,0 @@
-Here is the nightly for ${date} - Revision ${revision}
-
-% if not success:
-[b][color=red]At least one of the nightly builds failed![/color][/b]
-% endif
-% for file in files:
-
-
-Group: ${file.group}
-[url=${file.url}]${file.name}[/url] \
-    %for mirror in file.mirrors:
-        %if loop.first:
-(\
-        %endif
-[url=${mirror}]Mirror[/url]\
-        %if loop.last:
-)\
-        %else:
-, \
-        %endif
-    %endfor
-
-% endfor
-
-[code]
-${log}
-[/code]

ci/post/release.mako

@@ -1,79 +0,0 @@
-
-<%def name="build(file)">[url=${file.url}]${file.filename}[/url]</%def>
-
-[b]Change log:[/b] (chronologically ordered)
-PLACEHOLDER
-
-[b]Deprecations:[/b]
-PLACEHOLDER
-
-Deprecations are a mechanism in FSO where a certain feature or aspect of the engine has changed or is no longer supported. Since this would normally break existing mods, we have the mod table feature "[tt]$Target Version:[/tt]" with which a mod can specify what version of FSO it was developed with. Any features listed under Deprecations will be removed or changed when the target version of a mod is at least the version released in this post.
-
-[size=5pt]Previous [url=https://www.hard-light.net/forums/index.php?topic=99015.0]23.2.1 Release Thread[/url][/size]
-
-Launchers, if you don't have one already:
-[b]All platforms: [/b] For every day use, we recommend [url=https://knossosnet.github.io/Knossos-Release-Page/]Knossos.NET[/url], an integrated solution for downloading and launching mods.
-
-[hidden=Alternative Launchers]
-Cross-platform: [url=https://www.hard-light.net/forums/index.php?topic=89162]wxLauncher 0.12.x Test Build[/url] (legacy project for a unified launcher)
-[b]Important:[/b] For best compatibility with FSO 3.8 and later you should use at least wxLauncher 0.12.
-
-Windows:  [url=http://scp.fsmods.net/builds/Launcher55g.zip]Launcher 5.5g[/url] ([url=https://scp.indiegames.us/builds/Launcher55g.zip]Mirror[/url]) ([url=https://www.mediafire.com/?wdvzn7hhhzh418m]Mirror[/url]) Not compatible with Windows 8+, use wxLauncher above
-OS X:  Soulstorm's [url=https://www.hard-light.net/forums/index.php/topic,51391.0.html]OS X Launcher 3.0[/url]
-Linux:  [url=https://www.hard-light.net/forums/index.php/topic,53206.0.html]YAL[/url] or [url=https://www.hard-light.net/wiki/index.php/Fs2_open_on_Linux/Graphics_Settings]by hand[/url] or whatever you can figure out.[/hidden]
-
-[img]https://scp.indiegames.us/img/windows-icon.png[/img] [color=green][size=12pt]Windows (32/64-bit/ARM64)[/size][/color]
-[size=8pt]Compiled using GitHub Actions on Windows Server 2019 (10.0.17763), Visual Studio Enterprise 2019[/size]
-
-[b]64-bit:[/b] ${build(groups["Win64"].mainFile)}
-
-[b]32-bit:[/b] ${build(groups["Win32"].mainFile)}
-[size=8pt]This one is based on the SSE2 Optimizations from the MSVC Compiler.[/size]
-
-[b]ARM64:[/b] ${build(groups["WinARM64"].mainFile)}
-
-[hidden=Alternative builds]
-
-[b]64-bit AVX:[/b] ${build(groups["Win64"].subFiles["AVX"])}
-[size=8pt]This one is based on the AVX Optimizations from the MSVC Compiler (fastest build if your CPU supports AVX instructions).[/size]
-
-
-[b]32-bit AVX:[/b] ${build(groups["Win32"].subFiles["AVX"])}
-[size=8pt]This one is based on the AVX Optimizations from the MSVC Compiler.[/size]
-
-[b]What are those SSE, SSE2 and AVX builds I keep seeing everywhere?[/b]
-[url=https://www.hard-light.net/forums/index.php?topic=65628.0]Your answer is in this topic.[/url]
-Don't want to deal with that? Use [url=https://knossosnet.github.io/Knossos-Release-Page/]Knossos.NET[/url] and it will download the best build specifically for your PC!
-[/hidden]
-
-[img]https://scp.indiegames.us/img/linux-icon.png[/img] [color=green][size=12pt]Linux[/size][/color]
-[size=8pt]Compiled with Ubuntu 20.04 LTS, GCC 9[/size]
-[b]x86_64:[/b] ${build(groups["Linux"].subFiles["x86_64"])}
-[b]arm64:[/b] ${build(groups["Linux"].subFiles["arm64"])}
-
-These builds use a mechanism called [url=https://appimage.org/]AppImage[/url] which should allow these builds to run on most Linux distributions. However, we recommend that you compile your own builds which will result in less issues.
-Alternatively, if there is a package in your software repository then you should use that. If you are the maintainer of such a package for a distribution then let us know and we will include that here.
-
-
-[img]https://scp.indiegames.us/img/mac-icon.png[/img] [color=green][size=12pt]macOS[/size][/color]
-[size=8pt]macOS 10.9+[/size]
-[b]Intel (64-bit):[/b] ${build(groups["Mac"].subFiles["x86_64"])}
-[b]Apple Silicon:[/b] ${build(groups["Mac"].subFiles["arm64"])}
-
-These builds are not signed and so by default will fail to launch. To run them simply right-click on the app, click open, then click open again on the security confirmation dialog. You should only have to do this once for each app.
-If running the game through Knossos or Knossos.NET this step should not be necessary.
-
-[size=8pt][color=red][b]NOTE:[/b][/color] macOS builds currently have limited support and may exhibit issues not present on other platforms.[/size]
-
-
-[hidden=TrackIR Users]
-[size=12pt]Important!![/size]
-An external DLL is required for FSO to use TrackIR functions.  The following DLL is simply unpacked in to your main FreeSpace2 root dir.
-TrackIR is only supported on Windows.
-[url=https://www.mediafire.com/download.php?4zw024zrh44etse]TrackIR SCP DLL[/url] ([url=http://scp.fsmods.net/builds/scptrackir.zip]Mirror[/url]) ([url=https://scp.indiegames.us/builds/scptrackir.zip]Mirror[/url])[/hidden]
-
-Known issues:
-[list]
-[li][url=https://github.com/scp-fs2open/fs2open.github.com/issues]Github issues[/url] and [url=https://github.com/scp-fs2open/fs2open.github.com/pulls]pending pull requests[/url][/li]
-[li]See the list of [url=https://github.com/scp-fs2open/fs2open.github.com/projects/8]bugs ranked by priority[/url][/li]
-[/list]

ci/post/requirements.txt

@@ -1,3 +0,0 @@
-Mako==1.4.2
-requests==2.33.0
-semantic-version==2.8.5

ci/post/util.py

@@ -1,46 +0,0 @@
-# miscellaneous utilities
-
-import os
-import time
-from functools import wraps
-
-from requests import RequestException
-
-GLOBAL_TIMEOUT = 30
-
-def retry_multi(max_retries):
-    """!
-    @brief Decorator - Retry a function `max_retries` times.
-    
-    @param [in] `max_retries` Maximum number of times to retry the decorated function before giving up
-
-    @details  Intended for use with functions from the `request` module, only catches `RequestException`'s
-    @note This has been copied from https://stackoverflow.com/a/23892489
-    """
-
-    def retry(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            num_retries = 0
-            while num_retries <= max_retries:
-                try:
-                    ret = func(*args, **kwargs)
-                    break
-                except RequestException:
-                    if num_retries == max_retries:
-                        raise
-                    num_retries += 1
-                    time.sleep(5)
-            return ret
-
-        return wrapper
-
-    return retry
-
-
-def expand_config_vars(config):
-    """
-    @brief Expands the shell variable for the repo string from `config`
-    """
-
-    config["git"]["repo"] = os.path.expandvars(config["git"]["repo"])

ci/windows/install_v143_atlmfc.ps1

@@ -1,34 +0,0 @@
-# Installs ATL and MFC for the v143 toolset, which the Visual Studio 2026 runner images
-# only ship for the latest toolset.  ATL is needed by SAPI speech (sphelper.h) and MFC by FRED2.
-
-$ErrorActionPreference = 'Stop'
-
-$msvcVersion = '14.44'
-$component = 'Microsoft.VisualStudio.Component.VC.14.44.17.14'
-$suffix = if ($env:RUNNER_ARCH -eq 'ARM64') { '.ARM64' } else { '' }
-
-$installerDir = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer"
-$installPath = & "$installerDir\vswhere.exe" -version '[18.0,19.0)' -latest -property installationPath
-if (-not $installPath) {
-    Write-Error 'Visual Studio 2026 was not found'
-}
-
-$arguments = @(
-    '/c', 'vs_installer.exe', 'modify',
-    '--installPath', "`"$installPath`"",
-    '--add', "$component.ATL$suffix",
-    '--add', "$component.MFC$suffix",
-    '--quiet', '--norestart', '--nocache'
-)
-$process = Start-Process -FilePath cmd.exe -ArgumentList $arguments -WorkingDirectory $installerDir -Wait -PassThru -NoNewWindow
-# 3010 = success, reboot required
-if ($process.ExitCode -notin 0, 3010) {
-    Write-Error "vs_installer exited with code $($process.ExitCode)"
-}
-
-# fail here rather than with a confusing compile error if the components didn't install
-foreach ($header in 'atlbase.h', 'afxwin.h') {
-    if (-not (Test-Path "$installPath\VC\Tools\MSVC\$msvcVersion.*\atlmfc\include\$header")) {
-        Write-Error "$header for MSVC $msvcVersion is missing after install"
-    }
-}

cmake-variants.yaml

@@ -1,16 +0,0 @@
-buildType:
-  default: release
-  description: R
-  choices:
-    release:
-      short: Release
-      long: Release builds
-      buildType: Release
-    fastDebug:
-      short: FastDebug
-      long: Debug with optimizations
-      buildType: FastDebug
-    debug:
-      short: Debug
-      long: Debug without optimizations
-      buildType: Debug

cmake/CleanDirectoryList.cmake

@@ -1,48 +0,0 @@
-# - Removes duplicate entries and non-directories from a provided list
-#
-#  clean_directory_list(<listvar> [<additional list items>...])
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__clean_directory_list)
-	return()
-endif()
-set(__clean_directory_list YES)
-
-function(clean_directory_list _var)
-	# combine variable's current value with additional list items
-	set(_in ${${_var}} ${ARGN})
-
-	if(_in)
-		# Initial list cleaning
-		list(REMOVE_DUPLICATES _in)
-
-		# Grab the absolute path of each actual directory
-		set(_out)
-		foreach(_dir ${_in})
-			if(IS_DIRECTORY "${_dir}")
-				get_filename_component(_dir "${_dir}" ABSOLUTE)
-				file(TO_CMAKE_PATH "${_dir}" _dir)
-				list(APPEND _out "${_dir}")
-			endif()
-		endforeach()
-
-		if(_out)
-			# Clean up the output list now
-			list(REMOVE_DUPLICATES _out)
-		endif()
-
-		# return _out
-		set(${_var} "${_out}" PARENT_SCOPE)
-	endif()
-endfunction()

cmake/CreateLaunchers.cmake

@@ -1,311 +0,0 @@
-# - Create launchers to set working directory, env. vars, etc.
-#
-#  include(CreateLaunchers) - to make these available
-#  guess_runtime_library_dirs(<outputvarname> [<extralibrary> ...])
-#  create_default_target_launcher(<targetname>
-#    [ARGS <args...>]
-#    [FORWARD_ARGS]
-#    [RUNTIME_LIBRARY_DIRS <dir...>]
-#    [WORKING_DIRECTORY <dir>]
-#    [ENVIRONMENT <VAR=value> [<VAR=value>...]])
-#
-#  create_target_launcher(<targetname>
-#    [ARGS <args...>]
-#    [FORWARD_ARGS]
-#    [RUNTIME_LIBRARY_DIRS <dir...>]
-#    [WORKING_DIRECTORY <dir>]
-#    [ENVIRONMENT <VAR=value> [<VAR=value>...]])
-#
-#  create_generic_launcher(<launchername>
-#    [RUNTIME_LIBRARY_DIRS <dir...>]
-#    [WORKING_DIRECTORY <dir>]
-#    [ENVIRONMENT <VAR=value> [<VAR=value>...]])
-#    - sets GENERIC_LAUNCHER_COMMAND and GENERIC_LAUNCHER_FAIL_REGULAR_EXPRESSION
-#
-# Requires these CMake modules:
-#  ListFilter
-#  ProgramFilesGlob
-#  CleanDirectoryList
-#
-# Requires CMake 2.6 or newer (uses the 'function' command)
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__create_launchers)
-	return()
-endif()
-set(__create_launchers YES)
-
-include(CleanDirectoryList)
-
-# We must run the following at "include" time, not at function call time,
-# to find the path to this module rather than the path to a calling list file
-get_filename_component(_launchermoddir
-	${CMAKE_CURRENT_LIST_FILE}
-	PATH)
-set(_launchermoddir "${_launchermoddir}/launcher-templates")
-
-macro(_launcher_system_settings)
-	if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-		set(BITS 64)
-	else()
-		set(BITS 32)
-	endif()
-
-	if(WIN32)
-		# Find user and system name
-		set(SYSTEM_NAME $ENV{USERDOMAIN})
-		set(USER_NAME $ENV{USERNAME})
-		set(VCPROJ_TYPE vcproj)
-		set(USERFILE_EXTENSION ${SYSTEM_NAME}.${USER_NAME}.user)
-		set(LAUNCHER_LINESEP "&#x0A;")
-		if(MSVC90)
-			set(USERFILE_VC_VERSION 9.00)
-		elseif(MSVC80)
-			set(USERFILE_VC_VERSION 8.00)
-		elseif(MSVC71)
-			set(USERFILE_VC_VERSION 7.10)
-		elseif(MSVC10 OR (MSVC AND MSVC_VERSION GREATER 1600)) # 2010 or newer
-			set(LAUNCHER_LINESEP "\n")
-			set(USERFILE_VC_VERSION 10.00)
-			set(USERFILE_EXTENSION user)
-			set(VCPROJ_TYPE vcxproj)
-		endif()
-		if(BITS EQUAL 64)
-			set(USERFILE_PLATFORM x64)
-		else()
-			set(USERFILE_PLATFORM Win${BITS})
-		endif()
-		set(_pathdelim ";")
-		set(_suffix "cmd")
-	else()
-		set(_pathdelim ":")
-		set(USERFILE_PLATFORM ${CMAKE_SYSTEM_NAME}${BITS})
-		set(_suffix "sh")
-		find_package(GDB QUIET)
-		if(GDB_FOUND)
-			set(LAUNCHERS_GOT_GDB YES)
-			if(GDB_HAS_RETURN_CHILD_RESULT)
-				set(LAUNCHERS_GDB_ARG --return-child-result)
-			endif()
-		else()
-			set(LAUNCHERS_GOT_GDB)
-		endif()
-	endif()
-
-	if(WIN32 AND NOT USERFILE_REMOTE_MACHINE)
-		site_name(USERFILE_REMOTE_MACHINE)
-		mark_as_advanced(USERFILE_REMOTE_MACHINE)
-	endif()
-endmacro()
-
-macro(_launcher_process_args)
-	set(_nowhere)
-	set(_curdest _nowhere)
-	set(_val_args
-		ARGS
-		RUNTIME_LIBRARY_DIRS
-		WORKING_DIRECTORY
-		ENVIRONMENT)
-	set(_bool_args FORWARD_ARGS)
-	foreach(_arg ${_val_args} ${_bool_args})
-		set(${_arg})
-	endforeach()
-	foreach(_element ${ARGN})
-		list(FIND _val_args "${_element}" _val_arg_find)
-		list(FIND _bool_args "${_element}" _bool_arg_find)
-		if("${_val_arg_find}" GREATER "-1")
-			set(_curdest "${_element}")
-		elseif("${_bool_arg_find}" GREATER "-1")
-			set("${_element}" ON)
-			set(_curdest _nowhere)
-		else()
-			list(APPEND ${_curdest} "${_element}")
-		endif()
-	endforeach()
-
-	if(_nowhere)
-		message(FATAL_ERROR
-			"Syntax error in use of a function in CreateLaunchers!")
-	endif()
-
-	# Turn into a list of native paths
-	set(_runtime_lib_dirs)
-	foreach(_dlldir ${RUNTIME_LIBRARY_DIRS})
-		file(TO_NATIVE_PATH "${_dlldir}" _path)
-		set(_runtime_lib_dirs "${_runtime_lib_dirs}${_path}${_pathdelim}")
-	endforeach()
-
-	if(NOT WORKING_DIRECTORY)
-		set(WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
-	endif()
-
-	if(FORWARD_ARGS)
-		if(WIN32)
-			set(FWD_ARGS %*)
-		else()
-			set(FWD_ARGS $*)
-		endif()
-	else()
-		set(FWD_ARGS)
-	endif()
-
-	set(USERFILE_WORKING_DIRECTORY "${WORKING_DIRECTORY}")
-	set(USERFILE_COMMAND_ARGUMENTS "${ARGS}")
-	set(LAUNCHERSCRIPT_COMMAND_ARGUMENTS "${ARGS} ${FWD_ARGS}")
-
-	if(WIN32)
-		set(RUNTIME_LIBRARIES_ENVIRONMENT "PATH=${_runtime_lib_dirs};%PATH%")
-		file(READ
-			"${_launchermoddir}/launcher.env.cmd.in"
-			_cmdenv)
-	else()
-		if(APPLE)
-			set(RUNTIME_LIBRARIES_ENVIRONMENT
-				"DYLD_LIBRARY_PATH=${_runtime_lib_dirs}:$DYLD_LIBRARY_PATH")
-		else()
-			set(RUNTIME_LIBRARIES_ENVIRONMENT
-				"LD_LIBRARY_PATH=${_runtime_lib_dirs}:$LD_LIBRARY_PATH")
-		endif()
-		file(READ
-			"${_launchermoddir}/launcher.env.sh.in"
-			_cmdenv)
-	endif()
-	set(USERFILE_ENVIRONMENT "${RUNTIME_LIBRARIES_ENVIRONMENT}")
-
-	set(USERFILE_ENV_COMMANDS)
-	foreach(_arg "${RUNTIME_LIBRARIES_ENVIRONMENT}" ${ENVIRONMENT})
-		string(CONFIGURE
-			"@USERFILE_ENVIRONMENT@@LAUNCHER_LINESEP@@_arg@"
-			USERFILE_ENVIRONMENT
-			@ONLY)
-		string(CONFIGURE
-			"@USERFILE_ENV_COMMANDS@${_cmdenv}"
-			USERFILE_ENV_COMMANDS
-			@ONLY)
-	endforeach()
-endmacro()
-
-macro(_launcher_produce_vcproj_user)
-	if(MSVC)
-		file(READ
-			"${_launchermoddir}/perconfig.${VCPROJ_TYPE}.user.in"
-			_perconfig)
-		file(TO_NATIVE_PATH "${USERFILE_WORKING_DIRECTORY}" NATIVE_WORKING_DIRECTORY)
-		set(USERFILE_CONFIGSECTIONS)
-		foreach(USERFILE_CONFIGNAME ${CMAKE_CONFIGURATION_TYPES})
-			string(CONFIGURE "${_perconfig}" _temp @ONLY ESCAPE_QUOTES)
-			set(USERFILE_CONFIGSECTIONS "${USERFILE_CONFIGSECTIONS}${_temp}")
-		endforeach()
-
-
-		configure_file("${_launchermoddir}/${VCPROJ_TYPE}.user.in"
-			"${VCPROJNAME}.${VCPROJ_TYPE}.${USERFILE_EXTENSION}"
-			@ONLY)
-	endif()
-
-endmacro()
-
-macro(_launcher_configure_executable _src _tmp _target)
-#    get_filename_component(_targetname "${_target}" NAME)
-    get_filename_component(_targetpath "${_target}" PATH)
-	configure_file("${_src}"
-		"${_tmp}"
-		@ONLY)
-	file(COPY "${_tmp}"
-	    DESTINATION "${_targetpath}"
-	    FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_WRITE GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
-endmacro()
-
-macro(_launcher_create_target_launcher)
-	set(TARGET_NAME ${_targetname})
-	
-	set(_fn "launch-${_targetname}-generator.${_suffix}")
-	
-	configure_file("${_launchermoddir}/targetlauncher.${_suffix}.in" 
-					"${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_fn}"
-					@ONLY)
-	
-	file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/launch-${_targetname}-$<CONFIGURATION>.${_suffix}"
-			INPUT "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${_fn}")
-endmacro()
-
-function(create_default_target_launcher _targetname)
-	_launcher_system_settings()
-	_launcher_process_args(${ARGN})
-
-	set(VCPROJNAME "${CMAKE_BINARY_DIR}/ALL_BUILD")
-	_launcher_produce_vcproj_user()
-
-	_launcher_create_target_launcher()
-endfunction()
-
-function(create_target_launcher _targetname)
-	_launcher_system_settings()
-	_launcher_process_args(${ARGN})
-
-	set(VCPROJNAME "${CMAKE_CURRENT_BINARY_DIR}/${_targetname}")
-	_launcher_produce_vcproj_user()
-
-	_launcher_create_target_launcher()
-endfunction()
-
-function(create_generic_launcher _launchername)
-	_launcher_system_settings()
-	_launcher_process_args(${ARGN})
-
-	if(NOT IS_ABSOLUTE _launchername)
-		set(_launchername
-			"${CMAKE_CURRENT_BINARY_DIR}/${_launchername}.${_suffix}")
-	else()
-		set(_launchername "${_launchername}.${_suffix}")
-	endif()
-	if(WIN32)
-		set(GENERIC_LAUNCHER_COMMAND "${_launchername}" PARENT_SCOPE)
-		set(GENERIC_LAUNCHER_FAIL_REGULAR_EXPRESSION)
-	else()
-		set(GENERIC_LAUNCHER_COMMAND sh "${_launchername}" PARENT_SCOPE)
-		set(GENERIC_LAUNCHER_FAIL_REGULAR_EXPRESSION
-			"Program terminated with signal")
-	endif()
-
-	_launcher_configure_executable("${_launchermoddir}/genericlauncher.${_suffix}.in"
-	    "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/genericlauncher.${_suffix}.in"
-		"${_launchername}")
-endfunction()
-
-function(guess_runtime_library_dirs _var)
-	# Start off with the link directories of the calling listfile's directory
-	get_directory_property(_libdirs LINK_DIRECTORIES)
-
-	# Add additional libraries passed to the function
-	foreach(_lib ${ARGN})
-		get_filename_component(_libdir "${_lib}" PATH)
-		list(APPEND _libdirs "${_libdir}")
-	endforeach()
-
-	# Now, build a list of potential dll directories
-	set(_dlldirs)
-	foreach(_libdir ${_libdirs})
-		# Add the libdir itself
-		list(APPEND _dlldirs "${_libdir}")
-
-		# Look also in libdir/../bin since the dll might not be with the lib
-		get_filename_component(_libdir "${_libdir}/../bin" ABSOLUTE)
-		list(APPEND _dlldirs "${_libdir}")
-	endforeach()
-
-	# Only keep the valid, unique directories
-	clean_directory_list(_dlldirs)
-
-	# Return _dlldirs
-	set(${_var} "${_dlldirs}" PARENT_SCOPE)
-endfunction()

cmake/Cxx11.cmake

@@ -1,3 +0,0 @@
-
-set(CMAKE_CXX_STANDARD_REQUIRED 11)
-set(CMAKE_CXX_STANDARD 11)

cmake/EnableExtraCompilerWarnings.cmake

@@ -1,88 +0,0 @@
-# - Add flags to compile with extra warnings
-#
-#  enable_extra_compiler_warnings(<targetname>)
-#  globally_enable_extra_compiler_warnings() - to modify CMAKE_CXX_FLAGS, etc
-#    to change for all targets declared after the command, instead of per-command
-#
-#
-# Original Author:
-# 2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__enable_extra_compiler_warnings)
-	return()
-endif()
-set(__enable_extra_compiler_warnings YES)
-
-macro(_enable_extra_compiler_warnings_flags)
-	set(_flags)
-	if(MSVC)
-		option(COMPILER_WARNINGS_EXTREME
-			"Use compiler warnings that are probably overkill."
-			off)
-		mark_as_advanced(COMPILER_WARNINGS_EXTREME)
-		set(_flags "/W4")
-		if(COMPILER_WARNINGS_EXTREME)
-			set(_flags "${_flags} /Wall /wd4619 /wd4668 /wd4820 /wd4571 /wd4710")
-		endif()
-	else()
-		include(CheckCXXCompilerFlag)
-		set(_flags)
-
-		check_cxx_compiler_flag(-W SUPPORTS_W_FLAG)
-		if(SUPPORTS_W_FLAG)
-			set(_flags "${_flags} -W")
-		endif()
-
-		check_cxx_compiler_flag(-Wall SUPPORTS_WALL_FLAG)
-		if(SUPPORTS_WALL_FLAG)
-			set(_flags "${_flags} -Wall")
-		endif()
-
-		check_cxx_compiler_flag(-Wextra SUPPORTS_WEXTRA_FLAG)
-		if(SUPPORTS_WEXTRA_FLAG)
-			set(_flags "${_flags} -Wextra")
-		endif()
-
-		if(SUPPORTS_WALL_FLAG)
-			# At least GCC includes -Wmaybe-uninitialized in -Wall, which
-			# unneccesarily whines about boost::optional (by it's nature
-			# it's a "maybe" warning - prone to noisy false-positives)
-			check_cxx_compiler_flag(-Wno-maybe-uninitialized SUPPORTS_WNO_MAYBE_UNINITIALIZED_FLAG)
-			if(SUPPORTS_WNO_MAYBE_UNINITIALIZED_FLAG)
-				set(_flags "${_flags} -Wno-maybe-uninitialized")
-			endif()
-		endif()
-	endif()
-endmacro()
-
-function(enable_extra_compiler_warnings _target)
-	_enable_extra_compiler_warnings_flags()
-	get_target_property(_origflags ${_target} COMPILE_FLAGS)
-	if(_origflags)
-		set_property(TARGET
-			${_target}
-			PROPERTY
-			COMPILE_FLAGS
-			"${_flags} ${_origflags}")
-	else()
-		set_property(TARGET
-			${_target}
-			PROPERTY
-			COMPILE_FLAGS
-			"${_flags}")
-	endif()
-
-endfunction()
-
-function(globally_enable_extra_compiler_warnings)
-	_enable_extra_compiler_warnings_flags()
-	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_flags}" PARENT_SCOPE)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_flags}" PARENT_SCOPE)
-endfunction()

cmake/ListCombinations.cmake

@@ -1,53 +0,0 @@
-# - Combine lists of prefixes and suffixes in all combinations
-#
-#  list_combinations(var PREFIXES listitems... SUFFIXES listitems...) -
-#   where var is the name of your desired output variable and PREFIXES
-#   and SUFFIXES are special arguments that indicate the start of your
-#   list of prefixes or suffixes respectively.
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(__list_combinations)
-	return()
-endif()
-set(__list_combinations YES)
-
-function(list_combinations var)
-	# Parse arguments
-	set(_prefixes)
-	set(_suffixes)
-	set(_nowhere)
-	set(_curdest _nowhere)
-	foreach(_element ${ARGN})
-		if("${_element}" STREQUAL "PREFIXES")
-			set(_curdest _prefixes)
-		elseif("${_element}" STREQUAL "SUFFIXES")
-			set(_curdest _suffixes)
-		else()
-			list(APPEND ${_curdest} "${_element}")
-		endif()
-	endforeach()
-	if(_nowhere)
-		message(STATUS "_prefixes ${_prefixes}")
-		message(STATUS "_prefixes ${_suffixes}")
-		message(STATUS "_prefixes ${_nowhere}")
-		message(FATAL_ERROR
-			"Syntax error in use of ${CMAKE_CURRENT_LIST_FILE}")
-	endif()
-
-	foreach(_prefix ${_prefixes})
-		foreach(_suffix ${_suffixes})
-			list(APPEND _out "${_prefix}${_suffix}")
-		endforeach()
-	endforeach()
-
-	set(${var} "${_out}" PARENT_SCOPE)
-endfunction()

cmake/MSVCMultipleProcessCompile.cmake

@@ -1,31 +0,0 @@
-# - Compile with multiple processes on MSVC
-#
-#  include(MSVCMultipleProcessCompile)
-#
-# Requires these CMake modules:
-#  ListCombinations.cmake
-#
-# Original Author:
-# 2009-2010 Ryan Pavlik <[email protected]> <[email protected]>
-# http://academic.cleardefinition.com
-# Iowa State University HCI Graduate Program/VRAC
-#
-# Copyright Iowa State University 2009-2010.
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-if(MSVC AND NOT "${MSVC_VERSION}" LESS 1400)
-	# Only available in VS 2005 and newer
-	string(TOUPPER "${CMAKE_CONFIGURATION_TYPES}" _conftypesUC)
-	include(ListCombinations)
-	list_combinations(_varnames
-		PREFIXES
-		CMAKE_C_FLAGS_
-		CMAKE_CXX_FLAGS_
-		SUFFIXES
-		${_conftypesUC})
-	foreach(_var ${_varnames})
-		set(${_var} "${${_var}} /MP")
-	endforeach()
-endif()

cmake/clang-tidy.cmake

@@ -1,37 +0,0 @@
-option(ENABLE_CLANG_TIDY "Enable source code checking using clang-tidy" OFF)
-
-find_program(
-    CLANG_TIDY_EXE
-    NAMES "clang-tidy"
-    DOC "Path to clang-tidy executable"
-)
-
-function(enable_clang_tidy target)
-    # Not enabled in this configuration
-endfunction()
-
-if(NOT ENABLE_CLANG_TIDY)
-    return()
-endif()
-
-if(NOT EXISTS "${CLANG_TIDY_EXE}")
-    message(SEND_ERROR "clang-tidy: Could not find clang-tidy executable (value of variable is \"${CLANG_TIDY_EXE}\".")
-    return()
-endif()
-
-if(CMAKE_VERSION VERSION_LESS "3.6.0")
-    message(SEND_ERROR "Clang-tidy support requires CMake 3.6")
-    return()
-endif()
-
-message(STATUS "clang-tidy: Using \"${CLANG_TIDY_EXE}\"")
-
-function(enable_clang_tidy target)
-    SET(TIDY_OPTIONS "${CLANG_TIDY_EXE}")
-    if(FSO_FATAL_WARNINGS)
-        set(TIDY_OPTIONS "${TIDY_OPTIONS};-warnings-as-errors=*")
-    endif()
-
-    set_target_properties(${target} PROPERTIES CXX_CLANG_TIDY "${TIDY_OPTIONS}")
-endfunction()
-

cmake/cpufeatures.cpp

@@ -1,81 +0,0 @@
-// Code snippet from http://stackoverflow.com/a/7495023
-#ifdef _WIN32
-#include <intrin.h>
-//  Windows
-#define cpuid    __cpuidex
-#define xgetbv   _xgetbv
-
-#else
-
-#include <cstdint>
-
-//  GCC Inline Assembly
-void cpuid(int CPUInfo[4], int InfoType, int SubType){
-    __asm__ __volatile__ (
-        "cpuid":
-        "=a" (CPUInfo[0]),
-        "=b" (CPUInfo[1]),
-        "=c" (CPUInfo[2]),
-        "=d" (CPUInfo[3]) :
-        "a" (InfoType),
-		"c" (SubType)
-    );
-}
-
-uint64_t xgetbv(uint32_t xcr) {
-	uint32_t lower, higher;
-	__asm__ __volatile__ (
-		"xgetbv":
-		"=a"(lower),
-		"=d"(higher) :
-		"c"(xcr)
-	);
-	return (static_cast<uint64_t>(higher) << static_cast<uint64_t>(32)) | static_cast<uint64_t>(lower);
-}
-
-#endif
-
-#include <iostream>
-
-int main( int argc, char* argv[] )
-{
-	bool SSE     = false;
-	bool SSE2    = false;
-	bool OSXSAVE = false;
-	bool AVX     = false;
-	bool AVX2    = false;
-
-	int info[4];
-	cpuid(info, 0, 0);
-	int nIds = info[0];
-
-	//  Detect Instruction Set
-	if (nIds >= 1){
-		cpuid(info, 0x00000001, 0);
-		SSE     = (info[3] & ((int)1 << 25)) != 0;
-		SSE2    = (info[3] & ((int)1 << 26)) != 0;
-		OSXSAVE = (info[2] & ((int)1 << 27)) != 0;
-		AVX     = (info[2] & ((int)1 << 28)) != 0;
-	}
-	if (nIds >= 7){
-		cpuid(info,0x00000007, 0);
-		AVX2  = (info[1] & ((int)1 <<  5)) != 0;
-	}
-
-	//  Detect OS Support
-	if (!OSXSAVE || (xgetbv(0) & 0x6) == 0) {
-		AVX = false;
-		AVX2 = false;
-	}
-
-	if (AVX2)
-		std::cout << "AVX2";
-	else if(AVX)
-		std::cout << "AVX";
-	else if(SSE2)
-		std::cout << "SSE2";
-	else if(SSE)
-		std::cout << "SSE";
-
-	return 0;
-}

cmake/cross_compile/mingw64.cmake

@@ -1,42 +0,0 @@
-
-# Sample toolchain file for building for Windows from a Linux system.
-#
-# Typical usage:
-#    *) install cross compiler: `sudo apt-get install mingw-w64 g++-mingw-w64`
-#    *) cd build
-#    *) cmake -DCMAKE_TOOLCHAIN_FILE=~/Toolchain-Ubuntu-mingw64.cmake ..
-
-set(CMAKE_SYSTEM_NAME Windows)
-set(TOOLCHAIN_PREFIX x86_64-w64-mingw32)
-
-# cross compilers to use for C and C++
-set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
-set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
-set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
-
-# target environment on the build host system
-#   set 1st to dir with the cross compiler's C/C++ headers/libs
-set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
-
-# modify default behavior of FIND_XXX() commands to
-# search for headers/libs in the target environment and
-# don't search for programs in the build host environment
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-
-if (FSO_BUILD_WITH_DISCORD)
-    message(WARNING "Discord support is not tested for cross-compilation. Here be dragons! To disable, set -DFSO_BUILD_WITH_DISCORD:BOOL=OFF")
-endif()
-
-if (FSO_BUILD_FRED2)
-    message(WARNING "FRED2 support is not tested for cross-compilation. Here be dragons! To disable, set -DFSO_BUILD_FRED2:BOOL=OFF")
-endif()
-
-if (FSO_USE_SPEECH)
-    message(WARNING "Speech support is not tested for cross-compilation. Here be dragons! To disable, set -DFSO_USE_SPEECH:BOOL=OFF")
-endif()
-
-if (FSO_USE_VOICEREC)
-    message(WARNING "Voice recognition support is not tested for cross-compilation. Here be dragons! To disable, set -DFSO_USE_VOICEREC:BOOL=OFF")
-endif()

cmake/debug-vars.cmake

@@ -1,154 +0,0 @@
-# ------------------------- Begin Generic CMake Variable Logging ------------------
-
-# /*	C++ comment style not allowed	*/
-
-
-# if you are building in-source, this is the same as CMAKE_SOURCE_DIR, otherwise
-# this is the top level directory of your build tree
-MESSAGE( STATUS "CMAKE_BINARY_DIR:         " ${CMAKE_BINARY_DIR} )
-
-# if you are building in-source, this is the same as CMAKE_CURRENT_SOURCE_DIR, otherwise this
-# is the directory where the compiled or generated files from the current CMakeLists.txt will go to
-MESSAGE( STATUS "CMAKE_CURRENT_BINARY_DIR: " ${CMAKE_CURRENT_BINARY_DIR} )
-
-# this is the directory, from which cmake was started, i.e. the top level source directory
-MESSAGE( STATUS "CMAKE_SOURCE_DIR:         " ${CMAKE_SOURCE_DIR} )
-
-# this is the directory where the currently processed CMakeLists.txt is located in
-MESSAGE( STATUS "CMAKE_CURRENT_SOURCE_DIR: " ${CMAKE_CURRENT_SOURCE_DIR} )
-
-# contains the full path to the top level directory of your build tree
-MESSAGE( STATUS "PROJECT_BINARY_DIR: " ${PROJECT_BINARY_DIR} )
-
-MESSAGE( STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID} )
-
-# contains the full path to the root of your project source directory,
-# i.e. to the nearest directory where CMakeLists.txt contains the PROJECT() command
-MESSAGE( STATUS "PROJECT_SOURCE_DIR: " ${PROJECT_SOURCE_DIR} )
-
-# set this variable to specify a common place where CMake should put all executable files
-# (instead of CMAKE_CURRENT_BINARY_DIR)
-MESSAGE( STATUS "EXECUTABLE_OUTPUT_PATH: " ${EXECUTABLE_OUTPUT_PATH} )
-
-# set this variable to specify a common place where CMake should put all libraries
-# (instead of CMAKE_CURRENT_BINARY_DIR)
-MESSAGE( STATUS "LIBRARY_OUTPUT_PATH:     " ${LIBRARY_OUTPUT_PATH} )
-
-# tell CMake to search first in directories listed in CMAKE_MODULE_PATH
-# when you use FIND_PACKAGE() or INCLUDE()
-MESSAGE( STATUS "CMAKE_MODULE_PATH: " ${CMAKE_MODULE_PATH} )
-
-# this is the complete path of the cmake which runs currently (e.g. /usr/local/bin/cmake)
-MESSAGE( STATUS "CMAKE_COMMAND: " ${CMAKE_COMMAND} )
-
-# this is the CMake installation directory
-MESSAGE( STATUS "CMAKE_ROOT: " ${CMAKE_ROOT} )
-
-# this is the filename including the complete path of the file where this variable is used.
-MESSAGE( STATUS "CMAKE_CURRENT_LIST_FILE: " ${CMAKE_CURRENT_LIST_FILE} )
-
-# this is linenumber where the variable is used
-MESSAGE( STATUS "CMAKE_CURRENT_LIST_LINE: " ${CMAKE_CURRENT_LIST_LINE} )
-
-# this is used when searching for include files e.g. using the FIND_PATH() command.
-MESSAGE( STATUS "CMAKE_INCLUDE_PATH: " ${CMAKE_INCLUDE_PATH} )
-
-# this is used when searching for libraries e.g. using the FIND_LIBRARY() command.
-MESSAGE( STATUS "CMAKE_LIBRARY_PATH: " ${CMAKE_LIBRARY_PATH} )
-
-# the complete system name, e.g. "Linux-2.4.22", "FreeBSD-5.4-RELEASE" or "Windows 5.1"
-MESSAGE( STATUS "CMAKE_SYSTEM: " ${CMAKE_SYSTEM} )
-
-# the short system name, e.g. "Linux", "FreeBSD" or "Windows"
-MESSAGE( STATUS "CMAKE_SYSTEM_NAME: " ${CMAKE_SYSTEM_NAME} )
-
-# only the version part of CMAKE_SYSTEM
-MESSAGE( STATUS "CMAKE_SYSTEM_VERSION: " ${CMAKE_SYSTEM_VERSION} )
-
-# the processor name (e.g. "Intel(R) Pentium(R) M processor 2.00GHz")
-MESSAGE( STATUS "CMAKE_SYSTEM_PROCESSOR: " ${CMAKE_SYSTEM_PROCESSOR} )
-
-# is TRUE on all UNIX-like OS's, including Apple OS X and CygWin
-MESSAGE( STATUS "UNIX: " ${UNIX} )
-
-# is TRUE on Windows, including CygWin
-MESSAGE( STATUS "WIN32: " ${WIN32} )
-
-# is TRUE on Apple OS X
-MESSAGE( STATUS "APPLE: " ${APPLE} )
-
-# is TRUE when using the MinGW compiler in Windows
-MESSAGE( STATUS "MINGW: " ${MINGW} )
-
-# is TRUE on Windows when using the CygWin version of cmake
-MESSAGE( STATUS "CYGWIN: " ${CYGWIN} )
-
-# is TRUE on Windows when using a Borland compiler
-MESSAGE( STATUS "BORLAND: " ${BORLAND} )
-
-# Microsoft compiler
-MESSAGE( STATUS "MSVC: " ${MSVC} )
-MESSAGE( STATUS "MSVC_IDE: " ${MSVC_IDE} )
-MESSAGE( STATUS "MSVC60: " ${MSVC60} )
-MESSAGE( STATUS "MSVC70: " ${MSVC70} )
-MESSAGE( STATUS "MSVC71: " ${MSVC71} )
-MESSAGE( STATUS "MSVC80: " ${MSVC80} )
-MESSAGE( STATUS "CMAKE_COMPILER_2005: " ${CMAKE_COMPILER_2005} )
-
-
-# set this to true if you don't want to rebuild the object files if the rules have changed,
-# but not the actual source files or headers (e.g. if you changed the some compiler switches)
-MESSAGE( STATUS "CMAKE_SKIP_RULE_DEPENDENCY: " ${CMAKE_SKIP_RULE_DEPENDENCY} )
-
-# since CMake 2.1 the install rule depends on all, i.e. everything will be built before installing.
-# If you don't like this, set this one to true.
-MESSAGE( STATUS "CMAKE_SKIP_INSTALL_ALL_DEPENDENCY: " ${CMAKE_SKIP_INSTALL_ALL_DEPENDENCY} )
-
-# If set, runtime paths are not added when using shared libraries. Default it is set to OFF
-MESSAGE( STATUS "CMAKE_SKIP_RPATH: " ${CMAKE_SKIP_RPATH} )
-
-# set this to true if you are using makefiles and want to see the full compile and link
-# commands instead of only the shortened ones
-MESSAGE( STATUS "CMAKE_VERBOSE_MAKEFILE: " ${CMAKE_VERBOSE_MAKEFILE} )
-
-# this will cause CMake to not put in the rules that re-run CMake. This might be useful if
-# you want to use the generated build files on another machine.
-MESSAGE( STATUS "CMAKE_SUPPRESS_REGENERATION: " ${CMAKE_SUPPRESS_REGENERATION} )
-
-
-# A simple way to get switches to the compiler is to use ADD_DEFINITIONS().
-# But there are also two variables exactly for this purpose:
-
-# the compiler flags for compiling C sources
-MESSAGE( STATUS "CMAKE_C_FLAGS: " ${CMAKE_C_FLAGS} )
-
-# the compiler flags for compiling C++ sources
-MESSAGE( STATUS "CMAKE_CXX_FLAGS: " ${CMAKE_CXX_FLAGS} )
-
-
-# Choose the type of build.  Example: SET(CMAKE_BUILD_TYPE Debug)
-MESSAGE( STATUS "CMAKE_BUILD_TYPE: " ${CMAKE_BUILD_TYPE} )
-
-# if this is set to ON, then all libraries are built as shared libraries by default.
-MESSAGE( STATUS "BUILD_SHARED_LIBS: " ${BUILD_SHARED_LIBS} )
-
-# the compiler used for C files
-MESSAGE( STATUS "CMAKE_C_COMPILER: " ${CMAKE_C_COMPILER} )
-
-# the compiler used for C++ files
-MESSAGE( STATUS "CMAKE_CXX_COMPILER: " ${CMAKE_CXX_COMPILER} )
-
-# if the compiler is a variant of gcc, this should be set to 1
-MESSAGE( STATUS "CMAKE_COMPILER_IS_GNUCC: " ${CMAKE_COMPILER_IS_GNUCC} )
-
-# if the compiler is a variant of g++, this should be set to 1
-MESSAGE( STATUS "CMAKE_COMPILER_IS_GNUCXX : " ${CMAKE_COMPILER_IS_GNUCXX} )
-
-# the tools for creating libraries
-MESSAGE( STATUS "CMAKE_AR: " ${CMAKE_AR} )
-MESSAGE( STATUS "CMAKE_RANLIB: " ${CMAKE_RANLIB} )
-
-#
-#MESSAGE( STATUS ": " ${} )
-
-# ------------------------- End of Generic CMake Variable Logging ------------------

cmake/doxygen.cmake

@@ -1,37 +0,0 @@
-
-# add a target to generate API documentation with Doxygen
-find_package(Doxygen)
-if(DOXYGEN_FOUND)
-	SET(OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/documentation/doxygen")
-	FILE(MAKE_DIRECTORY "${OUTPUT_DIR}")
-	
-	FILE(TO_NATIVE_PATH ${OUTPUT_DIR} OUTPUT_DIR)
-	SET(OUTPUT_DIR \"${OUTPUT_DIR}\")
-	
-	SET(INPUTS "${CMAKE_CURRENT_SOURCE_DIR}/code" "${CMAKE_CURRENT_SOURCE_DIR}/freespace2" "${CMAKE_CURRENT_SOURCE_DIR}/fred2" "${CMAKE_CURRENT_SOURCE_DIR}/wxfred2" "${CMAKE_CURRENT_SOURCE_DIR}/qtfred")
-	
-	SET(INPUT_DIRS)
-	FOREACH(DIR IN LISTS INPUTS)
-		FILE(TO_NATIVE_PATH ${DIR} native_dir)
-		
-		LIST(APPEND INPUT_DIRS \"${native_dir}\")
-	ENDFOREACH(DIR)
-	STRING(REPLACE ";" " " INPUT_DIRS "${INPUT_DIRS}")
-	
-	CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/fs2open.Doxyfile.in
-					${CMAKE_CURRENT_BINARY_DIR}/fs2open.Doxyfile
-					@ONLY)
-	
-	add_custom_target(doxygen
-		${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/fs2open.Doxyfile
-		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-		COMMENT "Generating API documentation with Doxygen" VERBATIM
-	)
-	
-	set_target_properties(doxygen
-		PROPERTIES
-			FOLDER "Documentation"
-			EXCLUDE_FROM_ALL ON
-			EXCLUDE_FROM_DEFAULT_BUILD ON
-	)
-endif(DOXYGEN_FOUND)

cmake/embed_file.cmake

@@ -1,124 +0,0 @@
-
-set(_EMBEDD_FILE_BASE_DIR "${CMAKE_CURRENT_LIST_DIR}")
-
-function(target_embed_files _target)
-    set(options)
-    set(oneValueArgs RELATIVE_TO PATH_TYPE_PREFIX)
-    set(multiValueArgs FILES)
-    cmake_parse_arguments(EMBED "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-    if (NOT DEFINED EMBED_RELATIVE_TO)
-        set(EMBED_RELATIVE_TO "${CMAKE_CURRENT_SOURCE_DIR}")
-    endif()
-    if (NOT IS_ABSOLUTE "${EMBED_RELATIVE_TO}")
-        get_filename_component(EMBED_RELATIVE_TO "${EMBED_RELATIVE_TO}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-    endif()
-
-    foreach (file ${EMBED_FILES})
-        get_filename_component(_absoluteFile "${file}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-
-        file(RELATIVE_PATH _pathType "${EMBED_RELATIVE_TO}" "${_absoluteFile}")
-        get_filename_component(_pathType ${_pathType} DIRECTORY)
-        if (DEFINED EMBED_PATH_TYPE_PREFIX)
-            if (_pathType)
-                set(_pathType "${EMBED_PATH_TYPE_PREFIX}/${_pathType}")
-            else()
-                # Avoid trailing / when we are in the same directory
-                set(_pathType "${EMBED_PATH_TYPE_PREFIX}")
-            endif()
-        endif()
-
-        if (NOT _pathType)
-            # If it is still empty then we need to work around yet another annoying CMake behavior where it ignores
-            # "empty" property strings
-            set(_pathType ".")
-        endif()
-
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES "${_absoluteFile}")
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES_BASE_DIR "${EMBED_RELATIVE_TO}")
-        set_property(TARGET ${_target} APPEND PROPERTY EMBEDDED_FILES_PATH_TYPE "${_pathType}")
-    endforeach()
-endfunction()
-
-function(handle_embedded_files _target)
-    get_target_property(_filesToEmbed ${_target} EMBEDDED_FILES)
-    get_target_property(_baseDirs ${_target} EMBEDDED_FILES_BASE_DIR)
-    get_target_property(_pathTypes ${_target} EMBEDDED_FILES_PATH_TYPE)
-
-    SET(DEF_OUT_FILES)
-
-    set(INCLUDE_LIST)
-    set(ARRAY_ELEMENTS)
-
-    list(LENGTH _filesToEmbed _numFiles)
-
-    FOREACH(i RANGE ${_numFiles})
-        # Why must CMake always do the unexpected thing? The foreach variant includes the last index as opposed to every
-        # other sensible language which does not include it...
-        if (i GREATER_EQUAL _numFiles)
-            break()
-        endif()
-
-        list(GET _filesToEmbed ${i} _filePath)
-        list(GET _baseDirs ${i} _baseDir)
-        list(GET _pathTypes ${i} _pathType)
-
-        if (_pathType STREQUAL ".")
-            # Handle the workaround we had to do for empty path types
-            set(_pathType "")
-        endif()
-
-        file(RELATIVE_PATH _relativeFilePath "${_baseDir}" "${_filePath}")
-        SET(_outputBasePath "${CMAKE_CURRENT_BINARY_DIR}/embedded_files/${_relativeFilePath}")
-
-        # For some reason this is needed...
-        get_filename_component(_outputDirectory ${_outputBasePath} DIRECTORY)
-        file(MAKE_DIRECTORY ${_outputDirectory})
-
-        # Retrieve the path type name from the relative path
-        file(TO_NATIVE_PATH "${_pathType}" _pathType)
-        if (MINGW)
-            # There is a bug in CMake where it thinks MinGW uses forward slashes for paths but we need backslashes for Windows builds
-            string(REPLACE "/" "\\" _pathType "${_pathType}")
-        endif()
-        # Properly escape back slashes in strings
-        string(REPLACE "\\" "\\\\" _pathType "${_pathType}")
-
-        get_filename_component(FILE_NAME "${_relativeFilePath}" NAME)
-
-        string(MAKE_C_IDENTIFIER "${_relativeFilePath}" FIELD_NAME)
-
-        set(HEADER_FILE "${_outputBasePath}.h")
-        set(SOURCE_FILE "${_outputBasePath}.cpp")
-
-        set(ALL_OUTPUTS "${HEADER_FILE}" "${SOURCE_FILE}")
-        set(FIELD_NAME "Embedded_${FIELD_NAME}")
-
-        set(INCLUDE_LIST "${INCLUDE_LIST}\n#include \"${HEADER_FILE}\"")
-        set(ARRAY_ELEMENTS "${ARRAY_ELEMENTS}\n\t{ \"${_pathType}\", \"${FILE_NAME}\" , ${FIELD_NAME} , ${FIELD_NAME}_size },")
-
-        IF(CMAKE_CROSSCOMPILING)
-            SET(EMBEDFILE_PATH "EMBEDFILE-NOTFOUND" CACHE FILEPATH "Required for a cross compiling build, point to an embedfile of a cmake build for the host OS")
-            IF(EMBEDFILE_PATH STREQUAL "EMBEDFILE-NOTFOUND")
-                #This could, possibly, be configured to compile an embedfile using host compilation automatically, but that seems to be a challenge.
-                message(FATAL_ERROR "A manual embedfile path must be configured for cross compilation. Set EMBEDFILE_PATH to the location of an embedfile executable, found in the build directories for the host OS.")
-            ENDIF()
-        ELSE(CMAKE_CROSSCOMPILING)
-            SET(EMBEDFILE_PATH "embedfile")
-        ENDIF(CMAKE_CROSSCOMPILING)
-
-        add_custom_command(
-            OUTPUT ${ALL_OUTPUTS}
-            COMMAND ${EMBEDFILE_PATH} "${_filePath}" "${_outputBasePath}" "${FIELD_NAME}"
-            MAIN_DEPENDENCY "${_filePath}"
-            COMMENT "Generating string file for ${_filePath}"
-        )
-
-        list(APPEND DEF_OUT_FILES ${ALL_OUTPUTS})
-    ENDFOREACH()
-
-    configure_file("${_EMBEDD_FILE_BASE_DIR}/embedded_files.inc.in" "${CMAKE_CURRENT_BINARY_DIR}/embedded_files/embedded_files.inc")
-    target_include_directories(${_target} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/embedded_files")
-    target_sources(${_target} PRIVATE ${DEF_OUT_FILES})
-    source_group("Generated Files\\Embedded Files" FILES ${DEF_OUT_FILES})
-endfunction()

cmake/embedded_files.inc.in

@@ -1,7 +0,0 @@
-
-@INCLUDE_LIST@
-
-def_file Default_files[] =
-{
-@ARRAY_ELEMENTS@
-};

cmake/finder/FindSpeech.cmake

@@ -1,22 +0,0 @@
-
-include(CheckIncludeFile)
-
-add_library(speech INTERFACE)
-
-if (WIN32)
-	CHECK_INCLUDE_FILE_CXX("sapi.h" HAVE_SAPI_H)
-	
-	if (NOT HAVE_SAPI_H)
-		message(SEND_ERROR "sapi.h could not be found on your platform. Please disable speech support.")
-	endif()
-elseif(APPLE)
-	# it should just work
-elseif(ANDROID)
-	# connects to a java TTS manager via SDL activity class
-elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-	# uses speech-dispatcher with dlopen
-else()
-	message(SEND_ERROR "Text to Speech is not supported on this platform!")
-endif()
-
-target_compile_definitions(speech INTERFACE -DFS2_SPEECH)

cmake/fred_rc.h.in

@@ -1,9 +0,0 @@
-
-
-#ifndef __FREDRC_H
-#define __FREDRC_H
-
-#define ABOUT_LINE_1 "FRED2_OPEN - FreeSpace Editor, Version @FSO_PRODUCT_VERSION_STRING@ OpenGL"
-#define MAINFRAME_CONTENTS "FRED2_OPEN @FSO_PRODUCT_VERSION_STRING@ - FreeSpace2 Mission Editor\nUntitled\nFRED2\nFreeSpace2 Missions (*.fs2)\n.fs2\nFreeSpace2Mission\nFreeSpace2 Mission"
-
-#endif // __FREDRC_H

cmake/generateHeaders.cmake

@@ -1,7 +0,0 @@
-
-
-include(Cxx11)
-include(platformChecks)
-
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/project.h.in ${GENERATED_SOURCE_DIR}/project.h)
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/fred_rc.h.in ${GENERATED_SOURCE_DIR}/fred_rc.h)

cmake/globals.cmake

@@ -1,43 +0,0 @@
-
-SET(BINARY_DESTINATION ".")
-SET(LIBRAY_DESTINATION "${BINARY_DESTINATION}")
-
-if (CMAKE_SIZEOF_VOID_P EQUAL 8)
-    set(IS_64BIT TRUE)
-else()
-    set(IS_64BIT FALSE)
-endif()
-
-set(IS_ARM64 FALSE)
-set(IS_ARMV7A FALSE)
-
-if (NOT "${CMAKE_GENERATOR_PLATFORM}" STREQUAL "")   # needed to cover Visual Studio generator
-    if(CMAKE_GENERATOR_PLATFORM MATCHES "^(aarch64|arm64|ARM64)")
-        set(IS_ARM64 TRUE)
-	elseif(CMAKE_GENERATOR_PLATFORM MATCHES "^(armv7)")
-        set(IS_ARMV7A TRUE)
-    endif()
-else()
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)")
-        set(IS_ARM64 TRUE)
-    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7)")
-        set(IS_ARMV7A TRUE)
-    endif()
-endif()
-
-set(IS_RISCV FALSE)
-
-if (NOT "${CMAKE_GENERATOR_PLATFORM}" STREQUAL "")   # needed to cover Visual Studio generator
-    if(CMAKE_GENERATOR_PLATFORM MATCHES "^(riscv64|RISCV64|riscv32|RISCV32)")
-        set(IS_RISCV TRUE)
-    endif()
-else()
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(riscv64|RISCV64|riscv32|RISCV32)")
-        set(IS_RISCV TRUE)
-    endif()
-endif()
-
-set(IS_X86 FALSE)
-if (NOT IS_ARM64 AND NOT IS_RISCV AND NOT IS_ARMV7A)
-    set(IS_X86 TRUE)
-endif()

cmake/headers.cmake

@@ -1,8 +0,0 @@
-
-SET(CODE_HEADERS ${CMAKE_SOURCE_DIR}/code)
-
-SET(FREESPACE_HEADERS ${CMAKE_SOURCE_DIR}/freespace2)
-
-SET(FRED_HEADERS ${CMAKE_SOURCE_DIR}/fred2)
-
-SET(WXFRED_HEADERS ${CMAKE_SOURCE_DIR}/wxfred2)

cmake/launcher-templates/genericlauncher.cmd.in

@@ -1,14 +0,0 @@
-cd @USERFILE_WORKING_DIRECTORY@
-@USERFILE_ENV_COMMANDS@
-
-IF NOT [x%1]==[x--debugger] GOTO SkipDebuggingMess
-
-ECHO Need to ditch the debugger!
-SHIFT /1
-%1 %2 %3 %4 %5 %6 %7 %8 %9
-GOTO EOF
-
-:SkipDebuggingMess
-%*
-
-:EOF

cmake/launcher-templates/genericlauncher.sh.in

@@ -1,18 +0,0 @@
-#!/bin/sh
-bindir=$(pwd)
-cd @USERFILE_WORKING_DIRECTORY@
-@USERFILE_ENV_COMMANDS@
-if test "x$1" = "x--debugger"; then
-	shift
-	cmd="$1"
-	shift
-	if test "x@LAUNCHERS_GOT_GDB@" = "xYES"; then
-		echo "r $@" > $bindir/gdbscript
-		echo "bt" >> $bindir/gdbscript
-		@GDB_COMMAND@ -batch -command=$bindir/gdbscript @LAUNCHERS_GDB_ARG@ $cmd
-	else
-		$cmd $@
-	fi
-else
-	$@
-fi

cmake/launcher-templates/launcher.env.cmd.in

@@ -1 +0,0 @@
-set @_arg@

cmake/launcher-templates/launcher.env.sh.in

@@ -1 +0,0 @@
-export @_arg@

cmake/launcher-templates/perconfig.vcproj.user.in

@@ -1,28 +0,0 @@
-		<Configuration
-			Name="@USERFILE_CONFIGNAME@|@USERFILE_PLATFORM@"
-			>
-			<DebugSettings
-				Command="${USERFILE_@USERFILE_CONFIGNAME@_COMMAND}"
-				WorkingDirectory="@USERFILE_WORKING_DIRECTORY@"
-				CommandArguments="@USERFILE_COMMAND_ARGUMENTS@"
-				Attach="false"
-				DebuggerType="3"
-				Remote="1"
-				RemoteMachine="@USERFILE_REMOTE_MACHINE@"
-				RemoteCommand=""
-				HttpUrl=""
-				PDBPath=""
-				SQLDebugging=""
-				Environment="@USERFILE_ENVIRONMENT@"
-				EnvironmentMerge="true"
-				DebuggerFlavor=""
-				MPIRunCommand=""
-				MPIRunArguments=""
-				MPIRunWorkingDirectory=""
-				ApplicationCommand=""
-				ApplicationArguments=""
-				ShimCommand=""
-				MPIAcceptMode=""
-				MPIAcceptFilter=""
-			/>
-		</Configuration>

cmake/launcher-templates/perconfig.vcxproj.user.in

@@ -1,7 +0,0 @@
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='@USERFILE_CONFIGNAME@|@USERFILE_PLATFORM@'">
-    <LocalDebuggerEnvironment>@USERFILE_ENVIRONMENT@</LocalDebuggerEnvironment>
-    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
-    <LocalDebuggerCommand>$(TargetPath)</LocalDebuggerCommand>
-    <LocalDebuggerCommandArguments>@USERFILE_COMMAND_ARGUMENTS@</LocalDebuggerCommandArguments>
-    <LocalDebuggerWorkingDirectory>@NATIVE_WORKING_DIRECTORY@</LocalDebuggerWorkingDirectory>
-  </PropertyGroup>

cmake/launcher-templates/targetlauncher.cmd.in

@@ -1,8 +0,0 @@
-cd @USERFILE_WORKING_DIRECTORY@
-@USERFILE_ENV_COMMANDS@
-if [%1]==[--debugger] (
-	SHIFT
-)
-
-"@USERFILE_COMMAND@" @LAUNCHERSCRIPT_COMMAND_ARGUMENTS@
-pause

cmake/launcher-templates/targetlauncher.sh.in

@@ -1,16 +0,0 @@
-#!/bin/sh
-bindir=$(pwd)
-cd @USERFILE_WORKING_DIRECTORY@
-@USERFILE_ENV_COMMANDS@
-if test "x$1" = "x--debugger"; then
-	shift
-	if test "x@LAUNCHERS_GOT_GDB@" = "xYES"; then
-		echo "r @LAUNCHERSCRIPT_COMMAND_ARGUMENTS@" > $bindir/gdbscript
-		echo "bt" >> $bindir/gdbscript
-		@GDB_COMMAND@ -batch -command=$bindir/gdbscript @LAUNCHERS_GDB_ARG@ @USERFILE_COMMAND@ 
-	else
-		"@USERFILE_COMMAND@" @LAUNCHERSCRIPT_COMMAND_ARGUMENTS@
-	fi
-else
-	"@USERFILE_COMMAND@" @LAUNCHERSCRIPT_COMMAND_ARGUMENTS@
-fi

cmake/launcher-templates/vcproj.user.in

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioUserFile
-	ProjectType="Visual C++"
-	Version="@USERFILE_VC_VERSION@"
-	ShowAllFiles="false"
-	>
-	<Configurations>
-@USERFILE_CONFIGSECTIONS@
-	</Configurations>
-</VisualStudioUserFile>

cmake/launcher-templates/vcxproj.user.in

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-@USERFILE_CONFIGSECTIONS@
-</Project>

cmake/package.cmake

@@ -1,14 +0,0 @@
-
-SET(CPACK_PACKAGE_VERSION_MAJOR ${FSO_VERSION_MAJOR})
-SET(CPACK_PACKAGE_VERSION_MINOR ${FSO_VERSION_MINOR})
-SET(CPACK_PACKAGE_VERSION_PATCH ${FSO_VERSION_BUILD})
-
-SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY ${FSO_PROJECT_DESCRIPTION})
-
-IF(WIN32)
-	SET(CPACK_NSIS_MUI_ICON ${FSO_INSTALLER_ICON})
-	
-	set(CPACK_NSIS_MENU_LINKS "http://www.hard-light.net/" "FreeSpace Community")
-ENDIF(WIN32)
-
-include(CPack)

cmake/platform-darwin.cmake

@@ -1,40 +0,0 @@
-
-MESSAGE(STATUS "Doing Mac OSX specific things...")
-target_compile_definitions(platform INTERFACE APPLE_APP)
-SET(EXE_GUI_TYPE MACOSX_BUNDLE)
-
-FIND_LIBRARY(COCOA_LIBRARY Cocoa)
-
-if (NOT COCOA_LIBRARY)
-    message(FATAL_ERROR "Couldn't find Cocoa!")
-endif()
-
-target_link_libraries(platform INTERFACE ${COCOA_LIBRARY})
-
-SET(CMAKE_SKIP_RPATH FALSE)
-SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-SET(CMAKE_INSTALL_RPATH @loader_path/../Frameworks/)
-
-# Set the path where library dependencies are copied to
-SET(LIBRAY_DESTINATION "../Frameworks")
-
-set(PLATFORM_MAC TRUE CACHE INTERNAL "" FORCE)
-
-# Maybe override arm64 setting if we are compiling for different architecture
-# If not specified, or if it's a universal build, then this should do nothing
-if(CMAKE_OSX_ARCHITECTURES MATCHES "arm64")
-    set(IS_ARM64 TRUE)
-elseif(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
-    set(IS_ARM64 FALSE)
-endif()
-
-# Generate and don't strip debug symbols
-# These settings don't seem to generate debug symbols for code and Freespace2
-# so those settings are set manually in code and Freespace2's CMakeLists.txt files
-set(CMAKE_XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS "YES")
-set(CMAKE_XCODE_ATTRIBUTE_COPY_PHASE_STRIP "NO")
-set(CMAKE_XCODE_ATTRIBUTE_STRIP_INSTALLED_PRODUCT "NO")
-set(CMAKE_XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN "NO")
-
-# Generate .dSYM file
-set(CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT "dwarf-with-dsym")

cmake/platform-freebsd.cmake

@@ -1,10 +0,0 @@
-
-target_compile_definitions(platform INTERFACE SCP_BSD)
-
-find_library(EXECINFO_LIB execinfo)
-
-if (NOT EXECINFO_LIB)
-    message(FATAL_ERROR "Couldn't find libexecinfo! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${EXECINFO_LIB}")
-endif()

cmake/platform-solaris.cmake

@@ -1,18 +0,0 @@
-
-target_compile_definitions(platform INTERFACE SCP_SOLARIS)
-
-find_library(SOCKET_LIB socket)
-
-if (NOT SOCKET_LIB)
-    message(FATAL_ERROR "Couldn't find libsocket! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${SOCKET_LIB}")
-endif()
-
-find_library(NSL_LIB nsl)
-
-if (NOT NSL_LIB)
-    message(FATAL_ERROR "Couldn't find libnsl! Please install it and rerun the configuration.")
-else()
-    target_link_libraries(platform INTERFACE "${NSL_LIB}")
-endif()

cmake/platform-unix.cmake

@@ -1,13 +0,0 @@
-
-INCLUDE(util)
-
-MESSAGE(STATUS "Configuring UNIX specific things and stuff...")
-
-target_compile_definitions(platform INTERFACE SCP_UNIX USE_OPENAL _REENTRANT)
-
-# Set RPATH
-set(CMAKE_SKIP_BUILD_RPATH TRUE)
-set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-set(CMAKE_INSTALL_RPATH "\$ORIGIN")
-
-set(PLATFORM_UNIX TRUE CACHE INTERNAL "" FORCE)

cmake/platform-win32.cmake

@@ -1,28 +0,0 @@
-
-MESSAGE(STATUS "Configuring Windows specific things and stuff...")
-
-SET(WIN32_LIBS
-	comctl32
-	msacm32
-	odbc32
-	odbccp32
-	vfw32
-	winmm
-	ws2_32
-	psapi
-	shlwapi
-)
-
-IF (MINGW)
-	SET(WIN32_LIBS ${WIN32_LIBS} mingw32)
-ENDIF (MINGW)
-
-target_link_libraries(platform INTERFACE ${WIN32_LIBS})
-
-target_compile_definitions(platform INTERFACE WIN32 USE_OPENAL _WINDOWS)
-
-# Specify minimum Windows version for the headers (currently this is Vista)
-target_compile_definitions(platform INTERFACE NTDDI_VERSION=0x06000000 _WIN32_WINNT=0x0600)
-
-SET(EXE_GUI_TYPE WIN32)
-set(PLATFORM_WINDOWS TRUE CACHE INTERNAL "" FORCE)

cmake/platformChecks.cmake

@@ -1,45 +0,0 @@
-
-include(CheckFunctionExists)
-include(CheckIncludeFiles)
-include(CheckIncludeFile)
-include(CheckIncludeFileCXX)
-include(CheckLibraryExists)
-include(CheckPrototypeDefinition)
-include(CheckStructHasMember)
-include(CheckSymbolExists)
-include(CheckCXXSymbolExists)
-include(CheckTypeSize)
-
-CHECK_INCLUDE_FILE("execinfo.h" SCP_HAVE_EXECINFO_H)
-CHECK_INCLUDE_FILE_CXX("cxxabi.h" SCP_HAVE_CXXAPI_H)
-
-CHECK_TYPE_SIZE("max_align_t" MAX_ALIGN_T)
-
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-    set(CMAKE_REQUIRED_FLAGS "-std=c++11") # required for g++ <= 5
-endif()
-
-set(CMAKE_EXTRA_INCLUDE_FILES "cstddef")
-CHECK_TYPE_SIZE("std::max_align_t" STD_MAX_ALIGN_T LANGUAGE CXX)
-set(CMAKE_EXTRA_INCLUDE_FILES)
-
-CHECK_TYPE_SIZE("char32_t" CHAR32_T LANGUAGE CXX)
-CHECK_TYPE_SIZE("U'b'" UNICODE_CHAR_LITERAL LANGUAGE CXX)
-
-set(CMAKE_REQUIRED_FLAGS)
-
-
-CHECK_FUNCTION_EXISTS(strcasecmp SCP_HAVE_STRCASECMP)
-CHECK_FUNCTION_EXISTS(strncasecmp SCP_HAVE_STRNCASECMP)
-
-CHECK_FUNCTION_EXISTS(_stricmp SCP_HAVE__STRICMP)
-CHECK_FUNCTION_EXISTS(_strnicmp SCP_HAVE__STRNICMP)
-
-CHECK_FUNCTION_EXISTS(strlwr SCP_HAVE_STRLWR)
-
-CHECK_INCLUDE_FILE("strings.h" SCP_HAVE_STRINGS_H)
-
-check_symbol_exists(snprintf "stdio.h" SCP_HAVE_SNPRINTF)
-
-set(PLATFORM_CHECK_HEADER "${GENERATED_SOURCE_DIR}/platformChecks.h")
-CONFIGURE_FILE(${CMAKE_CURRENT_LIST_DIR}/platformChecks.h.in "${PLATFORM_CHECK_HEADER}")

cmake/platformChecks.h.in

@@ -1,30 +0,0 @@
-
-#ifndef __PLATFORM_CHECKS_H__
-#define __PLATFORM_CHECKS_H__
-#pragma once
-
-#cmakedefine SCP_HAVE_EXECINFO_H
-#cmakedefine SCP_HAVE_CXXAPI_H
-#cmakedefine SCP_HAVE_MAX_ALIGN_T
-#cmakedefine SCP_HAVE_STD_MAX_ALIGN_T
-
-#cmakedefine01 IS_64BIT
-#cmakedefine01 IS_ARM64
-#cmakedefine01 IS_RISCV
-
-#cmakedefine01 SCP_HAVE_STRCASECMP
-#cmakedefine01 SCP_HAVE_STRNCASECMP
-#cmakedefine01 SCP_HAVE__STRICMP
-#cmakedefine01 SCP_HAVE__STRNICMP
-
-#cmakedefine01 SCP_HAVE_STRLWR
-
-#cmakedefine01 SCP_HAVE_STRINGS_H
-
-#cmakedefine01 HAVE_CHAR32_T
-#cmakedefine01 HAVE_UNICODE_CHAR_LITERAL
-
-#cmakedefine01 SCP_HAVE_SNPRINTF
-#cmakedefine01 SCP_HAVE__SNPRINTF
-
-#endif // __PLATFORM_CHECKS_H__

cmake/platforms.cmake

@@ -1,29 +0,0 @@
-
-add_library(platform INTERFACE)
-
-IF(FSO_CMAKE_DEBUG)
-	INCLUDE(debug-vars)
-ENDIF(FSO_CMAKE_DEBUG)
-
-set(PLATFORM_WINDOWS FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_UNIX FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_LINUX FALSE CACHE INTERNAL "" FORCE)
-set(PLATFORM_MAC FALSE CACHE INTERNAL "" FORCE)
-
-IF(WIN32)
-	INCLUDE(platform-win32)
-ELSEIF(UNIX)
-	INCLUDE(platform-unix)
-
-	IF(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
-		INCLUDE(platform-freebsd)
-	ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-		INCLUDE(platform-solaris)
-	ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-		include(platform-darwin)
-	elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-		set(PLATFORM_LINUX TRUE CACHE INTERNAL "" FORCE)
-	ENDIF()
-ELSE(WIN32)
-	MESSAGE(STATUS "This platform is not supported, good luck!")
-ENDIF(WIN32)

cmake/project.h.in

@@ -1,17 +0,0 @@
-
-
-#ifndef __PROJECT_H
-#define __PROJECT_H
-
-#define FS_VERSION_MAJOR @FSO_VERSION_MAJOR@
-#define FS_VERSION_MINOR @FSO_VERSION_MINOR@
-#define FS_VERSION_BUILD @FSO_VERSION_BUILD@
-#define FS_VERSION_REVIS @FSO_VERSION_REVISION@
-#define FS_VERSION_REVIS_STR "@FSO_VERSION_REVISION_STR@"
-
-#define FS_VERSION_HAS_REVIS @FSO_VERSION_HAS_REVISION@
-
-#define FS_VERSION_FULL "@FSO_FULL_VERSION_STRING@"
-#define FS_PRODUCT_VERSION "@FSO_PRODUCT_VERSION_STRING@"
-
-#endif // __PROJECT_H

cmake/toolchain-apple-clang.cmake

@@ -1,18 +0,0 @@
-
-MESSAGE(STATUS "Doing configuration specific to Apple Clang...")
-
-# TODO: Actually add Mac specific flags here...
-
-# Suppress specific warning
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fsigned-char -Wno-unknown-pragmas")
-
-# Omit "conversion from string literal to 'char *' is deprecated" warnings.
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-write-strings")
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated -Wno-char-subscripts")
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")
-
-set(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-unused-variable -Wno-unused-parameter")
-
-set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -Wshadow")

cmake/toolchain-clang.cmake

@@ -1,186 +0,0 @@
-# Clang
-include(EnableExtraCompilerWarnings)
-include(CheckCXXCompilerFlag)
-
-MESSAGE(STATUS "Doing configuration specific to clang...")
-
-option(CLANG_ENABLE_LEAK_CHECK "Enable -fsanitize=leak" OFF)
-option(CLANG_ENABLE_ADDRESS_SANITIZER "Enable -fsanitize=address" OFF)
-
-option(CLANG_USE_LIBCXX "Use libc++" OFF)
-
-# These are the default values
-set(C_BASE_FLAGS "-pipe")
-set(CXX_BASE_FLAGS "-pipe")
-
-if(IS_X86)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		set(CLANG_EXTENSIONS "-march=native")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "")
-		set(CLANG_EXTENSIONS "-march=x86-64")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE")
-		set(CLANG_EXTENSIONS "-march=x86-64 -msse -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE2")
-		set(CLANG_EXTENSIONS "-march=x86-64 -msse -msse2 -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX")
-		set(CLANG_EXTENSIONS "-march=x86-64-v2 -msse -msse2 -mavx -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX2")
-		set(CLANG_EXTENSIONS "-march=x86-64-v3 -msse -msse2 -mavx -mavx2 -mfpmath=sse")
-	else ()
-		message( FATAL_ERROR "Unknown instruction set encountered for clang. Update toolchain-clang.cmake!" )
-	endif()
-
-	set(C_BASE_FLAGS "${C_BASE_FLAGS} ${CLANG_EXTENSIONS}")
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} ${CLANG_EXTENSIONS}")
-elseif(IS_ARM)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		set(C_BASE_FLAGS "${C_BASE_FLAGS} -march=native")
-		set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -march=native")
-    endif ()
-elseif(IS_RISCV)
-    # Default C/CXX_BASE_FLAGS are fine for RISC-V
-endif()
-
-if (USE_STATIC_LIBCXX)
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -static-libstdc++ -Qunused-arguments")
-endif()
-
-# For C and C++, the values can be overwritten independently
-if(DEFINED ENV{CXXFLAGS})
-	set(CXX_BASE_FLAGS $ENV{CXXFLAGS})
-endif()
-if(DEFINED ENV{CFLAGS})
-	set(C_BASE_FLAGS $ENV{CFLAGS})
-endif()
-
-if (CLANG_USE_LIBCXX)
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -stdlib=libc++")
-	target_link_libraries(compiler INTERFACE "c++" "c++abi")
-endif()
-
-# Initialize with an empty string to make sure we always get a clean start
-set(COMPILER_FLAGS "")
-
-# This is a slight hack since our flag setup is a bit more complicated
-_enable_extra_compiler_warnings_flags()
-set(COMPILER_FLAGS "${COMPILER_FLAGS} ${_flags}")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -fsigned-char -Wno-unknown-pragmas")
-
-
-if ("${CMAKE_GENERATOR}" STREQUAL "Ninja")
-	# Force color diagnostics for Ninja generator
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -fdiagnostics-color")
-endif()
-
-# Start with an empty list
-set(SANITIZE_FLAGS)
-
-if(CLANG_ENABLE_ADDRESS_SANITIZER)
-	set(CMAKE_REQUIRED_FLAGS "-fsanitize=address")
-	CHECK_C_COMPILER_FLAG("-fsanitize=address" SUPPORTS_SANITIZE_ADDRESS)
-
-	if (SUPPORTS_SANITIZE_ADDRESS)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "address")
-	endif()
-endif()
-if (CLANG_ENABLE_LEAK_CHECK)
-	check_linker_flag("-fsanitize=leak" SUPPORTS_FSANITIZE_LEAK)
-
-	if (SUPPORTS_FSANITIZE_LEAK)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "leak")
-	endif()
-endif()
-
-string(REPLACE ";" "," SANITIZE_FLAGS "${SANITIZE_FLAGS}")
-if (NOT "${SANITIZE_FLAGS}" STREQUAL "")
-	set(SANITIZE_FLAGS "-fsanitize=${SANITIZE_FLAGS}")
-endif()
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} ${SANITIZE_FLAGS}")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wformat-security")
-
-# Dear Clang, please tell us if a function does not return a value since that part of the standard is stupid!
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wreturn-type")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-char-subscripts")
-
-check_cxx_compiler_flag(-Wshift-negative-value SUPPORTS_SHIFT_NEGATIVE_VALUE)
-if(SUPPORTS_SHIFT_NEGATIVE_VALUE)
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-shift-negative-value")
-endif()
-
-# Check if there is a user-set optimisation flag
-string(REGEX MATCH "-O[a-zA-Z|0-9]+" CXX_OPT_FLAG ${CXX_BASE_FLAGS})
-string(REGEX MATCH "-O[a-zA-Z|0-9]+" C_OPT_FLAG ${C_BASE_FLAGS})
-
-# If no user-set opt flag, set -O3 and -Og
-if ("${CXX_OPT_FLAG}" STREQUAL "")
-	set(CXX_OPT_FLAG_RELEASE "-O3")
-	set(CXX_OPT_FLAG_DEBUG "-O0")
-else()
-	set(CXX_OPT_FLAG_RELEASE "${CXX_OPT_FLAG}")
-	set(CXX_OPT_FLAG_DEBUG "${CXX_OPT_FLAG}")
-endif()
-if ("${C_OPT_FLAG}" STREQUAL "")
-	set(C_OPT_FLAG_RELEASE "-O3")
-	set(C_OPT_FLAG_DEBUG "-O0")
-else()
-	set(C_OPT_FLAG_RELEASE "${C_OPT_FLAG}")
-	set(C_OPT_FLAG_DEBUG "${C_OPT_FLAG}")
-endif()
-
-set(CXX_FLAGS_RELEASE "${CXX_OPT_FLAG_RELEASE} -Wno-unused-variable -Wno-unused-parameter")
-set(C_FLAGS_RELEASE "${C_OPT_FLAG_RELEASE} -Wno-unused-variable -Wno-unused-parameter")
-
-# Valgrind (as used by CI) does not understand the DWARF5 debug info that clang
-# emits by default, so force DWARF4 to keep memcheck able to symbolize the binary.
-set(CXX_FLAGS_DEBUG "${CXX_OPT_FLAG_DEBUG} -g -gdwarf-4 -Wshadow")
-set(C_FLAGS_DEBUG "${C_OPT_FLAG_DEBUG} -g -gdwarf-4 -Wshadow")
-
-# Always use the base flags and add our compiler flags at the back
-set(CMAKE_CXX_FLAGS "${CXX_BASE_FLAGS} ${COMPILER_FLAGS}")
-set(CMAKE_C_FLAGS "${C_BASE_FLAGS} ${COMPILER_FLAGS}")
-
-set(CMAKE_CXX_FLAGS_RELEASE ${CXX_FLAGS_RELEASE})
-set(CMAKE_C_FLAGS_RELEASE ${C_FLAGS_RELEASE})
-
-set(CMAKE_CXX_FLAGS_DEBUG ${CXX_FLAGS_DEBUG})
-set(CMAKE_C_FLAGS_DEBUG ${C_FLAGS_DEBUG})
-
-set(CMAKE_EXE_LINKER_FLAGS "")
-
-if(DEFINED ENV{LDFLAGS})
-    set(CMAKE_EXE_LINKER_FLAGS $ENV{LDFLAGS})
-endif()
-
-if (CLANG_USE_LIBCXX)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lc++abi")
-endif()
-
-if (SANITIZE_FLAGS)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZE_FLAGS}")
-endif()
-
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "")
-set(CMAKE_EXE_LINKER_FLAGS_DEBUG "-g -rdynamic")
-
-if (FSO_FATAL_WARNINGS)
-	# Make warnings fatal if the right variable is set
-	target_compile_options(compiler INTERFACE "-Werror")
-endif()
-
-# Always define this to make sure that the fixed-width format macros are available
-target_compile_definitions(compiler INTERFACE __STDC_FORMAT_MACROS)
-
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
-	# GNU ar: Create thin archive files.
-	# Requires binutils-2.19 or later.
-	set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_C_ARCHIVE_APPEND   "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-endif()
-
-target_link_libraries(compiler INTERFACE m)

cmake/toolchain-gcc.cmake

@@ -1,241 +0,0 @@
-
-include(EnableExtraCompilerWarnings)
-include(CheckCCompilerFlag)
-include(util)
-
-MESSAGE(STATUS "Doing configuration specific to gcc...")
-
-option(GCC_ENABLE_LEAK_CHECK "Enable -fsanitize=leak" OFF)
-option(GCC_ENABLE_ADDRESS_SANITIZER "Enable -fsanitize=address" OFF)
-option(GCC_ENABLE_SANITIZE_UNDEFINED "Enable -fsanitize=undefined" OFF)
-option(GCC_USE_GOLD "Use the gold linker instead of the standard linker" OFF)
-option(GCC_GENERATE_GDB_INDEX "Adds linker option to generate the gdb index for debug builds" OFF)
-
-# These are the default values
-set(C_BASE_FLAGS "-pipe")
-set(CXX_BASE_FLAGS "-pipe")
-
-if(IS_X86)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		set(GCC_EXTENSIONS "-march=native")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "")
-		set(GCC_EXTENSIONS "-march=x86-64")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE")
-		set(GCC_EXTENSIONS "-march=x86-64 -msse -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE2")
-		set(GCC_EXTENSIONS "-march=x86-64 -msse -msse2 -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX")
-		set(GCC_EXTENSIONS "-march=x86-64-v2 -msse -msse2 -mavx -mfpmath=sse")
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX2")
-		set(GCC_EXTENSIONS "-march=x86-64-v3 -msse -msse2 -mavx -mavx2 -mfpmath=sse")
-	else ()
-		message( FATAL_ERROR "Unknown instruction set encountered for GCC. Update toolchain-gcc.cmake!" )
-	endif()
-
-	set(C_BASE_FLAGS "${C_BASE_FLAGS} ${GCC_EXTENSIONS}")
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} ${GCC_EXTENSIONS}")
-
-	if (IS_64BIT)
-		set(C_BASE_FLAGS "${C_BASE_FLAGS} -m64")
-		set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -m64")
-	endif()
-elseif(IS_ARM)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		set(C_BASE_FLAGS "${C_BASE_FLAGS} -march=native")
-		set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -march=native")
-    endif ()
-elseif(IS_RISCV)
-    # You do not need to pass a -march, passing nothing will make gcc to choose itself.
-    # If you want a specific set of instructions like vectors, set -march in CFLAGS and CXXFLAGS env variables
-    # Example for vectors: -march=rv64gcv
-    # https://gcc.gnu.org/onlinedocs/gcc/RISC-V-Options.html
-    # As such, default C/CXX_BASE_FLAGS are sufficient.
-endif()
-
-if (USE_STATIC_LIBCXX)
-	set(CXX_BASE_FLAGS "${CXX_BASE_FLAGS} -static-libstdc++")
-endif()
-
-# For C and C++, the values can be overwritten independently
-if(DEFINED ENV{CFLAGS})
-	set(C_BASE_FLAGS $ENV{CFLAGS})
-endif()
-if(DEFINED ENV{CXXFLAGS})
-	set(CXX_BASE_FLAGS $ENV{CXXFLAGS})
-endif()
-
-# Initialize with an empty string to make sure we always get a clean start
-set(COMPILER_FLAGS "")
-set(LINKER_FLAGS "")
-
-# Don't ignore user-set LDFLAGS
-if(DEFINED ENV{LDFLAGS})
-	set(LINKER_FLAGS $ENV{LDFLAGS})
-endif()
-
-if (GCC_USE_GOLD)
-	OPTION(GCC_INCREMENTAL_LINKING "Use incremental linking" OFF)
-	set(LINKER_FLAGS "${LINKER_FLAGS} -fuse-ld=gold")
-
-	if (GCC_INCREMENTAL_LINKING)
-		set(LINKER_FLAGS "${LINKER_FLAGS} -fno-use-linker-plugin -Wl,-z,norelro -Wl,--incremental")
-	endif()
-endif()
-
-# This is a slight hack since our flag setup is a bit more complicated
-_enable_extra_compiler_warnings_flags()
-set(COMPILER_FLAGS "${COMPILER_FLAGS} ${_flags}")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -fsigned-char -Wno-unknown-pragmas")
-
-if (NOT GCC_INCREMENTAL_LINKING)
-	# Place each function and data in its own section so the linker can
-	# perform dead code elimination
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -fdata-sections -ffunction-sections")
-endif()
-
-if ("${CMAKE_GENERATOR}" STREQUAL "Ninja")
-	# Force color diagnostics for Ninja generator
-	CHECK_C_COMPILER_FLAG(-fdiagnostics-color SUPPORTS_DIAGNOSTIC_COLOR)
-
-	if(SUPPORTS_DIAGNOSTIC_COLOR)
-		set(COMPILER_FLAGS "${COMPILER_FLAGS} -fdiagnostics-color")
-	endif()
-endif()
-
-# Start with an empty list
-set(SANITIZE_FLAGS)
-
-if(GCC_ENABLE_ADDRESS_SANITIZER)
-	set(CMAKE_REQUIRED_FLAGS "-fsanitize=address")
-	CHECK_C_COMPILER_FLAG("-fsanitize=address" SUPPORTS_SANITIZE_ADDRESS)
-
-	if (SUPPORTS_SANITIZE_ADDRESS)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "address")
-	endif()
-endif()
-if (GCC_ENABLE_LEAK_CHECK)
-	check_linker_flag("-fsanitize=leak" SUPPORTS_FSANITIZE_LEAK)
-
-	if (SUPPORTS_FSANITIZE_LEAK)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "leak")
-	endif()
-endif()
-if (GCC_ENABLE_SANITIZE_UNDEFINED)
-	check_linker_flag("-fsanitize=undefined" SUPPORTS_SANITIZE_UNDEFINED)
-
-	if (SUPPORTS_SANITIZE_UNDEFINED)
-		set(SANITIZE_FLAGS ${SANITIZE_FLAGS} "undefined")
-	endif()
-endif()
-
-string(REPLACE ";" "," SANITIZE_FLAGS "${SANITIZE_FLAGS}")
-if (NOT "${SANITIZE_FLAGS}" STREQUAL "")
-	set(SANITIZE_FLAGS "-fsanitize=${SANITIZE_FLAGS}")
-endif()
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} ${SANITIZE_FLAGS}")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wformat-security")
-
-# Dear GCC, please tell us if a function does not return a value since that part of the standard is stupid!
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wreturn-type")
-
-set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-deprecated -Wno-char-subscripts")
-
-# These two warnings cause a lot of false-positives in the FSO code base
-check_cxx_compiler_flag(-Wstringop-truncation SUPPORTS_STRINGOP_TRUNCATION)
-if(SUPPORTS_STRINGOP_TRUNCATION)
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-stringop-truncation")
-endif()
-
-check_cxx_compiler_flag(-Wstringop-overflow SUPPORTS_STRINGOP_OVERFLOW)
-if(SUPPORTS_STRINGOP_TRUNCATION)
-	set(COMPILER_FLAGS "${COMPILER_FLAGS} -Wno-stringop-overflow")
-endif()
-
-# Check if there is a user-set optimisation flag
-string(REGEX MATCH "-O[a-zA-Z|0-9]+" CXX_OPT_FLAG ${CXX_BASE_FLAGS})
-string(REGEX MATCH "-O[a-zA-Z|0-9]+" C_OPT_FLAG ${C_BASE_FLAGS})
-
-# If no user-set opt flag, set -O3 and -Og
-if ("${CXX_OPT_FLAG}" STREQUAL "")
-	set(CXX_OPT_FLAG_RELEASE "-O3")
-	set(CXX_OPT_FLAG_DEBUG "-O0")
-else()
-	set(CXX_OPT_FLAG_RELEASE "${CXX_OPT_FLAG}")
-	set(CXX_OPT_FLAG_DEBUG "${CXX_OPT_FLAG}")
-endif()
-if ("${C_OPT_FLAG}" STREQUAL "")
-	set(C_OPT_FLAG_RELEASE "-O3")
-	set(C_OPT_FLAG_DEBUG "-O0")
-else()
-	set(C_OPT_FLAG_RELEASE "${C_OPT_FLAG}")
-	set(C_OPT_FLAG_DEBUG "${C_OPT_FLAG}")
-endif()
-
-set(CXX_FLAGS_RELEASE "${CXX_OPT_FLAG_RELEASE} -Wno-unused-variable -Wno-unused-but-set-variable -Wno-array-bounds -Wno-empty-body -Wno-clobbered -Wno-unused-parameter")
-set(C_FLAGS_RELEASE "${C_OPT_FLAG_RELEASE} -Wno-unused-variable -Wno-unused-but-set-variable -Wno-array-bounds -Wno-empty-body -Wno-clobbered -Wno-unused-parameter")
-
-set(CXX_FLAGS_DEBUG "${CXX_OPT_FLAG_DEBUG} -g -Wshadow")
-set(C_FLAGS_DEBUG "${C_OPT_FLAG_DEBUG} -g -Wshadow")
-
-# Always use the base flags and add our compiler flags at the back
-set(CMAKE_CXX_FLAGS "${CXX_BASE_FLAGS} ${COMPILER_FLAGS}")
-set(CMAKE_C_FLAGS "${C_BASE_FLAGS} ${COMPILER_FLAGS}")
-
-set(CMAKE_CXX_FLAGS_RELEASE ${CXX_FLAGS_RELEASE})
-set(CMAKE_C_FLAGS_RELEASE ${C_FLAGS_RELEASE})
-
-set(CMAKE_CXX_FLAGS_DEBUG ${CXX_FLAGS_DEBUG})
-set(CMAKE_C_FLAGS_DEBUG ${C_FLAGS_DEBUG})
-
-set(CMAKE_EXE_LINKER_FLAGS "${LINKER_FLAGS}")
-
-IF (MINGW)
-	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static -static-libgcc -static-libstdc++ -Wl,--enable-auto-import")
-	target_compile_definitions(compiler INTERFACE __USE_MINGW_ANSI_STDIO=1)
-ENDIF(MINGW)
-
-if (SANITIZE_FLAGS)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZE_FLAGS}")
-endif()
-
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "")
-set(CMAKE_EXE_LINKER_FLAGS_DEBUG "-g")
-
-if (GCC_GENERATE_GDB_INDEX)
-	# For pure debug binaries, generate a gdb index for better debugging
-	SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -Wl,--gdb-index")
-endif()
-
-IF(NOT MINGW)
-	SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} -rdynamic")
-	# Allow the linker to perform dead code elimination; this is considered
-	# experimental for COFF and PE formats and thus disabled for Windows builds
-	# (https://sourceware.org/binutils/docs/ld/Options.html)
-	if (NOT GCC_INCREMENTAL_LINKING AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-		SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
-	endif()
-ENDIF(NOT MINGW)
-
-IF(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
-	SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-zignore")
-ENDIF()
-
-if (FSO_FATAL_WARNINGS)
-	# Make warnings fatal if the right variable is set
-	target_compile_options(compiler INTERFACE "-Werror")
-endif()
-
-# Always define this to make sure that the fixed-width format macros are available
-target_compile_definitions(compiler INTERFACE __STDC_FORMAT_MACROS=1)
-
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
-	# GNU ar: Create thin archive files.
-	# Requires binutils-2.19 or later.
-	set(CMAKE_C_ARCHIVE_CREATE   "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_C_ARCHIVE_APPEND   "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
-	set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qTP  <TARGET> <LINK_FLAGS> <OBJECTS>")
-endif()

cmake/toolchain-msvc.cmake

@@ -1,129 +0,0 @@
-
-include(EnableExtraCompilerWarnings)
-include(CheckCXXCompilerFlag)
-include(util)
-
-MESSAGE(STATUS "Doing configuration specific to visual studio...")
-
-set_property(GLOBAL PROPERTY DEBUG_CONFIGURATIONS Debug)
-
-option(MSVC_USE_RUNTIME_DLL "Use the dynamically linked version of the runtime" OFF)
-option(MSVC_RELEASE_DEBUGGING "Set options that allow to debug release builds" OFF)
-
-MARK_AS_ADVANCED(FORCE MSVC_USE_RUNTIME_DLL)
-MARK_AS_ADVANCED(FORCE MSVC_RELEASE_DEBUGGING)
-
-# Qt is only available as DLL-runtime builds, so qtFRED forces the DLL runtime for the whole tree
-if(MSVC_USE_RUNTIME_DLL OR FSO_BUILD_QTFRED)
-	set(FSO_MSVC_RUNTIME_DLL ON)
-else()
-	set(FSO_MSVC_RUNTIME_DLL OFF)
-endif()
-
-# These are the warnings we disable
-set(WARNING_FLAGS
-	/wd4100 # unreferenced formal parameters
-	/wd4127 # constant conditional (assert)
-	/wd4201 # nonstandard extension used: nameless struct/union (happens a lot in Windows include headers)
-	/wd4290 # C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
-	/wd4390 # empty control statement (triggered by nprintf and mprintf's inside of one-line if's, etc)
-	/wd4410 # illegal size for operand... ie... 	fxch st(1)
-	/wd4511 # copy constructor could not be generated (happens a lot in Windows include headers)
-	/wd4512 # assignment operator could not be generated (happens a lot in Windows include headers)
-	/wd4514 # unreferenced inline function removed
-	/wd4611 # _setjmp warning.  Since we use setjmp alot, and we don't really use constructors or destructors, this warning doesn't really apply to us.
-	/wd4663 # C++ language change (template specification)
-	/wd4710 # is inline function not expanded (who cares?)
-	/wd4711 # tells us an inline function was expanded (who cares?)
-	/wd4786 # is identifier truncated to 255 characters (happens all the time in Microsoft #includes) -- Goober5000"
-	/wd4996 # deprecated strcpy, strcat, sprintf, etc. (from MSVC 2005) - taylor
-	/wd4311 # Disables warnings about casting pointer types to ints. The funny thing is these warnings can't be resolved, just disabled... - m!m
-	/wd4302 # Same as above - m!m
-	/wd4366 # The result of the unary '&' operator may be unaligned - m!m
-	/wd4592 # "symbol will be dynamically initialized" is being generated by a compiler bug, see https://stackoverflow.com/a/34027257 for an explanation - m!m
-	$<$<CONFIG:Release>:/wd4101> # In release mode there are unreferenced variables because debug needs them
-	/wd4995 # "'vsprintf': name was marked as #pragma deprecated" is being caused by our custom definition of vsprintf. I have no idea what causes this or how to fix it - m!m
-	/wd4723 # "potential divide by 0" is caused by some code that definitely will not divide by zero - m!m
-	/wd4121 # "alignment of a member was sensitive to packing" happens in a Windows header - m!m
-)
-
-target_compile_options(compiler INTERFACE ${WARNING_FLAGS})
-
-# Base
-set(CMAKE_C_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /Zc:forScope /Gd /EHsc /nologo /Zm200")
-set(CMAKE_CXX_FLAGS "/MP /GS- /analyze- /Zc:wchar_t /errorReport:prompt /Zc:forScope /Gd /EHsc /nologo /Zm200")
-
-set(CMAKE_EXE_LINKER_FLAGS "/MANIFEST /SAFESEH:NO /ERRORREPORT:PROMPT /NOLOGO")
-set(CMAKE_STATIC_LINKER_FLAGS "")
-
-if(NOT IS_ARM64)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DYNAMICBASE:NO")
-endif()
-
-# Release
-set(CMAKE_C_FLAGS_RELEASE "/GL /Gy- /Ox /Ot /Ob2 /fp:precise /GF /Oy /Oi /Zi /W3")
-set(CMAKE_CXX_FLAGS_RELEASE "/GL /Gy- /Ox /Ot /Ob2 /fp:precise /GF /Oy /Oi /Zi /W3")
-# /DEBUG:FULL so that we get PDBs which is needed for debugging crashdumps
-set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/OPT:REF /LTCG /INCREMENTAL:NO /DEBUG:FULL")
-set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "/LTCG")
-
-globally_enable_extra_compiler_warnings()
-
-if (MSVC_RELEASE_DEBUGGING)
-	CHECK_CXX_COMPILER_FLAG("/Zo" MSVC_COMPILER_SUPPORTS_ARCH_ZO)
-
-	if (MSVC_COMPILER_SUPPORTS_ARCH_ZO)
-		set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zo")
-		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zo")
-	endif()
-endif()
-
-# The debug runtime is not redistributable (statically linked or not), so only Debug may use it
-IF(FSO_MSVC_RUNTIME_DLL)
-	set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
-	add_compile_definitions(_AFXDLL)
-ELSE()
-	set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-ENDIF()
-
-# Debug
-set(CMAKE_C_FLAGS_DEBUG "/W4 /Gy /Zi /Od /RTC1 /Gd /Oy-")
-set(CMAKE_CXX_FLAGS_DEBUG "/W4 /Gy /Zi /Od /RTC1 /Gd /Oy-")
-set(CMAKE_EXE_LINKER_FLAGS_DEBUG "/DEBUG /INCREMENTAL:NO /MAPINFO:EXPORTS /NODEFAULTLIB:libcmt.lib")
-
-INCLUDE(MSVCMultipleProcessCompile)
-
-# Visual Studio supports compiling for multiple vector instruction sets
-
-if(IS_X86)
-	if(FORCED_NATIVE_SIMD_INSTRUCTIONS)
-		# MSVC has no direct -march=native equivalent, so just use the detected extensions.
-		SET(FSO_INSTRUCTION_SET ${DETECTED_SIMD_INSTRUCTIONS})
-	endif()
-
-	if(FSO_INSTRUCTION_SET STREQUAL "")
-		set(MSVC_SIMD_INSTRUCTIONS "IA32")
-	else()
-		set(MSVC_SIMD_INSTRUCTIONS ${FSO_INSTRUCTION_SET})
-	endif()
-
-	if (NOT (IS_64BIT AND (MSVC_SIMD_INSTRUCTIONS STREQUAL "IA32" OR MSVC_SIMD_INSTRUCTIONS STREQUAL "SSE" OR MSVC_SIMD_INSTRUCTIONS STREQUAL "SSE2")))
-		# 32-Bit and SSE(2) mustn't be set, as these are implied in x86_64 and thus MSVC does not support it for the /arch argument
-		CHECK_CXX_COMPILER_FLAG("/arch:${MSVC_SIMD_INSTRUCTIONS}" COMPILER_SUPPORTS_ARCH)
-
-		IF(COMPILER_SUPPORTS_ARCH)
-			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:${MSVC_SIMD_INSTRUCTIONS}")
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:${MSVC_SIMD_INSTRUCTIONS}")
-		ELSE()
-			message( FATAL_ERROR "Your version of MSVC does not support the requested instruction set. Consider updating!" )
-		ENDIF()
-	endif()
-
-endif()
-
-target_compile_definitions(compiler INTERFACE _CRT_SECURE_NO_DEPRECATE _CRT_SECURE_NO_WARNINGS _SECURE_SCL=0 NOMINMAX _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)
-
-if (FSO_FATAL_WARNINGS)
-	# Make warnings fatal if the right variable is set
-	target_compile_options(compiler INTERFACE "/WX")
-endif()

cmake/toolchain.cmake

@@ -1,82 +0,0 @@
-
-# File to execute compiler specific commands
-
-add_library(compiler INTERFACE)
-
-set(FSO_CONFIG_DEFINITIONS "$<$<CONFIG:Release>:NDEBUG>" "$<$<CONFIG:Debug>:_DEBUG>")
-if(NOT MSVC)
-	# On MSVC the debug runtime flags (/MTd, /MDd) define _DEBUG themselves, and a FastDebug
-	# build on the release runtime must not have it
-	list(APPEND FSO_CONFIG_DEFINITIONS "$<$<CONFIG:FastDebug>:_DEBUG>")
-endif()
-target_compile_definitions(compiler INTERFACE ${FSO_CONFIG_DEFINITIONS})
-
-set(FORCED_NATIVE_SIMD_INSTRUCTIONS ON CACHE BOOL "Override instruction set detection and compile with the maximum possible instructions for the current system.")
-IF(IS_X86)
-	SET(POSSIBLE_INSTRUCTION_SETS "" SSE SSE2 AVX AVX2)
-	if (CMAKE_CROSSCOMPILING)
-		message("Cross-Compile cannot detect supported instruction sets. Defaulting to SSE2. Disabling host-optimization.")
-		set(FORCED_NATIVE_SIMD_INSTRUCTIONS OFF)
-		set(DETECTED_SIMD_INSTRUCTIONS SSE2)
-	else()
-		detect_simd_instructions(DETECTED_SIMD_INSTRUCTIONS)
-	endif()
-
-	set(FORCED_SIMD_INSTRUCTIONS "" CACHE STRING "Overrides any instruction set settings (including forced-native). Any of ${POSSIBLE_INSTRUCTION_SETS}.")
-	if (NOT FORCED_SIMD_INSTRUCTIONS STREQUAL "")
-		set(FORCED_NATIVE_SIMD_INSTRUCTIONS OFF)
-		LIST(FIND POSSIBLE_INSTRUCTION_SETS "${FORCED_SIMD_INSTRUCTIONS}" SET_INDEX)
-
-		if (SET_INDEX LESS 0)
-			MESSAGE(STATUS "An invalid instruction set was specified, defaulting to no special compiler options.")
-			set(FSO_INSTRUCTION_SET "")
-		else ()
-			LIST(FIND POSSIBLE_INSTRUCTION_SETS "${DETECTED_SIMD_INSTRUCTIONS}" SET_INDEX)
-			if (SET_INDEX LESS 0)
-				MESSAGE(STATUS "An instruction set was specified which is unsupported on this platform. Compiled binary might not be executable.")
-			endif()
-
-			set(FSO_INSTRUCTION_SET ${FORCED_SIMD_INSTRUCTIONS})
-		endif()
-	else()
-		SET(FSO_INSTRUCTION_SET ${DETECTED_SIMD_INSTRUCTIONS})
-	endif()
-	MESSAGE(STATUS "Using instruction set level ${FSO_INSTRUCTION_SET}. Optimizations for host-system specifically: ${FORCED_NATIVE_SIMD_INSTRUCTIONS}.")
-
-	if (FSO_INSTRUCTION_SET STREQUAL "SSE")
-		add_compile_definitions(FSO_SIMD_SSE)
-	elseif (FSO_INSTRUCTION_SET STREQUAL "SSE2")
-		add_compile_definitions(FSO_SIMD_SSE)
-		add_compile_definitions(FSO_SIMD_SSE2)
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX")
-		add_compile_definitions(FSO_SIMD_SSE)
-		add_compile_definitions(FSO_SIMD_SSE2)
-		add_compile_definitions(FSO_SIMD_AVX)
-	elseif (FSO_INSTRUCTION_SET STREQUAL "AVX2")
-		add_compile_definitions(FSO_SIMD_SSE)
-		add_compile_definitions(FSO_SIMD_SSE2)
-		add_compile_definitions(FSO_SIMD_AVX)
-		add_compile_definitions(FSO_SIMD_AVX2)
-	endif()
-ENDIF()
-
-if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	include(toolchain-gcc)
-elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-	include(toolchain-msvc)
-elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-	include(toolchain-clang)
-elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
-	include(toolchain-apple-clang)
-ELSE("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	MESSAGE(STATUS "No special handling for this compiler present, good luck!")
-ENDIF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-
-find_package(Threads REQUIRED)
-target_link_libraries(compiler INTERFACE Threads::Threads)
-
-# Copy release settings to FastDebug
-set(CMAKE_C_FLAGS_FASTDEBUG "${CMAKE_C_FLAGS_RELEASE}")
-set(CMAKE_CXX_FLAGS_FASTDEBUG "${CMAKE_CXX_FLAGS_RELEASE}")
-set(CMAKE_EXE_LINKER_FLAGS_FASTDEBUG "${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
-set(CMAKE_STATIC_LINKER_FLAGS_FASTDEBUG "${CMAKE_STATIC_LINKER_FLAGS_RELEASE}")