From f601f0d98f540b98eed28995f9df85dad300e8cf Mon Sep 17 00:00:00 2001 From: gdkchan Date: Thu, 28 Mar 2019 22:08:23 -0300 Subject: [PATCH] Implement TLD4 --- Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs | 2 +- .../Shader/CodeGen/Glsl/Declarations.cs | 2 +- .../Shader/CodeGen/Glsl/Instructions.cs | 53 +++- .../Shader/Decoders/OpCodeTable.cs | 1 + .../Shader/Instructions/InstEmitMemory.cs | 282 +++++++++++++----- .../Instructions/TextureGatherOffset.cs | 9 + .../TextureFlags.cs | 15 + .../TextureOperation.cs | 5 +- .../IntermediateRepresentation/TextureType.cs | 9 +- .../StructuredIr/AstTextureOperation.cs | 5 +- .../Shader/StructuredIr/StructuredProgram.cs | 1 + .../Shader/Translation/Translator.cs | 2 - 12 files changed, 294 insertions(+), 92 deletions(-) create mode 100644 Ryujinx.Graphics/Shader/Instructions/TextureGatherOffset.cs create mode 100644 Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureFlags.cs diff --git a/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs b/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs index 1b6e993706..d98363112c 100644 --- a/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs +++ b/Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs @@ -1460,7 +1460,7 @@ namespace Ryujinx.Graphics.Gal.Shader // TODO: Support PTP else if ((suffix & TextureInstructionSuffix.Ptp) != 0) { - throw new NotImplementedException(); + //throw new NotImplementedException(); } return "textureGather(" + sampler + ", " + coords + ", " + comp + ")" + chString; diff --git a/Ryujinx.Graphics/Shader/CodeGen/Glsl/Declarations.cs b/Ryujinx.Graphics/Shader/CodeGen/Glsl/Declarations.cs index b2f0b7cda4..e8c3555873 100644 --- a/Ryujinx.Graphics/Shader/CodeGen/Glsl/Declarations.cs +++ b/Ryujinx.Graphics/Shader/CodeGen/Glsl/Declarations.cs @@ -136,7 +136,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl typeName += "Array"; } - if ((type & TextureType.DepthCompare) != 0) + if ((type & TextureType.Shadow) != 0) { typeName += "Shadow"; } diff --git a/Ryujinx.Graphics/Shader/CodeGen/Glsl/Instructions.cs b/Ryujinx.Graphics/Shader/CodeGen/Glsl/Instructions.cs index de10866b5d..cc09a60b02 100644 --- a/Ryujinx.Graphics/Shader/CodeGen/Glsl/Instructions.cs +++ b/Ryujinx.Graphics/Shader/CodeGen/Glsl/Instructions.cs @@ -251,21 +251,31 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl { AstTextureOperation texOp = (AstTextureOperation)operation; - bool isShadow = (context.Info.Samplers[texOp.TextureHandle] & TextureType.DepthCompare) != 0; + bool isGather = (texOp.Flags & TextureFlags.Gather) != 0; + bool isShadow = (texOp.Type & TextureType.Shadow) != 0; string samplerName = OperandManager.GetSamplerName(context.ShaderType, texOp.TextureHandle); string texCall = "texture"; - if ((texOp.Type & TextureType.LodLevel) != 0) + if (isGather) + { + texCall += "Gather"; + } + + if ((texOp.Flags & TextureFlags.LodLevel) != 0) { texCall += "Lod"; } - if ((texOp.Type & TextureType.Offset) != 0) + if ((texOp.Flags & TextureFlags.Offset) != 0) { texCall += "Offset"; } + else if ((texOp.Flags & TextureFlags.Offsets) != 0) + { + texCall += "Offsets"; + } texCall += "(" + samplerName; @@ -292,12 +302,13 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl arrayIndexElem = pCount++; } - if ((texOp.Type & TextureType.DepthCompare) != 0) + if (isShadow && !isGather) { pCount++; } - bool hasExtraCompareArg = false; + //On textureGather*, the comparison value is always specified as an extra argument. + bool hasExtraCompareArg = isShadow && isGather; if (pCount == 5) { @@ -348,24 +359,48 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl texCall += ", " + Src(VariableType.F32); } - if ((texOp.Type & TextureType.LodLevel) != 0) + if ((texOp.Flags & TextureFlags.LodLevel) != 0) { texCall += ", " + Src(VariableType.F32); } - if ((texOp.Type & TextureType.Offset) != 0) + if ((texOp.Flags & TextureFlags.Offset) != 0) { texCall += ", " + AssembleVector(elemsCount, VariableType.S32); } + else if ((texOp.Flags & TextureFlags.Offsets) != 0) + { + const int gatherTexelsCount = 4; - if ((texOp.Type & TextureType.LodBias) != 0) + texCall += $", ivec{elemsCount}[{gatherTexelsCount}]("; + + for (int index = 0; index < gatherTexelsCount; index++) + { + texCall += AssembleVector(elemsCount, VariableType.S32); + + if (index < gatherTexelsCount - 1) + { + texCall += ", "; + } + } + + texCall += ")"; + } + + if ((texOp.Flags & TextureFlags.LodBias) != 0) { texCall += ", " + Src(VariableType.F32); } + //textureGather* optional extra component index, not needed for shadow samplers. + if (isGather && !isShadow) + { + texCall += ", " + Src(VariableType.S32); + } + texCall += ")"; - if (!isShadow) + if (isGather || !isShadow) { texCall += "."; diff --git a/Ryujinx.Graphics/Shader/Decoders/OpCodeTable.cs b/Ryujinx.Graphics/Shader/Decoders/OpCodeTable.cs index 4bbbcff8d7..520bd0ce4a 100644 --- a/Ryujinx.Graphics/Shader/Decoders/OpCodeTable.cs +++ b/Ryujinx.Graphics/Shader/Decoders/OpCodeTable.cs @@ -123,6 +123,7 @@ namespace Ryujinx.Graphics.Shader.Decoders Set("1111000011111x", InstEmit.Sync, typeof(OpCodeSync)); Set("110000xxxx111x", InstEmit.Tex, typeof(OpCodeTex)); Set("1101x00xxxxxxx", InstEmit.Texs, typeof(OpCodeTexs)); + Set("110010xxxx111x", InstEmit.Tld4, typeof(OpCodeTex)); Set("0100111xxxxxxx", InstEmit.Xmad, typeof(OpCodeAluCbuf)); Set("0011011x00xxxx", InstEmit.Xmad, typeof(OpCodeAluImm)); Set("010100010xxxxx", InstEmit.Xmad, typeof(OpCodeAluRegCbuf)); diff --git a/Ryujinx.Graphics/Shader/Instructions/InstEmitMemory.cs b/Ryujinx.Graphics/Shader/Instructions/InstEmitMemory.cs index e4f4553c52..389130ace9 100644 --- a/Ryujinx.Graphics/Shader/Instructions/InstEmitMemory.cs +++ b/Ryujinx.Graphics/Shader/Instructions/InstEmitMemory.cs @@ -156,7 +156,7 @@ namespace Ryujinx.Graphics.Shader.Instructions return Const(0); } - return Register(new Register(raIndex++, RegisterType.Gpr)); + return context.Copy(Register(new Register(raIndex++, RegisterType.Gpr))); } Operand Rb() @@ -166,36 +166,24 @@ namespace Ryujinx.Graphics.Shader.Instructions return Const(0); } - return Register(new Register(rbIndex++, RegisterType.Gpr)); + return context.Copy(Register(new Register(rbIndex++, RegisterType.Gpr))); } Operand arrayIndex = op.IsArray ? Ra() : null; List sourcesList = new List(); - switch (op.Dimensions) - { - case TextureDimensions.Texture1D: - sourcesList.Add(Ra()); - break; - - case TextureDimensions.Texture2D: - sourcesList.Add(Ra()); - sourcesList.Add(Ra()); - break; - - case TextureDimensions.Texture3D: - case TextureDimensions.TextureCube: - sourcesList.Add(Ra()); - sourcesList.Add(Ra()); - sourcesList.Add(Ra()); - break; - } - - int elemsCount = sourcesList.Count; - TextureType type = GetTextureType(op.Dimensions); + TextureFlags flags = TextureFlags.None; + + int elemsCount = GetTextureCoordsCount(type); + + for (int index = 0; index < elemsCount; index++) + { + sourcesList.Add(Ra()); + } + if (op.IsArray) { sourcesList.Add(arrayIndex); @@ -220,7 +208,7 @@ namespace Ryujinx.Graphics.Shader.Instructions { sourcesList.Add(lodValue); - type |= TextureType.LodLevel; + flags |= TextureFlags.LodLevel; } if (op.HasOffset) @@ -230,7 +218,7 @@ namespace Ryujinx.Graphics.Shader.Instructions sourcesList.Add(context.BitfieldExtractS32(packedOffs, Const(index * 4), Const(4))); } - type |= TextureType.Offset; + flags |= TextureFlags.Offset; } if (op.LodMode == TextureLodMode.LodBias || @@ -238,7 +226,7 @@ namespace Ryujinx.Graphics.Shader.Instructions { sourcesList.Add(lodValue); - type |= TextureType.LodBias; + flags |= TextureFlags.LodBias; } Operand[] sources = sourcesList.ToArray(); @@ -266,6 +254,7 @@ namespace Ryujinx.Graphics.Shader.Instructions TextureOperation operation = new TextureOperation( Instruction.TextureSample, type, + flags, textureHandle, compIndex, dest, @@ -287,7 +276,7 @@ namespace Ryujinx.Graphics.Shader.Instructions List sourcesList = new List(); - Operand GetSource(int index) + Operand Src(int index) { int regIndex = 0; @@ -308,17 +297,17 @@ namespace Ryujinx.Graphics.Shader.Instructions switch (op.Type) { case TexsType.Texture1DLodZero: - sourcesList.Add(GetSource(0)); + sourcesList.Add(Src(0)); break; case TexsType.Texture2D: - sourcesList.Add(GetSource(0)); - sourcesList.Add(GetSource(2)); + sourcesList.Add(Src(0)); + sourcesList.Add(Src(2)); break; case TexsType.Texture2DLodZero: - sourcesList.Add(GetSource(0)); - sourcesList.Add(GetSource(2)); + sourcesList.Add(Src(0)); + sourcesList.Add(Src(2)); sourcesList.Add(ConstF(0)); break; @@ -326,52 +315,53 @@ namespace Ryujinx.Graphics.Shader.Instructions case TexsType.Texture2DDepthCompare: case TexsType.Texture3D: case TexsType.TextureCube: - sourcesList.Add(GetSource(0)); - sourcesList.Add(GetSource(1)); - sourcesList.Add(GetSource(2)); + sourcesList.Add(Src(0)); + sourcesList.Add(Src(1)); + sourcesList.Add(Src(2)); break; case TexsType.Texture2DLodZeroDepthCompare: case TexsType.Texture3DLodZero: - sourcesList.Add(GetSource(0)); - sourcesList.Add(GetSource(1)); - sourcesList.Add(GetSource(2)); + sourcesList.Add(Src(0)); + sourcesList.Add(Src(1)); + sourcesList.Add(Src(2)); sourcesList.Add(ConstF(0)); break; case TexsType.Texture2DLodLevelDepthCompare: case TexsType.TextureCubeLodLevel: - sourcesList.Add(GetSource(0)); - sourcesList.Add(GetSource(1)); - sourcesList.Add(GetSource(2)); - sourcesList.Add(GetSource(3)); + sourcesList.Add(Src(0)); + sourcesList.Add(Src(1)); + sourcesList.Add(Src(2)); + sourcesList.Add(Src(3)); break; case TexsType.Texture2DArray: - sourcesList.Add(GetSource(1)); - sourcesList.Add(GetSource(2)); - sourcesList.Add(GetSource(0)); + sourcesList.Add(Src(1)); + sourcesList.Add(Src(2)); + sourcesList.Add(Src(0)); break; case TexsType.Texture2DArrayLodZero: - sourcesList.Add(GetSource(1)); - sourcesList.Add(GetSource(2)); - sourcesList.Add(GetSource(0)); + sourcesList.Add(Src(1)); + sourcesList.Add(Src(2)); + sourcesList.Add(Src(0)); sourcesList.Add(ConstF(0)); break; case TexsType.Texture2DArrayLodZeroDepthCompare: - sourcesList.Add(GetSource(1)); - sourcesList.Add(GetSource(2)); - sourcesList.Add(GetSource(0)); - sourcesList.Add(GetSource(3)); + sourcesList.Add(Src(1)); + sourcesList.Add(Src(2)); + sourcesList.Add(Src(0)); + sourcesList.Add(Src(3)); sourcesList.Add(ConstF(0)); break; } Operand[] sources = sourcesList.ToArray(); - TextureType type = GetTextureType(op.Type); + TextureType type = GetTextureType (op.Type); + TextureFlags flags = GetTextureFlags(op.Type); int destIncrement = 0; @@ -408,6 +398,129 @@ namespace Ryujinx.Graphics.Shader.Instructions TextureOperation operation = new TextureOperation( Instruction.TextureSample, type, + flags, + textureHandle, + compIndex, + dest, + sources); + + context.Add(operation); + } + } + } + + public static void Tld4(EmitterContext context) + { + OpCodeTex op = (OpCodeTex)context.CurrOp; + + if (op.Rd.IsRZ) + { + return; + } + + TextureGatherOffset offset = (TextureGatherOffset)op.RawOpCode.Extract(54, 2); + + int gatherCompIndex = op.RawOpCode.Extract(56, 2); + + int raIndex = op.Ra.Index; + int rbIndex = op.Rb.Index; + + Operand Ra() + { + if (raIndex > RegisterConsts.RegisterZeroIndex) + { + return Const(0); + } + + return context.Copy(Register(new Register(raIndex++, RegisterType.Gpr))); + } + + Operand Rb() + { + if (rbIndex > RegisterConsts.RegisterZeroIndex) + { + return Const(0); + } + + return context.Copy(Register(new Register(rbIndex++, RegisterType.Gpr))); + } + + Operand arrayIndex = op.IsArray ? Ra() : null; + + List sourcesList = new List(); + + TextureType type = GetTextureType(op.Dimensions); + + TextureFlags flags = TextureFlags.Gather; + + int elemsCount = GetTextureCoordsCount(type); + + for (int index = 0; index < elemsCount; index++) + { + sourcesList.Add(Ra()); + } + + if (op.IsArray) + { + sourcesList.Add(arrayIndex); + + type |= TextureType.Array; + } + + Operand[] packedOffs = new Operand[2]; + + packedOffs[0] = offset != TextureGatherOffset.None ? Rb() : null; + packedOffs[1] = offset == TextureGatherOffset.Offsets ? Rb() : null; + + if (op.HasDepthCompare) + { + sourcesList.Add(Rb()); + } + + if (offset != TextureGatherOffset.None) + { + int offsetTexelsCount = offset == TextureGatherOffset.Offsets ? 4 : 1; + + for (int index = 0; index < elemsCount * offsetTexelsCount; index++) + { + Operand packed = packedOffs[(index >> 2) & 1]; + + sourcesList.Add(context.BitfieldExtractS32(packed, Const((index & 3) * 8), Const(6))); + } + + flags |= offset == TextureGatherOffset.Offsets + ? TextureFlags.Offsets + : TextureFlags.Offset; + } + + sourcesList.Add(Const(gatherCompIndex)); + + Operand[] sources = sourcesList.ToArray(); + + int rdIndex = op.Rd.Index; + + Operand GetDest() + { + if (rdIndex > RegisterConsts.RegisterZeroIndex) + { + return Const(0); + } + + return Register(new Register(rdIndex++, RegisterType.Gpr)); + } + + int textureHandle = op.Immediate; + + for (int compMask = op.ComponentMask, compIndex = 0; compMask != 0; compMask >>= 1, compIndex++) + { + if ((compMask & 1) != 0) + { + Operand dest = GetDest(); + + TextureOperation operation = new TextureOperation( + Instruction.TextureSample, + type, + flags, textureHandle, compIndex, dest, @@ -431,47 +544,76 @@ namespace Ryujinx.Graphics.Shader.Instructions throw new ArgumentException($"Invalid texture dimensions \"{dimensions}\"."); } + private static int GetTextureCoordsCount(TextureType type) + { + switch (type & TextureType.Mask) + { + case TextureType.Texture1D: return 1; + case TextureType.Texture2D: return 2; + case TextureType.Texture3D: return 3; + case TextureType.TextureCube: return 3; + } + + throw new ArgumentException($"Invalid texture type \"{type}\"."); + } + private static TextureType GetTextureType(TexsType type) { switch (type) { case TexsType.Texture1DLodZero: - return TextureType.Texture1D | TextureType.LodLevel; + return TextureType.Texture1D; case TexsType.Texture2D: - return TextureType.Texture2D; - case TexsType.Texture2DLodZero: case TexsType.Texture2DLodLevel: - return TextureType.Texture2D | TextureType.LodLevel; + return TextureType.Texture2D; case TexsType.Texture2DDepthCompare: - return TextureType.Texture2D | TextureType.DepthCompare; - case TexsType.Texture2DLodLevelDepthCompare: case TexsType.Texture2DLodZeroDepthCompare: - return TextureType.Texture2D | TextureType.LodLevelDepthCompare; + return TextureType.Texture2D | TextureType.Shadow; case TexsType.Texture2DArray: + case TexsType.Texture2DArrayLodZero: return TextureType.Texture2D | TextureType.Array; - case TexsType.Texture2DArrayLodZero: - return TextureType.Texture2D | TextureType.Array | TextureType.LodLevel; - case TexsType.Texture2DArrayLodZeroDepthCompare: - return TextureType.Texture2D | TextureType.Array | TextureType.LodLevelDepthCompare; + return TextureType.Texture2D | TextureType.Array | TextureType.Shadow; case TexsType.Texture3D: + case TexsType.Texture3DLodZero: return TextureType.Texture3D; - case TexsType.Texture3DLodZero: - return TextureType.Texture3D | TextureType.LodLevel; - case TexsType.TextureCube: - return TextureType.TextureCube; - case TexsType.TextureCubeLodLevel: - return TextureType.TextureCube | TextureType.LodLevel; + return TextureType.TextureCube; + } + + throw new ArgumentException($"Invalid texture type \"{type}\"."); + } + + private static TextureFlags GetTextureFlags(TexsType type) + { + switch (type) + { + case TexsType.Texture1DLodZero: + case TexsType.Texture2DLodZero: + case TexsType.Texture2DLodLevel: + case TexsType.Texture2DLodLevelDepthCompare: + case TexsType.Texture2DLodZeroDepthCompare: + case TexsType.Texture2DArrayLodZero: + case TexsType.Texture2DArrayLodZeroDepthCompare: + case TexsType.Texture3DLodZero: + case TexsType.TextureCubeLodLevel: + return TextureFlags.LodLevel; + + case TexsType.Texture2D: + case TexsType.Texture2DDepthCompare: + case TexsType.Texture2DArray: + case TexsType.Texture3D: + case TexsType.TextureCube: + return TextureFlags.None; } throw new ArgumentException($"Invalid texture type \"{type}\"."); diff --git a/Ryujinx.Graphics/Shader/Instructions/TextureGatherOffset.cs b/Ryujinx.Graphics/Shader/Instructions/TextureGatherOffset.cs new file mode 100644 index 0000000000..28d2701f9b --- /dev/null +++ b/Ryujinx.Graphics/Shader/Instructions/TextureGatherOffset.cs @@ -0,0 +1,9 @@ +namespace Ryujinx.Graphics.Shader.Instructions +{ + enum TextureGatherOffset + { + None = 0, + Offset = 1, + Offsets = 2 + } +} \ No newline at end of file diff --git a/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureFlags.cs b/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureFlags.cs new file mode 100644 index 0000000000..cfe733f105 --- /dev/null +++ b/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureFlags.cs @@ -0,0 +1,15 @@ +using System; + +namespace Ryujinx.Graphics.Shader.IntermediateRepresentation +{ + [Flags] + enum TextureFlags + { + None = 0, + Gather = 1 << 0, + LodBias = 1 << 1, + LodLevel = 1 << 2, + Offset = 1 << 3, + Offsets = 1 << 4 + } +} \ No newline at end of file diff --git a/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureOperation.cs b/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureOperation.cs index cc417efb07..177fcca961 100644 --- a/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureOperation.cs +++ b/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureOperation.cs @@ -2,7 +2,8 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation { class TextureOperation : Operation { - public TextureType Type { get; } + public TextureType Type { get; } + public TextureFlags Flags { get; } public int TextureHandle { get; } public int ComponentIndex { get; } @@ -10,12 +11,14 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation public TextureOperation( Instruction inst, TextureType type, + TextureFlags flags, int textureHandle, int componentIndex, Operand dest, params Operand[] sources) : base(inst, dest, sources) { Type = type; + Flags = flags; TextureHandle = textureHandle; ComponentIndex = componentIndex; } diff --git a/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureType.cs b/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureType.cs index 54ae2a9995..8d89ac8fd0 100644 --- a/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureType.cs +++ b/Ryujinx.Graphics/Shader/IntermediateRepresentation/TextureType.cs @@ -12,12 +12,7 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation Mask = 0xff, - Array = 1 << 8, - DepthCompare = 1 << 9, - LodBias = 1 << 10, - LodLevel = 1 << 11, - Offset = 1 << 12, - - LodLevelDepthCompare = LodLevel | DepthCompare + Array = 1 << 8, + Shadow = 1 << 9 } } \ No newline at end of file diff --git a/Ryujinx.Graphics/Shader/StructuredIr/AstTextureOperation.cs b/Ryujinx.Graphics/Shader/StructuredIr/AstTextureOperation.cs index 9c8befe60d..c197859f21 100644 --- a/Ryujinx.Graphics/Shader/StructuredIr/AstTextureOperation.cs +++ b/Ryujinx.Graphics/Shader/StructuredIr/AstTextureOperation.cs @@ -4,7 +4,8 @@ namespace Ryujinx.Graphics.Shader.StructuredIr { class AstTextureOperation : AstOperation { - public TextureType Type { get; } + public TextureType Type { get; } + public TextureFlags Flags { get; } public int TextureHandle { get; } public int[] Components { get; } @@ -12,11 +13,13 @@ namespace Ryujinx.Graphics.Shader.StructuredIr public AstTextureOperation( Instruction inst, TextureType type, + TextureFlags flags, int textureHandle, int[] components, params IAstNode[] sources) : base(inst, sources) { Type = type; + Flags = flags; TextureHandle = textureHandle; Components = components; } diff --git a/Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs b/Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs index 6595d359be..26f6a82bcd 100644 --- a/Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs +++ b/Ryujinx.Graphics/Shader/StructuredIr/StructuredProgram.cs @@ -79,6 +79,7 @@ namespace Ryujinx.Graphics.Shader.StructuredIr astOperation = new AstTextureOperation( inst, texOp.Type, + texOp.Flags, texOp.TextureHandle, components, sources); diff --git a/Ryujinx.Graphics/Shader/Translation/Translator.cs b/Ryujinx.Graphics/Shader/Translation/Translator.cs index 2f063d3d31..29fe3c55d2 100644 --- a/Ryujinx.Graphics/Shader/Translation/Translator.cs +++ b/Ryujinx.Graphics/Shader/Translation/Translator.cs @@ -103,8 +103,6 @@ namespace Ryujinx.Graphics.Shader.Translation string glslProgram = generator.Generate(prgInfo, shaderType); - System.Console.WriteLine(glslProgram); - return glslProgram; } }