manuth/Ryujinx
1
0
Fork 0
mirror of https://git.naxdy.org/Mirror/Ryujinx.git synced 2025-02-19 07:43:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Update Spv.Generator

Browse source
This commit is contained in:
gdk 2021-12-11 20:12:44 -03:00 committed by riperiperi
parent adfba37a3f
commit 9a95c3c3bc
19 changed files with 1819 additions and 382 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
Ryujinx.Graphics.Shader/CodeGen/Spirv/CodeGenContext.cs
View file

@ -15,8 +15,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
{
public ShaderConfig Config { get; }
public Instruction ExtSet { get; }
public Dictionary<int, Instruction> UniformBuffers { get; } = new Dictionary<int, Instruction>();
public Instruction StorageBuffersArray { get; set; }
public Instruction LocalMemory { get; set; }
@ -68,8 +66,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
AddCapability(Capability.Shader);
AddCapability(Capability.Float64);
ExtSet = AddExtInstImport("GLSL.std.450");
SetMemoryModel(AddressingModel.Logical, MemoryModel.GLSL450);
}
@ -277,10 +273,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
return _functions[funcIndex];
}
protected override void Construct()
{
}
public Instruction GetType(AggregateType type, int length = 1)
{
if (type.HasFlag(AggregateType.Array))

4
Ryujinx.Graphics.Shader/CodeGen/Spirv/Declarations.cs
View file

@ -449,8 +449,8 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
AttributeConsts.ClipDistance0 => BuiltIn.ClipDistance,
AttributeConsts.PointCoordX => BuiltIn.PointCoord,
AttributeConsts.TessCoordX => BuiltIn.TessCoord,
AttributeConsts.InstanceId => BuiltIn.InstanceId,
AttributeConsts.VertexId => BuiltIn.VertexId,
AttributeConsts.InstanceId => BuiltIn.InstanceId, // FIXME: Invalid
AttributeConsts.VertexId => BuiltIn.VertexId, // FIXME: Invalid
AttributeConsts.FrontFacing => BuiltIn.FrontFacing,
AttributeConsts.FragmentOutputDepth => BuiltIn.FragDepth,
AttributeConsts.ThreadKill => BuiltIn.HelperInvocation,

193
Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs
View file

@ -143,7 +143,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateAbsolute(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 4, 5);
return GenerateUnary(context, operation, context.GlslFAbs, context.GlslSAbs);
}
private static OperationResult GenerateAdd(CodeGenContext context, AstOperation operation)
@ -306,17 +306,17 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateCeiling(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 9);
return GenerateUnary(context, operation, context.GlslCeil, null);
}
private static OperationResult GenerateClamp(CodeGenContext context, AstOperation operation)
{
return GenerateTernaryExtInst(context, operation, 43, 45);
return GenerateTernary(context, operation, context.GlslFClamp, context.GlslSClamp);
}
private static OperationResult GenerateClampU32(CodeGenContext context, AstOperation operation)
{
return GenerateTernaryExtInstU32(context, operation, 44);
return GenerateTernaryU32(context, operation, context.GlslUClamp);
}
private static OperationResult GenerateComment(CodeGenContext context, AstOperation operation)
@ -468,7 +468,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateCosine(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 14);
return GenerateUnary(context, operation, context.GlslCos, null);
}
private static OperationResult GenerateDdx(CodeGenContext context, AstOperation operation)
@ -494,35 +494,35 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateExponentB2(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 29);
return GenerateUnary(context, operation, context.GlslExp2, null);
}
private static OperationResult GenerateFindLSB(CodeGenContext context, AstOperation operation)
{
var source = context.GetU32(operation.GetSource(0));
return new OperationResult(AggregateType.U32, context.ExtInst(context.TypeU32(), context.ExtSet, 74, source));
return new OperationResult(AggregateType.U32, context.GlslFindILsb(context.TypeU32(), source));
}
private static OperationResult GenerateFindMSBS32(CodeGenContext context, AstOperation operation)
{
var source = context.GetS32(operation.GetSource(0));
return new OperationResult(AggregateType.U32, context.ExtInst(context.TypeU32(), context.ExtSet, 75, source));
return new OperationResult(AggregateType.U32, context.GlslFindSMsb(context.TypeU32(), source));
}
private static OperationResult GenerateFindMSBU32(CodeGenContext context, AstOperation operation)
{
var source = context.GetU32(operation.GetSource(0));
return new OperationResult(AggregateType.U32, context.ExtInst(context.TypeU32(), context.ExtSet, 75, source));
return new OperationResult(AggregateType.U32, context.GlslFindUMsb(context.TypeU32(), source));
}
private static OperationResult GenerateFloor(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 8);
return GenerateUnary(context, operation, context.GlslFloor, null);
}
private static OperationResult GenerateFusedMultiplyAdd(CodeGenContext context, AstOperation operation)
{
return GenerateTernaryExtInst(context, operation, 50);
return GenerateTernary(context, operation, context.GlslFma, null);
}
private static OperationResult GenerateGroupMemoryBarrier(CodeGenContext context, AstOperation operation)
@ -596,7 +596,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
var image = context.Load(imageType, imageVariable);
var texel = context.ImageRead(context.TypeVector(context.GetType(componentType.Convert()), 4), image, pCoords);
var texel = context.ImageRead(context.TypeVector(context.GetType(componentType.Convert()), 4), image, pCoords, ImageOperandsMask.MaskNone);
var result = context.CompositeExtract(context.TypeFP32(), texel, (SpvLiteralInteger)texOp.Index);
return new OperationResult(componentType.Convert(), result);
@ -683,7 +683,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
var image = context.Load(imageType, imageVariable);
context.ImageWrite(image, pCoords, texel);
context.ImageWrite(image, pCoords, texel, ImageOperandsMask.MaskNone);
return OperationResult.Invalid;
}
@ -831,7 +831,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateLogarithmB2(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 30);
return GenerateUnary(context, operation, context.GlslLog2, null);
}
private static OperationResult GenerateLogicalAnd(CodeGenContext context, AstOperation operation)
@ -864,12 +864,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateMaximum(CodeGenContext context, AstOperation operation)
{
return GenerateBinaryExtInst(context, operation, 40, 42);
return GenerateBinary(context, operation, context.GlslFMax, context.GlslSMax);
}
private static OperationResult GenerateMaximumU32(CodeGenContext context, AstOperation operation)
{
return GenerateBinaryExtInstU32(context, operation, 41);
return GenerateBinaryU32(context, operation, context.GlslUMax);
}
private static OperationResult GenerateMemoryBarrier(CodeGenContext context, AstOperation operation)
@ -880,12 +880,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateMinimum(CodeGenContext context, AstOperation operation)
{
return GenerateBinaryExtInst(context, operation, 37, 39);
return GenerateBinary(context, operation, context.GlslFMin, context.GlslSMin);
}
private static OperationResult GenerateMinimumU32(CodeGenContext context, AstOperation operation)
{
return GenerateBinaryExtInstU32(context, operation, 38);
return GenerateBinaryU32(context, operation, context.GlslUMin);
}
private static OperationResult GenerateMultiply(CodeGenContext context, AstOperation operation)
@ -903,14 +903,14 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
var value0 = context.GetFP32(operation.GetSource(0));
var value1 = context.GetFP32(operation.GetSource(1));
var vector = context.CompositeConstruct(context.TypeVector(context.TypeFP32(), 2), value0, value1);
var result = context.ExtInst(context.TypeU32(), context.ExtSet, 58, vector);
var result = context.GlslPackHalf2x16(context.TypeU32(), vector);
return new OperationResult(AggregateType.U32, result);
}
private static OperationResult GenerateReciprocalSquareRoot(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 32);
return GenerateUnary(context, operation, context.GlslInverseSqrt, null);
}
private static OperationResult GenerateReturn(CodeGenContext context, AstOperation operation)
@ -921,7 +921,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateRound(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 2);
return GenerateUnary(context, operation, context.GlslRoundEven, null);
}
private static OperationResult GenerateShiftLeft(CodeGenContext context, AstOperation operation)
@ -1064,12 +1064,12 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateSine(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 13);
return GenerateUnary(context, operation, context.GlslSin, null);
}
private static OperationResult GenerateSquareRoot(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 31);
return GenerateUnary(context, operation, context.GlslSqrt, null);
}
private static OperationResult GenerateStoreLocal(CodeGenContext context, AstOperation operation)
@ -1461,13 +1461,13 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
private static OperationResult GenerateTruncate(CodeGenContext context, AstOperation operation)
{
return GenerateUnaryExtInst(context, operation, 3);
return GenerateUnary(context, operation, context.GlslTrunc, null);
}
private static OperationResult GenerateUnpackHalf2x16(CodeGenContext context, AstOperation operation)
{
var value = context.GetU32(operation.GetSource(0));
var vector = context.ExtInst(context.TypeVector(context.TypeFP32(), 2), context.ExtSet, 62, value);
var vector = context.GlslUnpackHalf2x16(context.TypeVector(context.TypeFP32(), 2), value);
var result = context.CompositeExtract(context.TypeFP32(), vector, operation.Index);
return new OperationResult(AggregateType.FP32, result);
@ -1648,38 +1648,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
return new OperationResult(AggregateType.S32, emitS(context.TypeS32(), context.GetS32(source)));
}
private static OperationResult GenerateUnaryExtInst(CodeGenContext context, AstOperation operation, int instruction)
{
var source = operation.GetSource(0);
if (operation.Inst.HasFlag(Instruction.FP64))
{
return new OperationResult(AggregateType.FP64, context.ExtInst(context.TypeFP64(), context.ExtSet, instruction, context.GetFP64(source)));
}
else
{
return new OperationResult(AggregateType.FP32, context.ExtInst(context.TypeFP32(), context.ExtSet, instruction, context.GetFP32(source)));
}
}
private static OperationResult GenerateUnaryExtInst(CodeGenContext context, AstOperation operation, int instF, int instS)
{
var source = operation.GetSource(0);
if (operation.Inst.HasFlag(Instruction.FP64))
{
return new OperationResult(AggregateType.FP64, context.ExtInst(context.TypeFP64(), context.ExtSet, instF, context.GetFP64(source)));
}
else if (operation.Inst.HasFlag(Instruction.FP32))
{
return new OperationResult(AggregateType.FP32, context.ExtInst(context.TypeFP32(), context.ExtSet, instF, context.GetFP32(source)));
}
else
{
return new OperationResult(AggregateType.S32, context.ExtInst(context.TypeS32(), context.ExtSet, instS, context.GetS32(source)));
}
}
private static OperationResult GenerateBinary(
CodeGenContext context,
AstOperation operation,
@ -1729,33 +1697,45 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
return new OperationResult(AggregateType.S32, emitS(context.TypeS32(), context.GetS32(src1), context.GetS32(src2)));
}
private static OperationResult GenerateBinaryExtInst(CodeGenContext context, AstOperation operation, int instF, int instS)
private static OperationResult GenerateBinaryU32(
CodeGenContext context,
AstOperation operation,
Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitU)
{
var src1 = operation.GetSource(0);
var src2 = operation.GetSource(1);
return new OperationResult(AggregateType.U32, emitU(context.TypeU32(), context.GetU32(src1), context.GetU32(src2)));
}
private static OperationResult GenerateTernary(
CodeGenContext context,
AstOperation operation,
Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitF,
Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitI)
{
var src1 = operation.GetSource(0);
var src2 = operation.GetSource(1);
var src3 = operation.GetSource(2);
if (operation.Inst.HasFlag(Instruction.FP64))
{
return new OperationResult(AggregateType.FP64, context.ExtInst(context.TypeFP64(), context.ExtSet, instF, context.GetFP64(src1), context.GetFP64(src2)));
var result = emitF(context.TypeFP64(), context.GetFP64(src1), context.GetFP64(src2), context.GetFP64(src3));
context.Decorate(result, Decoration.NoContraction);
return new OperationResult(AggregateType.FP64, result);
}
else if (operation.Inst.HasFlag(Instruction.FP32))
{
return new OperationResult(AggregateType.FP32, context.ExtInst(context.TypeFP32(), context.ExtSet, instF, context.GetFP32(src1), context.GetFP32(src2)));
var result = emitF(context.TypeFP32(), context.GetFP32(src1), context.GetFP32(src2), context.GetFP32(src3));
context.Decorate(result, Decoration.NoContraction);
return new OperationResult(AggregateType.FP32, result);
}
else
{
return new OperationResult(AggregateType.S32, context.ExtInst(context.TypeS32(), context.ExtSet, instS, context.GetS32(src1), context.GetS32(src2)));
return new OperationResult(AggregateType.S32, emitI(context.TypeS32(), context.GetS32(src1), context.GetS32(src2), context.GetS32(src3)));
}
}
private static OperationResult GenerateBinaryExtInstU32(CodeGenContext context, AstOperation operation, int instU)
{
var src1 = operation.GetSource(0);
var src2 = operation.GetSource(1);
return new OperationResult(AggregateType.U32, context.ExtInst(context.TypeU32(), context.ExtSet, instU, context.GetU32(src1), context.GetU32(src2)));
}
private static OperationResult GenerateTernaryS32(
CodeGenContext context,
AstOperation operation,
@ -1772,82 +1752,17 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
context.GetS32(src3)));
}
private static OperationResult GenerateTernaryExtInst(CodeGenContext context, AstOperation operation, int instF)
private static OperationResult GenerateTernaryU32(
CodeGenContext context,
AstOperation operation,
Func<SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction, SpvInstruction> emitU)
{
var src1 = operation.GetSource(0);
var src2 = operation.GetSource(1);
var src3 = operation.GetSource(2);
if (operation.Inst.HasFlag(Instruction.FP64))
{
return new OperationResult(AggregateType.FP64, context.ExtInst(
context.TypeFP64(),
context.ExtSet,
instF,
context.GetFP64(src1),
context.GetFP64(src2),
context.GetFP64(src3)));
}
else
{
return new OperationResult(AggregateType.FP32, context.ExtInst(
context.TypeFP32(),
context.ExtSet,
instF,
context.GetFP32(src1),
context.GetFP32(src2),
context.GetFP32(src3)));
}
}
private static OperationResult GenerateTernaryExtInst(CodeGenContext context, AstOperation operation, int instF, int instS)
{
var src1 = operation.GetSource(0);
var src2 = operation.GetSource(1);
var src3 = operation.GetSource(2);
if (operation.Inst.HasFlag(Instruction.FP64))
{
return new OperationResult(AggregateType.FP64, context.ExtInst(
context.TypeFP64(),
context.ExtSet,
instF,
context.GetFP64(src1),
context.GetFP64(src2),
context.GetFP64(src3)));
}
else if (operation.Inst.HasFlag(Instruction.FP32))
{
return new OperationResult(AggregateType.FP32, context.ExtInst(
context.TypeFP32(),
context.ExtSet,
instF,
context.GetFP32(src1),
context.GetFP32(src2),
context.GetFP32(src3)));
}
else
{
return new OperationResult(AggregateType.S32, context.ExtInst(
context.TypeS32(),
context.ExtSet,
instS,
context.GetS32(src1),
context.GetS32(src2),
context.GetS32(src3)));
}
}
private static OperationResult GenerateTernaryExtInstU32(CodeGenContext context, AstOperation operation, int instU)
{
var src1 = operation.GetSource(0);
var src2 = operation.GetSource(1);
var src3 = operation.GetSource(2);
return new OperationResult(AggregateType.U32, context.ExtInst(
return new OperationResult(AggregateType.U32, emitU(
context.TypeU32(),
context.ExtSet,
instU,
context.GetU32(src1),
context.GetU32(src2),
context.GetU32(src3)));

2
Ryujinx.Graphics.Shader/Ryujinx.Graphics.Shader.csproj
View file

@ -10,7 +10,7 @@
<ItemGroup>
<ProjectReference Include="..\Ryujinx.Common\Ryujinx.Common.csproj" />
<ProjectReference Include="..\SpvGen\Spv.Generator.csproj" />
<ProjectReference Include="..\Spv.Generator\Spv.Generator.csproj" />
</ItemGroup>
<ItemGroup>

84
Ryujinx.Graphics.Shader/Translation/AttributeInfo.cs
View file

@ -7,44 +7,44 @@ namespace Ryujinx.Graphics.Shader.Translation
{
private static readonly Dictionary<int, AttributeInfo> BuiltInAttributes = new Dictionary<int, AttributeInfo>()
{
{ AttributeConsts.Layer, new AttributeInfo(AttributeConsts.Layer, 1, AggregateType.S32) },
{ AttributeConsts.ViewportIndex, new AttributeInfo(AttributeConsts.ViewportIndex, 1, AggregateType.S32) },
{ AttributeConsts.PointSize, new AttributeInfo(AttributeConsts.PointSize, 1, AggregateType.FP32) },
{ AttributeConsts.PositionX, new AttributeInfo(AttributeConsts.PositionX, 4, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.PositionY, new AttributeInfo(AttributeConsts.PositionY, 4, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.PositionZ, new AttributeInfo(AttributeConsts.PositionZ, 4, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.PositionW, new AttributeInfo(AttributeConsts.PositionW, 4, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.ClipDistance0, new AttributeInfo(AttributeConsts.ClipDistance0, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance1, new AttributeInfo(AttributeConsts.ClipDistance1, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance2, new AttributeInfo(AttributeConsts.ClipDistance2, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance3, new AttributeInfo(AttributeConsts.ClipDistance3, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance4, new AttributeInfo(AttributeConsts.ClipDistance4, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance5, new AttributeInfo(AttributeConsts.ClipDistance5, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance6, new AttributeInfo(AttributeConsts.ClipDistance6, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance7, new AttributeInfo(AttributeConsts.ClipDistance7, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.PointCoordX, new AttributeInfo(AttributeConsts.PointCoordX, 2, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.PointCoordY, new AttributeInfo(AttributeConsts.PointCoordY, 2, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.TessCoordX, new AttributeInfo(AttributeConsts.TessCoordX, 2, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.TessCoordY, new AttributeInfo(AttributeConsts.TessCoordY, 2, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.InstanceId, new AttributeInfo(AttributeConsts.InstanceId, 1, AggregateType.S32) },
{ AttributeConsts.VertexId, new AttributeInfo(AttributeConsts.VertexId, 1, AggregateType.S32) },
{ AttributeConsts.FrontFacing, new AttributeInfo(AttributeConsts.FrontFacing, 1, AggregateType.Bool) },
{ AttributeConsts.Layer, new AttributeInfo(AttributeConsts.Layer, 0, 1, AggregateType.S32) },
{ AttributeConsts.ViewportIndex, new AttributeInfo(AttributeConsts.ViewportIndex, 0, 1, AggregateType.S32) },
{ AttributeConsts.PointSize, new AttributeInfo(AttributeConsts.PointSize, 0, 1, AggregateType.FP32) },
{ AttributeConsts.PositionX, new AttributeInfo(AttributeConsts.PositionX, 0, 4, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.PositionY, new AttributeInfo(AttributeConsts.PositionX, 1, 4, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.PositionZ, new AttributeInfo(AttributeConsts.PositionX, 2, 4, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.PositionW, new AttributeInfo(AttributeConsts.PositionX, 3, 4, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.ClipDistance0, new AttributeInfo(AttributeConsts.ClipDistance0, 0, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance1, new AttributeInfo(AttributeConsts.ClipDistance0, 1, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance2, new AttributeInfo(AttributeConsts.ClipDistance0, 2, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance3, new AttributeInfo(AttributeConsts.ClipDistance0, 3, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance4, new AttributeInfo(AttributeConsts.ClipDistance0, 4, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance5, new AttributeInfo(AttributeConsts.ClipDistance0, 5, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance6, new AttributeInfo(AttributeConsts.ClipDistance0, 6, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.ClipDistance7, new AttributeInfo(AttributeConsts.ClipDistance0, 7, 8, AggregateType.Array | AggregateType.FP32) },
{ AttributeConsts.PointCoordX, new AttributeInfo(AttributeConsts.PointCoordX, 0, 2, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.PointCoordY, new AttributeInfo(AttributeConsts.PointCoordX, 1, 2, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.TessCoordX, new AttributeInfo(AttributeConsts.TessCoordX, 0, 2, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.TessCoordY, new AttributeInfo(AttributeConsts.TessCoordX, 1, 2, AggregateType.Vector | AggregateType.FP32) },
{ AttributeConsts.InstanceId, new AttributeInfo(AttributeConsts.InstanceId, 0, 1, AggregateType.S32) },
{ AttributeConsts.VertexId, new AttributeInfo(AttributeConsts.VertexId, 0, 1, AggregateType.S32) },
{ AttributeConsts.FrontFacing, new AttributeInfo(AttributeConsts.FrontFacing, 0, 1, AggregateType.Bool) },
// Special.
{ AttributeConsts.FragmentOutputDepth, new AttributeInfo(AttributeConsts.FragmentOutputDepth, 1, AggregateType.FP32) },
{ AttributeConsts.ThreadKill, new AttributeInfo(AttributeConsts.ThreadKill, 1, AggregateType.Bool) },
{ AttributeConsts.ThreadIdX, new AttributeInfo(AttributeConsts.ThreadIdX, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.ThreadIdY, new AttributeInfo(AttributeConsts.ThreadIdY, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.ThreadIdZ, new AttributeInfo(AttributeConsts.ThreadIdZ, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.CtaIdX, new AttributeInfo(AttributeConsts.CtaIdX, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.CtaIdY, new AttributeInfo(AttributeConsts.CtaIdY, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.CtaIdZ, new AttributeInfo(AttributeConsts.CtaIdZ, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.LaneId, new AttributeInfo(AttributeConsts.LaneId, 1, AggregateType.U32) },
{ AttributeConsts.EqMask, new AttributeInfo(AttributeConsts.EqMask, 1, AggregateType.U32) },
{ AttributeConsts.GeMask, new AttributeInfo(AttributeConsts.GeMask, 1, AggregateType.U32) },
{ AttributeConsts.GtMask, new AttributeInfo(AttributeConsts.GtMask, 1, AggregateType.U32) },
{ AttributeConsts.LeMask, new AttributeInfo(AttributeConsts.LeMask, 1, AggregateType.U32) },
{ AttributeConsts.LtMask, new AttributeInfo(AttributeConsts.LtMask, 1, AggregateType.U32) },
{ AttributeConsts.FragmentOutputDepth, new AttributeInfo(AttributeConsts.FragmentOutputDepth, 0, 1, AggregateType.FP32) },
{ AttributeConsts.ThreadKill, new AttributeInfo(AttributeConsts.ThreadKill, 0, 1, AggregateType.Bool) },
{ AttributeConsts.ThreadIdX, new AttributeInfo(AttributeConsts.ThreadIdX, 0, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.ThreadIdY, new AttributeInfo(AttributeConsts.ThreadIdX, 1, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.ThreadIdZ, new AttributeInfo(AttributeConsts.ThreadIdX, 2, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.CtaIdX, new AttributeInfo(AttributeConsts.CtaIdX, 0, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.CtaIdY, new AttributeInfo(AttributeConsts.CtaIdX, 1, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.CtaIdZ, new AttributeInfo(AttributeConsts.CtaIdX, 2, 3, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.LaneId, new AttributeInfo(AttributeConsts.LaneId, 0, 1, AggregateType.U32) },
{ AttributeConsts.EqMask, new AttributeInfo(AttributeConsts.EqMask, 0, 4, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.GeMask, new AttributeInfo(AttributeConsts.GeMask, 0, 4, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.GtMask, new AttributeInfo(AttributeConsts.GtMask, 0, 4, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.LeMask, new AttributeInfo(AttributeConsts.LeMask, 0, 4, AggregateType.Vector | AggregateType.U32) },
{ AttributeConsts.LtMask, new AttributeInfo(AttributeConsts.LtMask, 0, 4, AggregateType.Vector | AggregateType.U32) },
};
public int BaseValue { get; }
@ -54,10 +54,10 @@ namespace Ryujinx.Graphics.Shader.Translation
public bool IsBuiltin { get; }
public bool IsValid => Type != AggregateType.Invalid;
public AttributeInfo(int value, int length, AggregateType type, bool isBuiltin = true)
public AttributeInfo(int baseValue, int index, int length, AggregateType type, bool isBuiltin = true)
{
BaseValue = value & ~(BitUtils.Pow2RoundUp(length) * 4 - 1);
Value = value;
BaseValue = baseValue;
Value = baseValue + index * 4;
Length = length;
Type = type;
IsBuiltin = isBuiltin;
@ -82,18 +82,18 @@ namespace Ryujinx.Graphics.Shader.Translation
_ => AggregateType.FP32
};
return new AttributeInfo(value, 4, AggregateType.Vector | elemType, false);
return new AttributeInfo(value & ~0xf, (value >> 2) & 3, 4, AggregateType.Vector | elemType, false);
}
else if (value >= AttributeConsts.FragmentOutputColorBase && value < AttributeConsts.FragmentOutputColorEnd)
{
return new AttributeInfo(value, 4, AggregateType.Vector | AggregateType.FP32, false);
return new AttributeInfo(value & ~0xf, (value >> 2) & 3, 4, AggregateType.Vector | AggregateType.FP32, false);
}
else if (BuiltInAttributes.TryGetValue(value, out AttributeInfo info))
{
return info;
}
return new AttributeInfo(value, 0, AggregateType.Invalid);
return new AttributeInfo(value, 0, 0, AggregateType.Invalid);
}
}
}

10
Ryujinx.sln
View file

@ -76,7 +76,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Ryujinx.Horizon.Generators"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Ryujinx.Graphics.Vulkan", "Ryujinx.Graphics.Vulkan\Ryujinx.Graphics.Vulkan.csproj", "{D4D09B08-D580-4D69-B886-C35D2853F6C8}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Spv.Generator", "SpvGen\Spv.Generator.csproj", "{D0720AC9-8AE7-417C-AB39-82CE984045C4}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Spv.Generator", "Spv.Generator\Spv.Generator.csproj", "{2BCB3D7A-38C0-4FE7-8FDA-374C6AD56D0E}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@ -220,10 +220,10 @@ Global
{D4D09B08-D580-4D69-B886-C35D2853F6C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
{D4D09B08-D580-4D69-B886-C35D2853F6C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
{D4D09B08-D580-4D69-B886-C35D2853F6C8}.Release|Any CPU.Build.0 = Release|Any CPU
{D0720AC9-8AE7-417C-AB39-82CE984045C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{D0720AC9-8AE7-417C-AB39-82CE984045C4}.Debug|Any CPU.Build.0 = Debug|Any CPU
{D0720AC9-8AE7-417C-AB39-82CE984045C4}.Release|Any CPU.ActiveCfg = Release|Any CPU
{D0720AC9-8AE7-417C-AB39-82CE984045C4}.Release|Any CPU.Build.0 = Release|Any CPU
{2BCB3D7A-38C0-4FE7-8FDA-374C6AD56D0E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{2BCB3D7A-38C0-4FE7-8FDA-374C6AD56D0E}.Debug|Any CPU.Build.0 = Debug|Any CPU
{2BCB3D7A-38C0-4FE7-8FDA-374C6AD56D0E}.Release|Any CPU.ActiveCfg = Release|Any CPU
{2BCB3D7A-38C0-4FE7-8FDA-374C6AD56D0E}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

464
SpvGen/Autogenerated/CoreGrammar.cs → Spv.Generator/Autogenerated/CoreGrammar.cs
View file

@ -1,5 +1,5 @@
// AUTOGENERATED: DO NOT EDIT
// Last update date: 2020-05-20 22:58:10.704809
// Last update date: 2021-01-06 23:02:26.837899
#region Grammar License
// Copyright (c) 2014-2020 The Khronos Group Inc.
//
@ -62,18 +62,6 @@ namespace Spv.Generator
return result;
}
public Instruction ExtInst(Instruction resultType, Instruction set, LiteralInteger instruction, params Instruction[] parameters)
{
Instruction result = new Instruction(Op.OpExtInst, GetNewId(), resultType);
result.AddOperand(set);
result.AddOperand(instruction);
result.AddOperand(parameters);
AddToFunctionDefinitions(result);
return result;
}
// Debug
public Instruction SourceContinued(string continuedSource)
@ -901,53 +889,62 @@ namespace Spv.Generator
return result;
}
public Instruction ImageSampleImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] operands)
public Instruction ImageSampleImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleImplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
if (imageOperands != ImageOperandsMask.MaskNone)
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
result.AddOperand(operands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] operands)
public Instruction ImageSampleExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleExplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(imageOperands);
result.AddOperand(operands);
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleDrefImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] operands)
{
Instruction result = new Instruction(Op.OpImageSampleDrefImplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(dRef);
if (imageOperands != ImageOperandsMask.MaskNone)
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
result.AddOperand(operands);
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleDrefExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] operands)
public Instruction ImageSampleDrefImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleDrefImplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(dRef);
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleDrefExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleDrefExplicitLod, GetNewId(), resultType);
@ -955,59 +952,71 @@ namespace Spv.Generator
result.AddOperand(coordinate);
result.AddOperand(dRef);
result.AddOperand(imageOperands);
result.AddOperand(operands);
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleProjImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] operands)
{
Instruction result = new Instruction(Op.OpImageSampleProjImplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
if (imageOperands != ImageOperandsMask.MaskNone)
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
result.AddOperand(operands);
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleProjExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] operands)
public Instruction ImageSampleProjImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleProjImplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleProjExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleProjExplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(imageOperands);
result.AddOperand(operands);
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleProjDrefImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] operands)
{
Instruction result = new Instruction(Op.OpImageSampleProjDrefImplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(dRef);
if (imageOperands != ImageOperandsMask.MaskNone)
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
result.AddOperand(operands);
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleProjDrefExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] operands)
public Instruction ImageSampleProjDrefImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleProjDrefImplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(dRef);
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleProjDrefExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleProjDrefExplicitLod, GetNewId(), resultType);
@ -1015,63 +1024,75 @@ namespace Spv.Generator
result.AddOperand(coordinate);
result.AddOperand(dRef);
result.AddOperand(imageOperands);
result.AddOperand(operands);
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageFetch(Instruction resultType, Instruction image, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] operands)
{
Instruction result = new Instruction(Op.OpImageFetch, GetNewId(), resultType);
result.AddOperand(image);
result.AddOperand(coordinate);
if (imageOperands != ImageOperandsMask.MaskNone)
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
result.AddOperand(operands);
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageGather(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction component, ImageOperandsMask imageOperands, params Instruction[] operands)
public Instruction ImageFetch(Instruction resultType, Instruction image, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageFetch, GetNewId(), resultType);
result.AddOperand(image);
result.AddOperand(coordinate);
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageGather(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction component, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageGather, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(component);
if (imageOperands != ImageOperandsMask.MaskNone)
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
result.AddOperand(operands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageDrefGather(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] operands)
public Instruction ImageDrefGather(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageDrefGather, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(dRef);
if (imageOperands != ImageOperandsMask.MaskNone)
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperands);
result.AddOperand(operands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageRead(Instruction resultType, Instruction image, Instruction coordinate, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageRead(Instruction resultType, Instruction image, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageRead, GetNewId(), resultType);
@ -1081,12 +1102,16 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageWrite(Instruction image, Instruction coordinate, Instruction texel, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageWrite(Instruction image, Instruction coordinate, Instruction texel, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageWrite);
@ -1097,6 +1122,10 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
@ -1184,7 +1213,7 @@ namespace Spv.Generator
return result;
}
public Instruction ImageSparseSampleImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSparseSampleImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseSampleImplicitLod, GetNewId(), resultType);
@ -1194,24 +1223,32 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseSampleExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands)
public Instruction ImageSparseSampleExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseSampleExplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(imageOperands);
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseSampleDrefImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSparseSampleDrefImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseSampleDrefImplicitLod, GetNewId(), resultType);
@ -1222,12 +1259,16 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseSampleDrefExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands)
public Instruction ImageSparseSampleDrefExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseSampleDrefExplicitLod, GetNewId(), resultType);
@ -1235,12 +1276,16 @@ namespace Spv.Generator
result.AddOperand(coordinate);
result.AddOperand(dRef);
result.AddOperand(imageOperands);
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseSampleProjImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSparseSampleProjImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseSampleProjImplicitLod, GetNewId(), resultType);
@ -1250,24 +1295,32 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseSampleProjExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands)
public Instruction ImageSparseSampleProjExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseSampleProjExplicitLod, GetNewId(), resultType);
result.AddOperand(sampledImage);
result.AddOperand(coordinate);
result.AddOperand(imageOperands);
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseSampleProjDrefImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSparseSampleProjDrefImplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseSampleProjDrefImplicitLod, GetNewId(), resultType);
@ -1278,12 +1331,16 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseSampleProjDrefExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands)
public Instruction ImageSparseSampleProjDrefExplicitLod(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseSampleProjDrefExplicitLod, GetNewId(), resultType);
@ -1291,12 +1348,16 @@ namespace Spv.Generator
result.AddOperand(coordinate);
result.AddOperand(dRef);
result.AddOperand(imageOperands);
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseFetch(Instruction resultType, Instruction image, Instruction coordinate, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSparseFetch(Instruction resultType, Instruction image, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseFetch, GetNewId(), resultType);
@ -1306,12 +1367,16 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseGather(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction component, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSparseGather(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction component, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseGather, GetNewId(), resultType);
@ -1322,12 +1387,16 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSparseDrefGather(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSparseDrefGather(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction dRef, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseDrefGather, GetNewId(), resultType);
@ -1338,6 +1407,10 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
@ -1353,7 +1426,7 @@ namespace Spv.Generator
return result;
}
public Instruction ImageSparseRead(Instruction resultType, Instruction image, Instruction coordinate, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSparseRead(Instruction resultType, Instruction image, Instruction coordinate, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSparseRead, GetNewId(), resultType);
@ -1363,12 +1436,16 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
}
public Instruction ImageSampleFootprintNV(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction granularity, Instruction coarse, ImageOperandsMask imageOperands = (ImageOperandsMask)int.MaxValue)
public Instruction ImageSampleFootprintNV(Instruction resultType, Instruction sampledImage, Instruction coordinate, Instruction granularity, Instruction coarse, ImageOperandsMask imageOperands, params Instruction[] imageOperandIds)
{
Instruction result = new Instruction(Op.OpImageSampleFootprintNV, GetNewId(), resultType);
@ -1380,6 +1457,10 @@ namespace Spv.Generator
{
result.AddOperand(imageOperands);
}
if (imageOperands != (ImageOperandsMask)int.MaxValue)
{
result.AddOperand(imageOperandIds);
}
AddToFunctionDefinitions(result);
return result;
@ -2721,6 +2802,15 @@ namespace Spv.Generator
return result;
}
public Instruction TerminateInvocation()
{
Instruction result = new Instruction(Op.OpTerminateInvocation);
AddToFunctionDefinitions(result);
return result;
}
// Atomic
public Instruction AtomicLoad(Instruction resultType, Instruction pointer, Instruction memory, Instruction semantics)
@ -2956,6 +3046,19 @@ namespace Spv.Generator
return result;
}
public Instruction AtomicFAddEXT(Instruction resultType, Instruction pointer, Instruction memory, Instruction semantics, Instruction value)
{
Instruction result = new Instruction(Op.OpAtomicFAddEXT, GetNewId(), resultType);
result.AddOperand(pointer);
result.AddOperand(memory);
result.AddOperand(semantics);
result.AddOperand(value);
AddToFunctionDefinitions(result);
return result;
}
// Primitive
public Instruction EmitVertex()
@ -3897,6 +4000,28 @@ namespace Spv.Generator
return result;
}
public Instruction ReadPipeBlockingINTEL(Instruction resultType, Instruction packetSize, Instruction packetAlignment)
{
Instruction result = new Instruction(Op.OpReadPipeBlockingINTEL, GetNewId(), resultType);
result.AddOperand(packetSize);
result.AddOperand(packetAlignment);
AddToFunctionDefinitions(result);
return result;
}
public Instruction WritePipeBlockingINTEL(Instruction resultType, Instruction packetSize, Instruction packetAlignment)
{
Instruction result = new Instruction(Op.OpWritePipeBlockingINTEL, GetNewId(), resultType);
result.AddOperand(packetSize);
result.AddOperand(packetAlignment);
AddToFunctionDefinitions(result);
return result;
}
// Non-Uniform
public Instruction GroupNonUniformElect(Instruction resultType, Instruction execution)
@ -4373,9 +4498,68 @@ namespace Spv.Generator
// Reserved
public Instruction TypeRayQueryProvisionalKHR()
public Instruction TraceRayKHR(Instruction accel, Instruction rayFlags, Instruction cullMask, Instruction sBTOffset, Instruction sBTStride, Instruction missIndex, Instruction rayOrigin, Instruction rayTmin, Instruction rayDirection, Instruction rayTmax, Instruction payload)
{
Instruction result = new Instruction(Op.OpTypeRayQueryProvisionalKHR, GetNewId());
Instruction result = new Instruction(Op.OpTraceRayKHR);
result.AddOperand(accel);
result.AddOperand(rayFlags);
result.AddOperand(cullMask);
result.AddOperand(sBTOffset);
result.AddOperand(sBTStride);
result.AddOperand(missIndex);
result.AddOperand(rayOrigin);
result.AddOperand(rayTmin);
result.AddOperand(rayDirection);
result.AddOperand(rayTmax);
result.AddOperand(payload);
AddToFunctionDefinitions(result);
return result;
}
public Instruction ExecuteCallableKHR(Instruction sBTIndex, Instruction callableData)
{
Instruction result = new Instruction(Op.OpExecuteCallableKHR);
result.AddOperand(sBTIndex);
result.AddOperand(callableData);
AddToFunctionDefinitions(result);
return result;
}
public Instruction ConvertUToAccelerationStructureKHR(Instruction resultType, Instruction accel)
{
Instruction result = new Instruction(Op.OpConvertUToAccelerationStructureKHR, GetNewId(), resultType);
result.AddOperand(accel);
AddToFunctionDefinitions(result);
return result;
}
public Instruction IgnoreIntersectionKHR()
{
Instruction result = new Instruction(Op.OpIgnoreIntersectionKHR);
AddToFunctionDefinitions(result);
return result;
}
public Instruction TerminateRayKHR()
{
Instruction result = new Instruction(Op.OpTerminateRayKHR);
AddToFunctionDefinitions(result);
return result;
}
public Instruction TypeRayQueryKHR()
{
Instruction result = new Instruction(Op.OpTypeRayQueryKHR, GetNewId());
AddToFunctionDefinitions(result);
@ -4526,15 +4710,6 @@ namespace Spv.Generator
return result;
}
public Instruction IgnoreIntersectionKHR()
{
Instruction result = new Instruction(Op.OpIgnoreIntersectionKHR);
AddToFunctionDefinitions(result);
return result;
}
public Instruction TerminateRayNV()
{
Instruction result = new Instruction(Op.OpTerminateRayNV);
@ -4544,15 +4719,6 @@ namespace Spv.Generator
return result;
}
public Instruction TerminateRayKHR()
{
Instruction result = new Instruction(Op.OpTerminateRayKHR);
AddToFunctionDefinitions(result);
return result;
}
public Instruction TraceNV(Instruction accel, Instruction rayFlags, Instruction cullMask, Instruction sBTOffset, Instruction sBTStride, Instruction missIndex, Instruction rayOrigin, Instruction rayTmin, Instruction rayDirection, Instruction rayTmax, Instruction payloadId)
{
Instruction result = new Instruction(Op.OpTraceNV);
@ -4573,26 +4739,6 @@ namespace Spv.Generator
return result;
}
public Instruction TraceRayKHR(Instruction accel, Instruction rayFlags, Instruction cullMask, Instruction sBTOffset, Instruction sBTStride, Instruction missIndex, Instruction rayOrigin, Instruction rayTmin, Instruction rayDirection, Instruction rayTmax, Instruction payloadId)
{
Instruction result = new Instruction(Op.OpTraceRayKHR);
result.AddOperand(accel);
result.AddOperand(rayFlags);
result.AddOperand(cullMask);
result.AddOperand(sBTOffset);
result.AddOperand(sBTStride);
result.AddOperand(missIndex);
result.AddOperand(rayOrigin);
result.AddOperand(rayTmin);
result.AddOperand(rayDirection);
result.AddOperand(rayTmax);
result.AddOperand(payloadId);
AddToFunctionDefinitions(result);
return result;
}
public Instruction TypeAccelerationStructureNV()
{
Instruction result = new Instruction(Op.OpTypeAccelerationStructureNV, GetNewId());
@ -4622,17 +4768,6 @@ namespace Spv.Generator
return result;
}
public Instruction ExecuteCallableKHR(Instruction sBTIndex, Instruction callableDataId)
{
Instruction result = new Instruction(Op.OpExecuteCallableKHR);
result.AddOperand(sBTIndex);
result.AddOperand(callableDataId);
AddToFunctionDefinitions(result);
return result;
}
public Instruction TypeCooperativeMatrixNV(Instruction componentType, Instruction execution, Instruction rows, Instruction columns)
{
Instruction result = new Instruction(Op.OpTypeCooperativeMatrixNV, GetNewId());
@ -4889,6 +5024,27 @@ namespace Spv.Generator
return result;
}
public Instruction LoopControlINTEL(params LiteralInteger[] loopControlParameters)
{
Instruction result = new Instruction(Op.OpLoopControlINTEL);
result.AddOperand(loopControlParameters);
AddToFunctionDefinitions(result);
return result;
}
public Instruction FPGARegINTEL(Instruction resultType, Instruction resultObj, Instruction input)
{
Instruction result = new Instruction(Op.OpFPGARegINTEL, GetNewId(), resultType);
result.AddOperand(resultObj);
result.AddOperand(input);
AddToFunctionDefinitions(result);
return result;
}
public Instruction RayQueryGetRayTMinKHR(Instruction resultType, Instruction rayQuery)
{
Instruction result = new Instruction(Op.OpRayQueryGetRayTMinKHR, GetNewId(), resultType);

441
Spv.Generator/Autogenerated/GlslStd450Grammar.cs Normal file
View file

@ -0,0 +1,441 @@
// AUTOGENERATED: DO NOT EDIT
// Last update date: 2021-01-06 23:02:26.955269
#region Grammar License
// Copyright (c) 2014-2016 The Khronos Group Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and/or associated documentation files (the "Materials"),
// to deal in the Materials without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Materials, and to permit persons to whom the
// Materials are furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Materials.
//
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
//
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
// IN THE MATERIALS.
#endregion
using static Spv.Specification;
namespace Spv.Generator
{
public partial class Module
{
public Instruction GlslRound(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 1, x);
}
public Instruction GlslRoundEven(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 2, x);
}
public Instruction GlslTrunc(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 3, x);
}
public Instruction GlslFAbs(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 4, x);
}
public Instruction GlslSAbs(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 5, x);
}
public Instruction GlslFSign(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 6, x);
}
public Instruction GlslSSign(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 7, x);
}
public Instruction GlslFloor(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 8, x);
}
public Instruction GlslCeil(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 9, x);
}
public Instruction GlslFract(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 10, x);
}
public Instruction GlslRadians(Instruction resultType, Instruction degrees)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 11, degrees);
}
public Instruction GlslDegrees(Instruction resultType, Instruction radians)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 12, radians);
}
public Instruction GlslSin(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 13, x);
}
public Instruction GlslCos(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 14, x);
}
public Instruction GlslTan(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 15, x);
}
public Instruction GlslAsin(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 16, x);
}
public Instruction GlslAcos(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 17, x);
}
public Instruction GlslAtan(Instruction resultType, Instruction y_over_x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 18, y_over_x);
}
public Instruction GlslSinh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 19, x);
}
public Instruction GlslCosh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 20, x);
}
public Instruction GlslTanh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 21, x);
}
public Instruction GlslAsinh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 22, x);
}
public Instruction GlslAcosh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 23, x);
}
public Instruction GlslAtanh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 24, x);
}
public Instruction GlslAtan2(Instruction resultType, Instruction y, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 25, y, x);
}
public Instruction GlslPow(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 26, x, y);
}
public Instruction GlslExp(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 27, x);
}
public Instruction GlslLog(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 28, x);
}
public Instruction GlslExp2(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 29, x);
}
public Instruction GlslLog2(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 30, x);
}
public Instruction GlslSqrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 31, x);
}
public Instruction GlslInverseSqrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 32, x);
}
public Instruction GlslDeterminant(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 33, x);
}
public Instruction GlslMatrixInverse(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 34, x);
}
public Instruction GlslModf(Instruction resultType, Instruction x, Instruction i)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 35, x, i);
}
public Instruction GlslModfStruct(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 36, x);
}
public Instruction GlslFMin(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 37, x, y);
}
public Instruction GlslUMin(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 38, x, y);
}
public Instruction GlslSMin(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 39, x, y);
}
public Instruction GlslFMax(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 40, x, y);
}
public Instruction GlslUMax(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 41, x, y);
}
public Instruction GlslSMax(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 42, x, y);
}
public Instruction GlslFClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 43, x, minVal, maxVal);
}
public Instruction GlslUClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 44, x, minVal, maxVal);
}
public Instruction GlslSClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 45, x, minVal, maxVal);
}
public Instruction GlslFMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 46, x, y, a);
}
public Instruction GlslIMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 47, x, y, a);
}
public Instruction GlslStep(Instruction resultType, Instruction edge, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 48, edge, x);
}
public Instruction GlslSmoothStep(Instruction resultType, Instruction edge0, Instruction edge1, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 49, edge0, edge1, x);
}
public Instruction GlslFma(Instruction resultType, Instruction a, Instruction b, Instruction c)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 50, a, b, c);
}
public Instruction GlslFrexp(Instruction resultType, Instruction x, Instruction exp)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 51, x, exp);
}
public Instruction GlslFrexpStruct(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 52, x);
}
public Instruction GlslLdexp(Instruction resultType, Instruction x, Instruction exp)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 53, x, exp);
}
public Instruction GlslPackSnorm4x8(Instruction resultType, Instruction v)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 54, v);
}
public Instruction GlslPackUnorm4x8(Instruction resultType, Instruction v)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 55, v);
}
public Instruction GlslPackSnorm2x16(Instruction resultType, Instruction v)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 56, v);
}
public Instruction GlslPackUnorm2x16(Instruction resultType, Instruction v)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 57, v);
}
public Instruction GlslPackHalf2x16(Instruction resultType, Instruction v)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 58, v);
}
public Instruction GlslPackDouble2x32(Instruction resultType, Instruction v)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 59, v);
}
public Instruction GlslUnpackSnorm2x16(Instruction resultType, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 60, p);
}
public Instruction GlslUnpackUnorm2x16(Instruction resultType, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 61, p);
}
public Instruction GlslUnpackHalf2x16(Instruction resultType, Instruction v)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 62, v);
}
public Instruction GlslUnpackSnorm4x8(Instruction resultType, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 63, p);
}
public Instruction GlslUnpackUnorm4x8(Instruction resultType, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 64, p);
}
public Instruction GlslUnpackDouble2x32(Instruction resultType, Instruction v)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 65, v);
}
public Instruction GlslLength(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 66, x);
}
public Instruction GlslDistance(Instruction resultType, Instruction p0, Instruction p1)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 67, p0, p1);
}
public Instruction GlslCross(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 68, x, y);
}
public Instruction GlslNormalize(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 69, x);
}
public Instruction GlslFaceForward(Instruction resultType, Instruction n, Instruction i, Instruction nref)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 70, n, i, nref);
}
public Instruction GlslReflect(Instruction resultType, Instruction i, Instruction n)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 71, i, n);
}
public Instruction GlslRefract(Instruction resultType, Instruction i, Instruction n, Instruction eta)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 72, i, n, eta);
}
public Instruction GlslFindILsb(Instruction resultType, Instruction value)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 73, value);
}
public Instruction GlslFindSMsb(Instruction resultType, Instruction value)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 74, value);
}
public Instruction GlslFindUMsb(Instruction resultType, Instruction value)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 75, value);
}
public Instruction GlslInterpolateAtCentroid(Instruction resultType, Instruction interpolant)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 76, interpolant);
}
public Instruction GlslInterpolateAtSample(Instruction resultType, Instruction interpolant, Instruction sample)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 77, interpolant, sample);
}
public Instruction GlslInterpolateAtOffset(Instruction resultType, Instruction interpolant, Instruction offset)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 78, interpolant, offset);
}
public Instruction GlslNMin(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 79, x, y);
}
public Instruction GlslNMax(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 80, x, y);
}
public Instruction GlslNClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
{
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 81, x, minVal, maxVal);
}
}
}

