Remove barrier on Intel if control flow is potentially divergent (#5044)

* Remove barrier on Intel if control flow is potentially divergent

* Shader cache version bump

.editorconfig

@@ -63,6 +63,10 @@ dotnet_code_quality_unused_parameters = all:suggestion
 
 #### C# Coding Conventions ####
 
+# Namespace preferences
+csharp_style_namespace_declarations = block_scoped:warning
+resharper_csharp_namespace_body = block_scoped
+
 # var preferences
 csharp_style_var_elsewhere = false:silent
 csharp_style_var_for_built_in_types = false:silent

.github/ISSUE_TEMPLATE/missing_shader_instruction.yml

@@ -0,0 +1,19 @@
+name: Missing Shader Instruction
+description: Shader Instruction is missing in Ryujinx.
+title: "[GPU]"
+labels: [gpu, not-implemented]
+body:
+  - type: textarea
+    id: instruction
+    attributes:
+      label: Shader instruction
+      description: What shader instruction is missing?
+    validations:
+      required: true
+  - type: textarea
+    id: required
+    attributes:
+      label: Required by
+      description: Add links to the [compatibility list page(s)](https://github.com/Ryujinx/Ryujinx-Games-List/issues) of the game(s) that require this instruction.
+    validations:
+      required: true

.github/workflows/build.yml

@@ -18,10 +18,20 @@ on:
       - '*.yml'
       - 'README.md'
 
+concurrency:
+  group: pr-checks-${{ github.event.number }}
+  cancel-in-progress: true
+
+env:
+  POWERSHELL_TELEMETRY_OPTOUT: 1
+  DOTNET_CLI_TELEMETRY_OPTOUT: 1
+  RYUJINX_BASE_VERSION: "1.1.0"
+
 jobs:
   build:
-    name: ${{ matrix.os }} (${{ matrix.configuration }})
+    name: ${{ matrix.OS_NAME }} (${{ matrix.configuration }})
     runs-on: ${{ matrix.os }}
+    timeout-minutes: 45
     strategy:
       matrix:
         os: [ubuntu-latest, macOS-latest, windows-latest]
@@ -33,7 +43,7 @@ jobs:
           RELEASE_ZIP_OS_NAME: linux_x64
 
         - os: macOS-latest
-          OS_NAME: MacOS x64
+          OS_NAME: macOS x64
           DOTNET_RUNTIME_IDENTIFIER: osx-x64
           RELEASE_ZIP_OS_NAME: osx_x64
 
@@ -43,47 +53,107 @@ jobs:
           RELEASE_ZIP_OS_NAME: win_x64
 
       fail-fast: false
-    env:
-      POWERSHELL_TELEMETRY_OPTOUT: 1
-      DOTNET_CLI_TELEMETRY_OPTOUT: 1
-      RYUJINX_BASE_VERSION: "1.1.0"
     steps:
       - uses: actions/checkout@v3
+
       - uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 7.0.x
+          global-json-file: global.json
+
       - name: Get git short hash
         id: git_short_hash
         run: echo "result=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
         shell: bash
+
       - name: Build
         run: dotnet build -c "${{ matrix.configuration }}" -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER
+
       - name: Test
         run: dotnet test --no-build -c "${{ matrix.configuration }}"
+
       - name: Publish Ryujinx
-        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER Ryujinx --self-contained true
-        if: github.event_name == 'pull_request'
+        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx --self-contained true
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
       - name: Publish Ryujinx.Headless.SDL2
-        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_sdl2_headless -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER Ryujinx.Headless.SDL2 --self-contained true
-        if: github.event_name == 'pull_request'
+        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_sdl2_headless -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx.Headless.SDL2 --self-contained true
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
       - name: Publish Ryujinx.Ava
-        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_ava -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER Ryujinx.Ava --self-contained true
-        if: github.event_name == 'pull_request'
+        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_ava -p:Version="${{ env.RYUJINX_BASE_VERSION }}" -p:DebugType=embedded -p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" -p:ExtraDefineConstants=DISABLE_UPDATER src/Ryujinx.Ava --self-contained true
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
+      - name: Set executable bit
+        run: |
+          chmod +x ./publish/Ryujinx ./publish/Ryujinx.sh
+          chmod +x ./publish_sdl2_headless/Ryujinx.Headless.SDL2 ./publish_sdl2_headless/Ryujinx.sh
+          chmod +x ./publish_ava/Ryujinx.Ava ./publish_ava/Ryujinx.sh
+        if: github.event_name == 'pull_request' && matrix.os == 'ubuntu-latest'
+
       - name: Upload Ryujinx artifact
         uses: actions/upload-artifact@v3
         with:
           name: ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.RELEASE_ZIP_OS_NAME }}
           path: publish
-        if: github.event_name == 'pull_request'
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
       - name: Upload Ryujinx.Headless.SDL2 artifact
         uses: actions/upload-artifact@v3
         with:
           name: sdl2-ryujinx-headless-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.RELEASE_ZIP_OS_NAME }}
           path: publish_sdl2_headless
-        if: github.event_name == 'pull_request'
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
       - name: Upload Ryujinx.Ava artifact
         uses: actions/upload-artifact@v3
         with:
           name: ava-ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-${{ matrix.RELEASE_ZIP_OS_NAME }}
           path: publish_ava
-        if: github.event_name == 'pull_request'
+        if: github.event_name == 'pull_request' && matrix.os != 'macOS-latest'
+
+  build_macos:
+    name: macOS Universal (${{ matrix.configuration }})
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    strategy:
+      matrix:
+        configuration: [ Debug, Release ]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-dotnet@v3
+        with:
+          global-json-file: global.json
+
+      - name: Setup LLVM 14
+        run: |
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 14
+
+      - name: Install rcodesign
+        run: |
+          mkdir -p $HOME/.bin
+          gh release download -R indygreg/apple-platform-rs -O apple-codesign.tar.gz -p 'apple-codesign-*-x86_64-unknown-linux-musl.tar.gz'
+          tar -xzvf apple-codesign.tar.gz --wildcards '*/rcodesign' --strip-components=1
+          rm apple-codesign.tar.gz
+          mv rcodesign $HOME/.bin/
+          echo "$HOME/.bin" >> $GITHUB_PATH
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get git short hash
+        id: git_short_hash
+        run: echo "result=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
+
+      - name: Publish macOS
+        run: |
+          ./distribution/macos/create_macos_build.sh . publish_tmp publish_ava ./distribution/macos/entitlements.xml "${{ env.RYUJINX_BASE_VERSION }}" "${{ steps.git_short_hash.outputs.result }}" "${{ matrix.configuration }}" "-p:ExtraDefineConstants=DISABLE_UPDATER"
+
+      - name: Upload Ryujinx.Ava artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ava-ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-macos_universal
+          path: "publish_ava/*.tar.gz"
+        if: github.event_name == 'pull_request'

.github/workflows/flatpak.yml

@@ -12,13 +12,14 @@ concurrency: flatpak-release
 
 jobs:
   release:
+    timeout-minutes: ${{ fromJSON(vars.JOB_TIMEOUT) }}
     runs-on: ubuntu-latest
 
     env:
       NUGET_PACKAGES: ${{ github.workspace }}/.nuget/packages
       GIT_COMMITTER_NAME: "RyujinxBot"
       GIT_COMMITTER_EMAIL: "61127645+RyujinxBot@users.noreply.github.com"
-      RYUJINX_PROJECT_FILE: "Ryujinx/Ryujinx.csproj"
+      RYUJINX_PROJECT_FILE: "src/Ryujinx/Ryujinx.csproj"
       NUGET_SOURCES_DESTDIR: "nuget-sources"
       RYUJINX_VERSION: "${{ inputs.ryujinx_version }}"
 
@@ -168,4 +169,4 @@ jobs:
           git config user.email "${{ env.GIT_COMMITTER_EMAIL }}"
           git add .
           git commit -m "$COMMIT_MESSAGE"
-          git push origin master
+          git push origin master

.github/workflows/nightly_pr_comment.yml

@@ -7,6 +7,7 @@ jobs:
   pr_comment:
     if: github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success'
     runs-on: ubuntu-latest
+    timeout-minutes: ${{ fromJSON(vars.JOB_TIMEOUT) }}
     steps:
       - uses: actions/github-script@v6
         with:
@@ -65,4 +66,4 @@ jobs:
             } else {
               core.info(`Creating a comment`);
               await github.rest.issues.createComment({repo, owner, issue_number, body});
-            }
+            }

.github/workflows/release.yml

@@ -22,98 +22,18 @@ env:
   RYUJINX_TARGET_RELEASE_CHANNEL_REPO: "release-channel-master"
 
 jobs:
-  release:
-    runs-on: windows-latest
+  tag:
+    name: Create tag
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-dotnet@v3
-        with:
-          global-json-file: global.json
       - name: Get version info
         id: version_info
         run: |
           echo "build_version=${{ env.RYUJINX_BASE_VERSION }}.${{ github.run_number }}" >> $GITHUB_OUTPUT
-          echo "git_short_hash=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
         shell: bash
-      - name: Configure for release
-        run: |
-          sed -r --in-place 's/\%\%RYUJINX_BUILD_VERSION\%\%/${{ steps.version_info.outputs.build_version }}/g;' Ryujinx.Common/ReleaseInformation.cs
-          sed -r --in-place 's/\%\%RYUJINX_BUILD_GIT_HASH\%\%/${{ steps.version_info.outputs.git_short_hash }}/g;' Ryujinx.Common/ReleaseInformation.cs
-          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_NAME\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_NAME }}/g;' Ryujinx.Common/ReleaseInformation.cs
-          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_OWNER\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}/g;' Ryujinx.Common/ReleaseInformation.cs
-          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_REPO\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}/g;' Ryujinx.Common/ReleaseInformation.cs
-        shell: bash
-      - name: Create output dir
-        run: "mkdir release_output"
-      - name: Publish Windows
-        run: |
-          dotnet publish -c Release -r win10-x64 -o ./publish_windows/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx --self-contained true
-          dotnet publish -c Release -r win10-x64 -o ./publish_windows_sdl2_headless/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx.Headless.SDL2 --self-contained true
-          dotnet publish -c Release -r win10-x64 -o ./publish_windows_ava/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx.Ava --self-contained true
-      - name: Packing Windows builds
-        run: |
-          pushd publish_windows
-          7z a ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
-          popd
-
-          pushd publish_windows_sdl2_headless
-          7z a ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
-          popd
-
-          pushd publish_windows_ava
-          7z a ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
-          popd
-        shell: bash
-
-      - name: Publish Linux
-        run: |
-          dotnet publish -c Release -r linux-x64 -o ./publish_linux/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx --self-contained true
-          dotnet publish -c Release -r linux-x64 -o ./publish_linux_sdl2_headless/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx.Headless.SDL2 --self-contained true
-          dotnet publish -c Release -r linux-x64 -o ./publish_linux_ava/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded Ryujinx.Ava --self-contained true
-
-      - name: Packing Linux builds
-        run: |
-          pushd publish_linux
-          tar --exclude "publish/Ryujinx" --exclude "publish/Ryujinx.sh" -cvf ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar publish
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx" "publish/Ryujinx"
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.sh" "publish/Ryujinx.sh"
-          gzip -9 < ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar > ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz
-          rm ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar
-          popd
-
-          pushd publish_linux_sdl2_headless
-          tar --exclude "publish/Ryujinx.Headless.SDL2" --exclude "publish/Ryujinx.sh" -cvf ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar publish
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.Headless.SDL2" "publish/Ryujinx.Headless.SDL2"
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.sh" "publish/Ryujinx.sh"
-          gzip -9 < ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar > ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz
-          rm ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar
-          popd
-
-          pushd publish_linux_ava
-          tar --exclude "publish/Ryujinx.Ava" --exclude "publish/Ryujinx.sh" -cvf ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar publish
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.Ava" "publish/Ryujinx.Ava"
-          python3 ../distribution/misc/add_tar_exec.py ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar "publish/Ryujinx.sh" "publish/Ryujinx.sh"
-          gzip -9 < ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar > ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz
-          rm ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar
-          popd
-        shell: bash
-
-      - name: Pushing new release
-        uses: ncipollo/release-action@v1
-        with:
-          name: ${{ steps.version_info.outputs.build_version }}
-          artifacts: "release_output/*.tar.gz,release_output/*.zip"
-          tag: ${{ steps.version_info.outputs.build_version }}
-          body: "For more informations about this release please check out the official [Changelog](https://github.com/Ryujinx/Ryujinx/wiki/Changelog)."
-          allowUpdates: true
-          removeArtifacts: true
-          replacesArtifacts: true
-          owner: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}
-          repo: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}
-          token: ${{ secrets.RELEASE_TOKEN }}
 
       - name: Create tag
-        uses: actions/github-script@v5
+        uses: actions/github-script@v6
         with:
           script: |
             github.rest.git.createRef({
@@ -123,9 +43,168 @@ jobs:
               sha: context.sha
             })
 
+  release:
+    name: Release ${{ matrix.OS_NAME }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: ${{ fromJSON(vars.JOB_TIMEOUT) }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, windows-latest ]
+        include:
+          - os: ubuntu-latest
+            OS_NAME: Linux x64
+            DOTNET_RUNTIME_IDENTIFIER: linux-x64
+            RELEASE_ZIP_OS_NAME: linux_x64
+
+          - os: windows-latest
+            OS_NAME: Windows x64
+            DOTNET_RUNTIME_IDENTIFIER: win10-x64
+            RELEASE_ZIP_OS_NAME: win_x64
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-dotnet@v3
+        with:
+          global-json-file: global.json
+
+      - name: Get version info
+        id: version_info
+        run: |
+          echo "build_version=${{ env.RYUJINX_BASE_VERSION }}.${{ github.run_number }}" >> $GITHUB_OUTPUT
+          echo "git_short_hash=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - name: Configure for release
+        run: |
+          sed -r --in-place 's/\%\%RYUJINX_BUILD_VERSION\%\%/${{ steps.version_info.outputs.build_version }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_BUILD_GIT_HASH\%\%/${{ steps.version_info.outputs.git_short_hash }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_NAME\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_NAME }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_OWNER\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_REPO\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+        shell: bash
+
+      - name: Create output dir
+        run: "mkdir release_output"
+
+      - name: Publish
+        run: |
+          dotnet publish -c Release -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_gtk/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded src/Ryujinx --self-contained true
+          dotnet publish -c Release -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_sdl2_headless/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded src/Ryujinx.Headless.SDL2 --self-contained true
+          dotnet publish -c Release -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_ava/publish -p:Version="${{ steps.version_info.outputs.build_version }}" -p:SourceRevisionId="${{ steps.version_info.outputs.git_short_hash }}" -p:DebugType=embedded src/Ryujinx.Ava --self-contained true
+
+      - name: Packing Windows builds
+        if: matrix.os == 'windows-latest'
+        run: |
+          pushd publish_gtk
+          7z a ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
+          popd
+
+          pushd publish_sdl2_headless
+          7z a ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
+          popd
+
+          pushd publish_ava
+          7z a ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-win_x64.zip publish
+          popd
+        shell: bash
+
+      - name: Packing Linux builds
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          pushd publish_gtk
+          chmod +x publish/Ryujinx.sh publish/Ryujinx
+          tar -czvf ../release_output/ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz publish
+          popd
+
+          pushd publish_sdl2_headless
+          chmod +x publish/Ryujinx.sh publish/Ryujinx.Headless.SDL2
+          tar -czvf ../release_output/sdl2-ryujinx-headless-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz publish
+          popd
+
+          pushd publish_ava
+          chmod +x publish/Ryujinx.sh publish/Ryujinx.Ava
+          tar -czvf ../release_output/test-ava-ryujinx-${{ steps.version_info.outputs.build_version }}-linux_x64.tar.gz publish
+          popd
+        shell: bash
+
+      - name: Pushing new release
+        uses: ncipollo/release-action@v1
+        with:
+          name: ${{ steps.version_info.outputs.build_version }}
+          artifacts: "release_output/*.tar.gz,release_output/*.zip"
+          tag: ${{ steps.version_info.outputs.build_version }}
+          body: "For more information about this release please check out the official [Changelog](https://github.com/Ryujinx/Ryujinx/wiki/Changelog)."
+          omitBodyDuringUpdate: true
+          allowUpdates: true
+          replacesArtifacts: true
+          owner: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}
+          repo: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}
+          token: ${{ secrets.RELEASE_TOKEN }}
+
+  macos_release:
+    name: Release MacOS universal
+    runs-on: ubuntu-latest
+    timeout-minutes: ${{ fromJSON(vars.JOB_TIMEOUT) }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-dotnet@v3
+        with:
+          global-json-file: global.json
+
+      - name: Setup LLVM 14
+        run: |
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 14
+
+      - name: Install rcodesign
+        run: |
+          mkdir -p $HOME/.bin
+          gh release download -R indygreg/apple-platform-rs -O apple-codesign.tar.gz -p 'apple-codesign-*-x86_64-unknown-linux-musl.tar.gz'
+          tar -xzvf apple-codesign.tar.gz --wildcards '*/rcodesign' --strip-components=1
+          rm apple-codesign.tar.gz
+          mv rcodesign $HOME/.bin/
+          echo "$HOME/.bin" >> $GITHUB_PATH
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get version info
+        id: version_info
+        run: |
+          echo "build_version=${{ env.RYUJINX_BASE_VERSION }}.${{ github.run_number }}" >> $GITHUB_OUTPUT
+          echo "git_short_hash=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT
+
+      - name: Configure for release
+        run: |
+          sed -r --in-place 's/\%\%RYUJINX_BUILD_VERSION\%\%/${{ steps.version_info.outputs.build_version }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_BUILD_GIT_HASH\%\%/${{ steps.version_info.outputs.git_short_hash }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_NAME\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_NAME }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_OWNER\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_REPO\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
+        shell: bash
+
+      - name: Publish macOS
+        run: |
+          ./distribution/macos/create_macos_build.sh . publish_tmp publish_ava ./distribution/macos/entitlements.xml "${{ steps.version_info.outputs.build_version }}" "${{ steps.version_info.outputs.git_short_hash }}" Release
+
+      - name: Pushing new release
+        uses: ncipollo/release-action@v1
+        with:
+          name: ${{ steps.version_info.outputs.build_version }}
+          artifacts: "publish_ava/*.tar.gz"
+          tag: ${{ steps.version_info.outputs.build_version }}
+          body: "For more information about this release please check out the official [Changelog](https://github.com/Ryujinx/Ryujinx/wiki/Changelog)."
+          omitBodyDuringUpdate: true
+          allowUpdates: true
+          replacesArtifacts: true
+          owner: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_OWNER }}
+          repo: ${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}
+          token: ${{ secrets.RELEASE_TOKEN }}
+
   flatpak_release:
     uses: ./.github/workflows/flatpak.yml
     needs: release
     with:
       ryujinx_version: "1.1.${{ github.run_number }}"
-    secrets: inherit
+    secrets: inherit

ARMeilleure/Decoders/IOpCode32Exception.cs

@@ -1,6 +0,0 @@
-namespace ARMeilleure.Decoders;
-
-interface IOpCode32Exception
-{
-    int Id { get; }
-}

ARMeilleure/Translation/DelegateHelper.cs

@@ -1,104 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Reflection.Emit;
-
-namespace ARMeilleure.Translation
-{
-    static class DelegateHelper
-    {
-        private const string DelegateTypesAssemblyName = "JitDelegateTypes";
-
-        private static readonly ModuleBuilder _modBuilder;
-
-        private static readonly Dictionary<string, Type> _delegateTypesCache;
-
-        static DelegateHelper()
-        {
-            AssemblyBuilder asmBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(DelegateTypesAssemblyName), AssemblyBuilderAccess.Run);
-
-            _modBuilder = asmBuilder.DefineDynamicModule(DelegateTypesAssemblyName);
-
-            _delegateTypesCache = new Dictionary<string, Type>();
-        }
-
-        public static Delegate GetDelegate(MethodInfo info)
-        {
-            ArgumentNullException.ThrowIfNull(info);
-
-            Type[] parameters = info.GetParameters().Select(pI => pI.ParameterType).ToArray();
-            Type   returnType = info.ReturnType;
-
-            Type delegateType = GetDelegateType(parameters, returnType);
-
-            return Delegate.CreateDelegate(delegateType, info);
-        }
-
-        private static Type GetDelegateType(Type[] parameters, Type returnType)
-        {
-            string key = GetFunctionSignatureKey(parameters, returnType);
-
-            if (!_delegateTypesCache.TryGetValue(key, out Type delegateType))
-            {
-                delegateType = MakeDelegateType(parameters, returnType, key);
-
-                _delegateTypesCache.TryAdd(key, delegateType);
-            }
-
-            return delegateType;
-        }
-
-        private static string GetFunctionSignatureKey(Type[] parameters, Type returnType)
-        {
-            string sig = GetTypeName(returnType);
-
-            foreach (Type type in parameters)
-            {
-                sig += '_' + GetTypeName(type);
-            }
-
-            return sig;
-        }
-
-        private static string GetTypeName(Type type)
-        {
-            return type.FullName.Replace(".", string.Empty);
-        }
-
-        private const MethodAttributes CtorAttributes =
-            MethodAttributes.RTSpecialName |
-            MethodAttributes.HideBySig     |
-            MethodAttributes.Public;
-
-        private const TypeAttributes DelegateTypeAttributes =
-            TypeAttributes.Class     |
-            TypeAttributes.Public    |
-            TypeAttributes.Sealed    |
-            TypeAttributes.AnsiClass |
-            TypeAttributes.AutoClass;
-
-        private const MethodImplAttributes ImplAttributes =
-            MethodImplAttributes.Runtime |
-            MethodImplAttributes.Managed;
-
-        private const MethodAttributes InvokeAttributes =
-            MethodAttributes.Public    |
-            MethodAttributes.HideBySig |
-            MethodAttributes.NewSlot   |
-            MethodAttributes.Virtual;
-
-        private static readonly Type[] _delegateCtorSignature = { typeof(object), typeof(IntPtr) };
-
-        private static Type MakeDelegateType(Type[] parameters, Type returnType, string name)
-        {
-            TypeBuilder builder = _modBuilder.DefineType(name, DelegateTypeAttributes, typeof(MulticastDelegate));
-
-            builder.DefineConstructor(CtorAttributes, CallingConventions.Standard, _delegateCtorSignature).SetImplementationFlags(ImplAttributes);
-
-            builder.DefineMethod("Invoke", InvokeAttributes, returnType, parameters).SetImplementationFlags(ImplAttributes);
-
-            return builder.CreateTypeInfo();
-        }
-    }
-}

ARMeilleure/Translation/Delegates.cs

@@ -1,267 +0,0 @@
-using ARMeilleure.Instructions;
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-
-namespace ARMeilleure.Translation
-{
-    static class Delegates
-    {
-        public static bool TryGetDelegateFuncPtrByIndex(int index, out IntPtr funcPtr)
-        {
-            if (index >= 0 && index < _delegates.Count)
-            {
-                funcPtr = _delegates.Values[index].FuncPtr; // O(1).
-
-                return true;
-            }
-            else
-            {
-                funcPtr = default;
-
-                return false;
-            }
-        }
-
-        public static IntPtr GetDelegateFuncPtrByIndex(int index)
-        {
-            if (index < 0 || index >= _delegates.Count)
-            {
-                throw new ArgumentOutOfRangeException($"({nameof(index)} = {index})");
-            }
-
-            return _delegates.Values[index].FuncPtr; // O(1).
-        }
-
-        public static IntPtr GetDelegateFuncPtr(MethodInfo info)
-        {
-            ArgumentNullException.ThrowIfNull(info);
-
-            string key = GetKey(info);
-
-            if (!_delegates.TryGetValue(key, out DelegateInfo dlgInfo)) // O(log(n)).
-            {
-                throw new KeyNotFoundException($"({nameof(key)} = {key})");
-            }
-
-            return dlgInfo.FuncPtr;
-        }
-
-        public static int GetDelegateIndex(MethodInfo info)
-        {
-            ArgumentNullException.ThrowIfNull(info);
-
-            string key = GetKey(info);
-
-            int index = _delegates.IndexOfKey(key); // O(log(n)).
-
-            if (index == -1)
-            {
-                throw new KeyNotFoundException($"({nameof(key)} = {key})");
-            }
-
-            return index;
-        }
-
-        private static void SetDelegateInfo(MethodInfo info)
-        {
-            string key = GetKey(info);
-
-            Delegate dlg = DelegateHelper.GetDelegate(info);
-
-            _delegates.Add(key, new DelegateInfo(dlg)); // ArgumentException (key).
-        }
-
-        private static string GetKey(MethodInfo info)
-        {
-            return $"{info.DeclaringType.Name}.{info.Name}";
-        }
-
-        private static readonly SortedList<string, DelegateInfo> _delegates;
-
-        static Delegates()
-        {
-            _delegates = new SortedList<string, DelegateInfo>();
-
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Abs),      new Type[] { typeof(double) }));
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Ceiling),  new Type[] { typeof(double) }));
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Floor),    new Type[] { typeof(double) }));
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Round),    new Type[] { typeof(double), typeof(MidpointRounding) }));
-            SetDelegateInfo(typeof(Math).GetMethod(nameof(Math.Truncate), new Type[] { typeof(double) }));
-
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Abs),      new Type[] { typeof(float) }));
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Ceiling),  new Type[] { typeof(float) }));
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Floor),    new Type[] { typeof(float) }));
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Round),    new Type[] { typeof(float), typeof(MidpointRounding) }));
-            SetDelegateInfo(typeof(MathF).GetMethod(nameof(MathF.Truncate), new Type[] { typeof(float) }));
-
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.Break)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.CheckSynchronization)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.EnqueueForRejit)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntfrqEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntpctEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCntvctEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetCtrEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetDczidEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetFunctionAddress)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.InvalidateCacheLine)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrroEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidr32))); // A32 only.
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.GetTpidrEl032))); // A32 only.
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadByte)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt16)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt32)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadUInt64)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ReadVector128)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SetTpidrEl0)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SetTpidrEl032))); // A32 only.
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SignalMemoryTracking)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.SupervisorCall)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.ThrowInvalidMemoryAccess)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.Undefined)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteByte)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt16)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt32)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteUInt64)));
-            SetDelegateInfo(typeof(NativeInterface).GetMethod(nameof(NativeInterface.WriteVector128)));
-
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.CountLeadingSigns)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.CountLeadingZeros)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32b)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cb)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32ch)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cw)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32cx)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32h)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32w)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Crc32x)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Decrypt)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Encrypt)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.FixedRotate)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashChoose)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashLower)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashMajority)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashParity)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.HashUpper)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.InverseMixColumns)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.MixColumns)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.PolynomialMult64_128)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToS32)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToS64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToU32)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF32ToU64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToS32)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToS64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToU32)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SatF64ToU64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha1SchedulePart1)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha1SchedulePart2)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha256SchedulePart1)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Sha256SchedulePart2)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.SignedShrImm64)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl1)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl2)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl3)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbl4)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx1)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx2)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx3)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.Tbx4)));
-            SetDelegateInfo(typeof(SoftFallback).GetMethod(nameof(SoftFallback.UnsignedShrImm64)));
-
-            SetDelegateInfo(typeof(SoftFloat16_32).GetMethod(nameof(SoftFloat16_32.FPConvert)));
-            SetDelegateInfo(typeof(SoftFloat16_64).GetMethod(nameof(SoftFloat16_64.FPConvert)));
-
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAdd)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPAddFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompare)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQ)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareEQFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGE)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGEFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGT)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareGTFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLE)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLEFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLT)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPCompareLTFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPDiv)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMax)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNum)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMaxNumFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMin)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNum)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMinNumFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMul)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAdd)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulAddFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSub)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulSubFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPMulX)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulAdd)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPNegMulSub)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimate)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipEstimateFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStep))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecipStepFused)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRecpX)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimate)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtEstimateFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStep))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPRSqrtStepFused)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSqrt)));
-            SetDelegateInfo(typeof(SoftFloat32).GetMethod(nameof(SoftFloat32.FPSub)));
-
-            SetDelegateInfo(typeof(SoftFloat32_16).GetMethod(nameof(SoftFloat32_16.FPConvert)));
-
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAdd)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPAddFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompare)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQ)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareEQFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGE)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGEFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGT)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareGTFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLE)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLEFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLT)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPCompareLTFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPDiv)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMax)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNum)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMaxNumFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMin)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNum)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMinNumFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMul)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAdd)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulAddFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSub)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulSubFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPMulX)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulAdd)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPNegMulSub)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimate)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipEstimateFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStep))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecipStepFused)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRecpX)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimate)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtEstimateFpscr))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStep))); // A32 only.
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPRSqrtStepFused)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSqrt)));
-            SetDelegateInfo(typeof(SoftFloat64).GetMethod(nameof(SoftFloat64.FPSub)));
-
-            SetDelegateInfo(typeof(SoftFloat64_16).GetMethod(nameof(SoftFloat64_16.FPConvert)));
-        }
-    }
-}

Directory.Packages.props

@@ -3,17 +3,17 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
   <ItemGroup>
-    <PackageVersion Include="Avalonia" Version="0.10.18" />
-    <PackageVersion Include="Avalonia.Controls.DataGrid" Version="0.10.18" />
-    <PackageVersion Include="Avalonia.Desktop" Version="0.10.18" />
-    <PackageVersion Include="Avalonia.Diagnostics" Version="0.10.18" />
-    <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="0.10.18" />
+    <PackageVersion Include="Avalonia" Version="0.10.21" />
+    <PackageVersion Include="Avalonia.Controls.DataGrid" Version="0.10.21" />
+    <PackageVersion Include="Avalonia.Desktop" Version="0.10.21" />
+    <PackageVersion Include="Avalonia.Diagnostics" Version="0.10.21" />
+    <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="0.10.21" />
     <PackageVersion Include="Avalonia.Svg" Version="0.10.18" />
     <PackageVersion Include="Avalonia.Svg.Skia" Version="0.10.18" />
     <PackageVersion Include="CommandLineParser" Version="2.9.1" />
     <PackageVersion Include="Concentus" Version="1.1.7" />
     <PackageVersion Include="DiscordRichPresence" Version="1.1.3.18" />
-    <PackageVersion Include="DynamicData" Version="7.12.11" />
+    <PackageVersion Include="DynamicData" Version="7.14.2" />
     <PackageVersion Include="FluentAvaloniaUI" Version="1.4.5" />
     <PackageVersion Include="GtkSharp.Dependencies" Version="1.1.1" />
     <PackageVersion Include="GtkSharp.Dependencies.osx" Version="0.0.5" />
@@ -21,7 +21,7 @@
     <PackageVersion Include="LibHac" Version="0.18.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.0" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.6.1" />
     <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="2.3.2" />
     <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
     <PackageVersion Include="NUnit" Version="3.13.3" />
@@ -44,10 +44,10 @@
     <PackageVersion Include="SixLabors.ImageSharp.Drawing" Version="1.0.0-beta11" />
     <PackageVersion Include="SPB" Version="0.0.4-build28" />
     <PackageVersion Include="System.Drawing.Common" Version="7.0.0" />
-    <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="6.27.0" />
+    <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="6.30.1" />
     <PackageVersion Include="System.IO.Hashing" Version="7.0.0" />
-    <PackageVersion Include="System.Management" Version="7.0.0" />
+    <PackageVersion Include="System.Management" Version="7.0.1" />
     <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-fb78016" />
-    <PackageVersion Include="XamlNameReferenceGenerator" Version="1.5.1" />
+    <PackageVersion Include="XamlNameReferenceGenerator" Version="1.6.1" />
   </ItemGroup>
-</Project>
+</Project>

README.md

@@ -40,7 +40,7 @@
 
 ## Compatibility
 
