Fix Lambda Explicit Type Specification Warning (#4090)

* Fix Redundant Qualifer Warnings

* Remove unnecessary using

.github/workflows/release.yml

@@ -11,6 +11,7 @@ on:
       - '*.yml'
       - 'README.md'
 
+concurrency: release
 
 jobs:
   release:

ARMeilleure/Decoders/OpCodeTable.cs

@@ -1341,7 +1341,7 @@ namespace ARMeilleure.Decoders
         {
             string reversedEncoding = encoding.Substring(16) + encoding.Substring(0, 16);
             MakeOp reversedMakeOp =
-                (InstDescriptor inst, ulong address, int opCode)
+                (inst, address, opCode)
                     => makeOp(inst, address, (int)BitOperations.RotateRight((uint)opCode, 16));
             Set(reversedEncoding, AllInstT32, new InstDescriptor(name, emitter), reversedMakeOp);
         }

Ryujinx.Ava/Assets/Styles/Styles.xaml

@@ -161,6 +161,7 @@
     <Style Selector="MenuItem">
         <Setter Property="Height" Value="{DynamicResource MenuItemHeight}" />
         <Setter Property="Padding" Value="{DynamicResource MenuItemPadding}" />
+        <Setter Property="FontSize" Value="12" />
     </Style>
     <Style Selector="MenuItem:selected /template/ Border#root">
         <Setter Property="Background" Value="{DynamicResource ThemeControlBorderColor}" />

Ryujinx.Ava/Modules/Updater/Updater.cs

@@ -355,7 +355,7 @@ namespace Ryujinx.Modules
                         list[index] = args.Result;
                         Interlocked.Increment(ref completedRequests);
 
-                        if (Interlocked.Equals(completedRequests, ConnectionCount))
+                        if (Equals(completedRequests, ConnectionCount))
                         {
                             byte[] mergedFileBytes = new byte[_buildSize];
                             for (int connectionIndex = 0, destinationOffset = 0; connectionIndex < ConnectionCount; connectionIndex++)

Ryujinx.Ava/Program.cs

@@ -82,8 +82,8 @@ namespace Ryujinx.Ava
             Console.Title = $"Ryujinx Console {Version}";
 
             // Hook unhandled exception and process exit events.
-            AppDomain.CurrentDomain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) => ProcessUnhandledException(e.ExceptionObject as Exception, e.IsTerminating);
+            AppDomain.CurrentDomain.UnhandledException += (sender, e) => ProcessUnhandledException(e.ExceptionObject as Exception, e.IsTerminating);
-            AppDomain.CurrentDomain.ProcessExit        += (object sender, EventArgs e)                   => Exit();
+            AppDomain.CurrentDomain.ProcessExit        += (sender, e) => Exit();
 
             // Setup base data directory.
             AppDataManager.Initialize(CommandLineState.BaseDirPathArg);

Ryujinx.Ava/Ryujinx.Ava.csproj

@@ -32,8 +32,7 @@
 
     <PackageReference Include="OpenTK.Core" Version="4.7.5" />
     <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build12" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.osx" Version="5.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
     <PackageReference Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
     <PackageReference Include="Silk.NET.Vulkan" Version="2.16.0" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.16.0" />
@@ -41,6 +40,9 @@
     <PackageReference Include="SPB" Version="0.0.4-build28" />
     <PackageReference Include="SharpZipLib" Version="1.4.1" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.4" />
+
+    <!--NOTE: DO NOT REMOVE, THIS IS REQUIRED AS A RESULT OF A TRIMMING ISSUE IN AVALONIA -->
+    <PackageReference Include="System.Drawing.Common" Version="7.0.0" />
   </ItemGroup>
 
   <ItemGroup>

Ryujinx.Ava/Ui/Applet/AvaloniaDynamicTextInputHandler.cs

@@ -66,7 +66,7 @@ namespace Ryujinx.Ava.Ui.Applet
             });
         }
 
