Fix games freezing after initializing LDN 1021 times (#5787)

* Close handle for stateChangeEvent on Finalize

* Properly dispose NetworkClient before setting it to null

Directory.Packages.props

@@ -20,7 +20,7 @@
     <PackageVersion Include="jp2masa.Avalonia.Flexbox" Version="0.3.0-beta.4" />
     <PackageVersion Include="LibHac" Version="0.18.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.6.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.7.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="2.3.2" />
     <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />

src/ARMeilleure/Diagnostics/Symbols.cs

@@ -34,7 +34,6 @@ namespace ARMeilleure.Diagnostics
 
         public static string Get(ulong address)
         {
-
             if (_symbols.TryGetValue(address, out string result))
             {
                 return result;
@@ -57,7 +56,8 @@ namespace ARMeilleure.Diagnostics
                             resultBuilder.Append($"+{rem}");
                         }
 
-                        _symbols.TryAdd(address, resultBuilder.ToString());
+                        result = resultBuilder.ToString();
+                        _symbols.TryAdd(address, result);
 
                         return result;
                     }

src/Ryujinx.Ava/UI/ViewModels/MainWindowViewModel.cs

@@ -1278,6 +1278,11 @@ namespace Ryujinx.Ava.UI.ViewModels
             Glyph = Glyph.Grid;
         }
 
+        public void SetAspectRatio(AspectRatio aspectRatio)
+        {
+            ConfigurationState.Instance.Graphics.AspectRatio.Value = aspectRatio;
+        }
+
         public async Task InstallFirmwareFromFile()
         {
             var result = await StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions

src/Ryujinx.Ava/UI/Views/Main/MainStatusBarView.axaml

@@ -6,6 +6,7 @@
     xmlns:locale="clr-namespace:Ryujinx.Ava.Common.Locale"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
     xmlns:viewModels="clr-namespace:Ryujinx.Ava.UI.ViewModels"
+    xmlns:config="clr-namespace:Ryujinx.Common.Configuration;assembly=Ryujinx.Common"
     mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
     x:Class="Ryujinx.Ava.UI.Views.Main.MainStatusBarView"
     x:DataType="viewModels:MainWindowViewModel">
@@ -112,15 +113,52 @@
                 Background="Gray"
                 BorderThickness="1"
                 IsVisible="{Binding !ShowLoadProgress}" />
-            <TextBlock
+            <SplitButton
                 Name="AspectRatioStatus"
-                Margin="5,0,5,0"
+                Padding="5,0,5,0"
                 HorizontalAlignment="Left"
                 VerticalAlignment="Center"
+                Background="Transparent"
+                BorderThickness="0"
+                CornerRadius="0"
                 IsVisible="{Binding !ShowLoadProgress}"
-                PointerReleased="AspectRatioStatus_PointerReleased"
-                Text="{Binding AspectRatioStatusText}"
-                TextAlignment="Left" />
+                Content="{Binding AspectRatioStatusText}"
+                Click="AspectRatioStatus_OnClick"
+                ToolTip.Tip="{locale:Locale AspectRatioTooltip}">
+                <SplitButton.Styles>
+                    <Style Selector="Border#SeparatorBorder">
+                        <Setter Property="Opacity" Value="0" />
+                    </Style>
+                </SplitButton.Styles>
+                <SplitButton.Flyout>
+                    <MenuFlyout Placement="Bottom" ShowMode="TransientWithDismissOnPointerMoveAway">
+                        <MenuItem
+                            Header="{locale:Locale SettingsTabGraphicsAspectRatio4x3}"
+                            Command="{Binding SetAspectRatio}"
+                            CommandParameter="{x:Static config:AspectRatio.Fixed4x3}"/>
+                        <MenuItem
+                            Header="{locale:Locale SettingsTabGraphicsAspectRatio16x9}"
+                            Command="{Binding SetAspectRatio}"
+                            CommandParameter="{x:Static config:AspectRatio.Fixed16x9}"/>
+                        <MenuItem
+                            Header="{locale:Locale SettingsTabGraphicsAspectRatio16x10}"
+                            Command="{Binding SetAspectRatio}"
+                            CommandParameter="{x:Static config:AspectRatio.Fixed16x10}"/>
+                        <MenuItem
+                            Header="{locale:Locale SettingsTabGraphicsAspectRatio21x9}"
+                            Command="{Binding SetAspectRatio}"
+                            CommandParameter="{x:Static config:AspectRatio.Fixed21x9}"/>
+                        <MenuItem
+                            Header="{locale:Locale SettingsTabGraphicsAspectRatio32x9}"
+                            Command="{Binding SetAspectRatio}"
+                            CommandParameter="{x:Static config:AspectRatio.Fixed32x9}"/>
+                        <MenuItem
+                            Header="{locale:Locale SettingsTabGraphicsAspectRatioStretch}"
+                            Command="{Binding SetAspectRatio}"
+                            CommandParameter="{x:Static config:AspectRatio.Stretched}"/>
+                    </MenuFlyout>
+                </SplitButton.Flyout>
+            </SplitButton>
             <Border
                 Width="2"
                 Height="12"

src/Ryujinx.Ava/UI/Views/Main/MainStatusBarView.axaml.cs

@@ -43,10 +43,9 @@ namespace Ryujinx.Ava.UI.Views.Main
             ConfigurationState.Instance.System.EnableDockedMode.Value = !ConfigurationState.Instance.System.EnableDockedMode.Value;
         }
 
