Allow "reinterpretation" of framebuffer/zeta formats (#418)

* (Re)Implement format reinterpretation, other changes

* Implement writeback to guest memory, some refactoring

* More refactoring, implement reinterpretation the old way again

* Clean up

* Some fixes on M2MF (old Dma engine), added partial support for P2MF, fix conditional ssy, add Z24S8 zeta format, other fixes

* nit: Formatting

* Address PR feedback

ChocolArm64/Memory/AMemory.cs

@@ -287,6 +287,14 @@ namespace ChocolArm64.Memory
             return Data;
         }
 
+        public void ReadBytes(long Position, byte[] Data, int StartIndex, int Size)
+        {
+            //Note: This will be moved later.
+            EnsureRangeIsValid(Position, (uint)Size);
+
+            Marshal.Copy((IntPtr)Translate(Position), Data, StartIndex, Size);
+        }
+
         public void WriteSByte(long Position, sbyte Value)
         {
             WriteByte(Position, (byte)Value);
@@ -403,6 +411,27 @@ namespace ChocolArm64.Memory
             Marshal.Copy(Data, 0, (IntPtr)TranslateWrite(Position), Data.Length);
         }
 
+        public void WriteBytes(long Position, byte[] Data, int StartIndex, int Size)
+        {
+            //Note: This will be moved later.
+            //Using Translate instead of TranslateWrite is on purpose.
+            EnsureRangeIsValid(Position, (uint)Size);
+
+            Marshal.Copy(Data, StartIndex, (IntPtr)Translate(Position), Size);
+        }
+
+        public void CopyBytes(long Src, long Dst, long Size)
+        {
+            //Note: This will be moved later.
+            EnsureRangeIsValid(Src, Size);
+            EnsureRangeIsValid(Dst, Size);
+
+            byte* SrcPtr = Translate(Src);
+            byte* DstPtr = TranslateWrite(Dst);
+
+            Buffer.MemoryCopy(SrcPtr, DstPtr, Size, Size);
+        }
+
         public void Map(long VA, long PA, long Size)
         {
             SetPTEntries(VA, RamPtr + PA, Size);

Ryujinx.Graphics/Gal/GalImage.cs

@@ -1,12 +1,17 @@
+using Ryujinx.Graphics.Texture;
+
 namespace Ryujinx.Graphics.Gal
 {
     public struct GalImage
     {
         public int Width;
         public int Height;
+        public int TileWidth;
+        public int GobBlockHeight;
+        public int Pitch;
 
-        public GalImageFormat Format;
+        public GalImageFormat   Format;
-
+        public GalMemoryLayout  Layout;
         public GalTextureSource XSource;
         public GalTextureSource YSource;
         public GalTextureSource ZSource;
@@ -15,19 +20,44 @@ namespace Ryujinx.Graphics.Gal
         public GalImage(
             int              Width,
             int              Height,
+            int              TileWidth,
+            int              GobBlockHeight,
+            GalMemoryLayout  Layout,
             GalImageFormat   Format,
             GalTextureSource XSource = GalTextureSource.Red,
             GalTextureSource YSource = GalTextureSource.Green,
             GalTextureSource ZSource = GalTextureSource.Blue,
             GalTextureSource WSource = GalTextureSource.Alpha)
         {
-            this.Width   = Width;
+            this.Width          = Width;
-            this.Height  = Height;
+            this.Height         = Height;
-            this.Format  = Format;
+            this.TileWidth      = TileWidth;
-            this.XSource = XSource;
+            this.GobBlockHeight = GobBlockHeight;
-            this.YSource = YSource;
+            this.Layout         = Layout;
-            this.ZSource = ZSource;
+            this.Format         = Format;
-            this.WSource = WSource;
+            this.XSource        = XSource;
+            this.YSource        = YSource;
+            this.ZSource        = ZSource;
+            this.WSource        = WSource;
+
+            Pitch = ImageUtils.GetPitch(Format, Width);
+        }
+
+        public bool SizeMatches(GalImage Image)
+        {
+            if (ImageUtils.GetBytesPerPixel(Format) !=
+                ImageUtils.GetBytesPerPixel(Image.Format))
+            {
+                return false;
+            }
+
+            if (ImageUtils.GetAlignedWidth(this) !=
+                ImageUtils.GetAlignedWidth(Image))
+            {
+                return false;
+            }
+
+            return Height == Image.Height;
         }
     }
 }

Ryujinx.Graphics/Gal/GalMemoryLayout.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.Graphics.Gal
+{
+    public enum GalMemoryLayout
+    {
+        BlockLinear = 0,
+        Pitch       = 1
+    }
+}

Ryujinx.Graphics/Gal/GalPipelineState.cs

@@ -21,6 +21,8 @@
 
         public GalVertexBinding[] VertexBindings;
 
+        public bool FramebufferSrgb;
+
         public float FlipX;
         public float FlipY;
 

Ryujinx.Graphics/Gal/GalTextureFormat.cs

@@ -7,6 +7,7 @@ namespace Ryujinx.Graphics.Gal
         R32G32       = 0x4,
         A8B8G8R8     = 0x8,
         A2B10G10R10  = 0x9,
+        R16G16       = 0xc,
         R32          = 0xf,
         BC6H_SF16    = 0x10,
         BC6H_UF16    = 0x11,

Ryujinx.Graphics/Gal/IGalRasterizer.cs

@@ -24,7 +24,7 @@ namespace Ryujinx.Graphics.Gal
 
         void SetIndexArray(int Size, GalIndexFormat Format);
 
-        void DrawArrays(int First, int PrimCount, GalPrimitiveType PrimType);
+        void DrawArrays(int First, int Count, GalPrimitiveType PrimType);
 
         void DrawElements(long IboKey, int First, int VertexBase, GalPrimitiveType PrimType);
     }

Ryujinx.Graphics/Gal/IGalRenderTarget.cs

@@ -1,23 +1,17 @@
-using System;
-
 namespace Ryujinx.Graphics.Gal
 {
     public interface IGalRenderTarget
     {
-        void BindColor(long Key, int Attachment);
+        void BindColor(long Key, int Attachment, GalImage Image);
 
         void UnbindColor(int Attachment);
 
-        void BindZeta(long Key);
+        void BindZeta(long Key, GalImage Image);
 
         void UnbindZeta();
 
-        void BindTexture(long Key, int Index);
-
         void Set(long Key);
 
-        void Set(byte[] Data, int Width, int Height);
-
         void SetMap(int[] Map);
 
         void SetTransform(bool FlipX, bool FlipY, int Top, int Left, int Right, int Bottom);
@@ -40,12 +34,8 @@ namespace Ryujinx.Graphics.Gal
             int  DstX1,
             int  DstY1);
 
-        void GetBufferData(long Key, Action<byte[]> Callback);
+        void Reinterpret(long Key, GalImage NewImage);
 
-        void SetBufferData(
+        byte[] GetData(long Key);
-            long             Key,
-            int              Width,
-            int              Height,
-            byte[]           Buffer);
     }
 }

Ryujinx.Graphics/Gal/IGalTexture.cs

@@ -5,13 +5,13 @@ namespace Ryujinx.Graphics.Gal
         void LockCache();
         void UnlockCache();
 
+        void Create(long Key, int Size, GalImage Image);
+
         void Create(long Key, byte[] Data, GalImage Image);
 
-        void CreateFb(long Key, long Size, GalImage Image);
+        bool TryGetImage(long Key, out GalImage Image);
 
-        bool TryGetCachedTexture(long Key, long DataSize, out GalImage Image);
+        void Bind(long Key, int Index, GalImage Image);
-
-        void Bind(long Key, int Index);
 
         void SetSampler(GalTextureSampler Sampler);
     }

Ryujinx.Graphics/Gal/OpenGL/ImageHandler.cs

@@ -1,14 +1,9 @@
-using OpenTK.Graphics.OpenGL;
+using Ryujinx.Graphics.Texture;
-using Ryujinx.Graphics.Texture;
-using System;
 
 namespace Ryujinx.Graphics.Gal.OpenGL
 {
     class ImageHandler
     {
-        private static int CopyBuffer = 0;
-        private static int CopyBufferSize = 0;
-
         public GalImage Image { get; private set; }
 
         public int Width  => Image.Width;
@@ -16,144 +11,16 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
         public GalImageFormat Format => Image.Format;
 
-        public PixelInternalFormat InternalFormat { get; private set; }
-        public PixelFormat         PixelFormat    { get; private set; }
-        public PixelType           PixelType      { get; private set; }
-
         public int Handle { get; private set; }
 
-        private bool Initialized;
-
-        public ImageHandler()
-        {
-            Handle = GL.GenTexture();
-        }
-
-        public ImageHandler(int Handle, GalImage Image)
-        {
-            this.Handle = Handle;
-
-            this.Image = Image;
-        }
-
-        public void EnsureSetup(GalImage NewImage)
-        {
-            if (Width  == NewImage.Width  &&
-                Height == NewImage.Height &&
-                Format == NewImage.Format &&
-                Initialized)
-            {
-                return;
-            }
-
-            PixelInternalFormat InternalFmt;
-            PixelFormat         PixelFormat;
-            PixelType           PixelType;
-
-            if (ImageUtils.IsCompressed(NewImage.Format))
-            {
-                InternalFmt = (PixelInternalFormat)OGLEnumConverter.GetCompressedImageFormat(NewImage.Format);
-
-                PixelFormat = default(PixelFormat);
-                PixelType   = default(PixelType);
-            }
-            else
-            {
-                (InternalFmt, PixelFormat, PixelType) = OGLEnumConverter.GetImageFormat(NewImage.Format);
-            }
-
-            GL.BindTexture(TextureTarget.Texture2D, Handle);
-
-            if (Initialized)
-            {
-                if (CopyBuffer == 0)
-                {
-                    CopyBuffer = GL.GenBuffer();
-                }
-
-                int CurrentSize = Math.Max(ImageUtils.GetSize(NewImage),
-                                           ImageUtils.GetSize(Image));
-
-                GL.BindBuffer(BufferTarget.PixelPackBuffer, CopyBuffer);
-                GL.BindBuffer(BufferTarget.PixelUnpackBuffer, CopyBuffer);
-
-                if (CopyBufferSize < CurrentSize)
-                {
-                    CopyBufferSize = CurrentSize;
-
-                    GL.BufferData(BufferTarget.PixelPackBuffer, CurrentSize, IntPtr.Zero, BufferUsageHint.StreamCopy);
-                }
-
-                if (ImageUtils.IsCompressed(Image.Format))
-                {
-                    GL.GetCompressedTexImage(TextureTarget.Texture2D, 0, IntPtr.Zero);
-                }
-                else
-                {
-                    GL.GetTexImage(TextureTarget.Texture2D, 0, this.PixelFormat, this.PixelType, IntPtr.Zero);
-                }
-
-                GL.DeleteTexture(Handle);
-
-                Handle = GL.GenTexture();
-
-                GL.BindTexture(TextureTarget.Texture2D, Handle);
-            }
-
-            const int MinFilter = (int)TextureMinFilter.Linear;
-            const int MagFilter = (int)TextureMagFilter.Linear;
-
-            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, MinFilter);
-            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, MagFilter);
-
-            const int Level = 0;
-            const int Border = 0;
-
-            if (ImageUtils.IsCompressed(NewImage.Format))
-            {
-                Console.WriteLine("Hit");
-
-                GL.CompressedTexImage2D(
-                    TextureTarget.Texture2D,
-                    Level,
-                    (InternalFormat)InternalFmt,
-                    NewImage.Width,
-                    NewImage.Height,
-                    Border,
-                    ImageUtils.GetSize(NewImage),
-                    IntPtr.Zero);
-            }
-            else
-            {
-                GL.TexImage2D(
-                    TextureTarget.Texture2D,
-                    Level,
-                    InternalFmt,
-                    NewImage.Width,
-                    NewImage.Height,
-                    Border,
-                    PixelFormat,
-                    PixelType,
-                    IntPtr.Zero);
-            }
-
-            if (Initialized)
-            {
-                GL.BindBuffer(BufferTarget.PixelPackBuffer,   0);
-                GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);
-            }
-
-            Image = NewImage;
-
-            this.InternalFormat = InternalFmt;
-            this.PixelFormat = PixelFormat;
-            this.PixelType = PixelType;
-
-            Initialized = true;
-        }
-
         public bool HasColor   => ImageUtils.HasColor(Image.Format);
         public bool HasDepth   => ImageUtils.HasDepth(Image.Format);
         public bool HasStencil => ImageUtils.HasStencil(Image.Format);
+
+        public ImageHandler(int Handle, GalImage Image)
+        {
+            this.Handle = Handle;
+            this.Image  = Image;
+        }
     }
 }

Ryujinx.Graphics/Gal/OpenGL/OGLCachedResource.cs

@@ -22,9 +22,9 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
             public CacheBucket(T Value, long DataSize, LinkedListNode<long> Node)
             {
-                this.Value     = Value;
+                this.Value    = Value;
-                this.DataSize  = DataSize;
+                this.DataSize = DataSize;
-                this.Node      = Node;
+                this.Node     = Node;
 
                 Timestamp = Environment.TickCount;
             }

Ryujinx.Graphics/Gal/OpenGL/OGLEnumConverter.cs

@@ -149,8 +149,8 @@ namespace Ryujinx.Graphics.Gal.OpenGL
                 case GalImageFormat.R32          | GalImageFormat.Sfloat: return (PixelInternalFormat.R32f,         PixelFormat.Red,         PixelType.Float);
                 case GalImageFormat.R32          | GalImageFormat.Sint:   return (PixelInternalFormat.R32i,         PixelFormat.Red,         PixelType.Int);
                 case GalImageFormat.R32          | GalImageFormat.Uint:   return (PixelInternalFormat.R32ui,        PixelFormat.Red,         PixelType.UnsignedInt);
-                case GalImageFormat.A1R5G5B5     | GalImageFormat.Unorm:  return (PixelInternalFormat.Rgb5A1,       PixelFormat.Rgba,        PixelType.UnsignedShort5551);
+                case GalImageFormat.A1R5G5B5     | GalImageFormat.Unorm:  return (PixelInternalFormat.Rgb5A1,       PixelFormat.Rgba,        PixelType.UnsignedShort1555Reversed);
-                case GalImageFormat.B5G6R5       | GalImageFormat.Unorm:  return (PixelInternalFormat.Rgba,         PixelFormat.Rgb,         PixelType.UnsignedShort565);
+                case GalImageFormat.B5G6R5       | GalImageFormat.Unorm:  return (PixelInternalFormat.Rgba,         PixelFormat.Rgb,         PixelType.UnsignedShort565Reversed);
                 case GalImageFormat.R16G16       | GalImageFormat.Sfloat: return (PixelInternalFormat.Rg16f,        PixelFormat.Rg,          PixelType.HalfFloat);
                 case GalImageFormat.R16G16       | GalImageFormat.Sint:   return (PixelInternalFormat.Rg16i,        PixelFormat.RgInteger,   PixelType.Short);
                 case GalImageFormat.R16G16       | GalImageFormat.Snorm:  return (PixelInternalFormat.Rg16Snorm,    PixelFormat.Rg,          PixelType.Byte);

Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs

@@ -126,6 +126,11 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
             BindVertexLayout(New);
 
+            if (New.FramebufferSrgb != Old.FramebufferSrgb)
+            {
+                Enable(EnableCap.FramebufferSrgb, New.FramebufferSrgb);
+            }
+
             if (New.FlipX != Old.FlipX || New.FlipY != Old.FlipY || New.Instance != Old.Instance)
             {
                 Shader.SetExtraData(New.FlipX, New.FlipY, New.Instance);
@@ -337,6 +342,12 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
                 foreach (GalVertexAttrib Attrib in Binding.Attribs)
                 {
+                    //Skip uninitialized attributes.
+                    if (Attrib.Size == 0)
+                    {
+                        continue;
+                    }
+
                     GL.EnableVertexAttribArray(Attrib.Index);
 
                     GL.BindBuffer(BufferTarget.ArrayBuffer, VboHandle);

Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs

@@ -113,14 +113,14 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             IndexBuffer.ElemSizeLog2 = (int)Format;
         }
 
-        public void DrawArrays(int First, int PrimCount, GalPrimitiveType PrimType)
+        public void DrawArrays(int First, int Count, GalPrimitiveType PrimType)
         {
-            if (PrimCount == 0)
+            if (Count == 0)
             {
                 return;
             }
 
-            GL.DrawArrays(OGLEnumConverter.GetPrimitiveType(PrimType), First, PrimCount);
+            GL.DrawArrays(OGLEnumConverter.GetPrimitiveType(PrimType), First, Count);
         }
 
         public void DrawElements(long IboKey, int First, int VertexBase, GalPrimitiveType PrimType)

Ryujinx.Graphics/Gal/OpenGL/OGLRenderTarget.cs

@@ -15,9 +15,9 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
             public Rect(int X, int Y, int Width, int Height)
             {
-                this.X = X;
+                this.X      = X;
-                this.Y = Y;
+                this.Y      = Y;
-                this.Width = Width;
+                this.Width  = Width;
                 this.Height = Height;
             }
         }
@@ -29,7 +29,6 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
         private OGLTexture Texture;
 
-        private ImageHandler RawTex;
         private ImageHandler ReadTex;
 
         private Rect Viewport;
@@ -64,13 +63,13 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             this.Texture = Texture;
         }
 
-        public void BindColor(long Key, int Attachment)
+        public void BindColor(long Key, int Attachment, GalImage Image)
         {
-            if (Texture.TryGetImage(Key, out ImageHandler Tex))
+            if (Texture.TryGetImageHandler(Key, out ImageHandler CachedImage))
             {
                 EnsureFrameBuffer();
 
-                Attach(ref ColorAttachments[Attachment], Tex.Handle, FramebufferAttachment.ColorAttachment0 + Attachment);
+                Attach(ref ColorAttachments[Attachment], CachedImage.Handle, FramebufferAttachment.ColorAttachment0 + Attachment);
             }
             else
             {
@@ -85,39 +84,38 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             Attach(ref ColorAttachments[Attachment], 0, FramebufferAttachment.ColorAttachment0 + Attachment);
         }
 
-        public void BindZeta(long Key)
+        public void BindZeta(long Key, GalImage Image)
         {
-            if (Texture.TryGetImage(Key, out ImageHandler Tex))
+            if (Texture.TryGetImageHandler(Key, out ImageHandler CachedImage))
             {
                 EnsureFrameBuffer();
 
-                if (Tex.HasDepth && Tex.HasStencil)
+                if (CachedImage.HasDepth && CachedImage.HasStencil)
                 {
-                    if (DepthAttachment   != Tex.Handle ||
+                    if (DepthAttachment   != CachedImage.Handle ||
-                        StencilAttachment != Tex.Handle)
+                        StencilAttachment != CachedImage.Handle)
                     {
                         GL.FramebufferTexture(
                             FramebufferTarget.DrawFramebuffer,
                             FramebufferAttachment.DepthStencilAttachment,
-                            Tex.Handle,
+                            CachedImage.Handle,
                             0);
 
-                        DepthAttachment = Tex.Handle;
+                        DepthAttachment   = CachedImage.Handle;
-
+                        StencilAttachment = CachedImage.Handle;
-                        StencilAttachment = Tex.Handle;
                     }
                 }
-                else if (Tex.HasDepth)
+                else if (CachedImage.HasDepth)
                 {
-                    Attach(ref DepthAttachment, Tex.Handle, FramebufferAttachment.DepthAttachment);
+                    Attach(ref DepthAttachment, CachedImage.Handle, FramebufferAttachment.DepthAttachment);
 
                     Attach(ref StencilAttachment, 0, FramebufferAttachment.StencilAttachment);
                 }
-                else if (Tex.HasStencil)
+                else if (CachedImage.HasStencil)
                 {
                     Attach(ref DepthAttachment, 0, FramebufferAttachment.DepthAttachment);
 
-                    Attach(ref StencilAttachment, Tex.Handle, FramebufferAttachment.StencilAttachment);
+                    Attach(ref StencilAttachment, CachedImage.Handle, FramebufferAttachment.StencilAttachment);
                 }
                 else
                 {
@@ -130,12 +128,25 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             }
         }
 
+        private void Attach(ref int OldHandle, int NewHandle, FramebufferAttachment FbAttachment)
+        {
+            if (OldHandle != NewHandle)
+            {
+                GL.FramebufferTexture(
+                    FramebufferTarget.DrawFramebuffer,
+                    FbAttachment,
+                    NewHandle,
+                    0);
+
+                OldHandle = NewHandle;
+            }
+        }
+
         public void UnbindZeta()
         {
             EnsureFrameBuffer();
 
-            if (DepthAttachment   != 0 ||
+            if (DepthAttachment != 0 || StencilAttachment != 0)
-                StencilAttachment != 0)
             {
                 GL.FramebufferTexture(
                     FramebufferTarget.DrawFramebuffer,
@@ -143,44 +154,14 @@ namespace Ryujinx.Graphics.Gal.OpenGL
                     0,
                     0);
 
-                DepthAttachment = 0;
+                DepthAttachment   = 0;
-
                 StencilAttachment = 0;
             }
         }
 
-        public void BindTexture(long Key, int Index)
-        {
-            if (Texture.TryGetImage(Key, out ImageHandler Tex))
-            {
-                GL.ActiveTexture(TextureUnit.Texture0 + Index);
-
-                GL.BindTexture(TextureTarget.Texture2D, Tex.Handle);
-            }
-        }
-
         public void Set(long Key)
         {
-            if (Texture.TryGetImage(Key, out ImageHandler Tex))
+            Texture.TryGetImageHandler(Key, out ReadTex);
-            {
-                ReadTex = Tex;
-            }
-        }
-
-        public void Set(byte[] Data, int Width, int Height)
-        {
-            if (RawTex == null)
-            {
-                RawTex = new ImageHandler();
-            }
-
-            RawTex.EnsureSetup(new GalImage(Width, Height, RawFormat));
-
-            GL.BindTexture(TextureTarget.Texture2D, RawTex.Handle);
-
-            GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, Width, Height, RawTex.PixelFormat, RawTex.PixelType, Data);
-
-            ReadTex = RawTex;
         }
 
         public void SetMap(int[] Map)
@@ -280,13 +261,15 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             int DstY0 = FlipY ? DstPaddingY : Window.Height - DstPaddingY;
             int DstY1 = FlipY ? Window.Height - DstPaddingY : DstPaddingY;
 
-            if (SrcFb == 0) SrcFb = GL.GenFramebuffer();
-
-            GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, 0);
-
             GL.Viewport(0, 0, Window.Width, Window.Height);
 