841
Spv.Generator/Autogenerated/OpenClGrammar.cs Normal file
View file

@ -0,0 +1,841 @@
// AUTOGENERATED: DO NOT EDIT
// Last update date: 2021-01-06 23:02:27.020534
#region Grammar License
// Copyright (c) 2014-2016 The Khronos Group Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and/or associated documentation files (the "Materials"),
// to deal in the Materials without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Materials, and to permit persons to whom the
// Materials are furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Materials.
//
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
//
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
// IN THE MATERIALS.
#endregion
using static Spv.Specification;
namespace Spv.Generator
{
public partial class Module
{
public Instruction OpenClAcos(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 0, x);
}
public Instruction OpenClAcosh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 1, x);
}
public Instruction OpenClAcospi(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 2, x);
}
public Instruction OpenClAsin(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 3, x);
}
public Instruction OpenClAsinh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 4, x);
}
public Instruction OpenClAsinpi(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 5, x);
}
public Instruction OpenClAtan(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 6, x);
}
public Instruction OpenClAtan2(Instruction resultType, Instruction y, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 7, y, x);
}
public Instruction OpenClAtanh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 8, x);
}
public Instruction OpenClAtanpi(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 9, x);
}
public Instruction OpenClAtan2pi(Instruction resultType, Instruction y, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 10, y, x);
}
public Instruction OpenClCbrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 11, x);
}
public Instruction OpenClCeil(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 12, x);
}
public Instruction OpenClCopysign(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 13, x, y);
}
public Instruction OpenClCos(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 14, x);
}
public Instruction OpenClCosh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 15, x);
}
public Instruction OpenClCospi(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 16, x);
}
public Instruction OpenClErfc(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 17, x);
}
public Instruction OpenClErf(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 18, x);
}
public Instruction OpenClExp(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 19, x);
}
public Instruction OpenClExp2(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 20, x);
}
public Instruction OpenClExp10(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 21, x);
}
public Instruction OpenClExpm1(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 22, x);
}
public Instruction OpenClFabs(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 23, x);
}
public Instruction OpenClFdim(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 24, x, y);
}
public Instruction OpenClFloor(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 25, x);
}
public Instruction OpenClFma(Instruction resultType, Instruction a, Instruction b, Instruction c)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 26, a, b, c);
}
public Instruction OpenClFmax(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 27, x, y);
}
public Instruction OpenClFmin(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 28, x, y);
}
public Instruction OpenClFmod(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 29, x, y);
}
public Instruction OpenClFract(Instruction resultType, Instruction x, Instruction ptr)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 30, x, ptr);
}
public Instruction OpenClFrexp(Instruction resultType, Instruction x, Instruction exp)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 31, x, exp);
}
public Instruction OpenClHypot(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 32, x, y);
}
public Instruction OpenClIlogb(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 33, x);
}
public Instruction OpenClLdexp(Instruction resultType, Instruction x, Instruction k)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 34, x, k);
}
public Instruction OpenClLgamma(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 35, x);
}
public Instruction OpenClLgamma_r(Instruction resultType, Instruction x, Instruction signp)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 36, x, signp);
}
public Instruction OpenClLog(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 37, x);
}
public Instruction OpenClLog2(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 38, x);
}
public Instruction OpenClLog10(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 39, x);
}
public Instruction OpenClLog1p(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 40, x);
}
public Instruction OpenClLogb(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 41, x);
}
public Instruction OpenClMad(Instruction resultType, Instruction a, Instruction b, Instruction c)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 42, a, b, c);
}
public Instruction OpenClMaxmag(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 43, x, y);
}
public Instruction OpenClMinmag(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 44, x, y);
}
public Instruction OpenClModf(Instruction resultType, Instruction x, Instruction iptr)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 45, x, iptr);
}
public Instruction OpenClNan(Instruction resultType, Instruction nancode)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 46, nancode);
}
public Instruction OpenClNextafter(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 47, x, y);
}
public Instruction OpenClPow(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 48, x, y);
}
public Instruction OpenClPown(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 49, x, y);
}
public Instruction OpenClPowr(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 50, x, y);
}
public Instruction OpenClRemainder(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 51, x, y);
}
public Instruction OpenClRemquo(Instruction resultType, Instruction x, Instruction y, Instruction quo)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 52, x, y, quo);
}
public Instruction OpenClRint(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 53, x);
}
public Instruction OpenClRootn(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 54, x, y);
}
public Instruction OpenClRound(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 55, x);
}
public Instruction OpenClRsqrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 56, x);
}
public Instruction OpenClSin(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 57, x);
}
public Instruction OpenClSincos(Instruction resultType, Instruction x, Instruction cosval)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 58, x, cosval);
}
public Instruction OpenClSinh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 59, x);
}
public Instruction OpenClSinpi(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 60, x);
}
public Instruction OpenClSqrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 61, x);
}
public Instruction OpenClTan(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 62, x);
}
public Instruction OpenClTanh(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 63, x);
}
public Instruction OpenClTanpi(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 64, x);
}
public Instruction OpenClTgamma(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 65, x);
}
public Instruction OpenClTrunc(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 66, x);
}
public Instruction OpenClHalf_cos(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 67, x);
}
public Instruction OpenClHalf_divide(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 68, x, y);
}
public Instruction OpenClHalf_exp(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 69, x);
}
public Instruction OpenClHalf_exp2(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 70, x);
}
public Instruction OpenClHalf_exp10(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 71, x);
}
public Instruction OpenClHalf_log(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 72, x);
}
public Instruction OpenClHalf_log2(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 73, x);
}
public Instruction OpenClHalf_log10(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 74, x);
}
public Instruction OpenClHalf_powr(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 75, x, y);
}
public Instruction OpenClHalf_recip(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 76, x);
}
public Instruction OpenClHalf_rsqrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 77, x);
}
public Instruction OpenClHalf_sin(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 78, x);
}
public Instruction OpenClHalf_sqrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 79, x);
}
public Instruction OpenClHalf_tan(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 80, x);
}
public Instruction OpenClNative_cos(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 81, x);
}
public Instruction OpenClNative_divide(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 82, x, y);
}
public Instruction OpenClNative_exp(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 83, x);
}
public Instruction OpenClNative_exp2(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 84, x);
}
public Instruction OpenClNative_exp10(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 85, x);
}
public Instruction OpenClNative_log(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 86, x);
}
public Instruction OpenClNative_log2(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 87, x);
}
public Instruction OpenClNative_log10(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 88, x);
}
public Instruction OpenClNative_powr(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 89, x, y);
}
public Instruction OpenClNative_recip(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 90, x);
}
public Instruction OpenClNative_rsqrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 91, x);
}
public Instruction OpenClNative_sin(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 92, x);
}
public Instruction OpenClNative_sqrt(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 93, x);
}
public Instruction OpenClNative_tan(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 94, x);
}
public Instruction OpenClS_abs(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 141, x);
}
public Instruction OpenClS_abs_diff(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 142, x, y);
}
public Instruction OpenClS_add_sat(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 143, x, y);
}
public Instruction OpenClU_add_sat(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 144, x, y);
}
public Instruction OpenClS_hadd(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 145, x, y);
}
public Instruction OpenClU_hadd(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 146, x, y);
}
public Instruction OpenClS_rhadd(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 147, x, y);
}
public Instruction OpenClU_rhadd(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 148, x, y);
}
public Instruction OpenClS_clamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 149, x, minval, maxval);
}
public Instruction OpenClU_clamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 150, x, minval, maxval);
}
public Instruction OpenClClz(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 151, x);
}
public Instruction OpenClCtz(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 152, x);
}
public Instruction OpenClS_mad_hi(Instruction resultType, Instruction a, Instruction b, Instruction c)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 153, a, b, c);
}
public Instruction OpenClU_mad_sat(Instruction resultType, Instruction x, Instruction y, Instruction z)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 154, x, y, z);
}
public Instruction OpenClS_mad_sat(Instruction resultType, Instruction x, Instruction y, Instruction z)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 155, x, y, z);
}
public Instruction OpenClS_max(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 156, x, y);
}
public Instruction OpenClU_max(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 157, x, y);
}
public Instruction OpenClS_min(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 158, x, y);
}
public Instruction OpenClU_min(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 159, x, y);
}
public Instruction OpenClS_mul_hi(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 160, x, y);
}
public Instruction OpenClRotate(Instruction resultType, Instruction v, Instruction i)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 161, v, i);
}
public Instruction OpenClS_sub_sat(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 162, x, y);
}
public Instruction OpenClU_sub_sat(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 163, x, y);
}
public Instruction OpenClU_upsample(Instruction resultType, Instruction hi, Instruction lo)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 164, hi, lo);
}
public Instruction OpenClS_upsample(Instruction resultType, Instruction hi, Instruction lo)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 165, hi, lo);
}
public Instruction OpenClPopcount(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 166, x);
}
public Instruction OpenClS_mad24(Instruction resultType, Instruction x, Instruction y, Instruction z)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 167, x, y, z);
}
public Instruction OpenClU_mad24(Instruction resultType, Instruction x, Instruction y, Instruction z)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 168, x, y, z);
}
public Instruction OpenClS_mul24(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 169, x, y);
}
public Instruction OpenClU_mul24(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 170, x, y);
}
public Instruction OpenClU_abs(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 201, x);
}
public Instruction OpenClU_abs_diff(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 202, x, y);
}
public Instruction OpenClU_mul_hi(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 203, x, y);
}
public Instruction OpenClU_mad_hi(Instruction resultType, Instruction a, Instruction b, Instruction c)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 204, a, b, c);
}
public Instruction OpenClFclamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 95, x, minval, maxval);
}
public Instruction OpenClDegrees(Instruction resultType, Instruction radians)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 96, radians);
}
public Instruction OpenClFmax_common(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 97, x, y);
}
public Instruction OpenClFmin_common(Instruction resultType, Instruction x, Instruction y)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 98, x, y);
}
public Instruction OpenClMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 99, x, y, a);
}
public Instruction OpenClRadians(Instruction resultType, Instruction degrees)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 100, degrees);
}
public Instruction OpenClStep(Instruction resultType, Instruction edge, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 101, edge, x);
}
public Instruction OpenClSmoothstep(Instruction resultType, Instruction edge0, Instruction edge1, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 102, edge0, edge1, x);
}
public Instruction OpenClSign(Instruction resultType, Instruction x)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 103, x);
}
public Instruction OpenClCross(Instruction resultType, Instruction p0, Instruction p1)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 104, p0, p1);
}
public Instruction OpenClDistance(Instruction resultType, Instruction p0, Instruction p1)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 105, p0, p1);
}
public Instruction OpenClLength(Instruction resultType, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 106, p);
}
public Instruction OpenClNormalize(Instruction resultType, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 107, p);
}
public Instruction OpenClFast_distance(Instruction resultType, Instruction p0, Instruction p1)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 108, p0, p1);
}
public Instruction OpenClFast_length(Instruction resultType, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 109, p);
}
public Instruction OpenClFast_normalize(Instruction resultType, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 110, p);
}
public Instruction OpenClBitselect(Instruction resultType, Instruction a, Instruction b, Instruction c)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 186, a, b, c);
}
public Instruction OpenClSelect(Instruction resultType, Instruction a, Instruction b, Instruction c)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 187, a, b, c);
}
public Instruction OpenClVloadn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 171, offset, p, n);
}
public Instruction OpenClVstoren(Instruction resultType, Instruction data, Instruction offset, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 172, data, offset, p);
}
public Instruction OpenClVload_half(Instruction resultType, Instruction offset, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 173, offset, p);
}
public Instruction OpenClVload_halfn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 174, offset, p, n);
}
public Instruction OpenClVstore_half(Instruction resultType, Instruction data, Instruction offset, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 175, data, offset, p);
}
public Instruction OpenClVstore_half_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 176, data, offset, p, LiteralInteger.CreateForEnum(mode));
}
public Instruction OpenClVstore_halfn(Instruction resultType, Instruction data, Instruction offset, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 177, data, offset, p);
}
public Instruction OpenClVstore_halfn_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 178, data, offset, p, LiteralInteger.CreateForEnum(mode));
}
public Instruction OpenClVloada_halfn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 179, offset, p, n);
}
public Instruction OpenClVstorea_halfn(Instruction resultType, Instruction data, Instruction offset, Instruction p)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 180, data, offset, p);
}
public Instruction OpenClVstorea_halfn_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 181, data, offset, p, LiteralInteger.CreateForEnum(mode));
}
public Instruction OpenClShuffle(Instruction resultType, Instruction x, Instruction shufflemask)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 182, x, shufflemask);
}
public Instruction OpenClShuffle2(Instruction resultType, Instruction x, Instruction y, Instruction shufflemask)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 183, x, y, shufflemask);
}
public Instruction OpenClPrefetch(Instruction resultType, Instruction ptr, Instruction numelements)
{
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 185, ptr, numelements);
}
}
}

