mirrors/Ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Renaming part 7

Browse source
This commit is contained in:
Alex Barney 2019-03-03 13:25:40 -06:00
commit 171bc34d2e
16 changed files with 975 additions and 975 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Ryujinx.Graphics/Graphics3d/INvGpuEngine.cs
View file

@ -6,6 +6,6 @@ namespace Ryujinx.Graphics.Graphics3d
{ {
int[] Registers { get; } int[] Registers { get; }
void CallMethod(NvGpuVmm Vmm, GpuMethodCall MethCall); void CallMethod(NvGpuVmm vmm, GpuMethodCall methCall);
} }
} }

230
Ryujinx.Graphics/Graphics3d/MacroInterpreter.cs
View file

@ -42,78 +42,78 @@ namespace Ryujinx.Graphics.Graphics3d
BitwiseNotAnd = 12 BitwiseNotAnd = 12
} }
private NvGpuFifo PFifo; private NvGpuFifo _pFifo;
private INvGpuEngine Engine; private INvGpuEngine _engine;
public Queue<int> Fifo { get; private set; } public Queue<int> Fifo { get; private set; }
private int[] Gprs; private int[] _gprs;
private int MethAddr; private int _methAddr;
private int MethIncr; private int _methIncr;
private bool Carry; private bool _carry;
private int OpCode; private int _opCode;
private int PipeOp; private int _pipeOp;
private int Pc; private int _pc;
public MacroInterpreter(NvGpuFifo PFifo, INvGpuEngine Engine) public MacroInterpreter(NvGpuFifo pFifo, INvGpuEngine engine)
{ {
this.PFifo = PFifo; _pFifo = pFifo;
this.Engine = Engine; _engine = engine;
Fifo = new Queue<int>(); Fifo = new Queue<int>();
Gprs = new int[8]; _gprs = new int[8];
} }
public void Execute(NvGpuVmm Vmm, int[] Mme, int Position, int Param) public void Execute(NvGpuVmm vmm, int[] mme, int position, int param)
{ {
Reset(); Reset();
Gprs[1] = Param; _gprs[1] = param;
Pc = Position; _pc = position;
FetchOpCode(Mme); FetchOpCode(mme);
while (Step(Vmm, Mme)); while (Step(vmm, mme));
//Due to the delay slot, we still need to execute //Due to the delay slot, we still need to execute
//one more instruction before we actually exit. //one more instruction before we actually exit.
Step(Vmm, Mme); Step(vmm, mme);
} }
private void Reset() private void Reset()
{ {
for (int Index = 0; Index < Gprs.Length; Index++) for (int index = 0; index < _gprs.Length; index++)
{ {
Gprs[Index] = 0; _gprs[index] = 0;
} }
MethAddr = 0; _methAddr = 0;
MethIncr = 0; _methIncr = 0;
Carry = false; _carry = false;
} }
private bool Step(NvGpuVmm Vmm, int[] Mme) private bool Step(NvGpuVmm vmm, int[] mme)
{ {
int BaseAddr = Pc - 1; int baseAddr = _pc - 1;
FetchOpCode(Mme); FetchOpCode(mme);
if ((OpCode & 7) < 7) if ((_opCode & 7) < 7)
{ {
//Operation produces a value. //Operation produces a value.
AssignmentOperation AsgOp = (AssignmentOperation)((OpCode >> 4) & 7); AssignmentOperation asgOp = (AssignmentOperation)((_opCode >> 4) & 7);
int Result = GetAluResult(); int result = GetAluResult();
switch (AsgOp) switch (asgOp)
{ {
//Fetch parameter and ignore result. //Fetch parameter and ignore result.
case AssignmentOperation.IgnoreAndFetch: case AssignmentOperation.IgnoreAndFetch:
@ -126,7 +126,7 @@ namespace Ryujinx.Graphics.Graphics3d
//Move result. //Move result.
case AssignmentOperation.Move: case AssignmentOperation.Move:
{ {
SetDstGpr(Result); SetDstGpr(result);
break; break;
} }
@ -134,9 +134,9 @@ namespace Ryujinx.Graphics.Graphics3d
//Move result and use as Method Address. //Move result and use as Method Address.
case AssignmentOperation.MoveAndSetMaddr: case AssignmentOperation.MoveAndSetMaddr:
{ {
SetDstGpr(Result); SetDstGpr(result);
SetMethAddr(Result); SetMethAddr(result);
break; break;
} }
@ -146,7 +146,7 @@ namespace Ryujinx.Graphics.Graphics3d
{ {
SetDstGpr(FetchParam()); SetDstGpr(FetchParam());
Send(Vmm, Result); Send(vmm, result);
break; break;
} }
@ -154,9 +154,9 @@ namespace Ryujinx.Graphics.Graphics3d
//Move and send result. //Move and send result.
case AssignmentOperation.MoveAndSend: case AssignmentOperation.MoveAndSend:
{ {
SetDstGpr(Result); SetDstGpr(result);
Send(Vmm, Result); Send(vmm, result);
break; break;
} }
@ -166,7 +166,7 @@ namespace Ryujinx.Graphics.Graphics3d
{ {
SetDstGpr(FetchParam()); SetDstGpr(FetchParam());
SetMethAddr(Result); SetMethAddr(result);
break; break;
} }
@ -174,11 +174,11 @@ namespace Ryujinx.Graphics.Graphics3d
//Move result and use as Method Address, then fetch and send paramter. //Move result and use as Method Address, then fetch and send paramter.
case AssignmentOperation.MoveAndSetMaddrThenFetchAndSend: case AssignmentOperation.MoveAndSetMaddrThenFetchAndSend:
{ {
SetDstGpr(Result); SetDstGpr(result);
SetMethAddr(Result); SetMethAddr(result);
Send(Vmm, FetchParam()); Send(vmm, FetchParam());
break; break;
} }
@ -186,11 +186,11 @@ namespace Ryujinx.Graphics.Graphics3d
//Move result and use as Method Address, then send bits 17:12 of result. //Move result and use as Method Address, then send bits 17:12 of result.
case AssignmentOperation.MoveAndSetMaddrThenSendHigh: case AssignmentOperation.MoveAndSetMaddrThenSendHigh:
{ {
SetDstGpr(Result); SetDstGpr(result);
SetMethAddr(Result); SetMethAddr(result);
Send(Vmm, (Result >> 12) & 0x3f); Send(vmm, (result >> 12) & 0x3f);
break; break;
} }
@ -199,50 +199,50 @@ namespace Ryujinx.Graphics.Graphics3d
else else
{ {
//Branch. //Branch.
bool OnNotZero = ((OpCode >> 4) & 1) != 0; bool onNotZero = ((_opCode >> 4) & 1) != 0;
bool Taken = OnNotZero bool taken = onNotZero
? GetGprA() != 0 ? GetGprA() != 0
: GetGprA() == 0; : GetGprA() == 0;
if (Taken) if (taken)
{ {
Pc = BaseAddr + GetImm(); _pc = baseAddr + GetImm();
bool NoDelays = (OpCode & 0x20) != 0; bool noDelays = (_opCode & 0x20) != 0;
if (NoDelays) if (noDelays)
{ {
FetchOpCode(Mme); FetchOpCode(mme);
} }
return true; return true;
} }
} }
bool Exit = (OpCode & 0x80) != 0; bool exit = (_opCode & 0x80) != 0;
return !Exit; return !exit;
} }
private void FetchOpCode(int[] Mme) private void FetchOpCode(int[] mme)
{ {
OpCode = PipeOp; _opCode = _pipeOp;
PipeOp = Mme[Pc++]; _pipeOp = mme[_pc++];
} }
private int GetAluResult() private int GetAluResult()
{ {
AluOperation Op = (AluOperation)(OpCode & 7); AluOperation op = (AluOperation)(_opCode & 7);
switch (Op) switch (op)
{ {
case AluOperation.AluReg: case AluOperation.AluReg:
{ {
AluRegOperation AluOp = (AluRegOperation)((OpCode >> 17) & 0x1f); AluRegOperation aluOp = (AluRegOperation)((_opCode >> 17) & 0x1f);
return GetAluResult(AluOp, GetGprA(), GetGprB()); return GetAluResult(aluOp, GetGprA(), GetGprB());
} }
case AluOperation.AddImmediate: case AluOperation.AddImmediate:
@ -254,40 +254,40 @@ namespace Ryujinx.Graphics.Graphics3d
case AluOperation.BitfieldExtractLslImm: case AluOperation.BitfieldExtractLslImm:
case AluOperation.BitfieldExtractLslReg: case AluOperation.BitfieldExtractLslReg:
{ {
int BfSrcBit = (OpCode >> 17) & 0x1f; int bfSrcBit = (_opCode >> 17) & 0x1f;
int BfSize = (OpCode >> 22) & 0x1f; int bfSize = (_opCode >> 22) & 0x1f;
int BfDstBit = (OpCode >> 27) & 0x1f; int bfDstBit = (_opCode >> 27) & 0x1f;
int BfMask = (1 << BfSize) - 1; int bfMask = (1 << bfSize) - 1;
int Dst = GetGprA(); int dst = GetGprA();
int Src = GetGprB(); int src = GetGprB();
switch (Op) switch (op)
{ {
case AluOperation.BitfieldReplace: case AluOperation.BitfieldReplace:
{ {
Src = (int)((uint)Src >> BfSrcBit) & BfMask; src = (int)((uint)src >> bfSrcBit) & bfMask;
Dst &= ~(BfMask << BfDstBit); dst &= ~(bfMask << bfDstBit);
Dst |= Src << BfDstBit; dst |= src << bfDstBit;
return Dst; return dst;
} }
case AluOperation.BitfieldExtractLslImm: case AluOperation.BitfieldExtractLslImm:
{ {
Src = (int)((uint)Src >> Dst) & BfMask; src = (int)((uint)src >> dst) & bfMask;
return Src << BfDstBit; return src << bfDstBit;
} }
case AluOperation.BitfieldExtractLslReg: case AluOperation.BitfieldExtractLslReg:
{ {
Src = (int)((uint)Src >> BfSrcBit) & BfMask; src = (int)((uint)src >> bfSrcBit) & bfMask;
return Src << Dst; return src << dst;
} }
} }
@ -300,117 +300,117 @@ namespace Ryujinx.Graphics.Graphics3d
} }
} }
throw new ArgumentException(nameof(OpCode)); throw new ArgumentException(nameof(_opCode));
} }
private int GetAluResult(AluRegOperation AluOp, int A, int B) private int GetAluResult(AluRegOperation aluOp, int a, int b)
{ {
switch (AluOp) switch (aluOp)
{ {
case AluRegOperation.Add: case AluRegOperation.Add:
{ {
ulong Result = (ulong)A + (ulong)B; ulong result = (ulong)a + (ulong)b;
Carry = Result > 0xffffffff; _carry = result > 0xffffffff;
return (int)Result; return (int)result;
} }
case AluRegOperation.AddWithCarry: case AluRegOperation.AddWithCarry:
{ {
ulong Result = (ulong)A + (ulong)B + (Carry ? 1UL : 0UL); ulong result = (ulong)a + (ulong)b + (_carry ? 1UL : 0UL);
Carry = Result > 0xffffffff; _carry = result > 0xffffffff;
return (int)Result; return (int)result;
} }
case AluRegOperation.Subtract: case AluRegOperation.Subtract:
{ {
ulong Result = (ulong)A - (ulong)B; ulong result = (ulong)a - (ulong)b;
Carry = Result < 0x100000000; _carry = result < 0x100000000;
return (int)Result; return (int)result;
} }
case AluRegOperation.SubtractWithBorrow: case AluRegOperation.SubtractWithBorrow:
{ {
ulong Result = (ulong)A - (ulong)B - (Carry ? 0UL : 1UL); ulong result = (ulong)a - (ulong)b - (_carry ? 0UL : 1UL);
Carry = Result < 0x100000000; _carry = result < 0x100000000;
return (int)Result; return (int)result;
} }
case AluRegOperation.BitwiseExclusiveOr: return A ^ B; case AluRegOperation.BitwiseExclusiveOr: return a ^ b;
case AluRegOperation.BitwiseOr: return A | B; case AluRegOperation.BitwiseOr: return a | b;
case AluRegOperation.BitwiseAnd: return A & B; case AluRegOperation.BitwiseAnd: return a & b;
case AluRegOperation.BitwiseAndNot: return A & ~B; case AluRegOperation.BitwiseAndNot: return a & ~b;
case AluRegOperation.BitwiseNotAnd: return ~(A & B); case AluRegOperation.BitwiseNotAnd: return ~(a & b);
} }
throw new ArgumentOutOfRangeException(nameof(AluOp)); throw new ArgumentOutOfRangeException(nameof(aluOp));
} }
private int GetImm() private int GetImm()
{ {
//Note: The immediate is signed, the sign-extension is intended here. //Note: The immediate is signed, the sign-extension is intended here.
return OpCode >> 14; return _opCode >> 14;
} }
private void SetMethAddr(int Value) private void SetMethAddr(int value)
{ {
MethAddr = (Value >> 0) & 0xfff; _methAddr = (value >> 0) & 0xfff;
MethIncr = (Value >> 12) & 0x3f; _methIncr = (value >> 12) & 0x3f;
} }
private void SetDstGpr(int Value) private void SetDstGpr(int value)
{ {
Gprs[(OpCode >> 8) & 7] = Value; _gprs[(_opCode >> 8) & 7] = value;
} }
private int GetGprA() private int GetGprA()
{ {
return GetGprValue((OpCode >> 11) & 7); return GetGprValue((_opCode >> 11) & 7);
} }
private int GetGprB() private int GetGprB()
{ {
return GetGprValue((OpCode >> 14) & 7); return GetGprValue((_opCode >> 14) & 7);
} }
private int GetGprValue(int Index) private int GetGprValue(int index)
{ {
return Index != 0 ? Gprs[Index] : 0; return index != 0 ? _gprs[index] : 0;
} }
private int FetchParam() private int FetchParam()
{ {
int Value; int value;
if (!Fifo.TryDequeue(out Value)) if (!Fifo.TryDequeue(out value))
{ {
Logger.PrintWarning(LogClass.Gpu, "Macro attempted to fetch an inexistent argument."); Logger.PrintWarning(LogClass.Gpu, "Macro attempted to fetch an inexistent argument.");
return 0; return 0;
} }
return Value; return value;
} }
private int Read(int Reg) private int Read(int reg)
{ {
return Engine.Registers[Reg]; return _engine.Registers[reg];
} }
private void Send(NvGpuVmm Vmm, int Value) private void Send(NvGpuVmm vmm, int value)
{ {
GpuMethodCall MethCall = new GpuMethodCall(MethAddr, Value); GpuMethodCall methCall = new GpuMethodCall(_methAddr, value);
Engine.CallMethod(Vmm, MethCall); _engine.CallMethod(vmm, methCall);
MethAddr += MethIncr; _methAddr += _methIncr;
} }
} }
} }