-        private void AvaloniaDynamicTextInputHandler_KeyRelease(object sender, Avalonia.Input.KeyEventArgs e)
+        private void AvaloniaDynamicTextInputHandler_KeyRelease(object sender, KeyEventArgs e)
         {
             var key = (HidKey)AvaloniaKeyboardMappingHelper.ToInputKey(e.Key);
 

Ryujinx.Ava/Ui/Controls/ContentDialogHelper.cs

@@ -222,7 +222,7 @@ namespace Ryujinx.Ava.Ui.Controls
 
             content.MinHeight = 80;
 
-            SymbolIcon icon = new SymbolIcon { Symbol = (Symbol)symbol, Margin = new Avalonia.Thickness(10) };
+            SymbolIcon icon = new SymbolIcon { Symbol = (Symbol)symbol, Margin = new Thickness(10) };
             icon.FontSize = 40;
             icon.VerticalAlignment = Avalonia.Layout.VerticalAlignment.Center;
             Grid.SetColumn(icon, 0);
@@ -232,15 +232,15 @@ namespace Ryujinx.Ava.Ui.Controls
             TextBlock primaryLabel = new TextBlock()
             {
                 Text = primaryText,
-                Margin = new Avalonia.Thickness(5),
+                Margin = new Thickness(5),
-                TextWrapping = Avalonia.Media.TextWrapping.Wrap,
+                TextWrapping = TextWrapping.Wrap,
                 MaxWidth = 450
             };
             TextBlock secondaryLabel = new TextBlock()
             {
                 Text = secondaryText,
-                Margin = new Avalonia.Thickness(5),
+                Margin = new Thickness(5),
-                TextWrapping = Avalonia.Media.TextWrapping.Wrap,
+                TextWrapping = TextWrapping.Wrap,
                 MaxWidth = 450
             };
 

Ryujinx.Ava/Ui/Controls/EmbeddedWindow.cs

@@ -39,7 +39,7 @@ namespace Ryujinx.Ava.Ui.Controls
 
         public EmbeddedWindow()
         {
-            var stateObserverable = this.GetObservable(Control.BoundsProperty);
+            var stateObserverable = this.GetObservable(BoundsProperty);
 
             stateObserverable.Subscribe(StateChanged);
 
@@ -165,7 +165,7 @@ namespace Ryujinx.Ava.Ui.Controls
                     isLeft = msg == WindowsMessages.LBUTTONDOWN;
                     this.RaiseEvent(new PointerPressedEventArgs(
                         this,
-                        new Avalonia.Input.Pointer(0, PointerType.Mouse, true),
+                        new Pointer(0, PointerType.Mouse, true),
                         root,
                         this.TranslatePoint(point, root).Value,
                         (ulong)Environment.TickCount64,
@@ -177,7 +177,7 @@ namespace Ryujinx.Ava.Ui.Controls
                     isLeft = msg == WindowsMessages.LBUTTONUP;
                     this.RaiseEvent(new PointerReleasedEventArgs(
                         this,
-                        new Avalonia.Input.Pointer(0, PointerType.Mouse, true),
+                        new Pointer(0, PointerType.Mouse, true),
                         root,
                         this.TranslatePoint(point, root).Value,
                         (ulong)Environment.TickCount64,
@@ -189,7 +189,7 @@ namespace Ryujinx.Ava.Ui.Controls
                     this.RaiseEvent(new PointerEventArgs(
                         PointerMovedEvent,
                         this,
-                        new Avalonia.Input.Pointer(0, PointerType.Mouse, true),
+                        new Pointer(0, PointerType.Mouse, true),
                         root,
                         this.TranslatePoint(point, root).Value,
                         (ulong)Environment.TickCount64,

Ryujinx.Ava/Ui/Controls/GameListView.axaml

@@ -138,6 +138,9 @@
                 <Style Selector="ListBoxItem:selected /template/ ContentPresenter">
                     <Setter Property="Background" Value="{DynamicResource AppListBackgroundColor}" />
                 </Style>
+                <Style Selector="ListBoxItem:selected /template/ Border#SelectionIndicator">
+                    <Setter Property="MinHeight" Value="100" />
+                </Style>
                 <Style Selector="ListBoxItem:pointerover /template/ ContentPresenter">
                     <Setter Property="Background" Value="{DynamicResource AppListHoverBackgroundColor}" />
                 </Style>

Ryujinx.Ava/Ui/ViewModels/ControllerSettingsViewModel.cs

@@ -545,7 +545,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
 
                 config = new StandardKeyboardInputConfig
                 {
-                    Version = Ryujinx.Common.Configuration.Hid.InputConfig.CurrentVersion,
+                    Version = InputConfig.CurrentVersion,
                     Backend = InputBackendType.WindowKeyboard,
                     Id = id,
                     ControllerType = ControllerType.ProController,
@@ -600,7 +600,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
 
                 config = new StandardControllerInputConfig
                 {
-                    Version = Ryujinx.Common.Configuration.Hid.InputConfig.CurrentVersion,
+                    Version = InputConfig.CurrentVersion,
                     Backend = InputBackendType.GamepadSDL2,
                     Id = id,
                     ControllerType = ControllerType.ProController,

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

@@ -104,11 +104,11 @@ namespace Ryujinx.Ava.Ui.Windows
 
             var device = ViewModel.Devices[ViewModel.Device];
 
-            if (device.Type == Models.DeviceType.Keyboard)
+            if (device.Type == DeviceType.Keyboard)
             {
                 assigner = new KeyboardKeyAssigner((IKeyboard)ViewModel.SelectedGamepad);
             }
-            else if (device.Type == Models.DeviceType.Controller)
+            else if (device.Type == DeviceType.Controller)
             {
                 assigner = new GamepadButtonAssigner(ViewModel.SelectedGamepad, (ViewModel.Config as StandardControllerInputConfig).TriggerThreshold, forStick);
             }

Ryujinx.Ava/Ui/Windows/MainWindow.axaml

@@ -12,9 +12,9 @@
     xmlns:window="clr-namespace:Ryujinx.Ava.Ui.Windows"
     Title="Ryujinx"
     Width="1280"
-    Height="785"
+    Height="777"
     MinWidth="1092"
-    MinHeight="680"
+    MinHeight="672"
     d:DesignHeight="720"
     d:DesignWidth="1280"
     x:CompileBindings="True"
@@ -552,9 +552,8 @@
             <Grid
                 Name="StatusBar"
                 Grid.Row="2"
-                MinHeight="30"
+                Margin="0"
-                Height="30"
+                MinHeight="22"
-                Margin="0,0"
                 HorizontalAlignment="Stretch"
                 VerticalAlignment="Bottom"
                 Background="{DynamicResource ThemeContentBackgroundColor}"
@@ -568,7 +567,7 @@
                 </Grid.ColumnDefinitions>
                 <StackPanel
                     Grid.Column="0"
-                    Margin="10,0"
+                    Margin="5"
                     VerticalAlignment="Center"
                     IsVisible="{Binding EnableNonGameRunningControls}">
                     <Grid Margin="0">
@@ -610,14 +609,14 @@
                 </StackPanel>
                 <StackPanel
                     Grid.Column="1"
-                    Margin="10,0"
+                    Margin="0,2"
                     HorizontalAlignment="Left"
                     VerticalAlignment="Center"
                     IsVisible="{Binding IsGameRunning}"
                     Orientation="Horizontal">
                     <TextBlock
                         Name="VsyncStatus"
-                        Margin="0,0,5,0"
+                        Margin="5,0,5,0"
                         HorizontalAlignment="Left"
                         VerticalAlignment="Center"
                         Foreground="{Binding VsyncColor}"
@@ -628,7 +627,7 @@
                     <Border
                         Width="2"
                         Height="12"
-                        Margin="2,0"
+                        Margin="0"
                         BorderBrush="Gray"
                         BorderThickness="1"
                         IsVisible="{Binding !ShowLoadProgress}" />
@@ -644,7 +643,7 @@
                     <Border
                         Width="2"
                         Height="12"
-                        Margin="2,0"
+                        Margin="0"
                         BorderBrush="Gray"
                         BorderThickness="1"
                         IsVisible="{Binding !ShowLoadProgress}" />
@@ -660,13 +659,13 @@
                     <Border
                         Width="2"
                         Height="12"
-                        Margin="2,0"
+                        Margin="0"
                         BorderBrush="Gray"
                         BorderThickness="1"
                         IsVisible="{Binding !ShowLoadProgress}" />
                     <ui:ToggleSplitButton
                         Name="VolumeStatus"
-                        Padding="5"
+                        Padding="5,0,5,0"
                         HorizontalAlignment="Left"
                         VerticalAlignment="Center"
                         VerticalContentAlignment="Center"
@@ -679,6 +678,7 @@
                             <Flyout Placement="Bottom" ShowMode="TransientWithDismissOnPointerMoveAway">
                                 <Grid Margin="0">
                                     <Slider
+                                        MaxHeight="40"
                                         Width="150"
                                         Margin="0"
                                         Padding="0"
@@ -697,7 +697,7 @@
                     <Border
                         Width="2"
                         Height="12"
-                        Margin="2,0"
+                        Margin="0"
                         BorderBrush="Gray"
                         BorderThickness="1"
                         IsVisible="{Binding !ShowLoadProgress}" />
@@ -711,7 +711,7 @@
                     <Border
                         Width="2"
                         Height="12"
-                        Margin="2,0"
+                        Margin="0"
                         BorderBrush="Gray"
                         BorderThickness="1"
                         IsVisible="{Binding !ShowLoadProgress}" />
@@ -725,7 +725,7 @@
                     <Border
                         Width="2"
                         Height="12"
-                        Margin="2,0"
+                        Margin="0"
                         BorderBrush="Gray"
                         BorderThickness="1"
                         IsVisible="{Binding !ShowLoadProgress}" />
@@ -739,7 +739,7 @@
                     <Border
                         Width="2"
                         Height="12"
-                        Margin="2,0"
+                        Margin="0"
                         BorderBrush="Gray"
                         BorderThickness="1"
                         IsVisible="{Binding !ShowLoadProgress}" />
@@ -753,7 +753,7 @@
                 </StackPanel>
                 <StackPanel
                     Grid.Column="3"
-                    Margin="10,0"
+                    Margin="0,0,5,0"
                     VerticalAlignment="Center"
                     IsVisible="{Binding ShowFirmwareStatus}"
                     Orientation="Horizontal">

Ryujinx.Common/Ryujinx.Common.csproj

@@ -7,7 +7,6 @@
 
   <ItemGroup>
     <PackageReference Include="MsgPack.Cli" Version="1.0.1" />
-    <PackageReference Include="System.Drawing.Common" Version="7.0.0" />
     <PackageReference Include="System.Management" Version="7.0.0" />
   </ItemGroup>
 

Ryujinx.Common/System/ForceDpiAware.cs

@@ -1,6 +1,5 @@
 using Ryujinx.Common.Logging;
 using System;
-using System.Drawing;
 using System.Globalization;
 using System.Runtime.InteropServices;
 
@@ -51,7 +50,7 @@ namespace Ryujinx.Common.System
             {
                 if (OperatingSystem.IsWindows())
                 {
-                    userDpiScale = Graphics.FromHwnd(IntPtr.Zero).DpiX;
+                    userDpiScale = GdiPlusHelper.GetDpiX(IntPtr.Zero);
                 }
                 else if (OperatingSystem.IsLinux())
                 {

Ryujinx.Common/System/GdiPlusHelper.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+namespace Ryujinx.Common.System
+{
+    [SupportedOSPlatform("windows")]
+    public static class GdiPlusHelper
+    {
+        private const string LibraryName = "gdiplus.dll";
+
+        private static readonly IntPtr _initToken;
+
+        static GdiPlusHelper()
+        {
+            CheckStatus(GdiplusStartup(out _initToken, StartupInputEx.Default, out _));
+        }
+
+        private static void CheckStatus(int gdiStatus)
+        {
+            if (gdiStatus != 0)
+            {
+                throw new Exception($"GDI Status Error: {gdiStatus}");
+            }
+        }
+
+        private struct StartupInputEx
+        {
+            public int GdiplusVersion;
+
+#pragma warning disable CS0649
+            public IntPtr DebugEventCallback;
+            public int SuppressBackgroundThread;
+            public int SuppressExternalCodecs;
+            public int StartupParameters;
+#pragma warning restore CS0649
+
+            public static StartupInputEx Default => new StartupInputEx
+            {
+                // We assume Windows 8 and upper
+                GdiplusVersion = 2,
+                DebugEventCallback = IntPtr.Zero,
+                SuppressBackgroundThread = 0,
+                SuppressExternalCodecs = 0,
+                StartupParameters = 0,
+            };
+        }
+
+        private struct StartupOutput
+        {
+            public IntPtr NotificationHook;
+            public IntPtr NotificationUnhook;
+        }
+
+        [DllImport(LibraryName)]
+        private static extern int GdiplusStartup(out IntPtr token, in StartupInputEx input, out StartupOutput output);
+
+        [DllImport(LibraryName)]
+        private static extern int GdipCreateFromHWND(IntPtr hwnd, out IntPtr graphics);
+
+        [DllImport(LibraryName)]
+        private static extern int GdipDeleteGraphics(IntPtr graphics);
+
+        [DllImport(LibraryName)]
+        private static extern int GdipGetDpiX(IntPtr graphics, out float dpi);
+
+        public static float GetDpiX(IntPtr hwnd)
+        {
+            CheckStatus(GdipCreateFromHWND(hwnd, out IntPtr graphicsHandle));
+            CheckStatus(GdipGetDpiX(graphicsHandle, out float result));
+            CheckStatus(GdipDeleteGraphics(graphicsHandle));
+
+            return result;
+        }
+    }
+}

Ryujinx.Graphics.GAL/Multithreading/CommandHelper.cs

@@ -50,186 +50,186 @@ namespace Ryujinx.Graphics.GAL.Multithreading
 
         private static void InitLookup()
         {
-            _lookup[(int)CommandType.Action] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.Action] = (memory, threaded, renderer) =>
                 ActionCommand.Run(ref GetCommand<ActionCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateBuffer] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CreateBuffer] = (memory, threaded, renderer) =>
                 CreateBufferCommand.Run(ref GetCommand<CreateBufferCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateProgram] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CreateProgram] = (memory, threaded, renderer) =>
                 CreateProgramCommand.Run(ref GetCommand<CreateProgramCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateSampler] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CreateSampler] = (memory, threaded, renderer) =>
                 CreateSamplerCommand.Run(ref GetCommand<CreateSamplerCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateSync] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CreateSync] = (memory, threaded, renderer) =>
                 CreateSyncCommand.Run(ref GetCommand<CreateSyncCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CreateTexture] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CreateTexture] = (memory, threaded, renderer) =>
                 CreateTextureCommand.Run(ref GetCommand<CreateTextureCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.GetCapabilities] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.GetCapabilities] = (memory, threaded, renderer) =>
                 GetCapabilitiesCommand.Run(ref GetCommand<GetCapabilitiesCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.PreFrame] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.PreFrame] = (memory, threaded, renderer) =>
                 PreFrameCommand.Run(ref GetCommand<PreFrameCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ReportCounter] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.ReportCounter] = (memory, threaded, renderer) =>
                 ReportCounterCommand.Run(ref GetCommand<ReportCounterCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ResetCounter] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.ResetCounter] = (memory, threaded, renderer) =>
                 ResetCounterCommand.Run(ref GetCommand<ResetCounterCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.UpdateCounters] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.UpdateCounters] = (memory, threaded, renderer) =>
                 UpdateCountersCommand.Run(ref GetCommand<UpdateCountersCommand>(memory), threaded, renderer);
 
-            _lookup[(int)CommandType.BufferDispose] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.BufferDispose] = (memory, threaded, renderer) =>
                 BufferDisposeCommand.Run(ref GetCommand<BufferDisposeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.BufferGetData] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.BufferGetData] = (memory, threaded, renderer) =>
                 BufferGetDataCommand.Run(ref GetCommand<BufferGetDataCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.BufferSetData] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.BufferSetData] = (memory, threaded, renderer) =>
                 BufferSetDataCommand.Run(ref GetCommand<BufferSetDataCommand>(memory), threaded, renderer);
 
