GUI: Add option to register file types (#4250 )

* Add FileAssociationHelper.cs * Add register file types option to gtk * Add register file types option to avalonia * Add Windows support to FileAssociationHelper.cs * linux: Add uninstall support for file types * Ignore .glade~ backup files * Rename Register/Unregister methods * gtk: Add manage file types submenu * ava: Add manage file types submenu * windows: Add uninstall support for file types * Don't invert uninstall condition (formatting change) Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Add IsTypesRegisteredWindows & Fix Windows install function * Add AreMimeTypesRegisteredLinux() * Fix wrong indention Co-authored-by: AcK77 <acoustik666@gmail.com> Co-authored-by: gdkchan <gab.dark.100@gmail.com>
Handle parsing of corrupt Config.json and prevent crash on launch (#4309 )
2023-01-22 17:39:00 +00:00 · 2023-01-22 17:04:33 +01:00 · 2023-01-22 14:15:49 +00:00 · 2023-01-22 11:21:52 +01:00 · 2023-01-22 02:03:30 +00:00 · 2023-01-22 01:42:55 +01:00
118 changed files with 946 additions and 785 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -170,3 +170,6 @@ launchSettings.json

 # NetCore Publishing Profiles
 PublishProfiles/
+
+# Glade backup files
+*.glade~
--- a/ARMeilleure/ARMeilleure.csproj
+++ b/ARMeilleure/ARMeilleure.csproj
@@ -16,4 +16,10 @@
    </ContentWithTargetPath>
  </ItemGroup>

+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>Ryujinx.Tests</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
+
 </Project>
--- a/ARMeilleure/CodeGen/Arm64/CodeGenCommon.cs
+++ b/ARMeilleure/CodeGen/Arm64/CodeGenCommon.cs
@@ -1,5 +1,4 @@
 using ARMeilleure.IntermediateRepresentation;
-using System;
 using System.Numerics;

 namespace ARMeilleure.CodeGen.Arm64
@@ -32,9 +31,12 @@ namespace ARMeilleure.CodeGen.Arm64

        public static bool TryEncodeBitMask(Operand operand, out int immN, out int immS, out int immR)
        {
-            ulong value = operand.Value;
+            return TryEncodeBitMask(operand.Type, operand.Value, out immN, out immS, out immR);
+        }

-            if (operand.Type == OperandType.I32)
+        public static bool TryEncodeBitMask(OperandType type, ulong value, out int immN, out int immS, out int immR)
+        {
+            if (type == OperandType.I32)
            {
                value |= value << 32;
            }
@@ -50,7 +52,7 @@ namespace ARMeilleure.CodeGen.Arm64
            // Any value AND all ones will be equal itself, so it's effectively a no-op.
            // Any value OR all ones will be equal all ones, so one can just use MOV.
            // Any value XOR all ones will be equal its inverse, so one can just use MVN.
-            if (value == ulong.MaxValue)
+            if (value == 0 || value == ulong.MaxValue)
            {
                immN = 0;
                immS = 0;
@@ -59,79 +61,18 @@ namespace ARMeilleure.CodeGen.Arm64
                return false;
            }

-            int bitLength = CountSequence(value);
+            // Normalize value, rotating it such that the LSB is 1: Ensures we get a complete element that has not
+            // been cut-in-half across the word boundary.
+            int rotation = BitOperations.TrailingZeroCount(value & (value + 1));
+            ulong rotatedValue = ulong.RotateRight(value, rotation);

-            if ((value >> bitLength) != 0)
-            {
-                bitLength += CountSequence(value >> bitLength);
-            }
+            // Now that we have a complete element in the LSB with the LSB = 1, determine size and number of ones
+            // in element.
+            int elementSize = BitOperations.TrailingZeroCount(rotatedValue & (rotatedValue + 1));
+            int onesInElement = BitOperations.TrailingZeroCount(~rotatedValue);

-            int bitLengthLog2 = BitOperations.Log2((uint)bitLength);
-            int bitLengthPow2 = 1 << bitLengthLog2;
-
-            if (bitLengthPow2 < bitLength)
-            {
-                bitLengthLog2++;
-                bitLengthPow2 <<= 1;
-            }
-
-            int selectedESize = 64;
-            int repetitions = 1;
-            int onesCount = BitOperations.PopCount(value);
-
-            if (bitLengthPow2 < 64 && (value >> bitLengthPow2) != 0)
-            {
-                for (int eSizeLog2 = bitLengthLog2; eSizeLog2 < 6; eSizeLog2++)
-                {
-                    bool match = true;
-                    int eSize = 1 << eSizeLog2;
-                    ulong mask = (1UL << eSize) - 1;
-                    ulong eValue = value & mask;
-
-                    for (int e = 1; e < 64 / eSize; e++)
-                    {
-                        if (((value >> (e * eSize)) & mask) != eValue)
-                        {
-                            match = false;
-                            break;
-                        }
-                    }
-
-                    if (match)
-                    {
-                        selectedESize = eSize;
-                        repetitions = 64 / eSize;
-                        onesCount = BitOperations.PopCount(eValue);
-                        break;
-                    }
-                }
-            }
-
-            // Find rotation. We have two cases, one where the highest bit is 0
-            // and one where it is 1.
-            // If it's 1, we just need to count the number of 1 bits on the MSB to find the right rotation.
-            // If it's 0, we just need to count the number of 0 bits on the LSB to find the left rotation,
-            // then we can convert it to the right rotation shift by subtracting the value from the element size.
-            int rotation;
-            long vHigh = (long)(value << (64 - selectedESize));
-            if (vHigh < 0)
-            {
-                rotation = BitOperations.LeadingZeroCount(~(ulong)vHigh);
-            }
-            else
-            {
-                rotation = (selectedESize - BitOperations.TrailingZeroCount(value)) & (selectedESize - 1);
-            }
-
-            // Reconstruct value and see if it matches. If not, we can't encode.
-            ulong reconstructed = onesCount == 64 ? ulong.MaxValue : RotateRight((1UL << onesCount) - 1, rotation, selectedESize);
-
-            for (int bit = 32; bit >= selectedESize; bit >>= 1)
-            {
-                reconstructed |= reconstructed << bit;
-            }
-
-            if (reconstructed != value || onesCount == 0)
+            // Check the value is repeating; also ensures element size is a power of two.
+            if (ulong.RotateRight(value, elementSize) != value)
            {
                immN = 0;
                immS = 0;
@@ -140,34 +81,11 @@ namespace ARMeilleure.CodeGen.Arm64
                return false;
            }

-            immR = rotation;
-
-            // immN indicates that there are no repetitions.
-            // The MSB of immS indicates the amount of repetitions, and the LSB the number of bits set.
-            if (repetitions == 1)
-            {
-                immN = 1;
-                immS = 0;
-            }
-            else
-            {
-                immN = 0;
-                immS = (0xf80 >> BitOperations.Log2((uint)repetitions)) & 0x3f;
-            }
-
-            immS |= onesCount - 1;
+            immN = (elementSize >> 6) & 1;
+            immS = (((~elementSize + 1) << 1) | (onesInElement - 1)) & 0x3f;
+            immR = (elementSize - rotation) & (elementSize - 1);

            return true;
        }
-
-        private static int CountSequence(ulong value)
-        {
-            return BitOperations.TrailingZeroCount(value) + BitOperations.TrailingZeroCount(~value);
-        }
-
-        private static ulong RotateRight(ulong bits, int shift, int size)
-        {
-            return (bits >> shift) | ((bits << (size - shift)) & (size == 64 ? ulong.MaxValue : (1UL << size) - 1));
-        }
    }
 }
--- a/ARMeilleure/CodeGen/Arm64/CodeGenerator.cs
+++ b/ARMeilleure/CodeGen/Arm64/CodeGenerator.cs
@@ -1303,7 +1303,15 @@ namespace ARMeilleure.CodeGen.Arm64

        private static void GenerateConstantCopy(CodeGenContext context, Operand dest, ulong value)
        {
-            if (value != 0)
+            if (value == 0)
+            {
+                context.Assembler.Mov(dest, Register(ZrRegister, dest.Type));
+            }
+            else if (CodeGenCommon.TryEncodeBitMask(dest.Type, value, out _, out _, out _))
+            {
+                context.Assembler.Orr(dest, Register(ZrRegister, dest.Type), Const(dest.Type, (long)value));
+            }
+            else
            {
                int hw = 0;
                bool first = true;
@@ -1328,10 +1336,6 @@ namespace ARMeilleure.CodeGen.Arm64
                    value >>= 16;
                }
            }
-            else
-            {
-                context.Assembler.Mov(dest, Register(ZrRegister, dest.Type));
-            }
        }

        private static void GenerateAtomicCas(
--- a/ARMeilleure/Translation/PTC/Ptc.cs
+++ b/ARMeilleure/Translation/PTC/Ptc.cs
@@ -29,7 +29,7 @@ namespace ARMeilleure.Translation.PTC
        private const string OuterHeaderMagicString = "PTCohd\0\0";
        private const string InnerHeaderMagicString = "PTCihd\0\0";

-        private const uint InternalVersion = 4272; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 4328; //! To be incremented manually for each change to the ARMeilleure project.

        private const string ActualDir = "0";
        private const string BackupDir = "1";
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -20,7 +20,7 @@
    <PackageVersion Include="GtkSharp.Dependencies.osx" Version="0.0.5" />
    <PackageVersion Include="jp2masa.Avalonia.Flexbox" Version="0.2.0" />
    <PackageVersion Include="LibHac" Version="0.17.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
    <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
--- a/Ryujinx.Ava/AppHost.cs
+++ b/Ryujinx.Ava/AppHost.cs
@@ -231,7 +231,7 @@ namespace Ryujinx.Ava
            }
        }