10
SpvGen/Instruction.cs → Spv.Generator/Instruction.cs
View file

@ -188,16 +188,16 @@ namespace Spv.Generator
return result;
}
public bool EqualsResultType(Instruction cmpObj)
{
return _resultType.Opcode == cmpObj._resultType.Opcode && _resultType.EqualsContent(cmpObj._resultType);
}
public bool EqualsContent(Instruction cmpObj)
{
return _operands.SequenceEqual(cmpObj._operands);
}
public bool EqualsResultType(Instruction cmpObj)
{
return _resultType.Opcode == cmpObj._resultType.Opcode && _resultType.EqualsContent(cmpObj._resultType);
}
public override int GetHashCode()
{
return HashCode.Combine(Opcode, Id, _resultType, _operands);

0
SpvGen/LICENSE → Spv.Generator/LICENSE
View file

0
SpvGen/LiteralInteger.cs → Spv.Generator/LiteralInteger.cs
View file

0
SpvGen/LiteralString.cs → Spv.Generator/LiteralString.cs
View file

31
SpvGen/Module.cs → Spv.Generator/Module.cs
View file

@ -2,6 +2,7 @@
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using static Spv.Specification;
namespace Spv.Generator
@ -164,6 +165,7 @@ namespace Spv.Generator
AddToFunctionDefinitions(label);
}
public void AddLocalVariable(Instruction variable)
{
// TODO: ensure it has the local modifier
@ -195,7 +197,7 @@ namespace Spv.Generator
foreach (Instruction global in _globals)
{
if (global.Opcode == constant.Opcode && global.EqualsResultType(constant) && global.EqualsContent(constant))
if (global.Opcode == constant.Opcode && global.EqualsContent(constant) && global.EqualsResultType(constant))
{
// update the duplicate instance to use the good id so it ends up being encoded right.
constant.SetId(global.Id);
@ -209,21 +211,40 @@ namespace Spv.Generator
_globals.Add(constant);
}
public Instruction ExtInst(Instruction resultType, Instruction set, LiteralInteger instruction, params Operand[] parameters)
{
Instruction result = new Instruction(Op.OpExtInst, GetNewId(), resultType);
result.AddOperand(set);
result.AddOperand(instruction);
result.AddOperand(parameters);
AddToFunctionDefinitions(result);
return result;
}
public void SetMemoryModel(AddressingModel addressingModel, MemoryModel memoryModel)
{
_addressingModel = addressingModel;
_memoryModel = memoryModel;
}
protected virtual void Construct()
// TODO: Found a way to make the auto generate one used.
public Instruction OpenClPrintf(Instruction resultType, Instruction format, params Instruction[] additionalarguments)
{
throw new NotSupportedException("Construct should be overriden.");
Instruction result = new Instruction(Op.OpExtInst, GetNewId(), resultType);
result.AddOperand(AddExtInstImport("OpenCL.std"));
result.AddOperand((LiteralInteger)184);
result.AddOperand(format);
result.AddOperand(additionalarguments);
AddToFunctionDefinitions(result);
return result;
}
public byte[] Generate()
{
Construct();
using (MemoryStream stream = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(stream);

0
SpvGen/Operand.cs → Spv.Generator/Operand.cs
View file

0
SpvGen/OperandType.cs → Spv.Generator/OperandType.cs
View file

7
Spv.Generator/Spv.Generator.csproj Normal file
View file

@ -0,0 +1,7 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
</PropertyGroup>
</Project>

94
SpvGen/Autogenerated/spirv.cs → Spv.Generator/spirv.cs
View file

@ -1,4 +1,4 @@
// Copyright (c) 2014-2020 The Khronos Group Inc.
// Copyright (c) 2014-2020 The Khronos Group Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and/or associated documentation files (the "Materials"),
@ -49,7 +49,7 @@ namespace Spv
{
public const uint MagicNumber = 0x07230203;
public const uint Version = 0x00010500;
public const uint Revision = 3;
public const uint Revision = 4;
public const uint OpCodeMask = 0xffff;
public const uint WordCountShift = 16;
@ -164,6 +164,10 @@ namespace Spv
SampleInterlockUnorderedEXT = 5369,
ShadingRateInterlockOrderedEXT = 5370,
ShadingRateInterlockUnorderedEXT = 5371,
MaxWorkgroupSizeINTEL = 5893,
MaxWorkDimINTEL = 5894,
NoGlobalOffsetINTEL = 5895,
NumSIMDWorkitemsINTEL = 5896,
}
public enum StorageClass
@ -195,6 +199,7 @@ namespace Spv
ShaderRecordBufferNV = 5343,
PhysicalStorageBuffer = 5349,
PhysicalStorageBufferEXT = 5349,
CodeSectionINTEL = 5605,
}
public enum Dim
@ -265,6 +270,8 @@ namespace Spv
Rg8ui = 37,
R16ui = 38,
R8ui = 39,
R64ui = 40,
R64i = 41,
}
public enum ImageChannelOrder
@ -475,11 +482,24 @@ namespace Spv
RestrictPointerEXT = 5355,
AliasedPointer = 5356,
AliasedPointerEXT = 5356,
ReferencedIndirectlyINTEL = 5602,
CounterBuffer = 5634,
HlslCounterBufferGOOGLE = 5634,
HlslSemanticGOOGLE = 5635,
UserSemantic = 5635,
UserTypeGOOGLE = 5636,
RegisterINTEL = 5825,
MemoryINTEL = 5826,
NumbanksINTEL = 5827,
BankwidthINTEL = 5828,
MaxPrivateCopiesINTEL = 5829,
SinglepumpINTEL = 5830,
DoublepumpINTEL = 5831,
MaxReplicatesINTEL = 5832,
SimpleDualPortINTEL = 5833,
MergeINTEL = 5834,
BankBitsINTEL = 5835,
ForcePow2DepthINTEL = 5836,
}
public enum BuiltIn
@ -538,8 +558,10 @@ namespace Spv
BaseVertex = 4424,
BaseInstance = 4425,
DrawIndex = 4426,
PrimitiveShadingRateKHR = 4432,
DeviceIndex = 4438,
ViewIndex = 4440,
ShadingRateKHR = 4444,
BaryCoordNoPerspAMD = 4992,
BaryCoordNoPerspCentroidAMD = 4993,
BaryCoordNoPerspSampleAMD = 4994,
@ -590,7 +612,6 @@ namespace Spv
ObjectToWorldNV = 5330,
WorldToObjectKHR = 5331,
WorldToObjectNV = 5331,
HitTKHR = 5332,
HitTNV = 5332,
HitKindKHR = 5333,
HitKindNV = 5333,
@ -627,6 +648,13 @@ namespace Spv
IterationMultiple = 6,
PeelCount = 7,
PartialCount = 8,
InitiationIntervalINTEL = 16,
MaxConcurrencyINTEL = 17,
DependencyArrayINTEL = 18,
PipelineEnableINTEL = 19,
LoopCoalesceINTEL = 20,
MaxInterleavingINTEL = 21,
SpeculatedIterationsINTEL = 22,
}
public enum LoopControlMask
@ -641,6 +669,13 @@ namespace Spv
IterationMultiple = 0x00000040,
PeelCount = 0x00000080,
PartialCount = 0x00000100,
InitiationIntervalINTEL = 0x00010000,
MaxConcurrencyINTEL = 0x00020000,
DependencyArrayINTEL = 0x00040000,
PipelineEnableINTEL = 0x00080000,
LoopCoalesceINTEL = 0x00100000,
MaxInterleavingINTEL = 0x00200000,
SpeculatedIterationsINTEL = 0x00400000,
}
public enum FunctionControlShift
@ -842,6 +877,7 @@ namespace Spv
GroupNonUniformQuad = 68,
ShaderLayer = 69,
ShaderViewportIndex = 70,
FragmentShadingRateKHR = 4422,
SubgroupBallotKHR = 4423,
DrawParameters = 4427,
SubgroupVoteKHR = 4431,
@ -866,12 +902,15 @@ namespace Spv
RoundingModeRTE = 4467,
RoundingModeRTZ = 4468,
RayQueryProvisionalKHR = 4471,
RayTraversalPrimitiveCullingProvisionalKHR = 4478,
RayQueryKHR = 4472,
RayTraversalPrimitiveCullingKHR = 4478,
RayTracingKHR = 4479,
Float16ImageAMD = 5008,
ImageGatherBiasLodAMD = 5009,
FragmentMaskAMD = 5010,
StencilExportEXT = 5013,
ImageReadWriteLodAMD = 5015,
Int64ImageEXT = 5016,
ShaderClockKHR = 5055,
SampleMaskOverrideCoverageNV = 5249,
GeometryShaderPassthroughNV = 5251,
@ -932,9 +971,20 @@ namespace Spv
SubgroupImageBlockIOINTEL = 5570,
SubgroupImageMediaBlockIOINTEL = 5579,
IntegerFunctions2INTEL = 5584,
FunctionPointersINTEL = 5603,
IndirectReferencesINTEL = 5604,
SubgroupAvcMotionEstimationINTEL = 5696,
SubgroupAvcMotionEstimationIntraINTEL = 5697,
SubgroupAvcMotionEstimationChromaINTEL = 5698,
FPGAMemoryAttributesINTEL = 5824,
UnstructuredLoopControlsINTEL = 5886,
FPGALoopControlsINTEL = 5888,
KernelAttributesINTEL = 5892,
FPGAKernelAttributesINTEL = 5897,
BlockingPipesINTEL = 5945,
FPGARegINTEL = 5948,
AtomicFloat32AddEXT = 6033,
AtomicFloat64AddEXT = 6034,
}
public enum RayFlagsShift
@ -985,6 +1035,23 @@ namespace Spv
RayQueryCandidateIntersectionAABBKHR = 1,
}
public enum FragmentShadingRateShift
{
Vertical2Pixels = 0,
Vertical4Pixels = 1,
Horizontal2Pixels = 2,
Horizontal4Pixels = 3,
}
public enum FragmentShadingRateMask
{
MaskNone = 0,
Vertical2Pixels = 0x00000001,
Vertical4Pixels = 0x00000002,
Horizontal2Pixels = 0x00000004,
Horizontal4Pixels = 0x00000008,
}
public enum Op
{
OpNop = 0,
@ -1331,13 +1398,19 @@ namespace Spv
OpPtrEqual = 401,
OpPtrNotEqual = 402,
OpPtrDiff = 403,
OpTerminateInvocation = 4416,
OpSubgroupBallotKHR = 4421,
OpSubgroupFirstInvocationKHR = 4422,
OpSubgroupAllKHR = 4428,
OpSubgroupAnyKHR = 4429,
OpSubgroupAllEqualKHR = 4430,
OpSubgroupReadInvocationKHR = 4432,
OpTypeRayQueryProvisionalKHR = 4472,
OpTraceRayKHR = 4445,
OpExecuteCallableKHR = 4446,
OpConvertUToAccelerationStructureKHR = 4447,
OpIgnoreIntersectionKHR = 4448,
OpTerminateRayKHR = 4449,
OpTypeRayQueryKHR = 4472,
OpRayQueryInitializeKHR = 4473,
OpRayQueryTerminateKHR = 4474,
OpRayQueryGenerateIntersectionKHR = 4475,
@ -1360,15 +1433,11 @@ namespace Spv
OpWritePackedPrimitiveIndices4x8NV = 5299,
OpReportIntersectionKHR = 5334,
OpReportIntersectionNV = 5334,
OpIgnoreIntersectionKHR = 5335,
OpIgnoreIntersectionNV = 5335,
OpTerminateRayKHR = 5336,
OpTerminateRayNV = 5336,
OpTraceNV = 5337,
OpTraceRayKHR = 5337,
OpTypeAccelerationStructureKHR = 5341,
OpTypeAccelerationStructureNV = 5341,
OpExecuteCallableKHR = 5344,
OpExecuteCallableNV = 5344,
OpTypeCooperativeMatrixNV = 5358,
OpCooperativeMatrixLoadNV = 5359,
@ -1403,6 +1472,8 @@ namespace Spv
OpUSubSatINTEL = 5596,
OpIMul32x16INTEL = 5597,
OpUMul32x16INTEL = 5598,
OpFunctionPointerINTEL = 5600,
OpFunctionPointerCallINTEL = 5601,
OpDecorateString = 5632,
OpDecorateStringGOOGLE = 5632,
OpMemberDecorateString = 5633,
@ -1525,6 +1596,10 @@ namespace Spv
OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
OpLoopControlINTEL = 5887,
OpReadPipeBlockingINTEL = 5946,
OpWritePipeBlockingINTEL = 5947,
OpFPGARegINTEL = 5949,
OpRayQueryGetRayTMinKHR = 6016,
OpRayQueryGetRayFlagsKHR = 6017,
OpRayQueryGetIntersectionTKHR = 6018,
@ -1542,6 +1617,7 @@ namespace Spv
OpRayQueryGetWorldRayOriginKHR = 6030,
OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
OpAtomicFAddEXT = 6035,
}
}
}

12
SpvGen/Spv.Generator.csproj
View file

@ -1,12 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Library</OutputType>
<TargetFramework>netcoreapp3.1</TargetFramework>
<LangVersion>8.0</LangVersion>
<RuntimeIdentifiers>win-x64;osx-x64;linux-x64</RuntimeIdentifiers>
<ApplicationIcon />
<StartupObject />
</PropertyGroup>
</Project>