BeeEngine/glslang-zig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add support for GL_NV_shader_invocation_reorder. (#3054)

Browse source
This commit is contained in:
alelenv 2022-12-09 12:19:08 -08:00 • committed by GitHub
parent 19d816c8c9
commit 4fc43cd3c1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
30 changed files with 7478 additions and 5636 deletions
Download patch file Download diff file Expand all files Collapse all files

3
glslang/Include/BaseTypes.h
View file

@ -65,6 +65,7 @@ enum TBasicType {
EbtAccStruct,
EbtReference,
EbtRayQuery,
EbtHitObjectNV,
#ifndef GLSLANG_WEB
// SPIR-V type defined by spirv_type
EbtSpirvType,
@ -104,6 +105,7 @@ enum TStorageQualifier {
EvqHitAttr,
EvqCallableData,
EvqCallableDataIn,
EvqHitObjectAttrNV,
EvqtaskPayloadSharedEXT,
@ -375,6 +377,7 @@ __inline const char* GetStorageQualifierString(TStorageQualifier q)
case EvqCallableData: return "callableDataNV"; break;
case EvqCallableDataIn: return "callableDataInNV"; break;
case EvqtaskPayloadSharedEXT: return "taskPayloadSharedEXT"; break;
case EvqHitObjectAttrNV:return "hitObjectAttributeNV"; break;
default: return "unknown qualifier";
}
}

14
glslang/Include/Types.h
View file

@ -869,6 +869,9 @@ public:
bool isAnyCallable() const {
return storage == EvqCallableData || storage == EvqCallableDataIn;
}
bool isHitObjectAttrNV() const {
return storage == EvqHitObjectAttrNV;
}
// True if this type of IO is supposed to be arrayed with extra level for per-vertex data
bool isArrayedIo(EShLanguage language) const
@ -904,6 +907,7 @@ public:
// -2048 as the default value indicating layoutSecondaryViewportRelative is not set
layoutSecondaryViewportRelativeOffset = -2048;
layoutShaderRecord = false;
layoutHitObjectShaderRecordNV = false;
layoutBindlessSampler = false;
layoutBindlessImage = false;
layoutBufferReferenceAlign = layoutBufferReferenceAlignEnd;
@ -1005,6 +1009,7 @@ public:
bool layoutViewportRelative;
int layoutSecondaryViewportRelativeOffset;
bool layoutShaderRecord;
bool layoutHitObjectShaderRecordNV;
// GL_EXT_spirv_intrinsics
int spirvStorageClass;
@ -1134,6 +1139,7 @@ public:
TLayoutFormat getFormat() const { return layoutFormat; }
bool isPushConstant() const { return layoutPushConstant; }
bool isShaderRecord() const { return layoutShaderRecord; }
bool hasHitObjectShaderRecordNV() const { return layoutHitObjectShaderRecordNV; }
bool hasBufferReference() const { return layoutBufferReference; }
bool hasBufferReferenceAlign() const
{
@ -1913,7 +1919,8 @@ public:
}
virtual bool isOpaque() const { return basicType == EbtSampler
#ifndef GLSLANG_WEB
|| basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery
|| basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery
|| basicType == EbtHitObjectNV
#endif
; }
virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; }
@ -2314,12 +2321,17 @@ public:
appendStr(" layoutSecondaryViewportRelativeOffset=");
appendInt(qualifier.layoutSecondaryViewportRelativeOffset);
}
if (qualifier.layoutShaderRecord)
appendStr(" shaderRecordNV");
if (qualifier.layoutHitObjectShaderRecordNV)
appendStr(" hitobjectshaderrecordnv");
if (qualifier.layoutBindlessSampler)
appendStr(" layoutBindlessSampler");
if (qualifier.layoutBindlessImage)
appendStr(" layoutBindlessImage");
appendStr(")");
}
}

35
glslang/Include/intermediate.h
View file

