Move gl_Layer from vertex to geometry if GPU does not support it on vertex (#3866)

* Move gl_Layer from vertex to geometry if GPU does not support it on vertex

* Shader cache version bump

* PR feedback

.github/ISSUE_TEMPLATE/bug_report.md

@@ -34,7 +34,7 @@ about: Something doesn't work correctly in Ryujinx. Note that game-specific issu
   - OS: *(e.g. Windows 10)*
   - CPU: *(e.g. i7-6700)*
   - GPU: *(e.g. NVIDIA RTX 2070)*
-  - RAM: *(e.g. 16GB)*
+  - RAM: *(e.g. 16GiB)*
 - Applied Mods : [ Yes (Which ones) / No ]
 
 ### Additional context?

.github/dependabot.yml

@@ -0,0 +1,24 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: weekly
+    labels:
+      - "infra"
+    reviewers:
+      - marysaka
+    commit-message:
+      prefix: "ci"
+
+  - package-ecosystem: nuget
+    directory: /
+    open-pull-requests-limit: 5
+    schedule:
+      interval: daily
+    labels:
+      - "infra"
+    reviewers:
+      - marysaka
+    commit-message:
+      prefix: nuget

.github/workflows/build.yml

@@ -48,44 +48,41 @@ jobs:
       DOTNET_CLI_TELEMETRY_OPTOUT: 1
       RYUJINX_BASE_VERSION: "1.1.0"
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-dotnet@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 6.0.x
-      - name: Ensure NuGet Source
-        uses: fabriciomurta/ensure-nuget-source@v1
+          dotnet-version: 7.0.x
       - name: Get git short hash
         id: git_short_hash
-        run: echo "::set-output name=result::$(git rev-parse --short "${{ github.sha }}")"
-      - name: Clear
-        run: dotnet clean && dotnet nuget locals all --clear
+        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
+        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 -c "${{ matrix.configuration }}"
+        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
+        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'
       - 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
+        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'
       - name: Publish Ryujinx.Ava
-        run: dotnet publish -c "${{ matrix.configuration }}" -r "${{ matrix.DOTNET_RUNTIME_IDENTIFIER }}" -o ./publish_ava /p:Version="1.0.0" /p:DebugType=embedded /p:SourceRevisionId="${{ steps.git_short_hash.outputs.result }}" /p:ExtraDefineConstants=DISABLE_UPDATER 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'
       - name: Upload Ryujinx artifact
-        uses: actions/upload-artifact@v2
+        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'
       - name: Upload Ryujinx.Headless.SDL2 artifact
-        uses: actions/upload-artifact@v2
+        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'
       - name: Upload Ryujinx.Ava artifact
-        uses: actions/upload-artifact@v2
+        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

.github/workflows/nightly_pr_comment.yml

@@ -8,7 +8,7 @@ jobs:
     if: github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v3
+      - uses: actions/github-script@v6
         with:
           script: |
             const {owner, repo} = context.repo;
@@ -16,7 +16,7 @@ jobs:
             const pull_head_sha = '${{github.event.workflow_run.head_sha}}';
 
             const issue_number = await (async () => {
-              const pulls = await github.pulls.list({owner, repo});
+              const pulls = await github.rest.pulls.list({owner, repo});
               for await (const {data} of github.paginate.iterator(pulls)) {
                 for (const pull of data) {
                   if (pull.head.sha === pull_head_sha) {
@@ -31,7 +31,7 @@ jobs:
               return core.error(`No matching pull request found`);
             }
 
-            const {data: {artifacts}} = await github.actions.listWorkflowRunArtifacts({owner, repo, run_id});
+            const {data: {artifacts}} = await github.rest.actions.listWorkflowRunArtifacts({owner, repo, run_id});
             if (!artifacts.length) {
               return core.error(`No artifacts found`);
             }
@@ -57,12 +57,12 @@ jobs:
             body += hidden_headless_artifacts;
             body += hidden_debug_artifacts;
 
-            const {data: comments} = await github.issues.listComments({repo, owner, issue_number});
+            const {data: comments} = await github.rest.issues.listComments({repo, owner, issue_number});
             const existing_comment = comments.find((c) => c.user.login === 'github-actions[bot]');
             if (existing_comment) {
               core.info(`Updating comment ${existing_comment.id}`);
-              await github.issues.updateComment({repo, owner, comment_id: existing_comment.id, body});
+              await github.rest.issues.updateComment({repo, owner, comment_id: existing_comment.id, body});
             } else {
               core.info(`Creating a comment`);
-              await github.issues.createComment({repo, owner, issue_number, body});
+              await github.rest.issues.createComment({repo, owner, issue_number, body});
             }

.github/workflows/release.yml

@@ -25,19 +25,15 @@ jobs:
       RYUJINX_TARGET_RELEASE_CHANNEL_REPO: "release-channel-master"
 
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-dotnet@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 6.0.x
-      - name: Ensure NuGet Source
-        uses: fabriciomurta/ensure-nuget-source@v1
-      - name: Clear
-        run: dotnet clean && dotnet nuget locals all --clear
+          dotnet-version: 7.0.x
       - name: Get version info
         id: version_info
         run: |
-          echo "::set-output name=build_version::${{ env.RYUJINX_BASE_VERSION }}.${{ github.run_number }}"
-          echo "::set-output name=git_short_hash::$(git rev-parse --short "${{ github.sha }}")"
+          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: |
@@ -51,9 +47,9 @@ jobs:
         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
-          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
-          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
+          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
@@ -71,9 +67,9 @@ jobs:
 
       - 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
-          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
-          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
+          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: |

ARMeilleure/ARMeilleure.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 

ARMeilleure/Common/BitUtils.cs

@@ -1,15 +1,11 @@
+using System;
 using System.Numerics;
 
 namespace ARMeilleure.Common
 {
     static class BitUtils
     {
-        private static readonly sbyte[] HbsNibbleLut;
-
-        static BitUtils()
-        {
-            HbsNibbleLut = new sbyte[] { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 };
-        }
+        private static ReadOnlySpan<sbyte> HbsNibbleLut => new sbyte[] { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 };
 
         public static long FillWithOnes(int bits)
         {

ARMeilleure/Decoders/OpCode32SimdCvtTB.cs

@@ -0,0 +1,44 @@
+namespace ARMeilleure.Decoders
+{
+    class OpCode32SimdCvtTB : OpCode32, IOpCode32Simd
+    {
+        public int Vd { get; }
+        public int Vm { get; }
+        public bool Op { get; } // Convert to Half / Convert from Half
+        public bool T { get; } // Top / Bottom
+        public int Size { get; } // Double / Single
+
+        public new static OpCode Create(InstDescriptor inst, ulong address, int opCode) => new OpCode32SimdCvtTB(inst, address, opCode, false);
+        public static OpCode CreateT32(InstDescriptor inst, ulong address, int opCode) => new OpCode32SimdCvtTB(inst, address, opCode, true);
+
+        public OpCode32SimdCvtTB(InstDescriptor inst, ulong address, int opCode, bool isThumb) : base(inst, address, opCode)
+        {
+            IsThumb = isThumb;
+
+            Op   = ((opCode >> 16) & 0x1) != 0;
+            T    = ((opCode >> 7) & 0x1) != 0;
+            Size = ((opCode >> 8) & 0x1);
+
+            RegisterSize = Size == 1 ? RegisterSize.Int64 : RegisterSize.Int32;
+
+            if (Size == 1)
+            {
+                if (Op)
+                {
+                    Vm = ((opCode >> 1) & 0x10) | ((opCode >> 0) & 0xf);
+                    Vd = ((opCode >> 22) & 0x1) | ((opCode >> 11) & 0x1e);
+                }
+                else
+                {
+                    Vm = ((opCode >> 5) & 0x1) | ((opCode << 1) & 0x1e);
+                    Vd = ((opCode >> 18) & 0x10) | ((opCode >> 12) & 0xf);
+                }
+            }
+            else
+            {
+                Vm = ((opCode >> 5) & 0x1) | ((opCode << 1) & 0x1e);
+                Vd = ((opCode >> 22) & 0x1) | ((opCode >> 11) & 0x1e);
+            }
+        }
+    }
+}

ARMeilleure/Decoders/OpCodeTable.cs

@@ -828,6 +828,7 @@ namespace ARMeilleure.Decoders
             SetVfp("<<<<11101x11110xxxxx101x11x0xxxx", InstName.Vcvt,   InstEmit32.Vcvt_FI,  OpCode32SimdCvtFI.Create,       OpCode32SimdCvtFI.CreateT32); // FP32 to int.
             SetVfp("<<<<11101x111000xxxx101xx1x0xxxx", InstName.Vcvt,   InstEmit32.Vcvt_FI,  OpCode32SimdCvtFI.Create,       OpCode32SimdCvtFI.CreateT32); // Int to FP32.
             SetVfp("111111101x1111xxxxxx101xx1x0xxxx", InstName.Vcvt,   InstEmit32.Vcvt_RM,  OpCode32SimdCvtFI.Create,       OpCode32SimdCvtFI.CreateT32); // The many FP32 to int encodings (fp).
+            SetVfp("<<<<11101x11001xxxxx101xx1x0xxxx", InstName.Vcvt,   InstEmit32.Vcvt_TB,  OpCode32SimdCvtTB.Create,       OpCode32SimdCvtTB.CreateT32);
             SetVfp("<<<<11101x00xxxxxxxx101xx0x0xxxx", InstName.Vdiv,   InstEmit32.Vdiv_S,   OpCode32SimdRegS.Create,        OpCode32SimdRegS.CreateT32);
             SetVfp("<<<<11101xx0xxxxxxxx1011x0x10000", InstName.Vdup,   InstEmit32.Vdup,     OpCode32SimdDupGP.Create,       OpCode32SimdDupGP.CreateT32);
             SetVfp("<<<<11101x10xxxxxxxx101xx0x0xxxx", InstName.Vfma,   InstEmit32.Vfma_S,   OpCode32SimdRegS.Create,        OpCode32SimdRegS.CreateT32);

ARMeilleure/Diagnostics/TranslatorEventSource.cs

@@ -25,13 +25,13 @@ namespace ARMeilleure.Diagnostics
             _funcTabSizeCounter = new PollingCounter("addr-tab-alloc", this, () => _funcTabSize / 1024d / 1024d)
             {
                 DisplayName = "AddressTable Total Bytes Allocated",
-                DisplayUnits = "MB"
+                DisplayUnits = "MiB"
             };
 
             _funcTabLeafSizeCounter = new PollingCounter("addr-tab-leaf-alloc", this, () => _funcTabLeafSize / 1024d / 1024d)
             {
                 DisplayName = "AddressTable Total Leaf Bytes Allocated",
-                DisplayUnits = "MB"
+                DisplayUnits = "MiB"
             };
         }
 

ARMeilleure/Instructions/InstEmitSimdArithmetic.cs

@@ -1617,18 +1617,32 @@ namespace ARMeilleure.Instructions
 
         public static void Frinta_S(ArmEmitterContext context)
         {
-            EmitScalarUnaryOpF(context, (op1) =>
+            if (Optimizations.UseSse41)
             {
-                return EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1);
-            });
+                EmitSse41ScalarRoundOpF(context, FPRoundingMode.ToNearestAway);
+            }
+            else
+            {
+                EmitScalarUnaryOpF(context, (op1) =>
+                {
+                    return EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1);
+                });
+            }
         }
 
         public static void Frinta_V(ArmEmitterContext context)
         {
-            EmitVectorUnaryOpF(context, (op1) =>
+            if (Optimizations.UseSse41)
             {
-                return EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1);
-            });
+                EmitSse41VectorRoundOpF(context, FPRoundingMode.ToNearestAway);
+            }
+            else
+            {
+                EmitVectorUnaryOpF(context, (op1) =>
+                {
+                    return EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1);
+                });
+            }
         }
 
         public static void Frinti_S(ArmEmitterContext context)
@@ -3516,9 +3530,18 @@ namespace ARMeilleure.Instructions
 
             Operand n = GetVec(op.Rn);
 
-            Intrinsic inst = (op.Size & 1) != 0 ? Intrinsic.X86Roundsd : Intrinsic.X86Roundss;
+            Operand res;
 
-            Operand res = context.AddIntrinsic(inst, n, Const(X86GetRoundControl(roundMode)));
+            if (roundMode != FPRoundingMode.ToNearestAway)
+            {
+                Intrinsic inst = (op.Size & 1) != 0 ? Intrinsic.X86Roundsd : Intrinsic.X86Roundss;
+
+                res = context.AddIntrinsic(inst, n, Const(X86GetRoundControl(roundMode)));
+            }
+            else
+            {
+                res = EmitSse41RoundToNearestWithTiesToAwayOpF(context, n, scalar: true);
+            }
 
             if ((op.Size & 1) != 0)
             {
@@ -3538,9 +3561,18 @@ namespace ARMeilleure.Instructions
 
             Operand n = GetVec(op.Rn);
 
-            Intrinsic inst = (op.Size & 1) != 0 ? Intrinsic.X86Roundpd : Intrinsic.X86Roundps;
+            Operand res;
 
-            Operand res = context.AddIntrinsic(inst, n, Const(X86GetRoundControl(roundMode)));
+            if (roundMode != FPRoundingMode.ToNearestAway)
+            {
+                Intrinsic inst = (op.Size & 1) != 0 ? Intrinsic.X86Roundpd : Intrinsic.X86Roundps;
+
+                res = context.AddIntrinsic(inst, n, Const(X86GetRoundControl(roundMode)));
+            }
+            else
+            {
+                res = EmitSse41RoundToNearestWithTiesToAwayOpF(context, n, scalar: false);
+            }
 
             if (op.RegisterSize == RegisterSize.Simd64)
             {

ARMeilleure/Instructions/InstEmitSimdCvt.cs

@@ -164,32 +164,74 @@ namespace ARMeilleure.Instructions
 
         public static void Fcvtas_Gp(ArmEmitterContext context)
         {
-            EmitFcvt_s_Gp(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1));
+            if (Optimizations.UseSse41)
+            {
+                EmitSse41Fcvts_Gp(context, FPRoundingMode.ToNearestAway, isFixed: false);
+            }
+            else
+            {
+                EmitFcvt_s_Gp(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1));
+            }
         }
 
         public static void Fcvtas_S(ArmEmitterContext context)
         {
-            EmitFcvt(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1), signed: true, scalar: true);
+            if (Optimizations.UseSse41)
+            {
+                EmitSse41FcvtsOpF(context, FPRoundingMode.ToNearestAway, scalar: true);
+            }
+            else
+            {
+                EmitFcvt(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1), signed: true, scalar: true);
+            }
         }
 
         public static void Fcvtas_V(ArmEmitterContext context)
         {
-            EmitFcvt(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1), signed: true, scalar: false);
+            if (Optimizations.UseSse41)
+            {
+                EmitSse41FcvtsOpF(context, FPRoundingMode.ToNearestAway, scalar: false);
+            }
+            else
+            {
+                EmitFcvt(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1), signed: true, scalar: false);
+            }
         }
 
         public static void Fcvtau_Gp(ArmEmitterContext context)
         {
-            EmitFcvt_u_Gp(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1));
+            if (Optimizations.UseSse41)
+            {
+                EmitSse41Fcvtu_Gp(context, FPRoundingMode.ToNearestAway, isFixed: false);
+            }
+            else
+            {
+                EmitFcvt_u_Gp(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1));
+            }
         }
 
         public static void Fcvtau_S(ArmEmitterContext context)
         {
-            EmitFcvt(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1), signed: false, scalar: true);
+            if (Optimizations.UseSse41)
+            {
+                EmitSse41FcvtuOpF(context, FPRoundingMode.ToNearestAway, scalar: true);
+            }
+            else
+            {
+                EmitFcvt(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1), signed: false, scalar: true);
+            }
         }
 
         public static void Fcvtau_V(ArmEmitterContext context)
         {
-            EmitFcvt(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1), signed: false, scalar: false);
+            if (Optimizations.UseSse41)
+            {
+                EmitSse41FcvtuOpF(context, FPRoundingMode.ToNearestAway, scalar: false);
+            }
+            else
+            {
+                EmitFcvt(context, (op1) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, op1), signed: false, scalar: false);
+            }
         }
 
         public static void Fcvtl_V(ArmEmitterContext context)
@@ -1223,7 +1265,14 @@ namespace ARMeilleure.Instructions
                     nRes = context.AddIntrinsic(Intrinsic.X86Mulps, nRes, fpScaledMask);
                 }
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundps, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundps, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar);
+                }
 
                 Operand nInt = context.AddIntrinsic(Intrinsic.X86Cvtps2dq, nRes);
 
@@ -1265,7 +1314,14 @@ namespace ARMeilleure.Instructions
                     nRes = context.AddIntrinsic(Intrinsic.X86Mulpd, nRes, fpScaledMask);
                 }
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundpd, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundpd, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar);
+                }
 
                 Operand nLong = EmitSse2CvtDoubleToInt64OpF(context, nRes, scalar);
 
@@ -1314,7 +1370,14 @@ namespace ARMeilleure.Instructions
                     nRes = context.AddIntrinsic(Intrinsic.X86Mulps, nRes, fpScaledMask);
                 }
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundps, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundps, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar);
+                }
 
                 Operand zero = context.VectorZero();
 
@@ -1369,7 +1432,14 @@ namespace ARMeilleure.Instructions
                     nRes = context.AddIntrinsic(Intrinsic.X86Mulpd, nRes, fpScaledMask);
                 }
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundpd, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundpd, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar);
+                }
 
                 Operand zero = context.VectorZero();
 
@@ -1424,7 +1494,14 @@ namespace ARMeilleure.Instructions
                     nRes = context.AddIntrinsic(Intrinsic.X86Mulss, nRes, fpScaledMask);
                 }
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundss, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundss, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar: true);
+                }
 
                 Operand nIntOrLong = op.RegisterSize == RegisterSize.Int32
                     ? context.AddIntrinsicInt (Intrinsic.X86Cvtss2si, nRes)
@@ -1464,7 +1541,14 @@ namespace ARMeilleure.Instructions
                     nRes = context.AddIntrinsic(Intrinsic.X86Mulsd, nRes, fpScaledMask);
                 }
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundsd, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundsd, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar: true);
+                }
 
                 Operand nIntOrLong = op.RegisterSize == RegisterSize.Int32
                     ? context.AddIntrinsicInt (Intrinsic.X86Cvtsd2si, nRes)
@@ -1512,7 +1596,14 @@ namespace ARMeilleure.Instructions
                     nRes = context.AddIntrinsic(Intrinsic.X86Mulss, nRes, fpScaledMask);
                 }
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundss, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundss, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar: true);
+                }
 
                 Operand zero = context.VectorZero();
 
@@ -1567,7 +1658,14 @@ namespace ARMeilleure.Instructions
                     nRes = context.AddIntrinsic(Intrinsic.X86Mulsd, nRes, fpScaledMask);
                 }
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundsd, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundsd, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar: true);
+                }
 
                 Operand zero = context.VectorZero();
 

ARMeilleure/Instructions/InstEmitSimdCvt32.cs

@@ -203,6 +203,9 @@ namespace ARMeilleure.Instructions
             FPRoundingMode roundMode;
             switch (rm)
             {
+                case 0b00:
+                    roundMode = FPRoundingMode.ToNearestAway;
+                    break;
                 case 0b01:
                     roundMode = FPRoundingMode.ToNearest;
                     break;
@@ -228,7 +231,7 @@ namespace ARMeilleure.Instructions
             bool unsigned = op.Opc == 0;
             int rm = op.Opc2 & 3;
 
-            if (Optimizations.UseSse41 && rm != 0b00)
+            if (Optimizations.UseSse41)
             {
                 EmitSse41ConvertInt32(context, RMToRoundMode(rm), !unsigned);
             }
@@ -258,6 +261,74 @@ namespace ARMeilleure.Instructions
             }
         }
 
+        public static void Vcvt_TB(ArmEmitterContext context)
+        {
+            OpCode32SimdCvtTB op = (OpCode32SimdCvtTB)context.CurrOp;
+
+            if (Optimizations.UseF16c)
+            {
+                Debug.Assert(!Optimizations.ForceLegacySse);
+
+                if (op.Op)
+                {
+                    Operand res = ExtractScalar(context, op.Size == 1 ? OperandType.FP64 : OperandType.FP32, op.Vm);
+                    if (op.Size == 1)
+                    {
+                        res = context.AddIntrinsic(Intrinsic.X86Cvtsd2ss, context.VectorZero(), res);
+                    }
+                    res = context.AddIntrinsic(Intrinsic.X86Vcvtps2ph, res, Const(X86GetRoundControl(FPRoundingMode.ToNearest)));
+                    res = context.VectorExtract16(res, 0);
+                    InsertScalar16(context, op.Vd, op.T, res);
+                }
+                else
+                {
+                    Operand res = context.VectorCreateScalar(ExtractScalar16(context, op.Vm, op.T));
+                    res = context.AddIntrinsic(Intrinsic.X86Vcvtph2ps, res);
+                    if (op.Size == 1)
+                    {
+                        res = context.AddIntrinsic(Intrinsic.X86Cvtss2sd, context.VectorZero(), res);
+                    }
+                    res = context.VectorExtract(op.Size == 1 ? OperandType.I64 : OperandType.I32, res, 0);
+                    InsertScalar(context, op.Vd, res);
+                }
+            }
+            else
+            {
+                if (op.Op)
+                {
+                    // Convert to half.
+
+                    Operand src = ExtractScalar(context, op.Size == 1 ? OperandType.FP64 : OperandType.FP32, op.Vm);
+
+                    MethodInfo method = op.Size == 1
+                        ? typeof(SoftFloat64_16).GetMethod(nameof(SoftFloat64_16.FPConvert))
+                        : typeof(SoftFloat32_16).GetMethod(nameof(SoftFloat32_16.FPConvert));
+
+                    context.StoreToContext();
+                    Operand res = context.Call(method, src);
+                    context.LoadFromContext();
+
+                    InsertScalar16(context, op.Vd, op.T, res);
+                }
+                else
+                {
+                    // Convert from half.
+
+                    Operand src = ExtractScalar16(context, op.Vm, op.T);
+
+                    MethodInfo method = op.Size == 1
+                        ? typeof(SoftFloat16_64).GetMethod(nameof(SoftFloat16_64.FPConvert))
+                        : typeof(SoftFloat16_32).GetMethod(nameof(SoftFloat16_32.FPConvert));
+
+                    context.StoreToContext();
+                    Operand res = context.Call(method, src);
+                    context.LoadFromContext();
+
+                    InsertScalar(context, op.Vd, res);
+                }
+            }
+        }
+
         // VRINTA/M/N/P (floating-point).
         public static void Vrint_RM(ArmEmitterContext context)
         {
@@ -267,15 +338,21 @@ namespace ARMeilleure.Instructions
 
             int rm = op.Opc2 & 3;
 
-            if (Optimizations.UseSse2 && rm != 0b00)
+            if (Optimizations.UseSse41)
             {
                 EmitScalarUnaryOpSimd32(context, (m) =>
                 {
-                    Intrinsic inst = (op.Size & 1) == 0 ? Intrinsic.X86Roundss : Intrinsic.X86Roundsd;
-
                     FPRoundingMode roundMode = RMToRoundMode(rm);
 
-                    return context.AddIntrinsic(inst, m, Const(X86GetRoundControl(roundMode)));
+                    if (roundMode != FPRoundingMode.ToNearestAway)
+                    {
+                        Intrinsic inst = (op.Size & 1) == 0 ? Intrinsic.X86Roundss : Intrinsic.X86Roundsd;
+                        return context.AddIntrinsic(inst, m, Const(X86GetRoundControl(roundMode)));
+                    }
+                    else
+                    {
+                        return EmitSse41RoundToNearestWithTiesToAwayOpF(context, m, scalar: true);
+                    }
                 });
             }
             else
@@ -305,7 +382,17 @@ namespace ARMeilleure.Instructions
         // VRINTA (vector).
         public static void Vrinta_V(ArmEmitterContext context)
         {
-            EmitVectorUnaryOpF32(context, (m) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, m));
+            if (Optimizations.UseSse41)
+            {
+                EmitVectorUnaryOpSimd32(context, (m) =>
+                {
+                    return EmitSse41RoundToNearestWithTiesToAwayOpF(context, m, scalar: false);
+                });
+            }
+            else
+            {
+                EmitVectorUnaryOpF32(context, (m) => EmitRoundMathCall(context, MidpointRounding.AwayFromZero, m));
+            }
         }
 
         // VRINTM (vector).
@@ -413,7 +500,14 @@ namespace ARMeilleure.Instructions
                 Operand nRes = context.AddIntrinsic(Intrinsic.X86Cmpss, n, n, Const((int)CmpCondition.OrderedQ));
                 nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, n);
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundss, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundss, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar: true);
+                }
 
                 Operand zero = context.VectorZero();
 
@@ -464,7 +558,14 @@ namespace ARMeilleure.Instructions
                 Operand nRes = context.AddIntrinsic(Intrinsic.X86Cmpsd, n, n, Const((int)CmpCondition.OrderedQ));
                 nRes = context.AddIntrinsic(Intrinsic.X86Pand, nRes, n);
 
-                nRes = context.AddIntrinsic(Intrinsic.X86Roundsd, nRes, Const(X86GetRoundControl(roundMode)));
+                if (roundMode != FPRoundingMode.ToNearestAway)
+                {
+                    nRes = context.AddIntrinsic(Intrinsic.X86Roundsd, nRes, Const(X86GetRoundControl(roundMode)));
+                }
+                else
+                {
+                    nRes = EmitSse41RoundToNearestWithTiesToAwayOpF(context, nRes, scalar: true);
+                }
 
                 Operand zero = context.VectorZero();
 

ARMeilleure/Instructions/InstEmitSimdHelper.cs

@@ -33,6 +33,14 @@ namespace ARMeilleure.Instructions
         };
 
         public static readonly long ZeroMask = 128L << 56 | 128L << 48 | 128L << 40 | 128L << 32 | 128L << 24 | 128L << 16 | 128L << 8 | 128L << 0;
+
+        public static ulong X86GetGf2p8LogicalShiftLeft(int shift)
+        {
+            ulong identity = (0b00000001UL << 56) | (0b00000010UL << 48) | (0b00000100UL << 40) | (0b00001000UL << 32) |
+                             (0b00010000UL << 24) | (0b00100000UL << 16) | (0b01000000UL <<  8) | (0b10000000UL <<  0);
+
+            return shift >= 0 ? identity >> (shift * 8) : identity << (-shift * 8);
+        }
 #endregion
 
 #region "X86 SSE Intrinsics"
@@ -243,19 +251,44 @@ namespace ARMeilleure.Instructions
             throw new ArgumentException($"Invalid rounding mode \"{roundMode}\".");
         }
 
