Fix geometry shader passthrough issue (#6462)

* Fix geometry shader passthrough issue (Diagnosed by gdkchan)

* Fix whitespace formatting

* Fix whitespace formatting

* Bump shader cache version

* Don't apply PassthroughNV decorations to output geometry shader variables

Directory.Packages.props

@@ -42,8 +42,8 @@
     <PackageVersion Include="Silk.NET.Vulkan" Version="2.16.0" />
     <PackageVersion Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.16.0" />
     <PackageVersion Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.16.0" />
-    <PackageVersion Include="SixLabors.ImageSharp" Version="1.0.4" />
-    <PackageVersion Include="SixLabors.ImageSharp.Drawing" Version="1.0.0-beta11" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="2.1.7" />
+    <PackageVersion Include="SixLabors.ImageSharp.Drawing" Version="1.0.0" />
     <PackageVersion Include="SPB" Version="0.0.4-build32" />
     <PackageVersion Include="System.Drawing.Common" Version="8.0.2" />
     <PackageVersion Include="System.IO.Hashing" Version="8.0.0" />

src/Ryujinx.Cpu/AppleHv/HvMemoryManager.cs

@@ -16,12 +16,8 @@ namespace Ryujinx.Cpu.AppleHv
     /// Represents a CPU memory manager which maps guest virtual memory directly onto the Hypervisor page table.
     /// </summary>
     [SupportedOSPlatform("macos")]
-    public class HvMemoryManager : MemoryManagerBase, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
+    public class HvMemoryManager : VirtualMemoryManagerRefCountedBase<ulong, ulong>, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
     {
-        public const int PageBits = 12;
-        public const int PageSize = 1 << PageBits;
-        public const int PageMask = PageSize - 1;
-
         public const int PageToPteShift = 5; // 32 pages (2 bits each) in one ulong page table entry.
         public const ulong BlockMappedMask = 0x5555555555555555; // First bit of each table entry set.
 
@@ -39,8 +35,6 @@ namespace Ryujinx.Cpu.AppleHv
 
         private readonly InvalidAccessHandler _invalidAccessHandler;
 
-        private readonly ulong _addressSpaceSize;
-
         private readonly HvAddressSpace _addressSpace;
 
         internal HvAddressSpace AddressSpace => _addressSpace;
@@ -62,6 +56,8 @@ namespace Ryujinx.Cpu.AppleHv
 
         public event Action<ulong, ulong> UnmapEvent;
 
+        protected override ulong AddressSpaceSize { get; }
+
         /// <summary>
         /// Creates a new instance of the Hypervisor memory manager.
         /// </summary>
@@ -73,7 +69,7 @@ namespace Ryujinx.Cpu.AppleHv
             _backingMemory = backingMemory;
             _pageTable = new PageTable<ulong>();
             _invalidAccessHandler = invalidAccessHandler;
-            _addressSpaceSize = addressSpaceSize;
+            AddressSpaceSize = addressSpaceSize;
 
             ulong asSize = PageSize;
             int asBits = PageBits;
@@ -92,42 +88,6 @@ namespace Ryujinx.Cpu.AppleHv
             Tracking = new MemoryTracking(this, PageSize, invalidAccessHandler);
         }
 
-        /// <summary>
-        /// Checks if the virtual address is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address</param>
-        /// <returns>True if the virtual address is part of the addressable space</returns>
-        private bool ValidateAddress(ulong va)
-        {
-            return va < _addressSpaceSize;
-        }
-
-        /// <summary>
-        /// Checks if the combination of virtual address and size is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        /// <returns>True if the combination of virtual address and size is part of the addressable space</returns>
-        private bool ValidateAddressAndSize(ulong va, ulong size)
-        {
-            ulong endVa = va + size;
-            return endVa >= va && endVa >= size && endVa <= _addressSpaceSize;
-        }
-
-        /// <summary>
-        /// Ensures the combination of virtual address and size is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        /// <exception cref="InvalidMemoryRegionException">Throw when the memory region specified outside the addressable space</exception>
-        private void AssertValidAddressAndSize(ulong va, ulong size)
-        {
-            if (!ValidateAddressAndSize(va, size))
-            {
-                throw new InvalidMemoryRegionException($"va=0x{va:X16}, size=0x{size:X16}");
-            }
-        }
-
         /// <inheritdoc/>
         public void Map(ulong va, ulong pa, ulong size, MemoryMapFlags flags)
         {
@@ -209,9 +169,19 @@ namespace Ryujinx.Cpu.AppleHv
         }
 
         /// <inheritdoc/>
-        public void Read(ulong va, Span<byte> data)
+        public override void Read(ulong va, Span<byte> data)
         {
-            ReadImpl(va, data);
+            try
+            {
+                base.Read(va, data);
+            }
+            catch (InvalidMemoryRegionException)
+            {
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
+            }
         }
 
         /// <inheritdoc/>
@@ -340,7 +310,7 @@ namespace Ryujinx.Cpu.AppleHv
             {
                 Span<byte> data = new byte[size];
 
-                ReadImpl(va, data);
+                base.Read(va, data);
 
                 return data;
             }
@@ -367,7 +337,7 @@ namespace Ryujinx.Cpu.AppleHv
             {
                 Memory<byte> memory = new byte[size];
 
-                ReadImpl(va, memory.Span);
+                base.Read(va, memory.Span);
 
                 return new WritableRegion(this, va, memory);
             }
@@ -576,48 +546,6 @@ namespace Ryujinx.Cpu.AppleHv
             return regions;
         }
 
