Improve "Add raw copy dependencies for incompatible textures"

Initial PR was made by Avan for Ryubing.

This allows for Trails in the Sky 1st Chapter (and by extension Trails through Daybreak, Trails through Daybreak II, Trails Beyond the Horizon, and the future Trails in the Sky 2nd Chapter – tested via demo – to be fully playable.

Initial PR caused issues on macOS devices, specifically crashing in certain games (such as Mario Kart 8 Deluxe and the aforementioned Trails games). It was reverted on the original Ryubing project (at the time of writing this description) for causing small rendering issues on The Legend of Zelda: Breath of the Wild.

The rendering issues do not appear on macOS.

This commit improves the original PR by eliminating said macOS crash.

Trails in the Sky 1st writes its exposure/brightness value through an R32G32Float 1x1 texture and later reads the raw bits back through an R32Uint 2x1 texture mapped to the same guest memory. The two texture formats/dimensions are fully incompatible as texture views, so they end
up as separate host textures, and nothing kept their contents coherent - the reader saw stale zeroed data, making the exposure calculation (and the rendered image) too dark. (This is the initial fix for the game)

TextureGroup already had a raw-copy dependency mechanism intended to
handle this class of alias (TextureDependency, TextureGroupHandle
raw-copy plumbing), gated by CanCreateRawCopyDependency's strict same-guest-memory checks. This commit fixes three bugs that kept that mechanism from working correctly (and thus crashing Trails and other games, such as Mario Kart 8 Deluxe):

(1) TextureGroup.InitializeOverlaps() and TextureGroup.RegisterIncompatibleOverlap() only forwarded overlaps to CreateCopyDependency() when compatibility was LayoutIncompatible or better, silently excluding the fully Incompatible case the raw-copy path exists for. Widened both guards to let Incompatible overlaps through so CanCreateRawCopyDependency actually gets a chance to run.

(2) Once Incompatible overlaps were allowed through, CreateCopyDependency(TextureGroup, ...) could still fall back to a regular, non-raw textureCopy for such pairs, since ViewLayoutCompatible/CopySizeMatches only check byte size and were never meant to reason about fully incompatible pairs (e.g. a depth format aliasing a color format with the same byte size). On Vulkan running through MoltenVK on macOS, that non-raw copy path requires a pixel-format-reinterpreting texture view, and MoltenVK/Metal refuses to create any view onto a depth-format texture ("not castable"), aborting emulation. textureCopy is now forced false for Incompatible pairs, leaving raw copy (which already excludes depth/stencil formats) as the only route for that severity level.

(3) TextureGroupHandle.Inherit() copied a handle's pending DeferredCopy to the new handle when a view was recreated, but did not copy DeferredCopyRaw alongside it. A handle that inherited a pending raw copy would then execute it through the regular (non-raw) CopyTo path once acknowledged, reinterpreting the source bytes with the wrong row layout and corrupting the image - visible as vertical flickering stripes whenever a view happened to be recreated with a raw copy still pending. DeferredCopyRaw is now carried over together with DeferredCopy.

(As mentioned earlier, vertical stripes aren't present on macOS, so (3) doesn't negatively have an effect on macOS in any way).

src/ARMeilleure/Translation/PTC/Ptc.cs

@@ -32,7 +32,7 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 7020; //! To be incremented manually for each change to the ARMeilleure project. Your value was 7031, keeping this comment here just so you have the reference.
+        private const uint InternalVersion = 7031; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";
@@ -520,11 +520,7 @@ namespace ARMeilleure.Translation.PTC
 
             if (fileSize != 0L)
             {
-                Logger.Info?.Print(
-                    LogClass.Ptc,
-                    $"Saved Translation Cache (pid: {CacheInfo.ProcessId}, title: {CacheInfo.TitleIdText}, version: '{CacheInfo.DisplayVersion}', " +
-                    $"kind: {CacheInfo.ProcessKind}, selector: '{CacheInfo.CacheSelector}', key: '{CacheInfo.CacheKey}', " +
-                    $"path: '{fileName}', size: {fileSize} bytes, translated functions: {translatedFuncsCount}).");
+                Logger.Info?.Print(LogClass.Ptc, $"Saved Translation Cache (size: {fileSize} bytes, translated functions: {translatedFuncsCount}).");
             }
         }
 

src/Ryujinx.Graphics.GAL/Target.cs