-        public static ulong X86GetGf2p8LogicalShiftLeft(int shift)
+        public static Operand EmitSse41RoundToNearestWithTiesToAwayOpF(ArmEmitterContext context, Operand n, bool scalar)
         {
-            ulong identity = 
-                (0b00000001UL << 56) |
-                (0b00000010UL << 48) |
-                (0b00000100UL << 40) |
-                (0b00001000UL << 32) |
-                (0b00010000UL << 24) |
-                (0b00100000UL << 16) |
-                (0b01000000UL <<  8) |
-                (0b10000000UL <<  0);
+            Debug.Assert(n.Type == OperandType.V128);
 
-            return shift >= 0 ? identity >> (shift * 8) : identity << (-shift * 8);
+            Operand nCopy = context.Copy(n);
+
+            Operand rC = Const(X86GetRoundControl(FPRoundingMode.TowardsZero));
+
+            IOpCodeSimd op = (IOpCodeSimd)context.CurrOp;
+
+            if ((op.Size & 1) == 0)
+            {
+                Operand signMask = scalar ? X86GetScalar(context, int.MinValue) : X86GetAllElements(context, int.MinValue);
+                        signMask = context.AddIntrinsic(Intrinsic.X86Pand, signMask, nCopy);
+
+                // 0x3EFFFFFF == BitConverter.SingleToInt32Bits(0.5f) - 1
+                Operand valueMask = scalar ? X86GetScalar(context, 0x3EFFFFFF) : X86GetAllElements(context, 0x3EFFFFFF);
+                        valueMask = context.AddIntrinsic(Intrinsic.X86Por, valueMask, signMask);
+
+                nCopy = context.AddIntrinsic(scalar ? Intrinsic.X86Addss : Intrinsic.X86Addps, nCopy, valueMask);
+
+                nCopy = context.AddIntrinsic(scalar ? Intrinsic.X86Roundss : Intrinsic.X86Roundps, nCopy, rC);
+            }
+            else
+            {
+                Operand signMask = scalar ? X86GetScalar(context, long.MinValue) : X86GetAllElements(context, long.MinValue);
+                        signMask = context.AddIntrinsic(Intrinsic.X86Pand, signMask, nCopy);
+
+                // 0x3FDFFFFFFFFFFFFFL == BitConverter.DoubleToInt64Bits(0.5d) - 1L
+                Operand valueMask = scalar ? X86GetScalar(context, 0x3FDFFFFFFFFFFFFFL) : X86GetAllElements(context, 0x3FDFFFFFFFFFFFFFL);
+                        valueMask = context.AddIntrinsic(Intrinsic.X86Por, valueMask, signMask);
+
+                nCopy = context.AddIntrinsic(scalar ? Intrinsic.X86Addsd : Intrinsic.X86Addpd, nCopy, valueMask);
+
+                nCopy = context.AddIntrinsic(scalar ? Intrinsic.X86Roundsd : Intrinsic.X86Roundpd, nCopy, rC);
+            }
+
+            return nCopy;
         }
 
         public static Operand EmitCountSetBits8(ArmEmitterContext context, Operand op) // "size" is 8 (SIMD&FP Inst.).

ARMeilleure/Instructions/InstEmitSimdHelper32.cs

@@ -70,6 +70,22 @@ namespace ARMeilleure.Instructions
             context.Copy(vec, insert);
         }
 