-        private void ReadImpl(ulong va, Span<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return;
-            }
-
-            try
-            {
-                AssertValidAddressAndSize(va, (ulong)data.Length);
-
-                int offset = 0, size;
-
-                if ((va & PageMask) != 0)
-                {
-                    ulong pa = GetPhysicalAddressChecked(va);
-
-                    size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
-
-                    _backingMemory.GetSpan(pa, size).CopyTo(data[..size]);
-
-                    offset += size;
-                }
-
-                for (; offset < data.Length; offset += size)
-                {
-                    ulong pa = GetPhysicalAddressChecked(va + (ulong)offset);
-
-                    size = Math.Min(data.Length - offset, PageSize);
-
-                    _backingMemory.GetSpan(pa, size).CopyTo(data.Slice(offset, size));
-                }
-            }
-            catch (InvalidMemoryRegionException)
-            {
-                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
-                {
-                    throw;
-                }
-            }
-        }
-
         /// <inheritdoc/>
         /// <remarks>
         /// This function also validates that the given range is both valid and mapped, and will throw if it is not.
@@ -936,6 +864,10 @@ namespace Ryujinx.Cpu.AppleHv
             _addressSpace.Dispose();
         }
 
-        private static void ThrowInvalidMemoryRegionException(string message) => throw new InvalidMemoryRegionException(message);
+        protected override Span<byte> GetPhysicalAddressSpan(ulong pa, int size)
+            => _backingMemory.GetSpan(pa, size);
+
+        protected override ulong TranslateVirtualAddressForRead(ulong va)
+            => GetPhysicalAddressChecked(va);
     }
 }

src/Ryujinx.Cpu/Jit/MemoryManager.cs

@@ -14,12 +14,8 @@ namespace Ryujinx.Cpu.Jit
     /// <summary>
     /// Represents a CPU memory manager.
     /// </summary>
-    public sealed class MemoryManager : MemoryManagerBase, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
+    public sealed class MemoryManager : VirtualMemoryManagerRefCountedBase<ulong, ulong>, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
     {
-        public const int PageBits = 12;
-        public const int PageSize = 1 << PageBits;
-        public const int PageMask = PageSize - 1;
-
         private const int PteSize = 8;
 
         private const int PointerTagBit = 62;
@@ -35,8 +31,6 @@ namespace Ryujinx.Cpu.Jit
         /// </summary>
         public int AddressSpaceBits { get; }
 
-        private readonly ulong _addressSpaceSize;
-
         private readonly MemoryBlock _pageTable;
 
         /// <summary>
@@ -50,6 +44,8 @@ namespace Ryujinx.Cpu.Jit
 
         public event Action<ulong, ulong> UnmapEvent;
 
+        protected override ulong AddressSpaceSize { get; }
+
         /// <summary>
         /// Creates a new instance of the memory manager.
         /// </summary>
@@ -71,7 +67,7 @@ namespace Ryujinx.Cpu.Jit
             }
 
             AddressSpaceBits = asBits;
-            _addressSpaceSize = asSize;
+            AddressSpaceSize = asSize;
             _pageTable = new MemoryBlock((asSize / PageSize) * PteSize);
 
             Tracking = new MemoryTracking(this, PageSize);
@@ -153,9 +149,19 @@ namespace Ryujinx.Cpu.Jit
         }
 
         /// <inheritdoc/>
-        public void Read(ulong va, Span<byte> data)
+        public override void Read(ulong va, Span<byte> data)
         {
-            ReadImpl(va, data);
+            try
+            {
+                base.Read(va, data);
+            }
+            catch (InvalidMemoryRegionException)
+            {
+                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
+                {
+                    throw;
+                }
+            }
         }
 
         /// <inheritdoc/>
@@ -290,7 +296,7 @@ namespace Ryujinx.Cpu.Jit
             {
                 Span<byte> data = new byte[size];
 
-                ReadImpl(va, data);
+                base.Read(va, data);
 
                 return data;
             }
@@ -462,48 +468,6 @@ namespace Ryujinx.Cpu.Jit
             return regions;
         }
 