-        private unsafe void Renderer_ScreenCaptured(object sender, ScreenCaptureImageInfo e)
+        private void Renderer_ScreenCaptured(object sender, ScreenCaptureImageInfo e)
        {
            if (e.Data.Length > 0 && e.Height > 0 && e.Width > 0)
            {
@@ -240,7 +240,7 @@ namespace Ryujinx.Ava
                    lock (_lockObject)
                    {
                        DateTime currentTime = DateTime.Now;
-                        string   filename    = $"ryujinx_capture_{currentTime}-{currentTime:D2}-{currentTime:D2}_{currentTime:D2}-{currentTime:D2}-{currentTime:D2}.png";
+                        string   filename    = $"ryujinx_capture_{currentTime.Year}-{currentTime.Month:D2}-{currentTime.Day:D2}_{currentTime.Hour:D2}-{currentTime.Minute:D2}-{currentTime.Second:D2}.png";
                        
                        string directory = AppDataManager.Mode switch
                        {
--- a/Ryujinx.Ava/Assets/Locales/en_US.json
+++ b/Ryujinx.Ava/Assets/Locales/en_US.json
@@ -26,6 +26,9 @@
  "MenuBarToolsInstallFirmware": "Install Firmware",
  "MenuBarFileToolsInstallFirmwareFromFile": "Install a firmware from XCI or ZIP",
  "MenuBarFileToolsInstallFirmwareFromDirectory": "Install a firmware from a directory",
+  "MenuBarToolsManageFileTypes": "Manage file types",
+  "MenuBarToolsInstallFileTypes": "Install file types",
+  "MenuBarToolsUninstallFileTypes": "Uninstall file types",
  "MenuBarHelp": "Help",
  "MenuBarHelpCheckForUpdates": "Check for Updates",
  "MenuBarHelpAbout": "About",
@@ -339,6 +342,10 @@
  "DialogFirmwareInstallEmbeddedSuccessMessage": "No installed firmware was found but Ryujinx was able to install firmware {0} from the provided game.\\nThe emulator will now start.",
  "DialogFirmwareNoFirmwareInstalledMessage": "No Firmware Installed",
  "DialogFirmwareInstalledMessage": "Firmware {0} was installed",
+  "DialogInstallFileTypesSuccessMessage": "Successfully installed file types!",
+  "DialogInstallFileTypesErrorMessage": "Failed to install file types.",
+  "DialogUninstallFileTypesSuccessMessage": "Successfully uninstalled file types!",
+  "DialogUninstallFileTypesErrorMessage": "Failed to uninstall file types.",
  "DialogOpenSettingsWindowLabel": "Open Settings Window",
  "DialogControllerAppletTitle": "Controller Applet",
  "DialogMessageDialogErrorExceptionMessage": "Error displaying Message Dialog: {0}",
@@ -619,4 +626,4 @@
  "UserProfilesRecoverEmptyList": "No profiles to recover",
  "UserEditorTitle" : "Edit User",
  "UserEditorTitleCreate" : "Create User"
-}
+}
--- a/Ryujinx.Ava/Input/AvaloniaKeyboardDriver.cs
+++ b/Ryujinx.Ava/Input/AvaloniaKeyboardDriver.cs
@@ -1,5 +1,6 @@
 using Avalonia.Controls;
 using Avalonia.Input;
+using Avalonia.Interactivity;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Input;
 using System;
@@ -30,6 +31,7 @@ namespace Ryujinx.Ava.Input
            _control.KeyDown   += OnKeyPress;
            _control.KeyUp     += OnKeyRelease;
            _control.TextInput += Control_TextInput;
+            _control.AddHandler(InputElement.TextInputEvent, Control_LastChanceTextInput, RoutingStrategies.Bubble);
        }

        private void Control_TextInput(object sender, TextInputEventArgs e)
@@ -37,6 +39,12 @@ namespace Ryujinx.Ava.Input
            TextInput?.Invoke(this, e.Text);
        }

+        private void Control_LastChanceTextInput(object sender, TextInputEventArgs e)
+        {
+            // Swallow event
+            e.Handled = true;
+        }
+
        public event Action<string> OnGamepadConnected
        {
            add    { }
--- a/Ryujinx.Ava/Program.cs
+++ b/Ryujinx.Ava/Program.cs
@@ -14,10 +14,8 @@ using Ryujinx.Ui.Common;
 using Ryujinx.Ui.Common.Configuration;
 using Ryujinx.Ui.Common.Helper;
 using System;
-using System.Diagnostics;
 using System.IO;
 using System.Runtime.InteropServices;
-using System.Runtime.Versioning;
 using System.Threading.Tasks;

 namespace Ryujinx.Ava
@@ -35,48 +33,6 @@ namespace Ryujinx.Ava

        private const uint MB_ICONWARNING = 0x30;

-        [SupportedOSPlatform("linux")]
-        static void RegisterMimeTypes()
-        {
-            if (ReleaseInformation.IsFlatHubBuild())
-            {
-                return;
-            }
-
-            string mimeDbPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".local", "share", "mime");
-
-            if (!File.Exists(Path.Combine(mimeDbPath, "packages", "Ryujinx.xml")))
-            {
-                string mimeTypesFile = Path.Combine(ReleaseInformation.GetBaseApplicationDirectory(), "mime", "Ryujinx.xml");
-                using Process mimeProcess = new();
-
-                mimeProcess.StartInfo.FileName = "xdg-mime";
-                mimeProcess.StartInfo.Arguments = $"install --novendor --mode user {mimeTypesFile}";
-
-                mimeProcess.Start();
-                mimeProcess.WaitForExit();
-
-                if (mimeProcess.ExitCode != 0)
-                {
-                    Logger.Error?.PrintMsg(LogClass.Application, $"Unable to install mime types. Make sure xdg-utils is installed. Process exited with code: {mimeProcess.ExitCode}");
-                    return;
-                }
-
-                using Process updateMimeProcess = new();
-
-                updateMimeProcess.StartInfo.FileName = "update-mime-database";
-                updateMimeProcess.StartInfo.Arguments = mimeDbPath;
-
-                updateMimeProcess.Start();
-                updateMimeProcess.WaitForExit();
-
-                if (updateMimeProcess.ExitCode != 0)
-                {
-                    Logger.Error?.PrintMsg(LogClass.Application, $"Could not update local mime database. Process exited with code: {updateMimeProcess.ExitCode}");
-                }
-            }
-        }
-
        public static void Main(string[] args)
        {
            Version = ReleaseInformation.GetVersion();
@@ -139,12 +95,6 @@ namespace Ryujinx.Ava
            // Initialize the logger system.
            LoggerModule.Initialize();

-            // Register mime types on linux.
-            if (OperatingSystem.IsLinux())
-            {
-                RegisterMimeTypes();
-            }
-
            // Initialize Discord integration.
            DiscordIntegrationModule.Initialize();

--- a/Ryujinx.Ava/UI/Renderer/EmbeddedWindow.cs
+++ b/Ryujinx.Ava/UI/Renderer/EmbeddedWindow.cs
@@ -140,68 +140,75 @@ namespace Ryujinx.Ava.UI.Renderer
            {
                if (VisualRoot != null)
                {
-                    Point   rootVisualPosition = this.TranslatePoint(new Point((long)lParam & 0xFFFF, (long)lParam >> 16 & 0xFFFF), VisualRoot).Value;
-                    Pointer pointer            = new(0, PointerType.Mouse, true);
-
-                    switch (msg)
+                    if (msg == WindowsMessages.LBUTTONDOWN ||
+                        msg == WindowsMessages.RBUTTONDOWN ||
+                        msg == WindowsMessages.LBUTTONUP   ||
+                        msg == WindowsMessages.RBUTTONUP   ||
+                        msg == WindowsMessages.MOUSEMOVE)
                    {
-                        case WindowsMessages.LBUTTONDOWN:
-                        case WindowsMessages.RBUTTONDOWN:
-                            {
-                                bool                   isLeft               = msg == WindowsMessages.LBUTTONDOWN;
-                                RawInputModifiers      pointerPointModifier = isLeft ? RawInputModifiers.LeftMouseButton : RawInputModifiers.RightMouseButton;
-                                PointerPointProperties properties           = new(pointerPointModifier, isLeft ? PointerUpdateKind.LeftButtonPressed : PointerUpdateKind.RightButtonPressed);
+                        Point   rootVisualPosition = this.TranslatePoint(new Point((long)lParam & 0xFFFF, (long)lParam >> 16 & 0xFFFF), VisualRoot).Value;
+                        Pointer pointer            = new(0, PointerType.Mouse, true);

-                                var evnt = new PointerPressedEventArgs(
-                                    this,
-                                    pointer,
-                                    VisualRoot,
-                                    rootVisualPosition,
-                                    (ulong)Environment.TickCount64,
-                                    properties,
-                                    KeyModifiers.None);
+                        switch (msg)
+                        {
+                            case WindowsMessages.LBUTTONDOWN:
+                            case WindowsMessages.RBUTTONDOWN:
+                                {
+                                    bool                   isLeft               = msg == WindowsMessages.LBUTTONDOWN;
+                                    RawInputModifiers      pointerPointModifier = isLeft ? RawInputModifiers.LeftMouseButton : RawInputModifiers.RightMouseButton;
+                                    PointerPointProperties properties           = new(pointerPointModifier, isLeft ? PointerUpdateKind.LeftButtonPressed : PointerUpdateKind.RightButtonPressed);

-                                RaiseEvent(evnt);
+                                    var evnt = new PointerPressedEventArgs(
+                                        this,
+                                        pointer,
+                                        VisualRoot,
+                                        rootVisualPosition,
+                                        (ulong)Environment.TickCount64,
+                                        properties,
+                                        KeyModifiers.None);

-                                break;
-                            }
-                        case WindowsMessages.LBUTTONUP:
-                        case WindowsMessages.RBUTTONUP:
-                            {
-                                bool                   isLeft               = msg == WindowsMessages.LBUTTONUP;
-                                RawInputModifiers      pointerPointModifier = isLeft ? RawInputModifiers.LeftMouseButton : RawInputModifiers.RightMouseButton;
-                                PointerPointProperties properties           = new(pointerPointModifier, isLeft ? PointerUpdateKind.LeftButtonReleased : PointerUpdateKind.RightButtonReleased);
+                                    RaiseEvent(evnt);

-                                var evnt = new PointerReleasedEventArgs(
-                                    this,
-                                    pointer,
-                                    VisualRoot,
-                                    rootVisualPosition,
-                                    (ulong)Environment.TickCount64,
-                                    properties,
-                                    KeyModifiers.None,
-                                    isLeft ? MouseButton.Left : MouseButton.Right);
+                                    break;
+                                }
+                            case WindowsMessages.LBUTTONUP:
+                            case WindowsMessages.RBUTTONUP:
+                                {
+                                    bool                   isLeft               = msg == WindowsMessages.LBUTTONUP;
+                                    RawInputModifiers      pointerPointModifier = isLeft ? RawInputModifiers.LeftMouseButton : RawInputModifiers.RightMouseButton;
+                                    PointerPointProperties properties           = new(pointerPointModifier, isLeft ? PointerUpdateKind.LeftButtonReleased : PointerUpdateKind.RightButtonReleased);

-                                RaiseEvent(evnt);
+                                    var evnt = new PointerReleasedEventArgs(
+                                        this,
+                                        pointer,
+                                        VisualRoot,
+                                        rootVisualPosition,
+                                        (ulong)Environment.TickCount64,
+                                        properties,
+                                        KeyModifiers.None,
+                                        isLeft ? MouseButton.Left : MouseButton.Right);

-                                break;
-                            }
-                        case WindowsMessages.MOUSEMOVE:
-                            {
-                                var evnt = new PointerEventArgs(
-                                    PointerMovedEvent,
-                                    this,
-                                    pointer,
-                                    VisualRoot,
-                                    rootVisualPosition,
-                                    (ulong)Environment.TickCount64,
-                                    new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.Other),
-                                    KeyModifiers.None);
+                                    RaiseEvent(evnt);

-                                RaiseEvent(evnt);
+                                    break;
+                                }
+                            case WindowsMessages.MOUSEMOVE:
+                                {
+                                    var evnt = new PointerEventArgs(
+                                        PointerMovedEvent,
+                                        this,
+                                        pointer,
+                                        VisualRoot,
+                                        rootVisualPosition,
+                                        (ulong)Environment.TickCount64,
+                                        new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.Other),
+                                        KeyModifiers.None);

-                                break;
-                            }
+                                    RaiseEvent(evnt);
+
+                                    break;
+                                }
+                        }
                    }
                }