-        private void AspectRatioStatus_PointerReleased(object sender, PointerReleasedEventArgs e)
+        private void AspectRatioStatus_OnClick(object sender, RoutedEventArgs e)
         {
             AspectRatio aspectRatio = ConfigurationState.Instance.Graphics.AspectRatio.Value;
-
             ConfigurationState.Instance.Graphics.AspectRatio.Value = (int)aspectRatio + 1 > Enum.GetNames(typeof(AspectRatio)).Length - 1 ? AspectRatio.Fixed4x3 : aspectRatio + 1;
         }
 

src/Ryujinx.Common/Memory/StructArrayHelpers.cs

@@ -756,6 +756,18 @@ namespace Ryujinx.Common.Memory
         public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
     }
 
+    public struct Array96<T> : IArray<T> where T : unmanaged
+    {
+        T _e0;
+        Array64<T> _other;
+        Array31<T> _other2;
+        public readonly int Length => 96;
+        public ref T this[int index] => ref AsSpan()[index];
+
+        [Pure]
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
+    }
+
     public struct Array127<T> : IArray<T> where T : unmanaged
     {
         T _e0;

src/Ryujinx.Graphics.Gpu/Engine/DeviceStateWithShadow.cs

@@ -32,6 +32,11 @@ namespace Ryujinx.Graphics.Gpu.Engine
         /// </summary>
         public ref TState State => ref _state.State;
 
+        /// <summary>
+        /// Current shadow state.
+        /// </summary>
+        public ref TState ShadowState => ref _shadowState.State;
+
         /// <summary>
         /// Creates a new instance of the device state, with shadow state.
         /// </summary>

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

@@ -1,7 +1,10 @@
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.Device;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.GPFifo;
+using Ryujinx.Graphics.Gpu.Engine.Threed;
+using Ryujinx.Graphics.Gpu.Engine.Types;
 using System;
 using System.Collections.Generic;
 
@@ -15,9 +18,18 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         private const int ColorLayerCountOffset = 0x818;
         private const int ColorStructSize = 0x40;
         private const int ZetaLayerCountOffset = 0x1230;
+        private const int UniformBufferBindVertexOffset = 0x2410;
+        private const int FirstVertexOffset = 0x1434;
 
         private const int IndirectIndexedDataEntrySize = 0x14;
 
+        private const int LogicOpOffset = 0x19c4;
+        private const int ShaderIdScratchOffset = 0x3470;
+        private const int ShaderAddressScratchOffset = 0x3488;
+        private const int UpdateConstantBufferAddressesBase = 0x34a8;
+        private const int UpdateConstantBufferSizesBase = 0x34bc;
+        private const int UpdateConstantBufferAddressCbu = 0x3460;
+
         private readonly GPFifoProcessor _processor;
         private readonly MacroHLEFunctionName _functionName;
 
@@ -49,6 +61,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         {
             switch (_functionName)
             {
+                case MacroHLEFunctionName.BindShaderProgram:
+                    BindShaderProgram(state, arg0);
+                    break;
                 case MacroHLEFunctionName.ClearColor:
                     ClearColor(state, arg0);
                     break;
@@ -58,6 +73,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 case MacroHLEFunctionName.DrawArraysInstanced:
                     DrawArraysInstanced(state, arg0);
                     break;
+                case MacroHLEFunctionName.DrawElements:
+                    DrawElements(state, arg0);
+                    break;
                 case MacroHLEFunctionName.DrawElementsInstanced:
                     DrawElementsInstanced(state, arg0);
                     break;
@@ -67,6 +85,21 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 case MacroHLEFunctionName.MultiDrawElementsIndirectCount:
                     MultiDrawElementsIndirectCount(state, arg0);
                     break;
+                case MacroHLEFunctionName.UpdateBlendState:
+                    UpdateBlendState(state, arg0);
+                    break;
+                case MacroHLEFunctionName.UpdateColorMasks:
+                    UpdateColorMasks(state, arg0);
+                    break;
+                case MacroHLEFunctionName.UpdateUniformBufferState:
+                    UpdateUniformBufferState(state, arg0);
+                    break;
+                case MacroHLEFunctionName.UpdateUniformBufferStateCbu:
+                    UpdateUniformBufferStateCbu(state, arg0);
+                    break;
+                case MacroHLEFunctionName.UpdateUniformBufferStateCbuV2:
+                    UpdateUniformBufferStateCbuV2(state, arg0);
+                    break;
                 default:
                     throw new NotImplementedException(_functionName.ToString());
             }
@@ -75,6 +108,149 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
             Fifo.Clear();
         }
 
+        /// <summary>
+        /// Binds a shader program with the index in arg0.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void BindShaderProgram(IDeviceState state, int arg0)
+        {
+            int scratchOffset = ShaderIdScratchOffset + arg0 * 4;
+
+            int lastId = state.Read(scratchOffset);
+            int id = FetchParam().Word;
+            int offset = FetchParam().Word;
+
+            if (lastId == id)
+            {
+                FetchParam();
+                FetchParam();
+
+                return;
+            }
+
+            _processor.ThreedClass.SetShaderOffset(arg0, (uint)offset);
+
+            // Removes overflow on the method address into the increment portion.
+            // Present in the original macro.
+            int addrMask = unchecked((int)0xfffc0fff) << 2;
+
+            state.Write(scratchOffset & addrMask, id);
+            state.Write((ShaderAddressScratchOffset + arg0 * 4) & addrMask, offset);
+
+            int stage = FetchParam().Word;
+            uint cbAddress = (uint)FetchParam().Word;
+
+            _processor.ThreedClass.UpdateUniformBufferState(65536, cbAddress >> 24, cbAddress << 8);
+
+            int stageOffset = (stage & 0x7f) << 3;
+
+            state.Write((UniformBufferBindVertexOffset + stageOffset * 4) & addrMask, 17);
+        }
+
+        /// <summary>
+        /// Updates uniform buffer state for update or bind.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void UpdateUniformBufferState(IDeviceState state, int arg0)
+        {
+            uint address = (uint)state.Read(UpdateConstantBufferAddressesBase + arg0 * 4);
+            int size = state.Read(UpdateConstantBufferSizesBase + arg0 * 4);
+
+            _processor.ThreedClass.UpdateUniformBufferState(size, address >> 24, address << 8);
+        }
+
+        /// <summary>
+        /// Updates uniform buffer state for update.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void UpdateUniformBufferStateCbu(IDeviceState state, int arg0)
+        {
+            uint address = (uint)state.Read(UpdateConstantBufferAddressCbu);
+
+            UniformBufferState ubState = new()
+            {
+                Address = new()
+                {
+                    High = address >> 24,
+                    Low = address << 8
+                },
+                Size = 24320,
+                Offset = arg0 << 2
+            };
+
+            _processor.ThreedClass.UpdateUniformBufferState(ubState);
+        }
+
+        /// <summary>
+        /// Updates uniform buffer state for update.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void UpdateUniformBufferStateCbuV2(IDeviceState state, int arg0)
+        {
+            uint address = (uint)state.Read(UpdateConstantBufferAddressCbu);
+
+            UniformBufferState ubState = new()
+            {
+                Address = new()
+                {
+                    High = address >> 24,
+                    Low = address << 8
+                },
+                Size = 28672,
+                Offset = arg0 << 2
+            };
+
+            _processor.ThreedClass.UpdateUniformBufferState(ubState);
+        }
+
+        /// <summary>
+        /// Updates blend enable using the given argument.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void UpdateBlendState(IDeviceState state, int arg0)
+        {
+            state.Write(LogicOpOffset, 0);
+
+            Array8<Boolean32> enable = new();
+
+            for (int i = 0; i < 8; i++)
+            {
+                enable[i] = new Boolean32((uint)(arg0 >> (i + 8)) & 1);
+            }
+
+            _processor.ThreedClass.UpdateBlendEnable(ref enable);
+        }
+
+        /// <summary>
+        /// Updates color masks using the given argument and three pushed arguments.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void UpdateColorMasks(IDeviceState state, int arg0)
+        {
+            Array8<RtColorMask> masks = new();
+
+            int index = 0;
+
+            for (int i = 0; i < 4; i++)
+            {
+                masks[index++] = new RtColorMask((uint)arg0 & 0x1fff);
+                masks[index++] = new RtColorMask(((uint)arg0 >> 16) & 0x1fff);
+
+                if (i != 3)
+                {
+                    arg0 = FetchParam().Word;
+                }
+            }
+
+            _processor.ThreedClass.UpdateColorMasks(ref masks);
+        }
+
         /// <summary>
         /// Clears one bound color target.
         /// </summary>
@@ -129,6 +305,36 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
                 indexed: false);
         }
 
+        /// <summary>
+        /// Performs a indexed draw.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void DrawElements(IDeviceState state, int arg0)
+        {
+            var topology = (PrimitiveTopology)arg0;
+
+            var indexAddressHigh = FetchParam();
+            var indexAddressLow = FetchParam();
+            var indexType = FetchParam();
+            var firstIndex = 0;
+            var indexCount = FetchParam();
+
+            _processor.ThreedClass.UpdateIndexBuffer(
+                (uint)indexAddressHigh.Word,
+                (uint)indexAddressLow.Word,
+                (IndexType)indexType.Word);
+
+            _processor.ThreedClass.Draw(
+                topology,
+                indexCount.Word,
+                1,
+                firstIndex,
+                state.Read(FirstVertexOffset),
+                0,
+                indexed: true);
+        }
+
         /// <summary>
         /// Performs a indexed draw.
         /// </summary>

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

@@ -6,11 +6,19 @@
     enum MacroHLEFunctionName
     {
         None,
+        BindShaderProgram,
         ClearColor,
         ClearDepthStencil,
         DrawArraysInstanced,
+        DrawElements,
         DrawElementsInstanced,
         DrawElementsIndirect,
         MultiDrawElementsIndirectCount,
+
+        UpdateBlendState,
+        UpdateColorMasks,
+        UpdateUniformBufferState,
+        UpdateUniformBufferStateCbu,
+        UpdateUniformBufferStateCbuV2
     }
 }

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