@@ -16,19 +16,18 @@ namespace Ryujinx.Graphics.GAL
 
     public static class TargetExtensions
     {
-        public static bool IsMultisample(this Target target)
+        extension(Target target)
         {
-            return target is Target.Texture2DMultisample or Target.Texture2DMultisampleArray;
-        }
+            public bool IsMultisample => target is Target.Texture2DMultisample or Target.Texture2DMultisampleArray;
 
-        public static bool HasDepthOrLayers(this Target target)
-        {
-            return target is Target.Texture3D
-                or Target.Texture1DArray
-                or Target.Texture2DArray
-                or Target.Texture2DMultisampleArray
-                or Target.Cubemap
-                or Target.CubemapArray;
+            public bool HasDepthOrLayers =>
+                target is 
+                    Target.Texture3D or
+                    Target.Texture1DArray or
+                    Target.Texture2DArray or
+                    Target.Texture2DMultisampleArray or
+                    Target.Cubemap or
+                    Target.CubemapArray;
         }
     }
 }

src/Ryujinx.Graphics.Gpu/Image/Texture.cs

@@ -1117,7 +1117,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <returns>True if data was flushed, false otherwise</returns>
         public bool FlushModified(bool tracked = true)
         {
-            return TextureCompatibility.CanTextureFlush(this, _context.Capabilities) && Group.FlushModified(this, tracked);
+            return TextureCompatibility.CanTextureFlush(Info, _context.Capabilities) && Group.FlushModified(this, tracked);
         }
 
         /// <summary>