-        private void ReadImpl(ulong va, Span<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return;
-            }
-
-            try
-            {
-                AssertValidAddressAndSize(va, (ulong)data.Length);
-
-                int offset = 0, size;
-
-                if ((va & PageMask) != 0)
-                {
-                    ulong pa = GetPhysicalAddressInternal(va);
-
-                    size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
-
-                    _backingMemory.GetSpan(pa, size).CopyTo(data[..size]);
-
-                    offset += size;
-                }
-
-                for (; offset < data.Length; offset += size)
-                {
-                    ulong pa = GetPhysicalAddressInternal(va + (ulong)offset);
-
-                    size = Math.Min(data.Length - offset, PageSize);
-
-                    _backingMemory.GetSpan(pa, size).CopyTo(data.Slice(offset, size));
-                }
-            }
-            catch (InvalidMemoryRegionException)
-            {
-                if (_invalidAccessHandler == null || !_invalidAccessHandler(va))
-                {
-                    throw;
-                }
-            }
-        }
-
         /// <inheritdoc/>
         public bool IsRangeMapped(ulong va, ulong size)
         {
@@ -544,37 +508,6 @@ namespace Ryujinx.Cpu.Jit
             return _pageTable.Read<ulong>((va / PageSize) * PteSize) != 0;
         }
 
-        private bool ValidateAddress(ulong va)
-        {
-            return va < _addressSpaceSize;
-        }
-
-        /// <summary>
-        /// Checks if the combination of virtual address and size is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        /// <returns>True if the combination of virtual address and size is part of the addressable space</returns>
-        private bool ValidateAddressAndSize(ulong va, ulong size)
-        {
-            ulong endVa = va + size;
-            return endVa >= va && endVa >= size && endVa <= _addressSpaceSize;
-        }
-
-        /// <summary>
-        /// Ensures the combination of virtual address and size is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        /// <exception cref="InvalidMemoryRegionException">Throw when the memory region specified outside the addressable space</exception>
-        private void AssertValidAddressAndSize(ulong va, ulong size)
-        {
-            if (!ValidateAddressAndSize(va, size))
-            {
-                throw new InvalidMemoryRegionException($"va=0x{va:X16}, size=0x{size:X16}");
-            }
-        }
-
         private ulong GetPhysicalAddressInternal(ulong va)
         {
             return PteToPa(_pageTable.Read<ulong>((va / PageSize) * PteSize) & ~(0xffffUL << 48)) + (va & PageMask);
@@ -691,5 +624,11 @@ namespace Ryujinx.Cpu.Jit
         /// Disposes of resources used by the memory manager.
         /// </summary>
         protected override void Destroy() => _pageTable.Dispose();
+
+        protected override Span<byte> GetPhysicalAddressSpan(ulong pa, int size)
+            => _backingMemory.GetSpan(pa, size);
+
+        protected override ulong TranslateVirtualAddressForRead(ulong va)
+            => GetPhysicalAddressInternal(va);
     }
 }

src/Ryujinx.Cpu/Jit/MemoryManagerHostMapped.cs

@@ -13,12 +13,8 @@ namespace Ryujinx.Cpu.Jit
     /// <summary>
     /// Represents a CPU memory manager which maps guest virtual memory directly onto a host virtual region.
     /// </summary>
-    public sealed class MemoryManagerHostMapped : MemoryManagerBase, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
+    public sealed class MemoryManagerHostMapped : VirtualMemoryManagerRefCountedBase<ulong, ulong>, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
     {
-        public const int PageBits = 12;
-        public const int PageSize = 1 << PageBits;
-        public const int PageMask = PageSize - 1;
-
         public const int PageToPteShift = 5; // 32 pages (2 bits each) in one ulong page table entry.
         public const ulong BlockMappedMask = 0x5555555555555555; // First bit of each table entry set.
 
@@ -39,8 +35,6 @@ namespace Ryujinx.Cpu.Jit
 
         private readonly AddressSpace _addressSpace;
 
-        public ulong AddressSpaceSize { get; }
-
         private readonly PageTable<ulong> _pageTable;
 
         private readonly MemoryEhMeilleure _memoryEh;
@@ -60,6 +54,8 @@ namespace Ryujinx.Cpu.Jit
 
         public event Action<ulong, ulong> UnmapEvent;
 
+        protected override ulong AddressSpaceSize { get; }
+
         /// <summary>
         /// Creates a new instance of the host mapped memory manager.
         /// </summary>
@@ -91,42 +87,6 @@ namespace Ryujinx.Cpu.Jit
             _memoryEh = new MemoryEhMeilleure(_addressSpace.Base, _addressSpace.Mirror, Tracking);
         }
 
