mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-17 14:18:44 +02:00
Make sure attributes used on subsequent shader stages are initialized (#2538)
This commit is contained in:
parent
10d649e6d3
commit
ed754af8d5
15 changed files with 347 additions and 262 deletions
|
@ -38,7 +38,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
/// <summary>
|
||||
/// Version of the codegen (to be changed when codegen or guest format change).
|
||||
/// </summary>
|
||||
private const ulong ShaderCodeGenVersion = 2494;
|
||||
private const ulong ShaderCodeGenVersion = 2538;
|
||||
|
||||
// Progress reporting helpers
|
||||
private volatile int _shaderCount;
|
||||
|
@ -290,6 +290,43 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
{
|
||||
Task compileTask = Task.Run(() =>
|
||||
{
|
||||
TranslatorContext[] shaderContexts = null;
|
||||
|
||||
if (!isHostProgramValid)
|
||||
{
|
||||
shaderContexts = new TranslatorContext[1 + entries.Length];
|
||||
|
||||
for (int i = 0; i < entries.Length; i++)
|
||||
{
|
||||
GuestShaderCacheEntry entry = entries[i];
|
||||
|
||||
if (entry == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
var binaryCode = new Memory<byte>(entry.Code);
|
||||
|
||||
var gpuAccessor = new CachedGpuAccessor(
|
||||
_context,
|
||||
binaryCode,
|
||||
binaryCode.Slice(binaryCode.Length - entry.Header.Cb1DataSize),
|
||||
entry.Header.GpuAccessorHeader,
|
||||
entry.TextureDescriptors);
|
||||
|
||||
var options = new TranslationOptions(TargetLanguage.Glsl, TargetApi.OpenGL, flags);
|
||||
|
||||
shaderContexts[i + 1] = Translator.CreateContext(0, gpuAccessor, options, counts);
|
||||
|
||||
if (entry.Header.SizeA != 0)
|
||||
{
|
||||
var options2 = new TranslationOptions(TargetLanguage.Glsl, TargetApi.OpenGL, flags | TranslationFlags.VertexA);
|
||||
|
||||
shaderContexts[0] = Translator.CreateContext((ulong)entry.Header.Size, gpuAccessor, options2, counts);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Reconstruct code holder.
|
||||
for (int i = 0; i < entries.Length; i++)
|
||||
{
|
||||
|
@ -301,9 +338,6 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
}
|
||||
|
||||
ShaderProgram program;
|
||||
|
||||
if (entry.Header.SizeA != 0)
|
||||
{
|
||||
ShaderProgramInfo shaderProgramInfo;
|
||||
|
||||
if (isHostProgramValid)
|
||||
|
@ -313,58 +347,20 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
}
|
||||
else
|
||||
{
|
||||
var binaryCode = new Memory<byte>(entry.Code);
|
||||
int stageIndex = i + 1;
|
||||
|
||||
var gpuAccessor = new CachedGpuAccessor(
|
||||
_context,
|
||||
binaryCode,
|
||||
binaryCode.Slice(binaryCode.Length - entry.Header.Cb1DataSize),
|
||||
entry.Header.GpuAccessorHeader,
|
||||
entry.TextureDescriptors);
|
||||
TranslatorContext currentStage = shaderContexts[stageIndex];
|
||||
TranslatorContext nextStage = GetNextStageContext(shaderContexts, stageIndex);
|
||||
TranslatorContext vertexA = stageIndex == 1 ? shaderContexts[0] : null;
|
||||
|
||||
var options = new TranslationOptions(TargetLanguage.Glsl, TargetApi.OpenGL, flags);
|
||||
var options2 = new TranslationOptions(TargetLanguage.Glsl, TargetApi.OpenGL, flags | TranslationFlags.VertexA);
|
||||
|
||||
TranslatorContext translatorContext = Translator.CreateContext(0, gpuAccessor, options, counts);
|
||||
TranslatorContext translatorContext2 = Translator.CreateContext((ulong)entry.Header.Size, gpuAccessor, options2, counts);
|
||||
|
||||
program = translatorContext.Translate(out shaderProgramInfo, translatorContext2);
|
||||
program = currentStage.Translate(out shaderProgramInfo, nextStage, vertexA);
|
||||
}
|
||||
|
||||
// NOTE: Vertex B comes first in the shader cache.
|
||||
byte[] code = entry.Code.AsSpan().Slice(0, entry.Header.Size - entry.Header.Cb1DataSize).ToArray();
|
||||
byte[] code2 = entry.Code.AsSpan().Slice(entry.Header.Size, entry.Header.SizeA).ToArray();
|
||||
byte[] code2 = entry.Header.SizeA != 0 ? entry.Code.AsSpan().Slice(entry.Header.Size, entry.Header.SizeA).ToArray() : null;
|
||||
|
||||
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, code, code2);
|
||||
}
|
||||
else
|
||||
{
|
||||
ShaderProgramInfo shaderProgramInfo;
|
||||
|
||||
if (isHostProgramValid)
|
||||
{
|
||||
program = new ShaderProgram(entry.Header.Stage, "");
|
||||
shaderProgramInfo = hostShaderEntries[i].ToShaderProgramInfo();
|
||||
}
|
||||
else
|
||||
{
|
||||
var binaryCode = new Memory<byte>(entry.Code);
|
||||
|
||||
var gpuAccessor = new CachedGpuAccessor(
|
||||
_context,
|
||||
binaryCode,
|
||||
binaryCode.Slice(binaryCode.Length - entry.Header.Cb1DataSize),
|
||||
entry.Header.GpuAccessorHeader,
|
||||
entry.TextureDescriptors);
|
||||
|
||||
var options = new TranslationOptions(TargetLanguage.Glsl, TargetApi.OpenGL, flags);
|
||||
program = Translator.CreateContext(0, gpuAccessor, options, counts).Translate(out shaderProgramInfo);
|
||||
}
|
||||
|
||||
byte[] code = entry.Code.AsSpan().Slice(0, entry.Header.Size - entry.Header.Cb1DataSize).ToArray();
|
||||
|
||||
shaders[i] = new ShaderCodeHolder(program, shaderProgramInfo, code);
|
||||
}
|
||||
|
||||
shaderPrograms.Add(program);
|
||||
}
|
||||
|
@ -591,7 +587,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
}
|
||||
|
||||
// The shader isn't currently cached, translate it and compile it.
|
||||
ShaderCodeHolder shader = TranslateShader(channel.MemoryManager, shaderContexts[0]);
|
||||
ShaderCodeHolder shader = TranslateShader(_dumper, channel.MemoryManager, shaderContexts[0], null, null);
|
||||
|
||||
shader.HostShader = _context.Renderer.CompileShader(ShaderStage.Compute, shader.Program.Code);
|
||||
|
||||
|
@ -715,11 +711,10 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
// The shader isn't currently cached, translate it and compile it.
|
||||
ShaderCodeHolder[] shaders = new ShaderCodeHolder[Constants.ShaderStages];
|
||||
|
||||
shaders[0] = TranslateShader(channel.MemoryManager, shaderContexts[1], shaderContexts[0]);
|
||||
shaders[1] = TranslateShader(channel.MemoryManager, shaderContexts[2]);
|
||||
shaders[2] = TranslateShader(channel.MemoryManager, shaderContexts[3]);
|
||||
shaders[3] = TranslateShader(channel.MemoryManager, shaderContexts[4]);
|
||||
shaders[4] = TranslateShader(channel.MemoryManager, shaderContexts[5]);
|
||||
for (int stageIndex = 0; stageIndex < Constants.ShaderStages; stageIndex++)
|
||||
{
|
||||
shaders[stageIndex] = TranslateShader(_dumper, channel.MemoryManager, shaderContexts, stageIndex + 1);
|
||||
}
|
||||
|
||||
List<IShader> hostShaders = new List<IShader>();
|
||||
|
||||
|
@ -942,53 +937,94 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
/// <summary>
|
||||
/// Translates a previously generated translator context to something that the host API accepts.
|
||||
/// </summary>
|
||||
/// <param name="dumper">Optional shader code dumper</param>
|
||||
/// <param name="memoryManager">Memory manager used to access the GPU memory where the shader is located</param>
|
||||
/// <param name="translatorContext">Current translator context to translate</param>
|
||||
/// <param name="translatorContext2">Optional translator context of the shader that should be combined</param>
|
||||
/// <param name="stages">Translator context of all available shader stages</param>
|
||||
/// <param name="stageIndex">Index on the stages array to translate</param>
|
||||
/// <returns>Compiled graphics shader code</returns>
|
||||
private ShaderCodeHolder TranslateShader(
|
||||
private static ShaderCodeHolder TranslateShader(
|
||||
ShaderDumper dumper,
|
||||
MemoryManager memoryManager,
|
||||
TranslatorContext translatorContext,
|
||||
TranslatorContext translatorContext2 = null)
|
||||
TranslatorContext[] stages,
|
||||
int stageIndex)
|
||||
{
|
||||
if (translatorContext == null)
|
||||
TranslatorContext currentStage = stages[stageIndex];
|
||||
TranslatorContext nextStage = GetNextStageContext(stages, stageIndex);
|
||||
TranslatorContext vertexA = stageIndex == 1 ? stages[0] : null;
|
||||
|
||||
return TranslateShader(dumper, memoryManager, currentStage, nextStage, vertexA);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the next shader stage context, from an array of contexts and index of the current stage.
|
||||
/// </summary>
|
||||
/// <param name="stages">Translator context of all available shader stages</param>
|
||||
/// <param name="stageIndex">Index on the stages array to translate</param>
|
||||
/// <returns>The translator context of the next stage, or null if inexistent</returns>
|
||||
private static TranslatorContext GetNextStageContext(TranslatorContext[] stages, int stageIndex)
|
||||
{
|
||||
for (int nextStageIndex = stageIndex + 1; nextStageIndex < stages.Length; nextStageIndex++)
|
||||
{
|
||||
if (stages[nextStageIndex] != null)
|
||||
{
|
||||
return stages[nextStageIndex];
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Translates a previously generated translator context to something that the host API accepts.
|
||||
/// </summary>
|
||||
/// <param name="dumper">Optional shader code dumper</param>
|
||||
/// <param name="memoryManager">Memory manager used to access the GPU memory where the shader is located</param>
|
||||
/// <param name="currentStage">Translator context of the stage to be translated</param>
|
||||
/// <param name="nextStage">Translator context of the next active stage, if existent</param>
|
||||
/// <param name="vertexA">Optional translator context of the shader that should be combined</param>
|
||||
/// <returns>Compiled graphics shader code</returns>
|
||||
private static ShaderCodeHolder TranslateShader(
|
||||
ShaderDumper dumper,
|
||||
MemoryManager memoryManager,
|
||||
TranslatorContext currentStage,
|
||||
TranslatorContext nextStage,
|
||||
TranslatorContext vertexA)
|
||||
{
|
||||
if (currentStage == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (translatorContext2 != null)
|
||||
if (vertexA != null)
|
||||
{
|
||||
byte[] codeA = memoryManager.GetSpan(translatorContext2.Address, translatorContext2.Size).ToArray();
|
||||
byte[] codeB = memoryManager.GetSpan(translatorContext.Address, translatorContext.Size).ToArray();
|
||||
byte[] codeA = memoryManager.GetSpan(vertexA.Address, vertexA.Size).ToArray();
|
||||
byte[] codeB = memoryManager.GetSpan(currentStage.Address, currentStage.Size).ToArray();
|
||||
|
||||
_dumper.Dump(codeA, compute: false, out string fullPathA, out string codePathA);
|
||||
_dumper.Dump(codeB, compute: false, out string fullPathB, out string codePathB);
|
||||
ShaderDumpPaths pathsA = default;
|
||||
ShaderDumpPaths pathsB = default;
|
||||
|
||||
ShaderProgram program = translatorContext.Translate(out ShaderProgramInfo shaderProgramInfo, translatorContext2);
|
||||
|
||||
if (fullPathA != null && fullPathB != null && codePathA != null && codePathB != null)
|
||||
if (dumper != null)
|
||||
{
|
||||
program.Prepend("// " + codePathB);
|
||||
program.Prepend("// " + fullPathB);
|
||||
program.Prepend("// " + codePathA);
|
||||
program.Prepend("// " + fullPathA);
|
||||
pathsA = dumper.Dump(codeA, compute: false);
|
||||
pathsB = dumper.Dump(codeB, compute: false);
|
||||
}
|
||||
|
||||
ShaderProgram program = currentStage.Translate(out ShaderProgramInfo shaderProgramInfo, nextStage, vertexA);
|
||||
|
||||
pathsB.Prepend(program);
|
||||
pathsA.Prepend(program);
|
||||
|
||||
return new ShaderCodeHolder(program, shaderProgramInfo, codeB, codeA);
|
||||
}
|
||||
else
|
||||
{
|
||||
byte[] code = memoryManager.GetSpan(translatorContext.Address, translatorContext.Size).ToArray();
|
||||
byte[] code = memoryManager.GetSpan(currentStage.Address, currentStage.Size).ToArray();
|
||||
|
||||
_dumper.Dump(code, translatorContext.Stage == ShaderStage.Compute, out string fullPath, out string codePath);
|
||||
ShaderDumpPaths paths = dumper?.Dump(code, currentStage.Stage == ShaderStage.Compute) ?? default;
|
||||
|
||||
ShaderProgram program = translatorContext.Translate(out ShaderProgramInfo shaderProgramInfo);
|
||||
ShaderProgram program = currentStage.Translate(out ShaderProgramInfo shaderProgramInfo, nextStage);
|
||||
|
||||
if (fullPath != null && codePath != null)
|
||||
{
|
||||
program.Prepend("// " + codePath);
|
||||
program.Prepend("// " + fullPath);
|
||||
}
|
||||
paths.Prepend(program);
|
||||
|
||||
return new ShaderCodeHolder(program, shaderProgramInfo, code);
|
||||
}
|
||||
|
|
49
Ryujinx.Graphics.Gpu/Shader/ShaderDumpPaths.cs
Normal file
49
Ryujinx.Graphics.Gpu/Shader/ShaderDumpPaths.cs
Normal file
|
@ -0,0 +1,49 @@
|
|||
using Ryujinx.Graphics.Shader;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Shader
|
||||
{
|
||||
/// <summary>
|
||||
/// Paths where shader code was dumped on disk.
|
||||
/// </summary>
|
||||
struct ShaderDumpPaths
|
||||
{
|
||||
/// <summary>
|
||||
/// Path where the full shader code with header was dumped, or null if not dumped.
|
||||
/// </summary>
|
||||
public string FullPath { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Path where the shader code without header was dumped, or null if not dumped.
|
||||
/// </summary>
|
||||
public string CodePath { get; }
|
||||
|
||||
/// <summary>
|
||||
/// True if the shader was dumped, false otherwise.
|
||||
/// </summary>
|
||||
public bool HasPath => FullPath != null && CodePath != null;
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new shader dumps path structure.
|
||||
/// </summary>
|
||||
/// <param name="fullPath">Path where the full shader code with header was dumped, or null if not dumped</param>
|
||||
/// <param name="codePath">Path where the shader code without header was dumped, or null if not dumped</param>
|
||||
public ShaderDumpPaths(string fullPath, string codePath)
|
||||
{
|
||||
FullPath = fullPath;
|
||||
CodePath = codePath;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Prepends the shader paths on the program source, as a comment.
|
||||
/// </summary>
|
||||
/// <param name="program">Program to prepend into</param>
|
||||
public void Prepend(ShaderProgram program)
|
||||
{
|
||||
if (HasPath)
|
||||
{
|
||||
program.Prepend("// " + CodePath);
|
||||
program.Prepend("// " + FullPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
|
@ -1,4 +1,4 @@
|
|||
using System;
|
||||
using Ryujinx.Graphics.Shader;
|
||||
using System.IO;
|
||||
|
||||
namespace Ryujinx.Graphics.Gpu.Shader
|
||||
|
@ -30,24 +30,20 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
/// </summary>
|
||||
/// <param name="code">Code to be dumped</param>
|
||||
/// <param name="compute">True for compute shader code, false for graphics shader code</param>
|
||||
/// <param name="fullPath">Output path for the shader code with header included</param>
|
||||
/// <param name="codePath">Output path for the shader code without header</param>
|
||||
public void Dump(byte[] code, bool compute, out string fullPath, out string codePath)
|
||||
/// <returns>Paths where the shader code was dumped</returns>
|
||||
public ShaderDumpPaths Dump(byte[] code, bool compute)
|
||||
{
|
||||
_dumpPath = GraphicsConfig.ShadersDumpPath;
|
||||
|
||||
if (string.IsNullOrWhiteSpace(_dumpPath))
|
||||
{
|
||||
fullPath = null;
|
||||
codePath = null;
|
||||
|
||||
return;
|
||||
return default;
|
||||
}
|
||||
|
||||
string fileName = "Shader" + CurrentDumpIndex.ToString("d4") + ".bin";
|
||||
|
||||
fullPath = Path.Combine(FullDir(), fileName);
|
||||
codePath = Path.Combine(CodeDir(), fileName);
|
||||
string fullPath = Path.Combine(FullDir(), fileName);
|
||||
string codePath = Path.Combine(CodeDir(), fileName);
|
||||
|
||||
CurrentDumpIndex++;
|
||||
|
||||
|
@ -73,6 +69,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
|
|||
{
|
||||
codeWriter.Write(0);
|
||||
}
|
||||
|
||||
return new ShaderDumpPaths(fullPath, codePath);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
|
|
@ -3,14 +3,12 @@ using Ryujinx.Graphics.Shader.StructuredIr;
|
|||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Numerics;
|
||||
|
||||
namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
||||
{
|
||||
static class Declarations
|
||||
{
|
||||
// At least 16 attributes are guaranteed by the spec.
|
||||
public const int MaxAttributes = 16;
|
||||
|
||||
public static void Declare(CodeGenContext context, StructuredProgramInfo info)
|
||||
{
|
||||
context.AppendLine("#version 450 core");
|
||||
|
@ -129,14 +127,14 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
|||
context.AppendLine();
|
||||
}
|
||||
|
||||
if (info.IAttributes.Count != 0 || context.Config.GpPassthrough)
|
||||
if (context.Config.UsedInputAttributes != 0 || context.Config.GpPassthrough)
|
||||
{
|
||||
DeclareInputAttributes(context, info);
|
||||
|
||||
context.AppendLine();
|
||||
}
|
||||
|
||||
if (info.OAttributes.Count != 0 || context.Config.Stage != ShaderStage.Fragment)
|
||||
if (context.Config.UsedOutputAttributes != 0 || context.Config.Stage != ShaderStage.Fragment)
|
||||
{
|
||||
DeclareOutputAttributes(context, info);
|
||||
|
||||
|
@ -404,24 +402,14 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
|||
|
||||
private static void DeclareInputAttributes(CodeGenContext context, StructuredProgramInfo info)
|
||||
{
|
||||
if (context.Config.GpPassthrough)
|
||||
int usedAttribtes = context.Config.UsedInputAttributes;
|
||||
while (usedAttribtes != 0)
|
||||
{
|
||||
for (int attr = 0; attr < MaxAttributes; attr++)
|
||||
{
|
||||
DeclareInputAttribute(context, info, attr);
|
||||
}
|
||||
int index = BitOperations.TrailingZeroCount(usedAttribtes);
|
||||
|
||||
foreach (int attr in info.IAttributes.OrderBy(x => x).Where(x => x >= MaxAttributes))
|
||||
{
|
||||
DeclareInputAttribute(context, info, attr);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (int attr in info.IAttributes.OrderBy(x => x))
|
||||
{
|
||||
DeclareInputAttribute(context, info, attr);
|
||||
}
|
||||
DeclareInputAttribute(context, info, index);
|
||||
|
||||
usedAttribtes &= ~(1 << index);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -440,8 +428,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
|||
};
|
||||
}
|
||||
|
||||
string pass = context.Config.GpPassthrough && !info.OAttributes.Contains(attr) ? "passthrough, " : string.Empty;
|
||||
|
||||
string pass = (context.Config.PassthroughAttributes & (1 << attr)) != 0 ? "passthrough, " : string.Empty;
|
||||
string name = $"{DefaultNames.IAttributePrefix}{attr}";
|
||||
|
||||
if ((context.Config.Options.Flags & TranslationFlags.Feedback) != 0)
|
||||
|
@ -461,34 +448,14 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
|||
|
||||
private static void DeclareOutputAttributes(CodeGenContext context, StructuredProgramInfo info)
|
||||
{
|
||||
if (context.Config.Stage == ShaderStage.Fragment || context.Config.GpPassthrough)
|
||||
int usedAttribtes = context.Config.UsedOutputAttributes;
|
||||
while (usedAttribtes != 0)
|
||||
{
|
||||
DeclareUsedOutputAttributes(context, info);
|
||||
}
|
||||
else
|
||||
{
|
||||
DeclareAllOutputAttributes(context, info);
|
||||
}
|
||||
}
|
||||
int index = BitOperations.TrailingZeroCount(usedAttribtes);
|
||||
|
||||
private static void DeclareUsedOutputAttributes(CodeGenContext context, StructuredProgramInfo info)
|
||||
{
|
||||
foreach (int attr in info.OAttributes.OrderBy(x => x))
|
||||
{
|
||||
DeclareOutputAttribute(context, attr);
|
||||
}
|
||||
}
|
||||
DeclareOutputAttribute(context, index);
|
||||
|
||||
private static void DeclareAllOutputAttributes(CodeGenContext context, StructuredProgramInfo info)
|
||||
{
|
||||
for (int attr = 0; attr < MaxAttributes; attr++)
|
||||
{
|
||||
DeclareOutputAttribute(context, attr);
|
||||
}
|
||||
|
||||
foreach (int attr in info.OAttributes.OrderBy(x => x).Where(x => x >= MaxAttributes))
|
||||
{
|
||||
DeclareOutputAttribute(context, attr);
|
||||
usedAttribtes &= ~(1 << index);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -49,46 +49,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Glsl
|
|||
|
||||
Declarations.DeclareLocals(context, function);
|
||||
|
||||
if (funcName == MainFunctionName)
|
||||
{
|
||||
// Some games will leave some elements of gl_Position uninitialized,
|
||||
// in those cases, the elements will contain undefined values according
|
||||
// to the spec, but on NVIDIA they seems to be always initialized to (0, 0, 0, 1),
|
||||
// so we do explicit initialization to avoid UB on non-NVIDIA gpus.
|
||||
if (context.Config.Stage == ShaderStage.Vertex)
|
||||
{
|
||||
context.AppendLine("gl_Position = vec4(0.0, 0.0, 0.0, 1.0);");
|
||||
}
|
||||
|
||||
// Ensure that unused attributes are set, otherwise the downstream
|
||||
// compiler may eliminate them.
|
||||
// (Not needed for fragment shader as it is the last stage).
|
||||
if (context.Config.Stage != ShaderStage.Compute &&
|
||||
context.Config.Stage != ShaderStage.Fragment &&
|
||||
!context.Config.GpPassthrough)
|
||||
{
|
||||
for (int attr = 0; attr < Declarations.MaxAttributes; attr++)
|
||||
{
|
||||
if (info.OAttributes.Contains(attr))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if ((context.Config.Options.Flags & TranslationFlags.Feedback) != 0)
|
||||
{
|
||||
context.AppendLine($"{DefaultNames.OAttributePrefix}{attr}_x = 0.0;");
|
||||
context.AppendLine($"{DefaultNames.OAttributePrefix}{attr}_y = 0.0;");
|
||||
context.AppendLine($"{DefaultNames.OAttributePrefix}{attr}_z = 0.0;");
|
||||
context.AppendLine($"{DefaultNames.OAttributePrefix}{attr}_w = 1.0;");
|
||||
}
|
||||
else
|
||||
{
|
||||
context.AppendLine($"{DefaultNames.OAttributePrefix}{attr} = vec4(0.0, 0.0, 0.0, 1.0);");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
PrintBlock(context, function.MainBlock);
|
||||
|
||||
context.LeaveScope();
|
||||
|
|
|
@ -1,4 +1,5 @@
|
|||
using Ryujinx.Graphics.Shader.Instructions;
|
||||
using Ryujinx.Graphics.Shader.Translation;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
|
@ -9,10 +10,8 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
|||
{
|
||||
static class Decoder
|
||||
{
|
||||
public static Block[][] Decode(IGpuAccessor gpuAccessor, ulong startAddress, out bool hasBindless)
|
||||
public static Block[][] Decode(ShaderConfig config, ulong startAddress)
|
||||
{
|
||||
hasBindless = false;
|
||||
|
||||
List<Block[]> funcs = new List<Block[]>();
|
||||
|
||||
Queue<ulong> funcQueue = new Queue<ulong>();
|
||||
|
@ -90,8 +89,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
|||
}
|
||||
}
|
||||
|
||||
FillBlock(gpuAccessor, currBlock, limitAddress, startAddress, out bool blockHasBindless);
|
||||
hasBindless |= blockHasBindless;
|
||||
FillBlock(config, currBlock, limitAddress, startAddress);
|
||||
|
||||
if (currBlock.OpCodes.Count != 0)
|
||||
{
|
||||
|
@ -168,7 +166,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
|||
|
||||
for (int i = 0; i < cbOffsetsCount; i++)
|
||||
{
|
||||
uint targetOffset = gpuAccessor.ConstantBuffer1Read(cbBaseOffset + i * 4);
|
||||
uint targetOffset = config.GpuAccessor.ConstantBuffer1Read(cbBaseOffset + i * 4);
|
||||
Block target = GetBlock(baseOffset + targetOffset);
|
||||
opBrIndir.PossibleTargets.Add(target);
|
||||
target.Predecessors.Add(block);
|
||||
|
@ -224,15 +222,11 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
|||
return false;
|
||||
}
|
||||
|
||||
private static void FillBlock(
|
||||
IGpuAccessor gpuAccessor,
|
||||
Block block,
|
||||
ulong limitAddress,
|
||||
ulong startAddress,
|
||||
out bool hasBindless)
|
||||
private static void FillBlock(ShaderConfig config, Block block, ulong limitAddress, ulong startAddress)
|
||||
{
|
||||
IGpuAccessor gpuAccessor = config.GpuAccessor;
|
||||
|
||||
ulong address = block.Address;
|
||||
hasBindless = false;
|
||||
|
||||
do
|
||||
{
|
||||
|
@ -274,13 +268,38 @@ namespace Ryujinx.Graphics.Shader.Decoders
|
|||
OpCode op = makeOp(emitter, opAddress, opCode);
|
||||
|
||||
// We check these patterns to figure out the presence of bindless access
|
||||
hasBindless |= (op is OpCodeImage image && image.IsBindless) ||
|
||||
if ((op is OpCodeImage image && image.IsBindless) ||
|
||||
(op is OpCodeTxd txd && txd.IsBindless) ||
|
||||
(op is OpCodeTld4B) ||
|
||||
(emitter == InstEmit.TexB) ||
|
||||
(emitter == InstEmit.TldB) ||
|
||||
(emitter == InstEmit.TmmlB) ||
|
||||
(emitter == InstEmit.TxqB);
|
||||
(emitter == InstEmit.TxqB))
|
||||
{
|
||||
config.SetUsedFeature(FeatureFlags.Bindless);
|
||||
}
|
||||
|
||||
// Populate used attributes.
|
||||
if (op is IOpCodeAttribute opAttr)
|
||||
{
|
||||
for (int elemIndex = 0; elemIndex < opAttr.Count; elemIndex++)
|
||||
{
|
||||
int attr = opAttr.AttributeOffset + elemIndex * 4;
|
||||
if (attr >= AttributeConsts.UserAttributeBase && attr < AttributeConsts.UserAttributeEnd)
|
||||
{
|
||||
int index = (attr - AttributeConsts.UserAttributeBase) / 16;
|
||||
|
||||
if (op.Emitter == InstEmit.Ast)
|
||||
{
|
||||
config.SetOutputUserAttribute(index);
|
||||
}
|
||||
else
|
||||
{
|
||||
config.SetInputUserAttribute(index);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
block.OpCodes.Add(op);
|
||||
}
|
||||
|
|
8
Ryujinx.Graphics.Shader/Decoders/IOpCodeAttribute.cs
Normal file
8
Ryujinx.Graphics.Shader/Decoders/IOpCodeAttribute.cs
Normal file
|
@ -0,0 +1,8 @@
|
|||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
interface IOpCodeAttribute
|
||||
{
|
||||
int AttributeOffset { get; }
|
||||
int Count { get; }
|
||||
}
|
||||
}
|
|
@ -2,7 +2,7 @@ using Ryujinx.Graphics.Shader.Instructions;
|
|||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
class OpCodeAttribute : OpCodeAluReg
|
||||
class OpCodeAttribute : OpCodeAluReg, IOpCodeAttribute
|
||||
{
|
||||
public int AttributeOffset { get; }
|
||||
public int Count { get; }
|
||||
|
|
|
@ -2,9 +2,10 @@ using Ryujinx.Graphics.Shader.Instructions;
|
|||
|
||||
namespace Ryujinx.Graphics.Shader.Decoders
|
||||
{
|
||||
class OpCodeIpa : OpCodeAluReg
|
||||
class OpCodeIpa : OpCodeAluReg, IOpCodeAttribute
|
||||
{
|
||||
public int AttributeOffset { get; }
|
||||
public int Count => 1;
|
||||
|
||||
public InterpolationMode Mode { get; }
|
||||
|
||||
|
|
|
@ -277,21 +277,11 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
|
|||
|
||||
public AstOperand GetOperandDef(Operand operand)
|
||||
{
|
||||
if (TryGetUserAttributeIndex(operand, out int attrIndex))
|
||||
{
|
||||
Info.OAttributes.Add(attrIndex);
|
||||
}
|
||||
|
||||
return GetOperand(operand);
|
||||
}
|
||||
|
||||
public AstOperand GetOperandUse(Operand operand)
|
||||
{
|
||||
if (TryGetUserAttributeIndex(operand, out int attrIndex))
|
||||
{
|
||||
Info.IAttributes.Add(attrIndex);
|
||||
}
|
||||
|
||||
return GetOperand(operand);
|
||||
}
|
||||
|
||||
|
@ -318,30 +308,5 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
|
|||
|
||||
return astOperand;
|
||||
}
|
||||
|
||||
private static bool TryGetUserAttributeIndex(Operand operand, out int attrIndex)
|
||||
{
|
||||
if (operand.Type == OperandType.Attribute)
|
||||
{
|
||||
if (operand.Value >= AttributeConsts.UserAttributeBase &&
|
||||
operand.Value < AttributeConsts.UserAttributeEnd)
|
||||
{
|
||||
attrIndex = (operand.Value - AttributeConsts.UserAttributeBase) >> 4;
|
||||
|
||||
return true;
|
||||
}
|
||||
else if (operand.Value >= AttributeConsts.FragmentOutputColorBase &&
|
||||
operand.Value < AttributeConsts.FragmentOutputColorEnd)
|
||||
{
|
||||
attrIndex = (operand.Value - AttributeConsts.FragmentOutputColorBase) >> 4;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
attrIndex = 0;
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
|
@ -6,17 +6,11 @@ namespace Ryujinx.Graphics.Shader.StructuredIr
|
|||
{
|
||||
public List<StructuredFunction> Functions { get; }
|
||||
|
||||
public HashSet<int> IAttributes { get; }
|
||||
public HashSet<int> OAttributes { get; }
|
||||
|
||||
public HelperFunctionsMask HelperFunctionsMask { get; set; }
|
||||
|
||||
public StructuredProgramInfo()
|
||||
{
|
||||
Functions = new List<StructuredFunction>();
|
||||
|
||||
IAttributes = new HashSet<int>();
|
||||
OAttributes = new HashSet<int>();
|
||||
}
|
||||
}
|
||||
}
|
|
@ -15,6 +15,8 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
|
||||
public bool IsNonMain { get; }
|
||||
|
||||
public int OperationsCount => _operations.Count;
|
||||
|
||||
private readonly IReadOnlyDictionary<ulong, int> _funcs;
|
||||
private readonly List<Operation> _operations;
|
||||
private readonly Dictionary<ulong, Operand> _labels;
|
||||
|
@ -200,6 +202,7 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
|
||||
if (target.Enabled)
|
||||
{
|
||||
Config.SetOutputUserAttribute(rtIndex);
|
||||
regIndexBase += 4;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -41,6 +41,10 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
|
||||
private readonly TranslationCounts _counts;
|
||||
|
||||
public int UsedInputAttributes { get; private set; }
|
||||
public int UsedOutputAttributes { get; private set; }
|
||||
public int PassthroughAttributes { get; private set; }
|
||||
|
||||
private int _usedConstantBuffers;
|
||||
private int _usedStorageBuffers;
|
||||
private int _usedStorageBuffersWrite;
|
||||
|
@ -170,6 +174,8 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
|
||||
TextureHandlesForCache.UnionWith(other.TextureHandlesForCache);
|
||||
|
||||
UsedInputAttributes |= other.UsedInputAttributes;
|
||||
UsedOutputAttributes |= other.UsedOutputAttributes;
|
||||
_usedConstantBuffers |= other._usedConstantBuffers;
|
||||
_usedStorageBuffers |= other._usedStorageBuffers;
|
||||
_usedStorageBuffersWrite |= other._usedStorageBuffersWrite;
|
||||
|
@ -191,6 +197,28 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
}
|
||||
}
|
||||
|
||||
public void SetInputUserAttribute(int index)
|
||||
{
|
||||
UsedInputAttributes |= 1 << index;
|
||||
}
|
||||
|
||||
public void SetOutputUserAttribute(int index)
|
||||
{
|
||||
UsedOutputAttributes |= 1 << index;
|
||||
}
|
||||
|
||||
public void MergeOutputUserAttributes(int mask)
|
||||
{
|
||||
if (GpPassthrough)
|
||||
{
|
||||
PassthroughAttributes = mask & ~UsedOutputAttributes;
|
||||
}
|
||||
else
|
||||
{
|
||||
UsedOutputAttributes |= mask;
|
||||
}
|
||||
}
|
||||
|
||||
public void SetClipDistanceWritten(int index)
|
||||
{
|
||||
ClipDistancesWritten |= (byte)(1 << index);
|
||||
|
|
|
@ -5,6 +5,7 @@ using Ryujinx.Graphics.Shader.StructuredIr;
|
|||
using Ryujinx.Graphics.Shader.Translation.Optimizations;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Numerics;
|
||||
|
||||
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
||||
|
||||
|
@ -120,24 +121,17 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
Block[][] cfg;
|
||||
ulong maxEndAddress = 0;
|
||||
|
||||
bool hasBindless;
|
||||
|
||||
if ((options.Flags & TranslationFlags.Compute) != 0)
|
||||
{
|
||||
config = new ShaderConfig(gpuAccessor, options, counts);
|
||||
|
||||
cfg = Decoder.Decode(gpuAccessor, address, out hasBindless);
|
||||
cfg = Decoder.Decode(config, address);
|
||||
}
|
||||
else
|
||||
{
|
||||
config = new ShaderConfig(new ShaderHeader(gpuAccessor, address), gpuAccessor, options, counts);
|
||||
|
||||
cfg = Decoder.Decode(gpuAccessor, address + HeaderSize, out hasBindless);
|
||||
}
|
||||
|
||||
if (hasBindless)
|
||||
{
|
||||
config.SetUsedFeature(FeatureFlags.Bindless);
|
||||
cfg = Decoder.Decode(config, address + HeaderSize);
|
||||
}
|
||||
|
||||
for (int funcIndex = 0; funcIndex < cfg.Length; funcIndex++)
|
||||
|
@ -151,7 +145,7 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
maxEndAddress = block.EndAddress;
|
||||
}
|
||||
|
||||
if (!hasBindless)
|
||||
if (!config.UsedFeatures.HasFlag(FeatureFlags.Bindless))
|
||||
{
|
||||
for (int index = 0; index < block.OpCodes.Count; index++)
|
||||
{
|
||||
|
@ -169,8 +163,10 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
return cfg;
|
||||
}
|
||||
|
||||
internal static FunctionCode[] EmitShader(Block[][] cfg, ShaderConfig config)
|
||||
internal static FunctionCode[] EmitShader(Block[][] cfg, ShaderConfig config, bool initializeOutputs, out int initializationOperations)
|
||||
{
|
||||
initializationOperations = 0;
|
||||
|
||||
Dictionary<ulong, int> funcIds = new Dictionary<ulong, int>();
|
||||
|
||||
for (int funcIndex = 0; funcIndex < cfg.Length; funcIndex++)
|
||||
|
@ -184,6 +180,12 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
{
|
||||
EmitterContext context = new EmitterContext(config, funcIndex != 0, funcIds);
|
||||
|
||||
if (initializeOutputs && funcIndex == 0)
|
||||
{
|
||||
EmitOutputsInitialization(context, config);
|
||||
initializationOperations = context.OperationsCount;
|
||||
}
|
||||
|
||||
for (int blkIndex = 0; blkIndex < cfg[funcIndex].Length; blkIndex++)
|
||||
{
|
||||
Block block = cfg[funcIndex][blkIndex];
|
||||
|
@ -201,6 +203,39 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
return funcs.ToArray();
|
||||
}
|
||||
|
||||
private static void EmitOutputsInitialization(EmitterContext context, ShaderConfig config)
|
||||
{
|
||||
// Compute has no output attributes, and fragment is the last stage, so we
|
||||
// don't need to initialize outputs on those stages.
|
||||
if (config.Stage == ShaderStage.Compute || config.Stage == ShaderStage.Fragment)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void InitializeOutput(int baseAttr)
|
||||
{
|
||||
for (int c = 0; c < 4; c++)
|
||||
{
|
||||
context.Copy(Attribute(baseAttr + c * 4), ConstF(c == 3 ? 1f : 0f));
|
||||
}
|
||||
}
|
||||
|
||||
if (config.Stage == ShaderStage.Vertex)
|
||||
{
|
||||
InitializeOutput(AttributeConsts.PositionX);
|
||||
}
|
||||
|
||||
int usedAttribtes = context.Config.UsedOutputAttributes;
|
||||
while (usedAttribtes != 0)
|
||||
{
|
||||
int index = BitOperations.TrailingZeroCount(usedAttribtes);
|
||||
|
||||
InitializeOutput(AttributeConsts.UserAttributeBase + index * 16);
|
||||
|
||||
usedAttribtes &= ~(1 << index);
|
||||
}
|
||||
}
|
||||
|
||||
private static void EmitOps(EmitterContext context, Block block)
|
||||
{
|
||||
for (int opIndex = 0; opIndex < block.OpCodes.Count; opIndex++)
|
||||
|
|
|
@ -38,7 +38,7 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
operand.Value < AttributeConsts.UserAttributeEnd;
|
||||
}
|
||||
|
||||
private static FunctionCode[] Combine(FunctionCode[] a, FunctionCode[] b)
|
||||
private static FunctionCode[] Combine(FunctionCode[] a, FunctionCode[] b, int aStart)
|
||||
{
|
||||
// Here we combine two shaders.
|
||||
// For shader A:
|
||||
|
@ -57,7 +57,7 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
|
||||
Operand lblB = Label();
|
||||
|
||||
for (int index = 0; index < a[0].Code.Length; index++)
|
||||
for (int index = aStart; index < a[0].Code.Length; index++)
|
||||
{
|
||||
Operation operation = a[0].Code[index];
|
||||
|
||||
|
@ -102,11 +102,21 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
Operand temp = temps[(src.Value - AttributeConsts.UserAttributeBase) / 4];
|
||||
|
||||
if (temp != null)
|
||||
{
|
||||
// TODO: LoadAttribute should accept any integer value as first argument,
|
||||
// then we don't need special case here. Right now it expects the first
|
||||
// operand to be of type "attribute".
|
||||
if ((operation.Inst & Instruction.Mask) == Instruction.LoadAttribute)
|
||||
{
|
||||
operation.TurnIntoCopy(temp);
|
||||
}
|
||||
else
|
||||
{
|
||||
operation.SetSource(srcIndex, temp);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ops.Add(operation);
|
||||
}
|
||||
|
@ -126,13 +136,25 @@ namespace Ryujinx.Graphics.Shader.Translation
|
|||
return output;
|
||||
}
|
||||
|
||||
public ShaderProgram Translate(out ShaderProgramInfo shaderProgramInfo, TranslatorContext other = null)
|
||||
public ShaderProgram Translate(
|
||||
out ShaderProgramInfo shaderProgramInfo,
|
||||
TranslatorContext nextStage = null,
|
||||
TranslatorContext other = null)
|
||||
{
|
||||
FunctionCode[] code = EmitShader(_cfg, _config);
|
||||
if (nextStage != null)
|
||||
{
|
||||
_config.MergeOutputUserAttributes(nextStage._config.UsedInputAttributes);
|
||||
}
|
||||
|
||||
FunctionCode[] code = EmitShader(_cfg, _config, initializeOutputs: other == null, out _);
|
||||
|
||||
if (other != null)
|
||||
{
|
||||
code = Combine(EmitShader(other._cfg, other._config), code);
|
||||
other._config.MergeOutputUserAttributes(_config.UsedOutputAttributes);
|
||||
|
||||
FunctionCode[] otherCode = EmitShader(other._cfg, other._config, initializeOutputs: true, out int aStart);
|
||||
|
||||
code = Combine(otherCode, code, aStart);
|
||||
|
||||
_config.InheritFrom(other._config);
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue