diff --git a/Ryujinx.Graphics.Gpu/Engine/MethodCopyTexture.cs b/Ryujinx.Graphics.Gpu/Engine/MethodCopyTexture.cs
index af7ac038ff..8e92685bc2 100644
--- a/Ryujinx.Graphics.Gpu/Engine/MethodCopyTexture.cs
+++ b/Ryujinx.Graphics.Gpu/Engine/MethodCopyTexture.cs
@@ -1,4 +1,5 @@
 using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.Gpu.Image;
 using Ryujinx.Graphics.Gpu.State;
 using System;
 
@@ -28,16 +29,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
             // When the source texture that was found has a depth format,
             // we must enforce the target texture also has a depth format,
             // as copies between depth and color formats are not allowed.
-            dstCopyTexture.Format = srcTexture.Format switch
-            {
-                Format.S8Uint => RtFormat.S8Uint,
-                Format.D16Unorm => RtFormat.D16Unorm,
-                Format.D24X8Unorm => RtFormat.D24Unorm,
-                Format.D32Float => RtFormat.D32Float,
-                Format.D24UnormS8Uint => RtFormat.D24UnormS8Uint,
-                Format.D32FloatS8Uint => RtFormat.D32FloatS8Uint,
-                _ => dstCopyTexture.Format
-            };
+            dstCopyTexture.Format = TextureCompatibility.DeriveDepthFormat(dstCopyTexture.Format, srcTexture.Format);
 
             Texture dstTexture = TextureManager.FindOrCreateTexture(dstCopyTexture, srcTexture.ScaleMode == Image.TextureScaleMode.Scaled);
 
diff --git a/Ryujinx.Graphics.Gpu/Image/Texture.cs b/Ryujinx.Graphics.Gpu/Image/Texture.cs
index a312a8b7ea..2a61b441c6 100644
--- a/Ryujinx.Graphics.Gpu/Image/Texture.cs
+++ b/Ryujinx.Graphics.Gpu/Image/Texture.cs
@@ -659,32 +659,31 @@ namespace Ryujinx.Graphics.Gpu.Image
         }
 
         /// <summary>
-        /// Performs a comparison of this texture information, with the specified texture information.
-        /// This performs a strict comparison, used to check if two textures are equal.
+        /// This performs a strict comparison, used to check if this texture is equal to the one supplied.
         /// </summary>
