N-archive/Ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Added more shader instructions, including BFE, BRA (partial), FMNMX, ISCADD, SHL, LD_C, some shader related fixes, added support for texture component selection

Browse source
This commit is contained in:
gdkchan 2018-05-17 15:25:42 -03:00
parent 9b9ead94cd
commit b19c474082
28 changed files with 806 additions and 118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
Ryujinx.Core/Gpu/TextureFactory.cs
View file

@ -11,6 +11,11 @@ namespace Ryujinx.Core.Gpu
GalTextureFormat Format = (GalTextureFormat)(Tic[0] & 0x7f);
GalTextureSource XSource = (GalTextureSource)((Tic[0] >> 19) & 7);
GalTextureSource YSource = (GalTextureSource)((Tic[0] >> 22) & 7);
GalTextureSource ZSource = (GalTextureSource)((Tic[0] >> 25) & 7);
GalTextureSource WSource = (GalTextureSource)((Tic[0] >> 28) & 7);
long TextureAddress = (uint)Tic[1];
TextureAddress |= (long)((ushort)Tic[2]) << 32;
@ -37,7 +42,15 @@ namespace Ryujinx.Core.Gpu
byte[] Data = TextureReader.Read(Vmm, Texture);
return new GalTexture(Data, Width, Height, Format);
return new GalTexture(
Data,
Width,
Height,
Format,
XSource,
YSource,
ZSource,
WSource);
}
public static GalTextureSampler MakeSampler(NvGpu Gpu, NvGpuVmm Vmm, long TscPosition)

7
Ryujinx.Core/OsHle/Kernel/SvcThread.cs
View file

@ -141,6 +141,13 @@ namespace Ryujinx.Core.OsHle.Kernel
private void SvcSetThreadCoreMask(AThreadState ThreadState)
{
//FIXME: This is wrong, but the "correct" way to handle
//this svc causes deadlocks when more often.
//There is probably something wrong with it still.
ThreadState.X0 = 0;
return;
int Handle = (int)ThreadState.X0;
int IdealCore = (int)ThreadState.X1;
long CoreMask = (long)ThreadState.X2;

18
Ryujinx.Core/OsHle/Services/Nifm/IRequest.cs
View file

@ -18,11 +18,12 @@ namespace Ryujinx.Core.OsHle.Services.Nifm
{
m_Commands = new Dictionary<int, ServiceProcessRequest>()
{
{ 0, GetRequestState },
{ 1, GetResult },
{ 2, GetSystemEventReadableHandles },
{ 3, Cancel },
{ 4, Submit },
{ 0, GetRequestState },
{ 1, GetResult },
{ 2, GetSystemEventReadableHandles },
{ 3, Cancel },
{ 4, Submit },
{ 11, SetConnectionConfirmationOption }
};
Event = new KEvent();
@ -69,6 +70,13 @@ namespace Ryujinx.Core.OsHle.Services.Nifm
return 0;
}
public long SetConnectionConfirmationOption(ServiceCtx Context)
{
Context.Ns.Log.PrintStub(LogClass.ServiceNifm, "Stubbed.");
return 0;
}
public void Dispose()
{
Dispose(true);

10
Ryujinx.Core/OsHle/Services/Prepo/IPrepoService.cs
View file

@ -1,3 +1,4 @@
using Ryujinx.Core.Logging;
using Ryujinx.Core.OsHle.Ipc;
using System.Collections.Generic;
@ -13,8 +14,15 @@ namespace Ryujinx.Core.OsHle.Services.Prepo
{
m_Commands = new Dictionary<int, ServiceProcessRequest>()
{
//...
{ 10101, SaveReportWithUser }
};
}
public static long SaveReportWithUser(ServiceCtx Context)
{
Context.Ns.Log.PrintStub(LogClass.ServicePrepo, "Stubbed.");
return 0;
}
}
}

27
Ryujinx.Graphics/Gal/GalTexture.cs
View file

@ -9,12 +9,29 @@ namespace Ryujinx.Graphics.Gal
public GalTextureFormat Format;
public GalTexture(byte[] Data, int Width, int Height, GalTextureFormat Format)
public GalTextureSource XSource;
public GalTextureSource YSource;
public GalTextureSource ZSource;
public GalTextureSource WSource;
public GalTexture(
byte[] Data,
int Width,
int Height,
GalTextureFormat Format,
GalTextureSource XSource,
GalTextureSource YSource,
GalTextureSource ZSource,
GalTextureSource WSource)
{
this.Data = Data;
this.Width = Width;
this.Height = Height;
this.Format = Format;
this.Data = Data;
this.Width = Width;
this.Height = Height;
this.Format = Format;
this.XSource = XSource;
this.YSource = YSource;
this.ZSource = ZSource;
this.WSource = WSource;
}
}
}

13
Ryujinx.Graphics/Gal/GalTextureSource.cs Normal file
View file

@ -0,0 +1,13 @@
namespace Ryujinx.Graphics.Gal
{
public enum GalTextureSource
{
Zero = 0,
Red = 2,
Green = 3,
Blue = 4,
Alpha = 5,
OneInt = 6,
OneFloat = 7
}
}

16
Ryujinx.Graphics/Gal/OpenGL/OGLEnumConverter.cs
View file

@ -81,6 +81,22 @@ namespace Ryujinx.Graphics.Gal.OpenGL
throw new NotImplementedException(Format.ToString());
}
public static All GetTextureSwizzle(GalTextureSource Source)
{
switch (Source)
{
case GalTextureSource.Zero: return All.Zero;
case GalTextureSource.Red: return All.Red;
case GalTextureSource.Green: return All.Green;
case GalTextureSource.Blue: return All.Blue;
case GalTextureSource.Alpha: return All.Alpha;
case GalTextureSource.OneInt: return All.One;
case GalTextureSource.OneFloat: return All.One;
}
throw new ArgumentException(nameof(Source));
}
public static TextureWrapMode GetTextureWrapMode(GalTextureWrap Wrap)
{
switch (Wrap)

20
Ryujinx.Graphics/Gal/OpenGL/OGLShader.cs
View file

@ -87,10 +87,10 @@ namespace Ryujinx.Graphics.Gal.OpenGL
public void Create(long Tag, GalShaderType Type, byte[] Data)
{
Stages.GetOrAdd(Tag, (Key) => ShaderStageFactory(Type, Data));
Stages.GetOrAdd(Tag, (Key) => ShaderStageFactory(Type, Tag, Data));
}
private ShaderStage ShaderStageFactory(GalShaderType Type, byte[] Data)
private ShaderStage ShaderStageFactory(GalShaderType Type, long Tag, byte[] Data)
{
GlslProgram Program = GetGlslProgram(Data, Type);
@ -140,11 +140,21 @@ namespace Ryujinx.Graphics.Gal.OpenGL
{
foreach (ShaderDeclInfo DeclInfo in Stage.UniformUsage.Where(x => x.Cbuf == Cbuf))
{
float Value = BitConverter.ToSingle(Data, DeclInfo.Index * 4);
int Location = GL.GetUniformLocation(CurrentProgramHandle, DeclInfo.Name);
GL.Uniform1(Location, Value);
int Count = Data.Length >> 2;
//The Index is the index of the last element,
//so we can add 1 to get the uniform array size.
Count = Math.Min(Count, DeclInfo.Index + 1);
unsafe
{
fixed (byte* Ptr = Data)
{
GL.Uniform1(Location, Count, (float*)Ptr);
}
}
}
}
}

10
Ryujinx.Graphics/Gal/OpenGL/OGLTexture.cs
View file

@ -51,6 +51,16 @@ namespace Ryujinx.Graphics.Gal.OpenGL
Type,
Texture.Data);
}
int SwizzleR = (int)OGLEnumConverter.GetTextureSwizzle(Texture.XSource);
int SwizzleG = (int)OGLEnumConverter.GetTextureSwizzle(Texture.YSource);
int SwizzleB = (int)OGLEnumConverter.GetTextureSwizzle(Texture.ZSource);
int SwizzleA = (int)OGLEnumConverter.GetTextureSwizzle(Texture.WSource);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleR, SwizzleR);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleG, SwizzleG);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleB, SwizzleB);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureSwizzleA, SwizzleA);
}
public void Bind(int Index)

