builtin cheat to help Extreme Hunting 2 boot

The naomi2 vertex shader doesn't set 2-volume attributes (vtx_base1,
vtx_offs1 and vtx_uv1) if they aren't used. But the pixel shader always
references them even though they aren't actually used. This breaks some
gl drivers: "The shader uses varying vtx_uv1, but previous shader does
not write to it."

Fixes MINIDUMP-93

.cirrus.yml

@@ -1,5 +1,5 @@
 freebsd_instance:
-  image_family: freebsd-13-0
+  image_family: freebsd-13-1
 
 env:
   CCACHE_DIR: /tmp/ccache

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: ['https://utip.io/flyinghead', 'https://www.paypal.com/paypalme/FlycastEmu']

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,3 +1,12 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
 **Please Note: This form is the minimum required information for submitting bugs.**  
 **Removing this form may lead to your issue being closed until it is completed.**
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/android.yml

@@ -8,52 +8,89 @@ jobs:
 
     steps:
       - name: Set up build environment
-        run: sudo apt-get update && sudo apt-get -y install ninja-build
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ccache libcurl4-openssl-dev ninja-build
 
-      # Workaround for https://github.com/actions/virtual-environments/issues/3078
-      - name: Downgrade CMake
-        uses: jwlawson/[email protected]
-        with:
-          cmake-version: '3.19.x'
-
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
-          submodules: recursive
+          submodules: true
 
-      - uses: actions/cache@v2
+      - uses: actions/cache@v3
+        with:
+          path: ~/.ccache
+          key: android-ccache-${{ github.sha }}
+          restore-keys: android-ccache-
+
+      - uses: actions/cache@v3
         with:
           path: |
             ~/.gradle/caches
             ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-
+          key: android-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: android-gradle-
 
       - name: Gradle
         working-directory: shell/android-studio
         run: ./gradlew assembleRelease --parallel
+        env:
+          SENTRY_UPLOAD_URL: ${{ secrets.SENTRY_UPLOAD_URL }}
 
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
         with:
           name: flycast-release.apk
           path: shell/android-studio/flycast/build/outputs/apk/release/flycast-release.apk
 
-      - name: Set up git vars
+      - name: Build dump_syms
+        working-directory: core/deps/breakpad
         run: |
-          echo GIT_BUILD=`git describe --all --always | sed 's/remotes\/origin/heads/'`-$GITHUB_SHA >> $GITHUB_ENV
+          ./configure --prefix=$PWD
+          make -j2
+          make install
 
-      - name: Clean up
-        run: rm -f shell/android-studio/flycast/build/outputs/apk/release/*.json
+      - name: Extract symbols
+        run: |
+          DUMP_SYMS=./core/deps/breakpad/bin/dump_syms
+          SO_DIR=shell/android-studio/flycast/build/intermediates/cmake/release/obj
+          for arch in arm64-v8a armeabi-v7a x86 x86_64 ; do
+            $DUMP_SYMS $SO_DIR/$arch/libflycast.so > libflycast.so.sym
+            BUILD_ID=`head -1 libflycast.so.sym | awk '{ print $4 }'`
+            mkdir -p symbols/libflycast.so/$BUILD_ID
+            mv libflycast.so.sym symbols/libflycast.so/$BUILD_ID
+          done
 
-      - uses: jakejarvis/s3-sync-action@master
+      - name: Configure AWS Credentials
+        id: aws-credentials
+        uses: aws-actions/configure-aws-credentials@v1
         with:
-          args: --acl public-read --follow-symlinks
+          aws-access-key-id: AKIAJOZQS4H2PHQWYFCA
+          aws-secret-access-key: ${{ secrets.S3_SECRET_KEY }}
+          aws-region: us-east-2
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push'
+
+      - name: Upload to S3
+        run: aws s3 sync shell/android-studio/flycast/build/outputs/apk/release s3://flycast-builds/android/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --exclude='*.json' --follow-symlinks
+        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}
+
+      - name: Setup Sentry CLI
+        uses: mathieu-bour/[email protected]
         env:
-          AWS_S3_BUCKET: flycast-builds
-          AWS_ACCESS_KEY_ID: AKIAJOZQS4H2PHQWYFCA
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_SECRET_KEY }}
-          AWS_REGION: 'us-east-2'
-          SOURCE_DIR: 'shell/android-studio/flycast/build/outputs/apk/release/'
-          DEST_DIR: android/${{ env.GIT_BUILD }}
-        if: ${{ github.repository == 'flyinghead/flycast' && github.event_name == 'push' }}
+          SENTRY_TOKEN: ${{ secrets.SENTRY_TOKEN }}
+        with:
+          url: https://sentry.io
+          token: ${{ env.SENTRY_TOKEN }}
+          organization: flycast
+          project: minidump
+        if: ${{ env.SENTRY_TOKEN != '' }}
+      
+      - name: Upload symbols to Sentry
+        run: |
+          VERSION=$(git describe --tags --always)
+          sentry-cli releases new "$VERSION"
+          sentry-cli releases set-commits "$VERSION" --auto
+          sentry-cli upload-dif symbols 
+        shell: bash
+        env:
+          SENTRY_TOKEN: ${{ secrets.SENTRY_TOKEN }}
+        if: ${{ env.SENTRY_TOKEN != '' }}

.github/workflows/c-cpp.yml

@@ -7,112 +7,141 @@ jobs:
     name: ${{ matrix.config.name }}
     runs-on: ${{ matrix.config.os }}
 
+    defaults:
+      run:
+        shell: ${{ matrix.config.shell }}
+
+    env:
+      CCACHE_DIR: ${{ github.workspace }}/.ccache
+
     strategy:
       matrix:
         config:
-          - {name: i686-pc-windows-msvc, os: windows-latest, cmakeArgs: -DCMAKE_SYSTEM_VERSION="10.0.18362.0" -G "Visual Studio 16 2019" -A Win32}
-          - {name: x86_64-apple-darwin, os: macos-latest, cmakeArgs: -G "Xcode", destDir: osx}
-          - {name: x86_64-pc-linux-gnu, os: ubuntu-latest}
-          - {name: x86_64-pc-windows-msvc, os: windows-latest, cmakeArgs: -DCMAKE_SYSTEM_VERSION="10.0.18362.0" -G "Visual Studio 16 2019" -A x64}
-          - {name: x86_64-w64-mingw32, os: windows-latest, cmakeArgs: -G "MinGW Makefiles", destDir: win}
+          - {name: i686-pc-windows-msvc, os: windows-latest, shell: cmd, arch: x86, cmakeArgs: -G Ninja, buildType: Release}
+          - {name: apple-darwin, os: macos-latest, shell: sh, cmakeArgs: -G Xcode -DAPPLE_BREAKPAD=ON, destDir: osx, buildType: RelWithDebInfo}
+          - {name: apple-ios, os: macos-latest, shell: sh, cmakeArgs: -DCMAKE_SYSTEM_NAME=iOS -G Xcode, destDir: ios, buildType: Release}
+          - {name: x86_64-pc-linux-gnu, os: ubuntu-20.04, shell: sh, cmakeArgs: -G Ninja, destDir: linux, buildType: RelWithDebInfo}
+          - {name: x86_64-pc-windows-msvc, os: windows-latest, shell: cmd, arch: x64, cmakeArgs: -G Ninja, buildType: Release}
+          - {name: x86_64-w64-mingw32, os: windows-latest, shell: 'msys2 {0}', cmakeArgs: -G Ninja, destDir: win, buildType: RelWithDebInfo}
+          - {name: libretro-x86_64-pc-linux-gnu, os: ubuntu-latest, shell: sh, cmakeArgs: -DLIBRETRO=ON -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE -G Ninja, buildType: Release}
+          - {name: libretro-x86_64-w64-mingw32, os: windows-latest, shell: 'msys2 {0}', cmakeArgs: -DLIBRETRO=ON -G Ninja, buildType: Release}
 
     steps:
-      - name: Set up build environment (macos-latest)
+      - name: Set up build environment (macOS)
         run: |
-          brew install ccache libao libomp pulseaudio zlib
-          echo "/usr/local/opt/ccache/libexec" >> $GITHUB_PATH
-          echo "CCACHE_DIR=/tmp/ccache" >> $GITHUB_ENV
-        if: matrix.config.os == 'macos-latest'
+          # Unlink and re-link to prevent errors when github mac runner images install python outside of brew. See https://github.com/actions/setup-python/issues/577
+          brew list -1 | grep python | while read formula; do brew unlink $formula; brew link --overwrite $formula; done
+          brew update
+          brew install libao ldid ninja pulseaudio
+          VULKAN_VER=1.3.224.1 && aria2c --parameterized-uri=true https://{sdk.lunarg.com/sdk/download/$VULKAN_VER/mac,distfiles.macports.org/MoltenVK}/vulkansdk-macos-$VULKAN_VER.dmg
+          hdiutil attach ./vulkansdk-macos-*.dmg
+          sudo /Volumes/vulkansdk-macos-*/InstallVulkan.app/Contents/MacOS/InstallVulkan --root $HOME/VulkanSDK --accept-licenses --default-answer --confirm-command install
+          hdiutil detach /Volumes/vulkansdk-macos-*
+          echo "VULKAN_SDK=$HOME/VulkanSDK/macOS" >> $GITHUB_ENV
+        if: runner.os == 'macOS'
 
-      - name: Set up build environment (ubuntu-latest)
+      - name: Set up build environment (Linux)
         run: |
+          sudo add-apt-repository ppa:christianrauch/libdecoration
           sudo apt-get update
-          sudo apt-get -y install ccache libao-dev libasound2-dev libevdev-dev libgl1-mesa-dev libpulse-dev libsdl2-dev libudev-dev libzip-dev libminiupnpc-dev
-          echo "CCACHE_DIR=/tmp/ccache" >> $GITHUB_ENV
-        if: matrix.config.os == 'ubuntu-latest'
+          sudo apt-get -y install ccache libao-dev libasound2-dev libevdev-dev libgl1-mesa-dev liblua5.3-dev libminiupnpc-dev libpulse-dev libsdl2-dev libudev-dev libzip-dev ninja-build libcurl4-openssl-dev
+          sudo apt-get -y install libwayland-dev libdecor-0-dev libaudio-dev libjack-dev libsndio-dev libsamplerate0-dev libx11-dev libxext-dev libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxkbcommon-dev libdrm-dev libgbm-dev libgles2-mesa-dev libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev
+        if: runner.os == 'Linux'
 
-      - name: Set up build environment (windows-latest)
-        run: echo "DXSDK_DIR=${Env:HOMEDRIVE}${Env:HOMEPATH}\ccache\" | Out-File -FilePath $Env:GITHUB_ENV -Encoding utf-8 -Append
-        if: matrix.config.os == 'windows-latest' && matrix.config.name != 'x86_64-w64-mingw32'
-
-      - uses: actions/cache@v2
+      - name: Set up build environment (Windows, MinGW)
+        uses: msys2/setup-msys2@v2
         with:
-          path: /tmp/ccache
-          key: ccache-${{ matrix.config.os }}-${{ github.sha }}
-          restore-keys: ccache-${{ matrix.config.os }}-
-        if: matrix.config.os != 'windows-latest'
+          msystem: MINGW64
+          install: git make mingw-w64-x86_64-ccache mingw-w64-x86_64-cmake mingw-w64-x86_64-lua mingw-w64-x86_64-ninja mingw-w64-x86_64-SDL2 mingw-w64-x86_64-toolchain
+        if: matrix.config.shell == 'msys2 {0}'
 
-      - uses: actions/cache@v2
-        id: cache
+      - name: Set up build environment (Windows, Visual Studio)
+        run: |
+          choco install ccache directx-sdk ninja
+          echo DXSDK_DIR=C:\Program Files (x86)\Microsoft DirectX SDK (June 2010)>> %GITHUB_ENV%
+        if: matrix.config.shell == 'cmd'
+
+      - uses: ilammy/msvc-dev-cmd@v1
         with:
-          path: $HOME/ccache
-          key: ccache-${{ matrix.config.os }}-${{ github.sha }}
-          restore-keys: ccache-${{ matrix.config.os }}-
-        if: matrix.config.os == 'windows-latest'
+          arch: ${{ matrix.config.arch }}
+        if: matrix.config.shell == 'cmd'
 
-      - name: Download DX2010
-        if: steps.cache.outputs.cache-hit != 'true' && matrix.config.os == 'windows-latest' && matrix.config.name != 'x86_64-w64-mingw32'
-        run:   |
-               curl -L https://download.microsoft.com/download/a/e/7/ae743f1f-632b-4809-87a9-aa1bb3458e31/DXSDK_Jun10.exe -o _DX2010_.exe
-               7z x _DX2010_.exe DXSDK/Include -o_DX2010_
-               7z x _DX2010_.exe DXSDK/Lib/x86 -o_DX2010_
-               7z x _DX2010_.exe DXSDK/Lib/x64 -o_DX2010_
-               mv _DX2010_/DXSDK $HOME/ccache
-               rm -fR _DX*_ _DX*_.exe
-        shell: bash
-
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
-          submodules: recursive
+          submodules: true
 
-      - name: Create artifact directory
-        run: mkdir -p build/artifact
+      - name: Compile a universal OpenMP (macOS)
+        run: HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1 brew reinstall --build-from-source --formula ./shell/apple/libomp.rb
+        if: matrix.config.name == 'apple-darwin'
 
-      - name: Build SDL (macos-latest)
-        run: |
-          cd shell/apple
-          mkdir artifacts
-          brew install --build-from-source ./sdl2.rb
-        if: matrix.config.os == 'macos-latest'
+      - name: Compile OpenMP.xcframework (iOS)
+        run: ./shell/apple/emulator-ios/OpenMP/build_ios_openmp.sh --disableSimulator
+        if: matrix.config.name == 'apple-ios'
+
+      - uses: actions/cache@v3
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: ccache-${{ matrix.config.name }}-${{ github.sha }}
+          restore-keys: ccache-${{ matrix.config.name }}-
+        if: runner.os != 'macOS'
 
       - name: CMake
         run: |
-          cmake -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE=artifact ${{ matrix.config.cmakeArgs }}
-          cmake --build build --config Release --parallel 2
+          cmake -B build -DCMAKE_BUILD_TYPE=${{ matrix.config.buildType }} -DCMAKE_INSTALL_PREFIX=artifact ${{ matrix.config.cmakeArgs }} -DSENTRY_UPLOAD_URL=${{ env.SENTRY_UPLOAD_URL }}
+          cmake --build build --config ${{ matrix.config.buildType }} --target install
+        env:
+          SENTRY_UPLOAD_URL: ${{ secrets.SENTRY_UPLOAD_URL }}
 
       - name: Unit Tests
         run: |
-          mkdir -p build/tests
-          cmake -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE=tests -DENABLE_CTEST=ON ${{ matrix.config.cmakeArgs }}
-          cmake --build build --config Release --parallel 2
-          ./build/tests/flycast
+          cmake -B build -DCMAKE_BUILD_TYPE=${{ matrix.config.buildType }} -DCMAKE_INSTALL_PREFIX=artifact -DENABLE_CTEST=ON ${{ matrix.config.cmakeArgs }}
+          cmake --build build --config ${{ matrix.config.buildType }}
+          ./build/flycast
         if: matrix.config.name == 'x86_64-pc-linux-gnu'
 
-      - uses: actions/upload-artifact@v2
+      - name: Dump symbols
+        run: |
+          mkdir -p symbols
+          core/deps/breakpad/bin/dump_syms artifact/bin/flycast.exe > symbols/flycast.sym 2>/dev/null
+          strip artifact/bin/flycast.exe
+        if: matrix.config.name == 'x86_64-w64-mingw32'
+
+      - name: Build breakpad (linux)
+        working-directory: core/deps/breakpad
+        run: |
+          ./configure
+          make
+          sudo make install
+        if: matrix.config.name == 'x86_64-pc-linux-gnu'
+
+      - name: Dump symbols and make AppImage (linux)
+        run: |
+          mkdir -p symbols
+          dump_syms artifact/bin/flycast > symbols/flycast.sym 2>/dev/null
+          strip artifact/bin/flycast
+          shell/linux/make-appimage.sh . artifact/bin appimage
+          mv flycast-x86_64.AppImage artifact/bin
+          rm artifact/bin/flycast
+        if: matrix.config.name == 'x86_64-pc-linux-gnu'
+
+      - uses: actions/upload-artifact@v3
         with:
           name: flycast-${{ matrix.config.name }}
-          path: build/artifact
+          path: artifact/bin
 
       - name: Package app (macos)
         run: |
-          cd build/artifact
-          rm -rf Flycast.swiftmodule
-          zip -r flycast.app.zip Flycast.app
-          rm -rf Flycast.app
-        if: matrix.config.os == 'macos-latest'
+          cd artifact/bin
+          zip -rm flycast.app.zip Flycast.app
+        if: matrix.config.name == 'apple-darwin'
 
       - name: Package app (windows)
         run: |
-          powershell Compress-Archive build/artifact/flycast.exe build/artifact/flycast.zip 
-          rm build/artifact/flycast.exe
+          powershell Compress-Archive artifact/bin/flycast.exe artifact/bin/flycast.zip 
+          rm artifact/bin/flycast.exe
         if: matrix.config.name == 'x86_64-w64-mingw32'
 
-      - name: Set up git vars
-        run: |
-          echo GIT_BUILD=`git describe --all --always | sed 's/remotes\/origin/heads/'`-$GITHUB_SHA >> $GITHUB_ENV
-        shell: bash
-
       - name: Configure AWS Credentials
         id: aws-credentials
         uses: aws-actions/configure-aws-credentials@v1
@@ -123,5 +152,29 @@ jobs:
         if: github.repository == 'flyinghead/flycast' && github.event_name == 'push' && matrix.config.destDir != ''
 
       - name: Upload to S3
-        run: aws s3 sync build/artifact s3://flycast-builds/${{ matrix.config.destDir }}/${{ env.GIT_BUILD }} --acl public-read --follow-symlinks
+        run: aws s3 sync artifact/bin s3://flycast-builds/${{ matrix.config.destDir }}/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --follow-symlinks
+        shell: bash
         if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}
+
+      - name: Setup Sentry CLI
+        uses: mathieu-bour/[email protected]
+        env:
+          SENTRY_TOKEN: ${{ secrets.SENTRY_TOKEN }}
+        with:
+          url: https://sentry.io
+          token: ${{ env.SENTRY_TOKEN }}
+          organization: flycast
+          project: minidump
+        if: ${{ env.SENTRY_TOKEN != '' }}
+      
+      - name: Upload symbols to Sentry (Windows, macOS, Linux)
+        run: |
+          VERSION=$(git describe --tags --always)
+          sentry-cli releases new "$VERSION"
+          sentry-cli releases set-commits "$VERSION" --auto
+          sentry-cli upload-dif symbols
+        shell: bash
+        env:
+          SENTRY_TOKEN: ${{ secrets.SENTRY_TOKEN }}
+        if: ${{ env.SENTRY_TOKEN != '' && (matrix.config.name == 'x86_64-w64-mingw32' || matrix.config.name == 'apple-darwin' || matrix.config.name == 'x86_64-pc-linux-gnu') }}
+        

.github/workflows/crowdin_prep.yml

@@ -0,0 +1,36 @@
+# Prepare source texts & upload them to Crowdin
+
+name: Crowdin Source Texts Upload
+
+# on change to the English texts
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - 'shell/libretro/libretro_core_options.h'
+
+jobs:
+  upload_source_file:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Java JDK
+        uses: actions/setup-java@v3
+        with:
+          java-version: 18
+          distribution: zulu
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Upload Source
+        shell: bash
+        env:
+          CROWDIN_API_KEY: ${{ secrets.CROWDIN_API_KEY }}
+        run: |
+          python3 intl/upload_workflow.py $CROWDIN_API_KEY "flyinghead-flycast" "shell/libretro/libretro_core_options.h"

.github/workflows/crowdin_translate.yml

@@ -0,0 +1,49 @@
+# Download translations form Crowdin & Recreate libretro_core_options_intl.h
+
+name: Crowdin Translation Integration
+
+on:
+  schedule:
+  # please choose a random time & weekday to avoid all repos synching at the same time
+    - cron: '15 22 * * 5'  # Fridays at 10:15 PM, UTC
+
+jobs:
+  create_intl_file:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Java JDK
+        uses: actions/setup-java@v3
+        with:
+          java-version: 18
+          distribution: zulu
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          persist-credentials: false # otherwise, the token used is the GITHUB_TOKEN, instead of your personal access token.
+          fetch-depth: 0 # otherwise, there would be errors pushing refs to the destination repository.
+
+      - name: Create intl file
+        shell: bash
+        env:
+          CROWDIN_API_KEY: ${{ secrets.CROWDIN_API_KEY }}
+        run: |
+          python3 intl/download_workflow.py $CROWDIN_API_KEY "flyinghead-flycast" "shell/libretro/libretro_core_options_intl.h"
+
+      - name: Commit files
+        run: |
+          git config --local user.email "[email protected]"
+          git config --local user.name "github-actions[bot]"
+          git add intl/*_workflow.py "shell/libretro/libretro_core_options_intl.h"
+          git commit -m "Fetch translations & Recreate libretro_core_options_intl.h"
+
+      - name: GitHub Push
+        uses: ad-m/[email protected]
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ github.ref }}

.github/workflows/switch.yml

@@ -0,0 +1,59 @@
+name: Nintendo Switch CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    name: ${{ matrix.config.name }}
+    runs-on: ubuntu-latest
+    container: devkitpro/devkita64:20220128
+
+    strategy:
+      matrix:
+        config:
+          - {name: standalone, destDir: switch}
+          - {name: libretro, cmakeArgs: -DLIBRETRO=ON}
+
+    steps:
+      - name: Set up build environment
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install awscli ccache ninja-build
+
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - uses: actions/cache@v3
+        with:
+          path: ~/.ccache
+          key: ccache-switch-${{ matrix.config.name }}-${{ github.sha }}
+          restore-keys: ccache-switch-${{ matrix.config.name }}-
+
+      - name: CMake
+        run: |
+          $DEVKITPRO/portlibs/switch/bin/aarch64-none-elf-cmake -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=artifact -G Ninja ${{ matrix.config.cmakeArgs }}
+          cmake --build build --config Release --target install
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: flycast-switch-${{ matrix.config.name }}
+          path: artifact/bin
+
+      - name: Package app
+        run: zip -m artifact/bin/flycast.nro.zip artifact/bin/flycast.nro
+        if: hashFiles('artifact/bin/flycast.nro') != ''
+
+      - name: Configure AWS Credentials
+        id: aws-credentials
+        uses: aws-actions/configure-aws-credentials@v1
+        with:
+          aws-access-key-id: AKIAJOZQS4H2PHQWYFCA
+          aws-secret-access-key: ${{ secrets.S3_SECRET_KEY }}
+          aws-region: us-east-2
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push' && matrix.config.destDir != ''
+
+      - name: Upload to S3
+        run: aws s3 sync artifact/bin s3://flycast-builds/${{ matrix.config.destDir }}/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --follow-symlinks
+        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}

.github/workflows/uwp.yml

@@ -0,0 +1,69 @@
+name: Windows UWP CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    env:
+      VCPKG_ROOT: ${{ github.workspace }}/vcpkg
+      VCPKG_DEFAULT_BINARY_CACHE: ${{ github.workspace }}/vcpkg/bincache
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          submodules: true
+
+      - name: bootstrap vcpkg
+        run: |
+          git clone https://github.com/microsoft/vcpkg
+          mkdir vcpkg\bincache
+          vcpkg\bootstrap-vcpkg.bat
+
+      - uses: actions/cache@v3
+        with:
+          path: ${{ env.VCPKG_DEFAULT_BINARY_CACHE }}
+          key: vcpkg-${{ hashFiles( 'vcpkg.json' ) }}
+
+      - name: CMake
+        run: |
+          cmake -B build -DCMAKE_BUILD_TYPE=Release -G "Visual Studio 17 2022" -A x64 -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0.22000.0 -DCMAKE_SYSTEM_PROCESSOR=AMD64 -DCMAKE_CROSSCOMPILING=OFF -DCMAKE_TOOLCHAIN_FILE=%VCPKG_ROOT%\scripts\buildsystems\vcpkg.cmake
+          cmake --build build --config Release --parallel 2
+        shell: cmd
+
+      - uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Package app
+        run: |
+          mkdir build\artifact
+          cd build\AppPackages\flycast\flycast_*_x64_Test
+          mkdir tmp
+          ren *.msix flycast.msix
+          makeappx.exe unpack /p .\flycast.msix /d tmp
+          copy ..\..\..\Release\*.dll tmp
+          makeappx pack /d tmp /p ..\..\..\artifact\flycast.appx
+
+      - name: Sign app
+        run: signtool sign /f shell\uwp\sign_cert.pfx /p '${{ secrets.SIGN_CERT_PWD }}' /v /fd SHA256 build\artifact\flycast.appx
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push'
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: flycast-uwp
+          path: build/artifact
+
+      - name: Configure AWS Credentials
+        id: aws-credentials
+        uses: aws-actions/configure-aws-credentials@v1
+        with:
+          aws-access-key-id: AKIAJOZQS4H2PHQWYFCA
+          aws-secret-access-key: ${{ secrets.S3_SECRET_KEY }}
+          aws-region: us-east-2
+        if: github.repository == 'flyinghead/flycast' && github.event_name == 'push'
+
+      - name: Upload to S3
+        run: aws s3 sync build/artifact s3://flycast-builds/xbox/${GITHUB_REF#refs/}-$GITHUB_SHA --acl public-read --follow-symlinks
+        shell: bash
+        if: ${{ steps.aws-credentials.outputs.aws-account-id != '' }}

.gitignore

@@ -1,50 +1,12 @@
+build/
+
+# macOS
 .DS_Store
-*.class
-*.orig
-*build_obj
-Workdir/data
-Workdir/reicast*
-Workdir/vmu*
-Workdir/webui*
-Workdir/emu.cfg
-Workdir/lib*ant.properties
-
-# iOS General
-*/build/*
-**/build/*
-*.pbxuser
-!default.pbxuser
-*.mode1v3
-!default.mode1v3
-*.mode2v3
-!default.mode2v3
-*.perspectivev3
-!default.perspectivev3
-xcuserdata
-profile
-*.moved-aside
-DerivedData
-*.hmap
-emulator.xccheckout
-reicast.xccheckout
-build/*
-*.so
-*Karen_angelXwind*
-local.properties
-ant.properties
-*.d
-reicast-ios.xccheckout
-
-# Linux General
-shell/linux/.map
-shell/linux/flycast.elf.map
-shell/linux/nosym-flycast.elf
-shell/linux/flycast.elf
-shell/linux/dispframe.elf
+shell/apple/emulator-ios/OpenMP/OpenMP.xcframework
 
 # Visual Studio
-generated
-.vs
+.vs/
+out/
 
 # JetBrains IDES
 .idea/

.gitlab-ci.yml

@@ -0,0 +1,147 @@
+# DESCRIPTION: GitLab CI/CD for libRetro (NOT FOR GitLab-proper)
+
+##############################################################################
+################################# BOILERPLATE ################################
+##############################################################################
+
+# Core definitions
+.core-defs:
+  variables:
+    GIT_SUBMODULE_STRATEGY: recursive
+    CORENAME: flycast
+    CORE_ARGS: -DLIBRETRO=ON -DCMAKE_BUILD_TYPE=Release
+
+.core-defs-linux:
+  extends: .core-defs
+  variables:
+    CORE_ARGS: -DLIBRETRO=ON -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE -DCMAKE_BUILD_TYPE=Release
+
+.core-defs-osx-x64:
+  extends: .core-defs
+  variables:
+    CORE_ARGS: -DLIBRETRO=ON -G Xcode -DCMAKE_BUILD_TYPE=Release
+    EXTRA_PATH: Release
+
+.core-defs-osx-arm64:
+  extends: .core-defs
+  variables:
+    CORE_ARGS: -DLIBRETRO=ON -G Xcode -DCMAKE_BUILD_TYPE=Release
+    EXTRA_PATH: Release
+
+.core-defs-android:
+  extends: .core-defs
+  script:
+    - cmake $CORE_ARGS -DANDROID_PLATFORM=android-$API_LEVEL -DCMAKE_TOOLCHAIN_FILE=$NDK_ROOT/build/cmake/android.toolchain.cmake -DANDROID_STL=c++_static -DANDROID_ABI=$ANDROID_ABI -DANDROID_ARM_MODE=arm "$CMAKE_SOURCE_ROOT" -B$BUILD_DIR
+    - cmake --build $BUILD_DIR --target ${CORENAME}_libretro --config Release -- -j $NUMPROC
+    - mv $BUILD_DIR/${CORENAME}_libretro.so $LIBNAME
+    - if [ $STRIP_CORE_LIB -eq 1 ]; then $NDK_ROOT/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-strip $LIBNAME; fi
+  variables:
+    API_LEVEL: 18
+
+# Inclusion templates, required for the build to work
+include:
+  ################################## DESKTOPS ################################
+  # Windows
+  - project: 'libretro-infrastructure/ci-templates'
+    file: '/windows-cmake-mingw.yml'
+
+  # MacOS
+  - project: 'libretro-infrastructure/ci-templates'
+    file: 'osx-cmake-x86.yml'
+
+  # MacOS arm64
+  - project: 'libretro-infrastructure/ci-templates'
+    file: 'osx-cmake-arm64.yml'
+
+  # Linux
+  - project: 'libretro-infrastructure/ci-templates'
+    file: '/linux-cmake.yml'
+
+  ################################## CELLULAR ################################
+  # Android
+  - project: 'libretro-infrastructure/ci-templates'
+    file: '/android-cmake.yml'
+
+  ################################## CONSOLES ################################  
+  # Nintendo Switch
+#  - project: 'libretro-infrastructure/ci-templates'
+#    file: '/libnx-static.yml'
+
+# Stages for building
+stages:
+  - build-prepare
+  - build-shared
+#  - build-static
+
+##############################################################################
+#################################### STAGES ##################################
+##############################################################################
+#
+################################### DESKTOPS #################################
+# Windows 64-bit
+libretro-build-windows-x64:
+  extends:
+    - .libretro-windows-cmake-x86_64
+    - .core-defs
+
+# Windows 32-bit
+libretro-build-windows-i686:
+  extends:
+    - .libretro-windows-cmake-x86
+    - .core-defs
+
+# Linux 64-bit
+libretro-build-linux-x64:
+  extends:
+    - .libretro-linux-cmake-x86_64
+    - .core-defs-linux
+
+# Linux 32-bit
+libretro-build-linux-i686:
+  extends:
+    - .libretro-linux-cmake-x86
+    - .core-defs-linux
+
+# MacOS 64-bit
+libretro-build-osx-x64:
+  extends:
+    - .libretro-osx-cmake-x86
+    - .core-defs-osx-x64
+
+# MacOS arm 64-bit
+libretro-build-osx-arm64:
+  extends:
+    - .libretro-osx-cmake-arm64
+    - .core-defs-osx-arm64
+
+################################### CELLULAR #################################
+# Android ARMv7a
+android-armeabi-v7a:
+  extends:
+    - .libretro-android-cmake-armeabi-v7a
+    - .core-defs-android
+
+# Android ARMv8a
+android-arm64-v8a:
+  extends:
+    - .libretro-android-cmake-arm64-v8a
+    - .core-defs-android
+
+# Android 64-bit x86
+android-x86_64:
+  extends:
+    - .libretro-android-cmake-x86_64
+    - .core-defs-android
+
+# Android 32-bit x86
+android-x86:
+  extends:
+    - .libretro-android-cmake-x86
+    - .core-defs-android
+
+################################### CONSOLES #################################
+# Nintendo Switch
+#libretro-build-libnx-aarch64:
+#  extends:
+#    - .libretro-libnx-static-retroarch-master
+#    - .core-defs

.gitmodules

@@ -4,3 +4,21 @@
 [submodule "core/deps/libchdr"]
 	path = core/deps/libchdr
 	url = https://github.com/rtissera/libchdr.git
+[submodule "core/deps/luabridge"]
+	path = core/deps/luabridge
+	url = https://github.com/vinniefalco/LuaBridge.git
+[submodule "core/deps/breakpad"]
+	path = core/deps/breakpad
+	url = https://github.com/flyinghead/mingw-breakpad
+[submodule "core/deps/Vulkan-Headers"]
+	path = core/deps/Vulkan-Headers
+	url = https://github.com/KhronosGroup/Vulkan-Headers.git
+[submodule "core/deps/VulkanMemoryAllocator"]
+	path = core/deps/VulkanMemoryAllocator
+	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
+[submodule "core/deps/glslang"]
+	path = core/deps/glslang
+	url = https://github.com/KhronosGroup/glslang.git
+[submodule "core/deps/oboe"]
+	path = core/deps/oboe
+	url = https://github.com/google/oboe.git

README.md

@@ -1,11 +1,13 @@
 # Flycast
 
-[![C/C++ CI](https://github.com/flyinghead/flycast/actions/workflows/c-cpp.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/c-cpp.yml)
 [![Android CI](https://github.com/flyinghead/flycast/actions/workflows/android.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/android.yml)
+[![C/C++ CI](https://github.com/flyinghead/flycast/actions/workflows/c-cpp.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/c-cpp.yml)
+[![Nintendo Switch CI](https://github.com/flyinghead/flycast/actions/workflows/switch.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/switch.yml)
+[![Windows UWP CI](https://github.com/flyinghead/flycast/actions/workflows/uwp.yml/badge.svg)](https://github.com/flyinghead/flycast/actions/workflows/uwp.yml)
 
 ![flycast logo](https://github.com/flyinghead/flycast/raw/master/shell/linux/flycast.png)
 
-**Flycast** is a multi-platform Sega Dreamcast, Naomi and Atomiswave emulator derived from [**reicast**](https://reicast.com/).
+**Flycast** is a multi-platform Sega Dreamcast, Naomi, Naomi 2, and Atomiswave emulator derived from [**reicast**](https://github.com/skmp/reicast-emulator).
 
 Information about configuration and supported features can be found on [**TheArcadeStriker's flycast wiki**](https://github.com/TheArcadeStriker/flycast-wiki/wiki).
 
@@ -13,24 +15,36 @@ Join us on our [**Discord server**](https://discord.gg/X8YWP8w) for a chat.
 
 ## Install
 
-### Flatpak
+### Flatpak (Linux)
 
-1. [Set up Flatpak](https://www.flatpak.org/setup/)
+1. [Set up Flatpak](https://www.flatpak.org/setup/).
 
-2. Install Flycast from [Flathub](https://flathub.org/apps/details/org.flycast.Flycast)
+2. Install Flycast from [Flathub](https://flathub.org/apps/details/org.flycast.Flycast):
 
 `flatpak install -y org.flycast.Flycast`
 
-3. Run Flycast
+3. Run Flycast:
 
 `flatpak run org.flycast.Flycast`
 
+### Homebrew (MacOS)
+
+1. [Set up Homebrew](https://brew.sh).
+
+2. Install Flycast via Homebrew:
+
+`brew install --cask flycast`
+
+### Xbox One/Series
+
+#### Retail:
+Open [**gamr13's github page**](https://gamr13.github.io/) from your Xbox console.
+
+#### Dev Mode:
+Grab the latest build from [**the builds page**](https://flyinghead.github.io/flycast-builds/), or the [**GitHub Actions**](https://github.com/flyinghead/flycast/actions/workflows/uwp.yml). Then install it using the **Xbox Device Portal**.
+
 ### Binaries
 
-Get fresh builds for your system [on the builds page](https://flyinghead.github.io/flycast-builds/).
+Get fresh builds for your system [**on the builds page**](https://flyinghead.github.io/flycast-builds/).
 
-**New:** Now automated test results are available as well.
-
-## Disclaimer
-
-All code contributed to this fork is *not* bound by the Individual Contributor License Agreement of the upstream repository (https://github.com/reicast/reicast-emulator) and shall *not* be considered as a contribution to the upstream repository.
+**New:** Now automated test results are available as well. 

core/archive/7zArchive.cpp

@@ -33,20 +33,10 @@ bool SzArchive::Open(const char* path)
 
 	File_Close(&archiveStream.file);
 	File_Construct(&archiveStream.file);
-#ifdef USE_WINDOWS_FILE
-	nowide::wstackstring wpath;
-	if (!wpath.convert(path))
-		return false;
-	archiveStream.file.handle = CreateFileW(wpath.c_str(),
-			GENERIC_READ, FILE_SHARE_READ, NULL,
-			OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-	if (archiveStream.file.handle == INVALID_HANDLE_VALUE)
-		return false;
-#else
 	archiveStream.file.file = nowide::fopen(path, "rb");
 	if (archiveStream.file.file == nullptr)
 		return false;
-#endif
+
 	FileInStream_CreateVTable(&archiveStream);
 	LookToRead2_CreateVTable(&lookStream, 0);
 	lookStream.buf = (Byte *)ISzAlloc_Alloc(&g_Alloc, kInputBufSize);

core/archive/rzip.cpp

@@ -24,6 +24,7 @@ const u8 RZipHeader[8] = { '#', 'R', 'Z', 'I', 'P', 'v', 1, '#' };
 bool RZipFile::Open(const std::string& path, bool write)
 {
 	verify(file == nullptr);
+	this->write = write;
 
 	file = nowide::fopen(path.c_str(), write ? "wb" : "rb");
 	if (file == nullptr)
@@ -49,6 +50,17 @@ bool RZipFile::Open(const std::string& path, bool write)
 		chunkIndex = 0;
 		chunkSize = 0;
 	}
+	else
+	{
+		maxChunkSize = 1024 * 1024;
+		if (std::fwrite(RZipHeader, sizeof(RZipHeader), 1, file) != 1
+			|| std::fwrite(&maxChunkSize, sizeof(maxChunkSize), 1, file) != 1
+			|| std::fwrite(&size, sizeof(size), 1, file) != 1)
+		{
+			Close();
+			return false;
+		}
+	}
 
 	return true;
 }
@@ -57,6 +69,11 @@ void RZipFile::Close()
 {
 	if (file != nullptr)
 	{
+		if (write)
+		{
+			std::fseek(file, sizeof(RZipHeader) + sizeof(maxChunkSize), SEEK_SET);
+			std::fwrite(&size, sizeof(size), 1, file);
+		}
 		std::fclose(file);
 		file = nullptr;
 		if (chunk != nullptr)
@@ -70,6 +87,7 @@ void RZipFile::Close()
 size_t RZipFile::Read(void *data, size_t length)
 {
 	verify(file != nullptr);
+	verify(!write);
 
 	u8 *p = (u8 *)data;
 	size_t rv = 0;
@@ -99,7 +117,7 @@ size_t RZipFile::Read(void *data, size_t length)
 			delete [] zipped;
 			chunkSize = (u32)tl;
 		}
-		u32 l = std::min(chunkSize - chunkIndex, (u32)length);
+		u32 l = std::min(chunkSize - chunkIndex, (u32)(length - rv));
 		memcpy(p, chunk + chunkIndex, l);
 		p += l;
 		chunkIndex += l;
@@ -112,14 +130,9 @@ size_t RZipFile::Read(void *data, size_t length)
 size_t RZipFile::Write(const void *data, size_t length)
 {
 	verify(file != nullptr);
-	verify(std::ftell(file) == 0);
+	verify(write);
 
-	maxChunkSize = 1024 * 1024;
-	size = length;
-	if (std::fwrite(RZipHeader, sizeof(RZipHeader), 1, file) != 1
-		|| std::fwrite(&maxChunkSize, sizeof(maxChunkSize), 1, file) != 1
-		|| std::fwrite(&size, sizeof(size), 1, file) != 1)
-		return 0;
+	size += length;
 	const u8 *p = (const u8 *)data;
 	// compression output buffer must be 0.1% larger + 12 bytes
 	uLongf maxZippedSize = maxChunkSize + maxChunkSize / 1000 + 12;

core/archive/rzip.h

@@ -32,6 +32,7 @@ public:
 	size_t Size() const { return size; }
 	size_t Read(void *data, size_t length);
 	size_t Write(const void *data, size_t length);
+	FILE *rawFile() const { return file; }
 
 private:
 	FILE *file = nullptr;
@@ -40,4 +41,5 @@ private:
 	u8 *chunk = nullptr;
 	u32 chunkSize = 0;
 	u32 chunkIndex = 0;
+	bool write = false;
 };

core/build.h

@@ -121,14 +121,11 @@
 #define USE_WINCE_HACK
 #endif
 
-#define DC_PLATFORM_MASK        7
-#define DC_PLATFORM_DREAMCAST   0   /* Works, for the most part */
-#define DC_PLATFORM_DEV_UNIT    1   /* This is missing hardware */
-#define DC_PLATFORM_NAOMI       2   /* Works, for the most part */ 
-#define DC_PLATFORM_NAOMI2      3   /* Needs to be done, 2xsh4 + 2xpvr + custom TNL */
-#define DC_PLATFORM_ATOMISWAVE  4   /* Works, for the most part */
-#define DC_PLATFORM_HIKARU      5   /* Needs to be done, 2xsh4, 2x aica , custom vpu */
-#define DC_PLATFORM_AURORA      6   /* Needs to be done, Uses newer 300 mhz sh4 + 150 mhz pvr mbx SoC */
+#define DC_PLATFORM_DREAMCAST   0
+#define DC_PLATFORM_DEV_UNIT    1
+#define DC_PLATFORM_NAOMI       2
+#define DC_PLATFORM_NAOMI2      3
+#define DC_PLATFORM_ATOMISWAVE  4
 
 //HOST_CPU
 #define CPU_X86      0x20000001
@@ -139,14 +136,12 @@
 #define CPU_PPC      0x20000006
 #define CPU_PPC64    0x20000007
 #define CPU_ARM64    0x20000008
-#define CPU_MIPS64   0x20000009
 
 //FEAT_SHREC, FEAT_AREC, FEAT_DSPREC
 #define DYNAREC_NONE	0x40000001
 #define DYNAREC_JIT		0x40000002
 #define DYNAREC_CPP		0x40000003
 
-
 //automatic
 
 #if defined(__x86_64__) || defined(_M_X64)
@@ -181,13 +176,17 @@
 #define FEAT_DSPREC DYNAREC_NONE
 #endif
 
+#ifdef __SWITCH__
+#define FEAT_NO_RWX_PAGES
+#endif
+
 //defaults
 
 #ifndef FEAT_SHREC
-	#if HOST_CPU == CPU_MIPS
-		#define FEAT_SHREC DYNAREC_NONE
-	#else
+	#if HOST_CPU == CPU_ARM || HOST_CPU == CPU_ARM64 || HOST_CPU == CPU_X86 || HOST_CPU == CPU_X64
 		#define FEAT_SHREC DYNAREC_JIT
+	#else
+		#define FEAT_SHREC DYNAREC_NONE
 	#endif
 #endif
 
@@ -200,15 +199,13 @@
 #endif
 
 #ifndef FEAT_DSPREC
-	#if HOST_CPU == CPU_X86 || HOST_CPU == CPU_ARM64 || HOST_CPU == CPU_X64
+	#if HOST_CPU == CPU_ARM || HOST_CPU == CPU_ARM64 || HOST_CPU == CPU_X86 || HOST_CPU == CPU_X64
 		#define FEAT_DSPREC DYNAREC_JIT
 	#else
 		#define FEAT_DSPREC DYNAREC_NONE
 	#endif
 #endif
 
-#define USE_MINIUPNPC
-
 // Some restrictions on FEAT_NO_RWX_PAGES
 #if defined(FEAT_NO_RWX_PAGES) && FEAT_SHREC == DYNAREC_JIT
 #if HOST_CPU != CPU_X64 && HOST_CPU != CPU_ARM64
@@ -216,6 +213,18 @@
 #endif
 #endif
 
+#ifdef _WIN32
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#define TARGET_UWP
+#endif
+#ifdef HAVE_D3D11
+#define USE_DX11
+#endif
+#endif
+
+#if !defined(LIBRETRO) && !defined(TARGET_NO_EXCEPTIONS)
+#define USE_GGPO
+#endif
 
 // TARGET PLATFORM
 
@@ -223,15 +232,11 @@
 #define VRAM_SIZE_MAX (16*1024*1024)
 #define ARAM_SIZE_MAX (8*1024*1024)
 
-#define GD_CLOCK 33868800				//GDROM XTAL -- 768fs
-
-#define AICA_CORE_CLOCK (GD_CLOCK*4/3)		//[45158400]  GD->PLL 3:4 -> AICA CORE	 -- 1024fs
-#define ADAC_CLOCK (AICA_CORE_CLOCK/4)		//[11289600]  44100*256, AICA CORE -> PLL 4:1 -> ADAC -- 256fs
-#define AICA_ARM_CLOCK (AICA_CORE_CLOCK/2)	//[22579200]  AICA CORE -> PLL 2:1 -> ARM
-#define AICA_SDRAM_CLOCK (GD_CLOCK*2)		//[67737600]  GD-> PLL 2 -> SDRAM
-#define SH4_MAIN_CLOCK (200*1000*1000)		//[200000000] XTal(13.5) -> PLL (33.3) -> PLL 1:6 (200)
-#define SH4_RAM_CLOCK (100*1000*1000)		//[100000000] XTal(13.5) -> PLL (33.3) -> PLL 1:3 (100)	, also suplied to HOLLY chip
-#define G2_BUS_CLOCK (25*1000*1000)			//[25000000]  from Holly, from SH4_RAM_CLOCK w/ 2 2:1 plls
+#define GD_CLOCK 33868800						//GDROM XTAL -- 768fs
+#define AICA_CORE_CLOCK (GD_CLOCK * 4 / 3)		//[45158400]  GD->PLL 3:4 -> AICA CORE	 -- 1024fs
+#define AICA_ARM_CLOCK (AICA_CORE_CLOCK / 2)	//[22579200]  AICA CORE -> PLL 2:1 -> ARM
+#define SH4_MAIN_CLOCK (200 * 1000 * 1000)		//[200000000] XTal(13.5) -> PLL (33.3) -> PLL 1:6 (200)
+#define G2_BUS_CLOCK (25 * 1000 * 1000)			//[25000000]  from Holly, from SH4_RAM_CLOCK w/ 2 2:1 plls
 
 #if defined(GLES) && !defined(GLES3) && !defined(GLES2)
 // Only use GL ES 2.0 API functions

core/cfg/cfg.cpp

@@ -82,6 +82,13 @@ s32 cfgLoadInt(const std::string& section, const std::string& key, s32 def)
 	return cfgdb.get_int(section, key, def);
 }
 
+int64_t cfgLoadInt64(const std::string& section, const std::string& key, int64_t def) {
+	return cfgdb.get_int64(section, key, def);
+}
+void cfgSaveInt64(const std::string& section, const std::string& key, int64_t value) {
+	cfgdb.set_int64(section, key, value);
+}
+
 void  cfgSaveBool(const std::string& section, const std::string& key, bool value)
 {
 	cfgSaveStr(section, key, value ? "yes" : "no");
@@ -112,6 +119,11 @@ void cfgDeleteSection(const std::string& section)
 	cfgdb.delete_section(section);
 }
 
+void cfgDeleteEntry(const std::string& section, const std::string& key)
+{
+	cfgdb.delete_entry(section, key);
+}
+
 void cfgSetAutoSave(bool autoSave)
 {
 	::autoSave = autoSave;

core/cfg/cfg.h

@@ -5,6 +5,8 @@
 bool cfgOpen();
 s32 cfgLoadInt(const std::string& section, const std::string& key, s32 def);
 void cfgSaveInt(const std::string& section, const std::string& key, s32 value);
+int64_t cfgLoadInt64(const std::string& section, const std::string& key, int64_t def);
+void cfgSaveInt64(const std::string& section, const std::string& key, int64_t value);
 std::string cfgLoadStr(const std::string& section, const std::string& key, const std::string& def);
 void cfgSaveStr(const std::string& section, const std::string& key, const std::string& value);
 void cfgSaveBool(const std::string& section, const std::string& key, bool value);
@@ -17,3 +19,4 @@ bool ParseCommandLine(int argc, char *argv[]);
 void cfgSetAutoSave(bool autoSave);
 bool cfgHasSection(const std::string& section);
 void cfgDeleteSection(const std::string& section);
+void cfgDeleteEntry(const std::string& section, const std::string& key);

core/cfg/cl.cpp

@@ -1,8 +1,5 @@
 /*
 	Command line parsing
-	~yay~
-
-	Nothing too interesting here, really
 */
 
 #include <cstdio>
@@ -10,83 +7,61 @@
 #include <cstring>
 
 #include "cfg/cfg.h"
+#include "stdclass.h"
 
-char* trim_ws(char* str)
-{
-	if (str==0 || strlen(str)==0)
-		return 0;
-
-	while(*str)
-	{
-		if (!isspace(*str))
-			break;
-		str++;
-	}
-
-	size_t l=strlen(str);
-	
-	if (l==0)
-		return 0;
-
-	while(l>0)
-	{
-		if (!isspace(str[l-1]))
-			break;
-		str[l-1]=0;
-		l--;
-	}
-
-	if (l==0)
-		return 0;
-
-	return str;
-}
-
-int setconfig(char** arg,int cl)
+static int setconfig(char *arg[], int cl)
 {
 	int rv=0;
-	for(;;)
+
+	if (cl < 1)
 	{
-		if (cl<1)
+		WARN_LOG(COMMON, "-config : invalid number of parameters, format is section:key=value,section:key=value,...");
+		return rv;
+	}
+
+	std::string value(arg[1]);
+	for(;;)
+	{		
+		auto seppos = value.find(':');
+		if (seppos == std::string::npos)
 		{
-			WARN_LOG(COMMON, "-config : invalid number of parameters, format is section:key=value");
-			return rv;
+			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value,section:key=value,...", value.c_str());
+			break;
 		}
-		char* sep=strstr(arg[1],":");
-		if (sep==0)
+		auto eqpos = value.find('=', seppos);
+		if (eqpos == std::string::npos)
 		{
-			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value", arg[1]);
-			return rv;
-		}
-		char* value=strstr(sep+1,"=");
-		if (value==0)
-		{
-			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value", arg[1]);
-			return rv;
+			WARN_LOG(COMMON, "-config : invalid parameter %s, format is section:key=value,section:key=value,...", value.c_str());
+			break;
 		}
 
-		*sep++=0;
-		*value++=0;
+		auto commapos = value.find(',', eqpos);
 
-		char* sect=trim_ws(arg[1]);
-		char* key=trim_ws(sep);
-		value=trim_ws(value);
+		std::string sect = trim_ws(value.substr(0, seppos));
+		std::string key = trim_ws(value.substr(seppos + 1, eqpos - seppos - 1));
+		auto endofcurrent = (commapos == std::string::npos) ? value.size() : commapos;
+		std::string next = (commapos == std::string::npos) ? "" : trim_ws(value.substr(endofcurrent + 1, value.size() - endofcurrent));
+		value = trim_ws(value.substr(eqpos + 1, endofcurrent - eqpos - 1));
 
-		if (sect==0 || key==0)
+		if (sect.empty() || key.empty())
 		{
-			WARN_LOG(COMMON, "-config : invalid parameter, format is section:key=value");
-			return rv;
+			WARN_LOG(COMMON, "-config : invalid parameter, format is section:key=value,section:key=value,...");
+			break;
 		}
 
-		const char* constval = value;
-		if (constval==0)
-			constval="";
-		INFO_LOG(COMMON, "Virtual cfg %s:%s=%s", sect, key, value);
+		INFO_LOG(COMMON, "Virtual cfg %s:%s=%s", sect.c_str(), key.c_str(), value.c_str());
 
-		cfgSetVirtual(sect,key,value);
-		rv++;
+		cfgSetVirtual(sect, key, value);
 
-		if (cl>=3 && stricmp(arg[2],",")==0)
+		if (commapos == std::string::npos)
+			rv++;
+
+		if (commapos != std::string::npos)
+		{
+			value = next;
+			continue;
+		}
+		else if (cl>=3 && strcmp(arg[2],",")==0)
 		{
 			cl-=2;
 			arg+=2;
@@ -114,7 +89,7 @@ static int showhelp()
 
 bool ParseCommandLine(int argc,char* argv[])
 {
-	settings.imgread.ImagePath[0] = '\0';
+	settings.content.path.clear();
 	int cl=argc-2;
 	char** arg=argv+1;
 	while(cl>=0)
@@ -136,6 +111,10 @@ bool ParseCommandLine(int argc,char* argv[])
 			cl--;
 		}
 #endif
+		else if ((*arg)[0] == '-')
+		{
+			WARN_LOG(COMMON, "Ignoring unknown command line option '%s'", *arg);
+		}
 		else
 		{
 			char* extension = strrchr(*arg, '.');
@@ -145,18 +124,18 @@ bool ParseCommandLine(int argc,char* argv[])
 					|| stricmp(extension, ".gdi") == 0 || stricmp(extension, ".cue") == 0))
 			{
 				INFO_LOG(COMMON, "Using '%s' as cd image", *arg);
-				strcpy(settings.imgread.ImagePath, *arg);
+				settings.content.path = *arg;
 			}
 			else if (extension && stricmp(extension, ".elf") == 0)
 			{
 				INFO_LOG(COMMON, "Using '%s' as reios elf file", *arg);
 				cfgSetVirtual("config", "bios.UseReios", "yes");
-				strcpy(settings.imgread.ImagePath, *arg);
+				settings.content.path = *arg;
 			}
 			else
 			{
 				INFO_LOG(COMMON, "Using '%s' as rom", *arg);
-				strcpy(settings.imgread.ImagePath, *arg);
+				settings.content.path = *arg;
 			}
 		}
 		arg++;

core/cfg/ini.cpp

@@ -1,8 +1,7 @@
 #include "ini.h"
 #include "types.h"
 #include <sstream>
-
-char* trim_ws(char* str);
+#include "stdclass.h"
 
 namespace emucfg {
 
@@ -25,6 +24,14 @@ int ConfigEntry::get_int()
 	}
 }
 
+int64_t ConfigEntry::get_int64()
+{
+	int base = 10;
+	if (strstr(this->value.c_str(), "0x") != nullptr)
+		base = 16;
+	return (int64_t)strtoll(this->value.c_str(), nullptr, base);
+}
+
 bool ConfigEntry::get_bool()
 {
 	if (stricmp(this->value.c_str(), "yes") == 0 ||
@@ -159,6 +166,19 @@ int ConfigFile::get_int(const std::string& section_name, const std::string& entr
 	}
 }
 
+int64_t ConfigFile::get_int64(const std::string& section_name, const std::string& entry_name, int64_t default_value)
+{
+	ConfigEntry* entry = this->get_entry(section_name, entry_name);
+	if (entry == NULL)
+	{
+		return default_value;
+	}
+	else
+	{
+		return entry->get_int64();
+	}
+}
+
 bool ConfigFile::get_bool(const std::string& section_name, const std::string& entry_name, bool default_value)
 {
 	ConfigEntry* entry = this->get_entry(section_name, entry_name);
@@ -189,6 +209,13 @@ void ConfigFile::set_int(const std::string& section_name, const std::string& ent
 	this->set(section_name, entry_name, str_value.str(), is_virtual);
 }
 
+void ConfigFile::set_int64(const std::string& section_name, const std::string& entry_name, int64_t value, bool is_virtual)
+{
+	std::stringstream str_value;
+	str_value << value;
+	this->set(section_name, entry_name, str_value.str(), is_virtual);
+}
+
 void ConfigFile::set_bool(const std::string& section_name, const std::string& entry_name, bool value, bool is_virtual)
 {
 	std::string str_value = (value ? "yes" : "no");
@@ -197,74 +224,37 @@ void ConfigFile::set_bool(const std::string& section_name, const std::string& en
 
 void ConfigFile::parse(FILE* file)
 {
-	if(file == NULL)
-	{
+	if (file == nullptr)
 		return;
-	}
+
 	char line[512];
-	char current_section[512] = { '\0' };
+	std::string section;
 	int cline = 0;
-	while(file && !feof(file))
+	while (true)
 	{
-		if (std::fgets(line, 512, file) == NULL || std::feof(file))
-		{
+		if (std::fgets(line, sizeof(line), file) == nullptr)
 			break;
-		}
-
 		cline++;
-
-		if (strlen(line) < 3)
+		std::string s(line);
+		s = trim_ws(s, " \r\n");
+		if (s.empty())
+			continue;
+		if (s.length() >= 3 && s[0] == '[' && s[s.length() - 1] == ']')
 		{
+			section = s.substr(1, s.length() - 2);
 			continue;
 		}
-
-		if (line[strlen(line)-1] == '\r' ||
-			  line[strlen(line)-1] == '\n')
+		auto eqpos = s.find('=');
+		if (eqpos == std::string::npos)
 		{
-			line[strlen(line)-1] = '\0';
-		}
-
-		char* tl = trim_ws(line);
-
-		if (tl[0] == '[' && tl[strlen(tl)-1] == ']')
-		{
-			tl[strlen(tl)-1] = '\0';
-
-			// FIXME: Data loss if buffer is too small
-			strncpy(current_section, tl+1, sizeof(current_section));
-			current_section[sizeof(current_section) - 1] = '\0';
-
-			trim_ws(current_section);
-		}
-		else
-		{
-			if (strlen(current_section) == 0)
-			{
-				continue; //no open section
-			}
-
-			char* separator = strstr(tl, "=");
-
-			if (!separator)
-			{
-				WARN_LOG(COMMON, "Malformed entry on config - ignoring @ %d(%s)", cline, tl);
-				continue;
-			}
-
-			*separator = '\0';
-
-			char* name = trim_ws(tl);
-			char* value = trim_ws(separator + 1);
-			if (name == NULL || value == NULL)
-			{
-				//printf("Malformed entry on config - ignoring @ %d(%s)\n",cline, tl);
-				continue;
-			}
-			else
-			{
-				this->set(std::string(current_section), std::string(name), std::string(value));
-			}
+			WARN_LOG(COMMON, "Malformed entry on config - ignoring line %d: %s", cline, s.c_str());
+			continue;
 		}
+		std::string property = trim_ws(s.substr(0, eqpos));
+		std::string value = trim_ws(s.substr(eqpos + 1));
+		if (value.length() >= 2 && value[0] == '"' && value[value.length() - 1] == '"')
+			value = value.substr(1, value.length() - 2);
+		set(section, property, value);
 	}
 }
 
@@ -275,7 +265,8 @@ void ConfigFile::save(FILE* file)
 		const std::string& section_name = section_it.first;
 		const ConfigSection& section = section_it.second;
 
-		std::fprintf(file, "[%s]\n", section_name.c_str());
+		if (!section_name.empty())
+			std::fprintf(file, "[%s]\n", section_name.c_str());
 
 		for (const auto& entry_it : section.entries)
 		{
@@ -283,8 +274,8 @@ void ConfigFile::save(FILE* file)
 			const ConfigEntry& entry = entry_it.second;
 			std::fprintf(file, "%s = %s\n", entry_name.c_str(), entry.get_string().c_str());
 		}
-
-		std::fputs("\n", file);
+		if (!section_name.empty())
+			std::fputc('\n', file);
 	}
 }
 

core/cfg/ini.h

@@ -11,6 +11,7 @@ struct ConfigEntry {
 	const std::string& get_string() const;
 	int get_int();
 	bool get_bool();
+	int64_t get_int64();
 };
 
 struct ConfigSection {
@@ -41,10 +42,12 @@ struct ConfigFile {
 		/* getting values */
 		std::string get(const std::string& section_name, const std::string& entry_name, const std::string& default_value = "");
 		int get_int(const std::string& section_name, const std::string& entry_name, int default_value = 0);
+		int64_t get_int64(const std::string& section_name, const std::string& entry_name, int64_t default_value = 0);
 		bool get_bool(const std::string& section_name, const std::string& entry_name, bool default_value = false);
 		/* setting values */
 		void set(const std::string& section_name, const std::string& entry_name, const std::string& value, bool is_virtual = false);
 		void set_int(const std::string& section_name, const std::string& entry_name, int value, bool is_virtual = false);
+		void set_int64(const std::string& section_name, const std::string& entry_name, int64_t value, bool is_virtual = false);
 		void set_bool(const std::string& section_name, const std::string& entry_name, bool value, bool is_virtual = false);
 
 		void delete_section(const std::string& section_name);

core/cfg/option.cpp

@@ -17,6 +17,8 @@
     along with Flycast.  If not, see <https://www.gnu.org/licenses/>.
 */
 #include "option.h"
+#include "network/naomi_network.h"
+#include "debug/gdb_server.h"
 
 namespace config {
 
@@ -24,7 +26,6 @@ namespace config {
 
 Option<bool> DynarecEnabled("Dynarec.Enabled", true);
 Option<bool> DynarecIdleSkip("Dynarec.idleskip", true);
-Option<bool> DynarecSafeMode("Dynarec.safe-mode");
 
 // General
 
@@ -36,12 +37,14 @@ Option<bool> FullMMU("Dreamcast.FullMMU");
 Option<bool> ForceWindowsCE("Dreamcast.ForceWindowsCE");
 Option<bool> AutoLoadState("Dreamcast.AutoLoadState");
 Option<bool> AutoSaveState("Dreamcast.AutoSaveState");
-Option<int> SavestateSlot("Dreamcast.SavestateSlot");
+Option<int, false> SavestateSlot("Dreamcast.SavestateSlot");
+Option<bool> ForceFreePlay("ForceFreePlay", true);
+Option<bool, false> FetchBoxart("FetchBoxart", true);
+Option<bool, false> BoxartDisplayMode("BoxartDisplayMode", true);
 
 // Sound
 
 Option<bool> DSPEnabled("aica.DSPEnabled", false);
-Option<bool> DisableSound("aica.NoSound");
 #if HOST_CPU == CPU_ARM
 Option<int> AudioBufferSize("aica.BufferSize", 5644);	// 128 ms
 #else
@@ -78,7 +81,11 @@ Option<bool> Fog("rend.Fog", true);
 Option<bool> FloatVMUs("rend.FloatVMUs");
 Option<bool> Rotate90("rend.Rotate90");
 Option<bool> PerStripSorting("rend.PerStripSorting");
+#ifdef __APPLE__
+Option<bool> DelayFrameSwapping("rend.DelayFrameSwapping", false);
+#else
 Option<bool> DelayFrameSwapping("rend.DelayFrameSwapping", true);
+#endif
 Option<bool> WidescreenGameHacks("rend.WidescreenGameHacks");
 std::array<Option<int>, 4> CrosshairColor {
 	Option<int>("rend.CrossHairColor1"),
@@ -91,17 +98,36 @@ Option<int> MaxThreads("pvr.MaxThreads", 3);
 Option<int> AutoSkipFrame("pvr.AutoSkipFrame", 0);
 Option<int> RenderResolution("rend.Resolution", 480);
 Option<bool> VSync("rend.vsync", true);
+Option<int64_t> PixelBufferSize("rend.PixelBufferSize", 512 * 1024 * 1024);
+Option<int> AnisotropicFiltering("rend.AnisotropicFiltering", 1);
+Option<int> TextureFiltering("rend.TextureFiltering", 0); // Default
+Option<bool> ThreadedRendering("rend.ThreadedRendering", true);
+Option<bool> DupeFrames("rend.DupeFrames", false);
+Option<int> PerPixelLayers("rend.PerPixelLayers", 32);
+Option<bool> NativeDepthInterpolation("rend.NativeDepthInterpolation", false);
+Option<bool> EmulateFramebuffer("rend.EmulateFramebuffer", false);
 
 // Misc
 
 Option<bool> SerialConsole("Debug.SerialConsoleEnabled");
 Option<bool> SerialPTY("Debug.SerialPTY");
+Option<bool> GDB("Debug.GDBEnabled");
+Option<int> GDBPort("Debug.GDBPort", debugger::DEFAULT_PORT);
+Option<bool> GDBWaitForConnection("Debug.GDBWaitForConnection");
 Option<bool> UseReios("UseReios");
+Option<bool> FastGDRomLoad("FastGDRomLoad", false);
 
 Option<bool> OpenGlChecks("OpenGlChecks", false, "validate");
 
 Option<std::vector<std::string>, false> ContentPath("Dreamcast.ContentPath");
 Option<bool, false> HideLegacyNaomiRoms("Dreamcast.HideLegacyNaomiRoms", true);
+Option<bool, false> UploadCrashLogs("UploadCrashLogs", true);
+
+// Profiler
+Option<bool> ProfilerEnabled("Profiler.Enabled");
+Option<bool> ProfilerDrawToGUI("Profiler.DrawGUI");
+Option<bool> ProfilerOutputTTY("Profiler.OutputTTY");
+Option<float> ProfilerFrameWarningTime("Profiler.FrameWarningTime", 1.0f / 55.0f);
 
 // Network
 
@@ -109,7 +135,17 @@ Option<bool> NetworkEnable("Enable", false, "network");
 Option<bool> ActAsServer("ActAsServer", false, "network");
 OptionString DNS("DNS", "46.101.91.123", "network");
 OptionString NetworkServer("server", "", "network");
+Option<int> LocalPort("LocalPort", NaomiNetwork::SERVER_PORT, "network");
 Option<bool> EmulateBBA("EmulateBBA", false, "network");
+Option<bool> EnableUPnP("EnableUPnP", true, "network");
+Option<bool> GGPOEnable("GGPO", false, "network");
+Option<int> GGPODelay("GGPODelay", 0, "network");
+Option<bool> NetworkStats("Stats", true, "network");
+Option<int> GGPOAnalogAxes("GGPOAnalogAxes", 0, "network");
+Option<bool> GGPOChat("GGPOChat", true, "network");
+Option<bool> GGPOChatTimeoutToggle("GGPOChatTimeoutToggle", true, "network");
+Option<int> GGPOChatTimeout("GGPOChatTimeout", 10, "network");
+Option<bool> NetworkOutput("NetworkOutput", false, "network");
 
 #ifdef SUPPORT_DISPMANX
 Option<bool> DispmanxMaintainAspect("maintain_aspect", true, "dispmanx");
@@ -145,7 +181,11 @@ std::array<std::array<Option<MapleDeviceType>, 2>, 4> MapleExpansionDevices {
 	Option<MapleDeviceType>("device4.2", MDT_None, "input"),
 };
 #ifdef _WIN32
-Option<bool> UseRawInput("RawInput", false, "input");
+Option<bool, false> UseRawInput("RawInput", false, "input");
+#endif
+
+#ifdef USE_LUA
+Option<std::string, false> LuaFileName("LuaFileName", "flycast.lua");
 #endif
 
 } // namespace config

core/cfg/option.h

@@ -23,6 +23,9 @@
 #include <cmath>
 #include "cfg.h"
 #include "hw/maple/maple_cfg.h"
+#ifdef LIBRETRO
+#include <libretro.h>
+#endif
 
 namespace config {
 
@@ -34,6 +37,10 @@ public:
 	virtual void reset() = 0;
 };
 
+#ifdef LIBRETRO
+#include "option_lr.h"
+#else
+
 class Settings {
 public:
 	void reset() {
@@ -63,10 +70,6 @@ public:
 		cfgSetAutoSave(true);
 	}
 
-	const std::string& getGameId() const {
-		return gameId;
-	}
-
 	void setGameId(const std::string& gameId) {
 		this->gameId = gameId;
 	}
@@ -118,7 +121,7 @@ public:
 
 	void load() override {
 		if (PerGameOption && settings.hasPerGameConfig())
-			set(doLoad(settings.getGameId(), section + "." + name));
+			set(doLoad(settings.gameId, section + "." + name));
 		else
 		{
 			set(doLoad(section, name));
@@ -139,10 +142,14 @@ public:
 		else if (PerGameOption && settings.hasPerGameConfig())
 		{
 			if (value == doLoad(section, name))
+			{
+				// delete existing per-game option if any
+				cfgDeleteEntry(settings.gameId, section + "." + name);
 				return;
+			}
 		}
 		if (PerGameOption && settings.hasPerGameConfig())
-			doSave(settings.getGameId(), section + "." + name);
+			doSave(settings.gameId, section + "." + name);
 		else
 			doSave(section, name);
 	}
@@ -150,8 +157,8 @@ public:
 	T& get() { return value; }
 	void set(T v) { value = v; }
 
-	void override(T v) {
-		verify(PerGameOption);
+	void override(T v)
+	{
 		overriddenDefault = v;
 		overridden = true;
 		value = v;
@@ -172,9 +179,16 @@ protected:
 		return cfgLoadBool(section, name, value);
 	}
 
+	template <typename U = T>
+	enable_if_t<std::is_same<U, int64_t>::value, T>
+	doLoad(const std::string& section, const std::string& name) const
+	{
+		return cfgLoadInt64(section, name, value);
+	}
+
 	template <typename U = T>
 	enable_if_t<(std::is_integral<U>::value || std::is_enum<U>::value)
-			&& !std::is_same<U, bool>::value, T>
+			&& !std::is_same<U, bool>::value && !std::is_same<U, int64_t>::value, T>
 	doLoad(const std::string& section, const std::string& name) const
 	{
 		return (T)cfgLoadInt(section, name, (int)value);
@@ -195,7 +209,7 @@ protected:
 		if (strValue.empty())
 			return value;
 		else
-			return atof(strValue.c_str());
+			return (float)atof(strValue.c_str());
 	}
 
 	template <typename U = T>
@@ -209,14 +223,50 @@ protected:
 		std::vector<std::string> newValue;
 		while (true)
 		{
-			std::string::size_type end = paths.find(';', start);
-			if (end == std::string::npos)
-				end = paths.size();
-			if (start != end)
-				newValue.push_back(paths.substr(start, end - start));
-			if (end == paths.size())
-				break;
-			start = end + 1;
+			if (paths[start] == '"')
+			{
+				std::string v;
+				start++;
+				while (true)
+				{
+					if (paths[start] == '"')
+					{
+						if (start + 1 >= paths.size())
+						{
+							newValue.push_back(v);
+							return newValue;
+						}
+						if (paths[start + 1] == '"')
+						{
+							v += paths[start++];
+							start++;
+						}
+						else if (paths[start + 1] == ';')
+						{
+							newValue.push_back(v);
+							start += 2;
+							break;
+						}
+						else
+						{
+							v += paths[start++];
+						}
+					}
+					else
+						v += paths[start++];
+				}
+			}
+			else
+			{
+				std::string::size_type end = paths.find(';', start);
+				if (end == std::string::npos)
+					end = paths.size();
+				if (start != end)
+					newValue.push_back(paths.substr(start, end - start));
+				if (end == paths.size())
+					break;
+				start = end + 1;
+			}
 		}
 		return newValue;
 	}
@@ -228,9 +278,16 @@ protected:
 		cfgSaveBool(section, name, value);
 	}
 
+	template <typename U = T>
+	enable_if_t<std::is_same<U, int64_t>::value>
+	doSave(const std::string& section, const std::string& name) const
+	{
+		cfgSaveInt64(section, name, value);
+	}
+
 	template <typename U = T>
 	enable_if_t<(std::is_integral<U>::value || std::is_enum<U>::value)
-		&& !std::is_same<U, bool>::value>
+		&& !std::is_same<U, bool>::value && !std::is_same<U, int64_t>::value>
 	doSave(const std::string& section, const std::string& name) const
 	{
 		cfgSaveInt(section, name, (int)value);
@@ -257,12 +314,32 @@ protected:
 	doSave(const std::string& section, const std::string& name) const
 	{
 		std::string s;
-		for (auto& v : value)
+		for (const auto& v : value)
 		{
-			if (s.empty())
-				s = v;
+			if (!s.empty())
+				s += ';';
+			if (v.find(';') != std::string::npos || (!v.empty() && v[0] == '"'))
+			{
+				s += '"';
+				std::string v2 = v;
+				while (true)
+				{
+					auto pos = v2.find('"');
+					if (pos != std::string::npos)
+					{
+						s += v2.substr(0, pos + 1) + '"';
+						v2 = v2.substr(pos + 1);
+					}
+					else
+					{
+						s += v2;
+						break;
+					}
+				}
+				s += '"';
+			}
 			else
-				s += ";" + v;
+				s += v;
 		}
 		cfgSaveStr(section, name, s);
 	}
@@ -275,6 +352,7 @@ protected:
 	bool overridden = false;
 	Settings& settings;
 };
+#endif
 
 using OptionString = Option<std::string>;
 
@@ -282,7 +360,7 @@ using OptionString = Option<std::string>;
 
 extern Option<bool> DynarecEnabled;
 extern Option<bool> DynarecIdleSkip;
-extern Option<bool> DynarecSafeMode;
+constexpr bool DynarecSafeMode = false;
 
 // General
 
@@ -294,13 +372,15 @@ extern Option<bool> FullMMU;
 extern Option<bool> ForceWindowsCE;
 extern Option<bool> AutoLoadState;
 extern Option<bool> AutoSaveState;
-extern Option<int> SavestateSlot;
+extern Option<int, false> SavestateSlot;
+extern Option<bool> ForceFreePlay;
+extern Option<bool, false> FetchBoxart;
+extern Option<bool, false> BoxartDisplayMode;
 
 // Sound
 
 constexpr bool LimitFPS = true;
 extern Option<bool> DSPEnabled;
-extern Option<bool> DisableSound;
 extern Option<int> AudioBufferSize;	//In samples ,*4 for bytes
 extern Option<bool> AutoLatency;
 
@@ -323,9 +403,9 @@ public:
 	void calcDbPower()
 	{
 		// dB scaling calculation: https://www.dr-lex.be/info-stuff/volumecontrols.html
-		logarithmic_volume_scale = fmin(exp(4.605 * float(value) / 100.0) / 100.0, 1.0);
+		logarithmic_volume_scale = std::min(std::exp(4.605f * float(value) / 100.f) / 100.f, 1.f);
 		if (value < 10)
-			logarithmic_volume_scale *= value / 10.0;
+			logarithmic_volume_scale *= value / 10.f;
 	}
 };
 extern AudioVolumeOption AudioVolume;
@@ -335,49 +415,20 @@ extern AudioVolumeOption AudioVolume;
 class RendererOption : public Option<RenderType> {
 public:
 	RendererOption()
-#ifdef _WIN32
+#if defined(USE_DX11)
+		: Option<RenderType>("pvr.rend", RenderType::DirectX11) {}
+#elif defined(USE_DX9)
 		: Option<RenderType>("pvr.rend", RenderType::DirectX9) {}
 #else
 		: Option<RenderType>("pvr.rend", RenderType::OpenGL) {}
 #endif
 
-	bool isOpenGL() const {
-		return value == RenderType::OpenGL || value == RenderType::OpenGL_OIT;
-	}
-	bool isVulkan() const {
-		return value == RenderType::Vulkan || value == RenderType::Vulkan_OIT;
-	}
-	bool isDirectX() const {
-		return value == RenderType::DirectX9;
-	}
-
-	void set(RenderType v)
-	{
-		newValue = v;
-	}
 	RenderType& operator=(const RenderType& v) { set(v); return value; }
 
-	void load() override {
-		RenderType current = value;
-		Option<RenderType>::load();
-		newValue = value;
-		value = current;
-	}
-
 	void reset() override {
-		// don't reset the value to avoid vk -> gl -> vk quick switching
+		// don't reset the value to avoid quick switching when starting a game
 		overridden = false;
 	}
-
-	bool pendingChange() {
-		return newValue != value;
-	}
-	void commit() {
-		value = newValue;
-	}
-
-private:
-	RenderType newValue = RenderType();
 };
 extern RendererOption RendererType;
 extern Option<bool> UseMipmaps;
@@ -388,8 +439,11 @@ extern Option<bool> RenderToTextureBuffer;
 extern Option<bool> TranslucentPolygonDepthMask;
 extern Option<bool> ModifierVolumes;
 constexpr bool Clipping = true;
+#ifndef LIBRETRO
 extern Option<int> TextureUpscale;
 extern Option<int> MaxFilteredTextureSize;
+extern Option<int> PerPixelLayers;
+#endif
 extern Option<float> ExtraDepthScale;
 extern Option<bool> CustomTextures;
 extern Option<bool> DumpTextures;
@@ -406,17 +460,35 @@ extern Option<int> MaxThreads;
 extern Option<int> AutoSkipFrame;		// 0: none, 1: some, 2: more
 extern Option<int> RenderResolution;
 extern Option<bool> VSync;
+extern Option<int64_t> PixelBufferSize;
+extern Option<int> AnisotropicFiltering;
+extern Option<int> TextureFiltering; // 0: default, 1: force nearest, 2: force linear
+extern Option<bool> ThreadedRendering;
+extern Option<bool> DupeFrames;
+extern Option<bool> NativeDepthInterpolation;
+extern Option<bool> EmulateFramebuffer;
 
 // Misc
 
 extern Option<bool> SerialConsole;
 extern Option<bool> SerialPTY;
+extern Option<bool> GDB;
+extern Option<int> GDBPort;
+extern Option<bool> GDBWaitForConnection;
 extern Option<bool> UseReios;
+extern Option<bool> FastGDRomLoad;
 
 extern Option<bool> OpenGlChecks;
 
 extern Option<std::vector<std::string>, false> ContentPath;
 extern Option<bool, false> HideLegacyNaomiRoms;
+extern Option<bool, false> UploadCrashLogs;
+
+// Profiling
+extern Option<bool> ProfilerEnabled;
+extern Option<bool> ProfilerDrawToGUI;
+extern Option<bool> ProfilerOutputTTY;
+extern Option<float> ProfilerFrameWarningTime;
 
 // Network
 
@@ -424,7 +496,17 @@ extern Option<bool> NetworkEnable;
 extern Option<bool> ActAsServer;
 extern OptionString DNS;
 extern OptionString NetworkServer;
+extern Option<int> LocalPort;
 extern Option<bool> EmulateBBA;
+extern Option<bool> EnableUPnP;
+extern Option<bool> GGPOEnable;
+extern Option<int> GGPODelay;
+extern Option<bool> NetworkStats;
+extern Option<int> GGPOAnalogAxes;
+extern Option<bool> GGPOChat;
+extern Option<bool> GGPOChatTimeoutToggle;
+extern Option<int> GGPOChatTimeout;
+extern Option<bool> NetworkOutput;
 
 #ifdef SUPPORT_DISPMANX
 extern Option<bool> DispmanxMaintainAspect;
@@ -442,10 +524,13 @@ extern Option<int> VirtualGamepadVibration;
 extern std::array<Option<MapleDeviceType>, 4> MapleMainDevices;
 extern std::array<std::array<Option<MapleDeviceType>, 2>, 4> MapleExpansionDevices;
 #ifdef _WIN32
-extern Option<bool> UseRawInput;
+extern Option<bool, false> UseRawInput;
 #else
 constexpr bool UseRawInput = false;
 #endif
 
-} // namespace config
+#ifdef USE_LUA
+extern Option<std::string, false> LuaFileName;
+#endif
 
+} // namespace config

core/cheats.h

@@ -27,6 +27,7 @@ struct WidescreenCheat
 	const char *area_or_version;
 	u32 addresses[16];
 	u32 values[16];
+	u32 origValues[16];
 };
 
 struct Cheat
@@ -39,17 +40,30 @@ struct Cheat
 		runNextIfEq,
 		runNextIfNeq,
 		runNextIfGt,
-		runNextIfLt
+		runNextIfLt,
+		copy
 	};
-	Type type = Type::disabled;
+	Type type;
 	std::string description;
-	bool enabled = false;
-	u32 size = 0;
-	u32 address = 0;
-	u32 value = 0;
-	u32 repeatCount = 1;
-	u32 repeatValueIncrement = 0;
-	u32 repeatAddressIncrement = 0;
+	bool enabled;
+	u32 size;
+	u32 address;
+	u32 value;
+	u8 valueMask;
+	u32 repeatCount;
+	u32 repeatValueIncrement;
+	u32 repeatAddressIncrement;
+	u32 destAddress;
+	bool builtIn;
+
+	Cheat(Type type = Type::disabled, const std::string& description = "", bool enabled = false, u32 size = 0, u32 address = 0,
+			u32 value = 0, u8 valueMask = 0, u32 repeatCount = 1, u32 repeatValueIncrement = 0,
+			u32 repeatAddressIncrement = 0, u32 destAddress = 0, bool builtIn = false)
+		: type(type), description(description), enabled(enabled), size(size), address(address), value(value), valueMask(valueMask),
+		  repeatCount(repeatCount), repeatValueIncrement(repeatValueIncrement), repeatAddressIncrement(repeatAddressIncrement),
+		  destAddress(destAddress), builtIn(builtIn)
+	{
+	}
 };
 
 class CheatManager
@@ -62,12 +76,15 @@ public:
 	bool cheatEnabled(size_t index) const { return cheats[index].enabled; }
 	void enableCheat(size_t index, bool enabled) { cheats[index].enabled = enabled; }
 	void loadCheatFile(const std::string& filename);
+	void saveCheatFile(const std::string& filename);
 	// Returns true if using 16:9 anamorphic screen ratio
 	bool isWidescreen() const { return widescreen_cheat != nullptr; }
+	void addGameSharkCheat(const std::string& name, const std::string& s);
 
 private:
 	u32 readRam(u32 addr, u32 bits);
 	void writeRam(u32 addr, u32 value, u32 bits);
+	void setActive(bool active);
 
 	static const WidescreenCheat widescreen_cheats[];
 	static const WidescreenCheat naomi_widescreen_cheats[];
@@ -75,6 +92,10 @@ private:
 	bool active = false;
 	std::vector<Cheat> cheats;
 	std::string gameId;
+
+	friend class CheatManagerTest_TestLoad_Test;
+	friend class CheatManagerTest_TestGameShark_Test;
+	friend class CheatManagerTest_TestSave_Test;
 };
 
 extern CheatManager cheatManager;

core/core.mk

@@ -1,261 +0,0 @@
-RZDCY_FILES :=
-
-RZDCY_SRC_DIR ?= $(call my-dir)
-VERSION_HEADER := $(RZDCY_SRC_DIR)/version.h
-
-RZDCY_MODULES	:=	cfg/ hw/arm7/ hw/aica/ hw/holly/ hw/ hw/gdrom/ hw/maple/ \
- hw/mem/ hw/pvr/ hw/sh4/ hw/sh4/interpr/ hw/sh4/modules/ profiler/ oslib/ \
- hw/naomi/ imgread/ ./ deps/libchdr/src/ deps/libchdr/deps/zlib-1.2.11/ \
- deps/libelf/ deps/chdpsr/ rend/ reios/ deps/xbrz/ \
- deps/imgui/ archive/ input/ log/ wsi/ network/ hw/bba/ debug/ \
- hw/modem/ deps/picotcp/modules/ deps/picotcp/stack/
-
-ifndef NO_REC
-	ifndef NOT_ARM
-	    RZDCY_MODULES += rec-ARM/ deps/vixl/ deps/vixl/aarch32/
-	endif
-	
-	ifdef X86_REC
-	    RZDCY_MODULES += rec-x86/
-	endif
-	
-	ifdef X64_REC
-	    RZDCY_MODULES += rec-x64/
-	endif
-	
-	ifdef CPP_REC
-	    RZDCY_MODULES += rec-cpp/
-	endif
-	
-	ifdef ARM64_REC
-	    RZDCY_MODULES += rec-ARM64/ deps/vixl/ deps/vixl/aarch64/
-	endif
-endif
-
-ifndef NO_REND
-    RZDCY_MODULES += rend/gles/
-    ifndef USE_GLES
-	ifndef USE_DISPMANX
-	    RZDCY_MODULES += rend/gl4/
-	endif
-    endif
-    ifdef USE_VULKAN
-    	RZDCY_MODULES += rend/vulkan/ rend/vulkan/oit/ deps/volk/ \
-    		deps/glslang/glslang/MachineIndependent/ \
-    		deps/glslang/glslang/MachineIndependent/preprocessor/ \
-    		deps/glslang/glslang/GenericCodeGen/ \
-    		deps/glslang/OGLCompilersDLL/ \
-    		deps/glslang/SPIRV/
-    	ifdef FOR_WINDOWS
-    		RZDCY_FILES += $(RZDCY_SRC_DIR)/deps/glslang/glslang/OSDependent/Windows/ossource.cpp
-    	else
-    		RZDCY_FILES += $(RZDCY_SRC_DIR)/deps/glslang/glslang/OSDependent/Unix/ossource.cpp
-    	endif
-    endif
-else
-    RZDCY_MODULES += rend/norend/
-endif
-
-ifdef USE_SDL
-    RZDCY_MODULES += sdl/
-endif
-
-ifdef FOR_LINUX
-	ifndef UNIT_TESTS
-    	RZDCY_MODULES += linux-dist/
-	endif
-    RZDCY_MODULES += linux/
-endif
-
-ifdef FOR_WINDOWS
-	RZDCY_MODULES += rend/dx9/
-	ifndef UNIT_TESTS
-	    RZDCY_FILES += $(RZDCY_SRC_DIR)/windows/winmain.cpp
-	endif
-    RZDCY_FILES += $(RZDCY_SRC_DIR)/windows/win_vmem.cpp $(RZDCY_SRC_DIR)/windows/rawinput.cpp
-    RZDCY_CFLAGS += -I$(RZDCY_SRC_DIR)/deps/dirent
-endif
-
-ifdef USE_VULKAN
-	ifdef FOR_WINDOWS
-		RZDCY_CFLAGS += -DVK_USE_PLATFORM_WIN32_KHR
-	else
-		RZDCY_CFLAGS += -DVK_USE_PLATFORM_XLIB_KHR
-	endif
-	RZDCY_CFLAGS += -D USE_VULKAN
-endif
-
-RZDCY_CFLAGS += -I$(RZDCY_SRC_DIR) -I$(RZDCY_SRC_DIR)/rend/gles -I$(RZDCY_SRC_DIR)/deps \
-		 -I$(RZDCY_SRC_DIR)/deps/vixl -I$(RZDCY_SRC_DIR)/khronos -I$(RZDCY_SRC_DIR)/deps/glslang \
-		 -I$(RZDCY_SRC_DIR)/deps/glm -I$(RZDCY_SRC_DIR)/deps/xbyak -I$(RZDCY_SRC_DIR)/deps/nowide/include \
-		 -I$(RZDCY_SRC_DIR)/deps/picotcp/include -I$(RZDCY_SRC_DIR)/deps/picotcp/modules \
-		 -I$(RZDCY_SRC_DIR)/deps/libchdr/include -I$(RZDCY_SRC_DIR)/deps/libchdr/deps/zlib-1.2.11/ \
-		 -I$(RZDCY_SRC_DIR)/deps/libchdr/deps/lzma-19.00 -I$(RZDCY_SRC_DIR)/deps/libchdr/deps/lzma-19.00/include
-
-ifdef USE_SYSTEM_MINIUPNPC
-	RZDCY_CFLAGS += -I/usr/include/miniupnpc
-else
-	RZDCY_CFLAGS += -I$(RZDCY_SRC_DIR)/deps/miniupnpc
-endif
-
-ifdef NO_REC
-	RZDCY_CFLAGS += -DTARGET_NO_REC
-else
-	RZDCY_MODULES += hw/sh4/dyna/
-endif
-
-ifdef USE_GLES
-  RZDCY_CFLAGS += -DGLES -fPIC
-endif
-
-ifdef CHD5_FLAC
-	RZDCY_CFLAGS += -DCHD5_FLAC -I$(RZDCY_SRC_DIR)/deps/flac/src/libFLAC/include/ -I$(RZDCY_SRC_DIR)/deps/flac/include
-	RZDCY_CFLAGS += -DHAVE_CONFIG_H
-	RZDCY_MODULES += deps/flac/src/libFLAC/
-endif
-
-# 7-Zip/LZMA settings (CHDv5)
-ifdef CHD5_LZMA
-	RZDCY_MODULES += deps/lzma/
-	RZDCY_CFLAGS += -D_7ZIP_ST -DCHD5_LZMA
-endif
-
-RZDCY_CFLAGS += -DXXH_INLINE_ALL -I$(RZDCY_SRC_DIR)/deps/xxHash -I$(RZDCY_SRC_DIR)/deps/stb
-
-RZDCY_FILES += $(foreach dir,$(addprefix $(RZDCY_SRC_DIR)/,$(RZDCY_MODULES)),$(wildcard $(dir)*.cpp))
-RZDCY_FILES += $(foreach dir,$(addprefix $(RZDCY_SRC_DIR)/,$(RZDCY_MODULES)),$(wildcard $(dir)*.cc))
-RZDCY_FILES += $(foreach dir,$(addprefix $(RZDCY_SRC_DIR)/,$(RZDCY_MODULES)),$(wildcard $(dir)*.c))
-RZDCY_FILES += $(foreach dir,$(addprefix $(RZDCY_SRC_DIR)/,$(RZDCY_MODULES)),$(wildcard $(dir)*.S))
-
-ifdef STATIC_LIBZIP
-RZDCY_CFLAGS += -I$(RZDCY_SRC_DIR)/deps/libzip/lib
-LIBZIP_DIR = $(RZDCY_SRC_DIR)/deps/libzip/lib
-RZDCY_FILES += $(LIBZIP_DIR)/zip_add.c \
-	  $(LIBZIP_DIR)/zip_add_dir.c \
-	  $(LIBZIP_DIR)/zip_add_entry.c \
-	  $(LIBZIP_DIR)/zip_algorithm_deflate.c \
-	  $(LIBZIP_DIR)/zip_buffer.c \
-	  $(LIBZIP_DIR)/zip_close.c \
-	  $(LIBZIP_DIR)/zip_delete.c \
-	  $(LIBZIP_DIR)/zip_dir_add.c \
-	  $(LIBZIP_DIR)/zip_dirent.c \
-	  $(LIBZIP_DIR)/zip_discard.c \
-	  $(LIBZIP_DIR)/zip_entry.c \
-	  $(LIBZIP_DIR)/zip_error.c \
-	  $(LIBZIP_DIR)/zip_error_clear.c \
-	  $(LIBZIP_DIR)/zip_error_get.c \
-	  $(LIBZIP_DIR)/zip_error_get_sys_type.c \
-	  $(LIBZIP_DIR)/zip_error_strerror.c \
-	  $(LIBZIP_DIR)/zip_error_to_str.c \
-	  $(LIBZIP_DIR)/zip_extra_field.c \
-	  $(LIBZIP_DIR)/zip_extra_field_api.c \
-	  $(LIBZIP_DIR)/zip_fclose.c \
-	  $(LIBZIP_DIR)/zip_fdopen.c \
-	  $(LIBZIP_DIR)/zip_file_add.c \
-	  $(LIBZIP_DIR)/zip_file_error_clear.c \
-	  $(LIBZIP_DIR)/zip_file_error_get.c \
-	  $(LIBZIP_DIR)/zip_file_get_comment.c \
-	  $(LIBZIP_DIR)/zip_file_get_external_attributes.c \
-	  $(LIBZIP_DIR)/zip_file_get_offset.c \
-	  $(LIBZIP_DIR)/zip_file_rename.c \
-	  $(LIBZIP_DIR)/zip_file_replace.c \
-	  $(LIBZIP_DIR)/zip_file_set_comment.c \
-	  $(LIBZIP_DIR)/zip_file_set_encryption.c \
-	  $(LIBZIP_DIR)/zip_file_set_external_attributes.c \
-	  $(LIBZIP_DIR)/zip_file_set_mtime.c \
-	  $(LIBZIP_DIR)/zip_file_strerror.c \
-	  $(LIBZIP_DIR)/zip_fopen.c \
-	  $(LIBZIP_DIR)/zip_fopen_encrypted.c \
-	  $(LIBZIP_DIR)/zip_fopen_index.c \
-	  $(LIBZIP_DIR)/zip_fopen_index_encrypted.c \
-	  $(LIBZIP_DIR)/zip_fread.c \
-	  $(LIBZIP_DIR)/zip_fseek.c \
-	  $(LIBZIP_DIR)/zip_ftell.c \
-	  $(LIBZIP_DIR)/zip_get_archive_comment.c \
-	  $(LIBZIP_DIR)/zip_get_archive_flag.c \
-	  $(LIBZIP_DIR)/zip_get_encryption_implementation.c \
-	  $(LIBZIP_DIR)/zip_get_file_comment.c \
-	  $(LIBZIP_DIR)/zip_get_name.c \
-	  $(LIBZIP_DIR)/zip_get_num_entries.c \
-	  $(LIBZIP_DIR)/zip_get_num_files.c \
-	  $(LIBZIP_DIR)/zip_hash.c \
-	  $(LIBZIP_DIR)/zip_io_util.c \
-	  $(LIBZIP_DIR)/zip_libzip_version.c \
-	  $(LIBZIP_DIR)/zip_memdup.c \
-	  $(LIBZIP_DIR)/zip_name_locate.c \
-	  $(LIBZIP_DIR)/zip_new.c \
-	  $(LIBZIP_DIR)/zip_open.c \
-	  $(LIBZIP_DIR)/zip_pkware.c \
-	  $(LIBZIP_DIR)/zip_progress.c \
-	  $(LIBZIP_DIR)/zip_rename.c \
-	  $(LIBZIP_DIR)/zip_replace.c \
-	  $(LIBZIP_DIR)/zip_set_archive_comment.c \
-	  $(LIBZIP_DIR)/zip_set_archive_flag.c \
-	  $(LIBZIP_DIR)/zip_set_default_password.c \
-	  $(LIBZIP_DIR)/zip_set_file_comment.c \
-	  $(LIBZIP_DIR)/zip_set_file_compression.c \
-	  $(LIBZIP_DIR)/zip_set_name.c \
-	  $(LIBZIP_DIR)/zip_source_accept_empty.c \
-	  $(LIBZIP_DIR)/zip_source_begin_write.c \
-	  $(LIBZIP_DIR)/zip_source_begin_write_cloning.c \
-	  $(LIBZIP_DIR)/zip_source_buffer.c \
-	  $(LIBZIP_DIR)/zip_source_call.c \
-	  $(LIBZIP_DIR)/zip_source_close.c \
-	  $(LIBZIP_DIR)/zip_source_commit_write.c \
-	  $(LIBZIP_DIR)/zip_source_compress.c \
-	  $(LIBZIP_DIR)/zip_source_crc.c \
-	  $(LIBZIP_DIR)/zip_source_error.c \
-	  $(LIBZIP_DIR)/zip_source_file_common.c \
-	  $(LIBZIP_DIR)/zip_source_file_stdio.c \
-	  $(LIBZIP_DIR)/zip_source_free.c \
-	  $(LIBZIP_DIR)/zip_source_function.c \
-	  $(LIBZIP_DIR)/zip_source_get_file_attributes.c \
-	  $(LIBZIP_DIR)/zip_source_is_deleted.c \
-	  $(LIBZIP_DIR)/zip_source_layered.c \
-	  $(LIBZIP_DIR)/zip_source_open.c \
-	  $(LIBZIP_DIR)/zip_source_pkware_decode.c \
-	  $(LIBZIP_DIR)/zip_source_pkware_encode.c \
-	  $(LIBZIP_DIR)/zip_source_read.c \
-	  $(LIBZIP_DIR)/zip_source_remove.c \
-	  $(LIBZIP_DIR)/zip_source_rollback_write.c \
-	  $(LIBZIP_DIR)/zip_source_seek.c \
-	  $(LIBZIP_DIR)/zip_source_seek_write.c \
-	  $(LIBZIP_DIR)/zip_source_stat.c \
-	  $(LIBZIP_DIR)/zip_source_supports.c \
-	  $(LIBZIP_DIR)/zip_source_tell.c \
-	  $(LIBZIP_DIR)/zip_source_tell_write.c \
-	  $(LIBZIP_DIR)/zip_source_window.c \
-	  $(LIBZIP_DIR)/zip_source_write.c \
-	  $(LIBZIP_DIR)/zip_source_zip.c \
-	  $(LIBZIP_DIR)/zip_source_zip_new.c \
-	  $(LIBZIP_DIR)/zip_stat.c \
-	  $(LIBZIP_DIR)/zip_stat_index.c \
-	  $(LIBZIP_DIR)/zip_stat_init.c \
-	  $(LIBZIP_DIR)/zip_strerror.c \
-	  $(LIBZIP_DIR)/zip_string.c \
-	  $(LIBZIP_DIR)/zip_unchange.c \
-	  $(LIBZIP_DIR)/zip_unchange_all.c \
-	  $(LIBZIP_DIR)/zip_unchange_archive.c \
-	  $(LIBZIP_DIR)/zip_unchange_data.c \
-	  $(LIBZIP_DIR)/zip_utf-8.c \
-	  $(LIBZIP_DIR)/zip_err_str.c
-
-	  ifdef FOR_WINDOWS
-		  RZDCY_FILES += $(LIBZIP_DIR)/zip_source_file_win32.c \
-		  		$(LIBZIP_DIR)/zip_source_file_win32_named.c \
-			    $(LIBZIP_DIR)/zip_source_file_win32_utf16.c \
-			    $(LIBZIP_DIR)/zip_source_file_win32_utf8.c \
-				$(LIBZIP_DIR)/zip_source_file_win32_ansi.c \
-				$(LIBZIP_DIR)/zip_random_win32.c
-	  else
-		  RZDCY_FILES += $(LIBZIP_DIR)/zip_mkstempm.c \
-				$(LIBZIP_DIR)/zip_source_file_stdio_named.c \
-				$(LIBZIP_DIR)/zip_random_unix.c
-	  endif
-endif
-
-$(VERSION_HEADER):
-	echo "#define GIT_VERSION \"`git describe --tags --always`\"" > $(VERSION_HEADER)
-	echo "#define GIT_HASH \"`git rev-parse --short HEAD`\"" >> $(VERSION_HEADER)
-	echo "#define BUILD_DATE \"`date '+%Y-%m-%d %H:%M:%S %Z'`\"" >> $(VERSION_HEADER)
-

core/debug/debug_agent.h

@@ -34,6 +34,9 @@
 #define SIGBUS 7
 #endif
 
+#define SWAP_32(a) ((((a) & 0xff) << 24)  | (((a) & 0xff00) << 8) | (((a) >> 8) & 0xff00) | (((a) >> 24) & 0xff))
+#define SWAP_16(a) ((((a) & 0x00ff) << 8) | (((a) & 0xff00) >> 8))
+
 const std::array<Sh4RegType, 59> Sh4RegList {
 		reg_r0,
 		reg_r1,
@@ -77,16 +80,25 @@ public:
 	{
 		if (pc != 1)
 			Sh4cntx.pc = pc;
-		dc_resume();
+		emu.start();
 	}
 
 	void step()
 	{
-		bool restoreBreakpoint = removeMatchpoint(0, Sh4cntx.pc, 2);
+		bool restoreBreakpoint = removeMatchpoint(Breakpoint::Type::BP_TYPE_SOFTWARE_BREAK, Sh4cntx.pc, 2);
 		u32 savedPc = Sh4cntx.pc;
-		dc_step();
+		emu.step();
 		if (restoreBreakpoint)
-			insertMatchpoint(0, savedPc, 2);
+			insertMatchpoint(Breakpoint::Type::BP_TYPE_SOFTWARE_BREAK, savedPc, 2);
+	}
+
+	void stepRange(u32 from, u32 to)
+	{
+		bool restoreBreakpoint = removeMatchpoint(Breakpoint::Type::BP_TYPE_SOFTWARE_BREAK, Sh4cntx.pc, 2);
+		u32 savedPc = Sh4cntx.pc;
+		emu.stepRange(from, to);
+		if (restoreBreakpoint)
+			insertMatchpoint(Breakpoint::Type::BP_TYPE_SOFTWARE_BREAK, savedPc, 2);
 	}
 
 	int readAllRegs(u32 **regs)
@@ -95,9 +107,9 @@ public:
 		for (u32 i = 0; i < Sh4RegList.size(); i++)
 		{
 			if (Sh4RegList[i] == reg_sr_status)
-				allregs[i] = sh4_sr_GetFull();
+				allregs[i] = SWAP_32(sh4_sr_GetFull());
 			else if (Sh4RegList[i] != NoReg)
-				allregs[i] = *GetRegPtr(Sh4RegList[i]);
+				allregs[i] = SWAP_32(*GetRegPtr(Sh4RegList[i]));
 		}
 		*regs = &allregs[0];
 		return allregs.size();
@@ -107,7 +119,7 @@ public:
 	{
 		for (u32 i = 0; i < Sh4RegList.size(); i++)
 			if (Sh4RegList[i] != NoReg)
-				*GetRegPtr(Sh4RegList[i]) = regs[i];
+				*GetRegPtr(Sh4RegList[i]) = SWAP_32(regs[i]);
 	}
 
 	u32 readReg(u32 regNum)
@@ -116,9 +128,9 @@ public:
 			return 0;
 		Sh4RegType reg = Sh4RegList[regNum];
 		if (reg == reg_sr_status)
-			return sh4_sr_GetFull();
+			return SWAP_32(sh4_sr_GetFull());
 		if (reg != NoReg)
-			return *GetRegPtr(reg);
+			return SWAP_32(*GetRegPtr(reg));
 		return 0;
 	}
 	void writeReg(u32 regNum, u32 value)
@@ -127,9 +139,9 @@ public:
 			return;
 		Sh4RegType reg = Sh4RegList[regNum];
 		if (reg == reg_sr_status)
-			sh4_sr_SetFull(value);
+			sh4_sr_SetFull(SWAP_32(value));
 		else if (reg != NoReg)
-			*GetRegPtr(reg) = value;
+			*GetRegPtr(reg) = SWAP_32(value);
 	}
 
 	const u8 *readMem(u32 addr, u32 len)
@@ -141,14 +153,14 @@ public:
 		{
 			if (len >= 4 && (addr & 3) == 0)
 			{
-				*(u32 *)p = ReadMem32_nommu(addr);
+				*(u32 *)p = SWAP_32(ReadMem32_nommu(addr));
 				addr += 4;
 				len -= 4;
 				p += 4;
 			}
 			else if (len >= 2 && (addr & 1) == 0)
 			{
-				*(u16 *)p = ReadMem16_nommu(addr);
+				*(u16 *)p = SWAP_16(ReadMem16_nommu(addr));
 				addr += 2;
 				len -= 2;
 				p += 2;
@@ -170,14 +182,14 @@ public:
 		{
 			if (len >= 4 && (addr & 3) == 0)
 			{
-				WriteMem32_nommu(addr, *(u32 *)p);
+				WriteMem32_nommu(addr, SWAP_32(*(u32 *)p));
 				addr += 4;
 				len -= 4;
 				p += 4;
 			}
 			else if (len >= 2 && (addr & 3) == 0)
 			{
-				WriteMem16_nommu(addr, *(u16 *)p);
+				WriteMem16_nommu(addr, SWAP_16(*(u16 *)p));
 				addr += 2;
 				len -= 2;
 				p += 2;
@@ -197,10 +209,10 @@ public:
 			return false;
 		}
 		// TODO other matchpoint types
-		if (breakpoints.find(addr) != breakpoints.end())
+		if (breakpoints[type].find(addr) != breakpoints[type].end())
 			return true;
-		breakpoints[addr] = Breakpoint(type, addr);
-		breakpoints[addr].savedOp = ReadMem16_nommu(addr);
+		breakpoints[type][addr] = Breakpoint(type, addr);
+		breakpoints[type][addr].savedOp = ReadMem16_nommu(addr);
 		WriteMem16_nommu(addr, 0xC308);	// trapa #0x20
 		return true;
 	}
@@ -210,11 +222,11 @@ public:
 			WARN_LOG(COMMON, "removeMatchpoint: length != 2: %d", len);
 			return false;
 		}
-		auto it = breakpoints.find(addr);
-		if (it == breakpoints.end())
+		auto it = breakpoints[type].find(addr);
+		if (it == breakpoints[type].end())
 			return false;
 		WriteMem16_nommu(addr, it->second.savedOp);
-		breakpoints.erase(it);
+		breakpoints[type].erase(it);
 		return true;
 	}
 
@@ -222,7 +234,7 @@ public:
 	{
 		config::DynarecEnabled = false;
 		exception = SIGINT;
-		dc_stop();
+		emu.stop();
 		return exception;
 	}
 
@@ -236,7 +248,7 @@ public:
 	void postDebugTrap()
 	{
 		// needed to join the emu thread since debugTrap() is called by it
-		dc_stop();
+		emu.stop();
 	}
 
 	u32 currentException()
@@ -246,14 +258,14 @@ public:
 
 	void restart()
 	{
-		dc_stop();
-		dc_reset(true);
-		dc_resume();
+		emu.unloadGame();
+		emu.loadGame(settings.content.path.c_str());
+		emu.start();
 	}
 
 	void detach()
 	{
-		dc_resume();
+		emu.start();
 	}
 
 	void kill()
@@ -295,7 +307,10 @@ public:
 	{
 		verify(!Sh4cntx.CpuRunning);
 		size = stack.size() * 8;
-		return (const u32 *)&stack[0];
+		if (!stack.empty())
+			return (const u32 *)&stack[0];
+		else
+			return nullptr;
 	}
 
 	void subroutineCall()
@@ -313,12 +328,22 @@ public:
 	u32 exception = 0;
 
 	struct Breakpoint {
+		enum Type
+		{
+			BP_TYPE_SOFTWARE_BREAK,
+			BP_TYPE_HARDWARE_BREAK,
+			BP_TYPE_WRITE_WATCHPOINT,
+			BP_TYPE_READ_WATCHPOINT,
+			BP_TYPE_ACCESS_WATCHPOINT,
+			BP_TYPE_COUNT
+		};
+
 		Breakpoint() = default;
 		Breakpoint(u16 type, u32 addr) : addr(addr), type(type) { }
 		u32 addr = 0;
 		u16 type = 0;
 		u16 savedOp = 0;
 	};
-	std::map<u32, Breakpoint> breakpoints;
+	std::map<u32, Breakpoint> breakpoints[Breakpoint::Type::BP_TYPE_COUNT];
 	std::vector<std::pair<u32, u32>> stack;
 };

core/debug/gdb_server.cpp

@@ -22,16 +22,18 @@
 #include "gdb_server.h"
 #include "debug_agent.h"
 #include "network/net_platform.h"
+#include "cfg/option.h"
 #include <stdexcept>
 #include <thread>
 #include <chrono>
 #include <mutex>
+#include <cassert>
 
-#define SERVER_PORT 3263
+#define MAX_PACKET_LEN 4096
 
 namespace debugger {
 
-static void emuEventCallback(Event event);
+static void emuEventCallback(Event event, void *);
 
 class GdbServer
 {
@@ -40,7 +42,7 @@ public:
 		Error(const char *reason) : std::runtime_error(reason) {}
 	};
 
-	void init()
+	void init(int port)
 	{
 		if (VALID(serverSocket))
 			return;
@@ -55,7 +57,7 @@ public:
 		struct sockaddr_in serveraddr;
 		memset(&serveraddr, 0, sizeof(serveraddr));
 		serveraddr.sin_family = AF_INET;
-		serveraddr.sin_port = htons(SERVER_PORT);
+		serveraddr.sin_port = htons(port);
 
 		if (::bind(serverSocket, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
 		{
@@ -69,10 +71,16 @@ public:
 		}
 		EventManager::listen(Event::Resume, emuEventCallback);
 		EventManager::listen(Event::Terminate, emuEventCallback);
+
+		initialised = true;
 	}
 
 	void term()
 	{
+		if (!initialised)
+			return;
+		EventManager::unlisten(Event::Resume, emuEventCallback);
+		EventManager::unlisten(Event::Terminate, emuEventCallback);
 		stop();
 		if (VALID(clientSocket))
 		{
@@ -88,12 +96,21 @@ public:
 
 	void run()
 	{
+		if (!initialised || thread.joinable())
+			return;
 		DEBUG_LOG(COMMON, "GdbServer starting");
 		thread = std::thread(&GdbServer::serverThread, this);
+		if (config::GDBWaitForConnection)
+		{
+			DEBUG_LOG(COMMON, "Waiting for GDB connection...");
+			agent.interrupt();
+		}
 	}
 
 	void stop()
 	{
+		if (!initialised)
+			return;
 		if (thread.joinable())
 		{
 			DEBUG_LOG(COMMON, "GdbServer stopping");
@@ -104,7 +121,7 @@ public:
 	}
 
 	bool isRunning() const {
-		return thread.joinable();
+		return initialised && thread.joinable();
 	}
 
 	// called on the emu thread
@@ -494,7 +511,12 @@ private:
 				const u32 *data = agent.getStack(len);
 				len /= 4;
 
+#if _MSC_VER // Non-const array size is a GCC extension
+				assert((len * 9 * 2 + 1) < MAX_PACKET_LEN);
+				char reply[MAX_PACKET_LEN];
+#else
 				char reply[len * 9 * 2 + 1];
+#endif
 				char *r = reply;
 				for (u32 i = 0; i < len; i++)
 				{
@@ -513,9 +535,13 @@ private:
 				sendPacket("");
 		}
 		else if (pkt.rfind("qSupported", 0) == 0)
+		{
 			// Tell the remote stub about features supported by GDB,
 			// and query the stub for features it supports
-			sendPacket("PacketSize=10000");
+			char qsupported[128];
+			sprintf_s(qsupported, 128, "PacketSize=%i;vContSupported+", MAX_PACKET_LEN);
+			sendPacket(qsupported);
+		}
 		else if (pkt.rfind("qSymbol:", 0) == 0)
 			// Notify the target that GDB is prepared to serve symbol lookup requests
 			sendPacket("OK");
@@ -568,11 +594,41 @@ private:
 		if (pkt.rfind("vAttach;", 0) == 0)
 			sendPacket("S05");
 		else if (pkt.rfind("vCont?", 0) == 0)
-			// not supported
-			sendPacket("vCont;s;c");
+			// supported vCont actions - (c)ontinue, (C)ontinue with signal, (s)tep, (S)tep with signal, (r)ange-step
+			sendPacket("vCont;c;C;s;S;t;r");
 		else if (pkt.rfind("vCont", 0) == 0)
-			// not supported
-			WARN_LOG(COMMON, "vCont not supported %s", pkt.c_str());
+		{
+			std::string vContCmd = pkt.substr(strlen("vCont;"));
+			switch (vContCmd[0])
+			{
+			case 'c':
+			case 'C':
+				sendContinue(vContCmd);
+				break;
+			case 's':
+				step(EXCEPT_NONE);
+				break;
+			case 'S':
+				step();
+			case 'r':
+			{
+				u32 from, to;
+				if (sscanf(vContCmd.c_str(), "r%x,%x", &from, &to) == 2)
+				{
+					stepRange(from, to);
+				}
+				else
+				{
+					WARN_LOG(COMMON, "Unsupported vCont:r format %s", pkt.c_str());
+					sendContinue("c");
+				}
+
+				break;
+			}
+			default:
+				WARN_LOG(COMMON, "vCont action not supported %s", pkt[6], pkt.c_str());
+			}
+		}
 		else if (pkt.rfind("vFile:", 0) == 0)
 			// not supported
 			sendPacket("");
@@ -597,11 +653,11 @@ private:
 			sendPacket("OK");
 			agent.kill();
 		}
-		else if (pkt.rfind("vMustReplyEmpty", 0) == 0)
-			// Reply empty packet
-			sendPacket("");
 		else
+		{
 			WARN_LOG(COMMON, "unknown v packet: %s", pkt.c_str());
+			sendPacket("");
+		}
 	}
 
 	void restart()
@@ -615,6 +671,13 @@ private:
 		sendPacket("S05");
 	}
 
+	void stepRange(u32 from, u32 to)
+	{
+		sendPacket("OK");
+		agent.stepRange(from, to);
+		sendPacket("S05");
+	}
+
 	void insertMatchpoint(const std::string& pkt)
 	{
 		u32 type;
@@ -625,22 +688,22 @@ private:
 			sendPacket("E01");
 		}
 		switch (type) {
-		    case 0:		// soft bp
+			case DebugAgent::Breakpoint::Type::BP_TYPE_SOFTWARE_BREAK:		// soft bp
 		    	if (agent.insertMatchpoint(0, addr, len))
 		    		sendPacket("OK");
 		    	else
 		    		sendPacket("E01");
 		    	break;
-		    case 1:		// hardware bp
+		    case DebugAgent::Breakpoint::Type::BP_TYPE_HARDWARE_BREAK:		// hardware bp
 		    	sendPacket("");
 		    	break;
-		    case 2:		// write watchpoint
+		    case DebugAgent::Breakpoint::Type::BP_TYPE_WRITE_WATCHPOINT:	// write watchpoint
 		    	sendPacket("");
 		    	break;
-		    case 3:		// read watchpoint
+		    case DebugAgent::Breakpoint::Type::BP_TYPE_READ_WATCHPOINT:		// read watchpoint
 		    	sendPacket("");
 		    	break;
-		    case 4:		// access watchpoint
+		    case DebugAgent::Breakpoint::Type::BP_TYPE_ACCESS_WATCHPOINT:	// access watchpoint
 		    	sendPacket("");
 		    	break;
 		    default:
@@ -825,6 +888,7 @@ private:
 			throw Error("I/O error");
 	}
 
+	bool initialised = false;
 	bool stopRequested = false;
 	bool attached = false;
 	bool postDebugTrapNeeded = false;
@@ -838,9 +902,9 @@ public:
 
 static GdbServer gdbServer;
 
-void init()
+void init(int port)
 {
-	gdbServer.init();
+	gdbServer.init(port);
 }
 
 void term()
@@ -863,7 +927,7 @@ void subroutineReturn()
 	gdbServer.agent.subroutineReturn();
 }
 
-static void emuEventCallback(Event event)
+static void emuEventCallback(Event event, void *)
 {
 	switch (event)
 	{

core/debug/gdb_server.h

@@ -23,9 +23,11 @@ namespace debugger {
 // exception thrown in response to trap
 struct Stop { };
 
+	static const int DEFAULT_PORT = 3263;
+
 #ifdef GDB_SERVER
 
-	void init();
+	void init(int port);
 	void term();
 	void run();
 	void debugTrap(u32 event);
@@ -33,7 +35,7 @@ struct Stop { };
 	void subroutineReturn();
 
 #else
-	static inline void init() {}
+	static inline void init(int port) {}
 	static inline void term() {}
 	static inline void run() {}
 	static inline void debugTrap(u32 event) {}

core/deps/dirent/dirent.h

@@ -29,6 +29,10 @@
 #include <sys/stat.h>
 #include <errno.h>
 
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
+#define FindFirstFileExW FindFirstFileExFromAppW
+#endif
+
 /* Indicates that d_type field is available in dirent structure */
 #define _DIRENT_HAVE_D_TYPE
 
@@ -613,7 +617,7 @@ dirent_first(
         /* Failed to re-open directory: no directory entry in memory */
         dirp->cached = 0;
         datap = NULL;
-
+        dirent_set_errno(GetLastError()); /* Not a valid errno but better than nothing */
     }
     return datap;
 }
@@ -647,6 +651,8 @@ dirent_next(
             FindClose (dirp->handle);
             dirp->handle = INVALID_HANDLE_VALUE;
             p = NULL;
+            if (GetLastError() != ERROR_NO_MORE_FILES)
+            	dirent_set_errno(GetLastError());
         }
 
     } else {

core/deps/ggpo/include/ggponet.h

@@ -0,0 +1,598 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _GGPONET_H_
+#define _GGPONET_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+
+// On windows, export at build time and import at runtime.
+// ELF systems don't need an explicit export/import.
+#ifdef _WIN32
+#  if defined(GGPO_SHARED_LIB)
+#  ifdef GGPO_SDK_EXPORT
+#       define GGPO_API __declspec(dllexport)
+#     else
+#       define GGPO_API __declspec(dllimport)
+#     endif
+#  else
+#     define GGPO_API
+#  endif
+#else
+#  define GGPO_API
+#endif
+
+#ifdef __GNUC__
+#if defined(_WIN32) && !defined(_WIN64)
+#define __cdecl __attribute__((cdecl))
+#elif !defined(__cdecl)
+#define __cdecl
+#endif
+#endif
+
+#define GGPO_MAX_PLAYERS                  4
+#define GGPO_MAX_PREDICTION_FRAMES        8
+#define GGPO_MAX_SPECTATORS              32
+
+#define GGPO_SPECTATOR_INPUT_INTERVAL     4
+
+typedef struct GGPOSession GGPOSession;
+
+typedef int GGPOPlayerHandle;
+
+typedef enum {
+   GGPO_PLAYERTYPE_LOCAL,
+   GGPO_PLAYERTYPE_REMOTE,
+   GGPO_PLAYERTYPE_SPECTATOR,
+} GGPOPlayerType;
+
+/*
+ * The GGPOPlayer structure used to describe players in ggpo_add_player
+ *
+ * size: Should be set to the sizeof(GGPOPlayer)
+ *
+ * type: One of the GGPOPlayerType values describing how inputs should be handled
+ *       Local players must have their inputs updated every frame via
+ *       ggpo_add_local_inputs.  Remote players values will come over the
+ *       network.
+ *
+ * player_num: The player number.  Should be between 1 and the number of players
+ *       In the game (e.g. in a 2 player game, either 1 or 2).
+ *
+ * If type == GGPO_PLAYERTYPE_REMOTE:
+ * 
+ * u.remote.ip_address:  The ip address of the ggpo session which will host this
+ *       player.
+ *
+ * u.remote.port: The port where udp packets should be sent to reach this player.
+ *       All the local inputs for this session will be sent to this player at
+ *       ip_address:port.
+ *
+ */
+
+typedef struct GGPOPlayer {
+   int               size;
+   GGPOPlayerType    type;
+   int               player_num;
+   union {
+      struct {
+         bool _unused;
+      } local;
+      struct {
+         char           ip_address[32];
+         unsigned short port;
+      } remote;
+   } u;
+} GGPOPlayer;
+
+typedef struct GGPOLocalEndpoint {
+   int      player_num;
+} GGPOLocalEndpoint;
+
+
+#define GGPO_ERRORLIST                                               \
+   GGPO_ERRORLIST_ENTRY(GGPO_OK,                               0)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_SUCCESS,                0)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_GENERAL_FAILURE,        -1)   \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INVALID_SESSION,        1)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INVALID_PLAYER_HANDLE,  2)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_PLAYER_OUT_OF_RANGE,    3)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_PREDICTION_THRESHOLD,   4)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_UNSUPPORTED,            5)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_NOT_SYNCHRONIZED,       6)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_IN_ROLLBACK,            7)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INPUT_DROPPED,          8)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_PLAYER_DISCONNECTED,    9)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_TOO_MANY_SPECTATORS,   10)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INVALID_REQUEST,       11)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_INPUT_SIZE_DIFF,       12)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_NETWORK_ERROR,         13)    \
+   GGPO_ERRORLIST_ENTRY(GGPO_ERRORCODE_VERIFICATION_ERROR,    14)
+
+#define GGPO_ERRORLIST_ENTRY(name, value)       name = value,
+typedef enum {
+   GGPO_ERRORLIST
+} GGPOErrorCode;
+#undef GGPO_ERRORLIST_ENTRY
+
+#define GGPO_SUCCEEDED(result)      ((result) == GGPO_ERRORCODE_SUCCESS)
+
+
+#define GGPO_INVALID_HANDLE      (-1)
+
+
+/*
+ * The GGPOEventCode enumeration describes what type of event just happened.
+ *
+ * GGPO_EVENTCODE_CONNECTED_TO_PEER - Handshake with the game running on the
+ * other side of the network has been completed.
+ * 
+ * GGPO_EVENTCODE_SYNCHRONIZING_WITH_PEER - Beginning the synchronization
+ * process with the client on the other end of the networking.  The count
+ * and total fields in the u.synchronizing struct of the GGPOEvent
+ * object indicate progress.
+ *
+ * GGPO_EVENTCODE_SYNCHRONIZED_WITH_PEER - The synchronziation with this
+ * peer has finished.
+ *
+ * GGPO_EVENTCODE_RUNNING - All the clients have synchronized.  You may begin
+ * sending inputs with ggpo_synchronize_inputs.
+ *
+ * GGPO_EVENTCODE_DISCONNECTED_FROM_PEER - The network connection on 
+ * the other end of the network has closed.
+ *
+ * GGPO_EVENTCODE_TIMESYNC - The time synchronziation code has determined
+ * that this client is too far ahead of the other one and should slow
+ * down to ensure fairness.  The u.timesync.frames_ahead parameter in
+ * the GGPOEvent object indicates how many frames the client is.
+ *
+ */
+typedef enum {
+   GGPO_EVENTCODE_CONNECTED_TO_PEER            = 1000,
+   GGPO_EVENTCODE_SYNCHRONIZING_WITH_PEER      = 1001,
+   GGPO_EVENTCODE_SYNCHRONIZED_WITH_PEER       = 1002,
+   GGPO_EVENTCODE_RUNNING                      = 1003,
+   GGPO_EVENTCODE_DISCONNECTED_FROM_PEER       = 1004,
+   GGPO_EVENTCODE_TIMESYNC                     = 1005,
+   GGPO_EVENTCODE_CONNECTION_INTERRUPTED       = 1006,
+   GGPO_EVENTCODE_CONNECTION_RESUMED           = 1007,
+} GGPOEventCode;
+
+/*
+ * The GGPOEvent structure contains an asynchronous event notification sent
+ * by the on_event callback.  See GGPOEventCode, above, for a detailed
+ * explanation of each event.
+ */
+typedef struct {
+   GGPOEventCode code;
+   union {
+      struct {
+         GGPOPlayerHandle  player;
+      } connected;
+      struct {
+         GGPOPlayerHandle  player;
+         int               count;
+         int               total;
+      } synchronizing;
+      struct {
+         GGPOPlayerHandle  player;
+      } synchronized;
+      struct {
+         GGPOPlayerHandle  player;
+      } disconnected;
+      struct {
+         int               frames_ahead;
+      } timesync;
+      struct {
+         GGPOPlayerHandle  player;
+         int               disconnect_timeout;
+      } connection_interrupted;
+      struct {
+         GGPOPlayerHandle  player;
+      } connection_resumed;
+   } u;
+} GGPOEvent;
+
+/*
+ * The GGPOSessionCallbacks structure contains the callback functions that
+ * your application must implement.  GGPO.net will periodically call these
+ * functions during the game.  All callback functions must be implemented.
+ */
+typedef struct {
+   /*
+    * begin_game callback - This callback has been deprecated.  You must
+    * implement it, but should ignore the 'game' parameter.
+    */
+   bool (__cdecl *begin_game)(const char *game);
+
+   /*
+    * save_game_state - The client should allocate a buffer, copy the
+    * entire contents of the current game state into it, and copy the
+    * length into the *len parameter.  Optionally, the client can compute
+    * a checksum of the data and store it in the *checksum argument.
+    */
+   bool (__cdecl *save_game_state)(unsigned char **buffer, int *len, int *checksum, int frame);
+
+   /*
+    * load_game_state - GGPO.net will call this function at the beginning
+    * of a rollback.  The buffer and len parameters contain a previously
+    * saved state returned from the save_game_state function.  The client
+    * should make the current game state match the state contained in the
+    * buffer.
+    */
+   bool (__cdecl *load_game_state)(unsigned char *buffer, int len);
+
+   /*
+    * log_game_state - Used in diagnostic testing.  The client should use
+    * the ggpo_log function to write the contents of the specified save
+    * state in a human readible form.
+    */
+   bool (__cdecl *log_game_state)(char *filename, unsigned char *buffer, int len);
+
+   /*
+    * free_buffer - Frees a game state allocated in save_game_state.  You
+    * should deallocate the memory contained in the buffer.
+    */
+   void (__cdecl *free_buffer)(void *buffer);
+
+   /*
+    * advance_frame - Called during a rollback.  You should advance your game
+    * state by exactly one frame.  Before each frame, call ggpo_synchronize_input
+    * to retrieve the inputs you should use for that frame.  After each frame,
+    * you should call ggpo_advance_frame to notify GGPO.net that you're
+    * finished.
+    *
+    * The flags parameter is reserved.  It can safely be ignored at this time.
+    */
+   bool (__cdecl *advance_frame)(int flags);
+
+   /* 
+    * on_event - Notification that something has happened.  See the GGPOEventCode
+    * structure above for more information.
+    */
+   bool (__cdecl *on_event)(GGPOEvent *info);
+
+   /*
+    * on_message - Delivers an application message. Allows arbitrary data to be
+    * exchanged with peers. This callback is optional.
+    */
+   void (__cdecl *on_message)(unsigned char *msg, int len);
+} GGPOSessionCallbacks;
+
+/*
+ * The GGPONetworkStats function contains some statistics about the current
+ * session.
+ *
+ * network.send_queue_len - The length of the queue containing UDP packets
+ * which have not yet been acknowledged by the end client.  The length of
+ * the send queue is a rough indication of the quality of the connection.
+ * The longer the send queue, the higher the round-trip time between the
+ * clients.  The send queue will also be longer than usual during high
+ * packet loss situations.
+ *
+ * network.recv_queue_len - The number of inputs currently buffered by the
+ * GGPO.net network layer which have yet to be validated.  The length of
+ * the prediction queue is roughly equal to the current frame number
+ * minus the frame number of the last packet in the remote queue.
+ *
+ * network.ping - The roundtrip packet transmission time as calcuated
+ * by GGPO.net.  This will be roughly equal to the actual round trip
+ * packet transmission time + 2 the interval at which you call ggpo_idle
+ * or ggpo_advance_frame.
+ *
+ * network.kbps_sent - The estimated bandwidth used between the two
+ * clients, in kilobits per second.
+ *
+ * timesync.local_frames_behind - The number of frames GGPO.net calculates
+ * that the local client is behind the remote client at this instant in
+ * time.  For example, if at this instant the current game client is running
+ * frame 1002 and the remote game client is running frame 1009, this value
+ * will mostly likely roughly equal 7.
+ *
+ * timesync.remote_frames_behind - The same as local_frames_behind, but
+ * calculated from the perspective of the remote player.
+ *
+ */
+typedef struct GGPONetworkStats {
+   struct {
+      int   send_queue_len;
+      int   recv_queue_len;
+      int   ping;
+      int   kbps_sent;
+   } network;
+   struct {
+      int   local_frames_behind;
+      int   remote_frames_behind;
+   } timesync;
+   struct {
+	   int predicted_frames;
+   } sync;
+} GGPONetworkStats;
+
+/*
+ * ggpo_start_session --
+ *
+ * Used to being a new GGPO.net session.  The ggpo object returned by ggpo_start_session
+ * uniquely identifies the state for this session and should be passed to all other
+ * functions.
+ *
+ * session - An out parameter to the new ggpo session object.
+ *
+ * cb - A GGPOSessionCallbacks structure which contains the callbacks you implement
+ * to help GGPO.net synchronize the two games.  You must implement all functions in
+ * cb, even if they do nothing but 'return true';
+ *
+ * game - The name of the game.  This is used internally for GGPO for logging purposes only.
+ *
+ * num_players - The number of players which will be in this game.  The number of players
+ * per session is fixed.  If you need to change the number of players or any player
+ * disconnects, you must start a new session.
+ *
+ * input_size - The size of the game inputs which will be passsed to ggpo_add_local_input.
+ *
+ * local_port - The port GGPO should bind to for UDP traffic.
+ *
+ * verification - Some optional data that will be matched with the peers during initial sync.
+ * Can be set to null if verification_size is zero. This can be used to check that all peers are
+ * running the same version of the application and of the game, are using the same settings, etc.
+ *
+ * verification_size - Size of the verification data. Can be set to zero to not exchange verification data.
+ * Maximum size is 256 bytes.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_start_session(GGPOSession **session,
+                                                  GGPOSessionCallbacks *cb,
+                                                  const char *game,
+                                                  int num_players,
+                                                  int input_size,
+                                                  unsigned short localport,
+												  const void *verification,
+												  int verification_size);
+
+
+/*
+ * ggpo_add_player --
+ *
+ * Must be called for each player in the session (e.g. in a 3 player session, must
+ * be called 3 times).
+ *
+ * player - A GGPOPlayer struct used to describe the player.
+ *
+ * handle - An out parameter to a handle used to identify this player in the future.
+ * (e.g. in the on_event callbacks).
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_add_player(GGPOSession *session,
+                                               GGPOPlayer *player,
+                                               GGPOPlayerHandle *handle);
+
+
+/*
+ * ggpo_start_synctest --
+ *
+ * Used to being a new GGPO.net sync test session.  During a sync test, every
+ * frame of execution is run twice: once in prediction mode and once again to
+ * verify the result of the prediction.  If the checksums of your save states
+ * do not match, the test is aborted.
+ *
+ * cb - A GGPOSessionCallbacks structure which contains the callbacks you implement
+ * to help GGPO.net synchronize the two games.  You must implement all functions in
+ * cb, even if they do nothing but 'return true';
+ *
+ * game - The name of the game.  This is used internally for GGPO for logging purposes only.
+ *
+ * num_players - The number of players which will be in this game.  The number of players
+ * per session is fixed.  If you need to change the number of players or any player
+ * disconnects, you must start a new session.
+ *
+ * input_size - The size of the game inputs which will be passsed to ggpo_add_local_input.
+ *
+ * frames - The number of frames to run before verifying the prediction.  The
+ * recommended value is 1.
+ *
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_start_synctest(GGPOSession **session,
+                                                   GGPOSessionCallbacks *cb,
+                                                   const char *game,
+                                                   int num_players,
+                                                   int input_size,
+                                                   int frames);
+
+
+/*
+ * ggpo_start_spectating --
+ *
+ * Start a spectator session.
+ *
+ * cb - A GGPOSessionCallbacks structure which contains the callbacks you implement
+ * to help GGPO.net synchronize the two games.  You must implement all functions in
+ * cb, even if they do nothing but 'return true';
+ *
+ * game - The name of the game.  This is used internally for GGPO for logging purposes only.
+ *
+ * num_players - The number of players which will be in this game.  The number of players
+ * per session is fixed.  If you need to change the number of players or any player
+ * disconnects, you must start a new session.
+ *
+ * input_size - The size of the game inputs which will be passsed to ggpo_add_local_input.
+ *
+ * local_port - The port GGPO should bind to for UDP traffic.
+ *
+ * host_ip - The IP address of the host who will serve you the inputs for the game.  Any
+ * player partcipating in the session can serve as a host.
+ *
+ * host_port - The port of the session on the host
+ *
+ * verification - Some optional data that will be matched with the peers during initial sync.
+ * Can be set to null if verification_size is zero. This can be used to check that all peers are
+ * running the same version of the application and of the game, are using the same settings, etc.
+ *
+ * verification_size - Size of the verification data. Can be set to zero to not exchange verification data.
+ * Maximum size is 256 bytes.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_start_spectating(GGPOSession **session,
+                                                     GGPOSessionCallbacks *cb,
+                                                     const char *game,
+                                                     int num_players,
+                                                     int input_size,
+                                                     unsigned short local_port,
+                                                     char *host_ip,
+                                                     unsigned short host_port,
+													 const void *verification,
+													 int verification_size);
+
+/*
+ * ggpo_close_session --
+ * Used to close a session.  You must call ggpo_close_session to
+ * free the resources allocated in ggpo_start_session.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_close_session(GGPOSession *);
+
+
+/*
+ * ggpo_set_frame_delay --
+ *
+ * Change the amount of frames ggpo will delay local input.  Must be called
+ * before the first call to ggpo_synchronize_input.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_set_frame_delay(GGPOSession *,
+                                                    GGPOPlayerHandle player,
+                                                    int frame_delay);
+
+/*
+ * ggpo_idle --
+ * Should be called periodically by your application to give GGPO.net
+ * a chance to do some work.  Most packet transmissions and rollbacks occur
+ * in ggpo_idle.
+ *
+ * timeout - The amount of time GGPO.net is allowed to spend in this function,
+ * in milliseconds.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_idle(GGPOSession *,
+                                         int timeout);
+
+/*
+ * ggpo_add_local_input --
+ *
+ * Used to notify GGPO.net of inputs that should be trasmitted to remote
+ * players.  ggpo_add_local_input must be called once every frame for
+ * all player of type GGPO_PLAYERTYPE_LOCAL.
+ *
+ * player - The player handle returned for this player when you called
+ * ggpo_add_local_player.
+ *
+ * values - The controller inputs for this player.
+ *
+ * size - The size of the controller inputs.  This must be exactly equal to the
+ * size passed into ggpo_start_session.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_add_local_input(GGPOSession *,
+                                                    GGPOPlayerHandle player,
+                                                    void *values,
+                                                    int size);
+
+/*
+ * ggpo_synchronize_input --
+ *
+ * You should call ggpo_synchronize_input before every frame of execution,
+ * including those frames which happen during rollback.
+ *
+ * values - When the function returns, the values parameter will contain
+ * inputs for this frame for all players.  The values array must be at
+ * least (size * players) large.
+ *
+ * size - The size of the values array.
+ *
+ * disconnect_flags - Indicated whether the input in slot (1 << flag) is
+ * valid.  If a player has disconnected, the input in the values array for
+ * that player will be zeroed and the i-th flag will be set.  For example,
+ * if only player 3 has disconnected, disconnect flags will be 8 (i.e. 1 << 3).
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_synchronize_input(GGPOSession *,
+                                                      void *values,
+                                                      int size,
+                                                      int *disconnect_flags);
+
+/*
+ * ggpo_disconnect_player --
+ *
+ * Disconnects a remote player from a game.  Will return GGPO_ERRORCODE_PLAYER_DISCONNECTED
+ * if you try to disconnect a player who has already been disconnected.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_disconnect_player(GGPOSession *,
+                                                      GGPOPlayerHandle player);
+
+/*
+ * ggpo_advance_frame --
+ *
+ * You should call ggpo_advance_frame to notify GGPO.net that you have
+ * advanced your gamestate by a single frame.  You should call this everytime
+ * you advance the gamestate by a frame, even during rollbacks.  GGPO.net
+ * may call your save_state callback before this function returns.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_advance_frame(GGPOSession *);
+
+/*
+ * ggpo_get_network_stats --
+ *
+ * Used to fetch some statistics about the quality of the network connection.
+ *
+ * player - The player handle returned from the ggpo_add_player function you used
+ * to add the remote player.
+ *
+ * stats - Out parameter to the network statistics.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_get_network_stats(GGPOSession *,
+                                                      GGPOPlayerHandle player,
+                                                      GGPONetworkStats *stats);
+
+/*
+ * ggpo_set_disconnect_timeout --
+ *
+ * Sets the disconnect timeout.  The session will automatically disconnect
+ * from a remote peer if it has not received a packet in the timeout window.
+ * You will be notified of the disconnect via a GGPO_EVENTCODE_DISCONNECTED_FROM_PEER
+ * event.
+ *
+ * Setting a timeout value of 0 will disable automatic disconnects.
+ *
+ * timeout - The time in milliseconds to wait before disconnecting a peer.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_set_disconnect_timeout(GGPOSession *,
+                                                           int timeout);
+
+/*
+ * ggpo_set_disconnect_notify_start --
+ *
+ * The time to wait before the first GGPO_EVENTCODE_NETWORK_INTERRUPTED timeout
+ * will be sent.
+ *
+ * timeout - The amount of time which needs to elapse without receiving a packet
+ *           before the GGPO_EVENTCODE_NETWORK_INTERRUPTED event is sent.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_set_disconnect_notify_start(GGPOSession *,
+                                                                int timeout);
+
+/*
+ * ggpo_send_message --
+ *
+ * Sends application-specific data to other peers. The message is
+ * delivered by the on_user_message callback.
+ * If spectators is true, the message is also sent to spectators.
+ */
+GGPO_API GGPOErrorCode __cdecl ggpo_send_message(GGPOSession *,
+                                                 const void *msg,
+                                                 int len,
+												 bool spectators);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

core/deps/ggpo/lib/ggpo/backends/backend.h

@@ -0,0 +1,33 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _BACKEND_H
+#define _BACKEND_H
+
+#include "../ggpo_types.h"
+#include "ggponet.h"
+
+struct GGPOSession {
+   virtual ~GGPOSession() { }
+   virtual GGPOErrorCode DoPoll(int timeout) { return GGPO_OK; }
+   virtual GGPOErrorCode AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle) = 0;
+   virtual GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size) = 0;
+   virtual GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags) = 0;
+   virtual GGPOErrorCode IncrementFrame(void) { return GGPO_OK; }
+   virtual GGPOErrorCode DisconnectPlayer(GGPOPlayerHandle handle) { return GGPO_OK; }
+   virtual GGPOErrorCode GetNetworkStats(GGPONetworkStats *stats, GGPOPlayerHandle handle) { return GGPO_OK; }
+
+   virtual GGPOErrorCode SetFrameDelay(GGPOPlayerHandle player, int delay) { return GGPO_ERRORCODE_UNSUPPORTED; }
+   virtual GGPOErrorCode SetDisconnectTimeout(int timeout) { return GGPO_ERRORCODE_UNSUPPORTED; }
+   virtual GGPOErrorCode SetDisconnectNotifyStart(int timeout) { return GGPO_ERRORCODE_UNSUPPORTED; }
+   virtual GGPOErrorCode SendMessage(const void *msg, int len, bool spectators) { return GGPO_ERRORCODE_UNSUPPORTED; }
+};
+
+typedef struct GGPOSession Quark, IQuarkBackend; /* XXX: nuke this */
+
+#endif
+

core/deps/ggpo/lib/ggpo/backends/p2p.cpp

@@ -0,0 +1,664 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "p2p.h"
+#include <chrono>
+#include <thread>
+
+static const int RECOMMENDATION_INTERVAL           = 240;
+static const int DEFAULT_DISCONNECT_TIMEOUT        = 5000;
+static const int DEFAULT_DISCONNECT_NOTIFY_START   = 750;
+
+Peer2PeerBackend::Peer2PeerBackend(GGPOSessionCallbacks *cb,
+                                   const char *gamename,
+                                   uint16 localport,
+                                   int num_players,
+                                   int input_size,
+								   const void *verification,
+								   int verification_size) :
+    _sync(_local_connect_status),
+	_endpoints(nullptr),
+    _num_spectators(0),
+    _input_size(input_size),
+    _num_players(num_players),
+    _next_spectator_frame(0),
+    _disconnect_timeout(DEFAULT_DISCONNECT_TIMEOUT),
+    _disconnect_notify_start(DEFAULT_DISCONNECT_NOTIFY_START)
+{
+   _callbacks = *cb;
+   _synchronizing = true;
+   _next_recommended_sleep = 0;
+
+   /*
+    * Initialize the synchronziation layer
+    */
+   Sync::Config config = { 0 };
+   config.num_players = num_players;
+   config.input_size = input_size;
+   config.callbacks = _callbacks;
+   config.num_prediction_frames = MAX_PREDICTION_FRAMES;
+   _sync.Init(config);
+
+   /*
+    * Initialize the UDP port
+    */
+   _udp.Init(localport, &_poll, this);
+
+   _endpoints = new UdpProtocol[_num_players];
+   for (int i = 0; i < _num_players; i++)
+	   _endpoints[i].SetVerificationData(verification, verification_size);
+   memset(_local_connect_status, 0, sizeof(_local_connect_status));
+   for (unsigned i = 0; i < ARRAY_SIZE(_local_connect_status); i++) {
+      _local_connect_status[i].last_frame = -1;
+   }
+
+   /*
+    * Preload the ROM
+    */
+   _callbacks.begin_game(gamename);
+}
+  
+Peer2PeerBackend::~Peer2PeerBackend()
+{
+   delete [] _endpoints;
+}
+
+void
+Peer2PeerBackend::AddRemotePlayer(char *ip,
+                                  uint16 port,
+                                  int queue)
+{
+   /*
+    * Start the state machine (xxx: no)
+    */
+   _synchronizing = true;
+   
+   _endpoints[queue].Init(&_udp, _poll, queue, ip, port, _local_connect_status);
+   _endpoints[queue].SetDisconnectTimeout(_disconnect_timeout);
+   _endpoints[queue].SetDisconnectNotifyStart(_disconnect_notify_start);
+   _endpoints[queue].Synchronize();
+}
+
+GGPOErrorCode Peer2PeerBackend::AddSpectator(char *ip,
+                                             uint16 port)
+{
+   if (_num_spectators == GGPO_MAX_SPECTATORS) {
+      return GGPO_ERRORCODE_TOO_MANY_SPECTATORS;
+   }
+   /*
+    * Currently, we can only add spectators before the game starts.
+    */
+   if (!_synchronizing) {
+      return GGPO_ERRORCODE_INVALID_REQUEST;
+   }
+   int queue = _num_spectators++;
+
+   _spectators[queue].Init(&_udp, _poll, queue + 1000, ip, port, _local_connect_status);
+   _spectators[queue].SetDisconnectTimeout(_disconnect_timeout);
+   _spectators[queue].SetDisconnectNotifyStart(_disconnect_notify_start);
+   _spectators[queue].Synchronize();
+
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::DoPoll(int timeout)
+{
+   if (!_sync.InRollback()) {
+      _poll.Pump(0);
+
+      PollUdpProtocolEvents();
+
+      if (!_synchronizing) {
+         _sync.CheckSimulation(timeout);
+
+         // notify all of our endpoints of their local frame number for their
+         // next connection quality report
+         int current_frame = _sync.GetFrameCount();
+         for (int i = 0; i < _num_players; i++) {
+            _endpoints[i].SetLocalFrameNumber(current_frame);
+         }
+
+         int total_min_confirmed;
+         if (_num_players <= 2) {
+            total_min_confirmed = Poll2Players(current_frame);
+         } else {
+            total_min_confirmed = PollNPlayers(current_frame);
+         }
+
+         Log("last confirmed frame in p2p backend is %d.", total_min_confirmed);
+         if (total_min_confirmed >= 0) {
+            ASSERT(total_min_confirmed != INT_MAX);
+            if (_num_spectators > 0) {
+               while (_next_spectator_frame <= total_min_confirmed) {
+                  Log("pushing frame %d to spectators.", _next_spectator_frame);
+   
+                  GameInput input;
+                  input.frame = _next_spectator_frame;
+                  input.size = _input_size * _num_players;
+                  _sync.GetConfirmedInputs(input.bits, _input_size * _num_players, _next_spectator_frame);
+                  for (int i = 0; i < _num_spectators; i++) {
+                     _spectators[i].SendInput(input);
+                  }
+                  _next_spectator_frame++;
+               }
+            }
+            Log("setting confirmed frame in sync to %d.", total_min_confirmed);
+            _sync.SetLastConfirmedFrame(total_min_confirmed);
+         }
+
+         // send timesync notifications if now is the proper time
+         if (current_frame > _next_recommended_sleep) {
+            int interval = 0;
+            for (int i = 0; i < _num_players; i++) {
+               interval = MAX(interval, _endpoints[i].RecommendFrameDelay());
+            }
+
+            if (interval > 0) {
+               GGPOEvent info;
+               info.code = GGPO_EVENTCODE_TIMESYNC;
+               info.u.timesync.frames_ahead = interval;
+               _callbacks.on_event(&info);
+               _next_recommended_sleep = current_frame + RECOMMENDATION_INTERVAL;
+            }
+         }
+         // XXX: this is obviously a farce...
+         if (timeout)
+        	 std::this_thread::sleep_for(std::chrono::milliseconds(1));
+      }
+   }
+   return GGPO_OK;
+}
+
+int Peer2PeerBackend::Poll2Players(int current_frame)
+{
+   int i;
+
+   // discard confirmed frames as appropriate
+   int total_min_confirmed = MAX_INT;
+   for (i = 0; i < _num_players; i++) {
+      bool queue_connected = true;
+      if (_endpoints[i].IsRunning()) {
+         int ignore;
+         queue_connected = _endpoints[i].GetPeerConnectStatus(i, &ignore);
+      }
+      if (!_local_connect_status[i].disconnected) {
+         total_min_confirmed = MIN(_local_connect_status[i].last_frame, total_min_confirmed);
+      }
+      Log("  local endp: connected = %d, last_received = %d, total_min_confirmed = %d.", !_local_connect_status[i].disconnected, _local_connect_status[i].last_frame, total_min_confirmed);
+      if (!queue_connected && !_local_connect_status[i].disconnected) {
+         Log("disconnecting i %d by remote request.", i);
+         DisconnectPlayerQueue(i, total_min_confirmed);
+      }
+      Log("  total_min_confirmed = %d.", total_min_confirmed);
+   }
+   return total_min_confirmed;
+}
+
+int Peer2PeerBackend::PollNPlayers(int current_frame)
+{
+   int i, queue, last_received;
+
+   // discard confirmed frames as appropriate
+   int total_min_confirmed = MAX_INT;
+   for (queue = 0; queue < _num_players; queue++) {
+      bool queue_connected = true;
+      int queue_min_confirmed = MAX_INT;
+      Log("considering queue %d.", queue);
+      for (i = 0; i < _num_players; i++) {
+         // we're going to do a lot of logic here in consideration of endpoint i.
+         // keep accumulating the minimum confirmed point for all n*n packets and
+         // throw away the rest.
+         if (_endpoints[i].IsRunning()) {
+            bool connected = _endpoints[i].GetPeerConnectStatus(queue, &last_received);
+
+            queue_connected = queue_connected && connected;
+            queue_min_confirmed = MIN(last_received, queue_min_confirmed);
+            Log("  endpoint %d: connected = %d, last_received = %d, queue_min_confirmed = %d.", i, connected, last_received, queue_min_confirmed);
+         } else {
+            Log("  endpoint %d: ignoring... not running.", i);
+         }
+      }
+      // merge in our local status only if we're still connected!
+      if (!_local_connect_status[queue].disconnected) {
+         queue_min_confirmed = MIN(_local_connect_status[queue].last_frame, queue_min_confirmed);
+      }
+      Log("  local endp: connected = %d, last_received = %d, queue_min_confirmed = %d.", !_local_connect_status[queue].disconnected, _local_connect_status[queue].last_frame, queue_min_confirmed);
+
+      if (queue_connected) {
+         total_min_confirmed = MIN(queue_min_confirmed, total_min_confirmed);
+      } else {
+         // check to see if this disconnect notification is further back than we've been before.  If
+         // so, we need to re-adjust.  This can happen when we detect our own disconnect at frame n
+         // and later receive a disconnect notification for frame n-1.
+         if (!_local_connect_status[queue].disconnected || _local_connect_status[queue].last_frame > queue_min_confirmed) {
+            Log("disconnecting queue %d by remote request.", queue);
+            DisconnectPlayerQueue(queue, queue_min_confirmed);
+         }
+      }
+      Log("  total_min_confirmed = %d.", total_min_confirmed);
+   }
+   return total_min_confirmed;
+}
+
+
+GGPOErrorCode
+Peer2PeerBackend::AddPlayer(GGPOPlayer *player,
+                            GGPOPlayerHandle *handle)
+{
+   if (player->type == GGPO_PLAYERTYPE_SPECTATOR) {
+      return AddSpectator(player->u.remote.ip_address, player->u.remote.port);
+   }
+
+   int queue = player->player_num - 1;
+   if (player->player_num < 1 || player->player_num > _num_players) {
+      return GGPO_ERRORCODE_PLAYER_OUT_OF_RANGE;
+   }
+   *handle = QueueToPlayerHandle(queue);
+
+   if (player->type == GGPO_PLAYERTYPE_REMOTE) {
+      AddRemotePlayer(player->u.remote.ip_address, player->u.remote.port, queue);
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::AddLocalInput(GGPOPlayerHandle player,
+                                void *values,
+                                int size)
+{
+   int queue;
+   GameInput input;
+   GGPOErrorCode result;
+
+   if (_sync.InRollback()) {
+      return GGPO_ERRORCODE_IN_ROLLBACK;
+   }
+   if (_synchronizing) {
+      return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+   }
+   
+   result = PlayerHandleToQueue(player, &queue);
+   if (!GGPO_SUCCEEDED(result)) {
+      return result;
+   }
+
+   input.init(-1, (char *)values, size);
+
+   // Feed the input for the current frame into the synchronzation layer.
+   if (!_sync.AddLocalInput(queue, input)) {
+      return GGPO_ERRORCODE_PREDICTION_THRESHOLD;
+   }
+
+   if (input.frame != GameInput::NullFrame) { // xxx: <- comment why this is the case
+      // Update the local connect status state to indicate that we've got a
+      // confirmed local frame for this player.  this must come first so it
+      // gets incorporated into the next packet we send.
+
+      Log("setting local connect status for local queue %d to %d", queue, input.frame);
+      _local_connect_status[queue].last_frame = input.frame;
+
+      // Send the input to all the remote players.
+      for (int i = 0; i < _num_players; i++) {
+         if (_endpoints[i].IsInitialized()) {
+            _endpoints[i].SendInput(input);
+         }
+      }
+   }
+
+   return GGPO_OK;
+}
+
+
+GGPOErrorCode
+Peer2PeerBackend::SyncInput(void *values,
+                            int size,
+                            int *disconnect_flags)
+{
+   int flags;
+
+   // Wait until we've started to return inputs.
+   if (_synchronizing) {
+      return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+   }
+   flags = _sync.SynchronizeInputs(values, size);
+   if (disconnect_flags) {
+      *disconnect_flags = flags;
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::IncrementFrame(void)
+{  
+   Log("End of frame (%d)...", _sync.GetFrameCount());
+   _sync.IncrementFrame();
+   DoPoll(0);
+   PollSyncEvents();
+
+   return GGPO_OK;
+}
+
+
+void
+Peer2PeerBackend::PollSyncEvents(void)
+{
+   Sync::Event e;
+   while (_sync.GetEvent(e)) {
+      OnSyncEvent(e);
+   }
+   return;
+}
+
+void
+Peer2PeerBackend::PollUdpProtocolEvents(void)
+{
+   UdpProtocol::Event evt;
+   for (int i = 0; i < _num_players; i++) {
+      while (_endpoints[i].GetEvent(evt)) {
+         OnUdpProtocolPeerEvent(evt, i);
+      }
+   }
+   for (int i = 0; i < _num_spectators; i++) {
+      while (_spectators[i].GetEvent(evt)) {
+         OnUdpProtocolSpectatorEvent(evt, i);
+      }
+   }
+}
+
+void
+Peer2PeerBackend::OnUdpProtocolPeerEvent(UdpProtocol::Event &evt, int queue)
+{
+   OnUdpProtocolEvent(evt, QueueToPlayerHandle(queue));
+   switch (evt.type) {
+      case UdpProtocol::Event::Input:
+         if (!_local_connect_status[queue].disconnected) {
+            int current_remote_frame = _local_connect_status[queue].last_frame;
+            int new_remote_frame = evt.u.input.input.frame;
+            ASSERT(current_remote_frame == -1 || new_remote_frame == (current_remote_frame + 1));
+
+            _sync.AddRemoteInput(queue, evt.u.input.input);
+            // Notify the other endpoints which frame we received from a peer
+            Log("setting remote connect status for queue %d to %d", queue, evt.u.input.input.frame);
+            _local_connect_status[queue].last_frame = evt.u.input.input.frame;
+         }
+         break;
+
+   case UdpProtocol::Event::Disconnected:
+      DisconnectPlayer(QueueToPlayerHandle(queue));
+      break;
+
+   case UdpProtocol::Event::AppData:
+	   if (evt.u.app_data.spectators)
+		   for (int i = 0; i < _num_spectators; i++)
+			   if (_spectators[i].IsInitialized())
+				   _spectators[i].SendAppData(evt.u.app_data.data, evt.u.app_data.size, true);
+	   Log("calling on_message callback with %d bytes", evt.u.app_data.size);
+	   if (_callbacks.on_message != nullptr)
+		   _callbacks.on_message(evt.u.app_data.data, evt.u.app_data.size);
+	  break;
+
+   default:
+	  break;
+   }
+}
+
+
+void
+Peer2PeerBackend::OnUdpProtocolSpectatorEvent(UdpProtocol::Event &evt, int queue)
+{
+   GGPOPlayerHandle handle = QueueToSpectatorHandle(queue);
+   OnUdpProtocolEvent(evt, handle);
+
+   if (evt.type == UdpProtocol::Event::Disconnected)
+   {
+      _spectators[queue].Disconnect();
+
+      GGPOEvent info;
+      info.code = GGPO_EVENTCODE_DISCONNECTED_FROM_PEER;
+      info.u.disconnected.player = handle;
+      _callbacks.on_event(&info);
+   }
+}
+
+void
+Peer2PeerBackend::OnUdpProtocolEvent(UdpProtocol::Event &evt, GGPOPlayerHandle handle)
+{
+   GGPOEvent info;
+
+   switch (evt.type) {
+   case UdpProtocol::Event::Connected:
+      info.code = GGPO_EVENTCODE_CONNECTED_TO_PEER;
+      info.u.connected.player = handle;
+      _callbacks.on_event(&info);
+      break;
+   case UdpProtocol::Event::Synchronizing:
+      info.code = GGPO_EVENTCODE_SYNCHRONIZING_WITH_PEER;
+      info.u.synchronizing.player = handle;
+      info.u.synchronizing.count = evt.u.synchronizing.count;
+      info.u.synchronizing.total = evt.u.synchronizing.total;
+      _callbacks.on_event(&info);
+      break;
+   case UdpProtocol::Event::Synchronzied:
+      info.code = GGPO_EVENTCODE_SYNCHRONIZED_WITH_PEER;
+      info.u.synchronized.player = handle;
+      _callbacks.on_event(&info);
+
+      CheckInitialSync();
+      break;
+
+   case UdpProtocol::Event::NetworkInterrupted:
+      info.code = GGPO_EVENTCODE_CONNECTION_INTERRUPTED;
+      info.u.connection_interrupted.player = handle;
+      info.u.connection_interrupted.disconnect_timeout = evt.u.network_interrupted.disconnect_timeout;
+      _callbacks.on_event(&info);
+      break;
+
+   case UdpProtocol::Event::NetworkResumed:
+      info.code = GGPO_EVENTCODE_CONNECTION_RESUMED;
+      info.u.connection_resumed.player = handle;
+      _callbacks.on_event(&info);
+      break;
+
+   default:
+	  break;
+   }
+}
+
+/*
+ * Called only as the result of a local decision to disconnect.  The remote
+ * decisions to disconnect are a result of us parsing the peer_connect_settings
+ * blob in every endpoint periodically.
+ */
+GGPOErrorCode
+Peer2PeerBackend::DisconnectPlayer(GGPOPlayerHandle player)
+{
+   int queue;
+   GGPOErrorCode result;
+
+   result = PlayerHandleToQueue(player, &queue);
+   if (!GGPO_SUCCEEDED(result)) {
+      return result;
+   }
+   
+   if (_local_connect_status[queue].disconnected) {
+      return GGPO_ERRORCODE_PLAYER_DISCONNECTED;
+   }
+
+   if (!_endpoints[queue].IsInitialized()) {
+      int current_frame = _sync.GetFrameCount();
+      // xxx: we should be tracking who the local player is, but for now assume
+      // that if the endpoint is not initalized, this must be the local player.
+      Log("Disconnecting local player %d at frame %d by user request.", queue, _local_connect_status[queue].last_frame);
+      for (int i = 0; i < _num_players; i++) {
+         if (_endpoints[i].IsInitialized()) {
+            DisconnectPlayerQueue(i, current_frame);
+         }
+      }
+   } else {
+      Log("Disconnecting queue %d at frame %d by user request.", queue, _local_connect_status[queue].last_frame);
+      DisconnectPlayerQueue(queue, _local_connect_status[queue].last_frame);
+   }
+   return GGPO_OK;
+}
+
+void
+Peer2PeerBackend::DisconnectPlayerQueue(int queue, int syncto)
+{
+   GGPOEvent info;
+   int framecount = _sync.GetFrameCount();
+
+   _endpoints[queue].Disconnect();
+
+   Log("Changing queue %d local connect status for last frame from %d to %d on disconnect request (current: %d).",
+       queue, _local_connect_status[queue].last_frame, syncto, framecount);
+
+   _local_connect_status[queue].disconnected = 1;
+   _local_connect_status[queue].last_frame = syncto;
+
+   if (syncto != GameInput::NullFrame && syncto < framecount) {
+      Log("adjusting simulation to account for the fact that %d disconnected @ %d.", queue, syncto);
+      _sync.AdjustSimulation(syncto);
+      Log("finished adjusting simulation.");
+   }
+
+   info.code = GGPO_EVENTCODE_DISCONNECTED_FROM_PEER;
+   info.u.disconnected.player = QueueToPlayerHandle(queue);
+   _callbacks.on_event(&info);
+
+   CheckInitialSync();
+}
+
+
+GGPOErrorCode
+Peer2PeerBackend::GetNetworkStats(GGPONetworkStats *stats, GGPOPlayerHandle player)
+{
+   int queue;
+   GGPOErrorCode result;
+
+   result = PlayerHandleToQueue(player, &queue);
+   if (!GGPO_SUCCEEDED(result)) {
+      return result;
+   }
+
+   memset(stats, 0, sizeof *stats);
+   _endpoints[queue].GetNetworkStats(stats);
+   stats->sync.predicted_frames = _sync.GetPredictedFrames();
+
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::SetFrameDelay(GGPOPlayerHandle player, int delay) 
+{ 
+   int queue;
+   GGPOErrorCode result;
+
+   result = PlayerHandleToQueue(player, &queue);
+   if (!GGPO_SUCCEEDED(result)) {
+      return result;
+   }
+   _sync.SetFrameDelay(queue, delay);
+   return GGPO_OK; 
+}
+
+GGPOErrorCode
+Peer2PeerBackend::SetDisconnectTimeout(int timeout)
+{
+   _disconnect_timeout = timeout;
+   for (int i = 0; i < _num_players; i++) {
+      if (_endpoints[i].IsInitialized()) {
+         _endpoints[i].SetDisconnectTimeout(_disconnect_timeout);
+      }
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::SetDisconnectNotifyStart(int timeout)
+{
+   _disconnect_notify_start = timeout;
+   for (int i = 0; i < _num_players; i++) {
+      if (_endpoints[i].IsInitialized()) {
+         _endpoints[i].SetDisconnectNotifyStart(_disconnect_notify_start);
+      }
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+Peer2PeerBackend::PlayerHandleToQueue(GGPOPlayerHandle player, int *queue)
+{
+   int offset = ((int)player - 1);
+   if (offset < 0 || offset >= _num_players) {
+      return GGPO_ERRORCODE_INVALID_PLAYER_HANDLE;
+   }
+   *queue = offset;
+   return GGPO_OK;
+}
+
+ 
+void
+Peer2PeerBackend::OnMsg(sockaddr_in &from, UdpMsg *msg, int len)
+{
+   for (int i = 0; i < _num_players; i++) {
+      if (_endpoints[i].HandlesMsg(from, msg)) {
+         _endpoints[i].OnMsg(msg, len);
+         return;
+      }
+   }
+   for (int i = 0; i < _num_spectators; i++) {
+      if (_spectators[i].HandlesMsg(from, msg)) {
+         _spectators[i].OnMsg(msg, len);
+         return;
+      }
+   }
+}
+
+void
+Peer2PeerBackend::CheckInitialSync()
+{
+   int i;
+
+   if (_synchronizing) {
+      // Check to see if everyone is now synchronized.  If so,
+      // go ahead and tell the client that we're ok to accept input.
+      for (i = 0; i < _num_players; i++) {
+         // xxx: IsInitialized() must go... we're actually using it as a proxy for "represents the local player"
+         if (_endpoints[i].IsInitialized() && !_endpoints[i].IsSynchronized() && !_local_connect_status[i].disconnected) {
+            return;
+         }
+      }
+      for (i = 0; i < _num_spectators; i++) {
+         if (_spectators[i].IsInitialized() && !_spectators[i].IsSynchronized()) {
+            return;
+         }
+      }
+
+      GGPOEvent info;
+      info.code = GGPO_EVENTCODE_RUNNING;
+      _callbacks.on_event(&info);
+      _synchronizing = false;
+   }
+}
+
+GGPOErrorCode Peer2PeerBackend::SendMessage(const void *msg, int len, bool spectators)
+{
+	if (_synchronizing)
+		return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+	if (len > MAX_APPDATA_SIZE)
+		return GGPO_ERRORCODE_INVALID_REQUEST;
+	for (int i = 0; i < _num_players; i++)
+        if (_endpoints[i].IsInitialized())
+           _endpoints[i].SendAppData(msg, len, spectators);
+	if (spectators)
+		for (int i = 0; i < _num_spectators; i++)
+	        if (_spectators[i].IsInitialized())
+	        	_spectators[i].SendAppData(msg, len, spectators);
+
+	return GGPO_ERRORCODE_SUCCESS;
+}

core/deps/ggpo/lib/ggpo/backends/p2p.h

@@ -0,0 +1,79 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _P2P_H
+#define _P2P_H
+
+#include "ggpo_types.h"
+#include "ggpo_poll.h"
+#include "sync.h"
+#include "backend.h"
+#include "timesync.h"
+#include "network/udp_proto.h"
+
+class Peer2PeerBackend : public IQuarkBackend, IPollSink, Udp::Callbacks {
+public:
+   Peer2PeerBackend(GGPOSessionCallbacks *cb, const char *gamename, uint16 localport, int num_players, int input_size,
+		   const void *verification, int verification_size);
+   virtual ~Peer2PeerBackend();
+
+
+public:
+   GGPOErrorCode DoPoll(int timeout) override;
+   GGPOErrorCode AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle) override;
+   GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size) override;
+   GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags) override;
+   GGPOErrorCode IncrementFrame(void) override;
+   GGPOErrorCode DisconnectPlayer(GGPOPlayerHandle handle) override;
+   GGPOErrorCode GetNetworkStats(GGPONetworkStats *stats, GGPOPlayerHandle handle) override;
+   GGPOErrorCode SetFrameDelay(GGPOPlayerHandle player, int delay) override;
+   GGPOErrorCode SetDisconnectTimeout(int timeout) override;
+   GGPOErrorCode SetDisconnectNotifyStart(int timeout) override;
+   GGPOErrorCode SendMessage(const void *msg, int len, bool spectators) override;
+
+public:
+   void OnMsg(sockaddr_in &from, UdpMsg *msg, int len) override;
+
+protected:
+   GGPOErrorCode PlayerHandleToQueue(GGPOPlayerHandle player, int *queue);
+   GGPOPlayerHandle QueueToPlayerHandle(int queue) { return (GGPOPlayerHandle)(queue + 1); }
+   GGPOPlayerHandle QueueToSpectatorHandle(int queue) { return (GGPOPlayerHandle)(queue + 1000); } /* out of range of the player array, basically */
+   void DisconnectPlayerQueue(int queue, int syncto);
+   void PollSyncEvents(void);
+   void PollUdpProtocolEvents(void);
+   void CheckInitialSync(void);
+   int Poll2Players(int current_frame);
+   int PollNPlayers(int current_frame);
+   void AddRemotePlayer(char *remoteip, uint16 reportport, int queue);
+   GGPOErrorCode AddSpectator(char *remoteip, uint16 reportport);
+   virtual void OnSyncEvent(Sync::Event &e) { }
+   virtual void OnUdpProtocolEvent(UdpProtocol::Event &e, GGPOPlayerHandle handle);
+   virtual void OnUdpProtocolPeerEvent(UdpProtocol::Event &e, int queue);
+   virtual void OnUdpProtocolSpectatorEvent(UdpProtocol::Event &e, int queue);
+
+protected:
+   GGPOSessionCallbacks  _callbacks;
+   Poll                  _poll;
+   Sync                  _sync;
+   Udp                   _udp;
+   UdpProtocol           *_endpoints;
+   UdpProtocol           _spectators[GGPO_MAX_SPECTATORS];
+   int                   _num_spectators;
+   int                   _input_size;
+
+   bool                  _synchronizing;
+   int                   _num_players;
+   int                   _next_recommended_sleep;
+
+   int                   _next_spectator_frame;
+   int                   _disconnect_timeout;
+   int                   _disconnect_notify_start;
+
+   UdpMsg::connect_status _local_connect_status[UDP_MSG_MAX_PLAYERS];
+};
+
+#endif

core/deps/ggpo/lib/ggpo/backends/spectator.cpp

@@ -0,0 +1,189 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "spectator.h"
+
+SpectatorBackend::SpectatorBackend(GGPOSessionCallbacks *cb,
+                                   const char* gamename,
+                                   uint16 localport,
+                                   int num_players,
+                                   int input_size,
+                                   char *hostip,
+                                   u_short hostport,
+								   const void *verification,
+								   int verification_size) :
+   _input_size(input_size),
+   _num_players(num_players),
+   _next_input_to_send(0)
+{
+   _callbacks = *cb;
+   _synchronizing = true;
+
+   for (size_t i = 0; i < ARRAY_SIZE(_inputs); i++) {
+      _inputs[i].frame = -1;
+   }
+
+   /*
+    * Initialize the UDP port
+    */
+   _udp.Init(localport, &_poll, this);
+
+   /*
+    * Init the host endpoint
+    */
+   _host.SetVerificationData(verification, verification_size);
+   _host.Init(&_udp, _poll, 0, hostip, hostport, NULL);
+   _host.Synchronize();
+
+   /*
+    * Preload the ROM
+    */
+   _callbacks.begin_game(gamename);
+}
+  
+SpectatorBackend::~SpectatorBackend()
+{
+}
+
+GGPOErrorCode
+SpectatorBackend::DoPoll(int timeout)
+{
+   _poll.Pump(0);
+
+   PollUdpProtocolEvents();
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SpectatorBackend::SyncInput(void *values,
+                            int size,
+                            int *disconnect_flags)
+{
+   // Wait until we've started to return inputs.
+   if (_synchronizing) {
+      return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+   }
+
+   GameInput &input = _inputs[_next_input_to_send % SPECTATOR_FRAME_BUFFER_SIZE];
+   if (input.frame < _next_input_to_send) {
+      // Haven't received the input from the host yet.  Wait
+      return GGPO_ERRORCODE_PREDICTION_THRESHOLD;
+   }
+   if (input.frame > _next_input_to_send) {
+      // The host is way way way far ahead of the spectator.  How'd this
+      // happen?  Anyway, the input we need is gone forever.
+      return GGPO_ERRORCODE_GENERAL_FAILURE;
+   }
+
+   ASSERT(size >= _input_size * _num_players);
+   memcpy(values, input.bits, _input_size * _num_players);
+   if (disconnect_flags) {
+      *disconnect_flags = 0; // xxx: should get them from the host!
+   }
+   _next_input_to_send++;
+
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SpectatorBackend::IncrementFrame(void)
+{  
+   Log("End of frame (%d)...", _next_input_to_send - 1);
+   DoPoll(0);
+   PollUdpProtocolEvents();
+
+   return GGPO_OK;
+}
+
+void
+SpectatorBackend::PollUdpProtocolEvents(void)
+{
+   UdpProtocol::Event evt;
+   while (_host.GetEvent(evt)) {
+      OnUdpProtocolEvent(evt);
+   }
+}
+
+void
+SpectatorBackend::OnUdpProtocolEvent(UdpProtocol::Event &evt)
+{
+   GGPOEvent info;
+
+   switch (evt.type) {
+   case UdpProtocol::Event::Connected:
+      info.code = GGPO_EVENTCODE_CONNECTED_TO_PEER;
+      info.u.connected.player = 0;
+      _callbacks.on_event(&info);
+      break;
+   case UdpProtocol::Event::Synchronizing:
+      info.code = GGPO_EVENTCODE_SYNCHRONIZING_WITH_PEER;
+      info.u.synchronizing.player = 0;
+      info.u.synchronizing.count = evt.u.synchronizing.count;
+      info.u.synchronizing.total = evt.u.synchronizing.total;
+      _callbacks.on_event(&info);
+      break;
+   case UdpProtocol::Event::Synchronzied:
+      if (_synchronizing) {
+         info.code = GGPO_EVENTCODE_SYNCHRONIZED_WITH_PEER;
+         info.u.synchronized.player = 0;
+         _callbacks.on_event(&info);
+
+         info.code = GGPO_EVENTCODE_RUNNING;
+         _callbacks.on_event(&info);
+         _synchronizing = false;
+      }
+      break;
+
+   case UdpProtocol::Event::NetworkInterrupted:
+      info.code = GGPO_EVENTCODE_CONNECTION_INTERRUPTED;
+      info.u.connection_interrupted.player = 0;
+      info.u.connection_interrupted.disconnect_timeout = evt.u.network_interrupted.disconnect_timeout;
+      _callbacks.on_event(&info);
+      break;
+
+   case UdpProtocol::Event::NetworkResumed:
+      info.code = GGPO_EVENTCODE_CONNECTION_RESUMED;
+      info.u.connection_resumed.player = 0;
+      _callbacks.on_event(&info);
+      break;
+
+   case UdpProtocol::Event::Disconnected:
+      info.code = GGPO_EVENTCODE_DISCONNECTED_FROM_PEER;
+      info.u.disconnected.player = 0;
+      _callbacks.on_event(&info);
+      break;
+
+   case UdpProtocol::Event::Input:
+   	  {
+   		  GameInput& input = evt.u.input.input;
+
+   		  _host.SetLocalFrameNumber(input.frame);
+   		  _host.SendInputAck();
+   		  _inputs[input.frame % SPECTATOR_FRAME_BUFFER_SIZE] = input;
+   	  }
+      break;
+
+   case UdpProtocol::Event::AppData:
+	  Log("calling on_message callback with %d bytes", evt.u.app_data.size);
+	  if (_callbacks.on_message != nullptr)
+		  _callbacks.on_message(evt.u.app_data.data, evt.u.app_data.size);
+	  break;
+
+
+   default:
+	  break;
+   }
+}
+ 
+void
+SpectatorBackend::OnMsg(sockaddr_in &from, UdpMsg *msg, int len)
+{
+   if (_host.HandlesMsg(from, msg)) {
+      _host.OnMsg(msg, len);
+   }
+}
+

core/deps/ggpo/lib/ggpo/backends/spectator.h

@@ -0,0 +1,60 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _SPECTATOR_H
+#define _SPECTATOR_H
+
+#include "../ggpo_poll.h"
+#include "../ggpo_types.h"
+#include "sync.h"
+#include "backend.h"
+#include "timesync.h"
+#include "network/udp_proto.h"
+
+#define SPECTATOR_FRAME_BUFFER_SIZE    64
+
+class SpectatorBackend : public IQuarkBackend, IPollSink, Udp::Callbacks {
+public:
+   SpectatorBackend(GGPOSessionCallbacks *cb, const char *gamename, uint16 localport, int num_players, int input_size, char *hostip, u_short hostport,
+		   const void *verification, int verification_size);
+   virtual ~SpectatorBackend();
+
+
+public:
+   GGPOErrorCode DoPoll(int timeout) override;
+   GGPOErrorCode AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size) override { return GGPO_OK; }
+   GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags) override;
+   GGPOErrorCode IncrementFrame(void) override;
+   GGPOErrorCode DisconnectPlayer(GGPOPlayerHandle handle) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode GetNetworkStats(GGPONetworkStats *stats, GGPOPlayerHandle handle) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode SetFrameDelay(GGPOPlayerHandle player, int delay) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode SetDisconnectTimeout(int timeout) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+   GGPOErrorCode SetDisconnectNotifyStart(int timeout) override { return GGPO_ERRORCODE_UNSUPPORTED; }
+
+public:
+   void OnMsg(sockaddr_in &from, UdpMsg *msg, int len) override;
+
+protected:
+   void PollUdpProtocolEvents(void);
+   void CheckInitialSync(void);
+
+   void OnUdpProtocolEvent(UdpProtocol::Event &e);
+
+protected:
+   GGPOSessionCallbacks  _callbacks;
+   Poll                  _poll;
+   Udp                   _udp;
+   UdpProtocol           _host;
+   bool                  _synchronizing;
+   int                   _input_size;
+   int                   _num_players;
+   int                   _next_input_to_send;
+   GameInput             _inputs[SPECTATOR_FRAME_BUFFER_SIZE];
+};
+
+#endif

core/deps/ggpo/lib/ggpo/backends/synctest.cpp

@@ -0,0 +1,184 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "synctest.h"
+
+SyncTestBackend::SyncTestBackend(GGPOSessionCallbacks *cb,
+                                 const char *gamename,
+                                 int frames,
+                                 int num_players) :
+   _sync(NULL)
+{
+   _callbacks = *cb;
+   _num_players = num_players;
+   _check_distance = frames;
+   _last_verified = 0;
+   _rollingback = false;
+   _running = false;
+   _logfp = NULL;
+   _current_input.erase();
+   strcpy(_game, gamename);
+
+   /*
+    * Initialize the synchronziation layer
+    */
+   Sync::Config config = { 0 };
+   config.callbacks = _callbacks;
+   config.num_prediction_frames = MAX_PREDICTION_FRAMES;
+   _sync.Init(config);
+
+   /*
+    * Preload the ROM
+    */
+   _callbacks.begin_game(gamename);
+}
+
+SyncTestBackend::~SyncTestBackend()
+{
+}
+
+GGPOErrorCode
+SyncTestBackend::DoPoll(int timeout)
+{
+   if (!_running) {
+      GGPOEvent info;
+
+      info.code = GGPO_EVENTCODE_RUNNING;
+      _callbacks.on_event(&info);
+      _running = true;
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SyncTestBackend::AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle)
+{
+   if (player->player_num < 1 || player->player_num > _num_players) {
+      return GGPO_ERRORCODE_PLAYER_OUT_OF_RANGE;
+   }
+   *handle = (GGPOPlayerHandle)(player->player_num - 1);
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SyncTestBackend::AddLocalInput(GGPOPlayerHandle player, void *values, int size)
+{
+   if (!_running) {
+      return GGPO_ERRORCODE_NOT_SYNCHRONIZED;
+   }
+
+   int index = (int)player;
+   for (int i = 0; i < size; i++) {
+      _current_input.bits[(index * size) + i] |= ((char *)values)[i];
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SyncTestBackend::SyncInput(void *values,
+                           int size,
+                           int *disconnect_flags)
+{
+   if (_rollingback) {
+      _last_input = _saved_frames.front().input;
+   } else {
+      if (_sync.GetFrameCount() == 0 && _sync.GetLastSavedFrame().buf == nullptr) {
+         _sync.SaveCurrentFrame();
+      }
+      _last_input = _current_input;
+   }
+   memcpy(values, _last_input.bits, size);
+   if (disconnect_flags) {
+      *disconnect_flags = 0;
+   }
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+SyncTestBackend::IncrementFrame(void)
+{  
+   _sync.IncrementFrame();
+   _current_input.erase();
+   
+   DEBUG_LOG(NETWORK, "End of frame(%d)...", _sync.GetFrameCount());
+
+   if (_rollingback) {
+      return GGPO_OK;
+   }
+
+   int frame = _sync.GetFrameCount();
+   // Hold onto the current frame in our queue of saved states.  We'll need
+   // the checksum later to verify that our replay of the same frame got the
+   // same results.
+   SavedInfo info;
+   info.frame = frame;
+   info.input = _last_input;
+   info.cbuf = _sync.GetLastSavedFrame().cbuf;
+   info.buf = (char *)malloc(info.cbuf);
+   memcpy(info.buf, _sync.GetLastSavedFrame().buf, info.cbuf);
+   info.checksum = _sync.GetLastSavedFrame().checksum;
+   _saved_frames.push(info);
+
+   if (frame - _last_verified == _check_distance) {
+      // We've gone far enough ahead and should now start replaying frames.
+      // Load the last verified frame and set the rollback flag to true.
+      _sync.LoadFrame(_last_verified);
+
+      _rollingback = true;
+      while(!_saved_frames.empty()) {
+         _callbacks.advance_frame(0);
+
+         // Verify that the checksumn of this frame is the same as the one in our
+         // list.
+         info = _saved_frames.front();
+         _saved_frames.pop();
+
+         if (info.frame != _sync.GetFrameCount()) {
+            RaiseSyncError("Frame number %d does not match saved frame number %d", info.frame, frame);
+         }
+         int checksum = _sync.GetLastSavedFrame().checksum;
+         if (info.checksum != checksum) {
+            LogSaveStates(info);
+            RaiseSyncError("Checksum for frame %d does not match saved (%d != %d)", frame, checksum, info.checksum);
+         }
+         else
+        	 printf("Checksum %08d for frame %d matches.\n", checksum, info.frame);
+         free(info.buf);
+      }
+      _last_verified = frame;
+      _rollingback = false;
+   }
+
+   return GGPO_OK;
+}
+
+void
+SyncTestBackend::RaiseSyncError(const char *fmt, ...)
+{
+   char buf[1024];
+   va_list args;
+   va_start(args, fmt);
+   vsnprintf(buf, ARRAY_SIZE(buf), fmt, args);
+   va_end(args);
+
+   puts(buf);
+#ifdef _WIN32
+   OutputDebugStringA(buf);
+#endif
+//   DebugBreak();
+}
+
+void
+SyncTestBackend::LogSaveStates(SavedInfo &info)
+{
+   char filename[MAX_PATH];
+   snprintf(filename, ARRAY_SIZE(filename), "synclogs/state-%04d-original.log", _sync.GetFrameCount());
+   _callbacks.log_game_state(filename, (unsigned char *)info.buf, info.cbuf);
+
+   snprintf(filename, ARRAY_SIZE(filename), "synclogs/state-%04d-replay.log", _sync.GetFrameCount());
+   _callbacks.log_game_state(filename, _sync.GetLastSavedFrame().buf, _sync.GetLastSavedFrame().cbuf);
+}

core/deps/ggpo/lib/ggpo/backends/synctest.h

@@ -0,0 +1,57 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _SYNCTEST_H
+#define _SYNCTEST_H
+
+#include "ggpo_types.h"
+#include "backend.h"
+#include "sync.h"
+
+#include "ring_buffer.h"
+
+class SyncTestBackend : public IQuarkBackend {
+public:
+   SyncTestBackend(GGPOSessionCallbacks *cb, const char *gamename, int frames, int num_players);
+   virtual ~SyncTestBackend();
+
+   virtual GGPOErrorCode DoPoll(int timeout);
+   virtual GGPOErrorCode AddPlayer(GGPOPlayer *player, GGPOPlayerHandle *handle);
+   virtual GGPOErrorCode AddLocalInput(GGPOPlayerHandle player, void *values, int size);
+   virtual GGPOErrorCode SyncInput(void *values, int size, int *disconnect_flags);
+   virtual GGPOErrorCode IncrementFrame(void);
+
+protected:
+   struct SavedInfo {
+      int         frame;
+      int         checksum;
+      char        *buf;
+      int         cbuf;
+      GameInput   input;
+   };
+
+   void RaiseSyncError(const char *fmt, ...);
+   void LogSaveStates(SavedInfo &info);
+
+protected:
+   GGPOSessionCallbacks   _callbacks;
+   Sync                   _sync;
+   int                    _num_players;
+   int                    _check_distance;
+   int                    _last_verified;
+   bool                   _rollingback;
+   bool                   _running;
+   FILE                   *_logfp;
+   char                   _game[128];
+
+   GameInput                  _current_input;
+   GameInput                  _last_input;
+   RingBuffer<SavedInfo, 32>  _saved_frames;
+};
+
+#endif
+

core/deps/ggpo/lib/ggpo/bitvector.cpp

@@ -0,0 +1,55 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "ggpo_types.h"
+#include "bitvector.h"
+
+void
+BitVector_SetBit(uint8 *vector, int *offset)
+{
+   vector[(*offset) / 8] |= (1 << ((*offset) % 8));
+   *offset += 1;
+}
+
+void
+BitVector_ClearBit(uint8 *vector, int *offset)
+{
+   vector[(*offset) / 8] &= ~(1 << ((*offset) % 8));
+   *offset += 1;
+}
+
+void
+BitVector_WriteNibblet(uint8 *vector, int nibble, int *offset)
+{
+   ASSERT(nibble < (1 << BITVECTOR_NIBBLE_SIZE));
+   for (int i = 0; i < BITVECTOR_NIBBLE_SIZE; i++) {
+      if (nibble & (1 << i)) {
+         BitVector_SetBit(vector, offset);
+      } else {
+         BitVector_ClearBit(vector, offset);
+      }
+   }
+}
+
+int
+BitVector_ReadBit(uint8 *vector, int *offset)
+{
+   int retval = !!(vector[(*offset) / 8] & (1 << ((*offset) % 8)));
+   *offset += 1;
+   return retval;
+}
+
+int
+BitVector_ReadNibblet(uint8 *vector, int *offset)
+{
+   int nibblet = 0;
+   for (int i = 0; i < BITVECTOR_NIBBLE_SIZE; i++) {
+      nibblet |= (BitVector_ReadBit(vector, offset) << i);
+   }
+   return nibblet;
+}
+

core/deps/ggpo/lib/ggpo/bitvector.h

@@ -0,0 +1,19 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _BITVECTOR_H
+#define _BITVECTOR_H
+
+#define BITVECTOR_NIBBLE_SIZE 8
+
+void BitVector_SetBit(uint8 *vector, int *offset);
+void BitVector_ClearBit(uint8 *vector, int *offset);
+void BitVector_WriteNibblet(uint8 *vector, int nibble, int *offset);
+int BitVector_ReadBit(uint8 *vector, int *offset);
+int BitVector_ReadNibblet(uint8 *vector, int *offset);
+
+#endif // _BITVECTOR_H

core/deps/ggpo/lib/ggpo/game_input.cpp

@@ -0,0 +1,86 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "game_input.h"
+
+#include "ggpo_types.h"
+
+void
+GameInput::init(int iframe, char *ibits, int isize, int offset)
+{
+   ASSERT(isize);
+   ASSERT(isize <= GAMEINPUT_MAX_BYTES);
+   frame = iframe;
+   size = isize;
+   memset(bits, 0, sizeof(bits));
+   if (ibits) {
+      memcpy(bits + (offset * isize), ibits, isize);
+   }
+}
+
+void
+GameInput::init(int iframe, char *ibits, int isize)
+{
+   ASSERT(isize);
+   ASSERT(isize <= GAMEINPUT_MAX_BYTES * GAMEINPUT_MAX_PLAYERS);
+   frame = iframe;
+   size = isize;
+   memset(bits, 0, sizeof(bits));
+   if (ibits) {
+      memcpy(bits, ibits, isize);
+   }
+}
+
+void
+GameInput::desc(char *buf, size_t buf_size, bool show_frame) const
+{
+   ASSERT(size);
+   size_t remaining = buf_size;
+   if (show_frame) {
+      remaining -= snprintf(buf, buf_size, "(frame:%d size:%d ", frame, size);
+   } else {
+      remaining -= snprintf(buf, buf_size, "(size:%d ", size);
+   }
+
+   for (int i = 0; i < size * 8; i++) {
+      char buf2[16];
+      if (value(i)) {
+         int c = snprintf(buf2, ARRAY_SIZE(buf2), "%2d ", i);
+         strncat(buf, buf2, ARRAY_SIZE(buf2));
+         remaining -= c;
+      }
+   }
+   strcat(buf, ")");
+}
+
+void
+GameInput::log(char *prefix, bool show_frame) const
+{
+	char buf[1024];
+	size_t c = strlen(prefix);
+	strcpy(buf, prefix);
+	desc(buf + c, ARRAY_SIZE(buf) - c, show_frame);
+	Log("%s", buf);
+}
+
+bool
+GameInput::equal(GameInput &other, bool bitsonly)
+{
+   if (!bitsonly && frame != other.frame) {
+      Log("frames don't match: %d, %d", frame, other.frame);
+   }
+   if (size != other.size) {
+      Log("sizes don't match: %d, %d", size, other.size);
+   }
+   bool match = memcmp(bits, other.bits, size) == 0;
+   if (!match)
+      Log("bits don't match");
+   ASSERT(size && other.size);
+   return (bitsonly || frame == other.frame) &&
+          size == other.size && match;
+}
+

core/deps/ggpo/lib/ggpo/game_input.h

@@ -0,0 +1,40 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _GAMEINPUT_H
+#define _GAMEINPUT_H
+
+#include <stdio.h>
+#include <memory.h>
+
+// GAMEINPUT_MAX_BYTES * GAMEINPUT_MAX_PLAYERS * 8 must be less than
+// 2^BITVECTOR_NIBBLE_SIZE (see bitvector.h)
+
+#define GAMEINPUT_MAX_BYTES      9
+#define GAMEINPUT_MAX_PLAYERS    2
+
+struct GameInput {
+   enum Constants {
+      NullFrame = -1
+   };
+   int      frame;
+   int      size; /* size in bytes of the entire input for all players */
+   char     bits[GAMEINPUT_MAX_BYTES * GAMEINPUT_MAX_PLAYERS];
+
+   bool is_null() { return frame == NullFrame; }
+   void init(int frame, char *bits, int size, int offset);
+   void init(int frame, char *bits, int size);
+   bool value(int i) const { return (bits[i/8] & (1 << (i%8))) != 0; }
+   void set(int i) { bits[i/8] |= (1 << (i%8)); }
+   void clear(int i) { bits[i/8] &= ~(1 << (i%8)); }
+   void erase() { memset(bits, 0, sizeof(bits)); }
+   void desc(char *buf, size_t buf_size, bool show_frame = true) const;
+   void log(char *prefix, bool show_frame = true) const;
+   bool equal(GameInput &input, bool bitsonly = false);
+};
+
+#endif

core/deps/ggpo/lib/ggpo/ggpo_poll.h

@@ -0,0 +1,66 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _POLL_H
+#define _POLL_H
+
+#include "static_buffer.h"
+
+#define MAX_POLLABLE_HANDLES     64
+
+
+class IPollSink {
+public:
+   virtual ~IPollSink() { }
+   virtual bool OnHandlePoll(void *) { return true; }
+   virtual bool OnMsgPoll(void *) { return true; }
+   virtual bool OnPeriodicPoll(void *, int ) { return true; }
+   virtual bool OnLoopPoll(void *) { return true; }
+};
+
+class Poll {
+public:
+   Poll(void);
+//   void RegisterHandle(IPollSink *sink, HANDLE h, void *cookie = NULL);
+   void RegisterMsgLoop(IPollSink *sink, void *cookie = NULL);
+   void RegisterPeriodic(IPollSink *sink, int interval, void *cookie = NULL);
+   void RegisterLoop(IPollSink *sink, void *cookie = NULL);
+
+   void Run();
+   bool Pump(int timeout);
+
+protected:
+   int ComputeWaitTime(int elapsed);
+
+   struct PollSinkCb {
+      IPollSink   *sink;
+      void        *cookie;
+      PollSinkCb() : sink(NULL), cookie(NULL) { }
+      PollSinkCb(IPollSink *s, void *c) : sink(s), cookie(c) { }
+   };
+
+   struct PollPeriodicSinkCb : public PollSinkCb {
+      int         interval;
+      int         last_fired;
+      PollPeriodicSinkCb() : PollSinkCb(NULL, NULL), interval(0), last_fired(0) { }
+      PollPeriodicSinkCb(IPollSink *s, void *c, int i) :
+         PollSinkCb(s, c), interval(i), last_fired(0) { }
+   };
+
+   int               _start_time;
+   int               _handle_count;
+#ifdef _WIN32
+   HANDLE            _handles[MAX_POLLABLE_HANDLES];
+#endif
+   PollSinkCb        _handle_sinks[MAX_POLLABLE_HANDLES];
+
+   StaticBuffer<PollSinkCb, 16>          _msg_sinks;
+   StaticBuffer<PollSinkCb, 16>          _loop_sinks;
+   StaticBuffer<PollPeriodicSinkCb, 16>  _periodic_sinks;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/ggpo_types.h

@@ -0,0 +1,96 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _TYPES_H
+#define _TYPES_H
+/*
+ * Keep the compiler happy
+ */
+
+#ifdef _MSC_VER
+/*
+ * Disable specific compiler warnings
+ *   4018 - '<' : signed/unsigned mismatch
+ *   4100 - 'xxx' : unreferenced formal parameter
+ *   4127 - conditional expression is constant
+ *   4201 - nonstandard extension used : nameless struct/union
+ *   4389 - '!=' : signed/unsigned mismatch
+ *   4800 - 'int' : forcing value to bool 'true' or 'false' (performance warning)
+ */
+#pragma warning(disable: 4018 4100 4127 4201 4389 4800)
+#endif
+
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#define TARGET_UWP
+#endif
+
+/*
+ * Simple types
+ */
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint32;
+typedef unsigned char byte;
+typedef char int8;
+typedef short int16;
+typedef int int32;
+
+#include "ggponet.h"
+#include "log/Log.h"
+#include <stdexcept>
+
+class GGPOException : public std::runtime_error {
+public:
+	GGPOException(const char *what, GGPOErrorCode ggpoError)
+		: std::runtime_error(what), ggpoError(ggpoError) {}
+
+	GGPOErrorCode ggpoError;
+};
+
+/*
+ * Additional headers
+ */
+#if defined(_WIN32)
+#  include "platform_windows.h"
+#elif defined(__unix__) || defined(__APPLE__) || defined(__SWITCH__)
+#  include "platform_linux.h"
+#else
+#  error Unsupported platform
+#endif
+
+/*
+ * Macros
+ */
+#define ASSERT(x)                                           \
+   do {                                                     \
+      if (!(x)) {                                           \
+         char assert_buf[1024];                             \
+         snprintf(assert_buf, sizeof(assert_buf) - 1, "Assertion: %s @ %s:%d", #x, __FILE__, __LINE__); \
+         GGPOPlatform::AssertFailed(assert_buf);            \
+         throw GGPOException(assert_buf, GGPO_ERRORCODE_GENERAL_FAILURE); \
+      }                                                     \
+   } while (false)
+
+#define Log(...) DEBUG_LOG(NETWORK, __VA_ARGS__)
+
+#ifndef ARRAY_SIZE
+#  define ARRAY_SIZE(a)    (sizeof(a) / sizeof((a)[0]))
+#endif
+
+#ifndef MAX_INT
+#  define MAX_INT          0xEFFFFFF
+#endif
+
+#ifndef MAX
+#  define MAX(x, y)        (((x) > (y)) ? (x) : (y))
+#endif
+
+#ifndef MIN
+#  define MIN(x, y)        (((x) < (y)) ? (x) : (y))
+#endif
+
+#endif // _TYPES_H

core/deps/ggpo/lib/ggpo/input_queue.cpp

@@ -0,0 +1,305 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "input_queue.h"
+#include "ggpo_types.h"
+
+#define PREVIOUS_FRAME(offset)   (((offset) == 0) ? (INPUT_QUEUE_LENGTH - 1) : ((offset) - 1))
+
+InputQueue::InputQueue(int input_size)
+{
+   Init(-1, input_size);
+}
+
+InputQueue::~InputQueue()
+{
+}
+
+void
+InputQueue::Init(int id, int input_size)
+{
+   _id = id;
+   _head = 0;
+   _tail = 0;
+   _length = 0;
+   _frame_delay = 0;
+   _first_frame = true;
+   _last_user_added_frame = GameInput::NullFrame;
+   _first_incorrect_frame = GameInput::NullFrame;
+   _last_frame_requested = GameInput::NullFrame;
+   _last_added_frame = GameInput::NullFrame;
+
+   _prediction.init(GameInput::NullFrame, NULL, input_size);
+
+   /*
+    * This is safe because we know the GameInput is a proper structure (as in,
+    * no virtual methods, no contained classes, etc.).
+    */
+   memset(_inputs, 0, sizeof _inputs);
+   for (size_t i = 0; i < ARRAY_SIZE(_inputs); i++) {
+      _inputs[i].size = input_size;
+   }
+}
+
+int
+InputQueue::GetLastConfirmedFrame()
+{
+   Log("input q%d | returning last confirmed frame %d.", _id, _last_added_frame);
+   return _last_added_frame;
+}
+
+int
+InputQueue::GetFirstIncorrectFrame()
+{
+   return _first_incorrect_frame;
+}
+
+void
+InputQueue::DiscardConfirmedFrames(int frame)
+{
+   ASSERT(frame >= 0);
+
+   if (_last_frame_requested != GameInput::NullFrame) {
+      frame = MIN(frame, _last_frame_requested);
+   }
+
+   Log("input q%d | discarding confirmed frames up to %d (last_added:%d length:%d [head:%d tail:%d]).", _id,
+       frame, _last_added_frame, _length, _head, _tail);
+   if (frame >= _last_added_frame) {
+      _tail = _head;
+   } else {
+      int offset = frame - _inputs[_tail].frame + 1;
+      
+      Log("input q%d | difference of %d frames.", _id, offset);
+      ASSERT(offset >= 0);
+
+      _tail = (_tail + offset) % INPUT_QUEUE_LENGTH;
+      _length -= offset;
+   }
+
+   Log("input q%d | after discarding, new tail is %d (frame:%d).", _id, _tail, _inputs[_tail].frame);
+   ASSERT(_length >= 0);
+}
+
+void
+InputQueue::ResetPrediction(int frame)
+{
+   ASSERT(_first_incorrect_frame == GameInput::NullFrame || frame <= _first_incorrect_frame);
+
+   Log("input q%d | resetting all prediction errors back to frame %d.", _id, frame);
+
+   /*
+    * There's nothing really to do other than reset our prediction
+    * state and the incorrect frame counter...
+    */
+   _prediction.frame = GameInput::NullFrame;
+   _first_incorrect_frame = GameInput::NullFrame;
+   _last_frame_requested = GameInput::NullFrame;
+}
+
+bool
+InputQueue::GetConfirmedInput(int requested_frame, GameInput *input)
+{
+   ASSERT(_first_incorrect_frame == GameInput::NullFrame || requested_frame < _first_incorrect_frame);
+   int offset = requested_frame % INPUT_QUEUE_LENGTH; 
+   if (_inputs[offset].frame != requested_frame) {
+      return false;
+   }
+   *input = _inputs[offset];
+   return true;
+}
+
+bool
+InputQueue::GetInput(int requested_frame, GameInput *input)
+{
+   Log("input q%d | requesting input frame %d.", _id, requested_frame);
+
+   /*
+    * No one should ever try to grab any input when we have a prediction
+    * error.  Doing so means that we're just going further down the wrong
+    * path.  ASSERT this to verify that it's true.
+    */
+   ASSERT(_first_incorrect_frame == GameInput::NullFrame);
+
+   /*
+    * Remember the last requested frame number for later.  We'll need
+    * this in AddInput() to drop out of prediction mode.
+    */
+   _last_frame_requested = requested_frame;
+
+   ASSERT(requested_frame >= _inputs[_tail].frame);
+
+   if (_prediction.frame == GameInput::NullFrame) {
+      /*
+       * If the frame requested is in our range, fetch it out of the queue and
+       * return it.
+       */
+      int offset = requested_frame - _inputs[_tail].frame;
+
+      if (offset < _length) {
+         offset = (offset + _tail) % INPUT_QUEUE_LENGTH;
+         ASSERT(_inputs[offset].frame == requested_frame);
+         *input = _inputs[offset];
+         Log("input q%d | returning confirmed frame number %d.", _id, input->frame);
+         return true;
+      }
+
+      /*
+       * The requested frame isn't in the queue.  Bummer.  This means we need
+       * to return a prediction frame.  Predict that the user will do the
+       * same thing they did last time.
+       */
+      if (requested_frame == 0) {
+         Log("input q%d | basing new prediction frame from nothing, you're client wants frame 0.", _id);
+         _prediction.erase();
+      } else if (_last_added_frame == GameInput::NullFrame) {
+         Log("input q%d | basing new prediction frame from nothing, since we have no frames yet.", _id);
+         _prediction.erase();
+      } else {
+         Log("input q%d | basing new prediction frame from previously added frame (queue entry:%d, frame:%d).", _id,
+              PREVIOUS_FRAME(_head), _inputs[PREVIOUS_FRAME(_head)].frame);
+         _prediction = _inputs[PREVIOUS_FRAME(_head)];
+      }
+      _prediction.frame++;
+   }
+
+   ASSERT(_prediction.frame >= 0);
+
+   /*
+    * If we've made it this far, we must be predicting.  Go ahead and
+    * forward the prediction frame contents.  Be sure to return the
+    * frame number requested by the client, though.
+    */
+   *input = _prediction;
+   input->frame = requested_frame;
+   Log("input q%d | returning prediction frame number %d (%d).", _id, input->frame, _prediction.frame);
+
+   return false;
+}
+
+void
+InputQueue::AddInput(GameInput &input)
+{
+   int new_frame;
+
+   Log("input q%d | adding input frame number %d to queue.", _id, input.frame);
+
+   /*
+    * These next two lines simply verify that inputs are passed in 
+    * sequentially by the user, regardless of frame delay.
+    */
+   ASSERT(_last_user_added_frame == GameInput::NullFrame ||
+          input.frame == _last_user_added_frame + 1);
+   _last_user_added_frame = input.frame;
+
+   /*
+    * Move the queue head to the correct point in preparation to
+    * input the frame into the queue.
+    */
+   new_frame = AdvanceQueueHead(input.frame);
+   if (new_frame != GameInput::NullFrame) {
+      AddDelayedInputToQueue(input, new_frame);
+   }
+   
+   /*
+    * Update the frame number for the input.  This will also set the
+    * frame to GameInput::NullFrame for frames that get dropped (by
+    * design).
+    */
+   input.frame = new_frame;
+}
+
+void
+InputQueue::AddDelayedInputToQueue(GameInput &input, int frame_number)
+{
+   Log("input q%d | adding delayed input frame number %d to queue.", _id, frame_number);
+
+   if (input.size != _prediction.size)
+	   throw GGPOException("Input size differs from peer", GGPO_ERRORCODE_INPUT_SIZE_DIFF);
+
+   ASSERT(_last_added_frame == GameInput::NullFrame || frame_number == _last_added_frame + 1);
+
+   ASSERT(frame_number == 0 || _inputs[PREVIOUS_FRAME(_head)].frame == frame_number - 1);
+
+   /*
+    * Add the frame to the back of the queue
+    */ 
+   _inputs[_head] = input;
+   _inputs[_head].frame = frame_number;
+   _head = (_head + 1) % INPUT_QUEUE_LENGTH;
+   _length++;
+   _first_frame = false;
+
+   _last_added_frame = frame_number;
+
+   if (_prediction.frame != GameInput::NullFrame) {
+      ASSERT(frame_number == _prediction.frame);
+
+      /*
+       * We've been predicting...  See if the inputs we've gotten match
+       * what we've been predicting.  If so, don't worry about it.  If not,
+       * remember the first input which was incorrect so we can report it
+       * in GetFirstIncorrectFrame()
+       */
+      if (_first_incorrect_frame == GameInput::NullFrame && !_prediction.equal(input, true)) {
+         Log("input q%d | frame %d does not match prediction.  marking error.", _id, frame_number);
+         _first_incorrect_frame = frame_number;
+      }
+
+      /*
+       * If this input is the same frame as the last one requested and we
+       * still haven't found any mis-predicted inputs, we can dump out
+       * of predition mode entirely!  Otherwise, advance the prediction frame
+       * count up.
+       */
+      if (_prediction.frame == _last_frame_requested && _first_incorrect_frame == GameInput::NullFrame) {
+         Log("input q%d | prediction is correct!  dumping out of prediction mode.", _id);
+         _prediction.frame = GameInput::NullFrame;
+      } else {
+         _prediction.frame++;
+      }
+   }
+   ASSERT(_length <= INPUT_QUEUE_LENGTH);
+}
+
+int
+InputQueue::AdvanceQueueHead(int frame)
+{
+   Log("input q%d | advancing queue head to frame %d.", _id, frame);
+
+   int expected_frame = _first_frame ? 0 : _inputs[PREVIOUS_FRAME(_head)].frame + 1;
+
+   frame += _frame_delay;
+
+   if (expected_frame > frame) {
+      /*
+       * This can occur when the frame delay has dropped since the last
+       * time we shoved a frame into the system.  In this case, there's
+       * no room on the queue.  Toss it.
+       */
+      Log("input q%d | Dropping input frame %d (expected next frame to be %d).", _id,
+          frame, expected_frame);
+      return GameInput::NullFrame;
+   }
+
+   while (expected_frame < frame) {
+      /*
+       * This can occur when the frame delay has been increased since the last
+       * time we shoved a frame into the system.  We need to replicate the
+       * last frame in the queue several times in order to fill the space
+       * left.
+       */
+      Log("input q%d | Adding padding frame %d to account for change in frame delay.", _id,
+          expected_frame);
+      GameInput &last_frame = _inputs[PREVIOUS_FRAME(_head)];     
+      AddDelayedInputToQueue(last_frame, expected_frame);
+      expected_frame++;
+   }
+
+   ASSERT(frame == 0 || frame == _inputs[PREVIOUS_FRAME(_head)].frame + 1);
+   return frame;
+}

core/deps/ggpo/lib/ggpo/input_queue.h

@@ -0,0 +1,59 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _INPUT_QUEUE_H
+#define _INPUT_QUEUE_H
+
+#include "game_input.h"
+
+#define INPUT_QUEUE_LENGTH    128
+#define DEFAULT_INPUT_SIZE      4
+
+class InputQueue {
+public:
+   InputQueue(int input_size = DEFAULT_INPUT_SIZE);
+   ~InputQueue();
+
+public:
+   void Init(int id, int input_size);
+   int GetLastConfirmedFrame();
+   int GetFirstIncorrectFrame();
+   int GetLength() { return _length; }
+
+   void SetFrameDelay(int delay) { _frame_delay = delay; }
+   void ResetPrediction(int frame);
+   void DiscardConfirmedFrames(int frame);
+   bool GetConfirmedInput(int frame, GameInput *input);
+   bool GetInput(int frame, GameInput *input);
+   void AddInput(GameInput &input);
+
+protected:
+   int AdvanceQueueHead(int frame);
+   void AddDelayedInputToQueue(GameInput &input, int i);
+
+protected:
+   int                  _id;
+   int                  _head;
+   int                  _tail;
+   int                  _length;
+   bool                 _first_frame;
+
+   int                  _last_user_added_frame;
+   int                  _last_added_frame;
+   int                  _first_incorrect_frame;
+   int                  _last_frame_requested;
+
+   int                  _frame_delay;
+
+   GameInput            _inputs[INPUT_QUEUE_LENGTH];
+   GameInput            _prediction;
+};
+
+#endif
+
+
+

core/deps/ggpo/lib/ggpo/main.cpp

@@ -0,0 +1,260 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "backends/p2p.h"
+#include "backends/synctest.h"
+#include "backends/spectator.h"
+#include "ggpo_types.h"
+#include "ggponet.h"
+
+struct Init
+{
+	Init() {
+		srand(GGPOPlatform::GetCurrentTimeMS() + GGPOPlatform::GetProcessID());
+#ifdef _WIN32
+		WSADATA wsaData;
+		WSAStartup(MAKEWORD(2, 0), &wsaData);
+#endif
+	}
+};
+static Init init;
+
+GGPOErrorCode
+ggpo_start_session(GGPOSession **session,
+                   GGPOSessionCallbacks *cb,
+                   const char *game,
+                   int num_players,
+                   int input_size,
+                   unsigned short localport,
+				   const void *verification,
+				   int verification_size)
+{
+	try {
+	   *session= (GGPOSession *)new Peer2PeerBackend(cb,
+													 game,
+													 localport,
+													 num_players,
+													 input_size,
+													 verification,
+													 verification_size);
+	   return GGPO_OK;
+	} catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_session: %s", e.what());
+	   return e.ggpoError;
+	}
+}
+
+GGPOErrorCode
+ggpo_add_player(GGPOSession *ggpo,
+                GGPOPlayer *player,
+                GGPOPlayerHandle *handle)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->AddPlayer(player, handle);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_add_player: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+
+
+GGPOErrorCode
+ggpo_start_synctest(GGPOSession **ggpo,
+                    GGPOSessionCallbacks *cb,
+                    const char *game,
+                    int num_players,
+                    int input_size,
+                    int frames)
+{
+	try {
+	   *ggpo = (GGPOSession *)new SyncTestBackend(cb, game, frames, num_players);
+	   return GGPO_OK;
+	} catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_synctest: %s", e.what());
+	   return e.ggpoError;
+	}
+}
+
+GGPOErrorCode
+ggpo_set_frame_delay(GGPOSession *ggpo,
+                     GGPOPlayerHandle player,
+                     int frame_delay)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->SetFrameDelay(player, frame_delay);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_frame_delay: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_idle(GGPOSession *ggpo, int timeout)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->DoPoll(timeout);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_idle: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_add_local_input(GGPOSession *ggpo,
+                     GGPOPlayerHandle player,
+                     void *values,
+                     int size)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+      return ggpo->AddLocalInput(player, values, size);
+   } catch (const GGPOException& e) {
+	  ERROR_LOG(NETWORK, "GGPOException in ggpo_add_local_input: %s", e.what());
+      return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_synchronize_input(GGPOSession *ggpo,
+                       void *values,
+                       int size,
+                       int *disconnect_flags)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+      return ggpo->SyncInput(values, size, disconnect_flags);
+   } catch (const GGPOException& e) {
+	  ERROR_LOG(NETWORK, "GGPOException in ggpo_synchronize_input: %s", e.what());
+      return e.ggpoError;
+   }
+}
+
+GGPOErrorCode ggpo_disconnect_player(GGPOSession *ggpo,
+                                     GGPOPlayerHandle player)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->DisconnectPlayer(player);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_disconnect_player: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_advance_frame(GGPOSession *ggpo)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->IncrementFrame();
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_advance_frame: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_get_network_stats(GGPOSession *ggpo,
+                       GGPOPlayerHandle player,
+                       GGPONetworkStats *stats)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->GetNetworkStats(stats, player);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_get_network_stats: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+
+GGPOErrorCode
+ggpo_close_session(GGPOSession *ggpo)
+{
+   if (!ggpo) {
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   }
+   delete ggpo;
+   return GGPO_OK;
+}
+
+GGPOErrorCode
+ggpo_set_disconnect_timeout(GGPOSession *ggpo, int timeout)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->SetDisconnectTimeout(timeout);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_disconnect_timeout: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode
+ggpo_set_disconnect_notify_start(GGPOSession *ggpo, int timeout)
+{
+   if (!ggpo)
+      return GGPO_ERRORCODE_INVALID_SESSION;
+   try {
+	   return ggpo->SetDisconnectNotifyStart(timeout);
+   } catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_set_disconnect_notify_start: %s", e.what());
+	   return e.ggpoError;
+   }
+}
+
+GGPOErrorCode ggpo_start_spectating(GGPOSession **session,
+                                    GGPOSessionCallbacks *cb,
+                                    const char *game,
+                                    int num_players,
+                                    int input_size,
+                                    unsigned short local_port,
+                                    char *host_ip,
+                                    unsigned short host_port,
+									const void *verification,
+									int verification_size)
+{
+	try {
+	   *session= (GGPOSession *)new SpectatorBackend(cb,
+													 game,
+													 local_port,
+													 num_players,
+													 input_size,
+													 host_ip,
+													 host_port,
+													 verification,
+													 verification_size);
+	   return GGPO_OK;
+	} catch (const GGPOException& e) {
+	   ERROR_LOG(NETWORK, "GGPOException in ggpo_start_spectating: %s", e.what());
+	   return e.ggpoError;
+	}
+}
+
+GGPOErrorCode ggpo_send_message(GGPOSession *ggpo,
+                                const void *msg,
+                                int len,
+								bool spectators)
+{
+	if (ggpo == nullptr)
+		return GGPO_ERRORCODE_INVALID_SESSION;
+	return ggpo->SendMessage(msg, len, spectators);
+}
+

core/deps/ggpo/lib/ggpo/network/udp.cpp

@@ -0,0 +1,113 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "ggpo_types.h"
+#include "udp.h"
+
+SOCKET
+CreateSocket(uint16 bind_port, int retries)
+{
+   SOCKET s;
+   sockaddr_in sin;
+   uint16 port;
+   int optval = 1;
+
+   s = socket(AF_INET, SOCK_DGRAM, 0);
+   setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (const char *)&optval, sizeof optval);
+   optval = 0;
+   setsockopt(s, SOL_SOCKET, SO_LINGER, (const char *)&optval, sizeof optval);
+
+   // non-blocking...
+#ifndef _WIN32
+	fcntl(s, F_SETFL, O_NONBLOCK);
+#else
+	u_long iMode = 1;
+	ioctlsocket(s, FIONBIO, &iMode);
+#endif
+
+   sin.sin_family = AF_INET;
+   sin.sin_addr.s_addr = htonl(INADDR_ANY);
+   for (port = bind_port; port <= bind_port + retries; port++) {
+      sin.sin_port = htons(port);
+      if (bind(s, (sockaddr *)&sin, sizeof sin) == 0) {
+         Log("Udp bound to port: %d.", port);
+         return s;
+      }
+   }
+   closesocket(s);
+   return INVALID_SOCKET;
+}
+
+Udp::Udp() :
+   _socket(INVALID_SOCKET),
+   _callbacks(NULL)
+{
+}
+
+Udp::~Udp(void)
+{
+   if (_socket != INVALID_SOCKET) {
+      closesocket(_socket);
+      _socket = INVALID_SOCKET;
+   }
+}
+
+void
+Udp::Init(uint16 port, Poll *poll, Callbacks *callbacks)
+{
+   _callbacks = callbacks;
+   poll->RegisterLoop(this);
+
+   Log("binding udp socket to port %d.", port);
+   _socket = CreateSocket(port, 0);
+   if (_socket == INVALID_SOCKET)
+	   throw GGPOException("Socket creation or bind failed", GGPO_ERRORCODE_NETWORK_ERROR);
+}
+
+void
+Udp::SendTo(char *buffer, int len, int flags, struct sockaddr *dst, int destlen)
+{
+   struct sockaddr_in *to = (struct sockaddr_in *)dst;
+
+   int res = sendto(_socket, buffer, len, flags, dst, destlen);
+   if (res == SOCKET_ERROR) {
+	  int err = WSAGetLastError();
+      Log("unknown error in sendto (erro: %d  wsaerr: %d).", res, err);
+      ASSERT(false && "Unknown error in sendto");
+   }
+   char dst_ip[1024];
+   Log("sent packet length %d to %s:%d (ret:%d).", len, inet_ntop(AF_INET, (void *)&to->sin_addr, dst_ip, ARRAY_SIZE(dst_ip)), ntohs(to->sin_port), res);
+}
+
+bool
+Udp::OnLoopPoll(void *cookie)
+{
+   uint8          recv_buf[MAX_UDP_PACKET_SIZE];
+   sockaddr_in    recv_addr;
+   socklen_t      recv_addr_len;
+
+   for (;;) {
+      recv_addr_len = sizeof(recv_addr);
+      int len = recvfrom(_socket, (char *)recv_buf, MAX_UDP_PACKET_SIZE, 0, (struct sockaddr *)&recv_addr, &recv_addr_len);
+
+      // TODO: handle len == 0... indicates a disconnect.
+
+      if (len == -1) {
+         int error = WSAGetLastError();
+         if (error != WSAEWOULDBLOCK) {
+            Log("recvfrom WSAGetLastError returned %d (%x).", error, error);
+         }
+         break;
+      } else if (len > 0) {
+         char src_ip[1024];
+         Log("recvfrom returned (len:%d  from:%s:%d).", len, inet_ntop(AF_INET, (void*)&recv_addr.sin_addr, src_ip, ARRAY_SIZE(src_ip)), ntohs(recv_addr.sin_port) );
+         UdpMsg *msg = (UdpMsg *)recv_buf;
+         _callbacks->OnMsg(recv_addr, msg, len);
+      } 
+   }
+   return true;
+}

core/deps/ggpo/lib/ggpo/network/udp.h

@@ -0,0 +1,53 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _UDP_H
+#define _UDP_H
+
+#include "ggpo_poll.h"
+#include "udp_msg.h"
+#include "ggponet.h"
+#include "ring_buffer.h"
+
+#define MAX_UDP_ENDPOINTS     16
+
+constexpr size_t MAX_UDP_PACKET_SIZE = sizeof(UdpMsg);
+
+class Udp : public IPollSink
+{
+public:
+   struct Stats {
+      int      bytes_sent;
+      int      packets_sent;
+      float    kbps_sent;
+   };
+
+   struct Callbacks {
+      virtual ~Callbacks() { }
+      virtual void OnMsg(sockaddr_in &from, UdpMsg *msg, int len) = 0;
+   };
+
+   Udp();
+
+   void Init(uint16 port, Poll *p, Callbacks *callbacks);
+   
+   void SendTo(char *buffer, int len, int flags, struct sockaddr *dst, int destlen);
+
+   virtual bool OnLoopPoll(void *cookie);
+
+public:
+   ~Udp(void);
+
+protected:
+   // Network transmission information
+   SOCKET         _socket;
+
+   // state management
+   Callbacks      *_callbacks;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/network/udp_msg.h

@@ -0,0 +1,121 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _UDP_MSG_H
+#define _UDP_MSG_H
+
+#define MAX_COMPRESSED_BITS       4096
+#define UDP_MSG_MAX_PLAYERS          4
+#define MAX_VERIFICATION_SIZE      256
+#define MAX_APPDATA_SIZE           512
+
+#pragma pack(push, 1)
+
+struct UdpMsg
+{
+   enum MsgType {
+      Invalid       = 0,
+      SyncRequest   = 1,
+      SyncReply     = 2,
+      Input         = 3,
+      QualityReport = 4,
+      QualityReply  = 5,
+      KeepAlive     = 6,
+      InputAck      = 7,
+	  AppData       = 8
+   };
+
+   struct connect_status {
+      unsigned int   disconnected:1;
+      int            last_frame:31;
+   };
+
+   struct {
+      uint16         magic;
+      uint16         sequence_number;
+      uint8          type;            /* packet type */
+   } hdr;
+   union {
+      struct {
+         uint32      random_request;  /* please reply back with this random data */
+         uint16      remote_magic;
+         uint8       remote_endpoint;
+         uint8       verification[MAX_VERIFICATION_SIZE];
+      } sync_request;
+      
+      struct {
+         uint32      random_reply;    /* OK, here's your random data back */
+         uint8       verification_failure; /* set to one by peer if verification failed */
+      } sync_reply;
+      
+      struct {
+         int8        frame_advantage; /* what's the other guy's frame advantage? */
+         uint32      ping;
+      } quality_report;
+      
+      struct {
+         uint32      pong;
+      } quality_reply;
+
+      struct {
+         connect_status    peer_connect_status[UDP_MSG_MAX_PLAYERS];
+
+         uint32            start_frame;
+
+         int               disconnect_requested:1;
+         int               ack_frame:31;
+
+         uint16            num_bits;
+         uint8             input_size; // XXX: shouldn't be in every single packet!
+         uint8             bits[MAX_COMPRESSED_BITS / 8]; /* must be last */
+      } input;
+
+      struct {
+         int               ack_frame:31;
+      } input_ack;
+
+      struct {
+    	  uint16 size;
+    	  uint8 spectators;
+    	  uint8 data[MAX_APPDATA_SIZE];
+      } app_data;
+
+   } u;
+
+   int verification_size = 0;
+
+public:
+   int PacketSize() {
+      return sizeof(hdr) + PayloadSize();
+   }
+
+   int PayloadSize() {
+      switch (hdr.type) {
+      case SyncRequest:   return (int)(&u.sync_request.verification[0] - (uint8 *)&u) + verification_size;
+      case SyncReply:     return sizeof(u.sync_reply);
+      case QualityReport: return sizeof(u.quality_report);
+      case QualityReply:  return sizeof(u.quality_reply);
+      case InputAck:      return sizeof(u.input_ack);
+      case KeepAlive:     return 0;
+      case Input:
+		  {
+			 int size = (int)((char *)&u.input.bits - (char *)&u.input);
+			 size += (u.input.num_bits + 7) / 8;
+			 return size;
+		  }
+      case AppData:       return sizeof(u.app_data) - sizeof(u.app_data.data) + u.app_data.size;
+      }
+      ASSERT(false);
+      return 0;
+   }
+
+   UdpMsg(MsgType t) { hdr.type = (uint8)t; }
+};
+
+#pragma pack(pop)
+
+#endif   

core/deps/ggpo/lib/ggpo/network/udp_proto.cpp

@@ -0,0 +1,815 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "udp_proto.h"
+
+#include "../ggpo_types.h"
+#include "bitvector.h"
+
+static const int UDP_HEADER_SIZE = 28;     /* Size of IP + UDP headers */
+static const int NUM_SYNC_PACKETS = 5;
+static const int SYNC_RETRY_INTERVAL = 2000;
+static const int SYNC_FIRST_RETRY_INTERVAL = 500;
+static const int RUNNING_RETRY_INTERVAL = 200;
+static const int KEEP_ALIVE_INTERVAL    = 200;
+static const int QUALITY_REPORT_INTERVAL = 1000;
+static const int NETWORK_STATS_INTERVAL  = 1000;
+static const int UDP_SHUTDOWN_TIMER = 5000;
+static const int MAX_SEQ_DISTANCE = (1 << 15);
+
+UdpProtocol::UdpProtocol() :
+   _udp(NULL),
+   _magic_number(0),
+   _queue(-1),
+   _remote_magic_number(0),
+   _connected(false),
+   _packets_sent(0),
+   _bytes_sent(0),
+   _stats_start_time(0),
+   _local_frame_advantage(0),
+   _remote_frame_advantage(0),
+   _last_send_time(0),
+   _shutdown_timeout(0),
+   _disconnect_event_sent(false),
+   _disconnect_timeout(0),
+   _disconnect_notify_start(0),
+   _disconnect_notify_sent(false),
+   _next_send_seq(0),
+   _next_recv_seq(0)
+{
+   _last_sent_input.init(-1, NULL, 1);
+   _last_received_input.init(-1, NULL, 1);
+   _last_acked_input.init(-1, NULL, 1);
+
+   memset(&_state, 0, sizeof _state);
+   memset(_peer_connect_status, 0, sizeof(_peer_connect_status));
+   for (unsigned i = 0; i < ARRAY_SIZE(_peer_connect_status); i++) {
+      _peer_connect_status[i].last_frame = -1;
+   }
+   memset(&_peer_addr, 0, sizeof _peer_addr);
+   _oo_packet.msg = NULL;
+
+   _send_latency = GGPOPlatform::GetConfigInt("GGPO_NETWORK_DELAY");
+   _oop_percent = GGPOPlatform::GetConfigInt("GGPO_OOP_PERCENT");
+}
+
+UdpProtocol::~UdpProtocol()
+{
+   ClearSendQueue();
+}
+
+void
+UdpProtocol::Init(Udp *udp,
+                  Poll &poll,
+                  int queue,
+                  char *ip,
+                  u_short port,
+                  UdpMsg::connect_status *status)
+{  
+   _udp = udp;
+   _queue = queue;
+   _local_connect_status = status;
+
+   _peer_addr.sin_family = AF_INET;
+   if (ip != nullptr && ip[0] != '\0')
+   {
+	   _peer_addr.sin_port = htons(port);
+	   inet_pton(AF_INET, ip, &_peer_addr.sin_addr.s_addr);
+   }
+
+   do {
+      _magic_number = (uint16)rand();
+   } while (_magic_number == 0);
+   poll.RegisterLoop(this);
+}
+
+void
+UdpProtocol::SendInput(GameInput &input)
+{
+   if (_udp) {
+      if (_current_state == Running) {
+         /*
+          * Check to see if this is a good time to adjust for the rift...
+          */
+         _timesync.advance_frame(input, _local_frame_advantage, _remote_frame_advantage);
+
+         /*
+          * Save this input packet
+          *
+          * XXX: This queue may fill up for spectators who do not ack input packets in a timely
+          * manner.  When this happens, we can either resize the queue (ug) or disconnect them
+          * (better, but still ug).  For the meantime, make this queue really big to decrease
+          * the odds of this happening...
+          */
+         _pending_output.push(input);
+      }
+      SendPendingOutput();
+   }  
+}
+
+void
+UdpProtocol::SendPendingOutput()
+{
+   UdpMsg *msg = new UdpMsg(UdpMsg::Input);
+   int i, j, offset = 0;
+   uint8 *bits;
+   GameInput last;
+
+   if (_pending_output.size()) {
+      last = _last_acked_input;
+      bits = msg->u.input.bits;
+
+      msg->u.input.start_frame = _pending_output.front().frame;
+      msg->u.input.input_size = (uint8)_pending_output.front().size;
+
+      ASSERT(last.frame == -1 || last.frame + 1 == (int)msg->u.input.start_frame);
+      for (j = 0; j < _pending_output.size(); j++) {
+         GameInput &current = _pending_output.item(j);
+         if (memcmp(current.bits, last.bits, current.size) != 0) {
+            ASSERT((GAMEINPUT_MAX_BYTES * GAMEINPUT_MAX_PLAYERS * 8) < (1 << BITVECTOR_NIBBLE_SIZE));
+            for (i = 0; i < current.size * 8; i++) {
+               ASSERT(i < (1 << BITVECTOR_NIBBLE_SIZE));
+               if (current.value(i) != last.value(i)) {
+                  BitVector_SetBit(msg->u.input.bits, &offset);
+                  (current.value(i) ? BitVector_SetBit : BitVector_ClearBit)(bits, &offset);
+                  BitVector_WriteNibblet(bits, i, &offset);
+               }
+            }
+         }
+         BitVector_ClearBit(msg->u.input.bits, &offset);
+         last = _last_sent_input = current;
+      }
+   } else {
+      msg->u.input.start_frame = 0;
+      msg->u.input.input_size = 0;
+   }
+   msg->u.input.ack_frame = _last_received_input.frame;
+   msg->u.input.num_bits = (uint16)offset;
+
+   msg->u.input.disconnect_requested = _current_state == Disconnected;
+   if (_local_connect_status) {
+      memcpy(msg->u.input.peer_connect_status, _local_connect_status, sizeof(UdpMsg::connect_status) * UDP_MSG_MAX_PLAYERS);
+   } else {
+      memset(msg->u.input.peer_connect_status, 0, sizeof(UdpMsg::connect_status) * UDP_MSG_MAX_PLAYERS);
+   }
+
+   ASSERT(offset < MAX_COMPRESSED_BITS);
+
+   SendMsg(msg);
+}
+
+void
+UdpProtocol::SendInputAck()
+{
+   UdpMsg *msg = new UdpMsg(UdpMsg::InputAck);
+   msg->u.input_ack.ack_frame = _last_received_input.frame;
+   SendMsg(msg);
+}
+
+bool
+UdpProtocol::GetEvent(UdpProtocol::Event &e)
+{
+   if (_event_queue.size() == 0) {
+      return false;
+   }
+   e = _event_queue.front();
+   _event_queue.pop();
+   return true;
+}
+
+
+bool
+UdpProtocol::OnLoopPoll(void *cookie)
+{
+   if (!_udp) {
+      return true;
+   }
+
+   unsigned int now = GGPOPlatform::GetCurrentTimeMS();
+   unsigned int next_interval;
+
+   PumpSendQueue();
+   switch (_current_state) {
+   case Syncing:
+      next_interval = (_state.sync.roundtrips_remaining == NUM_SYNC_PACKETS) ? SYNC_FIRST_RETRY_INTERVAL : SYNC_RETRY_INTERVAL;
+      if (_last_send_time && _last_send_time + next_interval < now && _peer_addr.sin_addr.s_addr != 0) {
+         Log("udpproto%d | No luck syncing after %d ms... Re-queueing sync packet.", _queue, next_interval);
+         SendSyncRequest();
+      }
+      break;
+
+   case Running:
+      // xxx: rig all this up with a timer wrapper
+      if (!_state.running.last_input_packet_recv_time || _state.running.last_input_packet_recv_time + RUNNING_RETRY_INTERVAL < now) {
+         Log("udpproto%d | Haven't exchanged packets in a while (last received:%d  last sent:%d).  Resending.", _queue, _last_received_input.frame, _last_sent_input.frame);
+         SendPendingOutput();
+         _state.running.last_input_packet_recv_time = now;
+      }
+
+      if (!_state.running.last_quality_report_time || _state.running.last_quality_report_time + QUALITY_REPORT_INTERVAL < now) {
+         UdpMsg *msg = new UdpMsg(UdpMsg::QualityReport);
+         msg->u.quality_report.ping = GGPOPlatform::GetCurrentTimeMS();
+         msg->u.quality_report.frame_advantage = (uint8)_local_frame_advantage;
+         SendMsg(msg);
+         _state.running.last_quality_report_time = now;
+      }
+
+      if (!_state.running.last_network_stats_interval || _state.running.last_network_stats_interval + NETWORK_STATS_INTERVAL < now) {
+         UpdateNetworkStats();
+         _state.running.last_network_stats_interval =  now;
+      }
+
+      if (_last_send_time && _last_send_time + KEEP_ALIVE_INTERVAL < now) {
+         Log("udpproto%d | Sending keep alive packet", _queue);
+         SendMsg(new UdpMsg(UdpMsg::KeepAlive));
+      }
+
+      if (_disconnect_timeout && _disconnect_notify_start && 
+         !_disconnect_notify_sent && (_last_recv_time + _disconnect_notify_start < now)) {
+         Log("udpproto%d | Endpoint has stopped receiving packets for %d ms.  Sending notification.", _queue, _disconnect_notify_start);
+         Event e(Event::NetworkInterrupted);
+         e.u.network_interrupted.disconnect_timeout = _disconnect_timeout - _disconnect_notify_start;
+         QueueEvent(e);
+         _disconnect_notify_sent = true;
+      }
+
+      if (_disconnect_timeout && (_last_recv_time + _disconnect_timeout < now)) {
+         if (!_disconnect_event_sent) {
+            Log("udpproto%d | Endpoint has stopped receiving packets for %d ms.  Disconnecting.", _queue, _disconnect_timeout);
+            QueueEvent(Event(Event::Disconnected));
+            _disconnect_event_sent = true;
+         }
+      }
+      break;
+
+   case Disconnected:
+      if (_shutdown_timeout < now) {
+         Log("udpproto%d | Shutting down udp connection.", _queue);
+         _udp = NULL;
+         _shutdown_timeout = 0;
+      }
+      break;
+
+   default:
+	  break;
+   }
+
+
+   return true;
+}
+
+void
+UdpProtocol::Disconnect()
+{
+   _current_state = Disconnected;
+   _shutdown_timeout = GGPOPlatform::GetCurrentTimeMS() + UDP_SHUTDOWN_TIMER;
+}
+
+void
+UdpProtocol::SendSyncRequest()
+{
+   _state.sync.random = rand() & 0xFFFF;
+   UdpMsg *msg = new UdpMsg(UdpMsg::SyncRequest);
+   msg->u.sync_request.random_request = _state.sync.random;
+   msg->verification_size = verification.size();
+   if (!verification.empty())
+	   memcpy(&msg->u.sync_request.verification[0], &verification[0], verification.size());
+   SendMsg(msg);
+}
+
+void
+UdpProtocol::SendMsg(UdpMsg *msg)
+{
+   LogMsg("send", msg);
+
+   {
+	   std::lock_guard<std::mutex> lock(_send_mutex);
+	   _packets_sent++;
+	   _last_send_time = GGPOPlatform::GetCurrentTimeMS();
+	   _bytes_sent += msg->PacketSize();
+
+	   msg->hdr.magic = _magic_number;
+	   msg->hdr.sequence_number = _next_send_seq++;
+
+	   _send_queue.push(QueueEntry(GGPOPlatform::GetCurrentTimeMS(), _peer_addr, msg));
+   }
+   PumpSendQueue();
+}
+
+bool
+UdpProtocol::HandlesMsg(sockaddr_in &from,
+                        UdpMsg *msg)
+{
+   if (!_udp) {
+      return false;
+   }
+   if (_peer_addr.sin_addr.s_addr == 0)
+   {
+	   _peer_addr.sin_addr.s_addr = from.sin_addr.s_addr;
+	   _peer_addr.sin_port = from.sin_port;
+	   return true;
+   }
+   return _peer_addr.sin_addr.s_addr == from.sin_addr.s_addr &&
+          _peer_addr.sin_port == from.sin_port;
+}
+
+void
+UdpProtocol::OnMsg(UdpMsg *msg, int len)
+{
+   bool handled = false;
+   typedef bool (UdpProtocol::*DispatchFn)(UdpMsg *msg, int len);
+   static const DispatchFn table[] = {
+      &UdpProtocol::OnInvalid,             /* Invalid */
+      &UdpProtocol::OnSyncRequest,         /* SyncRequest */
+      &UdpProtocol::OnSyncReply,           /* SyncReply */
+      &UdpProtocol::OnInput,               /* Input */
+      &UdpProtocol::OnQualityReport,       /* QualityReport */
+      &UdpProtocol::OnQualityReply,        /* QualityReply */
+      &UdpProtocol::OnKeepAlive,           /* KeepAlive */
+      &UdpProtocol::OnInputAck,            /* InputAck */
+      &UdpProtocol::OnAppData,             /* AppData */
+   };
+
+   // filter out messages that don't match what we expect
+   uint16 seq = msg->hdr.sequence_number;
+   if (msg->hdr.type != UdpMsg::SyncRequest &&
+       msg->hdr.type != UdpMsg::SyncReply) {
+      if (msg->hdr.magic != _remote_magic_number) {
+         LogMsg("recv rejecting", msg);
+         return;
+      }
+
+      // filter out out-of-order packets
+      uint16 skipped = (uint16)((int)seq - (int)_next_recv_seq);
+      // Log("udpproto%d | checking sequence number -> next - seq : %d - %d = %d", _queue, seq, _next_recv_seq, skipped);
+      if (skipped > MAX_SEQ_DISTANCE) {
+         Log("udpproto%d | dropping out of order packet (seq: %d, last seq:%d)", _queue, seq, _next_recv_seq);
+         return;
+      }
+   }
+
+   _next_recv_seq = seq;
+   LogMsg("recv", msg);
+   if (msg->hdr.type >= ARRAY_SIZE(table)) {
+      OnInvalid(msg, len);
+   } else {
+      handled = (this->*(table[msg->hdr.type]))(msg, len);
+   }
+   if (handled) {
+      _last_recv_time = GGPOPlatform::GetCurrentTimeMS();
+      if (_disconnect_notify_sent && _current_state == Running) {
+         QueueEvent(Event(Event::NetworkResumed));   
+         _disconnect_notify_sent = false;
+      }
+   }
+}
+
+void
+UdpProtocol::UpdateNetworkStats(void)
+{
+   int now = GGPOPlatform::GetCurrentTimeMS();
+
+   if (_stats_start_time == 0) {
+      _stats_start_time = now;
+   }
+
+   int total_bytes_sent = _bytes_sent + (UDP_HEADER_SIZE * _packets_sent);
+   float seconds = (float)((now - _stats_start_time) / 1000.0);
+   float Bps = total_bytes_sent / seconds;
+   float udp_overhead = (float)(100.0 * (UDP_HEADER_SIZE * _packets_sent) / _bytes_sent);
+
+   _kbps_sent = int(Bps / 1024);
+
+   Log("udpproto%d | Network Stats -- Bandwidth: %.2f KBps   Packets Sent: %5d (%.2f pps)   "
+       "KB Sent: %.2f    UDP Overhead: %.2f %%.", _queue,
+       (float)_kbps_sent,
+       _packets_sent,
+       (float)_packets_sent * 1000 / (now - _stats_start_time),
+       total_bytes_sent / 1024.0,
+       udp_overhead);
+}
+
+
+void
+UdpProtocol::QueueEvent(const UdpProtocol::Event &evt)
+{
+   LogEvent("Queuing event", evt);
+   _event_queue.push(evt);
+}
+
+void
+UdpProtocol::Synchronize()
+{
+   if (_udp) {
+      _current_state = Syncing;
+      _state.sync.roundtrips_remaining = NUM_SYNC_PACKETS;
+      if (_peer_addr.sin_addr.s_addr != 0)
+    	  SendSyncRequest();
+   }
+}
+
+bool
+UdpProtocol::GetPeerConnectStatus(int id, int *frame)
+{
+   *frame = _peer_connect_status[id].last_frame;
+   return !_peer_connect_status[id].disconnected;
+}
+
+void
+UdpProtocol::LogMsg(const char *prefix, UdpMsg *msg)
+{
+   switch (msg->hdr.type) {
+   case UdpMsg::SyncRequest:
+      Log("udpproto%d | %s sync-request (%d).", _queue, prefix,
+          msg->u.sync_request.random_request);
+      break;
+   case UdpMsg::SyncReply:
+      Log("udpproto%d | %s sync-reply (%d).", _queue, prefix,
+          msg->u.sync_reply.random_reply);
+      break;
+   case UdpMsg::QualityReport:
+      Log("udpproto%d | %s quality report.", _queue, prefix);
+      break;
+   case UdpMsg::QualityReply:
+      Log("udpproto%d | %s quality reply.", _queue, prefix);
+      break;
+   case UdpMsg::KeepAlive:
+      Log("udpproto%d | %s keep alive.", _queue, prefix);
+      break;
+   case UdpMsg::Input:
+      Log("udpproto%d | %s game-compressed-input %d (+ %d bits).", _queue, prefix, msg->u.input.start_frame, msg->u.input.num_bits);
+      break;
+   case UdpMsg::InputAck:
+      Log("udpproto%d | %s input ack.", _queue, prefix);
+      break;
+   case UdpMsg::AppData:
+      Log("udpproto%d | %s app data (%d bytes).", _queue, prefix, msg->u.app_data.size);
+      break;
+   default:
+      ASSERT(false && "Unknown UdpMsg type.");
+   }
+}
+
+void
+UdpProtocol::LogEvent(const char *prefix, const UdpProtocol::Event &evt)
+{
+   if (evt.type == UdpProtocol::Event::Synchronzied)
+      Log("udpproto%d | %s (event: Synchronized).", _queue, prefix);
+}
+
+bool
+UdpProtocol::OnInvalid(UdpMsg *msg, int len)
+{
+   ASSERT(false && "Invalid msg in UdpProtocol");
+   return false;
+}
+
+bool
+UdpProtocol::OnSyncRequest(UdpMsg *msg, int len)
+{
+   if (_remote_magic_number != 0 && msg->hdr.magic != _remote_magic_number) {
+      Log("udpproto%d | Ignoring sync request from unknown endpoint (%d != %d).", _queue,
+           msg->hdr.magic, _remote_magic_number);
+      return false;
+   }
+   UdpMsg *reply = new UdpMsg(UdpMsg::SyncReply);
+   reply->u.sync_reply.random_reply = msg->u.sync_request.random_request;
+   // Calculate incoming verif data size
+   msg->verification_size = 0;
+   int msgVerifSize = len - msg->PacketSize();
+   if (msgVerifSize != (int)verification.size()
+		   || (msgVerifSize != 0 && memcmp(&msg->u.sync_request.verification[0], &verification[0], msgVerifSize)))
+   {
+	   Log("udpproto%d | Verification mismatch: size received %d expected %d", _queue, msgVerifSize, (int)verification.size());
+	   reply->u.sync_reply.verification_failure = 1;
+	   SendMsg(reply);
+	   throw GGPOException("Verification mismatch", GGPO_ERRORCODE_VERIFICATION_ERROR);
+   }
+   // FIXME
+   if (_state.sync.roundtrips_remaining == NUM_SYNC_PACKETS && msg->hdr.sequence_number == 0) {
+      Log("udpproto%d | Sync request 0 received... Re-queueing sync packet.", _queue);
+      SendSyncRequest();
+   }
+
+   reply->u.sync_reply.verification_failure = 0;
+   SendMsg(reply);
+
+   return true;
+}
+
+bool
+UdpProtocol::OnSyncReply(UdpMsg *msg, int len)
+{
+   if (_current_state != Syncing) {
+      Log("udpproto%d | Ignoring SyncReply while not synching.", _queue);
+      return msg->hdr.magic == _remote_magic_number;
+   }
+
+   if (msg->u.sync_reply.random_reply != _state.sync.random) {
+      Log("udpproto%d | sync reply %d != %d.  Keep looking...", _queue,
+          msg->u.sync_reply.random_reply, _state.sync.random);
+      return false;
+   }
+   if (msg->u.sync_reply.verification_failure == 1)
+	   throw GGPOException("Peer reported verification failure", GGPO_ERRORCODE_VERIFICATION_ERROR);
+
+   if (!_connected) {
+      QueueEvent(Event(Event::Connected));
+      _connected = true;
+   }
+
+   Log("udpproto%d | Checking sync state (%d round trips remaining).", _queue, _state.sync.roundtrips_remaining);
+   if (--_state.sync.roundtrips_remaining == 0) {
+      Log("udpproto%d | Synchronized!", _queue);
+      QueueEvent(UdpProtocol::Event(UdpProtocol::Event::Synchronzied));
+      _current_state = Running;
+      _last_received_input.frame = -1;
+      _remote_magic_number = msg->hdr.magic;
+   } else {
+      UdpProtocol::Event evt(UdpProtocol::Event::Synchronizing);
+      evt.u.synchronizing.total = NUM_SYNC_PACKETS;
+      evt.u.synchronizing.count = NUM_SYNC_PACKETS - _state.sync.roundtrips_remaining;
+      QueueEvent(evt);
+      SendSyncRequest();
+   }
+   return true;
+}
+
+bool
+UdpProtocol::OnInput(UdpMsg *msg, int len)
+{
+   /*
+    * If a disconnect is requested, go ahead and disconnect now.
+    */
+   bool disconnect_requested = msg->u.input.disconnect_requested;
+   if (disconnect_requested) {
+      if (_current_state != Disconnected && !_disconnect_event_sent) {
+         Log("udpproto%d | Disconnecting endpoint on remote request.", _queue);
+         QueueEvent(Event(Event::Disconnected));
+         _disconnect_event_sent = true;
+      }
+   } else {
+      /*
+       * Update the peer connection status if this peer is still considered to be part
+       * of the network.
+       */
+      UdpMsg::connect_status* remote_status = msg->u.input.peer_connect_status;
+      for (unsigned i = 0; i < ARRAY_SIZE(_peer_connect_status); i++) {
+         ASSERT(remote_status[i].last_frame >= _peer_connect_status[i].last_frame);
+         _peer_connect_status[i].disconnected = _peer_connect_status[i].disconnected || remote_status[i].disconnected;
+         _peer_connect_status[i].last_frame = MAX(_peer_connect_status[i].last_frame, remote_status[i].last_frame);
+      }
+   }
+
+   /*
+    * Decompress the input.
+    */
+   int last_received_frame_number = _last_received_input.frame;
+   if (msg->u.input.num_bits) {
+      int offset = 0;
+      uint8 *bits = (uint8 *)msg->u.input.bits;
+      int numBits = msg->u.input.num_bits;
+      int currentFrame = msg->u.input.start_frame;
+
+      _last_received_input.size = msg->u.input.input_size;
+      if (_last_received_input.frame < 0) {
+         _last_received_input.frame = msg->u.input.start_frame - 1;
+      }
+      while (offset < numBits) {
+         /*
+          * Keep walking through the frames (parsing bits) until we reach
+          * the inputs for the frame right after the one we're on.
+          */
+         ASSERT(currentFrame <= (_last_received_input.frame + 1));
+         bool useInputs = currentFrame == _last_received_input.frame + 1;
+
+         while (BitVector_ReadBit(bits, &offset)) {
+            int on = BitVector_ReadBit(bits, &offset);
+            int button = BitVector_ReadNibblet(bits, &offset);
+            if (useInputs) {
+               if (on) {
+                  _last_received_input.set(button);
+               } else {
+                  _last_received_input.clear(button);
+               }
+            }
+         }
+         ASSERT(offset <= numBits);
+
+         /*
+          * Now if we want to use these inputs, go ahead and send them to
+          * the emulator.
+          */
+         if (useInputs) {
+            /*
+             * Move forward 1 frame in the stream.
+             */
+            char desc[1024];
+            ASSERT(currentFrame == _last_received_input.frame + 1);
+            _last_received_input.frame = currentFrame;
+
+            /*
+             * Send the event to the emulator
+             */
+            UdpProtocol::Event evt(UdpProtocol::Event::Input);
+            evt.u.input.input = _last_received_input;
+
+            if (LogTypes::LDEBUG <= MAX_LOGLEVEL)
+            	_last_received_input.desc(desc, ARRAY_SIZE(desc));
+
+            _state.running.last_input_packet_recv_time = GGPOPlatform::GetCurrentTimeMS();
+
+            Log("udpproto%d | Sending frame %d to emu queue %d (%s).", _queue, _last_received_input.frame, _queue, desc);
+            QueueEvent(evt);
+
+         } else {
+            Log("udpproto%d | Skipping past frame:(%d) current is %d.", _queue, currentFrame, _last_received_input.frame);
+         }
+
+         /*
+          * Move forward 1 frame in the input stream.
+          */
+         currentFrame++;
+      }
+   }
+   ASSERT(_last_received_input.frame >= last_received_frame_number);
+
+   /*
+    * Get rid of our buffered input
+    */
+   while (_pending_output.size() && _pending_output.front().frame < msg->u.input.ack_frame) {
+      Log("udpproto%d | Throwing away pending output frame %d", _queue, _pending_output.front().frame);
+      _last_acked_input = _pending_output.front();
+      _pending_output.pop();
+   }
+   return true;
+}
+
+
+bool
+UdpProtocol::OnInputAck(UdpMsg *msg, int len)
+{
+   /*
+    * Get rid of our buffered input
+    */
+   while (_pending_output.size() && _pending_output.front().frame < msg->u.input_ack.ack_frame) {
+      Log("udpproto%d | Throwing away pending output frame %d", _queue, _pending_output.front().frame);
+      _last_acked_input = _pending_output.front();
+      _pending_output.pop();
+   }
+   return true;
+}
+
+bool
+UdpProtocol::OnQualityReport(UdpMsg *msg, int len)
+{
+   // send a reply so the other side can compute the round trip transmit time.
+   UdpMsg *reply = new UdpMsg(UdpMsg::QualityReply);
+   reply->u.quality_reply.pong = msg->u.quality_report.ping;
+   SendMsg(reply);
+
+   _remote_frame_advantage = msg->u.quality_report.frame_advantage;
+   return true;
+}
+
+bool
+UdpProtocol::OnQualityReply(UdpMsg *msg, int len)
+{
+   _round_trip_time = GGPOPlatform::GetCurrentTimeMS() - msg->u.quality_reply.pong;
+   return true;
+}
+
+bool
+UdpProtocol::OnKeepAlive(UdpMsg *msg, int len)
+{
+   return true;
+}
+
+void
+UdpProtocol::GetNetworkStats(struct GGPONetworkStats *s)
+{
+   s->network.ping = _round_trip_time;
+   s->network.send_queue_len = _pending_output.size();
+   s->network.kbps_sent = _kbps_sent;
+   s->timesync.remote_frames_behind = _remote_frame_advantage;
+   s->timesync.local_frames_behind = _local_frame_advantage;
+}
+
+void
+UdpProtocol::SetLocalFrameNumber(int localFrame)
+{
+   /*
+    * Estimate which frame the other guy is one by looking at the
+    * last frame they gave us plus some delta for the one-way packet
+    * trip time.
+    */
+   int remoteFrame = _last_received_input.frame + (_round_trip_time * 60 / 1000);
+
+   /*
+    * Our frame advantage is how many frames *behind* the other guy
+    * we are.  Counter-intuative, I know.  It's an advantage because
+    * it means they'll have to predict more often and our moves will
+    * pop more frequenetly.
+    */
+   _local_frame_advantage = remoteFrame - localFrame;
+}
+
+int
+UdpProtocol::RecommendFrameDelay()
+{
+   // XXX: require idle input should be a configuration parameter
+   return _timesync.recommend_frame_wait_duration(false);
+}
+
+
+void
+UdpProtocol::SetDisconnectTimeout(int timeout)
+{
+   _disconnect_timeout = timeout;
+}
+
+void
+UdpProtocol::SetDisconnectNotifyStart(int timeout)
+{
+   _disconnect_notify_start = timeout;
+}
+
+void
+UdpProtocol::PumpSendQueue()
+{
+   std::lock_guard<std::mutex> lock(_send_mutex);
+   while (!_send_queue.empty()) {
+      QueueEntry &entry = _send_queue.front();
+
+      if (_send_latency) {
+         // should really come up with a gaussian distributation based on the configured
+         // value, but this will do for now.
+         int jitter = (_send_latency * 2 / 3) + ((rand() % _send_latency) / 3);
+         if ((int)GGPOPlatform::GetCurrentTimeMS() < _send_queue.front().queue_time + jitter) {
+            break;
+         }
+      }
+      if (_oop_percent && !_oo_packet.msg && ((rand() % 100) < _oop_percent)) {
+         int delay = rand() % (_send_latency * 10 + 1000);
+         Log("udpproto%d | creating rogue oop (seq: %d  delay: %d)", _queue, entry.msg->hdr.sequence_number, delay);
+         _oo_packet.send_time = GGPOPlatform::GetCurrentTimeMS() + delay;
+         _oo_packet.msg = entry.msg;
+         _oo_packet.dest_addr = entry.dest_addr;
+      } else {
+         ASSERT(entry.dest_addr.sin_addr.s_addr);
+
+         _udp->SendTo((char *)entry.msg, entry.msg->PacketSize(), 0,
+                      (struct sockaddr *)&entry.dest_addr, sizeof entry.dest_addr);
+
+         delete entry.msg;
+      }
+      _send_queue.pop();
+   }
+   if (_oo_packet.msg && _oo_packet.send_time < (int)GGPOPlatform::GetCurrentTimeMS()) {
+      Log("udpproto%d | sending rogue oop!", _queue);
+      _udp->SendTo((char *)_oo_packet.msg, _oo_packet.msg->PacketSize(), 0,
+                     (struct sockaddr *)&_oo_packet.dest_addr, sizeof _oo_packet.dest_addr);
+
+      delete _oo_packet.msg;
+      _oo_packet.msg = NULL;
+   }
+}
+
+void
+UdpProtocol::ClearSendQueue()
+{
+   std::lock_guard<std::mutex> lock(_send_mutex);
+   while (!_send_queue.empty()) {
+      delete _send_queue.front().msg;
+      _send_queue.pop();
+   }
+}
+
+void UdpProtocol::SendAppData(const void *data, int len, bool spectators)
+{
+	if (_udp == nullptr)
+		return;
+	if (_current_state != Synchronzied && _current_state != Running)
+		return;
+
+	UdpMsg *msg = new UdpMsg(UdpMsg::AppData);
+	msg->u.app_data.spectators = spectators;
+	msg->u.app_data.size = len;
+	memcpy(msg->u.app_data.data, data, len);
+
+	SendMsg(msg);
+}
+
+bool UdpProtocol::OnAppData(UdpMsg *msg, int len)
+{
+    UdpProtocol::Event evt(UdpProtocol::Event::AppData);
+    evt.u.app_data.spectators = msg->u.app_data.spectators != 0;
+    evt.u.app_data.size = msg->u.app_data.size;
+    memcpy(evt.u.app_data.data, msg->u.app_data.data, msg->u.app_data.size);
+    QueueEvent(evt);
+	return true;
+}

core/deps/ggpo/lib/ggpo/network/udp_proto.h

@@ -0,0 +1,223 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _UDP_PROTO_H_
+#define _UDP_PROTO_H_
+
+#include "ggpo_poll.h"
+#include "udp.h"
+#include "udp_msg.h"
+#include "game_input.h"
+#include "timesync.h"
+#include "ggponet.h"
+#include "ring_buffer.h"
+#include <vector>
+#include <mutex>
+
+class UdpProtocol : public IPollSink
+{
+public:
+   struct Stats {
+      int                 ping;
+      int                 remote_frame_advantage;
+      int                 local_frame_advantage;
+      int                 send_queue_len;
+      Udp::Stats          udp;
+   };
+
+   struct Event {
+      enum Type {
+         Unknown = -1,
+         Connected,
+         Synchronizing,
+         Synchronzied,
+         Input,
+         Disconnected,
+         NetworkInterrupted,
+         NetworkResumed,
+		 AppData,
+      };
+
+      Type      type;
+      union {
+         struct {
+            GameInput   input;
+         } input;
+         struct {
+            int         total;
+            int         count;
+         } synchronizing;
+         struct {
+            int         disconnect_timeout;
+         } network_interrupted;
+         struct {
+        	 bool spectators;
+        	 int size;
+        	 uint8 data[MAX_APPDATA_SIZE];
+         } app_data;
+      } u;
+
+      Event(Type t = Unknown) : type(t) { }
+   };
+
+public:
+   virtual bool OnLoopPoll(void *cookie);
+
+public:
+   UdpProtocol();
+   virtual ~UdpProtocol();
+
+   void Init(Udp *udp, Poll &p, int queue, char *ip, u_short port, UdpMsg::connect_status *status);
+
+   void Synchronize();
+   bool GetPeerConnectStatus(int id, int *frame);
+   bool IsInitialized() { return _udp != NULL; }
+   bool IsSynchronized() { return _current_state == Running; }
+   bool IsRunning() { return _current_state == Running; }
+   void SendInput(GameInput &input);
+   void SendInputAck();
+   bool HandlesMsg(sockaddr_in &from, UdpMsg *msg);
+   void OnMsg(UdpMsg *msg, int len);
+   void Disconnect();
+   void SendAppData(const void *data, int len, bool spectators);
+  
+   void GetNetworkStats(struct GGPONetworkStats *stats);
+   bool GetEvent(UdpProtocol::Event &e);
+   void GGPONetworkStats(Stats *stats);
+   void SetLocalFrameNumber(int num);
+   int RecommendFrameDelay();
+   void SetVerificationData(const void *verification, int verification_size) {
+	   ASSERT(verification_size <= MAX_VERIFICATION_SIZE);
+	   this->verification.resize(verification_size);
+	   memcpy(&this->verification[0], verification, verification_size);
+   }
+
+   void SetDisconnectTimeout(int timeout);
+   void SetDisconnectNotifyStart(int timeout);
+
+protected:
+   enum State {
+      Syncing,
+      Synchronzied,
+      Running,
+      Disconnected
+   };
+   struct QueueEntry {
+      int         queue_time;
+      sockaddr_in dest_addr;
+      UdpMsg      *msg;
+
+      QueueEntry() {}
+      QueueEntry(int time, sockaddr_in &dst, UdpMsg *m) : queue_time(time), dest_addr(dst), msg(m) { }
+   };
+
+   bool CreateSocket(int retries);
+   void UpdateNetworkStats(void);
+   void QueueEvent(const UdpProtocol::Event &evt);
+   void ClearSendQueue(void);
+   void LogMsg(const char *prefix, UdpMsg *msg);
+   void LogEvent(const char *prefix, const UdpProtocol::Event &evt);
+   void SendSyncRequest();
+   void SendMsg(UdpMsg *msg);
+   void PumpSendQueue();
+   void SendPendingOutput();
+   bool OnInvalid(UdpMsg *msg, int len);
+   bool OnSyncRequest(UdpMsg *msg, int len);
+   bool OnSyncReply(UdpMsg *msg, int len);
+   bool OnInput(UdpMsg *msg, int len);
+   bool OnInputAck(UdpMsg *msg, int len);
+   bool OnQualityReport(UdpMsg *msg, int len);
+   bool OnQualityReply(UdpMsg *msg, int len);
+   bool OnKeepAlive(UdpMsg *msg, int len);
+   bool OnAppData(UdpMsg *msg, int len);
+
+protected:
+   /*
+    * Network transmission information
+    */
+   Udp            *_udp;
+   sockaddr_in    _peer_addr; 
+   uint16         _magic_number;
+   int            _queue;
+   uint16         _remote_magic_number;
+   bool           _connected;
+   int            _send_latency;
+   int            _oop_percent;
+   struct {
+      int         send_time;
+      sockaddr_in dest_addr;
+      UdpMsg*     msg;
+   }              _oo_packet;
+   RingBuffer<QueueEntry, 64> _send_queue;
+   std::mutex     _send_mutex;
+
+   std::vector<uint8> verification;
+
+   /*
+    * Stats
+    */
+   int            _round_trip_time;
+   int            _packets_sent;
+   int            _bytes_sent;
+   int            _kbps_sent;
+   int            _stats_start_time;
+
+   /*
+    * The state machine
+    */
+   UdpMsg::connect_status *_local_connect_status;
+   UdpMsg::connect_status _peer_connect_status[UDP_MSG_MAX_PLAYERS];
+
+   State          _current_state;
+   union {
+      struct {
+         uint32   roundtrips_remaining;
+         uint32   random;
+      } sync;
+      struct {
+         uint32   last_quality_report_time;
+         uint32   last_network_stats_interval;
+         uint32   last_input_packet_recv_time;
+      } running;
+   } _state;
+
+   /*
+    * Fairness.
+    */
+   int               _local_frame_advantage;
+   int               _remote_frame_advantage;
+
+   /*
+    * Packet loss...
+    */
+   RingBuffer<GameInput, 64>  _pending_output;
+   GameInput                  _last_received_input;
+   GameInput                  _last_sent_input;
+   GameInput                  _last_acked_input;
+   unsigned int               _last_send_time;
+   unsigned int               _last_recv_time;
+   unsigned int               _shutdown_timeout;
+   unsigned int               _disconnect_event_sent;
+   unsigned int               _disconnect_timeout;
+   unsigned int               _disconnect_notify_start;
+   bool                       _disconnect_notify_sent;
+
+   uint16                     _next_send_seq;
+   uint16                     _next_recv_seq;
+
+   /*
+    * Rift synchronization.
+    */
+   TimeSync                   _timesync;
+
+   /*
+    * Event queue
+    */
+   RingBuffer<UdpProtocol::Event, 64>  _event_queue;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/platform_linux.cpp

@@ -0,0 +1,38 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+#if defined(__unix__) || defined(__APPLE__) || defined(__SWITCH__)
+
+#include "platform_linux.h"
+#include <time.h>
+#include <strings.h>
+#include <chrono>
+
+uint32_t GGPOPlatform::GetCurrentTimeMS()
+{
+	using namespace std::chrono;
+	static steady_clock::time_point startTime = steady_clock::now();
+
+	return (uint32_t)duration_cast<milliseconds>(steady_clock::now() - startTime).count();
+}
+
+int GGPOPlatform::GetConfigInt(const char* name)
+{
+   char *buf = getenv(name);
+   if (buf == nullptr)
+      return 0;
+   return atoi(buf);
+}
+
+bool GGPOPlatform::GetConfigBool(const char* name)
+{
+	char *buf = getenv(name);
+	if (buf == nullptr)
+		return false;
+   return atoi(buf) != 0 || strcasecmp(buf, "true") == 0;
+}
+
+#endif

core/deps/ggpo/lib/ggpo/platform_linux.h

@@ -0,0 +1,69 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _GGPO_LINUX_H_
+#define _GGPO_LINUX_H_
+
+#include <limits>
+#include <stdio.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <cstdint>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#ifdef __SWITCH__
+#include "nswitch.h"
+#else
+#include <netinet/ip.h>
+#endif
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+
+using SOCKET = int;
+#define closesocket close
+#define INVALID_SOCKET (-1)
+#define SOCKET_ERROR (-1)
+#define WSAEWOULDBLOCK EWOULDBLOCK
+
+constexpr size_t MAX_PATH = 4096;
+#ifdef INT_MAX
+#undef INT_MAX
+#endif
+constexpr int INT_MAX = std::numeric_limits<int>::max();
+
+class GGPOPlatform {
+public:  // types
+   typedef pid_t ProcessID;
+
+public:  // functions
+   static ProcessID GetProcessID() { return getpid(); }
+   static void AssertFailed(char *msg) { fprintf(stderr, "%s", msg); }
+   static uint32_t GetCurrentTimeMS();
+   static int GetConfigInt(const char* name);
+   static bool GetConfigBool(const char* name);
+};
+
+extern "C" {
+
+inline static void DebugBreak()
+{
+	__builtin_trap();
+}
+
+inline static int WSAGetLastError() {
+	return errno;
+}
+
+}
+
+#endif

core/deps/ggpo/lib/ggpo/platform_windows.cpp

@@ -0,0 +1,28 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+#ifdef _WIN32
+#include "platform_windows.h"
+
+int
+GGPOPlatform::GetConfigInt(const char* name)
+{
+   char buf[1024];
+   if (GetEnvironmentVariableA(name, buf, ARRAY_SIZE(buf)) == 0) {
+      return 0;
+   }
+   return atoi(buf);
+}
+
+bool GGPOPlatform::GetConfigBool(const char* name)
+{
+   char buf[1024];
+   if (GetEnvironmentVariableA(name, buf, ARRAY_SIZE(buf)) == 0) {
+      return false;
+   }
+   return atoi(buf) != 0 || _stricmp(buf, "true") == 0;
+}
+#endif

core/deps/ggpo/lib/ggpo/platform_windows.h

@@ -0,0 +1,44 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _GGPO_WINDOWS_H_
+#define _GGPO_WINDOWS_H_
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <stdio.h>
+#include <chrono>
+
+#include "ggpo_types.h"
+
+class GGPOPlatform {
+public:  // types
+   typedef DWORD ProcessID;
+
+public:  // functions
+   static ProcessID GetProcessID() { return GetCurrentProcessId(); }
+   static void AssertFailed(char *msg) { 
+#ifndef TARGET_UWP
+	   MessageBoxA(NULL, msg, "GGPO Assertion Failed", MB_OK | MB_ICONEXCLAMATION);
+#endif
+   }
+   static uint32 GetCurrentTimeMS() {
+#ifdef TARGET_UWP
+	   using namespace std::chrono;
+	   static steady_clock::time_point startTime = steady_clock::now();
+
+	   return (uint32_t)duration_cast<milliseconds>(steady_clock::now() - startTime).count();
+#else
+	   return timeGetTime();
+#endif
+   }
+   static int GetConfigInt(const char* name);
+   static bool GetConfigBool(const char* name);
+};
+
+#endif

core/deps/ggpo/lib/ggpo/poll.cpp

@@ -0,0 +1,127 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "ggpo_poll.h"
+#include "ggpo_types.h"
+
+#ifndef _WIN32
+#include <chrono>
+#include <thread>
+constexpr int INFINITE = -1;
+#endif
+
+Poll::Poll(void) :
+   _start_time(0),
+   _handle_count(0)
+{
+   /*
+    * Create a dummy handle to simplify things.
+    */
+#ifdef _WIN32
+   _handles[_handle_count++] = CreateEvent(NULL, true, false, NULL);
+#endif
+}
+
+#if 0
+void
+Poll::RegisterHandle(IPollSink *sink, HANDLE h, void *cookie)
+{
+   ASSERT(_handle_count < MAX_POLLABLE_HANDLES - 1);
+
+   _handles[_handle_count] = h;
+   _handle_sinks[_handle_count] = PollSinkCb(sink, cookie);
+   _handle_count++;
+}
+#endif
+
+void
+Poll::RegisterMsgLoop(IPollSink *sink, void *cookie)
+{
+   _msg_sinks.push_back(PollSinkCb(sink, cookie));
+}
+
+void
+Poll::RegisterLoop(IPollSink *sink, void *cookie)
+{
+   _loop_sinks.push_back(PollSinkCb(sink, cookie));
+}
+void
+Poll::RegisterPeriodic(IPollSink *sink, int interval, void *cookie)
+{
+   _periodic_sinks.push_back(PollPeriodicSinkCb(sink, cookie, interval));
+}
+
+void
+Poll::Run()
+{
+   while (Pump(100)) {
+      continue;
+   }
+}
+
+bool
+Poll::Pump(int timeout)
+{
+   int i;
+   bool finished = false;
+
+   if (_start_time == 0) {
+      _start_time = GGPOPlatform::GetCurrentTimeMS();
+   }
+   int elapsed = GGPOPlatform::GetCurrentTimeMS() - _start_time;
+   int maxwait = ComputeWaitTime(elapsed);
+   if (maxwait != INFINITE) {
+      timeout = MIN(timeout, maxwait);
+   }
+
+#ifdef _WIN32
+   DWORD res = WaitForMultipleObjects(_handle_count, _handles, false, timeout);
+   if (res >= WAIT_OBJECT_0 && res < WAIT_OBJECT_0 + _handle_count) {
+      i = res - WAIT_OBJECT_0;
+      finished = !_handle_sinks[i].sink->OnHandlePoll(_handle_sinks[i].cookie) || finished;
+   }
+#else
+   if (timeout > 0)
+	   std::this_thread::sleep_for(std::chrono::milliseconds(timeout));
+#endif
+   for (i = 0; i < _msg_sinks.size(); i++) {
+      PollSinkCb &cb = _msg_sinks[i];
+      finished = !cb.sink->OnMsgPoll(cb.cookie) || finished;
+   }
+
+   for (i = 0; i < _periodic_sinks.size(); i++) {
+      PollPeriodicSinkCb &cb = _periodic_sinks[i];
+      if (cb.interval + cb.last_fired <= elapsed) {
+         cb.last_fired = (elapsed / cb.interval) * cb.interval;
+         finished = !cb.sink->OnPeriodicPoll(cb.cookie, cb.last_fired) || finished;
+      }
+   }
+
+   for (i = 0; i < _loop_sinks.size(); i++) {
+      PollSinkCb &cb = _loop_sinks[i];
+      finished = !cb.sink->OnLoopPoll(cb.cookie) || finished;
+   }
+   return finished;
+}
+
+int
+Poll::ComputeWaitTime(int elapsed)
+{
+   int waitTime = INFINITE;
+   size_t count = _periodic_sinks.size();
+
+   if (count > 0) {
+      for (size_t i = 0; i < count; i++) {
+         PollPeriodicSinkCb &cb = _periodic_sinks[i];
+         int timeout = (cb.interval + cb.last_fired) - elapsed;
+         if (waitTime == INFINITE || (timeout < waitTime)) {
+            waitTime = MAX(timeout, 0);
+         }         
+      }
+   }
+   return waitTime;
+}

core/deps/ggpo/lib/ggpo/ring_buffer.h

@@ -0,0 +1,60 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _RING_BUFFER_H
+#define _RING_BUFFER_H
+
+#include "ggpo_types.h"
+
+template<class T, int N> class RingBuffer
+{
+public:
+   RingBuffer<T, N>() : 
+      _head(0),
+      _tail(0),
+      _size(0) {
+  } 
+
+   T &front() {
+      ASSERT(_size != N);
+      return _elements[_tail];
+   }
+   
+   T &item(int i) {
+      ASSERT(i < _size);
+      return _elements[(_tail + i) % N];
+   }
+
+   void pop() {
+      ASSERT(_size != N);
+      _tail = (_tail + 1) % N;
+      _size--;
+   }
+
+   void push(const T &t) {
+      ASSERT(_size != (N-1));
+      _elements[_head] = t;
+      _head = (_head + 1) % N;
+      _size++;
+   }
+
+   int size() {
+      return _size;
+   }
+
+   bool empty() {
+      return _size == 0;
+   }
+
+protected:
+   T        _elements[N];
+   int      _head;
+   int      _tail;
+   int      _size;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/static_buffer.h

@@ -0,0 +1,40 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _STATIC_BUFFER_H
+#define _STATIC_BUFFER_H
+
+#include "ggpo_types.h"
+
+template<class T, int N> class StaticBuffer
+{
+public:
+   StaticBuffer<T, N>() :
+      _size(0) {
+   } 
+
+   T& operator[](int i) {
+      ASSERT(i >= 0 && i < _size);
+      return _elements[i];
+   }
+
+   void push_back(const T &t) {
+      ASSERT(_size != (N-1));
+      _elements[_size++] = t;
+   }
+
+   int size() {
+      return _size;
+   }
+
+
+protected:
+   T        _elements[N];
+   int      _size;
+};
+
+#endif

core/deps/ggpo/lib/ggpo/sync.cpp

@@ -0,0 +1,304 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "sync.h"
+
+Sync::Sync(UdpMsg::connect_status *connect_status) :
+_input_queues(NULL),
+ _local_connect_status(connect_status)
+{
+   _framecount = 0;
+   _last_confirmed_frame = -1;
+   _max_prediction_frames = 0;
+   memset(&_savedstate, 0, sizeof(_savedstate));
+}
+
+Sync::~Sync()
+{
+   /*
+    * Delete frames manually here rather than in a destructor of the SavedFrame
+    * structure so we can efficently copy frames via weak references.
+    */
+   for (size_t i = 0; i < ARRAY_SIZE(_savedstate.frames); i++) {
+      _callbacks.free_buffer(_savedstate.frames[i].buf);
+   }
+   delete [] _input_queues;
+   _input_queues = NULL;
+}
+
+void
+Sync::Init(Sync::Config &config)
+{
+   _config = config;
+   _callbacks = config.callbacks;
+   _framecount = 0;
+   _rollingback = false;
+
+   _max_prediction_frames = config.num_prediction_frames;
+
+   CreateQueues(config);
+}
+
+void
+Sync::SetLastConfirmedFrame(int frame) 
+{   
+   _last_confirmed_frame = frame;
+   if (_last_confirmed_frame > 0) {
+      for (int i = 0; i < _config.num_players; i++) {
+         _input_queues[i].DiscardConfirmedFrames(frame - 1);
+      }
+   }
+}
+
+bool
+Sync::AddLocalInput(int queue, GameInput &input)
+{
+   int frames_behind = _framecount - _last_confirmed_frame; 
+   if (_framecount >= _max_prediction_frames && frames_behind >= _max_prediction_frames) {
+      Log("Rejecting input from emulator: reached prediction barrier.");
+      return false;
+   }
+
+   if (_framecount == 0) {
+      SaveCurrentFrame();
+   }
+
+   Log("Sending undelayed local frame %d to queue %d.", _framecount, queue);
+   input.frame = _framecount;
+   _input_queues[queue].AddInput(input);
+
+   return true;
+}
+
+void
+Sync::AddRemoteInput(int queue, GameInput &input)
+{
+   _input_queues[queue].AddInput(input);
+}
+
+int
+Sync::GetConfirmedInputs(void *values, int size, int frame)
+{
+   int disconnect_flags = 0;
+   char *output = (char *)values;
+
+   ASSERT(size >= _config.num_players * _config.input_size);
+
+   memset(output, 0, size);
+   for (int i = 0; i < _config.num_players; i++) {
+      GameInput input;
+      if (_local_connect_status[i].disconnected && frame > _local_connect_status[i].last_frame) {
+         disconnect_flags |= (1 << i);
+         input.erase();
+      } else {
+         _input_queues[i].GetConfirmedInput(frame, &input);
+      }
+      memcpy(output + (i * _config.input_size), input.bits, _config.input_size);
+   }
+   return disconnect_flags;
+}
+
+int
+Sync::SynchronizeInputs(void *values, int size)
+{
+   int disconnect_flags = 0;
+   char *output = (char *)values;
+
+   ASSERT(size >= _config.num_players * _config.input_size);
+
+   memset(output, 0, size);
+   for (int i = 0; i < _config.num_players; i++) {
+      GameInput input;
+      if (_local_connect_status[i].disconnected && _framecount > _local_connect_status[i].last_frame) {
+         disconnect_flags |= (1 << i);
+         input.erase();
+      } else {
+         _input_queues[i].GetInput(_framecount, &input);
+      }
+      memcpy(output + (i * _config.input_size), input.bits, _config.input_size);
+   }
+   return disconnect_flags;
+}
+
+void
+Sync::CheckSimulation(int timeout)
+{
+   int seek_to;
+   if (!CheckSimulationConsistency(&seek_to)) {
+      AdjustSimulation(seek_to);
+   }
+}
+
+void
+Sync::IncrementFrame(void)
+{
+   _framecount++;
+   SaveCurrentFrame();
+}
+
+void
+Sync::AdjustSimulation(int seek_to)
+{
+   int framecount = _framecount;
+   int count = _framecount - seek_to;
+
+   Log("Catching up");
+   _rollingback = true;
+
+   /*
+    * Flush our input queue and load the last frame.
+    */
+   LoadFrame(seek_to);
+   ASSERT(_framecount == seek_to);
+
+   /*
+    * Advance frame by frame (stuffing notifications back to 
+    * the master).
+    */
+   ResetPrediction(_framecount);
+   for (int i = 0; i < count; i++) {
+      _callbacks.advance_frame(0);
+   }
+   ASSERT(_framecount == framecount);
+
+   _rollingback = false;
+
+   Log("---");
+}
+
+void
+Sync::LoadFrame(int frame)
+{
+   // find the frame in question
+   if (frame == _framecount) {
+      Log("Skipping NOP.");
+      return;
+   }
+
+   // Move the head pointer back and load it up
+   _savedstate.head = FindSavedFrameIndex(frame);
+   SavedFrame *state = _savedstate.frames + _savedstate.head;
+
+   Log("=== Loading frame info %d (size: %d  checksum: %08x).",
+       state->frame, state->cbuf, state->checksum);
+
+   ASSERT(state->buf && state->cbuf);
+   _callbacks.load_game_state(state->buf, state->cbuf);
+
+   // Reset framecount and the head of the state ring-buffer to point in
+   // advance of the current frame (as if we had just finished executing it).
+   _framecount = state->frame;
+   _savedstate.head = (_savedstate.head + 1) % ARRAY_SIZE(_savedstate.frames);
+}
+
+void
+Sync::SaveCurrentFrame()
+{
+   /*
+    * See StateCompress for the real save feature implemented by FinalBurn.
+    * Write everything into the head, then advance the head pointer.
+    */
+   SavedFrame *state = _savedstate.frames + _savedstate.head;
+   if (state->buf) {
+      _callbacks.free_buffer(state->buf);
+      state->buf = NULL;
+   }
+   state->frame = _framecount;
+   _callbacks.save_game_state(&state->buf, &state->cbuf, &state->checksum, state->frame);
+
+   Log("=== Saved frame info %d (size: %d  checksum: %08x).", state->frame, state->cbuf, state->checksum);
+   _savedstate.head = (_savedstate.head + 1) % ARRAY_SIZE(_savedstate.frames);
+}
+
+Sync::SavedFrame&
+Sync::GetLastSavedFrame()
+{
+   int i = _savedstate.head - 1;
+   if (i < 0) {
+      i = ARRAY_SIZE(_savedstate.frames) - 1;
+   }
+   return _savedstate.frames[i];
+}
+
+
+int
+Sync::FindSavedFrameIndex(int frame)
+{
+   int i, count = ARRAY_SIZE(_savedstate.frames);
+   for (i = 0; i < count; i++) {
+      if (_savedstate.frames[i].frame == frame) {
+         break;
+      }
+   }
+   if (i == count) {
+      ASSERT(false);
+   }
+   return i;
+}
+
+
+bool
+Sync::CreateQueues(Config &config)
+{
+   delete [] _input_queues;
+   _input_queues = new InputQueue[_config.num_players];
+
+   for (int i = 0; i < _config.num_players; i++) {
+      _input_queues[i].Init(i, _config.input_size);
+   }
+   return true;
+}
+
+bool
+Sync::CheckSimulationConsistency(int *seekTo)
+{
+   int first_incorrect = GameInput::NullFrame;
+   for (int i = 0; i < _config.num_players; i++) {
+      int incorrect = _input_queues[i].GetFirstIncorrectFrame();
+      Log("considering incorrect frame %d reported by queue %d.", incorrect, i);
+
+      if (incorrect != GameInput::NullFrame && (first_incorrect == GameInput::NullFrame || incorrect < first_incorrect)) {
+         first_incorrect = incorrect;
+      }
+   }
+
+   if (first_incorrect == GameInput::NullFrame) {
+      Log("prediction ok.  proceeding.");
+      return true;
+   }
+   *seekTo = first_incorrect;
+   return false;
+}
+
+void
+Sync::SetFrameDelay(int queue, int delay)
+{
+   _input_queues[queue].SetFrameDelay(delay);
+}
+
+
+void
+Sync::ResetPrediction(int frameNumber)
+{
+   for (int i = 0; i < _config.num_players; i++) {
+      _input_queues[i].ResetPrediction(frameNumber);
+   }
+}
+
+
+bool
+Sync::GetEvent(Event &e)
+{
+   if (_event_queue.size()) {
+      e = _event_queue.front();
+      _event_queue.pop();
+      return true;
+   }
+   return false;
+}
+
+

core/deps/ggpo/lib/ggpo/sync.h

@@ -0,0 +1,105 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _SYNC_H
+#define _SYNC_H
+
+#include "ggponet.h"
+#include "game_input.h"
+#include "ggpo_types.h"
+#include "input_queue.h"
+#include "ring_buffer.h"
+#include "network/udp_msg.h"
+
+#define MAX_PREDICTION_FRAMES    8
+
+class SyncTestBackend;
+
+class Sync {
+public:
+   struct Config {
+      GGPOSessionCallbacks    callbacks;
+      int                     num_prediction_frames;
+      int                     num_players;
+      int                     input_size;
+   };
+   struct Event {
+      enum {
+         ConfirmedInput,
+      } type;
+      union {
+         struct {
+            GameInput   input;
+         } confirmedInput;
+      } u;
+   };
+
+public:
+   Sync(UdpMsg::connect_status *connect_status);
+   virtual ~Sync();
+
+   void Init(Config &config);
+
+   void SetLastConfirmedFrame(int frame);
+   void SetFrameDelay(int queue, int delay);
+   bool AddLocalInput(int queue, GameInput &input);
+   void AddRemoteInput(int queue, GameInput &input);
+   int GetConfirmedInputs(void *values, int size, int frame);
+   int SynchronizeInputs(void *values, int size);
+
+   void CheckSimulation(int timeout);
+   void AdjustSimulation(int seek_to);
+   void IncrementFrame(void);
+
+   int GetFrameCount() { return _framecount; }
+   bool InRollback() { return _rollingback; }
+   int GetPredictedFrames() { return _framecount - _last_confirmed_frame; }
+
+   bool GetEvent(Event &e);
+
+protected:
+   friend SyncTestBackend;
+
+   struct SavedFrame {
+      byte    *buf;
+      int      cbuf;
+      int      frame;
+      int      checksum;
+      SavedFrame() : buf(NULL), cbuf(0), frame(-1), checksum(0) { }
+   };
+   struct SavedState {
+      SavedFrame frames[MAX_PREDICTION_FRAMES + 2];
+      int head;
+   };
+
+   void LoadFrame(int frame);
+   void SaveCurrentFrame();
+   int FindSavedFrameIndex(int frame);
+   SavedFrame &GetLastSavedFrame();
+
+   bool CreateQueues(Config &config);
+   bool CheckSimulationConsistency(int *seekTo);
+   void ResetPrediction(int frameNumber);
+
+protected:
+   GGPOSessionCallbacks _callbacks;
+   SavedState     _savedstate;
+   Config         _config;
+
+   bool           _rollingback;
+   int            _last_confirmed_frame;
+   int            _framecount;
+   int            _max_prediction_frames;
+
+   InputQueue     *_input_queues;
+
+   RingBuffer<Event, 32> _event_queue;
+   UdpMsg::connect_status *_local_connect_status;
+};
+
+#endif
+

core/deps/ggpo/lib/ggpo/timesync.cpp

@@ -0,0 +1,85 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#include "timesync.h"
+
+TimeSync::TimeSync()
+{
+   memset(_local, 0, sizeof(_local));
+   memset(_remote, 0, sizeof(_remote));
+   _next_prediction = FRAME_WINDOW_SIZE * 3;
+}
+
+TimeSync::~TimeSync()
+{
+}
+
+void
+TimeSync::advance_frame(GameInput &input, int advantage, int radvantage)
+{
+   // Remember the last frame and frame advantage
+   _last_inputs[input.frame % ARRAY_SIZE(_last_inputs)] = input;
+   _local[input.frame % ARRAY_SIZE(_local)] = advantage;
+   _remote[input.frame % ARRAY_SIZE(_remote)] = radvantage;
+}
+
+int
+TimeSync::recommend_frame_wait_duration(bool require_idle_input)
+{
+   // Average our local and remote frame advantages
+   int sum = 0;
+   float advantage, radvantage;
+   for (size_t i = 0; i < ARRAY_SIZE(_local); i++) {
+      sum += _local[i];
+   }
+   advantage = sum / (float)ARRAY_SIZE(_local);
+
+   sum = 0;
+   for (size_t i = 0; i < ARRAY_SIZE(_remote); i++) {
+      sum += _remote[i];
+   }
+   radvantage = sum / (float)ARRAY_SIZE(_remote);
+
+   static int count = 0;
+   count++;
+
+   // See if someone should take action.  The person furthest ahead
+   // needs to slow down so the other user can catch up.
+   // Only do this if both clients agree on who's ahead!!
+   if (advantage >= radvantage) {
+      return 0;
+   }
+
+   // Both clients agree that we're the one ahead.  Split
+   // the difference between the two to figure out how long to
+   // sleep for.
+   int sleep_frames = (int)(((radvantage - advantage) / 2) + 0.5);
+
+   Log("iteration %d:  sleep frames is %d", count, sleep_frames);
+
+   // Some things just aren't worth correcting for.  Make sure
+   // the difference is relevant before proceeding.
+   if (sleep_frames < MIN_FRAME_ADVANTAGE) {
+      return 0;
+   }
+
+   // Make sure our input had been "idle enough" before recommending
+   // a sleep.  This tries to make the emulator sleep while the
+   // user's input isn't sweeping in arcs (e.g. fireball motions in
+   // Street Fighter), which could cause the player to miss moves.
+   if (require_idle_input) {
+      for (size_t i = 1; i < ARRAY_SIZE(_last_inputs); i++) {
+         if (!_last_inputs[i].equal(_last_inputs[0], true)) {
+            Log("iteration %d:  rejecting due to input stuff at position %d...!!!", count, (int)i);
+            return 0;
+         }
+      }
+   }
+
+   // Success!!! Recommend the number of frames to sleep and adjust
+   return MIN(sleep_frames, MAX_FRAME_ADVANTAGE);
+}

core/deps/ggpo/lib/ggpo/timesync.h

@@ -0,0 +1,34 @@
+/* -----------------------------------------------------------------------
+ * GGPO.net (http://ggpo.net)  -  Copyright 2009 GroundStorm Studios, LLC.
+ *
+ * Use of this software is governed by the MIT license that can be found
+ * in the LICENSE file.
+ */
+
+#ifndef _TIMESYNC_H
+#define _TIMESYNC_H
+
+#include "game_input.h"
+#include "ggpo_types.h"
+
+#define FRAME_WINDOW_SIZE           40
+#define MIN_UNIQUE_FRAMES           10
+#define MIN_FRAME_ADVANTAGE          3
+#define MAX_FRAME_ADVANTAGE          9
+
+class TimeSync {
+public:
+   TimeSync();
+   virtual ~TimeSync ();
+
+   void advance_frame(GameInput &input, int advantage, int radvantage);
+   int recommend_frame_wait_duration(bool require_idle_input);
+
+protected:
+   int         _local[FRAME_WINDOW_SIZE];
+   int         _remote[FRAME_WINDOW_SIZE];
+   GameInput   _last_inputs[MIN_UNIQUE_FRAMES];
+   int         _next_prediction;
+};
+
+#endif

core/deps/glslang/.appveyor.yml

@@ -1,108 +0,0 @@
-# Windows Build Configuration for AppVeyor
-# http://www.appveyor.com/docs/appveyor-yml
-
-# build version format
-version: "{build}"
-
-os: Visual Studio 2013
-
-platform:
-  - x64
-
-configuration:
-  - Debug
-  - Release
-
-branches:
-  only:
-    - master
-
-# changes to these files don't need to trigger testing
-skip_commits:
-  files:
-    - README.md
-    - README-spirv-remap.txt
-    - LICENSE.txt
-    - CODE_OF_CONDUCT.md
-    - BUILD.*
-    - WORKSPACE
-    - kokoro/*
-    - make-revision
-    - Android.mk
-    - _config.yml
-
-# Travis advances the master-tot tag to current top of the tree after
-# each push into the master branch, because it relies on that tag to
-# upload build artifacts to the master-tot release. This will cause
-# double testing for each push on Appveyor: one for the push, one for
-# the tag advance. Disable testing tags.
-skip_tags: true
-
-clone_depth: 5
-
-matrix:
-  fast_finish: true # Show final status immediately if a test fails.
-
-# scripts that run after cloning repository
-install:
-  - C:/Python27/python.exe update_glslang_sources.py
-  - set PATH=C:\ninja;C:\Python36;%PATH%
-  - git clone https://github.com/google/googletest.git External/googletest
-  - cd External/googletest
-  - git checkout 440527a61e1c91188195f7de212c63c77e8f0a45
-  - cd ../..
-
-build:
-  parallel: true  # enable MSBuild parallel builds
-  verbosity: minimal
-
-build_script:
-  - mkdir build && cd build
-  - cmake -G "Visual Studio 12 2013 Win64" -DCMAKE_INSTALL_PREFIX=install ..
-  - cmake --build . --config %CONFIGURATION% --target install
-
-test_script:
-  - ctest -C %CONFIGURATION% --output-on-failure
-  - cd ../Test && bash runtests
-  - cd ../build
-
-after_test:
-  # For debug build, the generated dll has a postfix "d" in its name.
-  - ps: >-
-      If ($env:configuration -Match "Debug") {
-        $env:SUFFIX="d"
-      } Else {
-        $env:SUFFIX=""
-      }
-  - cd install
-  # Zip all glslang artifacts for uploading and deploying
-  - 7z a glslang-master-windows-"%PLATFORM%"-"%CONFIGURATION%".zip
-    bin\glslangValidator.exe
-    bin\spirv-remap.exe
-    include\glslang\*
-    lib\glslang%SUFFIX%.lib
-    lib\HLSL%SUFFIX%.lib
-    lib\OGLCompiler%SUFFIX%.lib
-    lib\OSDependent%SUFFIX%.lib
-    lib\SPIRV%SUFFIX%.lib
-    lib\SPVRemapper%SUFFIX%.lib
-    lib\SPIRV-Tools%SUFFIX%.lib
-    lib\SPIRV-Tools-opt%SUFFIX%.lib
-
-artifacts:
-  - path: build\install\*.zip
-    name: artifacts-zip
-
-deploy:
-  - provider: GitHub
-    auth_token:
-      secure: YglcSYdl0TylEa59H4K6lylBEDr586NAt2EMgZquSo+iuPrwgZQuJLPCoihSm9y6
-    release: master-tot
-    description: "Continuous build of the latest master branch by Appveyor and Travis CI"
-    artifact: artifacts-zip
-    draft: false
-    prerelease: false
-    force_update: true
-    on:
-      branch: master
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013

core/deps/glslang/.clang-format

@@ -1,13 +0,0 @@
-Language: Cpp
-IndentWidth: 4
-PointerAlignment: Left
-BreakBeforeBraces: Custom
-BraceWrapping: { AfterFunction: true, AfterControlStatement: false }
-IndentCaseLabels: false
-ReflowComments: false
-ColumnLimit: 120
-AccessModifierOffset: -4
-AlignTrailingComments: true
-AllowShortBlocksOnASingleLine: false
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false

core/deps/glslang/.gitattributes

@@ -1,17 +0,0 @@
-# test files have a mix of lf/crlf, and that's a good thing, for testing, don't mess with it
-# bash scripts need lines ending with lf, and that's correct for Windows too, e.g., under Cygwin
-# (scripts often don't have a suffix)
-* -text
-*.sh text eof=lf
-
-# txt files should be native and normalized
-*.txt text
-
-# source code can be native and normalized, but simpler if lf everywhere; will try that way
-*.h text eol=lf
-*.c text eol=lf
-*.cpp text eol=lf
-*.y text eol=lf
-*.out text eol=lf
-*.conf text eol=lf
-*.err text eol=lf

core/deps/glslang/.gitignore

@@ -1,10 +0,0 @@
-*.o
-*.a
-*.so
-*.exe
-tags
-TAGS
-build/
-Test/localResults/
-External/googletest
-External/spirv-tools

core/deps/glslang/.travis.yml

@@ -1,128 +0,0 @@
-# Linux and Mac Build Configuration for Travis
-
-language: cpp
-
-os:
-  - linux
-  - osx
-
-# Use Ubuntu 14.04 LTS (Trusty) as the Linux testing environment.
-sudo: false
-dist: trusty
-
-env:
-  global:
-    - secure: aGFrgzyKp+84hKrGkxVWg8cHV61uqrKEHT38gfSQK6+WS4GfLOyH83p7WnsEBb7AMhzU7LMNFdvOFr6+NaMpVnqRvc40CEG1Q+lNg9Pq9mhIZLowvDrfqTL9kQ+8Nbw5Q6/dg6CTvY7fvRfpfCEmKIUZBRkoKUuHeuM1uy3IupFcdNuL5bSYn3Beo+apSJginh9DI4BLDXFUgBzTRSLLyCX5g3cpaeGGOCr8quJlYx75W6HRck5g9SZuLtUoH9GFEV3l+ZEWB8noErW+J56L03bwNwFuuAh321evw++oQk5KFa8rlDvar3SJ3b1RHB8u/eq5DBYMyaK/fS8+Q7QbGr8diF/wDe68bKO7U9IhpNfExXmczCpExjHomW5TQv4rYdGhygPMfW97aIsPRYyNKcl4fkmb7NDrM8w0Jscdq2g5c2Kz0ItyZoBri/NXLwFQQjaVCs7Pf97TjuMA7mK0GJmDTRzi6SrDYlWMt5BQL3y0CCojyfLIRcTh0CQjQI29s97bLfQrYAxt9GNNFR+HTXRLLrkaAlJkPGEPwUywlSfEThnvHLesNxYqemolAYpQT4ithoL4GehGIHmaxsW295aKVhuRf8K9eBODNqrfblvM42UHhjntT+92ZnQ/Gkq80GqaMxnxi4PO5FyPIxt0r981b54YBkWi8YA4P7w5pNI=
-  matrix:
-    - GLSLANG_BUILD_TYPE=Release
-    - GLSLANG_BUILD_TYPE=Debug
-
-compiler:
-  - clang
-  - gcc
-
-matrix:
-  fast_finish: true # Show final status immediately if a test fails.
-  exclude:
-    # Skip GCC builds on Mac OS X.
-    - os: osx
-      compiler: gcc
-  include:
-    # Additional build using Android NDK.
-    - env: BUILD_NDK=ON
-
-cache:
-  apt: true
-
-branches:
-  only:
-    - master
-
-addons:
-  apt:
-    packages:
-      - clang-3.6
-
-install:
-  # Make sure that clang-3.6 is selected on Linux.
-  - if [[ "$TRAVIS_OS_NAME" == "linux" && "$CC" == "clang" ]]; then
-      export CC=clang-3.6 CXX=clang++-3.6;
-    fi
-  # Download a recent Android NDK and use its android.toolchain.cmake file.
-  - if [[ "$BUILD_NDK" == "ON" ]]; then
-      export ANDROID_NDK=$HOME/android-ndk;
-      git init $ANDROID_NDK;
-      pushd $ANDROID_NDK;
-        git remote add dneto0 https://github.com/dneto0/android-ndk.git;
-        git fetch --depth=1 dneto0 r17b-strip;
-        git checkout FETCH_HEAD;
-      popd;
-      export TOOLCHAIN_PATH=$ANDROID_NDK/build/cmake/android.toolchain.cmake;
-    fi
-
-before_script:
-  - git clone --depth=1 https://github.com/google/googletest.git External/googletest
-  - ./update_glslang_sources.py
-
-script:
-  - mkdir build && cd build
-  # For Android, do release building using NDK without testing.
-  # Use android-14, the oldest native API level supporeted by NDK r17b.
-  # We can use newer API levels if we want.
-  # For Linux and macOS, do debug/release building with testing.
-  - if [[ "$BUILD_NDK" == "ON" ]]; then
-      cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_PATH}
-            -DANDROID_NATIVE_API_LEVEL=android-14
-            -DCMAKE_BUILD_TYPE=Release
-            -DANDROID_ABI="armeabi-v7a with NEON"
-            -DBUILD_TESTING=OFF ..;
-      make -j4;
-    else
-      cmake -DCMAKE_BUILD_TYPE=${GLSLANG_BUILD_TYPE}
-            -DCMAKE_INSTALL_PREFIX=`pwd`/install ..;
-      make -j4 install;
-      ctest --output-on-failure &&
-      cd ../Test && ./runtests;
-    fi
-
-after_success:
-  # For debug build, the generated dll has a postfix "d" in its name.
-  - if [[ "${GLSLANG_BUILD_TYPE}" == "Debug" ]]; then
-      export SUFFIX="d";
-    else
-      export SUFFIX="";
-    fi
-  # Create tarball for deployment
-  - if [[ ${CC} == clang* && "${BUILD_NDK}" != "ON" ]]; then
-      cd ../build/install;
-      export TARBALL=glslang-master-${TRAVIS_OS_NAME}-${GLSLANG_BUILD_TYPE}.zip;
-      zip ${TARBALL}
-        bin/glslangValidator
-        include/glslang/*
-        lib/libglslang${SUFFIX}.a
-        lib/libHLSL${SUFFIX}.a
-        lib/libOGLCompiler${SUFFIX}.a
-        lib/libOSDependent${SUFFIX}.a
-        lib/libSPIRV${SUFFIX}.a
-        lib/libSPVRemapper${SUFFIX}.a
-        lib/libSPIRV-Tools${SUFFIX}.a
-        lib/libSPIRV-Tools-opt${SUFFIX}.a;
-    fi
-
-before_deploy:
-  # Tag the current top of the tree as "master-tot".
-  # Travis CI replies on the tag name to properly push to GitHub Releases.
-  - git config --global user.name "Travis CI"
-  - git config --global user.email "[email protected]"
-  - git tag -f master-tot
-  - git push -q -f https://${glslangtoken}@github.com/KhronosGroup/glslang --tags
-
-deploy:
-  provider: releases
-  api_key: ${glslangtoken}
-  on:
-    branch: master
-    condition: ${CC} == clang* && ${BUILD_NDK} != ON
-  file: ${TARBALL}
-  skip_cleanup: true
-  overwrite: true

core/deps/glslang/Android.mk

@@ -1,100 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-GLSLANG_OS_FLAGS := -DGLSLANG_OSINCLUDE_UNIX
-# AMD and NV extensions are turned on by default in upstream Glslang.
-GLSLANG_DEFINES:= -DAMD_EXTENSIONS -DNV_EXTENSIONS -DENABLE_HLSL $(GLSLANG_OS_FLAGS)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE:=OSDependent
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
-LOCAL_SRC_FILES:=glslang/OSDependent/Unix/ossource.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH) $(LOCAL_PATH)/glslang/OSDependent/Unix/
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)/glslang/OSDependent/Unix/
-include $(BUILD_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE:=OGLCompiler
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
-LOCAL_SRC_FILES:=OGLCompilersDLL/InitializeDll.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH)/OGLCompiler
-LOCAL_STATIC_LIBRARIES:=OSDependent
-include $(BUILD_STATIC_LIBRARY)
-
-# Build Glslang's HLSL parser library.
-include $(CLEAR_VARS)
-LOCAL_MODULE:=HLSL
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
-LOCAL_SRC_FILES:= \
-		hlsl/hlslAttributes.cpp \
-		hlsl/hlslGrammar.cpp \
-		hlsl/hlslOpMap.cpp \
-		hlsl/hlslParseables.cpp \
-		hlsl/hlslParseHelper.cpp \
-		hlsl/hlslScanContext.cpp \
-		hlsl/hlslTokenStream.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH) \
-	$(LOCAL_PATH)/hlsl
-include $(BUILD_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-GLSLANG_OUT_PATH=$(if $(call host-path-is-absolute,$(TARGET_OUT)),$(TARGET_OUT),$(abspath $(TARGET_OUT)))
-
-LOCAL_MODULE:=glslang
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
-LOCAL_SRC_FILES:= \
-		glslang/GenericCodeGen/CodeGen.cpp \
-		glslang/GenericCodeGen/Link.cpp \
-		glslang/MachineIndependent/attribute.cpp \
-		glslang/MachineIndependent/Constant.cpp \
-		glslang/MachineIndependent/glslang_tab.cpp \
-		glslang/MachineIndependent/InfoSink.cpp \
-		glslang/MachineIndependent/Initialize.cpp \
-		glslang/MachineIndependent/Intermediate.cpp \
-		glslang/MachineIndependent/intermOut.cpp \
-		glslang/MachineIndependent/IntermTraverse.cpp \
-		glslang/MachineIndependent/iomapper.cpp \
-		glslang/MachineIndependent/limits.cpp \
-		glslang/MachineIndependent/linkValidate.cpp \
-		glslang/MachineIndependent/parseConst.cpp \
-		glslang/MachineIndependent/ParseContextBase.cpp \
-		glslang/MachineIndependent/ParseHelper.cpp \
-		glslang/MachineIndependent/PoolAlloc.cpp \
-		glslang/MachineIndependent/propagateNoContraction.cpp \
-		glslang/MachineIndependent/reflection.cpp \
-		glslang/MachineIndependent/RemoveTree.cpp \
-		glslang/MachineIndependent/Scan.cpp \
-		glslang/MachineIndependent/ShaderLang.cpp \
-		glslang/MachineIndependent/SymbolTable.cpp \
-		glslang/MachineIndependent/Versions.cpp \
-		glslang/MachineIndependent/preprocessor/PpAtom.cpp \
-		glslang/MachineIndependent/preprocessor/PpContext.cpp \
-		glslang/MachineIndependent/preprocessor/Pp.cpp \
-		glslang/MachineIndependent/preprocessor/PpScanner.cpp \
-		glslang/MachineIndependent/preprocessor/PpTokens.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH) \
-	$(LOCAL_PATH)/glslang/MachineIndependent \
-	$(GLSLANG_OUT_PATH)
-LOCAL_STATIC_LIBRARIES:=OSDependent OGLCompiler HLSL
-include $(BUILD_STATIC_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE:=SPIRV
-LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti -Werror $(GLSLANG_DEFINES)
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
-LOCAL_SRC_FILES:= \
-	SPIRV/GlslangToSpv.cpp \
-	SPIRV/InReadableOrder.cpp \
-	SPIRV/Logger.cpp \
-	SPIRV/SPVRemapper.cpp \
-	SPIRV/SpvBuilder.cpp \
-	SPIRV/SpvPostProcess.cpp \
-	SPIRV/SpvTools.cpp \
-	SPIRV/disassemble.cpp \
-	SPIRV/doc.cpp
-LOCAL_C_INCLUDES:=$(LOCAL_PATH) $(LOCAL_PATH)/glslang/SPIRV
-LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)/glslang/SPIRV
-LOCAL_STATIC_LIBRARIES:=glslang
-include $(BUILD_STATIC_LIBRARY)

core/deps/glslang/BUILD.bazel

@@ -1,247 +0,0 @@
-package(
-    default_visibility = ["//visibility:public"],
-)
-
-# Description:
-#
-# Khronos reference front-end for GLSL and ESSL, and sample SPIR-V generator.
-
-licenses(["notice"])
-
-exports_files(["LICENSE"])
-
-COMMON_COPTS = select({
-    "@bazel_tools//src/conditions:windows": [""],
-    "//conditions:default": [
-        "-Wall",
-        "-Wuninitialized",
-        "-Wunused",
-        "-Wunused-local-typedefs",
-        "-Wunused-parameter",
-        "-Wunused-value",
-        "-Wunused-variable",
-        "-Wno-reorder",
-        "-std=c++11",
-        "-fvisibility=hidden",
-        "-fvisibility-inlines-hidden",
-        "-fno-exceptions",
-        "-fno-rtti",
-    ],
-})
-
-cc_library(
-    name = "glslang",
-    srcs = glob(
-        [
-            "glslang/GenericCodeGen/*.cpp",
-            "glslang/MachineIndependent/*.cpp",
-            "glslang/MachineIndependent/preprocessor/*.cpp",
-            "hlsl/*.cpp",
-        ],
-        exclude = [
-            "glslang/MachineIndependent/pch.cpp",
-            "glslang/MachineIndependent/pch.h",
-            "hlsl/pch.cpp",
-            "hlsl/pch.h",
-        ],
-    ) + [
-        "OGLCompilersDLL/InitializeDll.cpp",
-    ] + select({
-        "@bazel_tools//src/conditions:windows":
-            ["glslang/OSDependent/Windows/ossource.cpp"],
-        "//conditions:default":
-            ["glslang/OSDependent/Unix/ossource.cpp"],
-    }),
-    hdrs = glob([
-        "glslang/Include/*.h",
-        "glslang/MachineIndependent/*.h",
-        "glslang/MachineIndependent/preprocessor/*.h",
-        "hlsl/*.h",
-    ]) + [
-        "OGLCompilersDLL/InitializeDll.h",
-        "StandAlone/DirStackFileIncluder.h",
-        "glslang/OSDependent/osinclude.h",
-        "glslang/Public/ShaderLang.h",
-    ],
-    copts = COMMON_COPTS,
-    defines = [
-        "AMD_EXTENSIONS",
-        "ENABLE_HLSL=0",
-        "ENABLE_OPT=0",
-        "NV_EXTENSIONS",
-    ],
-    linkopts = select({
-        "@bazel_tools//src/conditions:windows": [""],
-        "//conditions:default": ["-lm", "-lpthread"],
-    }),
-    linkstatic = 1,
-)
-
-genrule(
-    name = "export_spirv_headers",
-    srcs = [
-        "SPIRV/GLSL.ext.AMD.h",
-        "SPIRV/GLSL.ext.EXT.h",
-        "SPIRV/GLSL.ext.KHR.h",
-        "SPIRV/GLSL.ext.NV.h",
-        "SPIRV/GLSL.std.450.h",
-        "SPIRV/NonSemanticDebugPrintf.h",
-        "SPIRV/spirv.hpp",
-    ],
-    outs = [
-        "include/SPIRV/GLSL.ext.AMD.h",
-        "include/SPIRV/GLSL.ext.EXT.h",
-        "include/SPIRV/GLSL.ext.KHR.h",
-        "include/SPIRV/GLSL.ext.NV.h",
-        "include/SPIRV/GLSL.std.450.h",
-        "include/SPIRV/NonSemanticDebugPrintf.h",
-        "include/SPIRV/spirv.hpp",
-    ],
-    cmd = "mkdir -p $(@D)/include/SPIRV && cp $(SRCS) $(@D)/include/SPIRV/",
-)
-
-cc_library(
-    name = "SPIRV_headers",
-    hdrs = [":export_spirv_headers"],
-    copts = COMMON_COPTS,
-    includes = [
-        "include",
-        "include/SPIRV",
-    ],
-    linkstatic = 1,
-)
-
-cc_library(
-    name = "SPIRV",
-    srcs = glob(
-        ["SPIRV/*.cpp"],
-        exclude = [
-            "SPIRV/SpvTools.cpp",
-        ],
-    ),
-    hdrs = [
-        "SPIRV/GlslangToSpv.h",
-        "SPIRV/Logger.h",
-        "SPIRV/SPVRemapper.h",
-        "SPIRV/SpvBuilder.h",
-        "SPIRV/SpvTools.h",
-        "SPIRV/bitutils.h",
-        "SPIRV/disassemble.h",
-        "SPIRV/doc.h",
-        "SPIRV/hex_float.h",
-        "SPIRV/spvIR.h",
-    ],
-    copts = COMMON_COPTS,
-    includes = ["SPIRV"],
-    linkopts = select({
-        "@bazel_tools//src/conditions:windows": [""],
-        "//conditions:default": ["-lm"],
-    }),
-    linkstatic = 1,
-    deps = [
-        ":SPIRV_headers",
-        ":glslang",
-    ],
-)
-
-cc_library(
-    name = "glslang-default-resource-limits",
-    srcs = ["StandAlone/ResourceLimits.cpp"],
-    hdrs = ["StandAlone/ResourceLimits.h"],
-    copts = COMMON_COPTS,
-    linkstatic = 1,
-    deps = [":glslang"],
-)
-
-cc_binary(
-    name = "glslangValidator",
-    srcs = [
-        "StandAlone/StandAlone.cpp",
-        "StandAlone/Worklist.h",
-    ],
-    copts = COMMON_COPTS,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-    ],
-)
-
-cc_binary(
-    name = "spirv-remap",
-    srcs = ["StandAlone/spirv-remap.cpp"],
-    copts = COMMON_COPTS,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-    ],
-)
-
-filegroup(
-    name = "test_files",
-    srcs = glob(
-        ["Test/**"],
-        exclude = [
-            "Test/bump",
-            "Test/glslangValidator",
-            "Test/runtests",
-        ],
-    ),
-)
-
-cc_library(
-    name = "glslang_test_lib",
-    testonly = 1,
-    srcs = [
-        "gtests/HexFloat.cpp",
-        "gtests/Initializer.h",
-        "gtests/Settings.cpp",
-        "gtests/Settings.h",
-        "gtests/TestFixture.cpp",
-        "gtests/TestFixture.h",
-        "gtests/main.cpp",
-    ],
-    copts = COMMON_COPTS,
-    data = [":test_files"],
-    defines = select({
-        # Unfortunately we can't use $(location) in cc_library at the moment.
-        # See https://github.com/bazelbuild/bazel/issues/1023
-        # So we'll specify the path manually.
-        "@bazel_tools//src/conditions:windows":
-            ["GLSLANG_TEST_DIRECTORY='\"../../../../../Test\"'"],
-        "//conditions:default":
-            ["GLSLANG_TEST_DIRECTORY='\"Test\"'"],
-    }),
-    linkstatic = 1,
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang-default-resource-limits",
-        "@com_google_googletest//:gtest",
-    ],
-)
-
-GLSLANG_TESTS = glob(
-    ["gtests/*.FromFile.cpp"],
-    # Since we are not building the SPIRV-Tools dependency, the following tests
-    # cannot be performed.
-    exclude = [
-        "gtests/Hlsl.FromFile.cpp",
-        "gtests/Spv.FromFile.cpp",
-    ],
-)
-
-[cc_test(
-    name = test_file.replace("gtests/", "").replace(".FromFile.cpp", "") + "_test",
-    srcs = [test_file],
-    copts = COMMON_COPTS,
-    data = [
-        ":test_files",
-    ],
-    deps = [
-        ":SPIRV",
-        ":glslang",
-        ":glslang_test_lib",
-    ],
-) for test_file in GLSLANG_TESTS]

core/deps/glslang/BUILD.gn

@@ -1,248 +0,0 @@
-# Copyright (C) 2018 Google, Inc.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-#    Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-#
-#    Redistributions in binary form must reproduce the above
-#    copyright notice, this list of conditions and the following
-#    disclaimer in the documentation and/or other materials provided
-#    with the distribution.
-#
-#    Neither the name of Google Inc. nor the names of its
-#    contributors may be used to endorse or promote products derived
-#    from this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-
-import("//build_overrides/glslang.gni")
-
-# Both Chromium and Fuchsia use by default a set of warning errors
-# that is far too strict to compile this project. These are also
-# typically appended after |cflags|, overriding target-specific
-# definitions. To work around this, determine which configs to
-# add and remove in order to succesfully build the project.
-if (defined(is_fuchsia_tree) && is_fuchsia_tree) {
-  _configs_to_remove = [ "//build/config:default_warnings" ]
-  _configs_to_add = []
-} else {
-  _configs_to_remove = [ "//build/config/compiler:chromium_code" ]
-  _configs_to_add = [ "//build/config/compiler:no_chromium_code" ]
-}
-
-spirv_tools_dir = glslang_spirv_tools_dir
-
-config("glslang_public") {
-  include_dirs = [ "." ]
-
-  defines = [ "ENABLE_HLSL=1" ]
-}
-
-source_set("glslang_sources") {
-  public_configs = [ ":glslang_public" ]
-
-  sources = [
-    "OGLCompilersDLL/InitializeDll.cpp",
-    "OGLCompilersDLL/InitializeDll.h",
-    "SPIRV/GLSL.ext.AMD.h",
-    "SPIRV/GLSL.ext.EXT.h",
-    "SPIRV/GLSL.ext.KHR.h",
-    "SPIRV/GLSL.ext.NV.h",
-    "SPIRV/GLSL.std.450.h",
-    "SPIRV/GlslangToSpv.cpp",
-    "SPIRV/GlslangToSpv.h",
-    "SPIRV/InReadableOrder.cpp",
-    "SPIRV/Logger.cpp",
-    "SPIRV/Logger.h",
-    "SPIRV/NonSemanticDebugPrintf.h",
-    "SPIRV/SPVRemapper.cpp",
-    "SPIRV/SPVRemapper.h",
-    "SPIRV/SpvBuilder.cpp",
-    "SPIRV/SpvBuilder.h",
-    "SPIRV/SpvPostProcess.cpp",
-    "SPIRV/SpvTools.cpp",
-    "SPIRV/SpvTools.h",
-    "SPIRV/bitutils.h",
-    "SPIRV/disassemble.cpp",
-    "SPIRV/disassemble.h",
-    "SPIRV/doc.cpp",
-    "SPIRV/doc.h",
-    "SPIRV/hex_float.h",
-    "SPIRV/spirv.hpp",
-    "SPIRV/spvIR.h",
-    "glslang/GenericCodeGen/CodeGen.cpp",
-    "glslang/GenericCodeGen/Link.cpp",
-    "glslang/Include/BaseTypes.h",
-    "glslang/Include/Common.h",
-    "glslang/Include/ConstantUnion.h",
-    "glslang/Include/InfoSink.h",
-    "glslang/Include/InitializeGlobals.h",
-    "glslang/Include/PoolAlloc.h",
-    "glslang/Include/ResourceLimits.h",
-    "glslang/Include/ShHandle.h",
-    "glslang/Include/Types.h",
-    "glslang/Include/arrays.h",
-    "glslang/Include/intermediate.h",
-    "glslang/Include/revision.h",
-    "glslang/MachineIndependent/Constant.cpp",
-    "glslang/MachineIndependent/InfoSink.cpp",
-    "glslang/MachineIndependent/Initialize.cpp",
-    "glslang/MachineIndependent/Initialize.h",
-    "glslang/MachineIndependent/IntermTraverse.cpp",
-    "glslang/MachineIndependent/Intermediate.cpp",
-    "glslang/MachineIndependent/LiveTraverser.h",
-    "glslang/MachineIndependent/ParseContextBase.cpp",
-    "glslang/MachineIndependent/ParseHelper.cpp",
-    "glslang/MachineIndependent/ParseHelper.h",
-    "glslang/MachineIndependent/PoolAlloc.cpp",
-    "glslang/MachineIndependent/RemoveTree.cpp",
-    "glslang/MachineIndependent/RemoveTree.h",
-    "glslang/MachineIndependent/Scan.cpp",
-    "glslang/MachineIndependent/Scan.h",
-    "glslang/MachineIndependent/ScanContext.h",
-    "glslang/MachineIndependent/ShaderLang.cpp",
-    "glslang/MachineIndependent/SymbolTable.cpp",
-    "glslang/MachineIndependent/SymbolTable.h",
-    "glslang/MachineIndependent/Versions.cpp",
-    "glslang/MachineIndependent/Versions.h",
-    "glslang/MachineIndependent/attribute.cpp",
-    "glslang/MachineIndependent/attribute.h",
-    "glslang/MachineIndependent/gl_types.h",
-    "glslang/MachineIndependent/glslang_tab.cpp",
-    "glslang/MachineIndependent/glslang_tab.cpp.h",
-    "glslang/MachineIndependent/intermOut.cpp",
-    "glslang/MachineIndependent/iomapper.cpp",
-    "glslang/MachineIndependent/iomapper.h",
-    "glslang/MachineIndependent/limits.cpp",
-    "glslang/MachineIndependent/linkValidate.cpp",
-    "glslang/MachineIndependent/localintermediate.h",
-    "glslang/MachineIndependent/parseConst.cpp",
-    "glslang/MachineIndependent/parseVersions.h",
-    "glslang/MachineIndependent/preprocessor/Pp.cpp",
-    "glslang/MachineIndependent/preprocessor/PpAtom.cpp",
-    "glslang/MachineIndependent/preprocessor/PpContext.cpp",
-    "glslang/MachineIndependent/preprocessor/PpContext.h",
-    "glslang/MachineIndependent/preprocessor/PpScanner.cpp",
-    "glslang/MachineIndependent/preprocessor/PpTokens.cpp",
-    "glslang/MachineIndependent/preprocessor/PpTokens.h",
-    "glslang/MachineIndependent/propagateNoContraction.cpp",
-    "glslang/MachineIndependent/propagateNoContraction.h",
-    "glslang/MachineIndependent/reflection.cpp",
-    "glslang/MachineIndependent/reflection.h",
-    "glslang/OSDependent/osinclude.h",
-    "glslang/Public/ShaderLang.h",
-    "hlsl/hlslAttributes.cpp",
-    "hlsl/hlslAttributes.h",
-    "hlsl/hlslGrammar.cpp",
-    "hlsl/hlslGrammar.h",
-    "hlsl/hlslOpMap.cpp",
-    "hlsl/hlslOpMap.h",
-    "hlsl/hlslParseHelper.cpp",
-    "hlsl/hlslParseHelper.h",
-    "hlsl/hlslParseables.cpp",
-    "hlsl/hlslParseables.h",
-    "hlsl/hlslScanContext.cpp",
-    "hlsl/hlslScanContext.h",
-    "hlsl/hlslTokenStream.cpp",
-    "hlsl/hlslTokenStream.h",
-    "hlsl/hlslTokens.h",
-  ]
-
-  defines = [ "ENABLE_OPT=1" ]
-
-  if (is_win) {
-    sources += [ "glslang/OSDependent/Windows/ossource.cpp" ]
-    defines += [ "GLSLANG_OSINCLUDE_WIN32" ]
-  } else {
-    sources += [ "glslang/OSDependent/Unix/ossource.cpp" ]
-    defines += [ "GLSLANG_OSINCLUDE_UNIX" ]
-  }
-
-  if (is_clang) {
-    cflags = [
-      "-Wno-extra-semi",
-      "-Wno-ignored-qualifiers",
-      "-Wno-implicit-fallthrough",
-      "-Wno-inconsistent-missing-override",
-      "-Wno-sign-compare",
-      "-Wno-unused-variable",
-      "-Wno-missing-field-initializers",
-      "-Wno-newline-eof",
-    ]
-  }
-  if (is_win && !is_clang) {
-    cflags = [
-      "/wd4018",  # signed/unsigned mismatch
-      "/wd4189",  # local variable is initialized but not referenced
-    ]
-  }
-
-  deps = [
-    "${spirv_tools_dir}:spvtools_opt",
-    "${spirv_tools_dir}:spvtools_val",
-  ]
-
-  configs -= _configs_to_remove
-  configs += _configs_to_add
-}
-
-source_set("glslang_default_resource_limits_sources") {
-  sources = [
-    "StandAlone/ResourceLimits.cpp",
-    "StandAlone/ResourceLimits.h",
-  ]
-  deps = [
-    ":glslang_sources",
-  ]
-  public_configs = [ ":glslang_public" ]
-
-  configs -= _configs_to_remove
-  configs += _configs_to_add
-}
-
-executable("glslang_validator") {
-  sources = [
-    "StandAlone/DirStackFileIncluder.h",
-    "StandAlone/StandAlone.cpp",
-  ]
-  if (!is_win) {
-    cflags = [ "-Woverflow" ]
-  }
-  defines = [ "ENABLE_OPT=1" ]
-  deps = [
-    ":glslang_default_resource_limits_sources",
-    ":glslang_sources",
-  ]
-
-  configs -= _configs_to_remove
-  configs += _configs_to_add
-}
-
-executable("spirv-remap") {
-  sources = [
-    "StandAlone/spirv-remap.cpp",
-  ]
-  defines = [ "ENABLE_OPT=1" ]
-  deps = [
-    ":glslang_sources",
-  ]
-
-  configs -= _configs_to_remove
-  configs += _configs_to_add
-}

core/deps/glslang/CMakeLists.txt

@@ -1,229 +0,0 @@
-# increase to 3.1 once all major distributions
-# include a version of CMake >= 3.1
-cmake_minimum_required(VERSION 2.8.12)
-if (POLICY CMP0048)
-  cmake_policy(SET CMP0048 NEW)
-endif()
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-
-# Enable compile commands database
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-# Adhere to GNU filesystem layout conventions
-include(GNUInstallDirs)
-
-# Needed for CMAKE_DEPENDENT_OPTION macro
-include(CMakeDependentOption)
-
-option(BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
-option(BUILD_EXTERNAL "Build external dependencies in /External" ON)
-
-set(LIB_TYPE STATIC)
-
-if(BUILD_SHARED_LIBS)
-    set(LIB_TYPE SHARED)
-endif()
-
-option(SKIP_GLSLANG_INSTALL "Skip installation" ${SKIP_GLSLANG_INSTALL})
-if(NOT ${SKIP_GLSLANG_INSTALL})
-  set(ENABLE_GLSLANG_INSTALL ON)
-endif()
-option(ENABLE_SPVREMAPPER "Enables building of SPVRemapper" ON)
-
-option(ENABLE_GLSLANG_BINARIES "Builds glslangValidator and spirv-remap" ON)
-
-option(ENABLE_GLSLANG_JS
-    "If using Emscripten, build glslang.js. Otherwise, builds a sample executable for binary-size testing." OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_GLSLANG_WEBMIN
-    "Reduces glslang to minimum needed for web use"
-    OFF "ENABLE_GLSLANG_JS"
-    OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_GLSLANG_WEBMIN_DEVEL
-    "For ENABLE_GLSLANG_WEBMIN builds, enables compilation error messages"
-    OFF "ENABLE_GLSLANG_WEBMIN"
-    OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_EMSCRIPTEN_SINGLE_FILE
-    "If using Emscripten, enables SINGLE_FILE build"
-    OFF "ENABLE_GLSLANG_JS AND EMSCRIPTEN"
-    OFF)
-CMAKE_DEPENDENT_OPTION(ENABLE_EMSCRIPTEN_ENVIRONMENT_NODE
-    "If using Emscripten, builds to run on Node instead of Web"
-    OFF "ENABLE_GLSLANG_JS AND EMSCRIPTEN"
-    OFF)
-
-CMAKE_DEPENDENT_OPTION(ENABLE_HLSL
-    "Enables HLSL input support"
-    ON "NOT ENABLE_GLSLANG_WEBMIN"
-    OFF)
-
-option(ENABLE_RTTI "Enables RTTI" OFF)
-option(ENABLE_OPT "Enables spirv-opt capability if present" ON)
-option(ENABLE_PCH "Enables Precompiled header" ON)
-option(ENABLE_CTEST "Enables testing" ON)
-
-if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32)
-    set(CMAKE_INSTALL_PREFIX "install" CACHE STRING "..." FORCE)
-endif()
-
-option(USE_CCACHE "Use ccache" OFF)
-if(USE_CCACHE)
-    find_program(CCACHE_FOUND ccache)
-    if(CCACHE_FOUND)
-        set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
-    endif(CCACHE_FOUND)
-endif()
-
-# Precompiled header macro. Parameters are source file list and filename for pch cpp file.
-macro(glslang_pch SRCS PCHCPP)
-  if(MSVC AND CMAKE_GENERATOR MATCHES "^Visual Studio" AND NOT ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" AND ENABLE_PCH)
-    set(PCH_NAME "$(IntDir)\\pch.pch")
-    # make source files use/depend on PCH_NAME
-    set_source_files_properties(${${SRCS}} PROPERTIES COMPILE_FLAGS "/Yupch.h /FIpch.h /Fp${PCH_NAME} /Zm300" OBJECT_DEPENDS "${PCH_NAME}")
-    # make PCHCPP file compile and generate PCH_NAME
-    set_source_files_properties(${PCHCPP} PROPERTIES COMPILE_FLAGS "/Ycpch.h /Fp${PCH_NAME} /Zm300" OBJECT_OUTPUTS "${PCH_NAME}")
-    list(APPEND ${SRCS} "${PCHCPP}")
-  endif()
-endmacro(glslang_pch)
-
-project(glslang)
-
-if(ENABLE_CTEST)
-    include(CTest)
-endif()
-
-if(ENABLE_HLSL)
-    add_definitions(-DENABLE_HLSL)
-endif(ENABLE_HLSL)
-
-if(ENABLE_GLSLANG_WEBMIN)
-    add_definitions(-DGLSLANG_WEB)
-    if(ENABLE_GLSLANG_WEBMIN_DEVEL)
-        add_definitions(-DGLSLANG_WEB_DEVEL)
-    endif(ENABLE_GLSLANG_WEBMIN_DEVEL)
-endif(ENABLE_GLSLANG_WEBMIN)
-
-if(WIN32)
-    set(CMAKE_DEBUG_POSTFIX "d")
-    if(MSVC)
-        include(ChooseMSVCCRT.cmake)
-    endif(MSVC)
-    add_definitions(-DGLSLANG_OSINCLUDE_WIN32)
-elseif(UNIX)
-    add_definitions(-DGLSLANG_OSINCLUDE_UNIX)
-else(WIN32)
-    message("unknown platform")
-endif(WIN32)
-
-if(${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
-    add_compile_options(-Wall -Wmaybe-uninitialized -Wuninitialized -Wunused -Wunused-local-typedefs
-                        -Wunused-parameter -Wunused-value  -Wunused-variable -Wunused-but-set-parameter -Wunused-but-set-variable -fno-exceptions)
-    add_compile_options(-Wno-reorder)  # disable this from -Wall, since it happens all over.
-    if(NOT ENABLE_RTTI)
-        add_compile_options(-fno-rtti)
-    endif()
-    if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "9.0.0")
-        add_compile_options(-Werror=deprecated-copy)
-    endif()
-elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" AND NOT MSVC)
-    add_compile_options(-Wall -Wuninitialized -Wunused -Wunused-local-typedefs
-                        -Wunused-parameter -Wunused-value  -Wunused-variable)
-    add_compile_options(-Wno-reorder)  # disable this from -Wall, since it happens all over.
-    if(NOT ENABLE_RTTI)
-        add_compile_options(-fno-rtti)
-    endif()
-elseif(MSVC)
-    if(NOT ENABLE_RTTI)
-        add_compile_options(/GR-) # Disable RTTI
-    endif()
-endif()
-
-if(ENABLE_GLSLANG_JS)
-    if(MSVC)
-        add_compile_options(/Os /GR-)
-    else()
-        add_compile_options(-Os -fno-exceptions)
-        if(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" AND NOT MSVC)
-            add_compile_options(-Wno-unused-parameter)
-            add_compile_options(-Wno-unused-variable -Wno-unused-const-variable)
-        endif()
-    endif()
-endif(ENABLE_GLSLANG_JS)
-
-# Request C++11
-if(${CMAKE_VERSION} VERSION_LESS 3.1)
-    # CMake versions before 3.1 do not understand CMAKE_CXX_STANDARD
-    # remove this block once CMake >=3.1 has fixated in the ecosystem
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-else()
-    set(CMAKE_CXX_STANDARD 11)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-    set(CMAKE_CXX_EXTENSIONS OFF)
-endif()
-
-function(glslang_set_link_args TARGET)
-    # For MinGW compiles, statically link against the GCC and C++ runtimes.
-    # This avoids the need to ship those runtimes as DLLs.
-    if(WIN32 AND ${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
-        set_target_properties(${TARGET} PROPERTIES
-                              LINK_FLAGS "-static -static-libgcc -static-libstdc++")
-    endif()
-endfunction(glslang_set_link_args)
-
-# CMake needs to find the right version of python, right from the beginning,
-# otherwise, it will find the wrong version and fail later
-if(BUILD_EXTERNAL AND IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/External)
-    find_package(PythonInterp 3 REQUIRED)
-
-	# We depend on these for later projects, so they should come first.
-	add_subdirectory(External)
-endif()
-
-if(NOT TARGET SPIRV-Tools-opt)
-    set(ENABLE_OPT OFF)
-endif()
-
-if(ENABLE_OPT)
-    message(STATUS "optimizer enabled")
-    add_definitions(-DENABLE_OPT=1)
-else()
-    if(ENABLE_HLSL)
-        message(STATUS "spirv-tools not linked - illegal SPIRV may be generated for HLSL")
-    endif()
-    add_definitions(-DENABLE_OPT=0)
-endif()
-
-add_subdirectory(glslang)
-add_subdirectory(OGLCompilersDLL)
-if(ENABLE_GLSLANG_BINARIES)
-    add_subdirectory(StandAlone)
-endif()
-add_subdirectory(SPIRV)
-if(ENABLE_HLSL)
-    add_subdirectory(hlsl)
-endif(ENABLE_HLSL)
-if(ENABLE_CTEST)
-    add_subdirectory(gtests)
-endif()
-
-if(BUILD_TESTING)
-    # glslang-testsuite runs a bash script on Windows.
-    # Make sure to use '-o igncr' flag to ignore carriage returns (\r).
-    set(IGNORE_CR_FLAG "")
-    if(WIN32)
-        set(IGNORE_CR_FLAG -o igncr)
-    endif()
-
-    if (CMAKE_CONFIGURATION_TYPES)
-        set(RESULTS_PATH ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>/localResults)
-        set(VALIDATOR_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/$<CONFIGURATION>/glslangValidator)
-        set(REMAP_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/$<CONFIGURATION>/spirv-remap)
-    else(CMAKE_CONFIGURATION_TYPES)
-        set(RESULTS_PATH ${CMAKE_CURRENT_BINARY_DIR}/localResults)
-        set(VALIDATOR_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/glslangValidator)
-        set(REMAP_PATH ${CMAKE_CURRENT_BINARY_DIR}/StandAlone/spirv-remap)
-    endif(CMAKE_CONFIGURATION_TYPES)
-
-    add_test(NAME glslang-testsuite
-        COMMAND bash ${IGNORE_CR_FLAG} runtests ${RESULTS_PATH} ${VALIDATOR_PATH} ${REMAP_PATH}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Test/)
-endif(BUILD_TESTING)

core/deps/glslang/CODE_OF_CONDUCT.md

@@ -1 +0,0 @@
-A reminder that this issue tracker is managed by the Khronos Group. Interactions here should follow the Khronos Code of Conduct (https://www.khronos.org/developers/code-of-conduct), which prohibits aggressive or derogatory language. Please keep the discussion friendly and civil.

core/deps/glslang/ChooseMSVCCRT.cmake

@@ -1,105 +0,0 @@
-# The macro choose_msvc_crt() takes a list of possible
-# C runtimes to choose from, in the form of compiler flags,
-# to present to the user. (MTd for /MTd, etc)
-#
-# The macro is invoked at the end of the file.
-#
-# CMake already sets CRT flags in the CMAKE_CXX_FLAGS_* and
-# CMAKE_C_FLAGS_* variables by default. To let the user
-# override that for each build type:
-# 1. Detect which CRT is already selected, and reflect this in
-# LLVM_USE_CRT_* so the user can have a better idea of what
-# changes they're making.
-# 2. Replace the flags in both variables with the new flag via a regex.
-# 3. set() the variables back into the cache so the changes
-# are user-visible.
-
-### Helper macros: ###
-macro(make_crt_regex regex crts)
-  set(${regex} "")
-  foreach(crt ${${crts}})
-    # Trying to match the beginning or end of the string with stuff
-    # like [ ^]+ didn't work, so use a bunch of parentheses instead.
-    set(${regex} "${${regex}}|(^| +)/${crt}($| +)")
-  endforeach(crt)
-  string(REGEX REPLACE "^\\|" "" ${regex} "${${regex}}")
-endmacro(make_crt_regex)
-
-macro(get_current_crt crt_current regex flagsvar)
-  # Find the selected-by-CMake CRT for each build type, if any.
-  # Strip off the leading slash and any whitespace.
-  string(REGEX MATCH "${${regex}}" ${crt_current} "${${flagsvar}}")
-  string(REPLACE "/" " " ${crt_current} "${${crt_current}}")
-  string(STRIP "${${crt_current}}" ${crt_current})
-endmacro(get_current_crt)
-
-# Replaces or adds a flag to a variable.
-# Expects 'flag' to be padded with spaces.
-macro(set_flag_in_var flagsvar regex flag)
-  string(REGEX MATCH "${${regex}}" current_flag "${${flagsvar}}")
-  if("${current_flag}" STREQUAL "")
-    set(${flagsvar} "${${flagsvar}}${${flag}}")
-  else()
-    string(REGEX REPLACE "${${regex}}" "${${flag}}" ${flagsvar} "${${flagsvar}}")
-  endif()
-  string(STRIP "${${flagsvar}}" ${flagsvar})
-  # Make sure this change gets reflected in the cache/gui.
-  # CMake requires the docstring parameter whenever set() touches the cache,
-  # so get the existing docstring and re-use that.
-  get_property(flagsvar_docs CACHE ${flagsvar} PROPERTY HELPSTRING)
-  set(${flagsvar} "${${flagsvar}}" CACHE STRING "${flagsvar_docs}" FORCE)
-endmacro(set_flag_in_var)
-
-
-macro(choose_msvc_crt MSVC_CRT)
-  if(LLVM_USE_CRT)
-    message(FATAL_ERROR
-      "LLVM_USE_CRT is deprecated. Use the CMAKE_BUILD_TYPE-specific
-variables (LLVM_USE_CRT_DEBUG, etc) instead.")
-  endif()
-
-  make_crt_regex(MSVC_CRT_REGEX ${MSVC_CRT})
-
-  foreach(build_type ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE})
-    string(TOUPPER "${build_type}" build)
-    if (NOT LLVM_USE_CRT_${build})
-      get_current_crt(LLVM_USE_CRT_${build}
-        MSVC_CRT_REGEX
-        CMAKE_CXX_FLAGS_${build})
-      set(LLVM_USE_CRT_${build}
-        "${LLVM_USE_CRT_${build}}"
-        CACHE STRING "Specify VC++ CRT to use for ${build_type} configurations."
-        FORCE)
-      set_property(CACHE LLVM_USE_CRT_${build}
-        PROPERTY STRINGS ;${${MSVC_CRT}})
-    endif(NOT LLVM_USE_CRT_${build})
-  endforeach(build_type)
-
-  foreach(build_type ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE})
-    string(TOUPPER "${build_type}" build)
-    if ("${LLVM_USE_CRT_${build}}" STREQUAL "")
-      set(flag_string " ")
-    else()
-      set(flag_string " /${LLVM_USE_CRT_${build}} ")
-      list(FIND ${MSVC_CRT} ${LLVM_USE_CRT_${build}} idx)
-      if (idx LESS 0)
-        message(FATAL_ERROR
-          "Invalid value for LLVM_USE_CRT_${build}: ${LLVM_USE_CRT_${build}}. Valid options are one of: ${${MSVC_CRT}}")
-      endif (idx LESS 0)
-      message(STATUS "Using ${build_type} VC++ CRT: ${LLVM_USE_CRT_${build}}")
-    endif()
-    foreach(lang C CXX)
-      set_flag_in_var(CMAKE_${lang}_FLAGS_${build} MSVC_CRT_REGEX flag_string)
-    endforeach(lang)
-  endforeach(build_type)
-endmacro(choose_msvc_crt MSVC_CRT)
-
-
-# List of valid CRTs for MSVC
-set(MSVC_CRT
-  MD
-  MDd
-  MT
-  MTd)
-
-choose_msvc_crt(MSVC_CRT)

core/deps/glslang/External/CMakeLists.txt

@@ -1,44 +0,0 @@
-# Suppress all warnings from external projects.
-set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS -w)
-
-if(BUILD_TESTING)
-    if(TARGET gmock)
-        message(STATUS "Google Mock already configured - use it")
-    elseif(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/googletest)
-        # We need to make sure Google Test does not mess up with the
-        # global CRT settings on Windows.
-        if(WIN32)
-            set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-        endif(WIN32)
-        # EXCLUDE_FROM_ALL keeps the install target from installing GTEST files.
-        add_subdirectory(googletest EXCLUDE_FROM_ALL)
-        set(GTEST_TARGETS
-            gtest
-            gtest_main
-            gmock
-            gmock_main)
-        foreach(target ${GTEST_TARGETS})
-            set_property(TARGET ${target} PROPERTY FOLDER gtest)
-        endforeach()
-        mark_as_advanced(gmock_build_tests
-            BUILD_GMOCK
-            BUILD_GTEST
-            BUILD_SHARED_LIBS
-            gtest_build_samples
-            gtest_build_tests
-            gtest_disable_pthreads
-            gtest_force_shared_crt
-            gtest_hide_internal_symbols)
-    else()
-        message(STATUS
-            "Google Mock was not found - tests based on that will not build")
-    endif()
-endif()
-
-if(ENABLE_OPT AND NOT TARGET SPIRV-Tools-opt)
-    if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/spirv-tools)
-        set(SPIRV_SKIP_TESTS ON CACHE BOOL "Skip building SPIRV-Tools tests")
-        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/spirv-tools spirv-tools)
-    endif()
-endif()
-

core/deps/glslang/LICENSE.txt

@@ -1,108 +0,0 @@
-Here, glslang proper means core GLSL parsing, HLSL parsing, and SPIR-V code
-generation. Glslang proper requires use of two licenses, one that covers
-non-preprocessing and an additional one that covers preprocessing.
-
-Bison was removed long ago. You can build glslang from the source grammar,
-using tools of your choice, without using bison or any bison files.
-
-Other parts, outside of glslang proper, include:
-
-- gl_types.h, only needed for OpenGL-like reflection, and can be left out of
-  a parse and codegen project.  See it for its license.
-
-- update_glslang_sources.py, which is not part of the project proper and does
-  not need to be used.
-
-- the SPIR-V "remapper", which is optional, but has the same license as
-  glslang proper
-
-- Google tests and SPIR-V tools, and anything in the external subdirectory
-  are external and optional; see them for their respective licenses.
-
---------------------------------------------------------------------------------
-
-The core of glslang-proper, minus the preprocessor is licenced as follows:
-
-//
-// Copyright (C) 2015-2018 Google, Inc.
-// Copyright (C) <various other dates and companies>
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-//    Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-//    Redistributions in binary form must reproduce the above
-//    copyright notice, this list of conditions and the following
-//    disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
-//    contributors may be used to endorse or promote products derived
-//    from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-
---------------------------------------------------------------------------------
-
-The preprocessor has the core license stated above, plus an additional licence:
-
-/****************************************************************************\
-Copyright (c) 2002, NVIDIA Corporation.
-
-NVIDIA Corporation("NVIDIA") supplies this software to you in
-consideration of your agreement to the following terms, and your use,
-installation, modification or redistribution of this NVIDIA software
-constitutes acceptance of these terms.  If you do not agree with these
-terms, please do not use, install, modify or redistribute this NVIDIA
-software.
-
-In consideration of your agreement to abide by the following terms, and
-subject to these terms, NVIDIA grants you a personal, non-exclusive
-license, under NVIDIA's copyrights in this original NVIDIA software (the
-"NVIDIA Software"), to use, reproduce, modify and redistribute the
-NVIDIA Software, with or without modifications, in source and/or binary
-forms; provided that if you redistribute the NVIDIA Software, you must
-retain the copyright notice of NVIDIA, this notice and the following
-text and disclaimers in all such redistributions of the NVIDIA Software.
-Neither the name, trademarks, service marks nor logos of NVIDIA
-Corporation may be used to endorse or promote products derived from the
-NVIDIA Software without specific prior written permission from NVIDIA.
-Except as expressly stated in this notice, no other rights or licenses
-express or implied, are granted by NVIDIA herein, including but not
-limited to any patent rights that may be infringed by your derivative
-works or by other works in which the NVIDIA Software may be
-incorporated. No hardware is licensed hereunder.
-
-THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED,
-INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE,
-NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
-ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER
-PRODUCTS.
-
-IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT,
-INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY
-OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE
-NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT,
-TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF
-NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-\****************************************************************************/

core/deps/glslang/OGLCompilersDLL/CMakeLists.txt

@@ -1,15 +0,0 @@
-set(SOURCES InitializeDll.cpp InitializeDll.h)
-
-add_library(OGLCompiler STATIC ${SOURCES})
-set_property(TARGET OGLCompiler PROPERTY FOLDER glslang)
-set_property(TARGET OGLCompiler PROPERTY POSITION_INDEPENDENT_CODE ON)
-
-if(WIN32)
-    source_group("Source" FILES ${SOURCES})
-endif(WIN32)
-
-if(ENABLE_GLSLANG_INSTALL)
-    install(TARGETS OGLCompiler EXPORT OGLCompilerTargets
-            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-	install(EXPORT OGLCompilerTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
-endif(ENABLE_GLSLANG_INSTALL)

core/deps/glslang/OGLCompilersDLL/InitializeDll.cpp

@@ -1,165 +0,0 @@
-//
-// Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-//    Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-//    Redistributions in binary form must reproduce the above
-//    copyright notice, this list of conditions and the following
-//    disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
-//    contributors may be used to endorse or promote products derived
-//    from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-
-#define SH_EXPORTING
-
-#include <cassert>
-
-#include "InitializeDll.h"
-#include "../glslang/Include/InitializeGlobals.h"
-#include "../glslang/Public/ShaderLang.h"
-#include "../glslang/Include/PoolAlloc.h"
-
-namespace glslang {
-
-OS_TLSIndex ThreadInitializeIndex = OS_INVALID_TLS_INDEX;
-
-// Per-process initialization.
-// Needs to be called at least once before parsing, etc. is done.
-// Will also do thread initialization for the calling thread; other
-// threads will need to do that explicitly.
-bool InitProcess()
-{
-    glslang::GetGlobalLock();
-
-    if (ThreadInitializeIndex != OS_INVALID_TLS_INDEX) {
-        //
-        // Function is re-entrant.
-        //
-
-        glslang::ReleaseGlobalLock();
-        return true;
-    }
-
-    ThreadInitializeIndex = OS_AllocTLSIndex();
-
-    if (ThreadInitializeIndex == OS_INVALID_TLS_INDEX) {
-        assert(0 && "InitProcess(): Failed to allocate TLS area for init flag");
-
-        glslang::ReleaseGlobalLock();
-        return false;
-    }
-
-    if (! InitializePoolIndex()) {
-        assert(0 && "InitProcess(): Failed to initialize global pool");
-
-        glslang::ReleaseGlobalLock();
-        return false;
-    }
-
-    if (! InitThread()) {
-        assert(0 && "InitProcess(): Failed to initialize thread");
-
-        glslang::ReleaseGlobalLock();
-        return false;
-    }
-
-    glslang::ReleaseGlobalLock();
-    return true;
-}
-
-// Per-thread scoped initialization.
-// Must be called at least once by each new thread sharing the
-// symbol tables, etc., needed to parse.
-bool InitThread()
-{
-    //
-    // This function is re-entrant
-    //
-    if (ThreadInitializeIndex == OS_INVALID_TLS_INDEX) {
-        assert(0 && "InitThread(): Process hasn't been initalised.");
-        return false;
-    }
-
-    if (OS_GetTLSValue(ThreadInitializeIndex) != 0)
-        return true;
-
-    if (! OS_SetTLSValue(ThreadInitializeIndex, (void *)1)) {
-        assert(0 && "InitThread(): Unable to set init flag.");
-        return false;
-    }
-
-    glslang::SetThreadPoolAllocator(nullptr);
-
-    return true;
-}
-
-// Not necessary to call this: InitThread() is reentrant, and the need
-// to do per thread tear down has been removed.
-//
-// This is kept, with memory management removed, to satisfy any exiting
-// calls to it that rely on it.
-bool DetachThread()
-{
-    bool success = true;
-
-    if (ThreadInitializeIndex == OS_INVALID_TLS_INDEX)
-        return true;
-
-    //
-    // Function is re-entrant and this thread may not have been initialized.
-    //
-    if (OS_GetTLSValue(ThreadInitializeIndex) != 0) {
-        if (!OS_SetTLSValue(ThreadInitializeIndex, (void *)0)) {
-            assert(0 && "DetachThread(): Unable to clear init flag.");
-            success = false;
-        }
-    }
-
-    return success;
-}
-
-// Not necessary to call this: InitProcess() is reentrant.
-//
-// This is kept, with memory management removed, to satisfy any exiting
-// calls to it that rely on it.
-//
-// Users of glslang should call shFinalize() or glslang::FinalizeProcess() for
-// process-scoped memory tear down.
-bool DetachProcess()
-{
-    bool success = true;
-
-    if (ThreadInitializeIndex == OS_INVALID_TLS_INDEX)
-        return true;
-
-    success = DetachThread();
-
-    OS_FreeTLSIndex(ThreadInitializeIndex);
-    ThreadInitializeIndex = OS_INVALID_TLS_INDEX;
-
-    return success;
-}
-
-} // end namespace glslang

core/deps/glslang/OGLCompilersDLL/InitializeDll.h

@@ -1,49 +0,0 @@
-//
-// Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-//    Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-//    Redistributions in binary form must reproduce the above
-//    copyright notice, this list of conditions and the following
-//    disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
-//    contributors may be used to endorse or promote products derived
-//    from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-#ifndef __INITIALIZEDLL_H
-#define __INITIALIZEDLL_H
-
-#include "../glslang/OSDependent/osinclude.h"
-
-namespace glslang {
-
-bool InitProcess();
-bool InitThread();
-bool DetachThread();  // not called from standalone, perhaps other tools rely on parts of it
-bool DetachProcess(); // not called from standalone, perhaps other tools rely on parts of it
-
-} // end namespace glslang
-
-#endif // __INITIALIZEDLL_H
-

core/deps/glslang/README-spirv-remap.txt

@@ -1,137 +0,0 @@
-
-VERSION
---------------------------------------------------------------------------------
-spirv-remap 0.97
-
-INTRO:
---------------------------------------------------------------------------------
-spirv-remap is a utility to improve compression of SPIR-V binary files via
-entropy reduction, plus optional stripping of debug information and
-load/store optimization.  It transforms SPIR-V to SPIR-V, remapping IDs.  The
-resulting modules have an increased ID range (IDs are not as tightly packed
-around zero), but will compress better when multiple modules are compressed
-together, since compressor's dictionary can find better cross module
-commonality.
-
-Remapping is accomplished via canonicalization.  Thus, modules can be
-compressed one at a time with no loss of quality relative to operating on
-many modules at once.  The command line tool operates on multiple modules
-only in the trivial repetition sense, for ease of use.  The remapper API
-only accepts a single module at a time.
-
-There are two modes of use: command line, and a C++11 API.  Both are
-described below.
-
-spirv-remap is currently in an alpha state.  Although there are no known
-remapping defects, it has only been exercised on one real world game shader
-workload.
-
-
-FEEDBACK
---------------------------------------------------------------------------------
-Report defects, enhancements requests, code improvements, etc to:
-   [email protected]
-
-
-COMMAND LINE USAGE:
---------------------------------------------------------------------------------
-Examples are given with a verbosity of one (-v), but more verbosity can be
-had via -vv, -vvv, etc, or an integer parameter to --verbose, such as
-"--verbose 4".  With no verbosity, the command is silent and returns 0 on
-success, and a positive integer error on failure.
-
-Pre-built binaries for several OSs are available.  Examples presented are
-for Linux.  Command line arguments can be provided in any order.
-
-1. Basic ID remapping
-
-Perform ID remapping on all shaders in "*.spv", writing new files with
-the same basenames to /tmp/out_dir.
-
-  spirv-remap -v --map all --input *.spv --output /tmp/out_dir
-
-2. Perform all possible size reductions
-
-  spirv-remap-linux-64 -v --do-everything --input *.spv --output /tmp/out_dir
-
-Note that --do-everything is a synonym for:
-
-  --map all --dce all --opt all --strip all
-
-API USAGE:
---------------------------------------------------------------------------------
-
-The public interface to the remapper is defined in SPIRV/SPVRemapper.h as follows:
-
-namespace spv {
-
-class spirvbin_t
-{
-public:
-   enum Options { ... };
-   spirvbin_t(int verbose = 0);  // construct
-
-   // remap an existing binary in memory
-   void remap(std::vector<std::uint32_t>& spv, std::uint32_t opts = DO_EVERYTHING);
-
-   // Type for error/log handler functions
-   typedef std::function<void(const std::string&)> errorfn_t;
-   typedef std::function<void(const std::string&)> logfn_t;
-
-   // Register error/log handling functions (can be c/c++ fn, lambda fn, or functor)
-   static void registerErrorHandler(errorfn_t handler) { errorHandler = handler; }
-   static void registerLogHandler(logfn_t handler)     { logHandler   = handler; }
-};
-
-} // namespace spv
-
-The class definition is in SPVRemapper.cpp.
-
-remap() accepts an std::vector of SPIR-V words, modifies them per the
-request given in 'opts', and leaves the 'spv' container with the result.
-It is safe to instantiate one spirvbin_t per thread and process a different
-SPIR-V in each.
-
-The "opts" parameter to remap() accepts a bit mask of desired remapping
-options.  See REMAPPING AND OPTIMIZATION OPTIONS.
-
-On error, the function supplied to registerErrorHandler() will be invoked.
-This can be a standard C/C++ function, a lambda function, or a functor.
-The default handler simply calls exit(5); The error handler is a static
-member, so need only be set up once, not once per spirvbin_t instance.
-
-Log messages are supplied to registerLogHandler().  By default, log
-messages are eaten silently.  The log handler is also a static member.
-
-BUILD DEPENDENCIES:
---------------------------------------------------------------------------------
- 1. C++11 compatible compiler
- 2. cmake
- 3. glslang
-
-
-BUILDING
---------------------------------------------------------------------------------
-The standalone remapper is built along side glslangValidator through its
-normal build process.
-
-
-REMAPPING AND OPTIMIZATION OPTIONS
---------------------------------------------------------------------------------
-API:
-   These are bits defined under spv::spirvbin_t::, and can be
-   bitwise or-ed together as desired.
-
-   MAP_TYPES      = canonicalize type IDs
-   MAP_NAMES      = canonicalize named data
-   MAP_FUNCS      = canonicalize function bodies
-   DCE_FUNCS      = remove dead functions
-   DCE_VARS       = remove dead variables
-   DCE_TYPES      = remove dead types
-   OPT_LOADSTORE  = optimize unneeded load/stores
-   MAP_ALL        = (MAP_TYPES | MAP_NAMES | MAP_FUNCS)
-   DCE_ALL        = (DCE_FUNCS | DCE_VARS | DCE_TYPES)
-   OPT_ALL        = (OPT_LOADSTORE)
-   ALL_BUT_STRIP  = (MAP_ALL | DCE_ALL | OPT_ALL)
-   DO_EVERYTHING  = (STRIP | ALL_BUT_STRIP)
-

core/deps/glslang/README.md

@@ -1,442 +0,0 @@
-# News
-
-[![Build Status](https://travis-ci.org/KhronosGroup/glslang.svg?branch=master)](https://travis-ci.org/KhronosGroup/glslang)
-[![Build status](https://ci.appveyor.com/api/projects/status/q6fi9cb0qnhkla68/branch/master?svg=true)](https://ci.appveyor.com/project/Khronoswebmaster/glslang/branch/master)
-
-## Planned Deprecations/Removals
-
-1. **SPIRV Folder, 1-May, 2020.** Glslang, when installed through CMake,
-will install a `SPIRV` folder into `${CMAKE_INSTALL_INCLUDEDIR}`.
-This `SPIRV` folder is being moved to `glslang/SPIRV`.
-During the transition the `SPIRV` folder will be installed into both locations.
-The old install of `SPIRV/` will be removed as a CMake install target no sooner than May 1, 2020.
-See issue #1964.
-
-2. **Visual Studio 2013, 20-July, 2020.** Keeping code compiling for MS Visual Studio 2013 will no longer be
-a goal as of July 20, 2020, the fifth anniversary of the release of Visual Studio 2015.
-
-# Glslang Components and Status
-
-There are several components:
-
-### Reference Validator and GLSL/ESSL -> AST Front End
-
-An OpenGL GLSL and OpenGL|ES GLSL (ESSL) front-end for reference validation and translation of GLSL/ESSL into an internal abstract syntax tree (AST).
-
-**Status**: Virtually complete, with results carrying similar weight as the specifications.
-
-### HLSL -> AST Front End
-
-An HLSL front-end for translation of an approximation of HLSL to glslang's AST form.
-
-**Status**: Partially complete. Semantics are not reference quality and input is not validated.
-This is in contrast to the [DXC project](https://github.com/Microsoft/DirectXShaderCompiler), which receives a much larger investment and attempts to have definitive/reference-level semantics.
-
-See [issue 362](https://github.com/KhronosGroup/glslang/issues/362) and [issue 701](https://github.com/KhronosGroup/glslang/issues/701) for current status.
-
-### AST -> SPIR-V Back End
-
-Translates glslang's AST to the Khronos-specified SPIR-V intermediate language.
-
-**Status**: Virtually complete.
-
-### Reflector
-
-An API for getting reflection information from the AST, reflection types/variables/etc. from the HLL source (not the SPIR-V).
-
-**Status**: There is a large amount of functionality present, but no specification/goal to measure completeness against.  It is accurate for the input HLL and AST, but only approximate for what would later be emitted for SPIR-V.
-
-### Standalone Wrapper
-
-`glslangValidator` is command-line tool for accessing the functionality above.
-
-Status: Complete.
-
-Tasks waiting to be done are documented as GitHub issues.
-
-## Other References
-
-Also see the Khronos landing page for glslang as a reference front end:
-
-https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/
-
-The above page, while not kept up to date, includes additional information regarding glslang as a reference validator.
-
-# How to Use Glslang
-
-## Execution of Standalone Wrapper
-
-To use the standalone binary form, execute `glslangValidator`, and it will print
-a usage statement.  Basic operation is to give it a file containing a shader,
-and it will print out warnings/errors and optionally an AST.
-
-The applied stage-specific rules are based on the file extension:
-* `.vert` for a vertex shader
-* `.tesc` for a tessellation control shader
-* `.tese` for a tessellation evaluation shader
-* `.geom` for a geometry shader
-* `.frag` for a fragment shader
-* `.comp` for a compute shader
-
-There is also a non-shader extension
-* `.conf` for a configuration file of limits, see usage statement for example
-
-## Building
-
-Instead of building manually, you can also download the binaries for your
-platform directly from the [master-tot release][master-tot-release] on GitHub.
-Those binaries are automatically uploaded by the buildbots after successful
-testing and they always reflect the current top of the tree of the master
-branch.
-
-### Dependencies
-
-* A C++11 compiler.
-  (For MSVS: 2015 is recommended, 2013 is fully supported/tested, and 2010 support is attempted, but not tested.)
-* [CMake][cmake]: for generating compilation targets.
-* make: _Linux_, ninja is an alternative, if configured.
-* [Python 3.x][python]: for executing SPIRV-Tools scripts. (Optional if not using SPIRV-Tools and the 'External' subdirectory does not exist.)
-* [bison][bison]: _optional_, but needed when changing the grammar (glslang.y).
-* [googletest][googletest]: _optional_, but should use if making any changes to glslang.
-
-### Build steps
-
-The following steps assume a Bash shell. On Windows, that could be the Git Bash
-shell or some other shell of your choosing.
-
-#### 1) Check-Out this project
-
-```bash
-cd <parent of where you want glslang to be>
-git clone https://github.com/KhronosGroup/glslang.git
-```
-
-#### 2) Check-Out External Projects
-
-```bash
-cd <the directory glslang was cloned to, "External" will be a subdirectory>
-git clone https://github.com/google/googletest.git External/googletest
-```
-
-If you want to use googletest with Visual Studio 2013, you also need to check out an older version:
-
-```bash
-# to use googletest with Visual Studio 2013
-cd External/googletest
-git checkout 440527a61e1c91188195f7de212c63c77e8f0a45
-cd ../..
-```
-
-If you wish to assure that SPIR-V generated from HLSL is legal for Vulkan,
-wish to invoke -Os to reduce SPIR-V size from HLSL or GLSL, or wish to run the
-integrated test suite, install spirv-tools with this:
-
-```bash
-./update_glslang_sources.py
-```
-
-#### 3) Configure
-
-Assume the source directory is `$SOURCE_DIR` and the build directory is
-`$BUILD_DIR`. First ensure the build directory exists, then navigate to it:
-
-```bash
-mkdir -p $BUILD_DIR
-cd $BUILD_DIR
-```
-
-For building on Linux:
-
-```bash
-cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="$(pwd)/install" $SOURCE_DIR
-# "Release" (for CMAKE_BUILD_TYPE) could also be "Debug" or "RelWithDebInfo"
-```
-
-For building on Android:
-```bash
-cmake $SOURCE_DIR -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DANDROID_ABI=arm64-v8a -DCMAKE_BUILD_TYPE=Release -DANDROID_STL=c++_static -DANDROID_PLATFORM=android-24 -DCMAKE_SYSTEM_NAME=Android -DANDROID_TOOLCHAIN=clang -DANDROID_ARM_MODE=arm -DCMAKE_MAKE_PROGRAM=$ANDROID_NDK_ROOT/prebuilt/linux-x86_64/bin/make -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake
-# If on Windows will be -DCMAKE_MAKE_PROGRAM=%ANDROID_NDK_ROOT%\prebuilt\windows-x86_64\bin\make.exe
-# -G is needed for building on Windows
-# -DANDROID_ABI can also be armeabi-v7a for 32 bit
-```
-
-For building on Windows:
-
-```bash
-cmake $SOURCE_DIR -DCMAKE_INSTALL_PREFIX="$(pwd)/install"
-# The CMAKE_INSTALL_PREFIX part is for testing (explained later).
-```
-
-The CMake GUI also works for Windows (version 3.4.1 tested).
-
-Also, consider using `git config --global core.fileMode false` (or with `--local`) on Windows
-to prevent the addition of execution permission on files.
-
-#### 4) Build and Install
-
-```bash
-# for Linux:
-make -j4 install
-
-# for Windows:
-cmake --build . --config Release --target install
-# "Release" (for --config) could also be "Debug", "MinSizeRel", or "RelWithDebInfo"
-```
-
-If using MSVC, after running CMake to configure, use the
-Configuration Manager to check the `INSTALL` project.
-
-### If you need to change the GLSL grammar
-
-The grammar in `glslang/MachineIndependent/glslang.y` has to be recompiled with
-bison if it changes, the output files are committed to the repo to avoid every
-developer needing to have bison configured to compile the project when grammar
-changes are quite infrequent. For windows you can get binaries from
-[GnuWin32][bison-gnu-win32].
-
-The command to rebuild is:
-
-```bash
-m4 -P MachineIndependent/glslang.m4 > MachineIndependent/glslang.y
-bison --defines=MachineIndependent/glslang_tab.cpp.h
-      -t MachineIndependent/glslang.y
-      -o MachineIndependent/glslang_tab.cpp
-```
-
-The above commands are also available in the bash script in `updateGrammar`,
-when executed from the glslang subdirectory of the glslang repository.
-With no arguments it builds the full grammar, and with a "web" argument,
-the web grammar subset (see more about the web subset in the next section).
-
-### Building to WASM for the Web and Node
-### Building a standalone JS/WASM library for the Web and Node
-
-Use the steps in [Build Steps](#build-steps), with the following notes/exceptions:
-* `emsdk` needs to be present in your executable search path, *PATH* for
-  Bash-like environments:
-  + [Instructions located here](https://emscripten.org/docs/getting_started/downloads.html#sdk-download-and-install)
-* Wrap cmake call: `emcmake cmake`
-* Set `-DBUILD_TESTING=OFF -DENABLE_OPT=OFF -DINSTALL_GTEST=OFF`.
-* Set `-DENABLE_HLSL=OFF` if HLSL is not needed.
-* For a standalone JS/WASM library, turn on `-DENABLE_GLSLANG_JS=ON`.
-* For building a minimum-size web subset of core glslang:
-  + turn on `-DENABLE_GLSLANG_WEBMIN=ON` (disables HLSL)
-  + execute `updateGrammar web` from the glslang subdirectory
-    (or if using your own scripts, `m4` needs a `-DGLSLANG_WEB` argument)
-  + optionally, for GLSL compilation error messages, turn on
-    `-DENABLE_GLSLANG_WEBMIN_DEVEL=ON`
-* To get a fully minimized build, make sure to use `brotli` to compress the .js
-  and .wasm files
-
-Example:
-
-```sh
-emcmake cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_GLSLANG_JS=ON \
-    -DENABLE_HLSL=OFF -DBUILD_TESTING=OFF -DENABLE_OPT=OFF -DINSTALL_GTEST=OFF ..
-```
-
-## Building glslang - Using vcpkg
-
-You can download and install glslang using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
-
-    git clone https://github.com/Microsoft/vcpkg.git
-    cd vcpkg
-    ./bootstrap-vcpkg.sh
-    ./vcpkg integrate install
-    ./vcpkg install glslang
-
-The glslang port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
-
-## Testing
-
-Right now, there are two test harnesses existing in glslang: one is [Google
-Test](gtests/), one is the [`runtests` script](Test/runtests). The former
-runs unit tests and single-shader single-threaded integration tests, while
-the latter runs multiple-shader linking tests and multi-threaded tests.
-
-### Running tests
-
-The [`runtests` script](Test/runtests) requires compiled binaries to be
-installed into `$BUILD_DIR/install`. Please make sure you have supplied the
-correct configuration to CMake (using `-DCMAKE_INSTALL_PREFIX`) when building;
-otherwise, you may want to modify the path in the `runtests` script.
-
-Running Google Test-backed tests:
-
-```bash
-cd $BUILD_DIR
-
-# for Linux:
-ctest
-
-# for Windows:
-ctest -C {Debug|Release|RelWithDebInfo|MinSizeRel}
-
-# or, run the test binary directly
-# (which gives more fine-grained control like filtering):
-<dir-to-glslangtests-in-build-dir>/glslangtests
-```
-
-Running `runtests` script-backed tests:
-
-```bash
-cd $SOURCE_DIR/Test && ./runtests
-```
-
-If some tests fail with validation errors, there may be a mismatch between the
-version of `spirv-val` on the system and the version of glslang.  In this
-case, it is necessary to run `update_glslang_sources.py`.  See "Check-Out
-External Projects" above for more details.
-
-### Contributing tests
-
-Test results should always be included with a pull request that modifies
-functionality.
-
-If you are writing unit tests, please use the Google Test framework and
-place the tests under the `gtests/` directory.
-
-Integration tests are placed in the `Test/` directory. It contains test input
-and a subdirectory `baseResults/` that contains the expected results of the
-tests.  Both the tests and `baseResults/` are under source-code control.
-
-Google Test runs those integration tests by reading the test input, compiling
-them, and then compare against the expected results in `baseResults/`. The
-integration tests to run via Google Test is registered in various
-`gtests/*.FromFile.cpp` source files. `glslangtests` provides a command-line
-option `--update-mode`, which, if supplied, will overwrite the golden files
-under the `baseResults/` directory with real output from that invocation.
-For more information, please check `gtests/` directory's
-[README](gtests/README.md).
-
-For the `runtests` script, it will generate current results in the
-`localResults/` directory and `diff` them against the `baseResults/`.
-When you want to update the tracked test results, they need to be
-copied from `localResults/` to `baseResults/`.  This can be done by
-the `bump` shell script.
-
-You can add your own private list of tests, not tracked publicly, by using
-`localtestlist` to list non-tracked tests.  This is automatically read
-by `runtests` and included in the `diff` and `bump` process.
-
-## Programmatic Interfaces
-
-Another piece of software can programmatically translate shaders to an AST
-using one of two different interfaces:
-* A new C++ class-oriented interface, or
-* The original C functional interface
-
-The `main()` in `StandAlone/StandAlone.cpp` shows examples using both styles.
-
-### C++ Class Interface (new, preferred)
-
-This interface is in roughly the last 1/3 of `ShaderLang.h`.  It is in the
-glslang namespace and contains the following, here with suggested calls
-for generating SPIR-V:
-
-```cxx
-const char* GetEsslVersionString();
-const char* GetGlslVersionString();
-bool InitializeProcess();
-void FinalizeProcess();
-
-class TShader
-    setStrings(...);
-    setEnvInput(EShSourceHlsl or EShSourceGlsl, stage,  EShClientVulkan or EShClientOpenGL, 100);
-    setEnvClient(EShClientVulkan or EShClientOpenGL, EShTargetVulkan_1_0 or EShTargetVulkan_1_1 or EShTargetOpenGL_450);
-    setEnvTarget(EShTargetSpv, EShTargetSpv_1_0 or EShTargetSpv_1_3);
-    bool parse(...);
-    const char* getInfoLog();
-
-class TProgram
-    void addShader(...);
-    bool link(...);
-    const char* getInfoLog();
-    Reflection queries
-```
-
-For just validating (not generating code), substitute these calls:
-
-```cxx
-    setEnvInput(EShSourceHlsl or EShSourceGlsl, stage,  EShClientNone, 0);
-    setEnvClient(EShClientNone, 0);
-    setEnvTarget(EShTargetNone, 0);
-```
-
-See `ShaderLang.h` and the usage of it in `StandAlone/StandAlone.cpp` for more
-details. There is a block comment giving more detail above the calls for
-`setEnvInput, setEnvClient, and setEnvTarget`.
-
-### C Functional Interface (original)
-
-This interface is in roughly the first 2/3 of `ShaderLang.h`, and referred to
-as the `Sh*()` interface, as all the entry points start `Sh`.
-
-The `Sh*()` interface takes a "compiler" call-back object, which it calls after
-building call back that is passed the AST and can then execute a back end on it.
-
-The following is a simplified resulting run-time call stack:
-
-```c
-ShCompile(shader, compiler) -> compiler(AST) -> <back end>
-```
-
-In practice, `ShCompile()` takes shader strings, default version, and
-warning/error and other options for controlling compilation.
-
-## Basic Internal Operation
-
-* Initial lexical analysis is done by the preprocessor in
-  `MachineIndependent/Preprocessor`, and then refined by a GLSL scanner
-  in `MachineIndependent/Scan.cpp`.  There is currently no use of flex.
-
-* Code is parsed using bison on `MachineIndependent/glslang.y` with the
-  aid of a symbol table and an AST.  The symbol table is not passed on to
-  the back-end; the intermediate representation stands on its own.
-  The tree is built by the grammar productions, many of which are
-  offloaded into `ParseHelper.cpp`, and by `Intermediate.cpp`.
-
-* The intermediate representation is very high-level, and represented
-  as an in-memory tree.   This serves to lose no information from the
-  original program, and to have efficient transfer of the result from
-  parsing to the back-end.  In the AST, constants are propagated and
-  folded, and a very small amount of dead code is eliminated.
-
-  To aid linking and reflection, the last top-level branch in the AST
-  lists all global symbols.
-
-* The primary algorithm of the back-end compiler is to traverse the
-  tree (high-level intermediate representation), and create an internal
-  object code representation.  There is an example of how to do this
-  in `MachineIndependent/intermOut.cpp`.
-
-* Reduction of the tree to a linear byte-code style low-level intermediate
-  representation is likely a good way to generate fully optimized code.
-
-* There is currently some dead old-style linker-type code still lying around.
-
-* Memory pool: parsing uses types derived from C++ `std` types, using a
-  custom allocator that puts them in a memory pool.  This makes allocation
-  of individual container/contents just few cycles and deallocation free.
-  This pool is popped after the AST is made and processed.
-
-  The use is simple: if you are going to call `new`, there are three cases:
-
-  - the object comes from the pool (its base class has the macro
-    `POOL_ALLOCATOR_NEW_DELETE` in it) and you do not have to call `delete`
-
-  - it is a `TString`, in which case call `NewPoolTString()`, which gets
-    it from the pool, and there is no corresponding `delete`
-
-  - the object does not come from the pool, and you have to do normal
-    C++ memory management of what you `new`
-
-* Features can be protected by version/extension/stage/profile:
-  See the comment in `glslang/MachineIndependent/Versions.cpp`.
-
-[cmake]: https://cmake.org/
-[python]: https://www.python.org/
-[bison]: https://www.gnu.org/software/bison/
-[googletest]: https://github.com/google/googletest
-[bison-gnu-win32]: http://gnuwin32.sourceforge.net/packages/bison.htm
-[master-tot-release]: https://github.com/KhronosGroup/glslang/releases/tag/master-tot

core/deps/glslang/SPIRV/CMakeLists.txt

@@ -1,103 +0,0 @@
-set(SOURCES
-    GlslangToSpv.cpp
-    InReadableOrder.cpp
-    Logger.cpp
-    SpvBuilder.cpp
-    SpvPostProcess.cpp
-    doc.cpp
-    SpvTools.cpp
-    disassemble.cpp)
-
-set(SPVREMAP_SOURCES
-    SPVRemapper.cpp
-    doc.cpp)
-
-set(HEADERS
-    bitutils.h
-    spirv.hpp
-    GLSL.std.450.h
-    GLSL.ext.EXT.h
-    GLSL.ext.KHR.h
-    GlslangToSpv.h
-    hex_float.h
-    Logger.h
-    SpvBuilder.h
-    spvIR.h
-    doc.h
-    SpvTools.h
-    disassemble.h
-    GLSL.ext.AMD.h
-    GLSL.ext.NV.h
-    NonSemanticDebugPrintf.h)
-
-set(SPVREMAP_HEADERS
-    SPVRemapper.h
-    doc.h)
-
-add_library(SPIRV ${LIB_TYPE} ${SOURCES} ${HEADERS})
-set_property(TARGET SPIRV PROPERTY FOLDER glslang)
-set_property(TARGET SPIRV PROPERTY POSITION_INDEPENDENT_CODE ON)
-target_include_directories(SPIRV PUBLIC
-	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>
-	$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
-
-if (ENABLE_SPVREMAPPER)
-    add_library(SPVRemapper ${LIB_TYPE} ${SPVREMAP_SOURCES} ${SPVREMAP_HEADERS})
-    set_property(TARGET SPVRemapper PROPERTY FOLDER glslang)
-    set_property(TARGET SPVRemapper PROPERTY POSITION_INDEPENDENT_CODE ON)
-endif()
-
-if(WIN32 AND BUILD_SHARED_LIBS)
-    set_target_properties(SPIRV PROPERTIES PREFIX "")
-    if (ENABLE_SPVREMAPPER)
-        set_target_properties(SPVRemapper PROPERTIES PREFIX "")
-    endif()
-endif()
-
-if(ENABLE_OPT)
-    target_include_directories(SPIRV
-        PRIVATE ${spirv-tools_SOURCE_DIR}/include
-        PRIVATE ${spirv-tools_SOURCE_DIR}/source
-    )
-    target_link_libraries(SPIRV glslang SPIRV-Tools-opt)
-    target_include_directories(SPIRV PUBLIC
-		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../External>
-		$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/External>)
-else()
-    target_link_libraries(SPIRV glslang)
-endif(ENABLE_OPT)
-
-if(WIN32)
-    source_group("Source" FILES ${SOURCES} ${HEADERS})
-    source_group("Source" FILES ${SPVREMAP_SOURCES} ${SPVREMAP_HEADERS})
-endif(WIN32)
-
-if(ENABLE_GLSLANG_INSTALL)
-    if(BUILD_SHARED_LIBS)
-        if (ENABLE_SPVREMAPPER)
-            install(TARGETS SPVRemapper EXPORT SPVRemapperTargets
-                    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
-        endif()
-        install(TARGETS SPIRV EXPORT SPIRVTargets
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-    else()
-        if (ENABLE_SPVREMAPPER)
-            install(TARGETS SPVRemapper EXPORT SPVRemapperTargets
-                    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-        endif()
-        install(TARGETS SPIRV EXPORT SPIRVTargets
-                ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif()
-
-    if (ENABLE_SPVREMAPPER)
-        install(EXPORT SPVRemapperTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
-    endif()
-
-    install(EXPORT SPIRVTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
-
-    install(FILES ${HEADERS} ${SPVREMAP_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/SPIRV/)
-    install(FILES ${HEADERS} ${SPVREMAP_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/glslang/SPIRV/)
-endif(ENABLE_GLSLANG_INSTALL)

core/deps/glslang/SPIRV/GLSL.ext.AMD.h

@@ -1,108 +0,0 @@
-/*
-** Copyright (c) 2014-2016 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a copy
-** of this software and/or associated documentation files (the "Materials"),
-** to deal in the Materials without restriction, including without limitation
-** the rights to use, copy, modify, merge, publish, distribute, sublicense,
-** and/or sell copies of the Materials, and to permit persons to whom the
-** Materials are furnished to do so, subject to the following conditions:
-**
-** The above copyright notice and this permission notice shall be included in
-** all copies or substantial portions of the Materials.
-**
-** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-** IN THE MATERIALS.
-*/
-
-#ifndef GLSLextAMD_H
-#define GLSLextAMD_H
-
-static const int GLSLextAMDVersion = 100;
-static const int GLSLextAMDRevision = 7;
-
-// SPV_AMD_shader_ballot
-static const char* const E_SPV_AMD_shader_ballot = "SPV_AMD_shader_ballot";
-
-enum ShaderBallotAMD {
-    ShaderBallotBadAMD = 0, // Don't use
-
-    SwizzleInvocationsAMD = 1,
-    SwizzleInvocationsMaskedAMD = 2,
-    WriteInvocationAMD = 3,
-    MbcntAMD = 4,
-
-    ShaderBallotCountAMD
-};
-
-// SPV_AMD_shader_trinary_minmax
-static const char* const E_SPV_AMD_shader_trinary_minmax = "SPV_AMD_shader_trinary_minmax";
-
-enum ShaderTrinaryMinMaxAMD {
-    ShaderTrinaryMinMaxBadAMD = 0, // Don't use
-
-    FMin3AMD = 1,
-    UMin3AMD = 2,
-    SMin3AMD = 3,
-    FMax3AMD = 4,
-    UMax3AMD = 5,
-    SMax3AMD = 6,
-    FMid3AMD = 7,
-    UMid3AMD = 8,
-    SMid3AMD = 9,
-
-    ShaderTrinaryMinMaxCountAMD
-};
-
-// SPV_AMD_shader_explicit_vertex_parameter
-static const char* const E_SPV_AMD_shader_explicit_vertex_parameter = "SPV_AMD_shader_explicit_vertex_parameter";
-
-enum ShaderExplicitVertexParameterAMD {
-    ShaderExplicitVertexParameterBadAMD = 0, // Don't use
-
-    InterpolateAtVertexAMD = 1,
-
-    ShaderExplicitVertexParameterCountAMD
-};
-
-// SPV_AMD_gcn_shader
-static const char* const E_SPV_AMD_gcn_shader = "SPV_AMD_gcn_shader";
-
-enum GcnShaderAMD {
-    GcnShaderBadAMD = 0, // Don't use
-
-    CubeFaceIndexAMD = 1,
-    CubeFaceCoordAMD = 2,
-    TimeAMD = 3,
-
-    GcnShaderCountAMD
-};
-
-// SPV_AMD_gpu_shader_half_float
-static const char* const E_SPV_AMD_gpu_shader_half_float = "SPV_AMD_gpu_shader_half_float";
-
-// SPV_AMD_texture_gather_bias_lod
-static const char* const E_SPV_AMD_texture_gather_bias_lod = "SPV_AMD_texture_gather_bias_lod";
-
-// SPV_AMD_gpu_shader_int16
-static const char* const E_SPV_AMD_gpu_shader_int16 = "SPV_AMD_gpu_shader_int16";
-
-// SPV_AMD_shader_image_load_store_lod
-static const char* const E_SPV_AMD_shader_image_load_store_lod = "SPV_AMD_shader_image_load_store_lod";
-
-// SPV_AMD_shader_fragment_mask
-static const char* const E_SPV_AMD_shader_fragment_mask = "SPV_AMD_shader_fragment_mask";
-
-// SPV_AMD_gpu_shader_half_float_fetch
-static const char* const E_SPV_AMD_gpu_shader_half_float_fetch = "SPV_AMD_gpu_shader_half_float_fetch";
-
-#endif  // #ifndef GLSLextAMD_H

core/deps/glslang/SPIRV/GLSL.ext.EXT.h

@@ -1,39 +0,0 @@
-/*
-** Copyright (c) 2014-2016 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a copy
-** of this software and/or associated documentation files (the "Materials"),
-** to deal in the Materials without restriction, including without limitation
-** the rights to use, copy, modify, merge, publish, distribute, sublicense,
-** and/or sell copies of the Materials, and to permit persons to whom the
-** Materials are furnished to do so, subject to the following conditions:
-**
-** The above copyright notice and this permission notice shall be included in
-** all copies or substantial portions of the Materials.
-**
-** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-** IN THE MATERIALS.
-*/
-
-#ifndef GLSLextEXT_H
-#define GLSLextEXT_H
-
-static const int GLSLextEXTVersion = 100;
-static const int GLSLextEXTRevision = 2;
-
-static const char* const E_SPV_EXT_shader_stencil_export        = "SPV_EXT_shader_stencil_export";
-static const char* const E_SPV_EXT_shader_viewport_index_layer  = "SPV_EXT_shader_viewport_index_layer";
-static const char* const E_SPV_EXT_fragment_fully_covered = "SPV_EXT_fragment_fully_covered";
-static const char* const E_SPV_EXT_fragment_invocation_density = "SPV_EXT_fragment_invocation_density";
-static const char* const E_SPV_EXT_demote_to_helper_invocation = "SPV_EXT_demote_to_helper_invocation";
-
-#endif  // #ifndef GLSLextEXT_H

core/deps/glslang/SPIRV/GLSL.ext.KHR.h

@@ -1,51 +0,0 @@
-/*
-** Copyright (c) 2014-2020 The Khronos Group Inc.
-** Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a copy
-** of this software and/or associated documentation files (the "Materials"),
-** to deal in the Materials without restriction, including without limitation
-** the rights to use, copy, modify, merge, publish, distribute, sublicense,
-** and/or sell copies of the Materials, and to permit persons to whom the
-** Materials are furnished to do so, subject to the following conditions:
-**
-** The above copyright notice and this permission notice shall be included in
-** all copies or substantial portions of the Materials.
-**
-** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-** IN THE MATERIALS.
-*/
-
-#ifndef GLSLextKHR_H
-#define GLSLextKHR_H
-
-static const int GLSLextKHRVersion = 100;
-static const int GLSLextKHRRevision = 2;
-
-static const char* const E_SPV_KHR_shader_ballot                = "SPV_KHR_shader_ballot";
-static const char* const E_SPV_KHR_subgroup_vote                = "SPV_KHR_subgroup_vote";
-static const char* const E_SPV_KHR_device_group                 = "SPV_KHR_device_group";
-static const char* const E_SPV_KHR_multiview                    = "SPV_KHR_multiview";
-static const char* const E_SPV_KHR_shader_draw_parameters       = "SPV_KHR_shader_draw_parameters";
-static const char* const E_SPV_KHR_16bit_storage                = "SPV_KHR_16bit_storage";
-static const char* const E_SPV_KHR_8bit_storage                 = "SPV_KHR_8bit_storage";
-static const char* const E_SPV_KHR_storage_buffer_storage_class = "SPV_KHR_storage_buffer_storage_class";
-static const char* const E_SPV_KHR_post_depth_coverage          = "SPV_KHR_post_depth_coverage";
-static const char* const E_SPV_KHR_vulkan_memory_model          = "SPV_KHR_vulkan_memory_model";
-static const char* const E_SPV_EXT_physical_storage_buffer      = "SPV_EXT_physical_storage_buffer";
-static const char* const E_SPV_KHR_physical_storage_buffer      = "SPV_KHR_physical_storage_buffer";
-static const char* const E_SPV_EXT_fragment_shader_interlock    = "SPV_EXT_fragment_shader_interlock";
-static const char* const E_SPV_KHR_shader_clock                 = "SPV_KHR_shader_clock";
-static const char* const E_SPV_KHR_non_semantic_info            = "SPV_KHR_non_semantic_info";
-static const char* const E_SPV_KHR_ray_tracing                  = "SPV_KHR_ray_tracing";
-static const char* const E_SPV_KHR_ray_query                    = "SPV_KHR_ray_query";
-#endif  // #ifndef GLSLextKHR_H

core/deps/glslang/SPIRV/GLSL.ext.NV.h

@@ -1,81 +0,0 @@
-/*
-** Copyright (c) 2014-2017 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a copy
-** of this software and/or associated documentation files (the "Materials"),
-** to deal in the Materials without restriction, including without limitation
-** the rights to use, copy, modify, merge, publish, distribute, sublicense,
-** and/or sell copies of the Materials, and to permit persons to whom the
-** Materials are furnished to do so, subject to the following conditions:
-**
-** The above copyright notice and this permission notice shall be included in
-** all copies or substantial portions of the Materials.
-**
-** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-** IN THE MATERIALS.
-*/
-
-#ifndef GLSLextNV_H
-#define GLSLextNV_H
-
-enum BuiltIn;
-enum Decoration;
-enum Op;
-enum Capability;
-
-static const int GLSLextNVVersion = 100;
-static const int GLSLextNVRevision = 11;
-
-//SPV_NV_sample_mask_override_coverage
-const char* const E_SPV_NV_sample_mask_override_coverage = "SPV_NV_sample_mask_override_coverage";
-
-//SPV_NV_geometry_shader_passthrough
-const char* const E_SPV_NV_geometry_shader_passthrough = "SPV_NV_geometry_shader_passthrough";
-
-//SPV_NV_viewport_array2
-const char* const E_SPV_NV_viewport_array2 = "SPV_NV_viewport_array2";
-const char* const E_ARB_shader_viewport_layer_array = "SPV_ARB_shader_viewport_layer_array";
-
-//SPV_NV_stereo_view_rendering
-const char* const E_SPV_NV_stereo_view_rendering = "SPV_NV_stereo_view_rendering";
-
-//SPV_NVX_multiview_per_view_attributes
-const char* const E_SPV_NVX_multiview_per_view_attributes = "SPV_NVX_multiview_per_view_attributes";
-
-//SPV_NV_shader_subgroup_partitioned
-const char* const E_SPV_NV_shader_subgroup_partitioned = "SPV_NV_shader_subgroup_partitioned";
-
-//SPV_NV_fragment_shader_barycentric
-const char* const E_SPV_NV_fragment_shader_barycentric = "SPV_NV_fragment_shader_barycentric";
-
-//SPV_NV_compute_shader_derivatives
-const char* const E_SPV_NV_compute_shader_derivatives = "SPV_NV_compute_shader_derivatives";
-
-//SPV_NV_shader_image_footprint
-const char* const E_SPV_NV_shader_image_footprint = "SPV_NV_shader_image_footprint";
-
-//SPV_NV_mesh_shader
-const char* const E_SPV_NV_mesh_shader = "SPV_NV_mesh_shader";
-
-//SPV_NV_raytracing
-const char* const E_SPV_NV_ray_tracing = "SPV_NV_ray_tracing";
-
-//SPV_NV_shading_rate
-const char* const E_SPV_NV_shading_rate = "SPV_NV_shading_rate";
-
-//SPV_NV_cooperative_matrix
-const char* const E_SPV_NV_cooperative_matrix = "SPV_NV_cooperative_matrix";
-
-//SPV_NV_shader_sm_builtins
-const char* const E_SPV_NV_shader_sm_builtins = "SPV_NV_shader_sm_builtins";
-
-#endif  // #ifndef GLSLextNV_H

core/deps/glslang/SPIRV/GLSL.std.450.h

@@ -1,131 +0,0 @@
-/*
-** Copyright (c) 2014-2016 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a copy
-** of this software and/or associated documentation files (the "Materials"),
-** to deal in the Materials without restriction, including without limitation
-** the rights to use, copy, modify, merge, publish, distribute, sublicense,
-** and/or sell copies of the Materials, and to permit persons to whom the
-** Materials are furnished to do so, subject to the following conditions:
-**
-** The above copyright notice and this permission notice shall be included in
-** all copies or substantial portions of the Materials.
-**
-** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-** IN THE MATERIALS.
-*/
-
-#ifndef GLSLstd450_H
-#define GLSLstd450_H
-
-static const int GLSLstd450Version = 100;
-static const int GLSLstd450Revision = 1;
-
-enum GLSLstd450 {
-    GLSLstd450Bad = 0,              // Don't use
-
-    GLSLstd450Round = 1,
-    GLSLstd450RoundEven = 2,
-    GLSLstd450Trunc = 3,
-    GLSLstd450FAbs = 4,
-    GLSLstd450SAbs = 5,
-    GLSLstd450FSign = 6,
-    GLSLstd450SSign = 7,
-    GLSLstd450Floor = 8,
-    GLSLstd450Ceil = 9,
-    GLSLstd450Fract = 10,
-
-    GLSLstd450Radians = 11,
-    GLSLstd450Degrees = 12,
-    GLSLstd450Sin = 13,
-    GLSLstd450Cos = 14,
-    GLSLstd450Tan = 15,
-    GLSLstd450Asin = 16,
-    GLSLstd450Acos = 17,
-    GLSLstd450Atan = 18,
-    GLSLstd450Sinh = 19,
-    GLSLstd450Cosh = 20,
-    GLSLstd450Tanh = 21,
-    GLSLstd450Asinh = 22,
-    GLSLstd450Acosh = 23,
-    GLSLstd450Atanh = 24,
-    GLSLstd450Atan2 = 25,
-
-    GLSLstd450Pow = 26,
-    GLSLstd450Exp = 27,
-    GLSLstd450Log = 28,
-    GLSLstd450Exp2 = 29,
-    GLSLstd450Log2 = 30,
-    GLSLstd450Sqrt = 31,
-    GLSLstd450InverseSqrt = 32,
-
-    GLSLstd450Determinant = 33,
-    GLSLstd450MatrixInverse = 34,
-
-    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
-    GLSLstd450ModfStruct = 36,      // no OpVariable operand
-    GLSLstd450FMin = 37,
-    GLSLstd450UMin = 38,
-    GLSLstd450SMin = 39,
-    GLSLstd450FMax = 40,
-    GLSLstd450UMax = 41,
-    GLSLstd450SMax = 42,
-    GLSLstd450FClamp = 43,
-    GLSLstd450UClamp = 44,
-    GLSLstd450SClamp = 45,
-    GLSLstd450FMix = 46,
-    GLSLstd450IMix = 47,            // Reserved
-    GLSLstd450Step = 48,
-    GLSLstd450SmoothStep = 49,
-
-    GLSLstd450Fma = 50,
-    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
-    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
-    GLSLstd450Ldexp = 53,
-
-    GLSLstd450PackSnorm4x8 = 54,
-    GLSLstd450PackUnorm4x8 = 55,
-    GLSLstd450PackSnorm2x16 = 56,
-    GLSLstd450PackUnorm2x16 = 57,
-    GLSLstd450PackHalf2x16 = 58,
-    GLSLstd450PackDouble2x32 = 59,
-    GLSLstd450UnpackSnorm2x16 = 60,
-    GLSLstd450UnpackUnorm2x16 = 61,
-    GLSLstd450UnpackHalf2x16 = 62,
-    GLSLstd450UnpackSnorm4x8 = 63,
-    GLSLstd450UnpackUnorm4x8 = 64,
-    GLSLstd450UnpackDouble2x32 = 65,
-
-    GLSLstd450Length = 66,
-    GLSLstd450Distance = 67,
-    GLSLstd450Cross = 68,
-    GLSLstd450Normalize = 69,
-    GLSLstd450FaceForward = 70,
-    GLSLstd450Reflect = 71,
-    GLSLstd450Refract = 72,
-
-    GLSLstd450FindILsb = 73,
-    GLSLstd450FindSMsb = 74,
-    GLSLstd450FindUMsb = 75,
-
-    GLSLstd450InterpolateAtCentroid = 76,
-    GLSLstd450InterpolateAtSample = 77,
-    GLSLstd450InterpolateAtOffset = 78,
-
-    GLSLstd450NMin = 79,
-    GLSLstd450NMax = 80,
-    GLSLstd450NClamp = 81,
-
-    GLSLstd450Count
-};
-
-#endif  // #ifndef GLSLstd450_H

core/deps/glslang/SPIRV/GlslangToSpv.h

@@ -1,61 +0,0 @@
-//
-// Copyright (C) 2014 LunarG, Inc.
-// Copyright (C) 2015-2018 Google, Inc.
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-//    Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-//    Redistributions in binary form must reproduce the above
-//    copyright notice, this list of conditions and the following
-//    disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
-//    contributors may be used to endorse or promote products derived
-//    from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-
-#pragma once
-
-#if defined(_MSC_VER) && _MSC_VER >= 1900
-    #pragma warning(disable : 4464) // relative include path contains '..'
-#endif
-
-#include "SpvTools.h"
-#include "glslang/Include/intermediate.h"
-
-#include <string>
-#include <vector>
-
-#include "Logger.h"
-
-namespace glslang {
-
-void GetSpirvVersion(std::string&);
-int GetSpirvGeneratorVersion();
-void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                  SpvOptions* options = nullptr);
-void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                  spv::SpvBuildLogger* logger, SpvOptions* options = nullptr);
-void OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName);
-void OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName);
-
-}

core/deps/glslang/SPIRV/InReadableOrder.cpp

@@ -1,131 +0,0 @@
-//
-// Copyright (C) 2016 Google, Inc.
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-//    Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-//    Redistributions in binary form must reproduce the above
-//    copyright notice, this list of conditions and the following
-//    disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
-//    contributors may be used to endorse or promote products derived
-//    from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-
-// The SPIR-V spec requires code blocks to appear in an order satisfying the
-// dominator-tree direction (ie, dominator before the dominated).  This is,
-// actually, easy to achieve: any pre-order CFG traversal algorithm will do it.
-// Because such algorithms visit a block only after traversing some path to it
-// from the root, they necessarily visit the block's idom first.
-//
-// But not every graph-traversal algorithm outputs blocks in an order that
-// appears logical to human readers.  The problem is that unrelated branches may
-// be interspersed with each other, and merge blocks may come before some of the
-// branches being merged.
-//
-// A good, human-readable order of blocks may be achieved by performing
-// depth-first search but delaying merge nodes until after all their branches
-// have been visited.  This is implemented below by the inReadableOrder()
-// function.
-
-#include "spvIR.h"
-
-#include <cassert>
-#include <unordered_set>
-
-using spv::Block;
-using spv::Id;
-
-namespace {
-// Traverses CFG in a readable order, invoking a pre-set callback on each block.
-// Use by calling visit() on the root block.
-class ReadableOrderTraverser {
-public:
-    ReadableOrderTraverser(std::function<void(Block*, spv::ReachReason, Block*)> callback)
-      : callback_(callback) {}
-    // Visits the block if it hasn't been visited already and isn't currently
-    // being delayed.  Invokes callback(block, why, header), then descends into its
-    // successors.  Delays merge-block and continue-block processing until all
-    // the branches have been completed.  If |block| is an unreachable merge block or
-    // an unreachable continue target, then |header| is the corresponding header block.
-    void visit(Block* block, spv::ReachReason why, Block* header)
-    {
-        assert(block);
-        if (why == spv::ReachViaControlFlow) {
-            reachableViaControlFlow_.insert(block);
-        }
-        if (visited_.count(block) || delayed_.count(block))
-            return;
-        callback_(block, why, header);
-        visited_.insert(block);
-        Block* mergeBlock = nullptr;
-        Block* continueBlock = nullptr;
-        auto mergeInst = block->getMergeInstruction();
-        if (mergeInst) {
-            Id mergeId = mergeInst->getIdOperand(0);
-            mergeBlock = block->getParent().getParent().getInstruction(mergeId)->getBlock();
-            delayed_.insert(mergeBlock);
-            if (mergeInst->getOpCode() == spv::OpLoopMerge) {
-                Id continueId = mergeInst->getIdOperand(1);
-                continueBlock =
-                    block->getParent().getParent().getInstruction(continueId)->getBlock();
-                delayed_.insert(continueBlock);
-            }
-        }
-        if (why == spv::ReachViaControlFlow) {
-            const auto& successors = block->getSuccessors();
-            for (auto it = successors.cbegin(); it != successors.cend(); ++it)
-                visit(*it, why, nullptr);
-        }
-        if (continueBlock) {
-            const spv::ReachReason continueWhy =
-                (reachableViaControlFlow_.count(continueBlock) > 0)
-                    ? spv::ReachViaControlFlow
-                    : spv::ReachDeadContinue;
-            delayed_.erase(continueBlock);
-            visit(continueBlock, continueWhy, block);
-        }
-        if (mergeBlock) {
-            const spv::ReachReason mergeWhy =
-                (reachableViaControlFlow_.count(mergeBlock) > 0)
-                    ? spv::ReachViaControlFlow
-                    : spv::ReachDeadMerge;
-            delayed_.erase(mergeBlock);
-            visit(mergeBlock, mergeWhy, block);
-        }
-    }
-
-private:
-    std::function<void(Block*, spv::ReachReason, Block*)> callback_;
-    // Whether a block has already been visited or is being delayed.
-    std::unordered_set<Block *> visited_, delayed_;
-
-    // The set of blocks that actually are reached via control flow.
-    std::unordered_set<Block *> reachableViaControlFlow_;
-};
-}
-
-void spv::inReadableOrder(Block* root, std::function<void(Block*, spv::ReachReason, Block*)> callback)
-{
-    ReadableOrderTraverser(callback).visit(root, spv::ReachViaControlFlow, nullptr);
-}

core/deps/glslang/SPIRV/Logger.cpp

@@ -1,72 +0,0 @@
-//
-// Copyright (C) 2016 Google, Inc.
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-//    Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-//    Redistributions in binary form must reproduce the above
-//    copyright notice, this list of conditions and the following
-//    disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-//    Neither the name of Google Inc. nor the names of its
-//    contributors may be used to endorse or promote products derived
-//    from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-
-#ifndef GLSLANG_WEB
-
-#include "Logger.h"
-
-#include <algorithm>
-#include <iterator>
-#include <sstream>
-
-namespace spv {
-
-void SpvBuildLogger::tbdFunctionality(const std::string& f)
-{
-    if (std::find(std::begin(tbdFeatures), std::end(tbdFeatures), f) == std::end(tbdFeatures))
-        tbdFeatures.push_back(f);
-}
-
-void SpvBuildLogger::missingFunctionality(const std::string& f)
-{
-    if (std::find(std::begin(missingFeatures), std::end(missingFeatures), f) == std::end(missingFeatures))
-        missingFeatures.push_back(f);
-}
-
-std::string SpvBuildLogger::getAllMessages() const {
-    std::ostringstream messages;
-    for (auto it = tbdFeatures.cbegin(); it != tbdFeatures.cend(); ++it)
-        messages << "TBD functionality: " << *it << "\n";
-    for (auto it = missingFeatures.cbegin(); it != missingFeatures.cend(); ++it)
-        messages << "Missing functionality: " << *it << "\n";
-    for (auto it = warnings.cbegin(); it != warnings.cend(); ++it)
-        messages << "warning: " << *it << "\n";
-    for (auto it = errors.cbegin(); it != errors.cend(); ++it)
-        messages << "error: " << *it << "\n";
-    return messages.str();
-}
-
-} // end spv namespace
-
-#endif

core/deps/glslang/SPIRV/Logger.h

@@ -1,83 +0,0 @@
-//
-// Copyright (C) 2016 Google, Inc.
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-//    Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-//    Redistributions in binary form must reproduce the above
-//    copyright notice, this list of conditions and the following
-//    disclaimer in the documentation and/or other materials provided
-//    with the distribution.
-//
-//    Neither the name of Google Inc. nor the names of its
-//    contributors may be used to endorse or promote products derived
-//    from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-
-#ifndef GLSLANG_SPIRV_LOGGER_H
-#define GLSLANG_SPIRV_LOGGER_H
-
-#include <string>
-#include <vector>
-
-namespace spv {
-
-// A class for holding all SPIR-V build status messages, including
-// missing/TBD functionalities, warnings, and errors.
-class SpvBuildLogger {
-public:
-    SpvBuildLogger() {}
-
-#ifdef GLSLANG_WEB
-    void tbdFunctionality(const std::string& f) { }
-    void missingFunctionality(const std::string& f) { }
-    void warning(const std::string& w) { }
-    void error(const std::string& e) { errors.push_back(e); }
-    std::string getAllMessages() { return ""; }
-#else
-
-    // Registers a TBD functionality.
-    void tbdFunctionality(const std::string& f);
-    // Registers a missing functionality.
-    void missingFunctionality(const std::string& f);
-
-    // Logs a warning.
-    void warning(const std::string& w) { warnings.push_back(w); }
-    // Logs an error.
-    void error(const std::string& e) { errors.push_back(e); }
-
-    // Returns all messages accumulated in the order of:
-    // TBD functionalities, missing functionalities, warnings, errors.
-    std::string getAllMessages() const;
-#endif
-
-private:
-    SpvBuildLogger(const SpvBuildLogger&);
-
-    std::vector<std::string> tbdFeatures;
-    std::vector<std::string> missingFeatures;
-    std::vector<std::string> warnings;
-    std::vector<std::string> errors;
-};
-
-} // end spv namespace
-
-#endif // GLSLANG_SPIRV_LOGGER_H