@ -968,7 +968,42 @@ enum TOperator {
EOpRayQueryGetIntersectionObjectToWorld,
EOpRayQueryGetIntersectionWorldToObject,
//
// GL_NV_shader_invocation_reorder
//
EOpHitObjectTraceRayNV,
EOpHitObjectTraceRayMotionNV,
EOpHitObjectRecordHitNV,
EOpHitObjectRecordHitMotionNV,
EOpHitObjectRecordHitWithIndexNV,
EOpHitObjectRecordHitWithIndexMotionNV,
EOpHitObjectRecordMissNV,
EOpHitObjectRecordMissMotionNV,
EOpHitObjectRecordEmptyNV,
EOpHitObjectExecuteShaderNV,
EOpHitObjectIsEmptyNV,
EOpHitObjectIsMissNV,
EOpHitObjectIsHitNV,
EOpHitObjectGetRayTMinNV,
EOpHitObjectGetRayTMaxNV,
EOpHitObjectGetObjectRayOriginNV,
EOpHitObjectGetObjectRayDirectionNV,
EOpHitObjectGetWorldRayOriginNV,
EOpHitObjectGetWorldRayDirectionNV,
EOpHitObjectGetWorldToObjectNV,
EOpHitObjectGetObjectToWorldNV,
EOpHitObjectGetInstanceCustomIndexNV,
EOpHitObjectGetInstanceIdNV,
EOpHitObjectGetGeometryIndexNV,
EOpHitObjectGetPrimitiveIndexNV,
EOpHitObjectGetHitKindNV,
EOpHitObjectGetShaderBindingTableRecordIndexNV,
EOpHitObjectGetShaderRecordBufferHandleNV,
EOpHitObjectGetAttributesNV,
EOpHitObjectGetCurrentTimeNV,
EOpReorderThreadNV,
// HLSL operations
//

160
glslang/MachineIndependent/Initialize.cpp
View file

@ -4550,7 +4550,8 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
"\n");
}
// Builtins for GL_NV_ray_tracing/GL_NV_ray_tracing_motion_blur/GL_EXT_ray_tracing/GL_EXT_ray_query
// Builtins for GL_NV_ray_tracing/GL_NV_ray_tracing_motion_blur/GL_EXT_ray_tracing/GL_EXT_ray_query/
// GL_NV_shader_invocation_reorder
if (profile != EEsProfile && version >= 460) {
commonBuiltins.append("void rayQueryInitializeEXT(rayQueryEXT, accelerationStructureEXT, uint, uint, vec3, float, vec3, float);"
"void rayQueryTerminateEXT(rayQueryEXT);"
@ -4583,6 +4584,39 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
"void traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);"
"void executeCallableEXT(uint, int);"
"void hitObjectTraceRayNV(hitObjectNV,accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectTraceRayMotionNV(hitObjectNV,accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordHitNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectRecordHitMotionNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordHitWithIndexNV(hitObjectNV, accelerationStructureEXT,int,int,int,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectRecordHitWithIndexMotionNV(hitObjectNV, accelerationStructureEXT,int,int,int,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordMissNV(hitObjectNV,uint,vec3,float,vec3,float);"
"void hitObjectRecordMissMotionNV(hitObjectNV,uint,vec3,float,vec3,float,float);"
"void hitObjectRecordEmptyNV(hitObjectNV);"
"void hitObjectExecuteShaderNV(hitObjectNV,int);"
"bool hitObjectIsEmptyNV(hitObjectNV);"
"bool hitObjectIsMissNV(hitObjectNV);"
"bool hitObjectIsHitNV(hitObjectNV);"
"float hitObjectGetRayTMinNV(hitObjectNV);"
"float hitObjectGetRayTMaxNV(hitObjectNV);"
"vec3 hitObjectGetWorldRayOriginNV(hitObjectNV);"
"vec3 hitObjectGetWorldRayDirectionNV(hitObjectNV);"
"vec3 hitObjectGetObjectRayOriginNV(hitObjectNV);"
"vec3 hitObjectGetObjectRayDirectionNV(hitObjectNV);"
"mat4x3 hitObjectGetWorldToObjectNV(hitObjectNV);"
"mat4x3 hitObjectGetObjectToWorldNV(hitObjectNV);"
"int hitObjectGetInstanceCustomIndexNV(hitObjectNV);"
"int hitObjectGetInstanceIdNV(hitObjectNV);"
"int hitObjectGetGeometryIndexNV(hitObjectNV);"
"int hitObjectGetPrimitiveIndexNV(hitObjectNV);"
"uint hitObjectGetHitKindNV(hitObjectNV);"
"void hitObjectGetAttributesNV(hitObjectNV,int);"
"float hitObjectGetCurrentTimeNV(hitObjectNV);"
"uint hitObjectGetShaderBindingTableRecordIndexNV(hitObjectNV);"
"uvec2 hitObjectGetShaderRecordBufferHandleNV(hitObjectNV);"
"void reorderThreadNV(uint, uint);"
"void reorderThreadNV(hitObjectNV);"
"void reorderThreadNV(hitObjectNV, uint, uint);"
"\n");
stageBuiltins[EShLangIntersect].append(
"bool reportIntersectionNV(float, uint);"
@ -4598,6 +4632,36 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
"void traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);"
"void executeCallableEXT(uint, int);"
"void hitObjectTraceRayNV(hitObjectNV,accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectTraceRayMotionNV(hitObjectNV,accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordHitNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectRecordHitMotionNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordHitWithIndexNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectRecordHitWithIndexMotionNV(hitObjectNV, accelerationStructureEXT,int,int,int,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordMissNV(hitObjectNV, uint, vec3, float, vec3, float);"
"void hitObjectRecordMissMotionNV(hitObjectNV,uint,vec3,float,vec3,float,float);"
"void hitObjectRecordEmptyNV(hitObjectNV);"
"void hitObjectExecuteShaderNV(hitObjectNV, int);"
"bool hitObjectIsEmptyNV(hitObjectNV);"
"bool hitObjectIsMissNV(hitObjectNV);"
"bool hitObjectIsHitNV(hitObjectNV);"
"float hitObjectGetRayTMinNV(hitObjectNV);"
"float hitObjectGetRayTMaxNV(hitObjectNV);"
"vec3 hitObjectGetWorldRayOriginNV(hitObjectNV);"
"vec3 hitObjectGetWorldRayDirectionNV(hitObjectNV);"
"vec3 hitObjectGetObjectRayOriginNV(hitObjectNV);"
"vec3 hitObjectGetObjectRayDirectionNV(hitObjectNV);"
"mat4x3 hitObjectGetWorldToObjectNV(hitObjectNV);"
"mat4x3 hitObjectGetObjectToWorldNV(hitObjectNV);"
"int hitObjectGetInstanceCustomIndexNV(hitObjectNV);"
"int hitObjectGetInstanceIdNV(hitObjectNV);"
"int hitObjectGetGeometryIndexNV(hitObjectNV);"
"int hitObjectGetPrimitiveIndexNV(hitObjectNV);"
"uint hitObjectGetHitKindNV(hitObjectNV);"
"void hitObjectGetAttributesNV(hitObjectNV,int);"
"float hitObjectGetCurrentTimeNV(hitObjectNV);"
"uint hitObjectGetShaderBindingTableRecordIndexNV(hitObjectNV);"
"uvec2 hitObjectGetShaderRecordBufferHandleNV(hitObjectNV);"
"\n");
stageBuiltins[EShLangMiss].append(
"void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
@ -4605,6 +4669,36 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
"void traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);"
"void executeCallableEXT(uint, int);"
"void hitObjectTraceRayNV(hitObjectNV,accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectTraceRayMotionNV(hitObjectNV,accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordHitNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectRecordHitMotionNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordHitWithIndexNV(hitObjectNV,accelerationStructureEXT,int,int,int,uint,uint,vec3,float,vec3,float,int);"
"void hitObjectRecordHitWithIndexMotionNV(hitObjectNV, accelerationStructureEXT,int,int,int,uint,uint,vec3,float,vec3,float,float,int);"
"void hitObjectRecordMissNV(hitObjectNV, uint, vec3, float, vec3, float);"
"void hitObjectRecordMissMotionNV(hitObjectNV,uint,vec3,float,vec3,float,float);"
"void hitObjectRecordEmptyNV(hitObjectNV);"
"void hitObjectExecuteShaderNV(hitObjectNV, int);"
"bool hitObjectIsEmptyNV(hitObjectNV);"
"bool hitObjectIsMissNV(hitObjectNV);"
"bool hitObjectIsHitNV(hitObjectNV);"
"float hitObjectGetRayTMinNV(hitObjectNV);"
"float hitObjectGetRayTMaxNV(hitObjectNV);"
"vec3 hitObjectGetWorldRayOriginNV(hitObjectNV);"
"vec3 hitObjectGetWorldRayDirectionNV(hitObjectNV);"
"vec3 hitObjectGetObjectRayOriginNV(hitObjectNV);"
"vec3 hitObjectGetObjectRayDirectionNV(hitObjectNV);"
"mat4x3 hitObjectGetWorldToObjectNV(hitObjectNV);"
"mat4x3 hitObjectGetObjectToWorldNV(hitObjectNV);"
"int hitObjectGetInstanceCustomIndexNV(hitObjectNV);"
"int hitObjectGetInstanceIdNV(hitObjectNV);"
"int hitObjectGetGeometryIndexNV(hitObjectNV);"
"int hitObjectGetPrimitiveIndexNV(hitObjectNV);"
"uint hitObjectGetHitKindNV(hitObjectNV);"
"void hitObjectGetAttributesNV(hitObjectNV,int);"
"float hitObjectGetCurrentTimeNV(hitObjectNV);"
"uint hitObjectGetShaderBindingTableRecordIndexNV(hitObjectNV);"
"uvec2 hitObjectGetShaderRecordBufferHandleNV(hitObjectNV);"
"\n");
stageBuiltins[EShLangCallable].append(
"void executeCallableNV(uint, int);"
@ -8852,6 +8946,38 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
symbolTable.setFunctionExtensions("executeCallableNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setFunctionExtensions("executeCallableEXT", 1, &E_GL_EXT_ray_tracing);
symbolTable.setFunctionExtensions("hitObjectTraceRayNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectTraceRayMotionNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectRecordHitNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectRecordHitMotionNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectRecordHitWithIndexNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectRecordHitWithIndexMotionNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectRecordMissNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectRecordMissMotionNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectRecordEmptyNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectExecuteShaderNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectIsEmptyNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectIsMissNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectIsHitNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetRayTMinNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetRayTMaxNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetObjectRayOriginNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetObjectRayDirectionNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetWorldRayOriginNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetWorldRayDirectionNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetWorldToObjectNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetbjectToWorldNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetInstanceCustomIndexNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetInstanceIdNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetGeometryIndexNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetPrimitiveIndexNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetHitKindNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetAttributesNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetCurrentTimeNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetShaderBindingTableRecordIndexNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("hitObjectGetShaderRecordBufferHandleNV", 1, &E_GL_NV_shader_invocation_reorder);
symbolTable.setFunctionExtensions("reorderThreadNV", 1, &E_GL_NV_shader_invocation_reorder);
BuiltInVariable("gl_LaunchIDNV", EbvLaunchId, symbolTable);
BuiltInVariable("gl_LaunchIDEXT", EbvLaunchId, symbolTable);
@ -9855,6 +9981,38 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
symbolTable.relateToOperator("traceRayEXT", EOpTraceKHR);
symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallableNV);
symbolTable.relateToOperator("executeCallableEXT", EOpExecuteCallableKHR);
symbolTable.relateToOperator("hitObjectTraceRayNV", EOpHitObjectTraceRayNV);
symbolTable.relateToOperator("hitObjectTraceRayMotionNV", EOpHitObjectTraceRayMotionNV);
symbolTable.relateToOperator("hitObjectRecordHitNV", EOpHitObjectRecordHitNV);
symbolTable.relateToOperator("hitObjectRecordHitMotionNV", EOpHitObjectRecordHitMotionNV);
symbolTable.relateToOperator("hitObjectRecordHitWithIndexNV", EOpHitObjectRecordHitWithIndexNV);
symbolTable.relateToOperator("hitObjectRecordHitWithIndexMotionNV", EOpHitObjectRecordHitWithIndexMotionNV);
symbolTable.relateToOperator("hitObjectRecordMissNV", EOpHitObjectRecordMissNV);
symbolTable.relateToOperator("hitObjectRecordMissMotionNV", EOpHitObjectRecordMissMotionNV);
symbolTable.relateToOperator("hitObjectRecordEmptyNV", EOpHitObjectRecordEmptyNV);
symbolTable.relateToOperator("hitObjectExecuteShaderNV", EOpHitObjectExecuteShaderNV);
symbolTable.relateToOperator("hitObjectIsEmptyNV", EOpHitObjectIsEmptyNV);
symbolTable.relateToOperator("hitObjectIsMissNV", EOpHitObjectIsMissNV);
symbolTable.relateToOperator("hitObjectIsHitNV", EOpHitObjectIsHitNV);
symbolTable.relateToOperator("hitObjectGetRayTMinNV", EOpHitObjectGetRayTMinNV);
symbolTable.relateToOperator("hitObjectGetRayTMaxNV", EOpHitObjectGetRayTMaxNV);
symbolTable.relateToOperator("hitObjectGetObjectRayOriginNV", EOpHitObjectGetObjectRayOriginNV);
symbolTable.relateToOperator("hitObjectGetObjectRayDirectionNV", EOpHitObjectGetObjectRayDirectionNV);
symbolTable.relateToOperator("hitObjectGetWorldRayOriginNV", EOpHitObjectGetWorldRayOriginNV);
symbolTable.relateToOperator("hitObjectGetWorldRayDirectionNV", EOpHitObjectGetWorldRayDirectionNV);
symbolTable.relateToOperator("hitObjectGetWorldToObjectNV", EOpHitObjectGetWorldToObjectNV);
symbolTable.relateToOperator("hitObjectGetObjectToWorldNV", EOpHitObjectGetObjectToWorldNV);
symbolTable.relateToOperator("hitObjectGetInstanceCustomIndexNV", EOpHitObjectGetInstanceCustomIndexNV);
symbolTable.relateToOperator("hitObjectGetInstanceIdNV", EOpHitObjectGetInstanceIdNV);
symbolTable.relateToOperator("hitObjectGetGeometryIndexNV", EOpHitObjectGetGeometryIndexNV);
symbolTable.relateToOperator("hitObjectGetPrimitiveIndexNV", EOpHitObjectGetPrimitiveIndexNV);
symbolTable.relateToOperator("hitObjectGetHitKindNV", EOpHitObjectGetHitKindNV);
symbolTable.relateToOperator("hitObjectGetAttributesNV", EOpHitObjectGetAttributesNV);
symbolTable.relateToOperator("hitObjectGetCurrentTimeNV", EOpHitObjectGetCurrentTimeNV);
symbolTable.relateToOperator("hitObjectGetShaderBindingTableRecordIndexNV", EOpHitObjectGetShaderBindingTableRecordIndexNV);
symbolTable.relateToOperator("hitObjectGetShaderRecordBufferHandleNV", EOpHitObjectGetShaderRecordBufferHandleNV);
symbolTable.relateToOperator("reorderThreadNV", EOpReorderThreadNV);
}
break;
case EShLangIntersect:

3
glslang/MachineIndependent/ParseContextBase.cpp
View file

@ -175,6 +175,9 @@ bool TParseContextBase::lValueErrorCheck(const TSourceLoc& loc, const char* op,
case EbtRayQuery:
message = "can't modify rayQueryEXT";
break;
case EbtHitObjectNV:
message = "can't modify hitObjectNV";
break;
#endif
default:
break;

89
glslang/MachineIndependent/ParseHelper.cpp
View file

@ -2368,6 +2368,79 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
}
break;
case EOpHitObjectTraceRayNV:
if (!(*argp)[11]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "payload number", "");
else {
unsigned int location = (*argp)[11]->getAsConstantUnion()->getAsConstantUnion()->getConstArray()[0].getUConst();
if (!extensionTurnedOn(E_GL_EXT_spirv_intrinsics) && intermediate.checkLocationRT(0, location) < 0)
error(loc, "with layout(location =", "no rayPayloadEXT/rayPayloadInEXT declared", "%d)", location);
}
break;
case EOpHitObjectTraceRayMotionNV:
if (!(*argp)[12]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "payload number", "");
else {
unsigned int location = (*argp)[12]->getAsConstantUnion()->getAsConstantUnion()->getConstArray()[0].getUConst();
if (!extensionTurnedOn(E_GL_EXT_spirv_intrinsics) && intermediate.checkLocationRT(0, location) < 0)
error(loc, "with layout(location =", "no rayPayloadEXT/rayPayloadInEXT declared", "%d)", location);
}
break;
case EOpHitObjectExecuteShaderNV:
if (!(*argp)[1]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "payload number", "");
else {
unsigned int location = (*argp)[1]->getAsConstantUnion()->getAsConstantUnion()->getConstArray()[0].getUConst();
if (!extensionTurnedOn(E_GL_EXT_spirv_intrinsics) && intermediate.checkLocationRT(0, location) < 0)
error(loc, "with layout(location =", "no rayPayloadEXT/rayPayloadInEXT declared", "%d)", location);
}
break;
case EOpHitObjectRecordHitNV:
if (!(*argp)[12]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "hitobjectattribute number", "");
else {
unsigned int location = (*argp)[12]->getAsConstantUnion()->getAsConstantUnion()->getConstArray()[0].getUConst();
if (!extensionTurnedOn(E_GL_EXT_spirv_intrinsics) && intermediate.checkLocationRT(2, location) < 0)
error(loc, "with layout(location =", "no hitObjectAttributeNV declared", "%d)", location);
}
break;
case EOpHitObjectRecordHitMotionNV:
if (!(*argp)[13]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "hitobjectattribute number", "");
else {
unsigned int location = (*argp)[13]->getAsConstantUnion()->getAsConstantUnion()->getConstArray()[0].getUConst();
if (!extensionTurnedOn(E_GL_EXT_spirv_intrinsics) && intermediate.checkLocationRT(2, location) < 0)
error(loc, "with layout(location =", "no hitObjectAttributeNV declared", "%d)", location);
}
break;
case EOpHitObjectRecordHitWithIndexNV:
if (!(*argp)[11]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "hitobjectattribute number", "");
else {
unsigned int location = (*argp)[11]->getAsConstantUnion()->getAsConstantUnion()->getConstArray()[0].getUConst();
if (!extensionTurnedOn(E_GL_EXT_spirv_intrinsics) && intermediate.checkLocationRT(2, location) < 0)
error(loc, "with layout(location =", "no hitObjectAttributeNV declared", "%d)", location);
}
break;
case EOpHitObjectRecordHitWithIndexMotionNV:
if (!(*argp)[12]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "hitobjectattribute number", "");
else {
unsigned int location = (*argp)[12]->getAsConstantUnion()->getAsConstantUnion()->getConstArray()[0].getUConst();
if (!extensionTurnedOn(E_GL_EXT_spirv_intrinsics) && intermediate.checkLocationRT(2, location) < 0)
error(loc, "with layout(location =", "no hitObjectAttributeNV declared", "%d)", location);
}
break;
case EOpHitObjectGetAttributesNV:
if (!(*argp)[1]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "hitobjectattribute number", "");
else {
unsigned int location = (*argp)[1]->getAsConstantUnion()->getAsConstantUnion()->getConstArray()[0].getUConst();
if (!extensionTurnedOn(E_GL_EXT_spirv_intrinsics) && intermediate.checkLocationRT(2, location) < 0)
error(loc, "with layout(location =", "no hitObjectAttributeNV declared", "%d)", location);
}
break;
case EOpRayQueryGetIntersectionType:
case EOpRayQueryGetIntersectionT:
case EOpRayQueryGetIntersectionInstanceCustomIndex:
@ -4581,7 +4654,7 @@ void TParseContext::checkRuntimeSizable(const TSourceLoc& loc, const TIntermType
// check for additional things allowed by GL_EXT_nonuniform_qualifier
if (base.getBasicType() == EbtSampler || base.getBasicType() == EbtAccStruct || base.getBasicType() == EbtRayQuery ||
(base.getBasicType() == EbtBlock && base.getType().getQualifier().isUniformOrBuffer()))
base.getBasicType() == EbtHitObjectNV || (base.getBasicType() == EbtBlock && base.getType().getQualifier().isUniformOrBuffer()))
requireExtensions(loc, 1, &E_GL_EXT_nonuniform_qualifier, "variable index");
else
error(loc, "", "[", "array must be redeclared with a size before being indexed with a variable");
@ -5761,6 +5834,10 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
}
publicType.qualifier.layoutShaderRecord = true;
return;
} else if (id == "hitobjectshaderrecordnv") {
requireExtensions(loc, 1, &E_GL_NV_shader_invocation_reorder, "hitobject shader record NV");
publicType.qualifier.layoutHitObjectShaderRecordNV = true;
return;
}
}
@ -6232,6 +6309,8 @@ void TParseContext::mergeObjectLayoutQualifiers(TQualifier& dst, const TQualifie
dst.pervertexNV = true;
if (src.pervertexEXT)
dst.pervertexEXT = true;
if (src.layoutHitObjectShaderRecordNV)
dst.layoutHitObjectShaderRecordNV = true;
#endif
}
}
@ -6389,6 +6468,7 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
case EvqHitAttr:
case EvqCallableData:
case EvqCallableDataIn:
case EvqHitObjectAttrNV:
break;
#endif
default:
@ -7344,7 +7424,10 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
if (initializer) {
if (type.getBasicType() == EbtRayQuery) {
error(loc, "ray queries can only be initialized by using the rayQueryInitializeEXT intrinsic:", "=", identifier.c_str());
} else if (type.getBasicType() == EbtHitObjectNV) {
error(loc, "hit objects cannot be initialized using initializers", "=", identifier.c_str());
}
}
if (type.isCoopMat()) {
@ -8771,6 +8854,10 @@ void TParseContext::blockStageIoCheck(const TSourceLoc& loc, const TQualifier& q
profileRequires(loc, ~EEsProfile, 460, 2, extsrt, "callableDataInNV block");
requireStage(loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV block");
break;
case EvqHitObjectAttrNV:
profileRequires(loc, ~EEsProfile, 460, E_GL_NV_shader_invocation_reorder, "hitObjectAttributeNV block");
requireStage(loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | EShLangMissMask), "hitObjectAttributeNV block");
break;
#endif
default:
error(loc, "only uniform, buffer, in, or out blocks are supported", blockName->c_str(), "");

17
glslang/MachineIndependent/Scan.cpp
View file

@ -765,6 +765,9 @@ void TScanContext::fillInKeywordMap()
(*KeywordMap)["icoopmatNV"] = ICOOPMATNV;
(*KeywordMap)["ucoopmatNV"] = UCOOPMATNV;
(*KeywordMap)["hitObjectNV"] = HITOBJECTNV;
(*KeywordMap)["hitObjectAttributeNV"] = HITOBJECTATTRNV;
ReservedSet = new std::unordered_set<const char*, str_hash, str_eq>;
ReservedSet->insert("common");
@ -1789,6 +1792,20 @@ int TScanContext::tokenizeIdentifier()
parseContext.extensionTurnedOn(E_GL_EXT_spirv_intrinsics))
return keyword;
return identifierOrType();
case HITOBJECTNV:
if (parseContext.symbolTable.atBuiltInLevel() ||
(!parseContext.isEsProfile() && parseContext.version >= 460
&& parseContext.extensionTurnedOn(E_GL_NV_shader_invocation_reorder)))
return keyword;
return identifierOrType();
case HITOBJECTATTRNV:
if (parseContext.symbolTable.atBuiltInLevel() ||
(!parseContext.isEsProfile() && parseContext.version >= 460
&& parseContext.extensionTurnedOn(E_GL_NV_shader_invocation_reorder)))
return keyword;
return identifierOrType();
#endif
default:

1
glslang/MachineIndependent/SymbolTable.cpp
View file

@ -78,6 +78,7 @@ void TType::buildMangledName(TString& mangledName) const
case EbtAccStruct: mangledName += "as"; break;
case EbtRayQuery: mangledName += "rq"; break;
case EbtSpirvType: mangledName += "spv-t"; break;
case EbtHitObjectNV: mangledName += "ho"; break;
#endif
case EbtSampler:
switch (sampler.type) {

6
glslang/MachineIndependent/Versions.cpp
View file

@ -302,9 +302,10 @@ void TParseVersions::initializeExtensionBehavior()
extensionBehavior[E_GL_NV_shader_sm_builtins] = EBhDisable;
extensionBehavior[E_GL_NV_integer_cooperative_matrix] = EBhDisable;
// ARM
extensionBehavior[E_GL_ARM_shader_core_builtins] = EBhDisable;
extensionBehavior[E_GL_NV_shader_invocation_reorder] = EBhDisable;
// ARM
extensionBehavior[E_GL_ARM_shader_core_builtins] = EBhDisable;
// AEP
extensionBehavior[E_GL_ANDROID_extension_pack_es31a] = EBhDisable;
@ -552,6 +553,7 @@ void TParseVersions::getPreamble(std::string& preamble)
"#define GL_NV_mesh_shader 1\n"
"#define GL_NV_cooperative_matrix 1\n"
"#define GL_NV_integer_cooperative_matrix 1\n"
"#define GL_NV_shader_execution_reorder 1\n"
"#define GL_EXT_shader_explicit_arithmetic_types 1\n"
"#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n"

1
glslang/MachineIndependent/Versions.h
View file

@ -277,6 +277,7 @@ const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]);
const char* const E_GL_NV_cooperative_matrix = "GL_NV_cooperative_matrix";
const char* const E_GL_NV_shader_sm_builtins = "GL_NV_shader_sm_builtins";
const char* const E_GL_NV_integer_cooperative_matrix = "GL_NV_integer_cooperative_matrix";
const char* const E_GL_NV_shader_invocation_reorder = "GL_NV_shader_invocation_reorder";
// AEP
const char* const E_GL_ANDROID_extension_pack_es31a = "GL_ANDROID_extension_pack_es31a";