-            _lookup[(int)CommandType.CounterEventDispose] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CounterEventDispose] = (memory, threaded, renderer) =>
                 CounterEventDisposeCommand.Run(ref GetCommand<CounterEventDisposeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CounterEventFlush] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CounterEventFlush] = (memory, threaded, renderer) =>
                 CounterEventFlushCommand.Run(ref GetCommand<CounterEventFlushCommand>(memory), threaded, renderer);
 
-            _lookup[(int)CommandType.ProgramDispose] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.ProgramDispose] = (memory, threaded, renderer) =>
                 ProgramDisposeCommand.Run(ref GetCommand<ProgramDisposeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ProgramGetBinary] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.ProgramGetBinary] = (memory, threaded, renderer) =>
                 ProgramGetBinaryCommand.Run(ref GetCommand<ProgramGetBinaryCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ProgramCheckLink] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.ProgramCheckLink] = (memory, threaded, renderer) =>
                 ProgramCheckLinkCommand.Run(ref GetCommand<ProgramCheckLinkCommand>(memory), threaded, renderer);
 
-            _lookup[(int)CommandType.SamplerDispose] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SamplerDispose] = (memory, threaded, renderer) =>
                 SamplerDisposeCommand.Run(ref GetCommand<SamplerDisposeCommand>(memory), threaded, renderer);
 