@@ -1131,7 +1131,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="tracked">Whether or not the flush triggers write tracking. If it doesn't, the texture will not be blacklisted for scaling either.</param>
         public void Flush(bool tracked)
         {
-            if (TextureCompatibility.CanTextureFlush(this, _context.Capabilities))
+            if (TextureCompatibility.CanTextureFlush(Info, _context.Capabilities))
             {
                 FlushTextureDataToGuest(tracked);
             }
@@ -1336,7 +1336,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             {
                 result = TextureCompatibility.PropagateViewCompatibility(result, TextureCompatibility.ViewTargetCompatible(Info, info, ref caps));
 
-                bool bothMs = Info.Target.IsMultisample() && info.Target.IsMultisample();
+                bool bothMs = Info.Target.IsMultisample && info.Target.IsMultisample;
                 if (bothMs && (Info.SamplesInX != info.SamplesInX || Info.SamplesInY != info.SamplesInY))
                 {
                     result = TextureViewCompatibility.Incompatible;

src/Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs

@@ -195,16 +195,6 @@ namespace Ryujinx.Graphics.Gpu.Image
             return true;
         }
 
-        /// <summary>
-        /// Determines whether a texture can flush its data back to guest memory.
-        /// </summary>
-        /// <param name="info">Texture that will have its data flushed</param>
-        /// <param name="caps">Host GPU Capabilities</param>
-        /// <returns>True if the texture can flush, false otherwise</returns>
-        public static bool CanTextureFlush(Texture texture, in Capabilities caps)
-        {
-            return !texture.HasImportOverride() && CanTextureFlush(texture.Info, caps);
-        }
 
         /// <summary>
         /// Determines whether a texture can flush its data back to guest memory.
@@ -212,14 +202,15 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="info">Texture information</param>
         /// <param name="caps">Host GPU Capabilities</param>
         /// <returns>True if the texture can flush, false otherwise</returns>
-        private static bool CanTextureFlush(TextureInfo info, in Capabilities caps)
+       public static bool CanTextureFlush(TextureInfo info, Capabilities caps)
         {
-            if (IsFormatHostIncompatible(info, in caps))
+            if (IsFormatHostIncompatible(info, caps))
             {
                 return false; // Flushing this format is not supported, as it may have been converted to another host format.
             }
 
-            if (info.Target is Target.Texture2DMultisample or Target.Texture2DMultisampleArray)
+            if (info.Target is Target.Texture2DMultisample or
+                Target.Texture2DMultisampleArray)
             {
                 return false; // Flushing multisample textures is not supported, the host does not allow getting their data.
             }
@@ -400,7 +391,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 return stride == rhs.Stride ? TextureViewCompatibility.CopyOnly : TextureViewCompatibility.LayoutIncompatible;
             }
-            else if (lhs.Target.IsMultisample() != rhs.Target.IsMultisample() && alignedWidthMatches && lhsAlignedSize.Height == rhsAlignedSize.Height)
+            else if (lhs.Target.IsMultisample != rhs.Target.IsMultisample && alignedWidthMatches && lhsAlignedSize.Height == rhsAlignedSize.Height)
             {
                 // Copy between multisample and non-multisample textures with mismatching size is allowed,
                 // as long aligned size matches.

src/Ryujinx.Graphics.Gpu/Image/TextureGroup.cs

@@ -147,7 +147,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             _allOffsets = size.AllOffsets;
             _sliceSizes = size.SliceSizes;
 
-            if (Storage.Target.HasDepthOrLayers() && Storage.Info.GetSlices() > GranularLayerThreshold)
+            if (Storage.Target.HasDepthOrLayers && Storage.Info.GetSlices() > GranularLayerThreshold)
             {
                 _hasLayerViews = true;
                 _hasMipViews = true;
@@ -182,7 +182,11 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             foreach (TextureIncompatibleOverlap overlap in _incompatibleOverlaps)
             {
-                if (overlap.Compatibility <= TextureViewCompatibility.LayoutIncompatible)
+                // LayoutIncompatible and better may still use a regular texture copy dependency.
+                // Fully Incompatible pairs are not copy compatible in general, but may still qualify for an
+                // exact raw byte copy dependency (checked internally by CreateCopyDependency) when they map
+                // to exactly the same guest memory, such as differently typed/sized aliases of the same data.
+                if (overlap.Compatibility <= TextureViewCompatibility.Incompatible)
                 {
                     CreateCopyDependency(overlap.Group, false, overlap.Compatibility);
                 }
@@ -226,7 +230,6 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
         }
 
-
         /// <summary>
         /// Flushes incompatible overlaps if the storage format requires it, and they have been modified.
         /// This allows unsupported host formats to accept data written to format aliased textures.
@@ -324,7 +327,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             FlushIncompatibleOverlapsIfNeeded();
 
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, _) =>
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, bound) =>
             {
                 bool dirty = false;
                 bool anyModified = false;
@@ -479,7 +482,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="texture">The texture to synchronize dependents of</param>
         public void SynchronizeDependents(Texture texture)
         {
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, _, _) =>
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, bound) =>
             {
                 for (int i = 0; i < regionCount; i++)
                 {
@@ -571,7 +574,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             tracked = tracked || ShouldFlushTriggerTracking();
             bool flushed = false;
 
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, _) =>
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, bound) =>
             {
                 int startSlice = 0;
                 int endSlice = 0;
@@ -652,14 +655,14 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             if (_flushBuffer == BufferHandle.Null)
             {
-                if (!TextureCompatibility.CanTextureFlush(Storage, _context.Capabilities))
+                if (!TextureCompatibility.CanTextureFlush(Storage.Info, _context.Capabilities))
                 {
                     return;
                 }
 
                 bool canImport = Storage.Info.IsLinear && Storage.Info.Stride >= Storage.Info.Width * Storage.Info.FormatInfo.BytesPerPixel;
 
-                IntPtr hostPointer = canImport ? _physicalMemory.GetHostPointer(Storage.Range) : 0;
+                nint hostPointer = canImport ? _physicalMemory.GetHostPointer(Storage.Range) : 0;
 
                 if (hostPointer != 0 && _context.Renderer.PrepareHostMapping(hostPointer, Storage.Size))
                 {
@@ -716,7 +719,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             ClearIncompatibleOverlaps(texture);
 
-            EvaluateRelevantHandles(texture, (baseHandle, regionCount, _, _) =>
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split, bound) =>
             {
                 for (int i = 0; i < regionCount; i++)
                 {
@@ -1049,7 +1052,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             int endOffset = _allOffsets[viewEnd] + _sliceSizes[lastLevel];
             int size = endOffset - offset;
 
-            List<RegionHandle> result = new();
+            List<RegionHandle> result = [];
 
             for (int i = 0; i < TextureRange.Count; i++)
             {
@@ -1163,7 +1166,6 @@ namespace Ryujinx.Graphics.Gpu.Image
             SignalAllDirty();
         }
 
-
         /// <summary>
         /// Removes a view from the group, removing it from all overlap lists.
         /// </summary>
@@ -1385,7 +1387,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 if (_is3D)
                 {
-                    List<TextureGroupHandle> handlesList = new();
+                    List<TextureGroupHandle> handlesList = [];
 
                     for (int i = 0; i < levelHandles; i++)
                     {
@@ -1468,15 +1470,15 @@ namespace Ryujinx.Graphics.Gpu.Image
             // Get the location of each texture within its storage, so we can find the handles to apply the dependency to.
             // This can consist of multiple disjoint regions, for example if this is a mip slice of an array texture.
 
-            List<(int BaseHandle, int RegionCount)> targetRange = new();
-            List<(int BaseHandle, int RegionCount)> otherRange = new();
+            List<(int BaseHandle, int RegionCount)> targetRange = [];
+            List<(int BaseHandle, int RegionCount)> otherRange = [];
 
-            EvaluateRelevantHandles(firstLayer, firstLevel, other.Info.GetSlices(), other.Info.Levels, (baseHandle, regionCount, _, _) =>
+            EvaluateRelevantHandles(firstLayer, firstLevel, other.Info.GetSlices(), other.Info.Levels, (baseHandle, regionCount, split, specialData) =>
             {
                 targetRange.Add((baseHandle, regionCount));
                 return true;
             }, out _);
-            otherGroup.EvaluateRelevantHandles(other, (baseHandle, regionCount, _, _) =>
+            otherGroup.EvaluateRelevantHandles(other, (baseHandle, regionCount, split, specialData) =>
             {
                 otherRange.Add((baseHandle, regionCount));
                 return true;
@@ -1601,7 +1603,15 @@ namespace Ryujinx.Graphics.Gpu.Image
                         TextureInfo info = Storage.Info;
                         TextureInfo otherInfo = other.Storage.Info;
 
-                        bool textureCopy = TextureCompatibility.ViewLayoutCompatible(info, otherInfo, level, otherLevel) &&
+                        // ViewLayoutCompatible/CopySizeMatches only reason about textures with some genuine
+                        // format relationship (LayoutIncompatible or better) - they are not aware of, and must
+                        // never be used to justify, a plain texture-to-texture copy (which some backends
+                        // implement via a reinterpreting view) between fully Incompatible aliases such as a
+                        // depth format and an unrelated color format. For Incompatible pairs, only the strict
+                        // raw byte copy dependency below (which explicitly excludes depth/stencil formats) may
+                        // be used.
+                        bool textureCopy = compatibility != TextureViewCompatibility.Incompatible &&
+                            TextureCompatibility.ViewLayoutCompatible(info, otherInfo, level, otherLevel) &&
                             TextureCompatibility.CopySizeMatches(info, otherInfo, level, otherLevel);
 
                         if (textureCopy || rawCopy)
@@ -1659,9 +1669,12 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             if (!_incompatibleOverlaps.Any(overlap => overlap.Group == other.Group))
             {
-                if (copy && other.Compatibility <= TextureViewCompatibility.LayoutIncompatible)
+                if (copy && other.Compatibility <= TextureViewCompatibility.Incompatible)
                 {
                     // Any of the group's views may share compatibility, even if the parents do not fully.
+                    // Fully Incompatible groups are also let through here, since CreateCopyDependency will
+                    // fall back to an exact raw byte copy dependency for them when the strict requirements
+                    // for one are met (see CanCreateRawCopyDependency).
                     CreateCopyDependency(other.Group, false, other.Compatibility);
                 }
 
@@ -1763,7 +1776,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                     }
                 }
 
-                if (TextureCompatibility.CanTextureFlush(Storage, _context.Capabilities) && !(inBuffer && _flushBufferImported))
+                if (TextureCompatibility.CanTextureFlush(Storage.Info, _context.Capabilities) && !(inBuffer && _flushBufferImported))
                 {
                     FlushSliceRange(false, handle.BaseSlice, handle.BaseSlice + handle.SliceCount, inBuffer, Storage.GetFlushTexture());
                 }
@@ -1803,4 +1816,3 @@ namespace Ryujinx.Graphics.Gpu.Image
         }
     }
 }
-

src/Ryujinx.Graphics.Gpu/Image/TextureGroupHandle.cs

@@ -717,6 +717,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 }
 
                 DeferredCopy = old.DeferredCopy;
+                DeferredCopyRaw = old.DeferredCopyRaw;
             }
         }
 

src/Ryujinx.Graphics.OpenGL/Image/TextureView.cs

@@ -116,8 +116,8 @@ namespace Ryujinx.Graphics.OpenGL.Image
         {
             TextureView destinationView = (TextureView)destination;
 
-            bool srcIsMultisample = Target.IsMultisample();
-            bool dstIsMultisample = destinationView.Target.IsMultisample();
+            bool srcIsMultisample = Target.IsMultisample;
+            bool dstIsMultisample = destinationView.Target.IsMultisample;
 
             if (dstIsMultisample != srcIsMultisample && Info.Format.IsDepthOrStencil())
             {
@@ -172,8 +172,8 @@ namespace Ryujinx.Graphics.OpenGL.Image
         {
             TextureView destinationView = (TextureView)destination;
 
-            bool srcIsMultisample = Target.IsMultisample();
-            bool dstIsMultisample = destinationView.Target.IsMultisample();
+            bool srcIsMultisample = Target.IsMultisample;
+            bool dstIsMultisample = destinationView.Target.IsMultisample;
 
             if (dstIsMultisample != srcIsMultisample && Info.Format.IsDepthOrStencil())
             {
@@ -216,7 +216,7 @@ namespace Ryujinx.Graphics.OpenGL.Image
             Extents2D srcRegion = new(0, 0, Width, Height);
             Extents2D dstRegion = new(0, 0, destinationView.Width, destinationView.Height);
 
-            if (destinationView.Target.IsMultisample())
+            if (destinationView.Target.IsMultisample)
             {
                 TextureView intermmediate = _renderer.TextureCopy.IntermediatePool.GetOrCreateWithAtLeast(
                     Info.Target,

src/Ryujinx.Graphics.Vulkan/HelperShader.cs

@@ -406,10 +406,10 @@ namespace Ryujinx.Graphics.Vulkan
 
             if (dstIsDepthOrStencil)
             {
-                _pipeline.SetProgram(src.Info.Target.IsMultisample() ? _programDepthBlitMs : _programDepthBlit);
+                _pipeline.SetProgram(src.Info.Target.IsMultisample ? _programDepthBlitMs : _programDepthBlit);
                 _pipeline.SetDepthTest(new DepthTestDescriptor(true, true, CompareOp.Always));
             }
-            else if (src.Info.Target.IsMultisample())
+            else if (src.Info.Target.IsMultisample)
             {
                 _pipeline.SetProgram(_programColorBlitMs);
             }
@@ -566,12 +566,12 @@ namespace Ryujinx.Graphics.Vulkan
 
             if (isDepth)
             {
-                _pipeline.SetProgram(src.Info.Target.IsMultisample() ? _programDepthBlitMs : _programDepthBlit);
+                _pipeline.SetProgram(src.Info.Target.IsMultisample ? _programDepthBlitMs : _programDepthBlit);
                 _pipeline.SetDepthTest(new DepthTestDescriptor(true, true, CompareOp.Always));
             }
             else
             {
-                _pipeline.SetProgram(src.Info.Target.IsMultisample() ? _programStencilBlitMs : _programStencilBlit);
+                _pipeline.SetProgram(src.Info.Target.IsMultisample ? _programStencilBlitMs : _programStencilBlit);
                 _pipeline.SetStencilTest(CreateStencilTestDescriptor(true));
             }
 

src/Ryujinx.Graphics.Vulkan/TextureStorage.cs

@@ -79,7 +79,7 @@ namespace Ryujinx.Graphics.Vulkan
             _device = device;
             _info = info;
 
-            bool isMsImageStorageSupported = gd.Capabilities.SupportsShaderStorageImageMultisample || !info.Target.IsMultisample();
+            bool isMsImageStorageSupported = gd.Capabilities.SupportsShaderStorageImageMultisample || !info.Target.IsMultisample;
 
             VkFormat format = _gd.FormatCapabilities.ConvertToVkFormat(info.Format, isMsImageStorageSupported);
             uint levels = (uint)info.Levels;
@@ -323,7 +323,7 @@ namespace Ryujinx.Graphics.Vulkan
                 usage |= ImageUsageFlags.ColorAttachmentBit;
             }
 
-            if (format.IsImageCompatible() && (isMsImageStorageSupported || !target.IsMultisample()))
+            if (format.IsImageCompatible() && (isMsImageStorageSupported || !target.IsMultisample))
             {
                 usage |= ImageUsageFlags.StorageBit;
             }

src/Ryujinx.Graphics.Vulkan/TextureView.cs

@@ -61,7 +61,7 @@ namespace Ryujinx.Graphics.Vulkan
 
             gd.Textures.Add(this);
 
-            bool isMsImageStorageSupported = gd.Capabilities.SupportsShaderStorageImageMultisample || !info.Target.IsMultisample();
+            bool isMsImageStorageSupported = gd.Capabilities.SupportsShaderStorageImageMultisample || !info.Target.IsMultisample;
 
             VkFormat format = _gd.FormatCapabilities.ConvertToVkFormat(info.Format, isMsImageStorageSupported);
             ImageUsageFlags usage = TextureStorage.GetImageUsage(info.Format, info.Target, gd.Capabilities, isMsImageStorageSupported) & storage.UsageFlags;
@@ -126,7 +126,7 @@ namespace Ryujinx.Graphics.Vulkan
 
             ImageUsageFlags shaderUsage = ImageUsageFlags.SampledBit;
 
-            if (info.Format.IsImageCompatible() && (_gd.Capabilities.SupportsShaderStorageImageMultisample || !info.Target.IsMultisample()))
+            if (info.Format.IsImageCompatible() && (_gd.Capabilities.SupportsShaderStorageImageMultisample || !info.Target.IsMultisample))
             {
                 shaderUsage |= ImageUsageFlags.StorageBit;
             }
@@ -225,12 +225,12 @@ namespace Ryujinx.Graphics.Vulkan
             Image srcImage = src.GetImage().Get(cbs).Value;
             Image dstImage = dst.GetImage().Get(cbs).Value;
 
-            if (!dst.Info.Target.IsMultisample() && Info.Target.IsMultisample())
+            if (!dst.Info.Target.IsMultisample && Info.Target.IsMultisample)
             {
                 int layers = Math.Min(Info.GetLayers(), dst.Info.GetLayers() - firstLayer);
                 _gd.HelperShader.CopyMSToNonMS(_gd, cbs, src, dst, 0, firstLayer, layers);
             }
-            else if (dst.Info.Target.IsMultisample() && !Info.Target.IsMultisample())
+            else if (dst.Info.Target.IsMultisample && !Info.Target.IsMultisample)
             {
                 int layers = Math.Min(Info.GetLayers(), dst.Info.GetLayers() - firstLayer);
                 _gd.HelperShader.CopyNonMSToMS(_gd, cbs, src, dst, 0, firstLayer, layers);
@@ -287,11 +287,11 @@ namespace Ryujinx.Graphics.Vulkan
             Image srcImage = src.GetImage().Get(cbs).Value;
             Image dstImage = dst.GetImage().Get(cbs).Value;
 
-            if (!dst.Info.Target.IsMultisample() && Info.Target.IsMultisample())
+            if (!dst.Info.Target.IsMultisample && Info.Target.IsMultisample)
             {
                 _gd.HelperShader.CopyMSToNonMS(_gd, cbs, src, dst, srcLayer, dstLayer, 1);
             }
-            else if (dst.Info.Target.IsMultisample() && !Info.Target.IsMultisample())
+            else if (dst.Info.Target.IsMultisample && !Info.Target.IsMultisample)
             {
                 _gd.HelperShader.CopyNonMSToMS(_gd, cbs, src, dst, srcLayer, dstLayer, 1);
             }

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/AllSystemAppletProxiesService/SystemAppletProxy/ICommonStateGetter.cs

@@ -12,12 +12,23 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
 {
     class ICommonStateGetter : DisposableIpcService
     {
+        // Nintendo serves the VR goggle commands based on Title ID, apparently.
+        private static ReadOnlySpan<ulong> _supportedVRGoggleTitles =>
+        [
+            0x0100CA001D972000, // Nintendo Classics: Virtual Boy NSO
+            0x0100BFC01D976000  // Nintendo Classics: Virtual Boy NSO
+        ];
+        
+        private int _resolutionWidth = 1280;
+        private int _resolutionHeight = 720;
+        
         private readonly ServiceCtx _context;
 
         private readonly Apm.ManagerServer _apmManagerServer;
         private readonly Apm.SystemManagerServer _apmSystemManagerServer;
 
         private bool _vrModeEnabled;
+        private bool _vrMode3dEnabled;
 #pragma warning disable CS0414, IDE0052 // Remove unread private member
         private bool _lcdBacklighOffEnabled;
         private bool _requestExitToLibraryAppletAtExecuteNextProgramEnabled;
@@ -153,6 +164,47 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
             return ResultCode.Success;
         }
 
+        [CommandCmif(30)]
+        // GetHomeButtonReaderLockAccessor() -> nn::am::service::ILockAccessor
+        public ResultCode GetHomeButtonReaderLockAccessor(ServiceCtx context)
+        {
+            // We currently do not have any home button functionality, so it's fine to stub this for now.
+            // Similar to using GetReaderLockAccessorEx() with inval=0.
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+            MakeObject(context, new ILockAccessor(context));
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(31)] // 2.0.0 +
+        // GetReaderLockAccessorEx(uint unknown) -> nn::am::service::ILockAccessor
+        public ResultCode GetReaderLockAccessorEx(ServiceCtx context)
+        {
+            uint unknown = context.RequestData.ReadUInt32();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm, new { unknown });
+            if (unknown < 0 || unknown > 3)
+            {
+                throw new ArgumentOutOfRangeException(nameof(unknown));
+            }
+            
+            MakeObject(context, new ILockAccessor(context));
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(32)] // 2.0.0+
+        // GetWriterLockAccessorEx(uint unknown) -> nn::am::service::ILockAccessor
+        public ResultCode GetWriterLockAccessorEx(ServiceCtx context)
+        {
+            uint unknown = context.RequestData.ReadUInt32();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm, new { unknown });
+            if (unknown < 0 || unknown > 3)
+            {
+                throw new ArgumentOutOfRangeException(nameof(unknown));
+            }
+            
+            MakeObject(context, new ILockAccessor(context));
+            return ResultCode.Success;
+        }
+
         [CommandCmif(50)] // 3.0.0+
         // IsVrModeEnabled() -> b8
         public ResultCode IsVrModeEnabled(ServiceCtx context)
@@ -177,8 +229,8 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
         // SetLcdBacklighOffEnabled(b8)
         public ResultCode SetLcdBacklighOffEnabled(ServiceCtx context)
         {
-            // NOTE: Service sets a private field here, maybe this field is used somewhere else to turned off the backlight.
-            //       Since we don't support backlight, it's fine to do nothing.
+            // NOTE: Service sets a private field here, maybe this field is used somewhere else to turn off the backlight.
+            //       Since we don't support the backlight feature, it's fine to stub it.
 
             _lcdBacklighOffEnabled = context.RequestData.ReadBoolean();
 
@@ -298,18 +350,43 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
             return (ResultCode)_apmSystemManagerServer.GetCurrentPerformanceConfiguration(context);
         }
 
+        [CommandCmif(130)] // 21.0.0+
+        // EnableStartupLogoDisappearedMessage()
+        public ResultCode EnableStartupLogoDisappearedMessage(ServiceCtx context)
+        {
+            // NOTE: Service only delivers the message once the startup logo has actually
+            //       disappeared. We never display one, so it is already deliverable. Callers
+            //       gate their first frame on this message and hang without it.
+
+            AppletStateMgr appletState = context.Device.System.AppletState;
+
+            appletState.Messages.Enqueue(AppletMessage.StartupLogoDisappeared);
+            appletState.MessageEvent.ReadableEvent.Signal();
+
+            return ResultCode.Success;
+        }
+
         [CommandCmif(300)] // 9.0.0+
         // GetSettingsPlatformRegion() -> u8
         public ResultCode GetSettingsPlatformRegion(ServiceCtx context)
         {
             PlatformRegion platformRegion = context.Device.System.State.DesiredRegionCode == (uint)RegionCode.China ? PlatformRegion.China : PlatformRegion.Global;
-
+            
             // FIXME: Call set:sys GetPlatformRegion
             context.ResponseData.Write((byte)platformRegion);
 
             return ResultCode.Success;
         }
 
+        [CommandCmif(610)] // 21.0.0+
+        // UnknownCommand610(long unknown)
+        public ResultCode UnknownCommand610(ServiceCtx context)
+        {
+            long unknown = context.RequestData.ReadInt64();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm, new { unknown });
+            return ResultCode.Success;
+        }
+
         [CommandCmif(900)] // 11.0.0+
         // SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled()
         public ResultCode SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled(ServiceCtx context)
@@ -320,6 +397,100 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
             return ResultCode.Success;
         }
 
+        [CommandCmif(1000)] // 19.0.0+
+        // BeginVrMode3d()
+        public ResultCode BeginVrMode3d(ServiceCtx context)
+        {
+            // NOTE: Service also applies a stereo scale to the goggle display, which we don't
+            //       model, so only the state is kept here.
+
+            _vrMode3dEnabled = true;
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1001)] // 19.0.0+
+        // EndVrMode3d()
+        public ResultCode EndVrMode3d(ServiceCtx context)
+        {
+            _vrMode3dEnabled = false;
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1002)] // 19.0.0+
+        // IsVrModeEnabled3d() -> b8
+        public ResultCode IsVrModeEnabled3d(ServiceCtx context)
+        {
+            context.ResponseData.Write(_vrMode3dEnabled);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1003)] // 21.0.0+
+        // GetVrLaboGoggleViewport() -> (s32 x, s32 y, s32 width, s32 height)
+        public ResultCode GetVrLaboGoggleViewport(ServiceCtx context)
+        {
+            if (!IsVrLaboGoggleSupportedTitle(context))
+            {
+                return ResultCode.ObjectInvalid;
+            }
+            
+            int VrDisplayCoordinateX = 0;
+            int VrDisplayCoordinateY = 0;
+            int VrDisplayWidth = _resolutionWidth;
+            int VrDisplayHeight = _resolutionHeight;
+
+            context.ResponseData.Write(VrDisplayCoordinateX);
+            context.ResponseData.Write(VrDisplayCoordinateY);
+            context.ResponseData.Write(VrDisplayWidth);
+            context.ResponseData.Write(VrDisplayHeight);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1004)] // 21.0.0+
+        // GetPanelPhysicalSizeForSpecificTitle() -> (f32 width, f32 height)
+        public ResultCode GetPanelPhysicalSizeForSpecificTitle(ServiceCtx context)
+        {
+            if (!IsVrLaboGoggleSupportedTitle(context))
+            {
+                return ResultCode.ObjectInvalid;
+            }
+            
+            // The switch provides micrometres, but the command reports millimetres.
+            // 6.2 inch 16:9 panel.
+            float PanelPhysicalWidthMicroMeters = 137250f;
+            float PanelPhysicalHeightMicroMeters = 77200f;
+            
+            context.ResponseData.Write(PanelPhysicalWidthMicroMeters / 1000f);
+            context.ResponseData.Write(PanelPhysicalHeightMicroMeters / 1000f);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1005)] // 21.0.0+
+        // GetPanelResolutionForSpecificTitle() -> (s32 width, s32 height)
+        public ResultCode GetPanelResolutionForSpecificTitle(ServiceCtx context)
+        {
+            if (!IsVrLaboGoggleSupportedTitle(context))
+            {
+                return ResultCode.ObjectInvalid;
+            }
+            
+            context.ResponseData.Write(_resolutionWidth);
+            context.ResponseData.Write(_resolutionHeight);
+
+            return ResultCode.Success;
+        }
+
+        private static bool IsVrLaboGoggleSupportedTitle(ServiceCtx context)
+        {
+            ulong programId = context.Device.Processes.ActiveApplication.ProgramId;
+
+            return _supportedVRGoggleTitles.Contains(programId);
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             if (isDisposing)

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/AllSystemAppletProxiesService/SystemAppletProxy/ILockAccessor.cs

@@ -0,0 +1,80 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Kernel.Threading;
+using Ryujinx.Horizon.Common;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.SystemAppletProxy
+{
+    class ILockAccessor : IpcService
+    {
+        private readonly ServiceCtx _context;
+
+        private readonly Apm.ManagerServer _apmManagerServer;
+        private readonly Apm.SystemManagerServer _apmSystemManagerServer;
+        
+        private readonly KEvent _lockEvent;
+        private int _lockEventHandle;
+
+        public ILockAccessor(ServiceCtx context)
+        {
+            
+            _context = context;
+            
+            _apmManagerServer = new Apm.ManagerServer(context);
+            _apmSystemManagerServer = new Apm.SystemManagerServer(context);
+
+            _lockEvent = new KEvent(context.Device.System.KernelContext);
+        }
+
+        [CommandCmif(1)]
+        // TryLock(unknown u8 bool) -> unknown u8 bool
+        public ResultCode TryLock(ServiceCtx context)
+        {
+            // Official sw only uses inflag=false.
+            // Official sw just closes the output handle.
+            // The input flag controls whether this returns the output handle. 
+            bool unknown = context.RequestData.ReadBoolean();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm, new { unknown });
+            
+            context.ResponseData.Write(false);
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_lockEventHandle);
+            
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(2)]
+        // Unlock()
+        public ResultCode Unlock(ServiceCtx context)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(3)]
+        // GetEvent() -> EventHandle w/ autoclear = false
+        public ResultCode GetEvent(ServiceCtx context)
+        {
+            if (_lockEventHandle == 0)
+            {
+                if (context.Process.HandleTable.GenerateHandle(_lockEvent.ReadableEvent, out _lockEventHandle) != Result.Success)
+                {
+                    throw new InvalidOperationException("Out of handles!");
+                }
+            }
+            
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_lockEventHandle);
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(4)] // 10.0.0+
+        // IsLocked() -> unknown u8 bool
+        public ResultCode IsLocked(ServiceCtx context)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+            context.ResponseData.Write(false);
+            return ResultCode.Success;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/AllSystemAppletProxiesService/SystemAppletProxy/Types/AppletMessage.cs

@@ -32,5 +32,6 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
         DetectShortPressingCaptureButton = 90,
         AlbumScreenShotTaken = 92,
         AlbumRecordingSaved = 93,
+        StartupLogoDisappeared = 95, // 21.0.0+
     }
 }