4
Ryujinx.Graphics/Graphics3d/NvGpuEngine.cs
View file

@ -2,8 +2,8 @@ namespace Ryujinx.Graphics.Graphics3d
{ {
enum NvGpuEngine enum NvGpuEngine
{ {
_2d = 0x902d, _2D = 0x902d,
_3d = 0xb197, _3D = 0xb197,
Compute = 0xb1c0, Compute = 0xb1c0,
P2mf = 0xa140, P2mf = 0xa140,
M2mf = 0xb0b5 M2mf = 0xb0b5

274
Ryujinx.Graphics/Graphics3d/NvGpuEngine2d.cs
View file

@ -5,7 +5,7 @@ using Ryujinx.Graphics.Texture;
namespace Ryujinx.Graphics.Graphics3d namespace Ryujinx.Graphics.Graphics3d
{ {
class NvGpuEngine2d : INvGpuEngine class NvGpuEngine2D : INvGpuEngine
{ {
private enum CopyOperation private enum CopyOperation
{ {
@ -20,187 +20,187 @@ namespace Ryujinx.Graphics.Graphics3d
public int[] Registers { get; private set; } public int[] Registers { get; private set; }
private NvGpu Gpu; private NvGpu _gpu;
public NvGpuEngine2d(NvGpu Gpu) public NvGpuEngine2D(NvGpu gpu)
{ {
this.Gpu = Gpu; _gpu = gpu;
Registers = new int[0x238]; Registers = new int[0x238];
} }
public void CallMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) public void CallMethod(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
WriteRegister(MethCall); WriteRegister(methCall);
if ((NvGpuEngine2dReg)MethCall.Method == NvGpuEngine2dReg.BlitSrcYInt) if ((NvGpuEngine2DReg)methCall.Method == NvGpuEngine2DReg.BlitSrcYInt)
{ {
TextureCopy(Vmm); TextureCopy(vmm);
} }
} }
private void TextureCopy(NvGpuVmm Vmm) private void TextureCopy(NvGpuVmm vmm)
{ {
CopyOperation Operation = (CopyOperation)ReadRegister(NvGpuEngine2dReg.CopyOperation); CopyOperation operation = (CopyOperation)ReadRegister(NvGpuEngine2DReg.CopyOperation);
int DstFormat = ReadRegister(NvGpuEngine2dReg.DstFormat); int dstFormat = ReadRegister(NvGpuEngine2DReg.DstFormat);
bool DstLinear = ReadRegister(NvGpuEngine2dReg.DstLinear) != 0; bool dstLinear = ReadRegister(NvGpuEngine2DReg.DstLinear) != 0;
int DstWidth = ReadRegister(NvGpuEngine2dReg.DstWidth); int dstWidth = ReadRegister(NvGpuEngine2DReg.DstWidth);
int DstHeight = ReadRegister(NvGpuEngine2dReg.DstHeight); int dstHeight = ReadRegister(NvGpuEngine2DReg.DstHeight);
int DstDepth = ReadRegister(NvGpuEngine2dReg.DstDepth); int dstDepth = ReadRegister(NvGpuEngine2DReg.DstDepth);
int DstLayer = ReadRegister(NvGpuEngine2dReg.DstLayer); int dstLayer = ReadRegister(NvGpuEngine2DReg.DstLayer);
int DstPitch = ReadRegister(NvGpuEngine2dReg.DstPitch); int dstPitch = ReadRegister(NvGpuEngine2DReg.DstPitch);
int DstBlkDim = ReadRegister(NvGpuEngine2dReg.DstBlockDimensions); int dstBlkDim = ReadRegister(NvGpuEngine2DReg.DstBlockDimensions);
int SrcFormat = ReadRegister(NvGpuEngine2dReg.SrcFormat); int srcFormat = ReadRegister(NvGpuEngine2DReg.SrcFormat);
bool SrcLinear = ReadRegister(NvGpuEngine2dReg.SrcLinear) != 0; bool srcLinear = ReadRegister(NvGpuEngine2DReg.SrcLinear) != 0;
int SrcWidth = ReadRegister(NvGpuEngine2dReg.SrcWidth); int srcWidth = ReadRegister(NvGpuEngine2DReg.SrcWidth);
int SrcHeight = ReadRegister(NvGpuEngine2dReg.SrcHeight); int srcHeight = ReadRegister(NvGpuEngine2DReg.SrcHeight);
int SrcDepth = ReadRegister(NvGpuEngine2dReg.SrcDepth); int srcDepth = ReadRegister(NvGpuEngine2DReg.SrcDepth);
int SrcLayer = ReadRegister(NvGpuEngine2dReg.SrcLayer); int srcLayer = ReadRegister(NvGpuEngine2DReg.SrcLayer);
int SrcPitch = ReadRegister(NvGpuEngine2dReg.SrcPitch); int srcPitch = ReadRegister(NvGpuEngine2DReg.SrcPitch);
int SrcBlkDim = ReadRegister(NvGpuEngine2dReg.SrcBlockDimensions); int srcBlkDim = ReadRegister(NvGpuEngine2DReg.SrcBlockDimensions);
int DstBlitX = ReadRegister(NvGpuEngine2dReg.BlitDstX); int dstBlitX = ReadRegister(NvGpuEngine2DReg.BlitDstX);
int DstBlitY = ReadRegister(NvGpuEngine2dReg.BlitDstY); int dstBlitY = ReadRegister(NvGpuEngine2DReg.BlitDstY);
int DstBlitW = ReadRegister(NvGpuEngine2dReg.BlitDstW); int dstBlitW = ReadRegister(NvGpuEngine2DReg.BlitDstW);
int DstBlitH = ReadRegister(NvGpuEngine2dReg.BlitDstH); int dstBlitH = ReadRegister(NvGpuEngine2DReg.BlitDstH);
long BlitDuDx = ReadRegisterFixed1_31_32(NvGpuEngine2dReg.BlitDuDxFract); long blitDuDx = ReadRegisterFixed1_31_32(NvGpuEngine2DReg.BlitDuDxFract);
long BlitDvDy = ReadRegisterFixed1_31_32(NvGpuEngine2dReg.BlitDvDyFract); long blitDvDy = ReadRegisterFixed1_31_32(NvGpuEngine2DReg.BlitDvDyFract);
long SrcBlitX = ReadRegisterFixed1_31_32(NvGpuEngine2dReg.BlitSrcXFract); long srcBlitX = ReadRegisterFixed1_31_32(NvGpuEngine2DReg.BlitSrcXFract);
long SrcBlitY = ReadRegisterFixed1_31_32(NvGpuEngine2dReg.BlitSrcYFract); long srcBlitY = ReadRegisterFixed1_31_32(NvGpuEngine2DReg.BlitSrcYFract);
GalImageFormat SrcImgFormat = ImageUtils.ConvertSurface((GalSurfaceFormat)SrcFormat); GalImageFormat srcImgFormat = ImageUtils.ConvertSurface((GalSurfaceFormat)srcFormat);
GalImageFormat DstImgFormat = ImageUtils.ConvertSurface((GalSurfaceFormat)DstFormat); GalImageFormat dstImgFormat = ImageUtils.ConvertSurface((GalSurfaceFormat)dstFormat);
GalMemoryLayout SrcLayout = GetLayout(SrcLinear); GalMemoryLayout srcLayout = GetLayout(srcLinear);
GalMemoryLayout DstLayout = GetLayout(DstLinear); GalMemoryLayout dstLayout = GetLayout(dstLinear);
int SrcBlockHeight = 1 << ((SrcBlkDim >> 4) & 0xf); int srcBlockHeight = 1 << ((srcBlkDim >> 4) & 0xf);
int DstBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf); int dstBlockHeight = 1 << ((dstBlkDim >> 4) & 0xf);
long SrcAddress = MakeInt64From2xInt32(NvGpuEngine2dReg.SrcAddress); long srcAddress = MakeInt64From2xInt32(NvGpuEngine2DReg.SrcAddress);
long DstAddress = MakeInt64From2xInt32(NvGpuEngine2dReg.DstAddress); long dstAddress = MakeInt64From2xInt32(NvGpuEngine2DReg.DstAddress);
long SrcKey = Vmm.GetPhysicalAddress(SrcAddress); long srcKey = vmm.GetPhysicalAddress(srcAddress);
long DstKey = Vmm.GetPhysicalAddress(DstAddress); long dstKey = vmm.GetPhysicalAddress(dstAddress);
bool IsSrcLayered = false; bool isSrcLayered = false;
bool IsDstLayered = false; bool isDstLayered = false;
GalTextureTarget SrcTarget = GalTextureTarget.TwoD; GalTextureTarget srcTarget = GalTextureTarget.TwoD;
if (SrcDepth != 0) if (srcDepth != 0)
{ {
SrcTarget = GalTextureTarget.TwoDArray; srcTarget = GalTextureTarget.TwoDArray;
SrcDepth++; srcDepth++;
IsSrcLayered = true; isSrcLayered = true;
} }
else else
{ {
SrcDepth = 1; srcDepth = 1;
} }
GalTextureTarget DstTarget = GalTextureTarget.TwoD; GalTextureTarget dstTarget = GalTextureTarget.TwoD;
if (DstDepth != 0) if (dstDepth != 0)
{ {
DstTarget = GalTextureTarget.TwoDArray; dstTarget = GalTextureTarget.TwoDArray;
DstDepth++; dstDepth++;
IsDstLayered = true; isDstLayered = true;
} }
else else
{ {
DstDepth = 1; dstDepth = 1;
} }
GalImage SrcTexture = new GalImage( GalImage srcTexture = new GalImage(
SrcWidth, srcWidth,
SrcHeight, srcHeight,
1, SrcDepth, 1, 1, srcDepth, 1,
SrcBlockHeight, 1, srcBlockHeight, 1,
SrcLayout, srcLayout,
SrcImgFormat, srcImgFormat,
SrcTarget); srcTarget);
GalImage DstTexture = new GalImage( GalImage dstTexture = new GalImage(
DstWidth, dstWidth,
DstHeight, dstHeight,
1, DstDepth, 1, 1, dstDepth, 1,
DstBlockHeight, 1, dstBlockHeight, 1,
DstLayout, dstLayout,
DstImgFormat, dstImgFormat,
DstTarget); dstTarget);
SrcTexture.Pitch = SrcPitch; srcTexture.Pitch = srcPitch;
DstTexture.Pitch = DstPitch; dstTexture.Pitch = dstPitch;
long GetLayerOffset(GalImage Image, int Layer) long GetLayerOffset(GalImage image, int layer)
{ {
int TargetMipLevel = Image.MaxMipmapLevel <= 1 ? 1 : Image.MaxMipmapLevel - 1; int targetMipLevel = image.MaxMipmapLevel <= 1 ? 1 : image.MaxMipmapLevel - 1;
return ImageUtils.GetLayerOffset(Image, TargetMipLevel) * Layer; return ImageUtils.GetLayerOffset(image, targetMipLevel) * layer;
} }
int SrcLayerIndex = -1; int srcLayerIndex = -1;
if (IsSrcLayered && Gpu.ResourceManager.TryGetTextureLayer(SrcKey, out SrcLayerIndex) && SrcLayerIndex != 0) if (isSrcLayered && _gpu.ResourceManager.TryGetTextureLayer(srcKey, out srcLayerIndex) && srcLayerIndex != 0)
{ {
SrcKey = SrcKey - GetLayerOffset(SrcTexture, SrcLayerIndex); srcKey = srcKey - GetLayerOffset(srcTexture, srcLayerIndex);
} }
int DstLayerIndex = -1; int dstLayerIndex = -1;
if (IsDstLayered && Gpu.ResourceManager.TryGetTextureLayer(DstKey, out DstLayerIndex) && DstLayerIndex != 0) if (isDstLayered && _gpu.ResourceManager.TryGetTextureLayer(dstKey, out dstLayerIndex) && dstLayerIndex != 0)
{ {
DstKey = DstKey - GetLayerOffset(DstTexture, DstLayerIndex); dstKey = dstKey - GetLayerOffset(dstTexture, dstLayerIndex);
} }
Gpu.ResourceManager.SendTexture(Vmm, SrcKey, SrcTexture); _gpu.ResourceManager.SendTexture(vmm, srcKey, srcTexture);
Gpu.ResourceManager.SendTexture(Vmm, DstKey, DstTexture); _gpu.ResourceManager.SendTexture(vmm, dstKey, dstTexture);
if (IsSrcLayered && SrcLayerIndex == -1) if (isSrcLayered && srcLayerIndex == -1)
{ {
for (int Layer = 0; Layer < SrcTexture.LayerCount; Layer++) for (int layer = 0; layer < srcTexture.LayerCount; layer++)
{ {
Gpu.ResourceManager.SetTextureArrayLayer(SrcKey + GetLayerOffset(SrcTexture, Layer), Layer); _gpu.ResourceManager.SetTextureArrayLayer(srcKey + GetLayerOffset(srcTexture, layer), layer);
} }
SrcLayerIndex = 0; srcLayerIndex = 0;
} }
if (IsDstLayered && DstLayerIndex == -1) if (isDstLayered && dstLayerIndex == -1)
{ {
for (int Layer = 0; Layer < DstTexture.LayerCount; Layer++) for (int layer = 0; layer < dstTexture.LayerCount; layer++)
{ {
Gpu.ResourceManager.SetTextureArrayLayer(DstKey + GetLayerOffset(DstTexture, Layer), Layer); _gpu.ResourceManager.SetTextureArrayLayer(dstKey + GetLayerOffset(dstTexture, layer), layer);
} }
DstLayerIndex = 0; dstLayerIndex = 0;
} }
int SrcBlitX1 = (int)(SrcBlitX >> 32); int srcBlitX1 = (int)(srcBlitX >> 32);
int SrcBlitY1 = (int)(SrcBlitY >> 32); int srcBlitY1 = (int)(srcBlitY >> 32);
int SrcBlitX2 = (int)(SrcBlitX + DstBlitW * BlitDuDx >> 32); int srcBlitX2 = (int)(srcBlitX + dstBlitW * blitDuDx >> 32);
int SrcBlitY2 = (int)(SrcBlitY + DstBlitH * BlitDvDy >> 32); int srcBlitY2 = (int)(srcBlitY + dstBlitH * blitDvDy >> 32);
Gpu.Renderer.RenderTarget.Copy( _gpu.Renderer.RenderTarget.Copy(
SrcTexture, srcTexture,
DstTexture, dstTexture,
SrcKey, srcKey,
DstKey, dstKey,
SrcLayerIndex, srcLayerIndex,
DstLayerIndex, dstLayerIndex,
SrcBlitX1, srcBlitX1,
SrcBlitY1, srcBlitY1,
SrcBlitX2, srcBlitX2,
SrcBlitY2, srcBlitY2,
DstBlitX, dstBlitX,
DstBlitY, dstBlitY,
DstBlitX + DstBlitW, dstBlitX + dstBlitW,
DstBlitY + DstBlitH); dstBlitY + dstBlitH);
//Do a guest side copy aswell. This is necessary when //Do a guest side copy aswell. This is necessary when
//the texture is modified by the guest, however it doesn't //the texture is modified by the guest, however it doesn't
@ -209,19 +209,19 @@ namespace Ryujinx.Graphics.Graphics3d
// FIXME: SUPPORT MULTILAYER CORRECTLY HERE (this will cause weird stuffs on the first layer) // FIXME: SUPPORT MULTILAYER CORRECTLY HERE (this will cause weird stuffs on the first layer)
ImageUtils.CopyTexture( ImageUtils.CopyTexture(
Vmm, vmm,
SrcTexture, srcTexture,
DstTexture, dstTexture,
SrcAddress, srcAddress,
DstAddress, dstAddress,
SrcBlitX1, srcBlitX1,
SrcBlitY1, srcBlitY1,
DstBlitX, dstBlitX,
DstBlitY, dstBlitY,
DstBlitW, dstBlitW,
DstBlitH); dstBlitH);
Vmm.IsRegionModified(DstKey, ImageUtils.GetSize(DstTexture), NvGpuBufferType.Texture); vmm.IsRegionModified(dstKey, ImageUtils.GetSize(dstTexture), NvGpuBufferType.Texture);
} }
private static GalMemoryLayout GetLayout(bool Linear) private static GalMemoryLayout GetLayout(bool Linear)
@ -231,29 +231,29 @@ namespace Ryujinx.Graphics.Graphics3d
: GalMemoryLayout.BlockLinear; : GalMemoryLayout.BlockLinear;
} }
private long MakeInt64From2xInt32(NvGpuEngine2dReg Reg) private long MakeInt64From2xInt32(NvGpuEngine2DReg reg)
{ {
return return
(long)Registers[(int)Reg + 0] << 32 | (long)Registers[(int)reg + 0] << 32 |
(uint)Registers[(int)Reg + 1]; (uint)Registers[(int)reg + 1];
} }
private void WriteRegister(GpuMethodCall MethCall) private void WriteRegister(GpuMethodCall methCall)
{ {
Registers[MethCall.Method] = MethCall.Argument; Registers[methCall.Method] = methCall.Argument;
} }
private long ReadRegisterFixed1_31_32(NvGpuEngine2dReg Reg) private long ReadRegisterFixed1_31_32(NvGpuEngine2DReg reg)
{ {
long Low = (uint)ReadRegister(Reg + 0); long low = (uint)ReadRegister(reg + 0);
long High = (uint)ReadRegister(Reg + 1); long high = (uint)ReadRegister(reg + 1);
return Low | (High << 32); return low | (high << 32);
} }
private int ReadRegister(NvGpuEngine2dReg Reg) private int ReadRegister(NvGpuEngine2DReg reg)
{ {
return Registers[(int)Reg]; return Registers[(int)reg];
} }
} }
} }

2
Ryujinx.Graphics/Graphics3d/NvGpuEngine2dReg.cs
View file

@ -1,6 +1,6 @@
namespace Ryujinx.Graphics.Graphics3d namespace Ryujinx.Graphics.Graphics3d
{ {
enum NvGpuEngine2dReg enum NvGpuEngine2DReg
{ {
DstFormat = 0x80, DstFormat = 0x80,
DstLinear = 0x81, DstLinear = 0x81,

948
Ryujinx.Graphics/Graphics3d/NvGpuEngine3d.cs
View file

File diff suppressed because it is too large Load diff

6
Ryujinx.Graphics/Graphics3d/NvGpuEngine3dReg.cs
View file

@ -1,6 +1,6 @@
namespace Ryujinx.Graphics.Graphics3d namespace Ryujinx.Graphics.Graphics3d
{ {
enum NvGpuEngine3dReg enum NvGpuEngine3DReg
{ {
FrameBufferNAddress = 0x200, FrameBufferNAddress = 0x200,
FrameBufferNWidth = 0x202, FrameBufferNWidth = 0x202,
@ -32,13 +32,13 @@ namespace Ryujinx.Graphics.Graphics3d
StencilBackMask = 0x3d6, StencilBackMask = 0x3d6,
StencilBackFuncMask = 0x3d7, StencilBackFuncMask = 0x3d7,
ColorMaskCommon = 0x3e4, ColorMaskCommon = 0x3e4,
RTSeparateFragData = 0x3eb, RtSeparateFragData = 0x3eb,
ZetaAddress = 0x3f8, ZetaAddress = 0x3f8,
ZetaFormat = 0x3fa, ZetaFormat = 0x3fa,
ZetaBlockDimensions = 0x3fb, ZetaBlockDimensions = 0x3fb,
ZetaLayerStride = 0x3fc, ZetaLayerStride = 0x3fc,
VertexAttribNFormat = 0x458, VertexAttribNFormat = 0x458,
RTControl = 0x487, RtControl = 0x487,
ZetaHoriz = 0x48a, ZetaHoriz = 0x48a,
ZetaVert = 0x48b, ZetaVert = 0x48b,
ZetaArrayMode = 0x48c, ZetaArrayMode = 0x48c,

184
Ryujinx.Graphics/Graphics3d/NvGpuEngineM2mf.cs
View file

@ -9,188 +9,188 @@ namespace Ryujinx.Graphics.Graphics3d
{ {
public int[] Registers { get; private set; } public int[] Registers { get; private set; }
private NvGpu Gpu; private NvGpu _gpu;
private Dictionary<int, NvGpuMethod> Methods; private Dictionary<int, NvGpuMethod> _methods;
public NvGpuEngineM2mf(NvGpu Gpu) public NvGpuEngineM2mf(NvGpu gpu)
{ {
this.Gpu = Gpu; _gpu = gpu;
Registers = new int[0x1d6]; Registers = new int[0x1d6];
Methods = new Dictionary<int, NvGpuMethod>(); _methods = new Dictionary<int, NvGpuMethod>();
void AddMethod(int Meth, int Count, int Stride, NvGpuMethod Method) void AddMethod(int meth, int count, int stride, NvGpuMethod method)
{ {
while (Count-- > 0) while (count-- > 0)
{ {
Methods.Add(Meth, Method); _methods.Add(meth, method);
Meth += Stride; meth += stride;
} }
} }
AddMethod(0xc0, 1, 1, Execute); AddMethod(0xc0, 1, 1, Execute);
} }
public void CallMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) public void CallMethod(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
if (Methods.TryGetValue(MethCall.Method, out NvGpuMethod Method)) if (_methods.TryGetValue(methCall.Method, out NvGpuMethod method))
{ {
Method(Vmm, MethCall); method(vmm, methCall);
} }
else else
{ {
WriteRegister(MethCall); WriteRegister(methCall);
} }
} }
private void Execute(NvGpuVmm Vmm, GpuMethodCall MethCall) private void Execute(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
//TODO: Some registers and copy modes are still not implemented. //TODO: Some registers and copy modes are still not implemented.
int Control = MethCall.Argument; int control = methCall.Argument;
bool SrcLinear = ((Control >> 7) & 1) != 0; bool srcLinear = ((control >> 7) & 1) != 0;
bool DstLinear = ((Control >> 8) & 1) != 0; bool dstLinear = ((control >> 8) & 1) != 0;
bool Copy2d = ((Control >> 9) & 1) != 0; bool copy2D = ((control >> 9) & 1) != 0;
long SrcAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.SrcAddress); long srcAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.SrcAddress);
long DstAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.DstAddress); long dstAddress = MakeInt64From2xInt32(NvGpuEngineM2mfReg.DstAddress);
int SrcPitch = ReadRegister(NvGpuEngineM2mfReg.SrcPitch); int srcPitch = ReadRegister(NvGpuEngineM2mfReg.SrcPitch);
int DstPitch = ReadRegister(NvGpuEngineM2mfReg.DstPitch); int dstPitch = ReadRegister(NvGpuEngineM2mfReg.DstPitch);
int XCount = ReadRegister(NvGpuEngineM2mfReg.XCount); int xCount = ReadRegister(NvGpuEngineM2mfReg.XCount);
int YCount = ReadRegister(NvGpuEngineM2mfReg.YCount); int yCount = ReadRegister(NvGpuEngineM2mfReg.YCount);
int Swizzle = ReadRegister(NvGpuEngineM2mfReg.Swizzle); int swizzle = ReadRegister(NvGpuEngineM2mfReg.Swizzle);
int DstBlkDim = ReadRegister(NvGpuEngineM2mfReg.DstBlkDim); int dstBlkDim = ReadRegister(NvGpuEngineM2mfReg.DstBlkDim);
int DstSizeX = ReadRegister(NvGpuEngineM2mfReg.DstSizeX); int dstSizeX = ReadRegister(NvGpuEngineM2mfReg.DstSizeX);
int DstSizeY = ReadRegister(NvGpuEngineM2mfReg.DstSizeY); int dstSizeY = ReadRegister(NvGpuEngineM2mfReg.DstSizeY);
int DstSizeZ = ReadRegister(NvGpuEngineM2mfReg.DstSizeZ); int dstSizeZ = ReadRegister(NvGpuEngineM2mfReg.DstSizeZ);
int DstPosXY = ReadRegister(NvGpuEngineM2mfReg.DstPosXY); int dstPosXy = ReadRegister(NvGpuEngineM2mfReg.DstPosXy);
int DstPosZ = ReadRegister(NvGpuEngineM2mfReg.DstPosZ); int dstPosZ = ReadRegister(NvGpuEngineM2mfReg.DstPosZ);
int SrcBlkDim = ReadRegister(NvGpuEngineM2mfReg.SrcBlkDim); int srcBlkDim = ReadRegister(NvGpuEngineM2mfReg.SrcBlkDim);
int SrcSizeX = ReadRegister(NvGpuEngineM2mfReg.SrcSizeX); int srcSizeX = ReadRegister(NvGpuEngineM2mfReg.SrcSizeX);
int SrcSizeY = ReadRegister(NvGpuEngineM2mfReg.SrcSizeY); int srcSizeY = ReadRegister(NvGpuEngineM2mfReg.SrcSizeY);
int SrcSizeZ = ReadRegister(NvGpuEngineM2mfReg.SrcSizeZ); int srcSizeZ = ReadRegister(NvGpuEngineM2mfReg.SrcSizeZ);
int SrcPosXY = ReadRegister(NvGpuEngineM2mfReg.SrcPosXY); int srcPosXy = ReadRegister(NvGpuEngineM2mfReg.SrcPosXy);
int SrcPosZ = ReadRegister(NvGpuEngineM2mfReg.SrcPosZ); int srcPosZ = ReadRegister(NvGpuEngineM2mfReg.SrcPosZ);
int SrcCpp = ((Swizzle >> 20) & 7) + 1; int srcCpp = ((swizzle >> 20) & 7) + 1;
int DstCpp = ((Swizzle >> 24) & 7) + 1; int dstCpp = ((swizzle >> 24) & 7) + 1;
int DstPosX = (DstPosXY >> 0) & 0xffff; int dstPosX = (dstPosXy >> 0) & 0xffff;
int DstPosY = (DstPosXY >> 16) & 0xffff; int dstPosY = (dstPosXy >> 16) & 0xffff;
int SrcPosX = (SrcPosXY >> 0) & 0xffff; int srcPosX = (srcPosXy >> 0) & 0xffff;
int SrcPosY = (SrcPosXY >> 16) & 0xffff; int srcPosY = (srcPosXy >> 16) & 0xffff;
int SrcBlockHeight = 1 << ((SrcBlkDim >> 4) & 0xf); int srcBlockHeight = 1 << ((srcBlkDim >> 4) & 0xf);
int DstBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf); int dstBlockHeight = 1 << ((dstBlkDim >> 4) & 0xf);
long SrcPA = Vmm.GetPhysicalAddress(SrcAddress); long srcPa = vmm.GetPhysicalAddress(srcAddress);
long DstPA = Vmm.GetPhysicalAddress(DstAddress); long dstPa = vmm.GetPhysicalAddress(dstAddress);
if (Copy2d) if (copy2D)
{ {
if (SrcLinear) if (srcLinear)
{ {
SrcPosX = SrcPosY = SrcPosZ = 0; srcPosX = srcPosY = srcPosZ = 0;
} }
if (DstLinear) if (dstLinear)
{ {
DstPosX = DstPosY = DstPosZ = 0; dstPosX = dstPosY = dstPosZ = 0;
} }
if (SrcLinear && DstLinear) if (srcLinear && dstLinear)
{ {
for (int Y = 0; Y < YCount; Y++) for (int y = 0; y < yCount; y++)
{ {
int SrcOffset = (SrcPosY + Y) * SrcPitch + SrcPosX * SrcCpp; int srcOffset = (srcPosY + y) * srcPitch + srcPosX * srcCpp;
int DstOffset = (DstPosY + Y) * DstPitch + DstPosX * DstCpp; int dstOffset = (dstPosY + y) * dstPitch + dstPosX * dstCpp;
long Src = SrcPA + (uint)SrcOffset; long src = srcPa + (uint)srcOffset;
long Dst = DstPA + (uint)DstOffset; long dst = dstPa + (uint)dstOffset;
Vmm.Memory.CopyBytes(Src, Dst, XCount * SrcCpp); vmm.Memory.CopyBytes(src, dst, xCount * srcCpp);
} }
} }
else else
{ {
ISwizzle SrcSwizzle; ISwizzle srcSwizzle;
if (SrcLinear) if (srcLinear)
{ {
SrcSwizzle = new LinearSwizzle(SrcPitch, SrcCpp, SrcSizeX, SrcSizeY); srcSwizzle = new LinearSwizzle(srcPitch, srcCpp, srcSizeX, srcSizeY);
} }
else else
{ {
SrcSwizzle = new BlockLinearSwizzle( srcSwizzle = new BlockLinearSwizzle(
SrcSizeX, srcSizeX,
SrcSizeY, 1, srcSizeY, 1,
SrcBlockHeight, 1, srcBlockHeight, 1,
SrcCpp); srcCpp);
} }
ISwizzle DstSwizzle; ISwizzle dstSwizzle;
if (DstLinear) if (dstLinear)
{ {
DstSwizzle = new LinearSwizzle(DstPitch, DstCpp, SrcSizeX, SrcSizeY); dstSwizzle = new LinearSwizzle(dstPitch, dstCpp, srcSizeX, srcSizeY);
} }
else else
{ {
DstSwizzle = new BlockLinearSwizzle( dstSwizzle = new BlockLinearSwizzle(
DstSizeX, dstSizeX,
DstSizeY, 1, dstSizeY, 1,
DstBlockHeight, 1, dstBlockHeight, 1,
DstCpp); dstCpp);
} }
for (int Y = 0; Y < YCount; Y++) for (int y = 0; y < yCount; y++)
for (int X = 0; X < XCount; X++) for (int x = 0; x < xCount; x++)
{ {
int SrcOffset = SrcSwizzle.GetSwizzleOffset(SrcPosX + X, SrcPosY + Y, 0); int srcOffset = srcSwizzle.GetSwizzleOffset(srcPosX + x, srcPosY + y, 0);
int DstOffset = DstSwizzle.GetSwizzleOffset(DstPosX + X, DstPosY + Y, 0); int dstOffset = dstSwizzle.GetSwizzleOffset(dstPosX + x, dstPosY + y, 0);
long Src = SrcPA + (uint)SrcOffset; long src = srcPa + (uint)srcOffset;
long Dst = DstPA + (uint)DstOffset; long dst = dstPa + (uint)dstOffset;
Vmm.Memory.CopyBytes(Src, Dst, SrcCpp); vmm.Memory.CopyBytes(src, dst, srcCpp);
} }
} }
} }
else else
{ {
Vmm.Memory.CopyBytes(SrcPA, DstPA, XCount); vmm.Memory.CopyBytes(srcPa, dstPa, xCount);
} }
} }
private long MakeInt64From2xInt32(NvGpuEngineM2mfReg Reg) private long MakeInt64From2xInt32(NvGpuEngineM2mfReg reg)
{ {
return return
(long)Registers[(int)Reg + 0] << 32 | (long)Registers[(int)reg + 0] << 32 |
(uint)Registers[(int)Reg + 1]; (uint)Registers[(int)reg + 1];
} }
private void WriteRegister(GpuMethodCall MethCall) private void WriteRegister(GpuMethodCall methCall)
{ {
Registers[MethCall.Method] = MethCall.Argument; Registers[methCall.Method] = methCall.Argument;
} }
private int ReadRegister(NvGpuEngineM2mfReg Reg) private int ReadRegister(NvGpuEngineM2mfReg reg)
{ {
return Registers[(int)Reg]; return Registers[(int)reg];
} }
private void WriteRegister(NvGpuEngineM2mfReg Reg, int Value) private void WriteRegister(NvGpuEngineM2mfReg reg, int value)
{ {
Registers[(int)Reg] = Value; Registers[(int)reg] = value;
} }
} }
} }