-As of November 2022, Ryujinx has been tested on approximately 3,800 titles; over 3,600 boot past menus and into gameplay, with roughly 3,200 of those being considered playable.
+As of April 2023, Ryujinx has been tested on approximately 4,050 titles; over 4,000 boot past menus and into gameplay, with roughly 3,400 of those being considered playable.
 You can check out the compatibility list [here](https://github.com/Ryujinx/Ryujinx-Games-List/issues). Anyone is free to submit a new game test or update an existing game test entry; simply follow the new issue template and testing guidelines, or post as a reply to the applicable game issue. Use the search function to see if a game has been tested already!
 
 ## Usage

Ryujinx.Ava/UI/Controls/GameGridView.axaml

@@ -1,177 +0,0 @@
-<UserControl
-    x:Class="Ryujinx.Ava.UI.Controls.GameGridView"
-    xmlns="https://github.com/avaloniaui"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-    xmlns:flex="clr-namespace:Avalonia.Flexbox;assembly=Avalonia.Flexbox"
-    xmlns:locale="clr-namespace:Ryujinx.Ava.Common.Locale"
-    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
-    xmlns:helpers="clr-namespace:Ryujinx.Ava.UI.Helpers"
-    d:DesignHeight="450"
-    d:DesignWidth="800"
-    mc:Ignorable="d"
-    Focusable="True">
-    <UserControl.Resources>
-        <helpers:BitmapArrayValueConverter x:Key="ByteImage" />
-        <MenuFlyout x:Key="GameContextMenu">
-            <MenuItem
-                Command="{Binding ToggleFavorite}"
-                Header="{locale:Locale GameListContextMenuToggleFavorite}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuToggleFavoriteToolTip}" />
-            <Separator />
-            <MenuItem
-                Command="{Binding OpenUserSaveDirectory}"
-                IsEnabled="{Binding EnabledUserSaveDirectory}"
-                Header="{locale:Locale GameListContextMenuOpenUserSaveDirectory}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuOpenUserSaveDirectoryToolTip}" />
-            <MenuItem
-                Command="{Binding OpenDeviceSaveDirectory}"
-                IsEnabled="{Binding EnabledDeviceSaveDirectory}"
-                Header="{locale:Locale GameListContextMenuOpenDeviceSaveDirectory}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuOpenDeviceSaveDirectoryToolTip}" />
-            <MenuItem
-                Command="{Binding OpenBcatSaveDirectory}"
-                IsEnabled="{Binding EnabledBcatSaveDirectory}"
-                Header="{locale:Locale GameListContextMenuOpenBcatSaveDirectory}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuOpenBcatSaveDirectoryToolTip}" />
-            <Separator />
-            <MenuItem
-                Command="{Binding OpenTitleUpdateManager}"
-                Header="{locale:Locale GameListContextMenuManageTitleUpdates}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuManageTitleUpdatesToolTip}" />
-            <MenuItem
-                Command="{Binding OpenDownloadableContentManager}"
-                Header="{locale:Locale GameListContextMenuManageDlc}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuManageDlcToolTip}" />
-            <MenuItem
-                Command="{Binding OpenCheatManager}"
-                Header="{locale:Locale GameListContextMenuManageCheat}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuManageCheatToolTip}" />
-            <MenuItem
-                Command="{Binding OpenModsDirectory}"
-                Header="{locale:Locale GameListContextMenuOpenModsDirectory}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuOpenModsDirectoryToolTip}" />
-            <MenuItem
-                Command="{Binding OpenSdModsDirectory}"
-                Header="{locale:Locale GameListContextMenuOpenSdModsDirectory}"
-                ToolTip.Tip="{locale:Locale GameListContextMenuOpenSdModsDirectoryToolTip}" />
-            <Separator />
-            <MenuItem Header="{locale:Locale GameListContextMenuCacheManagement}">
-                <MenuItem
-                    Command="{Binding PurgePtcCache}"
-                    Header="{locale:Locale GameListContextMenuCacheManagementPurgePptc}"
-                    ToolTip.Tip="{locale:Locale GameListContextMenuCacheManagementPurgePptcToolTip}" />
-                <MenuItem
-                    Command="{Binding PurgeShaderCache}"
-                    Header="{locale:Locale GameListContextMenuCacheManagementPurgeShaderCache}"
-                    ToolTip.Tip="{locale:Locale GameListContextMenuCacheManagementPurgeShaderCacheToolTip}" />
-                <MenuItem
-                    Command="{Binding OpenPtcDirectory}"
-                    Header="{locale:Locale GameListContextMenuCacheManagementOpenPptcDirectory}"
-                    ToolTip.Tip="{locale:Locale GameListContextMenuCacheManagementOpenPptcDirectoryToolTip}" />
-                <MenuItem
-                    Command="{Binding OpenShaderCacheDirectory}"
-                    Header="{locale:Locale GameListContextMenuCacheManagementOpenShaderCacheDirectory}"
-                    ToolTip.Tip="{locale:Locale GameListContextMenuCacheManagementOpenShaderCacheDirectoryToolTip}" />
-            </MenuItem>
-            <MenuItem Header="{locale:Locale GameListContextMenuExtractData}">
-                <MenuItem
-                    Command="{Binding ExtractExeFs}"
-                    Header="{locale:Locale GameListContextMenuExtractDataExeFS}"
-                    ToolTip.Tip="{locale:Locale GameListContextMenuExtractDataExeFSToolTip}" />
-                <MenuItem
-                    Command="{Binding ExtractRomFs}"
-                    Header="{locale:Locale GameListContextMenuExtractDataRomFS}"
-                    ToolTip.Tip="{locale:Locale GameListContextMenuExtractDataRomFSToolTip}" />
-                <MenuItem
-                    Command="{Binding ExtractLogo}"
-                    Header="{locale:Locale GameListContextMenuExtractDataLogo}"
-                    ToolTip.Tip="{locale:Locale GameListContextMenuExtractDataLogoToolTip}" />
-            </MenuItem>
-        </MenuFlyout>
-    </UserControl.Resources>
-    <Grid>
-        <Grid.RowDefinitions>
-            <RowDefinition Height="*" />
-        </Grid.RowDefinitions>
-        <ListBox
-            Grid.Row="0"
-            Padding="8"
-            HorizontalAlignment="Stretch"
-            VerticalAlignment="Stretch"
-            ContextFlyout="{StaticResource GameContextMenu}"
-            DoubleTapped="GameList_DoubleTapped"
-            Items="{Binding AppsObservableList}"
-            SelectionChanged="GameList_SelectionChanged">
-            <ListBox.ItemsPanel>
-                <ItemsPanelTemplate>
-                    <flex:FlexPanel
-                        HorizontalAlignment="Stretch"
-                        VerticalAlignment="Stretch"
-                        AlignContent="FlexStart"
-                        JustifyContent="Center" />
-                </ItemsPanelTemplate>
-            </ListBox.ItemsPanel>
-            <ListBox.Styles>
-                <Style Selector="ListBoxItem">
-                    <Setter Property="Margin" Value="5" />
-                    <Setter Property="CornerRadius" Value="4" />
-                </Style>
-                <Style Selector="ListBoxItem:selected /template/ Border#SelectionIndicator">
-                    <Setter Property="MinHeight" Value="{Binding $parent[UserControl].DataContext.GridItemSelectorSize}" />
-                </Style>
-            </ListBox.Styles>
-            <ListBox.ItemTemplate>
-                <DataTemplate>
-                    <Grid>
-                        <Border
-                            Margin="10"
-                            HorizontalAlignment="Stretch"
-                            VerticalAlignment="Stretch"
-                            Classes.huge="{Binding $parent[UserControl].DataContext.IsGridHuge}"
-                            Classes.large="{Binding $parent[UserControl].DataContext.IsGridLarge}"
-                            Classes.normal="{Binding $parent[UserControl].DataContext.IsGridMedium}"
-                            Classes.small="{Binding $parent[UserControl].DataContext.IsGridSmall}"
-                            ClipToBounds="True"
-                            CornerRadius="4">
-                            <Grid>
-                                <Grid.RowDefinitions>
-                                    <RowDefinition Height="Auto" />
-                                    <RowDefinition Height="Auto" />
-                                </Grid.RowDefinitions>
-                                <Image
-                                    Grid.Row="0"
-                                    HorizontalAlignment="Stretch"
-                                    VerticalAlignment="Top"
-                                    Source="{Binding Icon, Converter={StaticResource ByteImage}}" />
-                                <Panel
-                                    Grid.Row="1"
-                                    Height="50"
-                                    Margin="0 10 0 0"
-                                    HorizontalAlignment="Stretch"
-                                    VerticalAlignment="Stretch"
-                                    IsVisible="{Binding $parent[UserControl].DataContext.ShowNames}">
-                                    <TextBlock
-                                        HorizontalAlignment="Stretch"
-                                        VerticalAlignment="Center"
-                                        Text="{Binding TitleName}"
-                                        TextAlignment="Center"
-                                        TextWrapping="Wrap" />
-                                </Panel>
-                            </Grid>
-                        </Border>
-                        <ui:SymbolIcon
-                            Margin="5,5,0,0"
-                            HorizontalAlignment="Left"
-                            VerticalAlignment="Top"
-                            FontSize="16"
-                            Foreground="{DynamicResource SystemAccentColor}"
-                            IsVisible="{Binding Favorite}"
-                            Symbol="StarFilled" />
-                    </Grid>
-                </DataTemplate>
-            </ListBox.ItemTemplate>
-        </ListBox>
-    </Grid>
-</UserControl>

Ryujinx.Ava/UI/Controls/InputDialog.axaml

@@ -1,32 +0,0 @@
-<UserControl
-    x:Class="Ryujinx.Ava.UI.Controls.InputDialog"
-    xmlns="https://github.com/avaloniaui"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    mc:Ignorable="d"
-    Focusable="True">
-    <Grid
-        Margin="5,10,5,5"
-        HorizontalAlignment="Stretch"
-        VerticalAlignment="Center">
-        <Grid.RowDefinitions>
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-            <RowDefinition Height="Auto" />
-        </Grid.RowDefinitions>
-        <TextBlock HorizontalAlignment="Center" Text="{Binding Message}" />
-        <TextBox
-            Grid.Row="1"
-            Width="300"
-            Margin="10"
-            HorizontalAlignment="Center"
-            MaxLength="{Binding MaxLength}"
-            Text="{Binding Input, Mode=TwoWay}" />
-        <TextBlock
-            Grid.Row="2"
-            Margin="5,5,5,10"
-            HorizontalAlignment="Center"
-            Text="{Binding SubMessage}" />
-    </Grid>
-</UserControl>

Ryujinx.Ava/UI/Controls/InputDialog.axaml.cs

@@ -1,57 +0,0 @@
-using Avalonia.Controls;
-using FluentAvalonia.UI.Controls;
-using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Ava.UI.Helpers;
-using Ryujinx.Ava.UI.Models;
-using System.Threading.Tasks;
-
-namespace Ryujinx.Ava.UI.Controls
-{
-    public partial class InputDialog : UserControl
-    {
-        public string Message { get; set; }
-        public string Input { get; set; }
-        public string SubMessage { get; set; }
-
-        public uint MaxLength { get; }
-
-        public InputDialog(string message, string input = "", string subMessage = "", uint maxLength = int.MaxValue)
-        {
-            Message = message;
-            Input = input;
-            SubMessage = subMessage;
-            MaxLength = maxLength;
-
-            DataContext = this;
-        }
-
-        public InputDialog()
-        {
-            InitializeComponent();
-        }
-
-        public static async Task<(UserResult Result, string Input)> ShowInputDialog(string title, string message,
-            string input = "", string subMessage = "", uint maxLength = int.MaxValue)
-        {
-            UserResult result = UserResult.Cancel;
-
-            InputDialog content = new InputDialog(message, input, subMessage, maxLength);
-            ContentDialog contentDialog = new ContentDialog
-            {
-                Title = title,
-                PrimaryButtonText = LocaleManager.Instance[LocaleKeys.InputDialogOk],
-                SecondaryButtonText = "",
-                CloseButtonText = LocaleManager.Instance[LocaleKeys.InputDialogCancel],
-                Content = content,
-                PrimaryButtonCommand = MiniCommand.Create(() =>
-                {
-                    result = UserResult.Ok;
-                    input = content.Input;
-                })
-            };
-            await contentDialog.ShowAsync();
-
-            return (result, input);
-        }
-    }
-}

Ryujinx.Ava/UI/Models/Amiibo.cs

@@ -1,72 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text.Json.Serialization;
-
-namespace Ryujinx.Ava.UI.Models
-{
-    public class Amiibo
-    {
-        public struct AmiiboJson
-        {
-            [JsonPropertyName("amiibo")] public List<AmiiboApi> Amiibo { get; set; }
-            [JsonPropertyName("lastUpdated")] public DateTime LastUpdated { get; set; }
-        }
-
-        public struct AmiiboApi
-        {
-            [JsonPropertyName("name")] public string Name { get; set; }
-            [JsonPropertyName("head")] public string Head { get; set; }
-            [JsonPropertyName("tail")] public string Tail { get; set; }
-            [JsonPropertyName("image")] public string Image { get; set; }
-            [JsonPropertyName("amiiboSeries")] public string AmiiboSeries { get; set; }
-            [JsonPropertyName("character")] public string Character { get; set; }
-            [JsonPropertyName("gameSeries")] public string GameSeries { get; set; }
-            [JsonPropertyName("type")] public string Type { get; set; }
-
-            [JsonPropertyName("release")] public Dictionary<string, string> Release { get; set; }
-
-            [JsonPropertyName("gamesSwitch")] public List<AmiiboApiGamesSwitch> GamesSwitch { get; set; }
-
-            public override string ToString()
-            {
-                return Name;
-            }
-
-            public string GetId()
-            {
-                return Head + Tail;
-            }
-
-            public override bool Equals(object obj)
-            {
-                if (obj is AmiiboApi amiibo)
-                {
-                    return amiibo.Head + amiibo.Tail == Head + Tail;
-                }
-
-                return false;
-            }
-
-            public override int GetHashCode()
-            {
-                return base.GetHashCode();
-            }
-        }
-
-        public class AmiiboApiGamesSwitch
-        {
-            [JsonPropertyName("amiiboUsage")] public List<AmiiboApiUsage> AmiiboUsage { get; set; }
-
-            [JsonPropertyName("gameID")] public List<string> GameId { get; set; }
-
-            [JsonPropertyName("gameName")] public string GameName { get; set; }
-        }
-
-        public class AmiiboApiUsage
-        {
-            [JsonPropertyName("Usage")] public string Usage { get; set; }
-
-            [JsonPropertyName("write")] public bool Write { get; set; }
-        }
-    }
-}

Ryujinx.Ava/UI/ViewModels/TitleUpdateViewModel.cs

@@ -1,251 +0,0 @@
-using Avalonia.Collections;
-using Avalonia.Controls;
-using Avalonia.Controls.ApplicationLifetimes;
-using Avalonia.Threading;
-using LibHac.Common;
-using LibHac.Fs;
-using LibHac.Fs.Fsa;
-using LibHac.FsSystem;
-using LibHac.Ns;
-using LibHac.Tools.FsSystem;
-using LibHac.Tools.FsSystem.NcaUtils;
-using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Ava.UI.Helpers;
-using Ryujinx.Ava.UI.Models;
-using Ryujinx.Common.Configuration;
-using Ryujinx.Common.Logging;
-using Ryujinx.Common.Utilities;
-using Ryujinx.HLE.FileSystem;
-using Ryujinx.HLE.HOS;
-using Ryujinx.Ui.App.Common;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using Path = System.IO.Path;
-using SpanHelpers = LibHac.Common.SpanHelpers;
-
-namespace Ryujinx.Ava.UI.ViewModels;
-
-public class TitleUpdateViewModel : BaseModel
-{
-    public TitleUpdateMetadata _titleUpdateWindowData;
-    public readonly string     _titleUpdateJsonPath;
-    private VirtualFileSystem  _virtualFileSystem { get; }
-    private ulong              _titleId           { get; }
-    private string             _titleName         { get; }
-
-    private AvaloniaList<TitleUpdateModel> _titleUpdates = new();
-    private AvaloniaList<object> _views = new();
-    private object _selectedUpdate;
-
-    public AvaloniaList<TitleUpdateModel> TitleUpdates
-    {
-        get => _titleUpdates;
-        set
-        {
-            _titleUpdates = value;
-            OnPropertyChanged();
-        }
-    }
-
-    public AvaloniaList<object> Views
-    {
-        get => _views;
-        set
-        {
-            _views = value;
-            OnPropertyChanged();
-        }
-    }
-
-    public object SelectedUpdate
-    {
-        get => _selectedUpdate;
-        set
-        {
-            _selectedUpdate = value;
-            OnPropertyChanged();
-        }
-    }
-
-    public TitleUpdateViewModel(VirtualFileSystem virtualFileSystem, ulong titleId, string titleName)
-    {
-        _virtualFileSystem = virtualFileSystem;
-
-        _titleId   = titleId;
-        _titleName = titleName;
-
-        _titleUpdateJsonPath = Path.Combine(AppDataManager.GamesDirPath, titleId.ToString("x16"), "updates.json");
-
-        try
-        {
-            _titleUpdateWindowData = JsonHelper.DeserializeFromFile<TitleUpdateMetadata>(_titleUpdateJsonPath);
-        }
-        catch
-        {
-            Logger.Warning?.Print(LogClass.Application, $"Failed to deserialize title update data for {_titleId} at {_titleUpdateJsonPath}");
-
-            _titleUpdateWindowData = new TitleUpdateMetadata
-            {
-                Selected = "",
-                Paths    = new List<string>()
-            };
-
-            Save();
-        }
-
-        LoadUpdates();
-    }
-
-    private void LoadUpdates()
-    {
-        foreach (string path in _titleUpdateWindowData.Paths)
-        {
-            AddUpdate(path);
-        }
-
-        TitleUpdateModel selected = TitleUpdates.FirstOrDefault(x => x.Path == _titleUpdateWindowData.Selected, null);
-
-        SelectedUpdate = selected;
-
-        // NOTE: Save the list again to remove leftovers.
-        Save();
-
-        SortUpdates();
-    }
-
-    public void SortUpdates()
-    {
-        var list = TitleUpdates.ToList();
-
-        list.Sort((first, second) =>
-        {
-            if (string.IsNullOrEmpty(first.Control.DisplayVersionString.ToString()))
-            {
-                return -1;
-            }
-            else if (string.IsNullOrEmpty(second.Control.DisplayVersionString.ToString()))
-            {
-                return 1;
-            }
-
-            return Version.Parse(first.Control.DisplayVersionString.ToString()).CompareTo(Version.Parse(second.Control.DisplayVersionString.ToString())) * -1;
-        });
-
-        Views.Clear();
-        Views.Add(new BaseModel());
-        Views.AddRange(list);
-
-        if (SelectedUpdate == null)
-        {
-            SelectedUpdate = Views[0];
-        }
-        else if (!TitleUpdates.Contains(SelectedUpdate))
-        {
-            if (Views.Count > 1)
-            {
-                SelectedUpdate = Views[1];
-            }
-            else
-            {
-                SelectedUpdate = Views[0];
-            }
-        }
-    }
-
-    private void AddUpdate(string path)
-    {
-        if (File.Exists(path) && TitleUpdates.All(x => x.Path != path))
-        {
-            using FileStream file = new(path, FileMode.Open, FileAccess.Read);
-
-            try
-            {
-                (Nca patchNca, Nca controlNca) = ApplicationLibrary.GetGameUpdateDataFromPartition(_virtualFileSystem, new PartitionFileSystem(file.AsStorage()), _titleId.ToString("x16"), 0);
-
-                if (controlNca != null && patchNca != null)
-                {
-                    ApplicationControlProperty controlData = new();
-
-                    using UniqueRef<IFile> nacpFile = new();
-
-                    controlNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None).OpenFile(ref nacpFile.Ref, "/control.nacp".ToU8Span(), OpenMode.Read).ThrowIfFailure();
-                    nacpFile.Get.Read(out _, 0, SpanHelpers.AsByteSpan(ref controlData), ReadOption.None).ThrowIfFailure();
-
-                    TitleUpdates.Add(new TitleUpdateModel(controlData, path));
-                }
-                else
-                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogUpdateAddUpdateErrorMessage]);
-                    });
-                }
-            }
-            catch (Exception ex)
-            {
-                Dispatcher.UIThread.Post(async () =>
-                {
-                    await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogLoadNcaErrorMessage, ex.Message, path));
-                });
-            }
-        }
-    }
-
-    public void RemoveUpdate(TitleUpdateModel update)
-    {
-        TitleUpdates.Remove(update);
-
-        SortUpdates();
-    }
-
-    public async void Add()
-    {
-        OpenFileDialog dialog = new()
-        {
-            Title         = LocaleManager.Instance[LocaleKeys.SelectUpdateDialogTitle],
-            AllowMultiple = true
-        };
-
-        dialog.Filters.Add(new FileDialogFilter
-        {
-            Name       = "NSP",
-            Extensions = { "nsp" }
-        });
-
-        if (Avalonia.Application.Current.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
-        {
-            string[] files = await dialog.ShowAsync(desktop.MainWindow);
-
-            if (files != null)
-            {
-                foreach (string file in files)
-                {
-                    AddUpdate(file);
-                }
-            }
-        }
-
-        SortUpdates();
-    }
-
-    public void Save()
-    {
-        _titleUpdateWindowData.Paths.Clear();
-        _titleUpdateWindowData.Selected = "";
-
-        foreach (TitleUpdateModel update in TitleUpdates)
-        {
-            _titleUpdateWindowData.Paths.Add(update.Path);
-
-            if (update == SelectedUpdate)
-            {
-                _titleUpdateWindowData.Selected = update.Path;
-            }
-        }
-
-        File.WriteAllBytes(_titleUpdateJsonPath, Encoding.UTF8.GetBytes(JsonHelper.Serialize(_titleUpdateWindowData, true)));
-    }
-}

Ryujinx.Ava/UI/Views/Settings/SettingsInputView.axaml

@@ -1,46 +0,0 @@
-<UserControl 
-    x:Class="Ryujinx.Ava.UI.Views.Settings.SettingsInputView"
-    xmlns="https://github.com/avaloniaui"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    xmlns:locale="clr-namespace:Ryujinx.Ava.Common.Locale"
-    xmlns:window="clr-namespace:Ryujinx.Ava.UI.Windows"
-    xmlns:viewModels="clr-namespace:Ryujinx.Ava.UI.ViewModels"
-    mc:Ignorable="d"
-    x:CompileBindings="True"
-    x:DataType="viewModels:SettingsViewModel">
-    <Design.DataContext>
-        <viewModels:SettingsViewModel />
-    </Design.DataContext>
-    <ScrollViewer 
-        Name="InputPage"
-        HorizontalAlignment="Stretch"
-        VerticalAlignment="Stretch"
-        HorizontalScrollBarVisibility="Disabled"
-        VerticalScrollBarVisibility="Auto">
-        <Border Classes="settings">
-            <StackPanel Margin="4" Orientation="Vertical">
-                <StackPanel Orientation="Horizontal">
-                    <CheckBox Margin="5,0"
-                              ToolTip.Tip="{locale:Locale DockModeToggleTooltip}"
-                              IsChecked="{Binding EnableDockedMode}">
-                        <TextBlock VerticalAlignment="Center"
-                                   Text="{locale:Locale SettingsTabInputEnableDockedMode}" />
-                    </CheckBox>
-                    <CheckBox Margin="5,0"
-                              ToolTip.Tip="{locale:Locale DirectKeyboardTooltip}"
-                              IsChecked="{Binding EnableKeyboard}">
-                        <TextBlock Text="{locale:Locale SettingsTabInputDirectKeyboardAccess}" />
-                    </CheckBox>
-                    <CheckBox Margin="5,0"
-                              ToolTip.Tip="{locale:Locale DirectMouseTooltip}"
-                              IsChecked="{Binding EnableMouse}">
-                        <TextBlock Text="{locale:Locale SettingsTabInputDirectMouseAccess}" />
-                    </CheckBox>
-                </StackPanel>
-                <window:ControllerSettingsWindow Name="ControllerSettings" Margin="0" MinHeight="600" />
-            </StackPanel>
-        </Border>
-    </ScrollViewer>
-</UserControl>

Ryujinx.Common/Configuration/AntiAliasing.cs

@@ -1,12 +0,0 @@
-namespace Ryujinx.Common.Configuration
-{
-    public enum AntiAliasing
-    {
-        None,
-        Fxaa,
-        SmaaLow,
-        SmaaMedium,
-        SmaaHigh,
-        SmaaUltra
-    }
-}

Ryujinx.Common/Configuration/BackendThreading.cs

@@ -1,9 +0,0 @@
-namespace Ryujinx.Common.Configuration
-{
-    public enum BackendThreading
-    {
-        Auto,
-        Off,
-        On
-    }
-}

Ryujinx.Common/Configuration/GraphicsBackend.cs

@@ -1,8 +0,0 @@
-namespace Ryujinx.Common.Configuration
-{
-    public enum GraphicsBackend
-    {
-        Vulkan,
-        OpenGl
-    }
-}

Ryujinx.Common/Configuration/Hid/Controller/Motion/MotionInputBackendType.cs

@@ -1,9 +0,0 @@
-namespace Ryujinx.Common.Configuration.Hid.Controller.Motion
-{
-    public enum MotionInputBackendType : byte
-    {
-        Invalid,
-        GamepadDriver,
-        CemuHook
-    }
-}

Ryujinx.Common/Configuration/Hid/Controller/StickInputId.cs

@@ -1,11 +0,0 @@
-namespace Ryujinx.Common.Configuration.Hid.Controller
-{
-    public enum StickInputId : byte
-    {
-        Unbound,
-        Left,
-        Right,
-
-        Count
-    }
-}

Ryujinx.Common/Configuration/Hid/InputBackendType.cs

@@ -1,9 +0,0 @@
-namespace Ryujinx.Common.Configuration.Hid
-{
-    public enum InputBackendType
-    {
-        Invalid,
-        WindowKeyboard,
-        GamepadSDL2,
-    }
-}

Ryujinx.Common/Configuration/MemoryManagerMode.cs

@@ -1,9 +0,0 @@
-namespace Ryujinx.Common.Configuration
-{
-    public enum MemoryManagerMode : byte
-    {
-        SoftwarePageTable,
-        HostMapped,
-        HostMappedUnsafe
-    }
-}

Ryujinx.Common/Configuration/ScalingFilter.cs

@@ -1,9 +0,0 @@
-namespace Ryujinx.Common.Configuration
-{
-    public enum ScalingFilter
-    {
-        Bilinear,
-        Nearest,
-        Fsr
-    }
-}

Ryujinx.Common/Logging/Formatters/DefaultLogFormatter.cs

@@ -1,80 +0,0 @@
-using System;
-using System.Reflection;
-using System.Text;
-
-namespace Ryujinx.Common.Logging
-{
-    internal class DefaultLogFormatter : ILogFormatter
-    {
-        private static readonly ObjectPool<StringBuilder> _stringBuilderPool = SharedPools.Default<StringBuilder>();
-
-        public string Format(LogEventArgs args)
-        {
-            StringBuilder sb = _stringBuilderPool.Allocate();
-
-            try
-            {
-                sb.Clear();
-
-                sb.AppendFormat(@"{0:hh\:mm\:ss\.fff}", args.Time);
-                sb.Append($" |{args.Level.ToString()[0]}| ");
-
-                if (args.ThreadName != null)
-                {
-                    sb.Append(args.ThreadName);
-                    sb.Append(' ');
-                }
-
-                sb.Append(args.Message);
-
-                if (args.Data != null)
-                {
-                    PropertyInfo[] props = args.Data.GetType().GetProperties();
-
-                    sb.Append(" {");
-
-                    foreach (var prop in props)
-                    {
-                        sb.Append(prop.Name);
-                        sb.Append(": ");
-
-                        if (typeof(Array).IsAssignableFrom(prop.PropertyType))
-                        {
-                            Array array = (Array)prop.GetValue(args.Data);
-                            foreach (var item in array)
-                            {
-                                sb.Append(item.ToString());
-                                sb.Append(", ");
-                            }
-
-                            if (array.Length > 0)
-                            {
-                                sb.Remove(sb.Length - 2, 2);
-                            }
-                        }
-                        else
-                        {
-                            sb.Append(prop.GetValue(args.Data));
-                        }
-
-                        sb.Append(" ; ");
-                    }
-
-                    // We remove the final ';' from the string
-                    if (props.Length > 0)
-                    {
-                        sb.Remove(sb.Length - 3, 3);
-                    }
-
-                    sb.Append('}');
-                }
-
-                return sb.ToString();
-            }
-            finally
-            {
-                _stringBuilderPool.Release(sb);
-            }
-        }
-    }
-}

Ryujinx.Common/Utilities/JsonHelper.cs

@@ -1,110 +0,0 @@
-using Ryujinx.Common.Configuration.Hid;
-using Ryujinx.Common.Configuration.Hid.Controller.Motion;
-using System.IO;
-using System.Text;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace Ryujinx.Common.Utilities
-{
-    public class JsonHelper
-    {
-        public static JsonNamingPolicy SnakeCase { get; }
-
-        private class SnakeCaseNamingPolicy : JsonNamingPolicy
-        {
-            public override string ConvertName(string name)
-            {
-                if (string.IsNullOrEmpty(name))
-                {
-                    return name;
-                }
-
-                StringBuilder builder = new StringBuilder();
-
-                for (int i = 0; i < name.Length; i++)
-                {
-                    char c = name[i];
-
-                    if (char.IsUpper(c))
-                    {
-                        if (i == 0 || char.IsUpper(name[i - 1]))
-                        {
-                            builder.Append(char.ToLowerInvariant(c));
-                        }
-                        else
-                        {
-                            builder.Append("_");
-                            builder.Append(char.ToLowerInvariant(c));
-                        }
-                    }
-                    else
-                    {
-                        builder.Append(c);
-                    }
-                }
-
-                return builder.ToString();
-            }
-        }
-
-        static JsonHelper()
-        {
-            SnakeCase = new SnakeCaseNamingPolicy();
-        }
-
-        public static JsonSerializerOptions GetDefaultSerializerOptions(bool prettyPrint = false)
-        {
-            JsonSerializerOptions options = new JsonSerializerOptions
-            {
-                DictionaryKeyPolicy  = SnakeCase,
-                PropertyNamingPolicy = SnakeCase,
-                WriteIndented        = prettyPrint,
-                AllowTrailingCommas  = true,
-                ReadCommentHandling  = JsonCommentHandling.Skip
-            };
-
-            options.Converters.Add(new JsonStringEnumConverter());
-            options.Converters.Add(new JsonInputConfigConverter());
-            options.Converters.Add(new JsonMotionConfigControllerConverter());
-
-            return options;
-        }
-
-        public static T Deserialize<T>(Stream stream)
-        {
-            using (BinaryReader reader = new BinaryReader(stream))
-            {
-                return JsonSerializer.Deserialize<T>(reader.ReadBytes((int)(stream.Length - stream.Position)), GetDefaultSerializerOptions());
-            }
-        }
-
-        public static T DeserializeFromFile<T>(string path)
-        {
-            return Deserialize<T>(File.ReadAllText(path));
-        }
-
-        public static T Deserialize<T>(string json)
-        {
-            return JsonSerializer.Deserialize<T>(json, GetDefaultSerializerOptions());
-        }
-
-        public static void Serialize<TValue>(Stream stream, TValue obj, bool prettyPrint = false)
-        {
-            using (BinaryWriter writer = new BinaryWriter(stream))
-            {
-                writer.Write(SerializeToUtf8Bytes(obj, prettyPrint));
-            }
-        }
-
-        public static string Serialize<TValue>(TValue obj, bool prettyPrint = false)
-        {
-            return JsonSerializer.Serialize(obj, GetDefaultSerializerOptions(prettyPrint));
-        }
-
-        public static byte[] SerializeToUtf8Bytes<T>(T obj, bool prettyPrint = false)
-        {
-            return JsonSerializer.SerializeToUtf8Bytes(obj, GetDefaultSerializerOptions(prettyPrint));
-        }
-    }
-}

Ryujinx.Cpu/Tracking/CpuMultiRegionHandle.cs

@@ -1,28 +0,0 @@
-using Ryujinx.Memory.Tracking;
-using System;
-using System.Collections.Generic;
-
-namespace Ryujinx.Cpu.Tracking
-{
-    public class CpuMultiRegionHandle : IMultiRegionHandle
-    {
-        private readonly MultiRegionHandle _impl;
-
-        public bool Dirty => _impl.Dirty;
-
-        internal CpuMultiRegionHandle(MultiRegionHandle impl)
-        {
-            _impl = impl;
-        }
-
-        public void Dispose() => _impl.Dispose();
-        public void ForceDirty(ulong address, ulong size) => _impl.ForceDirty(address, size);
-        public IEnumerable<IRegionHandle> GetHandles() => _impl.GetHandles();
-        public void QueryModified(Action<ulong, ulong> modifiedAction) => _impl.QueryModified(modifiedAction);
-        public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction) => _impl.QueryModified(address, size, modifiedAction);
-        public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction, int sequenceNumber) => _impl.QueryModified(address, size, modifiedAction, sequenceNumber);
-        public void RegisterAction(ulong address, ulong size, RegionSignal action) => _impl.RegisterAction(address, size, action);
-        public void RegisterPreciseAction(ulong address, ulong size, PreciseRegionSignal action) => _impl.RegisterPreciseAction(address, size, action);
-        public void SignalWrite() => _impl.SignalWrite();
-    }
-}

Ryujinx.Cpu/Tracking/CpuRegionHandle.cs

@@ -1,37 +0,0 @@
-using Ryujinx.Memory.Tracking;
-using System;
-
-namespace Ryujinx.Cpu.Tracking
-{
-    public class CpuRegionHandle : IRegionHandle
-    {
-        private readonly RegionHandle _impl;
-
-        public bool Dirty => _impl.Dirty;
-        public bool Unmapped => _impl.Unmapped;
-        public ulong Address => _impl.Address;
-        public ulong Size => _impl.Size;
-        public ulong EndAddress => _impl.EndAddress;
-
-        internal CpuRegionHandle(RegionHandle impl)
-        {
-            _impl = impl;
-        }
-
-        public void Dispose() => _impl.Dispose();
-        public bool DirtyOrVolatile() => _impl.DirtyOrVolatile();
-        public void ForceDirty() => _impl.ForceDirty();
-        public IRegionHandle GetHandle() => _impl;
-        public void RegisterAction(RegionSignal action) => _impl.RegisterAction(action);
-        public void RegisterPreciseAction(PreciseRegionSignal action) => _impl.RegisterPreciseAction(action);
-        public void RegisterDirtyEvent(Action action) => _impl.RegisterDirtyEvent(action);
-        public void Reprotect(bool asDirty = false) => _impl.Reprotect(asDirty);
-
-        public bool OverlapsWith(ulong address, ulong size) => _impl.OverlapsWith(address, size);
-
-        public bool RangeEquals(CpuRegionHandle other)
-        {
-            return _impl.RealAddress == other._impl.RealAddress && _impl.RealSize == other._impl.RealSize;
-        }
-    }
-}

Ryujinx.Cpu/Tracking/CpuSmartMultiRegionHandle.cs

