diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs index deccd890f7..6a928603ae 100644 --- a/Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs +++ b/Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs @@ -159,25 +159,23 @@ namespace Ryujinx.Graphics.Gal.OpenGL Shader.SetExtraData(New.FlipX, New.FlipY, New.Instance); } - //Note: Uncomment SetFrontFace and SetCullFace when flipping issues are solved + if (New.FrontFace != Old.FrontFace) + { + GL.FrontFace(OGLEnumConverter.GetFrontFace(New.FrontFace)); + } - //if (New.FrontFace != Old.FrontFace) - //{ - // GL.FrontFace(OGLEnumConverter.GetFrontFace(New.FrontFace)); - //} + if (New.CullFaceEnabled != Old.CullFaceEnabled) + { + Enable(EnableCap.CullFace, New.CullFaceEnabled); + } - //if (New.CullFaceEnabled != Old.CullFaceEnabled) - //{ - // Enable(EnableCap.CullFace, New.CullFaceEnabled); - //} - - //if (New.CullFaceEnabled) - //{ - // if (New.CullFace != Old.CullFace) - // { - // GL.CullFace(OGLEnumConverter.GetCullFace(New.CullFace)); - // } - //} + if (New.CullFaceEnabled) + { + if (New.CullFace != Old.CullFace) + { + GL.CullFace(OGLEnumConverter.GetCullFace(New.CullFace)); + } + } if (New.DepthTestEnabled != Old.DepthTestEnabled) { diff --git a/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs b/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs index 77a451e959..854c827ee0 100644 --- a/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs +++ b/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs @@ -845,9 +845,7 @@ namespace Ryujinx.Graphics.Gal.Shader { case GlslDecl.PointCoordAttrX: return "gl_PointCoord.x"; case GlslDecl.PointCoordAttrY: return "gl_PointCoord.y"; - - //Note: It's a guess that Maxwell's face is 1 when gl_FrontFacing == true - case GlslDecl.FaceAttr: return "(gl_FrontFacing ? 1 : 0)"; + case GlslDecl.FaceAttr: return "(gl_FrontFacing ? -1 : 0)"; } } diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs index 24c85c8f0e..469092a23c 100644 --- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs @@ -1148,41 +1148,87 @@ namespace Ryujinx.Graphics.Gal.Shader Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op))); } + private enum XmadMode + { + Cfull = 0, + Clo = 1, + Chi = 2, + Csfu = 3, + Cbcc = 4 + } + 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.Read(48); - bool SignC = OpCode.Read(49); - bool HighB = OpCode.Read(52); - bool HighA = OpCode.Read(53); + bool SignedA = OpCode.Read(48); + bool SignedB = OpCode.Read(49); + bool HighB = OpCode.Read(52); + bool HighA = OpCode.Read(53); int Mode = OpCode.Read(50, 7); ShaderIrNode OperA = OpCode.Gpr8(), OperB, OperC; - ShaderIrOperImm Imm16 = new ShaderIrOperImm(16); - ShaderIrOperImm ImmMsk = new ShaderIrOperImm(0xffff); - - ShaderIrInst ShiftAB = SignAB ? ShaderIrInst.Asr : ShaderIrInst.Lsr; - ShaderIrInst ShiftC = SignC ? ShaderIrInst.Asr : ShaderIrInst.Lsr; - - if (HighA) - { - OperA = new ShaderIrOp(ShiftAB, OperA, Imm16); - } - switch (Oper) { - 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; + case ShaderOper.CR: OperB = OpCode.Cbuf34(); break; + case ShaderOper.Imm: OperB = OpCode.ImmU16_20(); break; + case ShaderOper.RC: OperB = OpCode.Gpr39(); break; + case ShaderOper.RR: OperB = OpCode.Gpr20(); break; default: throw new ArgumentException(nameof(Oper)); } - bool ProductShiftLeft = false, Merge = false; + ShaderIrNode OperB2 = OperB; + + if (Oper == ShaderOper.Imm) + { + int Imm = ((ShaderIrOperImm)OperB2).Value; + + if (!HighB) + { + Imm <<= 16; + } + + if (SignedB) + { + Imm >>= 16; + } + else + { + Imm = (int)((uint)Imm >> 16); + } + + OperB2 = new ShaderIrOperImm(Imm); + } + + ShaderIrOperImm Imm16 = new ShaderIrOperImm(16); + + //If we are working with the lower 16-bits of the A/B operands, + //we need to shift the lower 16-bits to the top 16-bits. Later, + //they will be right shifted. For U16 types, this will be a logical + //right shift, and for S16 types, a arithmetic right shift. + if (!HighA) + { + OperA = new ShaderIrOp(ShaderIrInst.Lsl, OperA, Imm16); + } + + if (!HighB && Oper != ShaderOper.Imm) + { + OperB2 = new ShaderIrOp(ShaderIrInst.Lsl, OperB2, Imm16); + } + + ShaderIrInst ShiftA = SignedA ? ShaderIrInst.Asr : ShaderIrInst.Lsr; + ShaderIrInst ShiftB = SignedB ? ShaderIrInst.Asr : ShaderIrInst.Lsr; + + OperA = new ShaderIrOp(ShiftA, OperA, Imm16); + + if (Oper != ShaderOper.Imm) + { + OperB2 = new ShaderIrOp(ShiftB, OperB2, Imm16); + } + + bool ProductShiftLeft = false; + bool Merge = false; if (Oper == ShaderOper.RC) { @@ -1196,40 +1242,53 @@ namespace Ryujinx.Graphics.Gal.Shader Merge = OpCode.Read(37); } - switch (Mode) - { - //CLO. - case 1: OperC = ExtendTo32(OperC, SignC, 16); break; - - //CHI. - case 2: OperC = new ShaderIrOp(ShiftC, OperC, Imm16); break; - } - - ShaderIrNode OperBH = OperB; - - if (HighB) - { - OperBH = new ShaderIrOp(ShiftAB, OperBH, Imm16); - } - - ShaderIrOp MulOp = new ShaderIrOp(ShaderIrInst.Mul, OperA, OperBH); + ShaderIrOp MulOp = new ShaderIrOp(ShaderIrInst.Mul, OperA, OperB2); if (ProductShiftLeft) { MulOp = new ShaderIrOp(ShaderIrInst.Lsl, MulOp, Imm16); } + switch ((XmadMode)Mode) + { + case XmadMode.Clo: OperC = ExtendTo32(OperC, Signed: false, Size: 16); break; + + case XmadMode.Chi: OperC = new ShaderIrOp(ShaderIrInst.Lsr, OperC, Imm16); break; + + case XmadMode.Cbcc: + { + ShaderIrOp OperBLsh16 = new ShaderIrOp(ShaderIrInst.Lsl, OperB, Imm16); + + OperC = new ShaderIrOp(ShaderIrInst.Add, OperC, OperBLsh16); + + break; + } + + case XmadMode.Csfu: + { + ShaderIrOperImm Imm31 = new ShaderIrOperImm(31); + + ShaderIrOp SignAdjustA = new ShaderIrOp(ShaderIrInst.Lsr, OperA, Imm31); + ShaderIrOp SignAdjustB = new ShaderIrOp(ShaderIrInst.Lsr, OperB2, Imm31); + + SignAdjustA = new ShaderIrOp(ShaderIrInst.Lsl, SignAdjustA, Imm16); + SignAdjustB = new ShaderIrOp(ShaderIrInst.Lsl, SignAdjustB, Imm16); + + ShaderIrOp SignAdjust = new ShaderIrOp(ShaderIrInst.Add, SignAdjustA, SignAdjustB); + + OperC = new ShaderIrOp(ShaderIrInst.Sub, OperC, SignAdjust); + + break; + } + } + ShaderIrOp AddOp = new ShaderIrOp(ShaderIrInst.Add, MulOp, OperC); if (Merge) { - AddOp = new ShaderIrOp(ShaderIrInst.And, AddOp, ImmMsk); - OperB = new ShaderIrOp(ShaderIrInst.Lsl, OperB, Imm16); - AddOp = new ShaderIrOp(ShaderIrInst.Or, AddOp, OperB); - } + ShaderIrOperImm Imm16Mask = new ShaderIrOperImm(0xffff); - if (Mode == 4) - { + AddOp = new ShaderIrOp(ShaderIrInst.And, AddOp, Imm16Mask); OperB = new ShaderIrOp(ShaderIrInst.Lsl, OperB, Imm16); AddOp = new ShaderIrOp(ShaderIrInst.Or, AddOp, OperB); } diff --git a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeOpCode.cs b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeOpCode.cs index 6531138e7a..f0f92148e6 100644 --- a/Ryujinx.Graphics/Gal/Shader/ShaderDecodeOpCode.cs +++ b/Ryujinx.Graphics/Gal/Shader/ShaderDecodeOpCode.cs @@ -138,6 +138,11 @@ namespace Ryujinx.Graphics.Gal.Shader return new ShaderIrOperImmf(BitConverter.Int32BitsToSingle((int)(OpCode >> 20))); } + private static ShaderIrOperImm ImmU16_20(this long OpCode) + { + return new ShaderIrOperImm(OpCode.Read(20, 0xffff)); + } + private static ShaderIrOperImm Imm19_20(this long OpCode) { int Value = OpCode.Read(20, 0x7ffff);