4
Ryujinx.Graphics/Graphics3d/NvGpuEngineM2mfReg.cs
View file

@ -14,12 +14,12 @@ namespace Ryujinx.Graphics.Graphics3d
DstSizeY = 0x1c5, DstSizeY = 0x1c5,
DstSizeZ = 0x1c6, DstSizeZ = 0x1c6,
DstPosZ = 0x1c7, DstPosZ = 0x1c7,
DstPosXY = 0x1c8, DstPosXy = 0x1c8,
SrcBlkDim = 0x1ca, SrcBlkDim = 0x1ca,
SrcSizeX = 0x1cb, SrcSizeX = 0x1cb,
SrcSizeY = 0x1cc, SrcSizeY = 0x1cc,
SrcSizeZ = 0x1cd, SrcSizeZ = 0x1cd,
SrcPosZ = 0x1ce, SrcPosZ = 0x1ce,
SrcPosXY = 0x1cf SrcPosXy = 0x1cf
} }
} }

140
Ryujinx.Graphics/Graphics3d/NvGpuEngineP2mf.cs
View file

@ -9,41 +9,41 @@ namespace Ryujinx.Graphics.Graphics3d
{ {
public int[] Registers { get; private set; } public int[] Registers { get; private set; }
private NvGpu Gpu; private NvGpu _gpu;
private Dictionary<int, NvGpuMethod> Methods; private Dictionary<int, NvGpuMethod> _methods;
private int CopyStartX; private int _copyStartX;
private int CopyStartY; private int _copyStartY;
private int CopyWidth; private int _copyWidth;
private int CopyHeight; private int _copyHeight;
private int CopyGobBlockHeight; private int _copyGobBlockHeight;
private long CopyAddress; private long _copyAddress;
private int CopyOffset; private int _copyOffset;
private int CopySize; private int _copySize;
private bool CopyLinear; private bool _copyLinear;
private byte[] Buffer; private byte[] _buffer;
public NvGpuEngineP2mf(NvGpu Gpu) public NvGpuEngineP2mf(NvGpu gpu)
{ {
this.Gpu = Gpu; _gpu = gpu;
Registers = new int[0x80]; Registers = new int[0x80];
Methods = new Dictionary<int, NvGpuMethod>(); _methods = new Dictionary<int, NvGpuMethod>();
void AddMethod(int Meth, int Count, int Stride, NvGpuMethod Method) void AddMethod(int meth, int count, int stride, NvGpuMethod method)
{ {
while (Count-- > 0) while (count-- > 0)
{ {
Methods.Add(Meth, Method); _methods.Add(meth, method);
Meth += Stride; meth += stride;
} }
} }
@ -51,115 +51,115 @@ namespace Ryujinx.Graphics.Graphics3d
AddMethod(0x6d, 1, 1, PushData); AddMethod(0x6d, 1, 1, PushData);
} }
public void CallMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) public void CallMethod(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
if (Methods.TryGetValue(MethCall.Method, out NvGpuMethod Method)) if (_methods.TryGetValue(methCall.Method, out NvGpuMethod method))
{ {
Method(Vmm, MethCall); method(vmm, methCall);
} }
else else
{ {
WriteRegister(MethCall); WriteRegister(methCall);
} }
} }
private void Execute(NvGpuVmm Vmm, GpuMethodCall MethCall) private void Execute(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
//TODO: Some registers and copy modes are still not implemented. //TODO: Some registers and copy modes are still not implemented.
int Control = MethCall.Argument; int control = methCall.Argument;
long DstAddress = MakeInt64From2xInt32(NvGpuEngineP2mfReg.DstAddress); long dstAddress = MakeInt64From2xInt32(NvGpuEngineP2mfReg.DstAddress);
int DstPitch = ReadRegister(NvGpuEngineP2mfReg.DstPitch); int dstPitch = ReadRegister(NvGpuEngineP2mfReg.DstPitch);
int DstBlkDim = ReadRegister(NvGpuEngineP2mfReg.DstBlockDim); int dstBlkDim = ReadRegister(NvGpuEngineP2mfReg.DstBlockDim);
int DstX = ReadRegister(NvGpuEngineP2mfReg.DstX); int dstX = ReadRegister(NvGpuEngineP2mfReg.DstX);
int DstY = ReadRegister(NvGpuEngineP2mfReg.DstY); int dstY = ReadRegister(NvGpuEngineP2mfReg.DstY);
int DstWidth = ReadRegister(NvGpuEngineP2mfReg.DstWidth); int dstWidth = ReadRegister(NvGpuEngineP2mfReg.DstWidth);
int DstHeight = ReadRegister(NvGpuEngineP2mfReg.DstHeight); int dstHeight = ReadRegister(NvGpuEngineP2mfReg.DstHeight);
int LineLengthIn = ReadRegister(NvGpuEngineP2mfReg.LineLengthIn); int lineLengthIn = ReadRegister(NvGpuEngineP2mfReg.LineLengthIn);
int LineCount = ReadRegister(NvGpuEngineP2mfReg.LineCount); int lineCount = ReadRegister(NvGpuEngineP2mfReg.LineCount);
CopyLinear = (Control & 1) != 0; _copyLinear = (control & 1) != 0;
CopyGobBlockHeight = 1 << ((DstBlkDim >> 4) & 0xf); _copyGobBlockHeight = 1 << ((dstBlkDim >> 4) & 0xf);
CopyStartX = DstX; _copyStartX = dstX;
CopyStartY = DstY; _copyStartY = dstY;
CopyWidth = DstWidth; _copyWidth = dstWidth;
CopyHeight = DstHeight; _copyHeight = dstHeight;
CopyAddress = DstAddress; _copyAddress = dstAddress;
CopyOffset = 0; _copyOffset = 0;
CopySize = LineLengthIn * LineCount; _copySize = lineLengthIn * lineCount;
Buffer = new byte[CopySize]; _buffer = new byte[_copySize];
} }
private void PushData(NvGpuVmm Vmm, GpuMethodCall MethCall) private void PushData(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
if (Buffer == null) if (_buffer == null)
{ {
return; return;
} }
for (int Shift = 0; Shift < 32 && CopyOffset < CopySize; Shift += 8, CopyOffset++) for (int shift = 0; shift < 32 && _copyOffset < _copySize; shift += 8, _copyOffset++)
{ {
Buffer[CopyOffset] = (byte)(MethCall.Argument >> Shift); _buffer[_copyOffset] = (byte)(methCall.Argument >> shift);
} }
if (MethCall.IsLastCall) if (methCall.IsLastCall)
{ {
if (CopyLinear) if (_copyLinear)
{ {
Vmm.WriteBytes(CopyAddress, Buffer); vmm.WriteBytes(_copyAddress, _buffer);
} }
else else
{ {
BlockLinearSwizzle Swizzle = new BlockLinearSwizzle( BlockLinearSwizzle swizzle = new BlockLinearSwizzle(
CopyWidth, _copyWidth,
CopyHeight, 1, _copyHeight, 1,
CopyGobBlockHeight, 1, 1); _copyGobBlockHeight, 1, 1);
int SrcOffset = 0; int srcOffset = 0;
for (int Y = CopyStartY; Y < CopyHeight && SrcOffset < CopySize; Y++) for (int y = _copyStartY; y < _copyHeight && srcOffset < _copySize; y++)
for (int X = CopyStartX; X < CopyWidth && SrcOffset < CopySize; X++) for (int x = _copyStartX; x < _copyWidth && srcOffset < _copySize; x++)
{ {
int DstOffset = Swizzle.GetSwizzleOffset(X, Y, 0); int dstOffset = swizzle.GetSwizzleOffset(x, y, 0);
Vmm.WriteByte(CopyAddress + DstOffset, Buffer[SrcOffset++]); vmm.WriteByte(_copyAddress + dstOffset, _buffer[srcOffset++]);
} }
} }
Buffer = null; _buffer = null;
} }
} }
private long MakeInt64From2xInt32(NvGpuEngineP2mfReg Reg) private long MakeInt64From2xInt32(NvGpuEngineP2mfReg reg)
{ {
return return
(long)Registers[(int)Reg + 0] << 32 | (long)Registers[(int)reg + 0] << 32 |
(uint)Registers[(int)Reg + 1]; (uint)Registers[(int)reg + 1];
} }
private void WriteRegister(GpuMethodCall MethCall) private void WriteRegister(GpuMethodCall methCall)
{ {
Registers[MethCall.Method] = MethCall.Argument; Registers[methCall.Method] = methCall.Argument;
} }
private int ReadRegister(NvGpuEngineP2mfReg Reg) private int ReadRegister(NvGpuEngineP2mfReg reg)
{ {
return Registers[(int)Reg]; return Registers[(int)reg];
} }
private void WriteRegister(NvGpuEngineP2mfReg Reg, int Value) private void WriteRegister(NvGpuEngineP2mfReg reg, int value)
{ {
Registers[(int)Reg] = Value; Registers[(int)reg] = value;
} }
} }
} }