@@ -46,12 +46,19 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
 
         private static readonly TableEntry[] _table = new TableEntry[]
         {
+            new(MacroHLEFunctionName.BindShaderProgram, new Hash128(0x5d5efb912369f60b, 0x69131ed5019f08ef), 0x68),
             new(MacroHLEFunctionName.ClearColor, new Hash128(0xA9FB28D1DC43645A, 0xB177E5D2EAE67FB0), 0x28),
             new(MacroHLEFunctionName.ClearDepthStencil, new Hash128(0x1B96CB77D4879F4F, 0x8557032FE0C965FB), 0x24),
             new(MacroHLEFunctionName.DrawArraysInstanced, new Hash128(0x197FB416269DBC26, 0x34288C01DDA82202), 0x48),
+            new(MacroHLEFunctionName.DrawElements, new Hash128(0x3D7F32AE6C2702A7, 0x9353C9F41C1A244D), 0x20),
             new(MacroHLEFunctionName.DrawElementsInstanced, new Hash128(0x1A501FD3D54EC8E0, 0x6CF570CF79DA74D6), 0x5c),
             new(MacroHLEFunctionName.DrawElementsIndirect, new Hash128(0x86A3E8E903AF8F45, 0xD35BBA07C23860A4), 0x7c),
             new(MacroHLEFunctionName.MultiDrawElementsIndirectCount, new Hash128(0x890AF57ED3FB1C37, 0x35D0C95C61F5386F), 0x19C),
+            new(MacroHLEFunctionName.UpdateBlendState, new Hash128(0x40F6D4E7B08D7640, 0x82167BEEAECB959F), 0x28),
+            new(MacroHLEFunctionName.UpdateColorMasks, new Hash128(0x9EE32420B8441DFD, 0x6E7724759A57333E), 0x24),
+            new(MacroHLEFunctionName.UpdateUniformBufferState, new Hash128(0x8EE66706049CB0B0, 0x51C1CF906EC86F7C), 0x20),
+            new(MacroHLEFunctionName.UpdateUniformBufferStateCbu, new Hash128(0xA4592676A3E581A0, 0xA39E77FE19FE04AC), 0x18),
+            new(MacroHLEFunctionName.UpdateUniformBufferStateCbuV2, new Hash128(0x392FA750489983D4, 0x35BACE455155D2C3), 0x18)
         };
 
         /// <summary>
@@ -62,18 +69,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         /// <returns>True if the host supports the HLE macro, false otherwise</returns>
         private static bool IsMacroHLESupported(Capabilities caps, MacroHLEFunctionName name)
         {
-            if (name == MacroHLEFunctionName.ClearColor ||
-                name == MacroHLEFunctionName.ClearDepthStencil ||
-                name == MacroHLEFunctionName.DrawArraysInstanced ||
-                name == MacroHLEFunctionName.DrawElementsInstanced ||
-                name == MacroHLEFunctionName.DrawElementsIndirect)
-            {
-                return true;
-            }
-            else if (name == MacroHLEFunctionName.MultiDrawElementsIndirectCount)
+            if (name == MacroHLEFunctionName.MultiDrawElementsIndirectCount)
             {
                 return caps.SupportsIndirectParameters;
             }
+            else if (name != MacroHLEFunctionName.None)
+            {
+                return true;
+            }
 
             return false;
         }

src/Ryujinx.Graphics.Gpu/Engine/SetMmeShadowRamControlMode.cs

@@ -10,4 +10,22 @@ namespace Ryujinx.Graphics.Gpu.Engine
         MethodPassthrough = 2,
         MethodReplay = 3,
     }