15
glslang/MachineIndependent/glslang.m4
View file

@ -211,6 +211,7 @@ GLSLANG_WEB_EXCLUDE_ON
%token <lex> ACCSTRUCTEXT
%token <lex> RAYQUERYEXT
%token <lex> FCOOPMATNV ICOOPMATNV UCOOPMATNV
%token <lex> HITOBJECTNV HITOBJECTATTRNV
// combined image/sampler
%token <lex> SAMPLERCUBEARRAY SAMPLERCUBEARRAYSHADOW
@ -310,7 +311,7 @@ GLSLANG_WEB_EXCLUDE_ON
%token <lex> DOUBLECONSTANT INT16CONSTANT UINT16CONSTANT FLOAT16CONSTANT INT32CONSTANT UINT32CONSTANT
%token <lex> INT64CONSTANT UINT64CONSTANT
%token <lex> SUBROUTINE DEMOTE
%token <lex> PAYLOADNV PAYLOADINNV HITATTRNV CALLDATANV CALLDATAINNV
%token <lex> PAYLOADNV PAYLOADINNV HITATTRNV CALLDATANV CALLDATAINNV
%token <lex> PAYLOADEXT PAYLOADINEXT HITATTREXT CALLDATAEXT CALLDATAINEXT
%token <lex> PATCH SAMPLE NONUNIFORM
%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT
@ -1534,6 +1535,14 @@ GLSLANG_WEB_EXCLUDE_ON
$$.init($1.loc);
$$.qualifier.storage = EvqHitAttr;
}
| HITOBJECTATTRNV {
parseContext.globalCheck($1.loc, "hitAttributeNV");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask
| EShLangMissMask), "hitObjectAttributeNV");
parseContext.profileRequires($1.loc, ECoreProfile, 460, E_GL_NV_shader_invocation_reorder, "hitObjectAttributeNV");
$$.init($1.loc);
$$.qualifier.storage = EvqHitObjectAttrNV;
}
| HITATTREXT {
parseContext.globalCheck($1.loc, "hitAttributeEXT");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@ -3509,6 +3518,10 @@ GLSLANG_WEB_EXCLUDE_ON
parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
$$ = $1;
}
| HITOBJECTNV {
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtHitObjectNV;
}
GLSLANG_WEB_EXCLUDE_OFF
| struct_specifier {
$$ = $1;

17
glslang/MachineIndependent/glslang.y
View file

@ -151,7 +151,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
%parse-param {glslang::TParseContext* pParseContext}
%lex-param {parseContext}
%define api.pure // enable thread safety
%pure-parser // enable thread safety
%expect 1 // One shift reduce conflict because of if | else
%token <lex> CONST BOOL INT UINT FLOAT
@ -211,6 +211,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
%token <lex> ACCSTRUCTEXT
%token <lex> RAYQUERYEXT
%token <lex> FCOOPMATNV ICOOPMATNV UCOOPMATNV
%token <lex> HITOBJECTNV HITOBJECTATTRNV
// combined image/sampler
%token <lex> SAMPLERCUBEARRAY SAMPLERCUBEARRAYSHADOW
@ -310,7 +311,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
%token <lex> DOUBLECONSTANT INT16CONSTANT UINT16CONSTANT FLOAT16CONSTANT INT32CONSTANT UINT32CONSTANT
%token <lex> INT64CONSTANT UINT64CONSTANT
%token <lex> SUBROUTINE DEMOTE
%token <lex> PAYLOADNV PAYLOADINNV HITATTRNV CALLDATANV CALLDATAINNV
%token <lex> PAYLOADNV PAYLOADINNV HITATTRNV CALLDATANV CALLDATAINNV
%token <lex> PAYLOADEXT PAYLOADINEXT HITATTREXT CALLDATAEXT CALLDATAINEXT
%token <lex> PATCH SAMPLE NONUNIFORM
%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT
@ -1534,6 +1535,14 @@ storage_qualifier
$$.init($1.loc);
$$.qualifier.storage = EvqHitAttr;
}
| HITOBJECTATTRNV {
parseContext.globalCheck($1.loc, "hitAttributeNV");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask
| EShLangMissMask), "hitObjectAttributeNV");
parseContext.profileRequires($1.loc, ECoreProfile, 460, E_GL_NV_shader_invocation_reorder, "hitObjectAttributeNV");
$$.init($1.loc);
$$.qualifier.storage = EvqHitObjectAttrNV;
}
| HITATTREXT {
parseContext.globalCheck($1.loc, "hitAttributeEXT");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask
@ -3509,6 +3518,10 @@ type_specifier_nonarray
parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
$$ = $1;
}
| HITOBJECTNV {
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtHitObjectNV;
}
| struct_specifier {
$$ = $1;

10668
glslang/MachineIndependent/glslang_tab.cpp
View file

File diff suppressed because it is too large Load diff

588
glslang/MachineIndependent/glslang_tab.cpp.h
View file

@ -217,298 +217,300 @@ extern int yydebug;
FCOOPMATNV = 418, /* FCOOPMATNV */
ICOOPMATNV = 419, /* ICOOPMATNV */
UCOOPMATNV = 420, /* UCOOPMATNV */
SAMPLERCUBEARRAY = 421, /* SAMPLERCUBEARRAY */
SAMPLERCUBEARRAYSHADOW = 422, /* SAMPLERCUBEARRAYSHADOW */
ISAMPLERCUBEARRAY = 423, /* ISAMPLERCUBEARRAY */
USAMPLERCUBEARRAY = 424, /* USAMPLERCUBEARRAY */
SAMPLER1D = 425, /* SAMPLER1D */
SAMPLER1DARRAY = 426, /* SAMPLER1DARRAY */
SAMPLER1DARRAYSHADOW = 427, /* SAMPLER1DARRAYSHADOW */
ISAMPLER1D = 428, /* ISAMPLER1D */
SAMPLER1DSHADOW = 429, /* SAMPLER1DSHADOW */
SAMPLER2DRECT = 430, /* SAMPLER2DRECT */
SAMPLER2DRECTSHADOW = 431, /* SAMPLER2DRECTSHADOW */
ISAMPLER2DRECT = 432, /* ISAMPLER2DRECT */
USAMPLER2DRECT = 433, /* USAMPLER2DRECT */
SAMPLERBUFFER = 434, /* SAMPLERBUFFER */
ISAMPLERBUFFER = 435, /* ISAMPLERBUFFER */
USAMPLERBUFFER = 436, /* USAMPLERBUFFER */
SAMPLER2DMS = 437, /* SAMPLER2DMS */
ISAMPLER2DMS = 438, /* ISAMPLER2DMS */
USAMPLER2DMS = 439, /* USAMPLER2DMS */
SAMPLER2DMSARRAY = 440, /* SAMPLER2DMSARRAY */
ISAMPLER2DMSARRAY = 441, /* ISAMPLER2DMSARRAY */
USAMPLER2DMSARRAY = 442, /* USAMPLER2DMSARRAY */
SAMPLEREXTERNALOES = 443, /* SAMPLEREXTERNALOES */
SAMPLEREXTERNAL2DY2YEXT = 444, /* SAMPLEREXTERNAL2DY2YEXT */
ISAMPLER1DARRAY = 445, /* ISAMPLER1DARRAY */
USAMPLER1D = 446, /* USAMPLER1D */
USAMPLER1DARRAY = 447, /* USAMPLER1DARRAY */
F16SAMPLER1D = 448, /* F16SAMPLER1D */
F16SAMPLER2D = 449, /* F16SAMPLER2D */
F16SAMPLER3D = 450, /* F16SAMPLER3D */
F16SAMPLER2DRECT = 451, /* F16SAMPLER2DRECT */
F16SAMPLERCUBE = 452, /* F16SAMPLERCUBE */
F16SAMPLER1DARRAY = 453, /* F16SAMPLER1DARRAY */
F16SAMPLER2DARRAY = 454, /* F16SAMPLER2DARRAY */
F16SAMPLERCUBEARRAY = 455, /* F16SAMPLERCUBEARRAY */
F16SAMPLERBUFFER = 456, /* F16SAMPLERBUFFER */
F16SAMPLER2DMS = 457, /* F16SAMPLER2DMS */
F16SAMPLER2DMSARRAY = 458, /* F16SAMPLER2DMSARRAY */
F16SAMPLER1DSHADOW = 459, /* F16SAMPLER1DSHADOW */
F16SAMPLER2DSHADOW = 460, /* F16SAMPLER2DSHADOW */
F16SAMPLER1DARRAYSHADOW = 461, /* F16SAMPLER1DARRAYSHADOW */
F16SAMPLER2DARRAYSHADOW = 462, /* F16SAMPLER2DARRAYSHADOW */
F16SAMPLER2DRECTSHADOW = 463, /* F16SAMPLER2DRECTSHADOW */
F16SAMPLERCUBESHADOW = 464, /* F16SAMPLERCUBESHADOW */
F16SAMPLERCUBEARRAYSHADOW = 465, /* F16SAMPLERCUBEARRAYSHADOW */
IMAGE1D = 466, /* IMAGE1D */
IIMAGE1D = 467, /* IIMAGE1D */
UIMAGE1D = 468, /* UIMAGE1D */
IMAGE2D = 469, /* IMAGE2D */
IIMAGE2D = 470, /* IIMAGE2D */
UIMAGE2D = 471, /* UIMAGE2D */
IMAGE3D = 472, /* IMAGE3D */
IIMAGE3D = 473, /* IIMAGE3D */
UIMAGE3D = 474, /* UIMAGE3D */
IMAGE2DRECT = 475, /* IMAGE2DRECT */
IIMAGE2DRECT = 476, /* IIMAGE2DRECT */
UIMAGE2DRECT = 477, /* UIMAGE2DRECT */
IMAGECUBE = 478, /* IMAGECUBE */
IIMAGECUBE = 479, /* IIMAGECUBE */
UIMAGECUBE = 480, /* UIMAGECUBE */
IMAGEBUFFER = 481, /* IMAGEBUFFER */
IIMAGEBUFFER = 482, /* IIMAGEBUFFER */
UIMAGEBUFFER = 483, /* UIMAGEBUFFER */
IMAGE1DARRAY = 484, /* IMAGE1DARRAY */
IIMAGE1DARRAY = 485, /* IIMAGE1DARRAY */
UIMAGE1DARRAY = 486, /* UIMAGE1DARRAY */
IMAGE2DARRAY = 487, /* IMAGE2DARRAY */
IIMAGE2DARRAY = 488, /* IIMAGE2DARRAY */
UIMAGE2DARRAY = 489, /* UIMAGE2DARRAY */
IMAGECUBEARRAY = 490, /* IMAGECUBEARRAY */
IIMAGECUBEARRAY = 491, /* IIMAGECUBEARRAY */
UIMAGECUBEARRAY = 492, /* UIMAGECUBEARRAY */
IMAGE2DMS = 493, /* IMAGE2DMS */
IIMAGE2DMS = 494, /* IIMAGE2DMS */
UIMAGE2DMS = 495, /* UIMAGE2DMS */
IMAGE2DMSARRAY = 496, /* IMAGE2DMSARRAY */
IIMAGE2DMSARRAY = 497, /* IIMAGE2DMSARRAY */
UIMAGE2DMSARRAY = 498, /* UIMAGE2DMSARRAY */
F16IMAGE1D = 499, /* F16IMAGE1D */
F16IMAGE2D = 500, /* F16IMAGE2D */
F16IMAGE3D = 501, /* F16IMAGE3D */
F16IMAGE2DRECT = 502, /* F16IMAGE2DRECT */
F16IMAGECUBE = 503, /* F16IMAGECUBE */
F16IMAGE1DARRAY = 504, /* F16IMAGE1DARRAY */
F16IMAGE2DARRAY = 505, /* F16IMAGE2DARRAY */
F16IMAGECUBEARRAY = 506, /* F16IMAGECUBEARRAY */
F16IMAGEBUFFER = 507, /* F16IMAGEBUFFER */
F16IMAGE2DMS = 508, /* F16IMAGE2DMS */
F16IMAGE2DMSARRAY = 509, /* F16IMAGE2DMSARRAY */
I64IMAGE1D = 510, /* I64IMAGE1D */
U64IMAGE1D = 511, /* U64IMAGE1D */
I64IMAGE2D = 512, /* I64IMAGE2D */
U64IMAGE2D = 513, /* U64IMAGE2D */
I64IMAGE3D = 514, /* I64IMAGE3D */
U64IMAGE3D = 515, /* U64IMAGE3D */
I64IMAGE2DRECT = 516, /* I64IMAGE2DRECT */
U64IMAGE2DRECT = 517, /* U64IMAGE2DRECT */
I64IMAGECUBE = 518, /* I64IMAGECUBE */
U64IMAGECUBE = 519, /* U64IMAGECUBE */
I64IMAGEBUFFER = 520, /* I64IMAGEBUFFER */
U64IMAGEBUFFER = 521, /* U64IMAGEBUFFER */
I64IMAGE1DARRAY = 522, /* I64IMAGE1DARRAY */
U64IMAGE1DARRAY = 523, /* U64IMAGE1DARRAY */
I64IMAGE2DARRAY = 524, /* I64IMAGE2DARRAY */
U64IMAGE2DARRAY = 525, /* U64IMAGE2DARRAY */
I64IMAGECUBEARRAY = 526, /* I64IMAGECUBEARRAY */
U64IMAGECUBEARRAY = 527, /* U64IMAGECUBEARRAY */
I64IMAGE2DMS = 528, /* I64IMAGE2DMS */
U64IMAGE2DMS = 529, /* U64IMAGE2DMS */
I64IMAGE2DMSARRAY = 530, /* I64IMAGE2DMSARRAY */
U64IMAGE2DMSARRAY = 531, /* U64IMAGE2DMSARRAY */
TEXTURECUBEARRAY = 532, /* TEXTURECUBEARRAY */
ITEXTURECUBEARRAY = 533, /* ITEXTURECUBEARRAY */
UTEXTURECUBEARRAY = 534, /* UTEXTURECUBEARRAY */
TEXTURE1D = 535, /* TEXTURE1D */
ITEXTURE1D = 536, /* ITEXTURE1D */
UTEXTURE1D = 537, /* UTEXTURE1D */
TEXTURE1DARRAY = 538, /* TEXTURE1DARRAY */
ITEXTURE1DARRAY = 539, /* ITEXTURE1DARRAY */
UTEXTURE1DARRAY = 540, /* UTEXTURE1DARRAY */
TEXTURE2DRECT = 541, /* TEXTURE2DRECT */
ITEXTURE2DRECT = 542, /* ITEXTURE2DRECT */
UTEXTURE2DRECT = 543, /* UTEXTURE2DRECT */
TEXTUREBUFFER = 544, /* TEXTUREBUFFER */
ITEXTUREBUFFER = 545, /* ITEXTUREBUFFER */
UTEXTUREBUFFER = 546, /* UTEXTUREBUFFER */
TEXTURE2DMS = 547, /* TEXTURE2DMS */
ITEXTURE2DMS = 548, /* ITEXTURE2DMS */
UTEXTURE2DMS = 549, /* UTEXTURE2DMS */
TEXTURE2DMSARRAY = 550, /* TEXTURE2DMSARRAY */
ITEXTURE2DMSARRAY = 551, /* ITEXTURE2DMSARRAY */
UTEXTURE2DMSARRAY = 552, /* UTEXTURE2DMSARRAY */
F16TEXTURE1D = 553, /* F16TEXTURE1D */
F16TEXTURE2D = 554, /* F16TEXTURE2D */
F16TEXTURE3D = 555, /* F16TEXTURE3D */
F16TEXTURE2DRECT = 556, /* F16TEXTURE2DRECT */
F16TEXTURECUBE = 557, /* F16TEXTURECUBE */
F16TEXTURE1DARRAY = 558, /* F16TEXTURE1DARRAY */
F16TEXTURE2DARRAY = 559, /* F16TEXTURE2DARRAY */
F16TEXTURECUBEARRAY = 560, /* F16TEXTURECUBEARRAY */
F16TEXTUREBUFFER = 561, /* F16TEXTUREBUFFER */
F16TEXTURE2DMS = 562, /* F16TEXTURE2DMS */
F16TEXTURE2DMSARRAY = 563, /* F16TEXTURE2DMSARRAY */
SUBPASSINPUT = 564, /* SUBPASSINPUT */
SUBPASSINPUTMS = 565, /* SUBPASSINPUTMS */
ISUBPASSINPUT = 566, /* ISUBPASSINPUT */
ISUBPASSINPUTMS = 567, /* ISUBPASSINPUTMS */
USUBPASSINPUT = 568, /* USUBPASSINPUT */
USUBPASSINPUTMS = 569, /* USUBPASSINPUTMS */
F16SUBPASSINPUT = 570, /* F16SUBPASSINPUT */
F16SUBPASSINPUTMS = 571, /* F16SUBPASSINPUTMS */
SPIRV_INSTRUCTION = 572, /* SPIRV_INSTRUCTION */
SPIRV_EXECUTION_MODE = 573, /* SPIRV_EXECUTION_MODE */
SPIRV_EXECUTION_MODE_ID = 574, /* SPIRV_EXECUTION_MODE_ID */
SPIRV_DECORATE = 575, /* SPIRV_DECORATE */
SPIRV_DECORATE_ID = 576, /* SPIRV_DECORATE_ID */
SPIRV_DECORATE_STRING = 577, /* SPIRV_DECORATE_STRING */
SPIRV_TYPE = 578, /* SPIRV_TYPE */
SPIRV_STORAGE_CLASS = 579, /* SPIRV_STORAGE_CLASS */
SPIRV_BY_REFERENCE = 580, /* SPIRV_BY_REFERENCE */
SPIRV_LITERAL = 581, /* SPIRV_LITERAL */
LEFT_OP = 582, /* LEFT_OP */
RIGHT_OP = 583, /* RIGHT_OP */
INC_OP = 584, /* INC_OP */
DEC_OP = 585, /* DEC_OP */
LE_OP = 586, /* LE_OP */
GE_OP = 587, /* GE_OP */
EQ_OP = 588, /* EQ_OP */
NE_OP = 589, /* NE_OP */
AND_OP = 590, /* AND_OP */
OR_OP = 591, /* OR_OP */
XOR_OP = 592, /* XOR_OP */
MUL_ASSIGN = 593, /* MUL_ASSIGN */
DIV_ASSIGN = 594, /* DIV_ASSIGN */
ADD_ASSIGN = 595, /* ADD_ASSIGN */
MOD_ASSIGN = 596, /* MOD_ASSIGN */
LEFT_ASSIGN = 597, /* LEFT_ASSIGN */
RIGHT_ASSIGN = 598, /* RIGHT_ASSIGN */
AND_ASSIGN = 599, /* AND_ASSIGN */
XOR_ASSIGN = 600, /* XOR_ASSIGN */
OR_ASSIGN = 601, /* OR_ASSIGN */
SUB_ASSIGN = 602, /* SUB_ASSIGN */
STRING_LITERAL = 603, /* STRING_LITERAL */
LEFT_PAREN = 604, /* LEFT_PAREN */
RIGHT_PAREN = 605, /* RIGHT_PAREN */
LEFT_BRACKET = 606, /* LEFT_BRACKET */
RIGHT_BRACKET = 607, /* RIGHT_BRACKET */
LEFT_BRACE = 608, /* LEFT_BRACE */
RIGHT_BRACE = 609, /* RIGHT_BRACE */
DOT = 610, /* DOT */
COMMA = 611, /* COMMA */
COLON = 612, /* COLON */
EQUAL = 613, /* EQUAL */
SEMICOLON = 614, /* SEMICOLON */
BANG = 615, /* BANG */
DASH = 616, /* DASH */
TILDE = 617, /* TILDE */
PLUS = 618, /* PLUS */
STAR = 619, /* STAR */
SLASH = 620, /* SLASH */
PERCENT = 621, /* PERCENT */
LEFT_ANGLE = 622, /* LEFT_ANGLE */
RIGHT_ANGLE = 623, /* RIGHT_ANGLE */
VERTICAL_BAR = 624, /* VERTICAL_BAR */
CARET = 625, /* CARET */
AMPERSAND = 626, /* AMPERSAND */
QUESTION = 627, /* QUESTION */
INVARIANT = 628, /* INVARIANT */
HIGH_PRECISION = 629, /* HIGH_PRECISION */
MEDIUM_PRECISION = 630, /* MEDIUM_PRECISION */
LOW_PRECISION = 631, /* LOW_PRECISION */
PRECISION = 632, /* PRECISION */
PACKED = 633, /* PACKED */
RESOURCE = 634, /* RESOURCE */
SUPERP = 635, /* SUPERP */
FLOATCONSTANT = 636, /* FLOATCONSTANT */
INTCONSTANT = 637, /* INTCONSTANT */
UINTCONSTANT = 638, /* UINTCONSTANT */
BOOLCONSTANT = 639, /* BOOLCONSTANT */
IDENTIFIER = 640, /* IDENTIFIER */
TYPE_NAME = 641, /* TYPE_NAME */
CENTROID = 642, /* CENTROID */
IN = 643, /* IN */
OUT = 644, /* OUT */
INOUT = 645, /* INOUT */
STRUCT = 646, /* STRUCT */
VOID = 647, /* VOID */
WHILE = 648, /* WHILE */
BREAK = 649, /* BREAK */
CONTINUE = 650, /* CONTINUE */
DO = 651, /* DO */
ELSE = 652, /* ELSE */
FOR = 653, /* FOR */
IF = 654, /* IF */
DISCARD = 655, /* DISCARD */
RETURN = 656, /* RETURN */
SWITCH = 657, /* SWITCH */
CASE = 658, /* CASE */
DEFAULT = 659, /* DEFAULT */
TERMINATE_INVOCATION = 660, /* TERMINATE_INVOCATION */
TERMINATE_RAY = 661, /* TERMINATE_RAY */
IGNORE_INTERSECTION = 662, /* IGNORE_INTERSECTION */
UNIFORM = 663, /* UNIFORM */
SHARED = 664, /* SHARED */
BUFFER = 665, /* BUFFER */
FLAT = 666, /* FLAT */
SMOOTH = 667, /* SMOOTH */
LAYOUT = 668, /* LAYOUT */
DOUBLECONSTANT = 669, /* DOUBLECONSTANT */
INT16CONSTANT = 670, /* INT16CONSTANT */
UINT16CONSTANT = 671, /* UINT16CONSTANT */
FLOAT16CONSTANT = 672, /* FLOAT16CONSTANT */
INT32CONSTANT = 673, /* INT32CONSTANT */
UINT32CONSTANT = 674, /* UINT32CONSTANT */
INT64CONSTANT = 675, /* INT64CONSTANT */
UINT64CONSTANT = 676, /* UINT64CONSTANT */
SUBROUTINE = 677, /* SUBROUTINE */
DEMOTE = 678, /* DEMOTE */
PAYLOADNV = 679, /* PAYLOADNV */
PAYLOADINNV = 680, /* PAYLOADINNV */
HITATTRNV = 681, /* HITATTRNV */
CALLDATANV = 682, /* CALLDATANV */
CALLDATAINNV = 683, /* CALLDATAINNV */
PAYLOADEXT = 684, /* PAYLOADEXT */
PAYLOADINEXT = 685, /* PAYLOADINEXT */
HITATTREXT = 686, /* HITATTREXT */
CALLDATAEXT = 687, /* CALLDATAEXT */
CALLDATAINEXT = 688, /* CALLDATAINEXT */
PATCH = 689, /* PATCH */
SAMPLE = 690, /* SAMPLE */
NONUNIFORM = 691, /* NONUNIFORM */
COHERENT = 692, /* COHERENT */
VOLATILE = 693, /* VOLATILE */
RESTRICT = 694, /* RESTRICT */
READONLY = 695, /* READONLY */
WRITEONLY = 696, /* WRITEONLY */
DEVICECOHERENT = 697, /* DEVICECOHERENT */
QUEUEFAMILYCOHERENT = 698, /* QUEUEFAMILYCOHERENT */
WORKGROUPCOHERENT = 699, /* WORKGROUPCOHERENT */
SUBGROUPCOHERENT = 700, /* SUBGROUPCOHERENT */
NONPRIVATE = 701, /* NONPRIVATE */
SHADERCALLCOHERENT = 702, /* SHADERCALLCOHERENT */
NOPERSPECTIVE = 703, /* NOPERSPECTIVE */
EXPLICITINTERPAMD = 704, /* EXPLICITINTERPAMD */
PERVERTEXEXT = 705, /* PERVERTEXEXT */
PERVERTEXNV = 706, /* PERVERTEXNV */
PERPRIMITIVENV = 707, /* PERPRIMITIVENV */
PERVIEWNV = 708, /* PERVIEWNV */
PERTASKNV = 709, /* PERTASKNV */
PERPRIMITIVEEXT = 710, /* PERPRIMITIVEEXT */
TASKPAYLOADWORKGROUPEXT = 711, /* TASKPAYLOADWORKGROUPEXT */
PRECISE = 712 /* PRECISE */
HITOBJECTNV = 421, /* HITOBJECTNV */
HITOBJECTATTRNV = 422, /* HITOBJECTATTRNV */
SAMPLERCUBEARRAY = 423, /* SAMPLERCUBEARRAY */
SAMPLERCUBEARRAYSHADOW = 424, /* SAMPLERCUBEARRAYSHADOW */
ISAMPLERCUBEARRAY = 425, /* ISAMPLERCUBEARRAY */
USAMPLERCUBEARRAY = 426, /* USAMPLERCUBEARRAY */
SAMPLER1D = 427, /* SAMPLER1D */
SAMPLER1DARRAY = 428, /* SAMPLER1DARRAY */
SAMPLER1DARRAYSHADOW = 429, /* SAMPLER1DARRAYSHADOW */
ISAMPLER1D = 430, /* ISAMPLER1D */
SAMPLER1DSHADOW = 431, /* SAMPLER1DSHADOW */
SAMPLER2DRECT = 432, /* SAMPLER2DRECT */
SAMPLER2DRECTSHADOW = 433, /* SAMPLER2DRECTSHADOW */
ISAMPLER2DRECT = 434, /* ISAMPLER2DRECT */
USAMPLER2DRECT = 435, /* USAMPLER2DRECT */
SAMPLERBUFFER = 436, /* SAMPLERBUFFER */
ISAMPLERBUFFER = 437, /* ISAMPLERBUFFER */
USAMPLERBUFFER = 438, /* USAMPLERBUFFER */
SAMPLER2DMS = 439, /* SAMPLER2DMS */
ISAMPLER2DMS = 440, /* ISAMPLER2DMS */
USAMPLER2DMS = 441, /* USAMPLER2DMS */
SAMPLER2DMSARRAY = 442, /* SAMPLER2DMSARRAY */
ISAMPLER2DMSARRAY = 443, /* ISAMPLER2DMSARRAY */
USAMPLER2DMSARRAY = 444, /* USAMPLER2DMSARRAY */
SAMPLEREXTERNALOES = 445, /* SAMPLEREXTERNALOES */
SAMPLEREXTERNAL2DY2YEXT = 446, /* SAMPLEREXTERNAL2DY2YEXT */
ISAMPLER1DARRAY = 447, /* ISAMPLER1DARRAY */
USAMPLER1D = 448, /* USAMPLER1D */
USAMPLER1DARRAY = 449, /* USAMPLER1DARRAY */
F16SAMPLER1D = 450, /* F16SAMPLER1D */
F16SAMPLER2D = 451, /* F16SAMPLER2D */
F16SAMPLER3D = 452, /* F16SAMPLER3D */
F16SAMPLER2DRECT = 453, /* F16SAMPLER2DRECT */
F16SAMPLERCUBE = 454, /* F16SAMPLERCUBE */
F16SAMPLER1DARRAY = 455, /* F16SAMPLER1DARRAY */
F16SAMPLER2DARRAY = 456, /* F16SAMPLER2DARRAY */
F16SAMPLERCUBEARRAY = 457, /* F16SAMPLERCUBEARRAY */
F16SAMPLERBUFFER = 458, /* F16SAMPLERBUFFER */
F16SAMPLER2DMS = 459, /* F16SAMPLER2DMS */
F16SAMPLER2DMSARRAY = 460, /* F16SAMPLER2DMSARRAY */
F16SAMPLER1DSHADOW = 461, /* F16SAMPLER1DSHADOW */
F16SAMPLER2DSHADOW = 462, /* F16SAMPLER2DSHADOW */
F16SAMPLER1DARRAYSHADOW = 463, /* F16SAMPLER1DARRAYSHADOW */
F16SAMPLER2DARRAYSHADOW = 464, /* F16SAMPLER2DARRAYSHADOW */
F16SAMPLER2DRECTSHADOW = 465, /* F16SAMPLER2DRECTSHADOW */
F16SAMPLERCUBESHADOW = 466, /* F16SAMPLERCUBESHADOW */
F16SAMPLERCUBEARRAYSHADOW = 467, /* F16SAMPLERCUBEARRAYSHADOW */
IMAGE1D = 468, /* IMAGE1D */
IIMAGE1D = 469, /* IIMAGE1D */
UIMAGE1D = 470, /* UIMAGE1D */
IMAGE2D = 471, /* IMAGE2D */
IIMAGE2D = 472, /* IIMAGE2D */
UIMAGE2D = 473, /* UIMAGE2D */
IMAGE3D = 474, /* IMAGE3D */
IIMAGE3D = 475, /* IIMAGE3D */
UIMAGE3D = 476, /* UIMAGE3D */
IMAGE2DRECT = 477, /* IMAGE2DRECT */
IIMAGE2DRECT = 478, /* IIMAGE2DRECT */
UIMAGE2DRECT = 479, /* UIMAGE2DRECT */
IMAGECUBE = 480, /* IMAGECUBE */
IIMAGECUBE = 481, /* IIMAGECUBE */
UIMAGECUBE = 482, /* UIMAGECUBE */
IMAGEBUFFER = 483, /* IMAGEBUFFER */
IIMAGEBUFFER = 484, /* IIMAGEBUFFER */
UIMAGEBUFFER = 485, /* UIMAGEBUFFER */
IMAGE1DARRAY = 486, /* IMAGE1DARRAY */
IIMAGE1DARRAY = 487, /* IIMAGE1DARRAY */
UIMAGE1DARRAY = 488, /* UIMAGE1DARRAY */
IMAGE2DARRAY = 489, /* IMAGE2DARRAY */
IIMAGE2DARRAY = 490, /* IIMAGE2DARRAY */
UIMAGE2DARRAY = 491, /* UIMAGE2DARRAY */
IMAGECUBEARRAY = 492, /* IMAGECUBEARRAY */
IIMAGECUBEARRAY = 493, /* IIMAGECUBEARRAY */
UIMAGECUBEARRAY = 494, /* UIMAGECUBEARRAY */
IMAGE2DMS = 495, /* IMAGE2DMS */
IIMAGE2DMS = 496, /* IIMAGE2DMS */
UIMAGE2DMS = 497, /* UIMAGE2DMS */
IMAGE2DMSARRAY = 498, /* IMAGE2DMSARRAY */
IIMAGE2DMSARRAY = 499, /* IIMAGE2DMSARRAY */
UIMAGE2DMSARRAY = 500, /* UIMAGE2DMSARRAY */
F16IMAGE1D = 501, /* F16IMAGE1D */
F16IMAGE2D = 502, /* F16IMAGE2D */
F16IMAGE3D = 503, /* F16IMAGE3D */
F16IMAGE2DRECT = 504, /* F16IMAGE2DRECT */
F16IMAGECUBE = 505, /* F16IMAGECUBE */
F16IMAGE1DARRAY = 506, /* F16IMAGE1DARRAY */
F16IMAGE2DARRAY = 507, /* F16IMAGE2DARRAY */
F16IMAGECUBEARRAY = 508, /* F16IMAGECUBEARRAY */
F16IMAGEBUFFER = 509, /* F16IMAGEBUFFER */
F16IMAGE2DMS = 510, /* F16IMAGE2DMS */
F16IMAGE2DMSARRAY = 511, /* F16IMAGE2DMSARRAY */
I64IMAGE1D = 512, /* I64IMAGE1D */
U64IMAGE1D = 513, /* U64IMAGE1D */
I64IMAGE2D = 514, /* I64IMAGE2D */
U64IMAGE2D = 515, /* U64IMAGE2D */
I64IMAGE3D = 516, /* I64IMAGE3D */
U64IMAGE3D = 517, /* U64IMAGE3D */
I64IMAGE2DRECT = 518, /* I64IMAGE2DRECT */
U64IMAGE2DRECT = 519, /* U64IMAGE2DRECT */
I64IMAGECUBE = 520, /* I64IMAGECUBE */
U64IMAGECUBE = 521, /* U64IMAGECUBE */
I64IMAGEBUFFER = 522, /* I64IMAGEBUFFER */
U64IMAGEBUFFER = 523, /* U64IMAGEBUFFER */
I64IMAGE1DARRAY = 524, /* I64IMAGE1DARRAY */
U64IMAGE1DARRAY = 525, /* U64IMAGE1DARRAY */
I64IMAGE2DARRAY = 526, /* I64IMAGE2DARRAY */
U64IMAGE2DARRAY = 527, /* U64IMAGE2DARRAY */
I64IMAGECUBEARRAY = 528, /* I64IMAGECUBEARRAY */
U64IMAGECUBEARRAY = 529, /* U64IMAGECUBEARRAY */
I64IMAGE2DMS = 530, /* I64IMAGE2DMS */
U64IMAGE2DMS = 531, /* U64IMAGE2DMS */
I64IMAGE2DMSARRAY = 532, /* I64IMAGE2DMSARRAY */
U64IMAGE2DMSARRAY = 533, /* U64IMAGE2DMSARRAY */
TEXTURECUBEARRAY = 534, /* TEXTURECUBEARRAY */
ITEXTURECUBEARRAY = 535, /* ITEXTURECUBEARRAY */
UTEXTURECUBEARRAY = 536, /* UTEXTURECUBEARRAY */
TEXTURE1D = 537, /* TEXTURE1D */
ITEXTURE1D = 538, /* ITEXTURE1D */
UTEXTURE1D = 539, /* UTEXTURE1D */
TEXTURE1DARRAY = 540, /* TEXTURE1DARRAY */
ITEXTURE1DARRAY = 541, /* ITEXTURE1DARRAY */
UTEXTURE1DARRAY = 542, /* UTEXTURE1DARRAY */
TEXTURE2DRECT = 543, /* TEXTURE2DRECT */
ITEXTURE2DRECT = 544, /* ITEXTURE2DRECT */
UTEXTURE2DRECT = 545, /* UTEXTURE2DRECT */
TEXTUREBUFFER = 546, /* TEXTUREBUFFER */
ITEXTUREBUFFER = 547, /* ITEXTUREBUFFER */
UTEXTUREBUFFER = 548, /* UTEXTUREBUFFER */
TEXTURE2DMS = 549, /* TEXTURE2DMS */
ITEXTURE2DMS = 550, /* ITEXTURE2DMS */
UTEXTURE2DMS = 551, /* UTEXTURE2DMS */
TEXTURE2DMSARRAY = 552, /* TEXTURE2DMSARRAY */
ITEXTURE2DMSARRAY = 553, /* ITEXTURE2DMSARRAY */
UTEXTURE2DMSARRAY = 554, /* UTEXTURE2DMSARRAY */
F16TEXTURE1D = 555, /* F16TEXTURE1D */
F16TEXTURE2D = 556, /* F16TEXTURE2D */
F16TEXTURE3D = 557, /* F16TEXTURE3D */
F16TEXTURE2DRECT = 558, /* F16TEXTURE2DRECT */
F16TEXTURECUBE = 559, /* F16TEXTURECUBE */
F16TEXTURE1DARRAY = 560, /* F16TEXTURE1DARRAY */
F16TEXTURE2DARRAY = 561, /* F16TEXTURE2DARRAY */
F16TEXTURECUBEARRAY = 562, /* F16TEXTURECUBEARRAY */
F16TEXTUREBUFFER = 563, /* F16TEXTUREBUFFER */
F16TEXTURE2DMS = 564, /* F16TEXTURE2DMS */
F16TEXTURE2DMSARRAY = 565, /* F16TEXTURE2DMSARRAY */
SUBPASSINPUT = 566, /* SUBPASSINPUT */
SUBPASSINPUTMS = 567, /* SUBPASSINPUTMS */
ISUBPASSINPUT = 568, /* ISUBPASSINPUT */
ISUBPASSINPUTMS = 569, /* ISUBPASSINPUTMS */
USUBPASSINPUT = 570, /* USUBPASSINPUT */
USUBPASSINPUTMS = 571, /* USUBPASSINPUTMS */
F16SUBPASSINPUT = 572, /* F16SUBPASSINPUT */
F16SUBPASSINPUTMS = 573, /* F16SUBPASSINPUTMS */
SPIRV_INSTRUCTION = 574, /* SPIRV_INSTRUCTION */
SPIRV_EXECUTION_MODE = 575, /* SPIRV_EXECUTION_MODE */
SPIRV_EXECUTION_MODE_ID = 576, /* SPIRV_EXECUTION_MODE_ID */
SPIRV_DECORATE = 577, /* SPIRV_DECORATE */
SPIRV_DECORATE_ID = 578, /* SPIRV_DECORATE_ID */
SPIRV_DECORATE_STRING = 579, /* SPIRV_DECORATE_STRING */
SPIRV_TYPE = 580, /* SPIRV_TYPE */
SPIRV_STORAGE_CLASS = 581, /* SPIRV_STORAGE_CLASS */
SPIRV_BY_REFERENCE = 582, /* SPIRV_BY_REFERENCE */
SPIRV_LITERAL = 583, /* SPIRV_LITERAL */
LEFT_OP = 584, /* LEFT_OP */
RIGHT_OP = 585, /* RIGHT_OP */
INC_OP = 586, /* INC_OP */
DEC_OP = 587, /* DEC_OP */
LE_OP = 588, /* LE_OP */
GE_OP = 589, /* GE_OP */
EQ_OP = 590, /* EQ_OP */
NE_OP = 591, /* NE_OP */
AND_OP = 592, /* AND_OP */
OR_OP = 593, /* OR_OP */
XOR_OP = 594, /* XOR_OP */
MUL_ASSIGN = 595, /* MUL_ASSIGN */
DIV_ASSIGN = 596, /* DIV_ASSIGN */
ADD_ASSIGN = 597, /* ADD_ASSIGN */
MOD_ASSIGN = 598, /* MOD_ASSIGN */
LEFT_ASSIGN = 599, /* LEFT_ASSIGN */
RIGHT_ASSIGN = 600, /* RIGHT_ASSIGN */
AND_ASSIGN = 601, /* AND_ASSIGN */
XOR_ASSIGN = 602, /* XOR_ASSIGN */
OR_ASSIGN = 603, /* OR_ASSIGN */
SUB_ASSIGN = 604, /* SUB_ASSIGN */
STRING_LITERAL = 605, /* STRING_LITERAL */
LEFT_PAREN = 606, /* LEFT_PAREN */
RIGHT_PAREN = 607, /* RIGHT_PAREN */
LEFT_BRACKET = 608, /* LEFT_BRACKET */
RIGHT_BRACKET = 609, /* RIGHT_BRACKET */
LEFT_BRACE = 610, /* LEFT_BRACE */
RIGHT_BRACE = 611, /* RIGHT_BRACE */
DOT = 612, /* DOT */
COMMA = 613, /* COMMA */
COLON = 614, /* COLON */
EQUAL = 615, /* EQUAL */
SEMICOLON = 616, /* SEMICOLON */
BANG = 617, /* BANG */
DASH = 618, /* DASH */
TILDE = 619, /* TILDE */
PLUS = 620, /* PLUS */
STAR = 621, /* STAR */
SLASH = 622, /* SLASH */
PERCENT = 623, /* PERCENT */
LEFT_ANGLE = 624, /* LEFT_ANGLE */
RIGHT_ANGLE = 625, /* RIGHT_ANGLE */
VERTICAL_BAR = 626, /* VERTICAL_BAR */
CARET = 627, /* CARET */
AMPERSAND = 628, /* AMPERSAND */
QUESTION = 629, /* QUESTION */
INVARIANT = 630, /* INVARIANT */
HIGH_PRECISION = 631, /* HIGH_PRECISION */
MEDIUM_PRECISION = 632, /* MEDIUM_PRECISION */
LOW_PRECISION = 633, /* LOW_PRECISION */
PRECISION = 634, /* PRECISION */
PACKED = 635, /* PACKED */
RESOURCE = 636, /* RESOURCE */
SUPERP = 637, /* SUPERP */
FLOATCONSTANT = 638, /* FLOATCONSTANT */
INTCONSTANT = 639, /* INTCONSTANT */
UINTCONSTANT = 640, /* UINTCONSTANT */
BOOLCONSTANT = 641, /* BOOLCONSTANT */
IDENTIFIER = 642, /* IDENTIFIER */
TYPE_NAME = 643, /* TYPE_NAME */
CENTROID = 644, /* CENTROID */
IN = 645, /* IN */
OUT = 646, /* OUT */
INOUT = 647, /* INOUT */
STRUCT = 648, /* STRUCT */
VOID = 649, /* VOID */
WHILE = 650, /* WHILE */
BREAK = 651, /* BREAK */
CONTINUE = 652, /* CONTINUE */
DO = 653, /* DO */
ELSE = 654, /* ELSE */
FOR = 655, /* FOR */
IF = 656, /* IF */
DISCARD = 657, /* DISCARD */
RETURN = 658, /* RETURN */
SWITCH = 659, /* SWITCH */
CASE = 660, /* CASE */
DEFAULT = 661, /* DEFAULT */
TERMINATE_INVOCATION = 662, /* TERMINATE_INVOCATION */
TERMINATE_RAY = 663, /* TERMINATE_RAY */
IGNORE_INTERSECTION = 664, /* IGNORE_INTERSECTION */
UNIFORM = 665, /* UNIFORM */
SHARED = 666, /* SHARED */
BUFFER = 667, /* BUFFER */
FLAT = 668, /* FLAT */
SMOOTH = 669, /* SMOOTH */
LAYOUT = 670, /* LAYOUT */
DOUBLECONSTANT = 671, /* DOUBLECONSTANT */
INT16CONSTANT = 672, /* INT16CONSTANT */
UINT16CONSTANT = 673, /* UINT16CONSTANT */
FLOAT16CONSTANT = 674, /* FLOAT16CONSTANT */
INT32CONSTANT = 675, /* INT32CONSTANT */
UINT32CONSTANT = 676, /* UINT32CONSTANT */
INT64CONSTANT = 677, /* INT64CONSTANT */
UINT64CONSTANT = 678, /* UINT64CONSTANT */
SUBROUTINE = 679, /* SUBROUTINE */
DEMOTE = 680, /* DEMOTE */
PAYLOADNV = 681, /* PAYLOADNV */
PAYLOADINNV = 682, /* PAYLOADINNV */
HITATTRNV = 683, /* HITATTRNV */
CALLDATANV = 684, /* CALLDATANV */
CALLDATAINNV = 685, /* CALLDATAINNV */
PAYLOADEXT = 686, /* PAYLOADEXT */
PAYLOADINEXT = 687, /* PAYLOADINEXT */
HITATTREXT = 688, /* HITATTREXT */
CALLDATAEXT = 689, /* CALLDATAEXT */
CALLDATAINEXT = 690, /* CALLDATAINEXT */
PATCH = 691, /* PATCH */
SAMPLE = 692, /* SAMPLE */
NONUNIFORM = 693, /* NONUNIFORM */
COHERENT = 694, /* COHERENT */
VOLATILE = 695, /* VOLATILE */
RESTRICT = 696, /* RESTRICT */
READONLY = 697, /* READONLY */
WRITEONLY = 698, /* WRITEONLY */
DEVICECOHERENT = 699, /* DEVICECOHERENT */
QUEUEFAMILYCOHERENT = 700, /* QUEUEFAMILYCOHERENT */
WORKGROUPCOHERENT = 701, /* WORKGROUPCOHERENT */
SUBGROUPCOHERENT = 702, /* SUBGROUPCOHERENT */
NONPRIVATE = 703, /* NONPRIVATE */
SHADERCALLCOHERENT = 704, /* SHADERCALLCOHERENT */
NOPERSPECTIVE = 705, /* NOPERSPECTIVE */
EXPLICITINTERPAMD = 706, /* EXPLICITINTERPAMD */
PERVERTEXEXT = 707, /* PERVERTEXEXT */
PERVERTEXNV = 708, /* PERVERTEXNV */
PERPRIMITIVENV = 709, /* PERPRIMITIVENV */
PERVIEWNV = 710, /* PERVIEWNV */
PERTASKNV = 711, /* PERTASKNV */
PERPRIMITIVEEXT = 712, /* PERPRIMITIVEEXT */
TASKPAYLOADWORKGROUPEXT = 713, /* TASKPAYLOADWORKGROUPEXT */
PRECISE = 714 /* PRECISE */
};
typedef enum yytokentype yytoken_kind_t;
#endif
@ -556,7 +558,7 @@ union YYSTYPE
glslang::TArraySizes* typeParameters;
} interm;
#line 560 "MachineIndependent/glslang_tab.cpp.h"
#line 562 "MachineIndependent/glslang_tab.cpp.h"
};
typedef union YYSTYPE YYSTYPE;