-        /// <param name="info">Texture information to compare with</param>
+        /// <param name="info">Texture information to compare against</param>
         /// <param name="flags">Comparison flags</param>
         /// <returns>True if the textures are strictly equal or similar, false otherwise</returns>
         public bool IsPerfectMatch(TextureInfo info, TextureSearchFlags flags)
         {
-            if (!FormatMatches(info, (flags & TextureSearchFlags.ForSampler) != 0, (flags & TextureSearchFlags.ForCopy) != 0))
+            if (!TextureCompatibility.FormatMatches(Info, info, (flags & TextureSearchFlags.ForSampler) != 0, (flags & TextureSearchFlags.ForCopy) != 0))
             {
                 return false;
             }
 
-            if (!LayoutMatches(info))
+            if (!TextureCompatibility.LayoutMatches(Info, info))
             {
                 return false;
             }
 
-            if (!SizeMatches(info, (flags & TextureSearchFlags.Strict) == 0))
+            if (!TextureCompatibility.SizeMatches(Info, info))
             {
                 return false;
             }
 
             if ((flags & TextureSearchFlags.ForSampler) != 0 || (flags & TextureSearchFlags.Strict) != 0)
             {
-                if (!SamplerParamsMatches(info))
+                if (!TextureCompatibility.SamplerParamsMatches(Info, info))
                 {
                     return false;
                 }
@@ -694,12 +693,12 @@ namespace Ryujinx.Graphics.Gpu.Image
             {
                 bool msTargetCompatible = Info.Target == Target.Texture2DMultisample && info.Target == Target.Texture2D;
 
-                if (!msTargetCompatible && !TargetAndSamplesCompatible(info))
+                if (!msTargetCompatible && !TextureCompatibility.TargetAndSamplesCompatible(Info, info))
                 {
                     return false;
                 }
             }
-            else if (!TargetAndSamplesCompatible(info))
+            else if (!TextureCompatibility.TargetAndSamplesCompatible(Info, info))
             {
                 return false;
             }
@@ -707,153 +706,6 @@ namespace Ryujinx.Graphics.Gpu.Image
             return Info.Address == info.Address && Info.Levels == info.Levels;
         }
 
-        /// <summary>
-        /// Checks if the texture format matches with the specified texture information.
-        /// </summary>
-        /// <param name="info">Texture information to compare with</param>
-        /// <param name="forSampler">Indicates that the texture will be used for shader sampling</param>
-        /// <param name="forCopy">Indicates that the texture will be used as copy source or target</param>
-        /// <returns>True if the format matches, with the given comparison rules</returns>
-        private bool FormatMatches(TextureInfo info, bool forSampler, bool forCopy)
-        {
-            // D32F and R32F texture have the same representation internally,
-            // however the R32F format is used to sample from depth textures.
-            if (Info.FormatInfo.Format == Format.D32Float && info.FormatInfo.Format == Format.R32Float && (forSampler || forCopy))
-            {
-                return true;
-            }
-
-            if (forCopy)
-            {
-                // The 2D engine does not support depth-stencil formats, so it will instead
-                // use equivalent color formats. We must also consider them as compatible.
-                if (Info.FormatInfo.Format == Format.S8Uint && info.FormatInfo.Format == Format.R8Unorm)
-                {
-                    return true;
-                }
-
-                if (Info.FormatInfo.Format == Format.D16Unorm && info.FormatInfo.Format == Format.R16Unorm)
-                {
-                    return true;
-                }
-
-                if ((Info.FormatInfo.Format == Format.D24UnormS8Uint ||
-                     Info.FormatInfo.Format == Format.D24X8Unorm) && info.FormatInfo.Format == Format.B8G8R8A8Unorm)
-                {
-                    return true;
-                }
-            }
-
-            return Info.FormatInfo.Format == info.FormatInfo.Format;
-        }
-
-        /// <summary>
-        /// Checks if the texture layout specified matches with this texture layout.
-        /// The layout information is composed of the Stride for linear textures, or GOB block size
-        /// for block linear textures.
-        /// </summary>
-        /// <param name="info">Texture information to compare with</param>
-        /// <returns>True if the layout matches, false otherwise</returns>
-        private bool LayoutMatches(TextureInfo info)
-        {
-            if (Info.IsLinear != info.IsLinear)
-            {
-                return false;
-            }
-
-            // For linear textures, gob block sizes are ignored.
-            // For block linear textures, the stride is ignored.
-            if (info.IsLinear)
-            {
-                return Info.Stride == info.Stride;
-            }
-            else
-            {
-                return Info.GobBlocksInY == info.GobBlocksInY &&
-                       Info.GobBlocksInZ == info.GobBlocksInZ;
-            }
-        }
-
-        /// <summary>
-        /// Checks if the texture sizes of the supplied texture information matches this texture.
-        /// </summary>
-        /// <param name="info">Texture information to compare with</param>
-        /// <returns>True if the size matches, false otherwise</returns>
-        public bool SizeMatches(TextureInfo info)
-        {
-            return SizeMatches(info, alignSizes: false);
-        }
-
-        /// <summary>
-        /// Checks if the texture sizes of the supplied texture information matches the given level of
-        /// this texture.
-        /// </summary>
-        /// <param name="info">Texture information to compare with</param>
-        /// <param name="level">Mipmap level of this texture to compare with</param>
-        /// <returns>True if the size matches with the level, false otherwise</returns>
-        public bool SizeMatches(TextureInfo info, int level)
-        {
-            return Math.Max(1, Info.Width      >> level) == info.Width  &&
-                   Math.Max(1, Info.Height     >> level) == info.Height &&
-                   Math.Max(1, Info.GetDepth() >> level) == info.GetDepth();
-        }
-
-        /// <summary>
-        /// Checks if the texture sizes of the supplied texture information matches this texture.
-        /// </summary>
-        /// <param name="info">Texture information to compare with</param>
-        /// <param name="alignSizes">True to align the sizes according to the texture layout for comparison</param>
-        /// <returns>True if the sizes matches, false otherwise</returns>
-        private bool SizeMatches(TextureInfo info, bool alignSizes)
-        {
-            if (Info.GetLayers() != info.GetLayers())
-            {
-                return false;
-            }
-
-            if (alignSizes)
-            {
-                Size size0 = GetAlignedSize(Info);
-                Size size1 = GetAlignedSize(info);
-
-                return size0.Width  == size1.Width  &&
-                       size0.Height == size1.Height &&
-                       size0.Depth  == size1.Depth;
-            }
-            else
-            {
-                return Info.Width      == info.Width  &&
-                       Info.Height     == info.Height &&
-                       Info.GetDepth() == info.GetDepth();
-            }
-        }
-
-        /// <summary>
-        /// Checks if the texture shader sampling parameters matches.
-        /// </summary>
-        /// <param name="info">Texture information to compare with</param>
-        /// <returns>True if the texture shader sampling parameters matches, false otherwise</returns>
-        private bool SamplerParamsMatches(TextureInfo info)
-        {
-            return Info.DepthStencilMode == info.DepthStencilMode &&
-                   Info.SwizzleR         == info.SwizzleR         &&
-                   Info.SwizzleG         == info.SwizzleG         &&
-                   Info.SwizzleB         == info.SwizzleB         &&
-                   Info.SwizzleA         == info.SwizzleA;
-        }
-
-        /// <summary>
-        /// Check if the texture target and samples count (for multisampled textures) matches.
-        /// </summary>
-        /// <param name="info">Texture information to compare with</param>
-        /// <returns>True if the texture target and samples count matches, false otherwise</returns>
-        private bool TargetAndSamplesCompatible(TextureInfo info)
-        {
-            return Info.Target     == info.Target     &&
-                   Info.SamplesInX == info.SamplesInX &&
-                   Info.SamplesInY == info.SamplesInY;
-        }
-
         /// <summary>
         /// Check if it's possible to create a view, with the given parameters, from this texture.
         /// </summary>
@@ -903,22 +755,22 @@ namespace Ryujinx.Graphics.Gpu.Image
                 return false;
             }
 