--- a/Ryujinx.Ava/UI/ViewModels/MainWindowViewModel.cs
+++ b/Ryujinx.Ava/UI/ViewModels/MainWindowViewModel.cs
@@ -683,6 +683,11 @@ namespace Ryujinx.Ava.UI.ViewModels
            get => ConsoleHelper.SetConsoleWindowStateSupported;
        }

+        public bool ManageFileTypesVisible
+        {
+            get => FileAssociationHelper.IsTypeAssociationSupported;
+        }
+
        public ObservableCollection<ApplicationData> Applications
        {
            get => _applications;
--- a/Ryujinx.Ava/UI/ViewModels/TitleUpdateViewModel.cs
+++ b/Ryujinx.Ava/UI/ViewModels/TitleUpdateViewModel.cs
@@ -21,8 +21,9 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using SpanHelpers = LibHac.Common.SpanHelpers;
+using System.Text;
 using Path = System.IO.Path;
+using SpanHelpers = LibHac.Common.SpanHelpers;

 namespace Ryujinx.Ava.UI.ViewModels;

@@ -90,6 +91,8 @@ public class TitleUpdateViewModel : BaseModel
                Selected = "",
                Paths    = new List<string>()
            };
+
+            Save();
        }

        LoadUpdates();
@@ -102,6 +105,9 @@ public class TitleUpdateViewModel : BaseModel
            AddUpdate(path);
        }

+        // NOTE: Save the list again to remove leftovers.
+        Save();
+
        TitleUpdateModel selected = TitleUpdates.FirstOrDefault(x => x.Path == _titleUpdateWindowData.Selected, null);

        SelectedUpdate = selected;
@@ -223,4 +229,22 @@ public class TitleUpdateViewModel : BaseModel

        SortUpdates();
    }
+
+    public void Save()
+    {
+        _titleUpdateWindowData.Paths.Clear();
+        _titleUpdateWindowData.Selected = "";
+
+        foreach (TitleUpdateModel update in TitleUpdates)
+        {
+            _titleUpdateWindowData.Paths.Add(update.Path);
+
+            if (update == SelectedUpdate)
+            {
+                _titleUpdateWindowData.Selected = update.Path;
+            }
+        }
+
+        File.WriteAllBytes(_titleUpdateJsonPath, Encoding.UTF8.GetBytes(JsonHelper.Serialize(_titleUpdateWindowData, true)));
+    }
 }
--- a/Ryujinx.Ava/UI/Views/Main/MainMenuBarView.axaml
+++ b/Ryujinx.Ava/UI/Views/Main/MainMenuBarView.axaml
@@ -77,8 +77,7 @@
                    </MenuItem.Icon>
                </MenuItem>
                <Separator />
-                <MenuItem Name="ChangeLanguageMenuItem" Header="{locale:Locale MenuBarOptionsChangeLanguage}">
-                </MenuItem>
+                <MenuItem Name="ChangeLanguageMenuItem" Header="{locale:Locale MenuBarOptionsChangeLanguage}" />
                <Separator />
                <MenuItem
                    Click="OpenSettings"
@@ -141,6 +140,10 @@
                    <MenuItem Command="{ReflectionBinding InstallFirmwareFromFile}" Header="{locale:Locale MenuBarFileToolsInstallFirmwareFromFile}" />
                    <MenuItem Command="{ReflectionBinding InstallFirmwareFromFolder}" Header="{locale:Locale MenuBarFileToolsInstallFirmwareFromDirectory}" />
                </MenuItem>
+                <MenuItem Header="{locale:Locale MenuBarToolsManageFileTypes}" IsVisible="{Binding ManageFileTypesVisible}">
+                    <MenuItem Header="{locale:Locale MenuBarToolsInstallFileTypes}" Click="InstallFileTypes_Click"/>
+                    <MenuItem Header="{locale:Locale MenuBarToolsUninstallFileTypes}" Click="UninstallFileTypes_Click"/>
+                </MenuItem>
            </MenuItem>
            <MenuItem VerticalAlignment="Center" Header="{locale:Locale MenuBarHelp}">
                <MenuItem
@@ -157,4 +160,4 @@
            </MenuItem>
        </Menu>
    </DockPanel>
-</UserControl>
+</UserControl>
--- a/Ryujinx.Ava/UI/Views/Main/MainMenuBarView.axaml.cs
+++ b/Ryujinx.Ava/UI/Views/Main/MainMenuBarView.axaml.cs
@@ -3,6 +3,7 @@ using Avalonia.Controls;
 using Avalonia.Interactivity;
 using LibHac.FsSystem;
 using LibHac.Ncm;
+using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.UI.Windows;
@@ -10,6 +11,7 @@ using Ryujinx.Common;
 using Ryujinx.Common.Utilities;
 using Ryujinx.HLE.HOS;
 using Ryujinx.Modules;
+using Ryujinx.Ui.Common.Helper;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -163,6 +165,32 @@ namespace Ryujinx.Ava.UI.Views.Main
            }
        }