+
+    static class SetMmeShadowRamControlModeExtensions
+    {
+        public static bool IsTrack(this SetMmeShadowRamControlMode mode)
+        {
+            return mode == SetMmeShadowRamControlMode.MethodTrack || mode == SetMmeShadowRamControlMode.MethodTrackWithFilter;
+        }
+
+        public static bool IsPassthrough(this SetMmeShadowRamControlMode mode)
+        {
+            return mode == SetMmeShadowRamControlMode.MethodPassthrough;
+        }
+
+        public static bool IsReplay(this SetMmeShadowRamControlMode mode)
+        {
+            return mode == SetMmeShadowRamControlMode.MethodReplay;
+        }
+    }
 }

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

@@ -17,9 +17,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
     class StateUpdater
     {
         public const int ShaderStateIndex = 26;
+        public const int RtColorMaskIndex = 14;
         public const int RasterizerStateIndex = 15;
         public const int ScissorStateIndex = 16;
         public const int VertexBufferStateIndex = 0;
+        public const int BlendStateIndex = 2;
         public const int IndexBufferStateIndex = 23;
         public const int PrimitiveRestartStateIndex = 12;
         public const int RenderTargetStateIndex = 27;

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

@@ -1,12 +1,15 @@
-using Ryujinx.Graphics.Device;
+using Ryujinx.Common.Memory;
+using Ryujinx.Graphics.Device;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.GPFifo;
 using Ryujinx.Graphics.Gpu.Engine.InlineToMemory;
 using Ryujinx.Graphics.Gpu.Engine.Threed.Blender;
+using Ryujinx.Graphics.Gpu.Engine.Types;
 using Ryujinx.Graphics.Gpu.Synchronization;
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
 
 namespace Ryujinx.Graphics.Gpu.Engine.Threed
 {
@@ -26,6 +29,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         private readonly ConstantBufferUpdater _cbUpdater;
         private readonly StateUpdater _stateUpdater;
 
+        private SetMmeShadowRamControlMode ShadowMode => _state.State.SetMmeShadowRamControlMode;
+
         /// <summary>
         /// Creates a new instance of the 3D engine class.
         /// </summary>
@@ -228,6 +233,206 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             _cbUpdater.Update(data);
         }
 
+        /// <summary>
+        /// Test if two 32 byte structs are equal. 
+        /// </summary>
+        /// <typeparam name="T">Type of the 32-byte struct</typeparam>
+        /// <param name="lhs">First struct</param>
+        /// <param name="rhs">Second struct</param>
+        /// <returns>True if equal, false otherwise</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool UnsafeEquals32Byte<T>(ref T lhs, ref T rhs) where T : unmanaged
+        {
+            if (Vector256.IsHardwareAccelerated)
+            {
+                return Vector256.EqualsAll(
+                    Unsafe.As<T, Vector256<uint>>(ref lhs),
+                    Unsafe.As<T, Vector256<uint>>(ref rhs)
+                );
+            }
+            else
+            {
+                ref var lhsVec = ref Unsafe.As<T, Vector128<uint>>(ref lhs);
+                ref var rhsVec = ref Unsafe.As<T, Vector128<uint>>(ref rhs);
+
+                return Vector128.EqualsAll(lhsVec, rhsVec) &&
+                    Vector128.EqualsAll(Unsafe.Add(ref lhsVec, 1), Unsafe.Add(ref rhsVec, 1));
+            }
+        }
+
+        /// <summary>
+        /// Updates blend enable. Respects current shadow mode.
+        /// </summary>
+        /// <param name="masks">Blend enable</param>
+        public void UpdateBlendEnable(ref Array8<Boolean32> enable)
+        {
+            var shadow = ShadowMode;
+            ref var state = ref _state.State.BlendEnable;
+
+            if (shadow.IsReplay())
+            {
+                enable = _state.ShadowState.BlendEnable;
+            }
+
+            if (!UnsafeEquals32Byte(ref enable, ref state))
+            {
+                state = enable;
+
+                _stateUpdater.ForceDirty(StateUpdater.BlendStateIndex);
+            }
+
+            if (shadow.IsTrack())
+            {
+                _state.ShadowState.BlendEnable = enable;
+            }
+        }
+
+        /// <summary>
+        /// Updates color masks. Respects current shadow mode.
+        /// </summary>
+        /// <param name="masks">Color masks</param>
+        public void UpdateColorMasks(ref Array8<RtColorMask> masks)
+        {
+            var shadow = ShadowMode;
+            ref var state = ref _state.State.RtColorMask;
+
+            if (shadow.IsReplay())
+            {
+                masks = _state.ShadowState.RtColorMask;
+            }
+
+            if (!UnsafeEquals32Byte(ref masks, ref state))
+            {
+                state = masks;
+
+                _stateUpdater.ForceDirty(StateUpdater.RtColorMaskIndex);
+            }
+
+            if (shadow.IsTrack())
+            {
+                _state.ShadowState.RtColorMask = masks;
+            }
+        }
+
+        /// <summary>
+        /// Updates index buffer state for an indexed draw. Respects current shadow mode.
+        /// </summary>
+        /// <param name="addrHigh">High part of the address</param>
+        /// <param name="addrLow">Low part of the address</param>
+        /// <param name="type">Type of the binding</param>
+        public void UpdateIndexBuffer(uint addrHigh, uint addrLow, IndexType type)
+        {
+            var shadow = ShadowMode;
+            ref var state = ref _state.State.IndexBufferState;
+
+            if (shadow.IsReplay())
+            {
+                ref var shadowState = ref _state.ShadowState.IndexBufferState;
+                addrHigh = shadowState.Address.High;
+                addrLow = shadowState.Address.Low;
+                type = shadowState.Type;
+            }
+
+            if (state.Address.High != addrHigh || state.Address.Low != addrLow || state.Type != type)
+            {
+                state.Address.High = addrHigh;
+                state.Address.Low = addrLow;
+                state.Type = type;
+
+                _stateUpdater.ForceDirty(StateUpdater.IndexBufferStateIndex);
+            }
+
+            if (shadow.IsTrack())
+            {
+                ref var shadowState = ref _state.ShadowState.IndexBufferState;
+                shadowState.Address.High = addrHigh;
+                shadowState.Address.Low = addrLow;
+                shadowState.Type = type;
+            }
+        }
+
+        /// <summary>
+        /// Updates uniform buffer state for update or bind. Respects current shadow mode.
+        /// </summary>
+        /// <param name="size">Size of the binding</param>
+        /// <param name="addrHigh">High part of the addrsss</param>
+        /// <param name="addrLow">Low part of the address</param>
+        public void UpdateUniformBufferState(int size, uint addrHigh, uint addrLow)
+        {
+            var shadow = ShadowMode;
+            ref var state = ref _state.State.UniformBufferState;
+
+            if (shadow.IsReplay())
+            {
+                ref var shadowState = ref _state.ShadowState.UniformBufferState;
+                size = shadowState.Size;
+                addrHigh = shadowState.Address.High;
+                addrLow = shadowState.Address.Low;
+            }
+
+            state.Size = size;
+            state.Address.High = addrHigh;
+            state.Address.Low = addrLow;
+
+            if (shadow.IsTrack())
+            {
+                ref var shadowState = ref _state.ShadowState.UniformBufferState;
+                shadowState.Size = size;
+                shadowState.Address.High = addrHigh;
+                shadowState.Address.Low = addrLow;
+            }
+        }
+
+        /// <summary>
+        /// Updates a shader offset. Respects current shadow mode.
+        /// </summary>
+        /// <param name="index">Index of the shader to update</param>
+        /// <param name="offset">Offset to update with</param>
+        public void SetShaderOffset(int index, uint offset)
+        {
+            var shadow = ShadowMode;
+            ref var shaderState = ref _state.State.ShaderState[index];
+
+            if (shadow.IsReplay())
+            {
+                offset = _state.ShadowState.ShaderState[index].Offset;
+            }
+
+            if (shaderState.Offset != offset)
+            {
+                shaderState.Offset = offset;
+
+                _stateUpdater.ForceDirty(StateUpdater.ShaderStateIndex);
+            }
+
+            if (shadow.IsTrack())
+            {
+                _state.ShadowState.ShaderState[index].Offset = offset;
+            }
+        }
+
+        /// <summary>
+        /// Updates uniform buffer state for update. Respects current shadow mode.
+        /// </summary>
+        /// <param name="ubState">Uniform buffer state</param>
+        public void UpdateUniformBufferState(UniformBufferState ubState)
+        {
+            var shadow = ShadowMode;
+            ref var state = ref _state.State.UniformBufferState;
+
+            if (shadow.IsReplay())
+            {
+                ubState = _state.ShadowState.UniformBufferState;
+            }
+
+            state = ubState;
+
+            if (shadow.IsTrack())
+            {
+                _state.ShadowState.UniformBufferState = ubState;
+            }
+        }
+
         /// <summary>
         /// Launches the Inline-to-Memory DMA copy operation.
         /// </summary>

src/Ryujinx.Graphics.Gpu/Engine/Threed/ThreedClassState.cs

@@ -590,9 +590,12 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
     /// </summary>
     struct RtColorMask
     {
-#pragma warning disable CS0649 // Field is never assigned to
         public uint Packed;
-#pragma warning restore CS0649
+
+        public RtColorMask(uint packed)
+        {
+            Packed = packed;
+        }
 
         /// <summary>
         /// Unpacks red channel enable.

src/Ryujinx.Graphics.Gpu/Engine/Types/Boolean32.cs

@@ -5,9 +5,12 @@
     /// </summary>
     readonly struct Boolean32
     {
-#pragma warning disable CS0649 // Field is never assigned to
         private readonly uint _value;
-#pragma warning restore CS0649
+
+        public Boolean32(uint value)
+        {
+            _value = value;
+        }
 
         public static implicit operator bool(Boolean32 value)
         {

src/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 = 5764;
+        private const uint CodeGenVersion = 5767;
 
         private const string SharedTocFileName = "shared.toc";
         private const string SharedDataFileName = "shared.data";

src/Ryujinx.Graphics.Shader/StructuredIr/StructuredProgram.cs

@@ -2,6 +2,7 @@ using Ryujinx.Graphics.Shader.IntermediateRepresentation;
 using Ryujinx.Graphics.Shader.Translation;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Numerics;
 
 namespace Ryujinx.Graphics.Shader.StructuredIr
@@ -62,7 +63,7 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
                         }
                         else
                         {
-                            AddOperation(context, operation, targetLanguage);
+                            AddOperation(context, operation, targetLanguage, functions);
                         }
                     }
                 }
@@ -77,7 +78,7 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
             return context.Info;
         }
 
