diff options
Diffstat (limited to 'Ryujinx.Graphics/Gal/Shader')
| -rw-r--r-- | Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs | 400 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs | 12 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs | 238 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs | 76 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs | 98 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/Shader/ShaderDecodeOpCode.cs | 260 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs | 12 |
7 files changed, 559 insertions, 537 deletions
diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs index afff7e9b..c2ee474b 100644 --- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs @@ -33,20 +33,20 @@ namespace Ryujinx.Graphics.Gal.Shader public static void Fadd_I32(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrNode OperA = GetOperGpr8 (OpCode); - ShaderIrNode OperB = GetOperImmf32_20(OpCode); + ShaderIrNode OperA = OpCode.Gpr8(); + ShaderIrNode OperB = OpCode.Immf32_20(); - bool NegB = ((OpCode >> 53) & 1) != 0; - bool AbsA = ((OpCode >> 54) & 1) != 0; - bool NegA = ((OpCode >> 56) & 1) != 0; - bool AbsB = ((OpCode >> 57) & 1) != 0; + bool NegB = OpCode.Read(53); + bool AbsA = OpCode.Read(54); + bool NegA = OpCode.Read(56); + bool AbsB = OpCode.Read(57); OperA = GetAluFabsFneg(OperA, AbsA, NegA); OperB = GetAluFabsFneg(OperB, AbsB, NegB); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Fadd, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } public static void Fadd_R(ShaderIrBlock Block, long OpCode, long Position) @@ -91,12 +91,12 @@ namespace Ryujinx.Graphics.Gal.Shader public static void Fmul_I32(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrNode OperA = GetOperGpr8 (OpCode); - ShaderIrNode OperB = GetOperImmf32_20(OpCode); + ShaderIrNode OperA = OpCode.Gpr8(); + ShaderIrNode OperB = OpCode.Immf32_20(); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Fmul, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } public static void Fmul_C(ShaderIrBlock Block, long OpCode, long Position) @@ -156,16 +156,16 @@ namespace Ryujinx.Graphics.Gal.Shader public static void Iadd_I32(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrNode OperA = GetOperGpr8 (OpCode); - ShaderIrNode OperB = GetOperImm32_20(OpCode); + ShaderIrNode OperA = OpCode.Gpr8(); + ShaderIrNode OperB = OpCode.Imm32_20(); - bool NegA = ((OpCode >> 56) & 1) != 0; + bool NegA = OpCode.Read(56); OperA = GetAluIneg(OperA, NegA); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Add, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } public static void Iadd_R(ShaderIrBlock Block, long OpCode, long Position) @@ -205,16 +205,16 @@ namespace Ryujinx.Graphics.Gal.Shader public static void Ipa(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrNode OperA = GetOperAbuf28(OpCode); - ShaderIrNode OperB = GetOperGpr20 (OpCode); + ShaderIrNode OperA = OpCode.Abuf28(); + ShaderIrNode OperB = OpCode.Gpr20(); - ShaderIpaMode Mode = (ShaderIpaMode)((OpCode >> 54) & 3); + ShaderIpaMode Mode = (ShaderIpaMode)(OpCode.Read(54, 3)); ShaderIrMetaIpa Meta = new ShaderIrMetaIpa(Mode); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Ipa, OperA, OperB, null, Meta); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } public static void Iscadd_C(ShaderIrBlock Block, long OpCode, long Position) @@ -264,10 +264,10 @@ namespace Ryujinx.Graphics.Gal.Shader public static void Lop_I32(ShaderIrBlock Block, long OpCode, long Position) { - int SubOp = (int)(OpCode >> 53) & 3; + int SubOp = OpCode.Read(53, 3); - bool InvA = ((OpCode >> 55) & 1) != 0; - bool InvB = ((OpCode >> 56) & 1) != 0; + bool InvA = OpCode.Read(55); + bool InvB = OpCode.Read(56); ShaderIrInst Inst = 0; @@ -278,21 +278,21 @@ namespace Ryujinx.Graphics.Gal.Shader case 2: Inst = ShaderIrInst.Xor; break; } - ShaderIrNode OperB = GetAluNot(GetOperImm32_20(OpCode), InvB); + ShaderIrNode OperB = GetAluNot(OpCode.Imm32_20(), InvB); //SubOp == 3 is pass, used by the not instruction //which just moves the inverted register value. if (SubOp < 3) { - ShaderIrNode OperA = GetAluNot(GetOperGpr8(OpCode), InvA); + ShaderIrNode OperA = GetAluNot(OpCode.Gpr8(), InvA); ShaderIrOp Op = new ShaderIrOp(Inst, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } else { - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), OperB), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OperB))); } } @@ -313,10 +313,10 @@ namespace Ryujinx.Graphics.Gal.Shader public static void Mufu(ShaderIrBlock Block, long OpCode, long Position) { - int SubOp = (int)(OpCode >> 20) & 0xf; + int SubOp = OpCode.Read(20, 0xf); - bool AbsA = ((OpCode >> 46) & 1) != 0; - bool NegA = ((OpCode >> 48) & 1) != 0; + bool AbsA = OpCode.Read(46); + bool NegA = OpCode.Read(48); ShaderIrInst Inst = 0; @@ -333,23 +333,23 @@ namespace Ryujinx.Graphics.Gal.Shader default: throw new NotImplementedException(SubOp.ToString()); } - ShaderIrNode OperA = GetOperGpr8(OpCode); + ShaderIrNode OperA = OpCode.Gpr8(); ShaderIrOp Op = new ShaderIrOp(Inst, GetAluFabsFneg(OperA, AbsA, NegA)); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } public static void Psetp(ShaderIrBlock Block, long OpCode, long Position) { - bool NegA = ((OpCode >> 15) & 1) != 0; - bool NegB = ((OpCode >> 32) & 1) != 0; - bool NegP = ((OpCode >> 42) & 1) != 0; + bool NegA = OpCode.Read(15); + bool NegB = OpCode.Read(32); + bool NegP = OpCode.Read(42); - ShaderIrInst LopInst = GetBLop24(OpCode); + ShaderIrInst LopInst = OpCode.BLop24(); - ShaderIrNode OperA = GetOperPred12(OpCode); - ShaderIrNode OperB = GetOperPred29(OpCode); + ShaderIrNode OperA = OpCode.Pred12(); + ShaderIrNode OperB = OpCode.Pred29(); if (NegA) { @@ -363,13 +363,13 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrOp Op = new ShaderIrOp(LopInst, OperA, OperB); - ShaderIrOperPred P0Node = GetOperPred3 (OpCode); - ShaderIrOperPred P1Node = GetOperPred0 (OpCode); - ShaderIrOperPred P2Node = GetOperPred39(OpCode); + ShaderIrOperPred P0Node = OpCode.Pred3(); + ShaderIrOperPred P1Node = OpCode.Pred0(); + ShaderIrOperPred P2Node = OpCode.Pred39(); - Block.AddNode(GetPredNode(new ShaderIrAsg(P0Node, Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op))); - LopInst = GetBLop45(OpCode); + LopInst = OpCode.BLop45(); if (LopInst == ShaderIrInst.Band && P1Node.IsConst && P2Node.IsConst) { @@ -387,11 +387,11 @@ namespace Ryujinx.Graphics.Gal.Shader Op = new ShaderIrOp(LopInst, Op, P2NNode); - Block.AddNode(GetPredNode(new ShaderIrAsg(P1Node, Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P1Node, Op))); Op = new ShaderIrOp(LopInst, P0Node, P2NNode); - Block.AddNode(GetPredNode(new ShaderIrAsg(P0Node, Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op))); } public static void Rro_C(ShaderIrBlock Block, long OpCode, long Position) @@ -441,33 +441,33 @@ namespace Ryujinx.Graphics.Gal.Shader private static ShaderIrInst GetShrInst(long OpCode) { - bool Signed = ((OpCode >> 48) & 1) != 0; + bool Signed = OpCode.Read(48); return Signed ? ShaderIrInst.Asr : ShaderIrInst.Lsr; } public static void Vmad(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrNode OperA = GetOperGpr8(OpCode); + ShaderIrNode OperA = OpCode.Gpr8(); ShaderIrNode OperB; - if (((OpCode >> 50) & 1) != 0) + if (OpCode.Read(50)) { - OperB = GetOperGpr20(OpCode); + OperB = OpCode.Gpr20(); } else { - OperB = GetOperImm19_20(OpCode); + OperB = OpCode.Imm19_20(); } - ShaderIrOperGpr OperC = GetOperGpr39(OpCode); + ShaderIrOperGpr OperC = OpCode.Gpr39(); ShaderIrNode Tmp = new ShaderIrOp(ShaderIrInst.Mul, OperA, OperB); ShaderIrNode Final = new ShaderIrOp(ShaderIrInst.Add, Tmp, OperC); - int Shr = (int)((OpCode >> 51) & 3); + int Shr = OpCode.Read(51, 3); if (Shr != 0) { @@ -478,7 +478,7 @@ namespace Ryujinx.Graphics.Gal.Shader Block.AddNode(new ShaderIrCmnt("Stubbed. Instruction is reduced to a * b + c")); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Final), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Final))); } public static void Xmad_CR(ShaderIrBlock Block, long OpCode, long Position) @@ -507,20 +507,20 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderOper Oper, ShaderIrInst Inst) { - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; + ShaderIrNode OperA = OpCode.Gpr8(), OperB; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } ShaderIrNode Op = new ShaderIrOp(Inst, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitBfe(ShaderIrBlock Block, long OpCode, ShaderOper Oper) @@ -528,23 +528,23 @@ namespace Ryujinx.Graphics.Gal.Shader //TODO: Handle the case where position + length //is greater than the word size, in this case the sign bit //needs to be replicated to fill the remaining space. - bool NegB = ((OpCode >> 48) & 1) != 0; - bool NegA = ((OpCode >> 49) & 1) != 0; + bool NegB = OpCode.Read(48); + bool NegA = OpCode.Read(49); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; + ShaderIrNode OperA = OpCode.Gpr8(), OperB; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } ShaderIrNode Op; - bool Signed = ((OpCode >> 48) & 1) != 0; //? + bool Signed = OpCode.Read(48); //? if (OperB is ShaderIrOperImm PosLen) { @@ -576,25 +576,25 @@ namespace Ryujinx.Graphics.Gal.Shader Op = ExtendTo32(Op, Signed, OpLen); } - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitFadd(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - bool NegB = ((OpCode >> 45) & 1) != 0; - bool AbsA = ((OpCode >> 46) & 1) != 0; - bool NegA = ((OpCode >> 48) & 1) != 0; - bool AbsB = ((OpCode >> 49) & 1) != 0; + bool NegB = OpCode.Read(45); + bool AbsA = OpCode.Read(46); + bool NegA = OpCode.Read(48); + bool AbsB = OpCode.Read(49); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; + ShaderIrNode OperA = OpCode.Gpr8(), OperB; OperA = GetAluFabsFneg(OperA, AbsA, NegA); switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Immf: OperB = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -603,20 +603,20 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrNode Op = new ShaderIrOp(ShaderIrInst.Fadd, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitFmul(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - bool NegB = ((OpCode >> 48) & 1) != 0; + bool NegB = OpCode.Read(48); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; + ShaderIrNode OperA = OpCode.Gpr8(), OperB; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Immf: OperB = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -625,22 +625,22 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrNode Op = new ShaderIrOp(ShaderIrInst.Fmul, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitFfma(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - bool NegB = ((OpCode >> 48) & 1) != 0; - bool NegC = ((OpCode >> 49) & 1) != 0; + bool NegB = OpCode.Read(48); + bool NegC = OpCode.Read(49); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB, OperC; + ShaderIrNode OperA = OpCode.Gpr8(), OperB, OperC; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Immf: OperB = GetOperImmf19_20(OpCode); break; - case ShaderOper.RC: OperB = GetOperGpr39 (OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break; + case ShaderOper.RC: OperB = OpCode.Gpr39(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -649,62 +649,62 @@ namespace Ryujinx.Graphics.Gal.Shader if (Oper == ShaderOper.RC) { - OperC = GetAluFneg(GetOperCbuf34(OpCode), NegC); + OperC = GetAluFneg(OpCode.Cbuf34(), NegC); } else { - OperC = GetAluFneg(GetOperGpr39(OpCode), NegC); + OperC = GetAluFneg(OpCode.Gpr39(), NegC); } ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Ffma, OperA, OperB, OperC); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitIadd(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - ShaderIrNode OperA = GetOperGpr8(OpCode); + ShaderIrNode OperA = OpCode.Gpr8(); ShaderIrNode OperB; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } - bool NegA = ((OpCode >> 49) & 1) != 0; - bool NegB = ((OpCode >> 48) & 1) != 0; + bool NegA = OpCode.Read(49); + bool NegB = OpCode.Read(48); OperA = GetAluIneg(OperA, NegA); OperB = GetAluIneg(OperB, NegB); ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Add, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitIadd3(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - int Mode = (int)((OpCode >> 37) & 3); + int Mode = OpCode.Read(37, 3); - bool Neg1 = ((OpCode >> 51) & 1) != 0; - bool Neg2 = ((OpCode >> 50) & 1) != 0; - bool Neg3 = ((OpCode >> 49) & 1) != 0; + bool Neg1 = OpCode.Read(51); + bool Neg2 = OpCode.Read(50); + bool Neg3 = OpCode.Read(49); - int Height1 = (int)((OpCode >> 35) & 3); - int Height2 = (int)((OpCode >> 33) & 3); - int Height3 = (int)((OpCode >> 31) & 3); + int Height1 = OpCode.Read(35, 3); + int Height2 = OpCode.Read(33, 3); + int Height3 = OpCode.Read(31, 3); ShaderIrNode OperB; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -726,9 +726,9 @@ namespace Ryujinx.Graphics.Gal.Shader } } - ShaderIrNode Src1 = GetAluIneg(ApplyHeight(GetOperGpr8(OpCode), Height1), Neg1); + ShaderIrNode Src1 = GetAluIneg(ApplyHeight(OpCode.Gpr8(), Height1), Neg1); ShaderIrNode Src2 = GetAluIneg(ApplyHeight(OperB, Height2), Neg2); - ShaderIrNode Src3 = GetAluIneg(ApplyHeight(GetOperGpr39(OpCode), Height3), Neg3); + ShaderIrNode Src3 = GetAluIneg(ApplyHeight(OpCode.Gpr39(), Height3), Neg3); ShaderIrOp Sum = new ShaderIrOp(ShaderIrInst.Add, Src1, Src2); @@ -744,23 +744,23 @@ namespace Ryujinx.Graphics.Gal.Shader //Note: Here there should be a "+ 1" when carry flag is set //but since carry is mostly ignored by other instructions, it's excluded for now - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), new ShaderIrOp(ShaderIrInst.Add, Sum, Src3)), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), new ShaderIrOp(ShaderIrInst.Add, Sum, Src3)))); } private static void EmitIscadd(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - bool NegB = ((OpCode >> 48) & 1) != 0; - bool NegA = ((OpCode >> 49) & 1) != 0; + bool NegB = OpCode.Read(48); + bool NegA = OpCode.Read(49); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; + ShaderIrNode OperA = OpCode.Gpr8(), OperB; - ShaderIrOperImm Scale = GetOperImm5_39(OpCode); + ShaderIrOperImm Scale = OpCode.Imm5_39(); switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -771,7 +771,7 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrOp ScaleOp = new ShaderIrOp(ShaderIrInst.Lsl, OperA, Scale); ShaderIrOp AddOp = new ShaderIrOp(ShaderIrInst.Add, OperB, ScaleOp); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), AddOp), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), AddOp))); } private static void EmitFmnmx(ShaderIrBlock Block, long OpCode, ShaderOper Oper) @@ -786,12 +786,12 @@ namespace Ryujinx.Graphics.Gal.Shader private static void EmitMnmx(ShaderIrBlock Block, long OpCode, bool IsFloat, ShaderOper Oper) { - bool NegB = ((OpCode >> 45) & 1) != 0; - bool AbsA = ((OpCode >> 46) & 1) != 0; - bool NegA = ((OpCode >> 48) & 1) != 0; - bool AbsB = ((OpCode >> 49) & 1) != 0; + bool NegB = OpCode.Read(45); + bool AbsA = OpCode.Read(46); + bool NegA = OpCode.Read(48); + bool AbsB = OpCode.Read(49); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; + ShaderIrNode OperA = OpCode.Gpr8(), OperB; if (IsFloat) { @@ -804,10 +804,10 @@ namespace Ryujinx.Graphics.Gal.Shader switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20 (OpCode); break; - case ShaderOper.Immf: OperB = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -821,7 +821,7 @@ namespace Ryujinx.Graphics.Gal.Shader OperB = GetAluIabsIneg(OperB, AbsB, NegB); } - ShaderIrOperPred Pred = GetOperPred39(OpCode); + ShaderIrOperPred Pred = OpCode.Pred39(); ShaderIrOp Op; @@ -830,26 +830,26 @@ namespace Ryujinx.Graphics.Gal.Shader if (Pred.IsConst) { - bool IsMax = ((OpCode >> 42) & 1) != 0; + bool IsMax = OpCode.Read(42); Op = new ShaderIrOp(IsMax ? MaxInst : MinInst, OperA, OperB); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } else { - ShaderIrNode PredN = GetOperPred39N(OpCode); + ShaderIrNode PredN = OpCode.Pred39N(); ShaderIrOp OpMax = new ShaderIrOp(MaxInst, OperA, OperB); ShaderIrOp OpMin = new ShaderIrOp(MinInst, OperA, OperB); - ShaderIrAsg AsgMax = new ShaderIrAsg(GetOperGpr0(OpCode), OpMax); - ShaderIrAsg AsgMin = new ShaderIrAsg(GetOperGpr0(OpCode), OpMin); + ShaderIrAsg AsgMax = new ShaderIrAsg(OpCode.Gpr0(), OpMax); + ShaderIrAsg AsgMin = new ShaderIrAsg(OpCode.Gpr0(), OpMin); - Block.AddNode(GetPredNode(new ShaderIrCond(PredN, AsgMax, Not: true), OpCode)); - Block.AddNode(GetPredNode(new ShaderIrCond(PredN, AsgMin, Not: false), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrCond(PredN, AsgMax, Not: true))); + Block.AddNode(OpCode.PredNode(new ShaderIrCond(PredN, AsgMin, Not: false))); } } @@ -857,16 +857,16 @@ namespace Ryujinx.Graphics.Gal.Shader { //Note: this is a range reduction instruction and is supposed to //be used with Mufu, here it just moves the value and ignores the operation. - bool NegA = ((OpCode >> 45) & 1) != 0; - bool AbsA = ((OpCode >> 49) & 1) != 0; + bool NegA = OpCode.Read(45); + bool AbsA = OpCode.Read(49); ShaderIrNode OperA; switch (Oper) { - case ShaderOper.CR: OperA = GetOperCbuf34 (OpCode); break; - case ShaderOper.Immf: OperA = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperA = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperA = OpCode.Cbuf34(); break; + case ShaderOper.Immf: OperA = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperA = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -875,7 +875,7 @@ namespace Ryujinx.Graphics.Gal.Shader Block.AddNode(new ShaderIrCmnt("Stubbed.")); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), OperA), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OperA))); } private static void EmitFset(ShaderIrBlock Block, long OpCode, ShaderOper Oper) @@ -890,21 +890,21 @@ namespace Ryujinx.Graphics.Gal.Shader private static void EmitSet(ShaderIrBlock Block, long OpCode, bool IsFloat, ShaderOper Oper) { - bool NegA = ((OpCode >> 43) & 1) != 0; - bool AbsB = ((OpCode >> 44) & 1) != 0; - bool NegB = ((OpCode >> 53) & 1) != 0; - bool AbsA = ((OpCode >> 54) & 1) != 0; + bool NegA = OpCode.Read(43); + bool AbsB = OpCode.Read(44); + bool NegB = OpCode.Read(53); + bool AbsA = OpCode.Read(54); - bool BoolFloat = ((OpCode >> (IsFloat ? 52 : 44)) & 1) != 0; + bool BoolFloat = OpCode.Read(IsFloat ? 52 : 44); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; + ShaderIrNode OperA = OpCode.Gpr8(), OperB; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20 (OpCode); break; - case ShaderOper.Immf: OperB = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -916,18 +916,18 @@ namespace Ryujinx.Graphics.Gal.Shader OperA = GetAluFabsFneg(OperA, AbsA, NegA); OperB = GetAluFabsFneg(OperB, AbsB, NegB); - CmpInst = GetCmpF(OpCode); + CmpInst = OpCode.CmpF(); } else { - CmpInst = GetCmp(OpCode); + CmpInst = OpCode.Cmp(); } ShaderIrOp Op = new ShaderIrOp(CmpInst, OperA, OperB); - ShaderIrInst LopInst = GetBLop45(OpCode); + ShaderIrInst LopInst = OpCode.BLop45(); - ShaderIrOperPred PNode = GetOperPred39(OpCode); + ShaderIrOperPred PNode = OpCode.Pred39(); ShaderIrNode Imm0, Imm1; @@ -942,8 +942,8 @@ namespace Ryujinx.Graphics.Gal.Shader Imm1 = new ShaderIrOperImm(-1); } - ShaderIrNode Asg0 = new ShaderIrAsg(GetOperGpr0(OpCode), Imm0); - ShaderIrNode Asg1 = new ShaderIrAsg(GetOperGpr0(OpCode), Imm1); + ShaderIrNode Asg0 = new ShaderIrAsg(OpCode.Gpr0(), Imm0); + ShaderIrNode Asg1 = new ShaderIrAsg(OpCode.Gpr0(), Imm1); if (LopInst != ShaderIrInst.Band || !PNode.IsConst) { @@ -958,8 +958,8 @@ namespace Ryujinx.Graphics.Gal.Shader Asg1 = new ShaderIrCond(Op, Asg1, Not: false); } - Block.AddNode(GetPredNode(Asg0, OpCode)); - Block.AddNode(GetPredNode(Asg1, OpCode)); + Block.AddNode(OpCode.PredNode(Asg0)); + Block.AddNode(OpCode.PredNode(Asg1)); } private static void EmitFsetp(ShaderIrBlock Block, long OpCode, ShaderOper Oper) @@ -974,19 +974,19 @@ namespace Ryujinx.Graphics.Gal.Shader private static void EmitSetp(ShaderIrBlock Block, long OpCode, bool IsFloat, ShaderOper Oper) { - bool AbsA = ((OpCode >> 7) & 1) != 0; - bool NegP = ((OpCode >> 42) & 1) != 0; - bool NegA = ((OpCode >> 43) & 1) != 0; - bool AbsB = ((OpCode >> 44) & 1) != 0; + bool AbsA = OpCode.Read(7); + bool NegP = OpCode.Read(42); + bool NegA = OpCode.Read(43); + bool AbsB = OpCode.Read(44); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB; + ShaderIrNode OperA = OpCode.Gpr8(), OperB; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20 (OpCode); break; - case ShaderOper.Immf: OperB = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -998,22 +998,22 @@ namespace Ryujinx.Graphics.Gal.Shader OperA = GetAluFabsFneg(OperA, AbsA, NegA); OperB = GetAluFabs (OperB, AbsB); - CmpInst = GetCmpF(OpCode); + CmpInst = OpCode.CmpF(); } else { - CmpInst = GetCmp(OpCode); + CmpInst = OpCode.Cmp(); } ShaderIrOp Op = new ShaderIrOp(CmpInst, OperA, OperB); - ShaderIrOperPred P0Node = GetOperPred3 (OpCode); - ShaderIrOperPred P1Node = GetOperPred0 (OpCode); - ShaderIrOperPred P2Node = GetOperPred39(OpCode); + ShaderIrOperPred P0Node = OpCode.Pred3(); + ShaderIrOperPred P1Node = OpCode.Pred0(); + ShaderIrOperPred P2Node = OpCode.Pred39(); - Block.AddNode(GetPredNode(new ShaderIrAsg(P0Node, Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op))); - ShaderIrInst LopInst = GetBLop45(OpCode); + ShaderIrInst LopInst = OpCode.BLop45(); if (LopInst == ShaderIrInst.Band && P1Node.IsConst && P2Node.IsConst) { @@ -1031,19 +1031,19 @@ namespace Ryujinx.Graphics.Gal.Shader Op = new ShaderIrOp(LopInst, Op, P2NNode); - Block.AddNode(GetPredNode(new ShaderIrAsg(P1Node, Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P1Node, Op))); Op = new ShaderIrOp(LopInst, P0Node, P2NNode); - Block.AddNode(GetPredNode(new ShaderIrAsg(P0Node, Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op))); } private static void EmitLop(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - int SubOp = (int)(OpCode >> 41) & 3; + int SubOp = OpCode.Read(41, 3); - bool InvA = ((OpCode >> 39) & 1) != 0; - bool InvB = ((OpCode >> 40) & 1) != 0; + bool InvA = OpCode.Read(39); + bool InvB = OpCode.Read(40); ShaderIrInst Inst = 0; @@ -1054,14 +1054,14 @@ namespace Ryujinx.Graphics.Gal.Shader case 2: Inst = ShaderIrInst.Xor; break; } - ShaderIrNode OperA = GetAluNot(GetOperGpr8(OpCode), InvA); + ShaderIrNode OperA = GetAluNot(OpCode.Gpr8(), InvA); ShaderIrNode OperB; switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -1081,23 +1081,23 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrNode Compare = new ShaderIrOp(ShaderIrInst.Cne, Op, new ShaderIrOperImm(0)); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperPred48(OpCode), Compare), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Pred48(), Compare))); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitXmad(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { //TODO: Confirm SignAB/C, it is just a guess. //TODO: Implement Mode 3 (CSFU), what it does? - bool SignAB = ((OpCode >> 48) & 1) != 0; - bool SignC = ((OpCode >> 49) & 1) != 0; - bool HighB = ((OpCode >> 52) & 1) != 0; - bool HighA = ((OpCode >> 53) & 1) != 0; + bool SignAB = OpCode.Read(48); + bool SignC = OpCode.Read(49); + bool HighB = OpCode.Read(52); + bool HighA = OpCode.Read(53); - int Mode = (int)(OpCode >> 50) & 7; + int Mode = OpCode.Read(50, 7); - ShaderIrNode OperA = GetOperGpr8(OpCode), OperB, OperC; + ShaderIrNode OperA = OpCode.Gpr8(), OperB, OperC; ShaderIrOperImm Imm16 = new ShaderIrOperImm(16); ShaderIrOperImm ImmMsk = new ShaderIrOperImm(0xffff); @@ -1112,10 +1112,10 @@ namespace Ryujinx.Graphics.Gal.Shader switch (Oper) { - case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break; - case ShaderOper.RC: OperB = GetOperGpr39 (OpCode); break; - case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break; + case ShaderOper.RC: OperB = OpCode.Gpr39(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -1124,14 +1124,14 @@ namespace Ryujinx.Graphics.Gal.Shader if (Oper == ShaderOper.RC) { - OperC = GetOperCbuf34(OpCode); + OperC = OpCode.Cbuf34(); } else { - OperC = GetOperGpr39(OpCode); + OperC = OpCode.Gpr39(); - ProductShiftLeft = ((OpCode >> 36) & 1) != 0; - Merge = ((OpCode >> 37) & 1) != 0; + ProductShiftLeft = OpCode.Read(36); + Merge = OpCode.Read(37); } switch (Mode) @@ -1172,7 +1172,7 @@ namespace Ryujinx.Graphics.Gal.Shader AddOp = new ShaderIrOp(ShaderIrInst.Or, AddOp, OperB); } - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), AddOp), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), AddOp))); } } }
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs index 2c699a1b..dfd10e00 100644 --- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs @@ -15,11 +15,11 @@ namespace Ryujinx.Graphics.Gal.Shader throw new NotImplementedException(); } - int Target = ((int)(OpCode >> 20) << 8) >> 8; + int Target = OpCode.Branch(); ShaderIrOperImm Imm = new ShaderIrOperImm(Target); - Block.AddNode(GetPredNode(new ShaderIrOp(ShaderIrInst.Bra, Imm), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Bra, Imm))); } public static void Exit(ShaderIrBlock Block, long OpCode, long Position) @@ -29,14 +29,14 @@ namespace Ryujinx.Graphics.Gal.Shader //TODO: Figure out what the other condition codes mean... if (CCode == 0xf) { - Block.AddNode(GetPredNode(new ShaderIrOp(ShaderIrInst.Exit), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Exit))); } } public static void Kil(ShaderIrBlock Block, long OpCode, long Position) { - Block.AddNode(GetPredNode(new ShaderIrOp(ShaderIrInst.Kil), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Kil))); } public static void Ssy(ShaderIrBlock Block, long OpCode, long Position) @@ -48,7 +48,7 @@ namespace Ryujinx.Graphics.Gal.Shader throw new NotImplementedException(); } - int Offset = ((int)(OpCode >> 20) << 8) >> 8; + int Offset = OpCode.Branch(); int Target = (int)(Position + Offset); @@ -61,7 +61,7 @@ namespace Ryujinx.Graphics.Gal.Shader { //TODO: Implement Sync condition codes - Block.AddNode(GetPredNode(new ShaderIrOp(ShaderIrInst.Sync), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Sync))); } } }
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs index 2093f070..010f06aa 100644 --- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs @@ -4,244 +4,6 @@ namespace Ryujinx.Graphics.Gal.Shader { static class ShaderDecodeHelper { - public static ShaderIrOperAbuf[] GetOperAbuf20(long OpCode) - { - int Abuf = (int)(OpCode >> 20) & 0x3ff; - int Size = (int)(OpCode >> 47) & 3; - - ShaderIrOperGpr Vertex = GetOperGpr39(OpCode); - - ShaderIrOperAbuf[] Opers = new ShaderIrOperAbuf[Size + 1]; - - for (int Index = 0; Index <= Size; Index++) - { - Opers[Index] = new ShaderIrOperAbuf(Abuf + Index * 4, Vertex); - } - - return Opers; - } - - public static ShaderIrOperAbuf GetOperAbuf28(long OpCode) - { - int Abuf = (int)(OpCode >> 28) & 0x3ff; - - return new ShaderIrOperAbuf(Abuf, GetOperGpr39(OpCode)); - } - - public static ShaderIrOperCbuf GetOperCbuf34(long OpCode) - { - return new ShaderIrOperCbuf( - (int)(OpCode >> 34) & 0x1f, - (int)(OpCode >> 20) & 0x3fff); - } - - public static ShaderIrOperGpr GetOperGpr8(long OpCode) - { - return new ShaderIrOperGpr((int)(OpCode >> 8) & 0xff); - } - - public static ShaderIrOperGpr GetOperGpr20(long OpCode) - { - return new ShaderIrOperGpr((int)(OpCode >> 20) & 0xff); - } - - public static ShaderIrOperGpr GetOperGpr39(long OpCode) - { - return new ShaderIrOperGpr((int)(OpCode >> 39) & 0xff); - } - - public static ShaderIrOperGpr GetOperGpr0(long OpCode) - { - return new ShaderIrOperGpr((int)(OpCode >> 0) & 0xff); - } - - public static ShaderIrOperGpr GetOperGpr28(long OpCode) - { - return new ShaderIrOperGpr((int)(OpCode >> 28) & 0xff); - } - - public static ShaderIrOperImm GetOperImm5_39(long OpCode) - { - return new ShaderIrOperImm((int)(OpCode >> 39) & 0x1f); - } - - public static ShaderIrOperImm GetOperImm13_36(long OpCode) - { - return new ShaderIrOperImm((int)(OpCode >> 36) & 0x1fff); - } - - public static ShaderIrOperImm GetOperImm32_20(long OpCode) - { - return new ShaderIrOperImm((int)(OpCode >> 20)); - } - - public static ShaderIrOperImmf GetOperImmf32_20(long OpCode) - { - return new ShaderIrOperImmf(BitConverter.Int32BitsToSingle((int)(OpCode >> 20))); - } - - public static ShaderIrOperImm GetOperImm19_20(long OpCode) - { - int Value = (int)(OpCode >> 20) & 0x7ffff; - - bool Neg = ((OpCode >> 56) & 1) != 0; - - if (Neg) - { - Value = -Value; - } - - return new ShaderIrOperImm((int)Value); - } - - public static ShaderIrOperImmf GetOperImmf19_20(long OpCode) - { - uint Imm = (uint)(OpCode >> 20) & 0x7ffff; - - bool Neg = ((OpCode >> 56) & 1) != 0; - - Imm <<= 12; - - if (Neg) - { - Imm |= 0x80000000; - } - - float Value = BitConverter.Int32BitsToSingle((int)Imm); - - return new ShaderIrOperImmf(Value); - } - - public static ShaderIrOperPred GetOperPred0(long OpCode) - { - return new ShaderIrOperPred((int)(OpCode >> 0) & 7); - } - - public static ShaderIrOperPred GetOperPred3(long OpCode) - { - return new ShaderIrOperPred((int)(OpCode >> 3) & 7); - } - - public static ShaderIrOperPred GetOperPred12(long OpCode) - { - return new ShaderIrOperPred((int)(OpCode >> 12) & 7); - } - - public static ShaderIrOperPred GetOperPred29(long OpCode) - { - return new ShaderIrOperPred((int)(OpCode >> 29) & 7); - } - - public static ShaderIrNode GetOperPred39N(long OpCode) - { - ShaderIrNode Node = GetOperPred39(OpCode); - - if (((OpCode >> 42) & 1) != 0) - { - Node = new ShaderIrOp(ShaderIrInst.Bnot, Node); - } - - return Node; - } - - public static ShaderIrOperPred GetOperPred39(long OpCode) - { - return new ShaderIrOperPred((int)(OpCode >> 39) & 7); - } - - public static ShaderIrOperPred GetOperPred48(long OpCode) - { - return new ShaderIrOperPred((int)((OpCode >> 48) & 7)); - } - - public static ShaderIrInst GetCmp(long OpCode) - { - switch ((int)(OpCode >> 49) & 7) - { - case 1: return ShaderIrInst.Clt; - case 2: return ShaderIrInst.Ceq; - case 3: return ShaderIrInst.Cle; - case 4: return ShaderIrInst.Cgt; - case 5: return ShaderIrInst.Cne; - case 6: return ShaderIrInst.Cge; - } - - throw new ArgumentException(nameof(OpCode)); - } - - public static ShaderIrInst GetCmpF(long OpCode) - { - switch ((int)(OpCode >> 48) & 0xf) - { - case 0x1: return ShaderIrInst.Fclt; - case 0x2: return ShaderIrInst.Fceq; - case 0x3: return ShaderIrInst.Fcle; - case 0x4: return ShaderIrInst.Fcgt; - case 0x5: return ShaderIrInst.Fcne; - case 0x6: return ShaderIrInst.Fcge; - case 0x7: return ShaderIrInst.Fcnum; - case 0x8: return ShaderIrInst.Fcnan; - case 0x9: return ShaderIrInst.Fcltu; - case 0xa: return ShaderIrInst.Fcequ; - case 0xb: return ShaderIrInst.Fcleu; - case 0xc: return ShaderIrInst.Fcgtu; - case 0xd: return ShaderIrInst.Fcneu; - case 0xe: return ShaderIrInst.Fcgeu; - } - - throw new ArgumentException(nameof(OpCode)); - } - - public static ShaderIrInst GetBLop45(long OpCode) - { - switch ((int)(OpCode >> 45) & 3) - { - case 0: return ShaderIrInst.Band; - case 1: return ShaderIrInst.Bor; - case 2: return ShaderIrInst.Bxor; - } - - throw new ArgumentException(nameof(OpCode)); - } - - public static ShaderIrInst GetBLop24(long OpCode) - { - switch ((int)(OpCode >> 24) & 3) - { - case 0: return ShaderIrInst.Band; - case 1: return ShaderIrInst.Bor; - case 2: return ShaderIrInst.Bxor; - } - - throw new ArgumentException(nameof(OpCode)); - } - - public static ShaderIrNode GetPredNode(ShaderIrNode Node, long OpCode) - { - ShaderIrOperPred Pred = GetPredNode(OpCode); - - if (Pred.Index != ShaderIrOperPred.UnusedIndex) - { - bool Inv = ((OpCode >> 19) & 1) != 0; - - Node = new ShaderIrCond(Pred, Node, Inv); - } - - return Node; - } - - private static ShaderIrOperPred GetPredNode(long OpCode) - { - int Pred = (int)(OpCode >> 16) & 0xf; - - if (Pred != 0xf) - { - Pred &= 7; - } - - return new ShaderIrOperPred(Pred); - } - public static ShaderIrNode GetAluFabsFneg(ShaderIrNode Node, bool Abs, bool Neg) { return GetAluFneg(GetAluFabs(Node, Abs), Neg); diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs index 2ae58bf8..508a0205 100644 --- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs @@ -33,28 +33,28 @@ namespace Ryujinx.Graphics.Gal.Shader public static void Ld_A(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrNode[] Opers = GetOperAbuf20(OpCode); + ShaderIrNode[] Opers = OpCode.Abuf20(); //Used by GS - ShaderIrOperGpr Vertex = GetOperGpr39(OpCode); + ShaderIrOperGpr Vertex = OpCode.Gpr39(); int Index = 0; foreach (ShaderIrNode OperA in Opers) { - ShaderIrOperGpr OperD = GetOperGpr0(OpCode); + ShaderIrOperGpr OperD = OpCode.Gpr0(); OperD.Index += Index++; - Block.AddNode(GetPredNode(new ShaderIrAsg(OperD, OperA), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperD, OperA))); } } public static void Ld_C(ShaderIrBlock Block, long OpCode, long Position) { - int CbufPos = (int)(OpCode >> 22) & 0x3fff; - int CbufIndex = (int)(OpCode >> 36) & 0x1f; - int Type = (int)(OpCode >> 48) & 7; + int CbufPos = OpCode.Read(22, 0x3fff); + int CbufIndex = OpCode.Read(36, 0x1f); + int Type = OpCode.Read(48, 7); if (Type > 5) { @@ -63,7 +63,7 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrOperGpr Temp = ShaderIrOperGpr.MakeTemporary(); - Block.AddNode(new ShaderIrAsg(Temp, GetOperGpr8(OpCode))); + Block.AddNode(new ShaderIrAsg(Temp, OpCode.Gpr8())); int Count = Type == 5 ? 2 : 1; @@ -71,7 +71,7 @@ namespace Ryujinx.Graphics.Gal.Shader { ShaderIrOperCbuf OperA = new ShaderIrOperCbuf(CbufIndex, CbufPos, Temp); - ShaderIrOperGpr OperD = GetOperGpr0(OpCode); + ShaderIrOperGpr OperD = OpCode.Gpr0(); OperA.Pos += Index; OperD.Index += Index; @@ -93,43 +93,43 @@ namespace Ryujinx.Graphics.Gal.Shader Node = ExtendTo32(Node, Signed, Size); } - Block.AddNode(GetPredNode(new ShaderIrAsg(OperD, Node), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperD, Node))); } } public static void St_A(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrNode[] Opers = GetOperAbuf20(OpCode); + ShaderIrNode[] Opers = OpCode.Abuf20(); int Index = 0; foreach (ShaderIrNode OperA in Opers) { - ShaderIrOperGpr OperD = GetOperGpr0(OpCode); + ShaderIrOperGpr OperD = OpCode.Gpr0(); OperD.Index += Index++; - Block.AddNode(GetPredNode(new ShaderIrAsg(OperA, OperD), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperA, OperD))); } } public static void Texq(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrNode OperD = GetOperGpr0(OpCode); - ShaderIrNode OperA = GetOperGpr8(OpCode); + ShaderIrNode OperD = OpCode.Gpr0(); + ShaderIrNode OperA = OpCode.Gpr8(); - ShaderTexqInfo Info = (ShaderTexqInfo)((OpCode >> 22) & 0x1f); + ShaderTexqInfo Info = (ShaderTexqInfo)(OpCode.Read(22, 0x1f)); ShaderIrMetaTexq Meta0 = new ShaderIrMetaTexq(Info, 0); ShaderIrMetaTexq Meta1 = new ShaderIrMetaTexq(Info, 1); - ShaderIrNode OperC = GetOperImm13_36(OpCode); + ShaderIrNode OperC = OpCode.Imm13_36(); ShaderIrOp Op0 = new ShaderIrOp(ShaderIrInst.Texq, OperA, null, OperC, Meta0); ShaderIrOp Op1 = new ShaderIrOp(ShaderIrInst.Texq, OperA, null, OperC, Meta1); - Block.AddNode(GetPredNode(new ShaderIrAsg(OperD, Op0), OpCode)); - Block.AddNode(GetPredNode(new ShaderIrAsg(OperA, Op1), OpCode)); //Is this right? + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperD, Op0))); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperA, Op1))); //Is this right? } public static void Tex(ShaderIrBlock Block, long OpCode, long Position) @@ -149,7 +149,7 @@ namespace Ryujinx.Graphics.Gal.Shader for (int Index = 0; Index < Coords.Length; Index++) { - Coords[Index] = GetOperGpr8(OpCode); + Coords[Index] = OpCode.Gpr8(); Coords[Index].Index += Index; @@ -159,11 +159,11 @@ namespace Ryujinx.Graphics.Gal.Shader } } - int ChMask = (int)(OpCode >> 31) & 0xf; + int ChMask = OpCode.Read(31, 0xf); ShaderIrNode OperC = GprHandle - ? (ShaderIrNode)GetOperGpr20 (OpCode) - : (ShaderIrNode)GetOperImm13_36(OpCode); + ? (ShaderIrNode)OpCode.Gpr20() + : (ShaderIrNode)OpCode.Imm13_36(); ShaderIrInst Inst = GprHandle ? ShaderIrInst.Texb : ShaderIrInst.Texs; @@ -175,7 +175,7 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrOp Op = new ShaderIrOp(Inst, Coords[0], Coords[1], OperC, Meta); - Block.AddNode(GetPredNode(new ShaderIrAsg(Dst, Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(Dst, Op))); } int RegInc = 0; @@ -189,7 +189,7 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrOperGpr Src = new ShaderIrOperGpr(TempRegStart + Ch); - ShaderIrOperGpr Dst = GetOperGpr0(OpCode); + ShaderIrOperGpr Dst = OpCode.Gpr0(); Dst.Index += RegInc++; @@ -198,7 +198,7 @@ namespace Ryujinx.Graphics.Gal.Shader continue; } - Block.AddNode(GetPredNode(new ShaderIrAsg(Dst, Src), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(Dst, Src))); } } @@ -215,14 +215,14 @@ namespace Ryujinx.Graphics.Gal.Shader private static void EmitTexs(ShaderIrBlock Block, long OpCode, ShaderIrInst Inst) { //TODO: Support other formats. - ShaderIrNode OperA = GetOperGpr8 (OpCode); - ShaderIrNode OperB = GetOperGpr20 (OpCode); - ShaderIrNode OperC = GetOperImm13_36(OpCode); + ShaderIrNode OperA = OpCode.Gpr8(); + ShaderIrNode OperB = OpCode.Gpr20(); + ShaderIrNode OperC = OpCode.Imm13_36(); int LutIndex; - LutIndex = GetOperGpr0 (OpCode).Index != ShaderIrOperGpr.ZRIndex ? 1 : 0; - LutIndex |= GetOperGpr28(OpCode).Index != ShaderIrOperGpr.ZRIndex ? 2 : 0; + LutIndex = OpCode.Gpr0 ().Index != ShaderIrOperGpr.ZRIndex ? 1 : 0; + LutIndex |= OpCode.Gpr28().Index != ShaderIrOperGpr.ZRIndex ? 2 : 0; if (LutIndex == 0) { @@ -231,7 +231,7 @@ namespace Ryujinx.Graphics.Gal.Shader return; } - int ChMask = MaskLut[LutIndex, (OpCode >> 50) & 7]; + int ChMask = MaskLut[LutIndex, OpCode.Read(50, 7)]; for (int Ch = 0; Ch < 4; Ch++) { @@ -241,7 +241,7 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrOp Op = new ShaderIrOp(Inst, OperA, OperB, OperC, Meta); - Block.AddNode(GetPredNode(new ShaderIrAsg(Dst, Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(Dst, Op))); } int RegInc = 0; @@ -252,11 +252,11 @@ namespace Ryujinx.Graphics.Gal.Shader switch (LutIndex) { - case 1: Dst = GetOperGpr0 (OpCode); break; - case 2: Dst = GetOperGpr28(OpCode); break; + case 1: Dst = OpCode.Gpr0(); break; + case 2: Dst = OpCode.Gpr28(); break; case 3: Dst = (RegInc >> 1) != 0 - ? GetOperGpr28(OpCode) - : GetOperGpr0 (OpCode); break; + ? OpCode.Gpr28() + : OpCode.Gpr0 (); break; default: throw new InvalidOperationException(); } @@ -279,7 +279,7 @@ namespace Ryujinx.Graphics.Gal.Shader if (Dst.Index != ShaderIrOperGpr.ZRIndex) { - Block.AddNode(GetPredNode(new ShaderIrAsg(Dst, Src), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(Dst, Src))); } } } diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs index aef92c5a..add39402 100644 --- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs @@ -92,35 +92,35 @@ namespace Ryujinx.Graphics.Gal.Shader Block.AddNode(new ShaderIrCmnt("Stubbed.")); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), GetOperGpr8(OpCode)), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OpCode.Gpr8()))); } public static void Mov_C(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrOperCbuf Cbuf = GetOperCbuf34(OpCode); + ShaderIrOperCbuf Cbuf = OpCode.Cbuf34(); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Cbuf), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Cbuf))); } public static void Mov_I(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrOperImm Imm = GetOperImm19_20(OpCode); + ShaderIrOperImm Imm = OpCode.Imm19_20(); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Imm), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Imm))); } public static void Mov_I32(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrOperImm Imm = GetOperImm32_20(OpCode); + ShaderIrOperImm Imm = OpCode.Imm32_20(); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Imm), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Imm))); } public static void Mov_R(ShaderIrBlock Block, long OpCode, long Position) { - ShaderIrOperGpr Gpr = GetOperGpr20(OpCode); + ShaderIrOperGpr Gpr = OpCode.Gpr20(); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Gpr), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Gpr))); } public static void Sel_C(ShaderIrBlock Block, long OpCode, long Position) @@ -145,21 +145,21 @@ namespace Ryujinx.Graphics.Gal.Shader //Zero is used as a special number to get a valid "0 * 0 + VertexIndex" in a GS ShaderIrNode Source = new ShaderIrOperImm(0); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Source), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Source))); } private static void EmitF2f(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - bool NegA = ((OpCode >> 45) & 1) != 0; - bool AbsA = ((OpCode >> 49) & 1) != 0; + bool NegA = OpCode.Read(45); + bool AbsA = OpCode.Read(49); ShaderIrNode OperA; switch (Oper) { - case ShaderOper.CR: OperA = GetOperCbuf34 (OpCode); break; - case ShaderOper.Immf: OperA = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperA = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperA = OpCode.Cbuf34(); break; + case ShaderOper.Immf: OperA = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperA = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -173,7 +173,7 @@ namespace Ryujinx.Graphics.Gal.Shader OperA = new ShaderIrOp(RoundInst, OperA); } - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), OperA), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OperA))); } private static void EmitF2i(ShaderIrBlock Block, long OpCode, ShaderOper Oper) @@ -188,16 +188,16 @@ namespace Ryujinx.Graphics.Gal.Shader throw new NotImplementedException(); } - bool NegA = ((OpCode >> 45) & 1) != 0; - bool AbsA = ((OpCode >> 49) & 1) != 0; + bool NegA = OpCode.Read(45); + bool AbsA = OpCode.Read(49); ShaderIrNode OperA; switch (Oper) { - case ShaderOper.CR: OperA = GetOperCbuf34 (OpCode); break; - case ShaderOper.Immf: OperA = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperA = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperA = OpCode.Cbuf34(); break; + case ShaderOper.Immf: OperA = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperA = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -242,7 +242,7 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrNode Op = new ShaderIrOp(Inst, OperA); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitI2f(ShaderIrBlock Block, long OpCode, ShaderOper Oper) @@ -257,18 +257,18 @@ namespace Ryujinx.Graphics.Gal.Shader throw new NotImplementedException(); } - int Sel = (int)(OpCode >> 41) & 3; + int Sel = OpCode.Read(41, 3); - bool NegA = ((OpCode >> 45) & 1) != 0; - bool AbsA = ((OpCode >> 49) & 1) != 0; + bool NegA = OpCode.Read(45); + bool AbsA = OpCode.Read(49); ShaderIrNode OperA; switch (Oper) { - case ShaderOper.CR: OperA = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: OperA = GetOperImm19_20(OpCode); break; - case ShaderOper.RR: OperA = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperA = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperA = OpCode.Imm19_20(); break; + case ShaderOper.RR: OperA = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -297,7 +297,7 @@ namespace Ryujinx.Graphics.Gal.Shader ShaderIrNode Op = new ShaderIrOp(Inst, OperA); - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } private static void EmitI2i(ShaderIrBlock Block, long OpCode, ShaderOper Oper) @@ -312,19 +312,19 @@ namespace Ryujinx.Graphics.Gal.Shader throw new NotImplementedException(); } - int Sel = (int)(OpCode >> 41) & 3; + int Sel = OpCode.Read(41, 3); - bool NegA = ((OpCode >> 45) & 1) != 0; - bool AbsA = ((OpCode >> 49) & 1) != 0; - bool SatA = ((OpCode >> 50) & 1) != 0; + bool NegA = OpCode.Read(45); + bool AbsA = OpCode.Read(49); + bool SatA = OpCode.Read(50); ShaderIrNode OperA; switch (Oper) { - case ShaderOper.CR: OperA = GetOperCbuf34 (OpCode); break; - case ShaderOper.Immf: OperA = GetOperImmf19_20(OpCode); break; - case ShaderOper.RR: OperA = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: OperA = OpCode.Cbuf34(); break; + case ShaderOper.Immf: OperA = OpCode.Immf19_20(); break; + case ShaderOper.RR: OperA = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } @@ -372,36 +372,36 @@ namespace Ryujinx.Graphics.Gal.Shader } } - Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), OperA), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OperA))); } private static void EmitSel(ShaderIrBlock Block, long OpCode, ShaderOper Oper) { - ShaderIrOperGpr Dst = GetOperGpr0 (OpCode); - ShaderIrNode Pred = GetOperPred39N(OpCode); + ShaderIrOperGpr Dst = OpCode.Gpr0(); + ShaderIrNode Pred = OpCode.Pred39N(); - ShaderIrNode ResultA = GetOperGpr8(OpCode); + ShaderIrNode ResultA = OpCode.Gpr8(); ShaderIrNode ResultB; switch (Oper) { - case ShaderOper.CR: ResultB = GetOperCbuf34 (OpCode); break; - case ShaderOper.Imm: ResultB = GetOperImm19_20(OpCode); break; - case ShaderOper.RR: ResultB = GetOperGpr20 (OpCode); break; + case ShaderOper.CR: ResultB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: ResultB = OpCode.Imm19_20(); break; + case ShaderOper.RR: ResultB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } - Block.AddNode(GetPredNode(new ShaderIrCond(Pred, new ShaderIrAsg(Dst, ResultA), false), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrCond(Pred, new ShaderIrAsg(Dst, ResultA), false))); - Block.AddNode(GetPredNode(new ShaderIrCond(Pred, new ShaderIrAsg(Dst, ResultB), true), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrCond(Pred, new ShaderIrAsg(Dst, ResultB), true))); } private static IntType GetIntType(long OpCode) { - bool Signed = ((OpCode >> 13) & 1) != 0; + bool Signed = OpCode.Read(13); - IntType Type = (IntType)((OpCode >> 10) & 3); + IntType Type = (IntType)(OpCode.Read(10, 3)); if (Signed) { @@ -413,12 +413,12 @@ namespace Ryujinx.Graphics.Gal.Shader private static FloatType GetFloatType(long OpCode) { - return (FloatType)((OpCode >> 8) & 3); + return (FloatType)(OpCode.Read(8, 3)); } private static ShaderIrInst GetRoundInst(long OpCode) { - switch ((OpCode >> 39) & 3) + switch (OpCode.Read(39, 3)) { case 1: return ShaderIrInst.Floor; case 2: return ShaderIrInst.Ceil; diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeOpCode.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeOpCode.cs new file mode 100644 index 00000000..3af17cae --- /dev/null +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeOpCode.cs @@ -0,0 +1,260 @@ +using System; + +namespace Ryujinx.Graphics.Gal.Shader +{ + static partial class ShaderDecode + { + private static int Read(this long OpCode, int Position, int Mask) + { + return (int)(OpCode >> Position) & Mask; + } + + private static bool Read(this long OpCode, int Position) + { + return ((OpCode >> Position) & 1) != 0; + } + + private static int Branch(this long OpCode) + { + return ((int)(OpCode >> 20) << 8) >> 8; + } + + private static ShaderIrOperAbuf[] Abuf20(this long OpCode) + { + int Abuf = OpCode.Read(20, 0x3ff); + int Size = OpCode.Read(47, 3); + + ShaderIrOperGpr Vertex = OpCode.Gpr39(); + + ShaderIrOperAbuf[] Opers = new ShaderIrOperAbuf[Size + 1]; + + for (int Index = 0; Index <= Size; Index++) + { + Opers[Index] = new ShaderIrOperAbuf(Abuf + Index * 4, Vertex); + } + + return Opers; + } + + private static ShaderIrOperAbuf Abuf28(this long OpCode) + { + int Abuf = OpCode.Read(28, 0x3ff); + + return new ShaderIrOperAbuf(Abuf, OpCode.Gpr39()); + } + + private static ShaderIrOperCbuf Cbuf34(this long OpCode) + { + return new ShaderIrOperCbuf( + OpCode.Read(34, 0x1f), + OpCode.Read(20, 0x3fff)); + } + + private static ShaderIrOperGpr Gpr8(this long OpCode) + { + return new ShaderIrOperGpr(OpCode.Read(8, 0xff)); + } + + private static ShaderIrOperGpr Gpr20(this long OpCode) + { + return new ShaderIrOperGpr(OpCode.Read(20, 0xff)); + } + + private static ShaderIrOperGpr Gpr39(this long OpCode) + { + return new ShaderIrOperGpr(OpCode.Read(39, 0xff)); + } + + private static ShaderIrOperGpr Gpr0(this long OpCode) + { + return new ShaderIrOperGpr(OpCode.Read(0, 0xff)); + } + + private static ShaderIrOperGpr Gpr28(this long OpCode) + { + return new ShaderIrOperGpr(OpCode.Read(28, 0xff)); + } + + private static ShaderIrOperImm Imm5_39(this long OpCode) + { + return new ShaderIrOperImm(OpCode.Read(39, 0x1f)); + } + + private static ShaderIrOperImm Imm13_36(this long OpCode) + { + return new ShaderIrOperImm(OpCode.Read(36, 0x1fff)); + } + + private static ShaderIrOperImm Imm32_20(this long OpCode) + { + return new ShaderIrOperImm((int)(OpCode >> 20)); + } + + private static ShaderIrOperImmf Immf32_20(this long OpCode) + { + return new ShaderIrOperImmf(BitConverter.Int32BitsToSingle((int)(OpCode >> 20))); + } + + private static ShaderIrOperImm Imm19_20(this long OpCode) + { + int Value = OpCode.Read(20, 0x7ffff); + + bool Neg = OpCode.Read(56); + + if (Neg) + { + Value = -Value; + } + + return new ShaderIrOperImm(Value); + } + + private static ShaderIrOperImmf Immf19_20(this long OpCode) + { + uint Imm = (uint)(OpCode >> 20) & 0x7ffff; + + bool Neg = OpCode.Read(56); + + Imm <<= 12; + + if (Neg) + { + Imm |= 0x80000000; + } + + float Value = BitConverter.Int32BitsToSingle((int)Imm); + + return new ShaderIrOperImmf(Value); + } + + private static ShaderIrOperPred Pred0(this long OpCode) + { + return new ShaderIrOperPred(OpCode.Read(0, 7)); + } + + private static ShaderIrOperPred Pred3(this long OpCode) + { + return new ShaderIrOperPred(OpCode.Read(3, 7)); + } + + private static ShaderIrOperPred Pred12(this long OpCode) + { + return new ShaderIrOperPred(OpCode.Read(12, 7)); + } + + private static ShaderIrOperPred Pred29(this long OpCode) + { + return new ShaderIrOperPred(OpCode.Read(29, 7)); + } + + private static ShaderIrNode Pred39N(this long OpCode) + { + ShaderIrNode Node = OpCode.Pred39(); + + if (OpCode.Read(42)) + { + Node = new ShaderIrOp(ShaderIrInst.Bnot, Node); + } + + return Node; + } + + private static ShaderIrOperPred Pred39(this long OpCode) + { + return new ShaderIrOperPred(OpCode.Read(39, 7)); + } + + private static ShaderIrOperPred Pred48(this long OpCode) + { + return new ShaderIrOperPred(OpCode.Read(48, 7)); + } + + private static ShaderIrInst Cmp(this long OpCode) + { + switch (OpCode.Read(49, 7)) + { + case 1: return ShaderIrInst.Clt; + case 2: return ShaderIrInst.Ceq; + case 3: return ShaderIrInst.Cle; + case 4: return ShaderIrInst.Cgt; + case 5: return ShaderIrInst.Cne; + case 6: return ShaderIrInst.Cge; + } + + throw new ArgumentException(nameof(OpCode)); + } + + private static ShaderIrInst CmpF(this long OpCode) + { + switch (OpCode.Read(48, 0xf)) + { + case 0x1: return ShaderIrInst.Fclt; + case 0x2: return ShaderIrInst.Fceq; + case 0x3: return ShaderIrInst.Fcle; + case 0x4: return ShaderIrInst.Fcgt; + case 0x5: return ShaderIrInst.Fcne; + case 0x6: return ShaderIrInst.Fcge; + case 0x7: return ShaderIrInst.Fcnum; + case 0x8: return ShaderIrInst.Fcnan; + case 0x9: return ShaderIrInst.Fcltu; + case 0xa: return ShaderIrInst.Fcequ; + case 0xb: return ShaderIrInst.Fcleu; + case 0xc: return ShaderIrInst.Fcgtu; + case 0xd: return ShaderIrInst.Fcneu; + case 0xe: return ShaderIrInst.Fcgeu; + } + + throw new ArgumentException(nameof(OpCode)); + } + + private static ShaderIrInst BLop45(this long OpCode) + { + switch (OpCode.Read(45, 3)) + { + case 0: return ShaderIrInst.Band; + case 1: return ShaderIrInst.Bor; + case 2: return ShaderIrInst.Bxor; + } + + throw new ArgumentException(nameof(OpCode)); + } + + private static ShaderIrInst BLop24(this long OpCode) + { + switch (OpCode.Read(24, 3)) + { + case 0: return ShaderIrInst.Band; + case 1: return ShaderIrInst.Bor; + case 2: return ShaderIrInst.Bxor; + } + + throw new ArgumentException(nameof(OpCode)); + } + + private static ShaderIrNode PredNode(this long OpCode, ShaderIrNode Node) + { + ShaderIrOperPred Pred = OpCode.PredNode(); + + if (Pred.Index != ShaderIrOperPred.UnusedIndex) + { + bool Inv = OpCode.Read(19); + + Node = new ShaderIrCond(Pred, Node, Inv); + } + + return Node; + } + + private static ShaderIrOperPred PredNode(this long OpCode) + { + int Pred = OpCode.Read(16, 0xf); + + if (Pred != 0xf) + { + Pred &= 7; + } + + return new ShaderIrOperPred(Pred); + } + } +}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs index 4300c32e..c3e42654 100644 --- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeSpecial.cs @@ -7,20 +7,20 @@ namespace Ryujinx.Graphics.Gal.Shader public static void Out_R(ShaderIrBlock Block, long OpCode, long Position) { //TODO: Those registers have to be used for something - ShaderIrOperGpr Gpr0 = GetOperGpr0(OpCode); - ShaderIrOperGpr Gpr8 = GetOperGpr8(OpCode); - ShaderIrOperGpr Gpr20 = GetOperGpr20(OpCode); + ShaderIrOperGpr Gpr0 = OpCode.Gpr0(); + ShaderIrOperGpr Gpr8 = OpCode.Gpr8(); + ShaderIrOperGpr Gpr20 = OpCode.Gpr20(); - int Type = (int)((OpCode >> 39) & 3); + int Type = OpCode.Read(39, 3); if ((Type & 1) != 0) { - Block.AddNode(GetPredNode(new ShaderIrOp(ShaderIrInst.Emit), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Emit))); } if ((Type & 2) != 0) { - Block.AddNode(GetPredNode(new ShaderIrOp(ShaderIrInst.Cut), OpCode)); + Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Cut))); } } } |