@@ -1,26 +0,0 @@
-using Ryujinx.Memory.Tracking;
-using System;
-
-namespace Ryujinx.Cpu.Tracking
-{
-    public class CpuSmartMultiRegionHandle : IMultiRegionHandle
-    {
-        private readonly SmartMultiRegionHandle _impl;
-
-        public bool Dirty => _impl.Dirty;
-
-        internal CpuSmartMultiRegionHandle(SmartMultiRegionHandle impl)
-        {
-            _impl = impl;
-        }
-
-        public void Dispose() => _impl.Dispose();
-        public void ForceDirty(ulong address, ulong size) => _impl.ForceDirty(address, size);
-        public void RegisterAction(RegionSignal action) => _impl.RegisterAction(action);
-        public void RegisterPreciseAction(PreciseRegionSignal action) => _impl.RegisterPreciseAction(action);
-        public void QueryModified(Action<ulong, ulong> modifiedAction) => _impl.QueryModified(modifiedAction);
-        public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction) => _impl.QueryModified(address, size, modifiedAction);
-        public void QueryModified(ulong address, ulong size, Action<ulong, ulong> modifiedAction, int sequenceNumber) => _impl.QueryModified(address, size, modifiedAction, sequenceNumber);
-        public void SignalWrite() => _impl.SignalWrite();
-    }
-}

Ryujinx.Graphics.GAL/ShaderBindings.cs

@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-
-namespace Ryujinx.Graphics.GAL
-{
-    public readonly struct ShaderBindings
-    {
-        public IReadOnlyCollection<int> UniformBufferBindings { get; }
-        public IReadOnlyCollection<int> StorageBufferBindings { get; }
-        public IReadOnlyCollection<int> TextureBindings { get; }
-        public IReadOnlyCollection<int> ImageBindings { get; }
-
-        public ShaderBindings(
-            IReadOnlyCollection<int> uniformBufferBindings,
-            IReadOnlyCollection<int> storageBufferBindings,
-            IReadOnlyCollection<int> textureBindings,
-            IReadOnlyCollection<int> imageBindings)
-        {
-            UniformBufferBindings = uniformBufferBindings;
-            StorageBufferBindings = storageBufferBindings;
-            TextureBindings = textureBindings;
-            ImageBindings = imageBindings;
-        }
-    }
-}

Ryujinx.Graphics.Gpu/Memory/UnmapEventArgs.cs

@@ -1,14 +0,0 @@
-namespace Ryujinx.Graphics.Gpu.Memory
-{
-    public class UnmapEventArgs
-    {
-        public ulong Address { get; }
-        public ulong Size { get; }
-
-        public UnmapEventArgs(ulong address, ulong size)
-        {
-            Address = address;
-            Size = size;
-        }
-    }
-}

Ryujinx.Graphics.Shader/CodeGen/Glsl/DefaultNames.cs

@@ -1,37 +0,0 @@
-namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
-{
-    static class DefaultNames
-    {
-        public const string LocalNamePrefix = "temp";
-
-        public const string SamplerNamePrefix = "tex";
-        public const string ImageNamePrefix   = "img";
-
-        public const string PerPatchAttributePrefix = "patch_attr_";
-        public const string IAttributePrefix = "in_attr";
-        public const string OAttributePrefix = "out_attr";
-
-        public const string StorageNamePrefix = "s";
-
-        public const string DataName = "data";
-
-        public const string SupportBlockName = "support_block";
-        public const string SupportBlockAlphaTestName = "s_alpha_test";
-        public const string SupportBlockIsBgraName = "s_is_bgra";
-        public const string SupportBlockViewportInverse = "s_viewport_inverse";
-        public const string SupportBlockFragmentScaleCount = "s_frag_scale_count";
-        public const string SupportBlockRenderScaleName = "s_render_scale";
-
-        public const string BlockSuffix = "block";
-
-        public const string UniformNamePrefix = "c";
-        public const string UniformNameSuffix = "data";
-
-        public const string LocalMemoryName  = "local_mem";
-        public const string SharedMemoryName = "shared_mem";
-
-        public const string ArgumentNamePrefix = "a";
-
-        public const string UndefinedName = "undef";
-    }
-}

Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/AtomicMinMaxS32Storage.glsl

@@ -1,21 +0,0 @@
-int Helper_AtomicMaxS32(int index, int offset, int value)
-{
-    uint oldValue, newValue;
-    do
-    {
-        oldValue = $STORAGE_MEM$[index].data[offset];
-        newValue = uint(max(int(oldValue), value));
-    } while (atomicCompSwap($STORAGE_MEM$[index].data[offset], oldValue, newValue) != oldValue);
-    return int(oldValue);
-}
-
-int Helper_AtomicMinS32(int index, int offset, int value)
-{
-    uint oldValue, newValue;
-    do
-    {
-        oldValue = $STORAGE_MEM$[index].data[offset];
-        newValue = uint(min(int(oldValue), value));
-    } while (atomicCompSwap($STORAGE_MEM$[index].data[offset], oldValue, newValue) != oldValue);
-    return int(oldValue);
-}

Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/StoreStorageSmallInt.glsl

@@ -1,23 +0,0 @@
-void Helper_StoreStorage16(int index, int offset, uint value)
-{
-    int wordOffset = offset >> 2;
-    int bitOffset = (offset & 3) * 8;
-    uint oldValue, newValue;
-    do
-    {
-        oldValue = $STORAGE_MEM$[index].data[wordOffset];
-        newValue = bitfieldInsert(oldValue, value, bitOffset, 16);
-    } while (atomicCompSwap($STORAGE_MEM$[index].data[wordOffset], oldValue, newValue) != oldValue);
-}
-
-void Helper_StoreStorage8(int index, int offset, uint value)
-{
-    int wordOffset = offset >> 2;
-    int bitOffset = (offset & 3) * 8;
-    uint oldValue, newValue;
-    do
-    {
-        oldValue = $STORAGE_MEM$[index].data[wordOffset];
-        newValue = bitfieldInsert(oldValue, value, bitOffset, 8);
-    } while (atomicCompSwap($STORAGE_MEM$[index].data[wordOffset], oldValue, newValue) != oldValue);
-}

Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/TexelFetchScale_cp.glsl

@@ -1,19 +0,0 @@
-ivec2 Helper_TexelFetchScale(ivec2 inputVec, int samplerIndex)
-{
-    float scale = s_render_scale[samplerIndex];
-    if (scale == 1.0)
-    {
-        return inputVec;
-    }
-    return ivec2(vec2(inputVec) * scale);
-}
-
-int Helper_TextureSizeUnscale(int size, int samplerIndex)
-{
-    float scale = s_render_scale[samplerIndex];
-    if (scale == 1.0)
-    {
-        return size;
-    }
-    return int(float(size) / scale);
-}

Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/TexelFetchScale_fp.glsl

@@ -1,26 +0,0 @@
-ivec2 Helper_TexelFetchScale(ivec2 inputVec, int samplerIndex)
-{
-    float scale = s_render_scale[1 + samplerIndex];
-    if (scale == 1.0)
-    {
-        return inputVec;
-    }
-    if (scale < 0.0) // If less than 0, try interpolate between texels by using the screen position.
-    {
-        return ivec2(vec2(inputVec) * (-scale) + mod(gl_FragCoord.xy, 0.0 - scale));
-    }
-    else
-    {
-        return ivec2(vec2(inputVec) * scale);
-    }
-}
-
-int Helper_TextureSizeUnscale(int size, int samplerIndex)
-{
-    float scale = abs(s_render_scale[1 + samplerIndex]);
-    if (scale == 1.0)
-    {
-        return size;
-    }
-    return int(float(size) / scale);
-}

Ryujinx.Graphics.Shader/CodeGen/Glsl/HelperFunctions/TexelFetchScale_vp.glsl

@@ -1,20 +0,0 @@
-ivec2 Helper_TexelFetchScale(ivec2 inputVec, int samplerIndex)
-{
-    float scale = abs(s_render_scale[1 + samplerIndex + s_frag_scale_count]);
-    if (scale == 1.0)
-    {
-        return inputVec;
-    }
-
-    return ivec2(vec2(inputVec) * scale);
-}
-
-int Helper_TextureSizeUnscale(int size, int samplerIndex)
-{
-    float scale = abs(s_render_scale[1 + samplerIndex + s_frag_scale_count]);
-    if (scale == 1.0)
-    {
-        return size;
-    }
-    return int(float(size) / scale);
-}

Ryujinx.Graphics.Shader/CodeGen/Glsl/OperandManager.cs

@@ -1,505 +0,0 @@
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Numerics;
-
-using static Ryujinx.Graphics.Shader.StructuredIr.InstructionInfo;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
-{
-    class OperandManager
-    {
-        private static readonly string[] StagePrefixes = new string[] { "cp", "vp", "tcp", "tep", "gp", "fp" };
-
-        private readonly struct BuiltInAttribute
-        {
-            public string Name { get; }
-
-            public AggregateType Type { get; }
-
-            public BuiltInAttribute(string name, AggregateType type)
-            {
-                Name = name;
-                Type = type;
-            }
-        }
-
-        private static Dictionary<int, BuiltInAttribute> _builtInAttributes = new Dictionary<int, BuiltInAttribute>()
-        {
-            { AttributeConsts.Layer,         new BuiltInAttribute("gl_Layer",           AggregateType.S32)  },
-            { AttributeConsts.PointSize,     new BuiltInAttribute("gl_PointSize",       AggregateType.FP32)  },
-            { AttributeConsts.PositionX,     new BuiltInAttribute("gl_Position.x",      AggregateType.FP32)  },
-            { AttributeConsts.PositionY,     new BuiltInAttribute("gl_Position.y",      AggregateType.FP32)  },
-            { AttributeConsts.PositionZ,     new BuiltInAttribute("gl_Position.z",      AggregateType.FP32)  },
-            { AttributeConsts.PositionW,     new BuiltInAttribute("gl_Position.w",      AggregateType.FP32)  },
-            { AttributeConsts.ClipDistance0, new BuiltInAttribute("gl_ClipDistance[0]", AggregateType.FP32)  },
-            { AttributeConsts.ClipDistance1, new BuiltInAttribute("gl_ClipDistance[1]", AggregateType.FP32)  },
-            { AttributeConsts.ClipDistance2, new BuiltInAttribute("gl_ClipDistance[2]", AggregateType.FP32)  },
-            { AttributeConsts.ClipDistance3, new BuiltInAttribute("gl_ClipDistance[3]", AggregateType.FP32)  },
-            { AttributeConsts.ClipDistance4, new BuiltInAttribute("gl_ClipDistance[4]", AggregateType.FP32)  },
-            { AttributeConsts.ClipDistance5, new BuiltInAttribute("gl_ClipDistance[5]", AggregateType.FP32)  },
-            { AttributeConsts.ClipDistance6, new BuiltInAttribute("gl_ClipDistance[6]", AggregateType.FP32)  },
-            { AttributeConsts.ClipDistance7, new BuiltInAttribute("gl_ClipDistance[7]", AggregateType.FP32)  },
-            { AttributeConsts.PointCoordX,   new BuiltInAttribute("gl_PointCoord.x",    AggregateType.FP32)  },
-            { AttributeConsts.PointCoordY,   new BuiltInAttribute("gl_PointCoord.y",    AggregateType.FP32)  },
-            { AttributeConsts.TessCoordX,    new BuiltInAttribute("gl_TessCoord.x",     AggregateType.FP32)  },
-            { AttributeConsts.TessCoordY,    new BuiltInAttribute("gl_TessCoord.y",     AggregateType.FP32)  },
-            { AttributeConsts.InstanceId,    new BuiltInAttribute("gl_InstanceID",      AggregateType.S32)  },
-            { AttributeConsts.VertexId,      new BuiltInAttribute("gl_VertexID",        AggregateType.S32)  },
-            { AttributeConsts.BaseInstance,  new BuiltInAttribute("gl_BaseInstanceARB", AggregateType.S32)  },
-            { AttributeConsts.BaseVertex,    new BuiltInAttribute("gl_BaseVertexARB",   AggregateType.S32)  },
-            { AttributeConsts.InstanceIndex, new BuiltInAttribute("gl_InstanceIndex",   AggregateType.S32)  },
-            { AttributeConsts.VertexIndex,   new BuiltInAttribute("gl_VertexIndex",     AggregateType.S32)  },
-            { AttributeConsts.DrawIndex,     new BuiltInAttribute("gl_DrawIDARB",       AggregateType.S32)  },
-            { AttributeConsts.FrontFacing,   new BuiltInAttribute("gl_FrontFacing",     AggregateType.Bool) },
-
-            // Special.
-            { AttributeConsts.FragmentOutputDepth, new BuiltInAttribute("gl_FragDepth",           AggregateType.FP32)  },
-            { AttributeConsts.ThreadKill,          new BuiltInAttribute("gl_HelperInvocation",    AggregateType.Bool) },
-            { AttributeConsts.ThreadIdX,           new BuiltInAttribute("gl_LocalInvocationID.x", AggregateType.U32)  },
-            { AttributeConsts.ThreadIdY,           new BuiltInAttribute("gl_LocalInvocationID.y", AggregateType.U32)  },
-            { AttributeConsts.ThreadIdZ,           new BuiltInAttribute("gl_LocalInvocationID.z", AggregateType.U32)  },
-            { AttributeConsts.CtaIdX,              new BuiltInAttribute("gl_WorkGroupID.x",       AggregateType.U32)  },
-            { AttributeConsts.CtaIdY,              new BuiltInAttribute("gl_WorkGroupID.y",       AggregateType.U32)  },
-            { AttributeConsts.CtaIdZ,              new BuiltInAttribute("gl_WorkGroupID.z",       AggregateType.U32)  },
-            { AttributeConsts.LaneId,              new BuiltInAttribute(null,                     AggregateType.U32)  },
-            { AttributeConsts.InvocationId,        new BuiltInAttribute("gl_InvocationID",        AggregateType.S32)  },
-            { AttributeConsts.PrimitiveId,         new BuiltInAttribute("gl_PrimitiveID",         AggregateType.S32)  },
-            { AttributeConsts.PatchVerticesIn,     new BuiltInAttribute("gl_PatchVerticesIn",     AggregateType.S32)  },
-            { AttributeConsts.EqMask,              new BuiltInAttribute(null,                     AggregateType.U32)  },
-            { AttributeConsts.GeMask,              new BuiltInAttribute(null,                     AggregateType.U32)  },
-            { AttributeConsts.GtMask,              new BuiltInAttribute(null,                     AggregateType.U32)  },
-            { AttributeConsts.LeMask,              new BuiltInAttribute(null,                     AggregateType.U32)  },
-            { AttributeConsts.LtMask,              new BuiltInAttribute(null,                     AggregateType.U32)  },
-
-            // Support uniforms.
-            { AttributeConsts.FragmentOutputIsBgraBase + 0,  new BuiltInAttribute($"{DefaultNames.SupportBlockIsBgraName}[0]",  AggregateType.Bool) },
-            { AttributeConsts.FragmentOutputIsBgraBase + 4,  new BuiltInAttribute($"{DefaultNames.SupportBlockIsBgraName}[1]",  AggregateType.Bool) },
-            { AttributeConsts.FragmentOutputIsBgraBase + 8,  new BuiltInAttribute($"{DefaultNames.SupportBlockIsBgraName}[2]",  AggregateType.Bool) },
-            { AttributeConsts.FragmentOutputIsBgraBase + 12, new BuiltInAttribute($"{DefaultNames.SupportBlockIsBgraName}[3]",  AggregateType.Bool) },
-            { AttributeConsts.FragmentOutputIsBgraBase + 16, new BuiltInAttribute($"{DefaultNames.SupportBlockIsBgraName}[4]",  AggregateType.Bool) },
-            { AttributeConsts.FragmentOutputIsBgraBase + 20, new BuiltInAttribute($"{DefaultNames.SupportBlockIsBgraName}[5]",  AggregateType.Bool) },
-            { AttributeConsts.FragmentOutputIsBgraBase + 24, new BuiltInAttribute($"{DefaultNames.SupportBlockIsBgraName}[6]",  AggregateType.Bool) },
-            { AttributeConsts.FragmentOutputIsBgraBase + 28, new BuiltInAttribute($"{DefaultNames.SupportBlockIsBgraName}[7]",  AggregateType.Bool) },
-
-            { AttributeConsts.SupportBlockViewInverseX,  new BuiltInAttribute($"{DefaultNames.SupportBlockViewportInverse}.x",  AggregateType.FP32) },
-            { AttributeConsts.SupportBlockViewInverseY,  new BuiltInAttribute($"{DefaultNames.SupportBlockViewportInverse}.y",  AggregateType.FP32) }
-        };
-
-        private Dictionary<AstOperand, string> _locals;
-
-        public OperandManager()
-        {
-            _locals = new Dictionary<AstOperand, string>();
-        }
-
-        public string DeclareLocal(AstOperand operand)
-        {
-            string name = $"{DefaultNames.LocalNamePrefix}_{_locals.Count}";
-
-            _locals.Add(operand, name);
-
-            return name;
-        }
-
-        public string GetExpression(CodeGenContext context, AstOperand operand)
-        {
-            return operand.Type switch
-            {
-                OperandType.Argument => GetArgumentName(operand.Value),
-                OperandType.Attribute => GetAttributeName(context, operand.Value, perPatch: false),
-                OperandType.AttributePerPatch => GetAttributeName(context, operand.Value, perPatch: true),
-                OperandType.Constant => NumberFormatter.FormatInt(operand.Value),
-                OperandType.ConstantBuffer => GetConstantBufferName(operand, context.Config),
-                OperandType.LocalVariable => _locals[operand],
-                OperandType.Undefined => DefaultNames.UndefinedName,
-                _ => throw new ArgumentException($"Invalid operand type \"{operand.Type}\".")
-            };
-        }
-
-        private static string GetConstantBufferName(AstOperand operand, ShaderConfig config)
-        {
-            return GetConstantBufferName(operand.CbufSlot, operand.CbufOffset, config.Stage, config.UsedFeatures.HasFlag(FeatureFlags.CbIndexing));
-        }
-
-        public static string GetConstantBufferName(int slot, int offset, ShaderStage stage, bool cbIndexable)
-        {
-            return $"{GetUbName(stage, slot, cbIndexable)}[{offset >> 2}].{GetSwizzleMask(offset & 3)}";
-        }
-
-        private static string GetVec4Indexed(string vectorName, string indexExpr, bool indexElement)
-        {
-            if (indexElement)
-            {
-                return $"{vectorName}[{indexExpr}]";
-            }
-
-            string result = $"{vectorName}.x";
-            for (int i = 1; i < 4; i++)
-            {
-                result = $"(({indexExpr}) == {i}) ? ({vectorName}.{GetSwizzleMask(i)}) : ({result})";
-            }
-            return $"({result})";
-        }
-
-        public static string GetConstantBufferName(int slot, string offsetExpr, ShaderStage stage, bool cbIndexable, bool indexElement)
-        {
-            return GetVec4Indexed(GetUbName(stage, slot, cbIndexable) + $"[{offsetExpr} >> 2]", offsetExpr + " & 3", indexElement);
-        }
-
-        public static string GetConstantBufferName(string slotExpr, string offsetExpr, ShaderStage stage, bool indexElement)
-        {
-            return GetVec4Indexed(GetUbName(stage, slotExpr) + $"[{offsetExpr} >> 2]", offsetExpr + " & 3", indexElement);
-        }
-
-        public static string GetOutAttributeName(CodeGenContext context, int value, bool perPatch)
-        {
-            return GetAttributeName(context, value, perPatch, isOutAttr: true);
-        }
-
-        public static string GetAttributeName(CodeGenContext context, int value, bool perPatch, bool isOutAttr = false, string indexExpr = "0")
-        {
-            ShaderConfig config = context.Config;
-
-            if ((value & AttributeConsts.LoadOutputMask) != 0)
-            {
-                isOutAttr = true;
-            }
-
-            value &= AttributeConsts.Mask & ~3;
-            char swzMask = GetSwizzleMask((value >> 2) & 3);
-
-            if (perPatch)
-            {
-                if (value >= AttributeConsts.UserAttributePerPatchBase && value < AttributeConsts.UserAttributePerPatchEnd)
-                {
-                    value -= AttributeConsts.UserAttributePerPatchBase;
-
-                    return $"{DefaultNames.PerPatchAttributePrefix}{(value >> 4)}.{swzMask}";
-                }
-                else if (value < AttributeConsts.UserAttributePerPatchBase)
-                {
-                    return value switch
-                    {
-                        AttributeConsts.TessLevelOuter0 => "gl_TessLevelOuter[0]",
-                        AttributeConsts.TessLevelOuter1 => "gl_TessLevelOuter[1]",
-                        AttributeConsts.TessLevelOuter2 => "gl_TessLevelOuter[2]",
-                        AttributeConsts.TessLevelOuter3 => "gl_TessLevelOuter[3]",
-                        AttributeConsts.TessLevelInner0 => "gl_TessLevelInner[0]",
-                        AttributeConsts.TessLevelInner1 => "gl_TessLevelInner[1]",
-                        _ => null
-                    };
-                }
-            }
-            else if (value >= AttributeConsts.UserAttributeBase && value < AttributeConsts.UserAttributeEnd)
-            {
-                int attrOffset = value;
-                value -= AttributeConsts.UserAttributeBase;
-
-                string prefix = isOutAttr
-                    ? DefaultNames.OAttributePrefix
-                    : DefaultNames.IAttributePrefix;
-
-                bool indexable = config.UsedFeatures.HasFlag(isOutAttr ? FeatureFlags.OaIndexing : FeatureFlags.IaIndexing);
-
-                if (indexable)
-                {
-                    string name = prefix;
-
-                    if (config.Stage == ShaderStage.Geometry && !isOutAttr)
-                    {
-                        name += $"[{indexExpr}]";
-                    }
-
-                    return name + $"[{(value >> 4)}]." + swzMask;
-                }
-                else if (config.TransformFeedbackEnabled &&
-                    ((config.LastInVertexPipeline && isOutAttr) ||
-                    (config.Stage == ShaderStage.Fragment && !isOutAttr)))
-                {
-                    int components = config.LastInPipeline ? context.Info.GetTransformFeedbackOutputComponents(attrOffset) : 1;
-                    string name = components > 1 ? $"{prefix}{(value >> 4)}" : $"{prefix}{(value >> 4)}_{swzMask}";
-
-                    if (AttributeInfo.IsArrayAttributeGlsl(config.Stage, isOutAttr))
-                    {
-                        name += isOutAttr ? "[gl_InvocationID]" : $"[{indexExpr}]";
-                    }
-
-                    return components > 1 ? name + '.' + swzMask : name;
-                }
-                else
-                {
-                    string name = $"{prefix}{(value >> 4)}";
-
-                    if (AttributeInfo.IsArrayAttributeGlsl(config.Stage, isOutAttr))
-                    {
-                        name += isOutAttr ? "[gl_InvocationID]" : $"[{indexExpr}]";
-                    }
-
-                    return name + '.' + swzMask;
-                }
-            }
-            else
-            {
-                if (value >= AttributeConsts.FragmentOutputColorBase && value < AttributeConsts.FragmentOutputColorEnd)
-                {
-                    value -= AttributeConsts.FragmentOutputColorBase;
-
-                    return $"{DefaultNames.OAttributePrefix}{(value >> 4)}.{swzMask}";
-                }
-                else if (_builtInAttributes.TryGetValue(value, out BuiltInAttribute builtInAttr))
-                {
-                    string subgroupMask = value switch
-                    {
-                        AttributeConsts.EqMask => "Eq",
-                        AttributeConsts.GeMask => "Ge",
-                        AttributeConsts.GtMask => "Gt",
-                        AttributeConsts.LeMask => "Le",
-                        AttributeConsts.LtMask => "Lt",
-                        _ => null
-                    };
-
-                    if (subgroupMask != null)
-                    {
-                        return config.GpuAccessor.QueryHostSupportsShaderBallot()
-                            ? $"unpackUint2x32(gl_SubGroup{subgroupMask}MaskARB).x"
-                            : $"gl_Subgroup{subgroupMask}Mask.x";
-                    }
-                    else if (value == AttributeConsts.LaneId)
-                    {
-                        return config.GpuAccessor.QueryHostSupportsShaderBallot()
-                            ? "gl_SubGroupInvocationARB"
-                            : "gl_SubgroupInvocationID";
-                    }
-
-                    if (config.Stage == ShaderStage.Fragment)
-                    {
-                        // TODO: There must be a better way to handle this...
-                        switch (value)
-                        {
-                            case AttributeConsts.PositionX: return $"(gl_FragCoord.x / {DefaultNames.SupportBlockRenderScaleName}[0])";
-                            case AttributeConsts.PositionY: return $"(gl_FragCoord.y / {DefaultNames.SupportBlockRenderScaleName}[0])";
-                            case AttributeConsts.PositionZ: return "gl_FragCoord.z";
-                            case AttributeConsts.PositionW: return "gl_FragCoord.w";
-
-                            case AttributeConsts.FrontFacing:
-                                if (config.GpuAccessor.QueryHostHasFrontFacingBug())
-                                {
-                                    // This is required for Intel on Windows, gl_FrontFacing sometimes returns incorrect
-                                    // (flipped) values. Doing this seems to fix it.
-                                    return "(-floatBitsToInt(float(gl_FrontFacing)) < 0)";
-                                }
-                                break;
-                        }
-                    }
-
-                    string name = builtInAttr.Name;
-
-                    if (AttributeInfo.IsArrayAttributeGlsl(config.Stage, isOutAttr) && AttributeInfo.IsArrayBuiltIn(value))
-                    {
-                        name = isOutAttr ? $"gl_out[gl_InvocationID].{name}" : $"gl_in[{indexExpr}].{name}";
-                    }
-
-                    return name;
-                }
-            }
-
-            // TODO: Warn about unknown built-in attribute.
-
-            return isOutAttr ? "// bad_attr0x" + value.ToString("X") : "0.0";
-        }
-
-        public static string GetAttributeName(string attrExpr, ShaderConfig config, bool isOutAttr = false, string indexExpr = "0")
-        {
-            string name = isOutAttr
-                ? DefaultNames.OAttributePrefix
-                : DefaultNames.IAttributePrefix;
-
-            if (config.Stage == ShaderStage.Geometry && !isOutAttr)
-            {
-                name += $"[{indexExpr}]";
-            }
-
-            return $"{name}[{attrExpr} >> 2][{attrExpr} & 3]";
-        }
-
-        public static string GetUbName(ShaderStage stage, int slot, bool cbIndexable)
-        {
-            if (cbIndexable)
-            {
-                return GetUbName(stage, NumberFormatter.FormatInt(slot, AggregateType.S32));
-            }
-
-            return $"{GetShaderStagePrefix(stage)}_{DefaultNames.UniformNamePrefix}{slot}_{DefaultNames.UniformNameSuffix}";
-        }
-
-        private static string GetUbName(ShaderStage stage, string slotExpr)
-        {
-            return $"{GetShaderStagePrefix(stage)}_{DefaultNames.UniformNamePrefix}[{slotExpr}].{DefaultNames.DataName}";
-        }
-
-        public static string GetSamplerName(ShaderStage stage, AstTextureOperation texOp, string indexExpr)
-        {
-            return GetSamplerName(stage, texOp.CbufSlot, texOp.Handle, texOp.Type.HasFlag(SamplerType.Indexed), indexExpr);
-        }
-
-        public static string GetSamplerName(ShaderStage stage, int cbufSlot, int handle, bool indexed, string indexExpr)
-        {
-            string suffix = cbufSlot < 0 ? $"_tcb_{handle:X}" : $"_cb{cbufSlot}_{handle:X}";
-
-            if (indexed)
-            {
-                suffix += $"a[{indexExpr}]";
-            }
-
-            return GetShaderStagePrefix(stage) + "_" + DefaultNames.SamplerNamePrefix + suffix;
-        }
-
-        public static string GetImageName(ShaderStage stage, AstTextureOperation texOp, string indexExpr)
-        {
-            return GetImageName(stage, texOp.CbufSlot, texOp.Handle, texOp.Format, texOp.Type.HasFlag(SamplerType.Indexed), indexExpr);
-        }
-
-        public static string GetImageName(
-            ShaderStage stage,
-            int cbufSlot,
-            int handle,
-            TextureFormat format,
-            bool indexed,
-            string indexExpr)
-        {
-            string suffix = cbufSlot < 0
-                ? $"_tcb_{handle:X}_{format.ToGlslFormat()}"
-                : $"_cb{cbufSlot}_{handle:X}_{format.ToGlslFormat()}";
-
-            if (indexed)
-            {
-                suffix += $"a[{indexExpr}]";
-            }
-
-            return GetShaderStagePrefix(stage) + "_" + DefaultNames.ImageNamePrefix + suffix;
-        }
-
-        public static string GetShaderStagePrefix(ShaderStage stage)
-        {
-            int index = (int)stage;
-
-            if ((uint)index >= StagePrefixes.Length)
-            {
-                return "invalid";
-            }
-
-            return StagePrefixes[index];
-        }
-
-        private static char GetSwizzleMask(int value)
-        {
-            return "xyzw"[value];
-        }
-
-        public static string GetArgumentName(int argIndex)
-        {
-            return $"{DefaultNames.ArgumentNamePrefix}{argIndex}";
-        }
-
-        public static AggregateType GetNodeDestType(CodeGenContext context, IAstNode node, bool isAsgDest = false)
-        {
-            if (node is AstOperation operation)
-            {
-                if (operation.Inst == Instruction.LoadAttribute)
-                {
-                    // Load attribute basically just returns the attribute value.
-                    // Some built-in attributes may have different types, so we need
-                    // to return the type based on the attribute that is being read.
-                    if (operation.GetSource(0) is AstOperand operand && operand.Type == OperandType.Constant)
-                    {
-                        if (_builtInAttributes.TryGetValue(operand.Value & ~3, out BuiltInAttribute builtInAttr))
-                        {
-                            return builtInAttr.Type;
-                        }
-                    }
-
-                    return OperandInfo.GetVarType(OperandType.Attribute);
-                }
-                else if (operation.Inst == Instruction.Call)
-                {
-                    AstOperand funcId = (AstOperand)operation.GetSource(0);
-
-                    Debug.Assert(funcId.Type == OperandType.Constant);
-
-                    return context.GetFunction(funcId.Value).ReturnType;
-                }
-                else if (operation.Inst == Instruction.VectorExtract)
-                {
-                    return GetNodeDestType(context, operation.GetSource(0)) & ~AggregateType.ElementCountMask;
-                }
-                else if (operation is AstTextureOperation texOp)
-                {
-                    if (texOp.Inst == Instruction.ImageLoad ||
-                        texOp.Inst == Instruction.ImageStore ||
-                        texOp.Inst == Instruction.ImageAtomic)
-                    {
-                        return texOp.GetVectorType(texOp.Format.GetComponentType());
-                    }
-                    else if (texOp.Inst == Instruction.TextureSample)
-                    {
-                        return texOp.GetVectorType(GetDestVarType(operation.Inst));
-                    }
-                }
-
-                return GetDestVarType(operation.Inst);
-            }
-            else if (node is AstOperand operand)
-            {
-                if (operand.Type == OperandType.Argument)
-                {
-                    int argIndex = operand.Value;
-
-                    return context.CurrentFunction.GetArgumentType(argIndex);
-                }
-
-                return GetOperandVarType(context, operand, isAsgDest);
-            }
-            else
-            {
-                throw new ArgumentException($"Invalid node type \"{node?.GetType().Name ?? "null"}\".");
-            }
-        }
-
-        private static AggregateType GetOperandVarType(CodeGenContext context, AstOperand operand, bool isAsgDest = false)
-        {
-            if (operand.Type == OperandType.Attribute)
-            {
-                if (_builtInAttributes.TryGetValue(operand.Value & ~3, out BuiltInAttribute builtInAttr))
-                {
-                    return builtInAttr.Type;
-                }
-                else if (context.Config.Stage == ShaderStage.Vertex && !isAsgDest &&
-                    operand.Value >= AttributeConsts.UserAttributeBase &&
-                    operand.Value < AttributeConsts.UserAttributeEnd)
-                {
-                    int location = (operand.Value - AttributeConsts.UserAttributeBase) / 16;
-
-                    AttributeType type = context.Config.GpuAccessor.QueryAttributeType(location);
-
-                    return type.ToAggregateType();
-                }
-                else if (context.Config.Stage == ShaderStage.Fragment && isAsgDest &&
-                    operand.Value >= AttributeConsts.FragmentOutputColorBase &&
-                    operand.Value < AttributeConsts.FragmentOutputColorEnd)
-                {
-                    int location = (operand.Value - AttributeConsts.FragmentOutputColorBase) / 16;
-
-                    AttributeType type = context.Config.GpuAccessor.QueryFragmentOutputType(location);
-
-                    return type.ToAggregateType();
-                }
-            }
-
-            return OperandInfo.GetVarType(operand);
-        }
-    }
-}

Ryujinx.Graphics.Shader/CodeGen/Spirv/Declarations.cs