+        private async void InstallFileTypes_Click(object sender, RoutedEventArgs e)
+        {
+            if (FileAssociationHelper.Install())
+            {
+                await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogInstallFileTypesSuccessMessage],
+                    string.Empty, LocaleManager.Instance[LocaleKeys.InputDialogOk], string.Empty, string.Empty);
+            }
+            else
+            {
+                await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogInstallFileTypesErrorMessage]);
+            }
+        }
+
+        private async void UninstallFileTypes_Click(object sender, RoutedEventArgs e)
+        {
+            if (FileAssociationHelper.Uninstall())
+            {
+                await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogUninstallFileTypesSuccessMessage],
+                    string.Empty, LocaleManager.Instance[LocaleKeys.InputDialogOk], string.Empty, string.Empty);
+            }
+            else
+            {
+                await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogUninstallFileTypesErrorMessage]);
+            }
+        }
+
        public async void CheckForUpdates(object sender, RoutedEventArgs e)
        {
            if (Updater.CanUpdate(true))
--- a/Ryujinx.Ava/UI/Windows/TitleUpdateWindow.axaml.cs
+++ b/Ryujinx.Ava/UI/Windows/TitleUpdateWindow.axaml.cs
@@ -60,24 +60,7 @@ namespace Ryujinx.Ava.UI.Windows

        public void Save(object sender, RoutedEventArgs e)
        {
-            ViewModel._titleUpdateWindowData.Paths.Clear();
-
-            ViewModel._titleUpdateWindowData.Selected = "";
-
-            foreach (TitleUpdateModel update in ViewModel.TitleUpdates)
-            {
-                ViewModel._titleUpdateWindowData.Paths.Add(update.Path);
-
-                if (update == ViewModel.SelectedUpdate)
-                {
-                    ViewModel._titleUpdateWindowData.Selected = update.Path;
-                }
-            }
-
-            using (FileStream titleUpdateJsonStream = File.Create(ViewModel._titleUpdateJsonPath, 4096, FileOptions.WriteThrough))
-            {
-                titleUpdateJsonStream.Write(Encoding.UTF8.GetBytes(JsonHelper.Serialize(ViewModel._titleUpdateWindowData, true)));
-            }
+            ViewModel.Save();

            if (VisualRoot is MainWindow window)
            {
--- a/Ryujinx.Graphics.GAL/Multithreading/CommandHelper.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/CommandHelper.cs
@@ -7,9 +7,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Commands.Sampler;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Texture;
 using Ryujinx.Graphics.GAL.Multithreading.Commands.Window;
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;

@@ -30,207 +28,115 @@ namespace Ryujinx.Graphics.GAL.Multithreading

        public static int GetMaxCommandSize()
        {
-            Assembly assembly = typeof(CommandHelper).Assembly;
-
-            IEnumerable<Type> commands = assembly.GetTypes().Where(type => typeof(IGALCommand).IsAssignableFrom(type) && type.IsValueType);
-
-            int maxSize = commands.Max(command =>
-            {
-                MethodInfo method = typeof(Unsafe).GetMethod(nameof(Unsafe.SizeOf));
-                MethodInfo generic = method.MakeGenericMethod(command);
-                int size = (int)generic.Invoke(null, null);
-
-                return size;
-            });
-
-            InitLookup();
-
-            return maxSize + 1; // 1 byte reserved for command size.
+            return InitLookup() + 1; // 1 byte reserved for command size.
        }

-        private static void InitLookup()
+        private static int InitLookup()
        {
-            _lookup[(int)CommandType.Action] = (memory, threaded, renderer) =>
-                ActionCommand.Run(ref GetCommand<ActionCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateBuffer] = (memory, threaded, renderer) =>
-                CreateBufferCommand.Run(ref GetCommand<CreateBufferCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateProgram] = (memory, threaded, renderer) =>
-                CreateProgramCommand.Run(ref GetCommand<CreateProgramCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateSampler] = (memory, threaded, renderer) =>
-                CreateSamplerCommand.Run(ref GetCommand<CreateSamplerCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateSync] = (memory, threaded, renderer) =>
-                CreateSyncCommand.Run(ref GetCommand<CreateSyncCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateTexture] = (memory, threaded, renderer) =>
-                CreateTextureCommand.Run(ref GetCommand<CreateTextureCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.GetCapabilities] = (memory, threaded, renderer) =>
-                GetCapabilitiesCommand.Run(ref GetCommand<GetCapabilitiesCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.PreFrame] = (memory, threaded, renderer) =>
-                PreFrameCommand.Run(ref GetCommand<PreFrameCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ReportCounter] = (memory, threaded, renderer) =>
-                ReportCounterCommand.Run(ref GetCommand<ReportCounterCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ResetCounter] = (memory, threaded, renderer) =>
-                ResetCounterCommand.Run(ref GetCommand<ResetCounterCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.UpdateCounters] = (memory, threaded, renderer) =>
-                UpdateCountersCommand.Run(ref GetCommand<UpdateCountersCommand>(memory), threaded, renderer);
+            int maxCommandSize = 0;

-            _lookup[(int)CommandType.BufferDispose] = (memory, threaded, renderer) =>
-                BufferDisposeCommand.Run(ref GetCommand<BufferDisposeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.BufferGetData] = (memory, threaded, renderer) =>
-                BufferGetDataCommand.Run(ref GetCommand<BufferGetDataCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.BufferSetData] = (memory, threaded, renderer) =>
-                BufferSetDataCommand.Run(ref GetCommand<BufferSetDataCommand>(memory), threaded, renderer);
+            void Register<T>(CommandType commandType) where T : unmanaged, IGALCommand, IGALCommand<T>
+            {
+                maxCommandSize = Math.Max(maxCommandSize, Unsafe.SizeOf<T>());
+                _lookup[(int)commandType] = (memory, threaded, renderer) => T.Run(ref GetCommand<T>(memory), threaded, renderer);
+            }

-            _lookup[(int)CommandType.CounterEventDispose] = (memory, threaded, renderer) =>
-                CounterEventDisposeCommand.Run(ref GetCommand<CounterEventDisposeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CounterEventFlush] = (memory, threaded, renderer) =>
-                CounterEventFlushCommand.Run(ref GetCommand<CounterEventFlushCommand>(memory), threaded, renderer);
+            Register<ActionCommand>(CommandType.Action);
+            Register<CreateBufferCommand>(CommandType.CreateBuffer);
+            Register<CreateProgramCommand>(CommandType.CreateProgram);
+            Register<CreateSamplerCommand>(CommandType.CreateSampler);
+            Register<CreateSyncCommand>(CommandType.CreateSync);
+            Register<CreateTextureCommand>(CommandType.CreateTexture);
+            Register<GetCapabilitiesCommand>(CommandType.GetCapabilities);
+            Register<PreFrameCommand>(CommandType.PreFrame);
+            Register<ReportCounterCommand>(CommandType.ReportCounter);
+            Register<ResetCounterCommand>(CommandType.ResetCounter);
+            Register<UpdateCountersCommand>(CommandType.UpdateCounters);

-            _lookup[(int)CommandType.ProgramDispose] = (memory, threaded, renderer) =>
-                ProgramDisposeCommand.Run(ref GetCommand<ProgramDisposeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ProgramGetBinary] = (memory, threaded, renderer) =>
-                ProgramGetBinaryCommand.Run(ref GetCommand<ProgramGetBinaryCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ProgramCheckLink] = (memory, threaded, renderer) =>
-                ProgramCheckLinkCommand.Run(ref GetCommand<ProgramCheckLinkCommand>(memory), threaded, renderer);
+            Register<BufferDisposeCommand>(CommandType.BufferDispose);
+            Register<BufferGetDataCommand>(CommandType.BufferGetData);
+            Register<BufferSetDataCommand>(CommandType.BufferSetData);

-            _lookup[(int)CommandType.SamplerDispose] = (memory, threaded, renderer) =>
-                SamplerDisposeCommand.Run(ref GetCommand<SamplerDisposeCommand>(memory), threaded, renderer);
+            Register<CounterEventDisposeCommand>(CommandType.CounterEventDispose);
+            Register<CounterEventFlushCommand>(CommandType.CounterEventFlush);

-            _lookup[(int)CommandType.TextureCopyTo] = (memory, threaded, renderer) =>
-                TextureCopyToCommand.Run(ref GetCommand<TextureCopyToCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureCopyToScaled] = (memory, threaded, renderer) =>
-                TextureCopyToScaledCommand.Run(ref GetCommand<TextureCopyToScaledCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureCopyToSlice] = (memory, threaded, renderer) =>
-                TextureCopyToSliceCommand.Run(ref GetCommand<TextureCopyToSliceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureCreateView] = (memory, threaded, renderer) =>
-                TextureCreateViewCommand.Run(ref GetCommand<TextureCreateViewCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureGetData] = (memory, threaded, renderer) =>
-                TextureGetDataCommand.Run(ref GetCommand<TextureGetDataCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureGetDataSlice] = (memory, threaded, renderer) =>
-                TextureGetDataSliceCommand.Run(ref GetCommand<TextureGetDataSliceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureRelease] = (memory, threaded, renderer) =>
-                TextureReleaseCommand.Run(ref GetCommand<TextureReleaseCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureSetData] = (memory, threaded, renderer) =>
-                TextureSetDataCommand.Run(ref GetCommand<TextureSetDataCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureSetDataSlice] = (memory, threaded, renderer) =>
-                TextureSetDataSliceCommand.Run(ref GetCommand<TextureSetDataSliceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureSetDataSliceRegion] = (memory, threaded, renderer) =>
-                TextureSetDataSliceRegionCommand.Run(ref GetCommand<TextureSetDataSliceRegionCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureSetStorage] = (memory, threaded, renderer) =>
-                TextureSetStorageCommand.Run(ref GetCommand<TextureSetStorageCommand>(memory), threaded, renderer);
+            Register<ProgramDisposeCommand>(CommandType.ProgramDispose);
+            Register<ProgramGetBinaryCommand>(CommandType.ProgramGetBinary);
+            Register<ProgramCheckLinkCommand>(CommandType.ProgramCheckLink);

-            _lookup[(int)CommandType.WindowPresent] = (memory, threaded, renderer) =>
-                WindowPresentCommand.Run(ref GetCommand<WindowPresentCommand>(memory), threaded, renderer);
+            Register<SamplerDisposeCommand>(CommandType.SamplerDispose);

-            _lookup[(int)CommandType.Barrier] = (memory, threaded, renderer) =>
-                BarrierCommand.Run(ref GetCommand<BarrierCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.BeginTransformFeedback] = (memory, threaded, renderer) =>
-                BeginTransformFeedbackCommand.Run(ref GetCommand<BeginTransformFeedbackCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ClearBuffer] = (memory, threaded, renderer) =>
-                ClearBufferCommand.Run(ref GetCommand<ClearBufferCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ClearRenderTargetColor] = (memory, threaded, renderer) =>
-                ClearRenderTargetColorCommand.Run(ref GetCommand<ClearRenderTargetColorCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ClearRenderTargetDepthStencil] = (memory, threaded, renderer) =>
-                ClearRenderTargetDepthStencilCommand.Run(ref GetCommand<ClearRenderTargetDepthStencilCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CommandBufferBarrier] = (memory, threaded, renderer) =>
-                CommandBufferBarrierCommand.Run(ref GetCommand<CommandBufferBarrierCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CopyBuffer] = (memory, threaded, renderer) =>
-                CopyBufferCommand.Run(ref GetCommand<CopyBufferCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DispatchCompute] = (memory, threaded, renderer) =>
-                DispatchComputeCommand.Run(ref GetCommand<DispatchComputeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.Draw] = (memory, threaded, renderer) =>
-                DrawCommand.Run(ref GetCommand<DrawCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndexed] = (memory, threaded, renderer) =>
-                DrawIndexedCommand.Run(ref GetCommand<DrawIndexedCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndexedIndirect] = (memory, threaded, renderer) =>
-                DrawIndexedIndirectCommand.Run(ref GetCommand<DrawIndexedIndirectCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndexedIndirectCount] = (memory, threaded, renderer) =>
-                DrawIndexedIndirectCountCommand.Run(ref GetCommand<DrawIndexedIndirectCountCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndirect] = (memory, threaded, renderer) =>
-                DrawIndirectCommand.Run(ref GetCommand<DrawIndirectCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndirectCount] = (memory, threaded, renderer) =>
-                DrawIndirectCountCommand.Run(ref GetCommand<DrawIndirectCountCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawTexture] = (memory, threaded, renderer) =>
-                DrawTextureCommand.Run(ref GetCommand<DrawTextureCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.EndHostConditionalRendering] = (memory, threaded, renderer) =>
-                EndHostConditionalRenderingCommand.Run(renderer);
-            _lookup[(int)CommandType.EndTransformFeedback] = (memory, threaded, renderer) =>
-                EndTransformFeedbackCommand.Run(ref GetCommand<EndTransformFeedbackCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetAlphaTest] = (memory, threaded, renderer) =>
-                SetAlphaTestCommand.Run(ref GetCommand<SetAlphaTestCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetBlendState] = (memory, threaded, renderer) =>
-                SetBlendStateCommand.Run(ref GetCommand<SetBlendStateCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetDepthBias] = (memory, threaded, renderer) =>
-                SetDepthBiasCommand.Run(ref GetCommand<SetDepthBiasCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetDepthClamp] = (memory, threaded, renderer) =>
-                SetDepthClampCommand.Run(ref GetCommand<SetDepthClampCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetDepthMode] = (memory, threaded, renderer) =>
-                SetDepthModeCommand.Run(ref GetCommand<SetDepthModeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetDepthTest] = (memory, threaded, renderer) =>
-                SetDepthTestCommand.Run(ref GetCommand<SetDepthTestCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetFaceCulling] = (memory, threaded, renderer) =>
-                SetFaceCullingCommand.Run(ref GetCommand<SetFaceCullingCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetFrontFace] = (memory, threaded, renderer) =>
-                SetFrontFaceCommand.Run(ref GetCommand<SetFrontFaceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetStorageBuffers] = (memory, threaded, renderer) =>
-                SetStorageBuffersCommand.Run(ref GetCommand<SetStorageBuffersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetTransformFeedbackBuffers] = (memory, threaded, renderer) =>
-                SetTransformFeedbackBuffersCommand.Run(ref GetCommand<SetTransformFeedbackBuffersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetUniformBuffers] = (memory, threaded, renderer) =>
-                SetUniformBuffersCommand.Run(ref GetCommand<SetUniformBuffersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetImage] = (memory, threaded, renderer) =>
-                SetImageCommand.Run(ref GetCommand<SetImageCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetIndexBuffer] = (memory, threaded, renderer) =>
-                SetIndexBufferCommand.Run(ref GetCommand<SetIndexBufferCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetLineParameters] = (memory, threaded, renderer) =>
-                SetLineParametersCommand.Run(ref GetCommand<SetLineParametersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetLogicOpState] = (memory, threaded, renderer) =>
-                SetLogicOpStateCommand.Run(ref GetCommand<SetLogicOpStateCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetMultisampleState] = (memory, threaded, renderer) =>
-                SetMultisampleStateCommand.Run(ref GetCommand<SetMultisampleStateCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPatchParameters] = (memory, threaded, renderer) =>
-                SetPatchParametersCommand.Run(ref GetCommand<SetPatchParametersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPointParameters] = (memory, threaded, renderer) =>
-                SetPointParametersCommand.Run(ref GetCommand<SetPointParametersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPolygonMode] = (memory, threaded, renderer) =>
-                SetPolygonModeCommand.Run(ref GetCommand<SetPolygonModeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPrimitiveRestart] = (memory, threaded, renderer) =>
-                SetPrimitiveRestartCommand.Run(ref GetCommand<SetPrimitiveRestartCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPrimitiveTopology] = (memory, threaded, renderer) =>
-                SetPrimitiveTopologyCommand.Run(ref GetCommand<SetPrimitiveTopologyCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetProgram] = (memory, threaded, renderer) =>
-                SetProgramCommand.Run(ref GetCommand<SetProgramCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetRasterizerDiscard] = (memory, threaded, renderer) =>
-                SetRasterizerDiscardCommand.Run(ref GetCommand<SetRasterizerDiscardCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetRenderTargetColorMasks] = (memory, threaded, renderer) =>
-                SetRenderTargetColorMasksCommand.Run(ref GetCommand<SetRenderTargetColorMasksCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetRenderTargetScale] = (memory, threaded, renderer) =>
-                SetRenderTargetScaleCommand.Run(ref GetCommand<SetRenderTargetScaleCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetRenderTargets] = (memory, threaded, renderer) =>
-                SetRenderTargetsCommand.Run(ref GetCommand<SetRenderTargetsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetScissor] = (memory, threaded, renderer) =>
-                SetScissorsCommand.Run(ref GetCommand<SetScissorsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetStencilTest] = (memory, threaded, renderer) =>
-                SetStencilTestCommand.Run(ref GetCommand<SetStencilTestCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetTextureAndSampler] = (memory, threaded, renderer) =>
-                SetTextureAndSamplerCommand.Run(ref GetCommand<SetTextureAndSamplerCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetUserClipDistance] = (memory, threaded, renderer) =>
-                SetUserClipDistanceCommand.Run(ref GetCommand<SetUserClipDistanceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetVertexAttribs] = (memory, threaded, renderer) =>
-                SetVertexAttribsCommand.Run(ref GetCommand<SetVertexAttribsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetVertexBuffers] = (memory, threaded, renderer) =>
-                SetVertexBuffersCommand.Run(ref GetCommand<SetVertexBuffersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetViewports] = (memory, threaded, renderer) =>
-                SetViewportsCommand.Run(ref GetCommand<SetViewportsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureBarrier] = (memory, threaded, renderer) =>
-                TextureBarrierCommand.Run(ref GetCommand<TextureBarrierCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureBarrierTiled] = (memory, threaded, renderer) =>
-                TextureBarrierTiledCommand.Run(ref GetCommand<TextureBarrierTiledCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TryHostConditionalRendering] = (memory, threaded, renderer) =>
-                TryHostConditionalRenderingCommand.Run(ref GetCommand<TryHostConditionalRenderingCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TryHostConditionalRenderingFlush] = (memory, threaded, renderer) =>
-                TryHostConditionalRenderingFlushCommand.Run(ref GetCommand<TryHostConditionalRenderingFlushCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.UpdateRenderScale] = (memory, threaded, renderer) =>
-                UpdateRenderScaleCommand.Run(ref GetCommand<UpdateRenderScaleCommand>(memory), threaded, renderer);
+            Register<TextureCopyToCommand>(CommandType.TextureCopyTo);
+            Register<TextureCopyToScaledCommand>(CommandType.TextureCopyToScaled);
+            Register<TextureCopyToSliceCommand>(CommandType.TextureCopyToSlice);
+            Register<TextureCreateViewCommand>(CommandType.TextureCreateView);
+            Register<TextureGetDataCommand>(CommandType.TextureGetData);
+            Register<TextureGetDataSliceCommand>(CommandType.TextureGetDataSlice);
+            Register<TextureReleaseCommand>(CommandType.TextureRelease);
+            Register<TextureSetDataCommand>(CommandType.TextureSetData);
+            Register<TextureSetDataSliceCommand>(CommandType.TextureSetDataSlice);
+            Register<TextureSetDataSliceRegionCommand>(CommandType.TextureSetDataSliceRegion);
+            Register<TextureSetStorageCommand>(CommandType.TextureSetStorage);
+
+            Register<WindowPresentCommand>(CommandType.WindowPresent);
+
+            Register<BarrierCommand>(CommandType.Barrier);
+            Register<BeginTransformFeedbackCommand>(CommandType.BeginTransformFeedback);
+            Register<ClearBufferCommand>(CommandType.ClearBuffer);
+            Register<ClearRenderTargetColorCommand>(CommandType.ClearRenderTargetColor);
+            Register<ClearRenderTargetDepthStencilCommand>(CommandType.ClearRenderTargetDepthStencil);
+            Register<CommandBufferBarrierCommand>(CommandType.CommandBufferBarrier);
+            Register<CopyBufferCommand>(CommandType.CopyBuffer);
+            Register<DispatchComputeCommand>(CommandType.DispatchCompute);
+            Register<DrawCommand>(CommandType.Draw);
+            Register<DrawIndexedCommand>(CommandType.DrawIndexed);
+            Register<DrawIndexedIndirectCommand>(CommandType.DrawIndexedIndirect);
+            Register<DrawIndexedIndirectCountCommand>(CommandType.DrawIndexedIndirectCount);
+            Register<DrawIndirectCommand>(CommandType.DrawIndirect);
+            Register<DrawIndirectCountCommand>(CommandType.DrawIndirectCount);
+            Register<DrawTextureCommand>(CommandType.DrawTexture);
+            Register<EndHostConditionalRenderingCommand>(CommandType.EndHostConditionalRendering);
+            Register<EndTransformFeedbackCommand>(CommandType.EndTransformFeedback);
+            Register<SetAlphaTestCommand>(CommandType.SetAlphaTest);
+            Register<SetBlendStateCommand>(CommandType.SetBlendState);
+            Register<SetDepthBiasCommand>(CommandType.SetDepthBias);
+            Register<SetDepthClampCommand>(CommandType.SetDepthClamp);
+            Register<SetDepthModeCommand>(CommandType.SetDepthMode);
+            Register<SetDepthTestCommand>(CommandType.SetDepthTest);
+            Register<SetFaceCullingCommand>(CommandType.SetFaceCulling);
+            Register<SetFrontFaceCommand>(CommandType.SetFrontFace);
+            Register<SetStorageBuffersCommand>(CommandType.SetStorageBuffers);
+            Register<SetTransformFeedbackBuffersCommand>(CommandType.SetTransformFeedbackBuffers);
+            Register<SetUniformBuffersCommand>(CommandType.SetUniformBuffers);
+            Register<SetImageCommand>(CommandType.SetImage);
+            Register<SetIndexBufferCommand>(CommandType.SetIndexBuffer);
+            Register<SetLineParametersCommand>(CommandType.SetLineParameters);
+            Register<SetLogicOpStateCommand>(CommandType.SetLogicOpState);
+            Register<SetMultisampleStateCommand>(CommandType.SetMultisampleState);
+            Register<SetPatchParametersCommand>(CommandType.SetPatchParameters);
+            Register<SetPointParametersCommand>(CommandType.SetPointParameters);
+            Register<SetPolygonModeCommand>(CommandType.SetPolygonMode);
+            Register<SetPrimitiveRestartCommand>(CommandType.SetPrimitiveRestart);
+            Register<SetPrimitiveTopologyCommand>(CommandType.SetPrimitiveTopology);
+            Register<SetProgramCommand>(CommandType.SetProgram);
+            Register<SetRasterizerDiscardCommand>(CommandType.SetRasterizerDiscard);
+            Register<SetRenderTargetColorMasksCommand>(CommandType.SetRenderTargetColorMasks);
+            Register<SetRenderTargetScaleCommand>(CommandType.SetRenderTargetScale);
+            Register<SetRenderTargetsCommand>(CommandType.SetRenderTargets);
+            Register<SetScissorsCommand>(CommandType.SetScissor);
+            Register<SetStencilTestCommand>(CommandType.SetStencilTest);
+            Register<SetTextureAndSamplerCommand>(CommandType.SetTextureAndSampler);
+            Register<SetUserClipDistanceCommand>(CommandType.SetUserClipDistance);
+            Register<SetVertexAttribsCommand>(CommandType.SetVertexAttribs);
+            Register<SetVertexBuffersCommand>(CommandType.SetVertexBuffers);
+            Register<SetViewportsCommand>(CommandType.SetViewports);
+            Register<TextureBarrierCommand>(CommandType.TextureBarrier);
+            Register<TextureBarrierTiledCommand>(CommandType.TextureBarrierTiled);
+            Register<TryHostConditionalRenderingCommand>(CommandType.TryHostConditionalRendering);
+            Register<TryHostConditionalRenderingFlushCommand>(CommandType.TryHostConditionalRenderingFlush);
+            Register<UpdateRenderScaleCommand>(CommandType.UpdateRenderScale);
+
+            return maxCommandSize;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/BarrierCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/BarrierCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct BarrierCommand : IGALCommand
+    struct BarrierCommand : IGALCommand, IGALCommand<BarrierCommand>
    {
        public CommandType CommandType => CommandType.Barrier;

--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/BeginTransformFeedbackCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/BeginTransformFeedbackCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct BeginTransformFeedbackCommand : IGALCommand
+    struct BeginTransformFeedbackCommand : IGALCommand, IGALCommand<BeginTransformFeedbackCommand>
    {
        public CommandType CommandType => CommandType.BeginTransformFeedback;
        private PrimitiveTopology _topology;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Buffer/BufferDisposeCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Buffer/BufferDisposeCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Buffer
 {
-    struct BufferDisposeCommand : IGALCommand
+    struct BufferDisposeCommand : IGALCommand, IGALCommand<BufferDisposeCommand>
    {
        public CommandType CommandType => CommandType.BufferDispose;
        private BufferHandle _buffer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Buffer/BufferGetDataCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Buffer/BufferGetDataCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Buffer
 {
-    struct BufferGetDataCommand : IGALCommand
+    struct BufferGetDataCommand : IGALCommand, IGALCommand<BufferGetDataCommand>
    {
        public CommandType CommandType => CommandType.BufferGetData;
        private BufferHandle _buffer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Buffer/BufferSetDataCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Buffer/BufferSetDataCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Buffer
 {
-    struct BufferSetDataCommand : IGALCommand
+    struct BufferSetDataCommand : IGALCommand, IGALCommand<BufferSetDataCommand>
    {
        public CommandType CommandType => CommandType.BufferSetData;
        private BufferHandle _buffer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/ClearBufferCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/ClearBufferCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct ClearBufferCommand : IGALCommand
+    struct ClearBufferCommand : IGALCommand, IGALCommand<ClearBufferCommand>
    {
        public CommandType CommandType => CommandType.ClearBuffer;
        private BufferHandle _destination;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/ClearRenderTargetColorCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/ClearRenderTargetColorCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct ClearRenderTargetColorCommand : IGALCommand
+    struct ClearRenderTargetColorCommand : IGALCommand, IGALCommand<ClearRenderTargetColorCommand>
    {
        public CommandType CommandType => CommandType.ClearRenderTargetColor;
        private int _index;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/ClearRenderTargetDepthStencilCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/ClearRenderTargetDepthStencilCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct ClearRenderTargetDepthStencilCommand : IGALCommand
+    struct ClearRenderTargetDepthStencilCommand : IGALCommand, IGALCommand<ClearRenderTargetDepthStencilCommand>
    {
        public CommandType CommandType => CommandType.ClearRenderTargetDepthStencil;
        private int _layer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/CommandBufferBarrierCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/CommandBufferBarrierCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct CommandBufferBarrierCommand : IGALCommand
+    struct CommandBufferBarrierCommand : IGALCommand, IGALCommand<CommandBufferBarrierCommand>
    {
        public CommandType CommandType => CommandType.CommandBufferBarrier;

--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/CopyBufferCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/CopyBufferCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct CopyBufferCommand : IGALCommand
+    struct CopyBufferCommand : IGALCommand, IGALCommand<CopyBufferCommand>
    {
        public CommandType CommandType => CommandType.CopyBuffer;
        private BufferHandle _source;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/CounterEvent/CounterEventDisposeCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/CounterEvent/CounterEventDisposeCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.CounterEvent
 {
-    struct CounterEventDisposeCommand : IGALCommand
+    struct CounterEventDisposeCommand : IGALCommand, IGALCommand<CounterEventDisposeCommand>
    {
        public CommandType CommandType => CommandType.CounterEventDispose;
        private TableRef<ThreadedCounterEvent> _event;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/CounterEvent/CounterEventFlushCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/CounterEvent/CounterEventFlushCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.CounterEvent
 {
-    struct CounterEventFlushCommand : IGALCommand
+    struct CounterEventFlushCommand : IGALCommand, IGALCommand<CounterEventFlushCommand>
    {
        public CommandType CommandType => CommandType.CounterEventFlush;
        private TableRef<ThreadedCounterEvent> _event;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/DispatchComputeCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/DispatchComputeCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct DispatchComputeCommand : IGALCommand
+    struct DispatchComputeCommand : IGALCommand, IGALCommand<DispatchComputeCommand>
    {
        public CommandType CommandType => CommandType.DispatchCompute;
        private int _groupsX;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct DrawIndexedCommand : IGALCommand
+    struct DrawIndexedCommand : IGALCommand, IGALCommand<DrawIndexedCommand>
    {
        public CommandType CommandType => CommandType.DrawIndexed;
        private int _indexCount;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndexedCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndexedCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct DrawCommand : IGALCommand
+    struct DrawCommand : IGALCommand, IGALCommand<DrawCommand>
    {
        public CommandType CommandType => CommandType.Draw;
        private int _vertexCount;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndexedIndirectCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndexedIndirectCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct DrawIndexedIndirectCommand : IGALCommand
+    struct DrawIndexedIndirectCommand : IGALCommand, IGALCommand<DrawIndexedIndirectCommand>
    {
        public CommandType CommandType => CommandType.DrawIndexedIndirect;
        private BufferRange _indirectBuffer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndexedIndirectCountCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndexedIndirectCountCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct DrawIndexedIndirectCountCommand : IGALCommand
+    struct DrawIndexedIndirectCountCommand : IGALCommand, IGALCommand<DrawIndexedIndirectCountCommand>
    {
        public CommandType CommandType => CommandType.DrawIndexedIndirectCount;
        private BufferRange _indirectBuffer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndirectCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndirectCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct DrawIndirectCommand : IGALCommand
+    struct DrawIndirectCommand : IGALCommand, IGALCommand<DrawIndirectCommand>
    {
        public CommandType CommandType => CommandType.DrawIndirect;
        private BufferRange _indirectBuffer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndirectCountCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawIndirectCountCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct DrawIndirectCountCommand : IGALCommand
+    struct DrawIndirectCountCommand : IGALCommand, IGALCommand<DrawIndirectCountCommand>
    {
        public CommandType CommandType => CommandType.DrawIndirectCount;
        private BufferRange _indirectBuffer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawTextureCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/DrawTextureCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct DrawTextureCommand : IGALCommand
+    struct DrawTextureCommand : IGALCommand, IGALCommand<DrawTextureCommand>
    {
        public CommandType CommandType => CommandType.DrawTexture;
        private TableRef<ITexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/EndHostConditionalRenderingCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/EndHostConditionalRenderingCommand.cs
@@ -1,10 +1,10 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct EndHostConditionalRenderingCommand : IGALCommand
+    struct EndHostConditionalRenderingCommand : IGALCommand, IGALCommand<EndHostConditionalRenderingCommand>
    {
        public CommandType CommandType => CommandType.EndHostConditionalRendering;

-        public static void Run(IRenderer renderer)
+        public static void Run(ref EndHostConditionalRenderingCommand command, ThreadedRenderer threaded, IRenderer renderer)
        {
            renderer.Pipeline.EndHostConditionalRendering();
        }
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/EndTransformFeedbackCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/EndTransformFeedbackCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct EndTransformFeedbackCommand : IGALCommand
+    struct EndTransformFeedbackCommand : IGALCommand, IGALCommand<EndTransformFeedbackCommand>
    {
        public CommandType CommandType => CommandType.EndTransformFeedback;

--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/IGALCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/IGALCommand.cs
@@ -4,4 +4,9 @@
    {
        CommandType CommandType { get; }
    }
+
+    interface IGALCommand<T> where T : IGALCommand
+    {
+        abstract static void Run(ref T command, ThreadedRenderer threaded, IRenderer renderer);
+    }
 }
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Program/ProgramCheckLinkCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Program/ProgramCheckLinkCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Program
 {
-    struct ProgramCheckLinkCommand : IGALCommand
+    struct ProgramCheckLinkCommand : IGALCommand, IGALCommand<ProgramCheckLinkCommand>
    {
        public CommandType CommandType => CommandType.ProgramCheckLink;
        private TableRef<ThreadedProgram> _program;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Program/ProgramDisposeCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Program/ProgramDisposeCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Program
 {
-    struct ProgramDisposeCommand : IGALCommand
+    struct ProgramDisposeCommand : IGALCommand, IGALCommand<ProgramDisposeCommand>
    {
        public CommandType CommandType => CommandType.ProgramDispose;
        private TableRef<ThreadedProgram> _program;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Program/ProgramGetBinaryCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Program/ProgramGetBinaryCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Program
 {
-    struct ProgramGetBinaryCommand : IGALCommand
+    struct ProgramGetBinaryCommand : IGALCommand, IGALCommand<ProgramGetBinaryCommand>
    {
        public CommandType CommandType => CommandType.ProgramGetBinary;
        private TableRef<ThreadedProgram> _program;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/ActionCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/ActionCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct ActionCommand : IGALCommand
+    struct ActionCommand : IGALCommand, IGALCommand<ActionCommand>
    {
        public CommandType CommandType => CommandType.Action;
        private TableRef<Action> _action;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateBufferCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateBufferCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct CreateBufferCommand : IGALCommand
+    struct CreateBufferCommand : IGALCommand, IGALCommand<CreateBufferCommand>
    {
        public CommandType CommandType => CommandType.CreateBuffer;
        private BufferHandle _threadedHandle;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateProgramCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateProgramCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources.Programs;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct CreateProgramCommand : IGALCommand
+    struct CreateProgramCommand : IGALCommand, IGALCommand<CreateProgramCommand>
    {
        public CommandType CommandType => CommandType.CreateProgram;
        private TableRef<IProgramRequest> _request;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateSamplerCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateSamplerCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct CreateSamplerCommand : IGALCommand
+    struct CreateSamplerCommand : IGALCommand, IGALCommand<CreateSamplerCommand>
    {
        public CommandType CommandType => CommandType.CreateSampler;
        private TableRef<ThreadedSampler> _sampler;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateSyncCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateSyncCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct CreateSyncCommand : IGALCommand
+    struct CreateSyncCommand : IGALCommand, IGALCommand<CreateSyncCommand>
    {
        public CommandType CommandType => CommandType.CreateSync;
        private ulong _id;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateTextureCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/CreateTextureCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct CreateTextureCommand : IGALCommand
+    struct CreateTextureCommand : IGALCommand, IGALCommand<CreateTextureCommand>
    {
        public CommandType CommandType => CommandType.CreateTexture;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/GetCapabilitiesCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/GetCapabilitiesCommand.cs
@@ -2,7 +2,7 @@

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct GetCapabilitiesCommand : IGALCommand
+    struct GetCapabilitiesCommand : IGALCommand, IGALCommand<GetCapabilitiesCommand>
    {
        public CommandType CommandType => CommandType.GetCapabilities;
        private TableRef<ResultBox<Capabilities>> _result;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/PreFrameCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/PreFrameCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct PreFrameCommand : IGALCommand
+    struct PreFrameCommand : IGALCommand, IGALCommand<PreFrameCommand>
    {
        public CommandType CommandType => CommandType.PreFrame;

--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/ReportCounterCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/ReportCounterCommand.cs
@@ -4,7 +4,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct ReportCounterCommand : IGALCommand
+    struct ReportCounterCommand : IGALCommand, IGALCommand<ReportCounterCommand>
    {
        public CommandType CommandType => CommandType.ReportCounter;
        private TableRef<ThreadedCounterEvent> _event;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/ResetCounterCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/ResetCounterCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct ResetCounterCommand : IGALCommand
+    struct ResetCounterCommand : IGALCommand, IGALCommand<ResetCounterCommand>
    {
        public CommandType CommandType => CommandType.ResetCounter;
        private CounterType _type;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/UpdateCountersCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Renderer/UpdateCountersCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer
 {
-    struct UpdateCountersCommand : IGALCommand
+    struct UpdateCountersCommand : IGALCommand, IGALCommand<UpdateCountersCommand>
    {
        public CommandType CommandType => CommandType.UpdateCounters;

--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Sampler/SamplerDisposeCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Sampler/SamplerDisposeCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Sampler
 {
-    struct SamplerDisposeCommand : IGALCommand
+    struct SamplerDisposeCommand : IGALCommand, IGALCommand<SamplerDisposeCommand>
    {
        public CommandType CommandType => CommandType.SamplerDispose;
        private TableRef<ThreadedSampler> _sampler;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetAlphaTestCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetAlphaTestCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetAlphaTestCommand : IGALCommand
+    struct SetAlphaTestCommand : IGALCommand, IGALCommand<SetAlphaTestCommand>
    {
        public CommandType CommandType => CommandType.SetAlphaTest;
        private bool _enable;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetBlendStateCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetBlendStateCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetBlendStateCommand : IGALCommand
+    struct SetBlendStateCommand : IGALCommand, IGALCommand<SetBlendStateCommand>
    {
        public CommandType CommandType => CommandType.SetBlendState;
        private int _index;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetDepthBiasCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetDepthBiasCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetDepthBiasCommand : IGALCommand
+    struct SetDepthBiasCommand : IGALCommand, IGALCommand<SetDepthBiasCommand>
    {
        public CommandType CommandType => CommandType.SetDepthBias;
        private PolygonModeMask _enables;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetDepthClampCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetDepthClampCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetDepthClampCommand : IGALCommand
+    struct SetDepthClampCommand : IGALCommand, IGALCommand<SetDepthClampCommand>
    {
        public CommandType CommandType => CommandType.SetDepthClamp;
        private bool _clamp;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetDepthModeCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetDepthModeCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetDepthModeCommand : IGALCommand
+    struct SetDepthModeCommand : IGALCommand, IGALCommand<SetDepthModeCommand>
    {
        public CommandType CommandType => CommandType.SetDepthMode;
        private DepthMode _mode;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetDepthTestCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetDepthTestCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetDepthTestCommand : IGALCommand
+    struct SetDepthTestCommand : IGALCommand, IGALCommand<SetDepthTestCommand>
    {
        public CommandType CommandType => CommandType.SetDepthTest;
        private DepthTestDescriptor _depthTest;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetFaceCullingCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetFaceCullingCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetFaceCullingCommand : IGALCommand
+    struct SetFaceCullingCommand : IGALCommand, IGALCommand<SetFaceCullingCommand>
    {
        public CommandType CommandType => CommandType.SetFaceCulling;
        private bool _enable;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetFrontFaceCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetFrontFaceCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetFrontFaceCommand : IGALCommand
+    struct SetFrontFaceCommand : IGALCommand, IGALCommand<SetFrontFaceCommand>
    {
        public CommandType CommandType => CommandType.SetFrontFace;
        private FrontFace _frontFace;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetImageCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetImageCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetImageCommand : IGALCommand
+    struct SetImageCommand : IGALCommand, IGALCommand<SetImageCommand>
    {
        public CommandType CommandType => CommandType.SetImage;
        private int _binding;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetIndexBufferCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetIndexBufferCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetIndexBufferCommand : IGALCommand
+    struct SetIndexBufferCommand : IGALCommand, IGALCommand<SetIndexBufferCommand>
    {
        public CommandType CommandType => CommandType.SetIndexBuffer;
        private BufferRange _buffer;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetLineParametersCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetLineParametersCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetLineParametersCommand : IGALCommand
+    struct SetLineParametersCommand : IGALCommand, IGALCommand<SetLineParametersCommand>
    {
        public CommandType CommandType => CommandType.SetLineParameters;
        private float _width;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetLogicOpStateCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetLogicOpStateCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetLogicOpStateCommand : IGALCommand
+    struct SetLogicOpStateCommand : IGALCommand, IGALCommand<SetLogicOpStateCommand>
    {
        public CommandType CommandType => CommandType.SetLogicOpState;
        private bool _enable;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetMultisampleStateCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetMultisampleStateCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetMultisampleStateCommand : IGALCommand
+    struct SetMultisampleStateCommand : IGALCommand, IGALCommand<SetMultisampleStateCommand>
    {
        public CommandType CommandType => CommandType.SetMultisampleState;
        private MultisampleDescriptor _multisample;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPatchParametersCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPatchParametersCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetPatchParametersCommand : IGALCommand
+    struct SetPatchParametersCommand : IGALCommand, IGALCommand<SetPatchParametersCommand>
    {
        public CommandType CommandType => CommandType.SetPatchParameters;
        private int _vertices;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPointParametersCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPointParametersCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetPointParametersCommand : IGALCommand
+    struct SetPointParametersCommand : IGALCommand, IGALCommand<SetPointParametersCommand>
    {
        public CommandType CommandType => CommandType.SetPointParameters;
        private float _size;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPolygonModeCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPolygonModeCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetPolygonModeCommand : IGALCommand
+    struct SetPolygonModeCommand : IGALCommand, IGALCommand<SetPolygonModeCommand>
    {
        public CommandType CommandType => CommandType.SetPolygonMode;
        private PolygonMode _frontMode;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPrimitiveRestartCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPrimitiveRestartCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetPrimitiveRestartCommand : IGALCommand
+    struct SetPrimitiveRestartCommand : IGALCommand, IGALCommand<SetPrimitiveRestartCommand>
    {
        public CommandType CommandType => CommandType.SetPrimitiveRestart;
        private bool _enable;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPrimitiveTopologyCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetPrimitiveTopologyCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetPrimitiveTopologyCommand : IGALCommand
+    struct SetPrimitiveTopologyCommand : IGALCommand, IGALCommand<SetPrimitiveTopologyCommand>
    {
        public CommandType CommandType => CommandType.SetPrimitiveTopology;
        private PrimitiveTopology _topology;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetProgramCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetProgramCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetProgramCommand : IGALCommand
+    struct SetProgramCommand : IGALCommand, IGALCommand<SetProgramCommand>
    {
        public CommandType CommandType => CommandType.SetProgram;
        private TableRef<IProgram> _program;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRasterizerDiscardCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRasterizerDiscardCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetRasterizerDiscardCommand : IGALCommand
+    struct SetRasterizerDiscardCommand : IGALCommand, IGALCommand<SetRasterizerDiscardCommand>
    {
        public CommandType CommandType => CommandType.SetRasterizerDiscard;
        private bool _discard;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRenderTargetColorMasksCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRenderTargetColorMasksCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetRenderTargetColorMasksCommand : IGALCommand
+    struct SetRenderTargetColorMasksCommand : IGALCommand, IGALCommand<SetRenderTargetColorMasksCommand>
    {
        public CommandType CommandType => CommandType.SetRenderTargetColorMasks;
        private SpanRef<uint> _componentMask;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRenderTargetScaleCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRenderTargetScaleCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetRenderTargetScaleCommand : IGALCommand
+    struct SetRenderTargetScaleCommand : IGALCommand, IGALCommand<SetRenderTargetScaleCommand>
    {
        public CommandType CommandType => CommandType.SetRenderTargetScale;
        private float _scale;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRenderTargetsCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetRenderTargetsCommand.cs
@@ -4,7 +4,7 @@ using System.Linq;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetRenderTargetsCommand : IGALCommand
+    struct SetRenderTargetsCommand : IGALCommand, IGALCommand<SetRenderTargetsCommand>
    {
        public CommandType CommandType => CommandType.SetRenderTargets;
        private TableRef<ITexture[]> _colors;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetScissorsCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetScissorsCommand.cs
@@ -2,7 +2,7 @@

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetScissorsCommand : IGALCommand
+    struct SetScissorsCommand : IGALCommand, IGALCommand<SetScissorsCommand>
    {
        public CommandType CommandType => CommandType.SetScissor;
        private SpanRef<Rectangle<int>> _scissors;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetStencilTestCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetStencilTestCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetStencilTestCommand : IGALCommand
+    struct SetStencilTestCommand : IGALCommand, IGALCommand<SetStencilTestCommand>
    {
        public CommandType CommandType => CommandType.SetStencilTest;
        private StencilTestDescriptor _stencilTest;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetStorageBuffersCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetStorageBuffersCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetStorageBuffersCommand : IGALCommand
+    struct SetStorageBuffersCommand : IGALCommand, IGALCommand<SetStorageBuffersCommand>
    {
        public CommandType CommandType => CommandType.SetStorageBuffers;
        private SpanRef<BufferAssignment> _buffers;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetTextureAndSamplerCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetTextureAndSamplerCommand.cs
@@ -4,7 +4,7 @@ using Ryujinx.Graphics.Shader;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetTextureAndSamplerCommand : IGALCommand
+    struct SetTextureAndSamplerCommand : IGALCommand, IGALCommand<SetTextureAndSamplerCommand>
    {
        public CommandType CommandType => CommandType.SetTextureAndSampler;
        private ShaderStage _stage;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetTransformFeedbackBuffersCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetTransformFeedbackBuffersCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetTransformFeedbackBuffersCommand : IGALCommand
+    struct SetTransformFeedbackBuffersCommand : IGALCommand, IGALCommand<SetTransformFeedbackBuffersCommand>
    {
        public CommandType CommandType => CommandType.SetTransformFeedbackBuffers;
        private SpanRef<BufferRange> _buffers;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetUniformBuffersCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetUniformBuffersCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetUniformBuffersCommand : IGALCommand
+    struct SetUniformBuffersCommand : IGALCommand, IGALCommand<SetUniformBuffersCommand>
    {
        public CommandType CommandType => CommandType.SetUniformBuffers;
        private SpanRef<BufferAssignment> _buffers;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetUserClipDistanceCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetUserClipDistanceCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetUserClipDistanceCommand : IGALCommand
+    struct SetUserClipDistanceCommand : IGALCommand, IGALCommand<SetUserClipDistanceCommand>
    {
        public CommandType CommandType => CommandType.SetUserClipDistance;
        private int _index;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetVertexAttribsCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetVertexAttribsCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetVertexAttribsCommand : IGALCommand
+    struct SetVertexAttribsCommand : IGALCommand, IGALCommand<SetVertexAttribsCommand>
    {
        public CommandType CommandType => CommandType.SetVertexAttribs;
        private SpanRef<VertexAttribDescriptor> _vertexAttribs;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetVertexBuffersCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetVertexBuffersCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetVertexBuffersCommand : IGALCommand
+    struct SetVertexBuffersCommand : IGALCommand, IGALCommand<SetVertexBuffersCommand>
    {
        public CommandType CommandType => CommandType.SetVertexBuffers;
        private SpanRef<VertexBufferDescriptor> _vertexBuffers;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/SetViewportsCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/SetViewportsCommand.cs
@@ -3,7 +3,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct SetViewportsCommand : IGALCommand
+    struct SetViewportsCommand : IGALCommand, IGALCommand<SetViewportsCommand>
    {
        public CommandType CommandType => CommandType.SetViewports;
        private SpanRef<Viewport> _viewports;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureCopyToCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureCopyToCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureCopyToCommand : IGALCommand
+    struct TextureCopyToCommand : IGALCommand, IGALCommand<TextureCopyToCommand>
    {
        public CommandType CommandType => CommandType.TextureCopyTo;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureCopyToScaledCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureCopyToScaledCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureCopyToScaledCommand : IGALCommand
+    struct TextureCopyToScaledCommand : IGALCommand, IGALCommand<TextureCopyToScaledCommand>
    {
        public CommandType CommandType => CommandType.TextureCopyToScaled;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureCopyToSliceCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureCopyToSliceCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureCopyToSliceCommand : IGALCommand
+    struct TextureCopyToSliceCommand : IGALCommand, IGALCommand<TextureCopyToSliceCommand>
    {
        public CommandType CommandType => CommandType.TextureCopyToSlice;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureCreateViewCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureCreateViewCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureCreateViewCommand : IGALCommand
+    struct TextureCreateViewCommand : IGALCommand, IGALCommand<TextureCreateViewCommand>
    {
        public CommandType CommandType => CommandType.TextureCreateView;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureGetDataCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureGetDataCommand.cs
@@ -4,7 +4,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureGetDataCommand : IGALCommand
+    struct TextureGetDataCommand : IGALCommand, IGALCommand<TextureGetDataCommand>
    {
        public CommandType CommandType => CommandType.TextureGetData;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureGetDataSliceCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureGetDataSliceCommand.cs
@@ -4,7 +4,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureGetDataSliceCommand : IGALCommand
+    struct TextureGetDataSliceCommand : IGALCommand, IGALCommand<TextureGetDataSliceCommand>
    {
        public CommandType CommandType => CommandType.TextureGetDataSlice;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureReleaseCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureReleaseCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureReleaseCommand : IGALCommand
+    struct TextureReleaseCommand : IGALCommand, IGALCommand<TextureReleaseCommand>
    {
        public CommandType CommandType => CommandType.TextureRelease;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataCommand.cs
@@ -4,7 +4,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureSetDataCommand : IGALCommand
+    struct TextureSetDataCommand : IGALCommand, IGALCommand<TextureSetDataCommand>
    {
        public CommandType CommandType => CommandType.TextureSetData;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataSliceCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataSliceCommand.cs
@@ -4,7 +4,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureSetDataSliceCommand : IGALCommand
+    struct TextureSetDataSliceCommand : IGALCommand, IGALCommand<TextureSetDataSliceCommand>
    {
        public CommandType CommandType => CommandType.TextureSetDataSlice;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataSliceRegionCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetDataSliceRegionCommand.cs
@@ -4,7 +4,7 @@ using System;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureSetDataSliceRegionCommand : IGALCommand
+    struct TextureSetDataSliceRegionCommand : IGALCommand, IGALCommand<TextureSetDataSliceRegionCommand>
    {
        public CommandType CommandType => CommandType.TextureSetDataSliceRegion;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetStorageCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/Texture/TextureSetStorageCommand.cs
@@ -3,7 +3,7 @@ using Ryujinx.Graphics.GAL.Multithreading.Resources;

 namespace Ryujinx.Graphics.GAL.Multithreading.Commands.Texture
 {
-    struct TextureSetStorageCommand : IGALCommand
+    struct TextureSetStorageCommand : IGALCommand, IGALCommand<TextureSetStorageCommand>
    {
        public CommandType CommandType => CommandType.TextureSetStorage;
        private TableRef<ThreadedTexture> _texture;
--- a/Ryujinx.Graphics.GAL/Multithreading/Commands/TextureBarrierCommand.cs
+++ b/Ryujinx.Graphics.GAL/Multithreading/Commands/TextureBarrierCommand.cs
@@ -1,6 +1,6 @@
 namespace Ryujinx.Graphics.GAL.Multithreading.Commands
 {
-    struct TextureBarrierCommand : IGALCommand
+    struct TextureBarrierCommand : IGALCommand, IGALCommand<TextureBarrierCommand>
    {
        public CommandType CommandType => CommandType.TextureBarrier;

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
TSRBerry	ad6ff6ce99	GUI: Add option to register file types (#4250 ) * Add FileAssociationHelper.cs * Add register file types option to gtk * Add register file types option to avalonia * Add Windows support to FileAssociationHelper.cs * linux: Add uninstall support for file types * Ignore .glade~ backup files * Rename Register/Unregister methods * gtk: Add manage file types submenu * ava: Add manage file types submenu * windows: Add uninstall support for file types * Don't invert uninstall condition (formatting change) Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Add IsTypesRegisteredWindows & Fix Windows install function * Add AreMimeTypesRegisteredLinux() * Fix wrong indention Co-authored-by: AcK77 <acoustik666@gmail.com> Co-authored-by: gdkchan <gab.dark.100@gmail.com>	2023-01-22 17:39:00 +00:00
gnisman	dc30d94852	Handle parsing of corrupt Config.json and prevent crash on launch (#4309 ) * Handle parsing of corrupt Config.json and prevent crash on launch * Implement a cleaner solution to handle empty json object	2023-01-22 17:04:33 +01:00
merry	4f293f8cbe	Arm64: Simplify TryEncodeBitMask and use for constants (#4328 ) * Arm64: Simplify TryEncodeBitMask * CodeGenerator: Use TryEncodeBitMask in GenerateConstantCopy * Ptc: Bump version	2023-01-22 14:15:49 +00:00
merry	32a1cd83fd	AvaloniaKeyboardDriver: Swallow TextInput events to avoid bell (#4320 )	2023-01-22 11:21:52 +01:00
riperiperi	e3d0ccf8d5	Allow setting texture data from 1x to fix some textures resetting randomly (#2860 ) * Allow setting texture data from 1x to fix some textures resetting randomly Expected targets: - Deltarune 1+2 - Crash Team Racing - Those new pokemon games idk * Allow scaling of MSAA textures, propagate scale on copy. * Fix Rebase Oops * Automatic disable * A bit more aggressive * Without the debug log * Actually decrement the score when writing.	2023-01-22 02:03:30 +00:00
Ac_K	c14844d12c	Ava UI: Various Fixes (#4326 ) * Ava UI: Various Fixes * use WriteAllBytes	2023-01-22 01:42:55 +01:00
gdkchan	7fea26e97e	Remove use of reflection on GAL multithreading (#4287 ) * Introduce new IGALCommand<T> interface and use it * Remove use of reflection on GAL multithreading * Unmanaged constraint	2023-01-22 01:07:43 +01:00
dependabot[bot]	7b7f62c776	nuget: bump Microsoft.CodeAnalysis.Analyzers from 3.3.3 to 3.3.4 (#4310 ) * nuget: bump Microsoft.CodeAnalysis.Analyzers from 3.3.3 to 3.3.4 Bumps [Microsoft.CodeAnalysis.Analyzers](https://github.com/dotnet/roslyn-analyzers) from 3.3.3 to 3.3.4. - [Release notes](https://github.com/dotnet/roslyn-analyzers/releases) - [Changelog](https://github.com/dotnet/roslyn-analyzers/blob/main/PostReleaseActivities.md) - [Commits](https://github.com/dotnet/roslyn-analyzers/compare/v3.3.3...v3.3.4) --- updated-dependencies: - dependency-name: Microsoft.CodeAnalysis.Analyzers dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> * Fixes warning Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Ac_K <Acoustik666@gmail.com>	2023-01-21 20:04:39 +00:00
riperiperi	423dbc8888	Use volatile read/writes for GAL threading (#4327 )	2023-01-21 19:49:55 +00:00