-        /// <summary>
-        /// Checks if the virtual address is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address</param>
-        /// <returns>True if the virtual address is part of the addressable space</returns>
-        private bool ValidateAddress(ulong va)
-        {
-            return va < AddressSpaceSize;
-        }
-
-        /// <summary>
-        /// Checks if the combination of virtual address and size is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        /// <returns>True if the combination of virtual address and size is part of the addressable space</returns>
-        private bool ValidateAddressAndSize(ulong va, ulong size)
-        {
-            ulong endVa = va + size;
-            return endVa >= va && endVa >= size && endVa <= AddressSpaceSize;
-        }
-
-        /// <summary>
-        /// Ensures the combination of virtual address and size is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        /// <exception cref="InvalidMemoryRegionException">Throw when the memory region specified outside the addressable space</exception>
-        private void AssertValidAddressAndSize(ulong va, ulong size)
-        {
-            if (!ValidateAddressAndSize(va, size))
-            {
-                throw new InvalidMemoryRegionException($"va=0x{va:X16}, size=0x{size:X16}");
-            }
-        }
-
         /// <summary>
         /// Ensures the combination of virtual address and size is part of the addressable space and fully mapped.
         /// </summary>
@@ -235,7 +195,7 @@ namespace Ryujinx.Cpu.Jit
         }
 
         /// <inheritdoc/>
-        public void Read(ulong va, Span<byte> data)
+        public override void Read(ulong va, Span<byte> data)
         {
             try
             {
@@ -816,6 +776,10 @@ namespace Ryujinx.Cpu.Jit
             _memoryEh.Dispose();
         }
 
-        private static void ThrowInvalidMemoryRegionException(string message) => throw new InvalidMemoryRegionException(message);
+        protected override Span<byte> GetPhysicalAddressSpan(ulong pa, int size)
+            => _addressSpace.Mirror.GetSpan(pa, size);
+
+        protected override ulong TranslateVirtualAddressForRead(ulong va)
+            => va;
     }
 }

src/Ryujinx.Cpu/VirtualMemoryManagerRefCountedBase.cs

@@ -1,10 +1,13 @@
 using Ryujinx.Memory;
 using System.Diagnostics;
+using System.Numerics;
 using System.Threading;
 
 namespace Ryujinx.Cpu
 {
-    public abstract class MemoryManagerBase : IRefCounted
+    public abstract class VirtualMemoryManagerRefCountedBase<TVirtual, TPhysical> : VirtualMemoryManagerBase<TVirtual, TPhysical>, IRefCounted
+        where TVirtual : IBinaryInteger<TVirtual>
+        where TPhysical : IBinaryInteger<TPhysical>
     {
         private int _referenceCount;
 

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 = 6253;
+        private const uint CodeGenVersion = 6462;
 
         private const string SharedTocFileName = "shared.toc";
         private const string SharedDataFileName = "shared.data";

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

@@ -356,6 +356,16 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
 
                     context.AddGlobalVariable(perVertexInputVariable);
                     context.Inputs.Add(new IoDefinition(StorageKind.Input, IoVariable.Position), perVertexInputVariable);
+
+                    if (context.Definitions.Stage == ShaderStage.Geometry &&
+                        context.Definitions.GpPassthrough &&
+                        context.HostCapabilities.SupportsGeometryShaderPassthrough)
+                    {
+                        context.MemberDecorate(perVertexInputStructType, 0, Decoration.PassthroughNV);
+                        context.MemberDecorate(perVertexInputStructType, 1, Decoration.PassthroughNV);
+                        context.MemberDecorate(perVertexInputStructType, 2, Decoration.PassthroughNV);
+                        context.MemberDecorate(perVertexInputStructType, 3, Decoration.PassthroughNV);
+                    }
                 }
 
                 var perVertexOutputStructType = CreatePerVertexStructType(context);

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

@@ -24,17 +24,21 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
                         continue;
                     }
 
+                    Operand temp = OperandHelper.Local();
+
                     for (int index = 0; index < phi.SourcesCount; index++)
                     {
                         Operand src = phi.GetSource(index);
-
                         BasicBlock srcBlock = phi.GetBlock(index);
 
-                        Operation copyOp = new(Instruction.Copy, phi.Dest, src);
+                        Operation copyOp = new(Instruction.Copy, temp, src);
 
                         srcBlock.Append(copyOp);
                     }
 
+                    Operation copyOp2 = new(Instruction.Copy, phi.Dest, temp);
+
+                    nextNode = block.Operations.AddAfter(node, copyOp2).Next;
                     block.Operations.Remove(node);
 
                     node = nextNode;

src/Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardRendererBase.cs

@@ -44,10 +44,10 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
         private readonly Color _textSelectedColor;
         private readonly Color _textOverCursorColor;
 