32
glslang/MachineIndependent/intermOut.cpp
View file

@ -1105,6 +1105,38 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
case EOpIsHelperInvocation: out.debug << "IsHelperInvocation"; break;
case EOpDebugPrintf: out.debug << "Debug printf"; break;
case EOpHitObjectTraceRayNV: out.debug << "HitObjectTraceRayNV"; break;
case EOpHitObjectTraceRayMotionNV: out.debug << "HitObjectTraceRayMotionNV"; break;
case EOpHitObjectRecordHitNV: out.debug << "HitObjectRecordHitNV"; break;
case EOpHitObjectRecordHitMotionNV: out.debug << "HitObjectRecordHitMotionNV"; break;
case EOpHitObjectRecordHitWithIndexNV: out.debug << "HitObjectRecordHitWithIndexNV"; break;
case EOpHitObjectRecordHitWithIndexMotionNV: out.debug << "HitObjectRecordHitWithIndexMotionNV"; break;
case EOpHitObjectRecordMissNV: out.debug << "HitObjectRecordMissNV"; break;
case EOpHitObjectRecordMissMotionNV: out.debug << "HitObjectRecordMissMotionNV"; break;
case EOpHitObjectRecordEmptyNV: out.debug << "HitObjectRecordEmptyNV"; break;
case EOpHitObjectExecuteShaderNV: out.debug << "HitObjectExecuteShaderNV"; break;
case EOpHitObjectIsEmptyNV: out.debug << "HitObjectIsEmptyNV"; break;
case EOpHitObjectIsMissNV: out.debug << "HitObjectIsMissNV"; break;
case EOpHitObjectIsHitNV: out.debug << "HitObjectIsHitNV"; break;
case EOpHitObjectGetRayTMinNV: out.debug << "HitObjectGetRayTMinNV"; break;
case EOpHitObjectGetRayTMaxNV: out.debug << "HitObjectGetRayTMaxNV"; break;
case EOpHitObjectGetObjectRayOriginNV: out.debug << "HitObjectGetObjectRayOriginNV"; break;
case EOpHitObjectGetObjectRayDirectionNV: out.debug << "HitObjectGetObjectRayDirectionNV"; break;
case EOpHitObjectGetWorldRayOriginNV: out.debug << "HitObjectGetWorldRayOriginNV"; break;
case EOpHitObjectGetWorldRayDirectionNV: out.debug << "HitObjectGetWorldRayDirectionNV"; break;
case EOpHitObjectGetObjectToWorldNV: out.debug << "HitObjectGetObjectToWorldNV"; break;
case EOpHitObjectGetWorldToObjectNV: out.debug << "HitObjectGetWorldToObjectNV"; break;
case EOpHitObjectGetInstanceCustomIndexNV: out.debug<< "HitObjectGetInstanceCustomIndexNV"; break;
case EOpHitObjectGetInstanceIdNV: out.debug << "HitObjectGetInstaneIdNV"; break;
case EOpHitObjectGetGeometryIndexNV: out.debug << "HitObjectGetGeometryIndexNV"; break;
case EOpHitObjectGetPrimitiveIndexNV: out.debug << "HitObjectGetPrimitiveIndexNV"; break;
case EOpHitObjectGetHitKindNV: out.debug << "HitObjectGetHitKindNV"; break;
case EOpHitObjectGetAttributesNV: out.debug << "HitObjectGetAttributesNV"; break;
case EOpHitObjectGetCurrentTimeNV: out.debug << "HitObjectGetCurrentTimeNV"; break;
case EOpHitObjectGetShaderBindingTableRecordIndexNV: out.debug << "HitObjectGetShaderBindingTableRecordIndexNV"; break;
case EOpHitObjectGetShaderRecordBufferHandleNV: out.debug << "HitObjectReadShaderRecordBufferHandleNV"; break;
case EOpReorderThreadNV: out.debug << "ReorderThreadNV"; break;
#ifndef GLSLANG_WEB
case EOpSpirvInst: out.debug << "spirv_instruction"; break;
#endif