@@ -1,784 +0,0 @@
-using Ryujinx.Common;
-using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation;
-using Spv.Generator;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using static Spv.Specification;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    static class Declarations
-    {
-        // At least 16 attributes are guaranteed by the spec.
-        public const int MaxAttributes = 16;
-
-        private static readonly string[] StagePrefixes = new string[] { "cp", "vp", "tcp", "tep", "gp", "fp" };
-
-        public static void DeclareParameters(CodeGenContext context, StructuredFunction function)
-        {
-            DeclareParameters(context, function.InArguments, 0);
-            DeclareParameters(context, function.OutArguments, function.InArguments.Length);
-        }
-
-        private static void DeclareParameters(CodeGenContext context, IEnumerable<AggregateType> argTypes, int argIndex)
-        {
-            foreach (var argType in argTypes)
-            {
-                var argPointerType = context.TypePointer(StorageClass.Function, context.GetType(argType));
-                var spvArg = context.FunctionParameter(argPointerType);
-
-                context.DeclareArgument(argIndex++, spvArg);
-            }
-        }
-
-        public static void DeclareLocals(CodeGenContext context, StructuredFunction function)
-        {
-            foreach (AstOperand local in function.Locals)
-            {
-                var localPointerType = context.TypePointer(StorageClass.Function, context.GetType(local.VarType));
-                var spvLocal = context.Variable(localPointerType, StorageClass.Function);
-
-                context.AddLocalVariable(spvLocal);
-                context.DeclareLocal(local, spvLocal);
-            }
-
-            var ivector2Type = context.TypeVector(context.TypeS32(), 2);
-            var coordTempPointerType = context.TypePointer(StorageClass.Function, ivector2Type);
-            var coordTemp = context.Variable(coordTempPointerType, StorageClass.Function);
-
-            context.AddLocalVariable(coordTemp);
-            context.CoordTemp = coordTemp;
-        }
-
-        public static void DeclareLocalForArgs(CodeGenContext context, List<StructuredFunction> functions)
-        {
-            for (int funcIndex = 0; funcIndex < functions.Count; funcIndex++)
-            {
-                StructuredFunction function = functions[funcIndex];
-                Instruction[] locals = new Instruction[function.InArguments.Length];
-
-                for (int i = 0; i < function.InArguments.Length; i++)
-                {
-                    var type = function.GetArgumentType(i);
-                    var localPointerType = context.TypePointer(StorageClass.Function, context.GetType(type));
-                    var spvLocal = context.Variable(localPointerType, StorageClass.Function);
-
-                    context.AddLocalVariable(spvLocal);
-
-                    locals[i] = spvLocal;
-                }
-
-                context.DeclareLocalForArgs(funcIndex, locals);
-            }
-        }
-
-        public static void DeclareAll(CodeGenContext context, StructuredProgramInfo info)
-        {
-            if (context.Config.Stage == ShaderStage.Compute)
-            {
-                int localMemorySize = BitUtils.DivRoundUp(context.Config.GpuAccessor.QueryComputeLocalMemorySize(), 4);
-
-                if (localMemorySize != 0)
-                {
-                    DeclareLocalMemory(context, localMemorySize);
-                }
-
-                int sharedMemorySize = BitUtils.DivRoundUp(context.Config.GpuAccessor.QueryComputeSharedMemorySize(), 4);
-
-                if (sharedMemorySize != 0)
-                {
-                    DeclareSharedMemory(context, sharedMemorySize);
-                }
-            }
-            else if (context.Config.LocalMemorySize != 0)
-            {
-                int localMemorySize = BitUtils.DivRoundUp(context.Config.LocalMemorySize, 4);
-                DeclareLocalMemory(context, localMemorySize);
-            }
-
-            DeclareSupportBuffer(context);
-            DeclareUniformBuffers(context, context.Config.GetConstantBufferDescriptors());
-            DeclareStorageBuffers(context, context.Config.GetStorageBufferDescriptors());
-            DeclareSamplers(context, context.Config.GetTextureDescriptors());
-            DeclareImages(context, context.Config.GetImageDescriptors());
-            DeclareInputAttributes(context, info, perPatch: false);
-            DeclareOutputAttributes(context, info, perPatch: false);
-            DeclareInputAttributes(context, info, perPatch: true);
-            DeclareOutputAttributes(context, info, perPatch: true);
-        }
-
-        private static void DeclareLocalMemory(CodeGenContext context, int size)
-        {
-            context.LocalMemory = DeclareMemory(context, StorageClass.Private, size);
-        }
-
-        private static void DeclareSharedMemory(CodeGenContext context, int size)
-        {
-            context.SharedMemory = DeclareMemory(context, StorageClass.Workgroup, size);
-        }
-
-        private static Instruction DeclareMemory(CodeGenContext context, StorageClass storage, int size)
-        {
-            var arrayType = context.TypeArray(context.TypeU32(), context.Constant(context.TypeU32(), size));
-            var pointerType = context.TypePointer(storage, arrayType);
-            var variable = context.Variable(pointerType, storage);
-
-            context.AddGlobalVariable(variable);
-
-            return variable;
-        }
-
-        private static void DeclareSupportBuffer(CodeGenContext context)
-        {
-            if (!context.Config.Stage.SupportsRenderScale() && !(context.Config.LastInVertexPipeline && context.Config.GpuAccessor.QueryViewportTransformDisable()))
-            {
-                return;
-            }
-
-            var isBgraArrayType = context.TypeArray(context.TypeU32(), context.Constant(context.TypeU32(), SupportBuffer.FragmentIsBgraCount));
-            var viewportInverseVectorType = context.TypeVector(context.TypeFP32(), 4);
-            var renderScaleArrayType = context.TypeArray(context.TypeFP32(), context.Constant(context.TypeU32(), SupportBuffer.RenderScaleMaxCount));
-
-            context.Decorate(isBgraArrayType, Decoration.ArrayStride, (LiteralInteger)SupportBuffer.FieldSize);
-            context.Decorate(renderScaleArrayType, Decoration.ArrayStride, (LiteralInteger)SupportBuffer.FieldSize);
-
-            var supportBufferStructType = context.TypeStruct(false, context.TypeU32(), isBgraArrayType, viewportInverseVectorType, context.TypeS32(), renderScaleArrayType);
-
-            context.MemberDecorate(supportBufferStructType, 0, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentAlphaTestOffset);
-            context.MemberDecorate(supportBufferStructType, 1, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentIsBgraOffset);
-            context.MemberDecorate(supportBufferStructType, 2, Decoration.Offset, (LiteralInteger)SupportBuffer.ViewportInverseOffset);
-            context.MemberDecorate(supportBufferStructType, 3, Decoration.Offset, (LiteralInteger)SupportBuffer.FragmentRenderScaleCountOffset);
-            context.MemberDecorate(supportBufferStructType, 4, Decoration.Offset, (LiteralInteger)SupportBuffer.GraphicsRenderScaleOffset);
-            context.Decorate(supportBufferStructType, Decoration.Block);
-
-            var supportBufferPointerType = context.TypePointer(StorageClass.Uniform, supportBufferStructType);
-            var supportBufferVariable = context.Variable(supportBufferPointerType, StorageClass.Uniform);
-
-            context.Decorate(supportBufferVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-            context.Decorate(supportBufferVariable, Decoration.Binding, (LiteralInteger)0);
-
-            context.AddGlobalVariable(supportBufferVariable);
-
-            context.SupportBuffer = supportBufferVariable;
-        }
-
-        private static void DeclareUniformBuffers(CodeGenContext context, BufferDescriptor[] descriptors)
-        {
-            if (descriptors.Length == 0)
-            {
-                return;
-            }
-
-            uint ubSize = Constants.ConstantBufferSize / 16;
-
-            var ubArrayType = context.TypeArray(context.TypeVector(context.TypeFP32(), 4), context.Constant(context.TypeU32(), ubSize), true);
-            context.Decorate(ubArrayType, Decoration.ArrayStride, (LiteralInteger)16);
-            var ubStructType = context.TypeStruct(true, ubArrayType);
-            context.Decorate(ubStructType, Decoration.Block);
-            context.MemberDecorate(ubStructType, 0, Decoration.Offset, (LiteralInteger)0);
-
-            if (context.Config.UsedFeatures.HasFlag(FeatureFlags.CbIndexing))
-            {
-                int count = descriptors.Max(x => x.Slot) + 1;
-
-                var ubStructArrayType = context.TypeArray(ubStructType, context.Constant(context.TypeU32(), count));
-                var ubPointerType = context.TypePointer(StorageClass.Uniform, ubStructArrayType);
-                var ubVariable = context.Variable(ubPointerType, StorageClass.Uniform);
-
-                context.Name(ubVariable, $"{GetStagePrefix(context.Config.Stage)}_u");
-                context.Decorate(ubVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-                context.Decorate(ubVariable, Decoration.Binding, (LiteralInteger)context.Config.FirstConstantBufferBinding);
-                context.AddGlobalVariable(ubVariable);
-
-                context.UniformBuffersArray = ubVariable;
-            }
-            else
-            {
-                var ubPointerType = context.TypePointer(StorageClass.Uniform, ubStructType);
-
-                foreach (var descriptor in descriptors)
-                {
-                    var ubVariable = context.Variable(ubPointerType, StorageClass.Uniform);
-
-                    context.Name(ubVariable, $"{GetStagePrefix(context.Config.Stage)}_c{descriptor.Slot}");
-                    context.Decorate(ubVariable, Decoration.DescriptorSet, (LiteralInteger)0);
-                    context.Decorate(ubVariable, Decoration.Binding, (LiteralInteger)descriptor.Binding);
-                    context.AddGlobalVariable(ubVariable);
-                    context.UniformBuffers.Add(descriptor.Slot, ubVariable);
-                }
-            }
-        }
-
-        private static void DeclareStorageBuffers(CodeGenContext context, BufferDescriptor[] descriptors)
-        {
-            if (descriptors.Length == 0)
-            {
-                return;
-            }
-
-            int setIndex = context.Config.Options.TargetApi == TargetApi.Vulkan ? 1 : 0;
-            int count = descriptors.Max(x => x.Slot) + 1;
-
-            var sbArrayType = context.TypeRuntimeArray(context.TypeU32());
-            context.Decorate(sbArrayType, Decoration.ArrayStride, (LiteralInteger)4);
-            var sbStructType = context.TypeStruct(true, sbArrayType);
-            context.Decorate(sbStructType, Decoration.BufferBlock);
-            context.MemberDecorate(sbStructType, 0, Decoration.Offset, (LiteralInteger)0);
-            var sbStructArrayType = context.TypeArray(sbStructType, context.Constant(context.TypeU32(), count));
-            var sbPointerType = context.TypePointer(StorageClass.Uniform, sbStructArrayType);
-            var sbVariable = context.Variable(sbPointerType, StorageClass.Uniform);
-
-            context.Name(sbVariable, $"{GetStagePrefix(context.Config.Stage)}_s");
-            context.Decorate(sbVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
-            context.Decorate(sbVariable, Decoration.Binding, (LiteralInteger)context.Config.FirstStorageBufferBinding);
-            context.AddGlobalVariable(sbVariable);
-
-            context.StorageBuffersArray = sbVariable;
-        }
-
-        private static void DeclareSamplers(CodeGenContext context, TextureDescriptor[] descriptors)
-        {
-            foreach (var descriptor in descriptors)
-            {
-                var meta = new TextureMeta(descriptor.CbufSlot, descriptor.HandleIndex, descriptor.Format);
-
-                if (context.Samplers.ContainsKey(meta))
-                {
-                    continue;
-                }
-
-                int setIndex = context.Config.Options.TargetApi == TargetApi.Vulkan ? 2 : 0;
-
-                var dim = (descriptor.Type & SamplerType.Mask) switch
-                {
-                    SamplerType.Texture1D => Dim.Dim1D,
-                    SamplerType.Texture2D => Dim.Dim2D,
-                    SamplerType.Texture3D => Dim.Dim3D,
-                    SamplerType.TextureCube => Dim.Cube,
-                    SamplerType.TextureBuffer => Dim.Buffer,
-                    _ => throw new InvalidOperationException($"Invalid sampler type \"{descriptor.Type & SamplerType.Mask}\".")
-                };
-
-                var imageType = context.TypeImage(
-                    context.TypeFP32(),
-                    dim,
-                    descriptor.Type.HasFlag(SamplerType.Shadow),
-                    descriptor.Type.HasFlag(SamplerType.Array),
-                    descriptor.Type.HasFlag(SamplerType.Multisample),
-                    1,
-                    ImageFormat.Unknown);
-
-                var nameSuffix = meta.CbufSlot < 0 ? $"_tcb_{meta.Handle:X}" : $"_cb{meta.CbufSlot}_{meta.Handle:X}";
-
-                var sampledImageType = context.TypeSampledImage(imageType);
-                var sampledImagePointerType = context.TypePointer(StorageClass.UniformConstant, sampledImageType);
-                var sampledImageVariable = context.Variable(sampledImagePointerType, StorageClass.UniformConstant);
-
-                context.Samplers.Add(meta, (imageType, sampledImageType, sampledImageVariable));
-                context.SamplersTypes.Add(meta, descriptor.Type);
-
-                context.Name(sampledImageVariable, $"{GetStagePrefix(context.Config.Stage)}_tex{nameSuffix}");
-                context.Decorate(sampledImageVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
-                context.Decorate(sampledImageVariable, Decoration.Binding, (LiteralInteger)descriptor.Binding);
-                context.AddGlobalVariable(sampledImageVariable);
-            }
-        }
-
-        private static void DeclareImages(CodeGenContext context, TextureDescriptor[] descriptors)
-        {
-            foreach (var descriptor in descriptors)
-            {
-                var meta = new TextureMeta(descriptor.CbufSlot, descriptor.HandleIndex, descriptor.Format);
-
-                if (context.Images.ContainsKey(meta))
-                {
-                    continue;
-                }
-
-                int setIndex = context.Config.Options.TargetApi == TargetApi.Vulkan ? 3 : 0;
-
-                var dim = GetDim(descriptor.Type);
-
-                var imageType = context.TypeImage(
-                    context.GetType(meta.Format.GetComponentType()),
-                    dim,
-                    descriptor.Type.HasFlag(SamplerType.Shadow),
-                    descriptor.Type.HasFlag(SamplerType.Array),
-                    descriptor.Type.HasFlag(SamplerType.Multisample),
-                    AccessQualifier.ReadWrite,
-                    GetImageFormat(meta.Format));
-
-                var nameSuffix = meta.CbufSlot < 0 ?
-                    $"_tcb_{meta.Handle:X}_{meta.Format.ToGlslFormat()}" :
-                    $"_cb{meta.CbufSlot}_{meta.Handle:X}_{meta.Format.ToGlslFormat()}";
-
-                var imagePointerType = context.TypePointer(StorageClass.UniformConstant, imageType);
-                var imageVariable = context.Variable(imagePointerType, StorageClass.UniformConstant);
-
-                context.Images.Add(meta, (imageType, imageVariable));
-
-                context.Name(imageVariable, $"{GetStagePrefix(context.Config.Stage)}_img{nameSuffix}");
-                context.Decorate(imageVariable, Decoration.DescriptorSet, (LiteralInteger)setIndex);
-                context.Decorate(imageVariable, Decoration.Binding, (LiteralInteger)descriptor.Binding);
-
-                if (descriptor.Flags.HasFlag(TextureUsageFlags.ImageCoherent))
-                {
-                    context.Decorate(imageVariable, Decoration.Coherent);
-                }
-
-                context.AddGlobalVariable(imageVariable);
-            }
-        }
-
-        private static Dim GetDim(SamplerType type)
-        {
-            return (type & SamplerType.Mask) switch
-            {
-                SamplerType.Texture1D => Dim.Dim1D,
-                SamplerType.Texture2D => Dim.Dim2D,
-                SamplerType.Texture3D => Dim.Dim3D,
-                SamplerType.TextureCube => Dim.Cube,
-                SamplerType.TextureBuffer => Dim.Buffer,
-                _ => throw new ArgumentException($"Invalid sampler type \"{type & SamplerType.Mask}\".")
-            };
-        }
-
-        private static ImageFormat GetImageFormat(TextureFormat format)
-        {
-            return format switch
-            {
-                TextureFormat.Unknown => ImageFormat.Unknown,
-                TextureFormat.R8Unorm => ImageFormat.R8,
-                TextureFormat.R8Snorm => ImageFormat.R8Snorm,
-                TextureFormat.R8Uint => ImageFormat.R8ui,
-                TextureFormat.R8Sint => ImageFormat.R8i,
-                TextureFormat.R16Float => ImageFormat.R16f,
-                TextureFormat.R16Unorm => ImageFormat.R16,
-                TextureFormat.R16Snorm => ImageFormat.R16Snorm,
-                TextureFormat.R16Uint => ImageFormat.R16ui,
-                TextureFormat.R16Sint => ImageFormat.R16i,
-                TextureFormat.R32Float => ImageFormat.R32f,
-                TextureFormat.R32Uint => ImageFormat.R32ui,
-                TextureFormat.R32Sint => ImageFormat.R32i,
-                TextureFormat.R8G8Unorm => ImageFormat.Rg8,
-                TextureFormat.R8G8Snorm => ImageFormat.Rg8Snorm,
-                TextureFormat.R8G8Uint => ImageFormat.Rg8ui,
-                TextureFormat.R8G8Sint => ImageFormat.Rg8i,
-                TextureFormat.R16G16Float => ImageFormat.Rg16f,
-                TextureFormat.R16G16Unorm => ImageFormat.Rg16,
-                TextureFormat.R16G16Snorm => ImageFormat.Rg16Snorm,
-                TextureFormat.R16G16Uint => ImageFormat.Rg16ui,
-                TextureFormat.R16G16Sint => ImageFormat.Rg16i,
-                TextureFormat.R32G32Float => ImageFormat.Rg32f,
-                TextureFormat.R32G32Uint => ImageFormat.Rg32ui,
-                TextureFormat.R32G32Sint => ImageFormat.Rg32i,
-                TextureFormat.R8G8B8A8Unorm => ImageFormat.Rgba8,
-                TextureFormat.R8G8B8A8Snorm => ImageFormat.Rgba8Snorm,
-                TextureFormat.R8G8B8A8Uint => ImageFormat.Rgba8ui,
-                TextureFormat.R8G8B8A8Sint => ImageFormat.Rgba8i,
-                TextureFormat.R16G16B16A16Float => ImageFormat.Rgba16f,
-                TextureFormat.R16G16B16A16Unorm => ImageFormat.Rgba16,
-                TextureFormat.R16G16B16A16Snorm => ImageFormat.Rgba16Snorm,
-                TextureFormat.R16G16B16A16Uint => ImageFormat.Rgba16ui,
-                TextureFormat.R16G16B16A16Sint => ImageFormat.Rgba16i,
-                TextureFormat.R32G32B32A32Float => ImageFormat.Rgba32f,
-                TextureFormat.R32G32B32A32Uint => ImageFormat.Rgba32ui,
-                TextureFormat.R32G32B32A32Sint => ImageFormat.Rgba32i,
-                TextureFormat.R10G10B10A2Unorm => ImageFormat.Rgb10A2,
-                TextureFormat.R10G10B10A2Uint => ImageFormat.Rgb10a2ui,
-                TextureFormat.R11G11B10Float => ImageFormat.R11fG11fB10f,
-                _ => throw new ArgumentException($"Invalid texture format \"{format}\".")
-            };
-        }
-
-        private static void DeclareInputAttributes(CodeGenContext context, StructuredProgramInfo info, bool perPatch)
-        {
-            bool iaIndexing = context.Config.UsedFeatures.HasFlag(FeatureFlags.IaIndexing);
-
-            if (iaIndexing && !perPatch)
-            {
-                var attrType = context.TypeVector(context.TypeFP32(), (LiteralInteger)4);
-                attrType = context.TypeArray(attrType, context.Constant(context.TypeU32(), (LiteralInteger)MaxAttributes));
-
-                if (context.Config.Stage == ShaderStage.Geometry)
-                {
-                    attrType = context.TypeArray(attrType, context.Constant(context.TypeU32(), (LiteralInteger)context.InputVertices));
-                }
-
-                var spvType = context.TypePointer(StorageClass.Input, attrType);
-                var spvVar = context.Variable(spvType, StorageClass.Input);
-
-                if (context.Config.PassthroughAttributes != 0 && context.Config.GpuAccessor.QueryHostSupportsGeometryShaderPassthrough())
-                {
-                    context.Decorate(spvVar, Decoration.PassthroughNV);
-                }
-
-                context.Decorate(spvVar, Decoration.Location, (LiteralInteger)0);
-
-                context.AddGlobalVariable(spvVar);
-                context.InputsArray = spvVar;
-            }
-
-            var inputs = perPatch ? info.InputsPerPatch : info.Inputs;
-
-            foreach (int attr in inputs)
-            {
-                if (!AttributeInfo.Validate(context.Config, attr, isOutAttr: false, perPatch))
-                {
-                    continue;
-                }
-
-                bool isUserAttr = attr >= AttributeConsts.UserAttributeBase && attr < AttributeConsts.UserAttributeEnd;
-
-                if (iaIndexing && isUserAttr && !perPatch)
-                {
-                    continue;
-                }
-
-                PixelImap iq = PixelImap.Unused;
-
-                if (context.Config.Stage == ShaderStage.Fragment)
-                {
-                    if (attr >= AttributeConsts.UserAttributeBase && attr < AttributeConsts.UserAttributeEnd)
-                    {
-                        iq = context.Config.ImapTypes[(attr - AttributeConsts.UserAttributeBase) / 16].GetFirstUsedType();
-                    }
-                    else
-                    {
-                        AttributeInfo attrInfo = AttributeInfo.From(context.Config, attr, isOutAttr: false);
-                        AggregateType elemType = attrInfo.Type & AggregateType.ElementTypeMask;
-
-                        if (attrInfo.IsBuiltin && (elemType == AggregateType.S32 || elemType == AggregateType.U32))
-                        {
-                            iq = PixelImap.Constant;
-                        }
-                    }
-                }
-
-                DeclareInputOrOutput(context, attr, perPatch, isOutAttr: false, iq);
-            }
-        }
-
-        private static void DeclareOutputAttributes(CodeGenContext context, StructuredProgramInfo info, bool perPatch)
-        {
-            bool oaIndexing = context.Config.UsedFeatures.HasFlag(FeatureFlags.OaIndexing);
-
-            if (oaIndexing && !perPatch)
-            {
-                var attrType = context.TypeVector(context.TypeFP32(), (LiteralInteger)4);
-                attrType = context.TypeArray(attrType, context.Constant(context.TypeU32(), (LiteralInteger)MaxAttributes));
-
-                if (context.Config.Stage == ShaderStage.TessellationControl)
-                {
-                    attrType = context.TypeArray(attrType, context.Constant(context.TypeU32(), context.Config.ThreadsPerInputPrimitive));
-                }
-
-                var spvType = context.TypePointer(StorageClass.Output, attrType);
-                var spvVar = context.Variable(spvType, StorageClass.Output);
-
-                context.Decorate(spvVar, Decoration.Location, (LiteralInteger)0);
-
-                context.AddGlobalVariable(spvVar);
-                context.OutputsArray = spvVar;
-            }
-
-            var outputs = perPatch ? info.OutputsPerPatch : info.Outputs;
-
-            foreach (int attr in outputs)
-            {
-                if (!AttributeInfo.Validate(context.Config, attr, isOutAttr: true, perPatch))
-                {
-                    continue;
-                }
-
-                bool isUserAttr = attr >= AttributeConsts.UserAttributeBase && attr < AttributeConsts.UserAttributeEnd;
-
-                if (oaIndexing && isUserAttr && !perPatch)
-                {
-                    continue;
-                }
-
-                DeclareOutputAttribute(context, attr, perPatch);
-            }
-
-            if (context.Config.Stage == ShaderStage.Vertex)
-            {
-                DeclareOutputAttribute(context, AttributeConsts.PositionX, perPatch: false);
-            }
-        }
-
-        private static void DeclareOutputAttribute(CodeGenContext context, int attr, bool perPatch)
-        {
-            DeclareInputOrOutput(context, attr, perPatch, isOutAttr: true);
-        }
-
-        public static void DeclareInvocationId(CodeGenContext context)
-        {
-            DeclareInputOrOutput(context, AttributeConsts.LaneId, perPatch: false, isOutAttr: false);
-        }
-
-        private static void DeclareInputOrOutput(CodeGenContext context, int attr, bool perPatch, bool isOutAttr, PixelImap iq = PixelImap.Unused)
-        {
-            bool isUserAttr = attr >= AttributeConsts.UserAttributeBase && attr < AttributeConsts.UserAttributeEnd;
-            if (isUserAttr && context.Config.TransformFeedbackEnabled && !perPatch &&
-                ((isOutAttr && context.Config.LastInVertexPipeline) ||
-                (!isOutAttr && context.Config.Stage == ShaderStage.Fragment)))
-            {
-                DeclareTransformFeedbackInputOrOutput(context, attr, isOutAttr, iq);
-                return;
-            }
-
-            var dict = perPatch
-                ? (isOutAttr ? context.OutputsPerPatch : context.InputsPerPatch)
-                : (isOutAttr ? context.Outputs : context.Inputs);
-
-            var attrInfo = perPatch
-                ? AttributeInfo.FromPatch(context.Config, attr, isOutAttr)
-                : AttributeInfo.From(context.Config, attr, isOutAttr);
-
-            if (dict.ContainsKey(attrInfo.BaseValue))
-            {
-                return;
-            }
-
-            var storageClass = isOutAttr ? StorageClass.Output : StorageClass.Input;
-            var attrType = context.GetType(attrInfo.Type, attrInfo.Length);
-            bool builtInPassthrough = false;
-
-            if (AttributeInfo.IsArrayAttributeSpirv(context.Config.Stage, isOutAttr) && !perPatch && (!attrInfo.IsBuiltin || AttributeInfo.IsArrayBuiltIn(attr)))
-            {
-                int arraySize = context.Config.Stage == ShaderStage.Geometry ? context.InputVertices : 32;
-                attrType = context.TypeArray(attrType, context.Constant(context.TypeU32(), (LiteralInteger)arraySize));
-
-                if (context.Config.GpPassthrough && context.Config.GpuAccessor.QueryHostSupportsGeometryShaderPassthrough())
-                {
-                    builtInPassthrough = true;
-                }
-            }
-
-            if (context.Config.Stage == ShaderStage.TessellationControl && isOutAttr && !perPatch)
-            {
-                attrType = context.TypeArray(attrType, context.Constant(context.TypeU32(), context.Config.ThreadsPerInputPrimitive));
-            }
-
-            var spvType = context.TypePointer(storageClass, attrType);
-            var spvVar = context.Variable(spvType, storageClass);
-
-            if (builtInPassthrough)
-            {
-                context.Decorate(spvVar, Decoration.PassthroughNV);
-            }
-
-            if (attrInfo.IsBuiltin)
-            {
-                if (perPatch)
-                {
-                    context.Decorate(spvVar, Decoration.Patch);
-                }
-
-                if (context.Config.GpuAccessor.QueryHostReducedPrecision() && attr == AttributeConsts.PositionX && context.Config.Stage != ShaderStage.Fragment)
-                {
-                    context.Decorate(spvVar, Decoration.Invariant);
-                }
-
-                context.Decorate(spvVar, Decoration.BuiltIn, (LiteralInteger)GetBuiltIn(context, attrInfo.BaseValue));
-
-                if (context.Config.TransformFeedbackEnabled && context.Config.LastInVertexPipeline && isOutAttr)
-                {
-                    var tfOutput = context.Info.GetTransformFeedbackOutput(attrInfo.BaseValue);
-                    if (tfOutput.Valid)
-                    {
-                        context.Decorate(spvVar, Decoration.XfbBuffer, (LiteralInteger)tfOutput.Buffer);
-                        context.Decorate(spvVar, Decoration.XfbStride, (LiteralInteger)tfOutput.Stride);
-                        context.Decorate(spvVar, Decoration.Offset, (LiteralInteger)tfOutput.Offset);
-                    }
-                }
-            }
-            else if (perPatch)
-            {
-                context.Decorate(spvVar, Decoration.Patch);
-
-                int location = context.Config.GetPerPatchAttributeLocation((attr - AttributeConsts.UserAttributePerPatchBase) / 16);
-
-                context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
-            }
-            else if (isUserAttr)
-            {
-                int location = (attr - AttributeConsts.UserAttributeBase) / 16;
-
-                context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
-
-                if (!isOutAttr &&
-                    !perPatch &&
-                    (context.Config.PassthroughAttributes & (1 << location)) != 0 &&
-                    context.Config.GpuAccessor.QueryHostSupportsGeometryShaderPassthrough())
-                {
-                    context.Decorate(spvVar, Decoration.PassthroughNV);
-                }
-            }
-            else if (attr >= AttributeConsts.FragmentOutputColorBase && attr < AttributeConsts.FragmentOutputColorEnd)
-            {
-                int location = (attr - AttributeConsts.FragmentOutputColorBase) / 16;
-                context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
-            }
-
-            if (!isOutAttr)
-            {
-                switch (iq)
-                {
-                    case PixelImap.Constant:
-                        context.Decorate(spvVar, Decoration.Flat);
-                        break;
-                    case PixelImap.ScreenLinear:
-                        context.Decorate(spvVar, Decoration.NoPerspective);
-                        break;
-                }
-            }
-
-            context.AddGlobalVariable(spvVar);
-            dict.Add(attrInfo.BaseValue, spvVar);
-        }
-
-        private static void DeclareTransformFeedbackInputOrOutput(CodeGenContext context, int attr, bool isOutAttr, PixelImap iq = PixelImap.Unused)
-        {
-            var dict = isOutAttr ? context.Outputs : context.Inputs;
-            var attrInfo = AttributeInfo.From(context.Config, attr, isOutAttr);
-
-            bool hasComponent = true;
-            int component = (attr >> 2) & 3;
-            int components = 1;
-            var type = attrInfo.Type & AggregateType.ElementTypeMask;
-
-            if (context.Config.LastInPipeline && isOutAttr)
-            {
-                components = context.Info.GetTransformFeedbackOutputComponents(attr);
-
-                if (components > 1)
-                {
-                    attr &= ~0xf;
-                    type = components switch
-                    {
-                        2 => AggregateType.Vector2 | AggregateType.FP32,
-                        3 => AggregateType.Vector3 | AggregateType.FP32,
-                        4 => AggregateType.Vector4 | AggregateType.FP32,
-                        _ => AggregateType.FP32
-                    };
-
-                    hasComponent = false;
-                }
-            }
-
-            if (dict.ContainsKey(attr))
-            {
-                return;
-            }
-
-            var storageClass = isOutAttr ? StorageClass.Output : StorageClass.Input;
-            var attrType = context.GetType(type, components);
-
-            if (AttributeInfo.IsArrayAttributeSpirv(context.Config.Stage, isOutAttr) && (!attrInfo.IsBuiltin || AttributeInfo.IsArrayBuiltIn(attr)))
-            {
-                int arraySize = context.Config.Stage == ShaderStage.Geometry ? context.InputVertices : 32;
-                attrType = context.TypeArray(attrType, context.Constant(context.TypeU32(), (LiteralInteger)arraySize));
-            }
-
-            if (context.Config.Stage == ShaderStage.TessellationControl && isOutAttr)
-            {
-                attrType = context.TypeArray(attrType, context.Constant(context.TypeU32(), context.Config.ThreadsPerInputPrimitive));
-            }
-
-            var spvType = context.TypePointer(storageClass, attrType);
-            var spvVar = context.Variable(spvType, storageClass);
-
-            Debug.Assert(attr >= AttributeConsts.UserAttributeBase && attr < AttributeConsts.UserAttributeEnd);
-            int location = (attr - AttributeConsts.UserAttributeBase) / 16;
-
-            context.Decorate(spvVar, Decoration.Location, (LiteralInteger)location);
-
-            if (hasComponent)
-            {
-                context.Decorate(spvVar, Decoration.Component, (LiteralInteger)component);
-            }
-
-            if (isOutAttr)
-            {
-                var tfOutput = context.Info.GetTransformFeedbackOutput(attr);
-                if (tfOutput.Valid)
-                {
-                    context.Decorate(spvVar, Decoration.XfbBuffer, (LiteralInteger)tfOutput.Buffer);
-                    context.Decorate(spvVar, Decoration.XfbStride, (LiteralInteger)tfOutput.Stride);
-                    context.Decorate(spvVar, Decoration.Offset, (LiteralInteger)tfOutput.Offset);
-                }
-            }
-            else
-            {
-                if ((context.Config.PassthroughAttributes & (1 << location)) != 0 &&
-                    context.Config.GpuAccessor.QueryHostSupportsGeometryShaderPassthrough())
-                {
-                    context.Decorate(spvVar, Decoration.PassthroughNV);
-                }
-
-                switch (iq)
-                {
-                    case PixelImap.Constant:
-                        context.Decorate(spvVar, Decoration.Flat);
-                        break;
-                    case PixelImap.ScreenLinear:
-                        context.Decorate(spvVar, Decoration.NoPerspective);
-                        break;
-                }
-            }
-
-            context.AddGlobalVariable(spvVar);
-            dict.Add(attr, spvVar);
-        }
-
-        private static BuiltIn GetBuiltIn(CodeGenContext context, int attr)
-        {
-            return attr switch
-            {
-                AttributeConsts.TessLevelOuter0 => BuiltIn.TessLevelOuter,
-                AttributeConsts.TessLevelInner0 => BuiltIn.TessLevelInner,
-                AttributeConsts.Layer => BuiltIn.Layer,
-                AttributeConsts.ViewportIndex => BuiltIn.ViewportIndex,
-                AttributeConsts.PointSize => BuiltIn.PointSize,
-                AttributeConsts.PositionX => context.Config.Stage == ShaderStage.Fragment ? BuiltIn.FragCoord : BuiltIn.Position,
-                AttributeConsts.ClipDistance0 => BuiltIn.ClipDistance,
-                AttributeConsts.PointCoordX => BuiltIn.PointCoord,
-                AttributeConsts.TessCoordX => BuiltIn.TessCoord,
-                AttributeConsts.InstanceId => BuiltIn.InstanceId,
-                AttributeConsts.VertexId => BuiltIn.VertexId,
-                AttributeConsts.BaseInstance => BuiltIn.BaseInstance,
-                AttributeConsts.BaseVertex => BuiltIn.BaseVertex,
-                AttributeConsts.InstanceIndex => BuiltIn.InstanceIndex,
-                AttributeConsts.VertexIndex => BuiltIn.VertexIndex,
-                AttributeConsts.DrawIndex => BuiltIn.DrawIndex,
-                AttributeConsts.FrontFacing => BuiltIn.FrontFacing,
-                AttributeConsts.FragmentOutputDepth => BuiltIn.FragDepth,
-                AttributeConsts.ThreadKill => BuiltIn.HelperInvocation,
-                AttributeConsts.ThreadIdX => BuiltIn.LocalInvocationId,
-                AttributeConsts.CtaIdX => BuiltIn.WorkgroupId,
-                AttributeConsts.LaneId => BuiltIn.SubgroupLocalInvocationId,
-                AttributeConsts.InvocationId => BuiltIn.InvocationId,
-                AttributeConsts.PrimitiveId => BuiltIn.PrimitiveId,
-                AttributeConsts.PatchVerticesIn => BuiltIn.PatchVertices,
-                AttributeConsts.EqMask => BuiltIn.SubgroupEqMask,
-                AttributeConsts.GeMask => BuiltIn.SubgroupGeMask,
-                AttributeConsts.GtMask => BuiltIn.SubgroupGtMask,
-                AttributeConsts.LeMask => BuiltIn.SubgroupLeMask,
-                AttributeConsts.LtMask => BuiltIn.SubgroupLtMask,
-                AttributeConsts.SupportBlockViewInverseX => BuiltIn.Position,
-                AttributeConsts.SupportBlockViewInverseY => BuiltIn.Position,
-                _ => throw new ArgumentException($"Invalid attribute number 0x{attr:X}.")
-            };
-        }
-
-        private static string GetStagePrefix(ShaderStage stage)
-        {
-            return StagePrefixes[(int)stage];
-        }
-    }
-}

Ryujinx.Graphics.Shader/CodeGen/Spirv/ScalingHelpers.cs

@@ -1,227 +0,0 @@
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using Ryujinx.Graphics.Shader.StructuredIr;
-using Ryujinx.Graphics.Shader.Translation;
-using static Spv.Specification;
-
-namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
-{
-    using SpvInstruction = Spv.Generator.Instruction;
-
-    static class ScalingHelpers
-    {
-        public static SpvInstruction ApplyScaling(
-            CodeGenContext context,
-            AstTextureOperation texOp,
-            SpvInstruction vector,
-            bool intCoords,
-            bool isBindless,
-            bool isIndexed,
-            bool isArray,
-            int pCount)
-        {
-            if (intCoords)
-            {
-                if (context.Config.Stage.SupportsRenderScale() &&
-                    !isBindless &&
-                    !isIndexed)
-                {
-                    int index = texOp.Inst == Instruction.ImageLoad
-                        ? context.Config.GetTextureDescriptors().Length + context.Config.FindImageDescriptorIndex(texOp)
-                        : context.Config.FindTextureDescriptorIndex(texOp);
-
-                    if (pCount == 3 && isArray)
-                    {
-                        return ApplyScaling2DArray(context, vector, index);
-                    }
-                    else if (pCount == 2 && !isArray)
-                    {
-                        return ApplyScaling2D(context, vector, index);
-                    }
-                }
-            }
-
-            return vector;
-        }
-
-        private static SpvInstruction ApplyScaling2DArray(CodeGenContext context, SpvInstruction vector, int index)
-        {
-            // The array index is not scaled, just x and y.
-            var vectorXY = context.VectorShuffle(context.TypeVector(context.TypeS32(), 2), vector, vector, 0, 1);
-            var vectorZ = context.CompositeExtract(context.TypeS32(), vector, 2);
-            var vectorXYScaled = ApplyScaling2D(context, vectorXY, index);
-            var vectorScaled = context.CompositeConstruct(context.TypeVector(context.TypeS32(), 3), vectorXYScaled, vectorZ);
-
-            return vectorScaled;
-        }
-
-        private static SpvInstruction ApplyScaling2D(CodeGenContext context, SpvInstruction vector, int index)
-        {
-            var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeFP32());
-            var fieldIndex = context.Constant(context.TypeU32(), 4);
-            var scaleIndex = context.Constant(context.TypeU32(), index);
-
-            if (context.Config.Stage == ShaderStage.Vertex)
-            {
-                var scaleCountPointerType = context.TypePointer(StorageClass.Uniform, context.TypeS32());
-                var scaleCountElemPointer = context.AccessChain(scaleCountPointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 3));
-                var scaleCount = context.Load(context.TypeS32(), scaleCountElemPointer);
-
-                scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, scaleCount);
-            }
-
-            scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, context.Constant(context.TypeU32(), 1));
-
-            var scaleElemPointer = context.AccessChain(pointerType, context.SupportBuffer, fieldIndex, scaleIndex);
-            var scale = context.Load(context.TypeFP32(), scaleElemPointer);
-
-            var ivector2Type = context.TypeVector(context.TypeS32(), 2);
-            var localVector = context.CoordTemp;
-
-            var passthrough = context.FOrdEqual(context.TypeBool(), scale, context.Constant(context.TypeFP32(), 1f));
-
-            var mergeLabel = context.Label();
-
-            if (context.Config.Stage == ShaderStage.Fragment)
-            {
-                var scaledInterpolatedLabel = context.Label();
-                var scaledNoInterpolationLabel = context.Label();
-
-                var needsInterpolation = context.FOrdLessThan(context.TypeBool(), scale, context.Constant(context.TypeFP32(), 0f));
-
-                context.SelectionMerge(mergeLabel, SelectionControlMask.MaskNone);
-                context.BranchConditional(needsInterpolation, scaledInterpolatedLabel, scaledNoInterpolationLabel);
-
-                // scale < 0.0
-                context.AddLabel(scaledInterpolatedLabel);
-
-                ApplyScalingInterpolated(context, localVector, vector, scale);
-                context.Branch(mergeLabel);
-
-                // scale >= 0.0
-                context.AddLabel(scaledNoInterpolationLabel);
-
-                ApplyScalingNoInterpolation(context, localVector, vector, scale);
-                context.Branch(mergeLabel);
-
-                context.AddLabel(mergeLabel);
-
-                var passthroughLabel = context.Label();
-                var finalMergeLabel = context.Label();
-
-                context.SelectionMerge(finalMergeLabel, SelectionControlMask.MaskNone);
-                context.BranchConditional(passthrough, passthroughLabel, finalMergeLabel);
-
-                context.AddLabel(passthroughLabel);
-
-                context.Store(localVector, vector);
-                context.Branch(finalMergeLabel);
-
-                context.AddLabel(finalMergeLabel);
-
-                return context.Load(ivector2Type, localVector);
-            }
-            else
-            {
-                var passthroughLabel = context.Label();
-                var scaledLabel = context.Label();
-
-                context.SelectionMerge(mergeLabel, SelectionControlMask.MaskNone);
-                context.BranchConditional(passthrough, passthroughLabel, scaledLabel);
-
-                // scale == 1.0
-                context.AddLabel(passthroughLabel);
-
-                context.Store(localVector, vector);
-                context.Branch(mergeLabel);
-
-                // scale != 1.0
-                context.AddLabel(scaledLabel);
-
-                ApplyScalingNoInterpolation(context, localVector, vector, scale);
-                context.Branch(mergeLabel);
-
-                context.AddLabel(mergeLabel);
-
-                return context.Load(ivector2Type, localVector);
-            }
-        }
-
-        private static void ApplyScalingInterpolated(CodeGenContext context, SpvInstruction output, SpvInstruction vector, SpvInstruction scale)
-        {
-            var vector2Type = context.TypeVector(context.TypeFP32(), 2);
-
-            var scaleNegated = context.FNegate(context.TypeFP32(), scale);
-            var scaleVector = context.CompositeConstruct(vector2Type, scaleNegated, scaleNegated);
-
-            var vectorFloat = context.ConvertSToF(vector2Type, vector);
-            var vectorScaled = context.VectorTimesScalar(vector2Type, vectorFloat, scaleNegated);
-
-            var fragCoordPointer = context.Inputs[AttributeConsts.PositionX];
-            var fragCoord = context.Load(context.TypeVector(context.TypeFP32(), 4), fragCoordPointer);
-            var fragCoordXY = context.VectorShuffle(vector2Type, fragCoord, fragCoord, 0, 1);
-
-            var scaleMod = context.FMod(vector2Type, fragCoordXY, scaleVector);
-            var vectorInterpolated = context.FAdd(vector2Type, vectorScaled, scaleMod);
-
-            context.Store(output, context.ConvertFToS(context.TypeVector(context.TypeS32(), 2), vectorInterpolated));
-        }
-
-        private static void ApplyScalingNoInterpolation(CodeGenContext context, SpvInstruction output, SpvInstruction vector, SpvInstruction scale)
-        {
-            if (context.Config.Stage == ShaderStage.Vertex)
-            {
-                scale = context.GlslFAbs(context.TypeFP32(), scale);
-            }
-
-            var vector2Type = context.TypeVector(context.TypeFP32(), 2);
-
-            var vectorFloat = context.ConvertSToF(vector2Type, vector);
-            var vectorScaled = context.VectorTimesScalar(vector2Type, vectorFloat, scale);
-
-            context.Store(output, context.ConvertFToS(context.TypeVector(context.TypeS32(), 2), vectorScaled));
-        }
-
-        public static SpvInstruction ApplyUnscaling(
-            CodeGenContext context,
-            AstTextureOperation texOp,
-            SpvInstruction size,
-            bool isBindless,
-            bool isIndexed)
-        {
-            if (context.Config.Stage.SupportsRenderScale() &&
-                !isBindless &&
-                !isIndexed)
-            {
-                int index = context.Config.FindTextureDescriptorIndex(texOp);
-
-                var pointerType = context.TypePointer(StorageClass.Uniform, context.TypeFP32());
-                var fieldIndex = context.Constant(context.TypeU32(), 4);
-                var scaleIndex = context.Constant(context.TypeU32(), index);
-
-                if (context.Config.Stage == ShaderStage.Vertex)
-                {
-                    var scaleCountPointerType = context.TypePointer(StorageClass.Uniform, context.TypeS32());
-                    var scaleCountElemPointer = context.AccessChain(scaleCountPointerType, context.SupportBuffer, context.Constant(context.TypeU32(), 3));
-                    var scaleCount = context.Load(context.TypeS32(), scaleCountElemPointer);
-
-                    scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, scaleCount);
-                }
-
-                scaleIndex = context.IAdd(context.TypeU32(), scaleIndex, context.Constant(context.TypeU32(), 1));
-
-                var scaleElemPointer = context.AccessChain(pointerType, context.SupportBuffer, fieldIndex, scaleIndex);
-                var scale = context.GlslFAbs(context.TypeFP32(), context.Load(context.TypeFP32(), scaleElemPointer));
-
-                var passthrough = context.FOrdEqual(context.TypeBool(), scale, context.Constant(context.TypeFP32(), 1f));
-
-                var sizeFloat = context.ConvertSToF(context.TypeFP32(), size);
-                var sizeUnscaled = context.FDiv(context.TypeFP32(), sizeFloat, scale);
-                var sizeUnscaledInt = context.ConvertFToS(context.TypeS32(), sizeUnscaled);
-
-                return context.Select(context.TypeS32(), passthrough, size, sizeUnscaledInt);
-            }
-
-            return size;
-        }
-    }
-}