+        public static Operand ExtractScalar16(ArmEmitterContext context, int reg, bool top)
+        {
+            return context.VectorExtract16(GetVecA32(reg >> 2), ((reg & 3) << 1) | (top ? 1 : 0));
+        }
+
+        public static void InsertScalar16(ArmEmitterContext context, int reg, bool top, Operand value)
+        {
+            Debug.Assert(value.Type == OperandType.FP32 || value.Type == OperandType.I32);
+
+            Operand vec, insert;
+            vec = GetVecA32(reg >> 2);
+            insert = context.VectorInsert16(vec, value, ((reg & 3) << 1) | (top ? 1 : 0));
+
+            context.Copy(vec, insert);
+        }
+
         public static Operand ExtractElement(ArmEmitterContext context, int reg, int size, bool signed)
         {
             return EmitVectorExtract32(context, reg >> (4 - size), reg & ((16 >> size) - 1), size, signed);

ARMeilleure/State/FPRoundingMode.cs

@@ -2,9 +2,10 @@ namespace ARMeilleure.State
 {
     public enum FPRoundingMode
     {
-        ToNearest            = 0,
+        ToNearest            = 0, // With ties to even.
         TowardsPlusInfinity  = 1,
         TowardsMinusInfinity = 2,
-        TowardsZero          = 3
+        TowardsZero          = 3,
+        ToNearestAway        = 4 // With ties to away.
     }
 }

ARMeilleure/Translation/PTC/Ptc.cs

@@ -27,7 +27,7 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 3710; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 3713; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";

ARMeilleure/Translation/Translator.cs

@@ -455,13 +455,16 @@ namespace ARMeilleure.Translation
 
         public void InvalidateJitCacheRegion(ulong address, ulong size)
         {
-            // If rejit is running, stop it as it may be trying to rejit a function on the invalidated region.
-            ClearRejitQueue(allowRequeue: true);
-
             ulong[] overlapAddresses = Array.Empty<ulong>();
 
             int overlapsCount = Functions.GetOverlaps(address, size, ref overlapAddresses);
 
+            if (overlapsCount != 0)
+            {
+                // If rejit is running, stop it as it may be trying to rejit a function on the invalidated region.
+                ClearRejitQueue(allowRequeue: true);
+            }
+
             for (int index = 0; index < overlapsCount; index++)
             {
                 ulong overlapAddress = overlapAddresses[index];

README.md

@@ -36,12 +36,12 @@
 
 ## Compatibility
 
-As of September 2022, Ryujinx has been tested on approximately 3,600 titles; over 3,400 boot past menus and into gameplay, with roughly 2,700 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!
+As of October 2022, Ryujinx has been tested on approximately 3,700 titles; over 3,500 boot past menus and into gameplay, with roughly 3,000 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
 
-To run this emulator, your PC must be equipped with at least 8GB of RAM; failing to meet this requirement may result in a poor gameplay experience or unexpected crashes.
+To run this emulator, your PC must be equipped with at least 8GiB of RAM; failing to meet this requirement may result in a poor gameplay experience or unexpected crashes.
 
 See our [Setup & Configuration Guide](https://github.com/Ryujinx/Ryujinx/wiki/Ryujinx-Setup-&-Configuration-Guide) on how to set up the emulator.
 
@@ -62,7 +62,7 @@ The latest automatic build for Windows, macOS, and Linux can be found on the [Of
 If you wish to build the emulator yourself, follow these steps:
 
 ### Step 1
-Install the X64 version of [.NET 6.0 (or higher) SDK](https://dotnet.microsoft.com/download/dotnet/6.0).
+Install the X64 version of [.NET 7.0 (or higher) SDK](https://dotnet.microsoft.com/download/dotnet/7.0).
 
 ### Step 2
 Either use `git clone https://github.com/Ryujinx/Ryujinx` on the command line to clone the repository or use Code --> Download zip button to get the files.
@@ -90,7 +90,7 @@ Ryujinx system files are stored in the `Ryujinx` folder. This folder is located
 
 - **GPU**
 
-  The GPU emulator emulates the Switch's Maxwell GPU using the OpenGL API (version 4.5 minimum) through a custom build of OpenTK. There are currently four graphics enhancements available to the end user in Ryujinx: disk shader caching, resolution scaling, aspect ratio adjustment and anisotropic filtering. These enhancements can be adjusted or toggled as desired in the GUI.
+  The GPU emulator emulates the Switch's Maxwell GPU using either the OpenGL (version 4.5 minimum) or Vulkan APIs through a custom build of OpenTK or Silk.NET respectively. There are currently four graphics enhancements available to the end user in Ryujinx: Disk Shader Caching, Resolution Scaling, Aspect Ratio Adjustment, and Anisotropic Filtering. These enhancements can be adjusted or toggled as desired in the GUI.
 
 - **Input**
 

Ryujinx.Audio.Backends.OpenAL/Ryujinx.Audio.Backends.OpenAL.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

Ryujinx.Audio.Backends.SDL2/Ryujinx.Audio.Backends.SDL2.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 

Ryujinx.Audio.Backends.SoundIo/Ryujinx.Audio.Backends.SoundIo.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <RuntimeIdentifiers>win10-x64;linux-x64;osx-x64</RuntimeIdentifiers>
   </PropertyGroup>

Ryujinx.Audio/Renderer/Server/Splitter/SplitterContext.cs

@@ -150,7 +150,7 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// </summary>
         /// <param name="inputHeader">The splitter header.</param>
         /// <param name="input">The raw data after the splitter header.</param>
-        private void UpdateState(ref SplitterInParameterHeader inputHeader, ref ReadOnlySpan<byte> input)
+        private void UpdateState(scoped ref SplitterInParameterHeader inputHeader, ref ReadOnlySpan<byte> input)
         {
             for (int i = 0; i < inputHeader.SplitterCount; i++)
             {
@@ -177,7 +177,7 @@ namespace Ryujinx.Audio.Renderer.Server.Splitter
         /// </summary>
         /// <param name="inputHeader">The splitter header.</param>
         /// <param name="input">The raw data after the splitter header.</param>
-        private void UpdateData(ref SplitterInParameterHeader inputHeader, ref ReadOnlySpan<byte> input)
+        private void UpdateData(scoped ref SplitterInParameterHeader inputHeader, ref ReadOnlySpan<byte> input)
         {
             for (int i = 0; i < inputHeader.SplitterDestinationCount; i++)
             {

Ryujinx.Audio/Renderer/Utils/FileHardwareDevice.cs

@@ -34,10 +34,10 @@ namespace Ryujinx.Audio.Renderer.Utils
 
             writer.Seek(0, SeekOrigin.Begin);
 
-            writer.Write(Encoding.ASCII.GetBytes("RIFF"));
+            writer.Write("RIFF"u8);
             writer.Write((int)(writer.BaseStream.Length - 8));
-            writer.Write(Encoding.ASCII.GetBytes("WAVE"));
-            writer.Write(Encoding.ASCII.GetBytes("fmt "));
+            writer.Write("WAVE"u8);
+            writer.Write("fmt "u8);
             writer.Write(16);
             writer.Write((short)1);
             writer.Write((short)GetChannelCount());
@@ -45,7 +45,7 @@ namespace Ryujinx.Audio.Renderer.Utils
             writer.Write(GetSampleRate() * GetChannelCount() * sizeof(short));
             writer.Write((short)(GetChannelCount() * sizeof(short)));
             writer.Write((short)(sizeof(short) * 8));
-            writer.Write(Encoding.ASCII.GetBytes("data"));
+            writer.Write("data"u8);
             writer.Write((int)(writer.BaseStream.Length - HeaderSize));
 
             writer.Seek((int)currentPos, SeekOrigin.Begin);

Ryujinx.Audio/Ryujinx.Audio.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 

Ryujinx.Ava/App.axaml.cs

@@ -10,6 +10,7 @@ using Ryujinx.Ava.Ui.Windows;
 using Ryujinx.Common;
 using Ryujinx.Common.Logging;
 using Ryujinx.Ui.Common.Configuration;
+using Ryujinx.Ui.Common.Helper;
 using System;
 using System.Diagnostics;
 using System.IO;
@@ -64,8 +65,7 @@ namespace Ryujinx.Ava
                     if (result == UserResult.Yes)
                     {
                         var path = Process.GetCurrentProcess().MainModule.FileName;
-                        var info = new ProcessStartInfo() { FileName = path, UseShellExecute = false };
-                        var proc = Process.Start(info);
+                        var proc = Process.Start(path, CommandLineState.Arguments);
                         desktop.Shutdown();
                         Environment.Exit(0);
                     }

Ryujinx.Ava/AppHost.cs

@@ -58,6 +58,8 @@ namespace Ryujinx.Ava
         private const float MaxResolutionScale = 4.0f; // Max resolution hotkeys can scale to before wrapping.
         private const int TargetFps = 60;
 
+        private const float VolumeDelta = 0.05f;
+
         private static readonly Cursor InvisibleCursor = new Cursor(StandardCursorType.None);        
 
         private readonly long _ticksPerFrame;
@@ -73,6 +75,7 @@ namespace Ryujinx.Ava
         private bool _isStopped;
         private bool _isActive;
         private long _lastCursorMoveTime;
+        private float _newVolume;
         private long _ticks = 0;
 
         private KeyboardHotkeyState _prevHotkeyState;
@@ -738,7 +741,7 @@ namespace Ryujinx.Ava
                 }
             }
 
-            var memoryConfiguration = ConfigurationState.Instance.System.ExpandRam.Value ? HLE.MemoryConfiguration.MemoryConfiguration6GB : HLE.MemoryConfiguration.MemoryConfiguration4GB;
+            var memoryConfiguration = ConfigurationState.Instance.System.ExpandRam.Value ? HLE.MemoryConfiguration.MemoryConfiguration6GiB : HLE.MemoryConfiguration.MemoryConfiguration4GiB;
 
             IntegrityCheckLevel fsIntegrityCheckLevel = ConfigurationState.Instance.System.EnableFsIntegrityChecks ? IntegrityCheckLevel.ErrorOnInvalid : IntegrityCheckLevel.None;
 
@@ -1003,6 +1006,18 @@ namespace Ryujinx.Ava
                             GraphicsConfig.ResScale =
                             (MaxResolutionScale + GraphicsConfig.ResScale - 2) % MaxResolutionScale + 1;
                             break;
+                        case KeyboardHotkeyState.VolumeUp:
+                            _newVolume = MathF.Round((Device.GetVolume() + VolumeDelta), 2);
+                            Device.SetVolume(_newVolume);
+
+                            _parent.ViewModel.Volume = Device.GetVolume();
+                            break;
+                        case KeyboardHotkeyState.VolumeDown:
+                            _newVolume = MathF.Round((Device.GetVolume() - VolumeDelta), 2);
+                            Device.SetVolume(_newVolume);
+
+                            _parent.ViewModel.Volume = Device.GetVolume();
+                            break;
                         case KeyboardHotkeyState.None:
                             (_keyboardInterface as AvaloniaKeyboard).Clear();
                             break;
@@ -1068,6 +1083,14 @@ namespace Ryujinx.Ava
             {
                 state = KeyboardHotkeyState.ResScaleDown;
             }
+            else if (_keyboardInterface.IsPressed((Key)ConfigurationState.Instance.Hid.Hotkeys.Value.VolumeUp))
+            {
+                state = KeyboardHotkeyState.VolumeUp;
+            }
+            else if (_keyboardInterface.IsPressed((Key)ConfigurationState.Instance.Hid.Hotkeys.Value.VolumeDown))
+            {
+                state = KeyboardHotkeyState.VolumeDown;
+            }
 
             return state;
         }

Ryujinx.Ava/Assets/Locales/de_DE.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
   "SettingsTabSystemHacksNote": " (Kann Fehler verursachen)",
-  "SettingsTabSystemExpandDramSize": "Erweitere DRAM Größe auf 6GB",
+  "SettingsTabSystemExpandDramSize": "Erweitere DRAM Größe auf 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "Ignoriere fehlende Dienste",
   "SettingsTabGraphics": "Grafik",
   "SettingsTabGraphicsAPI": "Grafik-API",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "Verwendung einer Software-Seitentabelle für die Adressumsetzung. Höchste Genauigkeit, aber langsamste Leistung.",
   "MemoryManagerHostTooltip": "Direkte Zuordnung von Speicher im Host-Adressraum. Viel schnellere JIT-Kompilierung und Ausführung.",
   "MemoryManagerUnsafeTooltip": "Direkte Zuordnung des Speichers, aber keine Maskierung der Adresse innerhalb des Gastadressraums vor dem Zugriff. Schneller, aber auf Kosten der Sicherheit. Die Gastanwendung kann von überall in Ryujinx auf den Speicher zugreifen, daher sollte in diesem Modus nur Programme ausgeführt werden denen vertraut wird.",
-  "DRamTooltip": "Erhöht den Arbeitsspeicher des emulierten Systems von 4 GB auf 6 GB.\n\nDies ist nur für Texturenpakete mit höherer Auflösung oder Mods mit 4K-Auflösung nützlich. Diese Option verbessert NICHT die Leistung.\n\nIm Zweifelsfall AUS lassen.",
+  "DRamTooltip": "Erhöht den Arbeitsspeicher des emulierten Systems von 4 GiB auf 6 GiB.\n\nDies ist nur für Texturenpakete mit höherer Auflösung oder Mods mit 4K-Auflösung nützlich. Diese Option verbessert NICHT die Leistung.\n\nIm Zweifelsfall AUS lassen.",
   "IgnoreMissingServicesTooltip": "Durch diese Option werden nicht implementierte Dienste der Switch-Firmware ignoriert. Dies kann dabei helfen, Abstürze beim Starten bestimmter Spiele zu umgehen.\n\nIm Zweifelsfall AUS lassen.",
   "GraphicsBackendThreadingTooltip": "Führt Grafik-Backend Befehle auf einem zweiten Thread aus.\n\nDies beschleunigt die Shader-Kompilierung, reduziert Stottern und verbessert die Leistung auf GPU-Treibern ohne eigene Multithreading-Unterstützung. Geringfügig bessere Leistung bei Treibern mit Multithreading.\n\nIm Zweifelsfall auf AUTO stellen.",
   "GalThreadingTooltip": "Führt Grafik-Backend Befehle auf einem zweiten Thread aus.\n\nDies Beschleunigt die Shader-Kompilierung, reduziert Stottern und verbessert die Leistung auf GPU-Treibern ohne eigene Multithreading-Unterstützung. Geringfügig bessere Leistung bei Treibern mit Multithreading.\n\nIm Zweifelsfall auf auf AUTO stellen.",
@@ -583,7 +583,7 @@
   "SettingsTabGraphicsBackend": "Grafik-Backend:",
   "SettingsTabGraphicsBackendTooltip": "Verwendendetes Grafik-Backend",
   "SettingsEnableTextureRecompression": "Textur-Rekompression",
-  "SettingsEnableTextureRecompressionTooltip": "Komprimiert bestimmte Texturen, um den VRAM-Verbrauch zu reduzieren.\n\nEmpfohlen für die Verwendung von GPUs, die weniger als 4 GB VRAM haben.\n\nIm Zweifelsfall AUS lassen",
+  "SettingsEnableTextureRecompressionTooltip": "Komprimiert bestimmte Texturen, um den VRAM-Verbrauch zu reduzieren.\n\nEmpfohlen für die Verwendung von GPUs, die weniger als 4 GiB VRAM haben.\n\nIm Zweifelsfall AUS lassen",
   "SettingsTabGraphicsPreferredGpu": "Bevorzugte GPU:",
   "SettingsTabGraphicsPreferredGpuTooltip": "Wähle die Grafikkarte aus, die mit dem Vulkan Grafik-Backend verwendet werden soll.\n\nDies hat keinen Einfluss auf die GPU die OpenGL verwendet.\n\nIm Zweifelsfall die als \"dGPU\" gekennzeichnete GPU auswählen. Diese Einstellung unberührt lassen, wenn keine zur Auswahl steht.",
   "SettingsAppRequiredRestartMessage": "Ein Neustart von Ryujinx ist erforderlich",

Ryujinx.Ava/Assets/Locales/el_GR.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Μικροδιορθώσεις",
   "SettingsTabSystemHacksNote": " (Μπορεί να προκαλέσουν αστάθεια)",
-  "SettingsTabSystemExpandDramSize": "Επέκταση μεγέθους DRAM στα 6GB",
+  "SettingsTabSystemExpandDramSize": "Επέκταση μεγέθους DRAM στα 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "Αγνόηση υπηρεσιών που λείπουν",
   "SettingsTabGraphics": "Γραφικά",
   "SettingsTabGraphicsAPI": "API Γραφικά",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "Χρησιμοποιήστε έναν πίνακα σελίδων λογισμικού για τη μετάφραση διευθύνσεων. Υψηλότερη ακρίβεια αλλά πιο αργή απόδοση.",
   "MemoryManagerHostTooltip": "Απευθείας αντιστοίχιση της μνήμης στον χώρο διευθύνσεων υπολογιστή υποδοχής. Πολύ πιο γρήγορη μεταγλώττιση και εκτέλεση JIT.",
   "MemoryManagerUnsafeTooltip": "Απευθείας χαρτογράφηση της μνήμης, αλλά μην καλύπτετε τη διεύθυνση εντός του χώρου διευθύνσεων επισκέπτη πριν από την πρόσβαση. Πιο γρήγορα, αλλά με κόστος ασφάλειας. Η εφαρμογή μπορεί να έχει πρόσβαση στη μνήμη από οπουδήποτε στο Ryujinx, επομένως εκτελείτε μόνο προγράμματα που εμπιστεύεστε με αυτήν τη λειτουργία.",
-  "DRamTooltip": "Επεκτείνει την ποσότητα της μνήμης στο εξομοιούμενο σύστημα από 4 GB σε 6 GB",
+  "DRamTooltip": "Επεκτείνει την ποσότητα της μνήμης στο εξομοιούμενο σύστημα από 4 GiB σε 6 GiB",
   "IgnoreMissingServicesTooltip": "Ενεργοποίηση ή απενεργοποίηση της αγνοώησης για υπηρεσίες που λείπουν",
   "GraphicsBackendThreadingTooltip": "Ενεργοποίηση Πολυνηματικής Επεξεργασίας Γραφικών",
   "GalThreadingTooltip": "Εκτελεί εντολές γραφικών σε ένα δεύτερο νήμα. Επιτρέπει την πολυνηματική μεταγλώττιση Shader σε χρόνο εκτέλεσης, μειώνει το τρεμόπαιγμα και βελτιώνει την απόδοση των προγραμμάτων οδήγησης χωρίς τη δική τους υποστήριξη πολλαπλών νημάτων. Ποικίλες κορυφαίες επιδόσεις σε προγράμματα οδήγησης με multithreading. Μπορεί να χρειαστεί επανεκκίνηση του Ryujinx για να απενεργοποιήσετε σωστά την ενσωματωμένη λειτουργία πολλαπλών νημάτων του προγράμματος οδήγησης ή ίσως χρειαστεί να το κάνετε χειροκίνητα για να έχετε την καλύτερη απόδοση.",
@@ -480,17 +480,17 @@
   "AudioVolumeTooltip": "Αλλαγή Έντασης Ήχου",
   "SettingsTabSystemEnableInternetAccess": "Ενεργοποίηση πρόσβασης επισκέπτη στο Διαδίκτυο",
   "EnableInternetAccessTooltip": "Επιτρέπει την πρόσβαση επισκέπτη στο Διαδίκτυο. Εάν ενεργοποιηθεί, η εξομοιωμένη κονσόλα Switch θα συμπεριφέρεται σαν να είναι συνδεδεμένη στο Διαδίκτυο. Λάβετε υπόψη ότι σε ορισμένες περιπτώσεις, οι εφαρμογές ενδέχεται να εξακολουθούν να έχουν πρόσβαση στο Διαδίκτυο, ακόμη και όταν αυτή η επιλογή είναι απενεργοποιημένη",
-  "GameListContextMenuManageCheatToolTip" : "Διαχείριση Κόλπων",
-  "GameListContextMenuManageCheat" : "Διαχείριση Κόλπων",
-  "ControllerSettingsStickRange" : "Εύρος:",
-  "DialogStopEmulationTitle" : "Ryujinx - Διακοπή εξομοίωσης",
+  "GameListContextMenuManageCheatToolTip": "Διαχείριση Κόλπων",
+  "GameListContextMenuManageCheat": "Διαχείριση Κόλπων",
+  "ControllerSettingsStickRange": "Εύρος:",
+  "DialogStopEmulationTitle": "Ryujinx - Διακοπή εξομοίωσης",
   "DialogStopEmulationMessage": "Είστε βέβαιοι ότι θέλετε να σταματήσετε την εξομοίωση;",
   "SettingsTabCpu": "Επεξεργαστής",
   "SettingsTabAudio": "Ήχος",
   "SettingsTabNetwork": "Δίκτυο",
-  "SettingsTabNetworkConnection" : "Σύνδεση δικτύου",
-  "SettingsTabCpuCache" : "Προσωρινή Μνήμη CPU",
-  "SettingsTabCpuMemory" : "Μνήμη CPU",
+  "SettingsTabNetworkConnection": "Σύνδεση δικτύου",
+  "SettingsTabCpuCache": "Προσωρινή Μνήμη CPU",
+  "SettingsTabCpuMemory": "Μνήμη CPU",
   "ControllerMotionTitle": "Motion Control Settings",
   "ControllerRumbleTitle": "Rumble Settings"
 }

Ryujinx.Ava/Assets/Locales/en_US.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
   "SettingsTabSystemHacksNote": " (may cause instability)",
-  "SettingsTabSystemExpandDramSize": "Expand DRAM Size to 6GB",
+  "SettingsTabSystemExpandDramSize": "Expand DRAM Size to 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "Ignore Missing Services",
   "SettingsTabGraphics": "Graphics",
   "SettingsTabGraphicsAPI": "Graphics API",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "Use a software page table for address translation. Highest accuracy but slowest performance.",
   "MemoryManagerHostTooltip": "Directly map memory in the host address space. Much faster JIT compilation and execution.",
   "MemoryManagerUnsafeTooltip": "Directly map memory, but do not mask the address within the guest address space before access. Faster, but at the cost of safety. The guest application can access memory from anywhere in Ryujinx, so only run programs you trust with this mode.",
-  "DRamTooltip": "Increases the amount of memory on the emulated system from 4GB to 6GB.\n\nThis is only useful for higher-resolution texture packs or 4k resolution mods. Does NOT improve performance.\n\nLeave OFF if unsure.",
+  "DRamTooltip": "Increases the amount of memory on the emulated system from 4GiB to 6GiB.\n\nThis is only useful for higher-resolution texture packs or 4k resolution mods. Does NOT improve performance.\n\nLeave OFF if unsure.",
   "IgnoreMissingServicesTooltip": "Ignores unimplemented Horizon OS services. This may help in bypassing crashes when booting certain games.\n\nLeave OFF if unsure.",
   "GraphicsBackendThreadingTooltip": "Executes graphics backend commands on a second thread.\n\nSpeeds up shader compilation, reduces stuttering, and improves performance on GPU drivers without multithreading support of their own. Slightly better performance on drivers with multithreading.\n\nSet to AUTO if unsure.",
   "GalThreadingTooltip": "Executes graphics backend commands on a second thread.\n\nSpeeds up shader compilation, reduces stuttering, and improves performance on GPU drivers without multithreading support of their own. Slightly better performance on drivers with multithreading.\n\nSet to AUTO if unsure.",
@@ -574,20 +574,25 @@
   "Discard": "Discard",
   "UserProfilesSetProfileImage": "Set Profile Image",
   "UserProfileEmptyNameError": "Name is required",
-  "UserProfileNoImageError":  "Profile image must be set",
+  "UserProfileNoImageError": "Profile image must be set",
   "GameUpdateWindowHeading": "Updates Available for {0} [{1}]",
   "SettingsTabHotkeysResScaleUpHotkey": "Increase resolution:",
   "SettingsTabHotkeysResScaleDownHotkey": "Decrease resolution:",
   "UserProfilesName": "Name:",
-  "UserProfilesUserId" : "User Id:",
+  "UserProfilesUserId": "User Id:",
   "SettingsTabGraphicsBackend": "Graphics Backend",
   "SettingsTabGraphicsBackendTooltip": "Graphics Backend to use",
   "SettingsEnableTextureRecompression": "Enable Texture Recompression",
-  "SettingsEnableTextureRecompressionTooltip": "Compresses certain textures in order to reduce VRAM usage.\n\nRecommended for use with GPUs that have less than 4GB VRAM.\n\nLeave OFF if unsure.",
+  "SettingsEnableTextureRecompressionTooltip": "Compresses certain textures in order to reduce VRAM usage.\n\nRecommended for use with GPUs that have less than 4GiB VRAM.\n\nLeave OFF if unsure.",
   "SettingsTabGraphicsPreferredGpu": "Preferred GPU",
   "SettingsTabGraphicsPreferredGpuTooltip": "Select the graphics card that will be used with the Vulkan graphics backend.\n\nDoes not affect the GPU that OpenGL will use.\n\nSet to the GPU flagged as \"dGPU\" if unsure. If there isn't one, leave untouched.",
   "SettingsAppRequiredRestartMessage": "Ryujinx Restart Required",
-  "SettingsGpuBackendRestartMessage": "Graphics Backend or Gpu settings have been modified. This will require a restart to be applied",
+  "SettingsGpuBackendRestartMessage": "Graphics Backend or GPU settings have been modified. This will require a restart to be applied",
   "SettingsGpuBackendRestartSubMessage": "Do you want to restart now?",
-  "VolumeShort": "Vol"
+  "RyujinxUpdaterMessage": "Do you want to update Ryujinx to the latest version?",
+  "SettingsTabHotkeysVolumeUpHotkey": "Increase Volume:",
+  "SettingsTabHotkeysVolumeDownHotkey": "Decrease Volume:",
+  "VolumeShort": "Vol",
+  "SettingsEnableMacroHLE": "Enable Macro HLE",
+  "SettingsEnableMacroHLETooltip": "High-level emulation of GPU Macro code.\n\nImproves performance, but may cause graphical glitches in some games.\n\nLeave ON if unsure."
 }

Ryujinx.Ava/Assets/Locales/es_ES.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
   "SettingsTabSystemHacksNote": " (Pueden causar inestabilidad)",
-  "SettingsTabSystemExpandDramSize": "Expandir DRAM a 6GB",
+  "SettingsTabSystemExpandDramSize": "Expandir DRAM a 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "Ignorar servicios no implementados",
   "SettingsTabGraphics": "Gráficos",
   "SettingsTabGraphicsAPI": "API de gráficos",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "Usa una tabla de paginación de software para traducir direcciones. Ofrece la precisión más exacta pero el rendimiento más lento.",
   "MemoryManagerHostTooltip": "Mapea la memoria directamente en la dirección de espacio del host. Compilación y ejecución JIT mucho más rápida.",
   "MemoryManagerUnsafeTooltip": "Mapea la memoria directamente, pero no enmascara la dirección dentro del espacio de dirección del guest antes del acceso. El modo más rápido, pero a costa de seguridad. La aplicación guest puede acceder a la memoria desde cualquier parte en Ryujinx, así que ejecuta solo programas en los que confíes cuando uses este modo.",
-  "DRamTooltip": "Expande la memoria DRAM del sistema emulado de 4GB a 6GB.\n\nUtilizar solo con packs de texturas HD o mods de resolución 4K. NO mejora el rendimiento.\n\nDesactívalo si no sabes qué hacer.",
+  "DRamTooltip": "Expande la memoria DRAM del sistema emulado de 4GiB a 6GiB.\n\nUtilizar solo con packs de texturas HD o mods de resolución 4K. NO mejora el rendimiento.\n\nDesactívalo si no sabes qué hacer.",
   "IgnoreMissingServicesTooltip": "Hack para ignorar servicios no implementados del Horizon OS. Esto puede ayudar a sobrepasar crasheos cuando inicies ciertos juegos.\n\nDesactívalo si no sabes qué hacer.",
   "GraphicsBackendThreadingTooltip": "Ejecuta los comandos del motor gráfico en un segundo hilo. Acelera la compilación de sombreadores, reduce los tirones, y mejora el rendimiento en controladores gráficos que no realicen su propio multihilado. Rendimiento máximo ligeramente superior en controladores gráficos que soporten multihilado.\n\nSelecciona \"Auto\" si no sabes qué hacer.",
   "GalThreadingTooltip": "Ejecuta los comandos del motor gráfico en un segundo hilo. Acelera la compilación de sombreadores, reduce los tirones, y mejora el rendimiento en controladores gráficos que no realicen su propio multihilado. Rendimiento máximo ligeramente superior en controladores gráficos que soporten multihilado.\n\nSelecciona \"Auto\" si no sabes qué hacer.",

Ryujinx.Ava/Assets/Locales/fr_FR.json

@@ -112,7 +112,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
   "SettingsTabSystemHacksNote": " (Cela peut causer des instabilitées)",
-  "SettingsTabSystemExpandDramSize": "Augmenter la taille de la DRAM à 6GB",
+  "SettingsTabSystemExpandDramSize": "Augmenter la taille de la DRAM à 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "Ignorer les services manquant",
   "SettingsTabGraphics": "Graphique",
   "SettingsTabGraphicsAPI": "API Graphique",

Ryujinx.Ava/Assets/Locales/it_IT.json

@@ -49,8 +49,8 @@
     "GameListContextMenuManageTitleUpdatesToolTip": "Apre la finestra di gestione aggiornamenti del gioco",
     "GameListContextMenuManageDlc": "Gestici DLC",
     "GameListContextMenuManageDlcToolTip": "Apre la finestra di gestione DLC",
-    "GameListContextMenuOpenModsDirectory": "Apri cartella delle mods",
-    "GameListContextMenuOpenModsDirectoryToolTip": "Apre la cartella che contiene le mods dell'applicazione",
+    "GameListContextMenuOpenModsDirectory": "Apri cartella delle mod",
+    "GameListContextMenuOpenModsDirectoryToolTip": "Apre la cartella che contiene le mod dell'applicazione",
     "GameListContextMenuCacheManagement": "Gestione della cache",
     "GameListContextMenuCacheManagementPurgePptc": "Pulisci PPTC cache",
     "GameListContextMenuCacheManagementPurgePptcToolTip": "Elimina la PPTC cache dell'applicazione",
@@ -81,7 +81,7 @@
     "SettingsTabGeneralRemove": "Rimuovi",
     "SettingsTabSystem": "Sistema",
     "SettingsTabSystemCore": "Core",
-    "SettingsTabSystemSystemRegion": "Regione di sistema:",
+    "SettingsTabSystemSystemRegion": "Regione del sistema:",
     "SettingsTabSystemSystemRegionJapan": "Giappone",
     "SettingsTabSystemSystemRegionUSA": "Stati Uniti d'America",
     "SettingsTabSystemSystemRegionEurope": "Europa",
@@ -89,7 +89,7 @@
     "SettingsTabSystemSystemRegionChina": "Cina",
     "SettingsTabSystemSystemRegionKorea": "Corea",
     "SettingsTabSystemSystemRegionTaiwan": "Taiwan",
-    "SettingsTabSystemSystemLanguage": "Lingua di sistema:",
+    "SettingsTabSystemSystemLanguage": "Lingua del sistema:",
     "SettingsTabSystemSystemLanguageJapanese": "Giapponese",
     "SettingsTabSystemSystemLanguageAmericanEnglish": "Inglese americano",
     "SettingsTabSystemSystemLanguageFrench": "Francese",
@@ -107,8 +107,8 @@
     "SettingsTabSystemSystemLanguageLatinAmericanSpanish": "Spagnolo latino americano",
     "SettingsTabSystemSystemLanguageSimplifiedChinese": "Cinese semplificato",
     "SettingsTabSystemSystemLanguageTraditionalChinese": "Cinese tradizionale",
-    "SettingsTabSystemSystemTimeZone": "Fuso orario di sistema:",
-    "SettingsTabSystemSystemTime": "Data e ora di sistema:",
+    "SettingsTabSystemSystemTimeZone": "Fuso orario del sistema:",
+    "SettingsTabSystemSystemTime": "Data e ora del sistema:",
     "SettingsTabSystemEnableVsync": "Attiva VSync",
     "SettingsTabSystemEnablePptc": "Attiva PPTC (Profiled Persistent Translation Cache)",
     "SettingsTabSystemEnableFsIntegrityChecks": "Attiva controlli d'integrità FS",
@@ -119,7 +119,7 @@
     "SettingsTabSystemAudioBackendSDL2": "SDL2",
     "SettingsTabSystemHacks": "Hacks",
     "SettingsTabSystemHacksNote": " (Possono causare instabilità)",
-    "SettingsTabSystemExpandDramSize": "Espandi dimensione DRAM a 6GB",
+    "SettingsTabSystemExpandDramSize": "Espandi dimensione DRAM a 6GiB",
     "SettingsTabSystemIgnoreMissingServices": "Ignora servizi mancanti",
     "SettingsTabGraphics": "Grafica",
     "SettingsTabGraphicsAPI": "API Grafiche",
@@ -155,7 +155,7 @@
     "SettingsTabLoggingEnableTraceLogs": "Attiva Trace Logs",
     "SettingsTabLoggingEnableGuestLogs": "Attiva Guest Logs",
     "SettingsTabLoggingEnableFsAccessLogs": "Attiva Fs Access Logs",
-    "SettingsTabLoggingFsGlobalAccessLogMode": "Modalità di log accesso globale Fs:",
+    "SettingsTabLoggingFsGlobalAccessLogMode": "Modalità log accesso globale Fs:",
     "SettingsTabLoggingDeveloperOptions": "Opzioni da sviluppatore (AVVISO: Ridurrà le prestazioni)",
     "SettingsTabLoggingOpenglLogLevel": "Livello di log OpenGL:",
     "SettingsTabLoggingOpenglLogLevelNone": "Nessuno",
@@ -240,7 +240,7 @@
     "ControllerSettingsRightSR": "SR",
     "ControllerSettingsExtraButtonsLeft": "Tasto sinitro",
     "ControllerSettingsExtraButtonsRight": "Tasto destro",
-    "ControllerSettingsMisc": "Miscellanee",
+    "ControllerSettingsMisc": "Varie",
     "ControllerSettingsTriggerThreshold": "Sensibilità dei grilletti:",
     "ControllerSettingsMotion": "Movimento",
     "ControllerSettingsMotionUseCemuhookCompatibleMotion": "Usa sensore compatibile con CemuHook",
@@ -261,7 +261,7 @@
     "UserProfilesClose": "Chiudi",
     "ProfileImageSelectionTitle": "Selezione dell'immagine profilo",
     "ProfileImageSelectionHeader": "Scegli un'immagine profilo",
-    "ProfileImageSelectionNote": "Puoi importare un'immagine profilo personalizzata o selezionare un avatar dal firmware di sistema",
+    "ProfileImageSelectionNote": "Puoi importare un'immagine profilo personalizzata o selezionare un avatar dal firmware del sistema",
     "ProfileImageSelectionImportImage": "Importa file immagine",
     "ProfileImageSelectionSelectAvatar": "Seleziona avatar dal firmware",
     "InputDialogTitle": "Input Dialog",
@@ -293,7 +293,7 @@
     "ControllerSettingsRumbleStrongMultiplier": "Moltiplicatore vibrazione forte",
     "ControllerSettingsRumbleWeakMultiplier": "Moltiplicatore vibrazione debole",
     "DialogMessageSaveNotAvailableMessage": "Non ci sono dati di salvataggio per {0} [{1:x16}]",
-    "DialogMessageSaveNotAvailableCreateSaveMessage": "Vuoi creare dei dat di salvataggio per questo gioco?",
+    "DialogMessageSaveNotAvailableCreateSaveMessage": "Vuoi creare dei dati di salvataggio per questo gioco?",
     "DialogConfirmationTitle": "Ryujinx - Conferma",
     "DialogUpdaterTitle": "Ryujinx - Updater",
     "DialogErrorTitle": "Ryujinx - Errore",
@@ -318,7 +318,7 @@
     "DialogUpdaterDownloadingMessage": "Download dell'aggiornamento...",
     "DialogUpdaterExtractionMessage": "Estrazione dell'aggiornamento...",
     "DialogUpdaterRenamingMessage": "Rinominazione dell'aggiornamento...",
-    "DialogUpdaterAddingFilesMessage": "Aggiunta nuovo aggiornamento...",
+    "DialogUpdaterAddingFilesMessage": "Aggiunta del nuovo aggiornamento...",
     "DialogUpdaterCompleteMessage": "Aggiornamento completato!",
     "DialogUpdaterRestartMessage": "Vuoi riavviare Ryujinx adesso?",
     "DialogUpdaterArchNotSupportedMessage": "Non stai usando un'architettura di sistema supportata!",
@@ -331,7 +331,7 @@
     "DialogThemeRestartMessage": "Il tema è stato salvato. E' richiesto un riavvio per applicare un tema.",
     "DialogThemeRestartSubMessage": "Vuoi riavviare?",
     "DialogFirmwareInstallEmbeddedMessage": "Vuoi installare il firmware incorporato in questo gioco? (Firmware {0})",
-    "DialogFirmwareInstallEmbeddedSuccessMessage": "Non è stato trovato alcun firmware installato, ma Ryujinx è riuscito di installare il firmware {0} dal gioco fornito.\nL'emulatore si avvierà adesso.",
+    "DialogFirmwareInstallEmbeddedSuccessMessage": "Non è stato trovato alcun firmware installato, ma Ryujinx è riuscito ad installare il firmware {0} dal gioco fornito.\nL'emulatore si avvierà adesso.",
     "DialogFirmwareNoFirmwareInstalledMessage": "Nessun firmware installato",
     "DialogFirmwareInstalledMessage": "Il firmware {0} è stato installato",
     "DialogOpenSettingsWindowLabel": "Apri finestra delle impostazioni",
@@ -355,14 +355,14 @@
     "DialogShaderDeletionMessage": "Stai per eliminare la Shader cache per :\n\n{0}\n\nSei sicuro di voler proseguire?",
     "DialogShaderDeletionErrorMessage": "Errore nell'eliminazione della Shader cache a {0}: {1}",
     "DialogRyujinxErrorMessage": "Ryujinx ha incontrato un errore",
-    "DialogInvalidTitleIdErrorMessage": "Errore UI: Il gioco selezionato non ha un title ID valido",
-    "DialogFirmwareInstallerFirmwareNotFoundErrorMessage": "Un firmware di sistema valido non è stato trovato in {0}.",
+    "DialogInvalidTitleIdErrorMessage": "Errore UI: Il gioco selezionato non ha un ID titolo valido",
+    "DialogFirmwareInstallerFirmwareNotFoundErrorMessage": "Un firmware del sistema valido non è stato trovato in {0}.",
     "DialogFirmwareInstallerFirmwareInstallTitle": "Installa firmware {0}",
-    "DialogFirmwareInstallerFirmwareInstallMessage": "La versione di sistema {0} sarà installata.",
+    "DialogFirmwareInstallerFirmwareInstallMessage": "La versione del sistema {0} sarà installata.",
     "DialogFirmwareInstallerFirmwareInstallSubMessage": "\n\nQuesta sostituirà l'attuale versione di sistema {0}.",
     "DialogFirmwareInstallerFirmwareInstallConfirmMessage": "\n\nVuoi continuare?",
     "DialogFirmwareInstallerFirmwareInstallWaitMessage": "Installazione del firmware...",
-    "DialogFirmwareInstallerFirmwareInstallSuccessMessage": "La versione di sistema {0} è stata installata.",
+    "DialogFirmwareInstallerFirmwareInstallSuccessMessage": "La versione del sistema {0} è stata installata.",
     "DialogUserProfileDeletionWarningMessage": "Non ci sarebbero altri profili da aprire se il profilo selezionato viene cancellato",
     "DialogUserProfileDeletionConfirmMessage": "Vuoi eliminare il profilo selezionato?",
     "DialogControllerSettingsModifiedConfirmMessage": "Le attuali impostazioni del controller sono state aggiornate.",
@@ -440,7 +440,7 @@
     "MemoryManagerSoftwareTooltip": "Usa una software page table per la traduzione degli indirizzi. Massima precisione ma prestazioni più lente.",
     "MemoryManagerHostTooltip": "Mappa direttamente la memoria nello spazio degli indirizzi dell'host. Compilazione ed esecuzione JIT molto più veloce.",
     "MemoryManagerUnsafeTooltip": "Mappa direttamente la memoria, ma non maschera l'indirizzo all'interno dello spazio degli indirizzi guest prima dell'accesso. Più veloce, ma a costo della sicurezza. L'applicazione guest può accedere alla memoria da qualsiasi punto di Ryujinx, quindi esegui solo programmi di cui ti fidi con questa modalità.",
-    "DRamTooltip": "Espande l'ammontare di memoria sul sistema emulato da 4GB A 6GB",
+    "DRamTooltip": "Espande l'ammontare di memoria sul sistema emulato da 4GiB A 6GiB",
     "IgnoreMissingServicesTooltip": "Attiva o disattiva l'opzione di ignorare i servizi mancanti",
     "GraphicsBackendThreadingTooltip": "Attiva il Graphics Backend Multithreading",
     "GalThreadingTooltip": "Esegue i comandi del backend grafico su un secondo thread. Permette il multithreading runtime della compilazione degli shader, riduce lo stuttering e migliora le prestazioni sui driver senza supporto multithreading proprio. Varia leggermente le prestazioni di picco sui driver con multithreading. Ryujinx potrebbe aver bisogno di essere riavviato per disabilitare correttamente il multithreading integrato nel driver, o potrebbe essere necessario farlo manualmente per ottenere le migliori prestazioni.",
@@ -557,4 +557,40 @@
     "SettingsXamlThemeFile" : "File del tema xaml",
     "SettingsTabHotkeysResScaleUpHotkey": "Aumentare la risoluzione:",
     "SettingsTabHotkeysResScaleDownHotkey": "Diminuire la risoluzione:"
+    "AvatarWindowTitle": "Gestisci account - Avatar"
+    "Amiibo": "Amiibo",
+    "Unknown": "Sconosciuto",
+    "Usage": "Utilizzo",
+    "Writable": "Scrivibile",
+    "SelectDlcDialogTitle": "Seleziona file dei DLC",
+    "SelectUpdateDialogTitle": "Seleziona file di aggiornamento",
+    "UserProfileWindowTitle": "Gestisci profili degli utenti",
+    "CheatWindowTitle": "Gestisci cheat dei giochi",
+    "DlcWindowTitle": "Gestisci DLC dei giochi",
+    "UpdateWindowTitle": "Gestisci aggiornamenti dei giochi",
+    "CheatWindowHeading": "Cheat disponibiili per {0} [{1}]",
+    "DlcWindowHeading": "DLC disponibili per {0} [{1}]",
+    "UserProfilesEditProfile": "Modifica selezionati",
+    "Cancel": "Annulla",
+    "Save": "Salva",
+    "Discard": "Scarta",
+    "UserProfilesSetProfileImage": "Imposta immagine profilo",
+    "UserProfileEmptyNameError": "È richiesto un nome",
+    "UserProfileNoImageError": "Dev'essere impostata un'immagine profilo",
+    "GameUpdateWindowHeading": "Aggiornamenti disponibili per {0} [{1}]",
+    "UserProfilesName": "Name:",
+    "UserProfilesUserId": "User Id:",
+    "SettingsTabGraphicsBackend": "Backend grafica",
+    "SettingsTabGraphicsBackendTooltip": "Backend grafica da usare",
+    "SettingsEnableTextureRecompression": "Abilita Ricompressione Texture",
+    "SettingsEnableTextureRecompressionTooltip": "Comprime alcune texture per ridurre l'utilizzo della VRAM.\n\nL'utilizzo è consigliato con GPU con meno di 4GB di VRAM.\n\nLascia su OFF se non sei sicuro.",
+    "SettingsTabGraphicsPreferredGpu": "GPU preferita",
+    "SettingsTabGraphicsPreferredGpuTooltip": "Seleziona la scheda grafica che verrà usata con la backend grafica Vulkan.\n\nNon influenza la GPU che userà OpenGL.\n\nImposta la GPU contrassegnata come \"dGPU\" se non sei sicuro. Se non ce n'è una, lascia intatta quest'impostazione.",
+    "SettingsAppRequiredRestartMessage": "È richiesto un riavvio di Ryujinx",
+    "SettingsGpuBackendRestartMessage": "Le impostazioni della backend grafica o della GPU sono state modificate. Questo richiederà un riavvio perché le modifiche siano applicate",
+    "SettingsGpuBackendRestartSubMessage": "Vuoi riavviare ora?",
+    "RyujinxUpdaterMessage": "Vuoi aggiornare Ryujinx all'ultima versione?",
+    "SettingsTabHotkeysVolumeUpHotkey": "Aumentare il volume:",
+    "SettingsTabHotkeysVolumeDownHotkey": "Diminuire il volume:",
+    "VolumeShort": "Vol"
 }

Ryujinx.Ava/Assets/Locales/ja_JP.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "ハック",
   "SettingsTabSystemHacksNote": " (挙動が不安定になる可能性があります)",
-  "SettingsTabSystemExpandDramSize": "DRAMサイズを6GBに拡大",
+  "SettingsTabSystemExpandDramSize": "DRAMサイズを6GiBに拡大",
   "SettingsTabSystemIgnoreMissingServices": "未実装サービスを無視",
   "SettingsTabGraphics": "グラフィックス",
   "SettingsTabGraphicsAPI": "グラフィックスAPI",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "アドレス変換にソフトウェアページテーブルを使用します. 非常に正確ですがパフォーマンスが大きく低下します.",
   "MemoryManagerHostTooltip": "ホストのアドレス空間にメモリを直接マップします.JITのコンパイルと実行速度が大きく向上します.",
   "MemoryManagerUnsafeTooltip": "メモリを直接マップしますが, アクセス前にゲストのアドレス空間内のアドレスをマスクしません. より高速になりますが, 安全性が犠牲になります. ゲストアプリケーションは Ryujinx のどこからでもメモリにアクセスできるので,このモードでは信頼できるプログラムだけを実行するようにしてください.",
-  "DRamTooltip": "エミュレートされたシステムのメモリ容量を 4GB から 6GB に増加します.\n\n高解像度のテクスチャパックや 4K解像度の mod を使用する場合に有用です. パフォーマンスを改善するものではありません.\n\nよくわからない場合はオフのままにしてください.",
+  "DRamTooltip": "エミュレートされたシステムのメモリ容量を 4GiB から 6GiB に増加します.\n\n高解像度のテクスチャパックや 4K解像度の mod を使用する場合に有用です. パフォーマンスを改善するものではありません.\n\nよくわからない場合はオフのままにしてください.",
   "IgnoreMissingServicesTooltip": "未実装の Horizon OS サービスを無視します. 特定のゲームにおいて起動時のクラッシュを回避できる場合があります.\n\nよくわからない場合はオフのままにしてください.",
   "GraphicsBackendThreadingTooltip": "グラフィックスバックエンドのコマンドを別スレッドで実行します.\n\nシェーダのコンパイルを高速化し, 遅延を軽減し, マルチスレッド非対応の GPU ドライバにおいてパフォーマンスを改善します. マルチスレッド対応のドライバでも若干パフォーマンス改善が見られます.\n\nよくわからない場合は自動に設定してください.",
   "GalThreadingTooltip": "グラフィックスバックエンドのコマンドを別スレッドで実行します.\n\nシェーダのコンパイルを高速化し, 遅延を軽減し, マルチスレッド非対応の GPU ドライバにおいてパフォーマンスを改善します. マルチスレッド対応のドライバでも若干パフォーマンス改善が見られます.\n\nよくわからない場合は自動に設定してください.",
@@ -583,7 +583,7 @@
   "SettingsTabGraphicsBackend": "グラフィックスバックエンド",
   "SettingsTabGraphicsBackendTooltip": "使用するグラフィックスバックエンドです",
   "SettingsEnableTextureRecompression": "テクスチャの再圧縮を有効",
-  "SettingsEnableTextureRecompressionTooltip": "VRAMの使用量を削減するためテクスチャを圧縮します.\n\nGPUのVRAMが4GB未満の場合は使用を推奨します.\n\nよくわからない場合はオフのままにしてください.",
+  "SettingsEnableTextureRecompressionTooltip": "VRAMの使用量を削減するためテクスチャを圧縮します.\n\nGPUのVRAMが4GiB未満の場合は使用を推奨します.\n\nよくわからない場合はオフのままにしてください.",
   "SettingsTabGraphicsPreferredGpu": "優先使用するGPU",
   "SettingsTabGraphicsPreferredGpuTooltip": "Vulkanグラフィックスバックエンドで使用されるグラフィックスカードを選択します.\n\nOpenGLが使用するGPUには影響しません.\n\n不明な場合は, \"dGPU\" としてフラグが立っているGPUに設定します. ない場合はそのままにします.",
   "SettingsAppRequiredRestartMessage": "Ryujinx の再起動が必要です",

Ryujinx.Ava/Assets/Locales/ko_KR.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "해킹",
   "SettingsTabSystemHacksNote": " (불안정을 일으킬 수 있음)",
-  "SettingsTabSystemExpandDramSize": "DRAM 크기를 6GB로 확장",
+  "SettingsTabSystemExpandDramSize": "DRAM 크기를 6GiB로 확장",
   "SettingsTabSystemIgnoreMissingServices": "누락된 서비스 무시",
   "SettingsTabGraphics": "제도법",
   "SettingsTabGraphicsAPI": "그래픽 API",
@@ -439,7 +439,7 @@
   "MemoryManagerSoftwareTooltip": "주소 변환을 위해 소프트웨어 페이지 테이블을 사용하십시오. 정확도는 가장 높지만 성능은 가장 느립니다.",
   "MemoryManagerHostTooltip": "호스트 주소 공간에서 메모리를 직접 매핑합니다. 훨씬 더 빠른 JIT 컴파일 및 실행.",
   "MemoryManagerUnsafeTooltip": "메모리를 직접 매핑하지만 액세스하기 전에 게스트 주소 공간 내의 주소를 마스킹하지 마십시오. 더 빠르지만 안전을 희생해야 합니다. 게스트 응용 프로그램은 Ryujinx의 어디에서나 메모리에 액세스할 수 있으므로 이 모드로 신뢰할 수 있는 프로그램만 실행하십시오.",
-  "DRamTooltip": "에뮬레이트된 시스템의 메모리 양을 4GB에서 6GB로 확장",
+  "DRamTooltip": "에뮬레이트된 시스템의 메모리 양을 4GiB에서 6GiB로 확장",
   "IgnoreMissingServicesTooltip": "누락된 서비스 무시 옵션 활성화 또는 비활성화",
   "GraphicsBackendThreadingTooltip": "그래픽 백엔드 멀티스레딩 활성화",
   "GalThreadingTooltip": "두 번째 스레드에서 그래픽 백엔드 명령을 실행합니다. 셰이더 컴파일의 런타임 멀티스레딩을 허용하고, 말더듬을 줄이고, 자체 멀티스레딩 지원 없이 드라이버의 성능을 개선합니다. 멀티스레딩이 있는 드라이버에서 약간 다른 최대 성능. 드라이버 내장 멀티스레딩을 올바르게 비활성화하려면 Ryujinx를 다시 시작해야 할 수도 있고 최상의 성능을 얻으려면 수동으로 수행해야 할 수도 있습니다.",

Ryujinx.Ava/Assets/Locales/pl_PL.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacki",
   "SettingsTabSystemHacksNote": " (mogą powodować niestabilność)",
-  "SettingsTabSystemExpandDramSize": "Rozszerz Rozmiar DRAM do 6 GB",
+  "SettingsTabSystemExpandDramSize": "Rozszerz Rozmiar DRAM do 6 GiB",
   "SettingsTabSystemIgnoreMissingServices": "Ignoruj Brakujące Usługi",
   "SettingsTabGraphics": "Grafika",
   "SettingsTabGraphicsAPI": "Graficzne API",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "Użyj tabeli stron oprogramowania do translacji adresów. Najwyższa celność, ale najwolniejsza wydajność.",
   "MemoryManagerHostTooltip": "Bezpośrednio mapuj pamięć w przestrzeni adresowej hosta. Znacznie szybsza kompilacja i wykonanie JIT.",
   "MemoryManagerUnsafeTooltip": "Bezpośrednio mapuj pamięć, ale nie maskuj adresu w przestrzeni adresowej gościa przed uzyskaniem dostępu. Szybciej, ale kosztem bezpieczeństwa. Aplikacja gościa może uzyskać dostęp do pamięci z dowolnego miejsca w Ryujinx, więc w tym trybie uruchamiaj tylko programy, którym ufasz.",
-  "DRamTooltip": "Zwiększa ilość pamięci w emulowanym systemie z 4 GB do 6 GB.\n\nJest to przydatne tylko w przypadku pakietów tekstur o wyższej rozdzielczości lub modów w rozdzielczości 4k. NIE poprawia wydajności.\n\nW razie wątpliwości pozostaw WYŁĄCZONE.",
+  "DRamTooltip": "Zwiększa ilość pamięci w emulowanym systemie z 4 GiB do 6 GiB.\n\nJest to przydatne tylko w przypadku pakietów tekstur o wyższej rozdzielczości lub modów w rozdzielczości 4k. NIE poprawia wydajności.\n\nW razie wątpliwości pozostaw WYŁĄCZONE.",
   "IgnoreMissingServicesTooltip": "Ignoruje niezaimplementowane usługi Horizon OS. Może to pomóc w ominięciu awarii podczas uruchamiania niektórych gier.\n\nW razie wątpliwości pozostaw WYŁĄCZONE.",
   "GraphicsBackendThreadingTooltip": "Wykonuje polecenia backend'u graficznego w drugim wątku.\n\nPrzyspiesza kompilację shaderów, zmniejsza zacinanie się i poprawia wydajność sterowników GPU bez własnej obsługi wielowątkowości. Nieco lepsza wydajność w sterownikach z wielowątkowością.\n\nUstaw na AUTO, jeśli nie masz pewności.",
   "GalThreadingTooltip": "Wykonuje polecenia backend'u graficznego w drugim wątku.\n\nPrzyspiesza kompilację shaderów, zmniejsza zacinanie się i poprawia wydajność sterowników GPU bez własnej obsługi wielowątkowości. Nieco lepsza wydajność w sterownikach z wielowątkowością.\n\nUstaw na AUTO, jeśli nie masz pewności.",
@@ -583,10 +583,14 @@
   "SettingsTabGraphicsBackend": "Backend Graficzny",
   "SettingsTabGraphicsBackendTooltip": "Używalne Backendy Graficzne",
   "SettingsEnableTextureRecompression": "Włącz Rekompresję Tekstur",
-  "SettingsEnableTextureRecompressionTooltip": "Kompresuje niektóre tekstury w celu zmniejszenia zużycia pamięci VRAM.\n\nZalecane do użytku z GPU, które mają mniej niż 4 GB pamięci VRAM.\n\nW razie wątpliwości pozostaw WYŁĄCZONE.",
+  "SettingsEnableTextureRecompressionTooltip": "Kompresuje niektóre tekstury w celu zmniejszenia zużycia pamięci VRAM.\n\nZalecane do użytku z GPU, które mają mniej niż 4 GiB pamięci VRAM.\n\nW razie wątpliwości pozostaw WYŁĄCZONE.",
   "SettingsTabGraphicsPreferredGpu": "Preferowane GPU",
   "SettingsTabGraphicsPreferredGpuTooltip": "Wybierz kartę graficzną, która będzie używana z backendem graficznym Vulkan.\n\nNie wpływa na GPU używane przez OpenGL.\n\nW razie wątpliwości ustaw flagę GPU jako \"dGPU\". Jeśli żadnej nie ma, pozostaw nietknięte.",
   "SettingsAppRequiredRestartMessage": "Wymagane Zrestartowanie Ryujinx",
   "SettingsGpuBackendRestartMessage": "Zmieniono ustawienia Backendu Graficznego lub GPU. Będzie to wymagało ponownego uruchomienia",
-  "SettingsGpuBackendRestartSubMessage": "Czy chcesz zrestartować teraz?"
+  "SettingsGpuBackendRestartSubMessage": "Czy chcesz zrestartować teraz?",
+  "RyujinxUpdaterMessage": "Czy chcesz zaktualizować Ryujinx do najnowszej wersji?",
+  "SettingsTabHotkeysVolumeUpHotkey": "Zwiększ Głośność:",
+  "SettingsTabHotkeysVolumeDownHotkey": "Zmniejsz Głośność:",
+  "VolumeShort": "Głoś"
 }

Ryujinx.Ava/Assets/Locales/pt_BR.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
   "SettingsTabSystemHacksNote": " (Pode causar instabilidade)",
-  "SettingsTabSystemExpandDramSize": "Expandir memória para 6GB",
+  "SettingsTabSystemExpandDramSize": "Expandir memória para 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "Ignorar serviços não implementados",
   "SettingsTabGraphics": "Gráficos",
   "SettingsTabGraphicsAPI": "API gráfica",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "Usar uma tabela de página via software para tradução de endereços. Maior precisão, porém performance mais baixa.",
   "MemoryManagerHostTooltip": "Mapeia memória no espaço de endereço hóspede diretamente. Compilação e execução do JIT muito mais rápida.",
   "MemoryManagerUnsafeTooltip": "Mapeia memória diretamente, mas sem limitar o acesso ao espaço de endereçamento do sistema convidado. Mais rápido, porém menos seguro. O aplicativo convidado pode acessar memória de qualquer parte do Ryujinx, então apenas rode programas em que você confia nesse modo.",
-  "DRamTooltip": "Expande a memória do sistema emulado de 4GB para 6GB",
+  "DRamTooltip": "Expande a memória do sistema emulado de 4GiB para 6GiB",
   "IgnoreMissingServicesTooltip": "Habilita ou desabilita a opção de ignorar serviços não implementados",
   "GraphicsBackendThreadingTooltip": "Habilita multithreading do backend gráfico",
   "GalThreadingTooltip": "Executa comandos do backend gráfico em uma segunda thread. Permite multithreading em tempo de execução da compilação de shader, diminui os travamentos, e melhora performance em drivers sem suporte embutido a multithreading. Pequena variação na performance máxima em drivers com suporte a multithreading. Ryujinx pode precisar ser reiniciado para desabilitar adequadamente o multithreading embutido do driver, ou você pode precisar fazer isso manualmente para ter a melhor performance.",
@@ -556,5 +556,7 @@
   "SettingsSelectThemeFileDialogTitle" : "Selecionar arquivo do tema",
   "SettingsXamlThemeFile" : "Arquivo de tema Xaml",
   "SettingsTabHotkeysResScaleUpHotkey": "Aumentar a resolução:",
-  "SettingsTabHotkeysResScaleDownHotkey": "Diminuir a resolução:"
+  "SettingsTabHotkeysResScaleDownHotkey": "Diminuir a resolução:",
+  "SettingsEnableMacroHLE": "Habilitar emulação de alto nível para Macros",
+  "SettingsEnableMacroHLETooltip": "Habilita emulação de alto nível de códigos Macro da GPU.\n\nMelhora a performance, mas pode causar problemas gráficos em alguns jogos.\n\nEm caso de dúvida, deixe ATIVADO."
 }

Ryujinx.Ava/Assets/Locales/ru_RU.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Хаки",
   "SettingsTabSystemHacksNote": " (Эти многие настройки вызывают нестабильность)",
-  "SettingsTabSystemExpandDramSize": "Увеличение размера DRAM до 6GB",
+  "SettingsTabSystemExpandDramSize": "Увеличение размера DRAM до 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "Игнорировать отсутствующие службы",
   "SettingsTabGraphics": "Графика",
   "SettingsTabGraphicsAPI": "Графические API",

Ryujinx.Ava/Assets/Locales/tr_TR.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacklar",
   "SettingsTabSystemHacksNote": " (Bunlar birçok dengesizlik oluşturabilir)",
-  "SettingsTabSystemExpandDramSize": "DRAM boyutunu 6GB'a genişlet",
+  "SettingsTabSystemExpandDramSize": "DRAM boyutunu 6GiB'a genişlet",
   "SettingsTabSystemIgnoreMissingServices": "Eksik Servisleri Görmezden Gel",
   "SettingsTabGraphics": "Grafikler",
   "SettingsTabGraphicsAPI": "Grafikler API",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "Adres çevirisi için bir işlemci sayfası kullanır. En yüksek doğruluğu ve en yavaş performansı sunar.",
   "MemoryManagerHostTooltip": "Hafızayı doğrudan host adres aralığında tahsis eder. Çok daha hızlı JIT derleme ve işletimi sunar.",
   "MemoryManagerUnsafeTooltip": "Hafızayı doğrudan tahsis eder, ancak host aralığına erişimden önce adresi maskelemez. Daha iyi performansa karşılık emniyetten ödün verir. Misafir uygulama Ryujinx içerisinden istediği hafızaya erişebilir, bu sebeple bu seçenek ile sadece güvendiğiniz uygulamaları çalıştırın.",
-  "DRamTooltip": "Emüle edilen sistem hafızasını 4GB'dan 6GB'a yükseltir.\n\nBu seçenek yalnızca yüksek çözünürlük doku paketleri veya 4k çözünürlük modları için kullanılır. Performansı artırMAZ!\n\nEmin değilseniz devre dışı bırakın.",
+  "DRamTooltip": "Emüle edilen sistem hafızasını 4GiB'dan 6GiB'a yükseltir.\n\nBu seçenek yalnızca yüksek çözünürlük doku paketleri veya 4k çözünürlük modları için kullanılır. Performansı artırMAZ!\n\nEmin değilseniz devre dışı bırakın.",
   "IgnoreMissingServicesTooltip": "Henüz programlanmamış Horizon işletim sistemi servislerini görmezden gelir. Bu seçenek belirli oyunların açılırken çökmesinin önüne geçmeye yardımcı olabilir.\n\nEmin değilseniz devre dışı bırakın.",
   "GraphicsBackendThreadingTooltip": "Grafik arka uç komutlarını ikinci bir iş parçacığında işletir.\n\nKendi multithreading desteği olmayan sürücülerde shader derlemeyi hızlandırıp performansı artırır. Multithreading desteği olan sürücülerde çok az daha iyi performans sağlar.\n\nEmin değilseniz Otomatik seçeneğine ayarlayın.",
   "GalThreadingTooltip": "Grafik arka uç komutlarını ikinci bir iş parçacığında işletir.\n\nKendi multithreading desteği olmayan sürücülerde shader derlemeyi hızlandırıp performansı artırır. Multithreading desteği olan sürücülerde çok az daha iyi performans sağlar.\n\nEmin değilseniz Otomatik seçeneğine ayarlayın.",

Ryujinx.Ava/Assets/Locales/zh_CN.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "修正",
   "SettingsTabSystemHacksNote": " (会引起模拟器不稳定)",
-  "SettingsTabSystemExpandDramSize": "将模拟RAM大小扩展到 6GB",
+  "SettingsTabSystemExpandDramSize": "将模拟RAM大小扩展到 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "忽略缺少的服务",
   "SettingsTabGraphics": "图形",
   "SettingsTabGraphicsAPI": "图形 API",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "使用软件内存页管理，最精确但是速度最慢",
   "MemoryManagerHostTooltip": "直接映射内存页到电脑内存，JIT效率高",
   "MemoryManagerUnsafeTooltip": "直接映射内存页，但不检查内存溢出，JIT效率最高。\nRyujinx可以访问任何位置的内存，因而相对不安全。\n此模式下只应运行您信任的游戏或软件(即官方游戏)",
-  "DRamTooltip": "扩展模拟的 Switch 内存为6GB。\n某些高清纹理MOD或4K MOD需要此选项",
+  "DRamTooltip": "扩展模拟的 Switch 内存为6GiB。\n某些高清纹理MOD或4K MOD需要此选项",
   "IgnoreMissingServicesTooltip": "开启后，游戏会忽略未实现的系统服务，从而继续运行。\n少部分新发布的游戏由于使用新的未知系统服务，可能需要此选项来避免闪退。\n模拟器更新完善系统服务之后，则无需开启选项。\n如您的游戏已经正常运行，请保持此选项关闭",
   "GraphicsBackendThreadingTooltip": "启用后端多线程",
   "GalThreadingTooltip": "使用模拟器内置的多线程优化，减少着色器编译的卡顿，并提高驱动程序的性能(尤其是缺失多线程的AMD)。\nNVIDIA显卡需要重启模拟器才能禁用驱动本身的线程优化，您也可以手动在控制面板将其禁用",
@@ -583,7 +583,7 @@
   "SettingsTabGraphicsBackend": "图形后端",
   "SettingsTabGraphicsBackendTooltip": "显卡使用的图形后端",
   "SettingsEnableTextureRecompression": "启用纹理重压缩",
-  "SettingsEnableTextureRecompressionTooltip": "压缩某些纹理以减少显存的使用。\n适合显存小于 4GB 的 GPU开启。\n如果您不确定，请保持此项为关闭。",
+  "SettingsEnableTextureRecompressionTooltip": "压缩某些纹理以减少显存的使用。\n适合显存小于 4GiB 的 GPU开启。\n如果您不确定，请保持此项为关闭。",
   "SettingsTabGraphicsPreferredGpu": "首选 GPU",
   "SettingsTabGraphicsPreferredGpuTooltip": "选择Vulkan API使用的显卡。\n此选项不会影响OpenGL API。\n如果您不确定，建议选择\"dGPU(独立显卡)\"。如果没有独立显卡，则无需改动此选项",
   "SettingsAppRequiredRestartMessage": "Ryujinx 需要重启",

Ryujinx.Ava/Assets/Locales/zh_TW.json

@@ -119,7 +119,7 @@
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "修正",
   "SettingsTabSystemHacksNote": " (會引起模擬器不穩定)",
-  "SettingsTabSystemExpandDramSize": "將模擬記憶體大小擴充至 6GB",
+  "SettingsTabSystemExpandDramSize": "將模擬記憶體大小擴充至 6GiB",
   "SettingsTabSystemIgnoreMissingServices": "忽略缺少的服務",
   "SettingsTabGraphics": "圖形",
   "SettingsTabGraphicsEnhancements": "增強",
@@ -440,7 +440,7 @@
   "MemoryManagerSoftwareTooltip": "使用軟體記憶體頁管理，最精確但是速度最慢",
   "MemoryManagerHostTooltip": "直接映射記憶體頁到電腦記憶體，JIT效率高",
   "MemoryManagerUnsafeTooltip": "直接映射記憶體頁，但是不檢查記憶體溢出，JIT效率最高。\nRyujinx可以存取任何位置的記憶體，因而相對不安全。此模式下只應執行您信任的遊戲或軟體(即官方遊戲)",
-  "DRamTooltip": "擴展模擬的 Switch 記憶體為6GB，某些高畫質材質模組或 4K 模組需要此選項",
+  "DRamTooltip": "擴展模擬的 Switch 記憶體為6GiB，某些高畫質材質模組或 4K 模組需要此選項",
   "IgnoreMissingServicesTooltip": "忽略某些未實現的系統服務，少部分遊戲需要此選項才能啟動",
   "GraphicsBackendThreadingTooltip": "啟用後端多執行緒",
   "GalThreadingTooltip": "使用模擬器自帶的多執行緒調度，減少渲染器編譯的卡頓，並提高驅動程式的效能(尤其是缺失多執行緒的AMD)。\nNVIDIA使用者需要重啟模擬器才能停用驅動本身的多執行緒，否則您需手動執行停用獲得最佳效能",

Ryujinx.Ava/Common/KeyboardHotkeyState.cs

@@ -9,6 +9,8 @@
         Pause,
         ToggleMute,
         ResScaleUp,
-        ResScaleDown
+        ResScaleDown,
+        VolumeUp,
+        VolumeDown
     }
 }

Ryujinx.Ava/Modules/Updater/Updater.cs

@@ -1,4 +1,6 @@
+using Avalonia.Controls;
 using Avalonia.Threading;
+using FluentAvalonia.UI.Controls;
 using ICSharpCode.SharpZipLib.GZip;
 using ICSharpCode.SharpZipLib.Tar;
 using ICSharpCode.SharpZipLib.Zip;
@@ -11,11 +13,13 @@ using Ryujinx.Common;
 using Ryujinx.Common.Logging;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.NetworkInformation;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
@@ -40,6 +44,8 @@ namespace Ryujinx.Modules
 
         private static readonly string[] WindowsDependencyDirs = Array.Empty<string>();
 
+        public static bool UpdateSuccessful { get; private set; }
+
         public static async Task BeginParse(MainWindow mainWindow, bool showVersionUpToDate)
         {
             if (Running)
@@ -198,11 +204,18 @@ namespace Ryujinx.Modules
                     _buildSize = -1;
                 }
             }