120
Ryujinx.Graphics/Graphics3d/NvGpuFifo.cs
View file

@ -11,166 +11,166 @@ namespace Ryujinx.Graphics.Graphics3d
//a guess here and use 256kb as the size. Increase if needed. //a guess here and use 256kb as the size. Increase if needed.
private const int MmeWords = 256 * 256; private const int MmeWords = 256 * 256;
private NvGpu Gpu; private NvGpu _gpu;
private NvGpuEngine[] SubChannels; private NvGpuEngine[] _subChannels;
private struct CachedMacro private struct CachedMacro
{ {
public int Position { get; private set; } public int Position { get; private set; }
private bool ExecutionPending; private bool _executionPending;
private int Argument; private int _argument;
private MacroInterpreter Interpreter; private MacroInterpreter _interpreter;
public CachedMacro(NvGpuFifo PFifo, INvGpuEngine Engine, int Position) public CachedMacro(NvGpuFifo pFifo, INvGpuEngine engine, int position)
{ {
this.Position = Position; Position = position;
ExecutionPending = false; _executionPending = false;
Argument = 0; _argument = 0;
Interpreter = new MacroInterpreter(PFifo, Engine); _interpreter = new MacroInterpreter(pFifo, engine);
} }
public void StartExecution(int Argument) public void StartExecution(int argument)
{ {
this.Argument = Argument; _argument = argument;
ExecutionPending = true; _executionPending = true;
} }
public void Execute(NvGpuVmm Vmm, int[] Mme) public void Execute(NvGpuVmm vmm, int[] mme)
{ {
if (ExecutionPending) if (_executionPending)
{ {
ExecutionPending = false; _executionPending = false;
Interpreter?.Execute(Vmm, Mme, Position, Argument); _interpreter?.Execute(vmm, mme, Position, _argument);
} }
} }
public void PushArgument(int Argument) public void PushArgument(int argument)
{ {
Interpreter?.Fifo.Enqueue(Argument); _interpreter?.Fifo.Enqueue(argument);
} }
} }
private int CurrMacroPosition; private int _currMacroPosition;
private int CurrMacroBindIndex; private int _currMacroBindIndex;
private CachedMacro[] Macros; private CachedMacro[] _macros;
private int[] Mme; private int[] _mme;
public NvGpuFifo(NvGpu Gpu) public NvGpuFifo(NvGpu gpu)
{ {
this.Gpu = Gpu; _gpu = gpu;
SubChannels = new NvGpuEngine[8]; _subChannels = new NvGpuEngine[8];
Macros = new CachedMacro[MacrosCount]; _macros = new CachedMacro[MacrosCount];
Mme = new int[MmeWords]; _mme = new int[MmeWords];
} }
public void CallMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) public void CallMethod(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
if ((NvGpuFifoMeth)MethCall.Method == NvGpuFifoMeth.BindChannel) if ((NvGpuFifoMeth)methCall.Method == NvGpuFifoMeth.BindChannel)
{ {
NvGpuEngine Engine = (NvGpuEngine)MethCall.Argument; NvGpuEngine engine = (NvGpuEngine)methCall.Argument;
SubChannels[MethCall.SubChannel] = Engine; _subChannels[methCall.SubChannel] = engine;
} }
else else
{ {
switch (SubChannels[MethCall.SubChannel]) switch (_subChannels[methCall.SubChannel])
{ {
case NvGpuEngine._2d: Call2dMethod (Vmm, MethCall); break; case NvGpuEngine._2D: Call2DMethod (vmm, methCall); break;
case NvGpuEngine._3d: Call3dMethod (Vmm, MethCall); break; case NvGpuEngine._3D: Call3DMethod (vmm, methCall); break;
case NvGpuEngine.P2mf: CallP2mfMethod(Vmm, MethCall); break; case NvGpuEngine.P2mf: CallP2mfMethod(vmm, methCall); break;
case NvGpuEngine.M2mf: CallM2mfMethod(Vmm, MethCall); break; case NvGpuEngine.M2mf: CallM2mfMethod(vmm, methCall); break;
} }
} }
} }
private void Call2dMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) private void Call2DMethod(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
Gpu.Engine2d.CallMethod(Vmm, MethCall); _gpu.Engine2d.CallMethod(vmm, methCall);
} }
private void Call3dMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) private void Call3DMethod(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
if (MethCall.Method < 0x80) if (methCall.Method < 0x80)
{ {
switch ((NvGpuFifoMeth)MethCall.Method) switch ((NvGpuFifoMeth)methCall.Method)
{ {
case NvGpuFifoMeth.SetMacroUploadAddress: case NvGpuFifoMeth.SetMacroUploadAddress:
{ {
CurrMacroPosition = MethCall.Argument; _currMacroPosition = methCall.Argument;
break; break;
} }
case NvGpuFifoMeth.SendMacroCodeData: case NvGpuFifoMeth.SendMacroCodeData:
{ {
Mme[CurrMacroPosition++] = MethCall.Argument; _mme[_currMacroPosition++] = methCall.Argument;
break; break;
} }
case NvGpuFifoMeth.SetMacroBindingIndex: case NvGpuFifoMeth.SetMacroBindingIndex:
{ {
CurrMacroBindIndex = MethCall.Argument; _currMacroBindIndex = methCall.Argument;
break; break;
} }
case NvGpuFifoMeth.BindMacro: case NvGpuFifoMeth.BindMacro:
{ {
int Position = MethCall.Argument; int position = methCall.Argument;
Macros[CurrMacroBindIndex] = new CachedMacro(this, Gpu.Engine3d, Position); _macros[_currMacroBindIndex] = new CachedMacro(this, _gpu.Engine3d, position);
break; break;
} }
default: CallP2mfMethod(Vmm, MethCall); break; default: CallP2mfMethod(vmm, methCall); break;
} }
} }
else if (MethCall.Method < 0xe00) else if (methCall.Method < 0xe00)
{ {
Gpu.Engine3d.CallMethod(Vmm, MethCall); _gpu.Engine3d.CallMethod(vmm, methCall);
} }
else else
{ {
int MacroIndex = (MethCall.Method >> 1) & MacroIndexMask; int macroIndex = (methCall.Method >> 1) & MacroIndexMask;
if ((MethCall.Method & 1) != 0) if ((methCall.Method & 1) != 0)
{ {
Macros[MacroIndex].PushArgument(MethCall.Argument); _macros[macroIndex].PushArgument(methCall.Argument);
} }
else else
{ {
Macros[MacroIndex].StartExecution(MethCall.Argument); _macros[macroIndex].StartExecution(methCall.Argument);
} }
if (MethCall.IsLastCall) if (methCall.IsLastCall)
{ {
Macros[MacroIndex].Execute(Vmm, Mme); _macros[macroIndex].Execute(vmm, _mme);
} }
} }
} }
private void CallP2mfMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) private void CallP2mfMethod(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
Gpu.EngineP2mf.CallMethod(Vmm, MethCall); _gpu.EngineP2mf.CallMethod(vmm, methCall);
} }
private void CallM2mfMethod(NvGpuVmm Vmm, GpuMethodCall MethCall) private void CallM2mfMethod(NvGpuVmm vmm, GpuMethodCall methCall)
{ {
Gpu.EngineM2mf.CallMethod(Vmm, MethCall); _gpu.EngineM2mf.CallMethod(vmm, methCall);
} }
} }
} }