Ryujinx.Graphics.Shader/Instructions/InstEmitPredicate.cs

@@ -1,54 +0,0 @@
-using Ryujinx.Graphics.Shader.Decoders;
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using Ryujinx.Graphics.Shader.Translation;
-
-using static Ryujinx.Graphics.Shader.Instructions.InstEmitAluHelper;
-using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
-using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
-
-namespace Ryujinx.Graphics.Shader.Instructions
-{
-    static partial class InstEmit
-    {
-        public static void Pset(EmitterContext context)
-        {
-            InstPset op = context.GetOp<InstPset>();
-
-            Operand srcA = context.BitwiseNot(Register(op.Src2Pred, RegisterType.Predicate), op.Src2PredInv);
-            Operand srcB = context.BitwiseNot(Register(op.Src1Pred, RegisterType.Predicate), op.Src1PredInv);
-            Operand srcC = context.BitwiseNot(Register(op.SrcPred, RegisterType.Predicate), op.SrcPredInv);
-
-            Operand res = GetPredLogicalOp(context, op.BoolOpAB, srcA, srcB);
-            res = GetPredLogicalOp(context, op.BoolOpC, res, srcC);
-
-            Operand dest = GetDest(op.Dest);
-
-            if (op.BVal)
-            {
-                context.Copy(dest, context.ConditionalSelect(res, ConstF(1), Const(0)));
-            }
-            else
-            {
-                context.Copy(dest, res);
-            }
-        }
-
-        public static void Psetp(EmitterContext context)
-        {
-            InstPsetp op = context.GetOp<InstPsetp>();
-
-            Operand srcA = context.BitwiseNot(Register(op.Src2Pred, RegisterType.Predicate), op.Src2PredInv);
-            Operand srcB = context.BitwiseNot(Register(op.Src1Pred, RegisterType.Predicate), op.Src1PredInv);
-
-            Operand p0Res = GetPredLogicalOp(context, op.BoolOpAB, srcA, srcB);
-            Operand p1Res = context.BitwiseNot(p0Res);
-            Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
-
-            p0Res = GetPredLogicalOp(context, op.BoolOpC, p0Res, srcPred);
-            p1Res = GetPredLogicalOp(context, op.BoolOpC, p1Res, srcPred);
-
-            context.Copy(Register(op.DestPred, RegisterType.Predicate), p0Res);
-            context.Copy(Register(op.DestPredInv, RegisterType.Predicate), p1Res);
-        }
-    }
-}

Ryujinx.Graphics.Shader/IntermediateRepresentation/OperandType.cs

@@ -1,23 +0,0 @@
-namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
-{
-    enum OperandType
-    {
-        Argument,
-        Attribute,
-        AttributePerPatch,
-        Constant,
-        ConstantBuffer,
-        Label,
-        LocalVariable,
-        Register,
-        Undefined
-    }
-
-    static class OperandTypeExtensions
-    {
-        public static bool IsAttribute(this OperandType type)
-        {
-            return type == OperandType.Attribute || type == OperandType.AttributePerPatch;
-        }
-    }
-}

Ryujinx.Graphics.Shader/StructuredIr/StructuredProgramInfo.cs

@@ -1,81 +0,0 @@
-using System.Collections.Generic;
-
-namespace Ryujinx.Graphics.Shader.StructuredIr
-{
-    readonly struct TransformFeedbackOutput
-    {
-        public readonly bool Valid;
-        public readonly int Buffer;
-        public readonly int Offset;
-        public readonly int Stride;
-
-        public TransformFeedbackOutput(int buffer, int offset, int stride)
-        {
-            Valid = true;
-            Buffer = buffer;
-            Offset = offset;
-            Stride = stride;
-        }
-    }
-
-    class StructuredProgramInfo
-    {
-        public List<StructuredFunction> Functions { get; }
-
-        public HashSet<int> Inputs { get; }
-        public HashSet<int> Outputs { get; }
-        public HashSet<int> InputsPerPatch { get; }
-        public HashSet<int> OutputsPerPatch { get; }
-
-        public HelperFunctionsMask HelperFunctionsMask { get; set; }
-
-        public TransformFeedbackOutput[] TransformFeedbackOutputs { get; }
-
-        public StructuredProgramInfo()
-        {
-            Functions = new List<StructuredFunction>();
-
-            Inputs = new HashSet<int>();
-            Outputs = new HashSet<int>();
-            InputsPerPatch = new HashSet<int>();
-            OutputsPerPatch = new HashSet<int>();
-
-            TransformFeedbackOutputs = new TransformFeedbackOutput[0xc0];
-        }
-
-        public TransformFeedbackOutput GetTransformFeedbackOutput(int attr)
-        {
-            int index = attr / 4;
-            return TransformFeedbackOutputs[index];
-        }
-
-        public int GetTransformFeedbackOutputComponents(int attr)
-        {
-            int index = attr / 4;
-            int baseIndex = index & ~3;
-
-            int count = 1;
-
-            for (; count < 4; count++)
-            {
-                ref var prev = ref TransformFeedbackOutputs[baseIndex + count - 1];
-                ref var curr = ref TransformFeedbackOutputs[baseIndex + count];
-
-                int prevOffset = prev.Offset;
-                int currOffset = curr.Offset;
-
-                if (!prev.Valid || !curr.Valid || prevOffset + 4 != currOffset)
-                {
-                    break;
-                }
-            }
-
-            if (baseIndex + count <= index)
-            {
-                return 1;
-            }
-
-            return count;
-        }
-    }
-}

Ryujinx.Graphics.Shader/Translation/AggregateType.cs

@@ -1,25 +0,0 @@
-namespace Ryujinx.Graphics.Shader.Translation
-{
-    enum AggregateType
-    {
-        Invalid,
-        Void,
-        Bool,
-        FP32,
-        FP64,
-        S32,
-        U32,
-
-        ElementTypeMask = 0xff,
-
-        ElementCountShift = 8,
-        ElementCountMask = 3 << ElementCountShift,
-
-        Scalar = 0 << ElementCountShift,
-        Vector2 = 1 << ElementCountShift,
-        Vector3 = 2 << ElementCountShift,
-        Vector4 = 3 << ElementCountShift,
-
-        Array  = 1 << 10
-    }
-}

Ryujinx.Graphics.Shader/Translation/AttributeConsts.cs

@@ -1,105 +0,0 @@
-namespace Ryujinx.Graphics.Shader.Translation
-{
-    static class AttributeConsts
-    {
-        public const int TessLevelOuter0     = 0x000;
-        public const int TessLevelOuter1     = 0x004;
-        public const int TessLevelOuter2     = 0x008;
-        public const int TessLevelOuter3     = 0x00c;
-        public const int TessLevelInner0     = 0x010;
-        public const int TessLevelInner1     = 0x014;
-        public const int PrimitiveId         = 0x060;
-        public const int Layer               = 0x064;
-        public const int ViewportIndex       = 0x068;
-        public const int PointSize           = 0x06c;
-        public const int PositionX           = 0x070;
-        public const int PositionY           = 0x074;
-        public const int PositionZ           = 0x078;
-        public const int PositionW           = 0x07c;
-        public const int FrontColorDiffuseR  = 0x280;
-        public const int FrontColorDiffuseG  = 0x284;
-        public const int FrontColorDiffuseB  = 0x288;
-        public const int FrontColorDiffuseA  = 0x28c;
-        public const int FrontColorSpecularR = 0x290;
-        public const int FrontColorSpecularG = 0x294;
-        public const int FrontColorSpecularB = 0x298;
-        public const int FrontColorSpecularA = 0x29c;
-        public const int BackColorDiffuseR   = 0x2a0;
-        public const int BackColorDiffuseG   = 0x2a4;
-        public const int BackColorDiffuseB   = 0x2a8;
-        public const int BackColorDiffuseA   = 0x2ac;
-        public const int BackColorSpecularR  = 0x2b0;
-        public const int BackColorSpecularG  = 0x2b4;
-        public const int BackColorSpecularB  = 0x2b8;
-        public const int BackColorSpecularA  = 0x2bc;
-        public const int ClipDistance0       = 0x2c0;
-        public const int ClipDistance1       = 0x2c4;
-        public const int ClipDistance2       = 0x2c8;
-        public const int ClipDistance3       = 0x2cc;
-        public const int ClipDistance4       = 0x2d0;
-        public const int ClipDistance5       = 0x2d4;
-        public const int ClipDistance6       = 0x2d8;
-        public const int ClipDistance7       = 0x2dc;
-        public const int PointCoordX         = 0x2e0;
-        public const int PointCoordY         = 0x2e4;
-        public const int TessCoordX          = 0x2f0;
-        public const int TessCoordY          = 0x2f4;
-        public const int InstanceId          = 0x2f8;
-        public const int VertexId            = 0x2fc;
-        public const int TexCoordCount       = 10;
-        public const int TexCoordBase        = 0x300;
-        public const int TexCoordEnd         = TexCoordBase + TexCoordCount * 16;
-        public const int FrontFacing         = 0x3fc;
-
-        public const int UserAttributesCount = 32;
-        public const int UserAttributeBase   = 0x80;
-        public const int UserAttributeEnd    = UserAttributeBase + UserAttributesCount * 16;
-
-        public const int UserAttributePerPatchBase = 0x18;
-        public const int UserAttributePerPatchEnd  = 0x200;
-
-        public const int LoadOutputMask = 1 << 30;
-        public const int Mask = 0x3fffffff;
-
-
-        // Note: Those attributes are used internally by the translator
-        // only, they don't exist on Maxwell.
-        public const int SpecialMask             = 0xf << 24;
-        public const int FragmentOutputDepth     = 0x1000000;
-        public const int FragmentOutputColorBase = 0x1000010;
-        public const int FragmentOutputColorEnd  = FragmentOutputColorBase + 8 * 16;
-
-        public const int FragmentOutputIsBgraBase = 0x1000100;
-        public const int FragmentOutputIsBgraEnd  = FragmentOutputIsBgraBase + 8 * 4;
-
-        public const int SupportBlockViewInverseX = 0x1000200;
-        public const int SupportBlockViewInverseY = 0x1000204;
-
-        public const int ThreadIdX = 0x2000000;
-        public const int ThreadIdY = 0x2000004;
-        public const int ThreadIdZ = 0x2000008;
-
-        public const int CtaIdX = 0x2000010;
-        public const int CtaIdY = 0x2000014;
-        public const int CtaIdZ = 0x2000018;
-
-        public const int LaneId = 0x2000020;
-
-        public const int InvocationId = 0x2000024;
-        public const int PatchVerticesIn = 0x2000028;
-
-        public const int EqMask = 0x2000030;
-        public const int GeMask = 0x2000034;
-        public const int GtMask = 0x2000038;
-        public const int LeMask = 0x200003c;
-        public const int LtMask = 0x2000040;
-
-        public const int ThreadKill = 0x2000044;
-
-        public const int BaseInstance = 0x2000050;
-        public const int BaseVertex = 0x2000054;
-        public const int InstanceIndex = 0x2000058;
-        public const int VertexIndex = 0x200005c;
-        public const int DrawIndex = 0x2000060;
-    }
-}

Ryujinx.Graphics.Shader/Translation/AttributeInfo.cs

@@ -1,210 +0,0 @@
-using System.Collections.Generic;
-
-namespace Ryujinx.Graphics.Shader.Translation
-{
-    readonly struct AttributeInfo
-    {
-        private static readonly Dictionary<int, AttributeInfo> _builtInAttributes = new Dictionary<int, AttributeInfo>()
-        {
-            { AttributeConsts.Layer,         new AttributeInfo(AttributeConsts.Layer,         0, 1, AggregateType.S32) },
-            { AttributeConsts.ViewportIndex, new AttributeInfo(AttributeConsts.ViewportIndex, 0, 1, AggregateType.S32) },
-            { AttributeConsts.PointSize,     new AttributeInfo(AttributeConsts.PointSize,     0, 1, AggregateType.FP32) },
-            { AttributeConsts.PositionX,     new AttributeInfo(AttributeConsts.PositionX,     0, 4, AggregateType.Vector4 | AggregateType.FP32) },
-            { AttributeConsts.PositionY,     new AttributeInfo(AttributeConsts.PositionX,     1, 4, AggregateType.Vector4 | AggregateType.FP32) },
-            { AttributeConsts.PositionZ,     new AttributeInfo(AttributeConsts.PositionX,     2, 4, AggregateType.Vector4 | AggregateType.FP32) },
-            { AttributeConsts.PositionW,     new AttributeInfo(AttributeConsts.PositionX,     3, 4, AggregateType.Vector4 | AggregateType.FP32) },
-            { AttributeConsts.ClipDistance0, new AttributeInfo(AttributeConsts.ClipDistance0, 0, 8, AggregateType.Array   | AggregateType.FP32) },
-            { AttributeConsts.ClipDistance1, new AttributeInfo(AttributeConsts.ClipDistance0, 1, 8, AggregateType.Array   | AggregateType.FP32) },
-            { AttributeConsts.ClipDistance2, new AttributeInfo(AttributeConsts.ClipDistance0, 2, 8, AggregateType.Array   | AggregateType.FP32) },
-            { AttributeConsts.ClipDistance3, new AttributeInfo(AttributeConsts.ClipDistance0, 3, 8, AggregateType.Array   | AggregateType.FP32) },
-            { AttributeConsts.ClipDistance4, new AttributeInfo(AttributeConsts.ClipDistance0, 4, 8, AggregateType.Array   | AggregateType.FP32) },
-            { AttributeConsts.ClipDistance5, new AttributeInfo(AttributeConsts.ClipDistance0, 5, 8, AggregateType.Array   | AggregateType.FP32) },
-            { AttributeConsts.ClipDistance6, new AttributeInfo(AttributeConsts.ClipDistance0, 6, 8, AggregateType.Array   | AggregateType.FP32) },
-            { AttributeConsts.ClipDistance7, new AttributeInfo(AttributeConsts.ClipDistance0, 7, 8, AggregateType.Array   | AggregateType.FP32) },
-            { AttributeConsts.PointCoordX,   new AttributeInfo(AttributeConsts.PointCoordX,   0, 2, AggregateType.Vector4 | AggregateType.FP32) },
-            { AttributeConsts.PointCoordY,   new AttributeInfo(AttributeConsts.PointCoordX,   1, 2, AggregateType.Vector4 | AggregateType.FP32) },
-            { AttributeConsts.TessCoordX,    new AttributeInfo(AttributeConsts.TessCoordX,    0, 3, AggregateType.Vector4 | AggregateType.FP32) },
-            { AttributeConsts.TessCoordY,    new AttributeInfo(AttributeConsts.TessCoordX,    1, 3, AggregateType.Vector4 | AggregateType.FP32) },
-            { AttributeConsts.InstanceId,    new AttributeInfo(AttributeConsts.InstanceId,    0, 1, AggregateType.S32) },
-            { AttributeConsts.VertexId,      new AttributeInfo(AttributeConsts.VertexId,      0, 1, AggregateType.S32) },
-            { AttributeConsts.BaseInstance,  new AttributeInfo(AttributeConsts.BaseInstance,  0, 1, AggregateType.S32) },
-            { AttributeConsts.BaseVertex,    new AttributeInfo(AttributeConsts.BaseVertex,    0, 1, AggregateType.S32) },
-            { AttributeConsts.InstanceIndex, new AttributeInfo(AttributeConsts.InstanceIndex, 0, 1, AggregateType.S32) },
-            { AttributeConsts.VertexIndex,   new AttributeInfo(AttributeConsts.VertexIndex,   0, 1, AggregateType.S32) },
-            { AttributeConsts.DrawIndex,     new AttributeInfo(AttributeConsts.DrawIndex,     0, 1, AggregateType.S32) },
-            { AttributeConsts.FrontFacing,   new AttributeInfo(AttributeConsts.FrontFacing,   0, 1, AggregateType.Bool) },
-
-            // Special.
-            { AttributeConsts.FragmentOutputDepth, new AttributeInfo(AttributeConsts.FragmentOutputDepth, 0, 1, AggregateType.FP32) },
-            { AttributeConsts.ThreadKill,          new AttributeInfo(AttributeConsts.ThreadKill,          0, 1, AggregateType.Bool) },
-            { AttributeConsts.ThreadIdX,           new AttributeInfo(AttributeConsts.ThreadIdX,           0, 3, AggregateType.Vector3 | AggregateType.U32) },
-            { AttributeConsts.ThreadIdY,           new AttributeInfo(AttributeConsts.ThreadIdX,           1, 3, AggregateType.Vector3 | AggregateType.U32) },
-            { AttributeConsts.ThreadIdZ,           new AttributeInfo(AttributeConsts.ThreadIdX,           2, 3, AggregateType.Vector3 | AggregateType.U32) },
-            { AttributeConsts.CtaIdX,              new AttributeInfo(AttributeConsts.CtaIdX,              0, 3, AggregateType.Vector3 | AggregateType.U32) },
-            { AttributeConsts.CtaIdY,              new AttributeInfo(AttributeConsts.CtaIdX,              1, 3, AggregateType.Vector3 | AggregateType.U32) },
-            { AttributeConsts.CtaIdZ,              new AttributeInfo(AttributeConsts.CtaIdX,              2, 3, AggregateType.Vector3 | AggregateType.U32) },
-            { AttributeConsts.LaneId,              new AttributeInfo(AttributeConsts.LaneId,              0, 1, AggregateType.U32) },
-            { AttributeConsts.InvocationId,        new AttributeInfo(AttributeConsts.InvocationId,        0, 1, AggregateType.S32) },
-            { AttributeConsts.PrimitiveId,         new AttributeInfo(AttributeConsts.PrimitiveId,         0, 1, AggregateType.S32) },
-            { AttributeConsts.PatchVerticesIn,     new AttributeInfo(AttributeConsts.PatchVerticesIn,     0, 1, AggregateType.S32) },
-            { AttributeConsts.EqMask,              new AttributeInfo(AttributeConsts.EqMask,              0, 4, AggregateType.Vector4 | AggregateType.U32) },
-            { AttributeConsts.GeMask,              new AttributeInfo(AttributeConsts.GeMask,              0, 4, AggregateType.Vector4 | AggregateType.U32) },
-            { AttributeConsts.GtMask,              new AttributeInfo(AttributeConsts.GtMask,              0, 4, AggregateType.Vector4 | AggregateType.U32) },
-            { AttributeConsts.LeMask,              new AttributeInfo(AttributeConsts.LeMask,              0, 4, AggregateType.Vector4 | AggregateType.U32) },
-            { AttributeConsts.LtMask,              new AttributeInfo(AttributeConsts.LtMask,              0, 4, AggregateType.Vector4 | AggregateType.U32) },
-        };
-
-        private static readonly Dictionary<int, AttributeInfo> _builtInAttributesPerPatch = new Dictionary<int, AttributeInfo>()
-        {
-            { AttributeConsts.TessLevelOuter0, new AttributeInfo(AttributeConsts.TessLevelOuter0, 0, 4, AggregateType.Array | AggregateType.FP32) },
-            { AttributeConsts.TessLevelOuter1, new AttributeInfo(AttributeConsts.TessLevelOuter0, 1, 4, AggregateType.Array | AggregateType.FP32) },
-            { AttributeConsts.TessLevelOuter2, new AttributeInfo(AttributeConsts.TessLevelOuter0, 2, 4, AggregateType.Array | AggregateType.FP32) },
-            { AttributeConsts.TessLevelOuter3, new AttributeInfo(AttributeConsts.TessLevelOuter0, 3, 4, AggregateType.Array | AggregateType.FP32) },
-            { AttributeConsts.TessLevelInner0, new AttributeInfo(AttributeConsts.TessLevelInner0, 0, 2, AggregateType.Array | AggregateType.FP32) },
-            { AttributeConsts.TessLevelInner1, new AttributeInfo(AttributeConsts.TessLevelInner0, 1, 2, AggregateType.Array | AggregateType.FP32) },
-        };
-
-        public int BaseValue { get; }
-        public int Value { get; }
-        public int Length { get; }
-        public AggregateType Type { get; }
-        public bool IsBuiltin { get; }
-        public bool IsValid => Type != AggregateType.Invalid;
-
-        public AttributeInfo(int baseValue, int index, int length, AggregateType type, bool isBuiltin = true)
-        {
-            BaseValue = baseValue;
-            Value = baseValue + index * 4;
-            Length = length;
-            Type = type;
-            IsBuiltin = isBuiltin;
-        }
-
-        public int GetInnermostIndex()
-        {
-            return (Value - BaseValue) / 4;
-        }
-
-        public static bool Validate(ShaderConfig config, int value, bool isOutAttr, bool perPatch)
-        {
-            return perPatch ? ValidatePerPatch(config, value, isOutAttr) : Validate(config, value, isOutAttr);
-        }
-
-        public static bool Validate(ShaderConfig config, int value, bool isOutAttr)
-        {
-            if (value == AttributeConsts.ViewportIndex && !config.GpuAccessor.QueryHostSupportsViewportIndex())
-            {
-                return false;
-            }
-
-            return From(config, value, isOutAttr).IsValid;
-        }
-
-        public static bool ValidatePerPatch(ShaderConfig config, int value, bool isOutAttr)
-        {
-            return FromPatch(config, value, isOutAttr).IsValid;
-        }
-
-        public static AttributeInfo From(ShaderConfig config, int value, bool isOutAttr)
-        {
-            value &= ~3;
-
-            if (value >= AttributeConsts.UserAttributeBase && value < AttributeConsts.UserAttributeEnd)
-            {
-                int location = (value - AttributeConsts.UserAttributeBase) / 16;
-
-                AggregateType elemType;
-
-                if (config.Stage == ShaderStage.Vertex && !isOutAttr)
-                {
-                    elemType = config.GpuAccessor.QueryAttributeType(location).ToAggregateType();
-                }
-                else
-                {
-                    elemType = AggregateType.FP32;
-                }
-
-                return new AttributeInfo(value & ~0xf, (value >> 2) & 3, 4, AggregateType.Vector4 | elemType, false);
-            }
-            else if (value >= AttributeConsts.FragmentOutputColorBase && value < AttributeConsts.FragmentOutputColorEnd)
-            {
-                int location = (value - AttributeConsts.FragmentOutputColorBase) / 16;
-                var elemType = config.GpuAccessor.QueryFragmentOutputType(location) switch
-                {
-                    AttributeType.Sint => AggregateType.S32,
-                    AttributeType.Uint => AggregateType.U32,
-                    _ => AggregateType.FP32
-                };
-
-                return new AttributeInfo(value & ~0xf, (value >> 2) & 3, 4, AggregateType.Vector4 | elemType, false);
-            }
-            else if (value == AttributeConsts.SupportBlockViewInverseX || value == AttributeConsts.SupportBlockViewInverseY)
-            {
-                return new AttributeInfo(value, 0, 1, AggregateType.FP32);
-            }
-            else if (_builtInAttributes.TryGetValue(value, out AttributeInfo info))
-            {
-                return info;
-            }
-
-            return new AttributeInfo(value, 0, 0, AggregateType.Invalid);
-        }
-
-        public static AttributeInfo FromPatch(ShaderConfig config, int value, bool isOutAttr)
-        {
-            value &= ~3;
-
-            if (value >= AttributeConsts.UserAttributePerPatchBase && value < AttributeConsts.UserAttributePerPatchEnd)
-            {
-                int offset = (value - AttributeConsts.UserAttributePerPatchBase) & 0xf;
-                return new AttributeInfo(value - offset, offset >> 2, 4, AggregateType.Vector4 | AggregateType.FP32, false);
-            }
-            else if (_builtInAttributesPerPatch.TryGetValue(value, out AttributeInfo info))
-            {
-                return info;
-            }
-
-            return new AttributeInfo(value, 0, 0, AggregateType.Invalid);
-        }
-
-        public static bool IsArrayBuiltIn(int attr)
-        {
-            if (attr <= AttributeConsts.TessLevelInner1 ||
-                attr == AttributeConsts.TessCoordX ||
-                attr == AttributeConsts.TessCoordY)
-            {
-                return false;
-            }
-
-            return (attr & AttributeConsts.SpecialMask) == 0;
-        }
-
-        public static bool IsArrayAttributeGlsl(ShaderStage stage, bool isOutAttr)
-        {
-            if (isOutAttr)
-            {
-                return stage == ShaderStage.TessellationControl;
-            }
-            else
-            {
-                return stage == ShaderStage.TessellationControl ||
-                       stage == ShaderStage.TessellationEvaluation ||
-                       stage == ShaderStage.Geometry;
-            }
-        }
-
-        public static bool IsArrayAttributeSpirv(ShaderStage stage, bool isOutAttr)
-        {
-            if (isOutAttr)
-            {
-                return false;
-            }
-            else
-            {
-                return stage == ShaderStage.TessellationControl ||
-                       stage == ShaderStage.TessellationEvaluation ||
-                       stage == ShaderStage.Geometry;
-            }
-        }
-    }
-}