-            if (!ViewLayoutCompatible(info, firstLevel))
+            if (!TextureCompatibility.ViewLayoutCompatible(Info, info, firstLevel))
             {
                 return false;
             }
 
-            if (!ViewFormatCompatible(info))
+            if (!TextureCompatibility.ViewFormatCompatible(Info, info))
             {
                 return false;
             }
 
-            if (!ViewSizeMatches(info, firstLevel, isCopy))
+            if (!TextureCompatibility.ViewSizeMatches(Info, info, firstLevel, isCopy))
             {
                 return false;
             }
 
-            if (!ViewTargetCompatible(info, isCopy))
+            if (!TextureCompatibility.ViewTargetCompatible(Info, info, isCopy))
             {
                 return false;
             }
@@ -927,167 +779,6 @@ namespace Ryujinx.Graphics.Gpu.Image
                    Info.SamplesInY == info.SamplesInY;
         }
 
-        /// <summary>
-        /// Check if it's possible to create a view with the specified layout.
-        /// The layout information is composed of the Stride for linear textures, or GOB block size
-        /// for block linear textures.
-        /// </summary>
-        /// <param name="info">Texture information of the texture view</param>
-        /// <param name="level">Start level of the texture view, in relation with this texture</param>
-        /// <returns>True if the layout is compatible, false otherwise</returns>
-        private bool ViewLayoutCompatible(TextureInfo info, int level)
-        {
-            if (Info.IsLinear != info.IsLinear)
-            {
-                return false;
-            }
-
-            // For linear textures, gob block sizes are ignored.
-            // For block linear textures, the stride is ignored.
-            if (info.IsLinear)
-            {
-                int width = Math.Max(1, Info.Width >> level);
-
-                int stride = width * Info.FormatInfo.BytesPerPixel;
-
-                stride = BitUtils.AlignUp(stride, 32);
-
-                return stride == info.Stride;
-            }
-            else
-            {
-                int height = Math.Max(1, Info.Height     >> level);
-                int depth  = Math.Max(1, Info.GetDepth() >> level);
-
-                (int gobBlocksInY, int gobBlocksInZ) = SizeCalculator.GetMipGobBlockSizes(
-                    height,
-                    depth,
-                    Info.FormatInfo.BlockHeight,
-                    Info.GobBlocksInY,
-                    Info.GobBlocksInZ);
-
-                return gobBlocksInY == info.GobBlocksInY &&
-                       gobBlocksInZ == info.GobBlocksInZ;
-            }
-        }
-
-        /// <summary>
-        /// Checks if the view format is compatible with this texture format.
-        /// In general, the formats are considered compatible if the bytes per pixel values are equal,
-        /// but there are more complex rules for some formats, like compressed or depth-stencil formats.
-        /// This follows the host API copy compatibility rules.
-        /// </summary>
-        /// <param name="info">Texture information of the texture view</param>
-        /// <returns>True if the formats are compatible, false otherwise</returns>
-        private bool ViewFormatCompatible(TextureInfo info)
-        {
-            return TextureCompatibility.FormatCompatible(Info.FormatInfo, info.FormatInfo);
-        }
-
-        /// <summary>
-        /// Checks if the size of a given texture view is compatible with this texture.
-        /// </summary>
-        /// <param name="info">Texture information of the texture view</param>
-        /// <param name="level">Mipmap level of the texture view in relation to this texture</param>
-        /// <param name="isCopy">True to check for copy compatibility rather than view compatibility</param>
-        /// <returns>True if the sizes are compatible, false otherwise</returns>
-        private bool ViewSizeMatches(TextureInfo info, int level, bool isCopy)
-        {
-            Size size = GetAlignedSize(Info, level);
-
-            Size otherSize = GetAlignedSize(info);
-
-            // For copies, we can copy a subset of the 3D texture slices,
-            // so the depth may be different in this case.
-            if (!isCopy && info.Target == Target.Texture3D && size.Depth != otherSize.Depth)
-            {
-                return false;
-            }
-
-            return size.Width  == otherSize.Width &&
-                   size.Height == otherSize.Height;
-        }
-
-        /// <summary>
-        /// Check if the target of the specified texture view information is compatible with this
-        /// texture.
-        /// This follows the host API target compatibility rules.
-        /// </summary>
-        /// <param name="info">Texture information of the texture view</param>
-        /// <param name="isCopy">True to check for copy rather than view compatibility</param>
-        /// <returns>True if the targets are compatible, false otherwise</returns>
-        private bool ViewTargetCompatible(TextureInfo info, bool isCopy)
-        {
-            switch (Info.Target)
-            {
-                case Target.Texture1D:
-                case Target.Texture1DArray:
-                    return info.Target == Target.Texture1D ||
-                           info.Target == Target.Texture1DArray;
-
-                case Target.Texture2D:
-                    return info.Target == Target.Texture2D ||
-                           info.Target == Target.Texture2DArray;
-
-                case Target.Texture2DArray:
-                case Target.Cubemap:
-                case Target.CubemapArray:
-                    return info.Target == Target.Texture2D      ||
-                           info.Target == Target.Texture2DArray ||
-                           info.Target == Target.Cubemap        ||
-                           info.Target == Target.CubemapArray;
-
-                case Target.Texture2DMultisample:
-                case Target.Texture2DMultisampleArray:
-                    return info.Target == Target.Texture2DMultisample ||
-                           info.Target == Target.Texture2DMultisampleArray;
-
-                case Target.Texture3D:
-                    return info.Target == Target.Texture3D ||
-                          (info.Target == Target.Texture2D && isCopy);
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Gets the aligned sizes of the specified texture information.
-        /// The alignment depends on the texture layout and format bytes per pixel.
-        /// </summary>
-        /// <param name="info">Texture information to calculate the aligned size from</param>
-        /// <param name="level">Mipmap level for texture views</param>
-        /// <returns>The aligned texture size</returns>
-        private static Size GetAlignedSize(TextureInfo info, int level = 0)
-        {
-            int width  = Math.Max(1, info.Width  >> level);
-            int height = Math.Max(1, info.Height >> level);
-
-            if (info.IsLinear)
-            {
-                return SizeCalculator.GetLinearAlignedSize(
-                    width,
-                    height,
-                    info.FormatInfo.BlockWidth,
-                    info.FormatInfo.BlockHeight,
-                    info.FormatInfo.BytesPerPixel);
-            }
-            else
-            {
-                int depth = Math.Max(1, info.GetDepth() >> level);
-
-                return SizeCalculator.GetBlockLinearAlignedSize(
-                    width,
-                    height,
-                    depth,
-                    info.FormatInfo.BlockWidth,
-                    info.FormatInfo.BlockHeight,
-                    info.FormatInfo.BytesPerPixel,
-                    info.GobBlocksInY,
-                    info.GobBlocksInZ,
-                    info.GobBlocksInTileX);
-            }
-        }
-
         /// <summary>
         /// Gets a texture of the specified target type from this texture.
         /// This can be used to get an array texture from a non-array texture and vice-versa.
diff --git a/Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs b/Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs
index 408f6e2ac2..b64a85a5d4 100644
--- a/Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs
+++ b/Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs
@@ -1,4 +1,8 @@
+using Ryujinx.Common;
 using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.Gpu.State;
+using Ryujinx.Graphics.Texture;
+using System;
 
 namespace Ryujinx.Graphics.Gpu.Image
 {
@@ -22,6 +26,26 @@ namespace Ryujinx.Graphics.Gpu.Image
             Bc7
         }
 
+        /// <summary>
+        /// Finds the appropriate depth format for a copy texture if the source texture has a depth format.
+        /// </summary>
+        /// <param name="dstTextureFormat">Destination CopyTexture Format</param>
+        /// <param name="srcTextureFormat">Source Texture Format</param>
+        /// <returns>Derived RtFormat if srcTextureFormat is a depth format, otherwise return dstTextureFormat.</returns>
+        public static RtFormat DeriveDepthFormat(RtFormat dstTextureFormat, Format srcTextureFormat)
+        {
+            return srcTextureFormat switch
+            {
+                Format.S8Uint => RtFormat.S8Uint,
+                Format.D16Unorm => RtFormat.D16Unorm,
+                Format.D24X8Unorm => RtFormat.D24Unorm,
+                Format.D32Float => RtFormat.D32Float,
+                Format.D24UnormS8Uint => RtFormat.D24UnormS8Uint,
+                Format.D32FloatS8Uint => RtFormat.D32FloatS8Uint,
+                _ => dstTextureFormat
+            };
+        }
+
         /// <summary>
         /// Checks if two formats are compatible, according to the host API copy format compatibility rules.
         /// </summary>
@@ -53,6 +77,321 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
         }
 
+        /// <summary>
+        /// Checks if the texture format matches with the specified texture information.
+        /// </summary>
+        /// <param name="lhs">Texture information to compare</param>
+        /// <param name="rhs">Texture information to compare with</param>
+        /// <param name="forSampler">Indicates that the texture will be used for shader sampling</param>
+        /// <param name="forCopy">Indicates that the texture will be used as copy source or target</param>
+        /// <returns>True if the format matches, with the given comparison rules</returns>
+        public static bool FormatMatches(TextureInfo lhs, TextureInfo rhs, bool forSampler, bool forCopy)
+        {
+            // D32F and R32F texture have the same representation internally,
+            // however the R32F format is used to sample from depth textures.
+            if (lhs.FormatInfo.Format == Format.D32Float && rhs.FormatInfo.Format == Format.R32Float && (forSampler || forCopy))
+            {
+                return true;
+            }
+
+            if (forCopy)
+            {
+                // The 2D engine does not support depth-stencil formats, so it will instead
+                // use equivalent color formats. We must also consider them as compatible.
+                if (lhs.FormatInfo.Format == Format.S8Uint && rhs.FormatInfo.Format == Format.R8Unorm)
+                {
+                    return true;
+                }
+
+                if (lhs.FormatInfo.Format == Format.D16Unorm && rhs.FormatInfo.Format == Format.R16Unorm)
+                {
+                    return true;
+                }
+
+                if ((lhs.FormatInfo.Format == Format.D24UnormS8Uint ||
+                     lhs.FormatInfo.Format == Format.D24X8Unorm) && rhs.FormatInfo.Format == Format.B8G8R8A8Unorm)
+                {
+                    return true;
+                }
+            }
+
+            return lhs.FormatInfo.Format == rhs.FormatInfo.Format;
+        }
+
+        /// <summary>
+        /// Checks if the texture layout specified matches with this texture layout.
+        /// The layout information is composed of the Stride for linear textures, or GOB block size
+        /// for block linear textures.
+        /// </summary>
+        /// <param name="lhs">Texture information to compare</param>
+        /// <param name="rhs">Texture information to compare with</param>
+        /// <returns>True if the layout matches, false otherwise</returns>
+        public static bool LayoutMatches(TextureInfo lhs, TextureInfo rhs)
+        {
+            if (lhs.IsLinear != rhs.IsLinear)
+            {
+                return false;
+            }
+
+            // For linear textures, gob block sizes are ignored.
+            // For block linear textures, the stride is ignored.
+            if (rhs.IsLinear)
+            {
+                return lhs.Stride == rhs.Stride;
+            }
+            else
+            {
+                return lhs.GobBlocksInY == rhs.GobBlocksInY &&
+                       lhs.GobBlocksInZ == rhs.GobBlocksInZ;
+            }
+        }
+
+        /// <summary>
+        /// Checks if the view sizes of a two given texture informations match.
+        /// </summary>
+        /// <param name="lhs">Texture information of the texture view</param>
+        /// <param name="rhs">Texture information of the texture view to match against</param>
+        /// <param name="level">Mipmap level of the texture view in relation to this texture</param>
+        /// <param name="isCopy">True to check for copy compatibility rather than view compatibility</param>
+        /// <returns>True if the sizes are compatible, false otherwise</returns>
+        public static bool ViewSizeMatches(TextureInfo lhs, TextureInfo rhs, int level, bool isCopy)
+        {
+            Size size = GetAlignedSize(lhs, level);
+
+            Size otherSize = GetAlignedSize(rhs);
+
+            // For copies, we can copy a subset of the 3D texture slices,
+            // so the depth may be different in this case.
+            if (!isCopy && rhs.Target == Target.Texture3D && size.Depth != otherSize.Depth)
+            {
+                return false;
+            }
+
+            return size.Width  == otherSize.Width &&
+                   size.Height == otherSize.Height;
+        }
+
+        /// <summary>
+        /// Checks if the texture sizes of the supplied texture informations match.
+        /// </summary>
+        /// <param name="lhs">Texture information to compare</param>
+        /// <param name="rhs">Texture information to compare with</param>
+        /// <returns>True if the size matches, false otherwise</returns>
+        public static bool SizeMatches(TextureInfo lhs, TextureInfo rhs)
+        {
+            return SizeMatches(lhs, rhs, alignSizes: false);
+        }
+
+        /// <summary>
+        /// Checks if the texture sizes of the supplied texture informations match the given level
+        /// </summary>
+        /// <param name="lhs">Texture information to compare</param>
+        /// <param name="rhs">Texture information to compare with</param>
+        /// <param name="level">Mipmap level of this texture to compare with</param>
+        /// <returns>True if the size matches with the level, false otherwise</returns>
+        public static bool SizeMatches(TextureInfo lhs, TextureInfo rhs, int level)
+        {
+            return Math.Max(1, lhs.Width >> level)      == rhs.Width &&
+                   Math.Max(1, lhs.Height >> level)     == rhs.Height &&
+                   Math.Max(1, lhs.GetDepth() >> level) == rhs.GetDepth();
+        }
+
+        /// <summary>
+        /// Checks if the texture sizes of the supplied texture informations match.
+        /// </summary>
+        /// <param name="lhs">Texture information to compare</param>
+        /// <param name="rhs">Texture information to compare with</param>
+        /// <param name="alignSizes">True to align the sizes according to the texture layout for comparison</param>
+        /// <returns>True if the sizes matches, false otherwise</returns>
+        private static bool SizeMatches(TextureInfo lhs, TextureInfo rhs, bool alignSizes)
+        {
+            if (lhs.GetLayers() != rhs.GetLayers())
+            {
+                return false;
+            }
+
+            if (alignSizes)
+            {
+                Size size0 = GetAlignedSize(lhs);
+                Size size1 = GetAlignedSize(rhs);
+
+                return size0.Width  == size1.Width &&
+                       size0.Height == size1.Height &&
+                       size0.Depth  == size1.Depth;
+            }
+            else
+            {
+                return lhs.Width      == rhs.Width &&
+                       lhs.Height     == rhs.Height &&
+                       lhs.GetDepth() == rhs.GetDepth();
+            }
+        }
+
+        /// <summary>
+        /// Gets the aligned sizes of the specified texture information.
+        /// The alignment depends on the texture layout and format bytes per pixel.
+        /// </summary>
+        /// <param name="info">Texture information to calculate the aligned size from</param>
+        /// <param name="level">Mipmap level for texture views</param>
+        /// <returns>The aligned texture size</returns>
+        public static Size GetAlignedSize(TextureInfo info, int level = 0)
+        {
+            int width = Math.Max(1, info.Width >> level);
+            int height = Math.Max(1, info.Height >> level);
+
+            if (info.IsLinear)
+            {
+                return SizeCalculator.GetLinearAlignedSize(
+                    width,
+                    height,
+                    info.FormatInfo.BlockWidth,
+                    info.FormatInfo.BlockHeight,
+                    info.FormatInfo.BytesPerPixel);
+            }
+            else
+            {
+                int depth = Math.Max(1, info.GetDepth() >> level);
+
+                return SizeCalculator.GetBlockLinearAlignedSize(
+                    width,
+                    height,
+                    depth,
+                    info.FormatInfo.BlockWidth,
+                    info.FormatInfo.BlockHeight,
+                    info.FormatInfo.BytesPerPixel,
+                    info.GobBlocksInY,
+                    info.GobBlocksInZ,
+                    info.GobBlocksInTileX);
+            }
+        }
+
+        /// <summary>
+        /// Check if it's possible to create a view with the layout of the second texture information from the first.
+        /// The layout information is composed of the Stride for linear textures, or GOB block size
+        /// for block linear textures.
+        /// </summary>
+        /// <param name="lhs">Texture information of the texture view</param>
+        /// <param name="rhs">Texture information of the texture view to compare against</param>
+        /// <param name="level">Start level of the texture view, in relation with the first texture</param>
+        /// <returns>True if the layout is compatible, false otherwise</returns>
+        public static bool ViewLayoutCompatible(TextureInfo lhs, TextureInfo rhs, int level)
+        {
+            if (lhs.IsLinear != rhs.IsLinear)
+            {
+                return false;
+            }
+
+            // For linear textures, gob block sizes are ignored.
+            // For block linear textures, the stride is ignored.
+            if (rhs.IsLinear)
+            {
+                int width = Math.Max(1, lhs.Width >> level);
+                int stride = width * lhs.FormatInfo.BytesPerPixel;
+                stride = BitUtils.AlignUp(stride, 32);
+
+                return stride == rhs.Stride;
+            }
+            else
+            {
+                int height = Math.Max(1, lhs.Height >> level);
+                int depth = Math.Max(1, lhs.GetDepth() >> level);
+
+                (int gobBlocksInY, int gobBlocksInZ) = SizeCalculator.GetMipGobBlockSizes(
+                    height,
+                    depth,
+                    lhs.FormatInfo.BlockHeight,
+                    lhs.GobBlocksInY,
+                    lhs.GobBlocksInZ);
+
+                return gobBlocksInY == rhs.GobBlocksInY &&
+                       gobBlocksInZ == rhs.GobBlocksInZ;
+            }
+        }
+
+        /// <summary>
+        /// Checks if the view format of the first texture format is compatible with the format of the second.
+        /// In general, the formats are considered compatible if the bytes per pixel values are equal,
+        /// but there are more complex rules for some formats, like compressed or depth-stencil formats.
+        /// This follows the host API copy compatibility rules.
+        /// </summary>
+        /// <param name="lhs">Texture information of the texture view</param>
+        /// <param name="rhs">Texture information of the texture view</param>
+        /// <returns>True if the formats are compatible, false otherwise</returns>
+        public static bool ViewFormatCompatible(TextureInfo lhs, TextureInfo rhs)
+        {
+            return FormatCompatible(lhs.FormatInfo, rhs.FormatInfo);
+        }
+
+        /// <summary>
+        /// Check if the target of the first texture view information is compatible with the target of the second texture view information.
+        /// This follows the host API target compatibility rules.
+        /// </summary>
+        /// <param name="lhs">Texture information of the texture view</param
+        /// <param name="rhs">Texture information of the texture view</param>
+        /// <param name="isCopy">True to check for copy rather than view compatibility</param>
+        /// <returns>True if the targets are compatible, false otherwise</returns>
+        public static bool ViewTargetCompatible(TextureInfo lhs, TextureInfo rhs, bool isCopy)
+        {
+            switch (lhs.Target)
+            {
+                case Target.Texture1D:
+                case Target.Texture1DArray:
+                    return rhs.Target == Target.Texture1D ||
+                           rhs.Target == Target.Texture1DArray;
+
+                case Target.Texture2D:
+                    return rhs.Target == Target.Texture2D ||
+                           rhs.Target == Target.Texture2DArray;
+
+                case Target.Texture2DArray:
+                case Target.Cubemap:
+                case Target.CubemapArray:
+                    return rhs.Target == Target.Texture2D ||
+                           rhs.Target == Target.Texture2DArray ||
+                           rhs.Target == Target.Cubemap ||
+                           rhs.Target == Target.CubemapArray;
+
+                case Target.Texture2DMultisample:
+                case Target.Texture2DMultisampleArray:
+                    return rhs.Target == Target.Texture2DMultisample ||
+                           rhs.Target == Target.Texture2DMultisampleArray;
+
+                case Target.Texture3D:
+                    return rhs.Target == Target.Texture3D ||
+                          (rhs.Target == Target.Texture2D && isCopy);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Checks if the texture shader sampling parameters of two texture informations match.
+        /// </summary>
+        /// <param name="lhs">Texture information to compare</param>
+        /// <param name="rhs">Texture information to compare with</param>
+        /// <returns>True if the texture shader sampling parameters matches, false otherwise</returns>
+        public static bool SamplerParamsMatches(TextureInfo lhs, TextureInfo rhs)
+        {
+            return lhs.DepthStencilMode == rhs.DepthStencilMode &&
+                   lhs.SwizzleR         == rhs.SwizzleR &&
+                   lhs.SwizzleG         == rhs.SwizzleG &&
+                   lhs.SwizzleB         == rhs.SwizzleB &&
+                   lhs.SwizzleA         == rhs.SwizzleA;
+        }
+
+        /// <summary>
+        /// Check if the texture target and samples count (for multisampled textures) matches.
+        /// </summary>
+        /// <param name="first">Texture information to compare with</param>
+        /// <param name="rhs">Texture information to compare with</param>
+        /// <returns>True if the texture target and samples count matches, false otherwise</returns>
+        public static bool TargetAndSamplesCompatible(TextureInfo lhs, TextureInfo rhs)
+        {
+            return lhs.Target     == rhs.Target &&
+                   lhs.SamplesInX == rhs.SamplesInX &&
+                   lhs.SamplesInY == rhs.SamplesInY;
+        }
+
         /// <summary>
         /// Gets the texture format class, for compressed textures, or Unclassified otherwise.
         /// </summary>
diff --git a/Ryujinx.Graphics.Gpu/Image/TextureManager.cs b/Ryujinx.Graphics.Gpu/Image/TextureManager.cs
index c69f69c627..cab76da1bc 100644
--- a/Ryujinx.Graphics.Gpu/Image/TextureManager.cs
+++ b/Ryujinx.Graphics.Gpu/Image/TextureManager.cs
@@ -634,7 +634,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                         // deletion.
                         _cache.Lift(overlap);
                     }
-                    else if (!overlap.SizeMatches(info))
+                    else if (!TextureCompatibility.SizeMatches(overlap.Info, info))
                     {
                         // If this is used for sampling, the size must match,
                         // otherwise the shader would sample garbage data.
@@ -707,7 +707,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                     // The size only matters (and is only really reliable) when the
                     // texture is used on a sampler, because otherwise the size will be
                     // aligned.
-                    if (!overlap.SizeMatches(info, firstLevel) && isSamplerTexture)
+                    if (!TextureCompatibility.SizeMatches(overlap.Info, info, firstLevel) && isSamplerTexture)
                     {
                         texture.ChangeSize(info.Width, info.Height, info.DepthOrLayers);
                     }