2
Ryujinx.Graphics/Graphics3d/NvGpuMethod.cs
View file

@ -2,5 +2,5 @@ using Ryujinx.Graphics.Memory;
namespace Ryujinx.Graphics.Graphics3d namespace Ryujinx.Graphics.Graphics3d
{ {
delegate void NvGpuMethod(NvGpuVmm Vmm, GpuMethodCall MethCall); delegate void NvGpuMethod(NvGpuVmm vmm, GpuMethodCall methCall);
} }

8
Ryujinx.Graphics/Graphics3d/Texture/BlockLinearSwizzle.cs
View file

@ -111,8 +111,8 @@ namespace Ryujinx.Graphics.Texture
public GobBlockSizes(int gobBlockHeight, int gobBlockDepth) public GobBlockSizes(int gobBlockHeight, int gobBlockDepth)
{ {
this.Height = gobBlockHeight; Height = gobBlockHeight;
this.Depth = gobBlockDepth; Depth = gobBlockDepth;
} }
} }
@ -144,8 +144,8 @@ namespace Ryujinx.Graphics.Texture
public RobAndSliceSizes(int robSize, int sliceSize) public RobAndSliceSizes(int robSize, int sliceSize)
{ {
this.RobSize = robSize; RobSize = robSize;
this.SliceSize = sliceSize; SliceSize = sliceSize;
} }
} }

