Support deswizzle of sparse tiled textures and some frame buffer fixes (#275)

* Attempt to support deswizzle of sparse tiled textures

* Use correct frame buffer and viewport sizes, started to clean up the copy engine

* Correct texture width alignment

* Use Scale/Translate registers to calculate viewport rect

* Allow texture copy between frame buffers

3 files changed, 113 insertions, 57 deletions

diff --git a/Ryujinx.HLE/Gpu/Engines/NvGpuEngine2d.cs b/Ryujinx.HLE/Gpu/Engines/NvGpuEngine2d.cs
index f150b3f5..d2c5f126 100644
--- a/Ryujinx.HLE/Gpu/Engines/NvGpuEngine2d.cs
+++ b/Ryujinx.HLE/Gpu/Engines/NvGpuEngine2d.cs
@@ -1,6 +1,7 @@
 using Ryujinx.Graphics.Gal;
 using Ryujinx.HLE.Gpu.Memory;
 using Ryujinx.HLE.Gpu.Texture;
+using System;
 using System.Collections.Generic;
 
 namespace Ryujinx.HLE.Gpu.Engines
@@ -64,6 +65,8 @@ namespace Ryujinx.HLE.Gpu.Engines
             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);
 
             bool DstLinear = ReadRegister(NvGpuEngine2dReg.DstLinear) != 0;
             int  DstWidth  = ReadRegister(NvGpuEngine2dReg.DstWidth);
@@ -71,73 +74,112 @@ namespace Ryujinx.HLE.Gpu.Engines
             int  DstPitch  = ReadRegister(NvGpuEngine2dReg.DstPitch);
             int  DstBlkDim = ReadRegister(NvGpuEngine2dReg.DstBlockDimensions);
 
+            TextureSwizzle SrcSwizzle = SrcLinear
+                ? TextureSwizzle.Pitch
+                : TextureSwizzle.BlockLinear;
+
             TextureSwizzle DstSwizzle = DstLinear
                 ? TextureSwizzle.Pitch
                 : TextureSwizzle.BlockLinear;
 
+            int SrcBlockHeight = 1 << ((SrcBlkDim >> 4) & 0xf);
             int DstBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf);
 
-            long Key = Vmm.GetPhysicalAddress(MakeInt64From2xInt32(NvGpuEngine2dReg.SrcAddress));
-
             long SrcAddress = MakeInt64From2xInt32(NvGpuEngine2dReg.SrcAddress);
             long DstAddress = MakeInt64From2xInt32(NvGpuEngine2dReg.DstAddress);
 
-            bool IsFbTexture = Gpu.Engine3d.IsFrameBufferPosition(Key);
+            long SrcKey = Vmm.GetPhysicalAddress(SrcAddress);
+            long DstKey = Vmm.GetPhysicalAddress(DstAddress);
+
+            bool IsSrcFb = Gpu.Engine3d.IsFrameBufferPosition(SrcKey);
+            bool IsDstFb = Gpu.Engine3d.IsFrameBufferPosition(DstKey);
 
-            if (IsFbTexture && DstLinear)
+            TextureInfo SrcTexture()
             {
-                DstSwizzle = TextureSwizzle.BlockLinear;
+                return new TextureInfo(
+                    SrcAddress,
+                    SrcWidth,
+                    SrcHeight,
+                    SrcPitch,
+                    SrcBlockHeight, 1,
+                    SrcSwizzle,
+                    GalTextureFormat.A8B8G8R8);
             }
 
-            TextureInfo DstTexture = new TextureInfo(
-                DstAddress,
-                DstWidth,
-                DstHeight,
-                DstBlockHeight,
-                DstBlockHeight,
-                DstSwizzle,
-                GalTextureFormat.A8B8G8R8);
-
-            if (IsFbTexture)
+            TextureInfo DstTexture()
             {
-                //TODO: Change this when the correct frame buffer resolution is used.
-                //Currently, the frame buffer size is hardcoded to 1280x720.
-                SrcWidth  = 1280;
-                SrcHeight = 720;
+                return new TextureInfo(
+                    DstAddress,
+                    DstWidth,
+                    DstHeight,
+                    DstPitch,
+                    DstBlockHeight, 1,
+                    DstSwizzle,
+                    GalTextureFormat.A8B8G8R8);
+            }
 
-                Gpu.Renderer.FrameBuffer.GetBufferData(Key, (byte[] Buffer) =>
+            //TODO: fb -> fb copies, tex -> fb copies, formats other than RGBA8,
+            //make it throw for unimpl stuff (like the copy mode)...
+            if (IsSrcFb && IsDstFb)
+            {
+                //Frame Buffer -> Frame Buffer copy.
+                Gpu.Renderer.FrameBuffer.Copy(
+                    SrcKey,
+                    DstKey,
+                    0,
+                    0,
+                    SrcWidth,
+                    SrcHeight,
+                    0,
+                    0,
+                    DstWidth,
+                    DstHeight);
+            }
+            if (IsSrcFb)
+            {
+                //Frame Buffer -> Texture copy.
+                Gpu.Renderer.FrameBuffer.GetBufferData(SrcKey, (byte[] Buffer) =>
                 {
-                    CopyTexture(
-                        Vmm,
-                        DstTexture,
-                        Buffer,
-                        SrcWidth,
-                        SrcHeight);
+                    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, Buffer);
                 });
             }
