Ryujinx/Ryujinx.Graphics/Graphics3d/NvGpuEngineM2mf.cs
Alex Barney b2b736abc2 Misc cleanup (#708)
* Fix typos

* Remove unneeded using statements

* Enforce var style more

* Remove redundant qualifiers

* Fix some indentation

* Disable naming warnings on files with external enum names

* Fix build

* Mass find & replace for comments with no spacing

* Standardize todo capitalization and for/if spacing
2019-07-02 04:39:22 +02:00

214 lines
7.3 KiB
C#

using Ryujinx.Graphics.Memory;
using Ryujinx.Graphics.Texture;
using System.Collections.Generic;
using Ryujinx.Profiler;
namespace Ryujinx.Graphics.Graphics3d
{
class NvGpuEngineM2mf : INvGpuEngine
{
public int[] Registers { get; private set; }
private NvGpu _gpu;
private Dictionary<int, NvGpuMethod> _methods;
public NvGpuEngineM2mf(NvGpu gpu)
{
_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, GpuMethodCall methCall)
{
if (_methods.TryGetValue(methCall.Method, out NvGpuMethod method))
{
ProfileConfig profile = Profiles.GPU.EngineM2mf.CallMethod;
profile.SessionItem = method.Method.Name;
Profile.Begin(profile);
method(vmm, methCall);
Profile.End(profile);
}
else
{
WriteRegister(methCall);
}
}
private void Execute(NvGpuVmm vmm, GpuMethodCall methCall)
{
Profile.Begin(Profiles.GPU.EngineM2mf.Execute);
// TODO: Some registers and copy modes are still not implemented.
int control = methCall.Argument;
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, srcSizeX, srcSizeY);
}
else
{
srcSwizzle = new BlockLinearSwizzle(
srcSizeX,
srcSizeY, 1,
srcBlockHeight, 1,
srcCpp);
}
ISwizzle dstSwizzle;
if (dstLinear)
{
dstSwizzle = new LinearSwizzle(dstPitch, dstCpp, srcSizeX, srcSizeY);
}
else
{
dstSwizzle = new BlockLinearSwizzle(
dstSizeX,
dstSizeY, 1,
dstBlockHeight, 1,
dstCpp);
}
// Calculate the bits per pixel
int bpp = srcPitch / xCount;
// Copying all the bits at the same time corrupts the texture, unknown why but probably because the texture isn't linear
// To avoid this we will simply loop more times to cover all the bits,
// this allows up to recalculate the memory locations for each iteration around the loop
xCount *= bpp / srcCpp;
for (int y = 0; y < yCount; y++)
for (int x = 0; x < xCount; x++)
{
int srcOffset = srcSwizzle.GetSwizzleOffset(srcPosX + x, srcPosY + y, 0);
int dstOffset = dstSwizzle.GetSwizzleOffset(dstPosX + x, dstPosY + y, 0);
long src = srcPa + (uint)srcOffset;
long dst = dstPa + (uint)dstOffset;
vmm.Memory.CopyBytes(src, dst, srcCpp);
}
}
}
else
{
vmm.Memory.CopyBytes(srcPa, dstPa, xCount);
}
Profile.End(Profiles.GPU.EngineM2mf.Execute);
}
private long MakeInt64From2xInt32(NvGpuEngineM2mfReg reg)
{
return
(long)Registers[(int)reg + 0] << 32 |
(uint)Registers[(int)reg + 1];
}
private void WriteRegister(GpuMethodCall methCall)
{
Registers[methCall.Method] = methCall.Argument;
}
private int ReadRegister(NvGpuEngineM2mfReg reg)
{
return Registers[(int)reg];
}
private void WriteRegister(NvGpuEngineM2mfReg reg, int value)
{
Registers[(int)reg] = value;
}
}
}