+
             Dispatcher.UIThread.Post(async () =>
             {
                 // Show a message asking the user if they want to update
-                UpdaterWindow updateDialog = new(mainWindow, newVersion, _buildUrl);
-                await updateDialog.ShowDialog(mainWindow);
+                var shouldUpdate = await ContentDialogHelper.CreateChoiceDialog(LocaleManager.Instance["RyujinxUpdater"],
+                    LocaleManager.Instance["RyujinxUpdaterMessage"],
+                    $"{Program.Version} -> {newVersion}");
+
+                if (shouldUpdate)
+                {
+                    UpdateRyujinx(mainWindow, _buildUrl);
+                }
             });
         }
 
@@ -216,8 +229,10 @@ namespace Ryujinx.Modules
             return result;
         }
 
-        public static void UpdateRyujinx(UpdaterWindow updateDialog, string downloadUrl)
+        public static async void UpdateRyujinx(Window parent, string downloadUrl)
         {
+            UpdateSuccessful = false;
+
             // Empty update dir, although it shouldn't ever have anything inside it
             if (Directory.Exists(UpdateDir))
             {
@@ -228,25 +243,56 @@ namespace Ryujinx.Modules
 
             string updateFile = Path.Combine(UpdateDir, "update.bin");
 
-            // Download the update .zip
-            updateDialog.MainText.Text = LocaleManager.Instance["UpdaterDownloading"];
-            updateDialog.ProgressBar.Value = 0;
-            updateDialog.ProgressBar.Maximum = 100;
+            var taskDialog = new TaskDialog()
+            {
+                Header = LocaleManager.Instance["RyujinxUpdater"],
+                SubHeader = LocaleManager.Instance["UpdaterDownloading"],
+                IconSource = new SymbolIconSource { Symbol = Symbol.Download },
+                Buttons = { },
+                ShowProgressBar = true
+            };
 
-            Task.Run(() =>
+            taskDialog.XamlRoot = parent;
+
+            taskDialog.Opened += (s, e) =>
             {
                 if (_buildSize >= 0)
                 {
-                    DoUpdateWithMultipleThreads(updateDialog, downloadUrl, updateFile);
+                    DoUpdateWithMultipleThreads(taskDialog, downloadUrl, updateFile);
                 }
                 else
                 {
-                    DoUpdateWithSingleThread(updateDialog, downloadUrl, updateFile);
+                    DoUpdateWithSingleThread(taskDialog, downloadUrl, updateFile);
                 }
-            });
+            };
+
+            await taskDialog.ShowAsync(true);
+
+            if (UpdateSuccessful)
+            {
+                var shouldRestart = await ContentDialogHelper.CreateChoiceDialog(LocaleManager.Instance["RyujinxUpdater"],
+                    LocaleManager.Instance["DialogUpdaterCompleteMessage"],
+                    LocaleManager.Instance["DialogUpdaterRestartMessage"]);
+
+                if (shouldRestart)
+                {
+                    string ryuName = Path.GetFileName(Environment.ProcessPath);
+                    string ryuExe = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ryuName);
+                    var ryuArg = Environment.GetCommandLineArgs().Skip(1);
+
+                    if (!OperatingSystem.IsWindows())
+                    {
+                        chmod(ryuExe, Convert.ToUInt32("0777", 8));
+                    }
+
+                    Process.Start(ryuExe, ryuArg);
+
+                    Environment.Exit(0);
+                }
+            }
         }
 
-        private static void DoUpdateWithMultipleThreads(UpdaterWindow updateDialog, string downloadUrl, string updateFile)
+        private static void DoUpdateWithMultipleThreads(TaskDialog taskDialog, string downloadUrl, string updateFile)
         {
             // Multi-Threaded Updater
             long chunkSize = _buildSize / ConnectionCount;
@@ -290,7 +336,7 @@ namespace Ryujinx.Modules
                         Interlocked.Exchange(ref progressPercentage[index], args.ProgressPercentage);
                         Interlocked.Add(ref totalProgressPercentage, args.ProgressPercentage);
 
-                        updateDialog.ProgressBar.Value = totalProgressPercentage / ConnectionCount;
+                        taskDialog.SetProgressBarState(totalProgressPercentage / ConnectionCount, TaskDialogProgressState.Normal);
                     };
 
                     client.DownloadDataCompleted += (_, args) =>
@@ -301,6 +347,8 @@ namespace Ryujinx.Modules
                         {
                             webClients[index].Dispose();
 
+                            taskDialog.Hide();
+
                             return;
                         }
 
@@ -320,14 +368,14 @@ namespace Ryujinx.Modules
 
                             try
                             {
-                                InstallUpdate(updateDialog, updateFile);
+                                InstallUpdate(taskDialog, updateFile);
                             }
                             catch (Exception e)
                             {
                                 Logger.Warning?.Print(LogClass.Application, e.Message);
                                 Logger.Warning?.Print(LogClass.Application, "Multi-Threaded update failed, falling back to single-threaded updater.");
 
-                                DoUpdateWithSingleThread(updateDialog, downloadUrl, updateFile);
+                                DoUpdateWithSingleThread(taskDialog, downloadUrl, updateFile);
 
                                 return;
                             }
@@ -348,7 +396,7 @@ namespace Ryujinx.Modules
                             webClients[j].CancelAsync();
                         }
 
-                        DoUpdateWithSingleThread(updateDialog, downloadUrl, updateFile);
+                        DoUpdateWithSingleThread(taskDialog, downloadUrl, updateFile);
 
                         return;
                     }
@@ -356,7 +404,7 @@ namespace Ryujinx.Modules
             }
         }
 
-        private static void DoUpdateWithSingleThreadWorker(UpdaterWindow updateDialog, string downloadUrl, string updateFile)
+        private static void DoUpdateWithSingleThreadWorker(TaskDialog taskDialog, string downloadUrl, string updateFile)
         {
             using (HttpClient client = new HttpClient())
             {
@@ -384,19 +432,26 @@ namespace Ryujinx.Modules
 
                             byteWritten += readSize;
 
-                            updateDialog.ProgressBar.Value = ((double)byteWritten / totalBytes) * 100;
+                            taskDialog.SetProgressBarState(GetPercentage(byteWritten, totalBytes), TaskDialogProgressState.Normal);
+
                             updateFileStream.Write(buffer, 0, readSize);
                         }
                     }
                 }
 
-                InstallUpdate(updateDialog, updateFile);
+                InstallUpdate(taskDialog, updateFile);
             }
         }
 
-        private static void DoUpdateWithSingleThread(UpdaterWindow updateDialog, string downloadUrl, string updateFile)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static double GetPercentage(double value, double max)
         {
-            Thread worker = new Thread(() => DoUpdateWithSingleThreadWorker(updateDialog, downloadUrl, updateFile));
+            return max == 0 ? 0 : value / max * 100;
+        }
+
+        private static void DoUpdateWithSingleThread(TaskDialog taskDialog, string downloadUrl, string updateFile)
+        {
+            Thread worker = new Thread(() => DoUpdateWithSingleThreadWorker(taskDialog, downloadUrl, updateFile));
             worker.Name = "Updater.SingleThreadWorker";
             worker.Start();
         }
@@ -414,11 +469,11 @@ namespace Ryujinx.Modules
             }
         }
 