-            _lookup[(int)CommandType.TextureCopyTo] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureCopyTo] = (memory, threaded, renderer) =>
                 TextureCopyToCommand.Run(ref GetCommand<TextureCopyToCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureCopyToScaled] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureCopyToScaled] = (memory, threaded, renderer) =>
                 TextureCopyToScaledCommand.Run(ref GetCommand<TextureCopyToScaledCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureCopyToSlice] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureCopyToSlice] = (memory, threaded, renderer) =>
                 TextureCopyToSliceCommand.Run(ref GetCommand<TextureCopyToSliceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureCreateView] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureCreateView] = (memory, threaded, renderer) =>
                 TextureCreateViewCommand.Run(ref GetCommand<TextureCreateViewCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureGetData] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureGetData] = (memory, threaded, renderer) =>
                 TextureGetDataCommand.Run(ref GetCommand<TextureGetDataCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureGetDataSlice] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureGetDataSlice] = (memory, threaded, renderer) =>
                 TextureGetDataSliceCommand.Run(ref GetCommand<TextureGetDataSliceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureRelease] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureRelease] = (memory, threaded, renderer) =>
                 TextureReleaseCommand.Run(ref GetCommand<TextureReleaseCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureSetData] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureSetData] = (memory, threaded, renderer) =>
                 TextureSetDataCommand.Run(ref GetCommand<TextureSetDataCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureSetDataSlice] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureSetDataSlice] = (memory, threaded, renderer) =>
                 TextureSetDataSliceCommand.Run(ref GetCommand<TextureSetDataSliceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureSetDataSliceRegion] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureSetDataSliceRegion] = (memory, threaded, renderer) =>
                 TextureSetDataSliceRegionCommand.Run(ref GetCommand<TextureSetDataSliceRegionCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureSetStorage] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureSetStorage] = (memory, threaded, renderer) =>
                 TextureSetStorageCommand.Run(ref GetCommand<TextureSetStorageCommand>(memory), threaded, renderer);
 
-            _lookup[(int)CommandType.WindowPresent] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.WindowPresent] = (memory, threaded, renderer) =>
                 WindowPresentCommand.Run(ref GetCommand<WindowPresentCommand>(memory), threaded, renderer);
 
-            _lookup[(int)CommandType.Barrier] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.Barrier] = (memory, threaded, renderer) =>
                 BarrierCommand.Run(ref GetCommand<BarrierCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.BeginTransformFeedback] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.BeginTransformFeedback] = (memory, threaded, renderer) =>
                 BeginTransformFeedbackCommand.Run(ref GetCommand<BeginTransformFeedbackCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ClearBuffer] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.ClearBuffer] = (memory, threaded, renderer) =>
                 ClearBufferCommand.Run(ref GetCommand<ClearBufferCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ClearRenderTargetColor] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.ClearRenderTargetColor] = (memory, threaded, renderer) =>
                 ClearRenderTargetColorCommand.Run(ref GetCommand<ClearRenderTargetColorCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.ClearRenderTargetDepthStencil] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.ClearRenderTargetDepthStencil] = (memory, threaded, renderer) =>
                 ClearRenderTargetDepthStencilCommand.Run(ref GetCommand<ClearRenderTargetDepthStencilCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CommandBufferBarrier] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CommandBufferBarrier] = (memory, threaded, renderer) =>
                 CommandBufferBarrierCommand.Run(ref GetCommand<CommandBufferBarrierCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.CopyBuffer] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.CopyBuffer] = (memory, threaded, renderer) =>
                 CopyBufferCommand.Run(ref GetCommand<CopyBufferCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DispatchCompute] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.DispatchCompute] = (memory, threaded, renderer) =>
                 DispatchComputeCommand.Run(ref GetCommand<DispatchComputeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.Draw] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.Draw] = (memory, threaded, renderer) =>
                 DrawCommand.Run(ref GetCommand<DrawCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndexed] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.DrawIndexed] = (memory, threaded, renderer) =>
                 DrawIndexedCommand.Run(ref GetCommand<DrawIndexedCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndexedIndirect] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.DrawIndexedIndirect] = (memory, threaded, renderer) =>
                 DrawIndexedIndirectCommand.Run(ref GetCommand<DrawIndexedIndirectCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndexedIndirectCount] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.DrawIndexedIndirectCount] = (memory, threaded, renderer) =>
                 DrawIndexedIndirectCountCommand.Run(ref GetCommand<DrawIndexedIndirectCountCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndirect] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.DrawIndirect] = (memory, threaded, renderer) =>
                 DrawIndirectCommand.Run(ref GetCommand<DrawIndirectCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawIndirectCount] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.DrawIndirectCount] = (memory, threaded, renderer) =>
                 DrawIndirectCountCommand.Run(ref GetCommand<DrawIndirectCountCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.DrawTexture] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.DrawTexture] = (memory, threaded, renderer) =>
                 DrawTextureCommand.Run(ref GetCommand<DrawTextureCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.EndHostConditionalRendering] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.EndHostConditionalRendering] = (memory, threaded, renderer) =>
                 EndHostConditionalRenderingCommand.Run(renderer);