-            else
+            else if (IsDstFb)
             {
-                long Size = SrcWidth * SrcHeight * 4;
+                //Texture -> Frame Buffer copy.
+                const GalTextureFormat Format = GalTextureFormat.A8B8G8R8;
 
-                byte[] Buffer = Vmm.ReadBytes(SrcAddress, Size);
+                byte[] Buffer = TextureReader.Read(Vmm, SrcTexture());
 
-                CopyTexture(
-                    Vmm,
-                    DstTexture,
-                    Buffer,
-                    SrcWidth,
-                    SrcHeight);
+                Gpu.Renderer.FrameBuffer.SetBufferData(
+                    DstKey,
+                    DstWidth,
+                    DstHeight,
+                    Format,
+                    Buffer);
             }
-        }
+            else
+            {
+                //Texture -> Texture copy.
+                TextureInfo Src = SrcTexture();
+                TextureInfo Dst = DstTexture();
 
-        private void CopyTexture(
-            NvGpuVmm    Vmm,
-            TextureInfo Texture,
-            byte[]      Buffer,
-            int         Width,
-            int         Height)
-        {
-            TextureWriter.Write(Vmm, Texture, Buffer, Width, Height);
+                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)
diff --git a/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs b/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs
index 5c474ab0..dce25a5e 100644
--- a/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs
+++ b/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3d.cs
@@ -132,10 +132,22 @@ namespace Ryujinx.HLE.Gpu.Engines
             int Width  = ReadRegister(NvGpuEngine3dReg.FrameBufferNWidth  + FbIndex * 0x10);
             int Height = ReadRegister(NvGpuEngine3dReg.FrameBufferNHeight + FbIndex * 0x10);
 
-            //Note: Using the Width/Height results seems to give incorrect results.
-            //Maybe the size of all frame buffers is hardcoded to screen size? This seems unlikely.
-            Gpu.Renderer.FrameBuffer.Create(Key, 1280, 720);
+            float TX = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNTranslateX + FbIndex * 4);
+            float TY = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNTranslateY + FbIndex * 4);
+
+            float SX = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNScaleX + FbIndex * 4);
+            float SY = ReadRegisterFloat(NvGpuEngine3dReg.ViewportNScaleY + FbIndex * 4);
+
+            int VpX = (int)MathF.Max(0, TX - MathF.Abs(SX));
+            int VpY = (int)MathF.Max(0, TY - MathF.Abs(SY));
+
+            int VpW = (int)(TX + MathF.Abs(SX)) - VpX;
+            int VpH = (int)(TY + MathF.Abs(SY)) - VpY;
+
+            Gpu.Renderer.FrameBuffer.Create(Key, Width, Height);
             Gpu.Renderer.FrameBuffer.Bind(Key);
+
+            Gpu.Renderer.FrameBuffer.SetViewport(VpX, VpY, VpW, VpH);
         }
 
         private long[] UploadShaders(NvGpuVmm Vmm)
@@ -195,8 +207,8 @@ namespace Ryujinx.HLE.Gpu.Engines
                 Gpu.Renderer.Shader.Bind(Key);
             }
 
-            float SignX = GetFlipSign(NvGpuEngine3dReg.ViewportScaleX);
-            float SignY = GetFlipSign(NvGpuEngine3dReg.ViewportScaleY);
+            float SignX = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleX);
+            float SignY = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleY);
 
             Gpu.Renderer.Shader.SetFlip(SignX, SignY);
 
@@ -220,8 +232,8 @@ namespace Ryujinx.HLE.Gpu.Engines
 
         private void SetFrontFace()
         {
-            float SignX = GetFlipSign(NvGpuEngine3dReg.ViewportScaleX);
-            float SignY = GetFlipSign(NvGpuEngine3dReg.ViewportScaleY);
+            float SignX = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleX);
+            float SignY = GetFlipSign(NvGpuEngine3dReg.ViewportNScaleY);
 
             GalFrontFace FrontFace = (GalFrontFace)ReadRegister(NvGpuEngine3dReg.FrontFace);
 
diff --git a/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3dReg.cs b/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3dReg.cs
index 3de2885e..e7dabe44 100644
--- a/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3dReg.cs
+++ b/Ryujinx.HLE/Gpu/Engines/NvGpuEngine3dReg.cs
@@ -6,12 +6,14 @@ namespace Ryujinx.HLE.Gpu.Engines
         FrameBufferNWidth    = 0x202,
         FrameBufferNHeight   = 0x203,
         FrameBufferNFormat   = 0x204,
-        ViewportScaleX       = 0x280,
-        ViewportScaleY       = 0x281,
-        ViewportScaleZ       = 0x282,
-        ViewportTranslateX   = 0x283,
-        ViewportTranslateY   = 0x284,
-        ViewportTranslateZ   = 0x285,
+        ViewportNScaleX      = 0x280,
+        ViewportNScaleY      = 0x281,
+        ViewportNScaleZ      = 0x282,
+        ViewportNTranslateX  = 0x283,
+        ViewportNTranslateY  = 0x284,
+        ViewportNTranslateZ  = 0x285,
+        ViewportNHoriz       = 0x300,
+        ViewportNVert        = 0x301,
         VertexArrayFirst     = 0x35d,
         VertexArrayCount     = 0x35e,
         ClearDepth           = 0x364,