Ryujinx.Graphics.Shader/Translation/GlobalMemory.cs

@@ -1,57 +0,0 @@
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-
-namespace Ryujinx.Graphics.Shader.Translation
-{
-    static class GlobalMemory
-    {
-        private const int StorageDescsBaseOffset = 0x44; // In words.
-
-        public const int StorageDescSize = 4; // In words.
-        public const int StorageMaxCount = 16;
-
-        public const int StorageDescsSize = StorageDescSize * StorageMaxCount;
-
-        public const int UbeBaseOffset = 0x98; // In words.
-        public const int UbeMaxCount   = 9;
-        public const int UbeDescsSize  = StorageDescSize * UbeMaxCount;
-        public const int UbeFirstCbuf  = 8;
-
-        public static bool UsesGlobalMemory(Instruction inst)
-        {
-            return (inst.IsAtomic() && IsGlobalMr(inst)) ||
-                    inst == Instruction.LoadGlobal ||
-                    inst == Instruction.StoreGlobal ||
-                    inst == Instruction.StoreGlobal16 ||
-                    inst == Instruction.StoreGlobal8;
-        }
-
-        private static bool IsGlobalMr(Instruction inst)
-        {
-            return (inst & Instruction.MrMask) == Instruction.MrGlobal;
-        }
-
-        public static int GetStorageCbOffset(ShaderStage stage, int slot)
-        {
-            return GetStorageBaseCbOffset(stage) + slot * StorageDescSize;
-        }
-
-        public static int GetStorageBaseCbOffset(ShaderStage stage)
-        {
-            return stage switch
-            {
-                ShaderStage.Compute                => StorageDescsBaseOffset + 2 * StorageDescsSize,
-                ShaderStage.Vertex                 => StorageDescsBaseOffset,
-                ShaderStage.TessellationControl    => StorageDescsBaseOffset + 1 * StorageDescsSize,
-                ShaderStage.TessellationEvaluation => StorageDescsBaseOffset + 2 * StorageDescsSize,
-                ShaderStage.Geometry               => StorageDescsBaseOffset + 3 * StorageDescsSize,
-                ShaderStage.Fragment               => StorageDescsBaseOffset + 4 * StorageDescsSize,
-                _ => 0
-            };
-        }
-
-        public static int GetConstantUbeOffset(int slot)
-        {
-            return UbeBaseOffset + slot * StorageDescSize;
-        }
-    }
-}

Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs

@@ -1,435 +0,0 @@
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using System.Collections.Generic;
-
-using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
-using static Ryujinx.Graphics.Shader.Translation.GlobalMemory;
-
-namespace Ryujinx.Graphics.Shader.Translation.Optimizations
-{
-    static class GlobalToStorage
-    {
-        public static void RunPass(BasicBlock block, ShaderConfig config, ref int sbUseMask, ref int ubeUseMask)
-        {
-            int sbStart = GetStorageBaseCbOffset(config.Stage);
-            int sbEnd = sbStart + StorageDescsSize;
-
-            int ubeStart = UbeBaseOffset;
-            int ubeEnd = UbeBaseOffset + UbeDescsSize;
-
-            for (LinkedListNode<INode> node = block.Operations.First; node != null; node = node.Next)
-            {
-                for (int index = 0; index < node.Value.SourcesCount; index++)
-                {
-                    Operand src = node.Value.GetSource(index);
-
-                    int storageIndex = GetStorageIndex(src, sbStart, sbEnd);
-
-                    if (storageIndex >= 0)
-                    {
-                        sbUseMask |= 1 << storageIndex;
-                    }
-
-                    if (config.Stage == ShaderStage.Compute)
-                    {
-                        int constantIndex = GetStorageIndex(src, ubeStart, ubeEnd);
-
-                        if (constantIndex >= 0)
-                        {
-                            ubeUseMask |= 1 << constantIndex;
-                        }
-                    }
-                }
-
-                if (!(node.Value is Operation operation))
-                {
-                    continue;
-                }
-
-                if (UsesGlobalMemory(operation.Inst))
-                {
-                    Operand source = operation.GetSource(0);
-
-                    int storageIndex = SearchForStorageBase(block, source, sbStart, sbEnd);
-
-                    if (storageIndex >= 0)
-                    {
-                        // Storage buffers are implemented using global memory access.
-                        // If we know from where the base address of the access is loaded,
-                        // we can guess which storage buffer it is accessing.
-                        // We can then replace the global memory access with a storage
-                        // buffer access.
-                        node = ReplaceGlobalWithStorage(block, node, config, storageIndex);
-                    }
-                    else if (config.Stage == ShaderStage.Compute && operation.Inst == Instruction.LoadGlobal)
-                    {
-                        // Here we effectively try to replace a LDG instruction with LDC.
-                        // The hardware only supports a limited amount of constant buffers
-                        // so NVN "emulates" more constant buffers using global memory access.
-                        // Here we try to replace the global access back to a constant buffer
-                        // load.
-                        storageIndex = SearchForStorageBase(block, source, ubeStart, ubeStart + ubeEnd);
-
-                        if (storageIndex >= 0)
-                        {
-                            node = ReplaceLdgWithLdc(node, config, storageIndex);
-                        }
-                    }
-                }
-            }
-
-            config.SetAccessibleBufferMasks(sbUseMask, ubeUseMask);
-        }
-
-        private static LinkedListNode<INode> ReplaceGlobalWithStorage(BasicBlock block, LinkedListNode<INode> node, ShaderConfig config, int storageIndex)
-        {
-            Operation operation = (Operation)node.Value;
-
-            bool isAtomic = operation.Inst.IsAtomic();
-            bool isStg16Or8 = operation.Inst == Instruction.StoreGlobal16 || operation.Inst == Instruction.StoreGlobal8;
-            bool isWrite = isAtomic || operation.Inst == Instruction.StoreGlobal || isStg16Or8;
-
-            config.SetUsedStorageBuffer(storageIndex, isWrite);
-
-            Operand[] sources = new Operand[operation.SourcesCount];
-
-            sources[0] = Const(storageIndex);
-            sources[1] = GetStorageOffset(block, node, config, storageIndex, operation.GetSource(0), isStg16Or8);
-
-            for (int index = 2; index < operation.SourcesCount; index++)
-            {
-                sources[index] = operation.GetSource(index);
-            }
-
-            Operation storageOp;
-
-            if (isAtomic)
-            {
-                Instruction inst = (operation.Inst & ~Instruction.MrMask) | Instruction.MrStorage;
-
-                storageOp = new Operation(inst, operation.Dest, sources);
-            }
-            else if (operation.Inst == Instruction.LoadGlobal)
-            {
-                storageOp = new Operation(Instruction.LoadStorage, operation.Dest, sources);
-            }
-            else
-            {
-                Instruction storeInst = operation.Inst switch
-                {
-                    Instruction.StoreGlobal16 => Instruction.StoreStorage16,
-                    Instruction.StoreGlobal8 => Instruction.StoreStorage8,
-                    _ => Instruction.StoreStorage
-                };
-
-                storageOp = new Operation(storeInst, null, sources);
-            }
-
-            for (int index = 0; index < operation.SourcesCount; index++)
-            {
-                operation.SetSource(index, null);
-            }
-
-            LinkedListNode<INode> oldNode = node;
-
-            node = node.List.AddBefore(node, storageOp);
-
-            node.List.Remove(oldNode);
-
-            return node;
-        }
-
-        private static Operand GetStorageOffset(
-            BasicBlock block,
-            LinkedListNode<INode> node,
-            ShaderConfig config,
-            int storageIndex,
-            Operand addrLow,
-            bool isStg16Or8)
-        {
-            int baseAddressCbOffset = GetStorageCbOffset(config.Stage, storageIndex);
-
-            bool storageAligned = !(config.GpuAccessor.QueryHasUnalignedStorageBuffer() || config.GpuAccessor.QueryHostStorageBufferOffsetAlignment() > Constants.StorageAlignment);
-
-            (Operand byteOffset, int constantOffset) = storageAligned ?
-                GetStorageOffset(block, Utils.FindLastOperation(addrLow, block), baseAddressCbOffset) :
-                (null, 0);
-
-            if (byteOffset != null)
-            {
-                ReplaceAddressAlignment(node.List, addrLow, byteOffset, constantOffset);
-            }
-
-            if (byteOffset == null)
-            {
-                Operand baseAddrLow = Cbuf(0, baseAddressCbOffset);
-                Operand baseAddrTrunc = Local();
-
-                Operand alignMask = Const(-config.GpuAccessor.QueryHostStorageBufferOffsetAlignment());
-
-                Operation andOp = new Operation(Instruction.BitwiseAnd, baseAddrTrunc, baseAddrLow, alignMask);
-
-                node.List.AddBefore(node, andOp);
-
-                Operand offset = Local();
-                Operation subOp = new Operation(Instruction.Subtract, offset, addrLow, baseAddrTrunc);
-
-                node.List.AddBefore(node, subOp);
-
-                byteOffset = offset;
-            }
-            else if (constantOffset != 0)
-            {
-                Operand offset = Local();
-                Operation addOp = new Operation(Instruction.Add, offset, byteOffset, Const(constantOffset));
-
-                node.List.AddBefore(node, addOp);
-
-                byteOffset = offset;
-            }
-
-            if (isStg16Or8)
-            {
-                return byteOffset;
-            }
-
-            Operand wordOffset = Local();
-            Operation shrOp = new Operation(Instruction.ShiftRightU32, wordOffset, byteOffset, Const(2));
-
-            node.List.AddBefore(node, shrOp);
-
-            return wordOffset;
-        }
-
-        private static bool IsCb0Offset(Operand operand, int offset)
-        {
-            return operand.Type == OperandType.ConstantBuffer && operand.GetCbufSlot() == 0 && operand.GetCbufOffset() == offset;
-        }
-
-        private static void ReplaceAddressAlignment(LinkedList<INode> list, Operand address, Operand byteOffset, int constantOffset)
-        {
-            // When we emit 16/8-bit LDG, we add extra code to determine the address alignment.
-            // Eliminate the storage buffer base address from this too, leaving only the byte offset.
-
-            foreach (INode useNode in address.UseOps)
-            {
-                if (useNode is Operation op && op.Inst == Instruction.BitwiseAnd)
-                {
-                    Operand src1 = op.GetSource(0);
-                    Operand src2 = op.GetSource(1);
-
-                    int addressIndex = -1;
-
-                    if (src1 == address && src2.Type == OperandType.Constant && src2.Value == 3)
-                    {
-                        addressIndex = 0;
-                    }
-                    else if (src2 == address && src1.Type == OperandType.Constant && src1.Value == 3)
-                    {
-                        addressIndex = 1;
-                    }
-
-                    if (addressIndex != -1)
-                    {
-                        LinkedListNode<INode> node = list.Find(op);
-
-                        // Add offset calculation before the use. Needs to be on the same block.
-                        if (node != null)
-                        {
-                            Operand offset = Local();
-                            Operation addOp = new Operation(Instruction.Add, offset, byteOffset, Const(constantOffset));
-                            list.AddBefore(node, addOp);
-
-                            op.SetSource(addressIndex, offset);
-                        }
-                    }
-                }
-            }
-        }
-
-        private static (Operand, int) GetStorageOffset(BasicBlock block, Operand address, int baseAddressCbOffset)
-        {
-            if (IsCb0Offset(address, baseAddressCbOffset))
-            {
-                // Direct offset: zero.
-                return (Const(0), 0);
-            }
-
-            (address, int constantOffset) = GetStorageConstantOffset(block, address);
-
-            address = Utils.FindLastOperation(address, block);
-
-            if (IsCb0Offset(address, baseAddressCbOffset))
-            {
-                // Only constant offset
-                return (Const(0), constantOffset);
-            }
-
-            if (!(address.AsgOp is Operation offsetAdd) || offsetAdd.Inst != Instruction.Add)
-            {
-                return (null, 0);
-            }
-
-            Operand src1 = offsetAdd.GetSource(0);
-            Operand src2 = Utils.FindLastOperation(offsetAdd.GetSource(1), block);
-
-            if (IsCb0Offset(src2, baseAddressCbOffset))
-            {
-                return (src1, constantOffset);
-            }
-            else if (IsCb0Offset(src1, baseAddressCbOffset))
-            {
-                return (src2, constantOffset);
-            }
-
-            return (null, 0);
-        }
-
-        private static (Operand, int) GetStorageConstantOffset(BasicBlock block, Operand address)
-        {
-            if (!(address.AsgOp is Operation offsetAdd) || offsetAdd.Inst != Instruction.Add)
-            {
-                return (address, 0);
-            }
-
-            Operand src1 = offsetAdd.GetSource(0);
-            Operand src2 = offsetAdd.GetSource(1);
-
-            if (src2.Type != OperandType.Constant)
-            {
-                return (address, 0);
-            }
-
-            return (src1, src2.Value);
-        }
-
-        private static LinkedListNode<INode> ReplaceLdgWithLdc(LinkedListNode<INode> node, ShaderConfig config, int storageIndex)
-        {
-            Operation operation = (Operation)node.Value;
-
-            Operand GetCbufOffset()
-            {
-                Operand addrLow = operation.GetSource(0);
-
-                Operand baseAddrLow = Cbuf(0, UbeBaseOffset + storageIndex * StorageDescSize);
-
-                Operand baseAddrTrunc = Local();
-
-                Operand alignMask = Const(-config.GpuAccessor.QueryHostStorageBufferOffsetAlignment());
-
-                Operation andOp = new Operation(Instruction.BitwiseAnd, baseAddrTrunc, baseAddrLow, alignMask);
-
-                node.List.AddBefore(node, andOp);
-
-                Operand byteOffset = Local();
-                Operand wordOffset = Local();
-
-                Operation subOp = new Operation(Instruction.Subtract, byteOffset, addrLow, baseAddrTrunc);
-                Operation shrOp = new Operation(Instruction.ShiftRightU32, wordOffset, byteOffset, Const(2));
-
-                node.List.AddBefore(node, subOp);
-                node.List.AddBefore(node, shrOp);
-
-                return wordOffset;
-            }
-
-            Operand[] sources = new Operand[operation.SourcesCount];
-
-            int cbSlot = UbeFirstCbuf + storageIndex;
-
-            sources[0] = Const(cbSlot);
-            sources[1] = GetCbufOffset();
-
-            config.SetUsedConstantBuffer(cbSlot);
-
-            for (int index = 2; index < operation.SourcesCount; index++)
-            {
-                sources[index] = operation.GetSource(index);
-            }
-
-            Operation ldcOp = new Operation(Instruction.LoadConstant, operation.Dest, sources);
-
-            for (int index = 0; index < operation.SourcesCount; index++)
-            {
-                operation.SetSource(index, null);
-            }
-
-            LinkedListNode<INode> oldNode = node;
-
-            node = node.List.AddBefore(node, ldcOp);
-
-            node.List.Remove(oldNode);
-
-            return node;
-        }
-
-        private static int SearchForStorageBase(BasicBlock block, Operand globalAddress, int sbStart, int sbEnd)
-        {
-            globalAddress = Utils.FindLastOperation(globalAddress, block);
-
-            if (globalAddress.Type == OperandType.ConstantBuffer)
-            {
-                return GetStorageIndex(globalAddress, sbStart, sbEnd);
-            }
-
-            Operation operation = globalAddress.AsgOp as Operation;
-
-            if (operation == null || operation.Inst != Instruction.Add)
-            {
-                return -1;
-            }
-
-            Operand src1 = operation.GetSource(0);
-            Operand src2 = operation.GetSource(1);
-
-            if ((src1.Type == OperandType.LocalVariable && src2.Type == OperandType.Constant) ||
-                (src2.Type == OperandType.LocalVariable && src1.Type == OperandType.Constant))
-            {
-                if (src1.Type == OperandType.LocalVariable)
-                {
-                    operation = Utils.FindLastOperation(src1, block).AsgOp as Operation;
-                }
-                else
-                {
-                    operation = Utils.FindLastOperation(src2, block).AsgOp as Operation;
-                }
-
-                if (operation == null || operation.Inst != Instruction.Add)
-                {
-                    return -1;
-                }
-            }
-
-            for (int index = 0; index < operation.SourcesCount; index++)
-            {
-                Operand source = operation.GetSource(index);
-
-                int storageIndex = GetStorageIndex(source, sbStart, sbEnd);
-
-                if (storageIndex != -1)
-                {
-                    return storageIndex;
-                }
-            }
-
-            return -1;
-        }
-
-        private static int GetStorageIndex(Operand operand, int sbStart, int sbEnd)
-        {
-            if (operand.Type == OperandType.ConstantBuffer)
-            {
-                int slot = operand.GetCbufSlot();
-                int offset = operand.GetCbufOffset();
-
-                if (slot == 0 && offset >= sbStart && offset < sbEnd)
-                {
-                    int storageIndex = (offset - sbStart) / StorageDescSize;
-
-                    return storageIndex;
-                }
-            }
-
-            return -1;
-        }
-    }
-}

Ryujinx.Graphics.Shader/Translation/Rewriter.cs