-        private static void AddOperation(StructuredProgramContext context, Operation operation, TargetLanguage targetLanguage)
+        private static void AddOperation(StructuredProgramContext context, Operation operation, TargetLanguage targetLanguage, IReadOnlyList<Function> functions)
         {
             Instruction inst = operation.Inst;
             StorageKind storageKind = operation.StorageKind;
@@ -124,14 +125,29 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
                 // (or at least that's what the Khronos compiler does).
 
                 // First one is the function index.
-                sources[0] = context.GetOperandOrCbLoad(operation.GetSource(0));
+                Operand funcIndexOperand = operation.GetSource(0);
+                Debug.Assert(funcIndexOperand.Type == OperandType.Constant);
+                int funcIndex = funcIndexOperand.Value;
+
+                sources[0] = new AstOperand(OperandType.Constant, funcIndex);
+
+                int inArgsCount = functions[funcIndex].InArgumentsCount;
 
                 // Remaining ones are parameters, copy them to a temp local variable.
                 for (int index = 1; index < operation.SourcesCount; index++)
                 {
-                    AstOperand argTemp = context.NewTemp(FuncParameterType);
-                    context.AddNode(new AstAssignment(argTemp, context.GetOperandOrCbLoad(operation.GetSource(index))));
-                    sources[index] = argTemp;
+                    IAstNode source = context.GetOperandOrCbLoad(operation.GetSource(index));
+
+                    if (index - 1 < inArgsCount)
+                    {
+                        AstOperand argTemp = context.NewTemp(FuncParameterType);
+                        context.AddNode(new AstAssignment(argTemp, source));
+                        sources[index] = argTemp;
+                    }
+                    else
+                    {
+                        sources[index] = source;
+                    }
                 }
             }
             else

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs

@@ -29,6 +29,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
         private const bool IsDevelopment = false;
 
         private readonly KEvent _stateChangeEvent;
+        private int _stateChangeEventHandle;
 
         private NetworkState _state;
         private DisconnectReason _disconnectReason;
@@ -277,12 +278,12 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
         // AttachStateChangeEvent() -> handle<copy>
         public ResultCode AttachStateChangeEvent(ServiceCtx context)
         {
-            if (context.Process.HandleTable.GenerateHandle(_stateChangeEvent.ReadableEvent, out int stateChangeEventHandle) != Result.Success)
+            if (_stateChangeEventHandle == 0 && context.Process.HandleTable.GenerateHandle(_stateChangeEvent.ReadableEvent, out _stateChangeEventHandle) != Result.Success)
             {
                 throw new InvalidOperationException("Out of handles!");
             }
 
-            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(stateChangeEventHandle);
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_stateChangeEventHandle);
 
             // Returns ResultCode.InvalidArgument if handle is null, doesn't occur in our case since we already throw an Exception.
 
@@ -964,6 +965,12 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
                 SetDisconnectReason(DisconnectReason.None);
             }
 
+            if (_stateChangeEventHandle != 0)
+            {
+                context.Process.HandleTable.CloseHandle(_stateChangeEventHandle);
+                _stateChangeEventHandle = 0;
+            }
+
             return resultCode;
         }
 
@@ -1021,7 +1028,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
             SetState(NetworkState.None);
 
-            NetworkClient?.DisconnectAndStop();
+            NetworkClient?.Dispose();
             NetworkClient = null;
 
             return ResultCode.Success;
@@ -1072,7 +1079,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
                     }
                     else
                     {
-                        // NOTE: Service returns differents ResultCode here related to the nifm ResultCode.
+                        // NOTE: Service returns different ResultCode here related to the nifm ResultCode.
                         resultCode = ResultCode.DeviceDisabled;
                         _nifmResultCode = resultCode;
                     }