-        private readonly IBrush _panelBrush;
-        private readonly IBrush _disabledBrush;
-        private readonly IBrush _cursorBrush;
-        private readonly IBrush _selectionBoxBrush;
+        private readonly Brush _panelBrush;
+        private readonly Brush _disabledBrush;
+        private readonly Brush _cursorBrush;
+        private readonly Brush _selectionBoxBrush;
 
         private readonly Pen _textBoxOutlinePen;
         private readonly Pen _cursorPen;
@@ -97,10 +97,10 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
             _cursorBrush = new SolidBrush(_textNormalColor);
             _selectionBoxBrush = new SolidBrush(selectionBackgroundColor);
 
-            _textBoxOutlinePen = new Pen(borderColor, _textBoxOutlineWidth);
-            _cursorPen = new Pen(_textNormalColor, cursorWidth);
-            _selectionBoxPen = new Pen(selectionBackgroundColor, cursorWidth);
-            _padPressedPen = new Pen(borderColor, _padPressedPenWidth);
+            _textBoxOutlinePen = Pens.Solid(borderColor, _textBoxOutlineWidth);
+            _cursorPen = Pens.Solid(_textNormalColor, cursorWidth);
+            _selectionBoxPen = Pens.Solid(selectionBackgroundColor, cursorWidth);
+            _padPressedPen = Pens.Solid(borderColor, _padPressedPenWidth);
 
             _inputTextFontSize = 20;
 
@@ -178,7 +178,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
         private static void SetGraphicsOptions(IImageProcessingContext context)
         {
             context.GetGraphicsOptions().Antialias = true;
-            context.GetShapeGraphicsOptions().GraphicsOptions.Antialias = true;
+            context.GetDrawingOptions().GraphicsOptions.Antialias = true;
         }
 
         private void DrawImmutableElements()
@@ -293,31 +293,31 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
         }
         private static RectangleF MeasureString(string text, Font font)
         {
-            RendererOptions options = new(font);
+            TextOptions options = new(font);
 
             if (text == "")
             {
-                FontRectangle emptyRectangle = TextMeasurer.Measure(" ", options);
+                FontRectangle emptyRectangle = TextMeasurer.MeasureSize(" ", options);
 
                 return new RectangleF(0, emptyRectangle.Y, 0, emptyRectangle.Height);
             }
 
-            FontRectangle rectangle = TextMeasurer.Measure(text, options);
+            FontRectangle rectangle = TextMeasurer.MeasureSize(text, options);
 
             return new RectangleF(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
         }
 
         private static RectangleF MeasureString(ReadOnlySpan<char> text, Font font)
         {
-            RendererOptions options = new(font);
+            TextOptions options = new(font);
 
             if (text == "")
             {
-                FontRectangle emptyRectangle = TextMeasurer.Measure(" ", options);
+                FontRectangle emptyRectangle = TextMeasurer.MeasureSize(" ", options);
                 return new RectangleF(0, emptyRectangle.Y, 0, emptyRectangle.Height);
             }
 
-            FontRectangle rectangle = TextMeasurer.Measure(text, options);
+            FontRectangle rectangle = TextMeasurer.MeasureSize(text, options);
 
             return new RectangleF(rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
         }
@@ -350,7 +350,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
             // Draw the cursor on top of the text and redraw the text with a different color if necessary.
 
             Color cursorTextColor;
-            IBrush cursorBrush;
+            Brush cursorBrush;
             Pen cursorPen;
 
             float cursorPositionYTop = inputTextY + 1;
@@ -435,7 +435,7 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
                         new PointF(cursorPositionXLeft, cursorPositionYBottom),
                     };
 
-                    context.DrawLines(cursorPen, points);
+                    context.DrawLine(cursorPen, points);
                 }
                 else
                 {
@@ -562,12 +562,12 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
 
                 // Convert the pixel format used in the image to the one used in the Switch surface.
 
-                if (!_surface.TryGetSinglePixelSpan(out Span<Argb32> pixels))
+                if (!_surface.DangerousTryGetSinglePixelMemory(out Memory<Argb32> pixels))
                 {
                     return;
                 }
 
-                _bufferData = MemoryMarshal.AsBytes(pixels).ToArray();
+                _bufferData = MemoryMarshal.AsBytes(pixels.Span).ToArray();
                 Span<uint> dataConvert = MemoryMarshal.Cast<byte, uint>(_bufferData);
 
                 Debug.Assert(_bufferData.Length == _surfaceInfo.Size);

src/Ryujinx.Memory/AddressSpaceManager.cs

@@ -11,12 +11,8 @@ namespace Ryujinx.Memory
     /// Represents a address space manager.
     /// Supports virtual memory region mapping, address translation and read/write access to mapped regions.
     /// </summary>
-    public sealed class AddressSpaceManager : IVirtualMemoryManager, IWritableBlock
+    public sealed class AddressSpaceManager : VirtualMemoryManagerBase<ulong, nuint>, IVirtualMemoryManager, IWritableBlock
     {
-        public const int PageBits = PageTable<nuint>.PageBits;
-        public const int PageSize = PageTable<nuint>.PageSize;
-        public const int PageMask = PageTable<nuint>.PageMask;
-
         /// <inheritdoc/>
         public bool Supports4KBPages => true;
 
@@ -25,11 +21,11 @@ namespace Ryujinx.Memory
         /// </summary>
         public int AddressSpaceBits { get; }
 
-        private readonly ulong _addressSpaceSize;
-
         private readonly MemoryBlock _backingMemory;
         private readonly PageTable<nuint> _pageTable;
 
+        protected override ulong AddressSpaceSize { get; }
+
         /// <summary>
         /// Creates a new instance of the memory manager.
         /// </summary>
@@ -47,7 +43,7 @@ namespace Ryujinx.Memory
             }
 
             AddressSpaceBits = asBits;
-            _addressSpaceSize = asSize;
+            AddressSpaceSize = asSize;
             _backingMemory = backingMemory;
             _pageTable = new PageTable<nuint>();
         }