28
Ryujinx.Graphics/Gal/Shader/GlslDecl.cs
View file

@ -28,7 +28,7 @@ namespace Ryujinx.Graphics.Gal.Shader
private Dictionary<int, ShaderDeclInfo> m_Textures;
private Dictionary<(int, int), ShaderDeclInfo> m_Uniforms;
private Dictionary<int, ShaderDeclInfo> m_Uniforms;
private Dictionary<int, ShaderDeclInfo> m_InAttributes;
private Dictionary<int, ShaderDeclInfo> m_OutAttributes;
@ -38,7 +38,7 @@ namespace Ryujinx.Graphics.Gal.Shader
public IReadOnlyDictionary<int, ShaderDeclInfo> Textures => m_Textures;
public IReadOnlyDictionary<(int, int), ShaderDeclInfo> Uniforms => m_Uniforms;
public IReadOnlyDictionary<int, ShaderDeclInfo> Uniforms => m_Uniforms;
public IReadOnlyDictionary<int, ShaderDeclInfo> InAttributes => m_InAttributes;
public IReadOnlyDictionary<int, ShaderDeclInfo> OutAttributes => m_OutAttributes;
@ -54,7 +54,7 @@ namespace Ryujinx.Graphics.Gal.Shader
StagePrefix = StagePrefixes[(int)ShaderType] + "_";
m_Uniforms = new Dictionary<(int, int), ShaderDeclInfo>();
m_Uniforms = new Dictionary<int, ShaderDeclInfo>();
m_Textures = new Dictionary<int, ShaderDeclInfo>();
@ -124,11 +124,27 @@ namespace Ryujinx.Graphics.Gal.Shader
case ShaderIrOperCbuf Cbuf:
{
string Name = StagePrefix + UniformName + Cbuf.Index + "_" + Cbuf.Offs;
if (m_Uniforms.TryGetValue(Cbuf.Index, out ShaderDeclInfo DeclInfo))
{
DeclInfo.SetCbufOffs(Cbuf.Pos);
}
else
{
string Name = StagePrefix + UniformName + Cbuf.Index;
ShaderDeclInfo DeclInfo = new ShaderDeclInfo(Name, Cbuf.Offs, Cbuf.Index);
DeclInfo = new ShaderDeclInfo(Name, Cbuf.Pos, Cbuf.Index);
m_Uniforms.TryAdd((Cbuf.Index, Cbuf.Offs), DeclInfo);
m_Uniforms.Add(Cbuf.Index, DeclInfo);
}
if (Cbuf.Offs != null)
{
//The constant buffer is being accessed as an array,
//we have no way to know the max element it may access in this case.
//Here, we just assume the array size with arbitrary values.
//TODO: Find a better solution for this.
DeclInfo.SetCbufOffs(Cbuf.Pos + 15);
}
break;
}

139
Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs
View file