@@ -1084,14 +1091,13 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
         public void Dispose()
         {
-            if (NetworkClient != null)
-            {
-                _station?.Dispose();
-                _accessPoint?.Dispose();
+            _station?.Dispose();
+            _station = null;
 
-                NetworkClient.DisconnectAndStop();
-            }
+            _accessPoint?.Dispose();
+            _accessPoint = null;
 
+            NetworkClient?.Dispose();
             NetworkClient = null;
         }
     }

src/Ryujinx.HLE/HOS/Services/Mii/DatabaseImpl.cs

@@ -290,7 +290,7 @@ namespace Ryujinx.HLE.HOS.Services.Mii
         {
             coreData = new CoreData();
 
-            if (charInfo.IsValid())
+            if (!charInfo.IsValid())
             {
                 return ResultCode.InvalidCharInfo;
             }

src/Ryujinx.HLE/HOS/Services/Mii/Types/CoreData.cs

@@ -1,4 +1,5 @@
-using System;
+using Ryujinx.Common.Memory;
+using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using static Ryujinx.HLE.HOS.Services.Mii.Types.RandomMiiConstants;
@@ -10,9 +11,9 @@ namespace Ryujinx.HLE.HOS.Services.Mii.Types
     {
         public const int Size = 0x30;
 
-        private byte _storage;
+        private Array48<byte> _storage;
 
-        public Span<byte> Storage => MemoryMarshal.CreateSpan(ref _storage, Size);
+        public Span<byte> Storage => _storage.AsSpan();
 
         [StructLayout(LayoutKind.Sequential, Pack = 4, Size = 0x18)]
         public struct ElementInfo

src/Ryujinx.HLE/HOS/Services/Mii/Types/Nickname.cs

@@ -1,4 +1,5 @@
-using System;
+using Ryujinx.Common.Memory;
+using System;
 using System.Runtime.InteropServices;
 using System.Text;
 
@@ -10,12 +11,12 @@ namespace Ryujinx.HLE.HOS.Services.Mii.Types
         public const int CharCount = 10;
         private const int SizeConst = (CharCount + 1) * 2;
 
-        private byte _storage;
+        private Array22<byte> _storage;
 
         public static Nickname Default => FromString("no name");
         public static Nickname Question => FromString("???");
 
-        public Span<byte> Raw => MemoryMarshal.CreateSpan(ref _storage, SizeConst);
+        public Span<byte> Raw => _storage.AsSpan();
 
         private ReadOnlySpan<ushort> Characters => MemoryMarshal.Cast<byte, ushort>(Raw);
 

src/Ryujinx.HLE/HOS/Services/Mii/Types/StoreData.cs

@@ -62,7 +62,7 @@ namespace Ryujinx.HLE.HOS.Services.Mii.Types
 
         private ushort CalculateDataCrc()
         {
-            return Helper.CalculateCrc16(AsSpanWithoutDeviceCrc(), 0, true);
+            return Helper.CalculateCrc16(AsSpanWithoutCrcs(), 0, true);
         }
 
         private ushort CalculateDeviceCrc()
@@ -71,7 +71,7 @@ namespace Ryujinx.HLE.HOS.Services.Mii.Types
 
             ushort deviceIdCrc16 = Helper.CalculateCrc16(SpanHelpers.AsByteSpan(ref deviceId), 0, false);
 
-            return Helper.CalculateCrc16(AsSpan(), deviceIdCrc16, true);
+            return Helper.CalculateCrc16(AsSpanWithoutDeviceCrc(), deviceIdCrc16, true);
         }
 
         private ReadOnlySpan<byte> AsSpan()
@@ -84,6 +84,11 @@ namespace Ryujinx.HLE.HOS.Services.Mii.Types
             return AsSpan()[..(Size - 2)];
         }
 
+        private ReadOnlySpan<byte> AsSpanWithoutCrcs()
+        {
+            return AsSpan()[..(Size - 4)];
+        }
+
         public static StoreData BuildDefault(UtilityImpl utilImpl, uint index)
         {
             StoreData result = new()

src/Ryujinx.HLE/HOS/Services/Mii/Types/Ver3StoreData.cs

@@ -1,4 +1,6 @@
-using System;
+using Ryujinx.Common.Memory;
+using Ryujinx.Common.Utilities;
+using System;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Mii.Types
@@ -8,9 +10,9 @@ namespace Ryujinx.HLE.HOS.Services.Mii.Types
     {
         public const int Size = 0x60;
 
-        private byte _storage;
+        private Array96<byte> _storage;
 
-        public Span<byte> Storage => MemoryMarshal.CreateSpan(ref _storage, Size);
+        public Span<byte> Storage => _storage.AsSpan();
 
         // TODO: define all getters/setters
     }