+            if (SrcFb == 0)
+            {
+                SrcFb = GL.GenFramebuffer();
+            }
+
             GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, SrcFb);
+            GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, 0);
 
             GL.FramebufferTexture(FramebufferTarget.ReadFramebuffer, FramebufferAttachment.ColorAttachment0, ReadTex.Handle, 0);
 
@@ -298,7 +281,8 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             GL.BlitFramebuffer(
                 SrcX0, SrcY0, SrcX1, SrcY1,
                 DstX0, DstY0, DstX1, DstY1,
-                ClearBufferMask.ColorBufferBit, BlitFramebufferFilter.Linear);
+                ClearBufferMask.ColorBufferBit,
+                BlitFramebufferFilter.Linear);
 
             EnsureFrameBuffer();
         }
@@ -315,110 +299,135 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             int  DstX1,
             int  DstY1)
         {
-            if (Texture.TryGetImage(SrcKey, out ImageHandler SrcTex) &&
+            if (Texture.TryGetImageHandler(SrcKey, out ImageHandler SrcTex) &&
-                Texture.TryGetImage(DstKey, out ImageHandler DstTex))
+                Texture.TryGetImageHandler(DstKey, out ImageHandler DstTex))
             {
-                if (SrcTex.HasColor != DstTex.HasColor ||
+                if (SrcTex.HasColor   != DstTex.HasColor ||
-                    SrcTex.HasDepth != DstTex.HasDepth ||
+                    SrcTex.HasDepth   != DstTex.HasDepth ||
                     SrcTex.HasStencil != DstTex.HasStencil)
                 {
                     throw new NotImplementedException();
                 }
 
+                if (SrcFb == 0)
+                {
+                    SrcFb = GL.GenFramebuffer();
+                }
+
+                if (DstFb == 0)
+                {
+                    DstFb = GL.GenFramebuffer();
+                }
+
+                GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, SrcFb);
+                GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, DstFb);
+
+                FramebufferAttachment Attachment = GetAttachment(SrcTex);
+
+                GL.FramebufferTexture(FramebufferTarget.ReadFramebuffer, Attachment, SrcTex.Handle, 0);
+                GL.FramebufferTexture(FramebufferTarget.DrawFramebuffer, Attachment, DstTex.Handle, 0);
+
+                BlitFramebufferFilter Filter = BlitFramebufferFilter.Nearest;
+
                 if (SrcTex.HasColor)
                 {
-                    CopyTextures(
+                    GL.DrawBuffer(DrawBufferMode.ColorAttachment0);
-                        SrcX0, SrcY0, SrcX1, SrcY1,
+
-                        DstX0, DstY0, DstX1, DstY1,
+                    Filter = BlitFramebufferFilter.Linear;
-                        SrcTex.Handle,
-                        DstTex.Handle,
-                        FramebufferAttachment.ColorAttachment0,
-                        ClearBufferMask.ColorBufferBit,
-                        true);
-                }
-                else if (SrcTex.HasDepth && SrcTex.HasStencil)
-                {
-                    CopyTextures(
-                        SrcX0, SrcY0, SrcX1, SrcY1,
-                        DstX0, DstY0, DstX1, DstY1,
-                        SrcTex.Handle,
-                        DstTex.Handle,
-                        FramebufferAttachment.DepthStencilAttachment,
-                        ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit,
-                        false);
-                }
-                else if (SrcTex.HasDepth)
-                {
-                    CopyTextures(
-                        SrcX0, SrcY0, SrcX1, SrcY1,
-                        DstX0, DstY0, DstX1, DstY1,
-                        SrcTex.Handle,
-                        DstTex.Handle,
-                        FramebufferAttachment.DepthAttachment,
-                        ClearBufferMask.DepthBufferBit,
-                        false);
-                }
-                else if (SrcTex.HasStencil)
-                {
-                    CopyTextures(
-                        SrcX0, SrcY0, SrcX1, SrcY1,
-                        DstX0, DstY0, DstX1, DstY1,
-                        SrcTex.Handle,
-                        DstTex.Handle,
-                        FramebufferAttachment.StencilAttachment,
-                        ClearBufferMask.StencilBufferBit,
-                        false);
-                }
-                else
-                {
-                    throw new InvalidOperationException();
                 }
+
+                ClearBufferMask Mask = GetClearMask(SrcTex);
+
+                GL.Clear(Mask);
+
+                GL.BlitFramebuffer(SrcX0, SrcY0, SrcX1, SrcY1, DstX0, DstY0, DstX1, DstY1, Mask, Filter);
+
+                EnsureFrameBuffer();
             }
         }
 
-        public void GetBufferData(long Key, Action<byte[]> Callback)
+        public void Reinterpret(long Key, GalImage NewImage)
         {
-            if (Texture.TryGetImage(Key, out ImageHandler Tex))
+            if (!Texture.TryGetImage(Key, out GalImage OldImage))
             {
-                byte[] Data = new byte[ImageUtils.GetSize(Tex.Image)];
+                return;
+            }
 
-                GL.BindTexture(TextureTarget.Texture2D, Tex.Handle);
+            if (NewImage.Format == OldImage.Format)
+            {
+                return;
+            }
 
-                GL.GetTexImage(
+            byte[] Data = GetData(Key);
-                    TextureTarget.Texture2D,
-                    0,
-                    Tex.PixelFormat,
-                    Tex.PixelType,
-                    Data);
 
-                Callback(Data);
+            GL.PixelStore(PixelStoreParameter.UnpackRowLength, OldImage.Width);
+
+            Texture.Create(Key, Data, NewImage);
+
+            GL.PixelStore(PixelStoreParameter.UnpackRowLength, 0);
+        }
+
+        public byte[] GetData(long Key)
+        {
+            if (!Texture.TryGetImageHandler(Key, out ImageHandler CachedImage))
+            {
+                return null;
+            }
+
+            if (SrcFb == 0)
+            {
+                SrcFb = GL.GenFramebuffer();
+            }
+
+            GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, SrcFb);
+
+            FramebufferAttachment Attachment = GetAttachment(CachedImage);
+
+            GL.FramebufferTexture(FramebufferTarget.ReadFramebuffer, Attachment, CachedImage.Handle, 0);
+
+            int Size = ImageUtils.GetSize(CachedImage.Image);
+
+            byte[] Data = new byte[Size];
+
+            int Width  = CachedImage.Width;
+            int Height = CachedImage.Height;
+
+            (_, PixelFormat Format, PixelType Type) = OGLEnumConverter.GetImageFormat(CachedImage.Format);
+
+            GL.ReadPixels(0, 0, Width, Height, Format, Type, Data);
+
+            return Data;
+        }
+
+        private static FramebufferAttachment GetAttachment(ImageHandler CachedImage)
+        {
+            if (CachedImage.HasColor)
+            {
+                return FramebufferAttachment.ColorAttachment0;
+            }
+            else if (CachedImage.HasDepth && CachedImage.HasStencil)
+            {
+                return FramebufferAttachment.DepthStencilAttachment;
+            }
+            else if (CachedImage.HasDepth)
+            {
+                return FramebufferAttachment.DepthAttachment;
+            }
+            else if (CachedImage.HasStencil)
+            {
+                return FramebufferAttachment.StencilAttachment;
+            }
+            else
+            {
+                throw new InvalidOperationException();
             }
         }
 
-        public void SetBufferData(
+        private static ClearBufferMask GetClearMask(ImageHandler CachedImage)
-            long             Key,
-            int              Width,
-            int              Height,
-            byte[]           Buffer)
         {
-            if (Texture.TryGetImage(Key, out ImageHandler Tex))
+            return (CachedImage.HasColor   ? ClearBufferMask.ColorBufferBit   : 0) |
-            {
+                   (CachedImage.HasDepth   ? ClearBufferMask.DepthBufferBit   : 0) |
-                GL.BindTexture(TextureTarget.Texture2D, Tex.Handle);
+                   (CachedImage.HasStencil ? ClearBufferMask.StencilBufferBit : 0);
-
-                const int Level  = 0;
-                const int Border = 0;
-
-                GL.TexImage2D(
-                    TextureTarget.Texture2D,
-                    Level,
-                    Tex.InternalFormat,
-                    Width,
-                    Height,
-                    Border,
-                    Tex.PixelFormat,
-                    Tex.PixelType,
-                    Buffer);
-            }
         }
 
         private void EnsureFrameBuffer()
@@ -430,68 +439,5 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
             GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, DummyFrameBuffer);
         }
-
-        private void Attach(ref int OldHandle, int NewHandle, FramebufferAttachment FbAttachment)
-        {
-            if (OldHandle != NewHandle)
-            {
-                GL.FramebufferTexture(
-                    FramebufferTarget.DrawFramebuffer,
-                    FbAttachment,
-                    NewHandle,
-                    0);
-
-                OldHandle = NewHandle;
-            }
-        }
-
-        private void CopyTextures(
-            int SrcX0,
-            int SrcY0,
-            int SrcX1,
-            int SrcY1,
-            int DstX0,
-            int DstY0,
-            int DstX1,
-            int DstY1,
-            int SrcTexture,
-            int DstTexture,
-            FramebufferAttachment Attachment,
-            ClearBufferMask Mask,
-            bool Color)
-        {
-            if (SrcFb == 0) SrcFb = GL.GenFramebuffer();
-            if (DstFb == 0) DstFb = GL.GenFramebuffer();
-
-            GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, SrcFb);
-            GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, DstFb);
-
-            GL.FramebufferTexture(
-                FramebufferTarget.ReadFramebuffer,
-                Attachment,
-                SrcTexture,
-                0);
-
-            GL.FramebufferTexture(
-                FramebufferTarget.DrawFramebuffer,
-                Attachment,
-                DstTexture,
-                0);
-
-            if (Color)
-            {
-                GL.DrawBuffer(DrawBufferMode.ColorAttachment0);
-            }
-
-            GL.Clear(Mask);
-
-            GL.BlitFramebuffer(
-                SrcX0, SrcY0, SrcX1, SrcY1,
-                DstX0, DstY0, DstX1, DstY1,
-                Mask,
-                Color ? BlitFramebufferFilter.Linear : BlitFramebufferFilter.Nearest);
-
-            EnsureFrameBuffer();
-        }
     }
 }

Ryujinx.Graphics/Gal/OpenGL/OGLTexture.cs

@@ -28,17 +28,65 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             GL.DeleteTexture(CachedImage.Handle);
         }
 
-        public void Create(long Key, byte[] Data, GalImage Image)
+        public void Create(long Key, int Size, GalImage Image)
         {
             int Handle = GL.GenTexture();
 
-            TextureCache.AddOrUpdate(Key, new ImageHandler(Handle, Image), (uint)Data.Length);
-
             GL.BindTexture(TextureTarget.Texture2D, Handle);
 
             const int Level  = 0; //TODO: Support mipmap textures.
             const int Border = 0;
 
+            TextureCache.AddOrUpdate(Key, new ImageHandler(Handle, Image), (uint)Size);
+
+            GalImageFormat TypeLess = Image.Format & GalImageFormat.FormatMask;
+
+            bool IsASTC = TypeLess >= GalImageFormat.ASTC_BEGIN && TypeLess <= GalImageFormat.ASTC_END;
+
+            if (ImageUtils.IsCompressed(Image.Format) && !IsASTC)
+            {
+                InternalFormat InternalFmt = OGLEnumConverter.GetCompressedImageFormat(Image.Format);
+
+                GL.CompressedTexImage2D(
+                    TextureTarget.Texture2D,
+                    Level,
+                    InternalFmt,
+                    Image.Width,
+                    Image.Height,
+                    Border,
+                    Size,
+                    IntPtr.Zero);
+            }
+            else
+            {
+                (PixelInternalFormat InternalFmt,
+                 PixelFormat         Format,
+                 PixelType           Type) = OGLEnumConverter.GetImageFormat(Image.Format);
+
+                GL.TexImage2D(
+                    TextureTarget.Texture2D,
+                    Level,
+                    InternalFmt,
+                    Image.Width,
+                    Image.Height,
+                    Border,
+                    Format,
+                    Type,
+                    IntPtr.Zero);
+            }
+        }
+
+        public void Create(long Key, byte[] Data, GalImage Image)
+        {
+            int Handle = GL.GenTexture();
+
+            GL.BindTexture(TextureTarget.Texture2D, Handle);
+
+            const int Level  = 0; //TODO: Support mipmap textures.
+            const int Border = 0;
+
+            TextureCache.AddOrUpdate(Key, new ImageHandler(Handle, Image), (uint)Data.Length);
+
             GalImageFormat TypeLess = Image.Format & GalImageFormat.FormatMask;
 
             bool IsASTC = TypeLess >= GalImageFormat.ASTC_BEGIN && TypeLess <= GalImageFormat.ASTC_END;
@@ -62,8 +110,8 @@ namespace Ryujinx.Graphics.Gal.OpenGL
                 //TODO: Use KHR_texture_compression_astc_hdr when available
                 if (IsASTC)
                 {
-                    int TextureBlockWidth  = GetAstcBlockWidth(Image.Format);
+                    int TextureBlockWidth  = ImageUtils.GetBlockWidth(Image.Format);
-                    int TextureBlockHeight = GetAstcBlockHeight(Image.Format);
+                    int TextureBlockHeight = ImageUtils.GetBlockHeight(Image.Format);
 
                     Data = ASTCDecoder.DecodeToRGBA8888(
                         Data,
@@ -85,12 +133,14 @@ namespace Ryujinx.Graphics.Gal.OpenGL
                     Image.Format = GalImageFormat.R8G8 | (Image.Format & GalImageFormat.TypeMask);
                 }
 
-                (PixelInternalFormat InternalFormat, PixelFormat Format, PixelType Type) = OGLEnumConverter.GetImageFormat(Image.Format);
+                (PixelInternalFormat InternalFmt,
+                 PixelFormat         Format,
+                 PixelType           Type) = OGLEnumConverter.GetImageFormat(Image.Format);
 
                 GL.TexImage2D(
                     TextureTarget.Texture2D,
                     Level,
-                    InternalFormat,
+                    InternalFmt,
                     Image.Width,
                     Image.Height,
                     Border,
@@ -98,31 +148,23 @@ namespace Ryujinx.Graphics.Gal.OpenGL
                     Type,
                     Data);
             }
-
-            int SwizzleR = (int)OGLEnumConverter.GetTextureSwizzle(Image.XSource);
-            int SwizzleG = (int)OGLEnumConverter.GetTextureSwizzle(Image.YSource);
-            int SwizzleB = (int)OGLEnumConverter.GetTextureSwizzle(Image.ZSource);
-            int SwizzleA = (int)OGLEnumConverter.GetTextureSwizzle(Image.WSource);
-
-            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleR, SwizzleR);
-            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleG, SwizzleG);
-            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleB, SwizzleB);
-            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleA, SwizzleA);
         }
 
-        public void CreateFb(long Key, long Size, GalImage Image)
+        public bool TryGetImage(long Key, out GalImage Image)
         {
-            if (!TryGetImage(Key, out ImageHandler CachedImage))
+            if (TextureCache.TryGetValue(Key, out ImageHandler CachedImage))
             {
-                CachedImage = new ImageHandler();
+                Image = CachedImage.Image;
 
-                TextureCache.AddOrUpdate(Key, CachedImage, Size);
+                return true;
             }
 
-            CachedImage.EnsureSetup(Image);
+            Image = default(GalImage);
+
+            return false;
         }
 
-        public bool TryGetImage(long Key, out ImageHandler CachedImage)
+        public bool TryGetImageHandler(long Key, out ImageHandler CachedImage)
         {
             if (TextureCache.TryGetValue(Key, out CachedImage))
             {
@@ -134,76 +176,23 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             return false;
         }
 
-        private static int GetAstcBlockWidth(GalImageFormat Format)
+        public void Bind(long Key, int Index, GalImage Image)
-        {
-            switch (Format)
-            {
-                case GalImageFormat.ASTC_4x4   | GalImageFormat.Unorm: return 4;
-                case GalImageFormat.ASTC_5x5   | GalImageFormat.Unorm: return 5;
-                case GalImageFormat.ASTC_6x6   | GalImageFormat.Unorm: return 6;
-                case GalImageFormat.ASTC_8x8   | GalImageFormat.Unorm: return 8;
-                case GalImageFormat.ASTC_10x10 | GalImageFormat.Unorm: return 10;
-                case GalImageFormat.ASTC_12x12 | GalImageFormat.Unorm: return 12;
-                case GalImageFormat.ASTC_5x4   | GalImageFormat.Unorm: return 5;
-                case GalImageFormat.ASTC_6x5   | GalImageFormat.Unorm: return 6;
-                case GalImageFormat.ASTC_8x6   | GalImageFormat.Unorm: return 8;
-                case GalImageFormat.ASTC_10x8  | GalImageFormat.Unorm: return 10;
-                case GalImageFormat.ASTC_12x10 | GalImageFormat.Unorm: return 12;
-                case GalImageFormat.ASTC_8x5   | GalImageFormat.Unorm: return 8;
-                case GalImageFormat.ASTC_10x5  | GalImageFormat.Unorm: return 10;
-                case GalImageFormat.ASTC_10x6  | GalImageFormat.Unorm: return 10;
-            }
-
-            throw new ArgumentException(nameof(Format));
-        }
-
-        private static int GetAstcBlockHeight(GalImageFormat Format)
-        {
-            switch (Format)
-            {
-                case GalImageFormat.ASTC_4x4   | GalImageFormat.Unorm: return 4;
-                case GalImageFormat.ASTC_5x5   | GalImageFormat.Unorm: return 5;
-                case GalImageFormat.ASTC_6x6   | GalImageFormat.Unorm: return 6;
-                case GalImageFormat.ASTC_8x8   | GalImageFormat.Unorm: return 8;
-                case GalImageFormat.ASTC_10x10 | GalImageFormat.Unorm: return 10;
-                case GalImageFormat.ASTC_12x12 | GalImageFormat.Unorm: return 12;
-                case GalImageFormat.ASTC_5x4   | GalImageFormat.Unorm: return 4;
-                case GalImageFormat.ASTC_6x5   | GalImageFormat.Unorm: return 5;
-                case GalImageFormat.ASTC_8x6   | GalImageFormat.Unorm: return 6;
-                case GalImageFormat.ASTC_10x8  | GalImageFormat.Unorm: return 8;
-                case GalImageFormat.ASTC_12x10 | GalImageFormat.Unorm: return 10;
-                case GalImageFormat.ASTC_8x5   | GalImageFormat.Unorm: return 5;
-                case GalImageFormat.ASTC_10x5  | GalImageFormat.Unorm: return 5;
-                case GalImageFormat.ASTC_10x6  | GalImageFormat.Unorm: return 6;
-            }
-
-            throw new ArgumentException(nameof(Format));
-        }
-
-        public bool TryGetCachedTexture(long Key, long DataSize, out GalImage Image)
-        {
-            if (TextureCache.TryGetSize(Key, out long Size) && Size == DataSize)
-            {
-                if (TextureCache.TryGetValue(Key, out ImageHandler CachedImage))
-                {
-                    Image = CachedImage.Image;
-
-                    return true;
-                }
-            }
-
-            Image = default(GalImage);
-
-            return false;
-        }
-
-        public void Bind(long Key, int Index)
         {
             if (TextureCache.TryGetValue(Key, out ImageHandler CachedImage))
             {
                 GL.ActiveTexture(TextureUnit.Texture0 + Index);
 
                 GL.BindTexture(TextureTarget.Texture2D, CachedImage.Handle);
+
+                int[] SwizzleRgba = new int[]
+                {
+                    (int)OGLEnumConverter.GetTextureSwizzle(Image.XSource),
+                    (int)OGLEnumConverter.GetTextureSwizzle(Image.YSource),
+                    (int)OGLEnumConverter.GetTextureSwizzle(Image.ZSource),
+                    (int)OGLEnumConverter.GetTextureSwizzle(Image.WSource)
+                };
+
+                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleRgba, SwizzleRgba);
             }
         }
 

Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs

@@ -641,6 +641,7 @@ namespace Ryujinx.Graphics.Gal.Shader
 
                     default:
                         SB.AppendLine(Identation + GetSrcExpr(Op, true) + ";");
+
                         break;
                 }
             }

Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs

@@ -6,32 +6,32 @@ namespace Ryujinx.Graphics.Gal.Shader
 {
     static partial class ShaderDecode
     {
-        public static void Bfe_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Bfe_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitBfe(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Bfe_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Bfe_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitBfe(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Bfe_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Bfe_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitBfe(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fadd_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fadd_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFadd(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fadd_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fadd_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFadd(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fadd_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fadd_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Gpr8();
             ShaderIrNode OperB = OpCode.Immf32_20();
@@ -49,47 +49,47 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Fadd_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fadd_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFadd(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Ffma_CR(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ffma_CR(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFfma(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Ffma_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ffma_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFfma(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Ffma_RC(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ffma_RC(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFfma(Block, OpCode, ShaderOper.RC);
         }
 
-        public static void Ffma_RR(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ffma_RR(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFfma(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fmnmx_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmnmx_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmnmx(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fmnmx_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmnmx_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmnmx(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fmnmx_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmnmx_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmnmx(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fmul_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmul_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Gpr8();
             ShaderIrNode OperB = OpCode.Immf32_20();
@@ -99,62 +99,62 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Fmul_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmul_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmul(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fmul_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmul_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmul(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fmul_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fmul_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFmul(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fset_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fset_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFset(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fset_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fset_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFset(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fset_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fset_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFset(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Fsetp_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fsetp_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFsetp(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Fsetp_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fsetp_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFsetp(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Fsetp_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Fsetp_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitFsetp(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Iadd_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Iadd_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Iadd_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Gpr8();
             ShaderIrNode OperB = OpCode.Imm32_20();
@@ -168,42 +168,42 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Iadd_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Iadd3_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd3_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd3(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Iadd3_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd3_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd3(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Iadd3_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iadd3_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIadd3(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Imnmx_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Imnmx_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitImnmx(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Imnmx_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Imnmx_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitImnmx(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Imnmx_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Imnmx_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitImnmx(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Ipa(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ipa(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Abuf28();
             ShaderIrNode OperB = OpCode.Gpr20();
@@ -217,52 +217,52 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Iscadd_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iscadd_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIscadd(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Iscadd_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iscadd_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIscadd(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Iscadd_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iscadd_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIscadd(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Iset_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iset_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIset(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Iset_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iset_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIset(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Iset_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Iset_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIset(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Isetp_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Isetp_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIsetp(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Isetp_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Isetp_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIsetp(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Isetp_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Isetp_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitIsetp(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Lop_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Lop_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             int SubOp = OpCode.Read(53, 3);
 
@@ -296,22 +296,22 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void Lop_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Lop_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitLop(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Lop_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Lop_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitLop(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Lop_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Lop_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitLop(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Mufu(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mufu(ShaderIrBlock Block, long OpCode, int Position)
         {
             int SubOp = OpCode.Read(20, 0xf);
 
@@ -340,7 +340,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));
         }
 
-        public static void Psetp(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Psetp(ShaderIrBlock Block, long OpCode, int Position)
         {
             bool NegA = OpCode.Read(15);
             bool NegB = OpCode.Read(32);
@@ -394,47 +394,47 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op)));
         }
 
-        public static void Rro_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Rro_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitRro(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Rro_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Rro_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitRro(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void Rro_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Rro_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitRro(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Shl_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shl_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.CR, ShaderIrInst.Lsl);
         }
 
-        public static void Shl_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shl_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.Imm, ShaderIrInst.Lsl);
         }
 
-        public static void Shl_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shl_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.RR, ShaderIrInst.Lsl);
         }
 
-        public static void Shr_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shr_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.CR, GetShrInst(OpCode));
         }
 
-        public static void Shr_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shr_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.Imm, GetShrInst(OpCode));
         }
 
-        public static void Shr_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Shr_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitAluBinary(Block, OpCode, ShaderOper.RR, GetShrInst(OpCode));
         }
@@ -446,7 +446,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             return Signed ? ShaderIrInst.Asr : ShaderIrInst.Lsr;
         }
 
-        public static void Vmad(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Vmad(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperA = OpCode.Gpr8();
 
@@ -481,22 +481,22 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Final)));
         }
 
-        public static void Xmad_CR(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Xmad_CR(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitXmad(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Xmad_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Xmad_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitXmad(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Xmad_RC(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Xmad_RC(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitXmad(Block, OpCode, ShaderOper.RC);
         }
 
-        public static void Xmad_RR(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Xmad_RR(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitXmad(Block, OpCode, ShaderOper.RR);
         }

Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs

@@ -1,12 +1,10 @@
 using System;
 
-using static Ryujinx.Graphics.Gal.Shader.ShaderDecodeHelper;
-
 namespace Ryujinx.Graphics.Gal.Shader
 {
     static partial class ShaderDecode
     {
-        public static void Bra(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Bra(ShaderIrBlock Block, long OpCode, int Position)
         {
             if ((OpCode & 0x20) != 0)
             {
@@ -15,14 +13,12 @@ namespace Ryujinx.Graphics.Gal.Shader
                 throw new NotImplementedException();
             }
 
-            int Target = OpCode.Branch();
+            ShaderIrOperImm Imm = new ShaderIrOperImm(Position + OpCode.Branch());
-
-            ShaderIrOperImm Imm = new ShaderIrOperImm(Target);
 
             Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Bra, Imm)));
         }
 
-        public static void Exit(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Exit(ShaderIrBlock Block, long OpCode, int Position)
         {
             int CCode = (int)OpCode & 0x1f;
 
@@ -31,15 +27,14 @@ namespace Ryujinx.Graphics.Gal.Shader
             {
                 Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Exit)));
             }
-
         }
 
-        public static void Kil(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Kil(ShaderIrBlock Block, long OpCode, int Position)
         {
             Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Kil)));
         }
 
-        public static void Ssy(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ssy(ShaderIrBlock Block, long OpCode, int Position)
         {
             if ((OpCode & 0x20) != 0)
             {
@@ -48,19 +43,14 @@ namespace Ryujinx.Graphics.Gal.Shader
                 throw new NotImplementedException();
             }
 
-            int Offset = OpCode.Branch();
+            ShaderIrOperImm Imm = new ShaderIrOperImm(Position + OpCode.Branch());
-
-            int Target = (int)(Position + Offset);
-
-            ShaderIrOperImm Imm = new ShaderIrOperImm(Target);
 
             Block.AddNode(new ShaderIrOp(ShaderIrInst.Ssy, Imm));
         }
 
-        public static void Sync(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Sync(ShaderIrBlock Block, long OpCode, int Position)
         {
             //TODO: Implement Sync condition codes
-
             Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Sync)));
         }
     }

Ryujinx.Graphics/Gal/Shader/ShaderDecodeFunc.cs

@@ -1,4 +1,4 @@
 namespace Ryujinx.Graphics.Gal.Shader
 {
-    delegate void ShaderDecodeFunc(ShaderIrBlock Block, long OpCode, long Position);
+    delegate void ShaderDecodeFunc(ShaderIrBlock Block, long OpCode, int Position);
 }

Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs

@@ -1,5 +1,3 @@
-using System;
-
 namespace Ryujinx.Graphics.Gal.Shader
 {
     static class ShaderDecodeHelper

Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs

@@ -31,7 +31,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             { RGB_, RG_A, R_BA, _GBA, RGBA, ____, ____, ____ }
         };
 
-        public static void Ld_A(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ld_A(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode[] Opers = OpCode.Abuf20();
 
@@ -50,7 +50,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void Ld_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Ld_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             int CbufPos   = OpCode.Read(22, 0x3fff);
             int CbufIndex = OpCode.Read(36, 0x1f);
@@ -97,7 +97,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void St_A(ShaderIrBlock Block, long OpCode, long Position)
+        public static void St_A(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode[] Opers = OpCode.Abuf20();
 
@@ -113,7 +113,7 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void Texq(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Texq(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrNode OperD = OpCode.Gpr0();
             ShaderIrNode OperA = OpCode.Gpr8();
@@ -132,12 +132,12 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperA, Op1))); //Is this right?
         }
 
-        public static void Tex(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Tex(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitTex(Block, OpCode, GprHandle: false);
         }
 
-        public static void Tex_B(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Tex_B(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitTex(Block, OpCode, GprHandle: true);
         }
@@ -202,12 +202,12 @@ namespace Ryujinx.Graphics.Gal.Shader
             }
         }
 
-        public static void Texs(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Texs(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitTexs(Block, OpCode, ShaderIrInst.Texs);
         }
 
-        public static void Tlds(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Tlds(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitTexs(Block, OpCode, ShaderIrInst.Txlf);
         }

Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs

@@ -25,67 +25,67 @@ namespace Ryujinx.Graphics.Gal.Shader
             F64 = 3
         }
 
-        public static void F2f_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2f_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2f(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void F2f_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2f_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2f(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void F2f_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2f_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2f(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void F2i_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2i_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2i(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void F2i_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2i_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2i(Block, OpCode, ShaderOper.Immf);
         }
 
-        public static void F2i_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void F2i_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitF2i(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void I2f_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2f_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2f(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void I2f_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2f_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2f(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void I2f_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2f_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2f(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void I2i_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2i_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2i(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void I2i_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2i_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2i(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void I2i_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void I2i_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitI2i(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Isberd(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Isberd(ShaderIrBlock Block, long OpCode, int Position)
         {
             //This instruction seems to be used to translate from an address to a vertex index in a GS
             //Stub it as such
@@ -95,50 +95,50 @@ namespace Ryujinx.Graphics.Gal.Shader
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OpCode.Gpr8())));
         }
 
-        public static void Mov_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrOperCbuf Cbuf = OpCode.Cbuf34();
 
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Cbuf)));
         }
 
-        public static void Mov_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrOperImm Imm = OpCode.Imm19_20();
 
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Imm)));
         }
 
-        public static void Mov_I32(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_I32(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrOperImm Imm = OpCode.Imm32_20();
 
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Imm)));
         }
 
-        public static void Mov_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             ShaderIrOperGpr Gpr = OpCode.Gpr20();
 
             Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Gpr)));
         }
 
-        public static void Sel_C(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Sel_C(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitSel(Block, OpCode, ShaderOper.CR);
         }
 
-        public static void Sel_I(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Sel_I(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitSel(Block, OpCode, ShaderOper.Imm);
         }
 
-        public static void Sel_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Sel_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             EmitSel(Block, OpCode, ShaderOper.RR);
         }
 
-        public static void Mov_S(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Mov_S(ShaderIrBlock Block, long OpCode, int Position)
         {
             Block.AddNode(new ShaderIrCmnt("Stubbed."));
 

Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs

@@ -1,10 +1,8 @@
-using static Ryujinx.Graphics.Gal.Shader.ShaderDecodeHelper;
+namespace Ryujinx.Graphics.Gal.Shader
-
-namespace Ryujinx.Graphics.Gal.Shader
 {
     static partial class ShaderDecode
     {
-        public static void Out_R(ShaderIrBlock Block, long OpCode, long Position)
+        public static void Out_R(ShaderIrBlock Block, long OpCode, int Position)
         {
             //TODO: Those registers have to be used for something
             ShaderIrOperGpr Gpr0  = OpCode.Gpr0();

Ryujinx.Graphics/Gal/Shader/ShaderDecoder.cs

@@ -10,12 +10,14 @@ namespace Ryujinx.Graphics.Gal.Shader
 
         public static ShaderIrBlock[] Decode(IGalMemory Memory, long Start)
         {
-            Dictionary<long, ShaderIrBlock> Visited    = new Dictionary<long, ShaderIrBlock>();
+            Dictionary<int, ShaderIrBlock> Visited    = new Dictionary<int, ShaderIrBlock>();
-            Dictionary<long, ShaderIrBlock> VisitedEnd = new Dictionary<long, ShaderIrBlock>();
+            Dictionary<int, ShaderIrBlock> VisitedEnd = new Dictionary<int, ShaderIrBlock>();
 
             Queue<ShaderIrBlock> Blocks = new Queue<ShaderIrBlock>();
 
-            ShaderIrBlock Enqueue(long Position, ShaderIrBlock Source = null)
+            long Beginning = Start + HeaderSize;
+
+            ShaderIrBlock Enqueue(int Position, ShaderIrBlock Source = null)
             {
                 if (!Visited.TryGetValue(Position, out ShaderIrBlock Output))
                 {
@@ -34,13 +36,13 @@ namespace Ryujinx.Graphics.Gal.Shader
                 return Output;
             }
 
-            ShaderIrBlock Entry = Enqueue(Start + HeaderSize);
+            ShaderIrBlock Entry = Enqueue(0);
 
             while (Blocks.Count > 0)
             {
                 ShaderIrBlock Current = Blocks.Dequeue();
 
-                FillBlock(Memory, Current, Start + HeaderSize);
+                FillBlock(Memory, Current, Beginning);
 
                 //Set child blocks. "Branch" is the block the branch instruction
                 //points to (when taken), "Next" is the block at the next address,
@@ -54,20 +56,18 @@ namespace Ryujinx.Graphics.Gal.Shader
 
                     if (InnerOp?.Inst == ShaderIrInst.Bra)
                     {
-                        int Offset = ((ShaderIrOperImm)InnerOp.OperandA).Value;
+                        int Target = ((ShaderIrOperImm)InnerOp.OperandA).Value;
-
-                        long Target = Current.EndPosition + Offset;
 
                         Current.Branch = Enqueue(Target, Current);
                     }
 
                     foreach (ShaderIrNode Node in Current.Nodes)
                     {
-                        if (Node is ShaderIrOp CurrOp && CurrOp.Inst == ShaderIrInst.Ssy)
+                        InnerOp = GetInnermostOp(Node);
-                        {
-                            int Offset = ((ShaderIrOperImm)CurrOp.OperandA).Value;
 
-                            long Target = Offset;
+                        if (InnerOp is ShaderIrOp CurrOp && CurrOp.Inst == ShaderIrInst.Ssy)
+                        {
+                            int Target = ((ShaderIrOperImm)CurrOp.OperandA).Value;
 
                             Current.Branch = Enqueue(Target, Current);
                         }
@@ -112,15 +112,15 @@ namespace Ryujinx.Graphics.Gal.Shader
 
             while (Visited.Count > 0)
             {
-                ulong FirstPos = ulong.MaxValue;
+                uint FirstPos = uint.MaxValue;
 
                 foreach (ShaderIrBlock Block in Visited.Values)
                 {
-                    if (FirstPos > (ulong)Block.Position)
+                    if (FirstPos > (uint)Block.Position)
-                        FirstPos = (ulong)Block.Position;
+                        FirstPos = (uint)Block.Position;
                 }
 
-                ShaderIrBlock Current = Visited[(long)FirstPos];
+                ShaderIrBlock Current = Visited[(int)FirstPos];
 
                 do
                 {
@@ -138,20 +138,20 @@ namespace Ryujinx.Graphics.Gal.Shader
 
         private static void FillBlock(IGalMemory Memory, ShaderIrBlock Block, long Beginning)
         {
-            long Position = Block.Position;
+            int Position = Block.Position;
 
             do
             {
                 //Ignore scheduling instructions, which are written every 32 bytes.
-                if (((Position - Beginning) & 0x1f) == 0)
+                if ((Position & 0x1f) == 0)
                 {
                     Position += 8;
 
                     continue;
                 }
 
-                uint Word0 = (uint)Memory.ReadInt32(Position + 0);
+                uint Word0 = (uint)Memory.ReadInt32(Position + Beginning + 0);
-                uint Word1 = (uint)Memory.ReadInt32(Position + 4);
+                uint Word1 = (uint)Memory.ReadInt32(Position + Beginning + 4);
 
                 Position += 8;
 
@@ -161,7 +161,7 @@ namespace Ryujinx.Graphics.Gal.Shader
 
                 if (AddDbgComments)
                 {
-                    string DbgOpCode = $"0x{(Position - Beginning - 8):x16}: 0x{OpCode:x16} ";
+                    string DbgOpCode = $"0x{(Position - 8):x16}: 0x{OpCode:x16} ";
 
                     DbgOpCode += (Decode?.Method.Name ?? "???");
 
@@ -169,7 +169,7 @@ namespace Ryujinx.Graphics.Gal.Shader
                     {
                         int Offset = ((int)(OpCode >> 20) << 8) >> 8;
 
-                        long Target = Position + Offset - Beginning;
+                        long Target = Position + Offset;
 
                         DbgOpCode += " (0x" + Target.ToString("x16") + ")";
                     }

Ryujinx.Graphics/Gal/Shader/ShaderIrBlock.cs

@@ -4,8 +4,8 @@ namespace Ryujinx.Graphics.Gal.Shader
 {
     class ShaderIrBlock
     {
-        public long Position    { get; set; }
+        public int Position    { get; set; }
-        public long EndPosition { get; set; }
+        public int EndPosition { get; set; }
 
         public ShaderIrBlock Next   { get; set; }
         public ShaderIrBlock Branch { get; set; }
@@ -14,7 +14,7 @@ namespace Ryujinx.Graphics.Gal.Shader
 
         public List<ShaderIrNode> Nodes { get; private set; }
 
-        public ShaderIrBlock(long Position)
+        public ShaderIrBlock(int Position)
         {
             this.Position = Position;
 

Ryujinx.Graphics/GpuResourceManager.cs

@@ -0,0 +1,122 @@
+using Ryujinx.Graphics.Gal;
+using Ryujinx.Graphics.Memory;
+using Ryujinx.Graphics.Texture;
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics
+{
+    public class GpuResourceManager
+    {
+        private NvGpu Gpu;
+
+        private HashSet<long>[] UploadedKeys;
+
+        public GpuResourceManager(NvGpu Gpu)
+        {
+            this.Gpu = Gpu;
+
+            UploadedKeys = new HashSet<long>[(int)NvGpuBufferType.Count];
+
+            for (int Index = 0; Index < UploadedKeys.Length; Index++)
+            {
+                UploadedKeys[Index] = new HashSet<long>();
+            }
+        }
+
+        public void SendColorBuffer(NvGpuVmm Vmm, long Position, int Attachment, GalImage NewImage)
+        {
+            long Size = (uint)ImageUtils.GetSize(NewImage);
+
+            MarkAsCached(Vmm, Position, Size, NvGpuBufferType.Texture);
+
+            bool IsCached = Gpu.Renderer.Texture.TryGetImage(Position, out GalImage CachedImage);
+
+            if (IsCached && CachedImage.SizeMatches(NewImage))
+            {
+                Gpu.Renderer.RenderTarget.Reinterpret(Position, NewImage);
+                Gpu.Renderer.RenderTarget.BindColor(Position, Attachment, NewImage);
+
+                return;
+            }
+
+            Gpu.Renderer.Texture.Create(Position, (int)Size, NewImage);
+
+            Gpu.Renderer.RenderTarget.BindColor(Position, Attachment, NewImage);
+        }
+
+        public void SendZetaBuffer(NvGpuVmm Vmm, long Position, GalImage NewImage)
+        {
+            long Size = (uint)ImageUtils.GetSize(NewImage);
+
+            MarkAsCached(Vmm, Position, Size, NvGpuBufferType.Texture);
+
+            bool IsCached = Gpu.Renderer.Texture.TryGetImage(Position, out GalImage CachedImage);
+
+            if (IsCached && CachedImage.SizeMatches(NewImage))
+            {
+                Gpu.Renderer.RenderTarget.Reinterpret(Position, NewImage);
+                Gpu.Renderer.RenderTarget.BindZeta(Position, NewImage);
+
+                return;
+            }
+
+            Gpu.Renderer.Texture.Create(Position, (int)Size, NewImage);
+
+            Gpu.Renderer.RenderTarget.BindZeta(Position, NewImage);
+        }
+
+        public void SendTexture(NvGpuVmm Vmm, long Position, GalImage NewImage, int TexIndex = -1)
+        {
+            long Size = (uint)ImageUtils.GetSize(NewImage);
+
+            if (!MemoryRegionModified(Vmm, Position, Size, NvGpuBufferType.Texture))
+            {
+                if (Gpu.Renderer.Texture.TryGetImage(Position, out GalImage CachedImage) && CachedImage.SizeMatches(NewImage))
+                {
+                    Gpu.Renderer.RenderTarget.Reinterpret(Position, NewImage);
+
+                    if (TexIndex >= 0)
+                    {
+                        Gpu.Renderer.Texture.Bind(Position, TexIndex, NewImage);
+                    }
+
+                    return;
+                }
+            }
+
+            byte[] Data = ImageUtils.ReadTexture(Vmm, NewImage, Position);
+
+            Gpu.Renderer.Texture.Create(Position, Data, NewImage);
+
+            if (TexIndex >= 0)
+            {
+                Gpu.Renderer.Texture.Bind(Position, TexIndex, NewImage);
+            }
+        }
+
+        private void MarkAsCached(NvGpuVmm Vmm, long Position, long Size, NvGpuBufferType Type)
+        {
+            Vmm.IsRegionModified(Position, Size, Type);
+        }
+
+        private bool MemoryRegionModified(NvGpuVmm Vmm, long Position, long Size, NvGpuBufferType Type)
+        {
+            HashSet<long> Uploaded = UploadedKeys[(int)Type];
+
+            if (!Uploaded.Add(Position))
+            {
+                return false;
+            }
+
+            return Vmm.IsRegionModified(Position, Size, Type);
+        }
+
+        public void ClearPbCache()
+        {
+            for (int Index = 0; Index < UploadedKeys.Length; Index++)
+            {
+                UploadedKeys[Index].Clear();
+            }
+        }
+    }
+}

Ryujinx.Graphics/Memory/NvGpuVmmCache.cs

@@ -1,309 +1,82 @@
 using ChocolArm64.Memory;
 using System;
-using System.Collections.Generic;
 
 namespace Ryujinx.Graphics.Memory
 {
     class NvGpuVmmCache
     {
-        private const long RamSize = 4L * 1024 * 1024 * 1024;
+        private ValueRangeSet<int> CachedRanges;
-
-        private const int MaxCpCount     = 10000;
-        private const int MaxCpTimeDelta = 60000;
-
-        private class CachedPage
-        {
-            private struct Range
-            {
-                public long Start;
-                public long End;
-
-                public Range(long Start, long End)
-                {
-                    this.Start = Start;
-                    this.End = End;
-                }
-            }
-
-            private List<Range>[] Regions;
-
-            private HashSet<long> ResidencyKeys;
-
-            public LinkedListNode<long> Node { get; set; }
-
-            public int Timestamp { get; private set; }
-
-            public CachedPage()
-            {
-                Regions = new List<Range>[(int)NvGpuBufferType.Count];
-
-                for (int Index = 0; Index < Regions.Length; Index++)
-                {
-                    Regions[Index] = new List<Range>();
-                }
-
-                ResidencyKeys = new HashSet<long>();
-            }
-
-            public void AddResidency(long Key)
-            {
-                ResidencyKeys.Add(Key);
-            }
-
-            public void RemoveResidency(HashSet<long>[] Residency, long PageSize)
-            {
-                for (int i = 0; i < (int)NvGpuBufferType.Count; i++)
-                {
-                    foreach (Range Region in Regions[i])
-                    {
-                        foreach (long Key in ResidencyKeys)
-                        {
-                            Residency[Region.Start / PageSize].Remove(Key);
-                        }
-                    }
-                }
-            }
-
-            public bool AddRange(long Start, long End, NvGpuBufferType BufferType)
-            {
-                List<Range> BtRegions = Regions[(int)BufferType];
-
-                for (int Index = 0; Index < BtRegions.Count; Index++)
-                {
-                    Range Rg = BtRegions[Index];
-
-                    if (Start >= Rg.Start && End <= Rg.End)
-                    {
-                        return false;
-                    }
-
-                    if (Start <= Rg.End && Rg.Start <= End)
-                    {
-                        long MinStart = Math.Min(Rg.Start, Start);
-                        long MaxEnd   = Math.Max(Rg.End,   End);
-
-                        BtRegions[Index] = new Range(MinStart, MaxEnd);
-
-                        Timestamp = Environment.TickCount;
-
-                        return true;
-                    }
-                }
-
-                BtRegions.Add(new Range(Start, End));
-
-                Timestamp = Environment.TickCount;
-
-                return true;
-            }
-
-            public int GetTotalCount()
-            {
-                int Count = 0;
-
-                for (int Index = 0; Index < Regions.Length; Index++)
-                {
-                    Count += Regions[Index].Count;
-                }
-
-                return Count;
-            }
-        }
-
-        private Dictionary<long, CachedPage> Cache;
-
-        private LinkedList<long> SortedCache;
-
-        private HashSet<long>[] Residency;
-
-        private long ResidencyPageSize;
-
-        private int CpCount;
 
         public NvGpuVmmCache()
         {
-            Cache = new Dictionary<long, CachedPage>();
+            CachedRanges = new ValueRangeSet<int>();
-
-            SortedCache = new LinkedList<long>();
         }
 
         public bool IsRegionModified(AMemory Memory, NvGpuBufferType BufferType, long PA, long Size)
         {
             (bool[] Modified, long ModifiedCount) = Memory.IsRegionModified(PA, Size);
 
-            PA = Memory.GetPhysicalAddress(PA);
+            //Remove all modified ranges.
-
-            ClearCachedPagesIfNeeded();
-
-            long PageSize = AMemory.PageSize;
-
-            EnsureResidencyInitialized(PageSize);
-
-            bool HasResidents = AddResidency(PA, Size);
-
-            if (!HasResidents && ModifiedCount == 0)
-            {
-                return false;
-            }
-
-            long Mask = PageSize - 1;
-
-            long ResidencyKey = PA;
-
-            long PAEnd = PA + Size;
-
-            bool RegMod = false;
-
             int Index = 0;
 
-            while (PA < PAEnd)
+            long Position = PA & ~NvGpuVmm.PageMask;
+
+            while (ModifiedCount > 0)
             {
-                long Key = PA & ~AMemory.PageMask;
+                if (Modified[Index++])
-
-                long PAPgEnd = Math.Min((PA + AMemory.PageSize) & ~AMemory.PageMask, PAEnd);
-
-                bool IsCached = Cache.TryGetValue(Key, out CachedPage Cp);
-
-                if (IsCached)
                 {
-                    CpCount -= Cp.GetTotalCount();
+                    CachedRanges.Remove(new ValueRange<int>(Position, Position + NvGpuVmm.PageSize));
 
-                    SortedCache.Remove(Cp.Node);
+                    ModifiedCount--;
+                }
+
+                Position += NvGpuVmm.PageSize;
+            }
+
+            //Mask has the bit set for the current resource type.
+            //If the region is not yet present on the list, then a new ValueRange
+            //is directly added with the current resource type as the only bit set.
+            //Otherwise, it just sets the bit for this new resource type on the current mask.
+            int Mask = 1 << (int)BufferType;
+
+            ValueRange<int> NewCached = new ValueRange<int>(PA, PA + Size);
+
+            ValueRange<int>[] Ranges = CachedRanges.GetAllIntersections(NewCached);
+
+            long LastEnd = NewCached.Start;
+
+            long Coverage = 0;
+
+            for (Index = 0; Index < Ranges.Length; Index++)
+            {
+                ValueRange<int> Current = Ranges[Index];
+
+                long RgStart = Math.Max(Current.Start, NewCached.Start);
+                long RgEnd   = Math.Min(Current.End,   NewCached.End);
+
+                if ((Current.Value & Mask) == 0)
+                {
+                    CachedRanges.Add(new ValueRange<int>(RgStart, RgEnd, Current.Value | Mask));
                 }
                 else
                 {
-                    Cp = new CachedPage();
+                    Coverage += RgEnd - RgStart;
-
-                    Cache.Add(Key, Cp);
                 }
 
-                if (Modified[Index++] && IsCached)
+                if (RgStart > LastEnd)
                 {
-                    Cp = new CachedPage();
+                    CachedRanges.Add(new ValueRange<int>(LastEnd, RgStart, Mask));
-
-                    Cache[Key] = Cp;
                 }
 
-                Cp.AddResidency(ResidencyKey);
+                LastEnd = RgEnd;
-
-                Cp.Node = SortedCache.AddLast(Key);
-
-                RegMod |= Cp.AddRange(PA, PAPgEnd, BufferType);
-
-                CpCount += Cp.GetTotalCount();
-
-                PA = PAPgEnd;
             }
 
-            return RegMod;
+            if (LastEnd < NewCached.End)
-        }
-
-        private bool AddResidency(long PA, long Size)
-        {
-            long PageSize = ResidencyPageSize;
-
-            long Mask = PageSize - 1;
-
-            long Key = PA;
-
-            bool ResidentFound = false;
-
-            for (long Cursor = PA & ~Mask; Cursor < ((PA + Size + PageSize - 1) & ~Mask); Cursor += PageSize)
             {
-                long PageIndex = Cursor / PageSize;
+                CachedRanges.Add(new ValueRange<int>(LastEnd, NewCached.End, Mask));
-
-                Residency[PageIndex].Add(Key);
-
-                if (Residency[PageIndex].Count > 1)
-                {
-                    ResidentFound = true;
-                }
             }
 
-            return ResidentFound;
+            return Coverage != Size;
-        }
-
-        private void EnsureResidencyInitialized(long PageSize)
-        {
-            if (Residency == null)
-            {
-                Residency = new HashSet<long>[RamSize / PageSize];
-
-                for (int i = 0; i < Residency.Length; i++)
-                {
-                    Residency[i] = new HashSet<long>();
-                }
-
-                ResidencyPageSize = PageSize;
-            }
-            else
-            {
-                if (ResidencyPageSize != PageSize)
-                {
-                    throw new InvalidOperationException("Tried to change residency page size");
-                }
-            }
-        }
-
-        private void ClearCachedPagesIfNeeded()
-        {
-            if (CpCount <= MaxCpCount)
-            {
-                return;
-            }
-
-            int Timestamp = Environment.TickCount;
-
-            int TimeDelta;
-
-            do
-            {
-                if (!TryPopOldestCachedPageKey(Timestamp, out long Key))
-                {
-                    break;
-                }
-
-                CachedPage Cp = Cache[Key];
-
-                Cp.RemoveResidency(Residency, ResidencyPageSize);
-
-                Cache.Remove(Key);
-
-                CpCount -= Cp.GetTotalCount();
-
-                TimeDelta = RingDelta(Cp.Timestamp, Timestamp);
-            }
-            while (CpCount > (MaxCpCount >> 1) || (uint)TimeDelta > (uint)MaxCpTimeDelta);
-        }
-
-        private bool TryPopOldestCachedPageKey(int Timestamp, out long Key)
-        {
-            LinkedListNode<long> Node = SortedCache.First;
-
-            if (Node == null)
-            {
-                Key = 0;
-
-                return false;
-            }
-
-            SortedCache.Remove(Node);
-
-            Key = Node.Value;
-
-            return true;
-        }
-
-        private int RingDelta(int Old, int New)
-        {
-            if ((uint)New < (uint)Old)
-            {
-                return New + (~Old + 1);
-            }
-            else
-            {
-                return New - Old;
-            }
         }
     }
 }

Ryujinx.Graphics/NvGpu.cs

@@ -1,5 +1,4 @@
 using Ryujinx.Graphics.Gal;
-using Ryujinx.Graphics;
 
 namespace Ryujinx.Graphics
 {
@@ -7,21 +6,27 @@ namespace Ryujinx.Graphics
     {
         public IGalRenderer Renderer { get; private set; }
 
+        public GpuResourceManager ResourceManager { get; private set; }
+
         public NvGpuFifo Fifo { get; private set; }
 
-        public NvGpuEngine2d  Engine2d  { get; private set; }
+        internal NvGpuEngine2d   Engine2d   { get; private set; }
-        public NvGpuEngine3d  Engine3d  { get; private set; }
+        internal NvGpuEngine3d   Engine3d   { get; private set; }
-        public NvGpuEngineDma EngineDma { get; private set; }
+        internal NvGpuEngineM2mf EngineM2mf { get; private set; }
+        internal NvGpuEngineP2mf EngineP2mf { get; private set; }
 
         public NvGpu(IGalRenderer Renderer)
         {
             this.Renderer = Renderer;
 
+            ResourceManager = new GpuResourceManager(this);
+
             Fifo = new NvGpuFifo(this);
 
-            Engine2d  = new NvGpuEngine2d(this);
+            Engine2d   = new NvGpuEngine2d(this);
-            Engine3d  = new NvGpuEngine3d(this);
+            Engine3d   = new NvGpuEngine3d(this);
-            EngineDma = new NvGpuEngineDma(this);
+            EngineM2mf = new NvGpuEngineM2mf(this);
+            EngineP2mf = new NvGpuEngineP2mf(this);
         }
     }
 }

Ryujinx.Graphics/NvGpuBufferType.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.Graphics.Memory
+namespace Ryujinx.Graphics
 {
     public enum NvGpuBufferType
     {

Ryujinx.Graphics/NvGpuEngine.cs

@@ -5,7 +5,7 @@ namespace Ryujinx.Graphics
         _2d     = 0x902d,
         _3d     = 0xb197,
         Compute = 0xb1c0,
-        Kepler  = 0xa140,
+        P2mf    = 0xa140,
-        Dma     = 0xb0b5
+        M2mf    = 0xb0b5
     }
 }

Ryujinx.Graphics/NvGpuEngine2d.cs

@@ -1,7 +1,6 @@
 using Ryujinx.Graphics.Gal;
 using Ryujinx.Graphics.Memory;
 using Ryujinx.Graphics.Texture;
-using System;
 using System.Collections.Generic;
 
 namespace Ryujinx.Graphics
@@ -62,25 +61,25 @@ namespace Ryujinx.Graphics
         {
             CopyOperation Operation = (CopyOperation)ReadRegister(NvGpuEngine2dReg.CopyOperation);
 
+            int  SrcFormat = ReadRegister(NvGpuEngine2dReg.SrcFormat);
             bool SrcLinear = ReadRegister(NvGpuEngine2dReg.SrcLinear) != 0;
             int  SrcWidth  = ReadRegister(NvGpuEngine2dReg.SrcWidth);
             int  SrcHeight = ReadRegister(NvGpuEngine2dReg.SrcHeight);
             int  SrcPitch  = ReadRegister(NvGpuEngine2dReg.SrcPitch);
             int  SrcBlkDim = ReadRegister(NvGpuEngine2dReg.SrcBlockDimensions);
 
+            int  DstFormat = ReadRegister(NvGpuEngine2dReg.DstFormat);
             bool DstLinear = ReadRegister(NvGpuEngine2dReg.DstLinear) != 0;
             int  DstWidth  = ReadRegister(NvGpuEngine2dReg.DstWidth);
             int  DstHeight = ReadRegister(NvGpuEngine2dReg.DstHeight);
             int  DstPitch  = ReadRegister(NvGpuEngine2dReg.DstPitch);
             int  DstBlkDim = ReadRegister(NvGpuEngine2dReg.DstBlockDimensions);
 
-            TextureSwizzle SrcSwizzle = SrcLinear
+            GalImageFormat SrcImgFormat = ImageUtils.ConvertSurface((GalSurfaceFormat)SrcFormat);
-                ? TextureSwizzle.Pitch
+            GalImageFormat DstImgFormat = ImageUtils.ConvertSurface((GalSurfaceFormat)DstFormat);
-                : TextureSwizzle.BlockLinear;
 
-            TextureSwizzle DstSwizzle = DstLinear
+            GalMemoryLayout SrcLayout = GetLayout(SrcLinear);
-                ? TextureSwizzle.Pitch
+            GalMemoryLayout DstLayout = GetLayout(DstLinear);
-                : TextureSwizzle.BlockLinear;
 
             int SrcBlockHeight = 1 << ((SrcBlkDim >> 4) & 0xf);
             int DstBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf);
@@ -91,91 +90,41 @@ namespace Ryujinx.Graphics
             long SrcKey = Vmm.GetPhysicalAddress(SrcAddress);
             long DstKey = Vmm.GetPhysicalAddress(DstAddress);
 
-            bool IsSrcFb = Gpu.Engine3d.IsFrameBufferPosition(SrcKey);
+            GalImage SrcTexture = new GalImage(
-            bool IsDstFb = Gpu.Engine3d.IsFrameBufferPosition(DstKey);
+                SrcWidth,
+                SrcHeight, 1,
+                SrcBlockHeight,
+                SrcLayout,
+                SrcImgFormat);
 
-            TextureInfo SrcTexture()
+            GalImage DstTexture = new GalImage(
-            {
+                DstWidth,
-                return new TextureInfo(
+                DstHeight, 1,
-                    SrcAddress,
+                DstBlockHeight,
-                    SrcWidth,
+                DstLayout,
-                    SrcHeight,
+                DstImgFormat);
-                    SrcPitch,
-                    SrcBlockHeight, 1,
-                    SrcSwizzle,
-                    GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm);
-            }
 
-            TextureInfo DstTexture()
+            Gpu.ResourceManager.SendTexture(Vmm, SrcKey, SrcTexture);
-            {
+            Gpu.ResourceManager.SendTexture(Vmm, DstKey, DstTexture);
-                return new TextureInfo(
-                    DstAddress,
-                    DstWidth,
-                    DstHeight,
-                    DstPitch,
-                    DstBlockHeight, 1,
-                    DstSwizzle,
-                    GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm);
-            }
 
-            //TODO: fb -> fb copies, tex -> fb copies, formats other than RGBA8,
+            Gpu.Renderer.RenderTarget.Copy(
-            //make it throw for unimpl stuff (like the copy mode)...
+                SrcKey,
-            if (IsSrcFb && IsDstFb)
+                DstKey,
-            {
+                0,
-                //Frame Buffer -> Frame Buffer copy.
+                0,
-                Gpu.Renderer.RenderTarget.Copy(
+                SrcWidth,
-                    SrcKey,
+                SrcHeight,
-                    DstKey,
+                0,
-                    0,
+                0,
-                    0,
+                DstWidth,
-                    SrcWidth,
+                DstHeight);
-                    SrcHeight,
+        }
-                    0,
-                    0,
-                    DstWidth,
-                    DstHeight);
-            }
-            if (IsSrcFb)
-            {
-                //Frame Buffer -> Texture copy.
-                Gpu.Renderer.RenderTarget.GetBufferData(SrcKey, (byte[] Buffer) =>
-                {
-                    TextureInfo Src = SrcTexture();
-                    TextureInfo Dst = DstTexture();
 
-                    if (Src.Width  != Dst.Width ||
+        private static GalMemoryLayout GetLayout(bool Linear)
-                        Src.Height != Dst.Height)
+        {
-                    {
+            return Linear
-                        throw new NotImplementedException("Texture resizing is not supported");
+                ? GalMemoryLayout.Pitch
-                    }
+                : GalMemoryLayout.BlockLinear;
-
-                    TextureWriter.Write(Vmm, Dst, Buffer);
-                });
-            }
-            else if (IsDstFb)
-            {
-                byte[] Buffer = TextureReader.Read(Vmm, SrcTexture());
-
-                Gpu.Renderer.RenderTarget.SetBufferData(
-                    DstKey,
-                    DstWidth,
-                    DstHeight,
-                    Buffer);
-            }
-            else
-            {
-                //Texture -> Texture copy.
-                TextureInfo Src = SrcTexture();
-                TextureInfo Dst = DstTexture();
-
-                if (Src.Width  != Dst.Width ||
-                    Src.Height != Dst.Height)
-                {
-                    throw new NotImplementedException("Texture resizing is not supported");
-                }
-
-                TextureWriter.Write(Vmm, Dst, TextureReader.Read(Vmm, Src));
-            }
         }
 
         private long MakeInt64From2xInt32(NvGpuEngine2dReg Reg)

Ryujinx.Graphics/NvGpuEngine3d.cs

@@ -23,8 +23,6 @@ namespace Ryujinx.Graphics
 
         private ConstBuffer[][] ConstBuffers;
 
-        private HashSet<long> FrameBuffers;
-
         private List<long>[] UploadedKeys;
 
         private int CurrentInstance = 0;
@@ -60,8 +58,6 @@ namespace Ryujinx.Graphics
                 ConstBuffers[Index] = new ConstBuffer[18];
             }
 
-            FrameBuffers = new HashSet<long>();
-
             UploadedKeys = new List<long>[(int)NvGpuBufferType.Count];
 
             for (int i = 0; i < UploadedKeys.Length; i++)
@@ -96,7 +92,7 @@ namespace Ryujinx.Graphics
 
             GalPipelineState State = new GalPipelineState();
 
-            SetFlip(State);
+            SetFrameBuffer(State);
             SetFrontFace(State);
             SetCullFace(State);
             SetDepth(State);
@@ -104,10 +100,7 @@ namespace Ryujinx.Graphics
             SetAlphaBlending(State);
             SetPrimitiveRestart(State);
 
-            for (int FbIndex = 0; FbIndex < 8; FbIndex++)
+            SetFrameBuffer(Vmm, 0);
-            {
-                SetFrameBuffer(Vmm, 0);
-            }
 
             SetZeta(Vmm);
 
@@ -173,9 +166,9 @@ namespace Ryujinx.Graphics
         {
             long VA = MakeInt64From2xInt32(NvGpuEngine3dReg.FrameBufferNAddress + FbIndex * 0x10);
 
-            int Format = ReadRegister(NvGpuEngine3dReg.FrameBufferNFormat + FbIndex * 0x10);
+            int SurfFormat = ReadRegister(NvGpuEngine3dReg.FrameBufferNFormat + FbIndex * 0x10);
 
-            if (VA == 0 || Format == 0)
+            if (VA == 0 || SurfFormat == 0)
             {
                 Gpu.Renderer.RenderTarget.UnbindColor(FbIndex);
 
@@ -184,11 +177,15 @@ namespace Ryujinx.Graphics
 
             long Key = Vmm.GetPhysicalAddress(VA);
 
-            FrameBuffers.Add(Key);
-
             int Width  = ReadRegister(NvGpuEngine3dReg.FrameBufferNWidth  + FbIndex * 0x10);
             int Height = ReadRegister(NvGpuEngine3dReg.FrameBufferNHeight + FbIndex * 0x10);
 
+            int BlockDim = ReadRegister(NvGpuEngine3dReg.FrameBufferNBlockDim + FbIndex * 0x10);
+
+            int GobBlockHeight = 1 << ((BlockDim >> 4) & 7);
+
+            GalMemoryLayout Layout = (GalMemoryLayout)((BlockDim >> 12) & 1);
+
             float TX = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNTranslateX + FbIndex * 8);
             float TY = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNTranslateY + FbIndex * 8);
 
@@ -201,48 +198,54 @@ namespace Ryujinx.Graphics
             int VpW = (int)(TX + MathF.Abs(SX)) - VpX;
             int VpH = (int)(TY + MathF.Abs(SY)) - VpY;
 
-            GalImageFormat ImageFormat = ImageUtils.ConvertSurface((GalSurfaceFormat)Format);
+            GalImageFormat Format = ImageUtils.ConvertSurface((GalSurfaceFormat)SurfFormat);
 
-            GalImage Image = new GalImage(Width, Height, ImageFormat);
+            GalImage Image = new GalImage(Width, Height, 1, GobBlockHeight, Layout, Format);
 
-            long Size = ImageUtils.GetSize(Image);
+            Gpu.ResourceManager.SendColorBuffer(Vmm, Key, FbIndex, Image);
-
-            Gpu.Renderer.Texture.CreateFb(Key, Size, Image);
-
-            Gpu.Renderer.RenderTarget.BindColor(Key, FbIndex);
 
             Gpu.Renderer.RenderTarget.SetViewport(VpX, VpY, VpW, VpH);
         }
 
+        private void SetFrameBuffer(GalPipelineState State)
+        {
+            State.FramebufferSrgb = (ReadRegister(NvGpuEngine3dReg.FrameBufferSrgb) & 1) != 0;
+
+            State.FlipX = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleX);
+            State.FlipY = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleY);
+        }
+
         private void SetZeta(NvGpuVmm Vmm)
         {
-            long ZA = MakeInt64From2xInt32(NvGpuEngine3dReg.ZetaAddress);
+            long VA = MakeInt64From2xInt32(NvGpuEngine3dReg.ZetaAddress);
 
-            int Format = ReadRegister(NvGpuEngine3dReg.ZetaFormat);
+            int ZetaFormat = ReadRegister(NvGpuEngine3dReg.ZetaFormat);
+
+            int BlockDim = ReadRegister(NvGpuEngine3dReg.ZetaBlockDimensions);
+
+            int GobBlockHeight = 1 << ((BlockDim >> 4) & 7);
+
+            GalMemoryLayout Layout = (GalMemoryLayout)((BlockDim >> 12) & 1); //?
 
             bool ZetaEnable = (ReadRegister(NvGpuEngine3dReg.ZetaEnable) & 1) != 0;
 
-            if (ZA == 0 || Format == 0 || !ZetaEnable)
+            if (VA == 0 || ZetaFormat == 0 || !ZetaEnable)
             {
                 Gpu.Renderer.RenderTarget.UnbindZeta();
 
                 return;
             }
 
-            long Key = Vmm.GetPhysicalAddress(ZA);
+            long Key = Vmm.GetPhysicalAddress(VA);
 
             int Width  = ReadRegister(NvGpuEngine3dReg.ZetaHoriz);
             int Height = ReadRegister(NvGpuEngine3dReg.ZetaVert);
 
-            GalImageFormat ImageFormat = ImageUtils.ConvertZeta((GalZetaFormat)Format);
+            GalImageFormat Format = ImageUtils.ConvertZeta((GalZetaFormat)ZetaFormat);
 
-            GalImage Image = new GalImage(Width, Height, ImageFormat);
+            GalImage Image = new GalImage(Width, Height, 1, GobBlockHeight, Layout, Format);
 
-            long Size = ImageUtils.GetSize(Image);
+            Gpu.ResourceManager.SendZetaBuffer(Vmm, Key, Image);
-
-            Gpu.Renderer.Texture.CreateFb(Key, Size, Image);
-
-            Gpu.Renderer.RenderTarget.BindZeta(Key);
         }
 
         private long[] UploadShaders(NvGpuVmm Vmm)
@@ -322,12 +325,6 @@ namespace Ryujinx.Graphics
             throw new ArgumentOutOfRangeException(nameof(Program));
         }
 
-        private void SetFlip(GalPipelineState State)
-        {
-            State.FlipX = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleX);
-            State.FlipY = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleY);
-        }
-
         private void SetFrontFace(GalPipelineState State)
         {
             float SignX = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleX);
@@ -504,53 +501,30 @@ namespace Ryujinx.Graphics
             TicPosition += TicIndex * 0x20;
             TscPosition += TscIndex * 0x20;
 
+            GalImage Image = TextureFactory.MakeTexture(Vmm, TicPosition);
+
             GalTextureSampler Sampler = TextureFactory.MakeSampler(Gpu, Vmm, TscPosition);
 
             long Key = Vmm.ReadInt64(TicPosition + 4) & 0xffffffffffff;
 
+            if (Image.Layout == GalMemoryLayout.BlockLinear)
+            {
+                Key &= ~0x1ffL;
+            }
+            else if (Image.Layout == GalMemoryLayout.Pitch)
+            {
+                Key &= ~0x1fL;
+            }
+
             Key = Vmm.GetPhysicalAddress(Key);
 
             if (Key == -1)
             {
-                //FIXME: Should'nt ignore invalid addresses.
+                //FIXME: Shouldn't ignore invalid addresses.
                 return;
             }
 
-            if (IsFrameBufferPosition(Key))
+            Gpu.ResourceManager.SendTexture(Vmm, Key, Image, TexIndex);
-            {
-                //This texture is a frame buffer texture,
-                //we shouldn't read anything from memory and bind
-                //the frame buffer texture instead, since we're not
-                //really writing anything to memory.
-                Gpu.Renderer.RenderTarget.BindTexture(Key, TexIndex);
-            }
-            else
-            {
-                GalImage NewImage = TextureFactory.MakeTexture(Vmm, TicPosition);
-
-                long Size = (uint)ImageUtils.GetSize(NewImage);
-
-                bool HasCachedTexture = false;
-
-                if (Gpu.Renderer.Texture.TryGetCachedTexture(Key, Size, out GalImage Image))
-                {
-                    if (NewImage.Equals(Image) && !QueryKeyUpload(Vmm, Key, Size, NvGpuBufferType.Texture))
-                    {
-                        Gpu.Renderer.Texture.Bind(Key, TexIndex);
-
-                        HasCachedTexture = true;
-                    }
-                }
-
-                if (!HasCachedTexture)
-                {
-                    byte[] Data = TextureFactory.GetTextureData(Vmm, TicPosition);
-
-                    Gpu.Renderer.Texture.Create(Key, Data, NewImage);
-                }
-
-                Gpu.Renderer.Texture.Bind(Key, TexIndex);
-            }
 
             Gpu.Renderer.Texture.SetSampler(Sampler);
         }
@@ -876,11 +850,6 @@ namespace Ryujinx.Graphics
             Registers[(int)Reg] = Value;
         }
 
-        public bool IsFrameBufferPosition(long Position)
-        {
-            return FrameBuffers.Contains(Position);
-        }
-
         private bool QueryKeyUpload(NvGpuVmm Vmm, long Key, long Size, NvGpuBufferType Type)
         {
             List<long> Uploaded = UploadedKeys[(int)Type];

Ryujinx.Graphics/NvGpuEngine3dReg.cs

@@ -6,6 +6,7 @@ namespace Ryujinx.Graphics
         FrameBufferNWidth    = 0x202,
         FrameBufferNHeight   = 0x203,
         FrameBufferNFormat   = 0x204,
+        FrameBufferNBlockDim = 0x205,
         ViewportNScaleX      = 0x280,
         ViewportNScaleY      = 0x281,
         ViewportNScaleZ      = 0x282,
@@ -62,6 +63,7 @@ namespace Ryujinx.Graphics
         StencilBackOpZFail   = 0x567,
         StencilBackOpZPass   = 0x568,
         StencilBackFuncFunc  = 0x569,
+        FrameBufferSrgb      = 0x56e,
         ShaderAddress        = 0x582,
         VertexBeginGl        = 0x586,
         PrimRestartEnable    = 0x591,

Ryujinx.Graphics/NvGpuEngineDma.cs

@@ -1,143 +0,0 @@
-using Ryujinx.Graphics.Memory;
-using Ryujinx.Graphics.Texture;
-using System.Collections.Generic;
-
-namespace Ryujinx.Graphics
-{
-    public class NvGpuEngineDma : INvGpuEngine
-    {
-        public int[] Registers { get; private set; }
-
-        private NvGpu Gpu;
-
-        private Dictionary<int, NvGpuMethod> Methods;
-
-        public NvGpuEngineDma(NvGpu Gpu)
-        {
-            this.Gpu = Gpu;
-
-            Registers = new int[0x1d6];
-
-            Methods = new Dictionary<int, NvGpuMethod>();
-
-            void AddMethod(int Meth, int Count, int Stride, NvGpuMethod Method)
-            {
-                while (Count-- > 0)
-                {
-                    Methods.Add(Meth, Method);
-
-                    Meth += Stride;
-                }
-            }
-
-            AddMethod(0xc0, 1, 1, Execute);
-        }
-
-        public void CallMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
-        {
-            if (Methods.TryGetValue(PBEntry.Method, out NvGpuMethod Method))
-            {
-                Method(Vmm, PBEntry);
-            }
-            else
-            {
-                WriteRegister(PBEntry);
-            }
-        }
-
-        private void Execute(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
-        {
-            int Control = PBEntry.Arguments[0];
-
-            bool SrcLinear = ((Control >> 7) & 1) != 0;
-            bool DstLinear = ((Control >> 8) & 1) != 0;
-
-            long SrcAddress = MakeInt64From2xInt32(NvGpuEngineDmaReg.SrcAddress);
-            long DstAddress = MakeInt64From2xInt32(NvGpuEngineDmaReg.DstAddress);
-
-            int SrcPitch = ReadRegister(NvGpuEngineDmaReg.SrcPitch);
-            int DstPitch = ReadRegister(NvGpuEngineDmaReg.DstPitch);
-
-            int DstBlkDim = ReadRegister(NvGpuEngineDmaReg.DstBlkDim);
-            int DstSizeX  = ReadRegister(NvGpuEngineDmaReg.DstSizeX);
-            int DstSizeY  = ReadRegister(NvGpuEngineDmaReg.DstSizeY);
-            int DstSizeZ  = ReadRegister(NvGpuEngineDmaReg.DstSizeZ);
-            int DstPosXY  = ReadRegister(NvGpuEngineDmaReg.DstPosXY);
-            int DstPosZ   = ReadRegister(NvGpuEngineDmaReg.DstPosZ);
-
-            int SrcBlkDim = ReadRegister(NvGpuEngineDmaReg.SrcBlkDim);
-            int SrcSizeX  = ReadRegister(NvGpuEngineDmaReg.SrcSizeX);
-            int SrcSizeY  = ReadRegister(NvGpuEngineDmaReg.SrcSizeY);
-            int SrcSizeZ  = ReadRegister(NvGpuEngineDmaReg.SrcSizeZ);
-            int SrcPosXY  = ReadRegister(NvGpuEngineDmaReg.SrcPosXY);
-            int SrcPosZ   = ReadRegister(NvGpuEngineDmaReg.SrcPosZ);
-
-            int DstPosX = (DstPosXY >>  0) & 0xffff;
-            int DstPosY = (DstPosXY >> 16) & 0xffff;
-
-            int SrcPosX = (SrcPosXY >>  0) & 0xffff;
-            int SrcPosY = (SrcPosXY >> 16) & 0xffff;
-
-            int SrcBlockHeight = 1 << ((SrcBlkDim >> 4) & 0xf);
-            int DstBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf);
-
-            ISwizzle SrcSwizzle;
-
-            if (SrcLinear)
-            {
-                SrcSwizzle = new LinearSwizzle(SrcPitch, 1);
-            }
-            else
-            {
-                SrcSwizzle = new BlockLinearSwizzle(SrcSizeX, 1, SrcBlockHeight);
-            }
-
-            ISwizzle DstSwizzle;
-
-            if (DstLinear)
-            {
-                DstSwizzle = new LinearSwizzle(DstPitch, 1);
-            }
-            else
-            {
-                DstSwizzle = new BlockLinearSwizzle(DstSizeX, 1, DstBlockHeight);
-            }
-
-            for (int Y = 0; Y < DstSizeY; Y++)
-            for (int X = 0; X < DstSizeX; X++)
-            {
-                long SrcOffset = SrcAddress + (uint)SrcSwizzle.GetSwizzleOffset(X, Y);
-                long DstOffset = DstAddress + (uint)DstSwizzle.GetSwizzleOffset(X, Y);
-
-                Vmm.WriteByte(DstOffset, Vmm.ReadByte(SrcOffset));
-            }
-        }
-
-        private long MakeInt64From2xInt32(NvGpuEngineDmaReg Reg)
-        {
-            return
-                (long)Registers[(int)Reg + 0] << 32 |
-                (uint)Registers[(int)Reg + 1];
-        }
-
-        private void WriteRegister(NvGpuPBEntry PBEntry)
-        {
-            int ArgsCount = PBEntry.Arguments.Count;
-
-            if (ArgsCount > 0)
-            {
-                Registers[PBEntry.Method] = PBEntry.Arguments[ArgsCount - 1];
-            }
-        }
-
-        private int ReadRegister(NvGpuEngineDmaReg Reg)
-        {
-            return Registers[(int)Reg];
-        }
-
-        private void WriteRegister(NvGpuEngineDmaReg Reg, int Value)
-        {
-            Registers[(int)Reg] = Value;
-        }
-    }
-}

Ryujinx.Graphics/NvGpuEngineM2mf.cs

@@ -0,0 +1,192 @@
+using Ryujinx.Graphics.Memory;
+using Ryujinx.Graphics.Texture;
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics
+{
+    public class NvGpuEngineM2mf : INvGpuEngine
+    {
+        public int[] Registers { get; private set; }
+
+        private NvGpu Gpu;
+
+        private Dictionary<int, NvGpuMethod> Methods;
+
+        public NvGpuEngineM2mf(NvGpu Gpu)
+        {
+            this.Gpu = Gpu;
+
+            Registers = new int[0x1d6];
+
+            Methods = new Dictionary<int, NvGpuMethod>();
+
+            void AddMethod(int Meth, int Count, int Stride, NvGpuMethod Method)
+            {
+                while (Count-- > 0)
+                {
+                    Methods.Add(Meth, Method);
+
+                    Meth += Stride;
+                }
+            }
+
+            AddMethod(0xc0, 1, 1, Execute);
+        }
+
+        public void CallMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            if (Methods.TryGetValue(PBEntry.Method, out NvGpuMethod Method))
+            {
+                Method(Vmm, PBEntry);
+            }
+            else
+            {
+                WriteRegister(PBEntry);
+            }
+        }
+
+        private void Execute(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            //TODO: Some registers and copy modes are still not implemented.
+            int Control = PBEntry.Arguments[0];
+
+            bool SrcLinear = ((Control >> 7) & 1) != 0;
+            bool DstLinear = ((Control >> 8) & 1) != 0;
+            bool Copy2d    = ((Control >> 9) & 1) != 0;
+
+            long SrcAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.SrcAddress);
+            long DstAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.DstAddress);
+
+            int SrcPitch = ReadRegister(NvGpuEngineM2mfReg.SrcPitch);
+            int DstPitch = ReadRegister(NvGpuEngineM2mfReg.DstPitch);
+
+            int XCount = ReadRegister(NvGpuEngineM2mfReg.XCount);
+            int YCount = ReadRegister(NvGpuEngineM2mfReg.YCount);
+
+            int Swizzle = ReadRegister(NvGpuEngineM2mfReg.Swizzle);
+
+            int DstBlkDim = ReadRegister(NvGpuEngineM2mfReg.DstBlkDim);
+            int DstSizeX  = ReadRegister(NvGpuEngineM2mfReg.DstSizeX);
+            int DstSizeY  = ReadRegister(NvGpuEngineM2mfReg.DstSizeY);
+            int DstSizeZ  = ReadRegister(NvGpuEngineM2mfReg.DstSizeZ);
+            int DstPosXY  = ReadRegister(NvGpuEngineM2mfReg.DstPosXY);
+            int DstPosZ   = ReadRegister(NvGpuEngineM2mfReg.DstPosZ);
+
+            int SrcBlkDim = ReadRegister(NvGpuEngineM2mfReg.SrcBlkDim);
+            int SrcSizeX  = ReadRegister(NvGpuEngineM2mfReg.SrcSizeX);
+            int SrcSizeY  = ReadRegister(NvGpuEngineM2mfReg.SrcSizeY);
+            int SrcSizeZ  = ReadRegister(NvGpuEngineM2mfReg.SrcSizeZ);
+            int SrcPosXY  = ReadRegister(NvGpuEngineM2mfReg.SrcPosXY);
+            int SrcPosZ   = ReadRegister(NvGpuEngineM2mfReg.SrcPosZ);
+
+            int SrcCpp = ((Swizzle >> 20) & 7) + 1;
+            int DstCpp = ((Swizzle >> 24) & 7) + 1;
+
+            int DstPosX = (DstPosXY >>  0) & 0xffff;
+            int DstPosY = (DstPosXY >> 16) & 0xffff;
+
+            int SrcPosX = (SrcPosXY >>  0) & 0xffff;
+            int SrcPosY = (SrcPosXY >> 16) & 0xffff;
+
+            int SrcBlockHeight = 1 << ((SrcBlkDim >> 4) & 0xf);
+            int DstBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf);
+
+            long SrcPA = Vmm.GetPhysicalAddress(SrcAddress);
+            long DstPA = Vmm.GetPhysicalAddress(DstAddress);
+
+            if (Copy2d)
+            {
+                if (SrcLinear)
+                {
+                    SrcPosX = SrcPosY = SrcPosZ = 0;
+                }
+
+                if (DstLinear)
+                {
+                    DstPosX = DstPosY = DstPosZ = 0;
+                }
+
+                if (SrcLinear && DstLinear)
+                {
+                    for (int Y = 0; Y < YCount; Y++)
+                    {
+                        int SrcOffset = (SrcPosY + Y) * SrcPitch + SrcPosX * SrcCpp;
+                        int DstOffset = (DstPosY + Y) * DstPitch + DstPosX * DstCpp;
+
+                        long Src = SrcPA + (uint)SrcOffset;
+                        long Dst = DstPA + (uint)DstOffset;
+
+                        Vmm.Memory.CopyBytes(Src, Dst, XCount * SrcCpp);
+                    }
+                }
+                else
+                {
+                    ISwizzle SrcSwizzle;
+
+                    if (SrcLinear)
+                    {
+                        SrcSwizzle = new LinearSwizzle(SrcPitch, SrcCpp);
+                    }
+                    else
+                    {
+                        SrcSwizzle = new BlockLinearSwizzle(SrcSizeX, SrcCpp, SrcBlockHeight);
+                    }
+
+                    ISwizzle DstSwizzle;
+
+                    if (DstLinear)
+                    {
+                        DstSwizzle = new LinearSwizzle(DstPitch, DstCpp);
+                    }
+                    else
+                    {
+                        DstSwizzle = new BlockLinearSwizzle(DstSizeX, DstCpp, DstBlockHeight);
+                    }
+
+                    for (int Y = 0; Y < YCount; Y++)
+                    for (int X = 0; X < XCount; X++)
+                    {
+                        int SrcOffset = SrcSwizzle.GetSwizzleOffset(SrcPosX + X, SrcPosY + Y);
+                        int DstOffset = DstSwizzle.GetSwizzleOffset(DstPosX + X, DstPosY + Y);
+
+                        long Src = SrcPA + (uint)SrcOffset;
+                        long Dst = DstPA + (uint)DstOffset;
+
+                        Vmm.Memory.CopyBytes(Src, Dst, SrcCpp);
+                    }
+                }
+            }
+            else
+            {
+                Vmm.Memory.CopyBytes(SrcPA, DstPA, XCount);
+            }
+        }
+
+        private long MakeInt64From2xInt32(NvGpuEngineM2mfReg Reg)
+        {
+            return
+                (long)Registers[(int)Reg + 0] << 32 |
+                (uint)Registers[(int)Reg + 1];
+        }
+
+        private void WriteRegister(NvGpuPBEntry PBEntry)
+        {
+            int ArgsCount = PBEntry.Arguments.Count;
+
+            if (ArgsCount > 0)
+            {
+                Registers[PBEntry.Method] = PBEntry.Arguments[ArgsCount - 1];
+            }
+        }
+
+        private int ReadRegister(NvGpuEngineM2mfReg Reg)
+        {
+            return Registers[(int)Reg];
+        }
+
+        private void WriteRegister(NvGpuEngineM2mfReg Reg, int Value)
+        {
+            Registers[(int)Reg] = Value;
+        }
+    }
+}

Ryujinx.Graphics/NvGpuEngineM2mfReg.cs

@@ -1,11 +1,14 @@
 namespace Ryujinx.Graphics
 {
-    enum NvGpuEngineDmaReg
+    enum NvGpuEngineM2mfReg
     {
         SrcAddress = 0x100,
         DstAddress = 0x102,
         SrcPitch   = 0x104,
         DstPitch   = 0x105,
+        XCount     = 0x106,
+        YCount     = 0x107,
+        Swizzle    = 0x1c2,
         DstBlkDim  = 0x1c3,
         DstSizeX   = 0x1c4,
         DstSizeY   = 0x1c5,

Ryujinx.Graphics/NvGpuEngineP2mf.cs

@@ -0,0 +1,102 @@
+using Ryujinx.Graphics.Memory;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace Ryujinx.Graphics
+{
+    public class NvGpuEngineP2mf : INvGpuEngine
+    {
+        public int[] Registers { get; private set; }
+
+        private NvGpu Gpu;
+
+        private Dictionary<int, NvGpuMethod> Methods;
+
+        private ReadOnlyCollection<int> DataBuffer;
+
+        public NvGpuEngineP2mf(NvGpu Gpu)
+        {
+            this.Gpu = Gpu;
+
+            Registers = new int[0x80];
+
+            Methods = new Dictionary<int, NvGpuMethod>();
+
+            void AddMethod(int Meth, int Count, int Stride, NvGpuMethod Method)
+            {
+                while (Count-- > 0)
+                {
+                    Methods.Add(Meth, Method);
+
+                    Meth += Stride;
+                }
+            }
+
+            AddMethod(0x6c, 1, 1, Execute);
+            AddMethod(0x6d, 1, 1, PushData);
+        }
+
+        public void CallMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            if (Methods.TryGetValue(PBEntry.Method, out NvGpuMethod Method))
+            {
+                Method(Vmm, PBEntry);
+            }
+            else
+            {
+                WriteRegister(PBEntry);
+            }
+        }
+
+        private void Execute(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            //TODO: Some registers and copy modes are still not implemented.
+            int Control = PBEntry.Arguments[0];
+
+            long DstAddress = MakeInt64From2xInt32(NvGpuEngineP2mfReg.DstAddress);
+
+            int LineLengthIn = ReadRegister(NvGpuEngineP2mfReg.LineLengthIn);
+
+            DataBuffer = null;
+
+            Gpu.Fifo.Step();
+
+            for (int Offset = 0; Offset < LineLengthIn; Offset += 4)
+            {
+                Vmm.WriteInt32(DstAddress + Offset, DataBuffer[Offset >> 2]);
+            }
+        }
+
+        private void PushData(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            DataBuffer = PBEntry.Arguments;
+        }
+
+        private long MakeInt64From2xInt32(NvGpuEngineP2mfReg Reg)
+        {
+            return
+                (long)Registers[(int)Reg + 0] << 32 |
+                (uint)Registers[(int)Reg + 1];
+        }
+
+        private void WriteRegister(NvGpuPBEntry PBEntry)
+        {
+            int ArgsCount = PBEntry.Arguments.Count;
+
+            if (ArgsCount > 0)
+            {
+                Registers[PBEntry.Method] = PBEntry.Arguments[ArgsCount - 1];
+            }
+        }
+
+        private int ReadRegister(NvGpuEngineP2mfReg Reg)
+        {
+            return Registers[(int)Reg];
+        }
+
+        private void WriteRegister(NvGpuEngineP2mfReg Reg, int Value)
+        {
+            Registers[(int)Reg] = Value;
+        }
+    }
+}

Ryujinx.Graphics/NvGpuEngineP2mfReg.cs

@@ -0,0 +1,17 @@
+namespace Ryujinx.Graphics
+{
+    enum NvGpuEngineP2mfReg
+    {
+        LineLengthIn = 0x60,
+        LineCount    = 0x61,
+        DstAddress   = 0x62,
+        DstPitch     = 0x64,
+        DstBlockDim  = 0x65,
+        DstWidth     = 0x66,
+        DstHeight    = 0x67,
+        DstDepth     = 0x68,
+        DstZ         = 0x69,
+        DstX         = 0x6a,
+        DstY         = 0x6b
+    }
+}

Ryujinx.Graphics/NvGpuFifo.cs

@@ -94,6 +94,8 @@ namespace Ryujinx.Graphics
 
                 Gpu.Engine3d.ResetCache();
 
+                Gpu.ResourceManager.ClearPbCache();
+
                 CurrPbEntryIndex = 0;
             }
 
@@ -103,20 +105,36 @@ namespace Ryujinx.Graphics
         }
 
         private void CallMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            if ((NvGpuFifoMeth)PBEntry.Method == NvGpuFifoMeth.BindChannel)
+            {
+                NvGpuEngine Engine = (NvGpuEngine)PBEntry.Arguments[0];
+
+                SubChannels[PBEntry.SubChannel] = Engine;
+            }
+            else
+            {
+                switch (SubChannels[PBEntry.SubChannel])
+                {
+                    case NvGpuEngine._2d:  Call2dMethod  (Vmm, PBEntry); break;
+                    case NvGpuEngine._3d:  Call3dMethod  (Vmm, PBEntry); break;
+                    case NvGpuEngine.P2mf: CallP2mfMethod(Vmm, PBEntry); break;
+                    case NvGpuEngine.M2mf: CallM2mfMethod(Vmm, PBEntry); break;
+                }
+            }
+        }
+
+        private void Call2dMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            Gpu.Engine2d.CallMethod(Vmm, PBEntry);
+        }
+
+        private void Call3dMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
         {
             if (PBEntry.Method < 0x80)
             {
                 switch ((NvGpuFifoMeth)PBEntry.Method)
                 {
-                    case NvGpuFifoMeth.BindChannel:
-                    {
-                        NvGpuEngine Engine = (NvGpuEngine)PBEntry.Arguments[0];
-
-                        SubChannels[PBEntry.SubChannel] = Engine;
-
-                        break;
-                    }
-
                     case NvGpuFifoMeth.SetMacroUploadAddress:
                     {
                         CurrMacroPosition = PBEntry.Arguments[0];
@@ -150,25 +168,7 @@ namespace Ryujinx.Graphics
                     }
                 }
             }
-            else
+            else if (PBEntry.Method < 0xe00)
-            {
-                switch (SubChannels[PBEntry.SubChannel])
-                {
-                    case NvGpuEngine._2d: Call2dMethod (Vmm, PBEntry); break;
-                    case NvGpuEngine._3d: Call3dMethod (Vmm, PBEntry); break;
-                    case NvGpuEngine.Dma: CallDmaMethod(Vmm, PBEntry); break;
-                }
-            }
-        }
-
-        private void Call2dMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
-        {
-            Gpu.Engine2d.CallMethod(Vmm, PBEntry);
-        }
-
-        private void Call3dMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
-        {
-            if (PBEntry.Method < 0xe00)
             {
                 Gpu.Engine3d.CallMethod(Vmm, PBEntry);
             }
@@ -190,9 +190,14 @@ namespace Ryujinx.Graphics
             }
         }
 
-        private void CallDmaMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        private void CallP2mfMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
         {
-            Gpu.EngineDma.CallMethod(Vmm, PBEntry);
+            Gpu.EngineP2mf.CallMethod(Vmm, PBEntry);
+        }
+
+        private void CallM2mfMethod(NvGpuVmm Vmm, NvGpuPBEntry PBEntry)
+        {
+            Gpu.EngineM2mf.CallMethod(Vmm, PBEntry);
         }
     }
 }

Ryujinx.Graphics/Texture/ImageUtils.cs

@@ -1,33 +1,37 @@
-using Ryujinx.Graphics.Gal;
+using ChocolArm64.Memory;
+using Ryujinx.Graphics.Gal;
+using Ryujinx.Graphics.Memory;
 using System;
 using System.Collections.Generic;
 
 namespace Ryujinx.Graphics.Texture
 {
-    static class ImageUtils
+    public static class ImageUtils
     {
-        struct ImageDescriptor
+        [Flags]
+        private enum TargetBuffer
         {
-            public TextureReaderDelegate Reader;
+            Color   = 1 << 0,
+            Depth   = 1 << 1,
+            Stencil = 1 << 2,
 
-            public bool HasColor;
+            DepthStencil = Depth | Stencil
-            public bool HasDepth;
+        }
-            public bool HasStencil;
 
-            public bool Compressed;
+        private struct ImageDescriptor
+        {
+            public int BytesPerPixel { get; private set; }
+            public int BlockWidth    { get; private set; }
+            public int BlockHeight   { get; private set; }
 
-            public ImageDescriptor(
+            public TargetBuffer Target { get; private set; }
-                TextureReaderDelegate Reader,
+
-                bool                  HasColor,
+            public ImageDescriptor(int BytesPerPixel, int BlockWidth, int BlockHeight, TargetBuffer Target)
-                bool                  HasDepth,
-                bool                  HasStencil,
-                bool                  Compressed)
             {
-                this.Reader     = Reader;
+                this.BytesPerPixel = BytesPerPixel;
-                this.HasColor   = HasColor;
+                this.BlockWidth    = BlockWidth;
-                this.HasDepth   = HasDepth;
+                this.BlockHeight   = BlockHeight;
-                this.HasStencil = HasStencil;
+                this.Target        = Target;
-                this.Compressed = Compressed;
             }
         }
 
@@ -48,6 +52,7 @@ namespace Ryujinx.Graphics.Texture
                 { GalTextureFormat.G8R8,         GalImageFormat.G8R8         | Snorm | Unorm | Sint | Uint          },
                 { GalTextureFormat.R16,          GalImageFormat.R16          | Snorm | Unorm | Sint | Uint | Sfloat },
                 { GalTextureFormat.R8,           GalImageFormat.R8           | Snorm | Unorm | Sint | Uint          },
+                { GalTextureFormat.R16G16,       GalImageFormat.R16G16       | Snorm                                },
                 { GalTextureFormat.R32,          GalImageFormat.R32                          | Sint | Uint | Sfloat },
                 { GalTextureFormat.A4B4G4R4,     GalImageFormat.A4B4G4R4             | Unorm                        },
                 { GalTextureFormat.A1B5G5R5,     GalImageFormat.A1R5G5B5             | Unorm                        },
@@ -85,58 +90,58 @@ namespace Ryujinx.Graphics.Texture
 
         private static readonly Dictionary<GalImageFormat, ImageDescriptor> s_ImageTable =
                             new Dictionary<GalImageFormat, ImageDescriptor>()
-            {
+        {
-                { GalImageFormat.R32G32B32A32,  new ImageDescriptor(TextureReader.Read16Bpp,                       true, false, false, false) },
+            { GalImageFormat.R32G32B32A32,  new ImageDescriptor(16, 1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.R16G16B16A16,  new ImageDescriptor(TextureReader.Read8Bpp,                        true, false, false, false) },
+            { GalImageFormat.R16G16B16A16,  new ImageDescriptor(8,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.R32G32,        new ImageDescriptor(TextureReader.Read8Bpp,                        true, false, false, false) },
+            { GalImageFormat.R32G32,        new ImageDescriptor(8,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.A8B8G8R8,      new ImageDescriptor(TextureReader.Read4Bpp,                        true, false, false, false) },
+            { GalImageFormat.A8B8G8R8,      new ImageDescriptor(4,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.A2B10G10R10,   new ImageDescriptor(TextureReader.Read4Bpp,                        true, false, false, false) },
+            { GalImageFormat.A2B10G10R10,   new ImageDescriptor(4,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.R32,           new ImageDescriptor(TextureReader.Read4Bpp,                        true, false, false, false) },
+            { GalImageFormat.R32,           new ImageDescriptor(4,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.A4B4G4R4,      new ImageDescriptor(TextureReader.Read2Bpp,                        true, false, false, false) },
+            { GalImageFormat.A4B4G4R4,      new ImageDescriptor(2,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.BC6H_SF16,     new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4,   true, false, false, true)  },
+            { GalImageFormat.BC6H_SF16,     new ImageDescriptor(16, 4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.BC6H_UF16,     new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4,   true, false, false, true)  },
+            { GalImageFormat.BC6H_UF16,     new ImageDescriptor(16, 4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.A1R5G5B5,      new ImageDescriptor(TextureReader.Read5551,                        true, false, false, false) },
+            { GalImageFormat.A1R5G5B5,      new ImageDescriptor(2,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.B5G6R5,        new ImageDescriptor(TextureReader.Read565,                         true, false, false, false) },
+            { GalImageFormat.B5G6R5,        new ImageDescriptor(2,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.BC7,           new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4,   true, false, false, true)  },
+            { GalImageFormat.BC7,           new ImageDescriptor(16, 4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.R16G16,        new ImageDescriptor(TextureReader.Read4Bpp,                        true, false, false, false) },
+            { GalImageFormat.R16G16,        new ImageDescriptor(4,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.R8G8,          new ImageDescriptor(TextureReader.Read2Bpp,                        true, false, false, false) },
+            { GalImageFormat.R8G8,          new ImageDescriptor(2,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.G8R8,          new ImageDescriptor(TextureReader.Read2Bpp,                        true, false, false, false) },
+            { GalImageFormat.G8R8,          new ImageDescriptor(2,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.R16,           new ImageDescriptor(TextureReader.Read2Bpp,                        true, false, false, false) },
+            { GalImageFormat.R16,           new ImageDescriptor(2,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.R8,            new ImageDescriptor(TextureReader.Read1Bpp,                        true, false, false, false) },
+            { GalImageFormat.R8,            new ImageDescriptor(1,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.B10G11R11,     new ImageDescriptor(TextureReader.Read4Bpp,                        true, false, false, false) },
+            { GalImageFormat.B10G11R11,     new ImageDescriptor(4,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.A8B8G8R8_SRGB, new ImageDescriptor(TextureReader.Read4Bpp,                        true, false, false, false) },
+            { GalImageFormat.A8B8G8R8_SRGB, new ImageDescriptor(4,  1,  1,  TargetBuffer.Color) },
-                { GalImageFormat.BC1_RGBA,      new ImageDescriptor(TextureReader.Read8Bpt4x4,                     true, false, false, true)  },
+            { GalImageFormat.BC1_RGBA,      new ImageDescriptor(8,  4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.BC2,           new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4,   true, false, false, true)  },
+            { GalImageFormat.BC2,           new ImageDescriptor(16, 4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.BC3,           new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4,   true, false, false, true)  },
+            { GalImageFormat.BC3,           new ImageDescriptor(16, 4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.BC4,           new ImageDescriptor(TextureReader.Read8Bpt4x4,                     true, false, false, true)  },
+            { GalImageFormat.BC4,           new ImageDescriptor(8,  4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.BC5,           new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4,   true, false, false, true)  },
+            { GalImageFormat.BC5,           new ImageDescriptor(16, 4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_4x4,      new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4,   true, false, false, true)  },
+            { GalImageFormat.ASTC_4x4,      new ImageDescriptor(16, 4,  4,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_5x5,      new ImageDescriptor(TextureReader.Read16BptCompressedTexture5x5,   true, false, false, true)  },
+            { GalImageFormat.ASTC_5x5,      new ImageDescriptor(16, 5,  5,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_6x6,      new ImageDescriptor(TextureReader.Read16BptCompressedTexture6x6,   true, false, false, true)  },
+            { GalImageFormat.ASTC_6x6,      new ImageDescriptor(16, 6,  6,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_8x8,      new ImageDescriptor(TextureReader.Read16BptCompressedTexture8x8,   true, false, false, true)  },
+            { GalImageFormat.ASTC_8x8,      new ImageDescriptor(16, 8,  8,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_10x10,    new ImageDescriptor(TextureReader.Read16BptCompressedTexture10x10, true, false, false, true)  },
+            { GalImageFormat.ASTC_10x10,    new ImageDescriptor(16, 10, 10, TargetBuffer.Color) },
-                { GalImageFormat.ASTC_12x12,    new ImageDescriptor(TextureReader.Read16BptCompressedTexture12x12, true, false, false, true)  },
+            { GalImageFormat.ASTC_12x12,    new ImageDescriptor(16, 12, 12, TargetBuffer.Color) },
-                { GalImageFormat.ASTC_5x4,      new ImageDescriptor(TextureReader.Read16BptCompressedTexture5x4,   true, false, false, true)  },
+            { GalImageFormat.ASTC_5x4,      new ImageDescriptor(16, 5,  4,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_6x5,      new ImageDescriptor(TextureReader.Read16BptCompressedTexture6x5,   true, false, false, true)  },
+            { GalImageFormat.ASTC_6x5,      new ImageDescriptor(16, 6,  5,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_8x6,      new ImageDescriptor(TextureReader.Read16BptCompressedTexture8x6,   true, false, false, true)  },
+            { GalImageFormat.ASTC_8x6,      new ImageDescriptor(16, 8,  6,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_10x8,     new ImageDescriptor(TextureReader.Read16BptCompressedTexture10x8,  true, false, false, true)  },
+            { GalImageFormat.ASTC_10x8,     new ImageDescriptor(16, 10, 8,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_12x10,    new ImageDescriptor(TextureReader.Read16BptCompressedTexture12x10, true, false, false, true)  },
+            { GalImageFormat.ASTC_12x10,    new ImageDescriptor(16, 12, 10, TargetBuffer.Color) },
-                { GalImageFormat.ASTC_8x5,      new ImageDescriptor(TextureReader.Read16BptCompressedTexture8x5,   true, false, false, true)  },
+            { GalImageFormat.ASTC_8x5,      new ImageDescriptor(16, 8,  5,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_10x5,     new ImageDescriptor(TextureReader.Read16BptCompressedTexture10x5,  true, false, false, true)  },
+            { GalImageFormat.ASTC_10x5,     new ImageDescriptor(16, 10, 5,  TargetBuffer.Color) },
-                { GalImageFormat.ASTC_10x6,     new ImageDescriptor(TextureReader.Read16BptCompressedTexture10x6,  true, false, false, true)  },
+            { GalImageFormat.ASTC_10x6,     new ImageDescriptor(16, 10, 6,  TargetBuffer.Color) },
 
-                { GalImageFormat.D24_S8, new ImageDescriptor(TextureReader.Read4Bpp, false, true, true,  false)  },
+            { GalImageFormat.D24_S8, new ImageDescriptor(4, 1, 1, TargetBuffer.DepthStencil) },
-                { GalImageFormat.D32,    new ImageDescriptor(TextureReader.Read4Bpp, false, true, false, false) },
+            { GalImageFormat.D32,    new ImageDescriptor(4, 1, 1, TargetBuffer.Depth)        },
-                { GalImageFormat.D16,    new ImageDescriptor(TextureReader.Read2Bpp, false, true, false, false) },
+            { GalImageFormat.D16,    new ImageDescriptor(2, 1, 1, TargetBuffer.Depth)        },
-                { GalImageFormat.D32_S8, new ImageDescriptor(TextureReader.Read8Bpp, false, true, true,  false)  },
+            { GalImageFormat.D32_S8, new ImageDescriptor(8, 1, 1, TargetBuffer.DepthStencil) },
-            };
+        };
 
         public static GalImageFormat ConvertTexture(
             GalTextureFormat Format,
-            GalTextureType RType,
+            GalTextureType   RType,
-            GalTextureType GType,
+            GalTextureType   GType,
-            GalTextureType BType,
+            GalTextureType   BType,
-            GalTextureType AType)
+            GalTextureType   AType)
         {
             if (RType != GType || RType != BType || RType != AType)
             {
@@ -202,128 +207,157 @@ namespace Ryujinx.Graphics.Texture
                 case GalZetaFormat.Z32Float:      return GalImageFormat.D32    | Sfloat;
                 case GalZetaFormat.S8Z24Unorm:    return GalImageFormat.D24_S8 | Unorm;
                 case GalZetaFormat.Z16Unorm:      return GalImageFormat.D16    | Unorm;
-                //This one might not be Uint, change when a texture uses this format
+                case GalZetaFormat.Z24S8Unorm:    return GalImageFormat.D24_S8 | Unorm;
-                case GalZetaFormat.Z32S8X24Float: return GalImageFormat.D32_S8 | Uint;
+                case GalZetaFormat.Z32S8X24Float: return GalImageFormat.D32_S8 | Sfloat;
             }
 
             throw new NotImplementedException(Format.ToString());
         }
 
-        public static TextureReaderDelegate GetReader(GalImageFormat Format)
+        public static byte[] ReadTexture(IAMemory Memory, GalImage Image, long Position)
         {
-            return GetImageDescriptor(Format).Reader;
+            AMemory CpuMemory;
+
+            if (Memory is NvGpuVmm Vmm)
+            {
+                CpuMemory = Vmm.Memory;
+            }
+            else
+            {
+                CpuMemory = (AMemory)Memory;
+            }
+
+            ISwizzle Swizzle = TextureHelper.GetSwizzle(Image);
+
+            ImageDescriptor Desc = GetImageDescriptor(Image.Format);
+
+            (int Width, int Height) = GetImageSizeInBlocks(Image);
+
+            int BytesPerPixel = Desc.BytesPerPixel;
+
+            int OutOffs = 0;
+
+            byte[] Data = new byte[Width * Height * BytesPerPixel];
+
+            for (int Y = 0; Y < Height; Y++)
+            for (int X = 0; X < Width;  X++)
+            {
+                long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
+
+                CpuMemory.ReadBytes(Position + Offset, Data, OutOffs, BytesPerPixel);
+
+                OutOffs += BytesPerPixel;
+            }
+
+            return Data;
+        }
+
+        public static void WriteTexture(NvGpuVmm Vmm, GalImage Image, long Position, byte[] Data)
+        {
+            ISwizzle Swizzle = TextureHelper.GetSwizzle(Image);
+
+            ImageDescriptor Desc = GetImageDescriptor(Image.Format);
+
+            (int Width, int Height) = ImageUtils.GetImageSizeInBlocks(Image);
+
+            int BytesPerPixel = Desc.BytesPerPixel;
+
+            int InOffs = 0;
+
+            for (int Y = 0; Y < Height; Y++)
+            for (int X = 0; X < Width;  X++)
+            {
+                long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
+
+                Vmm.Memory.WriteBytes(Position + Offset, Data, InOffs, BytesPerPixel);
+
+                InOffs += BytesPerPixel;
+            }
         }
 
         public static int GetSize(GalImage Image)
         {
-            switch (Image.Format & GalImageFormat.FormatMask)
+            ImageDescriptor Desc = GetImageDescriptor(Image.Format);
+
+            int Width  = DivRoundUp(Image.Width,  Desc.BlockWidth);
+            int Height = DivRoundUp(Image.Height, Desc.BlockHeight);
+
+            return Desc.BytesPerPixel * Width * Height;
+        }
+
+        public static int GetPitch(GalImageFormat Format, int Width)
+        {
+            ImageDescriptor Desc = GetImageDescriptor(Format);
+
+            return Desc.BytesPerPixel * DivRoundUp(Width, Desc.BlockWidth);
+        }
+
+        public static int GetBlockWidth(GalImageFormat Format)
+        {
+            return GetImageDescriptor(Format).BlockWidth;
+        }
+
+        public static int GetBlockHeight(GalImageFormat Format)
+        {
+            return GetImageDescriptor(Format).BlockHeight;
+        }
+
+        public static int GetAlignedWidth(GalImage Image)
+        {
+            ImageDescriptor Desc = GetImageDescriptor(Image.Format);
+
+             int AlignMask;
+
+            if (Image.Layout == GalMemoryLayout.BlockLinear)
             {
-                case GalImageFormat.R32G32B32A32:
+                AlignMask = Image.TileWidth * (64 / Desc.BytesPerPixel) - 1;
-                    return Image.Width * Image.Height * 16;
+            }
-
+            else
-                case GalImageFormat.R16G16B16A16:
+            {
-                case GalImageFormat.D32_S8:
+                AlignMask = (32 / Desc.BytesPerPixel) - 1;
-                case GalImageFormat.R32G32:
-                    return Image.Width * Image.Height * 8;
-
-                case GalImageFormat.A8B8G8R8:
-                case GalImageFormat.A8B8G8R8_SRGB:
-                case GalImageFormat.A2B10G10R10:
-                case GalImageFormat.R16G16:
-                case GalImageFormat.R32:
-                case GalImageFormat.D32:
-                case GalImageFormat.B10G11R11:
-                case GalImageFormat.D24_S8:
-                    return Image.Width * Image.Height * 4;
-
-                case GalImageFormat.B4G4R4A4:
-                case GalImageFormat.A1R5G5B5:
-                case GalImageFormat.B5G6R5:
-                case GalImageFormat.R8G8:
-                case GalImageFormat.G8R8:
-                case GalImageFormat.R16:
-                case GalImageFormat.D16:
-                    return Image.Width * Image.Height * 2;
-
-                case GalImageFormat.R8:
-                    return Image.Width * Image.Height;
-
-                case GalImageFormat.BC1_RGBA:
-                case GalImageFormat.BC4:
-                {
-                    return CompressedTextureSize(Image.Width, Image.Height, 4, 4, 8);
-                }
-
-                case GalImageFormat.BC6H_SF16:
-                case GalImageFormat.BC6H_UF16:
-                case GalImageFormat.BC7:
-                case GalImageFormat.BC2:
-                case GalImageFormat.BC3:
-                case GalImageFormat.BC5:
-                case GalImageFormat.ASTC_4x4:
-                    return CompressedTextureSize(Image.Width, Image.Height, 4, 4, 16);
-
-                case GalImageFormat.ASTC_5x5:
-                    return CompressedTextureSize(Image.Width, Image.Height, 5, 5, 16);
-
-                case GalImageFormat.ASTC_6x6:
-                    return CompressedTextureSize(Image.Width, Image.Height, 6, 6, 16);
-
-                case GalImageFormat.ASTC_8x8:
-                    return CompressedTextureSize(Image.Width, Image.Height, 8, 8, 16);
-
-                case GalImageFormat.ASTC_10x10:
-                    return CompressedTextureSize(Image.Width, Image.Height, 10, 10, 16);
-
-                case GalImageFormat.ASTC_12x12:
-                    return CompressedTextureSize(Image.Width, Image.Height, 12, 12, 16);
-
-                case GalImageFormat.ASTC_5x4:
-                    return CompressedTextureSize(Image.Width, Image.Height, 5, 4, 16);
-
-                case GalImageFormat.ASTC_6x5:
-                    return CompressedTextureSize(Image.Width, Image.Height, 6, 5, 16);
-
-                case GalImageFormat.ASTC_8x6:
-                    return CompressedTextureSize(Image.Width, Image.Height, 8, 6, 16);
-
-                case GalImageFormat.ASTC_10x8:
-                    return CompressedTextureSize(Image.Width, Image.Height, 10, 8, 16);
-
-                case GalImageFormat.ASTC_12x10:
-                    return CompressedTextureSize(Image.Width, Image.Height, 12, 10, 16);
-
-                case GalImageFormat.ASTC_8x5:
-                    return CompressedTextureSize(Image.Width, Image.Height, 8, 5, 16);
-
-                case GalImageFormat.ASTC_10x5:
-                    return CompressedTextureSize(Image.Width, Image.Height, 10, 5, 16);
-
-                case GalImageFormat.ASTC_10x6:
-                    return CompressedTextureSize(Image.Width, Image.Height, 10, 6, 16);
             }
 
-            throw new NotImplementedException((Image.Format & GalImageFormat.FormatMask).ToString());
+            return (Image.Width + AlignMask) & ~AlignMask;
+        }
+
+        public static (int Width, int Height) GetImageSizeInBlocks(GalImage Image)
+        {
+            ImageDescriptor Desc = GetImageDescriptor(Image.Format);
+
+            return (DivRoundUp(Image.Width,  Desc.BlockWidth),
+                    DivRoundUp(Image.Height, Desc.BlockHeight));
+        }
+
+        public static int GetBytesPerPixel(GalImageFormat Format)
+        {
+            return GetImageDescriptor(Format).BytesPerPixel;
+        }
+
+        private static int DivRoundUp(int LHS, int RHS)
+        {
+            return (LHS + (RHS - 1)) / RHS;
         }
 
         public static bool HasColor(GalImageFormat Format)
         {
-            return GetImageDescriptor(Format).HasColor;
+            return (GetImageDescriptor(Format).Target & TargetBuffer.Color) != 0;
         }
 
         public static bool HasDepth(GalImageFormat Format)
         {
-            return GetImageDescriptor(Format).HasDepth;
+            return (GetImageDescriptor(Format).Target & TargetBuffer.Depth) != 0;
         }
 
         public static bool HasStencil(GalImageFormat Format)
         {
-            return GetImageDescriptor(Format).HasStencil;
+            return (GetImageDescriptor(Format).Target & TargetBuffer.Stencil) != 0;
         }
 
         public static bool IsCompressed(GalImageFormat Format)
         {
-            return GetImageDescriptor(Format).Compressed;
+            ImageDescriptor Desc = GetImageDescriptor(Format);
+
+            return (Desc.BlockWidth | Desc.BlockHeight) != 1;
         }
 
         private static ImageDescriptor GetImageDescriptor(GalImageFormat Format)
@@ -351,13 +385,5 @@ namespace Ryujinx.Graphics.Texture
                 default: throw new NotImplementedException(((int)Type).ToString());
             }
         }
-
-        private static int CompressedTextureSize(int TextureWidth, int TextureHeight, int BlockWidth, int BlockHeight, int Bpb)
-        {
-            int W = (TextureWidth + (BlockWidth - 1)) / BlockWidth;
-            int H = (TextureHeight + (BlockHeight - 1)) / BlockHeight;
-
-            return W * H * Bpb;
-        }
     }
 }

Ryujinx.Graphics/Texture/TextureFactory.cs

@@ -17,44 +17,20 @@ namespace Ryujinx.Graphics.Texture
             GalTextureSource ZSource = (GalTextureSource)((Tic[0] >> 25) & 7);
             GalTextureSource WSource = (GalTextureSource)((Tic[0] >> 28) & 7);
 
-            int Width  = (Tic[4] & 0xffff) + 1;
-            int Height = (Tic[5] & 0xffff) + 1;
-
-            return new GalImage(
-                Width,
-                Height,
-                Format,
-                XSource,
-                YSource,
-                ZSource,
-                WSource);
-        }
-
-        public static byte[] GetTextureData(NvGpuVmm Vmm, long TicPosition)
-        {
-            int[] Tic = ReadWords(Vmm, TicPosition, 8);
-
-            GalImageFormat Format = GetImageFormat(Tic);
-
-            long TextureAddress = (uint)Tic[1];
-
-            TextureAddress |= (long)((ushort)Tic[2]) << 32;
-
             TextureSwizzle Swizzle = (TextureSwizzle)((Tic[2] >> 21) & 7);
 
+            GalMemoryLayout Layout;
+
             if (Swizzle == TextureSwizzle.BlockLinear ||
                 Swizzle == TextureSwizzle.BlockLinearColorKey)
             {
-                TextureAddress &= ~0x1ffL;
+                Layout = GalMemoryLayout.BlockLinear;
             }
-            else if (Swizzle == TextureSwizzle.Pitch ||
+            else
-                     Swizzle == TextureSwizzle.PitchColorKey)
             {
-                TextureAddress &= ~0x1fL;
+                Layout = GalMemoryLayout.Pitch;
             }
 
-            int Pitch = (Tic[3] & 0xffff) << 5;
-
             int BlockHeightLog2 = (Tic[3] >> 3)  & 7;
             int TileWidthLog2   = (Tic[3] >> 10) & 7;
 
@@ -64,17 +40,17 @@ namespace Ryujinx.Graphics.Texture
             int Width  = (Tic[4] & 0xffff) + 1;
             int Height = (Tic[5] & 0xffff) + 1;
 
-            TextureInfo Texture = new TextureInfo(
+            return new GalImage(
-                TextureAddress,
                 Width,
                 Height,
-                Pitch,
-                BlockHeight,
                 TileWidth,
-                Swizzle,
+                BlockHeight,
-                Format);
+                Layout,
-
+                Format,
-            return TextureReader.Read(Vmm, Texture);
+                XSource,
+                YSource,
+                ZSource,
+                WSource);
         }
 
         public static GalTextureSampler MakeSampler(NvGpu Gpu, NvGpuVmm Vmm, long TscPosition)
@@ -107,7 +83,7 @@ namespace Ryujinx.Graphics.Texture
 
         private static GalImageFormat GetImageFormat(int[] Tic)
         {
-            GalTextureType RType = (GalTextureType)((Tic[0] >> 7) & 7);
+            GalTextureType RType = (GalTextureType)((Tic[0] >> 7)  & 7);
             GalTextureType GType = (GalTextureType)((Tic[0] >> 10) & 7);
             GalTextureType BType = (GalTextureType)((Tic[0] >> 13) & 7);
             GalTextureType AType = (GalTextureType)((Tic[0] >> 16) & 7);

Ryujinx.Graphics/Texture/TextureHelper.cs

@@ -1,33 +1,30 @@
 using ChocolArm64.Memory;
 using Ryujinx.Graphics.Gal;
 using Ryujinx.Graphics.Memory;
-using System;
 
 namespace Ryujinx.Graphics.Texture
 {
     static class TextureHelper
     {
-        public static ISwizzle GetSwizzle(TextureInfo Texture, int BlockWidth, int Bpp)
+        public static ISwizzle GetSwizzle(GalImage Image)
         {
-            int Width = (Texture.Width + (BlockWidth - 1)) / BlockWidth;
+            int BlockWidth    = ImageUtils.GetBlockWidth   (Image.Format);
+            int BytesPerPixel = ImageUtils.GetBytesPerPixel(Image.Format);
 
-            int AlignMask = Texture.TileWidth * (64 / Bpp) - 1;
+            int Width = (Image.Width + (BlockWidth - 1)) / BlockWidth;
 
-            Width = (Width + AlignMask) & ~AlignMask;
+            if (Image.Layout == GalMemoryLayout.BlockLinear)
-
-            switch (Texture.Swizzle)
             {
-                case TextureSwizzle._1dBuffer:
+                int AlignMask = Image.TileWidth * (64 / BytesPerPixel) - 1;
-                case TextureSwizzle.Pitch:
-                case TextureSwizzle.PitchColorKey:
-                     return new LinearSwizzle(Texture.Pitch, Bpp);
 
-                case TextureSwizzle.BlockLinear:
+                Width = (Width + AlignMask) & ~AlignMask;
-                case TextureSwizzle.BlockLinearColorKey:
+
-                    return new BlockLinearSwizzle(Width, Bpp, Texture.BlockHeight);
+                return new BlockLinearSwizzle(Width, BytesPerPixel, Image.GobBlockHeight);
+            }
+            else
+            {
+                return new LinearSwizzle(Image.Pitch, BytesPerPixel);
             }
-
-            throw new NotImplementedException(Texture.Swizzle.ToString());
         }
 
         public static (AMemory Memory, long Position) GetMemoryAndPosition(

Ryujinx.Graphics/Texture/TextureInfo.cs

@@ -1,60 +0,0 @@
-using Ryujinx.Graphics.Gal;
-
-namespace Ryujinx.Graphics.Texture
-{
-    public struct TextureInfo
-    {
-        public long Position { get; private set; }
-
-        public int Width  { get; private set; }
-        public int Height { get; private set; }
-        public int Pitch  { get; private set; }
-
-        public int BlockHeight { get; private set; }
-        public int TileWidth   { get; private set; }
-
-        public TextureSwizzle Swizzle { get; private set; }
-
-        public GalImageFormat Format { get; private set; }
-
-        public TextureInfo(
-            long Position,
-            int  Width,
-            int  Height)
-        {
-            this.Position = Position;
-            this.Width    = Width;
-            this.Height   = Height;
-
-            Pitch = 0;
-
-            BlockHeight = 16;
-
-            TileWidth = 1;
-
-            Swizzle = TextureSwizzle.BlockLinear;
-
-            Format = GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm;
-        }
-
-        public TextureInfo(
-            long             Position,
-            int              Width,
-            int              Height,
-            int              Pitch,
-            int              BlockHeight,
-            int              TileWidth,
-            TextureSwizzle   Swizzle,
-            GalImageFormat   Format)
-        {
-            this.Position     = Position;
-            this.Width        = Width;
-            this.Height       = Height;
-            this.Pitch        = Pitch;
-            this.BlockHeight  = BlockHeight;
-            this.TileWidth    = TileWidth;
-            this.Swizzle      = Swizzle;
-            this.Format       = Format;
-        }
-    }
-}

Ryujinx.Graphics/Texture/TextureReader.cs

@@ -1,398 +0,0 @@
-using ChocolArm64.Memory;
-using Ryujinx.Graphics.Gal;
-using System;
-
-namespace Ryujinx.Graphics.Texture
-{
-    delegate byte[] TextureReaderDelegate(IAMemory Memory, TextureInfo Texture);
-
-    public static class TextureReader
-    {
-        public static byte[] Read(IAMemory Memory, TextureInfo Texture)
-        {
-            TextureReaderDelegate Reader = ImageUtils.GetReader(Texture.Format);
-
-            return Reader(Memory, Texture);
-        }
-
-        internal unsafe static byte[] Read1Bpp(IAMemory Memory, TextureInfo Texture)
-        {
-            int Width  = Texture.Width;
-            int Height = Texture.Height;
-
-            byte[] Output = new byte[Width * Height];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 1, 1);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    byte Pixel = CpuMem.ReadByte(Position + Offset);
-
-                    *(BuffPtr + OutOffs) = Pixel;
-
-                    OutOffs++;
-                }
-            }
-
-            return Output;
-        }
-
-        internal unsafe static byte[] Read5551(IAMemory Memory, TextureInfo Texture)
-        {
-            int Width  = Texture.Width;
-            int Height = Texture.Height;
-
-            byte[] Output = new byte[Width * Height * 2];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 1, 2);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    uint Pixel = (uint)CpuMem.ReadInt16(Position + Offset);
-
-                    Pixel = (Pixel & 0x001f) << 11 |
-                            (Pixel & 0x03e0) << 1  |
-                            (Pixel & 0x7c00) >> 9  |
-                            (Pixel & 0x8000) >> 15;
-
-                    *(short*)(BuffPtr + OutOffs) = (short)Pixel;
-
-                    OutOffs += 2;
-                }
-            }
-
-            return Output;
-        }
-
-        internal unsafe static byte[] Read565(IAMemory Memory, TextureInfo Texture)
-        {
-            int Width  = Texture.Width;
-            int Height = Texture.Height;
-
-            byte[] Output = new byte[Width * Height * 2];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 1, 2);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    uint Pixel = (uint)CpuMem.ReadInt16(Position + Offset);
-
-                    Pixel = (Pixel & 0x001f) << 11 |
-                            (Pixel & 0x07e0)       |
-                            (Pixel & 0xf800) >> 11;
-
-                    *(short*)(BuffPtr + OutOffs) = (short)Pixel;
-
-                    OutOffs += 2;
-                }
-            }
-
-            return Output;
-        }
-
-        internal unsafe static byte[] Read2Bpp(IAMemory Memory, TextureInfo Texture)
-        {
-            int Width  = Texture.Width;
-            int Height = Texture.Height;
-
-            byte[] Output = new byte[Width * Height * 2];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 1, 2);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    short Pixel = CpuMem.ReadInt16(Position + Offset);
-
-                    *(short*)(BuffPtr + OutOffs) = Pixel;
-
-                    OutOffs += 2;
-                }
-            }
-
-            return Output;
-        }
-
-        internal unsafe static byte[] Read4Bpp(IAMemory Memory, TextureInfo Texture)
-        {
-            int Width  = Texture.Width;
-            int Height = Texture.Height;
-
-            byte[] Output = new byte[Width * Height * 4];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 1, 4);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    int Pixel = CpuMem.ReadInt32(Position + Offset);
-
-                    *(int*)(BuffPtr + OutOffs) = Pixel;
-
-                    OutOffs += 4;
-                }
-            }
-
-            return Output;
-        }
-
-        internal unsafe static byte[] Read8Bpp(IAMemory Memory, TextureInfo Texture)
-        {
-            int Width  = Texture.Width;
-            int Height = Texture.Height;
-
-            byte[] Output = new byte[Width * Height * 8];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 1, 8);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    long Pixel = CpuMem.ReadInt64(Position + Offset);
-
-                    *(long*)(BuffPtr + OutOffs) = Pixel;
-
-                    OutOffs += 8;
-                }
-            }
-
-            return Output;
-        }
-
-        internal unsafe static byte[] Read16Bpp(IAMemory Memory, TextureInfo Texture)
-        {
-            int Width  = Texture.Width;
-            int Height = Texture.Height;
-
-            byte[] Output = new byte[Width * Height * 16];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 1, 16);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    long PxLow  = CpuMem.ReadInt64(Position + Offset + 0);
-                    long PxHigh = CpuMem.ReadInt64(Position + Offset + 8);
-
-                    *(long*)(BuffPtr + OutOffs + 0) = PxLow;
-                    *(long*)(BuffPtr + OutOffs + 8) = PxHigh;
-
-                    OutOffs += 16;
-                }
-            }
-
-            return Output;
-        }
-
-        internal unsafe static byte[] Read8Bpt4x4(IAMemory Memory, TextureInfo Texture)
-        {
-            int Width  = (Texture.Width  + 3) / 4;
-            int Height = (Texture.Height + 3) / 4;
-
-            byte[] Output = new byte[Width * Height * 8];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 4, 8);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    long Tile = CpuMem.ReadInt64(Position + Offset);
-
-                    *(long*)(BuffPtr + OutOffs) = Tile;
-
-                    OutOffs += 8;
-                }
-            }
-
-            return Output;
-        }
-
-        internal unsafe static byte[] Read16BptCompressedTexture(IAMemory Memory, TextureInfo Texture, int BlockWidth, int BlockHeight)
-        {
-            int Width  = (Texture.Width  + (BlockWidth - 1)) / BlockWidth;
-            int Height = (Texture.Height + (BlockHeight - 1)) / BlockHeight;
-
-            byte[] Output = new byte[Width * Height * 16];
-
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, BlockWidth, 16);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Output)
-            {
-                long OutOffs = 0;
-
-                for (int Y = 0; Y < Height; Y++)
-                for (int X = 0; X < Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    long Tile0 = CpuMem.ReadInt64(Position + Offset + 0);
-                    long Tile1 = CpuMem.ReadInt64(Position + Offset + 8);
-
-                    *(long*)(BuffPtr + OutOffs + 0) = Tile0;
-                    *(long*)(BuffPtr + OutOffs + 8) = Tile1;
-
-                    OutOffs += 16;
-                }
-            }
-
-            return Output;
-        }
-
-        internal static byte[] Read16BptCompressedTexture4x4(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 4, 4);
-        }
-
-        internal static byte[] Read16BptCompressedTexture5x5(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 5, 5);
-        }
-
-        internal static byte[] Read16BptCompressedTexture6x6(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 6, 6);
-        }
-
-        internal static byte[] Read16BptCompressedTexture8x8(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 8, 8);
-        }
-
-        internal static byte[] Read16BptCompressedTexture10x10(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 10, 10);
-        }
-
-        internal static byte[] Read16BptCompressedTexture12x12(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 12, 12);
-        }
-
-        internal static byte[] Read16BptCompressedTexture5x4(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 5, 4);
-        }
-
-        internal static byte[] Read16BptCompressedTexture6x5(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 6, 5);
-        }
-
-        internal static byte[] Read16BptCompressedTexture8x6(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 8, 6);
-        }
-
-        internal static byte[] Read16BptCompressedTexture10x8(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 10, 8);
-        }
-
-        internal static byte[] Read16BptCompressedTexture12x10(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 12, 10);
-        }
-
-        internal static byte[] Read16BptCompressedTexture8x5(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 5, 5);
-        }
-
-        internal static byte[] Read16BptCompressedTexture10x5(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 10, 5);
-        }
-
-        internal static byte[] Read16BptCompressedTexture10x6(IAMemory Memory, TextureInfo Texture)
-        {
-            return Read16BptCompressedTexture(Memory, Texture, 10, 6);
-        }
-    }
-}

Ryujinx.Graphics/Texture/TextureWriter.cs

@@ -1,35 +0,0 @@
-using ChocolArm64.Memory;
-using Ryujinx.Graphics.Gal;
-using Ryujinx.Graphics.Memory;
-
-namespace Ryujinx.Graphics.Texture
-{
-    static class TextureWriter
-    {
-        public unsafe static void Write(IAMemory Memory, TextureInfo Texture, byte[] Data)
-        {
-            ISwizzle Swizzle = TextureHelper.GetSwizzle(Texture, 1, 4);
-
-            (AMemory CpuMem, long Position) = TextureHelper.GetMemoryAndPosition(
-                Memory,
-                Texture.Position);
-
-            fixed (byte* BuffPtr = Data)
-            {
-                long InOffs = 0;
-
-                for (int Y = 0; Y < Texture.Height; Y++)
-                for (int X = 0; X < Texture.Width;  X++)
-                {
-                    long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
-
-                    int Pixel = *(int*)(BuffPtr + InOffs);
-
-                    CpuMem.WriteInt32(Position + Offset, Pixel);
-
-                    InOffs += 4;
-                }
-            }
-        }
-    }
-}

Ryujinx.Graphics/ValueRange.cs

@@ -0,0 +1,17 @@
+namespace Ryujinx.Graphics
+{
+    struct ValueRange<T>
+    {
+        public long Start { get; private set; }
+        public long End   { get; private set; }
+
+        public T Value { get; set; }
+
+        public ValueRange(long Start, long End, T Value = default(T))
+        {
+            this.Start = Start;
+            this.End   = End;
+            this.Value = Value;
+        }
+    }
+}

Ryujinx.Graphics/ValueRangeSet.cs

@@ -0,0 +1,234 @@
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics
+{
+    class ValueRangeSet<T>
+    {
+        private List<ValueRange<T>> Ranges;
+
+        public ValueRangeSet()
+        {
+            Ranges = new List<ValueRange<T>>();
+        }
+
+        public void Add(ValueRange<T> Range)
+        {
+            if (Range.End <= Range.Start)
+            {
+                //Empty or invalid range, do nothing.
+                return;
+            }
+
+            int First = BinarySearchFirstIntersection(Range);
+
+            if (First == -1)
+            {
+                //No intersections case.
+                //Find first greater than range (after the current one).
+                //If found, add before, otherwise add to the end of the list.
+                int GtIndex = BinarySearchGt(Range);
+
+                if (GtIndex != -1)
+                {
+                    Ranges.Insert(GtIndex, Range);
+                }
+                else
+                {
+                    Ranges.Add(Range);
+                }
+
+                return;
+            }
+
+            (int Start, int End) = GetAllIntersectionRanges(Range, First);
+
+            ValueRange<T> Prev = Ranges[Start];
+            ValueRange<T> Next = Ranges[End];
+
+            Ranges.RemoveRange(Start, (End - Start) + 1);
+
+            InsertNextNeighbour(Start, Range, Next);
+
+            int NewIndex = Start;
+
+            Ranges.Insert(Start, Range);
+
+            InsertPrevNeighbour(Start, Range, Prev);
+
+            //Try merging neighbours if the value is equal.
+            if (NewIndex > 0)
+            {
+                Prev = Ranges[NewIndex - 1];
+
+                if (Prev.End == Range.Start && CompareValues(Prev, Range))
+                {
+                    Ranges.RemoveAt(--NewIndex);
+
+                    Ranges[NewIndex] = new ValueRange<T>(Prev.Start, Range.End, Range.Value);
+                }
+            }
+
+            if (NewIndex < Ranges.Count - 1)
+            {
+                Next = Ranges[NewIndex + 1];
+
+                if (Next.Start == Range.End && CompareValues(Next, Range))
+                {
+                    Ranges.RemoveAt(NewIndex + 1);
+
+                    Ranges[NewIndex] = new ValueRange<T>(Range.Start, Next.End, Range.Value);
+                }
+            }
+        }
+
+        private bool CompareValues(ValueRange<T> LHS, ValueRange<T> RHS)
+        {
+            return LHS.Value?.Equals(RHS.Value) ?? RHS.Value == null;
+        }
+
+        public void Remove(ValueRange<T> Range)
+        {
+            int First = BinarySearchFirstIntersection(Range);
+
+            if (First == -1)
+            {
+                //Nothing to remove.
+                return;
+            }
+
+            (int Start, int End) = GetAllIntersectionRanges(Range, First);
+
+            ValueRange<T> Prev = Ranges[Start];
+            ValueRange<T> Next = Ranges[End];
+
+            Ranges.RemoveRange(Start, (End - Start) + 1);
+
+            InsertNextNeighbour(Start, Range, Next);
+            InsertPrevNeighbour(Start, Range, Prev);
+        }
+
+        private void InsertNextNeighbour(int Index, ValueRange<T> Range, ValueRange<T> Next)
+        {
+            //Split last intersection (ordered by Start) if necessary.
+            if (Range.End < Next.End)
+            {
+                InsertNewRange(Index, Range.End, Next.End, Next.Value);
+            }
+        }
+
+        private void InsertPrevNeighbour(int Index, ValueRange<T> Range, ValueRange<T> Prev)
+        {
+            //Split first intersection (ordered by Start) if necessary.
+            if (Range.Start > Prev.Start)
+            {
+                InsertNewRange(Index, Prev.Start, Range.Start, Prev.Value);
+            }
+        }
+
+        private void InsertNewRange(int Index, long Start, long End, T Value)
+        {
+            Ranges.Insert(Index, new ValueRange<T>(Start, End, Value));
+        }
+
+        public ValueRange<T>[] GetAllIntersections(ValueRange<T> Range)
+        {
+            int First = BinarySearchFirstIntersection(Range);
+
+            if (First == -1)
+            {
+                return new ValueRange<T>[0];
+            }
+
+            (int Start, int End) = GetAllIntersectionRanges(Range, First);
+
+            return Ranges.GetRange(Start, (End - Start) + 1).ToArray();
+        }
+
+        private (int Start, int End) GetAllIntersectionRanges(ValueRange<T> Range, int BaseIndex)
+        {
+            int Start = BaseIndex;
+            int End   = BaseIndex;
+
+            while (Start > 0 && Intersects(Range, Ranges[Start - 1]))
+            {
+                Start--;
+            }
+
+            while (End < Ranges.Count - 1 && Intersects(Range, Ranges[End + 1]))
+            {
+                End++;
+            }
+
+            return (Start, End);
+        }
+
+        private int BinarySearchFirstIntersection(ValueRange<T> Range)
+        {
+            int Left  = 0;
+            int Right = Ranges.Count - 1;
+
+            while (Left <= Right)
+            {
+                int Size = Right - Left;
+
+                int Middle = Left + (Size >> 1);
+
+                ValueRange<T> Current = Ranges[Middle];
+
+                if (Intersects(Range, Current))
+                {
+                    return Middle;
+                }
+
+                if (Range.Start < Current.Start)
+                {
+                    Right = Middle - 1;
+                }
+                else
+                {
+                    Left = Middle + 1;
+                }
+            }
+
+            return -1;
+        }
+
+        private int BinarySearchGt(ValueRange<T> Range)
+        {
+            int GtIndex = -1;
+
+            int Left  = 0;
+            int Right = Ranges.Count - 1;
+
+            while (Left <= Right)
+            {
+                int Size = Right - Left;
+
+                int Middle = Left + (Size >> 1);
+
+                ValueRange<T> Current = Ranges[Middle];
+
+                if (Range.Start < Current.Start)
+                {
+                    Right = Middle - 1;
+
+                    if (GtIndex == -1 || Current.Start < Ranges[GtIndex].Start)
+                    {
+                        GtIndex = Middle;
+                    }
+                }
+                else
+                {
+                    Left = Middle + 1;
+                }
+            }
+
+            return GtIndex;
+        }
+
+        private bool Intersects(ValueRange<T> LHS, ValueRange<T> RHS)
+        {
+            return LHS.Start < RHS.End && RHS.Start < LHS.End;
+        }
+    }
+}

Ryujinx.HLE/HOS/Kernel/SvcSystem.cs

@@ -288,7 +288,8 @@ namespace Ryujinx.HLE.HOS.Kernel
             //Fail for info not available on older Kernel versions.
             if (InfoType == 18 ||
                 InfoType == 19 ||
-                InfoType == 20)
+                InfoType == 20 ||
+                InfoType == 21)
             {
                 ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidEnumValue);
 

Ryujinx.HLE/HOS/Services/Acc/IProfile.cs

@@ -3,7 +3,6 @@ using Ryujinx.HLE.HOS.Ipc;
 using Ryujinx.HLE.HOS.SystemState;
 using Ryujinx.HLE.Logging;
 using Ryujinx.HLE.Utilities;
-using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;

Ryujinx.HLE/HOS/Services/Vi/IHOSBinderDriver.cs

@@ -13,7 +13,7 @@ namespace Ryujinx.HLE.HOS.Services.Vi
 
         public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
 
-        private KEvent ReleaseEvent;
+        private KEvent BinderEvent;
 
         private NvFlinger Flinger;
 
@@ -27,9 +27,11 @@ namespace Ryujinx.HLE.HOS.Services.Vi
                 { 3, TransactParcelAuto }
             };
 
-            ReleaseEvent = new KEvent();
+            BinderEvent = new KEvent();
 
-            Flinger = new NvFlinger(Renderer, ReleaseEvent);
+            BinderEvent.WaitEvent.Set();
+
+            Flinger = new NvFlinger(Renderer, BinderEvent);
         }
 
         public long TransactParcel(ServiceCtx Context)
@@ -75,7 +77,7 @@ namespace Ryujinx.HLE.HOS.Services.Vi
             int  Id  = Context.RequestData.ReadInt32();
             uint Unk = Context.RequestData.ReadUInt32();
 
-            int Handle = Context.Process.HandleTable.OpenHandle(ReleaseEvent);
+            int Handle = Context.Process.HandleTable.OpenHandle(BinderEvent);
 
             Context.Response.HandleDesc = IpcHandleDesc.MakeMove(Handle);
 
@@ -91,7 +93,7 @@ namespace Ryujinx.HLE.HOS.Services.Vi
         {
             if (Disposing)
             {
-                ReleaseEvent.Dispose();
+                BinderEvent.Dispose();
 
                 Flinger.Dispose();
             }

Ryujinx.HLE/HOS/Services/Vi/NvFlinger.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Graphics.Gal;
-using Ryujinx.Graphics.Texture;
+using Ryujinx.Graphics.Memory;
 using Ryujinx.HLE.HOS.Kernel;
+using Ryujinx.HLE.HOS.Services.Nv.NvGpuAS;
 using Ryujinx.HLE.HOS.Services.Nv.NvMap;
 using Ryujinx.HLE.Logging;
 using System;
@@ -19,7 +20,7 @@ namespace Ryujinx.HLE.HOS.Services.Android
 
         private Dictionary<(string, int), ServiceProcessParcel> Commands;
 
-        private KEvent ReleaseEvent;
+        private KEvent BinderEvent;
 
         private IGalRenderer Renderer;
 
@@ -67,7 +68,7 @@ namespace Ryujinx.HLE.HOS.Services.Android
 
         private bool Disposed;
 
-        public NvFlinger(IGalRenderer Renderer, KEvent ReleaseEvent)
+        public NvFlinger(IGalRenderer Renderer, KEvent BinderEvent)
         {
             Commands = new Dictionary<(string, int), ServiceProcessParcel>()
             {
@@ -82,8 +83,8 @@ namespace Ryujinx.HLE.HOS.Services.Android
                 { ("android.gui.IGraphicBufferProducer", 0xe), GbpPreallocBuffer }
             };
 
-            this.Renderer     = Renderer;
+            this.Renderer    = Renderer;
-            this.ReleaseEvent = ReleaseEvent;
+            this.BinderEvent = BinderEvent;
 
             BufferQueue = new BufferEntry[0x40];
 
@@ -301,42 +302,41 @@ namespace Ryujinx.HLE.HOS.Services.Android
             bool FlipX = BufferQueue[Slot].Transform.HasFlag(HalTransform.FlipX);
             bool FlipY = BufferQueue[Slot].Transform.HasFlag(HalTransform.FlipY);
 
-            //Rotation is being ignored
+            //Note: Rotation is being ignored.
 
             int Top    = Crop.Top;
             int Left   = Crop.Left;
             int Right  = Crop.Right;
             int Bottom = Crop.Bottom;
 
-            Renderer.QueueAction(() => Renderer.RenderTarget.SetTransform(FlipX, FlipY, Top, Left, Right, Bottom));
+            NvGpuVmm Vmm = NvGpuASIoctl.GetASCtx(Context).Vmm;
 
-            //TODO: Support double buffering here aswell, it is broken for GPU
+            Renderer.QueueAction(() =>
-            //frame buffers because it seems to be completely out of sync.
-            if (Context.Device.Gpu.Engine3d.IsFrameBufferPosition(FbAddr))
             {
-                //Frame buffer is rendered to by the GPU, we can just
+                if (!Renderer.Texture.TryGetImage(FbAddr, out GalImage Image))
-                //bind the frame buffer texture, it's not necessary to read anything.
+                {
-                Renderer.QueueAction(() => Renderer.RenderTarget.Set(FbAddr));
+                    Image = new GalImage(
-            }
+                        FbWidth,
-            else
+                        FbHeight, 1, 16,
-            {
+                        GalMemoryLayout.BlockLinear,
-                //Frame buffer is not set on the GPU registers, in this case
+                        GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm);
-                //assume that the app is manually writing to it.
+                }
-                TextureInfo Texture = new TextureInfo(FbAddr, FbWidth, FbHeight);
 
-                byte[] Data = TextureReader.Read(Context.Memory, Texture);
+                Context.Device.Gpu.ResourceManager.ClearPbCache();
+                Context.Device.Gpu.ResourceManager.SendTexture(Vmm, FbAddr, Image);
 
-                Renderer.QueueAction(() => Renderer.RenderTarget.Set(Data, FbWidth, FbHeight));
+                Renderer.RenderTarget.SetTransform(FlipX, FlipY, Top, Left, Right, Bottom);
-            }
+                Renderer.RenderTarget.Set(FbAddr);
 
-            Context.Device.Gpu.Renderer.QueueAction(() => ReleaseBuffer(Slot));
+                ReleaseBuffer(Slot);
+            });
         }
 
         private void ReleaseBuffer(int Slot)
         {
             BufferQueue[Slot].State = BufferState.Free;
 
-            ReleaseEvent.WaitEvent.Set();
+            BinderEvent.WaitEvent.Set();
 
             lock (WaitBufferFree)
             {