14
Ryujinx.Graphics/Graphics3d/Texture/ImageUtils.cs
View file

@ -31,11 +31,11 @@ namespace Ryujinx.Graphics.Texture
public ImageDescriptor(int bytesPerPixel, int blockWidth, int blockHeight, int blockDepth, TargetBuffer target) public ImageDescriptor(int bytesPerPixel, int blockWidth, int blockHeight, int blockDepth, TargetBuffer target)
{ {
this.BytesPerPixel = bytesPerPixel; BytesPerPixel = bytesPerPixel;
this.BlockWidth = blockWidth; BlockWidth = blockWidth;
this.BlockHeight = blockHeight; BlockHeight = blockHeight;
this.BlockDepth = blockDepth; BlockDepth = blockDepth;
this.Target = target; Target = target;
} }
} }
@ -257,7 +257,7 @@ namespace Ryujinx.Graphics.Texture
byte[] data = new byte[dataLayerSize * image.LayerCount]; byte[] data = new byte[dataLayerSize * image.LayerCount];
int targetMipLevel = image.MaxMipmapLevel <= 1 ? 1 : image.MaxMipmapLevel - 1; int targetMipLevel = image.MaxMipmapLevel <= 1 ? 1 : image.MaxMipmapLevel - 1;
int layerOffset = ImageUtils.GetLayerOffset(image, targetMipLevel); int layerOffset = GetLayerOffset(image, targetMipLevel);
for (int layer = 0; layer < image.LayerCount; layer++) for (int layer = 0; layer < image.LayerCount; layer++)
{ {
@ -288,7 +288,7 @@ namespace Ryujinx.Graphics.Texture
ImageDescriptor desc = GetImageDescriptor(image.Format); ImageDescriptor desc = GetImageDescriptor(image.Format);
(int width, int height, int depth) = ImageUtils.GetImageSizeInBlocks(image); (int width, int height, int depth) = GetImageSizeInBlocks(image);
int bytesPerPixel = desc.BytesPerPixel; int bytesPerPixel = desc.BytesPerPixel;

4
Ryujinx.Graphics/Graphics3d/Texture/LinearSwizzle.cs
View file

@ -11,8 +11,8 @@ namespace Ryujinx.Graphics.Texture
public LinearSwizzle(int pitch, int bpp, int width, int height) public LinearSwizzle(int pitch, int bpp, int width, int height)
{ {
this._pitch = pitch; _pitch = pitch;
this._bpp = bpp; _bpp = bpp;
_sliceSize = width * height * bpp; _sliceSize = width * height * bpp;
} }

8
Ryujinx.Graphics/NvGpu.cs
View file

@ -15,8 +15,8 @@ namespace Ryujinx.Graphics
public DmaPusher Pusher { get; private set; } public DmaPusher Pusher { get; private set; }
internal NvGpuFifo Fifo { get; private set; } internal NvGpuFifo Fifo { get; private set; }
internal NvGpuEngine2d Engine2d { get; private set; } internal NvGpuEngine2D Engine2d { get; private set; }
internal NvGpuEngine3d Engine3d { get; private set; } internal NvGpuEngine3D Engine3d { get; private set; }
internal NvGpuEngineM2mf EngineM2mf { get; private set; } internal NvGpuEngineM2mf EngineM2mf { get; private set; }
internal NvGpuEngineP2mf EngineP2mf { get; private set; } internal NvGpuEngineP2mf EngineP2mf { get; private set; }
@ -33,8 +33,8 @@ namespace Ryujinx.Graphics
Pusher = new DmaPusher(this); Pusher = new DmaPusher(this);
Fifo = new NvGpuFifo(this); Fifo = new NvGpuFifo(this);
Engine2d = new NvGpuEngine2d(this); Engine2d = new NvGpuEngine2D(this);
Engine3d = new NvGpuEngine3d(this); Engine3d = new NvGpuEngine3D(this);
EngineM2mf = new NvGpuEngineM2mf(this); EngineM2mf = new NvGpuEngineM2mf(this);
EngineP2mf = new NvGpuEngineP2mf(this); EngineP2mf = new NvGpuEngineP2mf(this);