CI:Add build date to program log of nightly builds

This is a temporary measure while we run some hardware tests, the previous change broke Burnout 3's engine sounds.

.github/workflows/architecture/release-process.puml

@@ -0,0 +1,47 @@
+@startuml
+participant User as user
+participant Github as github
+participant "Create Release WF" as create
+participant "Build WFs" as build
+participant "Finalize Release WF" as finalize
+participant Discord as discord
+
+==Nightly Release==
+
+user -> github : New Commit on master (from PR, or directly)
+...waiting for commit push event to fire...
+github -> create : Push a new git tag, patch incrementing latest Version
+alt from-pr? case
+    create -> create : Use links to the PR as a description
+else was a commit
+    create -> create : Use Commit Message as Description
+end
+create -> create : Generate release notes
+create -> github : Create new draft release, associated with tag and with the notes
+note right
+Draft releases are not public facing, only those with write access can see them!
+end note
+...waiting for push tag event to fire...
+loop for all build workflows
+github -> build : Build the tag commit
+build -> build : .exe will use the git tag for it's title and such
+build -> build : Upload the generated artifact to the associated release
+alt all-artifacts-uploaded? case
+  build -> github : Publish the release
+  user -> github : Can now download the artifacts on the published release
+end
+note right 
+This is the only area where an eventual consistency issue is apparent
+It is because GitHub does not fire events for when draft releases are edited
+This is glossed over in the initial impl and can be improved and be made eventually consistent as well
+end note
+
+
+...waiting for release publish event to fire...
+github -> finalize : Announce the Release
+finalize -> github : Gather all asset links, and format message embed.
+finalize -> discord : Announce new build via a WebHook
+
+...waiting for announcement...
+user -> discord : Can download artifacts from links via the discord
+@enduml

.github/workflows/linux-workflow.yml

@@ -6,59 +6,36 @@ on:
   push:
     branches:
       - master
-    paths-ignore:
-      - '**/*.md'
-      - '**/*.bat'
-      - '**/*.cmd'
-      - '**/*.props'
-      - '**/*.sln'
-      - '.clang-format'
-      - '.codacy.yaml'
-      - '.github/*'
-      - '.github/workflows/lint-gamedb.yml'
-      - '.github/workflows/macos-workflow.yml'
-      - '.github/workflows/pr-triage.yml'
-      - '.github/workflows/scripts/windows/**'
-      - '.github/workflows/scripts/validation/**'
-      - '.github/workflows/windows-workflow.yml'
-      - '.gitignore'
-      - 'bin/PCSX2_keys.ini.default'
-      - 'build.sh'
-      - 'buildbot.xml'
-      - 'pcsx2/CDVD/Windows/**'
-      - 'pcsx2/DEV9/Win32/**'
-      - 'pcsx2/PAD/Windows/**'
-      - 'pcsx2/SPU2/Windows/**'
-      - 'pcsx2/USB/Win32/**'
-      - 'pcsx2/windows/**'
+    tags:
+      - v*
   pull_request:
     branches:
       - master
     paths-ignore:
-      - '**/*.md'
-      - '**/*.bat'
-      - '**/*.cmd'
-      - '**/*.props'
-      - '**/*.sln'
-      - '.clang-format'
-      - '.codacy.yaml'
-      - '.github/*'
-      - '.github/workflows/lint-gamedb.yml'
-      - '.github/workflows/macos-workflow.yml'
-      - '.github/workflows/pr-triage.yml'
-      - '.github/workflows/scripts/windows/**'
-      - '.github/workflows/scripts/validation/**'
-      - '.github/workflows/windows-workflow.yml'
-      - '.gitignore'
-      - 'bin/PCSX2_keys.ini.default'
-      - 'build.sh'
-      - 'buildbot.xml'
-      - 'pcsx2/CDVD/Windows/**'
-      - 'pcsx2/DEV9/Win32/**'
-      - 'pcsx2/PAD/Windows/**'
-      - 'pcsx2/SPU2/Windows/**'
-      - 'pcsx2/USB/Win32/**'
-      - 'pcsx2/windows/**'
+      - "**/*.md"
+      - "**/*.bat"
+      - "**/*.cmd"
+      - "**/*.props"
+      - "**/*.sln"
+      - ".clang-format"
+      - ".codacy.yaml"
+      - ".github/*"
+      - ".github/workflows/lint-gamedb.yml"
+      - ".github/workflows/macos-workflow.yml"
+      - ".github/workflows/pr-triage.yml"
+      - ".github/workflows/scripts/windows/**"
+      - ".github/workflows/scripts/validation/**"
+      - ".github/workflows/windows-workflow.yml"
+      - ".gitignore"
+      - "bin/PCSX2_keys.ini.default"
+      - "build.sh"
+      - "buildbot.xml"
+      - "pcsx2/CDVD/Windows/**"
+      - "pcsx2/DEV9/Win32/**"
+      - "pcsx2/PAD/Windows/**"
+      - "pcsx2/SPU2/Windows/**"
+      - "pcsx2/USB/Win32/**"
+      - "pcsx2/windows/**"
 
 jobs:
   build:
@@ -86,18 +63,21 @@ jobs:
             # (PCH conflicts with ccache, fixed by https://gitlab.kitware.com/cmake/cmake/-/merge_requests/4400)
             cmakeflags: -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON
             detail: " nopch"
+            appimage: false
             experimental: false
           - os: ubuntu-18.04
             platform: x86
             compiler: gcc
             cmakeflags: -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON
             detail: " nopch"
+            appimage: false
             experimental: false
           - os: ubuntu-18.04
             platform: x86
             compiler: gcc
             cmakeflags: -DCMAKE_DISABLE_PRECOMPILE_HEADERS=ON -DARCH_FLAG=-march=haswell
             detail: " avx2 nopch"
+            appimage: false
             experimental: false
 
     name: ${{ matrix.platform }} | ${{ matrix.compiler }}${{ matrix.detail }}
@@ -169,7 +149,8 @@ jobs:
           TRIMMED_ARTIFACT_NAME=$(printf "%.199s]" "$ARTIFACT_NAME")
           echo "name=$TRIMMED_ARTIFACT_NAME"
           echo "##[set-output name=name;]${TRIMMED_ARTIFACT_NAME}"
-          
+          echo "##[set-output name=arch;]${ARCH}"
+
       - name: Install Packages
         env:
           PLATFORM: ${{ matrix.platform }}
@@ -190,18 +171,37 @@ jobs:
       - name: Run Tests
         working-directory: ./build
         run: ninja unittests
-        
+
       - name: Package AppImage
+        if: matrix.appimage == true
         env:
           PLATFORM: ${{ matrix.platform }}
           COMPILER: ${{ matrix.compiler }}
           name: ${{ steps.artifact-metadata.outputs.name }}
         run: .github/workflows/scripts/linux/appimage.sh
-        if: ${{ matrix.appimage }}
 
       - name: Upload artifact
+        if: matrix.appimage == true
         uses: actions/upload-artifact@v2
         with:
           name: ${{ steps.artifact-metadata.outputs.name }}