@ -6,7 +6,7 @@ using System.Text;
namespace Ryujinx.Graphics.Gal.Shader
{
class GlslDecompiler
public class GlslDecompiler
{
private delegate string GetInstExpr(ShaderIrOp Op);
@ -31,6 +31,8 @@ namespace Ryujinx.Graphics.Gal.Shader
{
InstsExpr = new Dictionary<ShaderIrInst, GetInstExpr>()
{
{ ShaderIrInst.Abs, GetAbsExpr },
{ ShaderIrInst.Add, GetAddExpr },
{ ShaderIrInst.And, GetAndExpr },
{ ShaderIrInst.Asr, GetAsrExpr },
{ ShaderIrInst.Band, GetBandExpr },
@ -45,8 +47,8 @@ namespace Ryujinx.Graphics.Gal.Shader
{ ShaderIrInst.Clt, GetCltExpr },
{ ShaderIrInst.Cne, GetCneExpr },
{ ShaderIrInst.Exit, GetExitExpr },
{ ShaderIrInst.Fabs, GetFabsExpr },
{ ShaderIrInst.Fadd, GetFaddExpr },
{ ShaderIrInst.Fabs, GetAbsExpr },
{ ShaderIrInst.Fadd, GetAddExpr },
{ ShaderIrInst.Fceq, GetCeqExpr },
{ ShaderIrInst.Fcge, GetCgeExpr },
{ ShaderIrInst.Fcgt, GetCgtExpr },
@ -59,8 +61,10 @@ namespace Ryujinx.Graphics.Gal.Shader
{ ShaderIrInst.Ffma, GetFfmaExpr },
{ ShaderIrInst.Flg2, GetFlg2Expr },
{ ShaderIrInst.Floor, GetFloorExpr },
{ ShaderIrInst.Fmul, GetFmulExpr },
{ ShaderIrInst.Fneg, GetFnegExpr },
{ ShaderIrInst.Fmax, GetFmaxExpr },
{ ShaderIrInst.Fmin, GetFminExpr },
{ ShaderIrInst.Fmul, GetMulExpr },
{ ShaderIrInst.Fneg, GetNegExpr },
{ ShaderIrInst.Frcp, GetFrcpExpr },
{ ShaderIrInst.Frsq, GetFrsqExpr },
{ ShaderIrInst.Fsin, GetFsinExpr },
@ -68,10 +72,14 @@ namespace Ryujinx.Graphics.Gal.Shader
{ ShaderIrInst.Ftou, GetFtouExpr },
{ ShaderIrInst.Ipa, GetIpaExpr },
{ ShaderIrInst.Kil, GetKilExpr },
{ ShaderIrInst.Lsl, GetLslExpr },
{ ShaderIrInst.Lsr, GetLsrExpr },
{ ShaderIrInst.Mul, GetMulExpr },
{ ShaderIrInst.Neg, GetNegExpr },
{ ShaderIrInst.Not, GetNotExpr },
{ ShaderIrInst.Or, GetOrExpr },
{ ShaderIrInst.Stof, GetStofExpr },
{ ShaderIrInst.Sub, GetSubExpr },
{ ShaderIrInst.Texq, GetTexqExpr },
{ ShaderIrInst.Texs, GetTexsExpr },
{ ShaderIrInst.Trunc, GetTruncExpr },
@ -100,7 +108,7 @@ namespace Ryujinx.Graphics.Gal.Shader
PrintDeclGprs();
PrintDeclPreds();
PrintBlockScope("void main()", 1, Nodes);
PrintBlockScope(Nodes, 0, Nodes.Length, "void main()", 1);
string GlslCode = SB.ToString();
@ -124,7 +132,7 @@ namespace Ryujinx.Graphics.Gal.Shader
foreach (ShaderDeclInfo DeclInfo in Decl.Uniforms.Values.OrderBy(DeclKeySelector))
{
SB.AppendLine($"uniform {GetDecl(DeclInfo)};");
SB.AppendLine($"uniform {GetDecl(DeclInfo)}[{DeclInfo.Index + 1}];");
}
if (Decl.Uniforms.Count > 0)
@ -221,7 +229,12 @@ namespace Ryujinx.Graphics.Gal.Shader
return ElemTypes[DeclInfo.Size - 1] + " " + DeclInfo.Name;
}
private void PrintBlockScope(string ScopeName, int IdentationLevel, params ShaderIrNode[] Nodes)
private void PrintBlockScope(
ShaderIrNode[] Nodes,
int Start,
int Count,
string ScopeName,
int IdentationLevel)
{
string Identation = string.Empty;
@ -244,7 +257,7 @@ namespace Ryujinx.Graphics.Gal.Shader
Identation += IdentationStr;
}
for (int Index = 0; Index < Nodes.Length; Index++)
for (int Index = Start; Index < Start + Count; Index++)
{
ShaderIrNode Node = Nodes[Index];
@ -257,9 +270,44 @@ namespace Ryujinx.Graphics.Gal.Shader
IfExpr = "!(" + IfExpr + ")";
}
string SubScopeName = "if (" + IfExpr + ")";
if (Cond.Child is ShaderIrOp Op && Op.Inst == ShaderIrInst.Bra)
{
ShaderIrLabel Label = (ShaderIrLabel)Op.OperandA;
int Target = FindLabel(Nodes, Label, Index + 1);
int IfCount = Target - Index - 1;
string SubScopeName = "if (!" + IfExpr + ")";
if (Nodes[Index + IfCount] is ShaderIrOp LastOp && LastOp.Inst == ShaderIrInst.Bra)
{
Target = FindLabel(Nodes, (ShaderIrLabel)LastOp.OperandA, Index + 1);
int ElseCount = Target - (Index + 1 + IfCount);
PrintBlockScope(Nodes, Index + 1, IfCount - 1, SubScopeName, IdentationLevel + 1);
PrintBlockScope(Nodes, Index + 1 + IfCount, ElseCount, "else", IdentationLevel + 1);
Index += IfCount + ElseCount;
}
else
{
PrintBlockScope(Nodes, Index + 1, IfCount, SubScopeName, IdentationLevel + 1);
Index += IfCount;
}
}
else
{
string SubScopeName = "if (" + IfExpr + ")";
ShaderIrNode[] Child = new ShaderIrNode[] { Cond.Child };
PrintBlockScope(Child, 0, 1, SubScopeName, IdentationLevel + 1);
}
PrintBlockScope(SubScopeName, IdentationLevel + 1, Cond.Child);
}
else if (Node is ShaderIrAsg Asg)
{
@ -288,6 +336,14 @@ namespace Ryujinx.Graphics.Gal.Shader
SB.AppendLine(Identation + GetSrcExpr(Op, true) + ";");
}
else if (Node is ShaderIrLabel Label)
{
//TODO: Add support for loops here.
}
else if (Node is ShaderIrCmnt Cmnt)
{
SB.AppendLine(Identation + "// " + Cmnt.Comment);
}
else
{
throw new InvalidOperationException();
@ -297,6 +353,21 @@ namespace Ryujinx.Graphics.Gal.Shader
SB.AppendLine(LastLine);
}
private int FindLabel(ShaderIrNode[] Nodes, ShaderIrLabel Label, int Start)
{
int Target;
for (Target = Start; Target < Nodes.Length; Target++)
{
if (Nodes[Target] == Label)
{
return Target;
}
}
throw new InvalidOperationException();
}
private bool IsValidOutOper(ShaderIrNode Node)
{
if (Node is ShaderIrOperGpr Gpr && Gpr.IsConst)
@ -383,12 +454,23 @@ namespace Ryujinx.Graphics.Gal.Shader
private string GetName(ShaderIrOperCbuf Cbuf)
{
if (!Decl.Uniforms.TryGetValue((Cbuf.Index, Cbuf.Offs), out ShaderDeclInfo DeclInfo))
if (!Decl.Uniforms.TryGetValue(Cbuf.Index, out ShaderDeclInfo DeclInfo))
{
throw new InvalidOperationException();
}
return DeclInfo.Name;
if (Cbuf.Offs != null)
{
//Note: We assume that the register value is always a multiple of 4.
//This may not be aways the case.
string Offset = "(floatBitsToInt(" + GetSrcExpr(Cbuf.Offs) + ") >> 2)";
return DeclInfo.Name + "[" + Cbuf.Pos + " + " + Offset + "]";
}
else
{
return DeclInfo.Name + "[" + Cbuf.Pos + "]";
}
}
private string GetOutAbufName(ShaderIrOperAbuf Abuf)
@ -473,6 +555,10 @@ namespace Ryujinx.Graphics.Gal.Shader
return "xyzw".Substring(Elem, 1);
}
private string GetAbsExpr(ShaderIrOp Op) => GetUnaryCall(Op, "abs");
private string GetAddExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "+");
private string GetAndExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "&");
private string GetAsrExpr(ShaderIrOp Op) => GetBinaryExpr(Op, ">>");
@ -506,10 +592,6 @@ namespace Ryujinx.Graphics.Gal.Shader
private string GetExitExpr(ShaderIrOp Op) => "return";
private string GetFabsExpr(ShaderIrOp Op) => GetUnaryCall(Op, "abs");
private string GetFaddExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "+");
private string GetFcosExpr(ShaderIrOp Op) => GetUnaryCall(Op, "cos");
private string GetFex2Expr(ShaderIrOp Op) => GetUnaryCall(Op, "exp2");
@ -522,9 +604,8 @@ namespace Ryujinx.Graphics.Gal.Shader
private string GetFloorExpr(ShaderIrOp Op) => GetUnaryCall(Op, "floor");
private string GetFmulExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "*");
private string GetFnegExpr(ShaderIrOp Op) => GetUnaryExpr(Op, "-");
private string GetFmaxExpr(ShaderIrOp Op) => GetBinaryCall(Op, "max");
private string GetFminExpr(ShaderIrOp Op) => GetBinaryCall(Op, "min");
private string GetFrcpExpr(ShaderIrOp Op) => GetUnaryExpr(Op, "1 / ");
@ -546,12 +627,17 @@ namespace Ryujinx.Graphics.Gal.Shader
private string GetKilExpr(ShaderIrOp Op) => "discard";
private string GetLslExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "<<");
private string GetLsrExpr(ShaderIrOp Op)
{
return "int(uint(" + GetOperExpr(Op, Op.OperandA) + ") >> " +
GetOperExpr(Op, Op.OperandB) + ")";
}
private string GetMulExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "*");
private string GetNegExpr(ShaderIrOp Op) => GetUnaryExpr(Op, "-");
private string GetNotExpr(ShaderIrOp Op) => GetUnaryExpr(Op, "~");
private string GetOrExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "|");
@ -561,6 +647,8 @@ namespace Ryujinx.Graphics.Gal.Shader
return "float(" + GetOperExpr(Op, Op.OperandA) + ")";
}
private string GetSubExpr(ShaderIrOp Op) => GetBinaryExpr(Op, "-");
private string GetTexqExpr(ShaderIrOp Op)
{
ShaderIrMetaTexq Meta = (ShaderIrMetaTexq)Op.MetaData;
@ -621,6 +709,12 @@ namespace Ryujinx.Graphics.Gal.Shader
return FuncName + "(" + GetOperExpr(Op, Op.OperandA) + ")";
}
private string GetBinaryCall(ShaderIrOp Op, string FuncName)
{
return FuncName + "(" + GetOperExpr(Op, Op.OperandA) + ", " +
GetOperExpr(Op, Op.OperandB) + ")";
}
private string GetTernaryCall(ShaderIrOp Op, string FuncName)
{
return FuncName + "(" + GetOperExpr(Op, Op.OperandA) + ", " +
@ -717,7 +811,10 @@ namespace Ryujinx.Graphics.Gal.Shader
{
float Value = BitConverter.Int32BitsToSingle(Imm.Value);
return Value.ToString(CultureInfo.InvariantCulture);
if (!float.IsNaN(Value) && !float.IsInfinity(Value))
{
return Value.ToString(CultureInfo.InvariantCulture);
}
}
break;
}

2
Ryujinx.Graphics/Gal/Shader/GlslProgram.cs
View file