@@ -1,763 +0,0 @@
-using Ryujinx.Graphics.Shader.Decoders;
-using Ryujinx.Graphics.Shader.IntermediateRepresentation;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Numerics;
-
-using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
-using static Ryujinx.Graphics.Shader.Translation.GlobalMemory;
-
-namespace Ryujinx.Graphics.Shader.Translation
-{
-    static class Rewriter
-    {
-        public static void RunPass(BasicBlock[] blocks, ShaderConfig config)
-        {
-            bool isVertexShader = config.Stage == ShaderStage.Vertex;
-            bool hasConstantBufferDrawParameters = config.GpuAccessor.QueryHasConstantBufferDrawParameters();
-            bool supportsSnormBufferTextureFormat = config.GpuAccessor.QueryHostSupportsSnormBufferTextureFormat();
-
-            for (int blkIndex = 0; blkIndex < blocks.Length; blkIndex++)
-            {
-                BasicBlock block = blocks[blkIndex];
-
-                for (LinkedListNode<INode> node = block.Operations.First; node != null;)
-                {
-                    if (node.Value is not Operation operation)
-                    {
-                        node = node.Next;
-                        continue;
-                    }
-
-                    if (isVertexShader)
-                    {
-                        if (hasConstantBufferDrawParameters)
-                        {
-                            if (ReplaceConstantBufferWithDrawParameters(operation))
-                            {
-                                config.SetUsedFeature(FeatureFlags.DrawParameters);
-                            }
-                        }
-                        else if (HasConstantBufferDrawParameters(operation))
-                        {
-                            config.SetUsedFeature(FeatureFlags.DrawParameters);
-                        }
-                    }
-
-                    LinkedListNode<INode> nextNode = node.Next;
-
-                    if (operation is TextureOperation texOp)
-                    {
-                        if (texOp.Inst == Instruction.TextureSample)
-                        {
-                            node = RewriteTextureSample(node, config);
-
-                            if (texOp.Type == SamplerType.TextureBuffer && !supportsSnormBufferTextureFormat)
-                            {
-                                node = InsertSnormNormalization(node, config);
-                            }
-                        }
-
-                        nextNode = node.Next;
-                    }
-                    else if (UsesGlobalMemory(operation.Inst))
-                    {
-                        nextNode = RewriteGlobalAccess(node, config)?.Next ?? nextNode;
-                    }
-
-                    node = nextNode;
-                }
-            }
-        }
-
-        private static LinkedListNode<INode> RewriteGlobalAccess(LinkedListNode<INode> node, ShaderConfig config)
-        {
-            Operation operation = (Operation)node.Value;
-
-            bool isAtomic = operation.Inst.IsAtomic();
-            bool isStg16Or8 = operation.Inst == Instruction.StoreGlobal16 || operation.Inst == Instruction.StoreGlobal8;
-            bool isWrite = isAtomic || operation.Inst == Instruction.StoreGlobal || isStg16Or8;
-
-            Operation storageOp = null;
-
-            Operand PrependOperation(Instruction inst, params Operand[] sources)
-            {
-                Operand local = Local();
-
-                node.List.AddBefore(node, new Operation(inst, local, sources));
-
-                return local;
-            }
-
-            Operand PrependExistingOperation(Operation operation)
-            {
-                Operand local = Local();
-
-                operation.Dest = local;
-                node.List.AddBefore(node, operation);
-
-                return local;
-            }
-
-            Operand addrLow  = operation.GetSource(0);
-            Operand addrHigh = operation.GetSource(1);
-
-            Operand sbBaseAddrLow = Const(0);
-            Operand sbSlot        = Const(0);
-
-            Operand alignMask = Const(-config.GpuAccessor.QueryHostStorageBufferOffsetAlignment());
-
-            Operand BindingRangeCheck(int cbOffset, out Operand baseAddrLow)
-            {
-                baseAddrLow = Cbuf(0, cbOffset);
-                Operand baseAddrHigh = Cbuf(0, cbOffset + 1);
-                Operand size = Cbuf(0, cbOffset + 2);
-
-                Operand offset = PrependOperation(Instruction.Subtract, addrLow, baseAddrLow);
-                Operand borrow = PrependOperation(Instruction.CompareLessU32, addrLow, baseAddrLow);
-
-                Operand inRangeLow = PrependOperation(Instruction.CompareLessU32, offset, size);
-
-                Operand addrHighBorrowed = PrependOperation(Instruction.Add, addrHigh, borrow);
-
-                Operand inRangeHigh = PrependOperation(Instruction.CompareEqual, addrHighBorrowed, baseAddrHigh);
-
-                return PrependOperation(Instruction.BitwiseAnd, inRangeLow, inRangeHigh);
-            }
-
-            int sbUseMask = config.AccessibleStorageBuffersMask;
-
-            while (sbUseMask != 0)
-            {
-                int slot = BitOperations.TrailingZeroCount(sbUseMask);
-
-                sbUseMask &= ~(1 << slot);
-
-                config.SetUsedStorageBuffer(slot, isWrite);
-
-                int cbOffset = GetStorageCbOffset(config.Stage, slot);
-
-                Operand inRange = BindingRangeCheck(cbOffset, out Operand baseAddrLow);
-
-                sbBaseAddrLow = PrependOperation(Instruction.ConditionalSelect, inRange, baseAddrLow, sbBaseAddrLow);
-                sbSlot        = PrependOperation(Instruction.ConditionalSelect, inRange, Const(slot), sbSlot);
-            }
-
-            if (config.AccessibleStorageBuffersMask != 0)
-            {
-                Operand baseAddrTrunc = PrependOperation(Instruction.BitwiseAnd, sbBaseAddrLow, alignMask);
-                Operand byteOffset    = PrependOperation(Instruction.Subtract, addrLow, baseAddrTrunc);
-
-                Operand[] sources = new Operand[operation.SourcesCount];
-
-                sources[0] = sbSlot;
-
-                if (isStg16Or8)
-                {
-                    sources[1] = byteOffset;
-                }
-                else
-                {
-                    sources[1] = PrependOperation(Instruction.ShiftRightU32, byteOffset, Const(2));
-                }
-
-                for (int index = 2; index < operation.SourcesCount; index++)
-                {
-                    sources[index] = operation.GetSource(index);
-                }
-
-                if (isAtomic)
-                {
-                    Instruction inst = (operation.Inst & ~Instruction.MrMask) | Instruction.MrStorage;
-
-                    storageOp = new Operation(inst, operation.Dest, sources);
-                }
-                else if (operation.Inst == Instruction.LoadGlobal)
-                {
-                    storageOp = new Operation(Instruction.LoadStorage, operation.Dest, sources);
-                }
-                else
-                {
-                    Instruction storeInst = operation.Inst switch
-                    {
-                        Instruction.StoreGlobal16 => Instruction.StoreStorage16,
-                        Instruction.StoreGlobal8 => Instruction.StoreStorage8,
-                        _ => Instruction.StoreStorage
-                    };
-
-                    storageOp = new Operation(storeInst, null, sources);
-                }
-            }
-            else if (operation.Dest != null)
-            {
-                storageOp = new Operation(Instruction.Copy, operation.Dest, Const(0));
-            }
-
-            if (operation.Inst == Instruction.LoadGlobal)
-            {
-                int cbeUseMask = config.AccessibleConstantBuffersMask;
-
-                while (cbeUseMask != 0)
-                {
-                    int slot = BitOperations.TrailingZeroCount(cbeUseMask);
-                    int cbSlot = UbeFirstCbuf + slot;
-
-                    cbeUseMask &= ~(1 << slot);
-
-                    config.SetUsedConstantBuffer(cbSlot);
-
-                    Operand previousResult = PrependExistingOperation(storageOp);
-
-                    int cbOffset = GetConstantUbeOffset(slot);
-
-                    Operand inRange = BindingRangeCheck(cbOffset, out Operand baseAddrLow);
-
-                    Operand baseAddrTruncConst = PrependOperation(Instruction.BitwiseAnd, baseAddrLow, alignMask);
-                    Operand byteOffsetConst = PrependOperation(Instruction.Subtract, addrLow, baseAddrTruncConst);
-
-                    Operand cbIndex = PrependOperation(Instruction.ShiftRightU32, byteOffsetConst, Const(2));
-
-                    Operand[] sourcesCb = new Operand[operation.SourcesCount];
-
-                    sourcesCb[0] = Const(cbSlot);
-                    sourcesCb[1] = cbIndex;
-
-                    for (int index = 2; index < operation.SourcesCount; index++)
-                    {
-                        sourcesCb[index] = operation.GetSource(index);
-                    }
-
-                    Operand ldcResult = PrependOperation(Instruction.LoadConstant, sourcesCb);
-
-                    storageOp = new Operation(Instruction.ConditionalSelect, operation.Dest, inRange, ldcResult, previousResult);
-                }
-            }
-
-            for (int index = 0; index < operation.SourcesCount; index++)
-            {
-                operation.SetSource(index, null);
-            }
-
-            LinkedListNode<INode> oldNode = node;
-            LinkedList<INode> oldNodeList = oldNode.List;
-
-            if (storageOp != null)
-            {
-                node = node.List.AddBefore(node, storageOp);
-            }
-            else
-            {
-                node = null;
-            }
-
-            oldNodeList.Remove(oldNode);
-
-            return node;
-        }
-
-        private static LinkedListNode<INode> RewriteTextureSample(LinkedListNode<INode> node, ShaderConfig config)
-        {
-            TextureOperation texOp = (TextureOperation)node.Value;
-
-            bool hasOffset  = (texOp.Flags & TextureFlags.Offset)  != 0;
-            bool hasOffsets = (texOp.Flags & TextureFlags.Offsets) != 0;
-
-            bool hasInvalidOffset = (hasOffset || hasOffsets) && !config.GpuAccessor.QueryHostSupportsNonConstantTextureOffset();
-
-            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
-
-            bool isCoordNormalized = isBindless || config.GpuAccessor.QueryTextureCoordNormalized(texOp.Handle, texOp.CbufSlot);
-
-            if (!hasInvalidOffset && isCoordNormalized)
-            {
-                return node;
-            }
-
-            bool isGather       = (texOp.Flags & TextureFlags.Gather)      != 0;
-            bool hasDerivatives = (texOp.Flags & TextureFlags.Derivatives) != 0;
-            bool intCoords      = (texOp.Flags & TextureFlags.IntCoords)   != 0;
-            bool hasLodBias     = (texOp.Flags & TextureFlags.LodBias)     != 0;
-            bool hasLodLevel    = (texOp.Flags & TextureFlags.LodLevel)    != 0;
-
-            bool isArray       = (texOp.Type & SamplerType.Array)       != 0;
-            bool isIndexed     = (texOp.Type & SamplerType.Indexed)     != 0;
-            bool isMultisample = (texOp.Type & SamplerType.Multisample) != 0;
-            bool isShadow      = (texOp.Type & SamplerType.Shadow)      != 0;
-
-            int coordsCount = texOp.Type.GetDimensions();
-
-            int offsetsCount;
-
-            if (hasOffsets)
-            {
-                offsetsCount = coordsCount * 4;
-            }
-            else if (hasOffset)
-            {
-                offsetsCount = coordsCount;
-            }
-            else
-            {
-                offsetsCount = 0;
-            }
-
-            Operand[] offsets = new Operand[offsetsCount];
-            Operand[] sources = new Operand[texOp.SourcesCount - offsetsCount];
-
-            int copyCount = 0;
-
-            if (isBindless || isIndexed)
-            {
-                copyCount++;
-            }
-
-            Operand[] lodSources = new Operand[copyCount + coordsCount];
-
-            for (int index = 0; index < lodSources.Length; index++)
-            {
-                lodSources[index] = texOp.GetSource(index);
-            }
-
-            copyCount += coordsCount;
-
-            if (isArray)
-            {
-                copyCount++;
-            }
-
-            if (isShadow)
-            {
-                copyCount++;
-            }
-
-            if (hasDerivatives)
-            {
-                copyCount += coordsCount * 2;
-            }
-
-            if (isMultisample)
-            {
-                copyCount++;
-            }
-            else if (hasLodLevel)
-            {
-                copyCount++;
-            }
-
-            int srcIndex = 0;
-            int dstIndex = 0;
-
-            for (int index = 0; index < copyCount; index++)
-            {
-                sources[dstIndex++] = texOp.GetSource(srcIndex++);
-            }
-
-            bool areAllOffsetsConstant = true;
-
-            for (int index = 0; index < offsetsCount; index++)
-            {
-                Operand offset = texOp.GetSource(srcIndex++);
-
-                areAllOffsetsConstant &= offset.Type == OperandType.Constant;
-
-                offsets[index] = offset;
-            }
-
-            hasInvalidOffset &= !areAllOffsetsConstant;
-
-            if (!hasInvalidOffset && isCoordNormalized)
-            {
-                return node;
-            }
-
-            if (hasLodBias)
-            {
-               sources[dstIndex++] = texOp.GetSource(srcIndex++);
-            }
-
-            if (isGather && !isShadow)
-            {
-               sources[dstIndex++] = texOp.GetSource(srcIndex++);
-            }
-
-            int coordsIndex = isBindless || isIndexed ? 1 : 0;
-
-            int componentIndex = texOp.Index;
-
-            Operand Float(Operand value)
-            {
-                Operand res = Local();
-
-                node.List.AddBefore(node, new Operation(Instruction.ConvertS32ToFP32, res, value));
-
-                return res;
-            }
-
-            // Emulate non-normalized coordinates by normalizing the coordinates on the shader.
-            // Without normalization, the coordinates are expected to the in the [0, W or H] range,
-            // and otherwise, it is expected to be in the [0, 1] range.
-            // We normalize by dividing the coords by the texture size.
-            if (!isCoordNormalized && !intCoords)
-            {
-                config.SetUsedFeature(FeatureFlags.IntegerSampling);
-
-                int normCoordsCount = (texOp.Type & SamplerType.Mask) == SamplerType.TextureCube ? 2 : coordsCount;
-
-                for (int index = 0; index < normCoordsCount; index++)
-                {
-                    Operand coordSize = Local();
-
-                    Operand[] texSizeSources;
-
-                    if (isBindless || isIndexed)
-                    {
-                        texSizeSources = new Operand[] { sources[0], Const(0) };
-                    }
-                    else
-                    {
-                        texSizeSources = new Operand[] { Const(0) };
-                    }
-
-                    node.List.AddBefore(node, new TextureOperation(
-                        Instruction.TextureSize,
-                        texOp.Type,
-                        texOp.Format,
-                        texOp.Flags,
-                        texOp.CbufSlot,
-                        texOp.Handle,
-                        index,
-                        new[] { coordSize },
-                        texSizeSources));
-
-                    config.SetUsedTexture(Instruction.TextureSize, texOp.Type, texOp.Format, texOp.Flags, texOp.CbufSlot, texOp.Handle);
-
-                    Operand source = sources[coordsIndex + index];
-
-                    Operand coordNormalized = Local();
-
-                    node.List.AddBefore(node, new Operation(Instruction.FP32 | Instruction.Divide, coordNormalized, source, Float(coordSize)));
-
-                    sources[coordsIndex + index] = coordNormalized;
-                }
-            }
-
-            Operand[] dests = new Operand[texOp.DestsCount];
-
-            for (int i = 0; i < texOp.DestsCount; i++)
-            {
-                dests[i] = texOp.GetDest(i);
-            }
-
-            Operand bindlessHandle = isBindless || isIndexed ? sources[0] : null;
-
-            LinkedListNode<INode> oldNode = node;
-
-            // Technically, non-constant texture offsets are not allowed (according to the spec),
-            // however some GPUs does support that.
-            // For GPUs where it is not supported, we can replace the instruction with the following:
-            // For texture*Offset, we replace it by texture*, and add the offset to the P coords.
-            // The offset can be calculated as offset / textureSize(lod), where lod = textureQueryLod(coords).
-            // For texelFetchOffset, we replace it by texelFetch and add the offset to the P coords directly.
-            // For textureGatherOffset, we split the operation into up to 4 operations, one for each component
-            // that is accessed, where each textureGather operation has a different offset for each pixel.
-            if (hasInvalidOffset && isGather && !isShadow)
-            {
-                config.SetUsedFeature(FeatureFlags.IntegerSampling);
-
-                Operand[] newSources = new Operand[sources.Length];
-
-                sources.CopyTo(newSources, 0);
-
-                Operand[] texSizes = InsertTextureSize(node, texOp, lodSources, bindlessHandle, coordsCount);
-
-                int destIndex = 0;
-
-                for (int compIndex = 0; compIndex < 4; compIndex++)
-                {
-                    if (((texOp.Index >> compIndex) & 1) == 0)
-                    {
-                        continue;
-                    }
-
-                    for (int index = 0; index < coordsCount; index++)
-                    {
-                        config.SetUsedTexture(Instruction.TextureSize, texOp.Type, texOp.Format, texOp.Flags, texOp.CbufSlot, texOp.Handle);
-
-                        Operand offset = Local();
-
-                        Operand intOffset = offsets[index + (hasOffsets ? compIndex * coordsCount : 0)];
-
-                        node.List.AddBefore(node, new Operation(Instruction.FP32 | Instruction.Divide, offset, Float(intOffset), Float(texSizes[index])));
-
-                        Operand source = sources[coordsIndex + index];
-
-                        Operand coordPlusOffset = Local();
-
-                        node.List.AddBefore(node, new Operation(Instruction.FP32 | Instruction.Add, coordPlusOffset, source, offset));
-
-                        newSources[coordsIndex + index] = coordPlusOffset;
-                    }
-
-                    TextureOperation newTexOp = new TextureOperation(
-                        Instruction.TextureSample,
-                        texOp.Type,
-                        texOp.Format,
-                        texOp.Flags & ~(TextureFlags.Offset | TextureFlags.Offsets),
-                        texOp.CbufSlot,
-                        texOp.Handle,
-                        1,
-                        new[] { dests[destIndex++] },
-                        newSources);
-
-                    node = node.List.AddBefore(node, newTexOp);
-                }
-            }
-            else
-            {
-                if (hasInvalidOffset)
-                {
-                    if (intCoords)
-                    {
-                        for (int index = 0; index < coordsCount; index++)
-                        {
-                            Operand source = sources[coordsIndex + index];
-
-                            Operand coordPlusOffset = Local();
-
-                            node.List.AddBefore(node, new Operation(Instruction.Add, coordPlusOffset, source, offsets[index]));
-
-                            sources[coordsIndex + index] = coordPlusOffset;
-                        }
-                    }
-                    else
-                    {
-                        config.SetUsedFeature(FeatureFlags.IntegerSampling);
-
-                        Operand[] texSizes = InsertTextureSize(node, texOp, lodSources, bindlessHandle, coordsCount);
-
-                        for (int index = 0; index < coordsCount; index++)
-                        {
-                            config.SetUsedTexture(Instruction.TextureSize, texOp.Type, texOp.Format, texOp.Flags, texOp.CbufSlot, texOp.Handle);
-
-                            Operand offset = Local();
-
-                            Operand intOffset = offsets[index];
-
-                            node.List.AddBefore(node, new Operation(Instruction.FP32 | Instruction.Divide, offset, Float(intOffset), Float(texSizes[index])));
-
-                            Operand source = sources[coordsIndex + index];
-
-                            Operand coordPlusOffset = Local();
-
-                            node.List.AddBefore(node, new Operation(Instruction.FP32 | Instruction.Add, coordPlusOffset, source, offset));
-
-                            sources[coordsIndex + index] = coordPlusOffset;
-                        }
-                    }
-                }
-
-                TextureOperation newTexOp = new TextureOperation(
-                    Instruction.TextureSample,
-                    texOp.Type,
-                    texOp.Format,
-                    texOp.Flags & ~(TextureFlags.Offset | TextureFlags.Offsets),
-                    texOp.CbufSlot,
-                    texOp.Handle,
-                    componentIndex,
-                    dests,
-                    sources);
-
-                node = node.List.AddBefore(node, newTexOp);
-            }
-
-            node.List.Remove(oldNode);
-
-            for (int index = 0; index < texOp.SourcesCount; index++)
-            {
-                texOp.SetSource(index, null);
-            }
-
-            return node;
-        }
-
-        private static Operand[] InsertTextureSize(
-            LinkedListNode<INode> node,
-            TextureOperation texOp,
-            Operand[] lodSources,
-            Operand bindlessHandle,
-            int coordsCount)
-        {
-            Operand Int(Operand value)
-            {
-                Operand res = Local();
-
-                node.List.AddBefore(node, new Operation(Instruction.ConvertFP32ToS32, res, value));
-
-                return res;
-            }
-
-            Operand[] texSizes = new Operand[coordsCount];
-
-            Operand lod = Local();
-
-            node.List.AddBefore(node, new TextureOperation(
-                Instruction.Lod,
-                texOp.Type,
-                texOp.Format,
-                texOp.Flags,
-                texOp.CbufSlot,
-                texOp.Handle,
-                0,
-                new[] { lod },
-                lodSources));
-
-            for (int index = 0; index < coordsCount; index++)
-            {
-                texSizes[index] = Local();
-
-                Operand[] texSizeSources;
-
-                if (bindlessHandle != null)
-                {
-                    texSizeSources = new Operand[] { bindlessHandle, Int(lod) };
-                }
-                else
-                {
-                    texSizeSources = new Operand[] { Int(lod) };
-                }
-
-                node.List.AddBefore(node, new TextureOperation(
-                    Instruction.TextureSize,
-                    texOp.Type,
-                    texOp.Format,
-                    texOp.Flags,
-                    texOp.CbufSlot,
-                    texOp.Handle,
-                    index,
-                    new[] { texSizes[index] },
-                    texSizeSources));
-            }
-
-            return texSizes;
-        }
-
-        private static LinkedListNode<INode> InsertSnormNormalization(LinkedListNode<INode> node, ShaderConfig config)
-        {
-            TextureOperation texOp = (TextureOperation)node.Value;
-
-            // We can't query the format of a bindless texture,
-            // because the handle is unknown, it can have any format.
-            if (texOp.Flags.HasFlag(TextureFlags.Bindless))
-            {
-                return node;
-            }
-
-            TextureFormat format = config.GpuAccessor.QueryTextureFormat(texOp.Handle, texOp.CbufSlot);
-
-            int maxPositive = format switch
-            {
-                TextureFormat.R8Snorm           => sbyte.MaxValue,
-                TextureFormat.R8G8Snorm         => sbyte.MaxValue,
-                TextureFormat.R8G8B8A8Snorm     => sbyte.MaxValue,
-                TextureFormat.R16Snorm          => short.MaxValue,
-                TextureFormat.R16G16Snorm       => short.MaxValue,
-                TextureFormat.R16G16B16A16Snorm => short.MaxValue,
-                _                               => 0
-            };
-
-            // The value being 0 means that the format is not a SNORM format,
-            // so there's nothing to do here.
-            if (maxPositive == 0)
-            {
-                return node;
-            }
-
-            // Do normalization. We assume SINT formats are being used
-            // as replacement for SNORM (which is not supported).
-            for (int i = 0; i < texOp.DestsCount; i++)
-            {
-                Operand dest = texOp.GetDest(i);
-
-                INode[] uses = dest.UseOps.ToArray();
-
-                Operation convOp = new Operation(Instruction.ConvertS32ToFP32, Local(), dest);
-                Operation normOp = new Operation(Instruction.FP32 | Instruction.Multiply, Local(), convOp.Dest, ConstF(1f / maxPositive));
-
-                node = node.List.AddAfter(node, convOp);
-                node = node.List.AddAfter(node, normOp);
-
-                foreach (INode useOp in uses)
-                {
-                    if (useOp is not Operation op)
-                    {
-                        continue;
-                    }
-
-                    // Replace all uses of the texture pixel value with the normalized value.
-                    for (int index = 0; index < op.SourcesCount; index++)
-                    {
-                        if (op.GetSource(index) == dest)
-                        {
-                            op.SetSource(index, normOp.Dest);
-                        }
-                    }
-                }
-            }
-
-            return node;
-        }
-
-        private static bool ReplaceConstantBufferWithDrawParameters(Operation operation)
-        {
-            bool modified = false;
-
-            for (int srcIndex = 0; srcIndex < operation.SourcesCount; srcIndex++)
-            {
-                Operand src = operation.GetSource(srcIndex);
-
-                if (src.Type == OperandType.ConstantBuffer && src.GetCbufSlot() == 0)
-                {
-                    switch (src.GetCbufOffset())
-                    {
-                        case Constants.NvnBaseVertexByteOffset / 4:
-                            operation.SetSource(srcIndex, Attribute(AttributeConsts.BaseVertex));
-                            modified = true;
-                            break;
-                        case Constants.NvnBaseInstanceByteOffset / 4:
-                            operation.SetSource(srcIndex, Attribute(AttributeConsts.BaseInstance));
-                            modified = true;
-                            break;
-                        case Constants.NvnDrawIndexByteOffset / 4:
-                            operation.SetSource(srcIndex, Attribute(AttributeConsts.DrawIndex));
-                            modified = true;
-                            break;
-                    }
-                }
-            }
-
-            return modified;
-        }
-
-        private static bool HasConstantBufferDrawParameters(Operation operation)
-        {
-            for (int srcIndex = 0; srcIndex < operation.SourcesCount; srcIndex++)
-            {
-                Operand src = operation.GetSource(srcIndex);
-
-                if (src.Type == OperandType.ConstantBuffer && src.GetCbufSlot() == 0)
-                {
-                    switch (src.GetCbufOffset())
-                    {
-                        case Constants.NvnBaseVertexByteOffset / 4:
-                        case Constants.NvnBaseInstanceByteOffset / 4:
-                        case Constants.NvnDrawIndexByteOffset / 4:
-                            return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-    }
-}

Ryujinx.Graphics.Vulkan/PipelineLayoutCache.cs

@@ -1,58 +0,0 @@
-using Ryujinx.Graphics.GAL;
-using Silk.NET.Vulkan;
-using System.Collections.Generic;
-
-namespace Ryujinx.Graphics.Vulkan
-{
-    class PipelineLayoutCache
-    {
-        private readonly PipelineLayoutCacheEntry[] _plce;
-        private readonly List<PipelineLayoutCacheEntry> _plceMinimal;
-
-        public PipelineLayoutCache()
-        {
-            _plce = new PipelineLayoutCacheEntry[1 << Constants.MaxShaderStages];
-            _plceMinimal = new List<PipelineLayoutCacheEntry>();
-        }
-
-        public PipelineLayoutCacheEntry Create(VulkanRenderer gd, Device device, ShaderSource[] shaders)
-        {
-            var plce = new PipelineLayoutCacheEntry(gd, device, shaders);
-            _plceMinimal.Add(plce);
-            return plce;
-        }
-
-        public PipelineLayoutCacheEntry GetOrCreate(VulkanRenderer gd, Device device, uint stages, bool usePd)
-        {
-            if (_plce[stages] == null)
-            {
-                _plce[stages] = new PipelineLayoutCacheEntry(gd, device, stages, usePd);
-            }
-
-            return _plce[stages];
-        }
-
-        protected virtual unsafe void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                for (int i = 0; i < _plce.Length; i++)
-                {
-                    _plce[i]?.Dispose();
-                }
-
-                foreach (var plce in _plceMinimal)
-                {
-                    plce.Dispose();
-                }
-
-                _plceMinimal.Clear();
-            }
-        }
-
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-    }
-}

Ryujinx.Graphics.Vulkan/PipelineLayoutFactory.cs

@@ -1,244 +0,0 @@
-using Ryujinx.Graphics.GAL;
-using Silk.NET.Vulkan;
-using System.Collections.Generic;
-using System.Numerics;
-
-namespace Ryujinx.Graphics.Vulkan
-{
-    static class PipelineLayoutFactory
-    {
-        private const ShaderStageFlags SupportBufferStages =
-            ShaderStageFlags.VertexBit |
-            ShaderStageFlags.FragmentBit |
-            ShaderStageFlags.ComputeBit;
-
-        public static unsafe DescriptorSetLayout[] Create(VulkanRenderer gd, Device device, uint stages, bool usePd, out PipelineLayout layout)
-        {
-            int stagesCount = BitOperations.PopCount(stages);
-
-            int uCount = Constants.MaxUniformBuffersPerStage * stagesCount + 1;
-            int tCount = Constants.MaxTexturesPerStage * 2 * stagesCount;
-            int iCount = Constants.MaxImagesPerStage * 2 * stagesCount;
-
-            DescriptorSetLayoutBinding* uLayoutBindings = stackalloc DescriptorSetLayoutBinding[uCount];
-            DescriptorSetLayoutBinding* sLayoutBindings = stackalloc DescriptorSetLayoutBinding[stagesCount];
-            DescriptorSetLayoutBinding* tLayoutBindings = stackalloc DescriptorSetLayoutBinding[tCount];
-            DescriptorSetLayoutBinding* iLayoutBindings = stackalloc DescriptorSetLayoutBinding[iCount];
-
-            uLayoutBindings[0] = new DescriptorSetLayoutBinding
-            {
-                Binding = 0,
-                DescriptorType = DescriptorType.UniformBuffer,
-                DescriptorCount = 1,
-                StageFlags = SupportBufferStages
-            };
-
-            int iter = 0;
-
-            while (stages != 0)
-            {
-                int stage = BitOperations.TrailingZeroCount(stages);
-                stages &= ~(1u << stage);
-
-                var stageFlags = stage switch
-                {
-                    1 => ShaderStageFlags.FragmentBit,
-                    2 => ShaderStageFlags.GeometryBit,
-                    3 => ShaderStageFlags.TessellationControlBit,
-                    4 => ShaderStageFlags.TessellationEvaluationBit,
-                    _ => ShaderStageFlags.VertexBit | ShaderStageFlags.ComputeBit
-                };
-
-                void Set(DescriptorSetLayoutBinding* bindings, int maxPerStage, DescriptorType type, int start, int skip)
-                {
-                    int totalPerStage = maxPerStage * skip;
-
-                    for (int i = 0; i < maxPerStage; i++)
-                    {
-                        bindings[start + iter * totalPerStage + i] = new DescriptorSetLayoutBinding
-                        {
-                            Binding = (uint)(start + stage * totalPerStage + i),
-                            DescriptorType = type,
-                            DescriptorCount = 1,
-                            StageFlags = stageFlags
-                        };
-                    }
-                }
-
-                void SetStorage(DescriptorSetLayoutBinding* bindings, int maxPerStage, int start = 0)
-                {
-                    bindings[start + iter] = new DescriptorSetLayoutBinding
-                    {
-                        Binding = (uint)(start + stage * maxPerStage),
-                        DescriptorType = DescriptorType.StorageBuffer,
-                        DescriptorCount = (uint)maxPerStage,
-                        StageFlags = stageFlags
-                    };
-                }
-
-                Set(uLayoutBindings, Constants.MaxUniformBuffersPerStage, DescriptorType.UniformBuffer, 1, 1);
-                SetStorage(sLayoutBindings, Constants.MaxStorageBuffersPerStage);
-                Set(tLayoutBindings, Constants.MaxTexturesPerStage, DescriptorType.CombinedImageSampler, 0, 2);
-                Set(tLayoutBindings, Constants.MaxTexturesPerStage, DescriptorType.UniformTexelBuffer, Constants.MaxTexturesPerStage, 2);
-                Set(iLayoutBindings, Constants.MaxImagesPerStage, DescriptorType.StorageImage, 0, 2);
-                Set(iLayoutBindings, Constants.MaxImagesPerStage, DescriptorType.StorageTexelBuffer, Constants.MaxImagesPerStage, 2);
-
-                iter++;
-            }
-
-            DescriptorSetLayout[] layouts = new DescriptorSetLayout[PipelineBase.DescriptorSetLayouts];
-
-            var uDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = uLayoutBindings,
-                BindingCount = (uint)uCount,
-                Flags = usePd ? DescriptorSetLayoutCreateFlags.PushDescriptorBitKhr : 0
-            };
-
-            var sDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = sLayoutBindings,
-                BindingCount = (uint)stagesCount
-            };
-
-            var tDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = tLayoutBindings,
-                BindingCount = (uint)tCount
-            };
-
-            var iDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = iLayoutBindings,
-                BindingCount = (uint)iCount
-            };
-
-            gd.Api.CreateDescriptorSetLayout(device, uDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.UniformSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, sDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.StorageSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, tDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.TextureSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, iDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.ImageSetIndex]).ThrowOnError();
-
-            fixed (DescriptorSetLayout* pLayouts = layouts)
-            {
-                var pipelineLayoutCreateInfo = new PipelineLayoutCreateInfo()
-                {
-                    SType = StructureType.PipelineLayoutCreateInfo,
-                    PSetLayouts = pLayouts,
-                    SetLayoutCount = PipelineBase.DescriptorSetLayouts
-                };
-
-                gd.Api.CreatePipelineLayout(device, &pipelineLayoutCreateInfo, null, out layout).ThrowOnError();
-            }
-
-            return layouts;
-        }
-
-        public static unsafe DescriptorSetLayout[] CreateMinimal(VulkanRenderer gd, Device device, ShaderSource[] shaders, out PipelineLayout layout)
-        {
-            int stagesCount = shaders.Length;
-
-            int uCount = 0;
-            int sCount = 0;
-            int tCount = 0;
-            int iCount = 0;
-
-            foreach (var shader in shaders)
-            {
-                uCount += shader.Bindings.UniformBufferBindings.Count;
-                sCount += shader.Bindings.StorageBufferBindings.Count;
-                tCount += shader.Bindings.TextureBindings.Count;
-                iCount += shader.Bindings.ImageBindings.Count;
-            }
-
-            DescriptorSetLayoutBinding* uLayoutBindings = stackalloc DescriptorSetLayoutBinding[uCount];
-            DescriptorSetLayoutBinding* sLayoutBindings = stackalloc DescriptorSetLayoutBinding[sCount];
-            DescriptorSetLayoutBinding* tLayoutBindings = stackalloc DescriptorSetLayoutBinding[tCount];
-            DescriptorSetLayoutBinding* iLayoutBindings = stackalloc DescriptorSetLayoutBinding[iCount];
-
-            int uIndex = 0;
-            int sIndex = 0;
-            int tIndex = 0;
-            int iIndex = 0;
-
-            foreach (var shader in shaders)
-            {
-                var stageFlags = shader.Stage.Convert();
-
-                void Set(DescriptorSetLayoutBinding* bindings, DescriptorType type, ref int start, IEnumerable<int> bds)
-                {
-                    foreach (var b in bds)
-                    {
-                        bindings[start++] = new DescriptorSetLayoutBinding
-                        {
-                            Binding = (uint)b,
-                            DescriptorType = type,
-                            DescriptorCount = 1,
-                            StageFlags = stageFlags
-                        };
-                    }
-                }
-
-                // TODO: Support buffer textures and images here.
-                // This is only used for the helper shaders on the backend, and we don't use buffer textures on them
-                // so far, so it's not really necessary right now.
-                Set(uLayoutBindings, DescriptorType.UniformBuffer, ref uIndex, shader.Bindings.UniformBufferBindings);
-                Set(sLayoutBindings, DescriptorType.StorageBuffer, ref sIndex, shader.Bindings.StorageBufferBindings);
-                Set(tLayoutBindings, DescriptorType.CombinedImageSampler, ref tIndex, shader.Bindings.TextureBindings);
-                Set(iLayoutBindings, DescriptorType.StorageImage, ref iIndex, shader.Bindings.ImageBindings);
-            }
-
-            DescriptorSetLayout[] layouts = new DescriptorSetLayout[PipelineBase.DescriptorSetLayouts];
-
-            var uDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = uLayoutBindings,
-                BindingCount = (uint)uCount
-            };
-
-            var sDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = sLayoutBindings,
-                BindingCount = (uint)sCount
-            };
-
-            var tDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = tLayoutBindings,
-                BindingCount = (uint)tCount
-            };
-
-            var iDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
-            {
-                SType = StructureType.DescriptorSetLayoutCreateInfo,
-                PBindings = iLayoutBindings,
-                BindingCount = (uint)iCount
-            };
-
-            gd.Api.CreateDescriptorSetLayout(device, uDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.UniformSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, sDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.StorageSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, tDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.TextureSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, iDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.ImageSetIndex]).ThrowOnError();
-
-            fixed (DescriptorSetLayout* pLayouts = layouts)
-            {
-                var pipelineLayoutCreateInfo = new PipelineLayoutCreateInfo()
-                {
-                    SType = StructureType.PipelineLayoutCreateInfo,
-                    PSetLayouts = pLayouts,
-                    SetLayoutCount = PipelineBase.DescriptorSetLayouts
-                };
-
-                gd.Api.CreatePipelineLayout(device, &pipelineLayoutCreateInfo, null, out layout).ThrowOnError();
-            }
-
-            return layouts;
-        }
-    }
-}

Ryujinx.HLE/HOS/Ipc/IpcMessageType.cs

@@ -1,13 +0,0 @@
-namespace Ryujinx.HLE.HOS.Ipc
-{
-    enum IpcMessageType
-    {
-        HipcResponse           = 0,
-        HipcCloseSession       = 2,
-        HipcRequest            = 4,
-        HipcControl            = 5,
-        HipcRequestWithContext = 6,
-        HipcControlWithContext = 7,
-        TipcCloseSession       = 0xF
-    }
-}

Ryujinx.HLE/HOS/Services/Account/Acc/Types/AccountState.cs

@@ -1,8 +0,0 @@
-namespace Ryujinx.HLE.HOS.Services.Account.Acc
-{
-    public enum AccountState
-    {
-        Closed,
-        Open
-    }
-}

Ryujinx.HLE/HOS/Services/Bcat/IServiceCreator.cs

@@ -1,85 +0,0 @@
-using LibHac;
-using LibHac.Common;
-using Ryujinx.Common;
-using Ryujinx.HLE.HOS.Services.Arp;
-using Ryujinx.HLE.HOS.Services.Bcat.ServiceCreator;
-
-namespace Ryujinx.HLE.HOS.Services.Bcat
-{
-    [Service("bcat:a", "bcat:a")]
-    [Service("bcat:m", "bcat:m")]
-    [Service("bcat:u", "bcat:u")]
-    [Service("bcat:s", "bcat:s")]
-    class IServiceCreator : DisposableIpcService
-    {
-        private SharedRef<LibHac.Bcat.Impl.Ipc.IServiceCreator> _base;
-
-        public IServiceCreator(ServiceCtx context, string serviceName)
-        {
-            var applicationClient = context.Device.System.LibHacHorizonManager.ApplicationClient;
-            applicationClient.Sm.GetService(ref _base, serviceName).ThrowIfFailure();
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            if (isDisposing)
-            {
-                _base.Destroy();
-            }
-        }
-
-        [CommandHipc(0)]
-        // CreateBcatService(pid) -> object<nn::bcat::detail::ipc::IBcatService>
-        public ResultCode CreateBcatService(ServiceCtx context)
-        {
-            // TODO: Call arp:r GetApplicationLaunchProperty with the pid to get the TitleId.
-            //       Add an instance of nn::bcat::detail::service::core::PassphraseManager.
-            //       Add an instance of nn::bcat::detail::service::ServiceMemoryManager.
-            //       Add an instance of nn::bcat::detail::service::core::TaskManager who load "bcat-sys:/" system save data and open "dc/task.bin". 
-            //       If the file don't exist, create a new one (size of 0x800) and write 2 empty struct with a size of 0x400.
-
-            MakeObject(context, new IBcatService(ApplicationLaunchProperty.GetByPid(context)));
-
-            // NOTE: If the IBcatService is null this error is returned, Doesn't occur in our case. 
-            //       return ResultCode.NullObject;
-
-            return ResultCode.Success;
-        }
-
-        [CommandHipc(1)]
-        // CreateDeliveryCacheStorageService(pid) -> object<nn::bcat::detail::ipc::IDeliveryCacheStorageService>
-        public ResultCode CreateDeliveryCacheStorageService(ServiceCtx context)
-        {
-            ulong pid = context.RequestData.ReadUInt64();
-
-            using var serv = new SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService>();
-
-            Result rc = _base.Get.CreateDeliveryCacheStorageService(ref serv.Ref, pid);
-
-            if (rc.IsSuccess())
-            {
-                MakeObject(context, new IDeliveryCacheStorageService(context, ref serv.Ref));
-            }
-
-            return (ResultCode)rc.Value;
-        }
-
-        [CommandHipc(2)]
-        // CreateDeliveryCacheStorageServiceWithApplicationId(nn::ApplicationId) -> object<nn::bcat::detail::ipc::IDeliveryCacheStorageService>
-        public ResultCode CreateDeliveryCacheStorageServiceWithApplicationId(ServiceCtx context)
-        {
-            ApplicationId applicationId = context.RequestData.ReadStruct<ApplicationId>();
-
-            using var service = new SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService>();
-
-            Result rc = _base.Get.CreateDeliveryCacheStorageServiceWithApplicationId(ref service.Ref, applicationId);
-
-            if (rc.IsSuccess())
-            {
-                MakeObject(context, new IDeliveryCacheStorageService(context, ref service.Ref));
-            }
-
-            return (ResultCode)rc.Value;
-        }
-    }
-}

Ryujinx.HLE/HOS/Services/Bcat/ResultCode.cs

@@ -1,29 +0,0 @@
-namespace Ryujinx.HLE.HOS.Services.Bcat
-{
-    enum ResultCode
-    {
-        ModuleId       = 122,
-        ErrorCodeShift = 9,
-
-        Success = 0,
-
-        InvalidArgument                   = (1 << ErrorCodeShift) | ModuleId,
-        NotFound                          = (2 << ErrorCodeShift) | ModuleId,
-        TargetLocked                      = (3 << ErrorCodeShift) | ModuleId,
-        TargetAlreadyMounted              = (4 << ErrorCodeShift) | ModuleId,
-        TargetNotMounted                  = (5 << ErrorCodeShift) | ModuleId,
-        AlreadyOpen                       = (6 << ErrorCodeShift) | ModuleId,
-        NotOpen                           = (7 << ErrorCodeShift) | ModuleId,
-        InternetRequestDenied             = (8 << ErrorCodeShift) | ModuleId,
-        ServiceOpenLimitReached           = (9 << ErrorCodeShift) | ModuleId,
-        SaveDataNotFound                  = (10 << ErrorCodeShift) | ModuleId,
-        NetworkServiceAccountNotAvailable = (31 << ErrorCodeShift) | ModuleId,
-        PassphrasePathNotFound            = (80 << ErrorCodeShift) | ModuleId,
-        DataVerificationFailed            = (81 << ErrorCodeShift) | ModuleId,
-        PermissionDenied                  = (90 << ErrorCodeShift) | ModuleId,
-        AllocationFailed                  = (91 << ErrorCodeShift) | ModuleId,
-        InvalidOperation                  = (98 << ErrorCodeShift) | ModuleId,
-        InvalidDeliveryCacheStorageFile   = (204 << ErrorCodeShift) | ModuleId,
-        StorageOpenLimitReached           = (205 << ErrorCodeShift) | ModuleId
-    }
-}

Ryujinx.HLE/HOS/Services/Bcat/ServiceCreator/IBcatService.cs

@@ -1,18 +0,0 @@
-using Ryujinx.HLE.HOS.Services.Arp;
-
-namespace Ryujinx.HLE.HOS.Services.Bcat.ServiceCreator
-{
-    class IBcatService : IpcService
-    {
-        public IBcatService(ApplicationLaunchProperty applicationLaunchProperty) { }
-
-        [CommandHipc(10100)]
-        // RequestSyncDeliveryCache() -> object<nn::bcat::detail::ipc::IDeliveryCacheProgressService>
-        public ResultCode RequestSyncDeliveryCache(ServiceCtx context)
-        {
-            MakeObject(context, new IDeliveryCacheProgressService(context));
-
-            return ResultCode.Success;
-        }
-    }
-}

Ryujinx.HLE/HOS/Services/Bcat/ServiceCreator/IDeliveryCacheDirectoryService.cs

@@ -1,65 +0,0 @@
-using LibHac;
-using LibHac.Bcat;
-using LibHac.Common;
-using Ryujinx.Common;
-using System.Runtime.InteropServices;
-
-namespace Ryujinx.HLE.HOS.Services.Bcat.ServiceCreator
-{
-    class IDeliveryCacheDirectoryService : DisposableIpcService
-    {
-        private SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheDirectoryService> _base;
-
-        public IDeliveryCacheDirectoryService(ref SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheDirectoryService> baseService)
-        {
-            _base = SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheDirectoryService>.CreateMove(ref baseService);
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            if (isDisposing)
-            {
-                _base.Destroy();
-            }
-        }
-
-        [CommandHipc(0)]
-        // Open(nn::bcat::DirectoryName)
-        public ResultCode Open(ServiceCtx context)
-        {
-            DirectoryName directoryName = context.RequestData.ReadStruct<DirectoryName>();
-
-            Result result = _base.Get.Open(ref directoryName);
-
-            return (ResultCode)result.Value;
-        }
-
-        [CommandHipc(1)]
-        // Read() -> (u32, buffer<nn::bcat::DeliveryCacheDirectoryEntry, 6>)
-        public ResultCode Read(ServiceCtx context)
-        {
-            ulong bufferAddress = context.Request.ReceiveBuff[0].Position;
-            ulong bufferLen = context.Request.ReceiveBuff[0].Size;
-
-            using (var region = context.Memory.GetWritableRegion(bufferAddress, (int)bufferLen, true))
-            {
-                Result result = _base.Get.Read(out int entriesRead, MemoryMarshal.Cast<byte, DeliveryCacheDirectoryEntry>(region.Memory.Span));
-
-                context.ResponseData.Write(entriesRead);
-
-                return (ResultCode)result.Value;
-            }
-        }
-
-        [CommandHipc(2)]
-        // GetCount() -> u32
-        public ResultCode GetCount(ServiceCtx context)
-        {
-            Result result = _base.Get.GetCount(out int count);
-
-            context.ResponseData.Write(count);
-
-            return (ResultCode)result.Value;
-        }
-    }
-}

Ryujinx.HLE/HOS/Services/Bcat/ServiceCreator/IDeliveryCacheFileService.cs

@@ -1,78 +0,0 @@
-using LibHac;
-using LibHac.Bcat;
-using LibHac.Common;
-using Ryujinx.Common;
-
-namespace Ryujinx.HLE.HOS.Services.Bcat.ServiceCreator
-{
-    class IDeliveryCacheFileService : DisposableIpcService
-    {
-        private SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheFileService> _base;
-
-        public IDeliveryCacheFileService(ref SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheFileService> baseService)
-        {
-            _base = SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheFileService>.CreateMove(ref baseService);
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            if (isDisposing)
-            {
-                _base.Destroy();
-            }
-        }
-
-        [CommandHipc(0)]
-        // Open(nn::bcat::DirectoryName, nn::bcat::FileName)
-        public ResultCode Open(ServiceCtx context)
-        {
-            DirectoryName directoryName = context.RequestData.ReadStruct<DirectoryName>();
-            FileName fileName = context.RequestData.ReadStruct<FileName>();
-
-            Result result = _base.Get.Open(ref directoryName, ref fileName);
-
-            return (ResultCode)result.Value;
-        }
-
-        [CommandHipc(1)]
-        // Read(u64) -> (u64, buffer<bytes, 6>)
-        public ResultCode Read(ServiceCtx context)
-        {
-            ulong bufferAddress = context.Request.ReceiveBuff[0].Position;
-            ulong bufferLen = context.Request.ReceiveBuff[0].Size;
-
-            long offset = context.RequestData.ReadInt64();
-
-            using (var region = context.Memory.GetWritableRegion(bufferAddress, (int)bufferLen, true))
-            {
-                Result result = _base.Get.Read(out long bytesRead, offset, region.Memory.Span);
-
-                context.ResponseData.Write(bytesRead);
-
-                return (ResultCode)result.Value;
-            }
-        }
-
-        [CommandHipc(2)]
-        // GetSize() -> u64
-        public ResultCode GetSize(ServiceCtx context)
-        {
-            Result result = _base.Get.GetSize(out long size);
-
-            context.ResponseData.Write(size);
-
-            return (ResultCode)result.Value;
-        }
-
-        [CommandHipc(3)]
-        // GetDigest() -> nn::bcat::Digest
-        public ResultCode GetDigest(ServiceCtx context)
-        {
-            Result result = _base.Get.GetDigest(out Digest digest);
-
-            context.ResponseData.WriteStruct(digest);
-
-            return (ResultCode)result.Value;
-        }
-    }
-}