-          path: artifacts
-        if: ${{ matrix.appimage }}
+          path: ci-artifacts
+
+      # ---- Release / Tagging related steps ----
+      - name: Prepare Build Artifacts
+        if: github.repository == 'PCSX2/pcsx2' && startsWith(github.ref, 'refs/tags/') && matrix.appimage == true
+        run: |
+          mv ./ci-artifacts/*.AppImage ./ci-artifacts/linux-AppImage-${{ steps.artifact-metadata.outputs.arch }}.AppImage
+          ls ./ci-artifacts/
+
+      - name: Upload Assets and Potential Publish Release
+        if: github.repository == 'PCSX2/pcsx2' && startsWith(github.ref, 'refs/tags/') && matrix.appimage == true
+        env:
+          GITHUB_TOKEN: ${{ secrets.BOT_PAT }}
+          ASSET_DIR: ${{ github.WORKSPACE }}/ci-artifacts
+          ASSET_EXTENSION: AppImage
+          TAG_TO_SEARCH_FOR: ${{ github.REF }}
+        run: |
+          cd ./.github/workflows/scripts/releases/upload-release-artifacts
+          npm ci
+          node index.js

.github/workflows/pr-triage.yml

@@ -5,6 +5,7 @@ on: pull_request_target
 
 jobs:
   triage:
+    if: github.repository == 'PCSX2/pcsx2'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/labeler@main

.github/workflows/release-announce.yml

@@ -0,0 +1,24 @@
+name: 📢 Announce Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  announce:
+    if: github.repository == 'PCSX2/pcsx2'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+
+      - name: Announce Release
+        env:
+          DISCORD_BUILD_WEBHOOK: ${{ secrets.DISCORD_BUILD_WEBHOOK }}
+        run: |
+          cd ./.github/workflows/scripts/releases/announce-release
+          npm ci
+          node index.js

.github/workflows/release-push-tag-and-draft.yml

@@ -0,0 +1,62 @@
+# Whenever a commit is pushed to master (ideally via a pull-request!)
+# this action will create the next release, which means:
+# 1. tag master with the proper version
+# 2. create a new draft release (pre-released if a nightly build)
+# 3. add release notes
+
+name: 🏭 Create Release
+
+on:
+  push:
+    branches:
+      - master
+  # TODO - future work
+  # workflow_dispatch:
+  #   inputs:
+  #     isStable:
+  #       description: 'Should it be a stable release?'
+  #       required: true
+  #       default: 'false'
+  #     versionTag:
+  #       description: 'The version to tag with'
+  #       required: true
+
+jobs:
+  cut-release:
+    if: github.repository == 'PCSX2/pcsx2'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      # Docs - https://github.com/mathieudutour/github-tag-action
+      # Workflows cannot trigger other workflows implicitly
+      # - https://github.community/t/github-actions-workflow-not-triggering-with-tag-push/17053/7
+      - name: Bump Version and Push Tag
+        id: tag_version
+        uses: mathieudutour/github-tag-action@v5.6
+        with:
+          github_token: ${{ secrets.BOT_PAT }}
+          tag_prefix: v
+          default_bump: patch
+
+      # Generate the Release Notes
+      - name: Generate Release Notes
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          COMMIT_SHA: ${{ github.SHA }}
+        run: |
+          cd ./.github/workflows/scripts/releases/generate-release-notes
+          npm ci
+          node index.js
+          mv ./release-notes.md ${GITHUB_WORKSPACE}/release-notes.md
+          ls
+
+      # Docs - https://github.com/softprops/action-gh-release
+      - name: Create a GitHub Release
+        uses: softprops/action-gh-release@v1
+        if: steps.tag_version.outputs.new_tag
+        with:
+          body_path: ./release-notes.md
+          draft: true
+          prerelease: true
+          tag_name: ${{ steps.tag_version.outputs.new_tag }}

.github/workflows/scripts/controller-db/.gitignore

@@ -0,0 +1 @@
+*.txt

.github/workflows/scripts/controller-db/update-db.py

@@ -0,0 +1,38 @@
+import os
+
+relevant_categories = [
+  "# Mac OS X",
+  "# Linux"
+]
+
+header_lines = []
+new_db_contents = []
+
+def is_relevant_category(line):
+  for category in relevant_categories:
+    if category in line:
+      return True
+  return False
+
+with open("./game_controller_db.txt") as file:
+  lines = file.readlines()
+  finished_header = False
+  processing_section = False
+  for line in lines:
+    if finished_header is False:
+      header_lines.append(line)
+      if line == "\n":
+        finished_header = True
+    if processing_section and line == "\n":
+      processing_section = False
+      new_db_contents.append("\n")
+    if is_relevant_category(line) and processing_section is False:
+      processing_section = True
+      new_db_contents.append(line)
+    elif processing_section:
+      new_db_contents.append(line)
+
+os.remove("./game_controller_db.txt")
+with open("./game_controller_db.txt", "w") as f:
+  f.writelines(header_lines)
+  f.writelines(new_db_contents)

.github/workflows/scripts/linux/appimage.sh

@@ -37,11 +37,15 @@ mkdir -p squashfs-root/usr/share/icons && cp ./squashfs-root/PCSX2.png ./squashf
 mkdir -p squashfs-root/usr/share/icons/hicolor/scalable/apps && cp ./squashfs-root/PCSX2.png ./squashfs-root/usr/share/icons/hicolor/scalable/apps
 mkdir -p squashfs-root/usr/share/pixmaps && cp ./squashfs-root/PCSX2.png ./squashfs-root/usr/share/pixmaps
 mkdir -p squashfs-root/usr/lib/
+mkdir -p squashfs-root/usr/optional/libstdc++
+mkdir -p squashfs-root/usr/optional/libgcc_s
 cp ./.github/workflows/scripts/linux/AppRun "$GITHUB_WORKSPACE"/squashfs-root/AppRun
-curl -sSfL "https://github.com/AppImage/AppImageKit/releases/download/continuous/AppRun-$APPARCH" -o "$GITHUB_WORKSPACE"/squashfs-root/AppRun-patched
+curl -sSfL "https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/AppRun-patched-$APPARCH" -o "$GITHUB_WORKSPACE"/squashfs-root/AppRun-patched
+curl -sSfL "https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/exec-$APPARCH.so" -o "$GITHUB_WORKSPACE"/squashfs-root/usr/optional/exec.so
 chmod a+x ./squashfs-root/AppRun
 chmod a+x ./squashfs-root/runtime
 chmod a+x ./squashfs-root/AppRun-patched
+chmod a+x ./squashfs-root/usr/optional/exec.so
 echo "$name" > "$GITHUB_WORKSPACE"/squashfs-root/version.txt
 mkdir -p "$GITHUB_WORKSPACE"/squashfs-root/usr/bin/app
 cp -r "$GITHUB_WORKSPACE"/bin/Langs "$GITHUB_WORKSPACE"/squashfs-root/usr/bin/
@@ -49,12 +53,14 @@ cp "$GITHUB_WORKSPACE"/bin/docs/{Configuration_Guide.pdf,PCSX2_FAQ.pdf} "$GITHUB
 cp "$GITHUB_WORKSPACE"/bin/cheats_ws.zip "$GITHUB_WORKSPACE"/squashfs-root/usr/bin/app
 cp ./bin/GameIndex.yaml "$GITHUB_WORKSPACE"/squashfs-root/usr/bin/app/GameIndex.yaml
 cp /usr/lib/$LIBARCH/libthai.so.0 "$GITHUB_WORKSPACE"/squashfs-root/usr/lib/
+cp --dereference /usr/lib/"$LIBARCH"/libstdc++.so.6 "$GITHUB_WORKSPACE"/squashfs-root/usr/optional/libstdc++/libstdc++.so.6
+cp --dereference /lib/"$LIBARCH"/libgcc_s.so.1 "$GITHUB_WORKSPACE"/squashfs-root/usr/optional/libgcc_s/libgcc_s.so.1
 export UPD_INFO="gh-releases-zsync|PCSX2|pcsx2|latest|$name.AppImage.zsync"
 export OUTPUT="$name.AppImage"
 /tmp/squashfs-root/AppRun --appdir="$GITHUB_WORKSPACE"/squashfs-root/ --plugin gtk -d "$GITHUB_WORKSPACE"/squashfs-root/PCSX2.desktop -i "$GITHUB_WORKSPACE"/squashfs-root/PCSX2.png --output appimage
-mkdir -p "$GITHUB_WORKSPACE"/artifacts/
+mkdir -p "$GITHUB_WORKSPACE"/ci-artifacts/
 ls -al .
-mv "$name.AppImage" "$GITHUB_WORKSPACE"/artifacts # && mv "$name.AppImage.zsync" "$GITHUB_WORKSPACE"/artifacts
-chmod -R 777 ./artifacts
-cd ./artifacts
+mv "$name.AppImage" "$GITHUB_WORKSPACE"/ci-artifacts # && mv "$name.AppImage.zsync" "$GITHUB_WORKSPACE"/ci-artifacts
+chmod -R 777 ./ci-artifacts
+cd ./ci-artifacts
 ls -al .

.github/workflows/scripts/linux/generate-cmake.sh

@@ -3,8 +3,8 @@
 set -e
 
 if [ "${COMPILER}" = "gcc" ]; then
-  export CC=gcc
-  export CXX=g++
+  export CC=gcc-10
+  export CXX=g++-10
 else
   export CC=clang
   export CXX=clang++

.github/workflows/scripts/linux/install-packages.sh

@@ -6,100 +6,42 @@ set -e
 declare -a BUILD_PACKAGES=(
   "ccache"
   "cmake"
-  "g++-8-multilib"
   "ninja-build"
 )
 
-declare -a GCC_PACKAGES=(
-  # Nothing Unique Needed
-)
-
-declare -a CLANG_PACKAGES=(
-  "clang-format"
-  "clang-tidy"
-  "clang-tools"
-  "clang"
-  "clangd-10"
-  "libc++-dev"
-  "libc++1"
-  "libc++abi-dev"
-  "libc++abi1"
-  "libclang-dev"
-  "libclang1"
-  "liblldb-10-dev"
-  "libllvm-10-ocaml-dev"
-  "libomp-dev"
-  "libomp5"
-  "lld"
-  "lldb"
-  "llvm-dev"
-  "llvm-runtime"
-  "llvm"
-  "python3-clang-10"
-)
-
 # Packages - PCSX2
 declare -a PCSX2_PACKAGES=(
-  "curl"
-  "fuse"
-  "gettext"
   "libaio-dev"
-  "libasound2-dev"
-  "libatk1.0-dev"
-  "libatk-bridge2.0-dev"
   "libbz2-dev"
-  "libcairo2-dev"
-  "libcggl"
-  "libdbus-1-dev"
   "libegl1-mesa-dev"
-  "libfontconfig1-dev"
   "libgdk-pixbuf2.0-dev"
-  "libgirepository-1.0-1"
-  "libgl-dev"
   "libgl1-mesa-dev"
-  "libgl1-mesa-dri"
-  "libgl1"
-  "libgles2-mesa-dev"
-  "libglew-dev"
-  "libglib2.0-dev"
-  "libglu1-mesa-dev"
-  "libglu1-mesa"
-  "libglvnd-dev"
-  "libglx-mesa0"
-  "libglx0"
   "libgtk-3-dev"
-  "libgtk2.0-dev"
   "libharfbuzz-dev"
-  "libibus-1.0-dev"
-  "libjack-jackd2-dev"
   "libjpeg-dev"
-  "libllvm10"
   "liblzma-dev"
-  "liblzma5"
-  "libpango1.0-dev"
   "libpcap0.8-dev"
   "libpng-dev"
-  "libportaudiocpp0"
   "libpulse-dev"
   "librsvg2-dev"
-  "libsdl1.2-dev"
   "libsdl2-dev"
   "libsamplerate0-dev"
   "libsoundtouch-dev"
-  "libwxgtk3.0-dev"
-  "libwxgtk3.0-gtk3-0v5"
   "libwxgtk3.0-gtk3-dev"
   "libx11-xcb-dev"
-  "libxext-dev"
-  "libxft-dev"
   "libxml2-dev"
-  "nvidia-cg-toolkit"
   "pkg-config"
   "portaudio19-dev"
-  "python"
   "zlib1g-dev"
 )
 
+if [ "${COMPILER}" = "gcc" ]; then
+  BUILD_PACKAGES+=("g++-10-multilib")
+else
+  BUILD_PACKAGES+=("clang-9")
+  PCSX2_PACKAGES+=("libstdc++-10-dev")
+fi
+
 # - https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2004-README.md
 ARCH=""
 echo "${PLATFORM}"
@@ -111,41 +53,14 @@ fi
 sudo apt-get -qq update
 
 # Install packages needed for building
-BUILD_PACKAGE_STR=""
-for i in "${BUILD_PACKAGES[@]}"; do
-  BUILD_PACKAGE_STR="${BUILD_PACKAGE_STR} ${i}"
-done
-
-if [ "${COMPILER}" = "gcc" ]; then
-  for i in "${GCC_PACKAGES[@]}"; do
-    BUILD_PACKAGE_STR="${BUILD_PACKAGE_STR} ${i}"
-  done
-else
-  for i in "${CLANG_PACKAGES[@]}"; do
-    BUILD_PACKAGE_STR="${BUILD_PACKAGE_STR} ${i}"
-  done
-fi
-
-echo "Will install the following packages for building - ${BUILD_PACKAGE_STR}"
+echo "Will install the following packages for building - ${BUILD_PACKAGES[*]}"
 #sudo apt remove gcc-9 g++-9
-sudo apt-get -y install ${BUILD_PACKAGE_STR}
-
-sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 10
-sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-8 10
-sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc 30
-sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/g++ 30
+sudo apt-get -y install "${BUILD_PACKAGES[@]}"
 
 # Install packages needed by pcsx2
-PCSX2_PACKAGES_STR=""
-for i in "${PCSX2_PACKAGES[@]}"; do
-  PCSX2_PACKAGES_STR="${PCSX2_PACKAGES_STR} ${i}${ARCH}"
-done
-if [ "${PLATFORM}" == "x86" ]; then
-echo "Installing workaround attempt"
-sudo apt-get -y install libgcc-s1:i386
-fi
-echo "Will install the following packages for pcsx2 - ${PCSX2_PACKAGES_STR}"
-sudo apt-get -y install ${PCSX2_PACKAGES_STR}
+PCSX2_PACKAGES=("${PCSX2_PACKAGES[@]/%/"${ARCH}"}")
+echo "Will install the following packages for pcsx2 - ${PCSX2_PACKAGES[*]}"
+sudo apt-get -y install "${PCSX2_PACKAGES[@]}"
 
 cd /tmp
 curl -sSfLO https://github.com/NixOS/patchelf/releases/download/0.12/patchelf-0.12.tar.bz2        

.github/workflows/scripts/releases/announce-release/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+*.md

.github/workflows/scripts/releases/announce-release/index.js

@@ -0,0 +1,53 @@
+import { MessageEmbed, WebhookClient } from "discord.js";
+import * as github from '@actions/github';
+
+const assets = github.context.payload.release.assets;
+let windowsAssetLinks = "";
+let linuxAssetLinks = "";
+
+for (var i = 0; i < assets.length; i++) {
+  let asset = assets[i];
+  if (asset.name.includes("symbols")) {
+    continue;
+  }
+  if (asset.name.includes("windows")) {
+    let friendlyName = asset.name;
+    try {
+      friendlyName = asset.name.split("windows-")[1].split(".7z")[0].replace("-", " ");
+    } catch (e) {
+      console.log(e);
+    }
+    windowsAssetLinks += `- [${friendlyName}](${asset.browser_download_url})\n`
+  } else if (asset.name.includes("linux")) {
+    let friendlyName = asset.name;
+    try {
+      friendlyName = asset.name.split("linux-")[1].split(".AppImage")[0].replace("-", " ");
+    } catch (e) {
+      console.log(e);
+    }
+    linuxAssetLinks += `- [${friendlyName}](${asset.browser_download_url})\n`
+  }
+}
+
+// Publish Webhook
+const embed = new MessageEmbed()
+  .setColor('#FF8000')
+  .setTitle('New PCSX2 Nightly Build Available!')
+  .addFields(
+    { name: 'Version', value: github.context.payload.release.tag_name, inline: true },
+    { name: 'Release Link', value: `[Github Release](${github.context.payload.release.html_url})`, inline: true },
+    { name: 'Installation Steps', value: '[See Here](https://github.com/PCSX2/pcsx2/wiki/Nightly-Build-Usage-Guide)', inline: true },
+    { name: 'Included Changes', value: github.context.payload.release.body, inline: false }
+  );
+
+if (windowsAssetLinks != "") {
+  embed.addField('Windows Downloads', windowsAssetLinks, false);
+}
+if (linuxAssetLinks != "") {
+  embed.addField('Linux Downloads', linuxAssetLinks, false);
+}
+
+const webhookClient = new WebhookClient({ url: process.env.DISCORD_BUILD_WEBHOOK });
+await webhookClient.send({
+  embeds: [embed],
+});

.github/workflows/scripts/releases/announce-release/package-lock.json

@@ -0,0 +1,806 @@
+{
+  "name": "announce-release",
+  "version": "1.0.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "@actions/github": "^5.0.0",
+        "discord.js": "^13.2.0"
+      }
+    },
+    "node_modules/@actions/github": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@actions/github/-/github-5.0.0.tgz",
+      "integrity": "sha512-QvE9eAAfEsS+yOOk0cylLBIO/d6WyWIOvsxxzdrPFaud39G6BOkUwScXZn1iBzQzHyu9SBkkLSWlohDWdsasAQ==",
+      "dependencies": {
+        "@actions/http-client": "^1.0.11",
+        "@octokit/core": "^3.4.0",
+        "@octokit/plugin-paginate-rest": "^2.13.3",
+        "@octokit/plugin-rest-endpoint-methods": "^5.1.1"
+      }
+    },
+    "node_modules/@actions/http-client": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-1.0.11.tgz",
+      "integrity": "sha512-VRYHGQV1rqnROJqdMvGUbY/Kn8vriQe/F9HR2AlYHzmKuM/p3kjNuXhmdBfcVgsvRWTz5C5XW5xvndZrVBuAYg==",
+      "dependencies": {
+        "tunnel": "0.0.6"
+      }
+    },
+    "node_modules/@discordjs/builders": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-0.6.0.tgz",
+      "integrity": "sha512-mH3Gx61LKk2CD05laCI9K5wp+a3NyASHDUGx83DGJFkqJlRlSV5WMJNY6RS37A5SjqDtGMF4wVR9jzFaqShe6Q==",
+      "dependencies": {
+        "@sindresorhus/is": "^4.0.1",
+        "discord-api-types": "^0.22.0",
+        "ow": "^0.27.0",
+        "ts-mixer": "^6.0.0",
+        "tslib": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=14.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/@discordjs/builders/node_modules/discord-api-types": {
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.22.0.tgz",
+      "integrity": "sha512-l8yD/2zRbZItUQpy7ZxBJwaLX/Bs2TGaCthRppk8Sw24LOIWg12t9JEreezPoYD0SQcC2htNNo27kYEpYW/Srg==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@discordjs/collection": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-0.2.1.tgz",
+      "integrity": "sha512-vhxqzzM8gkomw0TYRF3tgx7SwElzUlXT/Aa41O7mOcyN6wIJfj5JmDWaO5XGKsGSsNx7F3i5oIlrucCCWV1Nog==",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@discordjs/form-data": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/form-data/-/form-data-3.0.1.tgz",
+      "integrity": "sha512-ZfFsbgEXW71Rw/6EtBdrP5VxBJy4dthyC0tpQKGKmYFImlmmrykO14Za+BiIVduwjte0jXEBlhSKf0MWbFp9Eg==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/@octokit/auth-token": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz",
+      "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3"
+      }
+    },
+    "node_modules/@octokit/core": {
+      "version": "3.5.1",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.5.1.tgz",
+      "integrity": "sha512-omncwpLVxMP+GLpLPgeGJBF6IWJFjXDS5flY5VbppePYX9XehevbDykRH9PdCdvqt9TS5AOTiDide7h0qrkHjw==",
+      "dependencies": {
+        "@octokit/auth-token": "^2.4.4",
+        "@octokit/graphql": "^4.5.8",
+        "@octokit/request": "^5.6.0",
+        "@octokit/request-error": "^2.0.5",
+        "@octokit/types": "^6.0.3",
+        "before-after-hook": "^2.2.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/endpoint": {
+      "version": "6.0.12",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz",
+      "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3",
+        "is-plain-object": "^5.0.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/graphql": {
+      "version": "4.8.0",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz",
+      "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==",
+      "dependencies": {
+        "@octokit/request": "^5.6.0",
+        "@octokit/types": "^6.0.3",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/openapi-types": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-11.1.0.tgz",
+      "integrity": "sha512-dWZfYvCCdjZzDYA3lIAMF72Q0jld8xidqCq5Ryw09eBJXZdcM6he0vWBTvw/b5UnGYqexxOyHWgfrsTlUJL3Gw=="
+    },
+    "node_modules/@octokit/plugin-paginate-rest": {
+      "version": "2.16.9",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.16.9.tgz",
+      "integrity": "sha512-gfSCMgz5scFKsR0dW4jaYsDJVt/UwCHp4dF7sHlmSekZvwzvLiOAGZ4MQkEsL5DW9hIk2W+UQkYZMTA1b6Wsqw==",
+      "dependencies": {
+        "@octokit/types": "^6.33.0"
+      }
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "5.12.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.12.1.tgz",
+      "integrity": "sha512-0nY3htfl6x9UkPcqv8pm9vOC/bTA7f4IMDWln13neHRdNWQvOQgZ9fRxK7BAc74rye4yVINEFi9Yb9rnGUvosA==",
+      "dependencies": {
+        "@octokit/types": "^6.33.0",
+        "deprecation": "^2.3.1"
+      }
+    },
+    "node_modules/@octokit/request": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.2.tgz",
+      "integrity": "sha512-je66CvSEVf0jCpRISxkUcCa0UkxmFs6eGDRSbfJtAVwbLH5ceqF+YEyC8lj8ystKyZTy8adWr0qmkY52EfOeLA==",
+      "dependencies": {
+        "@octokit/endpoint": "^6.0.1",
+        "@octokit/request-error": "^2.1.0",
+        "@octokit/types": "^6.16.1",
+        "is-plain-object": "^5.0.0",
+        "node-fetch": "^2.6.1",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/request-error": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz",
+      "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3",
+        "deprecation": "^2.0.0",
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/@octokit/types": {
+      "version": "6.33.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.33.0.tgz",
+      "integrity": "sha512-0zffZ048M0UhthyPXQHLz4038Ak46nMWZXkzlXvXB/M/L1jYPBceq4iZj4qjKVrvveaJrrgKdJ9+3yUuITfcCw==",
+      "dependencies": {
+        "@octokit/openapi-types": "^11.1.0"
+      }
+    },
+    "node_modules/@sapphire/async-queue": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.1.6.tgz",
+      "integrity": "sha512-M5CbgMgesemMUCQo5G/InGHvp+GZx6uuJNV1iwvSWD8EFNVrfxaTcqhcAXM3MPYkjlxvNnoDNk0R1lfzvca6LA==",
+      "engines": {
+        "node": ">=v14.18.0",
+        "npm": ">=7.24.2"
+      }
+    },
+    "node_modules/@sindresorhus/is": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.2.0.tgz",
+      "integrity": "sha512-VkE3KLBmJwcCaVARtQpfuKcKv8gcBmUubrfHGF84dXuuW6jgsRYxPtzcIhPyK9WAPpRt2/xY6zkD9MnRaJzSyw==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/is?sponsor=1"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "16.10.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.10.3.tgz",
+      "integrity": "sha512-ho3Ruq+fFnBrZhUYI46n/bV2GjwzSkwuT4dTf0GkuNFmnb8nq4ny2z9JEVemFi6bdEJanHLlYfy9c6FN9B9McQ=="
+    },
+    "node_modules/@types/ws": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.2.0.tgz",
+      "integrity": "sha512-cyeefcUCgJlEk+hk2h3N+MqKKsPViQgF5boi9TTHSK+PoR9KWBb/C5ccPcDyAqgsbAYHTwulch725DV84+pSpg==",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k="
+    },
+    "node_modules/before-after-hook": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.2.tgz",
+      "integrity": "sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ=="
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/deprecation": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
+      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
+    },
+    "node_modules/discord-api-types": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.23.1.tgz",
+      "integrity": "sha512-igWmn+45mzXRWNEPU25I/pr8MwxHb767wAr51oy3VRLRcTlp5ADBbrBR0lq3SA1Rfw3MtM4TQu1xo3kxscfVdQ==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/discord.js": {
+      "version": "13.2.0",
+      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-13.2.0.tgz",
+      "integrity": "sha512-nyxUvL8wuQG38zx13wUMkpcA8koFszyiXdkSLwwM9opKW2LC2H5gD0cTZxImeJ6GtEnKPWT8xBiE8lLBmbNIhw==",
+      "dependencies": {
+        "@discordjs/builders": "^0.6.0",
+        "@discordjs/collection": "^0.2.1",
+        "@discordjs/form-data": "^3.0.1",
+        "@sapphire/async-queue": "^1.1.5",
+        "@types/ws": "^8.2.0",
+        "discord-api-types": "^0.23.1",
+        "node-fetch": "^2.6.1",
+        "ws": "^8.2.3"
+      },
+      "engines": {
+        "node": ">=16.6.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/dot-prop": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
+      "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
+      "dependencies": {
+        "is-obj": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-obj": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
+      "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-plain-object": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
+      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/lodash.isequal": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+      "integrity": "sha1-QVxEePK8wwEgwizhDtMib30+GOA="
+    },
+    "node_modules/mime-db": {
+      "version": "1.50.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.50.0.tgz",
+      "integrity": "sha512-9tMZCDlYHqeERXEHO9f/hKfNXhre5dK2eE/krIvUjZbS2KPcqGDfNShIWS1uW9XOTKQKqK6qbeOci18rbfW77A==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.33",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.33.tgz",
+      "integrity": "sha512-plLElXp7pRDd0bNZHw+nMd52vRYjLwQjygaNg7ddJ2uJtTlmnTCjWuPKxVu6//AdaRuME84SvLW91sIkBqGT0g==",
+      "dependencies": {
+        "mime-db": "1.50.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.5.tgz",
+      "integrity": "sha512-mmlIVHJEu5rnIxgEgez6b9GgWXbkZj5YZ7fx+2r94a2E+Uirsp6HsPTPlomfdHtpt/B0cdKviwkoaM6pyvUOpQ==",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/ow": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/ow/-/ow-0.27.0.tgz",
+      "integrity": "sha512-SGnrGUbhn4VaUGdU0EJLMwZWSupPmF46hnTRII7aCLCrqixTAC5eKo8kI4/XXf1eaaI8YEVT+3FeGNJI9himAQ==",
+      "dependencies": {
+        "@sindresorhus/is": "^4.0.1",
+        "callsites": "^3.1.0",
+        "dot-prop": "^6.0.1",
+        "lodash.isequal": "^4.5.0",
+        "type-fest": "^1.2.1",
+        "vali-date": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
+    },
+    "node_modules/ts-mixer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.0.tgz",
+      "integrity": "sha512-nXIb1fvdY5CBSrDIblLn73NW0qRDk5yJ0Sk1qPBF560OdJfQp9jhl+0tzcY09OZ9U+6GpeoI9RjwoIKFIoB9MQ=="
+    },
+    "node_modules/tslib": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.1.tgz",
+      "integrity": "sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw=="
+    },
+    "node_modules/tunnel": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
+      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==",
+      "engines": {
+        "node": ">=0.6.11 <=0.7.0 || >=0.7.3"
+      }
+    },
+    "node_modules/type-fest": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz",
+      "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/universal-user-agent": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
+      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
+    },
+    "node_modules/vali-date": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/vali-date/-/vali-date-1.0.0.tgz",
+      "integrity": "sha1-G5BKWWCfsyjvB4E4Qgk09rhnCaY=",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
+    },
+    "node_modules/ws": {
+      "version": "8.2.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.2.3.tgz",
+      "integrity": "sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": "^5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@actions/github": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@actions/github/-/github-5.0.0.tgz",
+      "integrity": "sha512-QvE9eAAfEsS+yOOk0cylLBIO/d6WyWIOvsxxzdrPFaud39G6BOkUwScXZn1iBzQzHyu9SBkkLSWlohDWdsasAQ==",
+      "requires": {
+        "@actions/http-client": "^1.0.11",
+        "@octokit/core": "^3.4.0",
+        "@octokit/plugin-paginate-rest": "^2.13.3",
+        "@octokit/plugin-rest-endpoint-methods": "^5.1.1"
+      }
+    },
+    "@actions/http-client": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-1.0.11.tgz",
+      "integrity": "sha512-VRYHGQV1rqnROJqdMvGUbY/Kn8vriQe/F9HR2AlYHzmKuM/p3kjNuXhmdBfcVgsvRWTz5C5XW5xvndZrVBuAYg==",
+      "requires": {
+        "tunnel": "0.0.6"
+      }
+    },
+    "@discordjs/builders": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-0.6.0.tgz",
+      "integrity": "sha512-mH3Gx61LKk2CD05laCI9K5wp+a3NyASHDUGx83DGJFkqJlRlSV5WMJNY6RS37A5SjqDtGMF4wVR9jzFaqShe6Q==",
+      "requires": {
+        "@sindresorhus/is": "^4.0.1",
+        "discord-api-types": "^0.22.0",
+        "ow": "^0.27.0",
+        "ts-mixer": "^6.0.0",
+        "tslib": "^2.3.1"
+      },
+      "dependencies": {
+        "discord-api-types": {
+          "version": "0.22.0",
+          "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.22.0.tgz",
+          "integrity": "sha512-l8yD/2zRbZItUQpy7ZxBJwaLX/Bs2TGaCthRppk8Sw24LOIWg12t9JEreezPoYD0SQcC2htNNo27kYEpYW/Srg=="
+        }
+      }
+    },
+    "@discordjs/collection": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-0.2.1.tgz",
+      "integrity": "sha512-vhxqzzM8gkomw0TYRF3tgx7SwElzUlXT/Aa41O7mOcyN6wIJfj5JmDWaO5XGKsGSsNx7F3i5oIlrucCCWV1Nog=="
+    },
+    "@discordjs/form-data": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/form-data/-/form-data-3.0.1.tgz",
+      "integrity": "sha512-ZfFsbgEXW71Rw/6EtBdrP5VxBJy4dthyC0tpQKGKmYFImlmmrykO14Za+BiIVduwjte0jXEBlhSKf0MWbFp9Eg==",
+      "requires": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      }
+    },
+    "@octokit/auth-token": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz",
+      "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==",
+      "requires": {
+        "@octokit/types": "^6.0.3"
+      }
+    },
+    "@octokit/core": {
+      "version": "3.5.1",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.5.1.tgz",
+      "integrity": "sha512-omncwpLVxMP+GLpLPgeGJBF6IWJFjXDS5flY5VbppePYX9XehevbDykRH9PdCdvqt9TS5AOTiDide7h0qrkHjw==",
+      "requires": {
+        "@octokit/auth-token": "^2.4.4",
+        "@octokit/graphql": "^4.5.8",
+        "@octokit/request": "^5.6.0",
+        "@octokit/request-error": "^2.0.5",
+        "@octokit/types": "^6.0.3",
+        "before-after-hook": "^2.2.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/endpoint": {
+      "version": "6.0.12",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz",
+      "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==",
+      "requires": {
+        "@octokit/types": "^6.0.3",
+        "is-plain-object": "^5.0.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/graphql": {
+      "version": "4.8.0",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz",
+      "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==",
+      "requires": {
+        "@octokit/request": "^5.6.0",
+        "@octokit/types": "^6.0.3",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/openapi-types": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-11.1.0.tgz",
+      "integrity": "sha512-dWZfYvCCdjZzDYA3lIAMF72Q0jld8xidqCq5Ryw09eBJXZdcM6he0vWBTvw/b5UnGYqexxOyHWgfrsTlUJL3Gw=="
+    },
+    "@octokit/plugin-paginate-rest": {
+      "version": "2.16.9",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.16.9.tgz",
+      "integrity": "sha512-gfSCMgz5scFKsR0dW4jaYsDJVt/UwCHp4dF7sHlmSekZvwzvLiOAGZ4MQkEsL5DW9hIk2W+UQkYZMTA1b6Wsqw==",
+      "requires": {
+        "@octokit/types": "^6.33.0"
+      }
+    },
+    "@octokit/plugin-rest-endpoint-methods": {
+      "version": "5.12.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.12.1.tgz",
+      "integrity": "sha512-0nY3htfl6x9UkPcqv8pm9vOC/bTA7f4IMDWln13neHRdNWQvOQgZ9fRxK7BAc74rye4yVINEFi9Yb9rnGUvosA==",
+      "requires": {
+        "@octokit/types": "^6.33.0",
+        "deprecation": "^2.3.1"
+      }
+    },
+    "@octokit/request": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.2.tgz",
+      "integrity": "sha512-je66CvSEVf0jCpRISxkUcCa0UkxmFs6eGDRSbfJtAVwbLH5ceqF+YEyC8lj8ystKyZTy8adWr0qmkY52EfOeLA==",
+      "requires": {
+        "@octokit/endpoint": "^6.0.1",
+        "@octokit/request-error": "^2.1.0",
+        "@octokit/types": "^6.16.1",
+        "is-plain-object": "^5.0.0",
+        "node-fetch": "^2.6.1",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/request-error": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz",
+      "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==",
+      "requires": {
+        "@octokit/types": "^6.0.3",
+        "deprecation": "^2.0.0",
+        "once": "^1.4.0"
+      }
+    },
+    "@octokit/types": {
+      "version": "6.33.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.33.0.tgz",
+      "integrity": "sha512-0zffZ048M0UhthyPXQHLz4038Ak46nMWZXkzlXvXB/M/L1jYPBceq4iZj4qjKVrvveaJrrgKdJ9+3yUuITfcCw==",
+      "requires": {
+        "@octokit/openapi-types": "^11.1.0"
+      }
+    },
+    "@sapphire/async-queue": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.1.6.tgz",
+      "integrity": "sha512-M5CbgMgesemMUCQo5G/InGHvp+GZx6uuJNV1iwvSWD8EFNVrfxaTcqhcAXM3MPYkjlxvNnoDNk0R1lfzvca6LA=="
+    },
+    "@sindresorhus/is": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.2.0.tgz",
+      "integrity": "sha512-VkE3KLBmJwcCaVARtQpfuKcKv8gcBmUubrfHGF84dXuuW6jgsRYxPtzcIhPyK9WAPpRt2/xY6zkD9MnRaJzSyw=="
+    },
+    "@types/node": {
+      "version": "16.10.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.10.3.tgz",
+      "integrity": "sha512-ho3Ruq+fFnBrZhUYI46n/bV2GjwzSkwuT4dTf0GkuNFmnb8nq4ny2z9JEVemFi6bdEJanHLlYfy9c6FN9B9McQ=="
+    },
+    "@types/ws": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.2.0.tgz",
+      "integrity": "sha512-cyeefcUCgJlEk+hk2h3N+MqKKsPViQgF5boi9TTHSK+PoR9KWBb/C5ccPcDyAqgsbAYHTwulch725DV84+pSpg==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k="
+    },
+    "before-after-hook": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.2.tgz",
+      "integrity": "sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ=="
+    },
+    "callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="
+    },
+    "combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "requires": {
+        "delayed-stream": "~1.0.0"
+      }
+    },
+    "delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk="
+    },
+    "deprecation": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
+      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
+    },
+    "discord-api-types": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.23.1.tgz",
+      "integrity": "sha512-igWmn+45mzXRWNEPU25I/pr8MwxHb767wAr51oy3VRLRcTlp5ADBbrBR0lq3SA1Rfw3MtM4TQu1xo3kxscfVdQ=="
+    },
+    "discord.js": {
+      "version": "13.2.0",
+      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-13.2.0.tgz",
+      "integrity": "sha512-nyxUvL8wuQG38zx13wUMkpcA8koFszyiXdkSLwwM9opKW2LC2H5gD0cTZxImeJ6GtEnKPWT8xBiE8lLBmbNIhw==",
+      "requires": {
+        "@discordjs/builders": "^0.6.0",
+        "@discordjs/collection": "^0.2.1",
+        "@discordjs/form-data": "^3.0.1",
+        "@sapphire/async-queue": "^1.1.5",
+        "@types/ws": "^8.2.0",
+        "discord-api-types": "^0.23.1",
+        "node-fetch": "^2.6.1",
+        "ws": "^8.2.3"
+      }
+    },
+    "dot-prop": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
+      "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
+      "requires": {
+        "is-obj": "^2.0.0"
+      }
+    },
+    "is-obj": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
+      "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w=="
+    },
+    "is-plain-object": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
+      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q=="
+    },
+    "lodash.isequal": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+      "integrity": "sha1-QVxEePK8wwEgwizhDtMib30+GOA="
+    },
+    "mime-db": {
+      "version": "1.50.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.50.0.tgz",
+      "integrity": "sha512-9tMZCDlYHqeERXEHO9f/hKfNXhre5dK2eE/krIvUjZbS2KPcqGDfNShIWS1uW9XOTKQKqK6qbeOci18rbfW77A=="
+    },
+    "mime-types": {
+      "version": "2.1.33",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.33.tgz",
+      "integrity": "sha512-plLElXp7pRDd0bNZHw+nMd52vRYjLwQjygaNg7ddJ2uJtTlmnTCjWuPKxVu6//AdaRuME84SvLW91sIkBqGT0g==",
+      "requires": {
+        "mime-db": "1.50.0"
+      }
+    },
+    "node-fetch": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.5.tgz",
+      "integrity": "sha512-mmlIVHJEu5rnIxgEgez6b9GgWXbkZj5YZ7fx+2r94a2E+Uirsp6HsPTPlomfdHtpt/B0cdKviwkoaM6pyvUOpQ==",
+      "requires": {
+        "whatwg-url": "^5.0.0"
+      }
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "ow": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/ow/-/ow-0.27.0.tgz",
+      "integrity": "sha512-SGnrGUbhn4VaUGdU0EJLMwZWSupPmF46hnTRII7aCLCrqixTAC5eKo8kI4/XXf1eaaI8YEVT+3FeGNJI9himAQ==",
+      "requires": {
+        "@sindresorhus/is": "^4.0.1",
+        "callsites": "^3.1.0",
+        "dot-prop": "^6.0.1",
+        "lodash.isequal": "^4.5.0",
+        "type-fest": "^1.2.1",
+        "vali-date": "^1.0.0"
+      }
+    },
+    "tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
+    },
+    "ts-mixer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.0.tgz",
+      "integrity": "sha512-nXIb1fvdY5CBSrDIblLn73NW0qRDk5yJ0Sk1qPBF560OdJfQp9jhl+0tzcY09OZ9U+6GpeoI9RjwoIKFIoB9MQ=="
+    },
+    "tslib": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.1.tgz",
+      "integrity": "sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw=="
+    },
+    "tunnel": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
+      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg=="
+    },
+    "type-fest": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz",
+      "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA=="
+    },
+    "universal-user-agent": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
+      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
+    },
+    "vali-date": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/vali-date/-/vali-date-1.0.0.tgz",
+      "integrity": "sha1-G5BKWWCfsyjvB4E4Qgk09rhnCaY="
+    },
+    "webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
+    },
+    "whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
+      "requires": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
+    },
+    "ws": {
+      "version": "8.2.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.2.3.tgz",
+      "integrity": "sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==",
+      "requires": {}
+    }
+  }
+}

.github/workflows/scripts/releases/announce-release/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "announce-release",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@actions/github": "^5.0.0",
+    "discord.js": "^13.2.0"
+  }
+}

.github/workflows/scripts/releases/generate-release-notes/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+*.md

.github/workflows/scripts/releases/generate-release-notes/index.js

@@ -0,0 +1,64 @@
+import { Octokit } from "@octokit/rest";
+import { throttling } from "@octokit/plugin-throttling";
+import { retry } from "@octokit/plugin-retry";
+Octokit.plugin(throttling);
+Octokit.plugin(retry);
+const octokit = new Octokit({
+  auth: process.env.GITHUB_TOKEN,
+  userAgent: 'PCSX2/pcsx2',
+  log: {
+    debug: () => { },
+    info: () => { },
+    warn: console.warn,
+    error: console.error
+  },
+  throttle: {
+    onRateLimit: (retryAfter, options) => {
+      octokit.log.warn(
+        `Request quota exhausted for request ${options.method} ${options.url}`
+      );
+
+      // Retry twice after hitting a rate limit error, then give up
+      if (options.request.retryCount <= 2) {
+        console.log(`Retrying after ${retryAfter} seconds!`);
+        return true;
+      }
+    },
+    onAbuseLimit: (retryAfter, options) => {
+      // does not retry, only logs a warning
+      octokit.log.warn(
+        `Abuse detected for request ${options.method} ${options.url}`
+      );
+    },
+  }
+});
+
+var args = process.argv.slice(2);
+let commitSha = process.env.COMMIT_SHA;
+
+console.log(`Searching for Commit - ${commitSha}`);
+
+const { data: commit } = await octokit.rest.repos.getCommit({
+  owner: "PCSX2",
+  repo: "pcsx2",
+  ref: commitSha,
+});
+
+const { data: associatedPulls } = await octokit.rest.repos.listPullRequestsAssociatedWithCommit({
+  owner: "PCSX2",
+  repo: "pcsx2",
+  commit_sha: commit.sha,
+});
+
+let releaseNotes = ``;
+
+if (associatedPulls.length === 0) {
+  releaseNotes += `- ${commit.commit.message}\n`;
+} else {
+  for (var j = 0; j < associatedPulls.length; j++) {
+    releaseNotes += `- [${associatedPulls[j].title}](${associatedPulls[j].html_url})\n`;
+  }
+}
+
+import * as fs from 'fs';
+fs.writeFileSync('./release-notes.md', releaseNotes);

.github/workflows/scripts/releases/generate-release-notes/package-lock.json

@@ -0,0 +1,202 @@
+{
+  "name": "generate-release-notes",
+  "version": "1.0.0",
+  "lockfileVersion": 1,
+  "requires": true,
+  "dependencies": {
+    "@octokit/auth-token": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz",
+      "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==",
+      "requires": {
+        "@octokit/types": "^6.0.3"
+      }
+    },
+    "@octokit/core": {
+      "version": "3.5.1",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.5.1.tgz",
+      "integrity": "sha512-omncwpLVxMP+GLpLPgeGJBF6IWJFjXDS5flY5VbppePYX9XehevbDykRH9PdCdvqt9TS5AOTiDide7h0qrkHjw==",
+      "requires": {
+        "@octokit/auth-token": "^2.4.4",
+        "@octokit/graphql": "^4.5.8",
+        "@octokit/request": "^5.6.0",
+        "@octokit/request-error": "^2.0.5",
+        "@octokit/types": "^6.0.3",
+        "before-after-hook": "^2.2.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/endpoint": {
+      "version": "6.0.12",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz",
+      "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==",
+      "requires": {
+        "@octokit/types": "^6.0.3",
+        "is-plain-object": "^5.0.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/graphql": {
+      "version": "4.8.0",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz",
+      "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==",
+      "requires": {
+        "@octokit/request": "^5.6.0",
+        "@octokit/types": "^6.0.3",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/openapi-types": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-11.1.0.tgz",
+      "integrity": "sha512-dWZfYvCCdjZzDYA3lIAMF72Q0jld8xidqCq5Ryw09eBJXZdcM6he0vWBTvw/b5UnGYqexxOyHWgfrsTlUJL3Gw=="
+    },
+    "@octokit/plugin-paginate-rest": {
+      "version": "2.16.9",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.16.9.tgz",
+      "integrity": "sha512-gfSCMgz5scFKsR0dW4jaYsDJVt/UwCHp4dF7sHlmSekZvwzvLiOAGZ4MQkEsL5DW9hIk2W+UQkYZMTA1b6Wsqw==",
+      "requires": {
+        "@octokit/types": "^6.33.0"
+      }
+    },
+    "@octokit/plugin-request-log": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz",
+      "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA=="
+    },
+    "@octokit/plugin-rest-endpoint-methods": {
+      "version": "5.12.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.12.1.tgz",
+      "integrity": "sha512-0nY3htfl6x9UkPcqv8pm9vOC/bTA7f4IMDWln13neHRdNWQvOQgZ9fRxK7BAc74rye4yVINEFi9Yb9rnGUvosA==",
+      "requires": {
+        "@octokit/types": "^6.33.0",
+        "deprecation": "^2.3.1"
+      }
+    },
+    "@octokit/plugin-retry": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-3.0.9.tgz",
+      "integrity": "sha512-r+fArdP5+TG6l1Rv/C9hVoty6tldw6cE2pRHNGmFPdyfrc696R6JjrQ3d7HdVqGwuzfyrcaLAKD7K8TX8aehUQ==",
+      "requires": {
+        "@octokit/types": "^6.0.3",
+        "bottleneck": "^2.15.3"
+      }
+    },
+    "@octokit/plugin-throttling": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-throttling/-/plugin-throttling-3.5.2.tgz",
+      "integrity": "sha512-Eu7kfJxU8vmHqWGNszWpg+GVp2tnAfax3XQV5CkYPEE69C+KvInJXW9WajgSeW+cxYe0UVdouzCtcreGNuJo7A==",
+      "requires": {
+        "@octokit/types": "^6.0.1",
+        "bottleneck": "^2.15.3"
+      }
+    },
+    "@octokit/request": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.2.tgz",
+      "integrity": "sha512-je66CvSEVf0jCpRISxkUcCa0UkxmFs6eGDRSbfJtAVwbLH5ceqF+YEyC8lj8ystKyZTy8adWr0qmkY52EfOeLA==",
+      "requires": {
+        "@octokit/endpoint": "^6.0.1",
+        "@octokit/request-error": "^2.1.0",
+        "@octokit/types": "^6.16.1",
+        "is-plain-object": "^5.0.0",
+        "node-fetch": "^2.6.1",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/request-error": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz",
+      "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==",
+      "requires": {
+        "@octokit/types": "^6.0.3",
+        "deprecation": "^2.0.0",
+        "once": "^1.4.0"
+      }
+    },
+    "@octokit/rest": {
+      "version": "18.12.0",
+      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-18.12.0.tgz",
+      "integrity": "sha512-gDPiOHlyGavxr72y0guQEhLsemgVjwRePayJ+FcKc2SJqKUbxbkvf5kAZEWA/MKvsfYlQAMVzNJE3ezQcxMJ2Q==",
+      "requires": {
+        "@octokit/core": "^3.5.1",
+        "@octokit/plugin-paginate-rest": "^2.16.8",
+        "@octokit/plugin-request-log": "^1.0.4",
+        "@octokit/plugin-rest-endpoint-methods": "^5.12.0"
+      }
+    },
+    "@octokit/types": {
+      "version": "6.33.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.33.0.tgz",
+      "integrity": "sha512-0zffZ048M0UhthyPXQHLz4038Ak46nMWZXkzlXvXB/M/L1jYPBceq4iZj4qjKVrvveaJrrgKdJ9+3yUuITfcCw==",
+      "requires": {
+        "@octokit/openapi-types": "^11.1.0"
+      }
+    },
+    "before-after-hook": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.2.tgz",
+      "integrity": "sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ=="
+    },
+    "bottleneck": {
+      "version": "2.19.5",
+      "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz",
+      "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw=="
+    },
+    "deprecation": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
+      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
+    },
+    "is-plain-object": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
+      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q=="
+    },
+    "node-fetch": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.5.tgz",
+      "integrity": "sha512-mmlIVHJEu5rnIxgEgez6b9GgWXbkZj5YZ7fx+2r94a2E+Uirsp6HsPTPlomfdHtpt/B0cdKviwkoaM6pyvUOpQ==",
+      "requires": {
+        "whatwg-url": "^5.0.0"
+      }
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
+    },
+    "universal-user-agent": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
+      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
+    },
+    "webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
+    },
+    "whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
+      "requires": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
+    }
+  }
+}

.github/workflows/scripts/releases/generate-release-notes/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "generate-release-notes",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@octokit/plugin-retry": "^3.0.9",
+    "@octokit/plugin-throttling": "^3.5.2",
+    "@octokit/rest": "^18.12.0"
+  }
+}

.github/workflows/scripts/releases/upload-release-artifacts/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+*.md

.github/workflows/scripts/releases/upload-release-artifacts/index.js

@@ -0,0 +1,145 @@
+import { Octokit } from "@octokit/rest";
+import { throttling } from "@octokit/plugin-throttling";
+import { retry } from "@octokit/plugin-retry";
+Octokit.plugin(throttling);
+Octokit.plugin(retry);
+const octokit = new Octokit({
+  auth: process.env.GITHUB_TOKEN,
+  userAgent: 'PCSX2/pcsx2',
+  log: {
+    debug: () => { },
+    info: () => { },
+    warn: console.warn,
+    error: console.error
+  },
+  throttle: {
+    onRateLimit: (retryAfter, options) => {
+      octokit.log.warn(
+        `Request quota exhausted for request ${options.method} ${options.url}`
+      );
+
+      // Retry twice after hitting a rate limit error, then give up
+      if (options.request.retryCount <= 2) {
+        console.log(`Retrying after ${retryAfter} seconds!`);
+        return true;
+      }
+    },
+    onAbuseLimit: (retryAfter, options) => {
+      // does not retry, only logs a warning
+      octokit.log.warn(
+        `Abuse detected for request ${options.method} ${options.url}`
+      );
+    },
+  }
+});
+
+let assetDir = process.env.ASSET_DIR;
+let tagToSearchFor = process.env.TAG_TO_SEARCH_FOR.split("refs/tags/")[1];
+
+console.log(`Searching in - ${assetDir}`);
+console.log(`Searching for tag - ${tagToSearchFor}`);
+
+const { data: recentReleases } = await octokit.rest.repos.listReleases({
+  owner: "PCSX2",
+  repo: "pcsx2",
+  per_page: 100
+});
+
+let release = undefined;
+for (var i = 0; i < recentReleases.length; i++) {
+  if (recentReleases[i].tag_name == tagToSearchFor) {
+    release = recentReleases[i];
+    break;
+  }
+}
+
+if (release == undefined) {
+  console.log(`Unable to find release with tag - ${tagToSearchFor}`);
+  process.exit(1);
+}
+
+// Upload any assets we need to, don't upload assets that are already there!
+const { data: releaseAssetsPre } = await octokit.rest.repos.listReleaseAssets({
+  owner: "PCSX2",
+  repo: "pcsx2",
+  release_id: release.id,
+  per_page: 100
+});
+
+import glob from 'glob';
+import * as fs from 'fs';
+import * as path from 'path';
+glob(assetDir + `/**/*${process.env.ASSET_EXTENSION}`, {}, async (err, files) => {
+  for (var i = 0; i < files.length; i++) {
+    let foundDuplicate = false;
+    for (var j = 0; j < releaseAssetsPre.length; j++) {
+      let existingAsset = releaseAssetsPre[j];
+      if (existingAsset.name == `pcsx2-${release.tag_name}-${path.basename(files[i])}`) {
+        foundDuplicate = true;
+        break;
+      }
+    }
+    if (foundDuplicate) {
+      continue;
+    }
+
+    var assetBytes = fs.readFileSync(files[i], null);
+    const { data: uploadAsset } = await octokit.rest.repos.uploadReleaseAsset({
+      owner: "PCSX2",
+      repo: "pcsx2",
+      release_id: release.id,
+      name: `pcsx2-${release.tag_name}-${path.basename(files[i])}`,
+      data: assetBytes,
+    });
+  }
+});
+
+// Ideally there would be a webhook event for when an artifact is added to a draft release
+// unfortunately, such a thing does not exist yet.  Therefore, we have to wait a bit
+// for the API to become consistent
+// TODO - future work - we could check previous draft releases to become eventually consistent as well
+// - draft releases should only be a temporary state, so anything that remains a draft had a problem
+await new Promise(resolve => setTimeout(resolve, 10 * 1000));
+
+// Poll the release, and check to see if it's ready to be published
+const { data: releaseAssetsPost } = await octokit.rest.repos.listReleaseAssets({
+  owner: "PCSX2",
+  repo: "pcsx2",
+  release_id: release.id,
+  per_page: 100
+});
+
+// Expected Assets, if we have all of them, we will publish it
+let expectedAssets = {
+  "windows-32bit-sse4": false,
+  "windows-32bit-avx2": false,
+  "windows-64bit-sse4": false,
+  "windows-64bit-avx2": false,
+  "linux-appimage-32bit": false,
+  "linux-appimage-64bit": false
+}
+
+for (var i = 0; i < releaseAssetsPost.length; i++) {
+  let asset = releaseAssetsPost[i];
+  if (asset.name.includes("symbols")) {
+    continue;
+  }
+  for (var j = 0; j < Object.keys(expectedAssets).length; j++) {
+    let expectedNamePrefix = Object.keys(expectedAssets)[j];
+    if (asset.name.toLowerCase().includes(expectedNamePrefix)) {
+      expectedAssets[expectedNamePrefix] = true;
+      break;
+    }
+  }
+}
+
+console.log(expectedAssets);
+
+if (Object.values(expectedAssets).every(Boolean)) {
+  await octokit.rest.repos.updateRelease({
+    owner: "PCSX2",
+    repo: "pcsx2",
+    release_id: release.id,
+    draft: false
+  });
+}

.github/workflows/scripts/releases/upload-release-artifacts/package-lock.json

@@ -0,0 +1,973 @@
+{
+  "name": "upload-release-artifacts",
+  "version": "1.0.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "@octokit/plugin-retry": "^3.0.9",
+        "@octokit/plugin-throttling": "^3.5.2",
+        "@octokit/rest": "^18.12.0",
+        "discord.js": "^13.2.0",
+        "glob": "^7.2.0"
+      }
+    },
+    "node_modules/@discordjs/builders": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-0.6.0.tgz",
+      "integrity": "sha512-mH3Gx61LKk2CD05laCI9K5wp+a3NyASHDUGx83DGJFkqJlRlSV5WMJNY6RS37A5SjqDtGMF4wVR9jzFaqShe6Q==",
+      "dependencies": {
+        "@sindresorhus/is": "^4.0.1",
+        "discord-api-types": "^0.22.0",
+        "ow": "^0.27.0",
+        "ts-mixer": "^6.0.0",
+        "tslib": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=14.0.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/@discordjs/builders/node_modules/discord-api-types": {
+      "version": "0.22.0",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.22.0.tgz",
+      "integrity": "sha512-l8yD/2zRbZItUQpy7ZxBJwaLX/Bs2TGaCthRppk8Sw24LOIWg12t9JEreezPoYD0SQcC2htNNo27kYEpYW/Srg==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@discordjs/collection": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-0.2.1.tgz",
+      "integrity": "sha512-vhxqzzM8gkomw0TYRF3tgx7SwElzUlXT/Aa41O7mOcyN6wIJfj5JmDWaO5XGKsGSsNx7F3i5oIlrucCCWV1Nog==",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@discordjs/form-data": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/form-data/-/form-data-3.0.1.tgz",
+      "integrity": "sha512-ZfFsbgEXW71Rw/6EtBdrP5VxBJy4dthyC0tpQKGKmYFImlmmrykO14Za+BiIVduwjte0jXEBlhSKf0MWbFp9Eg==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/@octokit/auth-token": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz",
+      "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3"
+      }
+    },
+    "node_modules/@octokit/core": {
+      "version": "3.5.1",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.5.1.tgz",
+      "integrity": "sha512-omncwpLVxMP+GLpLPgeGJBF6IWJFjXDS5flY5VbppePYX9XehevbDykRH9PdCdvqt9TS5AOTiDide7h0qrkHjw==",
+      "dependencies": {
+        "@octokit/auth-token": "^2.4.4",
+        "@octokit/graphql": "^4.5.8",
+        "@octokit/request": "^5.6.0",
+        "@octokit/request-error": "^2.0.5",
+        "@octokit/types": "^6.0.3",
+        "before-after-hook": "^2.2.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/endpoint": {
+      "version": "6.0.12",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz",
+      "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3",
+        "is-plain-object": "^5.0.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/graphql": {
+      "version": "4.8.0",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz",
+      "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==",
+      "dependencies": {
+        "@octokit/request": "^5.6.0",
+        "@octokit/types": "^6.0.3",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/openapi-types": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-11.1.0.tgz",
+      "integrity": "sha512-dWZfYvCCdjZzDYA3lIAMF72Q0jld8xidqCq5Ryw09eBJXZdcM6he0vWBTvw/b5UnGYqexxOyHWgfrsTlUJL3Gw=="
+    },
+    "node_modules/@octokit/plugin-paginate-rest": {
+      "version": "2.16.9",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.16.9.tgz",
+      "integrity": "sha512-gfSCMgz5scFKsR0dW4jaYsDJVt/UwCHp4dF7sHlmSekZvwzvLiOAGZ4MQkEsL5DW9hIk2W+UQkYZMTA1b6Wsqw==",
+      "dependencies": {
+        "@octokit/types": "^6.33.0"
+      }
+    },
+    "node_modules/@octokit/plugin-request-log": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz",
+      "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA=="
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "5.12.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.12.1.tgz",
+      "integrity": "sha512-0nY3htfl6x9UkPcqv8pm9vOC/bTA7f4IMDWln13neHRdNWQvOQgZ9fRxK7BAc74rye4yVINEFi9Yb9rnGUvosA==",
+      "dependencies": {
+        "@octokit/types": "^6.33.0",
+        "deprecation": "^2.3.1"
+      }
+    },
+    "node_modules/@octokit/plugin-retry": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-3.0.9.tgz",
+      "integrity": "sha512-r+fArdP5+TG6l1Rv/C9hVoty6tldw6cE2pRHNGmFPdyfrc696R6JjrQ3d7HdVqGwuzfyrcaLAKD7K8TX8aehUQ==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3",
+        "bottleneck": "^2.15.3"
+      }
+    },
+    "node_modules/@octokit/plugin-throttling": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-throttling/-/plugin-throttling-3.5.2.tgz",
+      "integrity": "sha512-Eu7kfJxU8vmHqWGNszWpg+GVp2tnAfax3XQV5CkYPEE69C+KvInJXW9WajgSeW+cxYe0UVdouzCtcreGNuJo7A==",
+      "dependencies": {
+        "@octokit/types": "^6.0.1",
+        "bottleneck": "^2.15.3"
+      }
+    },
+    "node_modules/@octokit/request": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.2.tgz",
+      "integrity": "sha512-je66CvSEVf0jCpRISxkUcCa0UkxmFs6eGDRSbfJtAVwbLH5ceqF+YEyC8lj8ystKyZTy8adWr0qmkY52EfOeLA==",
+      "dependencies": {
+        "@octokit/endpoint": "^6.0.1",
+        "@octokit/request-error": "^2.1.0",
+        "@octokit/types": "^6.16.1",
+        "is-plain-object": "^5.0.0",
+        "node-fetch": "^2.6.1",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/request-error": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz",
+      "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3",
+        "deprecation": "^2.0.0",
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/@octokit/rest": {
+      "version": "18.12.0",
+      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-18.12.0.tgz",
+      "integrity": "sha512-gDPiOHlyGavxr72y0guQEhLsemgVjwRePayJ+FcKc2SJqKUbxbkvf5kAZEWA/MKvsfYlQAMVzNJE3ezQcxMJ2Q==",
+      "dependencies": {
+        "@octokit/core": "^3.5.1",
+        "@octokit/plugin-paginate-rest": "^2.16.8",
+        "@octokit/plugin-request-log": "^1.0.4",
+        "@octokit/plugin-rest-endpoint-methods": "^5.12.0"
+      }
+    },
+    "node_modules/@octokit/types": {
+      "version": "6.33.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.33.0.tgz",
+      "integrity": "sha512-0zffZ048M0UhthyPXQHLz4038Ak46nMWZXkzlXvXB/M/L1jYPBceq4iZj4qjKVrvveaJrrgKdJ9+3yUuITfcCw==",
+      "dependencies": {
+        "@octokit/openapi-types": "^11.1.0"
+      }
+    },
+    "node_modules/@sapphire/async-queue": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.1.6.tgz",
+      "integrity": "sha512-M5CbgMgesemMUCQo5G/InGHvp+GZx6uuJNV1iwvSWD8EFNVrfxaTcqhcAXM3MPYkjlxvNnoDNk0R1lfzvca6LA==",
+      "engines": {
+        "node": ">=v14.18.0",
+        "npm": ">=7.24.2"
+      }
+    },
+    "node_modules/@sindresorhus/is": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.2.0.tgz",
+      "integrity": "sha512-VkE3KLBmJwcCaVARtQpfuKcKv8gcBmUubrfHGF84dXuuW6jgsRYxPtzcIhPyK9WAPpRt2/xY6zkD9MnRaJzSyw==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/is?sponsor=1"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "16.10.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.10.3.tgz",
+      "integrity": "sha512-ho3Ruq+fFnBrZhUYI46n/bV2GjwzSkwuT4dTf0GkuNFmnb8nq4ny2z9JEVemFi6bdEJanHLlYfy9c6FN9B9McQ=="
+    },
+    "node_modules/@types/ws": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.2.0.tgz",
+      "integrity": "sha512-cyeefcUCgJlEk+hk2h3N+MqKKsPViQgF5boi9TTHSK+PoR9KWBb/C5ccPcDyAqgsbAYHTwulch725DV84+pSpg==",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k="
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+    },
+    "node_modules/before-after-hook": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.2.tgz",
+      "integrity": "sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ=="
+    },
+    "node_modules/bottleneck": {
+      "version": "2.19.5",
+      "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz",
+      "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw=="
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/deprecation": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
+      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
+    },
+    "node_modules/discord-api-types": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.23.1.tgz",
+      "integrity": "sha512-igWmn+45mzXRWNEPU25I/pr8MwxHb767wAr51oy3VRLRcTlp5ADBbrBR0lq3SA1Rfw3MtM4TQu1xo3kxscfVdQ==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/discord.js": {
+      "version": "13.2.0",
+      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-13.2.0.tgz",
+      "integrity": "sha512-nyxUvL8wuQG38zx13wUMkpcA8koFszyiXdkSLwwM9opKW2LC2H5gD0cTZxImeJ6GtEnKPWT8xBiE8lLBmbNIhw==",
+      "dependencies": {
+        "@discordjs/builders": "^0.6.0",
+        "@discordjs/collection": "^0.2.1",
+        "@discordjs/form-data": "^3.0.1",
+        "@sapphire/async-queue": "^1.1.5",
+        "@types/ws": "^8.2.0",
+        "discord-api-types": "^0.23.1",
+        "node-fetch": "^2.6.1",
+        "ws": "^8.2.3"
+      },
+      "engines": {
+        "node": ">=16.6.0",
+        "npm": ">=7.0.0"
+      }
+    },
+    "node_modules/dot-prop": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
+      "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
+      "dependencies": {
+        "is-obj": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
+    },
+    "node_modules/glob": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
+      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "node_modules/is-obj": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
+      "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-plain-object": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
+      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/lodash.isequal": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+      "integrity": "sha1-QVxEePK8wwEgwizhDtMib30+GOA="
+    },
+    "node_modules/mime-db": {
+      "version": "1.50.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.50.0.tgz",
+      "integrity": "sha512-9tMZCDlYHqeERXEHO9f/hKfNXhre5dK2eE/krIvUjZbS2KPcqGDfNShIWS1uW9XOTKQKqK6qbeOci18rbfW77A==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.33",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.33.tgz",
+      "integrity": "sha512-plLElXp7pRDd0bNZHw+nMd52vRYjLwQjygaNg7ddJ2uJtTlmnTCjWuPKxVu6//AdaRuME84SvLW91sIkBqGT0g==",
+      "dependencies": {
+        "mime-db": "1.50.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.5.tgz",
+      "integrity": "sha512-mmlIVHJEu5rnIxgEgez6b9GgWXbkZj5YZ7fx+2r94a2E+Uirsp6HsPTPlomfdHtpt/B0cdKviwkoaM6pyvUOpQ==",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/ow": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/ow/-/ow-0.27.0.tgz",
+      "integrity": "sha512-SGnrGUbhn4VaUGdU0EJLMwZWSupPmF46hnTRII7aCLCrqixTAC5eKo8kI4/XXf1eaaI8YEVT+3FeGNJI9himAQ==",
+      "dependencies": {
+        "@sindresorhus/is": "^4.0.1",
+        "callsites": "^3.1.0",
+        "dot-prop": "^6.0.1",
+        "lodash.isequal": "^4.5.0",
+        "type-fest": "^1.2.1",
+        "vali-date": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
+    },
+    "node_modules/ts-mixer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.0.tgz",
+      "integrity": "sha512-nXIb1fvdY5CBSrDIblLn73NW0qRDk5yJ0Sk1qPBF560OdJfQp9jhl+0tzcY09OZ9U+6GpeoI9RjwoIKFIoB9MQ=="
+    },
+    "node_modules/tslib": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.1.tgz",
+      "integrity": "sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw=="
+    },
+    "node_modules/type-fest": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz",
+      "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/universal-user-agent": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
+      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
+    },
+    "node_modules/vali-date": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/vali-date/-/vali-date-1.0.0.tgz",
+      "integrity": "sha1-G5BKWWCfsyjvB4E4Qgk09rhnCaY=",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
+    },
+    "node_modules/ws": {
+      "version": "8.2.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.2.3.tgz",
+      "integrity": "sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": "^5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@discordjs/builders": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@discordjs/builders/-/builders-0.6.0.tgz",
+      "integrity": "sha512-mH3Gx61LKk2CD05laCI9K5wp+a3NyASHDUGx83DGJFkqJlRlSV5WMJNY6RS37A5SjqDtGMF4wVR9jzFaqShe6Q==",
+      "requires": {
+        "@sindresorhus/is": "^4.0.1",
+        "discord-api-types": "^0.22.0",
+        "ow": "^0.27.0",
+        "ts-mixer": "^6.0.0",
+        "tslib": "^2.3.1"
+      },
+      "dependencies": {
+        "discord-api-types": {
+          "version": "0.22.0",
+          "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.22.0.tgz",
+          "integrity": "sha512-l8yD/2zRbZItUQpy7ZxBJwaLX/Bs2TGaCthRppk8Sw24LOIWg12t9JEreezPoYD0SQcC2htNNo27kYEpYW/Srg=="
+        }
+      }
+    },
+    "@discordjs/collection": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/collection/-/collection-0.2.1.tgz",
+      "integrity": "sha512-vhxqzzM8gkomw0TYRF3tgx7SwElzUlXT/Aa41O7mOcyN6wIJfj5JmDWaO5XGKsGSsNx7F3i5oIlrucCCWV1Nog=="
+    },
+    "@discordjs/form-data": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/@discordjs/form-data/-/form-data-3.0.1.tgz",
+      "integrity": "sha512-ZfFsbgEXW71Rw/6EtBdrP5VxBJy4dthyC0tpQKGKmYFImlmmrykO14Za+BiIVduwjte0jXEBlhSKf0MWbFp9Eg==",
+      "requires": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      }
+    },
+    "@octokit/auth-token": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz",
+      "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==",
+      "requires": {
+        "@octokit/types": "^6.0.3"
+      }
+    },
+    "@octokit/core": {
+      "version": "3.5.1",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.5.1.tgz",
+      "integrity": "sha512-omncwpLVxMP+GLpLPgeGJBF6IWJFjXDS5flY5VbppePYX9XehevbDykRH9PdCdvqt9TS5AOTiDide7h0qrkHjw==",
+      "requires": {
+        "@octokit/auth-token": "^2.4.4",
+        "@octokit/graphql": "^4.5.8",
+        "@octokit/request": "^5.6.0",
+        "@octokit/request-error": "^2.0.5",
+        "@octokit/types": "^6.0.3",
+        "before-after-hook": "^2.2.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/endpoint": {
+      "version": "6.0.12",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz",
+      "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==",
+      "requires": {
+        "@octokit/types": "^6.0.3",
+        "is-plain-object": "^5.0.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/graphql": {
+      "version": "4.8.0",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz",
+      "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==",
+      "requires": {
+        "@octokit/request": "^5.6.0",
+        "@octokit/types": "^6.0.3",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/openapi-types": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-11.1.0.tgz",
+      "integrity": "sha512-dWZfYvCCdjZzDYA3lIAMF72Q0jld8xidqCq5Ryw09eBJXZdcM6he0vWBTvw/b5UnGYqexxOyHWgfrsTlUJL3Gw=="
+    },
+    "@octokit/plugin-paginate-rest": {
+      "version": "2.16.9",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.16.9.tgz",
+      "integrity": "sha512-gfSCMgz5scFKsR0dW4jaYsDJVt/UwCHp4dF7sHlmSekZvwzvLiOAGZ4MQkEsL5DW9hIk2W+UQkYZMTA1b6Wsqw==",
+      "requires": {
+        "@octokit/types": "^6.33.0"
+      }
+    },
+    "@octokit/plugin-request-log": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz",
+      "integrity": "sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA=="
+    },
+    "@octokit/plugin-rest-endpoint-methods": {
+      "version": "5.12.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.12.1.tgz",
+      "integrity": "sha512-0nY3htfl6x9UkPcqv8pm9vOC/bTA7f4IMDWln13neHRdNWQvOQgZ9fRxK7BAc74rye4yVINEFi9Yb9rnGUvosA==",
+      "requires": {
+        "@octokit/types": "^6.33.0",
+        "deprecation": "^2.3.1"
+      }
+    },
+    "@octokit/plugin-retry": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-3.0.9.tgz",
+      "integrity": "sha512-r+fArdP5+TG6l1Rv/C9hVoty6tldw6cE2pRHNGmFPdyfrc696R6JjrQ3d7HdVqGwuzfyrcaLAKD7K8TX8aehUQ==",
+      "requires": {
+        "@octokit/types": "^6.0.3",
+        "bottleneck": "^2.15.3"
+      }
+    },
+    "@octokit/plugin-throttling": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-throttling/-/plugin-throttling-3.5.2.tgz",
+      "integrity": "sha512-Eu7kfJxU8vmHqWGNszWpg+GVp2tnAfax3XQV5CkYPEE69C+KvInJXW9WajgSeW+cxYe0UVdouzCtcreGNuJo7A==",
+      "requires": {
+        "@octokit/types": "^6.0.1",
+        "bottleneck": "^2.15.3"
+      }
+    },
+    "@octokit/request": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.2.tgz",
+      "integrity": "sha512-je66CvSEVf0jCpRISxkUcCa0UkxmFs6eGDRSbfJtAVwbLH5ceqF+YEyC8lj8ystKyZTy8adWr0qmkY52EfOeLA==",
+      "requires": {
+        "@octokit/endpoint": "^6.0.1",
+        "@octokit/request-error": "^2.1.0",
+        "@octokit/types": "^6.16.1",
+        "is-plain-object": "^5.0.0",
+        "node-fetch": "^2.6.1",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "@octokit/request-error": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz",
+      "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==",
+      "requires": {
+        "@octokit/types": "^6.0.3",
+        "deprecation": "^2.0.0",
+        "once": "^1.4.0"
+      }
+    },
+    "@octokit/rest": {
+      "version": "18.12.0",
+      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-18.12.0.tgz",
+      "integrity": "sha512-gDPiOHlyGavxr72y0guQEhLsemgVjwRePayJ+FcKc2SJqKUbxbkvf5kAZEWA/MKvsfYlQAMVzNJE3ezQcxMJ2Q==",
+      "requires": {
+        "@octokit/core": "^3.5.1",
+        "@octokit/plugin-paginate-rest": "^2.16.8",
+        "@octokit/plugin-request-log": "^1.0.4",
+        "@octokit/plugin-rest-endpoint-methods": "^5.12.0"
+      }
+    },
+    "@octokit/types": {
+      "version": "6.33.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.33.0.tgz",
+      "integrity": "sha512-0zffZ048M0UhthyPXQHLz4038Ak46nMWZXkzlXvXB/M/L1jYPBceq4iZj4qjKVrvveaJrrgKdJ9+3yUuITfcCw==",
+      "requires": {
+        "@octokit/openapi-types": "^11.1.0"
+      }
+    },
+    "@sapphire/async-queue": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@sapphire/async-queue/-/async-queue-1.1.6.tgz",
+      "integrity": "sha512-M5CbgMgesemMUCQo5G/InGHvp+GZx6uuJNV1iwvSWD8EFNVrfxaTcqhcAXM3MPYkjlxvNnoDNk0R1lfzvca6LA=="
+    },
+    "@sindresorhus/is": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.2.0.tgz",
+      "integrity": "sha512-VkE3KLBmJwcCaVARtQpfuKcKv8gcBmUubrfHGF84dXuuW6jgsRYxPtzcIhPyK9WAPpRt2/xY6zkD9MnRaJzSyw=="
+    },
+    "@types/node": {
+      "version": "16.10.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.10.3.tgz",
+      "integrity": "sha512-ho3Ruq+fFnBrZhUYI46n/bV2GjwzSkwuT4dTf0GkuNFmnb8nq4ny2z9JEVemFi6bdEJanHLlYfy9c6FN9B9McQ=="
+    },
+    "@types/ws": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.2.0.tgz",
+      "integrity": "sha512-cyeefcUCgJlEk+hk2h3N+MqKKsPViQgF5boi9TTHSK+PoR9KWBb/C5ccPcDyAqgsbAYHTwulch725DV84+pSpg==",
+      "requires": {
+        "@types/node": "*"
+      }
+    },
+    "asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k="
+    },
+    "balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+    },
+    "before-after-hook": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.2.tgz",
+      "integrity": "sha512-3pZEU3NT5BFUo/AD5ERPWOgQOCZITni6iavr5AUw5AUwQjMlI0kzu5btnyD39AF0gUEsDPwJT+oY1ORBJijPjQ=="
+    },
+    "bottleneck": {
+      "version": "2.19.5",
+      "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz",
+      "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw=="
+    },
+    "brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="
+    },
+    "combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "requires": {
+        "delayed-stream": "~1.0.0"
+      }
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
+    },
+    "delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk="
+    },
+    "deprecation": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
+      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
+    },
+    "discord-api-types": {
+      "version": "0.23.1",
+      "resolved": "https://registry.npmjs.org/discord-api-types/-/discord-api-types-0.23.1.tgz",
+      "integrity": "sha512-igWmn+45mzXRWNEPU25I/pr8MwxHb767wAr51oy3VRLRcTlp5ADBbrBR0lq3SA1Rfw3MtM4TQu1xo3kxscfVdQ=="
+    },
+    "discord.js": {
+      "version": "13.2.0",
+      "resolved": "https://registry.npmjs.org/discord.js/-/discord.js-13.2.0.tgz",
+      "integrity": "sha512-nyxUvL8wuQG38zx13wUMkpcA8koFszyiXdkSLwwM9opKW2LC2H5gD0cTZxImeJ6GtEnKPWT8xBiE8lLBmbNIhw==",
+      "requires": {
+        "@discordjs/builders": "^0.6.0",
+        "@discordjs/collection": "^0.2.1",
+        "@discordjs/form-data": "^3.0.1",
+        "@sapphire/async-queue": "^1.1.5",
+        "@types/ws": "^8.2.0",
+        "discord-api-types": "^0.23.1",
+        "node-fetch": "^2.6.1",
+        "ws": "^8.2.3"
+      }
+    },
+    "dot-prop": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-6.0.1.tgz",
+      "integrity": "sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==",
+      "requires": {
+        "is-obj": "^2.0.0"
+      }
+    },
+    "fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
+    },
+    "glob": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
+      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
+      "requires": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      }
+    },
+    "inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "requires": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "is-obj": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz",
+      "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w=="
+    },
+    "is-plain-object": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
+      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q=="
+    },
+    "lodash.isequal": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+      "integrity": "sha1-QVxEePK8wwEgwizhDtMib30+GOA="
+    },
+    "mime-db": {
+      "version": "1.50.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.50.0.tgz",
+      "integrity": "sha512-9tMZCDlYHqeERXEHO9f/hKfNXhre5dK2eE/krIvUjZbS2KPcqGDfNShIWS1uW9XOTKQKqK6qbeOci18rbfW77A=="
+    },
+    "mime-types": {
+      "version": "2.1.33",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.33.tgz",
+      "integrity": "sha512-plLElXp7pRDd0bNZHw+nMd52vRYjLwQjygaNg7ddJ2uJtTlmnTCjWuPKxVu6//AdaRuME84SvLW91sIkBqGT0g==",
+      "requires": {
+        "mime-db": "1.50.0"
+      }
+    },
+    "minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "node-fetch": {
+      "version": "2.6.5",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.5.tgz",
+      "integrity": "sha512-mmlIVHJEu5rnIxgEgez6b9GgWXbkZj5YZ7fx+2r94a2E+Uirsp6HsPTPlomfdHtpt/B0cdKviwkoaM6pyvUOpQ==",
+      "requires": {
+        "whatwg-url": "^5.0.0"
+      }
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "ow": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/ow/-/ow-0.27.0.tgz",
+      "integrity": "sha512-SGnrGUbhn4VaUGdU0EJLMwZWSupPmF46hnTRII7aCLCrqixTAC5eKo8kI4/XXf1eaaI8YEVT+3FeGNJI9himAQ==",
+      "requires": {
+        "@sindresorhus/is": "^4.0.1",
+        "callsites": "^3.1.0",
+        "dot-prop": "^6.0.1",
+        "lodash.isequal": "^4.5.0",
+        "type-fest": "^1.2.1",
+        "vali-date": "^1.0.0"
+      }
+    },
+    "path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
+    },
+    "tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o="
+    },
+    "ts-mixer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/ts-mixer/-/ts-mixer-6.0.0.tgz",
+      "integrity": "sha512-nXIb1fvdY5CBSrDIblLn73NW0qRDk5yJ0Sk1qPBF560OdJfQp9jhl+0tzcY09OZ9U+6GpeoI9RjwoIKFIoB9MQ=="
+    },
+    "tslib": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.3.1.tgz",
+      "integrity": "sha512-77EbyPPpMz+FRFRuAFlWMtmgUWGe9UOG2Z25NqCwiIjRhOf5iKGuzSe5P2w1laq+FkRy4p+PCuVkJSGkzTEKVw=="
+    },
+    "type-fest": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz",
+      "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA=="
+    },
+    "universal-user-agent": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
+      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
+    },
+    "vali-date": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/vali-date/-/vali-date-1.0.0.tgz",
+      "integrity": "sha1-G5BKWWCfsyjvB4E4Qgk09rhnCaY="
+    },
+    "webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE="
+    },
+    "whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha1-lmRU6HZUYuN2RNNib2dCzotwll0=",
+      "requires": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
+    },
+    "ws": {
+      "version": "8.2.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.2.3.tgz",
+      "integrity": "sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==",
+      "requires": {}
+    }
+  }
+}

.github/workflows/scripts/releases/upload-release-artifacts/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "upload-release-artifacts",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@octokit/plugin-retry": "^3.0.9",
+    "@octokit/plugin-throttling": "^3.5.2",
+    "@octokit/rest": "^18.12.0",
+    "glob": "^7.2.0"
+  }
+}

.github/workflows/update-controller-db.yml

@@ -0,0 +1,29 @@
+name: 🏭 Update Controller Database
+
+on:
+  schedule:
+    - cron: "0 16 * * 1" # every monday @ 12pm EST - https://crontab.guru/#0_16_*_*_1
+
+jobs:
+  update-controller-db:
+    if: github.repository == 'PCSX2/pcsx2'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Get Latest DB and Prepare DB File
+        run: |
+          cd .github/workflows/scripts/controller-db/
+          wget -O game_controller_db.txt https://raw.githubusercontent.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt
+          python ./update-db.py
+          mv ./game_controller_db.txt ${{github.workspace}}/pcsx2/PAD/Linux/res/game_controller_db.txt
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          title: "pad-linux: Update to latest controller database"
+          commit-message: "pad-linux: Update to latest controller database."
+          committer: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
+          author: "PCSX2 Bot <PCSX2Bot@users.noreply.github.com>"
+          body: "Weekly automatic update of SDL Controller DB for Linux / Mac OS"
+          reviewers: lightningterror

.github/workflows/windows-workflow.yml

@@ -6,28 +6,8 @@ on:
   push:
     branches:
       - master
-    paths-ignore:
-      - '**/*.md'
-      - '.clang-format'
-      - '.codacy.yaml'
-      - '.github/*'
-      - '.github/workflows/lint-gamedb.yml'
-      - '.github/workflows/linux-workflow.yml'
-      - '.github/workflows/macos-workflow.yml'
-      - '.github/workflows/scripts/linux/**'
-      - '.github/workflows/scripts/validation/**'
-      - '.gitignore'
-      - 'bin/PCSX2_keys.ini.default'
-      - 'build.sh'
-      - 'buildbot.xml'
-      - 'linux_various/**'
-      - 'mscompile.cmd'
-      - 'pcsx2/CDVD/Linux/**'
-      - 'pcsx2/DEV9/Linux/**'
-      - 'pcsx2/Linux/**'
-      - 'pcsx2/PAD/Linux/**'
-      - 'pcsx2/SPU2/Linux/**'
-      - 'pcsx2/USB/linux/**'
+    tags:
+      - v*
   pull_request:
     branches:
       - master
@@ -53,12 +33,6 @@ on:
       - 'pcsx2/PAD/Linux/**'
       - 'pcsx2/SPU2/Linux/**'
       - 'pcsx2/USB/linux/**'
-  workflow_dispatch:
-    inputs:
-      retainDebugArtifacts:
-        description: 'Retain debug artifacts (.pdb/.exp/.lib) for an easier debugging experience. (true|false)'
-        required: true
-        default: 'false'
 
 jobs:
   build:
@@ -86,12 +60,6 @@ jobs:
       BUILDCACHE_LOG_FILE: ${{ github.workspace }}\buildcache.log
 
     steps:
-      # NOTE - useful for debugging
-      # - name: Dump GitHub context
-      #   env:
-      #     GITHUB_CONTEXT: ${{ toJson(github) }}
-      #   run: echo "$GITHUB_CONTEXT"
-
       - name: Checkout Repository
         uses: actions/checkout@v2
 
@@ -175,24 +143,49 @@ jobs:
           TRIMMED_ARTIFACT_NAME=$(printf "%.199s]" "$ARTIFACT_NAME")
           echo "name=$TRIMMED_ARTIFACT_NAME"
           echo "##[set-output name=name;]${TRIMMED_ARTIFACT_NAME}"
-
-      - name: Prepare Artifact Folder
-        shell: bash
-        working-directory: bin
-        run: |
-          retainDebugArtifacts=$([ "${{ github.event.inputs.retainDebugArtifacts }}" == "true" ] && echo "true" || echo "false")
-          if [ "${retainDebugArtifacts}" == "false" ]; then
-            ls ./
-            rm -f *.bsc *.exp *.ilk *.iobj *.ipdb *.lib *.pdb
-          fi
-          shopt -s extglob dotglob
-          mkdir -p "${{ steps.artifact-metadata.outputs.name }}"
-          mv !("${{ steps.artifact-metadata.outputs.name }}") "${{ steps.artifact-metadata.outputs.name }}"
-          shopt -u dotglob
+          echo "##[set-output name=arch;]${ARCH}"
+          echo "##[set-output name=simd;]${SIMD}"
 
       - name: Upload artifact
         uses: actions/upload-artifact@v2
         continue-on-error: true
         with:
           name: ${{ steps.artifact-metadata.outputs.name }}
-          path: bin
+          path: |
+            ./bin
+            !./bin/**/*.bsc
+            !./bin/**/*.exp
+            !./bin/**/*.ilk
+            !./bin/**/*.iobj
+            !./bin/**/*.ipdb
+            !./bin/**/*.pdb
+            !./bin/**/*.lib
+
+      - name: Upload artifact - with symbols
+        if: matrix.configuration != 'CMake'
+        uses: actions/upload-artifact@v2
+        continue-on-error: true
+        with:
+          name: ${{ steps.artifact-metadata.outputs.name }}-symbols
+          path: ./bin/**/*.pdb
+
+      # ---- Release / Tagging related steps ----
+      - name: Prepare Build Artifacts
+        if: github.repository == 'PCSX2/pcsx2' && startsWith(github.ref, 'refs/tags/') && matrix.configuration != 'CMake'
+        run: |
+          mkdir -p ./ci-artifacts/
+          7z a ./ci-artifacts/windows-${{ steps.artifact-metadata.outputs.arch }}-${{ steps.artifact-metadata.outputs.simd }}.7z ./bin/* '-xr!*bsc' '-xr!*.exp' '-xr!*.ilk' '-xr!*.iobj' '-xr!*.ipdb' '-xr!*.pdb' '-xr!*.lib'
+          7z a ./ci-artifacts/windows-${{ steps.artifact-metadata.outputs.arch }}-${{ steps.artifact-metadata.outputs.simd }}-symbols.7z ./bin/*.pdb
+          ls ./ci-artifacts/
+
+      - name: Upload Assets and Potential Publish Release
+        if: github.repository == 'PCSX2/pcsx2' && startsWith(github.ref, 'refs/tags/') && matrix.configuration != 'CMake'
+        env:
+          GITHUB_TOKEN: ${{ secrets.BOT_PAT }}
+          ASSET_DIR: ${{ github.WORKSPACE }}/ci-artifacts
+          ASSET_EXTENSION: 7z
+          TAG_TO_SEARCH_FOR: ${{ github.REF }}
+        run: |
+          cd ./.github/workflows/scripts/releases/upload-release-artifacts
+          npm ci
+          node index.js

.gitignore

@@ -114,3 +114,5 @@ oprofile_data/
 
 /out/build/x64-Debug (default)
 CMakeSettings.json
+/ci-artifacts/
+/out/

cmake/Pcsx2Utils.cmake

@@ -38,6 +38,7 @@ endfunction()
 function(get_git_version_info)
 	set(PCSX2_WC_TIME 0)
 	set(PCSX2_GIT_REV "")
+	set(PCSX2_GIT_TAG "")
 	if (GIT_FOUND AND EXISTS ${PROJECT_SOURCE_DIR}/.git)
 		EXECUTE_PROCESS(WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} COMMAND ${GIT_EXECUTABLE} show -s --format=%ci HEAD
 			OUTPUT_VARIABLE PCSX2_WC_TIME
@@ -50,6 +51,11 @@ function(get_git_version_info)
 			OUTPUT_VARIABLE PCSX2_GIT_REV
 			OUTPUT_STRIP_TRAILING_WHITESPACE
 			ERROR_QUIET)
+
+		EXECUTE_PROCESS(WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} COMMAND ${GIT_EXECUTABLE} tag --points-at HEAD
+			OUTPUT_VARIABLE PCSX2_GIT_TAG
+			OUTPUT_STRIP_TRAILING_WHITESPACE
+			ERROR_QUIET)
 	endif()
 	if(PCSX2_GIT_REV)
 		set(PCSX2_VERSION_LONG "${PCSX2_GIT_REV}")
@@ -64,12 +70,17 @@ function(get_git_version_info)
 
 	set(PCSX2_WC_TIME "${PCSX2_WC_TIME}" PARENT_SCOPE)
 	set(PCSX2_GIT_REV "${PCSX2_GIT_REV}" PARENT_SCOPE)
+	set(PCSX2_GIT_TAG "${PCSX2_GIT_TAG}" PARENT_SCOPE)
 	set(PCSX2_VERSION_LONG "${PCSX2_VERSION_LONG}" PARENT_SCOPE)
 	set(PCSX2_VERSION_SHORT "${PCSX2_VERSION_SHORT}" PARENT_SCOPE)
 endfunction()
 
 function(write_svnrev_h)
-	file(WRITE ${CMAKE_BINARY_DIR}/common/include/svnrev.h "#define SVN_REV ${PCSX2_WC_TIME}ll \n#define SVN_MODS 0\n#define GIT_REV \"${PCSX2_GIT_REV}\"\n")
+	if(PCSX2_GIT_TAG)
+		file(WRITE ${CMAKE_BINARY_DIR}/common/include/svnrev.h "#define SVN_REV ${PCSX2_WC_TIME}ll \n#define GIT_TAG \"${PCSX2_GIT_TAG}\"\n#define GIT_TAGGED_COMMIT 1\n#define GIT_REV \"\"\n")
+	else()
+		file(WRITE ${CMAKE_BINARY_DIR}/common/include/svnrev.h "#define SVN_REV ${PCSX2_WC_TIME}ll \n#define GIT_TAG \"${PCSX2_GIT_TAG}\"\n#define GIT_TAGGED_COMMIT 0\n#define GIT_REV \"${PCSX2_GIT_REV}\"\n")
+	endif()
 endfunction()
 
 function(check_compiler_version version_warn version_err)

common/Pcsx2Defs.h

@@ -31,6 +31,10 @@
 
 #include "common/emitter/x86_intrin.h"
 
+// The C++ standard doesn't allow `offsetof` to be used on non-constant values (e.g. `offsetof(class, field[i])`)
+// Use this in those situations
+#define OFFSETOF(a, b) (reinterpret_cast<size_t>(&(static_cast<a*>(0)->b)))
+
 // Renamed ARRAYSIZE to ArraySize -- looks nice and gets rid of Windows.h conflicts (air)
 // Notes: I'd have used ARRAY_SIZE instead but ran into cross-platform lib conflicts with
 // that as well.  >_<

common/vsprops/preBuild.cmd

@@ -23,7 +23,11 @@ FOR /F "tokens=1-2" %%i IN ('"git show -s --format=%%%ci HEAD 2> NUL"') do (
 )
 
 FOR /F %%i IN ('"git describe 2> NUL"') do (
-    set GIT_REV=%%i
+  set GIT_REV=%%i
+)
+
+FOR /F "tokens=* USEBACKQ" %%i IN (`git tag --points-at HEAD`) DO (
+  set GIT_TAG=%%i
 )
 
 set REV2=%REV3: =%
@@ -40,12 +44,24 @@ if %ERRORLEVEL% NEQ 0 (
 
   echo #define SVN_REV_UNKNOWN > "%CD%\svnrev.h"
   echo #define SVN_REV 0ll >> "%CD%\svnrev.h"
-  echo #define SVN_MODS 0 >> "%CD%\svnrev.h"
   echo #define GIT_REV "" >> "%CD%\svnrev.h"
+  echo #define GIT_TAG "" >> "%CD%\svnrev.h"
+  echo #define GIT_TAGGED_COMMIT 0 >> "%CD%\svnrev.h"
 ) else (
-  echo #define SVN_REV %REV%ll > "%CD%\svnrev.h"
-  echo #define SVN_MODS 0 /* Not implemented at the moment. */ >> "%CD%\svnrev.h"
-  echo #define GIT_REV "%GIT_REV%" >> "%CD%\svnrev.h"
+  :: Support New Tagged Release Model
+  if [%GIT_TAG%] NEQ [] (
+    echo Detected that the current commit is tagged, using that!
+    echo #define SVN_REV_UNKNOWN > "%CD%\svnrev.h"
+    echo #define SVN_REV 0ll >> "%CD%\svnrev.h"
+    echo #define GIT_REV "" >> "%CD%\svnrev.h"
+    echo #define GIT_TAG "%GIT_TAG%" >> "%CD%\svnrev.h"
+    echo #define GIT_TAGGED_COMMIT 1 >> "%CD%\svnrev.h"
+  ) else (
+    echo #define SVN_REV %REV%ll > "%CD%\svnrev.h"
+    echo #define GIT_REV "%GIT_REV%" >> "%CD%\svnrev.h"
+    echo #define GIT_TAG "" >> "%CD%\svnrev.h"
+    echo #define GIT_TAGGED_COMMIT 0 >> "%CD%\svnrev.h"
+  )
 )
 
 ENDLOCAL

pcsx2/CMakeLists.txt

@@ -639,21 +639,12 @@ set(pcsx2GSSources
 	GS/Renderers/HW/GSTextureCache.cpp
 	GS/Renderers/SW/GSDrawScanline.cpp
 	GS/Renderers/SW/GSDrawScanlineCodeGenerator.cpp
-	GS/Renderers/SW/GSDrawScanlineCodeGenerator.x64.cpp
-	GS/Renderers/SW/GSDrawScanlineCodeGenerator.x64.avx.cpp
-	GS/Renderers/SW/GSDrawScanlineCodeGenerator.x64.avx2.cpp
-	GS/Renderers/SW/GSDrawScanlineCodeGenerator.x86.cpp
-	GS/Renderers/SW/GSDrawScanlineCodeGenerator.x86.avx.cpp
-	GS/Renderers/SW/GSDrawScanlineCodeGenerator.x86.avx2.cpp
+	GS/Renderers/SW/GSDrawScanlineCodeGenerator.all.cpp
+	GS/Renderers/SW/GSNewCodeGenerator.cpp
 	GS/Renderers/SW/GSRasterizer.cpp
 	GS/Renderers/SW/GSRendererSW.cpp
 	GS/Renderers/SW/GSSetupPrimCodeGenerator.cpp
-	GS/Renderers/SW/GSSetupPrimCodeGenerator.x64.cpp
-	GS/Renderers/SW/GSSetupPrimCodeGenerator.x64.avx.cpp
-	GS/Renderers/SW/GSSetupPrimCodeGenerator.x64.avx2.cpp
-	GS/Renderers/SW/GSSetupPrimCodeGenerator.x86.cpp
-	GS/Renderers/SW/GSSetupPrimCodeGenerator.x86.avx.cpp
-	GS/Renderers/SW/GSSetupPrimCodeGenerator.x86.avx2.cpp
+	GS/Renderers/SW/GSSetupPrimCodeGenerator.all.cpp
 	GS/Renderers/SW/GSTextureCacheSW.cpp
 	GS/Renderers/SW/GSTextureSW.cpp
 	GS/Renderers/OpenGL/GLLoader.cpp
@@ -679,7 +670,6 @@ set(pcsx2GSHeaders
 	GS/GSDrawingEnvironment.h
 	GS/GSDump.h
 	GS/GS_types.h
-	GS/GS_codegen.h
 	GS/GS.h
 	GS/GSLocalMemory.h
 	GS/GSLzma.h
@@ -712,11 +702,14 @@ set(pcsx2GSHeaders
 	GS/Renderers/HW/GSTextureCache.h
 	GS/Renderers/HW/GSVertexHW.h
 	GS/Renderers/SW/GSDrawScanlineCodeGenerator.h
+	GS/Renderers/SW/GSDrawScanlineCodeGenerator.all.h
 	GS/Renderers/SW/GSDrawScanline.h
+	GS/Renderers/SW/GSNewCodeGenerator.h
 	GS/Renderers/SW/GSRasterizer.h
 	GS/Renderers/SW/GSRendererSW.h
 	GS/Renderers/SW/GSScanlineEnvironment.h
 	GS/Renderers/SW/GSSetupPrimCodeGenerator.h
+	GS/Renderers/SW/GSSetupPrimCodeGenerator.all.h
 	GS/Renderers/SW/GSTextureCacheSW.h
 	GS/Renderers/SW/GSTextureSW.h
 	GS/Renderers/SW/GSVertexSW.h

pcsx2/GS/GS.cpp

@@ -1262,22 +1262,19 @@ void GSApp::Init()
 	m_default_configuration["osd_monitor_enabled"]                        = "0";
 	m_default_configuration["osd_max_log_messages"]                       = "2";
 	m_default_configuration["override_geometry_shader"]                   = "-1";
-	m_default_configuration["override_GL_ARB_compute_shader"]             = "-1";
 	m_default_configuration["override_GL_ARB_copy_image"]                 = "-1";
 	m_default_configuration["override_GL_ARB_clear_texture"]              = "-1";
 	m_default_configuration["override_GL_ARB_clip_control"]               = "-1";
 	m_default_configuration["override_GL_ARB_direct_state_access"]        = "-1";
 	m_default_configuration["override_GL_ARB_draw_buffers_blend"]         = "-1";
-	m_default_configuration["override_GL_ARB_get_texture_sub_image"]      = "-1";
 	m_default_configuration["override_GL_ARB_gpu_shader5"]                = "-1";
-	m_default_configuration["override_GL_ARB_multi_bind"]                 = "-1";
 	m_default_configuration["override_GL_ARB_shader_image_load_store"]    = "-1";
-	m_default_configuration["override_GL_ARB_shader_storage_buffer_object"] = "-1";
 	m_default_configuration["override_GL_ARB_sparse_texture"]             = "-1";
 	m_default_configuration["override_GL_ARB_sparse_texture2"]            = "-1";
-	m_default_configuration["override_GL_ARB_texture_view"]               = "-1";
-	m_default_configuration["override_GL_ARB_vertex_attrib_binding"]      = "-1";
 	m_default_configuration["override_GL_ARB_texture_barrier"]            = "-1";
+#ifdef GL_EXT_TEX_SUB_IMAGE
+	m_default_configuration["override_GL_ARB_get_texture_sub_image"]      = "-1";
+#endif
 	m_default_configuration["paltex"]                                     = "0";
 	m_default_configuration["png_compression_level"]                      = std::to_string(Z_BEST_SPEED);
 	m_default_configuration["preload_frame_with_gs_data"]                 = "0";

pcsx2/GS/GSAlignedClass.h

@@ -18,10 +18,11 @@
 template <int i>
 class GSAlignedClass
 {
-public:
-	GSAlignedClass() {}
-	virtual ~GSAlignedClass() {}
+protected:
+	GSAlignedClass() = default;
+	~GSAlignedClass() = default;
 
+public:
 	void* operator new(size_t size)
 	{
 		return _aligned_malloc(size, i);

pcsx2/GS/GSClut.cpp

@@ -158,36 +158,12 @@ void GSClut::Write(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
 	m_read.dirty = true;
 
 	(this->*m_wc[TEX0.CSM][TEX0.CPSM][TEX0.PSM])(TEX0, TEXCLUT);
-
-	// Mirror write to other half of buffer to simulate wrapping memory
-
-	int offset = (TEX0.CSA & (TEX0.CPSM < PSM_PSMCT16 ? 15 : 31)) * 16;
-
-	if (TEX0.PSM == PSM_PSMT8 || TEX0.PSM == PSM_PSMT8H)
-	{
-		int size = TEX0.CPSM < PSM_PSMCT16 ? 512 : 256;
-
-		memcpy(m_clut + 512 + offset, m_clut + offset, sizeof(*m_clut) * std::min(size, 512 - offset));
-		memcpy(m_clut, m_clut + 512, sizeof(*m_clut) * std::max(0, size + offset - 512));
-	}
-	else
-	{
-		int size = 16;
-
-		memcpy(m_clut + 512 + offset, m_clut + offset, sizeof(*m_clut) * size);
-
-		if (TEX0.CPSM < PSM_PSMCT16)
-		{
-			memcpy(m_clut + 512 + 256 + offset, m_clut + 256 + offset, sizeof(*m_clut) * size);
-		}
-	}
 }
 
 void GSClut::WriteCLUT32_I8_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
 {
 	ALIGN_STACK(32);
-	//FIXME: Romance of the Three Kingdoms VIII text doesn't like the offset
-	WriteCLUT_T32_I8_CSM1((uint32*)m_mem->BlockPtr32(0, 0, TEX0.CBP, 1), m_clut + ((TEX0.CSA & 15) << 4));
+	WriteCLUT_T32_I8_CSM1((uint32*)m_mem->BlockPtr32(0, 0, TEX0.CBP, 1), m_clut, (TEX0.CSA & 15));
 }
 
 void GSClut::WriteCLUT32_I4_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
@@ -339,8 +315,7 @@ void GSClut::Read32(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA)
 			{
 				case PSM_PSMT8:
 				case PSM_PSMT8H:
-					clut += (TEX0.CSA & 15) << 4; // disney golf title screen
-					ReadCLUT_T32_I8(clut, m_buff32);
+					ReadCLUT_T32_I8(clut, m_buff32, (TEX0.CSA & 15) << 4);
 					break;
 				case PSM_PSMT4:
 				case PSM_PSMT4HL:
@@ -443,16 +418,16 @@ void GSClut::GetAlphaMinMax32(int& amin_out, int& amax_out)
 
 //
 
-void GSClut::WriteCLUT_T32_I8_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut)
+void GSClut::WriteCLUT_T32_I8_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut, uint16 offset)
 {
-	// 4 blocks
-
-	for (int i = 0; i < 64; i += 16)
+	// This is required when CSA is offset from the base of the CLUT so we point to the right data
+	for (int i = offset; i < 16; i ++)
 	{
-		WriteCLUT_T32_I4_CSM1(&src[i + 0], &clut[i * 2 + 0]);
-		WriteCLUT_T32_I4_CSM1(&src[i + 64], &clut[i * 2 + 16]);
-		WriteCLUT_T32_I4_CSM1(&src[i + 128], &clut[i * 2 + 128]);
-		WriteCLUT_T32_I4_CSM1(&src[i + 192], &clut[i * 2 + 144]);
+		const int off = i << 4; // WriteCLUT_T32_I4_CSM1 loads 16 at a time
+		// Source column
+		const int s = clutTableT32I8[off & 0x70] | (off & 0x80);
+
+		WriteCLUT_T32_I4_CSM1(&src[s], &clut[off]);
 	}
 }
 
@@ -532,11 +507,18 @@ __forceinline void GSClut::WriteCLUT_T16_I4_CSM1(const uint16* RESTRICT src, uin
 	}
 }
 
-void GSClut::ReadCLUT_T32_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst)
+void GSClut::ReadCLUT_T32_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst, int offset)
 {
+	// Okay this deserves a small explanation
+	// T32 I8 can address up to 256 colors however the offset can be "more than zero" when reading
+	// Previously I assumed that it would wrap around the end of the buffer to the beginning
+	// but it turns out this is incorrect, the address doesn't mirror, it clamps to to the last offset,
+	// probably though some sort of addressing mechanism then picks the color from the lower 0xF of the requested CLUT entry.
+	// if we don't do this, the dirt on GTA SA goes transparent and actually cleans the car driving through dirt.
 	for (int i = 0; i < 256; i += 16)
 	{
-		ReadCLUT_T32_I4(&clut[i], &dst[i]);
+		// Min value + offet or Last CSA * 16 (240)
+		ReadCLUT_T32_I4(&clut[std::min((i + offset), 240)], &dst[i]);
 	}
 }
 

pcsx2/GS/GSClut.h

@@ -74,11 +74,11 @@ class alignas(32) GSClut : public GSAlignedClass<32>
 
 	void WriteCLUT_NULL(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT);
 
-	static void WriteCLUT_T32_I8_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut);
+	static void WriteCLUT_T32_I8_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut, uint16 offset);
 	static void WriteCLUT_T32_I4_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut);
 	static void WriteCLUT_T16_I8_CSM1(const uint16* RESTRICT src, uint16* RESTRICT clut);
 	static void WriteCLUT_T16_I4_CSM1(const uint16* RESTRICT src, uint16* RESTRICT clut);
-	static void ReadCLUT_T32_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst);
+	static void ReadCLUT_T32_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst, int offset);
 	static void ReadCLUT_T32_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst);
 	//static void ReadCLUT_T32_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst32, uint64* RESTRICT dst64);
 	//static void ReadCLUT_T16_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst);

pcsx2/GS/GSVector4.h

@@ -205,6 +205,17 @@ public:
 		return m;
 	}
 
+	/// Makes Clang think that the whole vector is needed, preventing it from changing shuffles around because it thinks we don't need the whole vector
+	/// Useful for e.g. preventing clang from optimizing shuffles that remove possibly-denormal garbage data from vectors before computing with them
+	__forceinline GSVector4 noopt()
+	{
+		// Note: Clang is currently the only compiler that attempts to optimize vector intrinsics, if that changes in the future the implementation should be updated
+#ifdef __clang__
+		__asm__("":"+x"(m)::);
+#endif
+		return *this;
+	}
+
 	__forceinline uint32 rgba32() const
 	{
 		return GSVector4i(*this).rgba32();

pcsx2/GS/GS_types.h

@@ -110,11 +110,7 @@ extern void vmfree(void* ptr, size_t size);
 
 	// Convert gcc see define into GS (windows) define
 	#if defined(__AVX2__)
-		#if defined(__x86_64__)
-			#define _M_SSE 0x500 // TODO
-		#else
-			#define _M_SSE 0x501
-		#endif
+		#define _M_SSE 0x501
 	#elif defined(__AVX__)
 		#define _M_SSE 0x500
 	#elif defined(__SSE4_1__)

pcsx2/GS/Renderers/Common/GSVertexTrace.cpp

@@ -27,8 +27,7 @@ GSVertexTrace::GSVertexTrace(const GSState* state)
 	memset(&m_alpha, 0, sizeof(m_alpha));
 
 	#define InitUpdate3(P, IIP, TME, FST, COLOR) \
-		m_fmm[0][COLOR][FST][TME][IIP][P] = &GSVertexTrace::FindMinMax<P, IIP, TME, FST, COLOR, 0>; \
-		m_fmm[1][COLOR][FST][TME][IIP][P] = &GSVertexTrace::FindMinMax<P, IIP, TME, FST, COLOR, 1>; \
+		m_fmm[COLOR][FST][TME][IIP][P] = &GSVertexTrace::FindMinMax<P, IIP, TME, FST, COLOR>;
 
 	#define InitUpdate2(P, IIP, TME) \
 		InitUpdate3(P, IIP, TME, 0, 0) \
@@ -57,7 +56,7 @@ void GSVertexTrace::Update(const void* vertex, const uint32* index, int v_count,
 	uint32 fst = m_state->PRIM->FST;
 	uint32 color = !(m_state->PRIM->TME && m_state->m_context->TEX0.TFX == TFX_DECAL && m_state->m_context->TEX0.TCC);
 
-	(this->*m_fmm[m_accurate_stq][color][fst][tme][iip][primclass])(vertex, index, i_count);
+	(this->*m_fmm[color][fst][tme][iip][primclass])(vertex, index, i_count);
 
 	// Potential float overflow detected. Better uses the slower division instead
 	// Note: If Q is too big, 1/Q will end up as 0. 1e30 is a random number
@@ -66,7 +65,6 @@ void GSVertexTrace::Update(const void* vertex, const uint32* index, int v_count,
 	{
 		fprintf(stderr, "Vertex Trace: float overflow detected ! min %e max %e\n", m_min.t.z, m_max.t.z);
 		m_accurate_stq = true;
-		(this->*m_fmm[m_accurate_stq][color][fst][tme][iip][primclass])(vertex, index, i_count);
 	}
 
 	m_eq.value = (m_min.c == m_max.c).mask() | ((m_min.p == m_max.p).mask() << 16) | ((m_min.t == m_max.t).mask() << 20);
@@ -150,7 +148,7 @@ void GSVertexTrace::Update(const void* vertex, const uint32* index, int v_count,
 	}
 }
 
-template <GS_PRIM_CLASS primclass, uint32 iip, uint32 tme, uint32 fst, uint32 color, uint32 accurate_stq>
+template <GS_PRIM_CLASS primclass, uint32 iip, uint32 tme, uint32 fst, uint32 color>
 void GSVertexTrace::FindMinMax(const void* vertex, const uint32* index, int count)
 {
 	const GSDrawingContext* context = m_state->m_context;
@@ -181,287 +179,123 @@ void GSVertexTrace::FindMinMax(const void* vertex, const uint32* index, int coun
 
 	const GSVertex* RESTRICT v = (GSVertex*)vertex;
 
-	for (int i = 0; i < count; i += n)
+	// Process 2 vertices at a time for increased efficiency
+	auto processVertices = [&](const GSVertex& v0, const GSVertex& v1, bool finalVertex)
 	{
-		if (primclass == GS_POINT_CLASS)
+		if (color)
 		{
-			GSVector4i c(v[index[i]].m[0]);
-
-			if (color)
+			GSVector4i c0 = GSVector4i::load(v0.RGBAQ.u32[0]);
+			GSVector4i c1 = GSVector4i::load(v1.RGBAQ.u32[0]);
+			if (iip || finalVertex)
 			{
-				cmin = cmin.min_u8(c);
-				cmax = cmax.max_u8(c);
+				cmin = cmin.min_u8(c0.min_u8(c1));
+				cmax = cmax.max_u8(c0.max_u8(c1));
 			}
-
-			if (tme)
+			else if (n == 2)
 			{
-				if (!fst)
-				{
-					GSVector4 stq = GSVector4::cast(c);
-
-					GSVector4 q = stq.wwww();
-
-					if (accurate_stq)
-						stq = (stq.xyww() / q).xyww(q);
-					else
-						stq = (stq.xyww() * q.rcpnr()).xyww(q);
-
-					tmin = tmin.min(stq);
-					tmax = tmax.max(stq);
-				}
-				else
-				{
-					GSVector4i uv(v[index[i]].m[1]);
-
-					GSVector4 st = GSVector4(uv.uph16()).xyxy();
-
-					tmin = tmin.min(st);
-					tmax = tmax.max(st);
-				}
+				// For even n, we process v1 and v2 of the same prim
+				// (For odd n, we process one vertex from each of two prims)
+				cmin = cmin.min_u8(c1);
+				cmax = cmax.max_u8(c1);
 			}
-
-			GSVector4i xyzf(v[index[i]].m[1]);
-
-			GSVector4i xy = xyzf.upl16();
-			GSVector4i z = xyzf.yyyy();
-
-			GSVector4i p = xy.blend16<0xf0>(z.uph32(xyzf));
-
-			pmin = pmin.min_u32(p);
-			pmax = pmax.max_u32(p);
 		}
-		else if (primclass == GS_LINE_CLASS)
+
+		if (tme)
 		{
-			GSVector4i c0(v[index[i + 0]].m[0]);
-			GSVector4i c1(v[index[i + 1]].m[0]);
-
-			if (color)
+			if (!fst)
 			{
-				if (iip)
-				{
-					cmin = cmin.min_u8(c0.min_u8(c1));
-					cmax = cmax.max_u8(c0.max_u8(c1));
-				}
-				else
-				{
-					cmin = cmin.min_u8(c1);
-					cmax = cmax.max_u8(c1);
-				}
-			}
+				GSVector4 stq0 = GSVector4::cast(GSVector4i(v0.m[0]));
+				GSVector4 stq1 = GSVector4::cast(GSVector4i(v1.m[0]));
 
-			if (tme)
+				GSVector4 q;
+				// Sprites always have indices == vertices, so we don't have to look at the index table here
+				if (primclass == GS_SPRITE_CLASS)
+					q = stq1.wwww();
+				else
+					q = stq0.wwww(stq1);
+
+				// Note: If in the future this is changed in a way that causes parts of calculations to go unused,
+				//       make sure to remove the z (rgba) field as it's often denormal.
+				//       Then, use GSVector4::noopt() to prevent clang from optimizing out your "useless" shuffle
+				//       e.g. stq = (stq.xyww() / stq.wwww()).noopt().xyww(stq);
+				GSVector4 st = stq0.xyxy(stq1) / q;
+
+				stq0 = st.xyww(primclass == GS_SPRITE_CLASS ? stq1 : stq0);
+				stq1 = st.zwww(stq1);
+
+				tmin = tmin.min(stq0.min(stq1));
+				tmax = tmax.max(stq0.max(stq1));
+			}
+			else
 			{
-				if (!fst)
-				{
-					GSVector4 stq0 = GSVector4::cast(c0);
-					GSVector4 stq1 = GSVector4::cast(c1);
+				GSVector4i uv0(v0.m[1]);
+				GSVector4i uv1(v1.m[1]);
 
-					if (accurate_stq)
-					{
-						GSVector4 q = stq0.wwww(stq1);
+				GSVector4 st0 = GSVector4(uv0.uph16()).xyxy();
+				GSVector4 st1 = GSVector4(uv1.uph16()).xyxy();
 
-						stq0 = (stq0.xyww() / q.xxxx()).xyww(stq0);
-						stq1 = (stq1.xyww() / q.zzzz()).xyww(stq1);
-					}
-					else
-					{
-						GSVector4 q = stq0.wwww(stq1).rcpnr();
-
-						stq0 = (stq0.xyww() * q.xxxx()).xyww(stq0);
-						stq1 = (stq1.xyww() * q.zzzz()).xyww(stq1);
-					}
-
-					tmin = tmin.min(stq0.min(stq1));
-					tmax = tmax.max(stq0.max(stq1));
-				}
-				else
-				{
-					GSVector4i uv0(v[index[i + 0]].m[1]);
-					GSVector4i uv1(v[index[i + 1]].m[1]);
-
-					GSVector4 st0 = GSVector4(uv0.uph16()).xyxy();
-					GSVector4 st1 = GSVector4(uv1.uph16()).xyxy();
-
-					tmin = tmin.min(st0.min(st1));
-					tmax = tmax.max(st0.max(st1));
-				}
+				tmin = tmin.min(st0.min(st1));
+				tmax = tmax.max(st0.max(st1));
 			}
-
-			GSVector4i xyzf0(v[index[i + 0]].m[1]);
-			GSVector4i xyzf1(v[index[i + 1]].m[1]);
-
-			GSVector4i xy0 = xyzf0.upl16();
-			GSVector4i z0 = xyzf0.yyyy();
-			GSVector4i xy1 = xyzf1.upl16();
-			GSVector4i z1 = xyzf1.yyyy();
-
-			GSVector4i p0 = xy0.blend16<0xf0>(z0.uph32(xyzf0));
-			GSVector4i p1 = xy1.blend16<0xf0>(z1.uph32(xyzf1));
-
-			pmin = pmin.min_u32(p0.min_u32(p1));
-			pmax = pmax.max_u32(p0.max_u32(p1));
 		}
-		else if (primclass == GS_TRIANGLE_CLASS)
+
+		GSVector4i xyzf0(v0.m[1]);
+		GSVector4i xyzf1(v1.m[1]);
+
+		GSVector4i xy0 = xyzf0.upl16();
+		GSVector4i z0 = xyzf0.yyyy();
+		GSVector4i xy1 = xyzf1.upl16();
+		GSVector4i z1 = xyzf1.yyyy();
+
+		GSVector4i p0 = xy0.blend16<0xf0>(z0.uph32(primclass == GS_SPRITE_CLASS ? xyzf1 : xyzf0));
+		GSVector4i p1 = xy1.blend16<0xf0>(z1.uph32(xyzf1));
+
+		pmin = pmin.min_u32(p0.min_u32(p1));
+		pmax = pmax.max_u32(p0.max_u32(p1));
+	};
+
+	if (n == 2)
+	{
+		for (int i = 0; i < count; i += 2)
 		{
-			GSVector4i c0(v[index[i + 0]].m[0]);
-			GSVector4i c1(v[index[i + 1]].m[0]);
-			GSVector4i c2(v[index[i + 2]].m[0]);
-
-			if (color)
-			{
-				if (iip)
-				{
-					cmin = cmin.min_u8(c2).min_u8(c0.min_u8(c1));
-					cmax = cmax.max_u8(c2).max_u8(c0.max_u8(c1));
-				}
-				else
-				{
-					cmin = cmin.min_u8(c2);
-					cmax = cmax.max_u8(c2);
-				}
-			}
-
-			if (tme)
-			{
-				if (!fst)
-				{
-					GSVector4 stq0 = GSVector4::cast(c0);
-					GSVector4 stq1 = GSVector4::cast(c1);
-					GSVector4 stq2 = GSVector4::cast(c2);
-
-					if (accurate_stq)
-					{
-						GSVector4 q = stq0.wwww(stq1).xzww(stq2);
-
-						stq0 = (stq0.xyww() / q.xxxx()).xyww(stq0);
-						stq1 = (stq1.xyww() / q.yyyy()).xyww(stq1);
-						stq2 = (stq2.xyww() / q.zzzz()).xyww(stq2);
-					}
-					else
-					{
-						GSVector4 q = stq0.wwww(stq1).xzww(stq2).rcpnr();
-
-						stq0 = (stq0.xyww() * q.xxxx()).xyww(stq0);
-						stq1 = (stq1.xyww() * q.yyyy()).xyww(stq1);
-						stq2 = (stq2.xyww() * q.zzzz()).xyww(stq2);
-					}
-
-					tmin = tmin.min(stq2).min(stq0.min(stq1));
-					tmax = tmax.max(stq2).max(stq0.max(stq1));
-				}
-				else
-				{
-					GSVector4i uv0(v[index[i + 0]].m[1]);
-					GSVector4i uv1(v[index[i + 1]].m[1]);
-					GSVector4i uv2(v[index[i + 2]].m[1]);
-
-					GSVector4 st0 = GSVector4(uv0.uph16()).xyxy();
-					GSVector4 st1 = GSVector4(uv1.uph16()).xyxy();
-					GSVector4 st2 = GSVector4(uv2.uph16()).xyxy();
-
-					tmin = tmin.min(st2).min(st0.min(st1));
-					tmax = tmax.max(st2).max(st0.max(st1));
-				}
-			}
-
-			GSVector4i xyzf0(v[index[i + 0]].m[1]);
-			GSVector4i xyzf1(v[index[i + 1]].m[1]);
-			GSVector4i xyzf2(v[index[i + 2]].m[1]);
-
-			GSVector4i xy0 = xyzf0.upl16();
-			GSVector4i z0 = xyzf0.yyyy();
-			GSVector4i xy1 = xyzf1.upl16();
-			GSVector4i z1 = xyzf1.yyyy();
-			GSVector4i xy2 = xyzf2.upl16();
-			GSVector4i z2 = xyzf2.yyyy();
-
-			GSVector4i p0 = xy0.blend16<0xf0>(z0.uph32(xyzf0));
-			GSVector4i p1 = xy1.blend16<0xf0>(z1.uph32(xyzf1));
-			GSVector4i p2 = xy2.blend16<0xf0>(z2.uph32(xyzf2));
-
-			pmin = pmin.min_u32(p2).min_u32(p0.min_u32(p1));
-			pmax = pmax.max_u32(p2).max_u32(p0.max_u32(p1));
-		}
-		else if (primclass == GS_SPRITE_CLASS)
-		{
-			GSVector4i c0(v[index[i + 0]].m[0]);
-			GSVector4i c1(v[index[i + 1]].m[0]);
-
-			if (color)
-			{
-				if (iip)
-				{
-					cmin = cmin.min_u8(c0.min_u8(c1));
-					cmax = cmax.max_u8(c0.max_u8(c1));
-				}
-				else
-				{
-					cmin = cmin.min_u8(c1);
-					cmax = cmax.max_u8(c1);
-				}
-			}
-
-			if (tme)
-			{
-				if (!fst)
-				{
-					GSVector4 stq0 = GSVector4::cast(c0);
-					GSVector4 stq1 = GSVector4::cast(c1);
-
-					if (accurate_stq)
-					{
-						GSVector4 q = stq1.wwww();
-
-						stq0 = (stq0.xyww() / q).xyww(stq1);
-						stq1 = (stq1.xyww() / q).xyww(stq1);
-					}
-					else
-					{
-						GSVector4 q = stq1.wwww().rcpnr();
-
-						stq0 = (stq0.xyww() * q).xyww(stq1);
-						stq1 = (stq1.xyww() * q).xyww(stq1);
-					}
-
-					tmin = tmin.min(stq0.min(stq1));
-					tmax = tmax.max(stq0.max(stq1));
-				}
-				else
-				{
-					GSVector4i uv0(v[index[i + 0]].m[1]);
-					GSVector4i uv1(v[index[i + 1]].m[1]);
-
-					GSVector4 st0 = GSVector4(uv0.uph16()).xyxy();
-					GSVector4 st1 = GSVector4(uv1.uph16()).xyxy();
-
-					tmin = tmin.min(st0.min(st1));
-					tmax = tmax.max(st0.max(st1));
-				}
-			}
-
-			GSVector4i xyzf0(v[index[i + 0]].m[1]);
-			GSVector4i xyzf1(v[index[i + 1]].m[1]);
-
-			GSVector4i xy0 = xyzf0.upl16();
-			GSVector4i z0 = xyzf0.yyyy();
-			GSVector4i xy1 = xyzf1.upl16();
-			GSVector4i z1 = xyzf1.yyyy();
-
-			GSVector4i p0 = xy0.blend16<0xf0>(z0.uph32(xyzf1));
-			GSVector4i p1 = xy1.blend16<0xf0>(z1.uph32(xyzf1));
-
-			pmin = pmin.min_u32(p0.min_u32(p1));
-			pmax = pmax.max_u32(p0.max_u32(p1));
+			processVertices(v[index[i + 0]], v[index[i + 1]], false);
 		}
 	}
-
-	// FIXME/WARNING. A division by 2 is done on the depth. I suspect to avoid
-	// negative value. However it means that we lost the lsb bit. m_eq.z could
-	// be true if depth isn't constant but close enough. It also imply that
-	// pmin.z & 1 == 0 and pax.z & 1 == 0
-
-	pmin = pmin.blend16<0x30>(pmin.srl32(1));
-	pmax = pmax.blend16<0x30>(pmax.srl32(1));
+	else if (iip || n == 1) // iip means final and non-final vertexes are treated the same
+	{
+		int i = 0;
+		for (; i < (count - 1); i += 2) // 2x loop unroll
+		{
+			processVertices(v[index[i + 0]], v[index[i + 1]], true);
+		}
+		if (count & 1)
+		{
+			// Compiler optimizations go!
+			// (And if they don't, it's only one vertex out of many)
+			processVertices(v[index[i]], v[index[i]], true);
+		}
+	}
+	else if (n == 3)
+	{
+		int i = 0;
+		for (; i < (count - 3); i += 6)
+		{
+			processVertices(v[index[i + 0]], v[index[i + 3]], false);
+			processVertices(v[index[i + 1]], v[index[i + 4]], false);
+			processVertices(v[index[i + 2]], v[index[i + 5]], true);
+		}
+		if (count & 1)
+		{
+			processVertices(v[index[i + 0]], v[index[i + 1]], false);
+			// Compiler optimizations go!
+			// (And if they don't, it's only one vertex out of many)
+			processVertices(v[index[i + 2]], v[index[i + 2]], true);
+		}
+	}
+	else
+	{
+		pxAssertRel(0, "Bad n value");
+	}
 
 	GSVector4 o(context->XYOFFSET);
 	GSVector4 s(1.0f / 16, 1.0f / 16, 2.0f, 1.0f);
@@ -469,6 +303,10 @@ void GSVertexTrace::FindMinMax(const void* vertex, const uint32* index, int coun
 	m_min.p = (GSVector4(pmin) - o) * s;
 	m_max.p = (GSVector4(pmax) - o) * s;
 
+	// Fix signed int conversion
+	m_min.p = m_min.p.insert32<0, 2>(GSVector4::load((float)(uint32)pmin.extract32<2>()));
+	m_max.p = m_max.p.insert32<0, 2>(GSVector4::load((float)(uint32)pmax.extract32<2>()));
+
 	if (tme)
 	{
 		if (fst)
@@ -491,8 +329,8 @@ void GSVertexTrace::FindMinMax(const void* vertex, const uint32* index, int coun
 
 	if (color)
 	{
-		m_min.c = cmin.zzzz().u8to32();
-		m_max.c = cmax.zzzz().u8to32();
+		m_min.c = cmin.u8to32();
+		m_max.c = cmax.u8to32();
 	}
 	else
 	{

pcsx2/GS/Renderers/Common/GSVertexTrace.h

@@ -47,9 +47,9 @@ protected:
 
 	typedef void (GSVertexTrace::*FindMinMaxPtr)(const void* vertex, const uint32* index, int count);
 
-	FindMinMaxPtr m_fmm[2][2][2][2][2][4];
+	FindMinMaxPtr m_fmm[2][2][2][2][4];
 
-	template <GS_PRIM_CLASS primclass, uint32 iip, uint32 tme, uint32 fst, uint32 color, uint32 accurate_stq>
+	template <GS_PRIM_CLASS primclass, uint32 iip, uint32 tme, uint32 fst, uint32 color>
 	void FindMinMax(const void* vertex, const uint32* index, int count);
 
 public:

pcsx2/GS/Renderers/HW/GSTextureCache.cpp

@@ -1096,7 +1096,8 @@ void GSTextureCache::InvalidateLocalMem(GSOffset* off, const GSVector4i& r)
 				// the game can then draw using 8H format
 				// in the case of silent hill blit 8H -> 8P
 				// this will matter later when the data ends up in GS memory in the wrong format
-				if (t->m_32_bits_fmt)
+				// Be careful to avoid 24 bit textures which are technically 32bit, as you could lose alpha (8H) data.
+				if (t->m_32_bits_fmt && t->m_TEX0.PSM > PSM_PSMCT24)
 					t->m_TEX0.PSM = PSM_PSMCT32;
 
 				if (GSTextureCache::m_disable_partial_invalidation)

pcsx2/GS/Renderers/OpenGL/GLLoader.cpp

@@ -156,22 +156,19 @@ namespace GLLoader
 
 	bool found_geometry_shader = true; // we require GL3.3 so geometry must be supported by default
 	bool found_GL_ARB_clear_texture = false;
-	bool found_GL_ARB_get_texture_sub_image = false; // Not yet used
 	// DX11 GPU
 	bool found_GL_ARB_gpu_shader5 = false;             // Require IvyBridge
 	bool found_GL_ARB_shader_image_load_store = false; // Intel IB. Nvidia/AMD miss Mesa implementation.
-	bool found_GL_ARB_shader_storage_buffer_object = false;
-	bool found_GL_ARB_compute_shader = false;
-	bool found_GL_ARB_texture_view = false; // maybe older gpu can support it ?
-
-	// Mandatory in the future
-	bool found_GL_ARB_multi_bind = false;
-	bool found_GL_ARB_vertex_attrib_binding = false;
 
 	// In case sparse2 isn't supported
 	bool found_compatible_GL_ARB_sparse_texture2 = false;
 	bool found_compatible_sparse_depth = false;
 
+	// Not yet used
+#ifdef GL_EXT_TEX_SUB_IMAGE
+	bool found_GL_ARB_get_texture_sub_image = false;
+#endif
+
 	static void mandatory(const std::string& ext)
 	{
 		if (!GLExtension::Has(ext))
@@ -310,20 +307,17 @@ namespace GLLoader
 			found_GL_ARB_gpu_shader5 = optional("GL_ARB_gpu_shader5");
 			// GL4.2
 			found_GL_ARB_shader_image_load_store = optional("GL_ARB_shader_image_load_store");
-			// GL4.3
-			found_GL_ARB_compute_shader = optional("GL_ARB_compute_shader");
-			found_GL_ARB_shader_storage_buffer_object = optional("GL_ARB_shader_storage_buffer_object");
-			found_GL_ARB_texture_view = optional("GL_ARB_texture_view");
-			found_GL_ARB_vertex_attrib_binding = optional("GL_ARB_vertex_attrib_binding");
 			// GL4.4
 			found_GL_ARB_clear_texture = optional("GL_ARB_clear_texture");
-			found_GL_ARB_multi_bind = optional("GL_ARB_multi_bind");
 			// GL4.5
 			optional("GL_ARB_direct_state_access");
 			// Mandatory for the advance HW renderer effect. Unfortunately Mesa LLVMPIPE/SWR renderers doesn't support this extension.
 			// Rendering might be corrupted but it could be good enough for test/virtual machine.
 			optional("GL_ARB_texture_barrier");
+			// Not yet used
+#ifdef GL_EXT_TEX_SUB_IMAGE
 			found_GL_ARB_get_texture_sub_image = optional("GL_ARB_get_texture_sub_image");
+#endif
 		}
 
 		if (vendor_id_amd)

pcsx2/GS/Renderers/OpenGL/GSDeviceOGL.h

@@ -485,8 +485,6 @@ private:
 	std::unique_ptr<GL::StreamBuffer> m_vertex_stream_buffer;
 	std::unique_ptr<GL::StreamBuffer> m_index_stream_buffer;
 	GLuint m_vertex_array_object = 0;
-	u32 m_vertex_buffer_base_vertex = 0;
-	u32 m_index_buffer_offset = 0;
 	GLenum m_draw_topology = 0;
 
 	std::unique_ptr<GL::StreamBuffer> m_vertex_uniform_stream_buffer;

pcsx2/GS/Renderers/OpenGL/GSRendererOGL.cpp

@@ -82,6 +82,9 @@ void GSRendererOGL::SetupIA(const float& sx, const float& sy)
 			//
 			// Note2: Due to MultiThreaded driver, Nvidia suffers less of the previous issue. Still it isn't free
 			// Shadow Heart is 90 fps (gs) vs 113 fps (no gs)
+			//
+			// Note3: Some GPUs (Happens on GT 750m, not on Intel 5200) don't properly divide by large floats (e.g. FLT_MAX/FLT_MAX == 0)
+			// Lines2Sprites predivides by Q, avoiding this issue, so always use it if m_vt.m_accurate_stq
 
 			// If the draw calls contains few primitives. Geometry Shader gain with be rather small versus
 			// the extra validation cost of the extra stage.

pcsx2/GS/Renderers/OpenGL/GSTextureOGL.cpp

@@ -468,7 +468,7 @@ bool GSTextureOGL::Map(GSMap& m, const GSVector4i* _r, int layer)
 		// The fastest way will be to use a PBO to read the data asynchronously. Unfortunately GS
 		// architecture is waiting the data right now.
 
-#if 0
+#ifdef GL_EXT_TEX_SUB_IMAGE
 		// Maybe it is as good as the code below. I don't know
 		// With openGL 4.5 you can use glGetTextureSubImage
 

pcsx2/GS/Renderers/SW/GSDrawScanlineCodeGenerator.all.h

@@ -0,0 +1,189 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021 PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "GSScanlineEnvironment.h"
+#include "GSNewCodeGenerator.h"
+
+#undef _t // Conflict with wx, hopefully no one needs this
+
+#if _M_SSE >= 0x501
+	#define DRAW_SCANLINE_VECTOR_REGISTER Xbyak::Ymm
+	#define DRAW_SCANLINE_USING_XMM 0
+	#define DRAW_SCANLINE_USING_YMM 1
+#else
+	#define DRAW_SCANLINE_VECTOR_REGISTER Xbyak::Xmm
+	#define DRAW_SCANLINE_USING_XMM 1
+	#define DRAW_SCANLINE_USING_YMM 0
+#endif
+
+class GSDrawScanlineCodeGenerator2 : public GSNewCodeGenerator
+{
+	using _parent = GSNewCodeGenerator;
+	using XYm = DRAW_SCANLINE_VECTOR_REGISTER;
+
+	/// On x86-64 we reserve a bunch of GPRs for holding addresses of locals that would otherwise be hard to reach
+	/// On x86-32 the same values are just raw 32-bit addresses
+	using LocalAddr = Choose3264<size_t, AddressReg>::type;
+
+	constexpr static bool isXmm = std::is_same<XYm, Xbyak::Xmm>::value;
+	constexpr static bool isYmm = std::is_same<XYm, Xbyak::Ymm>::value;
+	constexpr static int wordsize = is64 ? 8 : 4;
+	constexpr static int vecsize = isXmm ? 16 : 32;
+	constexpr static int vecsizelog = isXmm ? 4 : 5;
+	constexpr static int vecints = vecsize / 4;
+
+
+// MARK: - Constants
+
+	constexpr static int _32_args = 16;
+	constexpr static int _invalid = 0xaaaaaaaa;
+#ifdef _WIN32
+	constexpr static int _64_top = 8 * 0;
+	// XMM registers will be saved to `rsp + _64_win_xmm_start + id - 6`
+	// Which will put xmm6 after the temporaries, them xmm7, etc
+	constexpr static int _64_win_xmm_start = 8 * 2;
+	// Windows has no redzone and also has 10 xmm registers to save
+	constexpr static int _64_win_stack_size = _64_win_xmm_start + 16 * 10;
+#else
+	// System-V has a redzone so stick everything there
+	constexpr static int _64_rz_rbx = -8 * 1;
+	constexpr static int _64_rz_r12 = -8 * 2;
+	constexpr static int _64_rz_r13 = -8 * 3;
+	constexpr static int _64_rz_r14 = -8 * 4;
+	constexpr static int _64_rz_r15 = -8 * 5;
+	constexpr static int _64_top    = -8 * 6;
+#endif
+	constexpr static int _top = is64 ? _64_top  : _32_args + 4;
+	constexpr static int _v   = is64 ? _invalid : _32_args + 8;
+
+	GSScanlineSelector m_sel;
+	GSScanlineLocalData& m_local;
+	bool m_rip;
+	bool use_lod;
+
+	const XYm xym0{0}, xym1{1}, xym2{2}, xym3{3}, xym4{4}, xym5{5}, xym6{6}, xym7{7}, xym8{8}, xym9{9}, xym10{10}, xym11{11}, xym12{12}, xym13{13}, xym14{14}, xym15{15};
+	/// Note: a2 and t3 are only available on x86-64
+	/// Outside of Init, usable registers are a0, t0, t1, t2, t3[x64], rax, rbx, rdx, r10+
+	const AddressReg a0, a1, a2, a3, t0, t1, t2, t3;
+	const LocalAddr _g_const, _m_local, _m_local__gd, _m_local__gd__vm;
+	/// Available on both x86 and x64, not always valid
+	const XYm _rb, _ga, _fm, _zm, _fd, _test;
+	/// Always valid if needed, x64 only
+	const XYm _z, _f, _s, _t, _q, _f_rb, _f_ga;
+
+	/// Returns the first arg on 32-bit, second on 64-bit
+	static LocalAddr chooseLocal(const void* addr32, AddressReg reg64)
+	{
+		return choose3264((size_t)addr32, reg64);
+	}
+
+public:
+	GSDrawScanlineCodeGenerator2(Xbyak::CodeGenerator* base, CPUInfo cpu, void* param, uint64 key);
+	void Generate();
+
+private:
+	/// Loads the given address into the given register if needed, and returns something that can be used in a `ptr[]`
+	LocalAddr loadAddress(AddressReg reg, const void* addr);
+	/// Broadcast 128 bits of floats from memory to the whole register, whatever size that register might be
+	void broadcastf128(const XYm& reg, const Xbyak::Address& mem);
+	/// Broadcast 128 bits of integers from memory to the whole register, whatever size that register might be
+	void broadcasti128(const XYm& reg, const Xbyak::Address& mem);
+	/// Broadcast a floating-point variable stored in GSScanlineLocalData to the whole register
+	/// On YMM registers this will be a broadcast from a 32-bit value
+	/// On XMM registers this will be a load of a full 128-bit value, with the broadcast happening before storing to the local data
+	void broadcastssLocal(const XYm& reg, const Xbyak::Address& mem);
+	/// Broadcast a qword variable stored in GSScanlineLocalData to the whole register
+	/// On YMM registers this will be a broadcast from a 64-bit value
+	/// On XMM registers this will be a load of a full 128-bit value, with the broadcast happening before storing to the local data
+	void pbroadcastqLocal(const XYm& reg, const Xbyak::Address& mem);
+	/// Broadcast a dword variable stored in GSScanlineLocalData to the whole register
+	/// On YMM registers this will be a broadcast from a 32-bit value
+	/// On XMM registers this will be a load of a full 128-bit value, with the broadcast happening before storing to the local data
+	void pbroadcastdLocal(const XYm& reg, const Xbyak::Address& mem);
+	/// Broadcast a word variable stored in GSScanlineLocalData to the whole register
+	/// On YMM registers this will be a broadcast from a 16-bit value
+	/// On XMM registers this will be a load of a full 128-bit value, with the broadcast happening before storing to the local data
+	void pbroadcastwLocal(const XYm& reg, const Xbyak::Address& mem);
+	/// Broadcast a 32-bit GPR to a vector register
+	void broadcastGPRToVec(const XYm& vec, const Xbyak::Reg32& gpr);
+	void modulate16(const XYm& a, const Xbyak::Operand& f, uint8 shift);
+	void lerp16(const XYm& a, const XYm& b, const XYm& f, uint8 shift);
+	void lerp16_4(const XYm& a, const XYm& b, const XYm& f);
+	void mix16(const XYm& a, const XYm& b, const XYm& temp);
+	void clamp16(const XYm& a, const XYm& temp);
+	void alltrue(const XYm& test);
+	void blend(const XYm& a, const XYm& b, const XYm& mask);
+	void blendr(const XYm& b, const XYm& a, const XYm& mask);
+	void blend8(const XYm& a, const XYm& b);
+	void blend8r(const XYm& b, const XYm& a);
+	void split16_2x8(const XYm& l, const XYm& h, const XYm& src);
+
+	void Init();
+	void Step();
+	void TestZ(const XYm& temp1, const XYm& temp2);
+	void SampleTexture();
+	void SampleTexture_TexelReadHelper(int mip_offset);
+	void Wrap(const XYm& uv);
+	void Wrap(const XYm& uv0, const XYm& uv1);
+	void SampleTextureLOD();
+	void WrapLOD(const XYm& uv);
+	void WrapLOD(const XYm& uv0, const XYm& uv1);
+	void AlphaTFX();
+	void ReadMask();
+	void TestAlpha();
+	void ColorTFX();
+	void Fog();
+	void ReadFrame();
+	void TestDestAlpha();
+	void WriteMask();
+	void WriteZBuf();
+	void AlphaBlend();
+	void WriteFrame();
+	void ReadPixel(const XYm& dst, const XYm& tmp, const AddressReg& addr);
+#if DRAW_SCANLINE_USING_XMM
+	void WritePixel(const XYm& src_, const AddressReg& addr, const Xbyak::Reg8& mask, bool fast, int psm, int fz);
+#else
+	void WritePixel(const XYm& src_, const AddressReg& addr, const Xbyak::Reg32& mask, bool fast, int psm, int fz);
+#endif
+	void WritePixel(const Xmm& src, const AddressReg& addr, uint8 i, uint8 j, int psm);
+	void ReadTexel1(const XYm& dst, const XYm& src, const XYm& tmp1, const XYm& tmp2, int mip_offset);
+	void ReadTexel4(
+		const XYm& d0,   const XYm& d1,
+		const XYm& d2s0, const XYm& d3s1,
+		const XYm& s2,   const XYm& s3,
+		const XYm& tmp1, const XYm& tmp2,
+		int mip_offset);
+	void ReadTexelImpl(
+		const XYm& d0,   const XYm& d1,
+		const XYm& d2s0, const XYm& d3s1,
+		const XYm& s2,   const XYm& s3,
+		const XYm& tmp1, const XYm& tmp2,
+		int pixels,      int mip_offset);
+	void ReadTexelImplLoadTexLOD(int lod, int mip_offset);
+	void ReadTexelImplYmm(
+		const Ymm& d0,   const Ymm& d1,
+		const Ymm& d2s0, const Ymm& d3s1,
+		const Ymm& s2,   const Ymm& s3,
+		const Ymm& tmp,
+		int pixels,      int mip_offset);
+	void ReadTexelImplSSE4(
+		const Xmm& d0,   const Xmm& d1,
+		const Xmm& d2s0, const Xmm& d3s1,
+		const Xmm& s2,   const Xmm& s3,
+		int pixels,      int mip_offset);
+	void ReadTexelImpl(const Xmm& dst, const Xmm& addr, uint8 i, bool texInA3, bool preserveDst);
+};

pcsx2/GS/Renderers/SW/GSDrawScanlineCodeGenerator.cpp

@@ -15,17 +15,8 @@
 
 #include "PrecompiledHeader.h"
 #include "GSDrawScanlineCodeGenerator.h"
+#include "GSDrawScanlineCodeGenerator.all.h"
 
-#if _M_SSE >= 0x501
-#else
-void GSDrawScanlineCodeGenerator::Generate()
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-		Generate_AVX();
-	else
-		Generate_SSE();
-}
-#endif
 
 GSDrawScanlineCodeGenerator::GSDrawScanlineCodeGenerator(void* param, uint64 key, void* code, size_t maxsize)
 	: GSCodeGenerator(code, maxsize)
@@ -37,227 +28,5 @@ GSDrawScanlineCodeGenerator::GSDrawScanlineCodeGenerator(void* param, uint64 key
 	if (m_sel.breakpoint)
 		db(0xCC);
 
-	try
-	{
-		Generate();
-	}
-	catch (std::exception& e)
-	{
-		fprintf(stderr, "ERR:GSDrawScanlineCodeGenerator %s\n", e.what());
-	}
-}
-
-void GSDrawScanlineCodeGenerator::modulate16(const Xmm& a, const Operand& f, uint8 shift)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		if (shift == 0)
-		{
-			vpmulhrsw(a, f);
-		}
-		else
-		{
-			vpsllw(a, shift + 1);
-			vpmulhw(a, f);
-		}
-	}
-	else
-	{
-		if (shift == 0 && m_cpu.has(Xbyak::util::Cpu::tSSSE3))
-		{
-			pmulhrsw(a, f);
-		}
-		else
-		{
-			psllw(a, shift + 1);
-			pmulhw(a, f);
-		}
-	}
-}
-
-void GSDrawScanlineCodeGenerator::lerp16(const Xmm& a, const Xmm& b, const Xmm& f, uint8 shift)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		vpsubw(a, b);
-		modulate16(a, f, shift);
-		vpaddw(a, b);
-	}
-	else
-	{
-		psubw(a, b);
-		modulate16(a, f, shift);
-		paddw(a, b);
-	}
-}
-
-void GSDrawScanlineCodeGenerator::lerp16_4(const Xmm& a, const Xmm& b, const Xmm& f)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		vpsubw(a, b);
-		vpmullw(a, f);
-		vpsraw(a, 4);
-		vpaddw(a, b);
-	}
-	else
-	{
-		psubw(a, b);
-		pmullw(a, f);
-		psraw(a, 4);
-		paddw(a, b);
-	}
-}
-
-void GSDrawScanlineCodeGenerator::mix16(const Xmm& a, const Xmm& b, const Xmm& temp)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		vpblendw(a, b, 0xaa);
-	}
-	else
-	{
-		pblendw(a, b, 0xaa);
-	}
-}
-
-void GSDrawScanlineCodeGenerator::clamp16(const Xmm& a, const Xmm& temp)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		vpackuswb(a, a);
-
-#if _M_SSE >= 0x501
-		// Greg: why ?
-		if (m_cpu.has(Xbyak::util::Cpu::tAVX2))
-		{
-			ASSERT(a.isYMM());
-			vpermq(Ymm(a.getIdx()), Ymm(a.getIdx()), _MM_SHUFFLE(3, 1, 2, 0)); // this sucks
-		}
-#endif
-
-		vpmovzxbw(a, a);
-	}
-	else
-	{
-		packuswb(a, a);
-		pmovzxbw(a, a);
-	}
-}
-
-void GSDrawScanlineCodeGenerator::alltrue(const Xmm& test)
-{
-	uint32 mask = test.isYMM() ? 0xffffffff : 0xffff;
-
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		vpmovmskb(eax, test);
-		cmp(eax, mask);
-		je("step", T_NEAR);
-	}
-	else
-	{
-		pmovmskb(eax, test);
-		cmp(eax, mask);
-		je("step", T_NEAR);
-	}
-}
-
-void GSDrawScanlineCodeGenerator::blend(const Xmm& a, const Xmm& b, const Xmm& mask)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		vpand(b, mask);
-		vpandn(mask, a);
-		vpor(a, b, mask);
-	}
-	else
-	{
-		pand(b, mask);
-		pandn(mask, a);
-		por(b, mask);
-		movdqa(a, b);
-	}
-}
-
-void GSDrawScanlineCodeGenerator::blendr(const Xmm& b, const Xmm& a, const Xmm& mask)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		vpand(b, mask);
-		vpandn(mask, a);
-		vpor(b, mask);
-	}
-	else
-	{
-		pand(b, mask);
-		pandn(mask, a);
-		por(b, mask);
-	}
-}
-
-void GSDrawScanlineCodeGenerator::blend8(const Xmm& a, const Xmm& b)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-		vpblendvb(a, a, b, xmm0);
-	else
-		pblendvb(a, b);
-}
-
-void GSDrawScanlineCodeGenerator::blend8r(const Xmm& b, const Xmm& a)
-{
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		vpblendvb(b, a, b, xmm0);
-	}
-	else
-	{
-		pblendvb(a, b);
-		movdqa(b, a);
-	}
-}
-
-void GSDrawScanlineCodeGenerator::split16_2x8(const Xmm& l, const Xmm& h, const Xmm& src)
-{
-	// l = src & 0xFF; (1 left shift + 1 right shift)
-	// h = (src >> 8) & 0xFF; (1 right shift)
-
-	if (m_cpu.has(Xbyak::util::Cpu::tAVX))
-	{
-		if (src == h)
-		{
-			vpsllw(l, src, 8);
-			vpsrlw(h, 8);
-		}
-		else if (src == l)
-		{
-			vpsrlw(h, src, 8);
-			vpsllw(l, 8);
-		}
-		else
-		{
-			vpsllw(l, src, 8);
-			vpsrlw(h, src, 8);
-		}
-		vpsrlw(l, 8);
-	}
-	else
-	{
-		if (src == h)
-		{
-			movdqa(l, src);
-		}
-		else if (src == l)
-		{
-			movdqa(h, src);
-		}
-		else
-		{
-			movdqa(l, src);
-			movdqa(h, src);
-		}
-		psllw(l, 8);
-		psrlw(l, 8);
-		psrlw(h, 8);
-	}
+	GSDrawScanlineCodeGenerator2(this, CPUInfo(m_cpu), (void*)&m_local, m_sel.key).Generate();
 }

pcsx2/GS/Renderers/SW/GSDrawScanlineCodeGenerator.h

@@ -27,117 +27,12 @@
 
 class GSDrawScanlineCodeGenerator : public GSCodeGenerator
 {
-	typedef Xbyak::Ymm Ymm;
-	typedef Xbyak::Xmm Xmm;
-	typedef Xbyak::Reg8 Reg8;
-	typedef Xbyak::Operand Operand;
-
 	void operator=(const GSDrawScanlineCodeGenerator&);
 
 	GSScanlineSelector m_sel;
 	GSScanlineLocalData& m_local;
 	bool m_rip;
 
-	void Generate();
-
-#if _M_SSE >= 0x501
-
-	void Init();
-	void Step();
-	void TestZ(const Ymm& temp1, const Ymm& temp2);
-	void SampleTexture();
-	void Wrap(const Ymm& uv0);
-	void Wrap(const Ymm& uv0, const Ymm& uv1);
-	void SampleTextureLOD();
-	void WrapLOD(const Ymm& uv0);
-	void WrapLOD(const Ymm& uv0, const Ymm& uv1);
-	void AlphaTFX();
-	void ReadMask();
-	void TestAlpha();
-	void ColorTFX();
-	void Fog();
-	void ReadFrame();
-	void TestDestAlpha();
-	void WriteMask();
-	void WriteZBuf();
-	void AlphaBlend();
-	void WriteFrame();
-	void ReadPixel(const Ymm& dst, const Ymm& temp, const RegLong& addr);
-	void WritePixel(const Ymm& src, const Ymm& temp, const RegLong& addr, const Xbyak::Reg32& mask, bool fast, int psm, int fz);
-	void WritePixel(const Xmm& src, const RegLong& addr, uint8 i, uint8 j, int psm);
-	void ReadTexel(int pixels, int mip_offset = 0);
-	void ReadTexel(const Ymm& dst, const Ymm& addr, uint8 i);
-
-#else
-
-	void Generate_SSE();
-	void Init_SSE();
-	void Step_SSE();
-	void TestZ_SSE(const Xmm& temp1, const Xmm& temp2);
-	void SampleTexture_SSE();
-	void Wrap_SSE(const Xmm& uv0);
-	void Wrap_SSE(const Xmm& uv0, const Xmm& uv1);
-	void SampleTextureLOD_SSE();
-	void WrapLOD_SSE(const Xmm& uv0);
-	void WrapLOD_SSE(const Xmm& uv0, const Xmm& uv1);
-	void AlphaTFX_SSE();
-	void ReadMask_SSE();
-	void TestAlpha_SSE();
-	void ColorTFX_SSE();
-	void Fog_SSE();
-	void ReadFrame_SSE();
-	void TestDestAlpha_SSE();
-	void WriteMask_SSE();
-	void WriteZBuf_SSE();
-	void AlphaBlend_SSE();
-	void WriteFrame_SSE();
-	void ReadPixel_SSE(const Xmm& dst, const RegLong& addr);
-	void WritePixel_SSE(const Xmm& src, const RegLong& addr, const Reg8& mask, bool fast, int psm, int fz);
-	void WritePixel_SSE(const Xmm& src, const RegLong& addr, uint8 i, int psm);
-	void ReadTexel_SSE(int pixels, int mip_offset = 0);
-	void ReadTexel_SSE(const Xmm& dst, const Xmm& addr, uint8 i);
-
-	void Generate_AVX();
-	void Init_AVX();
-	void Step_AVX();
-	void TestZ_AVX(const Xmm& temp1, const Xmm& temp2);
-	void SampleTexture_AVX();
-	void Wrap_AVX(const Xmm& uv0);
-	void Wrap_AVX(const Xmm& uv0, const Xmm& uv1);
-	void SampleTextureLOD_AVX();
-	void WrapLOD_AVX(const Xmm& uv0);
-	void WrapLOD_AVX(const Xmm& uv0, const Xmm& uv1);
-	void AlphaTFX_AVX();
-	void ReadMask_AVX();
-	void TestAlpha_AVX();
-	void ColorTFX_AVX();
-	void Fog_AVX();
-	void ReadFrame_AVX();
-	void TestDestAlpha_AVX();
-	void WriteMask_AVX();
-	void WriteZBuf_AVX();
-	void AlphaBlend_AVX();
-	void WriteFrame_AVX();
-	void ReadPixel_AVX(const Xmm& dst, const RegLong& addr);
-	void WritePixel_AVX(const Xmm& src, const RegLong& addr, const Reg8& mask, bool fast, int psm, int fz);
-	void WritePixel_AVX(const Xmm& src, const RegLong& addr, uint8 i, int psm);
-	void ReadTexel_AVX(int pixels, int mip_offset = 0);
-	void ReadTexel_AVX(const Xmm& dst, const Xmm& addr, uint8 i);
-
-#endif
-
-	void modulate16(const Xmm& a, const Operand& f, uint8 shift);
-	void lerp16(const Xmm& a, const Xmm& b, const Xmm& f, uint8 shift);
-	void lerp16_4(const Xmm& a, const Xmm& b, const Xmm& f);
-	void mix16(const Xmm& a, const Xmm& b, const Xmm& temp);
-	void clamp16(const Xmm& a, const Xmm& temp);
-	void alltrue(const Xmm& test);
-	void blend(const Xmm& a, const Xmm& b, const Xmm& mask);
-	void blendr(const Xmm& b, const Xmm& a, const Xmm& mask);
-	void blend8(const Xmm& a, const Xmm& b);
-	void blend8r(const Xmm& b, const Xmm& a);
-	void split16_2x8(const Xmm& l, const Xmm& h, const Xmm& src);
-
 public:
 	GSDrawScanlineCodeGenerator(void* param, uint64 key, void* code, size_t maxsize);
 };

pcsx2/GS/Renderers/SW/GSDrawScanlineCodeGenerator.x64.cpp

@@ -1,118 +0,0 @@
-/*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2021 PCSX2 Dev Team
- *
- *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
- *  of the GNU Lesser General Public License as published by the Free Software Found-
- *  ation, either version 3 of the License, or (at your option) any later version.
- *
- *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *  PURPOSE.  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with PCSX2.
- *  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PrecompiledHeader.h"
-#include "GSDrawScanlineCodeGenerator.h"
-
-#if _M_SSE < 0x501 && (defined(_M_AMD64) || defined(_WIN64))
-
-// It is useless to port the code to SSEx, better use the faster 32 bits version instead
-void GSDrawScanlineCodeGenerator::Generate_SSE()
-{
-	// Avoid a crash if someone want to use it
-	ret();
-}
-
-void GSDrawScanlineCodeGenerator::Init_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::Step_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::TestZ_SSE(const Xmm& temp1, const Xmm& temp2)
-{
-}
-
-void GSDrawScanlineCodeGenerator::SampleTexture_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::Wrap_SSE(const Xmm& uv)
-{
-}
-
-void GSDrawScanlineCodeGenerator::Wrap_SSE(const Xmm& uv0, const Xmm& uv1)
-{
-}
-
-void GSDrawScanlineCodeGenerator::AlphaTFX_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::ReadMask_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::TestAlpha_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::ColorTFX_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::Fog_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::ReadFrame_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::TestDestAlpha_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::WriteMask_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::WriteZBuf_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::AlphaBlend_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::WriteFrame_SSE()
-{
-}
-
-void GSDrawScanlineCodeGenerator::ReadPixel_SSE(const Xmm& dst, const RegLong& addr)
-{
-}
-
-void GSDrawScanlineCodeGenerator::WritePixel_SSE(const Xmm& src, const RegLong& addr, const Reg8& mask, bool fast, int psm, int fz)
-{
-}
-
-//static const int s_offsets[4] = {0, 2, 8, 10};
-
-void GSDrawScanlineCodeGenerator::WritePixel_SSE(const Xmm& src, const RegLong& addr, uint8 i, int psm)
-{
-}
-
-void GSDrawScanlineCodeGenerator::ReadTexel_SSE(int pixels, int mip_offset)
-{
-}
-
-void GSDrawScanlineCodeGenerator::ReadTexel_SSE(const Xmm& dst, const Xmm& addr, uint8 i)
-{
-}
-
-#endif

pcsx2/GS/Renderers/SW/GSNewCodeGenerator.cpp

@@ -13,26 +13,5 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#pragma once
-
-using namespace Xbyak;
-
-#ifdef _M_AMD64
-// Yeah let use mips naming ;)
-	#ifdef _WIN64
-		#define a0 rcx
-		#define a1 rdx
-		#define a2 r8
-		#define a3 r9
-		#define t0 rdi
-		#define t1 rsi
-	#else
-		#define a0 rdi
-		#define a1 rsi
-		#define a2 rdx
-		#define a3 rcx
-		#define t0 r8
-		#define t1 r9
-	#endif
-#endif
-
+#include "PrecompiledHeader.h"
+#include "GSNewCodeGenerator.h"

pcsx2/GS/Renderers/SW/GSNewCodeGenerator.h

@@ -0,0 +1,489 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021 PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "GS/GS_types.h"
+#include "xbyak/xbyak.h"
+#include "xbyak/xbyak_util.h"
+
+namespace SSEVersion
+{
+	enum SSEVersion
+	{
+		AVX2  = 0x501,
+		AVX   = 0x500,
+		SSE41 = 0x401,
+	};
+}
+
+/// Similar to Xbyak::util::cpu but more open to us putting in extra flags (e.g. "vpgatherdd is fast"), as well as making it easier to test other configurations by artifically limiting features
+struct CPUInfo
+{
+	bool hasFMA = false;
+	SSEVersion::SSEVersion sseVersion = SSEVersion::SSE41;
+
+	CPUInfo() = default;
+	CPUInfo(const Xbyak::util::Cpu& cpu)
+	{
+		auto version = SSEVersion::SSE41;
+		if (cpu.has(cpu.tAVX))
+			version = SSEVersion::AVX;
+		if (cpu.has(cpu.tAVX2))
+			version = SSEVersion::AVX2;
+
+		hasFMA = cpu.has(cpu.tFMA);
+		sseVersion = version;
+	}
+};
+
+/// Code generator that automatically selects between SSE and AVX, x86 and x64 so you don't have to
+/// Should make combined SSE and AVX codegen much easier
+class GSNewCodeGenerator
+{
+public:
+	using Address = Xbyak::Address;
+	using Label = Xbyak::Label;
+	using Operand = Xbyak::Operand;
+	using Reg32e = Xbyak::Reg32e;
+	using Reg32 = Xbyak::Reg32;
+	using Reg16 = Xbyak::Reg16;
+	using Reg8 = Xbyak::Reg8;
+	using Reg = Xbyak::Reg;
+	using Xmm = Xbyak::Xmm;
+	using Ymm = Xbyak::Ymm;
+	using Zmm = Xbyak::Zmm;
+
+	class Error : public std::exception
+	{
+	public:
+		enum Value
+		{
+			ERR_64_BIT_REG_IN_32,
+			ERR_64_INSTR_IN_32,
+			ERR_SSE_INSTR_IN_AVX,
+			ERR_AVX_INSTR_IN_SSE,
+		};
+
+		Value value;
+
+		Error(Value value) : value(value) {}
+
+		const char* what() const noexcept
+		{
+			static const char* tbl[] = {
+				"used 64-bit register in 32-bit code",
+				"used 64-bit only instruction in 32-bit code",
+				"used SSE instruction in AVX code",
+				"used AVX instruction in SSE code",
+			};
+			if (static_cast<uint32>(value) < (sizeof(tbl) / sizeof(*tbl)))
+			{
+				return tbl[value];
+			}
+			else
+			{
+				return "GSNewCodeGenerator Unknown Error";
+			}
+		}
+	};
+
+private:
+	/// Make sure the register is okay to use
+	void validateRegister(const Operand& op)
+	{
+		if (is64)
+			return;
+		if (op.isREG() && (op.isExtIdx() || op.isExt8bit()))
+			throw Error(Error::ERR_64_BIT_REG_IN_32);
+		if (op.isMEM())
+		{
+			auto e = static_cast<const Address&>(op).getRegExp();
+			validateRegister(e.getIndex());
+			validateRegister(e.getBase());
+		}
+	}
+	/// For easier macro-ing
+	void validateRegister(int imm)
+	{
+	}
+
+	void require64()
+	{
+		if (!is64)
+			throw Error(Error::ERR_64_INSTR_IN_32);
+	}
+	void requireAVX()
+	{
+		if (!hasAVX)
+			throw Error(Error::ERR_AVX_INSTR_IN_SSE);
+	}
+
+public:
+	Xbyak::CodeGenerator& actual;
+
+#if defined(_M_X86_64)
+	constexpr static bool is32 = false;
+	constexpr static bool is64 = true;
+	using AddressReg = Xbyak::Reg64;
+	using RipType = Xbyak::RegRip;
+
+	template <typename T32, typename T64>
+	struct Choose3264 { using type = T64; };
+
+	template <typename T32, typename T64>
+	static T64 choose3264(T32 t32, T64 t64) { return t64; }
+#else
+	constexpr static bool is32 = true;
+	constexpr static bool is64 = false;
+	using AddressReg = Xbyak::Reg32;
+	using RipType = int;
+
+	template <typename T32, typename T64>
+	struct Choose3264 { using type = T32; };
+
+	template <typename T32, typename T64>
+	static T32 choose3264(T32 t32, T64 t64) { return t32; }
+#endif
+
+	const bool hasAVX, hasAVX2, hasFMA;
+
+	const Xmm xmm0{0}, xmm1{1}, xmm2{2}, xmm3{3}, xmm4{4}, xmm5{5}, xmm6{6}, xmm7{7}, xmm8{8}, xmm9{9}, xmm10{10}, xmm11{11}, xmm12{12}, xmm13{13}, xmm14{14}, xmm15{15};
+	const Ymm ymm0{0}, ymm1{1}, ymm2{2}, ymm3{3}, ymm4{4}, ymm5{5}, ymm6{6}, ymm7{7}, ymm8{8}, ymm9{9}, ymm10{10}, ymm11{11}, ymm12{12}, ymm13{13}, ymm14{14}, ymm15{15};
+	const AddressReg rax{0}, rcx{1}, rdx{2}, rbx{3}, rsp{4}, rbp{5}, rsi{6}, rdi{7}, r8{8},  r9{9},  r10{10},  r11{11},  r12{12},  r13{13},  r14{14},  r15{15};
+	const Reg32      eax{0}, ecx{1}, edx{2}, ebx{3}, esp{4}, ebp{5}, esi{6}, edi{7}, r8d{8}, r9d{9}, r10d{10}, r11d{11}, r12d{12}, r13d{13}, r14d{14}, r15d{15};
+	const Reg16       ax{0},  cx{1},  dx{2},  bx{3},  sp{4},  bp{5},  si{6},  di{7};
+	const Reg8        al{0},  cl{1},  dl{2},  bl{3},  ah{4},  ch{5},  dh{6},  bh{7};
+
+	const RipType rip{};
+	const Xbyak::AddressFrame ptr{0}, byte{8}, word{16}, dword{32}, qword{64}, xword{128}, yword{256}, zword{512};
+
+	GSNewCodeGenerator(Xbyak::CodeGenerator* actual, CPUInfo cpu)
+		: actual(*actual)
+		, hasAVX(cpu.sseVersion >= SSEVersion::AVX)
+		, hasAVX2(cpu.sseVersion >= SSEVersion::AVX2)
+		, hasFMA(cpu.hasFMA)
+	{
+	}
+
+
+// ------------ Forwarding instructions ------------
+// Note: Only instructions used by codegen were added here, so if you're modifying codegen, you may need to add instructions here
+
+// For instructions available in SSE and AVX, functions with the SSE name and arguments that forward to SSE or AVX depending on the target, as well as functions with the AVX name and arguments that forward to the AVX version or assert on SSE
+
+// ARGS_* macros are provided for shorter argument lists.  The following single-letter abbreviations are used: X=Xmm, Y=Ymm, O=Operand, A=Address, I=Immediate
+// FORWARD(argcount, category, instrname, argtypes...) forwards an instruction.  The following categories are available:
+//   BASE:    non-SSE
+//   SSE:     available on SSE and v-prefixed on AVX
+//   SSEONLY: available only on SSE (exception on AVX)
+//   AVX:     available only on AVX (exception on SSE)
+//   AVX2:    available only on AVX2 (exception on AVX/SSE)
+//   FMA:     available only with FMA
+// SFORWARD forwards an SSE-AVX pair where the AVX variant takes the same number of registers (e.g. pshufd dst, src + vpshufd dst, src)
+// AFORWARD forwards an SSE-AVX pair where the AVX variant takes an extra destination register (e.g. shufps dst, src + vshufps dst, src, src)
+
+// Implementation details:
+// ACTUAL_FORWARD_*: Actually forward the function of the given type
+// FORWARD#: First validates the arguments (e.g. make sure you're not passing registers over 7 on x86), then forwards to an ACTUAL_FORWARD_*
+
+// Big thanks to https://stackoverflow.com/a/24028231 for helping me figure out how to work around MSVC's terrible macro expander
+// Of course GCC/Clang don't like the workaround so enjoy the ifdefs
+#define EXPAND_ARGS(macro, args) macro args
+
+#define ACTUAL_FORWARD_BASE(name, ...) \
+	actual.name(__VA_ARGS__);
+
+#define ACTUAL_FORWARD_SSE(name, ...) \
+	if (hasAVX) \
+		actual.v##name(__VA_ARGS__); \
+	else \
+		actual.name(__VA_ARGS__);
+
+#define ACTUAL_FORWARD_SSEONLY(name, ...) \
+	if (hasAVX) \
+		throw Error(Error::ERR_SSE_INSTR_IN_AVX); \
+	else \
+		actual.name(__VA_ARGS__);
+
+#define ACTUAL_FORWARD_AVX(name, ...) \
+	if (hasAVX) \
+		actual.name(__VA_ARGS__); \
+	else \
+		throw Error(Error::ERR_AVX_INSTR_IN_SSE);
+
+#define ACTUAL_FORWARD_AVX2(name, ...) \
+	if (hasAVX2) \
+		actual.name(__VA_ARGS__); \
+	else \
+		throw Error(Error::ERR_AVX_INSTR_IN_SSE);
+
+#define ACTUAL_FORWARD_FMA(name, ...) \
+	if (hasFMA) \
+		actual.name(__VA_ARGS__); \
+	else \
+		throw Error(Error::ERR_AVX_INSTR_IN_SSE);
+
+#define FORWARD1(category, name, type) \
+	void name(type a) \
+	{ \
+		validateRegister(a); \
+		ACTUAL_FORWARD_##category(name, a) \
+	}
+
+#define FORWARD2(category, name, type1, type2) \
+	void name(type1 a, type2 b) \
+	{ \
+		validateRegister(a); \
+		validateRegister(b); \
+		ACTUAL_FORWARD_##category(name, a, b) \
+	}
+
+#define FORWARD3(category, name, type1, type2, type3) \
+	void name(type1 a, type2 b, type3 c) \
+	{ \
+		validateRegister(a); \
+		validateRegister(b); \
+		validateRegister(c); \
+		ACTUAL_FORWARD_##category(name, a, b, c) \
+	}
+
+#define FORWARD4(category, name, type1, type2, type3, type4) \
+	void name(type1 a, type2 b, type3 c, type4 d) \
+	{ \
+		validateRegister(a); \
+		validateRegister(b); \
+		validateRegister(c); \
+		validateRegister(d); \
+		ACTUAL_FORWARD_##category(name, a, b, c, d) \
+	}
+
+#ifdef __GNUC__
+	#define FORWARD_(argcount, ...) FORWARD##argcount(__VA_ARGS__)
+	// Gets the macro evaluator to evaluate in the right order
+	#define FORWARD(...) FORWARD_(__VA_ARGS__)
+#else
+	#define FORWARD_(argcount, ...) EXPAND_ARGS(FORWARD##argcount, (__VA_ARGS__))
+	// Gets the macro evaluator to evaluate in the right order
+	#define FORWARD(...) EXPAND_ARGS(FORWARD_, (__VA_ARGS__))
+#endif
+
+#define FORWARD_SSE_XMM0(name) \
+	void name(const Xmm& a, const Operand& b) \
+	{ \
+		validateRegister(a); \
+		validateRegister(b); \
+		if (hasAVX) \
+			actual.v##name(a, b, Xmm(0)); \
+		else \
+			actual.name(a, b); \
+	} \
+	FORWARD(4, AVX, v##name, const Xmm&, const Xmm&, const Operand&, const Xmm&)
+
+#define FORWARD_JUMP(name) \
+	void name(const void *addr) { actual.name(addr); } \
+	void name(const Label& label, Xbyak::CodeGenerator::LabelType type = Xbyak::CodeGenerator::T_AUTO) { actual.name(label, type); } \
+	void name(const char *label, Xbyak::CodeGenerator::LabelType type = Xbyak::CodeGenerator::T_AUTO) { actual.name(label, type); }
+
+#define ADD_ONE_2 3
+#define ADD_ONE_3 4
+
+#ifdef __GNUC__
+	#define SFORWARD(argcount, name, ...) FORWARD(argcount, SSE, name, __VA_ARGS__)
+	#define AFORWARD_(argcount, name, arg1, ...) \
+		SFORWARD(argcount, name, arg1, __VA_ARGS__) \
+		FORWARD(ADD_ONE_##argcount, AVX, v##name, arg1, arg1, __VA_ARGS__)
+	// Gets the macro evaluator to evaluate in the right order
+	#define AFORWARD(...) EXPAND_ARGS(AFORWARD_, (__VA_ARGS__))
+#else
+	#define SFORWARD(argcount, name, ...) EXPAND_ARGS(FORWARD, (argcount, SSE, name, __VA_ARGS__))
+	#define AFORWARD_(argcount, name, arg1, ...) \
+		EXPAND_ARGS(SFORWARD, (argcount, name, arg1, __VA_ARGS__)) \
+		EXPAND_ARGS(FORWARD, (ADD_ONE_##argcount, AVX, v##name, arg1, arg1, __VA_ARGS__))
+	// Gets the macro evaluator to evaluate in the right order
+	#define AFORWARD(...) EXPAND_ARGS(AFORWARD_, (__VA_ARGS__))
+#endif
+
+#define FORWARD_OO_OI(name) \
+	FORWARD(2, BASE, name, ARGS_OO) \
+	FORWARD(2, BASE, name, ARGS_OI)
+
+#define ARGS_OI const Operand&, uint32
+#define ARGS_OO const Operand&, const Operand&
+#define ARGS_XI const Xmm&, int
+#define ARGS_XO const Xmm&, const Operand&
+#define ARGS_XOI const Xmm&, const Operand&, uint8
+#define ARGS_XXO const Xmm&, const Xmm&, const Operand&
+
+// For instructions that are ifdef'd out without XBYAK64
+#ifdef XBYAK64
+	#define REQUIRE64(action) require64(); action
+#else
+	#define REQUIRE64(action) require64()
+#endif
+
+	const uint8 *getCurr() { return actual.getCurr(); }
+	void align(int x = 16) { return actual.align(x); }
+	void db(int code) { actual.db(code); }
+	void L(const std::string& label) { actual.L(label); }
+
+	void cdqe() { REQUIRE64(actual.cdqe()); }
+	void ret(int imm = 0) { actual.ret(imm); }
+	void vzeroupper() { requireAVX(); actual.vzeroupper(); }
+	void vzeroall() { requireAVX(); actual.vzeroall(); }
+
+	FORWARD_OO_OI(add)
+	FORWARD_OO_OI(and)
+	FORWARD_OO_OI(cmp)
+	FORWARD_OO_OI(or)
+	FORWARD_OO_OI(sub)
+	FORWARD_OO_OI(xor)
+	FORWARD(2, BASE, lea,   const Reg&, const Address&)
+	FORWARD(2, BASE, mov,   const Operand&, size_t)
+	FORWARD(2, BASE, mov,   ARGS_OO)
+	FORWARD(2, BASE, movzx, const Reg&, const Operand&)
+	FORWARD(1, BASE, not,   const Operand&)
+	FORWARD(1, BASE, pop,   const Operand&)
+	FORWARD(1, BASE, push,  const Operand&)
+	FORWARD(2, BASE, sar,   const Operand&, const Reg8&)
+	FORWARD(2, BASE, sar,   ARGS_OI)
+	FORWARD(2, BASE, shl,   const Operand&, const Reg8&)
+	FORWARD(2, BASE, shl,   ARGS_OI)
+	FORWARD(2, BASE, shr,   const Operand&, const Reg8&)
+	FORWARD(2, BASE, shr,   ARGS_OI)
+	FORWARD(2, BASE, test,  const Operand&, const Reg&);
+	FORWARD(2, BASE, test,  ARGS_OI);
+
+	FORWARD_JUMP(je)
+	FORWARD_JUMP(jle)
+	FORWARD_JUMP(jmp)
+
+	AFORWARD(2, addps,     ARGS_XO)
+	SFORWARD(2, cvtdq2ps,  ARGS_XO)
+	SFORWARD(2, cvtps2dq,  ARGS_XO)
+	SFORWARD(2, cvttps2dq, ARGS_XO)
+	SFORWARD(3, extractps, const Operand&, const Xmm&, uint8)
+	AFORWARD(2, maxps,     ARGS_XO)
+	AFORWARD(2, minps,     ARGS_XO)
+	SFORWARD(2, movaps,    ARGS_XO)
+	SFORWARD(2, movaps,    const Address&, const Xmm&)
+	SFORWARD(2, movd,      const Address&, const Xmm&)
+	SFORWARD(2, movd,      const Reg32&, const Xmm&)
+	SFORWARD(2, movd,      const Xmm&, const Address&)
+	SFORWARD(2, movd,      const Xmm&, const Reg32&)
+	SFORWARD(2, movdqa,    ARGS_XO)
+	SFORWARD(2, movdqa,    const Address&, const Xmm&)
+	SFORWARD(2, movhps,    ARGS_XO)
+	SFORWARD(2, movhps,    const Address&, const Xmm&)
+	SFORWARD(2, movq,      const Address&, const Xmm&)
+	SFORWARD(2, movq,      const Xmm&, const Address&)
+	AFORWARD(2, mulps,     ARGS_XO)
+	AFORWARD(2, orps,      ARGS_XO)
+	AFORWARD(2, packssdw,  ARGS_XO)
+	AFORWARD(2, packusdw,  ARGS_XO)
+	AFORWARD(2, packuswb,  ARGS_XO)
+	AFORWARD(2, paddd,     ARGS_XO)
+	AFORWARD(2, paddusb,   ARGS_XO)
+	AFORWARD(2, paddw,     ARGS_XO)
+	AFORWARD(2, pand,      ARGS_XO)
+	AFORWARD(2, pandn,     ARGS_XO)
+	AFORWARD(3, pblendw,   ARGS_XOI)
+	AFORWARD(2, pcmpeqd,   ARGS_XO)
+	AFORWARD(2, pcmpeqw,   ARGS_XO)
+	AFORWARD(2, pcmpgtd,   ARGS_XO)
+	SFORWARD(3, pextrd,    const Operand&, const Xmm&, uint8)
+	SFORWARD(3, pextrw,    const Operand&, const Xmm&, uint8)
+	AFORWARD(3, pinsrd,    ARGS_XOI)
+	AFORWARD(2, pmaxsw,    ARGS_XO)
+	AFORWARD(2, pminsd,    ARGS_XO)
+	AFORWARD(2, pminsw,    ARGS_XO)
+	SFORWARD(2, pmovsxbd,  ARGS_XO)
+	SFORWARD(2, pmovmskb,  const Reg32e&, const Xmm&)
+	SFORWARD(2, pmovzxbw,  ARGS_XO)
+	AFORWARD(2, pmulhrsw,  ARGS_XO)
+	AFORWARD(2, pmulhw,    ARGS_XO)
+	AFORWARD(2, pmullw,    ARGS_XO)
+	AFORWARD(2, por,       ARGS_XO)
+	SFORWARD(3, pshufd,    ARGS_XOI)
+	SFORWARD(3, pshufhw,   ARGS_XOI)
+	SFORWARD(3, pshuflw,   ARGS_XOI)
+	AFORWARD(2, pslld,     ARGS_XI)
+	AFORWARD(2, psllw,     ARGS_XI)
+	AFORWARD(2, psrad,     ARGS_XI)
+	AFORWARD(2, psrad,     ARGS_XO)
+	AFORWARD(2, psraw,     ARGS_XI)
+	AFORWARD(2, psrld,     ARGS_XI)
+	AFORWARD(2, psrldq,    ARGS_XI)
+	AFORWARD(2, psrlw,     ARGS_XI)
+	AFORWARD(2, psrlw,     ARGS_XO)
+	AFORWARD(2, psubd,     ARGS_XO)
+	AFORWARD(2, psubw,     ARGS_XO)
+	AFORWARD(2, punpckhdq, ARGS_XO)
+	AFORWARD(2, punpckhwd, ARGS_XO)
+	AFORWARD(2, punpcklbw, ARGS_XO)
+	AFORWARD(2, punpckldq, ARGS_XO)
+	AFORWARD(2, punpcklqdq,ARGS_XO)
+	AFORWARD(2, punpcklwd, ARGS_XO)
+	AFORWARD(2, pxor,      ARGS_XO)
+	SFORWARD(2, rcpps,     ARGS_XO)
+	AFORWARD(3, shufps,    ARGS_XOI)
+	AFORWARD(2, subps,     ARGS_XO)
+	AFORWARD(2, xorps,     ARGS_XO)
+
+	FORWARD_SSE_XMM0(pblendvb)
+
+	FORWARD(2, AVX,  vbroadcastss,   ARGS_XO)
+	FORWARD(2, AVX2, vbroadcasti128, const Ymm&, const Address&)
+	FORWARD(2, AVX,  vbroadcastf128, const Ymm&, const Address&)
+	FORWARD(3, FMA,  vfmadd213ps,    ARGS_XXO)
+	FORWARD(3, AVX2, vextracti128,   const Operand&, const Ymm&, uint8)
+	FORWARD(4, AVX2, vinserti128,    const Ymm&, const Ymm&, const Operand&, uint8);
+	FORWARD(2, AVX2, vpbroadcastd,   ARGS_XO)
+	FORWARD(2, AVX2, vpbroadcastq,   ARGS_XO)
+	FORWARD(2, AVX2, vpbroadcastw,   ARGS_XO)
+	FORWARD(3, AVX2, vpermq,         const Ymm&, const Operand&, uint8)
+	FORWARD(3, AVX2, vpgatherdd,     const Xmm&, const Address&, const Xmm&);
+	FORWARD(3, AVX2, vpsravd,        ARGS_XXO)
+	FORWARD(3, AVX2, vpsrlvd,        ARGS_XXO)
+
+#undef REQUIRE64
+#undef ARGS_OI
+#undef ARGS_OO
+#undef ARGS_XI
+#undef ARGS_XO
+#undef ARGS_XOI
+#undef ARGS_XXO
+#undef FORWARD_OO_OI
+#undef AFORWARD
+#undef AFORWARD_
+#undef SFORWARD
+#undef ADD_ONE_2
+#undef ADD_ONE_3
+#undef FORWARD_SSE_XMM0
+#undef FORWARD_JUMP
+#undef FORWARD
+#undef FORWARD_
+#undef FORWARD4
+#undef FORWARD3
+#undef FORWARD2
+#undef FORWARD1
+#undef ACTUAL_FORWARD_FMA
+#undef ACTUAL_FORWARD_AVX2
+#undef ACTUAL_FORWARD_AVX
+#undef ACTUAL_FORWARD_SSE
+#undef ACTUAL_FORWARD_SSEONLY
+#undef ACTUAL_FORWARD_BASE
+#undef EXPAND_ARGS
+};

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.all.cpp

@@ -0,0 +1,566 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021 PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "PrecompiledHeader.h"
+#include "GS/GS_types.h"
+#include "GSSetupPrimCodeGenerator.all.h"
+#include "GSVertexSW.h"
+
+using namespace Xbyak;
+
+#define _rip_local(field) ((is32 || m_rip) ? ptr[rip + (char*)&m_local.field] : ptr[_m_local + OFFSETOF(GSScanlineLocalData, field)])
+
+#define _64_m_local _64_t0
+
+/// On AVX, does a v-prefixed separate destination operation
+/// On SSE, moves src1 into dst using movdqa, then does the operation
+#define THREEARG(operation, dst, src1, ...) \
+	do \
+	{ \
+		if (hasAVX) \
+		{ \
+			v##operation(dst, src1, __VA_ARGS__); \
+		} \
+		else \
+		{ \
+			movdqa(dst, src1); \
+			operation(dst, __VA_ARGS__); \
+		} \
+	} while (0)
+
+#if _M_SSE >= 0x501
+	#define _rip_local_d(x) _rip_local(d8.x)
+	#define _rip_local_d_p(x) _rip_local_d(p.x)
+#else
+	#define _rip_local_d(x) _rip_local(d4.x)
+	#define _rip_local_d_p(x) _rip_local_d(x)
+#endif
+
+GSSetupPrimCodeGenerator2::GSSetupPrimCodeGenerator2(Xbyak::CodeGenerator* base, CPUInfo cpu, void* param, uint64 key)
+	: _parent(base, cpu)
+	, m_local(*(GSScanlineLocalData*)param)
+	, m_rip(false), many_regs(false)
+	// On x86 arg registers are very temporary but on x64 they aren't, so on x86 some registers overlap
+#ifdef _WIN32
+	, _64_vertex(is64 ? rcx : r8)
+	, _index(is64 ? rdx : rcx)
+	, _dscan(is64 ? r8 : rdx)
+	, _64_t0(r9), t1(is64 ? r10 : rcx)
+#else
+	, _64_vertex(is64 ? rdi : r8)
+	, _index(is64 ? rsi : rcx)
+	, _dscan(rdx)
+	, _64_t0(is64 ? rcx : r8), t1(is64 ? r8 : rcx)
+#endif
+	, _m_local(chooseLocal(&m_local, _64_m_local))
+{
+	m_sel.key = key;
+
+	m_en.z = m_sel.zb ? 1 : 0;
+	m_en.f = m_sel.fb && m_sel.fge ? 1 : 0;
+	m_en.t = m_sel.fb && m_sel.tfx != TFX_NONE ? 1 : 0;
+	m_en.c = m_sel.fb && !(m_sel.tfx == TFX_DECAL && m_sel.tcc) ? 1 : 0;
+}
+
+void GSSetupPrimCodeGenerator2::broadcastf128(const XYm& reg, const Address& mem)
+{
+#if SETUP_PRIM_USING_YMM
+	vbroadcastf128(reg, mem);
+#else
+	movaps(reg, mem);
+#endif
+}
+
+void GSSetupPrimCodeGenerator2::Generate()
+{
+	// Technically we just need the delta < 2GB
+	m_rip = (size_t)&m_local < 0x80000000 && (size_t)getCurr() < 0x80000000;
+
+	bool needs_shift = (m_en.z || m_en.f) && m_sel.prim != GS_SPRITE_CLASS || m_en.t || m_en.c && m_sel.iip;
+	many_regs = is64 && isYmm && !m_sel.notest && needs_shift;
+
+#ifdef _WIN64
+	int needs_saving = many_regs ? 6 : m_sel.notest ? 0 : 2;
+	if (needs_saving)
+	{
+		sub(rsp, 8 + 16 * needs_saving);
+		for (int i = 0; i < needs_saving; i++)
+		{
+			movdqa(ptr[rsp + i * 16], Xmm(i + 6));
+		}
+	}
+#endif
+
+	if (is64 && !m_rip)
+		mov(_64_m_local, (size_t)&m_local);
+
+	if (needs_shift)
+	{
+		if (is32)
+			mov(_dscan, ptr[rsp + _32_dscan]);
+
+		if (isXmm)
+			mov(rax, (size_t)g_const->m_shift_128b);
+		else
+			mov(rax, (size_t)g_const->m_shift_256b);
+
+		for (int i = 0; i < (m_sel.notest ? 2 : many_regs ? 9 : 5); i++)
+		{
+			movaps(XYm(3 + i), ptr[rax + i * vecsize]);
+		}
+	}
+
+	if (isXmm)
+		Depth_XMM();
+	else
+		Depth_YMM();
+
+	Texture();
+
+	Color();
+
+#ifdef _WIN64
+	if (needs_saving)
+	{
+		for (int i = 0; i < needs_saving; i++)
+		{
+			movdqa(Xmm(i + 6), ptr[rsp + i * 16]);
+		}
+		add(rsp, 8 + 16 * needs_saving);
+	}
+#endif
+	if (isYmm)
+		vzeroupper();
+	ret();
+}
+
+void GSSetupPrimCodeGenerator2::Depth_XMM()
+{
+	if (!m_en.z && !m_en.f)
+	{
+		return;
+	}
+
+	if (m_sel.prim != GS_SPRITE_CLASS)
+	{
+		// GSVector4 p = dscan.p;
+
+
+		movaps(xmm0, ptr[_dscan + offsetof(GSVertexSW, p)]);
+
+		if (m_en.f)
+		{
+			// GSVector4 df = p.wwww();
+
+			THREEARG(shufps, xmm1, xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
+
+			// m_local.d4.f = GSVector4i(df * 4.0f).xxzzlh();
+
+			THREEARG(mulps, xmm2, xmm1, xmm3);
+			cvttps2dq(xmm2, xmm2);
+			pshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
+			pshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
+			movdqa(_rip_local_d_p(f), xmm2);
+
+			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
+			{
+				// m_local.d[i].f = GSVector4i(df * m_shift[i]).xxzzlh();
+
+				THREEARG(mulps, xmm2, xmm1, XYm(4 + i));
+				cvttps2dq(xmm2, xmm2);
+				pshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
+				pshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
+				movdqa(_rip_local(d[i].f), xmm2);
+			}
+		}
+
+		if (m_en.z)
+		{
+			// GSVector4 dz = p.zzzz();
+
+			shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
+
+			// m_local.d4.z = dz * 4.0f;
+
+			THREEARG(mulps, xmm1, xmm0, xmm3);
+			movdqa(_rip_local_d_p(z), xmm1);
+
+			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
+			{
+				// m_local.d[i].z = dz * m_shift[i];
+
+				THREEARG(mulps, xmm1, xmm0, XYm(4 + i));
+				movdqa(_rip_local(d[i].z), xmm1);
+			}
+		}
+	}
+	else
+	{
+		// GSVector4 p = vertex[index[1]].p;
+
+		if (is32)
+			mov(_index, ptr[rsp + _32_index]);
+		mov(eax, ptr[_index + sizeof(uint32) * 1]);
+		shl(eax, 6); // * sizeof(GSVertexSW)
+		if (is64)
+			add(rax, _64_vertex);
+		else
+			add(rax, ptr[rsp + _32_vertex]);
+
+		if (m_en.f)
+		{
+			// m_local.p.f = GSVector4i(p).zzzzh().zzzz();
+			movaps(xmm0, ptr[rax + offsetof(GSVertexSW, p)]);
+
+			cvttps2dq(xmm1, xmm0);
+			pshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
+			pshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
+			movdqa(_rip_local(p.f), xmm1);
+		}
+
+		if (m_en.z)
+		{
+			// uint32 z is bypassed in t.w
+
+			movdqa(xmm0, ptr[rax + offsetof(GSVertexSW, t)]);
+			pshufd(xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
+			movdqa(_rip_local(p.z), xmm0);
+		}
+	}
+}
+
+void GSSetupPrimCodeGenerator2::Depth_YMM()
+{
+	if (!m_en.z && !m_en.f)
+	{
+		return;
+	}
+
+	if (m_sel.prim != GS_SPRITE_CLASS)
+	{
+		// GSVector4 dp8 = dscan.p * GSVector4::broadcast32(&shift[0]);
+
+		broadcastf128(xym0, ptr[_dscan + offsetof(GSVertexSW, p)]);
+
+		vmulps(ymm1, ymm0, ymm3);
+
+		if (m_en.z)
+		{
+			// m_local.d8.p.z = dp8.extract32<2>();
+
+			extractps(_rip_local_d_p(z), xmm1, 2);
+
+			// GSVector8 dz = GSVector8(dscan.p).zzzz();
+
+			vshufps(ymm2, ymm0, ymm0, _MM_SHUFFLE(2, 2, 2, 2));
+		}
+
+		if (m_en.f)
+		{
+			// m_local.d8.p.f = GSVector4i(dp8).extract32<3>();
+
+			cvtps2dq(ymm1, ymm1);
+			pextrd(_rip_local_d_p(f), xmm1, 3);
+
+			// GSVector8 df = GSVector8(dscan.p).wwww();
+
+			vshufps(ymm1, ymm0, ymm0, _MM_SHUFFLE(3, 3, 3, 3));
+		}
+
+		for (int i = 0; i < (m_sel.notest ? 1 : dsize); i++)
+		{
+			if (m_en.z)
+			{
+				// m_local.d[i].z = dz * shift[1 + i];
+
+				// Save a byte in the encoding for ymm8-11 by swapping with ymm2 (multiplication is communative)
+				if (i < 4 || many_regs)
+					vmulps(ymm0, Ymm(4 + i), ymm2);
+				else
+					vmulps(ymm0, ymm2, ptr[g_const->m_shift_256b[i + 1]]);
+				movaps(_rip_local(d[i].z), ymm0);
+			}
+
+			if (m_en.f)
+			{
+				// m_local.d[i].f = GSVector8i(df * m_shift[i]).xxzzlh();
+
+				if (i < 4 || many_regs)
+					vmulps(ymm0, Ymm(4 + i), ymm1);
+				else
+					vmulps(ymm0, ymm1, ptr[g_const->m_shift_256b[i + 1]]);
+				cvttps2dq(ymm0, ymm0);
+				pshuflw(ymm0, ymm0, _MM_SHUFFLE(2, 2, 0, 0));
+				pshufhw(ymm0, ymm0, _MM_SHUFFLE(2, 2, 0, 0));
+				movdqa(_rip_local(d[i].f), ymm0);
+			}
+		}
+	}
+	else
+	{
+		// GSVector4 p = vertex[index[1]].p;
+
+		if (is32)
+			mov(_index, ptr[rsp + _32_index]);
+		mov(eax, ptr[_index + sizeof(uint32) * 1]);
+		shl(eax, 6); // * sizeof(GSVertexSW)
+		if (is64)
+			add(rax, _64_vertex);
+		else
+			add(rax, ptr[rsp + _32_vertex]);
+
+		if (m_en.f)
+		{
+			// m_local.p.f = GSVector4i(vertex[index[1]].p).extract32<3>();
+
+			movaps(xmm0, ptr[rax + offsetof(GSVertexSW, p)]);
+			cvttps2dq(xmm0, xmm0);
+			pextrd(_rip_local(p.f), xmm0, 3);
+		}
+
+		if (m_en.z)
+		{
+			// m_local.p.z = vertex[index[1]].t.u32[3]; // uint32 z is bypassed in t.w
+
+			mov(t1.cvt32(), ptr[rax + offsetof(GSVertexSW, t.w)]);
+			mov(_rip_local(p.z), t1.cvt32());
+		}
+	}
+}
+
+void GSSetupPrimCodeGenerator2::Texture()
+{
+	if (!m_en.t)
+	{
+		return;
+	}
+
+	// GSVector4 t = dscan.t;
+
+	broadcastf128(xym0, ptr[_dscan + offsetof(GSVertexSW, t)]);
+
+	THREEARG(mulps, xmm1, xmm0, xmm3);
+
+	if (m_sel.fst)
+	{
+		// m_local.d4.stq = GSVector4i(t * 4.0f);
+
+		cvttps2dq(xmm1, xmm1);
+
+		movdqa(_rip_local_d(stq), xmm1);
+	}
+	else
+	{
+		// m_local.d4.stq = t * 4.0f;
+
+		movaps(_rip_local_d(stq), xmm1);
+	}
+
+	for (int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
+	{
+		// GSVector4 ds = t.xxxx();
+		// GSVector4 dt = t.yyyy();
+		// GSVector4 dq = t.zzzz();
+
+		THREEARG(shufps, xym1, xym0, xym0, _MM_SHUFFLE(j, j, j, j));
+
+		for (int i = 0; i < (m_sel.notest ? 1 : dsize); i++)
+		{
+			// GSVector4 v = ds/dt * m_shift[i];
+
+			if (i < 4 || many_regs)
+				THREEARG(mulps, xym2, XYm(4 + i), xym1);
+			else
+				vmulps(ymm2, ymm1, ptr[g_const->m_shift_256b[i + 1]]);
+
+			if (m_sel.fst)
+			{
+				// m_local.d[i].s/t = GSVector4i(v);
+
+				cvttps2dq(xym2, xym2);
+
+				switch (j)
+				{
+					case 0: movdqa(_rip_local(d[i].s), xym2); break;
+					case 1: movdqa(_rip_local(d[i].t), xym2); break;
+				}
+			}
+			else
+			{
+				// m_local.d[i].s/t/q = v;
+
+				switch (j)
+				{
+					case 0: movaps(_rip_local(d[i].s), xym2); break;
+					case 1: movaps(_rip_local(d[i].t), xym2); break;
+					case 2: movaps(_rip_local(d[i].q), xym2); break;
+				}
+			}
+		}
+	}
+}
+
+void GSSetupPrimCodeGenerator2::Color()
+{
+	if (!m_en.c)
+	{
+		return;
+	}
+
+	if (m_sel.iip)
+	{
+		// GSVector4 c = dscan.c;
+
+		broadcastf128(xym0, ptr[_dscan + offsetof(GSVertexSW, c)]);
+
+		// m_local.d4.c = GSVector4i(c * 4.0f).xzyw().ps32();
+
+		THREEARG(mulps, xmm1, xmm0, xmm3);
+		cvttps2dq(xmm1, xmm1);
+		pshufd(xmm1, xmm1, _MM_SHUFFLE(3, 1, 2, 0));
+		packssdw(xmm1, xmm1);
+		if (isXmm)
+			movdqa(_rip_local_d(c), xmm1);
+		else
+			movq(_rip_local_d(c), xmm1);
+
+		// xym3 is not needed anymore
+
+		// GSVector4 dr = c.xxxx();
+		// GSVector4 db = c.zzzz();
+
+		THREEARG(shufps, xym2, xym0, xym0, _MM_SHUFFLE(0, 0, 0, 0));
+		THREEARG(shufps, xym3, xym0, xym0, _MM_SHUFFLE(2, 2, 2, 2));
+
+		for (int i = 0; i < (m_sel.notest ? 1 : dsize); i++)
+		{
+			// GSVector4i r = GSVector4i(dr * m_shift[i]).ps32();
+
+			if (i < 4 || many_regs)
+				THREEARG(mulps, xym0, XYm(4 + i), xym2);
+			else
+				vmulps(ymm0, ymm2, ptr[g_const->m_shift_256b[i + 1]]);
+			cvttps2dq(xym0, xym0);
+			packssdw(xym0, xym0);
+
+			// GSVector4i b = GSVector4i(db * m_shift[i]).ps32();
+
+			if (i < 4 || many_regs)
+				THREEARG(mulps, xym1, XYm(4 + i), xym3);
+			else
+				vmulps(ymm1, ymm3, ptr[g_const->m_shift_256b[i + 1]]);
+			cvttps2dq(xym1, xym1);
+			packssdw(xym1, xym1);
+
+			// m_local.d[i].rb = r.upl16(b);
+
+			punpcklwd(xym0, xym1);
+			movdqa(_rip_local(d[i].rb), xym0);
+		}
+
+		// GSVector4 c = dscan.c;
+
+		broadcastf128(xym0, ptr[_dscan + offsetof(GSVertexSW, c)]); // not enough regs, have to reload it
+
+		// GSVector4 dg = c.yyyy();
+		// GSVector4 da = c.wwww();
+
+		THREEARG(shufps, xym2, xym0, xym0, _MM_SHUFFLE(1, 1, 1, 1));
+		THREEARG(shufps, xym3, xym0, xym0, _MM_SHUFFLE(3, 3, 3, 3));
+
+		for (int i = 0; i < (m_sel.notest ? 1 : dsize); i++)
+		{
+			// GSVector4i g = GSVector4i(dg * m_shift[i]).ps32();
+
+			if (i < 4 || many_regs)
+				THREEARG(mulps, xym0, XYm(4 + i), xym2);
+			else
+				vmulps(ymm0, ymm2, ptr[g_const->m_shift_256b[i + 1]]);
+			cvttps2dq(xym0, xym0);
+			packssdw(xym0, xym0);
+
+			// GSVector4i a = GSVector4i(da * m_shift[i]).ps32();
+
+			if (i < 4 || many_regs)
+				THREEARG(mulps, xym1, XYm(4 + i), xym3);
+			else
+				vmulps(ymm1, ymm3, ptr[g_const->m_shift_256b[i + 1]]);
+			cvttps2dq(xym1, xym1);
+			packssdw(xym1, xym1);
+
+			// m_local.d[i].ga = g.upl16(a);
+
+			punpcklwd(xym0, xym1);
+			movdqa(_rip_local(d[i].ga), xym0);
+		}
+	}
+	else
+	{
+		// GSVector4i c = GSVector4i(vertex[index[last].c);
+
+		int last = 0;
+
+		switch (m_sel.prim)
+		{
+			case GS_POINT_CLASS:    last = 0; break;
+			case GS_LINE_CLASS:     last = 1; break;
+			case GS_TRIANGLE_CLASS: last = 2; break;
+			case GS_SPRITE_CLASS:   last = 1; break;
+		}
+
+		if (!(m_sel.prim == GS_SPRITE_CLASS && (m_en.z || m_en.f))) // if this is a sprite, the last vertex was already loaded in Depth()
+		{
+			if (is32)
+				mov(_index, ptr[rsp + _32_index]);
+			mov(eax, ptr[_index + sizeof(uint32) * last]);
+			shl(eax, 6); // * sizeof(GSVertexSW)
+			if (is64)
+				add(rax, _64_vertex);
+			else
+				add(rax, ptr[rsp + _32_vertex]);
+		}
+
+		if (isXmm)
+		{
+			cvttps2dq(xmm0, ptr[rax + offsetof(GSVertexSW, c)]);
+		}
+		else
+		{
+			vbroadcasti128(ymm0, ptr[rax + offsetof(GSVertexSW, c)]);
+			cvttps2dq(ymm0, ymm0);
+		}
+
+		// c = c.upl16(c.zwxy());
+
+		pshufd(xym1, xym0, _MM_SHUFFLE(1, 0, 3, 2));
+		punpcklwd(xym0, xym1);
+
+		// if(!tme) c = c.srl16(7);
+
+		if (m_sel.tfx == TFX_NONE)
+		{
+			psrlw(xym0, 7);
+		}
+
+		// m_local.c.rb = c.xxxx();
+		// m_local.c.ga = c.zzzz();
+
+		pshufd(xym1, xym0, _MM_SHUFFLE(0, 0, 0, 0));
+		pshufd(xym2, xym0, _MM_SHUFFLE(2, 2, 2, 2));
+
+		movdqa(_rip_local(c.rb), xym1);
+		movdqa(_rip_local(c.ga), xym2);
+	}
+}

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.all.h

@@ -0,0 +1,83 @@
+/*  PCSX2 - PS2 Emulator for PCs
+ *  Copyright (C) 2002-2021 PCSX2 Dev Team
+ *
+ *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
+ *  of the GNU Lesser General Public License as published by the Free Software Found-
+ *  ation, either version 3 of the License, or (at your option) any later version.
+ *
+ *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ *  PURPOSE.  See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with PCSX2.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "GSScanlineEnvironment.h"
+#include "GSNewCodeGenerator.h"
+
+#if _M_SSE >= 0x501
+	#define SETUP_PRIM_VECTOR_REGISTER Xbyak::Ymm
+	#define SETUP_PRIM_USING_XMM 0
+	#define SETUP_PRIM_USING_YMM 1
+#else
+	#define SETUP_PRIM_VECTOR_REGISTER Xbyak::Xmm
+	#define SETUP_PRIM_USING_XMM 1
+	#define SETUP_PRIM_USING_YMM 0
+#endif
+
+class GSSetupPrimCodeGenerator2 : public GSNewCodeGenerator
+{
+	using _parent = GSNewCodeGenerator;
+	using XYm = SETUP_PRIM_VECTOR_REGISTER;
+
+	using Xmm = Xbyak::Xmm;
+	using Ymm = Xbyak::Ymm;
+
+	/// On x86-64 we reserve a bunch of GPRs for holding addresses of locals that would otherwise be hard to reach
+	/// On x86-32 the same values are just raw 32-bit addresses
+	using LocalAddr = Choose3264<size_t, AddressReg>::type;
+
+	constexpr static bool isXmm = std::is_same<XYm, Xbyak::Xmm>::value;
+	constexpr static bool isYmm = std::is_same<XYm, Xbyak::Ymm>::value;
+	constexpr static int vecsize = isXmm ? 16 : 32;
+
+	constexpr static int dsize = isXmm ? 4 : 8;
+
+	constexpr static int _32_args = 0;
+	constexpr static int _invalid = 0xaaaaaaaa;
+	constexpr static int _32_vertex = is64 ? _invalid : _32_args + 4;
+	constexpr static int _32_index  = is64 ? _invalid : _32_args + 8;
+	constexpr static int _32_dscan  = is64 ? _invalid : _32_args + 12;
+
+	GSScanlineSelector m_sel;
+	GSScanlineLocalData& m_local;
+	bool m_rip;
+	bool many_regs;
+
+	struct {uint32 z:1, f:1, t:1, c:1;} m_en;
+
+	const XYm xym0{0}, xym1{1}, xym2{2}, xym3{3}, xym4{4}, xym5{5}, xym6{6}, xym7{7}, xym8{8}, xym9{9}, xym10{10}, xym11{11}, xym12{12}, xym13{13}, xym14{14}, xym15{15};
+	const AddressReg _64_vertex, _index, _dscan, _64_t0, t1;
+	const LocalAddr _m_local;
+	/// Returns the first arg on 32-bit, second on 64-bit
+	static LocalAddr chooseLocal(const void* addr32, AddressReg reg64)
+	{
+		return choose3264((size_t)addr32, reg64);
+	}
+
+public:
+	GSSetupPrimCodeGenerator2(Xbyak::CodeGenerator* base, CPUInfo cpu, void* param, uint64 key);
+	void Generate();
+
+private:
+	/// Broadcast 128 bits of floats from memory to the whole register, whatever size that register might be
+	void broadcastf128(const XYm& reg, const Xbyak::Address& mem);
+
+	void Depth_XMM();
+	void Depth_YMM();
+	void Texture();
+	void Color();
+};

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.cpp

@@ -15,6 +15,7 @@
 
 #include "PrecompiledHeader.h"
 #include "GSSetupPrimCodeGenerator.h"
+#include "GSSetupPrimCodeGenerator.all.h"
 
 using namespace Xbyak;
 
@@ -30,19 +31,5 @@ GSSetupPrimCodeGenerator::GSSetupPrimCodeGenerator(void* param, uint64 key, void
 	m_en.t = m_sel.fb && m_sel.tfx != TFX_NONE ? 1 : 0;
 	m_en.c = m_sel.fb && !(m_sel.tfx == TFX_DECAL && m_sel.tcc) ? 1 : 0;
 
-	try
-	{
-#if _M_SSE >= 0x501
-		Generate_AVX2();
-#else
-		if (m_cpu.has(util::Cpu::tAVX))
-			Generate_AVX();
-		else
-			Generate_SSE();
-#endif
-	}
-	catch (std::exception& e)
-	{
-		fprintf(stderr, "ERR:GSSetupPrimCodeGenerator %s\n", e.what());
-	}
+	GSSetupPrimCodeGenerator2(this, CPUInfo(m_cpu), param, key).Generate();
 }

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.h

@@ -32,23 +32,6 @@ class GSSetupPrimCodeGenerator : public GSCodeGenerator
 		uint32 z : 1, f : 1, t : 1, c : 1;
 	} m_en;
 
-#if _M_SSE < 0x501
-	void Generate_SSE();
-	void Depth_SSE();
-	void Texture_SSE();
-	void Color_SSE();
-
-	void Generate_AVX();
-	void Depth_AVX();
-	void Texture_AVX();
-	void Color_AVX();
-#else
-	void Generate_AVX2();
-	void Depth_AVX2();
-	void Texture_AVX2();
-	void Color_AVX2();
-#endif
-
 public:
 	GSSetupPrimCodeGenerator(void* param, uint64 key, void* code, size_t maxsize);
 };

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.x64.avx.cpp

@@ -1,365 +0,0 @@
-/*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2021 PCSX2 Dev Team
- *
- *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
- *  of the GNU Lesser General Public License as published by the Free Software Found-
- *  ation, either version 3 of the License, or (at your option) any later version.
- *
- *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *  PURPOSE.  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with PCSX2.
- *  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PrecompiledHeader.h"
-#include "GSSetupPrimCodeGenerator.h"
-#include "GSVertexSW.h"
-#include "GS/GS_codegen.h"
-
-#if _M_SSE < 0x501 && (defined(_M_AMD64) || defined(_WIN64))
-
-#define _rip_local(field) (m_rip ? ptr[rip + &m_local.field] : ptr[t0 + offsetof(GSScanlineLocalData, field)])
-#define _rip_local_v(field, offset) (m_rip ? ptr[rip + &m_local.field] : ptr[t0 + offset])
-
-void GSSetupPrimCodeGenerator::Generate_AVX()
-{
-	// Technically we just need the delta < 2GB
-	m_rip = (size_t)&m_local < 0x80000000 && (size_t)getCurr() < 0x80000000;
-
-#ifdef _WIN64
-	sub(rsp, 8 + 2 * 16);
-
-	vmovdqa(ptr[rsp + 0], xmm6);
-	vmovdqa(ptr[rsp + 16], xmm7);
-#endif
-
-	if (!m_rip)
-		mov(t0, (size_t)&m_local);
-
-	if ((m_en.z || m_en.f) && m_sel.prim != GS_SPRITE_CLASS || m_en.t || m_en.c && m_sel.iip)
-	{
-		mov(rax, (size_t)g_const->m_shift_128b);
-
-		for (int i = 0; i < (m_sel.notest ? 2 : 5); i++)
-		{
-			vmovaps(Xmm(3 + i), ptr[rax + i * 16]);
-		}
-	}
-
-	Depth_AVX();
-
-	Texture_AVX();
-
-	Color_AVX();
-
-#ifdef _WIN64
-	vmovdqa(xmm6, ptr[rsp + 0]);
-	vmovdqa(xmm7, ptr[rsp + 16]);
-
-	add(rsp, 8 + 2 * 16);
-#endif
-
-	ret();
-}
-
-void GSSetupPrimCodeGenerator::Depth_AVX()
-{
-	if (!m_en.z && !m_en.f)
-	{
-		return;
-	}
-
-	if (m_sel.prim != GS_SPRITE_CLASS)
-	{
-		// GSVector4 p = dscan.p;
-
-		vmovaps(xmm0, ptr[a2 + offsetof(GSVertexSW, p)]);
-
-		if (m_en.f)
-		{
-			// GSVector4 df = p.wwww();
-
-			vshufps(xmm1, xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
-
-			// m_local.d4.f = GSVector4i(df * 4.0f).xxzzlh();
-
-			vmulps(xmm2, xmm1, xmm3);
-			vcvttps2dq(xmm2, xmm2);
-			vpshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-			vpshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-			vmovdqa(_rip_local(d4.f), xmm2);
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-			{
-				// m_local.d[i].f = GSVector4i(df * m_shift[i]).xxzzlh();
-
-				vmulps(xmm2, xmm1, Xmm(4 + i));
-				vcvttps2dq(xmm2, xmm2);
-				vpshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-				vpshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-
-				const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].f) + (i * sizeof(GSScanlineLocalData::d[0]));
-				vmovdqa(_rip_local_v(d[i].f, variableOffset), xmm2);
-			}
-		}
-
-		if (m_en.z)
-		{
-			// GSVector4 dz = p.zzzz();
-
-			vshufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-			// m_local.d4.z = dz * 4.0f;
-
-			vmulps(xmm1, xmm0, xmm3);
-			vmovdqa(_rip_local(d4.z), xmm1);
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-			{
-				// m_local.d[i].z = dz * m_shift[i];
-
-				vmulps(xmm1, xmm0, Xmm(4 + i));
-
-				const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].z) + (i * sizeof(GSScanlineLocalData::d[0]));
-				vmovdqa(_rip_local_v(d[i].z, variableOffset), xmm1);
-			}
-		}
-	}
-	else
-	{
-		// GSVector4 p = vertex[index[1]].p;
-
-		mov(eax, ptr[a1 + sizeof(uint32) * 1]);
-		shl(eax, 6); // * sizeof(GSVertexSW)
-		add(rax, a0);
-
-		if (m_en.f)
-		{
-			// m_local.p.f = GSVector4i(p).zzzzh().zzzz();
-			vmovaps(xmm0, ptr[rax + offsetof(GSVertexSW, p)]);
-
-			vcvttps2dq(xmm1, xmm0);
-			vpshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-			vpshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-			vmovdqa(_rip_local(p.f), xmm1);
-		}
-
-		if (m_en.z)
-		{
-			// uint32 z is bypassed in t.w
-
-			vmovdqa(xmm0, ptr[rax + offsetof(GSVertexSW, t)]);
-			vpshufd(xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
-			vmovdqa(_rip_local(p.z), xmm0);
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Texture_AVX()
-{
-	if (!m_en.t)
-	{
-		return;
-	}
-
-	// GSVector4 t = dscan.t;
-
-	vmovaps(xmm0, ptr[a2 + offsetof(GSVertexSW, t)]);
-
-	vmulps(xmm1, xmm0, xmm3);
-
-	if (m_sel.fst)
-	{
-		// m_local.d4.stq = GSVector4i(t * 4.0f);
-
-		vcvttps2dq(xmm1, xmm1);
-
-		vmovdqa(_rip_local(d4.stq), xmm1);
-	}
-	else
-	{
-		// m_local.d4.stq = t * 4.0f;
-
-		vmovaps(_rip_local(d4.stq), xmm1);
-	}
-
-	for (int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
-	{
-		// GSVector4 ds = t.xxxx();
-		// GSVector4 dt = t.yyyy();
-		// GSVector4 dq = t.zzzz();
-
-		vshufps(xmm1, xmm0, xmm0, (uint8)_MM_SHUFFLE(j, j, j, j));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4 v = ds/dt * m_shift[i];
-
-			vmulps(xmm2, xmm1, Xmm(4 + i));
-
-			if (m_sel.fst)
-			{
-				// m_local.d[i].s/t = GSVector4i(v);
-
-				vcvttps2dq(xmm2, xmm2);
-
-				const size_t variableOffsetS = offsetof(GSScanlineLocalData, d[0].s) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetT = offsetof(GSScanlineLocalData, d[0].t) + (i * sizeof(GSScanlineLocalData::d[0]));
-
-				switch (j)
-				{
-					case 0: vmovdqa(_rip_local_v(d[i].s, variableOffsetS), xmm2); break;
-					case 1: vmovdqa(_rip_local_v(d[i].t, variableOffsetT), xmm2); break;
-				}
-			}
-			else
-			{
-				// m_local.d[i].s/t/q = v;
-
-				const size_t variableOffsetS = offsetof(GSScanlineLocalData, d[0].s) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetT = offsetof(GSScanlineLocalData, d[0].t) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetQ = offsetof(GSScanlineLocalData, d[0].q) + (i * sizeof(GSScanlineLocalData::d[0]));
-
-				switch (j)
-				{
-					case 0: vmovaps(_rip_local_v(d[i].s, variableOffsetS), xmm2); break;
-					case 1: vmovaps(_rip_local_v(d[i].t, variableOffsetT), xmm2); break;
-					case 2: vmovaps(_rip_local_v(d[i].q, variableOffsetQ), xmm2); break;
-				}
-			}
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Color_AVX()
-{
-	if (!m_en.c)
-	{
-		return;
-	}
-
-	if (m_sel.iip)
-	{
-		// GSVector4 c = dscan.c;
-
-		vmovaps(xmm0, ptr[a2 + offsetof(GSVertexSW, c)]);
-
-		// m_local.d4.c = GSVector4i(c * 4.0f).xzyw().ps32();
-
-		vmulps(xmm1, xmm0, xmm3);
-		vcvttps2dq(xmm1, xmm1);
-		vpshufd(xmm1, xmm1, _MM_SHUFFLE(3, 1, 2, 0));
-		vpackssdw(xmm1, xmm1);
-		vmovdqa(_rip_local(d4.c), xmm1);
-
-		// xmm3 is not needed anymore
-
-		// GSVector4 dr = c.xxxx();
-		// GSVector4 db = c.zzzz();
-
-		vshufps(xmm2, xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
-		vshufps(xmm3, xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4i r = GSVector4i(dr * m_shift[i]).ps32();
-
-			vmulps(xmm0, xmm2, Xmm(4 + i));
-			vcvttps2dq(xmm0, xmm0);
-			vpackssdw(xmm0, xmm0);
-
-			// GSVector4i b = GSVector4i(db * m_shift[i]).ps32();
-
-			vmulps(xmm1, xmm3, Xmm(4 + i));
-			vcvttps2dq(xmm1, xmm1);
-			vpackssdw(xmm1, xmm1);
-
-			// m_local.d[i].rb = r.upl16(b);
-
-			vpunpcklwd(xmm0, xmm1);
-
-			const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].rb) + (i * sizeof(GSScanlineLocalData::d[0]));
-			vmovdqa(_rip_local_v(d[i].rb, variableOffset), xmm0);
-		}
-
-		// GSVector4 c = dscan.c;
-
-		vmovaps(xmm0, ptr[a2 + offsetof(GSVertexSW, c)]); // not enough regs, have to reload it
-
-		// GSVector4 dg = c.yyyy();
-		// GSVector4 da = c.wwww();
-
-		vshufps(xmm2, xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
-		vshufps(xmm3, xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4i g = GSVector4i(dg * m_shift[i]).ps32();
-
-			vmulps(xmm0, xmm2, Xmm(4 + i));
-			vcvttps2dq(xmm0, xmm0);
-			vpackssdw(xmm0, xmm0);
-
-			// GSVector4i a = GSVector4i(da * m_shift[i]).ps32();
-
-			vmulps(xmm1, xmm3, Xmm(4 + i));
-			vcvttps2dq(xmm1, xmm1);
-			vpackssdw(xmm1, xmm1);
-
-			// m_local.d[i].ga = g.upl16(a);
-
-			vpunpcklwd(xmm0, xmm1);
-
-			const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].ga) + (i * sizeof(GSScanlineLocalData::d[0]));
-			vmovdqa(_rip_local_v(d[i].ga, variableOffset), xmm0);
-		}
-	}
-	else
-	{
-		// GSVector4i c = GSVector4i(vertex[index[last].c);
-
-		int last = 0;
-
-		switch (m_sel.prim)
-		{
-		case GS_POINT_CLASS:    last = 0; break;
-		case GS_LINE_CLASS:     last = 1; break;
-		case GS_TRIANGLE_CLASS: last = 2; break;
-		case GS_SPRITE_CLASS:   last = 1; break;
-		}
-
-		if (!(m_sel.prim == GS_SPRITE_CLASS && (m_en.z || m_en.f))) // if this is a sprite, the last vertex was already loaded in Depth()
-		{
-			mov(eax, ptr[a1 + sizeof(uint32) * last]);
-			shl(eax, 6); // * sizeof(GSVertexSW)
-			add(rax, a0);
-		}
-
-		vcvttps2dq(xmm0, ptr[rax + offsetof(GSVertexSW, c)]);
-
-		// c = c.upl16(c.zwxy());
-
-		vpshufd(xmm1, xmm0, _MM_SHUFFLE(1, 0, 3, 2));
-		vpunpcklwd(xmm0, xmm1);
-
-		// if(!tme) c = c.srl16(7);
-
-		if (m_sel.tfx == TFX_NONE)
-		{
-			vpsrlw(xmm0, 7);
-		}
-
-		// m_local.c.rb = c.xxxx();
-		// m_local.c.ga = c.zzzz();
-
-		vpshufd(xmm1, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
-		vpshufd(xmm2, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		vmovdqa(_rip_local(c.rb), xmm1);
-		vmovdqa(_rip_local(c.ga), xmm2);
-	}
-}
-
-#endif

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.x64.avx2.cpp

@@ -1,368 +0,0 @@
-/*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2021 PCSX2 Dev Team
- *
- *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
- *  of the GNU Lesser General Public License as published by the Free Software Found-
- *  ation, either version 3 of the License, or (at your option) any later version.
- *
- *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *  PURPOSE.  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with PCSX2.
- *  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PrecompiledHeader.h"
-#include "GSSetupPrimCodeGenerator.h"
-#include "GSVertexSW.h"
-#include "GS/GS_codegen.h"
-
-#if _M_SSE >= 0x501 && (defined(_M_AMD64) || defined(_WIN64))
-
-#define _rip_local(field) (m_rip ? ptr[rip + &m_local.field] : ptr[t0 + offsetof(GSScanlineLocalData, field)])
-#define _rip_local_v(field, offset) (m_rip ? ptr[rip + &m_local.field] : ptr[t0 + offset])
-
-#define _m_shift(i) (Ymm(7 + i))
-
-// FIXME windows ?
-#define _vertex rcx
-
-void GSSetupPrimCodeGenerator::Generate_AVX2()
-{
-	// Technically we just need the delta < 2GB
-	m_rip = (size_t)&m_local < 0x80000000 && (size_t)getCurr() < 0x80000000;
-
-#ifdef _WIN64
-	sub(rsp, 8 + 2 * 16);
-
-	vmovdqa(ptr[rsp + 0], ymm6);
-	vmovdqa(ptr[rsp + 16], ymm7);
-#endif
-
-	if (!m_rip)
-		mov(t0, (size_t)&m_local);
-
-	if ((m_en.z || m_en.f) && m_sel.prim != GS_SPRITE_CLASS || m_en.t || m_en.c && m_sel.iip)
-	{
-		mov(rax, (size_t)g_const->m_shift_256b);
-
-		for (int i = 0; i < (m_sel.notest ? 2 : 9); i++)
-		{
-			vmovaps(_m_shift(i), ptr[rax + i * 32]);
-		}
-	}
-	// ymm7 to ymm 15 = m_shift[i]
-
-	Depth_AVX2();
-
-	Texture_AVX2();
-
-	Color_AVX2();
-
-#ifdef _WIN64
-	vmovdqa(ymm6, ptr[rsp + 0]);
-	vmovdqa(ymm7, ptr[rsp + 16]);
-
-	add(rsp, 8 + 2 * 16);
-#endif
-
-	ret();
-}
-
-void GSSetupPrimCodeGenerator::Depth_AVX2()
-{
-	if (!m_en.z && !m_en.f)
-	{
-		return;
-	}
-
-	if (m_sel.prim != GS_SPRITE_CLASS)
-	{
-		const Ymm& dscan_p = ymm6;
-
-		// GSVector4 dp8 = dscan.p * GSVector4::broadcast32(&shift[0]);
-
-		vbroadcastf128(dscan_p, ptr[a2 + offsetof(GSVertexSW, p)]);
-
-		vmulps(ymm1, dscan_p, _m_shift(0));
-
-		if (m_en.z)
-		{
-			// m_local.d8.p.z = dp8.extract32<2>();
-
-			vextractps(_rip_local(d8.p.z), xmm1, 2);
-
-			// GSVector8 dz = GSVector8(dscan.p).zzzz();
-
-			vshufps(ymm2, dscan_p, dscan_p, _MM_SHUFFLE(2, 2, 2, 2));
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-			{
-				// m_local.d[i].z = dz * shift[1 + i];
-
-				vmulps(ymm0, ymm2, _m_shift(1 + i));
-
-				const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].z) + (i * sizeof(GSScanlineLocalData::d[0]));
-				vmovaps(_rip_local_v(d[i].z, variableOffset), ymm0);
-			}
-		}
-
-		if (m_en.f)
-		{
-			// m_local.d8.p.f = GSVector4i(dp8).extract32<3>();
-
-			// FIXME no truncate ? why ? vcvttps2dq ?
-			//vcvtps2dq(ymm2, ymm1); // let's guess a typo
-			vcvttps2dq(ymm2, ymm1);
-			vpextrd(_rip_local(d8.p.f), xmm2, 3);
-
-			// GSVector8 df = GSVector8(dscan.p).wwww();
-
-			vshufps(ymm3, dscan_p, dscan_p, _MM_SHUFFLE(3, 3, 3, 3));
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-			{
-				// m_local.d[i].f = GSVector8i(df * m_shift[i]).xxzzlh();
-
-				vmulps(ymm0, ymm3, _m_shift(1 + i));
-				vcvttps2dq(ymm0, ymm0);
-
-				vpshuflw(ymm0, ymm0, _MM_SHUFFLE(2, 2, 0, 0));
-				vpshufhw(ymm0, ymm0, _MM_SHUFFLE(2, 2, 0, 0));
-
-				const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].f) + (i * sizeof(GSScanlineLocalData::d[0]));
-				vmovdqa(_rip_local_v(d[i].f, variableOffset), ymm0);
-			}
-		}
-	}
-	else
-	{
-		// GSVector4 p = vertex[index[1]].p;
-
-		mov(_vertex.cvt32(), ptr[a1 + sizeof(uint32) * 1]);
-		shl(_vertex.cvt32(), 6); // * sizeof(GSVertexSW)
-		add(_vertex, a0);
-
-		if (m_en.f)
-		{
-			// m_local.p.f = GSVector4i(vertex[index[1]].p).extract32<3>();
-
-			vmovaps(xmm0, ptr[_vertex + offsetof(GSVertexSW, p)]);
-			vcvttps2dq(xmm0, xmm0);
-			vpextrd(_rip_local(p.f), xmm0, 3);
-		}
-
-		if (m_en.z)
-		{
-			// m_local.p.z = vertex[index[1]].t.u32[3]; // uint32 z is bypassed in t.w
-
-			mov(eax, ptr[ecx + offsetof(GSVertexSW, t.w)]);
-			mov(_rip_local(p.z), eax);
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Texture_AVX2()
-{
-	if (!m_en.t)
-	{
-		return;
-	}
-
-	// GSVector8 dt(dscan.t);
-
-	vbroadcastf128(ymm0, ptr[a2 + offsetof(GSVertexSW, t)]);
-
-	// GSVector8 dt8 = dt * shift[0];
-
-	vmulps(ymm1, ymm0, _m_shift(0));
-
-	if (m_sel.fst)
-	{
-		// m_local.84.stq = GSVector4i(t * 4.0f);
-
-		vcvttps2dq(ymm1, ymm1);
-
-		vmovdqa(_rip_local(d8.stq), xmm1);
-	}
-	else
-	{
-		// m_local.d8.stq = t * 4.0f;
-
-		vmovaps(_rip_local(d8.stq), xmm1);
-	}
-
-	for (int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
-	{
-		// GSVector8 dstq = dt.xxxx/yyyy/zzzz();
-
-		vshufps(ymm1, ymm0, ymm0, (uint8)_MM_SHUFFLE(j, j, j, j));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-		{
-			// GSVector8 v = dstq * shift[1 + i];
-
-			vmulps(ymm2, ymm1, _m_shift(1 + i));
-
-			if (m_sel.fst)
-			{
-				// m_local.d[i].s/t = GSVector8::cast(GSVector8i(v));
-
-				vcvttps2dq(ymm2, ymm2);
-
-				const size_t variableOffsetS = offsetof(GSScanlineLocalData, d[0].s) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetT = offsetof(GSScanlineLocalData, d[0].t) + (i * sizeof(GSScanlineLocalData::d[0]));
-
-				switch (j)
-				{
-					case 0: vmovdqa(_rip_local_v(d[i].s, variableOffsetS), ymm2); break;
-					case 1: vmovdqa(_rip_local_v(d[i].t, variableOffsetT), ymm2); break;
-				}
-			}
-			else
-			{
-				// m_local.d[i].s/t/q = v;
-
-				const size_t variableOffsetS = offsetof(GSScanlineLocalData, d[0].s) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetT = offsetof(GSScanlineLocalData, d[0].t) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetQ = offsetof(GSScanlineLocalData, d[0].q) + (i * sizeof(GSScanlineLocalData::d[0]));
-
-				switch (j)
-				{
-					case 0: vmovaps(_rip_local_v(d[i].s, variableOffsetS), ymm2); break;
-					case 1: vmovaps(_rip_local_v(d[i].t, variableOffsetT), ymm2); break;
-					case 2: vmovaps(_rip_local_v(d[i].q, variableOffsetQ), ymm2); break;
-				}
-			}
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Color_AVX2()
-{
-	if (!m_en.c)
-	{
-		return;
-	}
-
-	if (m_sel.iip)
-	{
-		const Ymm& dscan_c = ymm6;
-
-		// GSVector8 dc(dscan.c);
-
-		vbroadcastf128(dscan_c, ptr[a2 + offsetof(GSVertexSW, c)]);
-
-		// m_local.d8.c = GSVector4i(c * 4.0f).xzyw().ps32();
-
-		vmulps(ymm1, dscan_c, ymm3);
-		vcvttps2dq(ymm1, ymm1);
-		vpshufd(ymm1, ymm1, _MM_SHUFFLE(3, 1, 2, 0));
-		vpackssdw(ymm1, ymm1);
-		vmovq(_rip_local(d8.c), xmm1);
-
-		// GSVector8 dr = dc.xxxx();
-		// GSVector8 db = dc.zzzz();
-
-		vshufps(ymm2, dscan_c, dscan_c, _MM_SHUFFLE(0, 0, 0, 0));
-		vshufps(ymm3, dscan_c, dscan_c, _MM_SHUFFLE(2, 2, 2, 2));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-		{
-			// GSVector8i r = GSVector8i(dr * shift[1 + i]).ps32();
-
-			vmulps(ymm0, ymm2, _m_shift(1 + i));
-			vcvttps2dq(ymm0, ymm0);
-			vpackssdw(ymm0, ymm0);
-
-			// GSVector4i b = GSVector8i(db * shift[1 + i]).ps32();
-
-			vmulps(ymm1, ymm3, _m_shift(1 + i));
-			vcvttps2dq(ymm1, ymm1);
-			vpackssdw(ymm1, ymm1);
-
-			// m_local.d[i].rb = r.upl16(b);
-
-			vpunpcklwd(ymm0, ymm1);
-
-			const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].rb) + (i * sizeof(GSScanlineLocalData::d[0]));
-			vmovdqa(_rip_local_v(d[i].rb, variableOffset), ymm0);
-		}
-
-		// GSVector8 dg = dc.yyyy();
-		// GSVector8 da = dc.wwww();
-
-		vshufps(ymm2, dscan_c, dscan_c, _MM_SHUFFLE(1, 1, 1, 1));
-		vshufps(ymm3, dscan_c, dscan_c, _MM_SHUFFLE(3, 3, 3, 3));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-		{
-			// GSVector8i g = GSVector8i(dg * shift[1 + i]).ps32();
-
-			vmulps(ymm0, ymm2, _m_shift(1 + i));
-			vcvttps2dq(ymm0, ymm0);
-			vpackssdw(ymm0, ymm0);
-
-			// GSVector8i a = GSVector8i(da * shift[1 + i]).ps32();
-
-			vmulps(ymm1, ymm3, _m_shift(1 + i));
-			vcvttps2dq(ymm1, ymm1);
-			vpackssdw(ymm1, ymm1);
-
-			// m_local.d[i].ga = g.upl16(a);
-
-			vpunpcklwd(ymm0, ymm1);
-
-			const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].ga) + (i * sizeof(GSScanlineLocalData::d[0]));
-			vmovdqa(_rip_local_v(d[i].ga, variableOffset), ymm0);
-		}
-	}
-	else
-	{
-		// GSVector4i c = GSVector4i(vertex[index[last].c);
-
-		int last = 0;
-
-		switch (m_sel.prim)
-		{
-			case GS_POINT_CLASS:    last = 0; break;
-			case GS_LINE_CLASS:     last = 1; break;
-			case GS_TRIANGLE_CLASS: last = 2; break;
-			case GS_SPRITE_CLASS:   last = 1; break;
-		}
-
-		if (!(m_sel.prim == GS_SPRITE_CLASS && (m_en.z || m_en.f))) // if this is a sprite, the last vertex was already loaded in Depth()
-		{
-			mov(_vertex.cvt32(), ptr[a1 + sizeof(uint32) * last]);
-			shl(_vertex.cvt32(), 6); // * sizeof(GSVertexSW)
-			add(_vertex, a0);
-		}
-
-		vbroadcasti128(ymm0, ptr[_vertex + offsetof(GSVertexSW, c)]);
-		vcvttps2dq(ymm0, ymm0);
-
-		// c = c.upl16(c.zwxy());
-
-		vpshufd(ymm1, ymm0, _MM_SHUFFLE(1, 0, 3, 2));
-		vpunpcklwd(ymm0, ymm1);
-
-		// if(!tme) c = c.srl16(7);
-
-		if (m_sel.tfx == TFX_NONE)
-		{
-			vpsrlw(ymm0, 7);
-		}
-
-		// m_local.c.rb = c.xxxx();
-		// m_local.c.ga = c.zzzz();
-
-		vpshufd(ymm1, ymm0, _MM_SHUFFLE(0, 0, 0, 0));
-		vpshufd(ymm2, ymm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		vmovdqa(_rip_local(c.rb), ymm1);
-		vmovdqa(_rip_local(c.ga), ymm2);
-	}
-}
-
-#endif

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.x64.cpp

@@ -1,374 +0,0 @@
-/*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2021 PCSX2 Dev Team
- *
- *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
- *  of the GNU Lesser General Public License as published by the Free Software Found-
- *  ation, either version 3 of the License, or (at your option) any later version.
- *
- *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *  PURPOSE.  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with PCSX2.
- *  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PrecompiledHeader.h"
-#include "GSSetupPrimCodeGenerator.h"
-#include "GSVertexSW.h"
-#include "GS/GS_codegen.h"
-
-#if _M_SSE < 0x501 && (defined(_M_AMD64) || defined(_WIN64))
-
-void GSSetupPrimCodeGenerator::Generate_SSE()
-{
-#ifdef _WIN64
-	sub(rsp, 8 + 2 * 16);
-
-	vmovdqa(ptr[rsp + 0], xmm6);
-	vmovdqa(ptr[rsp + 16], xmm7);
-#endif
-
-	mov(t0, (size_t)&m_local);
-
-	if ((m_en.z || m_en.f) && m_sel.prim != GS_SPRITE_CLASS || m_en.t || m_en.c && m_sel.iip)
-	{
-		mov(rax, (size_t)g_const->m_shift_128b[0]);
-
-		for (int i = 0; i < (m_sel.notest ? 2 : 5); i++)
-		{
-			movaps(Xmm(3 + i), ptr[rax + i * 16]);
-		}
-	}
-
-	Depth_SSE();
-
-	Texture_SSE();
-
-	Color_SSE();
-
-#ifdef _WIN64
-	vmovdqa(xmm6, ptr[rsp + 0]);
-	vmovdqa(xmm7, ptr[rsp + 16]);
-
-	add(rsp, 8 + 2 * 16);
-#endif
-
-	ret();
-}
-
-void GSSetupPrimCodeGenerator::Depth_SSE()
-{
-	if (!m_en.z && !m_en.f)
-	{
-		return;
-	}
-
-	if (m_sel.prim != GS_SPRITE_CLASS)
-	{
-		// GSVector4 p = dscan.p;
-
-		movaps(xmm0, ptr[a2 + offsetof(GSVertexSW, p)]);
-
-		if (m_en.f)
-		{
-			// GSVector4 df = p.wwww();
-
-			movaps(xmm1, xmm0);
-			shufps(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
-
-			// m_local.d4.f = GSVector4i(df * 4.0f).xxzzlh();
-
-			movaps(xmm2, xmm1);
-			mulps(xmm2, xmm3);
-			cvttps2dq(xmm2, xmm2);
-			pshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-			pshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-			movdqa(ptr[t0 + offsetof(GSScanlineLocalData, d4.f)], xmm2);
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-			{
-				// m_local.d[i].f = GSVector4i(df * m_shift[i]).xxzzlh();
-
-				movaps(xmm2, xmm1);
-				mulps(xmm2, Xmm(4 + i));
-				cvttps2dq(xmm2, xmm2);
-				pshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-				pshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-
-				const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].f) + (i * sizeof(GSScanlineLocalData::d[0]));
-				movdqa(ptr[t0 + variableOffset], xmm2);
-			}
-		}
-
-		if (m_en.z)
-		{
-			// GSVector4 dz = p.zzzz();
-
-			shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-			// m_local.d4.z = dz * 4.0f;
-
-			movaps(xmm1, xmm0);
-			mulps(xmm1, xmm3);
-			movdqa(ptr[t0 + offsetof(GSScanlineLocalData, d4.z)], xmm1);
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-			{
-				// m_local.d[i].z = dz * m_shift[i];
-
-				movaps(xmm1, xmm0);
-				mulps(xmm1, Xmm(4 + i));
-
-				const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].z) + (i * sizeof(GSScanlineLocalData::d[0]));
-				movdqa(ptr[t0 + variableOffset], xmm1);
-			}
-		}
-	}
-	else
-	{
-		// GSVector4 p = vertex[index[1]].p;
-
-		mov(eax, ptr[a1 + sizeof(uint32) * 1]);
-		shl(eax, 6); // * sizeof(GSVertexSW)
-		add(rax, a0);
-
-		movaps(xmm0, ptr[rax + offsetof(GSVertexSW, p)]);
-
-		if (m_en.f)
-		{
-			// m_local.p.f = GSVector4i(p).zzzzh().zzzz();
-
-			cvttps2dq(xmm1, xmm0);
-			pshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-			pshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-			movdqa(ptr[t0 + offsetof(GSScanlineLocalData, p.f)], xmm1);
-		}
-
-		if (m_en.z)
-		{
-			// uint32 z is bypassed in t.w
-
-			vmovdqa(xmm0, ptr[rax + offsetof(GSVertexSW, t)]);
-			vpshufd(xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
-			vmovdqa(ptr[t0 + offsetof(GSScanlineLocalData, p.z)], xmm0);
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Texture_SSE()
-{
-	if (!m_en.t)
-	{
-		return;
-	}
-
-	// GSVector4 t = dscan.t;
-
-	movaps(xmm0, ptr[a2 + offsetof(GSVertexSW, t)]);
-
-	movaps(xmm1, xmm0);
-	mulps(xmm1, xmm3);
-
-	if (m_sel.fst)
-	{
-		// m_local.d4.stq = GSVector4i(t * 4.0f);
-
-		cvttps2dq(xmm1, xmm1);
-
-		movdqa(ptr[t0 + offsetof(GSScanlineLocalData, d4.stq)], xmm1);
-	}
-	else
-	{
-		// m_local.d4.stq = t * 4.0f;
-
-		movaps(ptr[t0 + offsetof(GSScanlineLocalData, d4.stq)], xmm1);
-	}
-
-	for (int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
-	{
-		// GSVector4 ds = t.xxxx();
-		// GSVector4 dt = t.yyyy();
-		// GSVector4 dq = t.zzzz();
-
-		movaps(xmm1, xmm0);
-		shufps(xmm1, xmm1, (uint8)_MM_SHUFFLE(j, j, j, j));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4 v = ds/dt * m_shift[i];
-
-			movaps(xmm2, xmm1);
-			mulps(xmm2, Xmm(4 + i));
-
-			if (m_sel.fst)
-			{
-				// m_local.d[i].s/t = GSVector4i(v);
-
-				cvttps2dq(xmm2, xmm2);
-
-				const size_t variableOffsetS = offsetof(GSScanlineLocalData, d[0].s) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetT = offsetof(GSScanlineLocalData, d[0].t) + (i * sizeof(GSScanlineLocalData::d[0]));
-
-				switch (j)
-				{
-					case 0: movdqa(ptr[t0 + variableOffsetS], xmm2); break;
-					case 1: movdqa(ptr[t0 + variableOffsetT], xmm2); break;
-				}
-			}
-			else
-			{
-				// m_local.d[i].s/t/q = v;
-
-				const size_t variableOffsetS = offsetof(GSScanlineLocalData, d[0].s) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetT = offsetof(GSScanlineLocalData, d[0].t) + (i * sizeof(GSScanlineLocalData::d[0]));
-				const size_t variableOffsetQ = offsetof(GSScanlineLocalData, d[0].q) + (i * sizeof(GSScanlineLocalData::d[0]));
-
-				switch (j)
-				{
-					case 0: movaps(ptr[t0 + variableOffsetS], xmm2); break;
-					case 1: movaps(ptr[t0 + variableOffsetT], xmm2); break;
-					case 2: movaps(ptr[t0 + variableOffsetQ], xmm2); break;
-				}
-			}
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Color_SSE()
-{
-	if (!m_en.c)
-	{
-		return;
-	}
-
-	if (m_sel.iip)
-	{
-		// GSVector4 c = dscan.c;
-
-		movaps(xmm0, ptr[a2 + offsetof(GSVertexSW, c)]);
-		movaps(xmm1, xmm0);
-
-		// m_local.d4.c = GSVector4i(c * 4.0f).xzyw().ps32();
-
-		movaps(xmm2, xmm0);
-		mulps(xmm2, xmm3);
-		cvttps2dq(xmm2, xmm2);
-		pshufd(xmm2, xmm2, _MM_SHUFFLE(3, 1, 2, 0));
-		packssdw(xmm2, xmm2);
-		movdqa(ptr[t0 + offsetof(GSScanlineLocalData, d4.c)], xmm2);
-
-		// xmm3 is not needed anymore
-
-		// GSVector4 dr = c.xxxx();
-		// GSVector4 db = c.zzzz();
-
-		shufps(xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
-		shufps(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4i r = GSVector4i(dr * m_shift[i]).ps32();
-
-			movaps(xmm2, xmm0);
-			mulps(xmm2, Xmm(4 + i));
-			cvttps2dq(xmm2, xmm2);
-			packssdw(xmm2, xmm2);
-
-			// GSVector4i b = GSVector4i(db * m_shift[i]).ps32();
-
-			movaps(xmm3, xmm1);
-			mulps(xmm3, Xmm(4 + i));
-			cvttps2dq(xmm3, xmm3);
-			packssdw(xmm3, xmm3);
-
-			// m_local.d[i].rb = r.upl16(b);
-
-			punpcklwd(xmm2, xmm3);
-
-			const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].rb) + (i * sizeof(GSScanlineLocalData::d[0]));
-			movdqa(ptr[t0 + variableOffset], xmm2);
-		}
-
-		// GSVector4 c = dscan.c;
-
-		movaps(xmm0, ptr[a2 + offsetof(GSVertexSW, c)]); // not enough regs, have to reload it
-		movaps(xmm1, xmm0);
-
-		// GSVector4 dg = c.yyyy();
-		// GSVector4 da = c.wwww();
-
-		shufps(xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
-		shufps(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4i g = GSVector4i(dg * m_shift[i]).ps32();
-
-			movaps(xmm2, xmm0);
-			mulps(xmm2, Xmm(4 + i));
-			cvttps2dq(xmm2, xmm2);
-			packssdw(xmm2, xmm2);
-
-			// GSVector4i a = GSVector4i(da * m_shift[i]).ps32();
-
-			movaps(xmm3, xmm1);
-			mulps(xmm3, Xmm(4 + i));
-			cvttps2dq(xmm3, xmm3);
-			packssdw(xmm3, xmm3);
-
-			// m_local.d[i].ga = g.upl16(a);
-
-			punpcklwd(xmm2, xmm3);
-
-			const size_t variableOffset = offsetof(GSScanlineLocalData, d[0].ga) + (i * sizeof(GSScanlineLocalData::d[0]));
-			movdqa(ptr[t0 + variableOffset], xmm2);
-		}
-	}
-	else
-	{
-		// GSVector4i c = GSVector4i(vertex[index[last].c);
-
-		int last = 0;
-
-		switch (m_sel.prim)
-		{
-			case GS_POINT_CLASS:    last = 0; break;
-			case GS_LINE_CLASS:     last = 1; break;
-			case GS_TRIANGLE_CLASS: last = 2; break;
-			case GS_SPRITE_CLASS:   last = 1; break;
-		}
-
-		if (!(m_sel.prim == GS_SPRITE_CLASS && (m_en.z || m_en.f))) // if this is a sprite, the last vertex was already loaded in Depth()
-		{
-			mov(eax, ptr[a1 + sizeof(uint32) * last]);
-			shl(eax, 6); // * sizeof(GSVertexSW)
-			add(rax, a0);
-		}
-
-		cvttps2dq(xmm0, ptr[rax + offsetof(GSVertexSW, c)]);
-
-		// c = c.upl16(c.zwxy());
-
-		pshufd(xmm1, xmm0, _MM_SHUFFLE(1, 0, 3, 2));
-		punpcklwd(xmm0, xmm1);
-
-		// if(!tme) c = c.srl16(7);
-
-		if (m_sel.tfx == TFX_NONE)
-		{
-			psrlw(xmm0, 7);
-		}
-
-		// m_local.c.rb = c.xxxx();
-		// m_local.c.ga = c.zzzz();
-
-		pshufd(xmm1, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
-		pshufd(xmm2, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		movdqa(ptr[t0 + offsetof(GSScanlineLocalData, c.rb)], xmm1);
-		movdqa(ptr[t0 + offsetof(GSScanlineLocalData, c.ga)], xmm2);
-	}
-}
-
-#endif

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.x86.avx.cpp

@@ -1,335 +0,0 @@
-/*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2021 PCSX2 Dev Team
- *
- *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
- *  of the GNU Lesser General Public License as published by the Free Software Found-
- *  ation, either version 3 of the License, or (at your option) any later version.
- *
- *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *  PURPOSE.  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with PCSX2.
- *  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PrecompiledHeader.h"
-#include "GSSetupPrimCodeGenerator.h"
-#include "GSVertexSW.h"
-#include "GS/GS_codegen.h"
-
-#if _M_SSE < 0x501 && !(defined(_M_AMD64) || defined(_WIN64))
-
-static const int _args = 0;
-static const int _vertex = _args + 4;
-static const int _index = _args + 8;
-static const int _dscan = _args + 12;
-
-void GSSetupPrimCodeGenerator::Generate_AVX()
-{
-	if ((m_en.z || m_en.f) && m_sel.prim != GS_SPRITE_CLASS || m_en.t || m_en.c && m_sel.iip)
-	{
-		mov(edx, dword[esp + _dscan]);
-
-		for (int i = 0; i < (m_sel.notest ? 2 : 5); i++)
-		{
-			vmovaps(Xmm(3 + i), ptr[g_const->m_shift_128b[i]]);
-		}
-	}
-
-	Depth_AVX();
-
-	Texture_AVX();
-
-	Color_AVX();
-
-	ret();
-}
-
-void GSSetupPrimCodeGenerator::Depth_AVX()
-{
-	if (!m_en.z && !m_en.f)
-	{
-		return;
-	}
-
-	if (m_sel.prim != GS_SPRITE_CLASS)
-	{
-		// GSVector4 p = dscan.p;
-
-		vmovaps(xmm0, ptr[edx + offsetof(GSVertexSW, p)]);
-
-		if (m_en.f)
-		{
-			// GSVector4 df = p.wwww();
-
-			vshufps(xmm1, xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
-
-			// m_local.d4.f = GSVector4i(df * 4.0f).xxzzlh();
-
-			vmulps(xmm2, xmm1, xmm3);
-			vcvttps2dq(xmm2, xmm2);
-			vpshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-			vpshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-			vmovdqa(ptr[&m_local.d4.f], xmm2);
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-			{
-				// m_local.d[i].f = GSVector4i(df * m_shift[i]).xxzzlh();
-
-				vmulps(xmm2, xmm1, Xmm(4 + i));
-				vcvttps2dq(xmm2, xmm2);
-				vpshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-				vpshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-				vmovdqa(ptr[&m_local.d[i].f], xmm2);
-			}
-		}
-
-		if (m_en.z)
-		{
-			// GSVector4 dz = p.zzzz();
-
-			vshufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-			// m_local.d4.z = dz * 4.0f;
-
-			vmulps(xmm1, xmm0, xmm3);
-			vmovdqa(ptr[&m_local.d4.z], xmm1);
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-			{
-				// m_local.d[i].z = dz * m_shift[i];
-
-				vmulps(xmm1, xmm0, Xmm(4 + i));
-				vmovdqa(ptr[&m_local.d[i].z], xmm1);
-			}
-		}
-	}
-	else
-	{
-		// GSVector4 p = vertex[index[1]].p;
-
-		mov(ecx, ptr[esp + _index]);
-		mov(ecx, ptr[ecx + sizeof(uint32) * 1]);
-		shl(ecx, 6); // * sizeof(GSVertexSW)
-		add(ecx, ptr[esp + _vertex]);
-
-		vmovaps(xmm0, ptr[ecx + offsetof(GSVertexSW, p)]);
-
-		if (m_en.f)
-		{
-			// m_local.p.f = GSVector4i(p).zzzzh().zzzz();
-
-			vcvttps2dq(xmm1, xmm0);
-			vpshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-			vpshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-			vmovdqa(ptr[&m_local.p.f], xmm1);
-		}
-
-		if (m_en.z)
-		{
-			// uint32 z is bypassed in t.w
-
-			vmovdqa(xmm0, ptr[ecx + offsetof(GSVertexSW, t)]);
-			vpshufd(xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
-			vmovdqa(ptr[&m_local.p.z], xmm0);
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Texture_AVX()
-{
-	if (!m_en.t)
-	{
-		return;
-	}
-
-	// GSVector4 t = dscan.t;
-
-	vmovaps(xmm0, ptr[edx + offsetof(GSVertexSW, t)]);
-
-	vmulps(xmm1, xmm0, xmm3);
-
-	if (m_sel.fst)
-	{
-		// m_local.d4.stq = GSVector4i(t * 4.0f);
-
-		vcvttps2dq(xmm1, xmm1);
-
-		vmovdqa(ptr[&m_local.d4.stq], xmm1);
-	}
-	else
-	{
-		// m_local.d4.stq = t * 4.0f;
-
-		vmovaps(ptr[&m_local.d4.stq], xmm1);
-	}
-
-	for (int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
-	{
-		// GSVector4 ds = t.xxxx();
-		// GSVector4 dt = t.yyyy();
-		// GSVector4 dq = t.zzzz();
-
-		vshufps(xmm1, xmm0, xmm0, (uint8)_MM_SHUFFLE(j, j, j, j));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4 v = ds/dt * m_shift[i];
-
-			vmulps(xmm2, xmm1, Xmm(4 + i));
-
-			if (m_sel.fst)
-			{
-				// m_local.d[i].s/t = GSVector4i(v);
-
-				vcvttps2dq(xmm2, xmm2);
-
-				switch (j)
-				{
-					case 0: vmovdqa(ptr[&m_local.d[i].s], xmm2); break;
-					case 1: vmovdqa(ptr[&m_local.d[i].t], xmm2); break;
-				}
-			}
-			else
-			{
-				// m_local.d[i].s/t/q = v;
-
-				switch (j)
-				{
-					case 0: vmovaps(ptr[&m_local.d[i].s], xmm2); break;
-					case 1: vmovaps(ptr[&m_local.d[i].t], xmm2); break;
-					case 2: vmovaps(ptr[&m_local.d[i].q], xmm2); break;
-				}
-			}
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Color_AVX()
-{
-	if (!m_en.c)
-	{
-		return;
-	}
-
-	if (m_sel.iip)
-	{
-		// GSVector4 c = dscan.c;
-
-		vmovaps(xmm0, ptr[edx + offsetof(GSVertexSW, c)]);
-
-		// m_local.d4.c = GSVector4i(c * 4.0f).xzyw().ps32();
-
-		vmulps(xmm1, xmm0, xmm3);
-		vcvttps2dq(xmm1, xmm1);
-		vpshufd(xmm1, xmm1, _MM_SHUFFLE(3, 1, 2, 0));
-		vpackssdw(xmm1, xmm1);
-		vmovdqa(ptr[&m_local.d4.c], xmm1);
-
-		// xmm3 is not needed anymore
-
-		// GSVector4 dr = c.xxxx();
-		// GSVector4 db = c.zzzz();
-
-		vshufps(xmm2, xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
-		vshufps(xmm3, xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4i r = GSVector4i(dr * m_shift[i]).ps32();
-
-			vmulps(xmm0, xmm2, Xmm(4 + i));
-			vcvttps2dq(xmm0, xmm0);
-			vpackssdw(xmm0, xmm0);
-
-			// GSVector4i b = GSVector4i(db * m_shift[i]).ps32();
-
-			vmulps(xmm1, xmm3, Xmm(4 + i));
-			vcvttps2dq(xmm1, xmm1);
-			vpackssdw(xmm1, xmm1);
-
-			// m_local.d[i].rb = r.upl16(b);
-
-			vpunpcklwd(xmm0, xmm1);
-			vmovdqa(ptr[&m_local.d[i].rb], xmm0);
-		}
-
-		// GSVector4 c = dscan.c;
-
-		vmovaps(xmm0, ptr[edx + offsetof(GSVertexSW, c)]); // not enough regs, have to reload it
-
-		// GSVector4 dg = c.yyyy();
-		// GSVector4 da = c.wwww();
-
-		vshufps(xmm2, xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
-		vshufps(xmm3, xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4i g = GSVector4i(dg * m_shift[i]).ps32();
-
-			vmulps(xmm0, xmm2, Xmm(4 + i));
-			vcvttps2dq(xmm0, xmm0);
-			vpackssdw(xmm0, xmm0);
-
-			// GSVector4i a = GSVector4i(da * m_shift[i]).ps32();
-
-			vmulps(xmm1, xmm3, Xmm(4 + i));
-			vcvttps2dq(xmm1, xmm1);
-			vpackssdw(xmm1, xmm1);
-
-			// m_local.d[i].ga = g.upl16(a);
-
-			vpunpcklwd(xmm0, xmm1);
-			vmovdqa(ptr[&m_local.d[i].ga], xmm0);
-		}
-	}
-	else
-	{
-		// GSVector4i c = GSVector4i(vertex[index[last].c);
-
-		int last = 0;
-
-		switch (m_sel.prim)
-		{
-			case GS_POINT_CLASS:    last = 0; break;
-			case GS_LINE_CLASS:     last = 1; break;
-			case GS_TRIANGLE_CLASS: last = 2; break;
-			case GS_SPRITE_CLASS:   last = 1; break;
-		}
-
-		if (!(m_sel.prim == GS_SPRITE_CLASS && (m_en.z || m_en.f))) // if this is a sprite, the last vertex was already loaded in Depth()
-		{
-			mov(ecx, ptr[esp + _index]);
-			mov(ecx, ptr[ecx + sizeof(uint32) * last]);
-			shl(ecx, 6); // * sizeof(GSVertexSW)
-			add(ecx, ptr[esp + _vertex]);
-		}
-
-		vcvttps2dq(xmm0, ptr[ecx + offsetof(GSVertexSW, c)]);
-
-		// c = c.upl16(c.zwxy());
-
-		vpshufd(xmm1, xmm0, _MM_SHUFFLE(1, 0, 3, 2));
-		vpunpcklwd(xmm0, xmm1);
-
-		// if(!tme) c = c.srl16(7);
-
-		if (m_sel.tfx == TFX_NONE)
-		{
-			vpsrlw(xmm0, 7);
-		}
-
-		// m_local.c.rb = c.xxxx();
-		// m_local.c.ga = c.zzzz();
-
-		vpshufd(xmm1, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
-		vpshufd(xmm2, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		vmovdqa(ptr[&m_local.c.rb], xmm1);
-		vmovdqa(ptr[&m_local.c.ga], xmm2);
-	}
-}
-
-#endif

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.x86.avx2.cpp

@@ -1,360 +0,0 @@
-/*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2021 PCSX2 Dev Team
- *
- *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
- *  of the GNU Lesser General Public License as published by the Free Software Found-
- *  ation, either version 3 of the License, or (at your option) any later version.
- *
- *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *  PURPOSE.  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with PCSX2.
- *  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PrecompiledHeader.h"
-#include "GSSetupPrimCodeGenerator.h"
-#include "GSVertexSW.h"
-#include "GS/GS_codegen.h"
-
-#if _M_SSE >= 0x501 && !(defined(_M_AMD64) || defined(_WIN64))
-
-static const int _args = 0;
-static const int _vertex = _args + 4;
-static const int _index = _args + 8;
-static const int _dscan = _args + 12;
-
-void GSSetupPrimCodeGenerator::Generate_AVX2()
-{
-	if ((m_en.z || m_en.f) && m_sel.prim != GS_SPRITE_CLASS || m_en.t || m_en.c && m_sel.iip)
-	{
-		mov(edx, dword[esp + _dscan]);
-
-		for (int i = 0; i < (m_sel.notest ? 2 : 5); i++)
-		{
-			vmovaps(Ymm(3 + i), ptr[g_const->m_shift_256b[i]]);
-		}
-	}
-
-	Depth_AVX2();
-
-	Texture_AVX2();
-
-	Color_AVX2();
-
-	ret();
-}
-
-void GSSetupPrimCodeGenerator::Depth_AVX2()
-{
-	if (!m_en.z && !m_en.f)
-	{
-		return;
-	}
-
-	if (m_sel.prim != GS_SPRITE_CLASS)
-	{
-		// GSVector4 dp8 = dscan.p * GSVector4::broadcast32(&shift[0]);
-
-		vbroadcastf128(ymm0, ptr[edx + offsetof(GSVertexSW, p)]);
-
-		vmulps(ymm1, ymm0, ymm3);
-
-		if (m_en.z)
-		{
-			// m_local.d8.p.z = dp8.extract32<2>();
-
-			vextractps(ptr[&m_local.d8.p.z], xmm1, 2);
-		}
-
-		if (m_en.f)
-		{
-			// m_local.d8.p.f = GSVector4i(dp8).extract32<3>();
-
-			vcvtps2dq(ymm2, ymm1);
-			vpextrd(ptr[&m_local.d8.p.f], xmm2, 3);
-		}
-
-		if (m_en.z)
-		{
-			// GSVector8 dz = GSVector8(dscan.p).zzzz();
-
-			vshufps(ymm2, ymm0, ymm0, _MM_SHUFFLE(2, 2, 2, 2));
-		}
-
-		if (m_en.f)
-		{
-			// GSVector8 df = GSVector8(dscan.p).wwww();
-
-			vshufps(ymm1, ymm0, ymm0, _MM_SHUFFLE(3, 3, 3, 3));
-		}
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-		{
-			if (m_en.z)
-			{
-				// m_local.d[i].z = dz * shift[1 + i];
-
-				if (i < 4)
-					vmulps(ymm0, ymm2, Ymm(4 + i));
-				else
-					vmulps(ymm0, ymm2, ptr[g_const->m_shift_256b[i + 1]]);
-				vmovaps(ptr[&m_local.d[i].z], ymm0);
-			}
-
-			if (m_en.f)
-			{
-				// m_local.d[i].f = GSVector8i(df * m_shift[i]).xxzzlh();
-
-				if (i < 4)
-					vmulps(ymm0, ymm1, Ymm(4 + i));
-				else
-					vmulps(ymm0, ymm1, ptr[g_const->m_shift_256b[i + 1]]);
-				vcvttps2dq(ymm0, ymm0);
-				vpshuflw(ymm0, ymm0, _MM_SHUFFLE(2, 2, 0, 0));
-				vpshufhw(ymm0, ymm0, _MM_SHUFFLE(2, 2, 0, 0));
-				vmovdqa(ptr[&m_local.d[i].f], ymm0);
-			}
-		}
-	}
-	else
-	{
-		// GSVector4 p = vertex[index[1]].p;
-
-		mov(ecx, ptr[esp + _index]);
-		mov(ecx, ptr[ecx + sizeof(uint32) * 1]);
-		shl(ecx, 6); // * sizeof(GSVertexSW)
-		add(ecx, ptr[esp + _vertex]);
-
-		if (m_en.f)
-		{
-			// m_local.p.f = GSVector4i(vertex[index[1]].p).extract32<3>();
-
-			vmovaps(xmm0, ptr[ecx + offsetof(GSVertexSW, p)]);
-			vcvttps2dq(xmm0, xmm0);
-			vpextrd(ptr[&m_local.p.f], xmm0, 3);
-		}
-
-		if (m_en.z)
-		{
-			// m_local.p.z = vertex[index[1]].t.u32[3]; // uint32 z is bypassed in t.w
-
-			mov(eax, ptr[ecx + offsetof(GSVertexSW, t.w)]);
-			mov(ptr[&m_local.p.z], eax);
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Texture_AVX2()
-{
-	if (!m_en.t)
-	{
-		return;
-	}
-
-	// GSVector8 dt(dscan.t);
-
-	vbroadcastf128(ymm0, ptr[edx + offsetof(GSVertexSW, t)]);
-
-	// GSVector8 dt8 = dt * shift[0];
-
-	vmulps(ymm1, ymm0, ymm3);
-
-	if (m_sel.fst)
-	{
-		// m_local.d8.stq = GSVector8::cast(GSVector8i(dt8));
-
-		vcvttps2dq(ymm1, ymm1);
-
-		vmovdqa(ptr[&m_local.d8.stq], xmm1);
-	}
-	else
-	{
-		// m_local.d8.stq = dt8;
-
-		vmovaps(ptr[&m_local.d8.stq], xmm1);
-	}
-
-	for (int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
-	{
-		// GSVector8 dstq = dt.xxxx/yyyy/zzzz();
-
-		vshufps(ymm1, ymm0, ymm0, (uint8)_MM_SHUFFLE(j, j, j, j));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-		{
-			// GSVector8 v = dstq * shift[1 + i];
-
-			if (i < 4)
-				vmulps(ymm2, ymm1, Ymm(4 + i));
-			else
-				vmulps(ymm2, ymm1, ptr[g_const->m_shift_256b[i + 1]]);
-
-			if (m_sel.fst)
-			{
-				// m_local.d[i].s/t = GSVector8::cast(GSVector8i(v));
-
-				vcvttps2dq(ymm2, ymm2);
-
-				switch (j)
-				{
-					case 0: vmovdqa(ptr[&m_local.d[i].s], ymm2); break;
-					case 1: vmovdqa(ptr[&m_local.d[i].t], ymm2); break;
-				}
-			}
-			else
-			{
-				// m_local.d[i].s/t/q = v;
-
-				switch (j)
-				{
-					case 0: vmovaps(ptr[&m_local.d[i].s], ymm2); break;
-					case 1: vmovaps(ptr[&m_local.d[i].t], ymm2); break;
-					case 2: vmovaps(ptr[&m_local.d[i].q], ymm2); break;
-				}
-			}
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Color_AVX2()
-{
-	if (!m_en.c)
-	{
-		return;
-	}
-
-	if (m_sel.iip)
-	{
-		// GSVector8 dc(dscan.c);
-
-		vbroadcastf128(ymm0, ptr[edx + offsetof(GSVertexSW, c)]);
-
-		// m_local.d8.c = GSVector8i(dc * shift[0]).xzyw().ps32();
-
-		vmulps(ymm1, ymm0, ymm3);
-		vcvttps2dq(ymm1, ymm1);
-		vpshufd(ymm1, ymm1, _MM_SHUFFLE(3, 1, 2, 0));
-		vpackssdw(ymm1, ymm1);
-		vmovq(ptr[&m_local.d8.c], xmm1);
-
-		// ymm3 is not needed anymore
-
-		// GSVector8 dr = dc.xxxx();
-		// GSVector8 db = dc.zzzz();
-
-		vshufps(ymm2, ymm0, ymm0, _MM_SHUFFLE(0, 0, 0, 0));
-		vshufps(ymm3, ymm0, ymm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-		{
-			// GSVector8i r = GSVector8i(dr * shift[1 + i]).ps32();
-
-			if (i < 4)
-				vmulps(ymm0, ymm2, Ymm(4 + i));
-			else
-				vmulps(ymm0, ymm2, ptr[g_const->m_shift_256b[i + 1]]);
-			vcvttps2dq(ymm0, ymm0);
-			vpackssdw(ymm0, ymm0);
-
-			// GSVector4i b = GSVector8i(db * shift[1 + i]).ps32();
-
-			if (i < 4)
-				vmulps(ymm1, ymm3, Ymm(4 + i));
-			else
-				vmulps(ymm1, ymm3, ptr[g_const->m_shift_256b[i + 1]]);
-			vcvttps2dq(ymm1, ymm1);
-			vpackssdw(ymm1, ymm1);
-
-			// m_local.d[i].rb = r.upl16(b);
-
-			vpunpcklwd(ymm0, ymm1);
-			vmovdqa(ptr[&m_local.d[i].rb], ymm0);
-		}
-
-		// GSVector8 dc(dscan.c);
-
-		vbroadcastf128(ymm0, ptr[edx + offsetof(GSVertexSW, c)]); // not enough regs, have to reload it
-
-		// GSVector8 dg = dc.yyyy();
-		// GSVector8 da = dc.wwww();
-
-		vshufps(ymm2, ymm0, ymm0, _MM_SHUFFLE(1, 1, 1, 1));
-		vshufps(ymm3, ymm0, ymm0, _MM_SHUFFLE(3, 3, 3, 3));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 8); i++)
-		{
-			// GSVector8i g = GSVector8i(dg * shift[1 + i]).ps32();
-
-			if (i < 4)
-				vmulps(ymm0, ymm2, Ymm(4 + i));
-			else
-				vmulps(ymm0, ymm2, ptr[g_const->m_shift_256b[i + 1]]);
-			vcvttps2dq(ymm0, ymm0);
-			vpackssdw(ymm0, ymm0);
-
-			// GSVector8i a = GSVector8i(da * shift[1 + i]).ps32();
-
-			if (i < 4)
-				vmulps(ymm1, ymm3, Ymm(4 + i));
-			else
-				vmulps(ymm1, ymm3, ptr[g_const->m_shift_256b[i + 1]]);
-			vcvttps2dq(ymm1, ymm1);
-			vpackssdw(ymm1, ymm1);
-
-			// m_local.d[i].ga = g.upl16(a);
-
-			vpunpcklwd(ymm0, ymm1);
-			vmovdqa(ptr[&m_local.d[i].ga], ymm0);
-		}
-	}
-	else
-	{
-		// GSVector8i c = GSVector8i(GSVector8(vertex[index[last]].c));
-
-		int last = 0;
-
-		switch (m_sel.prim)
-		{
-			case GS_POINT_CLASS:    last = 0; break;
-			case GS_LINE_CLASS:     last = 1; break;
-			case GS_TRIANGLE_CLASS: last = 2; break;
-			case GS_SPRITE_CLASS:   last = 1; break;
-		}
-
-		if (!(m_sel.prim == GS_SPRITE_CLASS && (m_en.z || m_en.f))) // if this is a sprite, the last vertex was already loaded in Depth()
-		{
-			mov(ecx, ptr[esp + _index]);
-			mov(ecx, ptr[ecx + sizeof(uint32) * last]);
-			shl(ecx, 6); // * sizeof(GSVertexSW)
-			add(ecx, ptr[esp + _vertex]);
-		}
-
-		vbroadcasti128(ymm0, ptr[ecx + offsetof(GSVertexSW, c)]);
-		vcvttps2dq(ymm0, ymm0);
-
-		// c = c.upl16(c.zwxy());
-
-		vpshufd(ymm1, ymm0, _MM_SHUFFLE(1, 0, 3, 2));
-		vpunpcklwd(ymm0, ymm1);
-
-		// if(!tme) c = c.srl16(7);
-
-		if (m_sel.tfx == TFX_NONE)
-		{
-			vpsrlw(ymm0, 7);
-		}
-
-		// m_local.c.rb = c.xxxx();
-		// m_local.c.ga = c.zzzz();
-
-		vpshufd(ymm1, ymm0, _MM_SHUFFLE(0, 0, 0, 0));
-		vpshufd(ymm2, ymm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		vmovdqa(ptr[&m_local.c.rb], ymm1);
-		vmovdqa(ptr[&m_local.c.ga], ymm2);
-	}
-}
-
-#endif

pcsx2/GS/Renderers/SW/GSSetupPrimCodeGenerator.x86.cpp

@@ -1,350 +0,0 @@
-/*  PCSX2 - PS2 Emulator for PCs
- *  Copyright (C) 2002-2021 PCSX2 Dev Team
- *
- *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
- *  of the GNU Lesser General Public License as published by the Free Software Found-
- *  ation, either version 3 of the License, or (at your option) any later version.
- *
- *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *  PURPOSE.  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with PCSX2.
- *  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "PrecompiledHeader.h"
-#include "GSSetupPrimCodeGenerator.h"
-#include "GSVertexSW.h"
-#include "GS/GS_codegen.h"
-
-#if _M_SSE < 0x501 && !(defined(_M_AMD64) || defined(_WIN64))
-
-static const int _args = 0;
-static const int _vertex = _args + 4;
-static const int _index = _args + 8;
-static const int _dscan = _args + 12;
-
-void GSSetupPrimCodeGenerator::Generate_SSE()
-{
-	if ((m_en.z || m_en.f) && m_sel.prim != GS_SPRITE_CLASS || m_en.t || m_en.c && m_sel.iip)
-	{
-		mov(edx, dword[esp + _dscan]);
-
-		for (int i = 0; i < (m_sel.notest ? 2 : 5); i++)
-		{
-			movaps(Xmm(3 + i), ptr[g_const->m_shift_128b[i]]);
-		}
-	}
-
-	Depth_SSE();
-
-	Texture_SSE();
-
-	Color_SSE();
-
-	ret();
-}
-
-void GSSetupPrimCodeGenerator::Depth_SSE()
-{
-	if (!m_en.z && !m_en.f)
-	{
-		return;
-	}
-
-	if (m_sel.prim != GS_SPRITE_CLASS)
-	{
-		// GSVector4 p = dscan.p;
-
-		movaps(xmm0, ptr[edx + offsetof(GSVertexSW, p)]);
-
-		if (m_en.f)
-		{
-			// GSVector4 df = p.wwww();
-
-			movaps(xmm1, xmm0);
-			shufps(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
-
-			// m_local.d4.f = GSVector4i(df * 4.0f).xxzzlh();
-
-			movaps(xmm2, xmm1);
-			mulps(xmm2, xmm3);
-			cvttps2dq(xmm2, xmm2);
-			pshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-			pshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-			movdqa(ptr[&m_local.d4.f], xmm2);
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-			{
-				// m_local.d[i].f = GSVector4i(df * m_shift[i]).xxzzlh();
-
-				movaps(xmm2, xmm1);
-				mulps(xmm2, Xmm(4 + i));
-				cvttps2dq(xmm2, xmm2);
-				pshuflw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-				pshufhw(xmm2, xmm2, _MM_SHUFFLE(2, 2, 0, 0));
-				movdqa(ptr[&m_local.d[i].f], xmm2);
-			}
-		}
-
-		if (m_en.z)
-		{
-			// GSVector4 dz = p.zzzz();
-
-			shufps(xmm0, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-			// m_local.d4.z = dz * 4.0f;
-
-			movaps(xmm1, xmm0);
-			mulps(xmm1, xmm3);
-			movdqa(ptr[&m_local.d4.z], xmm1);
-
-			for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-			{
-				// m_local.d[i].z = dz * m_shift[i];
-
-				movaps(xmm1, xmm0);
-				mulps(xmm1, Xmm(4 + i));
-				movdqa(ptr[&m_local.d[i].z], xmm1);
-			}
-		}
-	}
-	else
-	{
-		// GSVector4 p = vertex[index[1]].p;
-
-		mov(ecx, ptr[esp + _index]);
-		mov(ecx, ptr[ecx + sizeof(uint32) * 1]);
-		shl(ecx, 6); // * sizeof(GSVertexSW)
-		add(ecx, ptr[esp + _vertex]);
-
-		movaps(xmm0, ptr[ecx + offsetof(GSVertexSW, p)]);
-
-		if (m_en.f)
-		{
-			// m_local.p.f = GSVector4i(p).zzzzh().zzzz();
-
-			cvttps2dq(xmm1, xmm0);
-			pshufhw(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-			pshufd(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-			movdqa(ptr[&m_local.p.f], xmm1);
-		}
-
-		if (m_en.z)
-		{
-			// uint32 z is bypassed in t.w
-
-			movdqa(xmm0, ptr[ecx + offsetof(GSVertexSW, t)]);
-			pshufd(xmm0, xmm0, _MM_SHUFFLE(3, 3, 3, 3));
-			movdqa(ptr[&m_local.p.z], xmm0);
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Texture_SSE()
-{
-	if (!m_en.t)
-	{
-		return;
-	}
-
-	// GSVector4 t = dscan.t;
-
-	movaps(xmm0, ptr[edx + offsetof(GSVertexSW, t)]);
-
-	movaps(xmm1, xmm0);
-	mulps(xmm1, xmm3);
-
-	if (m_sel.fst)
-	{
-		// m_local.d4.stq = GSVector4i(t * 4.0f);
-
-		cvttps2dq(xmm1, xmm1);
-
-		movdqa(ptr[&m_local.d4.stq], xmm1);
-	}
-	else
-	{
-		// m_local.d4.stq = t * 4.0f;
-
-		movaps(ptr[&m_local.d4.stq], xmm1);
-	}
-
-	for (int j = 0, k = m_sel.fst ? 2 : 3; j < k; j++)
-	{
-		// GSVector4 ds = t.xxxx();
-		// GSVector4 dt = t.yyyy();
-		// GSVector4 dq = t.zzzz();
-
-		movaps(xmm1, xmm0);
-		shufps(xmm1, xmm1, (uint8)_MM_SHUFFLE(j, j, j, j));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4 v = ds/dt * m_shift[i];
-
-			movaps(xmm2, xmm1);
-			mulps(xmm2, Xmm(4 + i));
-
-			if (m_sel.fst)
-			{
-				// m_local.d[i].s/t = GSVector4i(v);
-
-				cvttps2dq(xmm2, xmm2);
-
-				switch (j)
-				{
-					case 0: movdqa(ptr[&m_local.d[i].s], xmm2); break;
-					case 1: movdqa(ptr[&m_local.d[i].t], xmm2); break;
-				}
-			}
-			else
-			{
-				// m_local.d[i].s/t/q = v;
-
-				switch (j)
-				{
-					case 0: movaps(ptr[&m_local.d[i].s], xmm2); break;
-					case 1: movaps(ptr[&m_local.d[i].t], xmm2); break;
-					case 2: movaps(ptr[&m_local.d[i].q], xmm2); break;
-				}
-			}
-		}
-	}
-}
-
-void GSSetupPrimCodeGenerator::Color_SSE()
-{
-	if (!m_en.c)
-	{
-		return;
-	}
-
-	if (m_sel.iip)
-	{
-		// GSVector4 c = dscan.c;
-
-		movaps(xmm0, ptr[edx + offsetof(GSVertexSW, c)]);
-		movaps(xmm1, xmm0);
-
-		// m_local.d4.c = GSVector4i(c * 4.0f).xzyw().ps32();
-
-		movaps(xmm2, xmm0);
-		mulps(xmm2, xmm3);
-		cvttps2dq(xmm2, xmm2);
-		pshufd(xmm2, xmm2, _MM_SHUFFLE(3, 1, 2, 0));
-		packssdw(xmm2, xmm2);
-		movdqa(ptr[&m_local.d4.c], xmm2);
-
-		// xmm3 is not needed anymore
-
-		// GSVector4 dr = c.xxxx();
-		// GSVector4 db = c.zzzz();
-
-		shufps(xmm0, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
-		shufps(xmm1, xmm1, _MM_SHUFFLE(2, 2, 2, 2));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4i r = GSVector4i(dr * m_shift[i]).ps32();
-
-			movaps(xmm2, xmm0);
-			mulps(xmm2, Xmm(4 + i));
-			cvttps2dq(xmm2, xmm2);
-			packssdw(xmm2, xmm2);
-
-			// GSVector4i b = GSVector4i(db * m_shift[i]).ps32();
-
-			movaps(xmm3, xmm1);
-			mulps(xmm3, Xmm(4 + i));
-			cvttps2dq(xmm3, xmm3);
-			packssdw(xmm3, xmm3);
-
-			// m_local.d[i].rb = r.upl16(b);
-
-			punpcklwd(xmm2, xmm3);
-			movdqa(ptr[&m_local.d[i].rb], xmm2);
-		}
-
-		// GSVector4 c = dscan.c;
-
-		movaps(xmm0, ptr[edx + offsetof(GSVertexSW, c)]); // not enough regs, have to reload it
-		movaps(xmm1, xmm0);
-
-		// GSVector4 dg = c.yyyy();
-		// GSVector4 da = c.wwww();
-
-		shufps(xmm0, xmm0, _MM_SHUFFLE(1, 1, 1, 1));
-		shufps(xmm1, xmm1, _MM_SHUFFLE(3, 3, 3, 3));
-
-		for (int i = 0; i < (m_sel.notest ? 1 : 4); i++)
-		{
-			// GSVector4i g = GSVector4i(dg * m_shift[i]).ps32();
-
-			movaps(xmm2, xmm0);
-			mulps(xmm2, Xmm(4 + i));
-			cvttps2dq(xmm2, xmm2);
-			packssdw(xmm2, xmm2);
-
-			// GSVector4i a = GSVector4i(da * m_shift[i]).ps32();
-
-			movaps(xmm3, xmm1);
-			mulps(xmm3, Xmm(4 + i));
-			cvttps2dq(xmm3, xmm3);
-			packssdw(xmm3, xmm3);
-
-			// m_local.d[i].ga = g.upl16(a);
-
-			punpcklwd(xmm2, xmm3);
-			movdqa(ptr[&m_local.d[i].ga], xmm2);
-		}
-	}
-	else
-	{
-		// GSVector4i c = GSVector4i(vertex[index[last].c);
-
-		int last = 0;
-
-		switch (m_sel.prim)
-		{
-			case GS_POINT_CLASS:    last = 0; break;
-			case GS_LINE_CLASS:     last = 1; break;
-			case GS_TRIANGLE_CLASS: last = 2; break;
-			case GS_SPRITE_CLASS:   last = 1; break;
-		}
-
-		if (!(m_sel.prim == GS_SPRITE_CLASS && (m_en.z || m_en.f))) // if this is a sprite, the last vertex was already loaded in Depth()
-		{
-			mov(ecx, ptr[esp + _index]);
-			mov(ecx, ptr[ecx + sizeof(uint32) * last]);
-			shl(ecx, 6); // * sizeof(GSVertexSW)
-			add(ecx, ptr[esp + _vertex]);
-		}
-
-		cvttps2dq(xmm0, ptr[ecx + offsetof(GSVertexSW, c)]);
-
-		// c = c.upl16(c.zwxy());
-
-		pshufd(xmm1, xmm0, _MM_SHUFFLE(1, 0, 3, 2));
-		punpcklwd(xmm0, xmm1);
-
-		// if(!tme) c = c.srl16(7);
-
-		if (m_sel.tfx == TFX_NONE)
-		{
-			psrlw(xmm0, 7);
-		}
-
-		// m_local.c.rb = c.xxxx();
-		// m_local.c.ga = c.zzzz();
-
-		pshufd(xmm1, xmm0, _MM_SHUFFLE(0, 0, 0, 0));
-		pshufd(xmm2, xmm0, _MM_SHUFFLE(2, 2, 2, 2));
-
-		movdqa(ptr[&m_local.c.rb], xmm1);
-		movdqa(ptr[&m_local.c.ga], xmm2);
-	}
-}
-
-#endif

pcsx2/GS/config.h

@@ -28,6 +28,8 @@
 
 //#define DISABLE_DATE
 
+// Not yet used/experimental OpenGL extensions
+//#define GL_EXT_TEX_SUB_IMAGE
 
 #if !defined(NDEBUG) || defined(_DEBUG) || defined(_DEVEL)
 #define ENABLE_OGL_DEBUG // Create a debug context and check opengl command status. Allow also to dump various textures/states.

pcsx2/IPC.cpp

@@ -381,7 +381,16 @@ SocketIPC::IPCBuffer SocketIPC::ParseCommand(char* buf, char* ret_buffer, u32 bu
 			case MsgVersion:
 			{
 				char version[256] = {};
-				sprintf(version, "PCSX2 %u.%u.%u-%lld %s", PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo, SVN_REV, SVN_MODS ? "(modded)" : "");
+				if (GIT_TAGGED_COMMIT) // Nightly builds
+				{
+					// tagged commit - more modern implementation of dev build versioning
+					// - there is no need to include the commit - that is associated with the tag, git is implied
+					sprintf(version, "PCSX2 Nightly - %s", GIT_TAG);
+				}
+				else
+				{
+					sprintf(version, "PCSX2 %u.%u.%u-%lld", PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo, SVN_REV);
+				}
 				version[255] = 0x00;
 				if (!SafetyChecks(buf_cnt, 0, ret_cnt, 256, buf_size))
 					goto error;

pcsx2/SPU2/ReadInput.cpp

@@ -111,11 +111,17 @@ StereoOut32 V_Core::ReadInput()
 			SetIrqCall(i);
 
 	// PlayMode & 2 is Bypass Mode, so it doesn't go through the SPU
-	if ((AutoDMACtrl & (Index + 1)) && !(Index == 0 && (PlayMode & 2) != 0))
+	if ((Index == 1) || !(Index == 0 && (PlayMode & 2) != 0))
 	{
 		retval = StereoOut32(
 			(s32)(*GetMemPtr(0x2000 + (Index << 10) + ReadIndex)),
 			(s32)(*GetMemPtr(0x2200 + (Index << 10) + ReadIndex)));
+
+		// Not accurate behaviour but shouldn't hurt for now, need to run some tests
+		// to see why Prince of Persia Warrior Within buzzes when going in to the map
+		// since it starts an ADMA of music, then kills ADMA, so it loops on a few ms of data.
+		GetMemPtr(0x2000 + (Index << 10) + ReadIndex)[0] = 0;
+		GetMemPtr(0x2200 + (Index << 10) + ReadIndex)[0] = 0;
 	}
 
 #ifdef PCSX2_DEVBUILD

pcsx2/System.cpp

@@ -156,13 +156,21 @@ void SysLogMachineCaps()
 {
 	if ( !PCSX2_isReleaseVersion )
 	{
-		Console.WriteLn(Color_StrongGreen, "\nPCSX2 %u.%u.%u-%lld %s"
+		if (GIT_TAGGED_COMMIT) // Nightly builds
+		{
+			// tagged commit - more modern implementation of dev build versioning
+			// - there is no need to include the commit - that is associated with the tag, 
+			// - git is implied and the tag is timestamped
+			Console.WriteLn(Color_StrongGreen, "\nPCSX2 Nightly - %s Compiled on %s", GIT_TAG, __DATE__);
+		} else {
+			Console.WriteLn(Color_StrongGreen, "\nPCSX2 %u.%u.%u-%lld"
 #ifndef DISABLE_BUILD_DATE
-			"- compiled on " __DATE__
+											   "- compiled on " __DATE__
 #endif
-			, PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo,
-			SVN_REV, SVN_MODS ? "(modded)" : ""
-			);
+				,
+				PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo,
+				SVN_REV);
+		}
 	}
 	else { // shorter release version string
 		Console.WriteLn(Color_StrongGreen, "PCSX2 %u.%u.%u-%lld"

pcsx2/gui/MainFrame.cpp

@@ -621,6 +621,12 @@ MainEmuFrame::MainEmuFrame(wxWindow* parent, const wxString& title)
 		// stable releases, with a simple title.
 		wintitle.Printf(L"%s  %d.%d.%d", pxGetAppName().c_str(), PCSX2_VersionHi, PCSX2_VersionMid, PCSX2_VersionLo);
 	}
+	else if (GIT_TAGGED_COMMIT) // Nightly builds
+	{
+		// tagged commit - more modern implementation of dev build versioning
+		// - there is no need to include the commit - that is associated with the tag, git is implied
+		wintitle.Printf(L"%s Nightly - %s", pxGetAppName().c_str(), GIT_TAG);
+	}
 	else
 	{
 		// beta / development editions, which feature revision number and compile date.
@@ -630,8 +636,8 @@ MainEmuFrame::MainEmuFrame(wxWindow* parent, const wxString& title)
 		}
 		else
 		{
-			wintitle.Printf(L"%s  %d.%d.%d-%lld%s (git)", pxGetAppName().c_str(), PCSX2_VersionHi, PCSX2_VersionMid,
-				PCSX2_VersionLo, SVN_REV, SVN_MODS ? L"m" : wxEmptyString);
+			wintitle.Printf(L"%s  %d.%d.%d-%lld (git)", pxGetAppName().c_str(), PCSX2_VersionHi, PCSX2_VersionMid,
+				PCSX2_VersionLo, SVN_REV);
 		}
 	}
 

pcsx2/pcsx2.vcxproj

@@ -466,12 +466,8 @@
     <ClCompile Include="GS\GSDrawingContext.cpp" />
     <ClCompile Include="GS\Renderers\SW\GSDrawScanline.cpp" />
     <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x64.avx.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x64.avx2.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x64.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x86.avx.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x86.avx2.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x86.cpp" />
+    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.all.cpp" />
+    <ClCompile Include="GS\Renderers\SW\GSNewCodeGenerator.cpp" />
     <ClCompile Include="GS\GSDump.cpp" />
     <ClCompile Include="GS\Renderers\Common\GSFunctionMap.cpp" />
     <ClCompile Include="GS\Renderers\HW\GSHwHack.cpp" />
@@ -490,12 +486,7 @@
     <ClCompile Include="GS\Window\GSSetting.cpp" />
     <ClCompile Include="GS\Window\GSSettingsDlg.cpp" />
     <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x64.avx.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x64.avx2.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x64.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x86.avx.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x86.avx2.cpp" />
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x86.cpp" />
+    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.all.cpp" />
     <ClCompile Include="GS\Renderers\OpenGL\GSShaderOGL.cpp" />
     <ClCompile Include="GS\GSState.cpp" />
     <ClCompile Include="GS\GSTables.cpp" />
@@ -815,7 +806,6 @@
     <ClInclude Include="GS\Renderers\OpenGL\GLLoader.h" />
     <ClInclude Include="GS\Renderers\OpenGL\GLState.h" />
     <ClInclude Include="GS\GS.h" />
-    <ClInclude Include="GS\GS_codegen.h" />
     <ClInclude Include="GS\GS_types.h" />
     <ClInclude Include="GS\GSAlignedClass.h" />
     <ClInclude Include="GS\GSBlock.h" />
@@ -834,6 +824,8 @@
     <ClInclude Include="GS\GSDrawingEnvironment.h" />
     <ClInclude Include="GS\Renderers\SW\GSDrawScanline.h" />
     <ClInclude Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.h" />
+    <ClInclude Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.all.h" />
+    <ClInclude Include="GS\Renderers\SW\GSNewCodeGenerator.h" />
     <ClInclude Include="GS\GSDump.h" />
     <ClInclude Include="GS\Renderers\Common\GSFastList.h" />
     <ClInclude Include="GS\Renderers\Common\GSFunctionMap.h" />
@@ -853,6 +845,7 @@
     <ClInclude Include="GS\Window\GSSetting.h" />
     <ClInclude Include="GS\Window\GSSettingsDlg.h" />
     <ClInclude Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.h" />
+    <ClInclude Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.all.h" />
     <ClInclude Include="GS\Renderers\OpenGL\GSShaderOGL.h" />
     <ClInclude Include="GS\GSState.h" />
     <ClInclude Include="GS\GSTables.h" />

pcsx2/pcsx2.vcxproj.filters

@@ -1517,22 +1517,10 @@
     <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.cpp">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x64.avx.cpp">
+    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.all.cpp">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x64.avx2.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x64.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x86.avx.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x86.avx2.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.x86.cpp">
+    <ClCompile Include="GS\Renderers\SW\GSNewCodeGenerator.cpp">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClCompile>
     <ClCompile Include="GS\Renderers\SW\GSRendererSW.cpp">
@@ -1541,24 +1529,6 @@
     <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.cpp">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x64.avx.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x64.avx2.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x64.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x86.avx.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x86.avx2.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
-    <ClCompile Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.x86.cpp">
-      <Filter>System\Ps2\GS\Renderers\Software</Filter>
-    </ClCompile>
     <ClCompile Include="GS\Renderers\SW\GSTextureCacheSW.cpp">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClCompile>
@@ -2508,9 +2478,6 @@
     <ClInclude Include="GS\GS.h">
       <Filter>System\Ps2\GS</Filter>
     </ClInclude>
-    <ClInclude Include="GS\GS_codegen.h">
-      <Filter>System\Ps2\GS</Filter>
-    </ClInclude>
     <ClInclude Include="GS\GS_types.h">
       <Filter>System\Ps2\GS</Filter>
     </ClInclude>
@@ -2631,6 +2598,12 @@
     <ClInclude Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.h">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClInclude>
+    <ClInclude Include="GS\Renderers\SW\GSDrawScanlineCodeGenerator.all.h">
+      <Filter>System\Ps2\GS\Renderers\Software</Filter>
+    </ClInclude>
+    <ClInclude Include="GS\Renderers\SW\GSNewCodeGenerator.h">
+      <Filter>System\Ps2\GS\Renderers\Software</Filter>
+    </ClInclude>
     <ClInclude Include="GS\Renderers\SW\GSRendererSW.h">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClInclude>
@@ -2640,6 +2613,9 @@
     <ClInclude Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.h">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClInclude>
+    <ClInclude Include="GS\Renderers\SW\GSSetupPrimCodeGenerator.all.h">
+      <Filter>System\Ps2\GS\Renderers\Software</Filter>
+    </ClInclude>
     <ClInclude Include="GS\Renderers\SW\GSTextureCacheSW.h">
       <Filter>System\Ps2\GS\Renderers\Software</Filter>
     </ClInclude>

pcsx2/x86/ix86-32/iR5900LoadStore.cpp

@@ -538,6 +538,11 @@ void recLDL()
 	if (GPR_IS_CONST1(_Rs_))
 	{
 		u32 srcadr = g_cpuConstRegs[_Rs_].UL[0] + _Imm_;
+
+		// If _Rs_ is equal to _Rt_ we need to put the shift in to eax since it won't take the CONST path
+		if (_Rs_ == _Rt_)
+			xMOV(calleeSavedReg1d, srcadr);
+
 		srcadr &= ~0x07;
 
 		t2reg = vtlb_DynGenRead64_Const(64, srcadr, -1);
@@ -609,6 +614,11 @@ void recLDR()
 	if (GPR_IS_CONST1(_Rs_))
 	{
 		u32 srcadr = g_cpuConstRegs[_Rs_].UL[0] + _Imm_;
+
+		// If _Rs_ is equal to _Rt_ we need to put the shift in to eax since it won't take the CONST path
+		if(_Rs_ == _Rt_)
+			xMOV(calleeSavedReg1d, srcadr);
+
 		srcadr &= ~0x07;
 
 		t2reg = vtlb_DynGenRead64_Const(64, srcadr, -1);