@@ -102,12 +98,6 @@ namespace Ryujinx.Memory
             return MemoryMarshal.Cast<byte, T>(GetSpan(va, Unsafe.SizeOf<T>()))[0];
         }
 
-        /// <inheritdoc/>
-        public void Read(ulong va, Span<byte> data)
-        {
-            ReadImpl(va, data);
-        }
-
         /// <inheritdoc/>
         public void Write<T>(ulong va, T value) where T : unmanaged
         {
@@ -174,7 +164,7 @@ namespace Ryujinx.Memory
             {
                 Span<byte> data = new byte[size];
 
-                ReadImpl(va, data);
+                Read(va, data);
 
                 return data;
             }
@@ -346,34 +336,6 @@ namespace Ryujinx.Memory
             return regions;
         }
 
-        private void ReadImpl(ulong va, Span<byte> data)
-        {
-            if (data.Length == 0)
-            {
-                return;
-            }
-
-            AssertValidAddressAndSize(va, (ulong)data.Length);
-
-            int offset = 0, size;
-
-            if ((va & PageMask) != 0)
-            {
-                size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
-
-                GetHostSpanContiguous(va, size).CopyTo(data[..size]);
-
-                offset += size;
-            }
-
-            for (; offset < data.Length; offset += size)
-            {
-                size = Math.Min(data.Length - offset, PageSize);
-
-                GetHostSpanContiguous(va + (ulong)offset, size).CopyTo(data.Slice(offset, size));
-            }
-        }
-
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool IsMapped(ulong va)
@@ -414,37 +376,6 @@ namespace Ryujinx.Memory
             return true;
         }
 
-        private bool ValidateAddress(ulong va)
-        {
-            return va < _addressSpaceSize;
-        }
-
-        /// <summary>
-        /// Checks if the combination of virtual address and size is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        /// <returns>True if the combination of virtual address and size is part of the addressable space</returns>
-        private bool ValidateAddressAndSize(ulong va, ulong size)
-        {
-            ulong endVa = va + size;
-            return endVa >= va && endVa >= size && endVa <= _addressSpaceSize;
-        }
-
-        /// <summary>
-        /// Ensures the combination of virtual address and size is part of the addressable space.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        /// <exception cref="InvalidMemoryRegionException">Throw when the memory region specified outside the addressable space</exception>
-        private void AssertValidAddressAndSize(ulong va, ulong size)
-        {
-            if (!ValidateAddressAndSize(va, size))
-            {
-                throw new InvalidMemoryRegionException($"va=0x{va:X16}, size=0x{size:X16}");
-            }
-        }
-
         private unsafe Span<byte> GetHostSpanContiguous(ulong va, int size)
         {
             return new Span<byte>((void*)GetHostAddress(va), size);
@@ -471,5 +402,11 @@ namespace Ryujinx.Memory
         {
             // Only the ARM Memory Manager has tracking for now.
         }
+
+        protected override unsafe Span<byte> GetPhysicalAddressSpan(nuint pa, int size)
+            => new((void*)pa, size);
+
+        protected override nuint TranslateVirtualAddressForRead(ulong va)
+            => GetHostAddress(va);
     }
 }