@ -2,7 +2,7 @@ using System.Collections.Generic;
namespace Ryujinx.Graphics.Gal.Shader
{
struct GlslProgram
public struct GlslProgram
{
public string Code { get; private set; }

285
Ryujinx.Graphics/Gal/Shader/ShaderDecodeAlu.cs
View file

@ -6,6 +6,21 @@ namespace Ryujinx.Graphics.Gal.Shader
{
static partial class ShaderDecode
{
public static void Bfe_C(ShaderIrBlock Block, long OpCode)
{
EmitBfe(Block, OpCode, ShaderOper.CR);
}
public static void Bfe_I(ShaderIrBlock Block, long OpCode)
{
EmitBfe(Block, OpCode, ShaderOper.Imm);
}
public static void Bfe_R(ShaderIrBlock Block, long OpCode)
{
EmitBfe(Block, OpCode, ShaderOper.RR);
}
public static void Fadd_C(ShaderIrBlock Block, long OpCode)
{
EmitAluBinaryF(Block, OpCode, ShaderOper.CR, ShaderIrInst.Fadd);
@ -23,25 +38,40 @@ namespace Ryujinx.Graphics.Gal.Shader
public static void Ffma_CR(ShaderIrBlock Block, long OpCode)
{
EmitAluFfma(Block, OpCode, ShaderOper.CR);
EmitFfma(Block, OpCode, ShaderOper.CR);
}
public static void Ffma_I(ShaderIrBlock Block, long OpCode)
{
EmitAluFfma(Block, OpCode, ShaderOper.Immf);
EmitFfma(Block, OpCode, ShaderOper.Immf);
}
public static void Ffma_RC(ShaderIrBlock Block, long OpCode)
{
EmitAluFfma(Block, OpCode, ShaderOper.RC);
EmitFfma(Block, OpCode, ShaderOper.RC);
}
public static void Ffma_RR(ShaderIrBlock Block, long OpCode)
{
EmitAluFfma(Block, OpCode, ShaderOper.RR);
EmitFfma(Block, OpCode, ShaderOper.RR);
}
public static void Fmul32i(ShaderIrBlock Block, long OpCode)
public static void Fmnmx_C(ShaderIrBlock Block, long OpCode)
{
EmitFmnmx(Block, OpCode, ShaderOper.CR);
}
public static void Fmnmx_I(ShaderIrBlock Block, long OpCode)
{
EmitFmnmx(Block, OpCode, ShaderOper.Immf);
}
public static void Fmnmx_R(ShaderIrBlock Block, long OpCode)
{
EmitFmnmx(Block, OpCode, ShaderOper.RR);
}
public static void Fmul_I32(ShaderIrBlock Block, long OpCode)
{
ShaderIrNode OperA = GetOperGpr8 (OpCode);
ShaderIrNode OperB = GetOperImmf32_20(OpCode);
@ -106,6 +136,21 @@ namespace Ryujinx.Graphics.Gal.Shader
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
public static void Iscadd_C(ShaderIrBlock Block, long OpCode)
{
EmitIscadd(Block, OpCode, ShaderOper.CR);
}
public static void Iscadd_I(ShaderIrBlock Block, long OpCode)
{
EmitIscadd(Block, OpCode, ShaderOper.Imm);
}
public static void Iscadd_R(ShaderIrBlock Block, long OpCode)
{
EmitIscadd(Block, OpCode, ShaderOper.RR);
}
public static void Isetp_C(ShaderIrBlock Block, long OpCode)
{
EmitIsetp(Block, OpCode, ShaderOper.CR);
@ -121,12 +166,12 @@ namespace Ryujinx.Graphics.Gal.Shader
EmitIsetp(Block, OpCode, ShaderOper.RR);
}
public static void Lop32i(ShaderIrBlock Block, long OpCode)
public static void Lop_I32(ShaderIrBlock Block, long OpCode)
{
int SubOp = (int)(OpCode >> 53) & 3;
bool Ia = ((OpCode >> 55) & 1) != 0;
bool Ib = ((OpCode >> 56) & 1) != 0;
bool InvA = ((OpCode >> 55) & 1) != 0;
bool InvB = ((OpCode >> 56) & 1) != 0;
ShaderIrInst Inst = 0;
@ -137,13 +182,13 @@ namespace Ryujinx.Graphics.Gal.Shader
case 2: Inst = ShaderIrInst.Xor; break;
}
ShaderIrNode OperA = GetAluNot(GetOperGpr8(OpCode), Ia);
ShaderIrNode OperA = GetAluNot(GetOperGpr8(OpCode), InvA);
//SubOp == 3 is pass, used by the not instruction
//which just moves the inverted register value.
if (SubOp < 3)
{
ShaderIrNode OperB = GetAluNot(GetOperImm32_20(OpCode), Ib);
ShaderIrNode OperB = GetAluNot(GetOperImm32_20(OpCode), InvB);
ShaderIrOp Op = new ShaderIrOp(Inst, OperA, OperB);
@ -159,8 +204,8 @@ namespace Ryujinx.Graphics.Gal.Shader
{
int SubOp = (int)(OpCode >> 20) & 7;
bool Aa = ((OpCode >> 46) & 1) != 0;
bool Na = ((OpCode >> 48) & 1) != 0;
bool AbsA = ((OpCode >> 46) & 1) != 0;
bool NegA = ((OpCode >> 48) & 1) != 0;
ShaderIrInst Inst = 0;
@ -178,11 +223,26 @@ namespace Ryujinx.Graphics.Gal.Shader
ShaderIrNode OperA = GetOperGpr8(OpCode);
ShaderIrOp Op = new ShaderIrOp(Inst, GetAluAbsNeg(OperA, Aa, Na));
ShaderIrOp Op = new ShaderIrOp(Inst, GetAluFabsFneg(OperA, AbsA, NegA));
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
public static void Shl_C(ShaderIrBlock Block, long OpCode)
{
EmitAluBinary(Block, OpCode, ShaderOper.CR, ShaderIrInst.Lsl);
}
public static void Shl_I(ShaderIrBlock Block, long OpCode)
{
EmitAluBinary(Block, OpCode, ShaderOper.Imm, ShaderIrInst.Lsl);
}
public static void Shl_R(ShaderIrBlock Block, long OpCode)
{
EmitAluBinary(Block, OpCode, ShaderOper.RR, ShaderIrInst.Lsl);
}
public static void Shr_C(ShaderIrBlock Block, long OpCode)
{
EmitAluBinary(Block, OpCode, ShaderOper.CR, GetShrInst(OpCode));
@ -233,16 +293,16 @@ namespace Ryujinx.Graphics.Gal.Shader
ShaderOper Oper,
ShaderIrInst Inst)
{
bool Nb = ((OpCode >> 45) & 1) != 0;
bool Aa = ((OpCode >> 46) & 1) != 0;
bool Na = ((OpCode >> 48) & 1) != 0;
bool Ab = ((OpCode >> 49) & 1) != 0;
bool NegB = ((OpCode >> 45) & 1) != 0;
bool AbsA = ((OpCode >> 46) & 1) != 0;
bool NegA = ((OpCode >> 48) & 1) != 0;
bool AbsB = ((OpCode >> 49) & 1) != 0;
ShaderIrNode OperA = GetOperGpr8(OpCode), OperB;
if (Inst == ShaderIrInst.Fadd)
{
OperA = GetAluAbsNeg(OperA, Aa, Na);
OperA = GetAluFabsFneg(OperA, AbsA, NegA);
}
switch (Oper)
@ -254,17 +314,73 @@ namespace Ryujinx.Graphics.Gal.Shader
default: throw new ArgumentException(nameof(Oper));
}
OperB = GetAluAbsNeg(OperB, Ab, Nb);
OperB = GetAluFabsFneg(OperB, AbsB, NegB);
ShaderIrNode Op = new ShaderIrOp(Inst, OperA, OperB);
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
private static void EmitAluFfma(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
private static void EmitBfe(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
bool Nb = ((OpCode >> 48) & 1) != 0;
bool Nc = ((OpCode >> 49) & 1) != 0;
//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;
ShaderIrNode OperA = GetOperGpr8(OpCode), 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;
default: throw new ArgumentException(nameof(Oper));
}
ShaderIrNode Op;
bool Signed = ((OpCode >> 48) & 1) != 0; //?
if (OperB is ShaderIrOperImm PosLen)
{
int Position = (PosLen.Value >> 0) & 0xff;
int Length = (PosLen.Value >> 8) & 0xff;
int LSh = 32 - (Position + Length);
ShaderIrInst RightShift = Signed
? ShaderIrInst.Asr
: ShaderIrInst.Lsr;
Op = new ShaderIrOp(ShaderIrInst.Lsl, OperA, new ShaderIrOperImm(LSh));
Op = new ShaderIrOp(RightShift, Op, new ShaderIrOperImm(LSh + Position));
}
else
{
ShaderIrOperImm Shift = new ShaderIrOperImm(8);
ShaderIrOperImm Mask = new ShaderIrOperImm(0xff);
ShaderIrNode OpPos, OpLen;
OpPos = new ShaderIrOp(ShaderIrInst.And, OperB, Mask);
OpLen = new ShaderIrOp(ShaderIrInst.Lsr, OperB, Shift);
OpLen = new ShaderIrOp(ShaderIrInst.And, OpLen, Mask);
Op = new ShaderIrOp(ShaderIrInst.Lsr, OperA, OpPos);
Op = ExtendTo32(Op, Signed, OpLen);
}
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
private static void EmitFfma(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
bool NegB = ((OpCode >> 48) & 1) != 0;
bool NegC = ((OpCode >> 49) & 1) != 0;
ShaderIrNode OperA = GetOperGpr8(OpCode), OperB, OperC;
@ -278,15 +394,15 @@ namespace Ryujinx.Graphics.Gal.Shader
default: throw new ArgumentException(nameof(Oper));
}
OperB = GetAluNeg(OperB, Nb);
OperB = GetAluFneg(OperB, NegB);
if (Oper == ShaderOper.RC)
{
OperC = GetAluNeg(GetOperCbuf34(OpCode), Nc);
OperC = GetAluFneg(GetOperCbuf34(OpCode), NegC);
}
else
{
OperC = GetAluNeg(GetOperGpr39(OpCode), Nc);
OperC = GetAluFneg(GetOperGpr39(OpCode), NegC);
}
ShaderIrOp Op = new ShaderIrOp(ShaderIrInst.Ffma, OperA, OperB, OperC);
@ -294,6 +410,84 @@ namespace Ryujinx.Graphics.Gal.Shader
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
private static void EmitFmnmx(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;
ShaderIrNode OperA = GetOperGpr8(OpCode), 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;
default: throw new ArgumentException(nameof(Oper));
}
OperB = GetAluFabsFneg(OperB, AbsB, NegB);
ShaderIrOperPred Pred = GetOperPred39(OpCode);
ShaderIrOp Op;
if (Pred.IsConst)
{
bool IsMax = ((OpCode >> 42) & 1) != 0;
Op = new ShaderIrOp(IsMax
? ShaderIrInst.Fmax
: ShaderIrInst.Fmin, OperA, OperB);
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Op), OpCode));
}
else
{
ShaderIrNode PredN = GetOperPred39N(OpCode);
ShaderIrOp OpMax = new ShaderIrOp(ShaderIrInst.Fmax, OperA, OperB);
ShaderIrOp OpMin = new ShaderIrOp(ShaderIrInst.Fmin, OperA, OperB);
ShaderIrAsg AsgMax = new ShaderIrAsg(GetOperGpr0(OpCode), OpMax);
ShaderIrAsg AsgMin = new ShaderIrAsg(GetOperGpr0(OpCode), OpMin);
Block.AddNode(GetPredNode(new ShaderIrCond(PredN, AsgMax, Not: true), OpCode));
Block.AddNode(GetPredNode(new ShaderIrCond(PredN, AsgMin, Not: false), OpCode));
}
}
private static void EmitIscadd(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
bool NegB = ((OpCode >> 48) & 1) != 0;
bool NegA = ((OpCode >> 49) & 1) != 0;
ShaderIrNode OperA = GetOperGpr8(OpCode), OperB;
ShaderIrOperImm Scale = GetOperImm5_39(OpCode);
switch (Oper)
{
case ShaderOper.CR: OperB = GetOperCbuf34 (OpCode); break;
case ShaderOper.Imm: OperB = GetOperImm19_20(OpCode); break;
case ShaderOper.RR: OperB = GetOperGpr20 (OpCode); break;
default: throw new ArgumentException(nameof(Oper));
}
OperA = GetAluIneg(OperA, NegA);
OperB = GetAluIneg(OperB, NegB);
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));
}
private static void EmitFset(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
EmitSet(Block, OpCode, true, Oper);
@ -306,10 +500,11 @@ namespace Ryujinx.Graphics.Gal.Shader
private static void EmitSet(ShaderIrBlock Block, long OpCode, bool IsFloat, ShaderOper Oper)
{
bool Na = ((OpCode >> 43) & 1) != 0;
bool Ab = ((OpCode >> 44) & 1) != 0;
bool Nb = ((OpCode >> 53) & 1) != 0;
bool Aa = ((OpCode >> 54) & 1) != 0;
bool NegA = ((OpCode >> 43) & 1) != 0;
bool AbsB = ((OpCode >> 44) & 1) != 0;
bool BoolFloat = ((OpCode >> 52) & 1) != 0;
bool NegB = ((OpCode >> 53) & 1) != 0;
bool AbsA = ((OpCode >> 54) & 1) != 0;
ShaderIrNode OperA = GetOperGpr8(OpCode), OperB;
@ -327,8 +522,8 @@ namespace Ryujinx.Graphics.Gal.Shader
if (IsFloat)
{
OperA = GetAluAbsNeg(OperA, Aa, Na);
OperB = GetAluAbsNeg(OperB, Ab, Nb);
OperA = GetAluFabsFneg(OperA, AbsA, NegA);
OperB = GetAluFabsFneg(OperB, AbsB, NegB);
CmpInst = GetCmpF(OpCode);
}
@ -343,8 +538,18 @@ namespace Ryujinx.Graphics.Gal.Shader
ShaderIrOperPred PNode = GetOperPred39(OpCode);
ShaderIrOperImmf Imm0 = new ShaderIrOperImmf(0);
ShaderIrOperImmf Imm1 = new ShaderIrOperImmf(1);
ShaderIrNode Imm0, Imm1;
if (BoolFloat)
{
Imm0 = new ShaderIrOperImmf(0);
Imm1 = new ShaderIrOperImmf(1);
}
else
{
Imm0 = new ShaderIrOperImm(0);
Imm1 = new ShaderIrOperImm(-1);
}
ShaderIrNode Asg0 = new ShaderIrAsg(GetOperGpr0(OpCode), Imm0);
ShaderIrNode Asg1 = new ShaderIrAsg(GetOperGpr0(OpCode), Imm1);
@ -378,10 +583,10 @@ namespace Ryujinx.Graphics.Gal.Shader
private static void EmitSetp(ShaderIrBlock Block, long OpCode, bool IsFloat, ShaderOper Oper)
{
bool Aa = ((OpCode >> 7) & 1) != 0;
bool Np = ((OpCode >> 42) & 1) != 0;
bool Na = ((OpCode >> 43) & 1) != 0;
bool Ab = ((OpCode >> 44) & 1) != 0;
bool AbsA = ((OpCode >> 7) & 1) != 0;
bool NegP = ((OpCode >> 42) & 1) != 0;
bool NegA = ((OpCode >> 43) & 1) != 0;
bool AbsB = ((OpCode >> 44) & 1) != 0;
ShaderIrNode OperA = GetOperGpr8(OpCode), OperB;
@ -399,8 +604,8 @@ namespace Ryujinx.Graphics.Gal.Shader
if (IsFloat)
{
OperA = GetAluAbsNeg(OperA, Aa, Na);
OperB = GetAluAbs (OperB, Ab);
OperA = GetAluFabsFneg(OperA, AbsA, NegA);
OperB = GetAluFabs (OperB, AbsB);
CmpInst = GetCmpF(OpCode);
}
@ -426,7 +631,7 @@ namespace Ryujinx.Graphics.Gal.Shader
ShaderIrNode P2NNode = P2Node;
if (Np)
if (NegP)
{
P2NNode = new ShaderIrOp(ShaderIrInst.Bnot, P2NNode);
}

18
Ryujinx.Graphics/Gal/Shader/ShaderDecodeFlow.cs
View file

@ -1,9 +1,27 @@
using System;
using static Ryujinx.Graphics.Gal.Shader.ShaderDecodeHelper;
namespace Ryujinx.Graphics.Gal.Shader
{
static partial class ShaderDecode
{
public static void Bra(ShaderIrBlock Block, long OpCode)
{
if ((OpCode & 0x20) != 0)
{
//This reads the target offset from the constant buffer.
//Almost impossible to support with GLSL.
throw new NotImplementedException();
}
int Target = ((int)(OpCode >> 20) << 8) >> 8;
Target += Block.Position + 8;
Block.AddNode(GetPredNode(new ShaderIrOp(ShaderIrInst.Bra, Block.GetLabel(Target)), OpCode));
}
public static void Exit(ShaderIrBlock Block, long OpCode)
{
Block.AddNode(GetPredNode(new ShaderIrOp(ShaderIrInst.Exit), OpCode));

65
Ryujinx.Graphics/Gal/Shader/ShaderDecodeHelper.cs
View file

@ -35,6 +35,13 @@ namespace Ryujinx.Graphics.Gal.Shader
(int)(OpCode >> 20) & 0x3fff);
}
public static ShaderIrOperCbuf GetOperCbuf36(long OpCode)
{
return new ShaderIrOperCbuf(
(int)(OpCode >> 36) & 0x1f,
(int)(OpCode >> 22) & 0x3fff, GetOperGpr8(OpCode));
}
public static ShaderIrOperGpr GetOperGpr8(long OpCode)
{
return new ShaderIrOperGpr((int)(OpCode >> 8) & 0xff);
@ -60,6 +67,11 @@ namespace Ryujinx.Graphics.Gal.Shader
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);
@ -210,24 +222,69 @@ namespace Ryujinx.Graphics.Gal.Shader
return new ShaderIrOperPred(Pred);
}
public static ShaderIrNode GetAluAbsNeg(ShaderIrNode Node, bool Abs, bool Neg)
public static ShaderIrNode GetAluFabsFneg(ShaderIrNode Node, bool Abs, bool Neg)
{
return GetAluNeg(GetAluAbs(Node, Abs), Neg);
return GetAluFneg(GetAluFabs(Node, Abs), Neg);
}
public static ShaderIrNode GetAluAbs(ShaderIrNode Node, bool Abs)
public static ShaderIrNode GetAluFabs(ShaderIrNode Node, bool Abs)
{
return Abs ? new ShaderIrOp(ShaderIrInst.Fabs, Node) : Node;
}
public static ShaderIrNode GetAluNeg(ShaderIrNode Node, bool Neg)
public static ShaderIrNode GetAluFneg(ShaderIrNode Node, bool Neg)
{
return Neg ? new ShaderIrOp(ShaderIrInst.Fneg, Node) : Node;
}
public static ShaderIrNode GetAluIabsIneg(ShaderIrNode Node, bool Abs, bool Neg)
{
return GetAluIneg(GetAluIabs(Node, Abs), Neg);
}
public static ShaderIrNode GetAluIabs(ShaderIrNode Node, bool Abs)
{
return Abs ? new ShaderIrOp(ShaderIrInst.Abs, Node) : Node;
}
public static ShaderIrNode GetAluIneg(ShaderIrNode Node, bool Neg)
{
return Neg ? new ShaderIrOp(ShaderIrInst.Neg, Node) : Node;
}
public static ShaderIrNode GetAluNot(ShaderIrNode Node, bool Not)
{
return Not ? new ShaderIrOp(ShaderIrInst.Not, Node) : Node;
}
public static ShaderIrNode ExtendTo32(ShaderIrNode Node, bool Signed, int Size)
{
int Shift = 32 - Size;
ShaderIrInst RightShift = Signed
? ShaderIrInst.Asr
: ShaderIrInst.Lsr;
Node = new ShaderIrOp(ShaderIrInst.Lsl, Node, new ShaderIrOperImm(Shift));
Node = new ShaderIrOp(RightShift, Node, new ShaderIrOperImm(Shift));
return Node;
}
public static ShaderIrNode ExtendTo32(ShaderIrNode Node, bool Signed, ShaderIrNode Size)
{
ShaderIrOperImm WordSize = new ShaderIrOperImm(32);
ShaderIrOp Shift = new ShaderIrOp(ShaderIrInst.Sub, WordSize, Size);
ShaderIrInst RightShift = Signed
? ShaderIrInst.Asr
: ShaderIrInst.Lsr;
Node = new ShaderIrOp(ShaderIrInst.Lsl, Node, Shift);
Node = new ShaderIrOp(RightShift, Node, Shift);
return Node;
}
}
}

37
Ryujinx.Graphics/Gal/Shader/ShaderDecodeMem.cs
View file

@ -1,3 +1,5 @@
using System;
using static Ryujinx.Graphics.Gal.Shader.ShaderDecodeHelper;
namespace Ryujinx.Graphics.Gal.Shader
@ -20,6 +22,41 @@ namespace Ryujinx.Graphics.Gal.Shader
}
}
public static void Ld_C(ShaderIrBlock Block, long OpCode)
{
int Type = (int)(OpCode >> 48) & 7;
if (Type > 5)
{
throw new InvalidOperationException();
}
int Count = Type == 5 ? 2 : 1;
for (int Index = 0; Index < Count; Index++)
{
ShaderIrOperCbuf OperA = GetOperCbuf36(OpCode);
ShaderIrOperGpr OperD = GetOperGpr0 (OpCode);
OperA.Pos += Index;
OperD.Index += Index;
ShaderIrNode Node = OperA;
if (Type < 4)
{
//This is a 8 or 16 bits type.
bool Signed = (Type & 1) != 0;
int Size = 8 << (Type >> 1);
Node = ExtendTo32(Node, Signed, Size);
}
Block.AddNode(GetPredNode(new ShaderIrAsg(OperD, Node), OpCode));
}
}
public static void St_A(ShaderIrBlock Block, long OpCode)
{
ShaderIrNode[] Opers = GetOperAbuf20(OpCode);

40
Ryujinx.Graphics/Gal/Shader/ShaderDecodeMove.cs
View file

@ -99,6 +99,13 @@ namespace Ryujinx.Graphics.Gal.Shader
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Imm), OpCode));
}
public static void Mov_I32(ShaderIrBlock Block, long OpCode)
{
ShaderIrOperImm Imm = GetOperImm32_20(OpCode);
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Imm), OpCode));
}
public static void Mov_R(ShaderIrBlock Block, long OpCode)
{
ShaderIrOperGpr Gpr = GetOperGpr20(OpCode);
@ -106,17 +113,10 @@ namespace Ryujinx.Graphics.Gal.Shader
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Gpr), OpCode));
}
public static void Mov32i(ShaderIrBlock Block, long OpCode)
{
ShaderIrOperImm Imm = GetOperImm32_20(OpCode);
Block.AddNode(GetPredNode(new ShaderIrAsg(GetOperGpr0(OpCode), Imm), OpCode));
}
private static void EmitF2f(ShaderIrBlock Block, long OpCode, ShaderOper Oper)
{
bool Na = ((OpCode >> 45) & 1) != 0;
bool Aa = ((OpCode >> 49) & 1) != 0;
bool NegA = ((OpCode >> 45) & 1) != 0;
bool AbsA = ((OpCode >> 49) & 1) != 0;
ShaderIrNode OperA;
@ -129,7 +129,7 @@ namespace Ryujinx.Graphics.Gal.Shader
default: throw new ArgumentException(nameof(Oper));
}
OperA = GetAluAbsNeg(OperA, Aa, Na);
OperA = GetAluFabsFneg(OperA, AbsA, NegA);
ShaderIrInst RoundInst = GetRoundInst(OpCode);
@ -153,8 +153,8 @@ namespace Ryujinx.Graphics.Gal.Shader
throw new NotImplementedException();
}
bool Na = ((OpCode >> 45) & 1) != 0;
bool Aa = ((OpCode >> 49) & 1) != 0;
bool NegA = ((OpCode >> 45) & 1) != 0;
bool AbsA = ((OpCode >> 49) & 1) != 0;
ShaderIrNode OperA;
@ -167,7 +167,7 @@ namespace Ryujinx.Graphics.Gal.Shader
default: throw new ArgumentException(nameof(Oper));
}
OperA = GetAluAbsNeg(OperA, Aa, Na);
OperA = GetAluFabsFneg(OperA, AbsA, NegA);
ShaderIrInst RoundInst = GetRoundInst(OpCode);
@ -224,8 +224,8 @@ namespace Ryujinx.Graphics.Gal.Shader
int Sel = (int)(OpCode >> 41) & 3;
bool Na = ((OpCode >> 45) & 1) != 0;
bool Aa = ((OpCode >> 49) & 1) != 0;
bool NegA = ((OpCode >> 45) & 1) != 0;
bool AbsA = ((OpCode >> 49) & 1) != 0;
ShaderIrNode OperA;
@ -238,7 +238,7 @@ namespace Ryujinx.Graphics.Gal.Shader
default: throw new ArgumentException(nameof(Oper));
}
OperA = GetAluAbsNeg(OperA, Aa, Na);
OperA = GetAluIabsIneg(OperA, AbsA, NegA);
bool Signed = Type >= IntType.S8;
@ -253,9 +253,7 @@ namespace Ryujinx.Graphics.Gal.Shader
if (Size < 32)
{
uint Mask = uint.MaxValue >> (32 - Size);
OperA = new ShaderIrOp(ShaderIrInst.And, OperA, new ShaderIrOperImm((int)Mask));
OperA = ExtendTo32(OperA, Signed, Size);
}
ShaderIrInst Inst = Signed
@ -296,7 +294,7 @@ namespace Ryujinx.Graphics.Gal.Shader
default: throw new ArgumentException(nameof(Oper));
}
OperA = GetAluAbsNeg(OperA, AbsA, NegA);
OperA = GetAluIabsIneg(OperA, AbsA, NegA);
bool Signed = Type >= IntType.S8;
@ -335,7 +333,7 @@ namespace Ryujinx.Graphics.Gal.Shader
}
else
{
OperA = new ShaderIrOp(ShaderIrInst.And, OperA, new ShaderIrOperImm((int)Mask));
OperA = ExtendTo32(OperA, Signed, Size);
}
}