Ryujinx.HLE/HOS/Services/Bcat/ServiceCreator/IDeliveryCacheProgressService.cs

@@ -1,63 +0,0 @@
-using Ryujinx.Common.Logging;
-using Ryujinx.Cpu;
-using Ryujinx.HLE.HOS.Ipc;
-using Ryujinx.HLE.HOS.Kernel.Threading;
-using Ryujinx.HLE.HOS.Services.Bcat.ServiceCreator.Types;
-using Ryujinx.Horizon.Common;
-using System;
-
-namespace Ryujinx.HLE.HOS.Services.Bcat.ServiceCreator
-{
-    class IDeliveryCacheProgressService : IpcService
-    {
-        private KEvent _event;
-        private int    _eventHandle;
-
-        public IDeliveryCacheProgressService(ServiceCtx context)
-        {
-            _event = new KEvent(context.Device.System.KernelContext);
-        }
-
-        [CommandHipc(0)]
-        // GetEvent() -> handle<copy>
-        public ResultCode GetEvent(ServiceCtx context)
-        {
-            if (_eventHandle == 0)
-            {
-                if (context.Process.HandleTable.GenerateHandle(_event.ReadableEvent, out _eventHandle) != Result.Success)
-                {
-                    throw new InvalidOperationException("Out of handles!");
-                }
-            }
-
-            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_eventHandle);
-
-            Logger.Stub?.PrintStub(LogClass.ServiceBcat);
-
-            return ResultCode.Success;
-        }
-
-        [CommandHipc(1)]
-        // GetImpl() -> buffer<nn::bcat::detail::DeliveryCacheProgressImpl, 0x1a>
-        public ResultCode GetImpl(ServiceCtx context)
-        {
-            DeliveryCacheProgressImpl deliveryCacheProgress = new DeliveryCacheProgressImpl
-            {
-                State  = DeliveryCacheProgressImpl.Status.Done,
-                Result = 0
-            };
-
-            ulong dcpSize = WriteDeliveryCacheProgressImpl(context, context.Request.RecvListBuff[0], deliveryCacheProgress);
-            context.Response.PtrBuff[0] = context.Response.PtrBuff[0].WithSize(dcpSize);
-
-            Logger.Stub?.PrintStub(LogClass.ServiceBcat);
-
-            return ResultCode.Success;
-        }
-
-        private ulong WriteDeliveryCacheProgressImpl(ServiceCtx context, IpcRecvListBuffDesc ipcDesc, DeliveryCacheProgressImpl deliveryCacheProgress)
-        {
-            return MemoryHelper.Write(context.Memory, ipcDesc.Position, deliveryCacheProgress);
-        }
-    }
-}

Ryujinx.HLE/HOS/Services/Bcat/ServiceCreator/IDeliveryCacheStorageService.cs

@@ -1,74 +0,0 @@
-using LibHac;
-using LibHac.Bcat;
-using LibHac.Common;
-using System.Runtime.InteropServices;
-
-namespace Ryujinx.HLE.HOS.Services.Bcat.ServiceCreator
-{
-    class IDeliveryCacheStorageService : DisposableIpcService
-    {
-        private SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService> _base;
-
-        public IDeliveryCacheStorageService(ServiceCtx context, ref SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService> baseService)
-        {
-            _base = SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheStorageService>.CreateMove(ref baseService);
-        }
-
-        [CommandHipc(0)]
-        // CreateFileService() -> object<nn::bcat::detail::ipc::IDeliveryCacheFileService>
-        public ResultCode CreateFileService(ServiceCtx context)
-        {
-            using var service = new SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheFileService>();
-
-            Result result = _base.Get.CreateFileService(ref service.Ref);
-
-            if (result.IsSuccess())
-            {
-                MakeObject(context, new IDeliveryCacheFileService(ref service.Ref));
-            }
-
-            return (ResultCode)result.Value;
-        }
-
-        [CommandHipc(1)]
-        // CreateDirectoryService() -> object<nn::bcat::detail::ipc::IDeliveryCacheDirectoryService>
-        public ResultCode CreateDirectoryService(ServiceCtx context)
-        {
-            using var service = new SharedRef<LibHac.Bcat.Impl.Ipc.IDeliveryCacheDirectoryService>();
-
-            Result result = _base.Get.CreateDirectoryService(ref service.Ref);
-
-            if (result.IsSuccess())
-            {
-                MakeObject(context, new IDeliveryCacheDirectoryService(ref service.Ref));
-            }
-
-            return (ResultCode)result.Value;
-        }
-
-        [CommandHipc(10)]
-        // EnumerateDeliveryCacheDirectory() -> (u32, buffer<nn::bcat::DirectoryName, 6>)
-        public ResultCode EnumerateDeliveryCacheDirectory(ServiceCtx context)
-        {
-            ulong bufferAddress = context.Request.ReceiveBuff[0].Position;
-            ulong bufferLen = context.Request.ReceiveBuff[0].Size;
-
-            using (var region = context.Memory.GetWritableRegion(bufferAddress, (int)bufferLen, true))
-            {
-                Result result = _base.Get.EnumerateDeliveryCacheDirectory(out int count, MemoryMarshal.Cast<byte, DirectoryName>(region.Memory.Span));
-
-                context.ResponseData.Write(count);
-
-                return (ResultCode)result.Value;
-            }
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            if (isDisposing)
-            {
-                _base.Destroy();
-            }
-        }
-    }
-}

Ryujinx.HLE/HOS/Services/Hid/Types/SharedMemory/Common/ISampledData.cs

@@ -1,7 +0,0 @@
-namespace Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Common
-{
-    interface ISampledData
-    {
-        ulong SamplingNumber { get; }
-    }
-}

Ryujinx.HLE/HOS/Services/Nv/NvDrvServices/NvHostCtrlGpu/Types/ZbcSetTableArguments.cs

@@ -1,49 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrlGpu.Types
-{
-    [StructLayout(LayoutKind.Sequential)]
-    struct ZbcColorArray
-    {
-        private uint element0;
-        private uint element1;
-        private uint element2;
-        private uint element3;
-
-        public uint this[int index]
-        {
-            get
-            {
-                if (index == 0)
-                {
-                    return element0;
-                }
-                else if (index == 1)
-                {
-                    return element1;
-                }
-                else if (index == 2)
-                {
-                    return element2;
-                }
-                else if (index == 2)
-                {
-                    return element3;
-                }
-
-                throw new IndexOutOfRangeException();
-            }
-        }
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    struct ZbcSetTableArguments
-    {
-        public ZbcColorArray ColorDs;
-        public ZbcColorArray ColorL2;
-        public uint          Depth;
-        public uint          Format;
-        public uint          Type;
-    }
-}

Ryujinx.Headless.SDL2/HideCursor.cs

@@ -1,9 +0,0 @@
-namespace Ryujinx.Headless.SDL2
-{
-    public enum HideCursor
-    {
-        Never,
-        OnIdle,
-        Always
-    }
-}

Ryujinx.Ui.Common/App/ApplicationData.cs

@@ -1,23 +0,0 @@
-using LibHac.Common;
-using LibHac.Ns;
-
-namespace Ryujinx.Ui.App.Common
-{
-    public class ApplicationData
-    {
-        public bool   Favorite      { get; set; }
-        public byte[] Icon          { get; set; }
-        public string TitleName     { get; set; }
-        public string TitleId       { get; set; }
-        public string Developer     { get; set; }
-        public string Version       { get; set; }
-        public string TimePlayed    { get; set; }
-        public double TimePlayedNum { get; set; }
-        public string LastPlayed    { get; set; }
-        public string FileExtension { get; set; }
-        public string FileSize      { get; set; }
-        public double FileSizeBytes { get; set; }
-        public string Path          { get; set; }
-        public BlitStruct<ApplicationControlProperty> ControlHolder { get; set; }
-    }
-}

Ryujinx.Ui.Common/App/ApplicationMetadata.cs

@@ -1,10 +0,0 @@
-namespace Ryujinx.Ui.App.Common
-{
-    public class ApplicationMetadata
-    {
-        public string Title { get; set; }
-        public bool   Favorite   { get; set; }
-        public double TimePlayed { get; set; }
-        public string LastPlayed { get; set; } = "Never";
-    }
-}

Ryujinx.Ui.Common/Configuration/AudioBackend.cs

@@ -1,10 +0,0 @@
-namespace Ryujinx.Ui.Common.Configuration
-{
-    public enum AudioBackend
-    {
-        Dummy,
-        OpenAl,
-        SoundIo,
-        SDL2
-    }
-}

Ryujinx.Ui.Common/Configuration/System/Region.cs

@@ -1,13 +0,0 @@
-namespace Ryujinx.Ui.Common.Configuration.System
-{
-    public enum Region
-    {
-        Japan,
-        USA,
-        Europe,
-        Australia,
-        China,
-        Korea,
-        Taiwan
-    }
-}

Ryujinx.sln

@@ -3,33 +3,33 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.1.32228.430
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx", "Ryujinx\Ryujinx.csproj", "{074045D4-3ED2-4711-9169-E385F2BFB5A0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx", "src\Ryujinx\Ryujinx.csproj", "{074045D4-3ED2-4711-9169-E385F2BFB5A0}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Tests", "Ryujinx.Tests\Ryujinx.Tests.csproj", "{EBB55AEA-C7D7-4DEB-BF96-FA1789E225E9}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Tests", "src\Ryujinx.Tests\Ryujinx.Tests.csproj", "{EBB55AEA-C7D7-4DEB-BF96-FA1789E225E9}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Tests.Unicorn", "Ryujinx.Tests.Unicorn\Ryujinx.Tests.Unicorn.csproj", "{D8F72938-78EF-4E8C-BAFE-531C9C3C8F15}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Tests.Unicorn", "src\Ryujinx.Tests.Unicorn\Ryujinx.Tests.Unicorn.csproj", "{D8F72938-78EF-4E8C-BAFE-531C9C3C8F15}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.HLE", "Ryujinx.HLE\Ryujinx.HLE.csproj", "{CB92CFF9-1D62-4D4F-9E88-8130EF61E351}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.HLE", "src\Ryujinx.HLE\Ryujinx.HLE.csproj", "{CB92CFF9-1D62-4D4F-9E88-8130EF61E351}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.ShaderTools", "Ryujinx.ShaderTools\Ryujinx.ShaderTools.csproj", "{3AB294D0-2230-468F-9EB3-BDFCAEAE99A5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.ShaderTools", "src\Ryujinx.ShaderTools\Ryujinx.ShaderTools.csproj", "{3AB294D0-2230-468F-9EB3-BDFCAEAE99A5}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Common", "Ryujinx.Common\Ryujinx.Common.csproj", "{5FD4E4F6-8928-4B3C-BE07-28A675C17226}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Common", "src\Ryujinx.Common\Ryujinx.Common.csproj", "{5FD4E4F6-8928-4B3C-BE07-28A675C17226}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ARMeilleure", "ARMeilleure\ARMeilleure.csproj", "{ABF09A5E-2D8B-4B6F-A51D-5CE414DDB15A}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ARMeilleure", "src\ARMeilleure\ARMeilleure.csproj", "{ABF09A5E-2D8B-4B6F-A51D-5CE414DDB15A}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Gpu", "Ryujinx.Graphics.Gpu\Ryujinx.Graphics.Gpu.csproj", "{ADA7EA87-0D63-4D97-9433-922A2124401F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Gpu", "src\Ryujinx.Graphics.Gpu\Ryujinx.Graphics.Gpu.csproj", "{ADA7EA87-0D63-4D97-9433-922A2124401F}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.GAL", "Ryujinx.Graphics.GAL\Ryujinx.Graphics.GAL.csproj", "{A602AE97-91A5-4608-8DF1-EBF4ED7A0B9E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.GAL", "src\Ryujinx.Graphics.GAL\Ryujinx.Graphics.GAL.csproj", "{A602AE97-91A5-4608-8DF1-EBF4ED7A0B9E}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.OpenGL", "Ryujinx.Graphics.OpenGL\Ryujinx.Graphics.OpenGL.csproj", "{9558FB96-075D-4219-8FFF-401979DC0B69}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.OpenGL", "src\Ryujinx.Graphics.OpenGL\Ryujinx.Graphics.OpenGL.csproj", "{9558FB96-075D-4219-8FFF-401979DC0B69}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Texture", "Ryujinx.Graphics.Texture\Ryujinx.Graphics.Texture.csproj", "{E1B1AD28-289D-47B7-A106-326972240207}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Texture", "src\Ryujinx.Graphics.Texture\Ryujinx.Graphics.Texture.csproj", "{E1B1AD28-289D-47B7-A106-326972240207}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Shader", "Ryujinx.Graphics.Shader\Ryujinx.Graphics.Shader.csproj", "{03B955CD-AD84-4B93-AAA7-BF17923BBAA5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Shader", "src\Ryujinx.Graphics.Shader\Ryujinx.Graphics.Shader.csproj", "{03B955CD-AD84-4B93-AAA7-BF17923BBAA5}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Nvdec", "Ryujinx.Graphics.Nvdec\Ryujinx.Graphics.Nvdec.csproj", "{85A0FA56-DC01-4A42-8808-70DAC76BD66D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Nvdec", "src\Ryujinx.Graphics.Nvdec\Ryujinx.Graphics.Nvdec.csproj", "{85A0FA56-DC01-4A42-8808-70DAC76BD66D}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio", "Ryujinx.Audio\Ryujinx.Audio.csproj", "{806ACF6D-90B0-45D0-A1AC-5F220F3B3985}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio", "src\Ryujinx.Audio\Ryujinx.Audio.csproj", "{806ACF6D-90B0-45D0-A1AC-5F220F3B3985}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{36F870C1-3E5F-485F-B426-F0645AF78751}"
 	ProjectSection(SolutionItems) = preProject
@@ -37,55 +37,55 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		Directory.Packages.props = Directory.Packages.props
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Memory", "Ryujinx.Memory\Ryujinx.Memory.csproj", "{A5E6C691-9E22-4263-8F40-42F002CE66BE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Memory", "src\Ryujinx.Memory\Ryujinx.Memory.csproj", "{A5E6C691-9E22-4263-8F40-42F002CE66BE}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Memory.Tests", "Ryujinx.Memory.Tests\Ryujinx.Memory.Tests.csproj", "{D1CC5322-7325-4F6B-9625-194B30BE1296}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Tests.Memory", "src\Ryujinx.Tests.Memory\Ryujinx.Tests.Memory.csproj", "{D1CC5322-7325-4F6B-9625-194B30BE1296}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Cpu", "Ryujinx.Cpu\Ryujinx.Cpu.csproj", "{3DF35E3D-D844-4399-A9A1-A9E923264C17}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Cpu", "src\Ryujinx.Cpu\Ryujinx.Cpu.csproj", "{3DF35E3D-D844-4399-A9A1-A9E923264C17}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Device", "Ryujinx.Graphics.Device\Ryujinx.Graphics.Device.csproj", "{C3002C3C-7B09-4FE7-894A-372EDA22FC6E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Device", "src\Ryujinx.Graphics.Device\Ryujinx.Graphics.Device.csproj", "{C3002C3C-7B09-4FE7-894A-372EDA22FC6E}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Host1x", "Ryujinx.Graphics.Host1x\Ryujinx.Graphics.Host1x.csproj", "{C35F1536-7DE5-4F9D-9604-B5B4E1561947}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Host1x", "src\Ryujinx.Graphics.Host1x\Ryujinx.Graphics.Host1x.csproj", "{C35F1536-7DE5-4F9D-9604-B5B4E1561947}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Nvdec.Vp9", "Ryujinx.Graphics.Nvdec.Vp9\Ryujinx.Graphics.Nvdec.Vp9.csproj", "{B9AECA11-E248-4886-A10B-81B631CAAF29}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Nvdec.Vp9", "src\Ryujinx.Graphics.Nvdec.Vp9\Ryujinx.Graphics.Nvdec.Vp9.csproj", "{B9AECA11-E248-4886-A10B-81B631CAAF29}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Vic", "Ryujinx.Graphics.Vic\Ryujinx.Graphics.Vic.csproj", "{81BB2C11-9408-4EA3-822E-42987AF54429}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Vic", "src\Ryujinx.Graphics.Vic\Ryujinx.Graphics.Vic.csproj", "{81BB2C11-9408-4EA3-822E-42987AF54429}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Video", "Ryujinx.Graphics.Video\Ryujinx.Graphics.Video.csproj", "{FD4A2C14-8E3D-4957-ABBE-3C38897B3E2D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Video", "src\Ryujinx.Graphics.Video\Ryujinx.Graphics.Video.csproj", "{FD4A2C14-8E3D-4957-ABBE-3C38897B3E2D}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio.Backends.OpenAL", "Ryujinx.Audio.Backends.OpenAL\Ryujinx.Audio.Backends.OpenAL.csproj", "{0BE11899-DF2D-4BDE-B9EE-2489E8D35E7D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio.Backends.OpenAL", "src\Ryujinx.Audio.Backends.OpenAL\Ryujinx.Audio.Backends.OpenAL.csproj", "{0BE11899-DF2D-4BDE-B9EE-2489E8D35E7D}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio.Backends.SoundIo", "Ryujinx.Audio.Backends.SoundIo\Ryujinx.Audio.Backends.SoundIo.csproj", "{716364DE-B988-41A6-BAB4-327964266ECC}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio.Backends.SoundIo", "src\Ryujinx.Audio.Backends.SoundIo\Ryujinx.Audio.Backends.SoundIo.csproj", "{716364DE-B988-41A6-BAB4-327964266ECC}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Input", "Ryujinx.Input\Ryujinx.Input.csproj", "{C16F112F-38C3-40BC-9F5F-4791112063D6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Input", "src\Ryujinx.Input\Ryujinx.Input.csproj", "{C16F112F-38C3-40BC-9F5F-4791112063D6}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Input.SDL2", "Ryujinx.Input.SDL2\Ryujinx.Input.SDL2.csproj", "{DFAB6F2D-B9BF-4AFF-B22B-7684A328EBA3}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Input.SDL2", "src\Ryujinx.Input.SDL2\Ryujinx.Input.SDL2.csproj", "{DFAB6F2D-B9BF-4AFF-B22B-7684A328EBA3}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.SDL2.Common", "Ryujinx.SDL2.Common\Ryujinx.SDL2.Common.csproj", "{2D5D3A1D-5730-4648-B0AB-06C53CB910C0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.SDL2.Common", "src\Ryujinx.SDL2.Common\Ryujinx.SDL2.Common.csproj", "{2D5D3A1D-5730-4648-B0AB-06C53CB910C0}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio.Backends.SDL2", "Ryujinx.Audio.Backends.SDL2\Ryujinx.Audio.Backends.SDL2.csproj", "{D99A395A-8569-4DB0-B336-900647890052}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio.Backends.SDL2", "src\Ryujinx.Audio.Backends.SDL2\Ryujinx.Audio.Backends.SDL2.csproj", "{D99A395A-8569-4DB0-B336-900647890052}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Headless.SDL2", "Ryujinx.Headless.SDL2\Ryujinx.Headless.SDL2.csproj", "{390DC343-5CB4-4C79-A5DD-E3ED235E4C49}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Headless.SDL2", "src\Ryujinx.Headless.SDL2\Ryujinx.Headless.SDL2.csproj", "{390DC343-5CB4-4C79-A5DD-E3ED235E4C49}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Nvdec.FFmpeg", "Ryujinx.Graphics.Nvdec.FFmpeg\Ryujinx.Graphics.Nvdec.FFmpeg.csproj", "{BEE1C184-C9A4-410B-8DFC-FB74D5C93AEB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Nvdec.FFmpeg", "src\Ryujinx.Graphics.Nvdec.FFmpeg\Ryujinx.Graphics.Nvdec.FFmpeg.csproj", "{BEE1C184-C9A4-410B-8DFC-FB74D5C93AEB}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Ava", "Ryujinx.Ava\Ryujinx.Ava.csproj", "{7C1B2721-13DA-4B62-B046-C626605ECCE6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Ava", "src\Ryujinx.Ava\Ryujinx.Ava.csproj", "{7C1B2721-13DA-4B62-B046-C626605ECCE6}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Ui.Common", "Ryujinx.Ui.Common\Ryujinx.Ui.Common.csproj", "{BA161CA0-CD65-4E6E-B644-51C8D1E542DC}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Ui.Common", "src\Ryujinx.Ui.Common\Ryujinx.Ui.Common.csproj", "{BA161CA0-CD65-4E6E-B644-51C8D1E542DC}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon.Generators", "Ryujinx.Horizon.Generators\Ryujinx.Horizon.Generators.csproj", "{6AE2A5E8-4C5A-48B9-997B-E1455C0355C6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon.Generators", "src\Ryujinx.Horizon.Generators\Ryujinx.Horizon.Generators.csproj", "{6AE2A5E8-4C5A-48B9-997B-E1455C0355C6}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Vulkan", "Ryujinx.Graphics.Vulkan\Ryujinx.Graphics.Vulkan.csproj", "{D4D09B08-D580-4D69-B886-C35D2853F6C8}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Vulkan", "src\Ryujinx.Graphics.Vulkan\Ryujinx.Graphics.Vulkan.csproj", "{D4D09B08-D580-4D69-B886-C35D2853F6C8}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Spv.Generator", "Spv.Generator\Spv.Generator.csproj", "{2BCB3D7A-38C0-4FE7-8FDA-374C6AD56D0E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Spv.Generator", "src\Spv.Generator\Spv.Generator.csproj", "{2BCB3D7A-38C0-4FE7-8FDA-374C6AD56D0E}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Ui.LocaleGenerator", "Ryujinx.Ui.LocaleGenerator\Ryujinx.Ui.LocaleGenerator.csproj", "{77D01AD9-2C98-478E-AE1D-8F7100738FB4}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Ui.LocaleGenerator", "src\Ryujinx.Ui.LocaleGenerator\Ryujinx.Ui.LocaleGenerator.csproj", "{77D01AD9-2C98-478E-AE1D-8F7100738FB4}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon.Common", "Ryujinx.Horizon.Common\Ryujinx.Horizon.Common.csproj", "{77F96ECE-4952-42DB-A528-DED25572A573}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon.Common", "src\Ryujinx.Horizon.Common\Ryujinx.Horizon.Common.csproj", "{77F96ECE-4952-42DB-A528-DED25572A573}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon", "Ryujinx.Horizon\Ryujinx.Horizon.csproj", "{AF34127A-3A92-43E5-8496-14960A50B1F1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon", "src\Ryujinx.Horizon\Ryujinx.Horizon.csproj", "{AF34127A-3A92-43E5-8496-14960A50B1F1}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon.Kernel.Generators", "Ryujinx.Horizon.Kernel.Generators\Ryujinx.Horizon.Kernel.Generators.csproj", "{7F55A45D-4E1D-4A36-ADD3-87F29A285AA2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Horizon.Kernel.Generators", "src\Ryujinx.Horizon.Kernel.Generators\Ryujinx.Horizon.Kernel.Generators.csproj", "{7F55A45D-4E1D-4A36-ADD3-87F29A285AA2}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

distribution/linux/Ryujinx.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-SCRIPT_DIR=$(dirname $(realpath $0))
+SCRIPT_DIR=$(dirname "$(realpath "$0")")
 RYUJINX_BIN="Ryujinx"
 
 if [ -f "$SCRIPT_DIR/Ryujinx.Ava" ]; then
@@ -11,4 +11,10 @@ if [ -f "$SCRIPT_DIR/Ryujinx.Headless.SDL2" ]; then
     RYUJINX_BIN="Ryujinx.Headless.SDL2"
 fi
 
-env DOTNET_EnableAlternateStackCheck=1 "$SCRIPT_DIR/$RYUJINX_BIN" "$@"
+COMMAND="env DOTNET_EnableAlternateStackCheck=1"
+
+if command -v gamemoderun > /dev/null 2>&1; then
+    COMMAND="$COMMAND gamemoderun"
+fi
+
+$COMMAND "$SCRIPT_DIR/$RYUJINX_BIN" "$@"

distribution/macos/create_app_bundle.sh

@@ -41,12 +41,10 @@ then
         exit 1
     fi
 
-    # NOTE: Currently require https://github.com/indygreg/apple-platform-rs/pull/44 to work on other OSes.
-    # cargo install --git "https://github.com/marysaka/apple-platform-rs" --branch "fix/adhoc-app-bundle" apple-codesign --bin "rcodesign"
+    # cargo install apple-codesign
     echo "Usign rcodesign for ad-hoc signing"
     rcodesign sign --entitlements-xml-path "$ENTITLEMENTS_FILE_PATH" "$APP_BUNDLE_DIRECTORY"
 else
     echo "Usign codesign for ad-hoc signing"
     codesign --entitlements "$ENTITLEMENTS_FILE_PATH" -f --deep -s - "$APP_BUNDLE_DIRECTORY"
-fi
-
+fi

distribution/macos/create_macos_build.sh

@@ -2,8 +2,8 @@
 
 set -e
 
-if [ "$#" -ne 6 ]; then
-    echo "usage <BASE_DIR> <TEMP_DIRECTORY> <OUTPUT_DIRECTORY> <ENTITLEMENTS_FILE_PATH> <VERSION> <SOURCE_REVISION_ID>"
+if [ "$#" -lt 7 ]; then
+    echo "usage <BASE_DIR> <TEMP_DIRECTORY> <OUTPUT_DIRECTORY> <ENTITLEMENTS_FILE_PATH> <VERSION> <SOURCE_REVISION_ID> <CONFIGURATION> <EXTRA_ARGS>"
     exit 1
 fi
 
@@ -17,8 +17,16 @@ OUTPUT_DIRECTORY=$(readlink -f "$3")
 ENTITLEMENTS_FILE_PATH=$(readlink -f "$4")
 VERSION=$5
 SOURCE_REVISION_ID=$6
+CONFIGURATION=$7
+EXTRA_ARGS=$8
+
+if [ "$VERSION" == "1.1.0" ];
+then
+  RELEASE_TAR_FILE_NAME=test-ava-ryujinx-$CONFIGURATION-$VERSION+$SOURCE_REVISION_ID-macos_universal.app.tar
+else
+  RELEASE_TAR_FILE_NAME=test-ava-ryujinx-$VERSION-macos_universal.app.tar
+fi
 
-RELEASE_TAR_FILE_NAME=Ryujinx-$VERSION-macos_universal.app.tar
 ARM64_APP_BUNDLE="$TEMP_DIRECTORY/output_arm64/Ryujinx.app"
 X64_APP_BUNDLE="$TEMP_DIRECTORY/output_x64/Ryujinx.app"
 UNIVERSAL_APP_BUNDLE="$OUTPUT_DIRECTORY/Ryujinx.app"
@@ -27,17 +35,17 @@ EXECUTABLE_SUB_PATH=Contents/MacOS/Ryujinx
 rm -rf "$TEMP_DIRECTORY"
 mkdir -p "$TEMP_DIRECTORY"
 
-DOTNET_COMMON_ARGS="-p:DebugType=embedded -p:Version=$VERSION -p:SourceRevisionId=$SOURCE_REVISION_ID --self-contained true"
+DOTNET_COMMON_ARGS="-p:DebugType=embedded -p:Version=$VERSION -p:SourceRevisionId=$SOURCE_REVISION_ID --self-contained true $EXTRA_ARGS"
 
 dotnet restore
-dotnet build -c Release Ryujinx.Ava
-dotnet publish -c Release -r osx-arm64 -o "$TEMP_DIRECTORY/publish_arm64" $DOTNET_COMMON_ARGS Ryujinx.Ava
-dotnet publish -c Release -r osx-x64 -o "$TEMP_DIRECTORY/publish_x64" $DOTNET_COMMON_ARGS Ryujinx.Ava
+dotnet build -c $CONFIGURATION src/Ryujinx.Ava
+dotnet publish -c $CONFIGURATION -r osx-arm64 -o "$TEMP_DIRECTORY/publish_arm64" $DOTNET_COMMON_ARGS src/Ryujinx.Ava
+dotnet publish -c $CONFIGURATION -r osx-x64 -o "$TEMP_DIRECTORY/publish_x64" $DOTNET_COMMON_ARGS src/Ryujinx.Ava
 
-# Get ride of the support library for ARMeilleur for x64 (that's only for arm64)
+# Get rid of the support library for ARMeilleure for x64 (that's only for arm64)
 rm -rf "$TEMP_DIRECTORY/publish_x64/libarmeilleure-jitsupport.dylib"
 
-# Get ride of libsoundio from arm64 builds as we don't have a arm64 variant
+# Get rid of libsoundio from arm64 builds as we don't have a arm64 variant
 # TODO: remove this once done
 rm -rf "$TEMP_DIRECTORY/publish_arm64/libsoundio.dylib"
 
@@ -68,7 +76,7 @@ else
     LIPO=lipo
 fi
 
-# Make it the executable universal
+# Make the executable universal
 $LIPO "$ARM64_APP_BUNDLE/$EXECUTABLE_SUB_PATH" "$X64_APP_BUNDLE/$EXECUTABLE_SUB_PATH" -output "$UNIVERSAL_APP_BUNDLE/$EXECUTABLE_SUB_PATH" -create
 
 # Patch up the Info.plist to have appropriate version
@@ -87,10 +95,10 @@ then
 
     # NOTE: Currently require https://github.com/indygreg/apple-platform-rs/pull/44 to work on other OSes.
     # cargo install --git "https://github.com/marysaka/apple-platform-rs" --branch "fix/adhoc-app-bundle" apple-codesign --bin "rcodesign"
-    echo "Usign rcodesign for ad-hoc signing"
+    echo "Using rcodesign for ad-hoc signing"
     rcodesign sign --entitlements-xml-path "$ENTITLEMENTS_FILE_PATH" "$UNIVERSAL_APP_BUNDLE"
 else
-    echo "Usign codesign for ad-hoc signing"
+    echo "Using codesign for ad-hoc signing"
     codesign --entitlements "$ENTITLEMENTS_FILE_PATH" -f --deep -s - "$UNIVERSAL_APP_BUNDLE"
 fi
 
@@ -102,4 +110,4 @@ gzip -9 < $RELEASE_TAR_FILE_NAME > $RELEASE_TAR_FILE_NAME.gz
 rm $RELEASE_TAR_FILE_NAME
 popd
 
-echo "Done"
+echo "Done"

distribution/macos/updater.sh

@@ -27,13 +27,31 @@ error_handler() {
 
 trap 'error_handler ${LINENO}' ERR
 
-# Wait for Ryujinx to exit
-# NOTE: in case no fds are open, lsof could be returning with a process still living.
-# We wait 1s and assume the process stopped after that
-lsof -p $APP_PID +r 1 &>/dev/null
+# Wait for Ryujinx to exit.
+# If the main process is still acitve, we wait for 1 second and check it again.
+# After the fifth time checking, this script exits with status 1.
+
+attempt=0
+while true; do
+    if lsof -p $APP_PID +r 1 &>/dev/null || ps -p "$APP_PID" &>/dev/null; then
+        if [ "$attempt" -eq 4 ]; then
+            exit 1
+        fi
+        sleep 1
+    else
+        break
+    fi
+    (( attempt++ ))
+done
+
 sleep 1
 
 # Now replace and reopen.
 rm -rf "$INSTALL_DIRECTORY"
 mv "$NEW_APP_DIRECTORY" "$INSTALL_DIRECTORY"
-open -a "$INSTALL_DIRECTORY" --args "$APP_ARGUMENTS"
+
+if [ "$#" -le 3 ]; then
+    open -a "$INSTALL_DIRECTORY"
+else
+    open -a "$INSTALL_DIRECTORY" --args "$APP_ARGUMENTS"
+fi

src/ARMeilleure/CodeGen/Arm64/IntrinsicTable.cs

@@ -226,6 +226,8 @@ namespace ARMeilleure.CodeGen.Arm64
             Add(Intrinsic.Arm64MlsVe,         new IntrinsicInfo(0x2f004000u, IntrinsicType.VectorTernaryRdByElem));
             Add(Intrinsic.Arm64MlsV,          new IntrinsicInfo(0x2e209400u, IntrinsicType.VectorTernaryRd));
             Add(Intrinsic.Arm64MoviV,         new IntrinsicInfo(0x0f000400u, IntrinsicType.VectorMovi));
+            Add(Intrinsic.Arm64MrsFpcr,       new IntrinsicInfo(0xd53b4400u, IntrinsicType.GetRegister));
+            Add(Intrinsic.Arm64MsrFpcr,       new IntrinsicInfo(0xd51b4400u, IntrinsicType.SetRegister));
             Add(Intrinsic.Arm64MrsFpsr,       new IntrinsicInfo(0xd53b4420u, IntrinsicType.GetRegister));
             Add(Intrinsic.Arm64MsrFpsr,       new IntrinsicInfo(0xd51b4420u, IntrinsicType.SetRegister));
             Add(Intrinsic.Arm64MulVe,         new IntrinsicInfo(0x0f008000u, IntrinsicType.VectorBinaryByElem));