src/Ryujinx.Memory/VirtualMemoryManagerBase.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Numerics;
+
+namespace Ryujinx.Memory
+{
+    public abstract class VirtualMemoryManagerBase<TVirtual, TPhysical>
+        where TVirtual : IBinaryInteger<TVirtual>
+        where TPhysical : IBinaryInteger<TPhysical>
+    {
+        public const int PageBits = 12;
+        public const int PageSize = 1 << PageBits;
+        public const int PageMask = PageSize - 1;
+
+        protected abstract TVirtual AddressSpaceSize { get; }
+
+        public virtual void Read(TVirtual va, Span<byte> data)
+        {
+            if (data.Length == 0)
+            {
+                return;
+            }
+
+            AssertValidAddressAndSize(va, TVirtual.CreateChecked(data.Length));
+
+            int offset = 0, size;
+
+            if ((int.CreateTruncating(va) & PageMask) != 0)
+            {
+                TPhysical pa = TranslateVirtualAddressForRead(va);
+
+                size = Math.Min(data.Length, PageSize - ((int.CreateTruncating(va) & PageMask)));
+
+                GetPhysicalAddressSpan(pa, size).CopyTo(data[..size]);
+
+                offset += size;
+            }
+
+            for (; offset < data.Length; offset += size)
+            {
+                TPhysical pa = TranslateVirtualAddressForRead(va + TVirtual.CreateChecked(offset));
+
+                size = Math.Min(data.Length - offset, PageSize);
+
+                GetPhysicalAddressSpan(pa, size).CopyTo(data.Slice(offset, size));
+            }
+        }
+
+        /// <summary>
+        /// Ensures the combination of virtual address and size is part of the addressable space.
+        /// </summary>
+        /// <param name="va">Virtual address of the range</param>
+        /// <param name="size">Size of the range in bytes</param>
+        /// <exception cref="InvalidMemoryRegionException">Throw when the memory region specified outside the addressable space</exception>
+        protected void AssertValidAddressAndSize(TVirtual va, TVirtual size)
+        {
+            if (!ValidateAddressAndSize(va, size))
+            {
+                throw new InvalidMemoryRegionException($"va=0x{va:X16}, size=0x{size:X16}");
+            }
+        }
+
+        protected abstract Span<byte> GetPhysicalAddressSpan(TPhysical pa, int size);
+
+        protected abstract TPhysical TranslateVirtualAddressForRead(TVirtual va);
+
+        /// <summary>
+        /// Checks if the virtual address is part of the addressable space.
+        /// </summary>
+        /// <param name="va">Virtual address</param>
+        /// <returns>True if the virtual address is part of the addressable space</returns>
+        protected bool ValidateAddress(TVirtual va)
+        {
+            return va < AddressSpaceSize;
+        }
+
+        /// <summary>
+        /// Checks if the combination of virtual address and size is part of the addressable space.
+        /// </summary>
+        /// <param name="va">Virtual address of the range</param>
+        /// <param name="size">Size of the range in bytes</param>
+        /// <returns>True if the combination of virtual address and size is part of the addressable space</returns>
+        protected bool ValidateAddressAndSize(TVirtual va, TVirtual size)
+        {
+            TVirtual endVa = va + size;
+            return endVa >= va && endVa >= size && endVa <= AddressSpaceSize;
+        }
+
+        protected static void ThrowInvalidMemoryRegionException(string message)
+            => throw new InvalidMemoryRegionException(message);
+    }
+}

src/Ryujinx/UI/Helpers/Win32NativeInterop.cs

@@ -8,6 +8,8 @@ namespace Ryujinx.Ava.UI.Helpers
     [SupportedOSPlatform("windows")]
     internal partial class Win32NativeInterop
     {
+        internal const int GWLP_WNDPROC = -4;
+
         [Flags]
         public enum ClassStyles : uint
         {
@@ -29,22 +31,7 @@ namespace Ryujinx.Ava.UI.Helpers
         [SuppressMessage("Design", "CA1069: Enums values should not be duplicated")]
         public enum WindowsMessages : uint
         {
-            Mousemove = 0x0200,
-            Lbuttondown = 0x0201,
-            Lbuttonup = 0x0202,
-            Lbuttondblclk = 0x0203,
-            Rbuttondown = 0x0204,
-            Rbuttonup = 0x0205,
-            Rbuttondblclk = 0x0206,
-            Mbuttondown = 0x0207,
-            Mbuttonup = 0x0208,
-            Mbuttondblclk = 0x0209,
-            Mousewheel = 0x020A,
-            Xbuttondown = 0x020B,
-            Xbuttonup = 0x020C,
-            Xbuttondblclk = 0x020D,
-            Mousehwheel = 0x020E,
-            Mouselast = 0x020E,
+            NcHitTest = 0x0084,
         }
 
         [UnmanagedFunctionPointer(CallingConvention.Winapi)]
@@ -121,5 +108,11 @@ namespace Ryujinx.Ava.UI.Helpers
            IntPtr hMenu,
            IntPtr hInstance,
            IntPtr lpParam);
+
+        [LibraryImport("user32.dll", SetLastError = true)]
+        public static partial IntPtr SetWindowLongPtrW(IntPtr hWnd, int nIndex, IntPtr value);
+
+        [LibraryImport("user32.dll", SetLastError = true)]
+        public static partial IntPtr SetWindowLongW(IntPtr hWnd, int nIndex, int value);
     }
 }