20
Ryujinx.Graphics/Gal/Shader/ShaderDecoder.cs
View file

@ -2,14 +2,21 @@ namespace Ryujinx.Graphics.Gal.Shader
{
static class ShaderDecoder
{
private const bool AddDbgComments = true;
public static ShaderIrBlock DecodeBasicBlock(int[] Code, int Offset)
{
ShaderIrBlock Block = new ShaderIrBlock();
while (Offset + 2 <= Code.Length)
{
//Ignore scheduling instructions, which are
//written every 32 bytes.
int InstPos = Offset * 4;
Block.Position = InstPos;
Block.MarkLabel(InstPos);
//Ignore scheduling instructions, which are written every 32 bytes.
if ((Offset & 7) == 0)
{
Offset += 2;
@ -24,6 +31,13 @@ namespace Ryujinx.Graphics.Gal.Shader
ShaderDecodeFunc Decode = ShaderOpCodeTable.GetDecoder(OpCode);
if (AddDbgComments)
{
string DbgOpCode = $"0x{InstPos:x8}: 0x{OpCode:x16} ";
Block.AddNode(new ShaderIrCmnt(DbgOpCode + (Decode?.Method.Name ?? "???")));
}
if (Decode == null)
{
continue;
@ -31,7 +45,7 @@ namespace Ryujinx.Graphics.Gal.Shader
Decode(Block, OpCode);
if (Block.GetLastNode() is ShaderIrOp Op && IsFlowChange(Op.Inst))
if (Block.GetLastNode() is ShaderIrOp Op && Op.Inst == ShaderIrInst.Exit)
{
break;
}

28
Ryujinx.Graphics/Gal/Shader/ShaderIrBlock.cs
View file

@ -6,9 +6,15 @@ namespace Ryujinx.Graphics.Gal.Shader
{
private List<ShaderIrNode> Nodes;
private Dictionary<int, ShaderIrLabel> LabelsToInsert;
public int Position;
public ShaderIrBlock()
{
Nodes = new List<ShaderIrNode>();
LabelsToInsert = new Dictionary<int, ShaderIrLabel>();
}
public void AddNode(ShaderIrNode Node)
@ -16,6 +22,28 @@ namespace Ryujinx.Graphics.Gal.Shader
Nodes.Add(Node);
}
public ShaderIrLabel GetLabel(int Position)
{
if (LabelsToInsert.TryGetValue(Position, out ShaderIrLabel Label))
{
return Label;
}
Label = new ShaderIrLabel();
LabelsToInsert.Add(Position, Label);
return Label;
}
public void MarkLabel(int Position)
{
if (LabelsToInsert.TryGetValue(Position, out ShaderIrLabel Label))
{
Nodes.Add(Label);
}
}
public ShaderIrNode[] GetNodes()
{
return Nodes.ToArray();

12
Ryujinx.Graphics/Gal/Shader/ShaderIrCmnt.cs Normal file
View file

@ -0,0 +1,12 @@
namespace Ryujinx.Graphics.Gal.Shader
{
class ShaderIrCmnt : ShaderIrNode
{
public string Comment { get; private set; }
public ShaderIrCmnt(string Comment)
{
this.Comment = Comment;
}
}
}

9
Ryujinx.Graphics/Gal/Shader/ShaderIrInst.cs
View file

@ -36,6 +36,8 @@ namespace Ryujinx.Graphics.Gal.Shader
Ffma,
Flg2,
Floor,
Fmax,
Fmin,
Fmul,
Fneg,
Frcp,
@ -49,6 +51,8 @@ namespace Ryujinx.Graphics.Gal.Shader
F_End,
I_Start,
Abs,
Add,
And,
Asr,
Ceq,
@ -59,16 +63,21 @@ namespace Ryujinx.Graphics.Gal.Shader
Cle,
Clt,
Cne,
Lsl,
Lsr,
Mul,
Neg,
Not,
Or,
Stof,
Sub,
Texq,
Txlf,
Utof,
Xor,
I_End,
Bra,
Exit,
Kil
}

4
Ryujinx.Graphics/Gal/Shader/ShaderIrLabel.cs Normal file
View file

@ -0,0 +1,4 @@
namespace Ryujinx.Graphics.Gal.Shader
{
class ShaderIrLabel : ShaderIrNode { }
}

7
Ryujinx.Graphics/Gal/Shader/ShaderIrOperCbuf.cs
View file

@ -3,11 +3,14 @@ namespace Ryujinx.Graphics.Gal.Shader
class ShaderIrOperCbuf : ShaderIrNode
{
public int Index { get; private set; }
public int Offs { get; private set; }
public int Pos { get; set; }
public ShaderIrOperCbuf(int Index, int Offs)
public ShaderIrNode Offs { get; private set; }
public ShaderIrOperCbuf(int Index, int Pos, ShaderIrNode Offs = null)
{
this.Index = Index;
this.Pos = Pos;
this.Offs = Offs;
}
}

20
Ryujinx.Graphics/Gal/Shader/ShaderOpCodeTable.cs
View file

@ -26,6 +26,10 @@ namespace Ryujinx.Graphics.Gal.Shader
OpCodes = new ShaderDecodeEntry[1 << EncodingBits];
#region Instructions
Set("0100110000000x", ShaderDecode.Bfe_C);
Set("0011100x00000x", ShaderDecode.Bfe_I);
Set("0101110000000x", ShaderDecode.Bfe_R);
Set("111000100100xx", ShaderDecode.Bra);
Set("111000110000xx", ShaderDecode.Exit);
Set("0100110010101x", ShaderDecode.F2f_C);
Set("0011100x10101x", ShaderDecode.F2f_I);
@ -40,10 +44,13 @@ namespace Ryujinx.Graphics.Gal.Shader
Set("001100101xxxxx", ShaderDecode.Ffma_I);
Set("010100011xxxxx", ShaderDecode.Ffma_RC);
Set("010110011xxxxx", ShaderDecode.Ffma_RR);
Set("00011110xxxxxx", ShaderDecode.Fmul32i);
Set("00011110xxxxxx", ShaderDecode.Fmul_I32);
Set("0100110001101x", ShaderDecode.Fmul_C);
Set("0011100x01101x", ShaderDecode.Fmul_I);
Set("0101110001101x", ShaderDecode.Fmul_R);
Set("0100110001100x", ShaderDecode.Fmnmx_C);
Set("0011100x01100x", ShaderDecode.Fmnmx_I);
Set("0101110001100x", ShaderDecode.Fmnmx_R);
Set("0100100xxxxxxx", ShaderDecode.Fset_C);
Set("0011000xxxxxxx", ShaderDecode.Fset_I);
Set("01011000xxxxxx", ShaderDecode.Fset_R);
@ -57,17 +64,24 @@ namespace Ryujinx.Graphics.Gal.Shader
Set("0011100x11100x", ShaderDecode.I2i_I);
Set("0101110011100x", ShaderDecode.I2i_R);
Set("11100000xxxxxx", ShaderDecode.Ipa);
Set("0100110000011x", ShaderDecode.Iscadd_C);
Set("0011100x00011x", ShaderDecode.Iscadd_I);
Set("0101110000011x", ShaderDecode.Iscadd_R);
Set("010010110110xx", ShaderDecode.Isetp_C);
Set("0011011x0110xx", ShaderDecode.Isetp_I);
Set("010110110110xx", ShaderDecode.Isetp_R);
Set("111000110011xx", ShaderDecode.Kil);
Set("1110111111011x", ShaderDecode.Ld_A);
Set("000001xxxxxxxx", ShaderDecode.Lop32i);
Set("1110111110010x", ShaderDecode.Ld_C);
Set("000001xxxxxxxx", ShaderDecode.Lop_I32);
Set("0100110010011x", ShaderDecode.Mov_C);
Set("0011100x10011x", ShaderDecode.Mov_I);
Set("000000010000xx", ShaderDecode.Mov_I32);
Set("0101110010011x", ShaderDecode.Mov_R);
Set("000000010000xx", ShaderDecode.Mov32i);
Set("0101000010000x", ShaderDecode.Mufu);
Set("0100110001001x", ShaderDecode.Shl_C);
Set("0011100x01001x", ShaderDecode.Shl_I);
Set("0101110001001x", ShaderDecode.Shl_R);
Set("0100110000101x", ShaderDecode.Shr_C);
Set("0011100x00101x", ShaderDecode.Shr_I);
Set("0101110000101x", ShaderDecode.Shr_R);

8
Ryujinx.Graphics/Gal/ShaderDeclInfo.cs
View file

@ -23,5 +23,13 @@ namespace Ryujinx.Graphics.Gal
Size = NewSize;
}
}
internal void SetCbufOffs(int Offs)
{
if (Index < Offs)
{
Index = Offs;
}
}
}
}

6
Ryujinx.sln
View file

@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics", "Ryujinx
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Audio", "Ryujinx.Audio\Ryujinx.Audio.csproj", "{5C1D818E-682A-46A5-9D54-30006E26C270}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ryushader", "Ryushader\Ryushader.csproj", "{3AB294D0-2230-468F-9EB3-BDFCAEAE99A5}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -45,6 +47,10 @@ Global
{5C1D818E-682A-46A5-9D54-30006E26C270}.Debug|Any CPU.Build.0 = Debug|Any CPU
{5C1D818E-682A-46A5-9D54-30006E26C270}.Release|Any CPU.ActiveCfg = Release|Any CPU
{5C1D818E-682A-46A5-9D54-30006E26C270}.Release|Any CPU.Build.0 = Release|Any CPU
{3AB294D0-2230-468F-9EB3-BDFCAEAE99A5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{3AB294D0-2230-468F-9EB3-BDFCAEAE99A5}.Debug|Any CPU.Build.0 = Debug|Any CPU
{3AB294D0-2230-468F-9EB3-BDFCAEAE99A5}.Release|Any CPU.ActiveCfg = Release|Any CPU
{3AB294D0-2230-468F-9EB3-BDFCAEAE99A5}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

48
Ryushader/Program.cs Normal file
View file

@ -0,0 +1,48 @@
using Ryujinx.Graphics.Gal;
using Ryujinx.Graphics.Gal.Shader;
using System;
using System.IO;
namespace Ryushader
{
class Program
{
static void Main(string[] args)
{
if (args.Length == 2)
{
GlslDecompiler Decompiler = new GlslDecompiler();
GalShaderType ShaderType = GalShaderType.Vertex;
switch (args[0].ToLower())
{
case "v": ShaderType = GalShaderType.Vertex; break;
case "tc": ShaderType = GalShaderType.TessControl; break;
case "te": ShaderType = GalShaderType.TessEvaluation; break;
case "g": ShaderType = GalShaderType.Geometry; break;
case "f": ShaderType = GalShaderType.Fragment; break;
}
byte[] Data = File.ReadAllBytes(args[1]);
int[] Code = new int[Data.Length / 4];
for (int Offset = 0; Offset < Data.Length; Offset += 4)
{
int Value = BitConverter.ToInt32(Data, Offset);
Code[Offset >> 2] = Value;
}
GlslProgram Program = Decompiler.Decompile(Code, ShaderType);
Console.WriteLine(Program.Code);
}
else
{
Console.WriteLine("Usage: Ryushader [v|tc|te|g|f] shader.bin");
}
}
}
}

12
Ryushader/Ryushader.csproj Normal file
View file

@ -0,0 +1,12 @@
<Project Sdk="Microsoft.NET.Sdk">
<ItemGroup>
<ProjectReference Include="..\Ryujinx.Graphics\Ryujinx.Graphics.csproj" />
</ItemGroup>
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>netcoreapp2.1</TargetFramework>
</PropertyGroup>
</Project>