-            _lookup[(int)CommandType.EndTransformFeedback] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.EndTransformFeedback] = (memory, threaded, renderer) =>
                 EndTransformFeedbackCommand.Run(ref GetCommand<EndTransformFeedbackCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetAlphaTest] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetAlphaTest] = (memory, threaded, renderer) =>
                 SetAlphaTestCommand.Run(ref GetCommand<SetAlphaTestCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetBlendState] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetBlendState] = (memory, threaded, renderer) =>
                 SetBlendStateCommand.Run(ref GetCommand<SetBlendStateCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetDepthBias] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetDepthBias] = (memory, threaded, renderer) =>
                 SetDepthBiasCommand.Run(ref GetCommand<SetDepthBiasCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetDepthClamp] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetDepthClamp] = (memory, threaded, renderer) =>
                 SetDepthClampCommand.Run(ref GetCommand<SetDepthClampCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetDepthMode] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetDepthMode] = (memory, threaded, renderer) =>
                 SetDepthModeCommand.Run(ref GetCommand<SetDepthModeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetDepthTest] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetDepthTest] = (memory, threaded, renderer) =>
                 SetDepthTestCommand.Run(ref GetCommand<SetDepthTestCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetFaceCulling] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetFaceCulling] = (memory, threaded, renderer) =>
                 SetFaceCullingCommand.Run(ref GetCommand<SetFaceCullingCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetFrontFace] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetFrontFace] = (memory, threaded, renderer) =>
                 SetFrontFaceCommand.Run(ref GetCommand<SetFrontFaceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetStorageBuffers] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetStorageBuffers] = (memory, threaded, renderer) =>
                 SetStorageBuffersCommand.Run(ref GetCommand<SetStorageBuffersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetTransformFeedbackBuffers] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetTransformFeedbackBuffers] = (memory, threaded, renderer) =>
                 SetTransformFeedbackBuffersCommand.Run(ref GetCommand<SetTransformFeedbackBuffersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetUniformBuffers] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetUniformBuffers] = (memory, threaded, renderer) =>
                 SetUniformBuffersCommand.Run(ref GetCommand<SetUniformBuffersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetImage] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetImage] = (memory, threaded, renderer) =>
                 SetImageCommand.Run(ref GetCommand<SetImageCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetIndexBuffer] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetIndexBuffer] = (memory, threaded, renderer) =>
                 SetIndexBufferCommand.Run(ref GetCommand<SetIndexBufferCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetLineParameters] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetLineParameters] = (memory, threaded, renderer) =>
                 SetLineParametersCommand.Run(ref GetCommand<SetLineParametersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetLogicOpState] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetLogicOpState] = (memory, threaded, renderer) =>
                 SetLogicOpStateCommand.Run(ref GetCommand<SetLogicOpStateCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetMultisampleState] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetMultisampleState] = (memory, threaded, renderer) =>
                 SetMultisampleStateCommand.Run(ref GetCommand<SetMultisampleStateCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPatchParameters] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetPatchParameters] = (memory, threaded, renderer) =>
                 SetPatchParametersCommand.Run(ref GetCommand<SetPatchParametersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPointParameters] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetPointParameters] = (memory, threaded, renderer) =>
                 SetPointParametersCommand.Run(ref GetCommand<SetPointParametersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPolygonMode] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetPolygonMode] = (memory, threaded, renderer) =>
                 SetPolygonModeCommand.Run(ref GetCommand<SetPolygonModeCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPrimitiveRestart] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetPrimitiveRestart] = (memory, threaded, renderer) =>
                 SetPrimitiveRestartCommand.Run(ref GetCommand<SetPrimitiveRestartCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetPrimitiveTopology] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetPrimitiveTopology] = (memory, threaded, renderer) =>
                 SetPrimitiveTopologyCommand.Run(ref GetCommand<SetPrimitiveTopologyCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetProgram] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetProgram] = (memory, threaded, renderer) =>
                 SetProgramCommand.Run(ref GetCommand<SetProgramCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetRasterizerDiscard] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetRasterizerDiscard] = (memory, threaded, renderer) =>
                 SetRasterizerDiscardCommand.Run(ref GetCommand<SetRasterizerDiscardCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetRenderTargetColorMasks] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetRenderTargetColorMasks] = (memory, threaded, renderer) =>
                 SetRenderTargetColorMasksCommand.Run(ref GetCommand<SetRenderTargetColorMasksCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetRenderTargetScale] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetRenderTargetScale] = (memory, threaded, renderer) =>
                 SetRenderTargetScaleCommand.Run(ref GetCommand<SetRenderTargetScaleCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetRenderTargets] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetRenderTargets] = (memory, threaded, renderer) =>
                 SetRenderTargetsCommand.Run(ref GetCommand<SetRenderTargetsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetScissor] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetScissor] = (memory, threaded, renderer) =>
                 SetScissorsCommand.Run(ref GetCommand<SetScissorsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetStencilTest] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetStencilTest] = (memory, threaded, renderer) =>
                 SetStencilTestCommand.Run(ref GetCommand<SetStencilTestCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetTextureAndSampler] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetTextureAndSampler] = (memory, threaded, renderer) =>
                 SetTextureAndSamplerCommand.Run(ref GetCommand<SetTextureAndSamplerCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetUserClipDistance] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetUserClipDistance] = (memory, threaded, renderer) =>
                 SetUserClipDistanceCommand.Run(ref GetCommand<SetUserClipDistanceCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetVertexAttribs] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetVertexAttribs] = (memory, threaded, renderer) =>
                 SetVertexAttribsCommand.Run(ref GetCommand<SetVertexAttribsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetVertexBuffers] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetVertexBuffers] = (memory, threaded, renderer) =>
                 SetVertexBuffersCommand.Run(ref GetCommand<SetVertexBuffersCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetViewports] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.SetViewports] = (memory, threaded, renderer) =>
                 SetViewportsCommand.Run(ref GetCommand<SetViewportsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureBarrier] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureBarrier] = (memory, threaded, renderer) =>
                 TextureBarrierCommand.Run(ref GetCommand<TextureBarrierCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TextureBarrierTiled] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TextureBarrierTiled] = (memory, threaded, renderer) =>
                 TextureBarrierTiledCommand.Run(ref GetCommand<TextureBarrierTiledCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TryHostConditionalRendering] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TryHostConditionalRendering] = (memory, threaded, renderer) =>
                 TryHostConditionalRenderingCommand.Run(ref GetCommand<TryHostConditionalRenderingCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.TryHostConditionalRenderingFlush] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.TryHostConditionalRenderingFlush] = (memory, threaded, renderer) =>
                 TryHostConditionalRenderingFlushCommand.Run(ref GetCommand<TryHostConditionalRenderingFlushCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.UpdateRenderScale] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+            _lookup[(int)CommandType.UpdateRenderScale] = (memory, threaded, renderer) =>
                 UpdateRenderScaleCommand.Run(ref GetCommand<UpdateRenderScaleCommand>(memory), threaded, renderer);
         }
 

Ryujinx.Graphics.GAL/Multithreading/ThreadedRenderer.cs