4
glslang/MachineIndependent/linkValidate.cpp
View file

@ -1614,6 +1614,8 @@ int TIntermediate::addUsedLocation(const TQualifier& qualifier, const TType& typ
setRT = 0;
else if (qualifier.isAnyCallable())
setRT = 1;
else if (qualifier.isHitObjectAttrNV())
setRT = 2;
else
return -1;
@ -1653,7 +1655,7 @@ int TIntermediate::addUsedLocation(const TQualifier& qualifier, const TType& typ
// slot irrespective of type.
int collision = -1; // no collision
#ifndef GLSLANG_WEB
if (qualifier.isAnyPayload() || qualifier.isAnyCallable()) {
if (qualifier.isAnyPayload() || qualifier.isAnyCallable() || qualifier.isHitObjectAttrNV()) {
TRange range(qualifier.layoutLocation, qualifier.layoutLocation);
collision = checkLocationRT(setRT, qualifier.layoutLocation);
if (collision < 0)

5
glslang/MachineIndependent/localintermediate.h
View file

@ -1268,8 +1268,9 @@ protected:
std::unordered_set<int> usedConstantId; // specialization constant ids used
std::vector<TOffsetRange> usedAtomics; // sets of bindings used by atomic counters
std::vector<TIoRange> usedIo[4]; // sets of used locations, one for each of in, out, uniform, and buffers
std::vector<TRange> usedIoRT[2]; // sets of used location, one for rayPayload/rayPayloadIN and other
// for callableData/callableDataIn
std::vector<TRange> usedIoRT[4]; // sets of used location, one for rayPayload/rayPayloadIN,
// one for callableData/callableDataIn, one for hitObjectAttributeNV and
// one for shaderrecordhitobjectNV
// set of names of statically read/written I/O that might need extra checking
std::set<TString> ioAccessed;