-        private static async void InstallUpdate(UpdaterWindow updateDialog, string updateFile)
+        private static async void InstallUpdate(TaskDialog taskDialog, string updateFile)
         {
             // Extract Update
-            updateDialog.MainText.Text = LocaleManager.Instance["UpdaterExtracting"];
-            updateDialog.ProgressBar.Value = 0;
+            taskDialog.SubHeader = LocaleManager.Instance["UpdaterExtracting"];
+            taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
 
             if (OperatingSystem.IsLinux())
             {
@@ -426,8 +481,6 @@ namespace Ryujinx.Modules
                 using (Stream gzipStream = new GZipInputStream(inStream))
                 using (TarInputStream tarStream = new TarInputStream(gzipStream, Encoding.ASCII))
                 {
-                    updateDialog.ProgressBar.Maximum = inStream.Length;
-
                     await Task.Run(() =>
                     {
                         TarEntry tarEntry;
@@ -450,12 +503,12 @@ namespace Ryujinx.Modules
 
                             Dispatcher.UIThread.Post(() =>
                             {
-                                updateDialog.ProgressBar.Value += entry.Size;
+                                taskDialog.SetProgressBarState(GetPercentage(entry.Size, inStream.Length), TaskDialogProgressState.Normal);
                             });
                         }
                     });
 
-                    updateDialog.ProgressBar.Value = inStream.Length;
+                    taskDialog.SetProgressBarState(100, TaskDialogProgressState.Normal);
                 }
             }
             else
@@ -463,12 +516,12 @@ namespace Ryujinx.Modules
                 using (Stream inStream = File.OpenRead(updateFile))
                 using (ZipFile zipFile = new ZipFile(inStream))
                 {
-                    updateDialog.ProgressBar.Maximum = zipFile.Count;
-
                     await Task.Run(() =>
                     {
+                        double count = 0;
                         foreach (ZipEntry zipEntry in zipFile)
                         {
+                            count++;
                             if (zipEntry.IsDirectory) continue;
 
                             string outPath = Path.Combine(UpdateDir, zipEntry.Name);
@@ -485,7 +538,7 @@ namespace Ryujinx.Modules
 
                             Dispatcher.UIThread.Post(() =>
                             {
-                                updateDialog.ProgressBar.Value++;
+                                taskDialog.SetProgressBarState(GetPercentage(count, zipFile.Count), TaskDialogProgressState.Normal);
                             });
                         }
                     });
@@ -497,22 +550,23 @@ namespace Ryujinx.Modules
 
             List<string> allFiles = EnumerateFilesToDelete().ToList();
 
-            updateDialog.MainText.Text = LocaleManager.Instance["UpdaterRenaming"];
-            updateDialog.ProgressBar.Value = 0;
-            updateDialog.ProgressBar.Maximum = allFiles.Count;
+            taskDialog.SubHeader = LocaleManager.Instance["UpdaterRenaming"];
+            taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
 
             // Replace old files
             await Task.Run(() =>
             {
+                double count = 0;
                 foreach (string file in allFiles)
                 {
+                    count++;
                     try
                     {
                         File.Move(file, file + ".ryuold");
 
                         Dispatcher.UIThread.Post(() =>
                         {
-                            updateDialog.ProgressBar.Value++;
+                            taskDialog.SetProgressBarState(GetPercentage(count, allFiles.Count), TaskDialogProgressState.Normal);
                         });
                     }
                     catch
@@ -523,23 +577,20 @@ namespace Ryujinx.Modules
 
                 Dispatcher.UIThread.Post(() =>
                 {
-                    updateDialog.MainText.Text = LocaleManager.Instance["UpdaterAddingFiles"];
-                    updateDialog.ProgressBar.Value = 0;
-                    updateDialog.ProgressBar.Maximum = Directory.GetFiles(UpdatePublishDir, "*", SearchOption.AllDirectories).Length;
+                    taskDialog.SubHeader = LocaleManager.Instance["UpdaterAddingFiles"];
+                    taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
                 });
 
-                MoveAllFilesOver(UpdatePublishDir, HomeDir, updateDialog);
+                MoveAllFilesOver(UpdatePublishDir, HomeDir, taskDialog);
             });
 
             Directory.Delete(UpdateDir, true);
 
             SetUnixPermissions();
 
-            updateDialog.MainText.Text = LocaleManager.Instance["DialogUpdaterCompleteMessage"];
-            updateDialog.SecondaryText.Text = LocaleManager.Instance["DialogUpdaterRestartMessage"];
+            UpdateSuccessful = true;
 
-            updateDialog.ProgressBar.IsVisible = false;
-            updateDialog.ButtonBox.IsVisible = true;
+            taskDialog.Hide();
         }
 
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
@@ -618,8 +669,9 @@ namespace Ryujinx.Modules
             return files;
         }
 
-        private static void MoveAllFilesOver(string root, string dest, UpdaterWindow dialog)
+        private static void MoveAllFilesOver(string root, string dest, TaskDialog taskDialog)
         {
+            var total = Directory.GetFiles(root, "*", SearchOption.AllDirectories).Length;
             foreach (string directory in Directory.GetDirectories(root))
             {
                 string dirName = Path.GetFileName(directory);
@@ -629,16 +681,18 @@ namespace Ryujinx.Modules
                     Directory.CreateDirectory(Path.Combine(dest, dirName));
                 }
 
-                MoveAllFilesOver(directory, Path.Combine(dest, dirName), dialog);
+                MoveAllFilesOver(directory, Path.Combine(dest, dirName), taskDialog);
             }
 
+            double count = 0;
             foreach (string file in Directory.GetFiles(root))
             {
+                count++;
                 File.Move(file, Path.Combine(dest, Path.GetFileName(file)), true);
 
                 Dispatcher.UIThread.InvokeAsync(() =>
                 {
-                    dialog.ProgressBar.Value++;
+                    taskDialog.SetProgressBarState(GetPercentage(count, total), TaskDialogProgressState.Normal);
                 });
             }
         }

Ryujinx.Ava/Program.cs

@@ -13,6 +13,7 @@ using Ryujinx.Common.SystemInfo;
 using Ryujinx.Modules;
 using Ryujinx.Ui.Common;
 using Ryujinx.Ui.Common.Configuration;
+using Ryujinx.Ui.Common.Helper;
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
@@ -26,7 +27,6 @@ namespace Ryujinx.Ava
         public static double ActualScaleFactor { get; set; }
         public static string Version { get; private set; }
         public static string ConfigurationPath { get; private set; }
-        public static string CommandLineProfile { get; set; }
         public static bool PreviewerDetached { get; private set; }
 
         public static RenderTimer RenderTimer { get; private set; }
@@ -87,46 +87,8 @@ namespace Ryujinx.Ava
 
         private static void Initialize(string[] args)
         {
-            // Parse Arguments.
-            string launchPathArg = null;
-            string baseDirPathArg = null;
-            bool startFullscreenArg = false;
-
-            for (int i = 0; i < args.Length; ++i)
-            {
-                string arg = args[i];
-
-                if (arg == "-r" || arg == "--root-data-dir")
-                {
-                    if (i + 1 >= args.Length)
-                    {
-                        Logger.Error?.Print(LogClass.Application, $"Invalid option '{arg}'");
-
-                        continue;
-                    }
-
-                    baseDirPathArg = args[++i];
-                }
-                else if (arg == "-p" || arg == "--profile")
-                {
-                    if (i + 1 >= args.Length)
-                    {
-                        Logger.Error?.Print(LogClass.Application, $"Invalid option '{arg}'");
-
-                        continue;
-                    }
-
-                    CommandLineProfile = args[++i];
-                }
-                else if (arg == "-f" || arg == "--fullscreen")
-                {
-                    startFullscreenArg = true;
-                }
-                else
-                {
-                    launchPathArg = arg;
-                }
-            }
+            // Parse arguments
+            CommandLineState.ParseArguments(args);
 
             // Delete backup files after updating.
             Task.Run(Updater.CleanupUpdate);
@@ -135,10 +97,10 @@ namespace Ryujinx.Ava
 
             // Hook unhandled exception and process exit events.
             AppDomain.CurrentDomain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) => ProcessUnhandledException(e.ExceptionObject as Exception, e.IsTerminating);
-            AppDomain.CurrentDomain.ProcessExit += (object sender, EventArgs e) => Exit();
+            AppDomain.CurrentDomain.ProcessExit        += (object sender, EventArgs e)                   => Exit();
 
             // Setup base data directory.
-            AppDataManager.Initialize(baseDirPathArg);
+            AppDataManager.Initialize(CommandLineState.BaseDirPathArg);
 
             // Initialize the configuration.
             ConfigurationState.Initialize();
@@ -173,9 +135,9 @@ namespace Ryujinx.Ava
                 }
             }
 
-            if (launchPathArg != null)
+            if (CommandLineState.LaunchPathArg != null)
             {
-                MainWindow.DeferLoadApplication(launchPathArg, startFullscreenArg);
+                MainWindow.DeferLoadApplication(CommandLineState.LaunchPathArg, CommandLineState.StartFullscreenArg);
             }
         }
 
@@ -215,6 +177,19 @@ namespace Ryujinx.Ava
                     Logger.Warning?.PrintMsg(LogClass.Application, $"Failed to load config! Loading the default config instead.\nFailed config location {ConfigurationPath}");
                 }
             }
+
+            // Check if graphics backend was overridden
+            if (CommandLineState.OverrideGraphicsBackend != null)
+            {
+                if (CommandLineState.OverrideGraphicsBackend.ToLower() == "opengl")
+                {
+                    ConfigurationState.Instance.Graphics.GraphicsBackend.Value = GraphicsBackend.OpenGl;
+                }
+                else if (CommandLineState.OverrideGraphicsBackend.ToLower() == "vulkan")
+                {
+                    ConfigurationState.Instance.Graphics.GraphicsBackend.Value = GraphicsBackend.Vulkan;
+                }
+            }
         }
 
         private static void PrintSystemInfo()

Ryujinx.Ava/Ryujinx.Ava.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <RuntimeIdentifiers>win10-x64;osx-x64;linux-x64</RuntimeIdentifiers>
     <OutputType>Exe</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
@@ -8,11 +8,13 @@
     <DefineConstants Condition=" '$(ExtraDefineConstants)' != '' ">$(DefineConstants);$(ExtraDefineConstants)</DefineConstants>
     <RootNamespace>Ryujinx.Ava</RootNamespace>
     <ApplicationIcon>Ryujinx.ico</ApplicationIcon>
+    <TieredPGO>true</TieredPGO>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(RuntimeIdentifier)' != ''">
     <PublishSingleFile>true</PublishSingleFile>
     <PublishTrimmed>true</PublishTrimmed>
+    <TrimMode>partial</TrimMode>
   </PropertyGroup>
 
   <ItemGroup>
@@ -34,7 +36,7 @@
     <PackageReference Include="Silk.NET.Vulkan" Version="2.10.1" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.10.1" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.10.1" />
-    <PackageReference Include="SPB" Version="0.0.4-build24" />
+    <PackageReference Include="SPB" Version="0.0.4-build28" />
     <PackageReference Include="SharpZipLib" Version="1.3.3" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.4" />
   </ItemGroup>

Ryujinx.Ava/Ui/Controls/ContentDialogHelper.cs

@@ -4,6 +4,7 @@ using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Controls.Primitives;
 using Avalonia.Media;
 using Avalonia.Threading;
+using FluentAvalonia.Core;
 using FluentAvalonia.UI.Controls;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.Ui.Models;
@@ -27,7 +28,10 @@ namespace Ryujinx.Ava.Ui.Controls
             string secondaryButton,
             string closeButton,
             int iconSymbol,
-            UserResult primaryButtonResult = UserResult.Ok)
+            UserResult primaryButtonResult = UserResult.Ok,
+            ManualResetEvent deferResetEvent = null,
+            Func<Window, Task> doWhileDeferred = null,
+            TypedEventHandler<ContentDialog, ContentDialogButtonClickEventArgs> deferCloseAction = null)
         {
             UserResult result = UserResult.None;
 
@@ -110,12 +114,19 @@ namespace Ryujinx.Ava.Ui.Controls
                 contentDialog.SecondaryButtonCommand = MiniCommand.Create(() =>
                 {
                     result = UserResult.No;
+                    contentDialog.PrimaryButtonClick -= deferCloseAction;
                 });
                 contentDialog.CloseButtonCommand = MiniCommand.Create(() =>
                 {
                     result = UserResult.Cancel;
+                    contentDialog.PrimaryButtonClick -= deferCloseAction;
                 });
 
+                if (deferResetEvent != null)
+                {
+                    contentDialog.PrimaryButtonClick += deferCloseAction;
+                }
+
                 await contentDialog.ShowAsync(ContentDialogPlacement.Popup);
 
                 overlay?.Close();
@@ -143,35 +154,20 @@ namespace Ryujinx.Ava.Ui.Controls
             Func<Window, Task> doWhileDeferred = null)
         {
             bool startedDeferring = false;
-
             UserResult result = UserResult.None;
 
-            ContentDialog contentDialog = new ContentDialog
-            {
-                Title = title,
-                PrimaryButtonText = primaryButton,
-                SecondaryButtonText = secondaryButton,
-                CloseButtonText = closeButton,
-                Content = CreateDialogTextContent(primaryText, secondaryText, iconSymbol),
-                PrimaryButtonCommand = MiniCommand.Create(() =>
-                {
-                    result = primaryButton == LocaleManager.Instance["InputDialogYes"] ? UserResult.Yes : UserResult.Ok;
-                }),
-            };
-            contentDialog.SecondaryButtonCommand = MiniCommand.Create(() =>
-            {
-                contentDialog.PrimaryButtonClick -= DeferClose;
-                result = UserResult.No;
-            });
-            contentDialog.CloseButtonCommand = MiniCommand.Create(() =>
-            {
-                contentDialog.PrimaryButtonClick -= DeferClose;
-                result = UserResult.Cancel;
-            });
-            contentDialog.PrimaryButtonClick += DeferClose;
-            await contentDialog.ShowAsync(ContentDialogPlacement.Popup);
-
-            return result;
+            return await ShowContentDialog(
+                title,
+                primaryText,
+                secondaryText,
+                primaryButton,
+                secondaryButton,
+                closeButton,
+                iconSymbol,
+                primaryButton == LocaleManager.Instance["InputDialogYes"] ? UserResult.Yes : UserResult.Ok,
+                deferResetEvent,
+                doWhileDeferred,
+                DeferClose);
 
             async void DeferClose(ContentDialog sender, ContentDialogButtonClickEventArgs args)
             {
@@ -180,7 +176,7 @@ namespace Ryujinx.Ava.Ui.Controls
                     return;
                 }
 
-                contentDialog.PrimaryButtonClick -= DeferClose;
+                sender.PrimaryButtonClick -= DeferClose;
 
                 startedDeferring = true;
 
@@ -188,7 +184,7 @@ namespace Ryujinx.Ava.Ui.Controls
 
                 result = primaryButton == LocaleManager.Instance["InputDialogYes"] ? UserResult.Yes : UserResult.Ok;
 
-                contentDialog.PrimaryButtonClick -= DeferClose;
+                sender.PrimaryButtonClick -= DeferClose;
 
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                 Task.Run(() =>

Ryujinx.Ava/Ui/Models/FileSizeSortComparer.cs

@@ -10,22 +10,22 @@ namespace Ryujinx.Ava.Ui.Models
             string aValue = (x as ApplicationData).TimePlayed;
             string bValue = (y as ApplicationData).TimePlayed;
 
-            if (aValue[^2..] == "GB")
+            if (aValue[^3..] == "GiB")
             {
-                aValue = (float.Parse(aValue[0..^2]) * 1024).ToString();
+                aValue = (float.Parse(aValue[0..^3]) * 1024).ToString();
             }
             else
             {
-                aValue = aValue[0..^2];
+                aValue = aValue[0..^3];
             }
 
-            if (bValue[^2..] == "GB")
+            if (bValue[^3..] == "GiB")
             {
-                bValue = (float.Parse(bValue[0..^2]) * 1024).ToString();
+                bValue = (float.Parse(bValue[0..^3]) * 1024).ToString();
             }
             else
             {
-                bValue = bValue[0..^2];
+                bValue = bValue[0..^3];
             }
 
             if (float.Parse(aValue) > float.Parse(bValue))

Ryujinx.Ava/Ui/Models/Generic/FileSizeSortComparer.cs

@@ -15,22 +15,22 @@ namespace Ryujinx.Ava.Ui.Models.Generic
             string aValue = x.FileSize;
             string bValue = y.FileSize;
 
-            if (aValue[^2..] == "GB")
+            if (aValue[^3..] == "GiB")
             {
-                aValue = (float.Parse(aValue[0..^2]) * 1024).ToString();
+                aValue = (float.Parse(aValue[0..^3]) * 1024).ToString();
             }
             else
             {
-                aValue = aValue[0..^2];
+                aValue = aValue[0..^3];
             }
 
-            if (bValue[^2..] == "GB")
+            if (bValue[^3..] == "GiB")
             {
-                bValue = (float.Parse(bValue[0..^2]) * 1024).ToString();
+                bValue = (float.Parse(bValue[0..^3]) * 1024).ToString();
             }
             else
             {
-                bValue = bValue[0..^2];
+                bValue = bValue[0..^3];
             }
 
             if (float.Parse(aValue) > float.Parse(bValue))

Ryujinx.Ava/Ui/ViewModels/SettingsViewModel.cs

@@ -21,14 +21,10 @@ using Ryujinx.HLE.HOS.Services.Time.TimeZone;
 using Ryujinx.Input;
 using Ryujinx.Ui.Common.Configuration;
 using Ryujinx.Ui.Common.Configuration.System;
-using Silk.NET.Vulkan;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Diagnostics;
 using System.Linq;
-using System.Runtime.InteropServices;
-using System.Threading.Tasks;
 using TimeZone = Ryujinx.Ava.Ui.Models.TimeZone;
 
 namespace Ryujinx.Ava.Ui.ViewModels
@@ -138,6 +134,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
         public bool ExpandDramSize { get; set; }
         public bool EnableShaderCache { get; set; }
         public bool EnableTextureRecompression { get; set; }
+        public bool EnableMacroHLE { get; set; }
         public bool EnableFileLog { get; set; }
         public bool EnableStub { get; set; }
         public bool EnableInfo { get; set; }
@@ -295,8 +292,6 @@ namespace Ryujinx.Ava.Ui.ViewModels
             if (_validTzRegions.Contains(location))
             {
                 TimeZone = location;
-
-                OnPropertyChanged(nameof(TimeZone));
             }
         }
 
@@ -341,6 +336,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
             ExpandDramSize = config.System.ExpandRam;
             EnableShaderCache = config.Graphics.EnableShaderCache;
             EnableTextureRecompression = config.Graphics.EnableTextureRecompression;
+            EnableMacroHLE = config.Graphics.EnableMacroHLE;
             EnableFileLog = config.Logger.EnableFileLog;
             EnableStub = config.Logger.EnableStub;
             EnableInfo = config.Logger.EnableInfo;
@@ -424,6 +420,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
             config.Graphics.EnableVsync.Value = EnableVsync;
             config.Graphics.EnableShaderCache.Value = EnableShaderCache;
             config.Graphics.EnableTextureRecompression.Value = EnableTextureRecompression;
+            config.Graphics.EnableMacroHLE.Value = EnableMacroHLE;
             config.Graphics.GraphicsBackend.Value = (GraphicsBackend)GraphicsBackendIndex;
             config.System.EnablePtc.Value = EnablePptc;
             config.System.EnableInternetAccess.Value = EnableInternetAccess;

Ryujinx.Ava/Ui/Windows/AboutWindow.axaml

@@ -6,7 +6,6 @@
     xmlns:locale="clr-namespace:Ryujinx.Ava.Common.Locale"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     xmlns:window="clr-namespace:Ryujinx.Ava.Ui.Windows"
-    Title="Ryujinx - About"
     Width="850"
     Height="550"
     MinWidth="500"

Ryujinx.Ava/Ui/Windows/MainWindow.axaml

@@ -164,7 +164,7 @@
                                 <MenuItem
                                     Command="{ReflectionBinding ChangeLanguage}"
                                     CommandParameter="pl_PL"
-                                    Header="Polish" />
+                                    Header="Polski" />
                                 <MenuItem
                                     Command="{ReflectionBinding ChangeLanguage}"
                                     CommandParameter="ru_RU"

Ryujinx.Ava/Ui/Windows/MainWindow.axaml.cs

@@ -23,6 +23,7 @@ using Ryujinx.Modules;
 using Ryujinx.Ui.App.Common;
 using Ryujinx.Ui.Common;
 using Ryujinx.Ui.Common.Configuration;
+using Ryujinx.Ui.Common.Helper;
 using SixLabors.ImageSharp.PixelFormats;
 using System;
 using System.ComponentModel;
@@ -247,7 +248,7 @@ namespace Ryujinx.Ava.Ui.Windows
             {
                 RendererControl.CreateVulkan();
             }
-            
+
             AppHost = new AppHost(RendererControl, InputManager, path, VirtualFileSystem, ContentManager, AccountManager, _userChannelPersistence, this);
 
             if (!AppHost.LoadGuestApplication().Result)
@@ -432,7 +433,7 @@ namespace Ryujinx.Ava.Ui.Windows
             // Consider removing this at some point in the future when we don't need to worry about old saves.
             VirtualFileSystem.FixExtraData(LibHacHorizonManager.RyujinxClient);
 
-            AccountManager = new AccountManager(LibHacHorizonManager.RyujinxClient, Program.CommandLineProfile);
+            AccountManager = new AccountManager(LibHacHorizonManager.RyujinxClient, CommandLineState.Profile);
 
             VirtualFileSystem.ReloadKeySet();
 
@@ -525,6 +526,7 @@ namespace Ryujinx.Ava.Ui.Windows
             GraphicsConfig.ShadersDumpPath = ConfigurationState.Instance.Graphics.ShadersDumpPath;
             GraphicsConfig.EnableShaderCache = ConfigurationState.Instance.Graphics.EnableShaderCache;
             GraphicsConfig.EnableTextureRecompression = ConfigurationState.Instance.Graphics.EnableTextureRecompression;
+            GraphicsConfig.EnableMacroHLE = ConfigurationState.Instance.Graphics.EnableMacroHLE;
         }
 
         public void LoadHotKeys()

Ryujinx.Ava/Ui/Windows/SettingsWindow.axaml

@@ -257,6 +257,22 @@
                                     TextAlignment="Center" />
                             </ToggleButton>
                         </StackPanel>
+                        <StackPanel Margin="10,0,0,0" Orientation="Horizontal">
+                            <TextBlock VerticalAlignment="Center" Text="{locale:Locale SettingsTabHotkeysVolumeUpHotkey}" Width="230" />
+                            <ToggleButton Width="90" Height="27" Checked="Button_Checked" Unchecked="Button_Unchecked">
+                                <TextBlock
+                                    Text="{Binding KeyboardHotkeys.VolumeUp, Mode=TwoWay, Converter={StaticResource Key}}"
+                                    TextAlignment="Center" />
+                            </ToggleButton>
+                        </StackPanel>
+                        <StackPanel Margin="10,0,0,0" Orientation="Horizontal">
+                            <TextBlock VerticalAlignment="Center" Text="{locale:Locale SettingsTabHotkeysVolumeDownHotkey}" Width="230" />
+                            <ToggleButton Width="90" Height="27" Checked="Button_Checked" Unchecked="Button_Unchecked">
+                                <TextBlock
+                                    Text="{Binding KeyboardHotkeys.VolumeDown, Mode=TwoWay, Converter={StaticResource Key}}"
+                                    TextAlignment="Center" />
+                            </ToggleButton>
+                        </StackPanel>
                     </StackPanel>
                 </Border>
             </ScrollViewer>
@@ -552,6 +568,10 @@
                                     ToolTip.Tip="{locale:Locale SettingsEnableTextureRecompressionTooltip}">
                                     <TextBlock Text="{locale:Locale SettingsEnableTextureRecompression}" />
                                 </CheckBox>
+                                <CheckBox IsChecked="{Binding EnableMacroHLE}"
+                                    ToolTip.Tip="{locale:Locale SettingsEnableMacroHLETooltip}">
+                                    <TextBlock Text="{locale:Locale SettingsEnableMacroHLE}" />
+                                </CheckBox>
                             </StackPanel>
                             <StackPanel Orientation="Horizontal">
                                 <TextBlock VerticalAlignment="Center"

Ryujinx.Ava/Ui/Windows/SettingsWindow.axaml.cs

@@ -37,7 +37,7 @@ namespace Ryujinx.Ava.Ui.Windows
             InitializeComponent();
             Load();
 
-            FuncMultiValueConverter<string, string> converter = new(parts => string.Format("{0}  {1}   {2}", parts.ToArray()));
+            FuncMultiValueConverter<string, string> converter = new(parts => string.Format("{0}  {1}   {2}", parts.ToArray()).Trim());
             MultiBinding tzMultiBinding = new() { Converter = converter };
             tzMultiBinding.Bindings.Add(new Binding("UtcDifference"));
             tzMultiBinding.Bindings.Add(new Binding("Location"));

Ryujinx.Ava/Ui/Windows/UpdaterWindow.axaml

@@ -1,66 +0,0 @@
-<window:StyleableWindow
-    x:Class="Ryujinx.Ava.Ui.Windows.UpdaterWindow"
-    xmlns="https://github.com/avaloniaui"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-    xmlns:locale="clr-namespace:Ryujinx.Ava.Common.Locale"
-    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    xmlns:window="clr-namespace:Ryujinx.Ava.Ui.Windows"
-    Title="Ryujinx Updater"
-    Width="500"
-    Height="500"
-    MinWidth="500"
-    MinHeight="500"
-    d:DesignHeight="350"
-    d:DesignWidth="400"
-    CanResize="False"
-    SizeToContent="Height"
-    WindowStartupLocation="CenterOwner"
-    mc:Ignorable="d">
-    <Grid
-        Margin="20"
-        HorizontalAlignment="Stretch"
-        VerticalAlignment="Stretch">
-        <Grid.RowDefinitions>
-            <RowDefinition />
-            <RowDefinition />
-            <RowDefinition />
-            <RowDefinition />
-            <RowDefinition />
-        </Grid.RowDefinitions>
-        <TextBlock
-            Name="MainText"
-            Grid.Row="1"
-            Height="20"
-            HorizontalAlignment="Stretch"
-            TextAlignment="Center" />
-        <TextBlock
-            Name="SecondaryText"
-            Grid.Row="2"
-            Height="20"
-            HorizontalAlignment="Stretch"
-            TextAlignment="Center" />
-        <ProgressBar
-            Name="ProgressBar"
-            Grid.Row="3"
-            Margin="20"
-            HorizontalAlignment="Stretch"
-            IsVisible="False"
-            Maximum="100"
-            Minimum="0" />
-        <StackPanel
-            Name="ButtonBox"
-            Grid.Row="4"
-            HorizontalAlignment="Right"
-            IsVisible="False"
-            Orientation="Horizontal"
-            Spacing="20">
-            <Button MinWidth="50" Command="{Binding YesPressed}">
-                <TextBlock Text="{locale:Locale InputDialogYes}" TextAlignment="Center" />
-            </Button>
-            <Button MinWidth="50" Command="{Binding NoPressed}">
-                <TextBlock Text="{locale:Locale InputDialogNo}" TextAlignment="Center" />
-            </Button>
-        </StackPanel>
-    </Grid>
-</window:StyleableWindow>