@@ -72,7 +72,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
         {
             _baseRenderer = renderer;
 
-            renderer.ScreenCaptured += (object sender, ScreenCaptureImageInfo info) => ScreenCaptured?.Invoke(this, info);
+            renderer.ScreenCaptured += (sender, info) => ScreenCaptured?.Invoke(this, info);
 
             Pipeline = new ThreadedPipeline(this, renderer.Pipeline);
             Window = new ThreadedWindow(this, renderer);

Ryujinx.Graphics.GAL/SamplerCreateInfo.cs

@@ -61,7 +61,7 @@ namespace Ryujinx.Graphics.GAL
                 AddressMode.ClampToEdge,
                 AddressMode.ClampToEdge,
                 CompareMode.None,
-                GAL.CompareOp.Always,
+                CompareOp.Always,
                 new ColorF(0f, 0f, 0f, 0f),
                 0f,
                 0f,

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

@@ -253,14 +253,19 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// Indicates that any storage buffer use is unaligned.
         /// </summary>
         /// <param name="value">The new value</param>
-        public void SetHasUnalignedStorageBuffer(bool value)
+        /// <returns>True if the unaligned state changed, false otherwise</returns>
+        public bool SetHasUnalignedStorageBuffer(bool value)
         {
             if (value != _graphics.HasUnalignedStorageBuffer)
             {
                 _graphics.HasUnalignedStorageBuffer = value;
 
                 Signal();
+
+                return true;
             }
+
+            return false;
         }
 
         /// <summary>

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

@@ -304,14 +304,12 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         private void CommitBindings()
         {
-            var buffers = _channel.BufferManager;
-            var hasUnaligned = buffers.HasUnalignedStorageBuffers;
-
             UpdateStorageBuffers();
 
-            if (!_channel.TextureManager.CommitGraphicsBindings(_shaderSpecState) || (buffers.HasUnalignedStorageBuffers != hasUnaligned))
+            bool unalignedChanged = _currentSpecState.SetHasUnalignedStorageBuffer(_channel.BufferManager.HasUnalignedStorageBuffers);
+
+            if (!_channel.TextureManager.CommitGraphicsBindings(_shaderSpecState) || unalignedChanged)
             {
-                _currentSpecState.SetHasUnalignedStorageBuffer(buffers.HasUnalignedStorageBuffers);
                 // Shader must be reloaded. _vtgWritesRtLayer should not change.
                 UpdateShaderState();
             }

Ryujinx.Graphics.Gpu/Shader/DiskCache/DiskCacheHostStorage.cs

@@ -22,7 +22,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
         private const ushort FileFormatVersionMajor = 1;
         private const ushort FileFormatVersionMinor = 2;
         private const uint FileFormatVersionPacked = ((uint)FileFormatVersionMajor << 16) | FileFormatVersionMinor;
-        private const uint CodeGenVersion = 4028;
+        private const uint CodeGenVersion = 4069;
 
         private const string SharedTocFileName = "shared.toc";
         private const string SharedDataFileName = "shared.data";

Ryujinx.Graphics.Gpu/Shader/ShaderSpecializationState.cs

@@ -110,7 +110,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
             /// <summary>
             /// Texture target.
             /// </summary>
-            public Image.TextureTarget TextureTarget;
+            public TextureTarget TextureTarget;
 
             /// <summary>
             /// Indicates if the coordinates used to sample the texture are normalized or not (0.0..1.0 or 0..Width/Height).
@@ -331,7 +331,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
             int cbufSlot,
             uint format,
             bool formatSrgb,
-            Image.TextureTarget target,
+            TextureTarget target,
             bool coordNormalized)
         {
             Box<TextureSpecializationState> state = GetOrCreateTextureSpecState(stageIndex, handle, cbufSlot);
@@ -415,7 +415,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="stageIndex">Shader stage where the texture is used</param>
         /// <param name="handle">Offset in words of the texture handle on the texture buffer</param>
         /// <param name="cbufSlot">Slot of the texture buffer constant buffer</param>
-        public Image.TextureTarget GetTextureTarget(int stageIndex, int handle, int cbufSlot)
+        public TextureTarget GetTextureTarget(int stageIndex, int handle, int cbufSlot)
         {
             return GetTextureSpecState(stageIndex, handle, cbufSlot).Value.TextureTarget;
         }

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

@@ -2,6 +2,6 @@ float Helper_SwizzleAdd(float x, float y, int mask)
 {
     vec4 xLut = vec4(1.0, -1.0, 1.0, 0.0);
     vec4 yLut = vec4(1.0, 1.0, -1.0, 1.0);
-    int lutIdx = mask >> int($SUBGROUP_INVOCATION$ & 3u) * 2;
+    int lutIdx = (mask >> (int($SUBGROUP_INVOCATION$ & 3u) * 2)) & 3;
     return x * xLut[lutIdx] + y * yLut[lutIdx];
 }

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

@@ -10,8 +10,6 @@ using static Spv.Specification;
 
 namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 {
-    using SpvInstruction = Spv.Generator.Instruction;
-
     static class Declarations
     {
         // At least 16 attributes are guaranteed by the spec.
@@ -60,7 +58,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             for (int funcIndex = 0; funcIndex < functions.Count; funcIndex++)
             {
                 StructuredFunction function = functions[funcIndex];
-                SpvInstruction[] locals = new SpvInstruction[function.InArguments.Length];
+                Instruction[] locals = new Instruction[function.InArguments.Length];
 
                 for (int i = 0; i < function.InArguments.Length; i++)
                 {
@@ -122,7 +120,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             context.SharedMemory = DeclareMemory(context, StorageClass.Workgroup, size);
         }
 
-        private static SpvInstruction DeclareMemory(CodeGenContext context, StorageClass storage, int size)
+        private static Instruction DeclareMemory(CodeGenContext context, StorageClass storage, int size)
         {
             var arrayType = context.TypeArray(context.TypeU32(), context.Constant(context.TypeU32(), size));
             var pointerType = context.TypePointer(storage, arrayType);

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

@@ -1449,10 +1449,13 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
             var xLut = context.ConstantComposite(v4float, one, minusOne, one, zero);
             var yLut = context.ConstantComposite(v4float, one, one, minusOne, one);
 
+            var three = context.Constant(context.TypeU32(), 3);
+
             var threadId = context.GetAttribute(AggregateType.U32, AttributeConsts.LaneId, false);
-            var shift = context.BitwiseAnd(context.TypeU32(), threadId, context.Constant(context.TypeU32(), 3));
+            var shift = context.BitwiseAnd(context.TypeU32(), threadId, three);
             shift = context.ShiftLeftLogical(context.TypeU32(), shift, context.Constant(context.TypeU32(), 1));
             var lutIdx = context.ShiftRightLogical(context.TypeU32(), mask, shift);
+            lutIdx = context.BitwiseAnd(context.TypeU32(), lutIdx, three);
 
             var xLutValue = context.VectorExtractDynamic(context.TypeFP32(), xLut, lutIdx);
             var yLutValue = context.VectorExtractDynamic(context.TypeFP32(), yLut, lutIdx);

Ryujinx.Graphics.Shader/Translation/AttributeConsts.cs

@@ -8,6 +8,7 @@ namespace Ryujinx.Graphics.Shader.Translation
         public const int TessLevelOuter3     = 0x00c;
         public const int TessLevelInner0     = 0x010;
         public const int TessLevelInner1     = 0x014;
+        public const int PrimitiveId         = 0x060;
         public const int Layer               = 0x064;
         public const int ViewportIndex       = 0x068;
         public const int PointSize           = 0x06c;
@@ -85,8 +86,7 @@ namespace Ryujinx.Graphics.Shader.Translation
         public const int LaneId = 0x2000020;
 
         public const int InvocationId = 0x2000024;
-        public const int PrimitiveId = 0x2000028;
+        public const int PatchVerticesIn = 0x2000028;
-        public const int PatchVerticesIn = 0x200002c;
 
         public const int EqMask = 0x2000030;
         public const int GeMask = 0x2000034;

Ryujinx.Graphics.Vulkan/BufferHolder.cs

@@ -272,7 +272,7 @@ namespace Ryujinx.Graphics.Vulkan
                 _gd,
                 cbs.CommandBuffer,
                 dstBuffer,
-                BufferHolder.DefaultAccessFlags,
+                DefaultAccessFlags,
                 AccessFlags.TransferWriteBit,
                 PipelineStageFlags.AllCommandsBit,
                 PipelineStageFlags.TransferBit,
@@ -294,7 +294,7 @@ namespace Ryujinx.Graphics.Vulkan
                 cbs.CommandBuffer,
                 dstBuffer,
                 AccessFlags.TransferWriteBit,
-                BufferHolder.DefaultAccessFlags,
+                DefaultAccessFlags,
                 PipelineStageFlags.TransferBit,
                 PipelineStageFlags.AllCommandsBit,
                 dstOffset,
@@ -319,7 +319,7 @@ namespace Ryujinx.Graphics.Vulkan
                 gd,
                 cbs.CommandBuffer,
                 dstBuffer,
-                BufferHolder.DefaultAccessFlags,
+                DefaultAccessFlags,
                 AccessFlags.TransferWriteBit,
                 PipelineStageFlags.AllCommandsBit,
                 PipelineStageFlags.TransferBit,
@@ -335,7 +335,7 @@ namespace Ryujinx.Graphics.Vulkan
                 cbs.CommandBuffer,
                 dstBuffer,
                 AccessFlags.TransferWriteBit,
-                BufferHolder.DefaultAccessFlags,
+                DefaultAccessFlags,
                 PipelineStageFlags.TransferBit,
                 PipelineStageFlags.AllCommandsBit,
                 dstOffset,

Ryujinx.Graphics.Vulkan/DescriptorSetUpdater.cs

@@ -97,7 +97,7 @@ namespace Ryujinx.Graphics.Vulkan
                 _dummyBuffer = gd.BufferManager.Create(gd, 0x10000, forConditionalRendering: false, deviceLocal: true);
             }
 
-            _dummyTexture = gd.CreateTextureView(new GAL.TextureCreateInfo(
+            _dummyTexture = gd.CreateTextureView(new TextureCreateInfo(
                 1,
                 1,
                 1,

Ryujinx.Graphics.Vulkan/DisposableBufferView.cs

@@ -3,7 +3,7 @@ using System;
 
 namespace Ryujinx.Graphics.Vulkan
 {
-    readonly struct DisposableBufferView : System.IDisposable
+    readonly struct DisposableBufferView : IDisposable
     {
         private readonly Vk _api;
         private readonly Device _device;

Ryujinx.Graphics.Vulkan/PipelineLayoutFactory.cs

@@ -86,7 +86,7 @@ namespace Ryujinx.Graphics.Vulkan
                 iter++;
             }
 
-            DescriptorSetLayout[] layouts = new DescriptorSetLayout[PipelineFull.DescriptorSetLayouts];
+            DescriptorSetLayout[] layouts = new DescriptorSetLayout[PipelineBase.DescriptorSetLayouts];
 
             var uDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
             {
@@ -117,10 +117,10 @@ namespace Ryujinx.Graphics.Vulkan
                 BindingCount = (uint)iCount
             };
 
-            gd.Api.CreateDescriptorSetLayout(device, uDescriptorSetLayoutCreateInfo, null, out layouts[PipelineFull.UniformSetIndex]).ThrowOnError();
+            gd.Api.CreateDescriptorSetLayout(device, uDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.UniformSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, sDescriptorSetLayoutCreateInfo, null, out layouts[PipelineFull.StorageSetIndex]).ThrowOnError();
+            gd.Api.CreateDescriptorSetLayout(device, sDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.StorageSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, tDescriptorSetLayoutCreateInfo, null, out layouts[PipelineFull.TextureSetIndex]).ThrowOnError();
+            gd.Api.CreateDescriptorSetLayout(device, tDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.TextureSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, iDescriptorSetLayoutCreateInfo, null, out layouts[PipelineFull.ImageSetIndex]).ThrowOnError();
+            gd.Api.CreateDescriptorSetLayout(device, iDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.ImageSetIndex]).ThrowOnError();
 
             fixed (DescriptorSetLayout* pLayouts = layouts)
             {
@@ -128,7 +128,7 @@ namespace Ryujinx.Graphics.Vulkan
                 {
                     SType = StructureType.PipelineLayoutCreateInfo,
                     PSetLayouts = pLayouts,
-                    SetLayoutCount = PipelineFull.DescriptorSetLayouts
+                    SetLayoutCount = PipelineBase.DescriptorSetLayouts
                 };
 
                 gd.Api.CreatePipelineLayout(device, &pipelineLayoutCreateInfo, null, out layout).ThrowOnError();
@@ -191,7 +191,7 @@ namespace Ryujinx.Graphics.Vulkan
                 Set(iLayoutBindings, DescriptorType.StorageImage, ref iIndex, shader.Bindings.ImageBindings);
             }
 
-            DescriptorSetLayout[] layouts = new DescriptorSetLayout[PipelineFull.DescriptorSetLayouts];
+            DescriptorSetLayout[] layouts = new DescriptorSetLayout[PipelineBase.DescriptorSetLayouts];
 
             var uDescriptorSetLayoutCreateInfo = new DescriptorSetLayoutCreateInfo()
             {
@@ -221,10 +221,10 @@ namespace Ryujinx.Graphics.Vulkan
                 BindingCount = (uint)iCount
             };
 
-            gd.Api.CreateDescriptorSetLayout(device, uDescriptorSetLayoutCreateInfo, null, out layouts[PipelineFull.UniformSetIndex]).ThrowOnError();
+            gd.Api.CreateDescriptorSetLayout(device, uDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.UniformSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, sDescriptorSetLayoutCreateInfo, null, out layouts[PipelineFull.StorageSetIndex]).ThrowOnError();
+            gd.Api.CreateDescriptorSetLayout(device, sDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.StorageSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, tDescriptorSetLayoutCreateInfo, null, out layouts[PipelineFull.TextureSetIndex]).ThrowOnError();
+            gd.Api.CreateDescriptorSetLayout(device, tDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.TextureSetIndex]).ThrowOnError();
-            gd.Api.CreateDescriptorSetLayout(device, iDescriptorSetLayoutCreateInfo, null, out layouts[PipelineFull.ImageSetIndex]).ThrowOnError();
+            gd.Api.CreateDescriptorSetLayout(device, iDescriptorSetLayoutCreateInfo, null, out layouts[PipelineBase.ImageSetIndex]).ThrowOnError();
 
             fixed (DescriptorSetLayout* pLayouts = layouts)
             {
@@ -232,7 +232,7 @@ namespace Ryujinx.Graphics.Vulkan
                 {
                     SType = StructureType.PipelineLayoutCreateInfo,
                     PSetLayouts = pLayouts,
-                    SetLayoutCount = PipelineFull.DescriptorSetLayouts
+                    SetLayoutCount = PipelineBase.DescriptorSetLayouts
                 };
 
                 gd.Api.CreatePipelineLayout(device, &pipelineLayoutCreateInfo, null, out layout).ThrowOnError();

Ryujinx.HLE/HOS/Services/Am/AppletOE/ApplicationProxyService/ApplicationProxy/IApplicationFunctions.cs

@@ -157,7 +157,7 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletOE.ApplicationProxyService.Applicati
             int  supportedLanguages  = (int)context.Device.Application.ControlData.Value.SupportedLanguageFlag;
             int  firstSupported      = BitOperations.TrailingZeroCount(supportedLanguages);
 
-            if (firstSupported > (int)SystemState.TitleLanguage.BrazilianPortuguese)
+            if (firstSupported > (int)TitleLanguage.BrazilianPortuguese)
             {
                 Logger.Warning?.Print(LogClass.ServiceAm, "Application has zero supported languages");
 
@@ -170,7 +170,7 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletOE.ApplicationProxyService.Applicati
             // TODO: In the future, a GUI could enable user-specified search priority
             if (((1 << (int)context.Device.System.State.DesiredTitleLanguage) & supportedLanguages) == 0)
             {
-                SystemLanguage newLanguage = Enum.Parse<SystemLanguage>(Enum.GetName(typeof(SystemState.TitleLanguage), firstSupported));
+                SystemLanguage newLanguage = Enum.Parse<SystemLanguage>(Enum.GetName(typeof(TitleLanguage), firstSupported));
                 desiredLanguageCode = SystemStateMgr.GetLanguageCode((int)newLanguage);
 
                 Logger.Info?.Print(LogClass.ServiceAm, $"Application doesn't support configured language. Using {newLanguage}");

Ryujinx.HLE/HOS/Services/Fs/IFileSystemProxy.cs

@@ -901,7 +901,7 @@ namespace Ryujinx.HLE.HOS.Services.Fs
         [CommandHipc(606)]
         public ResultCode GetRightsId(ServiceCtx context)
         {
-            LibHac.Ncm.StorageId storageId = (LibHac.Ncm.StorageId)context.RequestData.ReadInt64();
+            StorageId storageId = (StorageId)context.RequestData.ReadInt64();
             ProgramId programId = context.RequestData.ReadStruct<ProgramId>();
 
             Result result = _baseFileSystemProxy.Get.GetRightsId(out RightsId rightsId, programId, storageId);

Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneContentManager.cs

@@ -130,7 +130,7 @@ namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
             }
 
             List<(int Offset, string Location, string Abbr)> outList = new List<(int Offset, string Location, string Abbr)>();
-            var now = System.DateTimeOffset.Now.ToUnixTimeSeconds();
+            var now = DateTimeOffset.Now.ToUnixTimeSeconds();
             using (IStorage ncaStorage = new LocalStorage(_virtualFileSystem.SwitchPathToSystemPath(tzBinaryContentPath), FileAccess.Read, FileMode.Open))
             using (IFileSystem romfs = new Nca(_virtualFileSystem.KeySet, ncaStorage).OpenFileSystem(NcaSectionType.Data, _fsIntegrityCheckLevel))
             {

Ryujinx.Headless.SDL2/Ryujinx.Headless.SDL2.csproj

@@ -12,8 +12,7 @@
 
   <ItemGroup>
     <PackageReference Include="OpenTK.Core" Version="4.7.5" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build12" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.osx" Version="5.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
   </ItemGroup>
 
   <ItemGroup>
@@ -29,7 +28,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CommandLineParser" Version="2.8.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
   </ItemGroup>
 
 	<ItemGroup>

Ryujinx.ShaderTools/Ryujinx.ShaderTools.csproj

@@ -11,7 +11,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CommandLineParser" Version="2.8.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
   </ItemGroup>
 
 </Project>

Ryujinx.Tests.Unicorn/UnicornAArch32.cs

@@ -122,14 +122,14 @@ namespace Ryujinx.Tests.Unicorn
         {
             if (!_isDisposed)
             {
-                Interface.Checked(Native.Interface.uc_close(uc));
+                Interface.Checked(Interface.uc_close(uc));
                 _isDisposed = true;
             }
         }
 
         public void RunForCount(ulong count)
         {
-            Interface.Checked(Native.Interface.uc_emu_start(uc, this.PC, 0xFFFFFFFFFFFFFFFFu, 0, count));
+            Interface.Checked(Interface.uc_emu_start(uc, this.PC, 0xFFFFFFFFFFFFFFFFu, 0, count));
         }
 
         public void Step()
@@ -222,7 +222,7 @@ namespace Ryujinx.Tests.Unicorn
         {
             byte[] data = new byte[4];
 
-            Interface.Checked(Native.Interface.uc_reg_read(uc, (int)register, data));
+            Interface.Checked(Interface.uc_reg_read(uc, (int)register, data));
 
             return (uint)BitConverter.ToInt32(data, 0);
         }

Ryujinx.Tests.Unicorn/UnicornAArch64.cs

@@ -111,14 +111,14 @@ namespace Ryujinx.Tests.Unicorn
         {
             if (!_isDisposed)
             {
-                Interface.Checked(Native.Interface.uc_close(uc));
+                Interface.Checked(Interface.uc_close(uc));
                 _isDisposed = true;
             }
         }
 
         public void RunForCount(ulong count)
         {
-            Interface.Checked(Native.Interface.uc_emu_start(uc, this.PC, 0xFFFFFFFFFFFFFFFFu, 0, count));
+            Interface.Checked(Interface.uc_emu_start(uc, this.PC, 0xFFFFFFFFFFFFFFFFu, 0, count));
         }
 
         public void Step()
@@ -241,7 +241,7 @@ namespace Ryujinx.Tests.Unicorn
         {
             byte[] data = new byte[8];
 
-            Interface.Checked(Native.Interface.uc_reg_read(uc, (int)register, data));
+            Interface.Checked(Interface.uc_reg_read(uc, (int)register, data));
 
             return (ulong)BitConverter.ToInt64(data, 0);
         }

Ryujinx/Modules/Updater/UpdateDialog.cs

@@ -32,7 +32,7 @@ namespace Ryujinx.Modules
             _mainWindow = mainWindow;
             _buildUrl   = buildUrl;
 
-            Icon = new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");
+            Icon = new Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");
             MainText.Text      = "Do you want to update Ryujinx to the latest version?";
             SecondaryText.Text = $"{Program.Version} -> {newVersion}";
 

Ryujinx/Modules/Updater/Updater.cs

@@ -293,7 +293,7 @@ namespace Ryujinx.Modules
                         list[index] = args.Result;
                         Interlocked.Increment(ref completedRequests);
 
-                        if (Interlocked.Equals(completedRequests, ConnectionCount))
+                        if (Equals(completedRequests, ConnectionCount))
                         {
                             byte[] mergedFileBytes = new byte[_buildSize];
                             for (int connectionIndex = 0, destinationOffset = 0; connectionIndex < ConnectionCount; connectionIndex++)

Ryujinx/Program.cs

@@ -151,7 +151,7 @@ namespace Ryujinx
             // Initialize SDL2 driver
             SDL2Driver.MainThreadDispatcher = action =>
             {
-                Gtk.Application.Invoke(delegate
+                Application.Invoke(delegate
                 {
                     action();
                 });
@@ -282,7 +282,7 @@ namespace Ryujinx
                     ? GraphicsBackend.Vulkan
                     : GraphicsBackend.OpenGl;
 
-                ConfigurationState.Instance.ToFileFormat().SaveConfig(Program.ConfigurationPath);
+                ConfigurationState.Instance.ToFileFormat().SaveConfig(ConfigurationPath);
             }
 
             Application.Run();

Ryujinx/Ryujinx.csproj

@@ -22,8 +22,7 @@
     <PackageReference Include="Ryujinx.GtkSharp" Version="3.24.24.59-ryujinx" />
     <PackageReference Include="GtkSharp.Dependencies" Version="1.1.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
     <PackageReference Include="GtkSharp.Dependencies.osx" Version="0.0.5" Condition="'$(RuntimeIdentifier)' == 'osx-x64' OR '$(RuntimeIdentifier)' == 'osx-arm64'" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build12" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.osx" Version="5.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
     <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
     <PackageReference Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
     <PackageReference Include="OpenTK.Core" Version="4.7.5" />

Ryujinx/Ui/RendererWidgetBase.cs

@@ -132,7 +132,7 @@ namespace Ryujinx.Ui
 
         private void HideCursorStateChanged(object sender, ReactiveEventArgs<bool> state)
         {
-            Gtk.Application.Invoke(delegate
+            Application.Invoke(delegate
             {
                 _hideCursorOnIdle = state.NewValue;
 
@@ -248,7 +248,7 @@ namespace Ryujinx.Ui
                                 && keyboard.IsPressed(Key.Enter))
                                 || keyboard.IsPressed(Key.Escape);
 
-            bool fullScreenToggled = ParentWindow.State.HasFlag(Gdk.WindowState.Fullscreen);
+            bool fullScreenToggled = ParentWindow.State.HasFlag(WindowState.Fullscreen);
 
             if (toggleFullscreen != _toggleFullscreen)
             {
@@ -340,7 +340,7 @@ namespace Ryujinx.Ui
                         string directory   = AppDataManager.Mode switch
                         {
                             AppDataManager.LaunchMode.Portable => System.IO.Path.Combine(AppDataManager.BaseDirPath, "screenshots"),
-                            _ => System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyPictures), "Ryujinx")
+                            _ => System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyPictures), "Ryujinx")
                         };
 
                         string path = System.IO.Path.Combine(directory, filename);
@@ -434,7 +434,7 @@ namespace Ryujinx.Ui
                     if (_ticks >= _ticksPerFrame)
                     {
                         string dockedMode = ConfigurationState.Instance.System.EnableDockedMode ? "Docked" : "Handheld";
-                        float scale = Graphics.Gpu.GraphicsConfig.ResScale;
+                        float scale = GraphicsConfig.ResScale;
                         if (scale != 1)
                         {
                             dockedMode += $" ({scale}x)";