src/Ryujinx/UI/Renderer/EmbeddedWindow.cs

@@ -141,80 +141,10 @@ namespace Ryujinx.Ava.UI.Renderer
 
             _wndProcDelegate = delegate (IntPtr hWnd, WindowsMessages msg, IntPtr wParam, IntPtr lParam)
             {
-                if (VisualRoot != null)
+                switch (msg)
                 {
-                    if (msg == WindowsMessages.Lbuttondown ||
-                        msg == WindowsMessages.Rbuttondown ||
-                        msg == WindowsMessages.Lbuttonup ||
-                        msg == WindowsMessages.Rbuttonup ||
-                        msg == WindowsMessages.Mousemove)
-                    {
-                        Point rootVisualPosition = this.TranslatePoint(new Point((long)lParam & 0xFFFF, (long)lParam >> 16 & 0xFFFF), this).Value;
-                        Pointer pointer = new(0, PointerType.Mouse, true);
-
-#pragma warning disable CS0618 // Type or member is obsolete (As of Avalonia 11, the constructors for PointerPressedEventArgs & PointerEventArgs are marked as obsolete)
-                        switch (msg)
-                        {
-                            case WindowsMessages.Lbuttondown:
-                            case WindowsMessages.Rbuttondown:
-                                {
-                                    bool isLeft = msg == WindowsMessages.Lbuttondown;
-                                    RawInputModifiers pointerPointModifier = isLeft ? RawInputModifiers.LeftMouseButton : RawInputModifiers.RightMouseButton;
-                                    PointerPointProperties properties = new(pointerPointModifier, isLeft ? PointerUpdateKind.LeftButtonPressed : PointerUpdateKind.RightButtonPressed);
-
-                                    var evnt = new PointerPressedEventArgs(
-                                        this,
-                                        pointer,
-                                        this,
-                                        rootVisualPosition,
-                                        (ulong)Environment.TickCount64,
-                                        properties,
-                                        KeyModifiers.None);
-
-                                    RaiseEvent(evnt);
-
-                                    break;
-                                }
-                            case WindowsMessages.Lbuttonup:
-                            case WindowsMessages.Rbuttonup:
-                                {
-                                    bool isLeft = msg == WindowsMessages.Lbuttonup;
-                                    RawInputModifiers pointerPointModifier = isLeft ? RawInputModifiers.LeftMouseButton : RawInputModifiers.RightMouseButton;
-                                    PointerPointProperties properties = new(pointerPointModifier, isLeft ? PointerUpdateKind.LeftButtonReleased : PointerUpdateKind.RightButtonReleased);
-
-                                    var evnt = new PointerReleasedEventArgs(
-                                        this,
-                                        pointer,
-                                        this,
-                                        rootVisualPosition,
-                                        (ulong)Environment.TickCount64,
-                                        properties,
-                                        KeyModifiers.None,
-                                        isLeft ? MouseButton.Left : MouseButton.Right);
-
-                                    RaiseEvent(evnt);
-
-                                    break;
-                                }
-                            case WindowsMessages.Mousemove:
-                                {
-                                    var evnt = new PointerEventArgs(
-                                        PointerMovedEvent,
-                                        this,
-                                        pointer,
-                                        this,
-                                        rootVisualPosition,
-                                        (ulong)Environment.TickCount64,
-                                        new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.Other),
-                                        KeyModifiers.None);
-
-                                    RaiseEvent(evnt);
-
-                                    break;
-                                }
-                        }
-#pragma warning restore CS0618
-                    }
+                    case WindowsMessages.NcHitTest:
+                        return -1;
                 }
 
                 return DefWindowProc(hWnd, msg, wParam, lParam);
@@ -234,6 +164,8 @@ namespace Ryujinx.Ava.UI.Renderer
 
             WindowHandle = CreateWindowEx(0, _className, "NativeWindow", WindowStyles.WsChild, 0, 0, 640, 480, control.Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
 
+            SetWindowLongPtrW(control.Handle, GWLP_WNDPROC, wndClassEx.lpfnWndProc);
+
             Marshal.FreeHGlobal(wndClassEx.lpszClassName);
 
             return new PlatformHandle(WindowHandle, "HWND");

src/Ryujinx/UI/Windows/IconColorPicker.cs

@@ -127,7 +127,7 @@ namespace Ryujinx.Ava.UI.Windows
 
         public static Bgra32[] GetBuffer(Image<Bgra32> image)
         {
-            return image.TryGetSinglePixelSpan(out var data) ? data.ToArray() : Array.Empty<Bgra32>();
+            return image.DangerousTryGetSinglePixelMemory(out var data) ? data.ToArray() : Array.Empty<Bgra32>();
         }
 
         private static int GetColorScore(Dictionary<int, int> dominantColorBin, int maxHitCount, PaletteColor color)