Ryujinx.Ava/Ui/Windows/UpdaterWindow.axaml.cs

@@ -1,73 +0,0 @@
-using Ryujinx.Ava.Common.Locale;
-using Ryujinx.Modules;
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-
-namespace Ryujinx.Ava.Ui.Windows
-{
-    public partial class UpdaterWindow : StyleableWindow
-    {
-        private readonly string _buildUrl;
-        private readonly MainWindow _mainWindow;
-        private readonly Version _newVersion;
-        private bool _restartQuery;
-
-        public UpdaterWindow()
-        {
-            DataContext = this;
-
-            InitializeComponent();
-
-            Title = LocaleManager.Instance["RyujinxUpdater"];
-        }
-
-        public UpdaterWindow(MainWindow mainWindow, Version newVersion, string buildUrl) : this()
-        {
-            _mainWindow = mainWindow;
-            _newVersion = newVersion;
-            _buildUrl = buildUrl;
-        }
-
-        [DllImport("libc", SetLastError = true)]
-        private static extern int chmod(string path, uint mode);
-
-        public void YesPressed()
-        {
-            if (_restartQuery)
-            {
-                string ryuName = OperatingSystem.IsWindows() ? "Ryujinx.Ava.exe" : "Ryujinx.Ava";
-                string ryuExe = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ryuName);
-                string ryuArg = string.Join(" ", Environment.GetCommandLineArgs().AsEnumerable().Skip(1).ToArray());
-
-                if (!OperatingSystem.IsWindows())
-                {
-                    chmod(ryuExe, 0777);
-                }
-
-                Process.Start(ryuExe, ryuArg);
-
-                Environment.Exit(0);
-            }
-            else
-            {
-                ButtonBox.IsVisible = false;
-                ProgressBar.IsVisible = true;
-
-                SecondaryText.Text = "";
-                _restartQuery = true;
-
-                Updater.UpdateRyujinx(this, _buildUrl);
-            }
-        }
-
-        public void NoPressed()
-        {
-            _mainWindow.UpdateMenuItem.IsEnabled = true;
-
-            Close();
-        }
-    }
-}

Ryujinx.Common/Configuration/Hid/KeyboardHotkeys.cs

@@ -9,5 +9,7 @@
         public Key ToggleMute { get; set; }
         public Key ResScaleUp { get; set; }
         public Key ResScaleDown { get; set; }
+        public Key VolumeUp { get; set; }
+        public Key VolumeDown { get; set; }
     }
 }

Ryujinx.Common/Extensions/BinaryReaderExtensions.cs

@@ -53,5 +53,11 @@ namespace Ryujinx.Common
 
             writer.Write(data);
         }
+
+        public static void Write(this BinaryWriter writer, UInt128 value)
+        {
+            writer.Write((ulong)value);
+            writer.Write((ulong)(value >> 64));
+        }
     }
 }

Ryujinx.Common/Memory/SpanOrArray.cs

@@ -0,0 +1,89 @@
+using System;
+
+namespace Ryujinx.Common.Memory
+{
+    /// <summary>
+    /// A struct that can represent both a Span and Array.
+    /// This is useful to keep the Array representation when possible to avoid copies.
+    /// </summary>
+    /// <typeparam name="T">Element Type</typeparam>
+    public ref struct SpanOrArray<T> where T : unmanaged
+    {
+        public readonly T[] Array;
+        public readonly ReadOnlySpan<T> Span;
+
+        /// <summary>
+        /// Create a new SpanOrArray from an array.
+        /// </summary>
+        /// <param name="array">Array to store</param>
+        public SpanOrArray(T[] array)
+        {
+            Array = array;
+            Span = ReadOnlySpan<T>.Empty;
+        }
+
+        /// <summary>
+        /// Create a new SpanOrArray from a readonly span.
+        /// </summary>
+        /// <param name="array">Span to store</param>
+        public SpanOrArray(ReadOnlySpan<T> span)
+        {
+            Array = null;
+            Span = span;
+        }
+
+        /// <summary>
+        /// Return the contained array, or convert the span if necessary.
+        /// </summary>
+        /// <returns>An array containing the data</returns>
+        public T[] ToArray()
+        {
+            return Array ?? Span.ToArray();
+        }
+
+        /// <summary>
+        /// Return a ReadOnlySpan from either the array or ReadOnlySpan.
+        /// </summary>
+        /// <returns>A ReadOnlySpan containing the data</returns>
+        public ReadOnlySpan<T> AsSpan()
+        {
+            return Array ?? Span;
+        }
+
+        /// <summary>
+        /// Cast an array to a SpanOrArray.
+        /// </summary>
+        /// <param name="array">Source array</param>
+        public static implicit operator SpanOrArray<T>(T[] array)
+        {
+            return new SpanOrArray<T>(array);
+        }
+
+        /// <summary>
+        /// Cast a ReadOnlySpan to a SpanOrArray.
+        /// </summary>
+        /// <param name="span">Source ReadOnlySpan</param>
+        public static implicit operator SpanOrArray<T>(ReadOnlySpan<T> span)
+        {
+            return new SpanOrArray<T>(span);
+        }
+
+        /// <summary>
+        /// Cast a Span to a SpanOrArray.
+        /// </summary>
+        /// <param name="span">Source Span</param>
+        public static implicit operator SpanOrArray<T>(Span<T> span)
+        {
+            return new SpanOrArray<T>(span);
+        }
+
+        /// <summary>
+        /// Cast a SpanOrArray to a ReadOnlySpan
+        /// </summary>
+        /// <param name="spanOrArray">Source SpanOrArray</param>
+        public static implicit operator ReadOnlySpan<T>(SpanOrArray<T> spanOrArray)
+        {
+            return spanOrArray.AsSpan();
+        }
+    }
+}

Ryujinx.Common/Ryujinx.Common.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 

Ryujinx.Common/SystemInfo/LinuxSystemInfo.cs

@@ -36,13 +36,13 @@ namespace Ryujinx.Common.SystemInfo
 
             ParseKeyValues("/proc/meminfo", memDict);
 
-            // Entries are in KB
-            ulong.TryParse(memDict["MemTotal"]?.Split(' ')[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong totalKB);
-            ulong.TryParse(memDict["MemAvailable"]?.Split(' ')[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong availableKB);
+            // Entries are in KiB
+            ulong.TryParse(memDict["MemTotal"]?.Split(' ')[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong totalKiB);
+            ulong.TryParse(memDict["MemAvailable"]?.Split(' ')[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong availableKiB);
 
             CpuName = $"{cpuName} ; {LogicalCoreCount} logical";
-            RamTotal = totalKB * 1024;
-            RamAvailable = availableKB * 1024;
+            RamTotal = totalKiB * 1024;
+            RamAvailable = availableKiB * 1024;
         }
 
         private static void ParseKeyValues(string filePath, Dictionary<string, string> itemDict)

Ryujinx.Common/SystemInfo/SystemInfo.cs

@@ -20,13 +20,13 @@ namespace Ryujinx.Common.SystemInfo
             CpuName = "Unknown";
         }
 
-        private static string ToMBString(ulong bytesValue) => (bytesValue == 0) ? "Unknown" : $"{bytesValue / 1024 / 1024} MB";
+        private static string ToMiBString(ulong bytesValue) => (bytesValue == 0) ? "Unknown" : $"{bytesValue / 1024 / 1024} MiB";
 
         public void Print()
         {
             Logger.Notice.Print(LogClass.Application, $"Operating System: {OsDescription}");
             Logger.Notice.Print(LogClass.Application, $"CPU: {CpuName}");
-            Logger.Notice.Print(LogClass.Application, $"RAM: Total {ToMBString(RamTotal)} ; Available {ToMBString(RamAvailable)}");
+            Logger.Notice.Print(LogClass.Application, $"RAM: Total {ToMiBString(RamTotal)} ; Available {ToMiBString(RamAvailable)}");
         }
 
         public static SystemInfo Gather()

Ryujinx.Common/Utilities/EmbeddedResources.cs

@@ -129,7 +129,7 @@ namespace Ryujinx.Common
 
         private static (Assembly, string) ResolveManifestPath(string filename)
         {
-            var segments = filename.Split(new[] { '/' }, 2, StringSplitOptions.RemoveEmptyEntries);
+            var segments = filename.Split('/', 2, StringSplitOptions.RemoveEmptyEntries);
 
             if (segments.Length >= 2)
             {

Ryujinx.Common/Utilities/SpanHelpers.cs

@@ -7,19 +7,19 @@ namespace Ryujinx.Common.Utilities
     public static class SpanHelpers
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Span<T> CreateSpan<T>(ref T reference, int length)
+        public static Span<T> CreateSpan<T>(scoped ref T reference, int length)
         {
             return MemoryMarshal.CreateSpan(ref reference, length);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Span<T> AsSpan<T>(ref T reference) where T : unmanaged
+        public static Span<T> AsSpan<T>(scoped ref T reference) where T : unmanaged
         {
             return CreateSpan(ref reference, 1);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Span<TSpan> AsSpan<TStruct, TSpan>(ref TStruct reference)
+        public static Span<TSpan> AsSpan<TStruct, TSpan>(scoped ref TStruct reference)
             where TStruct : unmanaged where TSpan : unmanaged
         {
             return CreateSpan(ref Unsafe.As<TStruct, TSpan>(ref reference),
@@ -27,25 +27,25 @@ namespace Ryujinx.Common.Utilities
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Span<byte> AsByteSpan<T>(ref T reference) where T : unmanaged
+        public static Span<byte> AsByteSpan<T>(scoped ref T reference) where T : unmanaged
         {
             return CreateSpan(ref Unsafe.As<T, byte>(ref reference), Unsafe.SizeOf<T>());
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlySpan<T> CreateReadOnlySpan<T>(ref T reference, int length)
+        public static ReadOnlySpan<T> CreateReadOnlySpan<T>(scoped ref T reference, int length)
         {
             return MemoryMarshal.CreateReadOnlySpan(ref reference, length);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlySpan<T> AsReadOnlySpan<T>(ref T reference) where T : unmanaged
+        public static ReadOnlySpan<T> AsReadOnlySpan<T>(scoped ref T reference) where T : unmanaged
         {
             return CreateReadOnlySpan(ref reference, 1);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlySpan<TSpan> AsReadOnlySpan<TStruct, TSpan>(ref TStruct reference)
+        public static ReadOnlySpan<TSpan> AsReadOnlySpan<TStruct, TSpan>(scoped ref TStruct reference)
             where TStruct : unmanaged where TSpan : unmanaged
         {
             return CreateReadOnlySpan(ref Unsafe.As<TStruct, TSpan>(ref reference),
@@ -53,7 +53,7 @@ namespace Ryujinx.Common.Utilities
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ReadOnlySpan<byte> AsReadOnlyByteSpan<T>(ref T reference) where T : unmanaged
+        public static ReadOnlySpan<byte> AsReadOnlyByteSpan<T>(scoped ref T reference) where T : unmanaged
         {
             return CreateReadOnlySpan(ref Unsafe.As<T, byte>(ref reference), Unsafe.SizeOf<T>());
         }

Ryujinx.Common/Utilities/UInt128Utils.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Ryujinx.Common.Utilities
+{
+    public static class UInt128Utils
+    {
+        public static UInt128 FromHex(string hex)
+        {
+            return new UInt128((ulong)Convert.ToInt64(hex.Substring(0, 16), 16), (ulong)Convert.ToInt64(hex.Substring(16), 16));
+        }
+
+        public static UInt128 CreateRandom()
+        {
+            return new UInt128((ulong)Random.Shared.NextInt64(), (ulong)Random.Shared.NextInt64());
+        }
+    }
+}

Ryujinx.Cpu/IExecutionContext.cs

@@ -27,7 +27,7 @@ namespace Ryujinx.Cpu
         long TpidrroEl0 { get; set; }
 
         /// <summary>
-        /// Processor State register.
+        /// Processor State Register.
         /// </summary>
         uint Pstate { get; set; }
 
@@ -109,4 +109,4 @@ namespace Ryujinx.Cpu
         /// </remarks>
         void StopRunning();
     }
-}
+}

Ryujinx.Cpu/Ryujinx.Cpu.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 

Ryujinx.Graphics.Device/Ryujinx.Graphics.Device.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
 </Project>

Ryujinx.Graphics.GAL/Capabilities.cs

@@ -21,6 +21,7 @@ namespace Ryujinx.Graphics.GAL
         public readonly bool SupportsFragmentShaderOrderingIntel;
         public readonly bool SupportsGeometryShaderPassthrough;
         public readonly bool SupportsImageLoadFormatted;
+        public readonly bool SupportsLayerVertexTessellation;
         public readonly bool SupportsMismatchingViewFormat;
         public readonly bool SupportsCubemapView;
         public readonly bool SupportsNonConstantTextureOffset;
@@ -55,6 +56,7 @@ namespace Ryujinx.Graphics.GAL
             bool supportsFragmentShaderOrderingIntel,
             bool supportsGeometryShaderPassthrough,
             bool supportsImageLoadFormatted,
+            bool supportsLayerVertexTessellation,
             bool supportsMismatchingViewFormat,
             bool supportsCubemapView,
             bool supportsNonConstantTextureOffset,
@@ -86,6 +88,7 @@ namespace Ryujinx.Graphics.GAL
             SupportsFragmentShaderOrderingIntel = supportsFragmentShaderOrderingIntel;
             SupportsGeometryShaderPassthrough = supportsGeometryShaderPassthrough;
             SupportsImageLoadFormatted = supportsImageLoadFormatted;
+            SupportsLayerVertexTessellation = supportsLayerVertexTessellation;
             SupportsMismatchingViewFormat = supportsMismatchingViewFormat;
             SupportsCubemapView = supportsCubemapView;
             SupportsNonConstantTextureOffset = supportsNonConstantTextureOffset;

Ryujinx.Graphics.GAL/IPipeline.cs

@@ -34,13 +34,14 @@ namespace Ryujinx.Graphics.GAL
             int firstIndex,
             int firstVertex,
             int firstInstance);
+        void DrawIndexedIndirect(BufferRange indirectBuffer);
+        void DrawIndexedIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride);
+        void DrawIndirect(BufferRange indirectBuffer);
+        void DrawIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride);
         void DrawTexture(ITexture texture, ISampler sampler, Extents2DF srcRegion, Extents2DF dstRegion);
 
         void EndTransformFeedback();
 
-        void MultiDrawIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride);
-        void MultiDrawIndexedIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride);
-
         void SetAlphaTest(bool enable, float reference, CompareOp op);
 
         void SetBlendState(int index, BlendDescriptor blend);

Ryujinx.Graphics.GAL/ITexture.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Memory;
 using System;
 
 namespace Ryujinx.Graphics.GAL
@@ -17,9 +18,9 @@ namespace Ryujinx.Graphics.GAL
         ReadOnlySpan<byte> GetData();
         ReadOnlySpan<byte> GetData(int layer, int level);
 
-        void SetData(ReadOnlySpan<byte> data);
-        void SetData(ReadOnlySpan<byte> data, int layer, int level);
-        void SetData(ReadOnlySpan<byte> data, int layer, int level, Rectangle<int> region);
+        void SetData(SpanOrArray<byte> data);
+        void SetData(SpanOrArray<byte> data, int layer, int level);
+        void SetData(SpanOrArray<byte> data, int layer, int level, Rectangle<int> region);
         void SetStorage(BufferRange buffer);
         void Release();
     }

Ryujinx.Graphics.GAL/Multithreading/CommandHelper.cs

@@ -141,16 +141,20 @@ namespace Ryujinx.Graphics.GAL.Multithreading
                 DrawCommand.Run(ref GetCommand<DrawCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.DrawIndexed] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
                 DrawIndexedCommand.Run(ref GetCommand<DrawIndexedCommand>(memory), threaded, renderer);
+            _lookup[(int)CommandType.DrawIndexedIndirect] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+                DrawIndexedIndirectCommand.Run(ref GetCommand<DrawIndexedIndirectCommand>(memory), threaded, renderer);
+            _lookup[(int)CommandType.DrawIndexedIndirectCount] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+                DrawIndexedIndirectCountCommand.Run(ref GetCommand<DrawIndexedIndirectCountCommand>(memory), threaded, renderer);
+            _lookup[(int)CommandType.DrawIndirect] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+                DrawIndirectCommand.Run(ref GetCommand<DrawIndirectCommand>(memory), threaded, renderer);
+            _lookup[(int)CommandType.DrawIndirectCount] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+                DrawIndirectCountCommand.Run(ref GetCommand<DrawIndirectCountCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.DrawTexture] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
                 DrawTextureCommand.Run(ref GetCommand<DrawTextureCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.EndHostConditionalRendering] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
                 EndHostConditionalRenderingCommand.Run(renderer);
             _lookup[(int)CommandType.EndTransformFeedback] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
                 EndTransformFeedbackCommand.Run(ref GetCommand<EndTransformFeedbackCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.MultiDrawIndirectCount] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
-                MultiDrawIndirectCountCommand.Run(ref GetCommand<MultiDrawIndirectCountCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.MultiDrawIndexedIndirectCount] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
-                MultiDrawIndexedIndirectCountCommand.Run(ref GetCommand<MultiDrawIndexedIndirectCountCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.SetAlphaTest] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
                 SetAlphaTestCommand.Run(ref GetCommand<SetAlphaTestCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.SetBlendState] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>

Ryujinx.Graphics.GAL/Multithreading/CommandType.cs

@@ -52,11 +52,13 @@
         DispatchCompute,
         Draw,
         DrawIndexed,
+        DrawIndexedIndirect,
+        DrawIndexedIndirectCount,
+        DrawIndirect,
+        DrawIndirectCount,
         DrawTexture,
         EndHostConditionalRendering,
         EndTransformFeedback,
-        MultiDrawIndirectCount,
-        MultiDrawIndexedIndirectCount,
         SetAlphaTest,
         SetBlendState,
         SetDepthBias,

Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndexedIndirectCommand.cs

@@ -0,0 +1,18 @@
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct DrawIndexedIndirectCommand : IGALCommand
+    {
+        public CommandType CommandType => CommandType.DrawIndexedIndirect;
+        private BufferRange _indirectBuffer;
+
+        public void Set(BufferRange indirectBuffer)
+        {
+            _indirectBuffer = indirectBuffer;
+        }
+
+        public static void Run(ref DrawIndexedIndirectCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.DrawIndexedIndirect(threaded.Buffers.MapBufferRange(command._indirectBuffer));
+        }
+    }
+}

Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndexedIndirectCountCommand.cs

@@ -1,8 +1,8 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct MultiDrawIndexedIndirectCountCommand : IGALCommand
+    struct DrawIndexedIndirectCountCommand : IGALCommand
     {
-        public CommandType CommandType => CommandType.MultiDrawIndexedIndirectCount;
+        public CommandType CommandType => CommandType.DrawIndexedIndirectCount;
         private BufferRange _indirectBuffer;
         private BufferRange _parameterBuffer;
         private int _maxDrawCount;
@@ -16,9 +16,9 @@
             _stride = stride;
         }
 
-        public static void Run(ref MultiDrawIndexedIndirectCountCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        public static void Run(ref DrawIndexedIndirectCountCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
-            renderer.Pipeline.MultiDrawIndexedIndirectCount(
+            renderer.Pipeline.DrawIndexedIndirectCount(
                 threaded.Buffers.MapBufferRange(command._indirectBuffer),
                 threaded.Buffers.MapBufferRange(command._parameterBuffer),
                 command._maxDrawCount,

Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndirectCommand.cs

@@ -0,0 +1,18 @@
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct DrawIndirectCommand : IGALCommand
+    {
+        public CommandType CommandType => CommandType.DrawIndirect;
+        private BufferRange _indirectBuffer;
+
+        public void Set(BufferRange indirectBuffer)
+        {
+            _indirectBuffer = indirectBuffer;
+        }
+
+        public static void Run(ref DrawIndirectCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.DrawIndirect(threaded.Buffers.MapBufferRange(command._indirectBuffer));
+        }
+    }
+}

Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndirectCountCommand.cs

@@ -1,8 +1,8 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct MultiDrawIndirectCountCommand : IGALCommand
+    struct DrawIndirectCountCommand : IGALCommand
     {
-        public CommandType CommandType => CommandType.MultiDrawIndirectCount;
+        public CommandType CommandType => CommandType.DrawIndirectCount;
         private BufferRange _indirectBuffer;
         private BufferRange _parameterBuffer;
         private int _maxDrawCount;
@@ -16,9 +16,9 @@
             _stride = stride;
         }
 
-        public static void Run(ref MultiDrawIndirectCountCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        public static void Run(ref DrawIndirectCountCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
-            renderer.Pipeline.MultiDrawIndirectCount(
+            renderer.Pipeline.DrawIndirectCount(
                 threaded.Buffers.MapBufferRange(command._indirectBuffer),
                 threaded.Buffers.MapBufferRange(command._parameterBuffer),
                 command._maxDrawCount,

Ryujinx.Graphics.GAL/Multithreading/Resources/ThreadedTexture.cs

@@ -1,4 +1,5 @@
-using Ryujinx.Graphics.GAL.Multithreading.Commands.Texture;
+using Ryujinx.Common.Memory;
+using Ryujinx.Graphics.GAL.Multithreading.Commands.Texture;
 using Ryujinx.Graphics.GAL.Multithreading.Model;
 using System;
 
@@ -107,19 +108,19 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Resources
             }
         }
 
-        public void SetData(ReadOnlySpan<byte> data)
+        public void SetData(SpanOrArray<byte> data)
         {
             _renderer.New<TextureSetDataCommand>().Set(Ref(this), Ref(data.ToArray()));
             _renderer.QueueCommand();
         }
 
-        public void SetData(ReadOnlySpan<byte> data, int layer, int level)
+        public void SetData(SpanOrArray<byte> data, int layer, int level)
         {
             _renderer.New<TextureSetDataSliceCommand>().Set(Ref(this), Ref(data.ToArray()), layer, level);
             _renderer.QueueCommand();
         }
 
-        public void SetData(ReadOnlySpan<byte> data, int layer, int level, Rectangle<int> region)
+        public void SetData(SpanOrArray<byte> data, int layer, int level, Rectangle<int> region)
         {
             _renderer.New<TextureSetDataSliceRegionCommand>().Set(Ref(this), Ref(data.ToArray()), layer, level, region);
             _renderer.QueueCommand();

Ryujinx.Graphics.GAL/Multithreading/ThreadedPipeline.cs

@@ -83,6 +83,30 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _renderer.QueueCommand();
         }
 
+        public void DrawIndexedIndirect(BufferRange indirectBuffer)
+        {
+            _renderer.New<DrawIndexedIndirectCommand>().Set(indirectBuffer);
+            _renderer.QueueCommand();
+        }
+
+        public void DrawIndexedIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride)
+        {
+            _renderer.New<DrawIndexedIndirectCountCommand>().Set(indirectBuffer, parameterBuffer, maxDrawCount, stride);
+            _renderer.QueueCommand();
+        }
+
+        public void DrawIndirect(BufferRange indirectBuffer)
+        {
+            _renderer.New<DrawIndirectCommand>().Set(indirectBuffer);
+            _renderer.QueueCommand();
+        }
+
+        public void DrawIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride)
+        {
+            _renderer.New<DrawIndirectCountCommand>().Set(indirectBuffer, parameterBuffer, maxDrawCount, stride);
+            _renderer.QueueCommand();
+        }
+
         public void DrawTexture(ITexture texture, ISampler sampler, Extents2DF srcRegion, Extents2DF dstRegion)
         {
             _renderer.New<DrawTextureCommand>().Set(Ref(texture), Ref(sampler), srcRegion, dstRegion);
@@ -101,18 +125,6 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _renderer.QueueCommand();
         }
 
-        public void MultiDrawIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride)
-        {
-            _renderer.New<MultiDrawIndirectCountCommand>().Set(indirectBuffer, parameterBuffer, maxDrawCount, stride);
-            _renderer.QueueCommand();
-        }
-
-        public void MultiDrawIndexedIndirectCount(BufferRange indirectBuffer, BufferRange parameterBuffer, int maxDrawCount, int stride)
-        {
-            _renderer.New<MultiDrawIndexedIndirectCountCommand>().Set(indirectBuffer, parameterBuffer, maxDrawCount, stride);
-            _renderer.QueueCommand();
-        }
-
         public void SetAlphaTest(bool enable, float reference, CompareOp op)
         {
             _renderer.New<SetAlphaTestCommand>().Set(enable, reference, op);

Ryujinx.Graphics.GAL/Ryujinx.Graphics.GAL.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">

Ryujinx.Graphics.Gpu/Constants.cs

@@ -95,5 +95,10 @@ namespace Ryujinx.Graphics.Gpu
         /// Byte alignment for block linear textures
         /// </summary>
         public const int GobAlignment = 64;
+
+        /// <summary>
+        /// Expected byte alignment for storage buffers
+        /// </summary>
+        public const int StorageAlignment = 16;
     }
 }

Ryujinx.Graphics.Gpu/Engine/Compute/ComputeClass.cs

@@ -94,6 +94,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
         {
             var memoryManager = _channel.MemoryManager;
 
+            // Since we're going to change the state, make sure any pending instanced draws are done.
+            _3dEngine.PerformDeferredDraws();
+
+            // Make sure all pending uniform buffer data is written to memory.
             _3dEngine.FlushUboDirty();
 
             uint qmdAddress = _state.State.SendPcasA;
@@ -134,7 +138,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
                 qmd.CtaThreadDimension1,
                 qmd.CtaThreadDimension2,
                 localMemorySize,
-                sharedMemorySize);
+                sharedMemorySize,
+                _channel.BufferManager.HasUnalignedStorageBuffers);
 
             CachedShaderProgram cs = memoryManager.Physical.ShaderCache.GetComputeShader(_channel, poolState, computeState, shaderGpuVa);
 
@@ -146,6 +151,33 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
 
             ShaderProgramInfo info = cs.Shaders[0].Info;
 
+            bool hasUnaligned = _channel.BufferManager.HasUnalignedStorageBuffers;
+
+            for (int index = 0; index < info.SBuffers.Count; index++)
+            {
+                BufferDescriptor sb = info.SBuffers[index];
+
+                ulong sbDescAddress = _channel.BufferManager.GetComputeUniformBufferAddress(0);
+
+                int sbDescOffset = 0x310 + sb.Slot * 0x10;
+
+                sbDescAddress += (ulong)sbDescOffset;
+
+                SbDescriptor sbDescriptor = _channel.MemoryManager.Physical.Read<SbDescriptor>(sbDescAddress);
+
+                _channel.BufferManager.SetComputeStorageBuffer(sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size, sb.Flags);
+            }
+
+            if ((_channel.BufferManager.HasUnalignedStorageBuffers) != hasUnaligned)
+            {
+                // Refetch the shader, as assumptions about storage buffer alignment have changed.
+                cs = memoryManager.Physical.ShaderCache.GetComputeShader(_channel, poolState, computeState, shaderGpuVa);
+
+                _context.Renderer.Pipeline.SetProgram(cs.HostProgram);
+
+                info = cs.Shaders[0].Info;
+            }
+
             for (int index = 0; index < info.CBuffers.Count; index++)
             {
                 BufferDescriptor cb = info.CBuffers[index];
@@ -170,21 +202,6 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
                 _channel.BufferManager.SetComputeUniformBuffer(cb.Slot, cbDescriptor.PackAddress(), (uint)cbDescriptor.Size);
             }
 
-            for (int index = 0; index < info.SBuffers.Count; index++)
-            {
-                BufferDescriptor sb = info.SBuffers[index];
-
-                ulong sbDescAddress = _channel.BufferManager.GetComputeUniformBufferAddress(0);
-
-                int sbDescOffset = 0x310 + sb.Slot * 0x10;
-
-                sbDescAddress += (ulong)sbDescOffset;
-
-                SbDescriptor sbDescriptor = _channel.MemoryManager.Physical.Read<SbDescriptor>(sbDescAddress);
-
-                _channel.BufferManager.SetComputeStorageBuffer(sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size, sb.Flags);
-            }
-
             _channel.BufferManager.SetComputeStorageBufferBindings(info.SBuffers);
             _channel.BufferManager.SetComputeUniformBufferBindings(info.CBuffers);
 

Ryujinx.Graphics.Gpu/Engine/Dma/DmaClass.cs

@@ -229,7 +229,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Dma
 
                     if (target != null)
                     {
-                        ReadOnlySpan<byte> data;
+                        byte[] data;
                         if (srcLinear)
                         {
                             data = LayoutConverter.ConvertLinearStridedToLinear(

Ryujinx.Graphics.Gpu/Engine/MME/Macro.cs

@@ -62,10 +62,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 }
             }
 
-            if (_hleFunction == MacroHLEFunctionName.MultiDrawElementsIndirectCount)
+            // We don't consume the parameter buffer value, so we don't need to flush it.
+            // Doing so improves performance if the value was written by a GPU shader.
+            if (_hleFunction == MacroHLEFunctionName.DrawElementsIndirect)
+            {
+                context.GPFifo.SetFlushSkips(1);
+            }
+            else if (_hleFunction == MacroHLEFunctionName.MultiDrawElementsIndirectCount)
             {
-                // We don't consume the parameter buffer value, so we don't need to flush it.
-                // Doing so improves performance if the value was written by a GPU shader.
                 context.GPFifo.SetFlushSkips(2);
             }
         }

Ryujinx.Graphics.Gpu/Engine/MME/MacroHLE.cs

@@ -16,6 +16,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         private const int ColorStructSize = 0x40;
         private const int ZetaLayerCountOffset = 0x1230;
 
+        private const int IndirectDataEntrySize = 0x10;
+        private const int IndirectIndexedDataEntrySize = 0x14;
+
         private readonly GPFifoProcessor _processor;
         private readonly MacroHLEFunctionName _functionName;
 
@@ -27,9 +30,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         /// <summary>
         /// Creates a new instance of the HLE macro handler.
         /// </summary>
-        /// <param name="context">GPU context the macro is being executed on</param>
-        /// <param name="memoryManager">GPU memory manager</param>
-        /// <param name="engine">3D engine where this macro is being called</param>
+        /// <param name="processor">GPU GP FIFO command processor</param>
         /// <param name="functionName">Name of the HLE macro function to be called</param>
         public MacroHLE(GPFifoProcessor processor, MacroHLEFunctionName functionName)
         {
@@ -55,12 +56,24 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 case MacroHLEFunctionName.ClearDepthStencil:
                     ClearDepthStencil(state, arg0);
                     break;
+                case MacroHLEFunctionName.DrawArraysInstanced:
+                    DrawArraysInstanced(state, arg0);
+                    break;
+                case MacroHLEFunctionName.DrawElementsInstanced:
+                    DrawElementsInstanced(state, arg0);
+                    break;
+                case MacroHLEFunctionName.DrawElementsIndirect:
+                    DrawElementsIndirect(state, arg0);
+                    break;
                 case MacroHLEFunctionName.MultiDrawElementsIndirectCount:
                     MultiDrawElementsIndirectCount(state, arg0);
                     break;
                 default:
                     throw new NotImplementedException(_functionName.ToString());
             }
+
+            // It should be empty at this point, but clear it just to be safe.
+            Fifo.Clear();
         }
 
         /// <summary>
@@ -89,7 +102,118 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         }
 
         /// <summary>
-        /// Performs a indirect multi-draw, with parameters from a GPU buffer.
+        /// Performs a draw.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void DrawArraysInstanced(IDeviceState state, int arg0)
+        {
+            var topology = (PrimitiveTopology)arg0;
+
+            var count = FetchParam();
+            var instanceCount = FetchParam();
+            var firstVertex = FetchParam();
+            var firstInstance = FetchParam();
+
+            if (ShouldSkipDraw(state, instanceCount.Word))
+            {
+                return;
+            }
+
+            _processor.ThreedClass.Draw(
+                topology,
+                count.Word,
+                instanceCount.Word,
+                0,
+                firstVertex.Word,
+                firstInstance.Word,
+                indexed: false);
+        }
+
+        /// <summary>
+        /// Performs a indexed draw.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void DrawElementsInstanced(IDeviceState state, int arg0)
+        {
+            var topology = (PrimitiveTopology)arg0;
+
+            var count = FetchParam();
+            var instanceCount = FetchParam();
+            var firstIndex = FetchParam();
+            var firstVertex = FetchParam();
+            var firstInstance = FetchParam();
+
+            if (ShouldSkipDraw(state, instanceCount.Word))
+            {
+                return;
+            }
+
+            _processor.ThreedClass.Draw(
+                topology,
+                count.Word,
+                instanceCount.Word,
+                firstIndex.Word,
+                firstVertex.Word,
+                firstInstance.Word,
+                indexed: true);
+        }
+
+        /// <summary>
+        /// Performs a indirect indexed draw, with parameters from a GPU buffer.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void DrawElementsIndirect(IDeviceState state, int arg0)
+        {
+            var topology = (PrimitiveTopology)arg0;
+
+            var count = FetchParam();
+            var instanceCount = FetchParam();
+            var firstIndex = FetchParam();
+            var firstVertex = FetchParam();
+            var firstInstance = FetchParam();
+
+            ulong indirectBufferGpuVa = count.GpuVa;
+
+            var bufferCache = _processor.MemoryManager.Physical.BufferCache;
+
+            bool useBuffer = bufferCache.CheckModified(_processor.MemoryManager, indirectBufferGpuVa, IndirectIndexedDataEntrySize, out ulong indirectBufferAddress);
+
+            if (useBuffer)
+            {
+                int indexCount = firstIndex.Word + count.Word;
+
+                _processor.ThreedClass.DrawIndirect(
+                    topology,
+                    indirectBufferAddress,
+                    0,
+                    1,
+                    IndirectIndexedDataEntrySize,
+                    indexCount,
+                    Threed.IndirectDrawType.DrawIndexedIndirect);
+            }
+            else
+            {
+                if (ShouldSkipDraw(state, instanceCount.Word))
+                {
+                    return;
+                }
+
+                _processor.ThreedClass.Draw(
+                    topology,
+                    count.Word,
+                    instanceCount.Word,
+                    firstIndex.Word,
+                    firstVertex.Word,
+                    firstInstance.Word,
+                    indexed: true);
+            }
+        }
+
+        /// <summary>
+        /// Performs a indirect indexed multi-draw, with parameters from a GPU buffer.
         /// </summary>
         /// <param name="state">GPU state at the time of the call</param>
         /// <param name="arg0">First argument of the call</param>
@@ -132,8 +256,6 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 return;
             }
 
