9f12e50a54
* Refactor attribute handling on the shader generator * Implement gl_ViewportMask[] * Add back the Intel FrontFacing bug workaround * Fix GLSL transform feedback outputs mistmatch with fragment stage * Shader cache version bump * Fix geometry shader recognition * PR feedback * Delete GetOperandDef and GetOperandUse * Remove replacements that are no longer needed on GLSL compilation on Vulkan * Fix incorrect load for per-patch outputs * Fix build
351 lines
No EOL
16 KiB
C#
351 lines
No EOL
16 KiB
C#
using Ryujinx.Graphics.Shader.IntermediateRepresentation;
|
|
using Ryujinx.Graphics.Shader.Translation;
|
|
using System.Collections.Generic;
|
|
|
|
using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
|
|
|
|
namespace Ryujinx.Graphics.Shader.Instructions
|
|
{
|
|
static class AttributeMap
|
|
{
|
|
private enum StagesMask : byte
|
|
{
|
|
None = 0,
|
|
Compute = 1 << (int)ShaderStage.Compute,
|
|
Vertex = 1 << (int)ShaderStage.Vertex,
|
|
TessellationControl = 1 << (int)ShaderStage.TessellationControl,
|
|
TessellationEvaluation = 1 << (int)ShaderStage.TessellationEvaluation,
|
|
Geometry = 1 << (int)ShaderStage.Geometry,
|
|
Fragment = 1 << (int)ShaderStage.Fragment,
|
|
|
|
Tessellation = TessellationControl | TessellationEvaluation,
|
|
VertexTessellationGeometry = Vertex | Tessellation | Geometry,
|
|
TessellationGeometryFragment = Tessellation | Geometry | Fragment,
|
|
AllGraphics = Vertex | Tessellation | Geometry | Fragment
|
|
}
|
|
|
|
private struct AttributeEntry
|
|
{
|
|
public int BaseOffset { get; }
|
|
public AggregateType Type { get; }
|
|
public IoVariable IoVariable { get; }
|
|
public StagesMask InputMask { get; }
|
|
public StagesMask OutputMask { get; }
|
|
|
|
public AttributeEntry(
|
|
int baseOffset,
|
|
AggregateType type,
|
|
IoVariable ioVariable,
|
|
StagesMask inputMask,
|
|
StagesMask outputMask)
|
|
{
|
|
BaseOffset = baseOffset;
|
|
Type = type;
|
|
IoVariable = ioVariable;
|
|
InputMask = inputMask;
|
|
OutputMask = outputMask;
|
|
}
|
|
}
|
|
|
|
private static readonly IReadOnlyDictionary<int, AttributeEntry> _attributes;
|
|
private static readonly IReadOnlyDictionary<int, AttributeEntry> _attributesPerPatch;
|
|
|
|
static AttributeMap()
|
|
{
|
|
_attributes = CreateMap();
|
|
_attributesPerPatch = CreatePerPatchMap();
|
|
}
|
|
|
|
private static IReadOnlyDictionary<int, AttributeEntry> CreateMap()
|
|
{
|
|
var map = new Dictionary<int, AttributeEntry>();
|
|
|
|
Add(map, 0x060, AggregateType.S32, IoVariable.PrimitiveId, StagesMask.TessellationGeometryFragment, StagesMask.Geometry);
|
|
Add(map, 0x064, AggregateType.S32, IoVariable.Layer, StagesMask.Fragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x068, AggregateType.S32, IoVariable.ViewportIndex, StagesMask.Fragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x06c, AggregateType.FP32, IoVariable.PointSize, StagesMask.None, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x070, AggregateType.Vector4 | AggregateType.FP32, IoVariable.Position, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x080, AggregateType.Vector4 | AggregateType.FP32, IoVariable.UserDefined, StagesMask.AllGraphics, StagesMask.VertexTessellationGeometry, 32);
|
|
Add(map, 0x280, AggregateType.Vector4 | AggregateType.FP32, IoVariable.FrontColorDiffuse, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x290, AggregateType.Vector4 | AggregateType.FP32, IoVariable.FrontColorSpecular, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x2a0, AggregateType.Vector4 | AggregateType.FP32, IoVariable.BackColorDiffuse, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x2b0, AggregateType.Vector4 | AggregateType.FP32, IoVariable.BackColorSpecular, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x2c0, AggregateType.Array | AggregateType.FP32, IoVariable.ClipDistance, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry, 8);
|
|
Add(map, 0x2e0, AggregateType.Vector2 | AggregateType.FP32, IoVariable.PointCoord, StagesMask.Fragment, StagesMask.None);
|
|
Add(map, 0x2e8, AggregateType.FP32, IoVariable.FogCoord, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x2f0, AggregateType.Vector2 | AggregateType.FP32, IoVariable.TessellationCoord, StagesMask.TessellationEvaluation, StagesMask.None);
|
|
Add(map, 0x2f8, AggregateType.S32, IoVariable.InstanceId, StagesMask.Vertex, StagesMask.None);
|
|
Add(map, 0x2fc, AggregateType.S32, IoVariable.VertexId, StagesMask.Vertex, StagesMask.None);
|
|
Add(map, 0x300, AggregateType.Vector4 | AggregateType.FP32, IoVariable.TextureCoord, StagesMask.TessellationGeometryFragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x3a0, AggregateType.Array | AggregateType.S32, IoVariable.ViewportMask, StagesMask.Fragment, StagesMask.VertexTessellationGeometry);
|
|
Add(map, 0x3fc, AggregateType.Bool, IoVariable.FrontFacing, StagesMask.Fragment, StagesMask.None);
|
|
|
|
return map;
|
|
}
|
|
|
|
private static IReadOnlyDictionary<int, AttributeEntry> CreatePerPatchMap()
|
|
{
|
|
var map = new Dictionary<int, AttributeEntry>();
|
|
|
|
Add(map, 0x000, AggregateType.Vector4 | AggregateType.FP32, IoVariable.TessellationLevelOuter, StagesMask.TessellationEvaluation, StagesMask.TessellationControl);
|
|
Add(map, 0x010, AggregateType.Vector2 | AggregateType.FP32, IoVariable.TessellationLevelInner, StagesMask.TessellationEvaluation, StagesMask.TessellationControl);
|
|
Add(map, 0x018, AggregateType.Vector4 | AggregateType.FP32, IoVariable.UserDefined, StagesMask.TessellationEvaluation, StagesMask.TessellationControl, 31, 0x200);
|
|
|
|
return map;
|
|
}
|
|
|
|
private static void Add(
|
|
Dictionary<int, AttributeEntry> attributes,
|
|
int offset,
|
|
AggregateType type,
|
|
IoVariable ioVariable,
|
|
StagesMask inputMask,
|
|
StagesMask outputMask,
|
|
int count = 1,
|
|
int upperBound = 0x400)
|
|
{
|
|
int baseOffset = offset;
|
|
|
|
int elementsCount = GetElementCount(type);
|
|
|
|
for (int index = 0; index < count; index++)
|
|
{
|
|
for (int elementIndex = 0; elementIndex < elementsCount; elementIndex++)
|
|
{
|
|
attributes.Add(offset, new AttributeEntry(baseOffset, type, ioVariable, inputMask, outputMask));
|
|
|
|
offset += 4;
|
|
|
|
if (offset >= upperBound)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static Operand GenerateAttributeLoad(EmitterContext context, Operand primVertex, int offset, bool isOutput, bool isPerPatch)
|
|
{
|
|
if (!(isPerPatch ? _attributesPerPatch : _attributes).TryGetValue(offset, out AttributeEntry entry))
|
|
{
|
|
context.Config.GpuAccessor.Log($"Attribute offset 0x{offset:X} is not valid.");
|
|
return Const(0);
|
|
}
|
|
|
|
StagesMask validUseMask = isOutput ? entry.OutputMask : entry.InputMask;
|
|
|
|
if (((StagesMask)(1 << (int)context.Config.Stage) & validUseMask) == StagesMask.None)
|
|
{
|
|
context.Config.GpuAccessor.Log($"Attribute offset 0x{offset:X} ({entry.IoVariable}) is not valid for stage {context.Config.Stage}.");
|
|
return Const(0);
|
|
}
|
|
|
|
if (!IsSupportedByHost(context.Config.GpuAccessor, context.Config.Stage, entry.IoVariable))
|
|
{
|
|
context.Config.GpuAccessor.Log($"Attribute offset 0x{offset:X} ({entry.IoVariable}) is not supported by the host for stage {context.Config.Stage}.");
|
|
return Const(0);
|
|
}
|
|
|
|
if (HasInvocationId(context.Config.Stage, isOutput) && !isPerPatch)
|
|
{
|
|
primVertex = context.Load(StorageKind.Input, IoVariable.InvocationId);
|
|
}
|
|
|
|
int innerOffset = offset - entry.BaseOffset;
|
|
int innerIndex = innerOffset / 4;
|
|
|
|
StorageKind storageKind = isPerPatch
|
|
? (isOutput ? StorageKind.OutputPerPatch : StorageKind.InputPerPatch)
|
|
: (isOutput ? StorageKind.Output : StorageKind.Input);
|
|
IoVariable ioVariable = GetIoVariable(context.Config.Stage, in entry);
|
|
AggregateType type = GetType(context.Config, isOutput, innerIndex, in entry);
|
|
int elementCount = GetElementCount(type);
|
|
|
|
bool isArray = type.HasFlag(AggregateType.Array);
|
|
bool hasArrayIndex = isArray || context.Config.HasPerLocationInputOrOutput(ioVariable, isOutput);
|
|
|
|
bool hasElementIndex = elementCount > 1;
|
|
|
|
if (hasArrayIndex && hasElementIndex)
|
|
{
|
|
int arrayIndex = innerIndex / elementCount;
|
|
int elementIndex = innerIndex - (arrayIndex * elementCount);
|
|
|
|
return primVertex == null || isArray
|
|
? context.Load(storageKind, ioVariable, primVertex, Const(arrayIndex), Const(elementIndex))
|
|
: context.Load(storageKind, ioVariable, Const(arrayIndex), primVertex, Const(elementIndex));
|
|
}
|
|
else if (hasArrayIndex || hasElementIndex)
|
|
{
|
|
return primVertex == null || isArray || !hasArrayIndex
|
|
? context.Load(storageKind, ioVariable, primVertex, Const(innerIndex))
|
|
: context.Load(storageKind, ioVariable, Const(innerIndex), primVertex);
|
|
}
|
|
else
|
|
{
|
|
return context.Load(storageKind, ioVariable, primVertex);
|
|
}
|
|
}
|
|
|
|
public static void GenerateAttributeStore(EmitterContext context, int offset, bool isPerPatch, Operand value)
|
|
{
|
|
if (!(isPerPatch ? _attributesPerPatch : _attributes).TryGetValue(offset, out AttributeEntry entry))
|
|
{
|
|
context.Config.GpuAccessor.Log($"Attribute offset 0x{offset:X} is not valid.");
|
|
return;
|
|
}
|
|
|
|
if (((StagesMask)(1 << (int)context.Config.Stage) & entry.OutputMask) == StagesMask.None)
|
|
{
|
|
context.Config.GpuAccessor.Log($"Attribute offset 0x{offset:X} ({entry.IoVariable}) is not valid for stage {context.Config.Stage}.");
|
|
return;
|
|
}
|
|
|
|
if (!IsSupportedByHost(context.Config.GpuAccessor, context.Config.Stage, entry.IoVariable))
|
|
{
|
|
context.Config.GpuAccessor.Log($"Attribute offset 0x{offset:X} ({entry.IoVariable}) is not supported by the host for stage {context.Config.Stage}.");
|
|
return;
|
|
}
|
|
|
|
Operand invocationId = null;
|
|
|
|
if (HasInvocationId(context.Config.Stage, isOutput: true) && !isPerPatch)
|
|
{
|
|
invocationId = context.Load(StorageKind.Input, IoVariable.InvocationId);
|
|
}
|
|
|
|
int innerOffset = offset - entry.BaseOffset;
|
|
int innerIndex = innerOffset / 4;
|
|
|
|
StorageKind storageKind = isPerPatch ? StorageKind.OutputPerPatch : StorageKind.Output;
|
|
IoVariable ioVariable = GetIoVariable(context.Config.Stage, in entry);
|
|
AggregateType type = GetType(context.Config, isOutput: true, innerIndex, in entry);
|
|
int elementCount = GetElementCount(type);
|
|
|
|
bool isArray = type.HasFlag(AggregateType.Array);
|
|
bool hasArrayIndex = isArray || context.Config.HasPerLocationInputOrOutput(ioVariable, isOutput: true);
|
|
|
|
bool hasElementIndex = elementCount > 1;
|
|
|
|
if (hasArrayIndex && hasElementIndex)
|
|
{
|
|
int arrayIndex = innerIndex / elementCount;
|
|
int elementIndex = innerIndex - (arrayIndex * elementCount);
|
|
|
|
if (invocationId == null || isArray)
|
|
{
|
|
context.Store(storageKind, ioVariable, invocationId, Const(arrayIndex), Const(elementIndex), value);
|
|
}
|
|
else
|
|
{
|
|
context.Store(storageKind, ioVariable, Const(arrayIndex), invocationId, Const(elementIndex), value);
|
|
}
|
|
}
|
|
else if (hasArrayIndex || hasElementIndex)
|
|
{
|
|
if (invocationId == null || isArray || !hasArrayIndex)
|
|
{
|
|
context.Store(storageKind, ioVariable, invocationId, Const(innerIndex), value);
|
|
}
|
|
else
|
|
{
|
|
context.Store(storageKind, ioVariable, Const(innerIndex), invocationId, value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
context.Store(storageKind, ioVariable, invocationId, value);
|
|
}
|
|
}
|
|
|
|
private static bool IsSupportedByHost(IGpuAccessor gpuAccessor, ShaderStage stage, IoVariable ioVariable)
|
|
{
|
|
if (ioVariable == IoVariable.ViewportIndex && stage != ShaderStage.Geometry && stage != ShaderStage.Fragment)
|
|
{
|
|
return gpuAccessor.QueryHostSupportsViewportIndexVertexTessellation();
|
|
}
|
|
else if (ioVariable == IoVariable.ViewportMask)
|
|
{
|
|
return gpuAccessor.QueryHostSupportsViewportMask();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static IoVariable GetIoVariable(ShaderConfig config, int offset, out int location)
|
|
{
|
|
location = 0;
|
|
|
|
if (!_attributes.TryGetValue(offset, out AttributeEntry entry))
|
|
{
|
|
return IoVariable.Invalid;
|
|
}
|
|
|
|
if (((StagesMask)(1 << (int)config.Stage) & entry.OutputMask) == StagesMask.None)
|
|
{
|
|
return IoVariable.Invalid;
|
|
}
|
|
|
|
if (config.HasPerLocationInputOrOutput(entry.IoVariable, isOutput: true))
|
|
{
|
|
location = (offset - entry.BaseOffset) / 16;
|
|
}
|
|
|
|
return GetIoVariable(config.Stage, in entry);
|
|
}
|
|
|
|
private static IoVariable GetIoVariable(ShaderStage stage, in AttributeEntry entry)
|
|
{
|
|
if (entry.IoVariable == IoVariable.Position && stage == ShaderStage.Fragment)
|
|
{
|
|
return IoVariable.FragmentCoord;
|
|
}
|
|
|
|
return entry.IoVariable;
|
|
}
|
|
|
|
private static AggregateType GetType(ShaderConfig config, bool isOutput, int innerIndex, in AttributeEntry entry)
|
|
{
|
|
AggregateType type = entry.Type;
|
|
|
|
if (entry.IoVariable == IoVariable.UserDefined)
|
|
{
|
|
type = config.GetUserDefinedType(innerIndex / 4, isOutput);
|
|
}
|
|
else if (entry.IoVariable == IoVariable.FragmentOutputColor)
|
|
{
|
|
type = config.GetFragmentOutputColorType(innerIndex / 4);
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
public static bool HasPrimitiveVertex(ShaderStage stage, bool isOutput)
|
|
{
|
|
if (isOutput)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return stage == ShaderStage.TessellationControl ||
|
|
stage == ShaderStage.TessellationEvaluation ||
|
|
stage == ShaderStage.Geometry;
|
|
}
|
|
|
|
public static bool HasInvocationId(ShaderStage stage, bool isOutput)
|
|
{
|
|
return isOutput && stage == ShaderStage.TessellationControl;
|
|
}
|
|
|
|
private static int GetElementCount(AggregateType type)
|
|
{
|
|
return (type & AggregateType.ElementCountMask) switch
|
|
{
|
|
AggregateType.Vector2 => 2,
|
|
AggregateType.Vector3 => 3,
|
|
AggregateType.Vector4 => 4,
|
|
_ => 1
|
|
};
|
|
}
|
|
}
|
|
} |