-            int indirectBufferSize = maxDrawCount * stride;
-
             ulong indirectBufferGpuVa = 0;
             int indexCount = 0;
 
@@ -142,8 +264,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 var count = FetchParam();
                 var instanceCount = FetchParam();
                 var firstIndex = FetchParam();
-                var baseVertex = FetchParam();
-                var baseInstance = FetchParam();
+                var firstVertex = FetchParam();
+                var firstInstance = FetchParam();
 
                 if (i == 0)
                 {
@@ -161,15 +283,32 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 }
             }
 
-            // It should be empty at this point, but clear it just to be safe.
-            Fifo.Clear();
-
             var bufferCache = _processor.MemoryManager.Physical.BufferCache;
 
-            var parameterBuffer = bufferCache.GetGpuBufferRange(_processor.MemoryManager, parameterBufferGpuVa, 4);
-            var indirectBuffer = bufferCache.GetGpuBufferRange(_processor.MemoryManager, indirectBufferGpuVa, (ulong)indirectBufferSize);
+            ulong indirectBufferSize = (ulong)maxDrawCount * (ulong)stride;
 
-            _processor.ThreedClass.MultiDrawIndirectCount(indexCount, topology, indirectBuffer, parameterBuffer, maxDrawCount, stride);
+            ulong indirectBufferAddress = bufferCache.TranslateAndCreateBuffer(_processor.MemoryManager, indirectBufferGpuVa, indirectBufferSize);
+            ulong parameterBufferAddress = bufferCache.TranslateAndCreateBuffer(_processor.MemoryManager, parameterBufferGpuVa, 4);
+
+            _processor.ThreedClass.DrawIndirect(
+                topology,
+                indirectBufferAddress,
+                parameterBufferAddress,
+                maxDrawCount,
+                stride,
+                indexCount,
+                Threed.IndirectDrawType.DrawIndexedIndirectCount);
+        }
+
+        /// <summary>
+        /// Checks if the draw should be skipped, because the masked instance count is zero.
+        /// </summary>
+        /// <param name="state">Current GPU state</param>
+        /// <param name="instanceCount">Draw instance count</param>
+        /// <returns>True if the draw should be skipped, false otherwise</returns>
+        private static bool ShouldSkipDraw(IDeviceState state, int instanceCount)
+        {
+            return (Read(state, 0xd1b) & instanceCount) == 0;
         }
 
         /// <summary>
@@ -189,14 +328,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         }
 
         /// <summary>
-        /// Performs a GPU method call.
+        /// Reads data from a GPU register.
         /// </summary>
         /// <param name="state">Current GPU state</param>
-        /// <param name="methAddr">Address, in words, of the method</param>
-        /// <param name="value">Call argument</param>
-        private static void Send(IDeviceState state, int methAddr, int value)
+        /// <param name="reg">Register offset to read</param>
+        /// <returns>GPU register value</returns>
+        private static int Read(IDeviceState state, int reg)
         {
-            state.Write(methAddr * 4, value);
+            return state.Read(reg * 4);
         }
     }
 }

Ryujinx.Graphics.Gpu/Engine/MME/MacroHLEFunctionName.cs

@@ -8,6 +8,9 @@
         None,
         ClearColor,
         ClearDepthStencil,
+        DrawArraysInstanced,
+        DrawElementsInstanced,
+        DrawElementsIndirect,
         MultiDrawElementsIndirectCount
     }
 }

Ryujinx.Graphics.Gpu/Engine/MME/MacroHLETable.cs

@@ -44,17 +44,29 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
             }
         }
 
-        private static readonly TableEntry[] Table = new TableEntry[]
+        private static readonly TableEntry[] _table = new TableEntry[]
         {
             new TableEntry(MacroHLEFunctionName.ClearColor, new Hash128(0xA9FB28D1DC43645A, 0xB177E5D2EAE67FB0), 0x28),
             new TableEntry(MacroHLEFunctionName.ClearDepthStencil, new Hash128(0x1B96CB77D4879F4F, 0x8557032FE0C965FB), 0x24),
+            new TableEntry(MacroHLEFunctionName.DrawArraysInstanced, new Hash128(0x197FB416269DBC26, 0x34288C01DDA82202), 0x48),
+            new TableEntry(MacroHLEFunctionName.DrawElementsInstanced, new Hash128(0x1A501FD3D54EC8E0, 0x6CF570CF79DA74D6), 0x5c),
+            new TableEntry(MacroHLEFunctionName.DrawElementsIndirect, new Hash128(0x86A3E8E903AF8F45, 0xD35BBA07C23860A4), 0x7c),
             new TableEntry(MacroHLEFunctionName.MultiDrawElementsIndirectCount, new Hash128(0x890AF57ED3FB1C37, 0x35D0C95C61F5386F), 0x19C)
         };
 
+        /// <summary>
+        /// Checks if the host supports all features required by the HLE macro.
+        /// </summary>
+        /// <param name="caps">Host capabilities</param>
+        /// <param name="name">Name of the HLE macro to be checked</param>
+        /// <returns>True if the host supports the HLE macro, false otherwise</returns>
         private static bool IsMacroHLESupported(Capabilities caps, MacroHLEFunctionName name)
         {
             if (name == MacroHLEFunctionName.ClearColor ||
-                name == MacroHLEFunctionName.ClearDepthStencil)
+                name == MacroHLEFunctionName.ClearDepthStencil ||
+                name == MacroHLEFunctionName.DrawArraysInstanced ||
+                name == MacroHLEFunctionName.DrawElementsInstanced ||
+                name == MacroHLEFunctionName.DrawElementsIndirect)
             {
                 return true;
             }
@@ -77,15 +89,20 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         {
             var mc = MemoryMarshal.Cast<int, byte>(code);
 
-            for (int i = 0; i < Table.Length; i++)
+            for (int i = 0; i < _table.Length; i++)
             {
-                ref var entry = ref Table[i];
+                ref var entry = ref _table[i];
 
                 var hash = XXHash128.ComputeHash(mc.Slice(0, entry.Length));
                 if (hash == entry.Hash)
                 {
-                    name = entry.Name;
-                    return IsMacroHLESupported(caps, name);
+                    if (IsMacroHLESupported(caps, entry.Name))
+                    {
+                        name = entry.Name;
+                        return true;
+                    }
+
+                    break;
                 }
             }
 

Ryujinx.Graphics.Gpu/Engine/Threed/ConditionalRendering.cs

@@ -63,7 +63,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             else
             {
                 evt.Flush();
-                return (memoryManager.Read<ulong>(gpuVa) != 0) ? ConditionalRenderEnabled.True : ConditionalRenderEnabled.False;
+                return (memoryManager.Read<ulong>(gpuVa, true) != 0) ? ConditionalRenderEnabled.True : ConditionalRenderEnabled.False;
             }
         }
 
@@ -108,8 +108,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 evt?.Flush();
                 evt2?.Flush();
 
-                ulong x = memoryManager.Read<ulong>(gpuVa);
-                ulong y = memoryManager.Read<ulong>(gpuVa + 16);
+                ulong x = memoryManager.Read<ulong>(gpuVa, true);
+                ulong y = memoryManager.Read<ulong>(gpuVa + 16, true);
 
                 return (isEqual ? x == y : x != y) ? ConditionalRenderEnabled.True : ConditionalRenderEnabled.False;
             }

Ryujinx.Graphics.Gpu/Engine/Threed/DrawManager.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.Types;
+using Ryujinx.Graphics.Gpu.Memory;
 using System;
 
 namespace Ryujinx.Graphics.Gpu.Engine.Threed
@@ -9,6 +10,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
     /// </summary>
     class DrawManager
     {
+        // Since we don't know the index buffer size for indirect draws,
+        // we must assume a minimum and maximum size and use that for buffer data update purposes.
+        private const int MinIndirectIndexCount = 0x10000;
+        private const int MaxIndirectIndexCount = 0x4000000;
+
         private readonly GpuContext _context;
         private readonly GpuChannel _channel;
         private readonly DeviceStateWithShadow<ThreedClassState> _state;
@@ -28,6 +34,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
         private int _instanceIndex;
 
+        private const int VertexBufferFirstMethodOffset = 0x35d;
         private const int IndexBufferCountMethodOffset = 0x5f8;
 
         /// <summary>
@@ -237,6 +244,15 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 _instanceIndex = 0;
             }
 
+            UpdateTopology(topology);
+        }
+
+        /// <summary>
+        /// Updates the current primitive topology if needed.
+        /// </summary>
+        /// <param name="topology">New primitive topology</param>
+        private void UpdateTopology(PrimitiveTopology topology)
+        {
             if (_drawState.Topology != topology || !_topologySet)
             {
                 _context.Renderer.Pipeline.SetPrimitiveTopology(topology);
@@ -383,28 +399,27 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         }
 
         /// <summary>
-        /// Performs a indirect multi-draw, with parameters from a GPU buffer.
+        /// Performs a indexed or non-indexed draw.
         /// </summary>
         /// <param name="engine">3D engine where this method is being called</param>
         /// <param name="topology">Primitive topology</param>
-        /// <param name="indirectBuffer">GPU buffer with the draw parameters, such as count, first index, etc</param>
-        /// <param name="parameterBuffer">GPU buffer with the draw count</param>
-        /// <param name="maxDrawCount">Maximum number of draws that can be made</param>
-        /// <param name="stride">Distance in bytes between each element on the <paramref name="indirectBuffer"/> array</param>
-        public void MultiDrawIndirectCount(
+        /// <param name="count">Index count for indexed draws, vertex count for non-indexed draws</param>
+        /// <param name="instanceCount">Instance count</param>
+        /// <param name="firstIndex">First index on the index buffer for indexed draws, ignored for non-indexed draws</param>
+        /// <param name="firstVertex">First vertex on the vertex buffer</param>
+        /// <param name="firstInstance">First instance</param>
+        /// <param name="indexed">True if the draw is indexed, false otherwise</param>
+        public void Draw(
             ThreedClass engine,
-            int indexCount,
             PrimitiveTopology topology,
-            BufferRange indirectBuffer,
-            BufferRange parameterBuffer,
-            int maxDrawCount,
-            int stride)
+            int count,
+            int instanceCount,
+            int firstIndex,
+            int firstVertex,
+            int firstInstance,
+            bool indexed)
         {
-            engine.Write(IndexBufferCountMethodOffset * 4, indexCount);
-
-            _context.Renderer.Pipeline.SetPrimitiveTopology(topology);
-            _drawState.Topology = topology;
-            _topologySet = true;
+            UpdateTopology(topology);
 
             ConditionalRenderEnabled renderEnable = ConditionalRendering.GetRenderEnable(
                 _context,
@@ -418,21 +433,133 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 return;
             }
 
-            _drawState.FirstIndex = _state.State.IndexBufferState.First;
-            _drawState.IndexCount = indexCount;
-
-            engine.UpdateState();
-
-            if (_drawState.DrawIndexed)
+            if (indexed)
             {
-                _context.Renderer.Pipeline.MultiDrawIndexedIndirectCount(indirectBuffer, parameterBuffer, maxDrawCount, stride);
+                _drawState.FirstIndex = firstIndex;
+                _drawState.IndexCount = count;
+                _state.State.FirstVertex = (uint)firstVertex;
+                engine.ForceStateDirty(IndexBufferCountMethodOffset * 4);
             }
             else
             {
-                _context.Renderer.Pipeline.MultiDrawIndirectCount(indirectBuffer, parameterBuffer, maxDrawCount, stride);
+                _state.State.VertexBufferDrawState.First = firstVertex;
+                _state.State.VertexBufferDrawState.Count = count;
+                engine.ForceStateDirty(VertexBufferFirstMethodOffset * 4);
+            }
+
+            _state.State.FirstInstance = (uint)firstInstance;
+
+            _drawState.DrawIndexed = indexed;
+            _drawState.HasConstantBufferDrawParameters = true;
+
+            engine.UpdateState();
+
+            if (indexed)
+            {
+                _context.Renderer.Pipeline.DrawIndexed(count, instanceCount, firstIndex, firstVertex, firstInstance);
+                _state.State.FirstVertex = 0;
+            }
+            else
+            {
+                _context.Renderer.Pipeline.Draw(count, instanceCount, firstVertex, firstInstance);
+            }
+
+            _state.State.FirstInstance = 0;
+
+            _drawState.DrawIndexed = false;
+            _drawState.HasConstantBufferDrawParameters = false;
+
+            if (renderEnable == ConditionalRenderEnabled.Host)
+            {
+                _context.Renderer.Pipeline.EndHostConditionalRendering();
+            }
+        }
+
+        /// <summary>
+        /// Performs a indirect draw, with parameters from a GPU buffer.
+        /// </summary>
+        /// <param name="engine">3D engine where this method is being called</param>
+        /// <param name="topology">Primitive topology</param>
+        /// <param name="indirectBufferAddress">Address of the buffer with the draw parameters, such as count, first index, etc</param>
+        /// <param name="parameterBufferAddress">Address of the buffer with the draw count</param>
+        /// <param name="maxDrawCount">Maximum number of draws that can be made</param>
+        /// <param name="stride">Distance in bytes between each entry on the data pointed to by <paramref name="indirectBufferAddress"/></param>
+        /// <param name="indexCount">Maximum number of indices that the draw can consume</param>
+        /// <param name="drawType">Type of the indirect draw, which can be indexed or non-indexed, with or without a draw count</param>
+        public void DrawIndirect(
+            ThreedClass engine,
+            PrimitiveTopology topology,
+            ulong indirectBufferAddress,
+            ulong parameterBufferAddress,
+            int maxDrawCount,
+            int stride,
+            int indexCount,
+            IndirectDrawType drawType)
+        {
+            UpdateTopology(topology);
+
+            ConditionalRenderEnabled renderEnable = ConditionalRendering.GetRenderEnable(
+                _context,
+                _channel.MemoryManager,
+                _state.State.RenderEnableAddress,
+                _state.State.RenderEnableCondition);
+
+            if (renderEnable == ConditionalRenderEnabled.False)
+            {
+                _drawState.DrawIndexed = false;
+                return;
+            }
+
+            PhysicalMemory memory = _channel.MemoryManager.Physical;
+
+            bool hasCount = (drawType & IndirectDrawType.Count) != 0;
+            bool indexed = (drawType & IndirectDrawType.Indexed) != 0;
+
+            if (indexed)
+            {
+                indexCount = Math.Clamp(indexCount, MinIndirectIndexCount, MaxIndirectIndexCount);
+                _drawState.FirstIndex = 0;
+                _drawState.IndexCount = indexCount;
+                engine.ForceStateDirty(IndexBufferCountMethodOffset * 4);
+            }
+
+            _drawState.DrawIndexed = indexed;
+            _drawState.DrawIndirect = true;
+            _drawState.HasConstantBufferDrawParameters = true;
+
+            engine.UpdateState();
+
+            if (hasCount)
+            {
+                var indirectBuffer = memory.BufferCache.GetBufferRange(indirectBufferAddress, (ulong)maxDrawCount * (ulong)stride);
+                var parameterBuffer = memory.BufferCache.GetBufferRange(parameterBufferAddress, 4);
+
+                if (indexed)
+                {
+                    _context.Renderer.Pipeline.DrawIndexedIndirectCount(indirectBuffer, parameterBuffer, maxDrawCount, stride);
+                }
+                else
+                {
+                    _context.Renderer.Pipeline.DrawIndirectCount(indirectBuffer, parameterBuffer, maxDrawCount, stride);
+                }
+            }
+            else
+            {
+                var indirectBuffer = memory.BufferCache.GetBufferRange(indirectBufferAddress, (ulong)stride);
+
+                if (indexed)
+                {
+                    _context.Renderer.Pipeline.DrawIndexedIndirect(indirectBuffer);
+                }
+                else
+                {
+                    _context.Renderer.Pipeline.DrawIndirect(indirectBuffer);
+                }
             }
 
             _drawState.DrawIndexed = false;
+            _drawState.DrawIndirect = false;
+            _drawState.HasConstantBufferDrawParameters = false;
 
             if (renderEnable == ConditionalRenderEnabled.Host)
             {

Ryujinx.Graphics.Gpu/Engine/Threed/DrawState.cs

@@ -22,6 +22,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         public bool DrawIndexed;
 
+        /// <summary>
+        /// Indicates if the next draw will be a indirect draw.
+        /// </summary>
+        public bool DrawIndirect;
+
         /// <summary>
         /// Indicates if any of the currently used vertex shaders reads the instance ID.
         /// </summary>
@@ -32,6 +37,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         public bool IsAnyVbInstanced;
 
+        /// <summary>
+        /// Indicates that the draw is writing the base vertex, base instance and draw index to Constant Buffer 0.
+        /// </summary>
+        public bool HasConstantBufferDrawParameters;
+
         /// <summary>
         /// Primitive topology for the next draw.
         /// </summary>

Ryujinx.Graphics.Gpu/Engine/Threed/IndirectDrawType.cs

@@ -0,0 +1,38 @@
+namespace Ryujinx.Graphics.Gpu.Engine.Threed
+{
+    /// <summary>
+    /// Indirect draw type, which can be indexed or non-indexed, with or without a draw count.
+    /// </summary>
+    enum IndirectDrawType
+    {
+        /// <summary>
+        /// Non-indexed draw without draw count.
+        /// </summary>
+        DrawIndirect = 0,
+
+        /// <summary>
+        /// Indexed draw without draw count.
+        /// </summary>
+        DrawIndexedIndirect = Indexed,
+
+        /// <summary>
+        /// Non-indexed draw with draw count.
+        /// </summary>
+        DrawIndirectCount = Count,
+
+        /// <summary>
+        /// Indexed draw with draw count.
+        /// </summary>
+        DrawIndexedIndirectCount = Indexed | Count,
+
+        /// <summary>
+        /// Indexed flag.
+        /// </summary>
+        Indexed = 1 << 0,
+
+        /// <summary>
+        /// Draw count flag.
+        /// </summary>
+        Count = 1 << 1
+    }
+}

Ryujinx.Graphics.Gpu/Engine/Threed/StateUpdater.cs

@@ -34,10 +34,12 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
         private ProgramPipelineState _pipeline;
 
+        private bool _vsUsesDrawParameters;
         private bool _vtgWritesRtLayer;
         private byte _vsClipDistancesWritten;
 
         private bool _prevDrawIndexed;
+        private bool _prevDrawIndirect;
         private IndexType _prevIndexType;
         private uint _prevFirstVertex;
         private bool _prevTfEnable;
@@ -210,7 +212,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             // of the shader for the new state.
             if (_shaderSpecState != null)
             {
-                if (!_shaderSpecState.MatchesGraphics(_channel, GetPoolState(), GetGraphicsState(), false))
+                if (!_shaderSpecState.MatchesGraphics(_channel, GetPoolState(), GetGraphicsState(), _vsUsesDrawParameters, false))
                 {
                     ForceShaderUpdate();
                 }
@@ -237,6 +239,15 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 _prevDrawIndexed = _drawState.DrawIndexed;
             }
 
+            // Some draw parameters are used to restrict the vertex buffer size,
+            // but they can't be used on indirect draws because their values are unknown in this case.
+            // When switching between indirect and non-indirect draw, we need to
+            // make sure the vertex buffer sizes are still correct.
+            if (_drawState.DrawIndirect != _prevDrawIndirect)
+            {
+                _updateTracker.ForceDirty(VertexBufferStateIndex);
+            }
+
             // In some cases, the index type is also used to guess the
             // vertex buffer size, so we must update it if the type changed too.
             if (_drawState.DrawIndexed &&
@@ -282,9 +293,12 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         private void CommitBindings()
         {
+            var buffers = _channel.BufferManager;
+            var hasUnaligned = buffers.HasUnalignedStorageBuffers;
+
             UpdateStorageBuffers();
 
-            if (!_channel.TextureManager.CommitGraphicsBindings(_shaderSpecState))
+            if (!_channel.TextureManager.CommitGraphicsBindings(_shaderSpecState) || (buffers.HasUnalignedStorageBuffers != hasUnaligned))
             {
                 // Shader must be reloaded.
                 UpdateShaderState();
@@ -938,6 +952,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             _drawState.IsAnyVbInstanced = false;
 
+            bool drawIndexed = _drawState.DrawIndexed;
+            bool drawIndirect = _drawState.DrawIndirect;
+
             for (int index = 0; index < Constants.TotalVertexBuffers; index++)
             {
                 var vertexBuffer = _state.State.VertexBufferState[index];
@@ -965,14 +982,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 ulong vbSize = endAddress.Pack() - address + 1;
                 ulong size;
 
-                if (_drawState.IbStreamer.HasInlineIndexData || _drawState.DrawIndexed || stride == 0 || instanced)
+                if (_drawState.IbStreamer.HasInlineIndexData || drawIndexed || stride == 0 || instanced)
                 {
                     // This size may be (much) larger than the real vertex buffer size.
                     // Avoid calculating it this way, unless we don't have any other option.
 
                     size = vbSize;
 
-                    if (stride > 0 && indexTypeSmall && _drawState.DrawIndexed && !instanced)
+                    if (stride > 0 && indexTypeSmall && drawIndexed && !drawIndirect && !instanced)
                     {
                         // If the index type is a small integer type, then we might be still able
                         // to reduce the vertex buffer size based on the maximum possible index value.
@@ -1207,6 +1224,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             byte oldVsClipDistancesWritten = _vsClipDistancesWritten;
 
             _drawState.VsUsesInstanceId = gs.Shaders[1]?.Info.UsesInstanceId ?? false;
+            _vsUsesDrawParameters = gs.Shaders[1]?.Info.UsesDrawParameters ?? false;
             _vsClipDistancesWritten = gs.Shaders[1]?.Info.ClipDistancesWritten ?? 0;
 
             if (oldVsClipDistancesWritten != _vsClipDistancesWritten)
@@ -1222,6 +1240,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             _context.Renderer.Pipeline.SetProgram(gs.HostProgram);
         }
 
+        /// <summary>
+        /// Updates bindings consumed by the shader stage on the texture and buffer managers.
+        /// </summary>
+        /// <param name="stage">Shader stage to have the bindings updated</param>
+        /// <param name="info">Shader stage bindings info</param>
         private void UpdateStageBindings(int stage, ShaderProgramInfo info)
         {
             _currentProgramInfo[stage] = info;
@@ -1340,7 +1363,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 _state.State.AlphaTestEnable,
                 _state.State.AlphaTestFunc,
                 _state.State.AlphaTestRef,
-                ref attributeTypes);
+                ref attributeTypes,
+                _drawState.HasConstantBufferDrawParameters,
+                _channel.BufferManager.HasUnalignedStorageBuffers);
         }
 
         /// <summary>

Ryujinx.Graphics.Gpu/Engine/Threed/ThreedClass.cs

@@ -497,6 +497,50 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             return 0;
         }
 
+        /// <summary>
+        /// Performs a indexed or non-indexed draw.
+        /// </summary>
+        /// <param name="topology">Primitive topology</param>
+        /// <param name="count">Index count for indexed draws, vertex count for non-indexed draws</param>
+        /// <param name="instanceCount">Instance count</param>
+        /// <param name="firstIndex">First index on the index buffer for indexed draws, ignored for non-indexed draws</param>
+        /// <param name="firstVertex">First vertex on the vertex buffer</param>
+        /// <param name="firstInstance">First instance</param>
+        /// <param name="indexed">True if the draw is indexed, false otherwise</param>
+        public void Draw(
+            PrimitiveTopology topology,
+            int count,
+            int instanceCount,
+            int firstIndex,
+            int firstVertex,
+            int firstInstance,
+            bool indexed)
+        {
+            _drawManager.Draw(this, topology, count, instanceCount, firstIndex, firstVertex, firstInstance, indexed);
+        }
+
+        /// <summary>
+        /// Performs a indirect draw, with parameters from a GPU buffer.
+        /// </summary>
+        /// <param name="topology">Primitive topology</param>
+        /// <param name="indirectBufferAddress">Address of the buffer with the draw parameters, such as count, first index, etc</param>
+        /// <param name="parameterBufferAddress">Address of the buffer with the draw count</param>
+        /// <param name="maxDrawCount">Maximum number of draws that can be made</param>
+        /// <param name="stride">Distance in bytes between each entry on the data pointed to by <paramref name="indirectBufferAddress"/></param>
+        /// <param name="indexCount">Maximum number of indices that the draw can consume</param>
+        /// <param name="drawType">Type of the indirect draw, which can be indexed or non-indexed, with or without a draw count</param>
+        public void DrawIndirect(
+            PrimitiveTopology topology,
+            ulong indirectBufferAddress,
+            ulong parameterBufferAddress,
+            int maxDrawCount,
+            int stride,
+            int indexCount,
+            IndirectDrawType drawType)
+        {
+            _drawManager.DrawIndirect(this, topology, indirectBufferAddress, parameterBufferAddress, maxDrawCount, stride, indexCount, drawType);
+        }
+
         /// <summary>
         /// Clears the current color and depth-stencil buffers.
         /// Which buffers should be cleared can also specified with the arguments.
@@ -507,25 +551,5 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         {
             _drawManager.Clear(this, argument, layerCount);
         }
-
-        /// <summary>
-        /// Performs a indirect multi-draw, with parameters from a GPU buffer.
-        /// </summary>
-        /// <param name="indexCount">Index Buffer Count</param>
-        /// <param name="topology">Primitive topology</param>
-        /// <param name="indirectBuffer">GPU buffer with the draw parameters, such as count, first index, etc</param>
-        /// <param name="parameterBuffer">GPU buffer with the draw count</param>
-        /// <param name="maxDrawCount">Maximum number of draws that can be made</param>
-        /// <param name="stride">Distance in bytes between each element on the <paramref name="indirectBuffer"/> array</param>
-        public void MultiDrawIndirectCount(
-            int indexCount,
-            PrimitiveTopology topology,
-            BufferRange indirectBuffer,
-            BufferRange parameterBuffer,
-            int maxDrawCount,
-            int stride)
-        {
-            _drawManager.MultiDrawIndirectCount(this, indexCount, topology, indirectBuffer, parameterBuffer, maxDrawCount, stride);
-        }
     }
 }

Ryujinx.Graphics.Gpu/GpuChannel.cs

@@ -67,6 +67,7 @@ namespace Ryujinx.Graphics.Gpu
 
             // Since the memory manager changed, make sure we will get pools from addresses of the new memory manager.
             TextureManager.ReloadPools();
+            MemoryManager.Physical.BufferCache.QueuePrune();
         }
 
         /// <summary>
@@ -77,6 +78,7 @@ namespace Ryujinx.Graphics.Gpu
         private void MemoryUnmappedHandler(object sender, UnmapEventArgs e)
         {
             TextureManager.ReloadPools();
+            MemoryManager.Physical.BufferCache.QueuePrune();
         }
 
         /// <summary>

Ryujinx.Graphics.Gpu/Image/Texture.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Common;
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Memory;
 using Ryujinx.Graphics.Texture;
@@ -136,11 +137,6 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         public LinkedListNode<Texture> CacheNode { get; set; }
 
-        /// <summary>
-        /// Event to fire when texture data is disposed.
-        /// </summary>
-        public event Action<Texture> Disposed;
-
         /// <summary>
         /// Physical memory ranges where the texture data is located.
         /// </summary>
@@ -712,17 +708,18 @@ namespace Ryujinx.Graphics.Gpu.Image
                 else
                 {
                     bool dataMatches = _currentData != null && data.SequenceEqual(_currentData);
-                    _currentData = data.ToArray();
                     if (dataMatches)
                     {
                         return;
                     }
+
+                    _currentData = data.ToArray();
                 }
             }
 
-            data = ConvertToHostCompatibleFormat(data);
+            SpanOrArray<byte> result = ConvertToHostCompatibleFormat(data);
 
-            HostTexture.SetData(data);
+            HostTexture.SetData(result);
 
             _hasData = true;
         }
@@ -731,7 +728,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// Uploads new texture data to the host GPU.
         /// </summary>
         /// <param name="data">New data</param>
-        public void SetData(ReadOnlySpan<byte> data)
+        public void SetData(SpanOrArray<byte> data)
         {
             BlacklistScale();
 
@@ -750,7 +747,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="data">New data</param>
         /// <param name="layer">Target layer</param>
         /// <param name="level">Target level</param>
-        public void SetData(ReadOnlySpan<byte> data, int layer, int level)
+        public void SetData(SpanOrArray<byte> data, int layer, int level)
         {
             BlacklistScale();
 
@@ -786,7 +783,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="level">Mip level to convert</param>
         /// <param name="single">True to convert a single slice</param>
         /// <returns>Converted data</returns>
-        public ReadOnlySpan<byte> ConvertToHostCompatibleFormat(ReadOnlySpan<byte> data, int level = 0, bool single = false)
+        public SpanOrArray<byte> ConvertToHostCompatibleFormat(ReadOnlySpan<byte> data, int level = 0, bool single = false)
         {
             int width = Info.Width;
             int height = Info.Height;
@@ -799,9 +796,11 @@ namespace Ryujinx.Graphics.Gpu.Image
             height = Math.Max(height >> level, 1);
             depth = Math.Max(depth >> level, 1);
 
+            SpanOrArray<byte> result;
+
             if (Info.IsLinear)
             {
-                data = LayoutConverter.ConvertLinearStridedToLinear(
+                result = LayoutConverter.ConvertLinearStridedToLinear(
                     width,
                     height,
                     Info.FormatInfo.BlockWidth,
@@ -813,7 +812,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
             else
             {
-                data = LayoutConverter.ConvertBlockLinearToLinear(
+                result = LayoutConverter.ConvertBlockLinearToLinear(
                     width,
                     height,
                     depth,
@@ -836,7 +835,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             if (!_context.Capabilities.SupportsAstcCompression && Format.IsAstc())
             {
                 if (!AstcDecoder.TryDecodeToRgba8P(
-                    data.ToArray(),
+                    result.ToArray(),
                     Info.FormatInfo.BlockWidth,
                     Info.FormatInfo.BlockHeight,
                     width,
@@ -856,11 +855,11 @@ namespace Ryujinx.Graphics.Gpu.Image
                     decoded = BCnEncoder.EncodeBC7(decoded, width, height, depth, levels, layers);
                 }
 
-                data = decoded;
+                result = decoded;
             }
             else if (!_context.Capabilities.SupportsR4G4Format && Format == Format.R4G4Unorm)
             {
-                data = PixelConverter.ConvertR4G4ToR4G4B4A4(data);
+                result = PixelConverter.ConvertR4G4ToR4G4B4A4(result);
             }
             else if (!TextureCompatibility.HostSupportsBcFormat(Format, Target, _context.Capabilities))
             {
@@ -868,36 +867,36 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     case Format.Bc1RgbaSrgb:
                     case Format.Bc1RgbaUnorm:
-                        data = BCnDecoder.DecodeBC1(data, width, height, depth, levels, layers);
+                        result = BCnDecoder.DecodeBC1(result, width, height, depth, levels, layers);
                         break;
                     case Format.Bc2Srgb:
                     case Format.Bc2Unorm:
-                        data = BCnDecoder.DecodeBC2(data, width, height, depth, levels, layers);
+                        result = BCnDecoder.DecodeBC2(result, width, height, depth, levels, layers);
                         break;
                     case Format.Bc3Srgb:
                     case Format.Bc3Unorm:
-                        data = BCnDecoder.DecodeBC3(data, width, height, depth, levels, layers);
+                        result = BCnDecoder.DecodeBC3(result, width, height, depth, levels, layers);
                         break;
                     case Format.Bc4Snorm:
                     case Format.Bc4Unorm:
-                        data = BCnDecoder.DecodeBC4(data, width, height, depth, levels, layers, Format == Format.Bc4Snorm);
+                        result = BCnDecoder.DecodeBC4(result, width, height, depth, levels, layers, Format == Format.Bc4Snorm);
                         break;
                     case Format.Bc5Snorm:
                     case Format.Bc5Unorm:
-                        data = BCnDecoder.DecodeBC5(data, width, height, depth, levels, layers, Format == Format.Bc5Snorm);
+                        result = BCnDecoder.DecodeBC5(result, width, height, depth, levels, layers, Format == Format.Bc5Snorm);
                         break;
                     case Format.Bc6HSfloat:
                     case Format.Bc6HUfloat:
-                        data = BCnDecoder.DecodeBC6(data, width, height, depth, levels, layers, Format == Format.Bc6HSfloat);
+                        result = BCnDecoder.DecodeBC6(result, width, height, depth, levels, layers, Format == Format.Bc6HSfloat);
                         break;
                     case Format.Bc7Srgb:
                     case Format.Bc7Unorm:
-                        data = BCnDecoder.DecodeBC7(data, width, height, depth, levels, layers);
+                        result = BCnDecoder.DecodeBC7(result, width, height, depth, levels, layers);
                         break;
                 }
             }
 
-            return data;
+            return result;
         }
 
         /// <summary>
@@ -1445,7 +1444,6 @@ namespace Ryujinx.Graphics.Gpu.Image
             DisposeTextures();
 
             HostTexture = hostTexture;
-            InvalidatedSequence++;
         }
 
         /// <summary>
@@ -1600,6 +1598,8 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         private void DisposeTextures()
         {
+            InvalidatedSequence++;
+
             _currentData = null;
             HostTexture.Release();
 
@@ -1634,8 +1634,6 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             DisposeTextures();
 
-            Disposed?.Invoke(this);
-
             if (Group.Storage == this)
             {
                 Group.Dispose();

Ryujinx.Graphics.Gpu/Image/TextureBindingsManager.cs

@@ -413,10 +413,10 @@ namespace Ryujinx.Graphics.Gpu.Image
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void UpdateCachedBuffer(
             int stageIndex,
-            ref int cachedTextureBufferIndex,
-            ref int cachedSamplerBufferIndex,
-            ref ReadOnlySpan<int> cachedTextureBuffer,
-            ref ReadOnlySpan<int> cachedSamplerBuffer,
+            scoped ref int cachedTextureBufferIndex,
+            scoped ref int cachedSamplerBufferIndex,
+            scoped ref ReadOnlySpan<int> cachedTextureBuffer,
+            scoped ref ReadOnlySpan<int> cachedSamplerBuffer,
             int textureBufferIndex,
             int samplerBufferIndex)
         {

Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs

@@ -710,7 +710,12 @@ namespace Ryujinx.Graphics.Gpu.Image
                     break;
                 case Target.Texture2DMultisample:
                 case Target.Texture2DMultisampleArray:
-                    if (rhs.Target == Target.Texture2D || rhs.Target == Target.Texture2DArray)
+                    // We don't support copy between multisample and non-multisample depth-stencil textures
+                    // because there's no way to emulate that since most GPUs don't support writing a
+                    // custom stencil value into the texture, among several other API limitations.
+
+                    if ((rhs.Target == Target.Texture2D || rhs.Target == Target.Texture2DArray) &&
+                        !rhs.FormatInfo.Format.IsDepthOrStencil())
                     {
                         return TextureViewCompatibility.CopyOnly;
                     }

Ryujinx.Graphics.Gpu/Image/TextureGroup.cs

@@ -1,4 +1,5 @@
-using Ryujinx.Cpu.Tracking;
+using Ryujinx.Common.Memory;
+using Ryujinx.Cpu.Tracking;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Memory;
 using Ryujinx.Graphics.Texture;
@@ -348,9 +349,9 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                             ReadOnlySpan<byte> data = _physicalMemory.GetSpan(Storage.Range.GetSlice((ulong)offset, (ulong)size));
 
-                            data = Storage.ConvertToHostCompatibleFormat(data, info.BaseLevel, true);
+                            SpanOrArray<byte> result = Storage.ConvertToHostCompatibleFormat(data, info.BaseLevel, true);
 
-                            Storage.SetData(data, info.BaseLayer, info.BaseLevel);
+                            Storage.SetData(result, info.BaseLayer, info.BaseLevel);
 
                             offsetIndex++;
                         }

Ryujinx.Graphics.Gpu/Memory/BufferCache.cs

@@ -27,6 +27,8 @@ namespace Ryujinx.Graphics.Gpu.Memory
         private Buffer[] _bufferOverlaps;
 
         private readonly Dictionary<ulong, BufferCacheEntry> _dirtyCache;
+        private readonly Dictionary<ulong, BufferCacheEntry> _modifiedCache;
+        private bool _pruneCaches;
 
         public event Action NotifyBuffersModified;
 
@@ -45,6 +47,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
             _bufferOverlaps = new Buffer[OverlapsBufferInitialCapacity];
 
             _dirtyCache = new Dictionary<ulong, BufferCacheEntry>();
+
+            // There are a lot more entries on the modified cache, so it is separate from the one for ForceDirty.
+            _modifiedCache = new Dictionary<ulong, BufferCacheEntry>();
         }
 
         /// <summary>
@@ -132,6 +137,11 @@ namespace Ryujinx.Graphics.Gpu.Memory
         /// <param name="size">Size in bytes of the buffer</param>
         public void ForceDirty(MemoryManager memoryManager, ulong gpuVa, ulong size)
         {
+            if (_pruneCaches)
+            {
+                Prune();
+            }
+
             if (!_dirtyCache.TryGetValue(gpuVa, out BufferCacheEntry result) ||
                 result.EndGpuAddress < gpuVa + size ||
                 result.UnmappedSequence != result.Buffer.UnmappedSequence)
@@ -145,6 +155,42 @@ namespace Ryujinx.Graphics.Gpu.Memory
             result.Buffer.ForceDirty(result.Address, size);
         }
 
+        /// <summary>
+        /// Checks if the given buffer range has been GPU modifed.
+        /// </summary>
+        /// <param name="memoryManager">GPU memory manager where the buffer is mapped</param>
+        /// <param name="gpuVa">Start GPU virtual address of the buffer</param>
+        /// <param name="size">Size in bytes of the buffer</param>
+        /// <returns>True if modified, false otherwise</returns>
+        public bool CheckModified(MemoryManager memoryManager, ulong gpuVa, ulong size, out ulong outAddr)
+        {
+            if (_pruneCaches)
+            {
+                Prune();
+            }
+
+            // Align the address to avoid creating too many entries on the quick lookup dictionary.
+            ulong mask = BufferAlignmentMask;
+            ulong alignedGpuVa = gpuVa & (~mask);
+            ulong alignedEndGpuVa = (gpuVa + size + mask) & (~mask);
+
+            size = alignedEndGpuVa - alignedGpuVa;
+
+            if (!_modifiedCache.TryGetValue(alignedGpuVa, out BufferCacheEntry result) ||
+                result.EndGpuAddress < alignedEndGpuVa ||
+                result.UnmappedSequence != result.Buffer.UnmappedSequence)
+            {
+                ulong address = TranslateAndCreateBuffer(memoryManager, alignedGpuVa, size);
+                result = new BufferCacheEntry(address, alignedGpuVa, GetBuffer(address, size));
+
+                _modifiedCache[alignedGpuVa] = result;
+            }
+
+            outAddr = result.Address | (gpuVa & mask);
+
+            return result.Buffer.IsModified(result.Address, size);
+        }
+
         /// <summary>
         /// Creates a new buffer for the specified range, if needed.
         /// If a buffer where this range can be fully contained already exists,
@@ -326,18 +372,6 @@ namespace Ryujinx.Graphics.Gpu.Memory
             buffer.SignalModified(address, size);
         }
 
-        /// <summary>
-        /// Gets a buffer sub-range for a given GPU memory range.
-        /// </summary>
-        /// <param name="memoryManager">GPU memory manager where the buffer is mapped</param>
-        /// <param name="gpuVa">Start GPU virtual address of the buffer</param>
-        /// <param name="size">Size in bytes of the buffer</param>
-        /// <returns>The buffer sub-range for the given range</returns>
-        public BufferRange GetGpuBufferRange(MemoryManager memoryManager, ulong gpuVa, ulong size)
-        {
-            return GetBufferRange(TranslateAndCreateBuffer(memoryManager, gpuVa, size), size);
-        }
-
         /// <summary>
         /// Gets a buffer sub-range starting at a given memory address.
         /// </summary>
@@ -419,6 +453,54 @@ namespace Ryujinx.Graphics.Gpu.Memory
             }
         }
 
+        /// <summary>
+        /// Prune any invalid entries from a quick access dictionary.
+        /// </summary>
+        /// <param name="dictionary">Dictionary to prune</param>
+        /// <param name="toDelete">List used to track entries to delete</param>
+        private void Prune(Dictionary<ulong, BufferCacheEntry> dictionary, ref List<ulong> toDelete)
+        {
+            foreach (var entry in dictionary)
+            {
+                if (entry.Value.UnmappedSequence != entry.Value.Buffer.UnmappedSequence)
+                {
+                    (toDelete ??= new()).Add(entry.Key);
+                }
+            }
+
+            if (toDelete != null)
+            {
+                foreach (ulong entry in toDelete)
+                {
+                    dictionary.Remove(entry);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Prune any invalid entries from the quick access dictionaries.
+        /// </summary>
+        private void Prune()
+        {
+            List<ulong> toDelete = null;
+
+            Prune(_dirtyCache, ref toDelete);
+
+            toDelete?.Clear();
+
+            Prune(_modifiedCache, ref toDelete);
+
+            _pruneCaches = false;
+        }
+
+        /// <summary>
+        /// Queues a prune of invalid entries the next time a dictionary cache is accessed.
+        /// </summary>
+        public void QueuePrune()
+        {
+            _pruneCaches = true;
+        }
+
         /// <summary>
         /// Disposes all buffers in the cache.
         /// It's an error to use the buffer manager after disposal.

Ryujinx.Graphics.Gpu/Memory/BufferManager.cs

@@ -17,6 +17,9 @@ namespace Ryujinx.Graphics.Gpu.Memory
         private readonly GpuContext _context;
         private readonly GpuChannel _channel;
 
+        private int _unalignedStorageBuffers;
+        public bool HasUnalignedStorageBuffers => _unalignedStorageBuffers > 0;
+
         private IndexBuffer _indexBuffer;
         private readonly VertexBuffer[] _vertexBuffers;
         private readonly BufferBounds[] _transformFeedbackBuffers;
@@ -38,6 +41,11 @@ namespace Ryujinx.Graphics.Gpu.Memory
             /// </summary>
             public BufferBounds[] Buffers { get; }
 
+            /// <summary>
+            /// Flag indicating if this binding is unaligned.
+            /// </summary>
+            public bool[] Unaligned { get; }
+
             /// <summary>
             /// Total amount of buffers used on the shader.
             /// </summary>
@@ -51,6 +59,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
             {
                 Bindings = new BufferDescriptor[count];
                 Buffers = new BufferBounds[count];
+                Unaligned = new bool[count];
             }
 
             /// <summary>
@@ -202,6 +211,31 @@ namespace Ryujinx.Graphics.Gpu.Memory
             _transformFeedbackBuffersDirty = true;
         }
 
+        /// <summary>
+        /// Records the alignment of a storage buffer.
+        /// Unaligned storage buffers disable some optimizations on the shader.
+        /// </summary>
+        /// <param name="buffers">The binding list to modify</param>
+        /// <param name="index">Index of the storage buffer</param>
+        /// <param name="gpuVa">Start GPU virtual address of the buffer</param>
+        private void RecordStorageAlignment(BuffersPerStage buffers, int index, ulong gpuVa)
+        {
+            bool unaligned = (gpuVa & (Constants.StorageAlignment - 1)) != 0;
+
+            if (unaligned || HasUnalignedStorageBuffers)
+            {
+                // Check if the alignment changed for this binding.
+
+                ref bool currentUnaligned = ref buffers.Unaligned[index];
+
+                if (currentUnaligned != unaligned)
+                {
+                    currentUnaligned = unaligned;
+                    _unalignedStorageBuffers += unaligned ? 1 : -1;
+                }
+            }
+        }
+
         /// <summary>
         /// Sets a storage buffer on the compute pipeline.
         /// Storage buffers can be read and written to on shaders.
@@ -214,6 +248,8 @@ namespace Ryujinx.Graphics.Gpu.Memory
         {
             size += gpuVa & ((ulong)_context.Capabilities.StorageBufferOffsetAlignment - 1);
 
+            RecordStorageAlignment(_cpStorageBuffers, index, gpuVa);
+
             gpuVa = BitUtils.AlignDown(gpuVa, _context.Capabilities.StorageBufferOffsetAlignment);
 
             ulong address = _channel.MemoryManager.Physical.BufferCache.TranslateAndCreateBuffer(_channel.MemoryManager, gpuVa, size);
@@ -234,17 +270,21 @@ namespace Ryujinx.Graphics.Gpu.Memory
         {
             size += gpuVa & ((ulong)_context.Capabilities.StorageBufferOffsetAlignment - 1);
 
+            BuffersPerStage buffers = _gpStorageBuffers[stage];
+
+            RecordStorageAlignment(buffers, index, gpuVa);
+
             gpuVa = BitUtils.AlignDown(gpuVa, _context.Capabilities.StorageBufferOffsetAlignment);
 
             ulong address = _channel.MemoryManager.Physical.BufferCache.TranslateAndCreateBuffer(_channel.MemoryManager, gpuVa, size);
 
-            if (_gpStorageBuffers[stage].Buffers[index].Address != address ||
-                _gpStorageBuffers[stage].Buffers[index].Size != size)
+            if (buffers.Buffers[index].Address != address ||
+                buffers.Buffers[index].Size != size)
             {
                 _gpStorageBuffersDirty = true;
             }
 
-            _gpStorageBuffers[stage].SetBounds(index, address, size, flags);
+            buffers.SetBounds(index, address, size, flags);
         }
 
         /// <summary>