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

Multiple features and misc fixes for final raytracing non experimental version.

Browse source
This commit is contained in:
Ashwin Lele 2018-10-22 16:41:44 -07:00
parent b2b3d81e9b
commit ff1783db87
48 changed files with 5168 additions and 4850 deletions
Download patch file Download diff file Expand all files Collapse all files

200
glslang/MachineIndependent/Initialize.cpp
View file

@ -5059,23 +5059,29 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
#ifdef NV_EXTENSIONS
// Builtins for GL_NV_raytracing
// Builtins for GL_NV_ray_tracing
if (profile != EEsProfile && version >= 460) {
stageBuiltins[EShLangRayGenNV].append(
"void traceNVX(accelerationStructureNVX,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);"
"\n");
stageBuiltins[EShLangIntersectNV].append(
"bool reportIntersectionNVX(float, uint);"
"bool reportIntersectionNV(float, uint);"
"\n");
stageBuiltins[EShLangAnyHitNV].append(
"void ignoreIntersectionNVX();"
"void terminateRayNVX();"
"void ignoreIntersectionNV();"
"void terminateRayNV();"
"\n");
stageBuiltins[EShLangClosestHitNV].append(
"void traceNVX(accelerationStructureNVX,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);"
"\n");
stageBuiltins[EShLangMissNV].append(
"void traceNVX(accelerationStructureNVX,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);"
"\n");
stageBuiltins[EShLangCallableNV].append(
"void executeCallableNV(uint, int);"
"\n");
}
@ -6107,79 +6113,94 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
}
#ifdef NV_EXTENSIONS
// GL_NV_raytracing
// GL_NV_ray_tracing
if (profile != EEsProfile && version >= 460) {
const char *constRayFlags =
"const uint gl_RayFlagsNoneNVX = 0U;"
"const uint gl_RayFlagsOpaqueNVX = 1U;"
"const uint gl_RayFlagsNoOpaqueNVX = 2U;"
"const uint gl_RayFlagsTerminateOnFirstHitNVX = 4U;"
"const uint gl_RayFlagsSkipClosestHitShaderNVX = 8U;"
"const uint gl_RayFlagsCullBackFacingTrianglesNVX = 16U;"
"const uint gl_RayFlagsCullFrontFacingTrianglesNVX = 32U;"
"const uint gl_RayFlagsCullOpaqueNVX = 64U;"
"const uint gl_RayFlagsCullNoOpaqueNVX = 128U;"
"const uint gl_RayFlagsNoneNV = 0U;"
"const uint gl_RayFlagsOpaqueNV = 1U;"
"const uint gl_RayFlagsNoOpaqueNV = 2U;"
"const uint gl_RayFlagsTerminateOnFirstHitNV = 4U;"
"const uint gl_RayFlagsSkipClosestHitShaderNV = 8U;"
"const uint gl_RayFlagsCullBackFacingTrianglesNV = 16U;"
"const uint gl_RayFlagsCullFrontFacingTrianglesNV = 32U;"
"const uint gl_RayFlagsCullOpaqueNV = 64U;"
"const uint gl_RayFlagsCullNoOpaqueNV = 128U;"
"\n";
const char *rayGenDecls =
"in uvec2 gl_LaunchIDNVX;"
"in uvec2 gl_LaunchSizeNVX;"
"in uvec3 gl_LaunchIDNV;"
"in uvec3 gl_LaunchSizeNV;"
"\n";
const char *intersectDecls =
"in uvec2 gl_LaunchIDNVX;"
"in uvec2 gl_LaunchSizeNVX;"
"in uvec3 gl_LaunchIDNV;"
"in uvec3 gl_LaunchSizeNV;"
"in int gl_PrimitiveID;"
"in int gl_InstanceID;"
"in int gl_InstanceCustomIndexNVX;"
"in vec3 gl_WorldRayOriginNVX;"
"in vec3 gl_WorldRayDirectionNVX;"
"in vec3 gl_ObjectRayOriginNVX;"
"in vec3 gl_ObjectRayDirectionNVX;"
"in float gl_RayTminNVX;"
"in float gl_RayTmaxNVX;"
"in mat4x3 gl_ObjectToWorldNVX;"
"in mat4x3 gl_WorldToObjectNVX;"
"in int gl_InstanceCustomIndexNV;"
"in vec3 gl_WorldRayOriginNV;"
"in vec3 gl_WorldRayDirectionNV;"
"in vec3 gl_ObjectRayOriginNV;"
"in vec3 gl_ObjectRayDirectionNV;"
"in float gl_RayTminNV;"
"in float gl_RayTmaxNV;"
"in mat4x3 gl_ObjectToWorldNV;"
"in mat4x3 gl_WorldToObjectNV;"
"in uint gl_IncomingRayFlagsNV;"
"\n";
const char *hitDecls =
"in uvec2 gl_LaunchIDNVX;"
"in uvec2 gl_LaunchSizeNVX;"
"in uvec3 gl_LaunchIDNV;"
"in uvec3 gl_LaunchSizeNV;"
"in int gl_PrimitiveID;"
"in int gl_InstanceID;"
"in int gl_InstanceCustomIndexNVX;"
"in vec3 gl_WorldRayOriginNVX;"
"in vec3 gl_WorldRayDirectionNVX;"
"in vec3 gl_ObjectRayOriginNVX;"
"in vec3 gl_ObjectRayDirectionNVX;"
"in float gl_RayTminNVX;"
"in float gl_RayTmaxNVX;"
"in float gl_HitTNVX;"
"in uint gl_HitKindNVX;"
"in mat4x3 gl_ObjectToWorldNVX;"
"in mat4x3 gl_WorldToObjectNVX;"
"in int gl_InstanceCustomIndexNV;"
"in vec3 gl_WorldRayOriginNV;"
"in vec3 gl_WorldRayDirectionNV;"
"in vec3 gl_ObjectRayOriginNV;"
"in vec3 gl_ObjectRayDirectionNV;"
"in float gl_RayTminNV;"
"in float gl_RayTmaxNV;"
"in float gl_HitTNV;"
"in uint gl_HitKindNV;"
"in mat4x3 gl_ObjectToWorldNV;"
"in mat4x3 gl_WorldToObjectNV;"
"in uint gl_IncomingRayFlagsNV;"
"\n";
const char *missDecls =
"in uvec2 gl_LaunchIDNVX;"
"in uvec2 gl_LaunchSizeNVX;"
"in vec3 gl_WorldRayOriginNVX;"
"in vec3 gl_WorldRayDirectionNVX;"
"in vec3 gl_ObjectRayOriginNVX;"
"in vec3 gl_ObjectRayDirectionNVX;"
"in float gl_RayTminNVX;"
"in float gl_RayTmaxNVX;"
"in uvec3 gl_LaunchIDNV;"
"in uvec3 gl_LaunchSizeNV;"
"in vec3 gl_WorldRayOriginNV;"
"in vec3 gl_WorldRayDirectionNV;"
"in vec3 gl_ObjectRayOriginNV;"
"in vec3 gl_ObjectRayDirectionNV;"
"in float gl_RayTminNV;"
"in float gl_RayTmaxNV;"
"in uint gl_IncomingRayFlagsNV;"
"\n";
const char *callableDecls =
"in uvec3 gl_LaunchIDNV;"
"in uvec3 gl_LaunchSizeNV;"
"in uint gl_IncomingRayFlagsNV;"
"\n";
stageBuiltins[EShLangRayGenNV].append(rayGenDecls);
stageBuiltins[EShLangRayGenNV].append(constRayFlags);
stageBuiltins[EShLangIntersectNV].append(intersectDecls);
stageBuiltins[EShLangIntersectNV].append(constRayFlags);
stageBuiltins[EShLangAnyHitNV].append(hitDecls);
stageBuiltins[EShLangAnyHitNV].append(constRayFlags);
stageBuiltins[EShLangClosestHitNV].append(hitDecls);
stageBuiltins[EShLangClosestHitNV].append(constRayFlags);
stageBuiltins[EShLangMissNV].append(missDecls);
stageBuiltins[EShLangMissNV].append(constRayFlags);
stageBuiltins[EShLangCallableNV].append(callableDecls);
stageBuiltins[EShLangCallableNV].append(constRayFlags);
}
if ((profile != EEsProfile && version >= 140)) {
const char *deviceIndex =
@ -8600,39 +8621,43 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
case EShLangAnyHitNV:
case EShLangClosestHitNV:
case EShLangMissNV:
case EShLangCallableNV:
if (profile != EEsProfile && version >= 460) {
symbolTable.setVariableExtensions("gl_LaunchIDNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_LaunchSizeNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_PrimitiveID", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_InstanceID", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_InstanceCustomIndexNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_WorldRayOriginNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_WorldRayDirectionNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_ObjectRayOriginNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_ObjectRayDirectionNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_RayTminNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_RayTmaxNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_HitTNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_HitKindNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_ObjectToWorldNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_WorldToObjectNVX", 1, &E_GL_NVX_raytracing);
symbolTable.setVariableExtensions("gl_LaunchIDNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_LaunchSizeNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_PrimitiveID", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_InstanceID", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_InstanceCustomIndexNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_WorldRayOriginNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_WorldRayDirectionNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_ObjectRayOriginNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_ObjectRayDirectionNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_RayTminNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_RayTmaxNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_HitTNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_HitKindNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_ObjectToWorldNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_WorldToObjectNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_IncomingRayFlagsNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setVariableExtensions("gl_DeviceIndex", 1, &E_GL_EXT_device_group);
BuiltInVariable("gl_LaunchIDNVX", EbvLaunchIdNV, symbolTable);
BuiltInVariable("gl_LaunchSizeNVX", EbvLaunchSizeNV, symbolTable);
BuiltInVariable("gl_LaunchIDNV", EbvLaunchIdNV, symbolTable);
BuiltInVariable("gl_LaunchSizeNV", EbvLaunchSizeNV, symbolTable);
BuiltInVariable("gl_PrimitiveID", EbvPrimitiveId, symbolTable);
BuiltInVariable("gl_InstanceID", EbvInstanceId, symbolTable);
BuiltInVariable("gl_InstanceCustomIndexNVX",EbvInstanceCustomIndexNV,symbolTable);
BuiltInVariable("gl_WorldRayOriginNVX", EbvWorldRayOriginNV, symbolTable);
BuiltInVariable("gl_WorldRayDirectionNVX", EbvWorldRayDirectionNV, symbolTable);
BuiltInVariable("gl_ObjectRayOriginNVX", EbvObjectRayOriginNV, symbolTable);
BuiltInVariable("gl_ObjectRayDirectionNVX", EbvObjectRayDirectionNV, symbolTable);
BuiltInVariable("gl_RayTminNVX", EbvRayTminNV, symbolTable);
BuiltInVariable("gl_RayTmaxNVX", EbvRayTmaxNV, symbolTable);
BuiltInVariable("gl_HitTNVX", EbvHitTNV, symbolTable);
BuiltInVariable("gl_HitKindNVX", EbvHitKindNV, symbolTable);
BuiltInVariable("gl_ObjectToWorldNVX", EbvObjectToWorldNV, symbolTable);
BuiltInVariable("gl_WorldToObjectNVX", EbvWorldToObjectNV, symbolTable);
BuiltInVariable("gl_InstanceCustomIndexNV", EbvInstanceCustomIndexNV,symbolTable);
BuiltInVariable("gl_WorldRayOriginNV", EbvWorldRayOriginNV, symbolTable);
BuiltInVariable("gl_WorldRayDirectionNV", EbvWorldRayDirectionNV, symbolTable);
BuiltInVariable("gl_ObjectRayOriginNV", EbvObjectRayOriginNV, symbolTable);
BuiltInVariable("gl_ObjectRayDirectionNV", EbvObjectRayDirectionNV, symbolTable);
BuiltInVariable("gl_RayTminNV", EbvRayTminNV, symbolTable);
BuiltInVariable("gl_RayTmaxNV", EbvRayTmaxNV, symbolTable);
BuiltInVariable("gl_HitTNV", EbvHitTNV, symbolTable);
BuiltInVariable("gl_HitKindNV", EbvHitKindNV, symbolTable);
BuiltInVariable("gl_ObjectToWorldNV", EbvObjectToWorldNV, symbolTable);
BuiltInVariable("gl_WorldToObjectNV", EbvWorldToObjectNV, symbolTable);
BuiltInVariable("gl_IncomingRayFlagsNV", EbvIncomingRayFlagsNV, symbolTable);
BuiltInVariable("gl_DeviceIndex", EbvDeviceIndex, symbolTable);
}
break;
@ -9373,17 +9398,24 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
case EShLangRayGenNV:
case EShLangClosestHitNV:
case EShLangMissNV:
if (profile != EEsProfile && version >= 460)
symbolTable.relateToOperator("traceNVX", EOpTraceNV);
if (profile != EEsProfile && version >= 460) {
symbolTable.relateToOperator("traceNV", EOpTraceNV);
symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallableNV);
}
break;
case EShLangIntersectNV:
if (profile != EEsProfile && version >= 460)
symbolTable.relateToOperator("reportIntersectionNVX", EOpReportIntersectionNV);
symbolTable.relateToOperator("reportIntersectionNV", EOpReportIntersectionNV);
break;
case EShLangAnyHitNV:
if (profile != EEsProfile && version >= 460) {
symbolTable.relateToOperator("ignoreIntersectionNVX", EOpIgnoreIntersectionNV);
symbolTable.relateToOperator("terminateRayNVX", EOpTerminateRayNV);
symbolTable.relateToOperator("ignoreIntersectionNV", EOpIgnoreIntersectionNV);
symbolTable.relateToOperator("terminateRayNV", EOpTerminateRayNV);
}
break;
case EShLangCallableNV:
if (profile != EEsProfile && version >= 460) {
symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallableNV);
}
break;
case EShLangMeshNV:

4
glslang/MachineIndependent/ParseContextBase.cpp
View file

@ -156,7 +156,7 @@ bool TParseContextBase::lValueErrorCheck(const TSourceLoc& loc, const char* op,
#ifdef NV_EXTENSIONS
case EvqHitAttrNV:
if (language != EShLangIntersectNV)
message = "cannot modify hitAttributeNVX in this stage";
message = "cannot modify hitAttributeNV in this stage";
break;
#endif
@ -176,7 +176,7 @@ bool TParseContextBase::lValueErrorCheck(const TSourceLoc& loc, const char* op,
break;
#ifdef NV_EXTENSIONS
case EbtAccStructNV:
message = "can't modify accelerationStructureNVX";
message = "can't modify accelerationStructureNV";
break;
#endif
default:

56
glslang/MachineIndependent/ParseHelper.cpp
View file

@ -1872,6 +1872,17 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
break;
}
#ifdef NV_EXTENSIONS
case EOpTraceNV:
if (!(*argp)[10]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "payload number", "");
break;
case EOpExecuteCallableNV:
if (!(*argp)[1]->getAsConstantUnion())
error(loc, "argument must be compile-time constant", "callable data number", "");
break;
#endif
case EOpTextureQuerySamples:
case EOpImageQuerySamples:
// GL_ARB_shader_texture_image_samples
@ -2990,9 +3001,9 @@ void TParseContext::accStructNVCheck(const TSourceLoc& loc, const TType& type, c
return;
if (type.getBasicType() == EbtStruct && containsFieldWithBasicType(type, EbtAccStructNV))
error(loc, "non-uniform struct contains an accelerationStructureNVX:", type.getBasicTypeString().c_str(), identifier.c_str());
error(loc, "non-uniform struct contains an accelerationStructureNV:", type.getBasicTypeString().c_str(), identifier.c_str());
else if (type.getBasicType() == EbtAccStructNV && type.getQualifier().storage != EvqUniform)
error(loc, "accelerationStructureNVX can only be used in uniform variables or function parameters:",
error(loc, "accelerationStructureNV can only be used in uniform variables or function parameters:",
type.getBasicTypeString().c_str(), identifier.c_str());
}
@ -4778,7 +4789,7 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
if (language == EShLangRayGenNV || language == EShLangIntersectNV ||
language == EShLangAnyHitNV || language == EShLangClosestHitNV ||
language == EShLangMissNV || language == EShLangCallableNV) {
if (id == "shaderrecordnvx") {
if (id == "shaderrecordnv") {
publicType.qualifier.layoutShaderRecordNV = true;
return;
}
@ -5236,7 +5247,7 @@ void TParseContext::layoutObjectCheck(const TSourceLoc& loc, const TSymbol& symb
error(loc, "can only specify on a uniform block", "push_constant", "");
#ifdef NV_EXTENSIONS
if (qualifier.layoutShaderRecordNV)
error(loc, "can only specify on a buffer block", "shaderRecordNVX", "");
error(loc, "can only specify on a buffer block", "shaderRecordNV", "");
#endif
}
break;
@ -5315,6 +5326,8 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
case EvqPayloadNV:
case EvqPayloadInNV:
case EvqHitAttrNV:
case EvqCallableDataNV:
case EvqCallableDataInNV:
break;
#endif
default:
@ -5457,7 +5470,7 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
#ifdef NV_EXTENSIONS
if (qualifier.layoutShaderRecordNV && type.getBasicType() != EbtBlock)
error(loc, "can only be used with a block", "shaderRecordNVX", "");
error(loc, "can only be used with a block", "shaderRecordNV", "");
#endif
// input attachment
@ -5598,11 +5611,15 @@ void TParseContext::layoutQualifierCheck(const TSourceLoc& loc, const TQualifier
#ifdef NV_EXTENSIONS
if (qualifier.layoutShaderRecordNV) {
if (qualifier.storage != EvqBuffer)
error(loc, "can only be used with a buffer", "shaderRecordNVX", "");
error(loc, "can only be used with a buffer", "shaderRecordNV", "");
if (qualifier.hasBinding())
error(loc, "cannot be used with shaderRecordNVX", "binding", "");
error(loc, "cannot be used with shaderRecordNV", "binding", "");
if (qualifier.hasSet())
error(loc, "cannot be used with shaderRecordNVX", "set", "");
error(loc, "cannot be used with shaderRecordNV", "set", "");
}
if (qualifier.storage == EvqHitAttrNV && qualifier.hasLayout()) {
error(loc, "cannot apply layout qualifiers to hitAttributeNV variable", "hitAttributeNV", "");
}
#endif
}
@ -6963,18 +6980,27 @@ void TParseContext::blockStageIoCheck(const TSourceLoc& loc, const TQualifier& q
break;
#ifdef NV_EXTENSIONS
case EvqPayloadNV:
profileRequires(loc, ~EEsProfile, 450, E_GL_NVX_raytracing, "rayPayloadNVX block");
profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "rayPayloadNV block");
requireStage(loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangAnyHitNVMask | EShLangClosestHitNVMask | EShLangMissNVMask),
"rayPayloadNVX block");
"rayPayloadNV block");
break;
case EvqPayloadInNV:
profileRequires(loc, ~EEsProfile, 450, E_GL_NVX_raytracing, "rayPayloadInNVX block");
profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "rayPayloadInNV block");
requireStage(loc, (EShLanguageMask)(EShLangAnyHitNVMask | EShLangClosestHitNVMask | EShLangMissNVMask),
"rayPayloadInNVX block");
"rayPayloadInNV block");
break;
case EvqHitAttrNV:
profileRequires(loc, ~EEsProfile, 450, E_GL_NVX_raytracing, "hitAttributeNVX block");
requireStage(loc, (EShLanguageMask)(EShLangIntersectNVMask | EShLangAnyHitNVMask | EShLangClosestHitNVMask), "hitAttributeNVX block");
profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "hitAttributeNV block");
requireStage(loc, (EShLanguageMask)(EShLangIntersectNVMask | EShLangAnyHitNVMask | EShLangClosestHitNVMask), "hitAttributeNV block");
break;
case EvqCallableDataNV:
profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "callableDataNV block");
requireStage(loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangClosestHitNVMask | EShLangMissNVMask | EShLangCallableNVMask),
"callableDataNV block");
break;
case EvqCallableDataInNV:
profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "callableDataInNV block");
requireStage(loc, (EShLanguageMask)(EShLangCallableNVMask), "callableDataInNV block");
break;
#endif
default:
@ -7503,7 +7529,7 @@ void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, con
error(loc, "cannot declare a default, can only be used on a scalar", "constant_id", "");
#ifdef NV_EXTENSIONS
if (qualifier.layoutShaderRecordNV)
error(loc, "cannot declare a default, can only be used on a block", "shaderRecordNVX", "");
error(loc, "cannot declare a default, can only be used on a block", "shaderRecordNV", "");
#endif
}

14
glslang/MachineIndependent/Scan.cpp
View file

@ -701,10 +701,12 @@ void TScanContext::fillInKeywordMap()
(*KeywordMap)["superp"] = SUPERP;
#ifdef NV_EXTENSIONS
(*KeywordMap)["rayPayloadNVX"] = PAYLOADNV;
(*KeywordMap)["rayPayloadInNVX"] = PAYLOADINNV;
(*KeywordMap)["hitAttributeNVX"] = HITATTRNV;
(*KeywordMap)["accelerationStructureNVX"] = ACCSTRUCTNV;
(*KeywordMap)["rayPayloadNV"] = PAYLOADNV;
(*KeywordMap)["rayPayloadInNV"] = PAYLOADINNV;
(*KeywordMap)["hitAttributeNV"] = HITATTRNV;
(*KeywordMap)["callableDataNV"] = CALLDATANV;
(*KeywordMap)["callableDataInNV"] = CALLDATAINNV;
(*KeywordMap)["accelerationStructureNV"] = ACCSTRUCTNV;
(*KeywordMap)["perprimitiveNV"] = PERPRIMITIVENV;
(*KeywordMap)["perviewNV"] = PERVIEWNV;
(*KeywordMap)["taskNV"] = PERTASKNV;
@ -952,10 +954,12 @@ int TScanContext::tokenizeIdentifier()
case PAYLOADNV:
case PAYLOADINNV:
case HITATTRNV:
case CALLDATANV:
case CALLDATAINNV:
case ACCSTRUCTNV:
if (parseContext.symbolTable.atBuiltInLevel() ||
(parseContext.profile != EEsProfile && parseContext.version >= 460
&& parseContext.extensionTurnedOn(E_GL_NVX_raytracing)))
&& parseContext.extensionTurnedOn(E_GL_NV_ray_tracing)))
return keyword;
return identifierOrType();
#endif

4
glslang/MachineIndependent/ShaderLang.cpp
View file

@ -360,6 +360,8 @@ bool InitializeSymbolTables(TInfoSink& infoSink, TSymbolTable** commonTable, TS
infoSink, commonTable, symbolTables);
InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangMissNV, source,
infoSink, commonTable, symbolTables);
InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangCallableNV, source,
infoSink, commonTable, symbolTables);
}
// check for mesh
@ -607,7 +609,7 @@ bool DeduceVersionProfile(TInfoSink& infoSink, EShLanguage stage, bool versionNo
case EShLangCallableNV:
if (profile == EEsProfile || version < 460) {
correct = false;
infoSink.info.message(EPrefixError, "#version: raytracing shaders require non-es profile with version 460 or above");
infoSink.info.message(EPrefixError, "#version: ray tracing shaders require non-es profile with version 460 or above");
version = 460;
}
break;

4
glslang/MachineIndependent/Versions.cpp
View file

@ -236,7 +236,7 @@ void TParseVersions::initializeExtensionBehavior()
extensionBehavior[E_GL_NV_shader_noperspective_interpolation] = EBhDisable;
extensionBehavior[E_GL_NV_shader_subgroup_partitioned] = EBhDisable;
extensionBehavior[E_GL_NV_shading_rate_image] = EBhDisable;
extensionBehavior[E_GL_NVX_raytracing] = EBhDisable;
extensionBehavior[E_GL_NV_ray_tracing] = EBhDisable;
extensionBehavior[E_GL_NV_fragment_shader_barycentric] = EBhDisable;
extensionBehavior[E_GL_NV_compute_shader_derivatives] = EBhDisable;
extensionBehavior[E_GL_NV_shader_texture_footprint] = EBhDisable;
@ -412,7 +412,7 @@ void TParseVersions::getPreamble(std::string& preamble)
"#define GL_NV_conservative_raster_underestimation 1\n"
"#define GL_NV_shader_subgroup_partitioned 1\n"
"#define GL_NV_shading_rate_image 1\n"
"#define GL_NVX_raytracing 1\n"
"#define GL_NV_ray_tracing 1\n"
"#define GL_NV_fragment_shader_barycentric 1\n"
"#define GL_NV_compute_shader_derivatives 1\n"
"#define GL_NV_shader_texture_footprint 1\n"

2
glslang/MachineIndependent/Versions.h
View file

@ -208,7 +208,7 @@ const char* const E_GL_NV_conservative_raster_underestimation = "GL_NV_conserv
const char* const E_GL_NV_shader_noperspective_interpolation = "GL_NV_shader_noperspective_interpolation";
const char* const E_GL_NV_shader_subgroup_partitioned = "GL_NV_shader_subgroup_partitioned";
const char* const E_GL_NV_shading_rate_image = "GL_NV_shading_rate_image";
const char* const E_GL_NVX_raytracing = "GL_NVX_raytracing";
const char* const E_GL_NV_ray_tracing = "GL_NV_ray_tracing";
const char* const E_GL_NV_fragment_shader_barycentric = "GL_NV_fragment_shader_barycentric";
const char* const E_GL_NV_compute_shader_derivatives = "GL_NV_compute_shader_derivatives";
const char* const E_GL_NV_shader_texture_footprint = "GL_NV_shader_texture_footprint";

39
glslang/MachineIndependent/glslang.y
View file

@ -140,7 +140,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
%token <lex> U8VEC2 U8VEC3 U8VEC4
%token <lex> VEC2 VEC3 VEC4
%token <lex> MAT2 MAT3 MAT4 CENTROID IN OUT INOUT
%token <lex> UNIFORM PATCH SAMPLE BUFFER SHARED NONUNIFORM PAYLOADNV PAYLOADINNV HITATTRNV
%token <lex> UNIFORM PATCH SAMPLE BUFFER SHARED NONUNIFORM PAYLOADNV PAYLOADINNV HITATTRNV CALLDATANV CALLDATAINNV
%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT SUBGROUPCOHERENT NONPRIVATE
%token <lex> DVEC2 DVEC3 DVEC4 DMAT2 DMAT3 DMAT4
%token <lex> F16VEC2 F16VEC3 F16VEC4 F16MAT2 F16MAT3 F16MAT4
@ -1348,32 +1348,51 @@ storage_qualifier
}
| HITATTRNV {
#ifdef NV_EXTENSIONS
parseContext.globalCheck($1.loc, "hitAttributeNVX");
parseContext.globalCheck($1.loc, "hitAttributeNV");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangIntersectNVMask | EShLangClosestHitNVMask
| EShLangAnyHitNVMask), "hitAttributeNVX");
parseContext.profileRequires($1.loc, ECoreProfile, 450, E_GL_NVX_raytracing, "hitAttributeNVX");
| EShLangAnyHitNVMask), "hitAttributeNV");
parseContext.profileRequires($1.loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "hitAttributeNV");
$$.init($1.loc);
$$.qualifier.storage = EvqHitAttrNV;
#endif
}
| PAYLOADNV {
#ifdef NV_EXTENSIONS
parseContext.globalCheck($1.loc, "rayPayloadNVX");
parseContext.globalCheck($1.loc, "rayPayloadNV");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangClosestHitNVMask |
EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadNVX");
parseContext.profileRequires($1.loc, ECoreProfile, 450, E_GL_NVX_raytracing, "rayPayloadNVX");
EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadNV");
parseContext.profileRequires($1.loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadNV");
$$.init($1.loc);
$$.qualifier.storage = EvqPayloadNV;
#endif
}
| PAYLOADINNV {
#ifdef NV_EXTENSIONS
parseContext.globalCheck($1.loc, "rayPayloadInNVX");
parseContext.globalCheck($1.loc, "rayPayloadInNV");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangClosestHitNVMask |
EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadInNVX");
parseContext.profileRequires($1.loc, ECoreProfile, 450, E_GL_NVX_raytracing, "rayPayloadInNVX");
EShLangAnyHitNVMask | EShLangMissNVMask), "rayPayloadInNV");
parseContext.profileRequires($1.loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "rayPayloadInNV");
$$.init($1.loc);
$$.qualifier.storage = EvqPayloadInNV;
#endif
}
| CALLDATANV {
#ifdef NV_EXTENSIONS
parseContext.globalCheck($1.loc, "callableDataNV");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangRayGenNVMask |
EShLangClosestHitNVMask | EShLangMissNVMask | EShLangCallableNVMask), "callableDataNV");
parseContext.profileRequires($1.loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataNV");
$$.init($1.loc);
$$.qualifier.storage = EvqCallableDataNV;
#endif
}
| CALLDATAINNV {
#ifdef NV_EXTENSIONS
parseContext.globalCheck($1.loc, "callableDataInNV");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangCallableNVMask), "callableDataInNV");
parseContext.profileRequires($1.loc, ECoreProfile, 460, E_GL_NV_ray_tracing, "callableDataInNV");
$$.init($1.loc);
$$.qualifier.storage = EvqCallableDataInNV;
#endif
}
| SHARED {

7729
glslang/MachineIndependent/glslang_tab.cpp
View file

File diff suppressed because it is too large Load diff

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

@ -128,324 +128,326 @@ extern int yydebug;
PAYLOADNV = 338,
PAYLOADINNV = 339,
HITATTRNV = 340,
COHERENT = 341,
VOLATILE = 342,
RESTRICT = 343,
READONLY = 344,
WRITEONLY = 345,
DEVICECOHERENT = 346,
QUEUEFAMILYCOHERENT = 347,
WORKGROUPCOHERENT = 348,
SUBGROUPCOHERENT = 349,
NONPRIVATE = 350,
DVEC2 = 351,
DVEC3 = 352,
DVEC4 = 353,
DMAT2 = 354,
DMAT3 = 355,
DMAT4 = 356,
F16VEC2 = 357,
F16VEC3 = 358,
F16VEC4 = 359,
F16MAT2 = 360,
F16MAT3 = 361,
F16MAT4 = 362,
F32VEC2 = 363,
F32VEC3 = 364,
F32VEC4 = 365,
F32MAT2 = 366,
F32MAT3 = 367,
F32MAT4 = 368,
F64VEC2 = 369,
F64VEC3 = 370,
F64VEC4 = 371,
F64MAT2 = 372,
F64MAT3 = 373,
F64MAT4 = 374,
NOPERSPECTIVE = 375,
FLAT = 376,
SMOOTH = 377,
LAYOUT = 378,
EXPLICITINTERPAMD = 379,
PERVERTEXNV = 380,
PERPRIMITIVENV = 381,
PERVIEWNV = 382,
PERTASKNV = 383,
MAT2X2 = 384,
MAT2X3 = 385,
MAT2X4 = 386,
MAT3X2 = 387,
MAT3X3 = 388,
MAT3X4 = 389,
MAT4X2 = 390,
MAT4X3 = 391,
MAT4X4 = 392,
DMAT2X2 = 393,
DMAT2X3 = 394,
DMAT2X4 = 395,
DMAT3X2 = 396,
DMAT3X3 = 397,
DMAT3X4 = 398,
DMAT4X2 = 399,
DMAT4X3 = 400,
DMAT4X4 = 401,
F16MAT2X2 = 402,
F16MAT2X3 = 403,
F16MAT2X4 = 404,
F16MAT3X2 = 405,
F16MAT3X3 = 406,
F16MAT3X4 = 407,
F16MAT4X2 = 408,
F16MAT4X3 = 409,
F16MAT4X4 = 410,
F32MAT2X2 = 411,
F32MAT2X3 = 412,
F32MAT2X4 = 413,
F32MAT3X2 = 414,
F32MAT3X3 = 415,
F32MAT3X4 = 416,
F32MAT4X2 = 417,
F32MAT4X3 = 418,
F32MAT4X4 = 419,
F64MAT2X2 = 420,
F64MAT2X3 = 421,
F64MAT2X4 = 422,
F64MAT3X2 = 423,
F64MAT3X3 = 424,
F64MAT3X4 = 425,
F64MAT4X2 = 426,
F64MAT4X3 = 427,
F64MAT4X4 = 428,
ATOMIC_UINT = 429,
ACCSTRUCTNV = 430,
SAMPLER1D = 431,
SAMPLER2D = 432,
SAMPLER3D = 433,
SAMPLERCUBE = 434,
SAMPLER1DSHADOW = 435,
SAMPLER2DSHADOW = 436,
SAMPLERCUBESHADOW = 437,
SAMPLER1DARRAY = 438,
SAMPLER2DARRAY = 439,
SAMPLER1DARRAYSHADOW = 440,
SAMPLER2DARRAYSHADOW = 441,
ISAMPLER1D = 442,
ISAMPLER2D = 443,
ISAMPLER3D = 444,
ISAMPLERCUBE = 445,
ISAMPLER1DARRAY = 446,
ISAMPLER2DARRAY = 447,
USAMPLER1D = 448,
USAMPLER2D = 449,
USAMPLER3D = 450,
USAMPLERCUBE = 451,
USAMPLER1DARRAY = 452,
USAMPLER2DARRAY = 453,
SAMPLER2DRECT = 454,
SAMPLER2DRECTSHADOW = 455,
ISAMPLER2DRECT = 456,
USAMPLER2DRECT = 457,
SAMPLERBUFFER = 458,
ISAMPLERBUFFER = 459,
USAMPLERBUFFER = 460,
SAMPLERCUBEARRAY = 461,
SAMPLERCUBEARRAYSHADOW = 462,
ISAMPLERCUBEARRAY = 463,
USAMPLERCUBEARRAY = 464,
SAMPLER2DMS = 465,
ISAMPLER2DMS = 466,
USAMPLER2DMS = 467,
SAMPLER2DMSARRAY = 468,
ISAMPLER2DMSARRAY = 469,
USAMPLER2DMSARRAY = 470,
SAMPLEREXTERNALOES = 471,
F16SAMPLER1D = 472,
F16SAMPLER2D = 473,
F16SAMPLER3D = 474,
F16SAMPLER2DRECT = 475,
F16SAMPLERCUBE = 476,
F16SAMPLER1DARRAY = 477,
F16SAMPLER2DARRAY = 478,
F16SAMPLERCUBEARRAY = 479,
F16SAMPLERBUFFER = 480,
F16SAMPLER2DMS = 481,
F16SAMPLER2DMSARRAY = 482,
F16SAMPLER1DSHADOW = 483,
F16SAMPLER2DSHADOW = 484,
F16SAMPLER1DARRAYSHADOW = 485,
F16SAMPLER2DARRAYSHADOW = 486,
F16SAMPLER2DRECTSHADOW = 487,
F16SAMPLERCUBESHADOW = 488,
F16SAMPLERCUBEARRAYSHADOW = 489,
SAMPLER = 490,
SAMPLERSHADOW = 491,
TEXTURE1D = 492,
TEXTURE2D = 493,
TEXTURE3D = 494,
TEXTURECUBE = 495,
TEXTURE1DARRAY = 496,
TEXTURE2DARRAY = 497,
ITEXTURE1D = 498,
ITEXTURE2D = 499,
ITEXTURE3D = 500,
ITEXTURECUBE = 501,
ITEXTURE1DARRAY = 502,
ITEXTURE2DARRAY = 503,
UTEXTURE1D = 504,
UTEXTURE2D = 505,
UTEXTURE3D = 506,
UTEXTURECUBE = 507,
UTEXTURE1DARRAY = 508,
UTEXTURE2DARRAY = 509,
TEXTURE2DRECT = 510,
ITEXTURE2DRECT = 511,
UTEXTURE2DRECT = 512,
TEXTUREBUFFER = 513,
ITEXTUREBUFFER = 514,
UTEXTUREBUFFER = 515,
TEXTURECUBEARRAY = 516,
ITEXTURECUBEARRAY = 517,
UTEXTURECUBEARRAY = 518,
TEXTURE2DMS = 519,
ITEXTURE2DMS = 520,
UTEXTURE2DMS = 521,
TEXTURE2DMSARRAY = 522,
ITEXTURE2DMSARRAY = 523,
UTEXTURE2DMSARRAY = 524,
F16TEXTURE1D = 525,
F16TEXTURE2D = 526,
F16TEXTURE3D = 527,
F16TEXTURE2DRECT = 528,
F16TEXTURECUBE = 529,
F16TEXTURE1DARRAY = 530,
F16TEXTURE2DARRAY = 531,
F16TEXTURECUBEARRAY = 532,
F16TEXTUREBUFFER = 533,
F16TEXTURE2DMS = 534,
F16TEXTURE2DMSARRAY = 535,
SUBPASSINPUT = 536,
SUBPASSINPUTMS = 537,
ISUBPASSINPUT = 538,
ISUBPASSINPUTMS = 539,
USUBPASSINPUT = 540,
USUBPASSINPUTMS = 541,
F16SUBPASSINPUT = 542,
F16SUBPASSINPUTMS = 543,
IMAGE1D = 544,
IIMAGE1D = 545,
UIMAGE1D = 546,
IMAGE2D = 547,
IIMAGE2D = 548,
UIMAGE2D = 549,
IMAGE3D = 550,
IIMAGE3D = 551,
UIMAGE3D = 552,
IMAGE2DRECT = 553,
IIMAGE2DRECT = 554,
UIMAGE2DRECT = 555,
IMAGECUBE = 556,
IIMAGECUBE = 557,
UIMAGECUBE = 558,
IMAGEBUFFER = 559,
IIMAGEBUFFER = 560,
UIMAGEBUFFER = 561,
IMAGE1DARRAY = 562,
IIMAGE1DARRAY = 563,
UIMAGE1DARRAY = 564,
IMAGE2DARRAY = 565,
IIMAGE2DARRAY = 566,
UIMAGE2DARRAY = 567,
IMAGECUBEARRAY = 568,
IIMAGECUBEARRAY = 569,
UIMAGECUBEARRAY = 570,
IMAGE2DMS = 571,
IIMAGE2DMS = 572,
UIMAGE2DMS = 573,
IMAGE2DMSARRAY = 574,
IIMAGE2DMSARRAY = 575,
UIMAGE2DMSARRAY = 576,
F16IMAGE1D = 577,
F16IMAGE2D = 578,
F16IMAGE3D = 579,
F16IMAGE2DRECT = 580,
F16IMAGECUBE = 581,
F16IMAGE1DARRAY = 582,
F16IMAGE2DARRAY = 583,
F16IMAGECUBEARRAY = 584,
F16IMAGEBUFFER = 585,
F16IMAGE2DMS = 586,
F16IMAGE2DMSARRAY = 587,
STRUCT = 588,
VOID = 589,
WHILE = 590,
IDENTIFIER = 591,
TYPE_NAME = 592,
FLOATCONSTANT = 593,
DOUBLECONSTANT = 594,
INT16CONSTANT = 595,
UINT16CONSTANT = 596,
INT32CONSTANT = 597,
UINT32CONSTANT = 598,
INTCONSTANT = 599,
UINTCONSTANT = 600,
INT64CONSTANT = 601,
UINT64CONSTANT = 602,
BOOLCONSTANT = 603,
FLOAT16CONSTANT = 604,
LEFT_OP = 605,
RIGHT_OP = 606,
INC_OP = 607,
DEC_OP = 608,
LE_OP = 609,
GE_OP = 610,
EQ_OP = 611,
NE_OP = 612,
AND_OP = 613,
OR_OP = 614,
XOR_OP = 615,
MUL_ASSIGN = 616,
DIV_ASSIGN = 617,
ADD_ASSIGN = 618,
MOD_ASSIGN = 619,
LEFT_ASSIGN = 620,
RIGHT_ASSIGN = 621,
AND_ASSIGN = 622,
XOR_ASSIGN = 623,
OR_ASSIGN = 624,
SUB_ASSIGN = 625,
LEFT_PAREN = 626,
RIGHT_PAREN = 627,
LEFT_BRACKET = 628,
RIGHT_BRACKET = 629,
LEFT_BRACE = 630,
RIGHT_BRACE = 631,
DOT = 632,
COMMA = 633,
COLON = 634,
EQUAL = 635,
SEMICOLON = 636,
BANG = 637,
DASH = 638,
TILDE = 639,
PLUS = 640,
STAR = 641,
SLASH = 642,
PERCENT = 643,
LEFT_ANGLE = 644,
RIGHT_ANGLE = 645,
VERTICAL_BAR = 646,
CARET = 647,
AMPERSAND = 648,
QUESTION = 649,
INVARIANT = 650,
PRECISE = 651,
HIGH_PRECISION = 652,
MEDIUM_PRECISION = 653,
LOW_PRECISION = 654,
PRECISION = 655,
PACKED = 656,
RESOURCE = 657,
SUPERP = 658
CALLDATANV = 341,
CALLDATAINNV = 342,
COHERENT = 343,
VOLATILE = 344,
RESTRICT = 345,
READONLY = 346,
WRITEONLY = 347,
DEVICECOHERENT = 348,
QUEUEFAMILYCOHERENT = 349,
WORKGROUPCOHERENT = 350,
SUBGROUPCOHERENT = 351,
NONPRIVATE = 352,
DVEC2 = 353,
DVEC3 = 354,
DVEC4 = 355,
DMAT2 = 356,
DMAT3 = 357,
DMAT4 = 358,
F16VEC2 = 359,
F16VEC3 = 360,
F16VEC4 = 361,
F16MAT2 = 362,
F16MAT3 = 363,
F16MAT4 = 364,
F32VEC2 = 365,
F32VEC3 = 366,
F32VEC4 = 367,
F32MAT2 = 368,
F32MAT3 = 369,
F32MAT4 = 370,
F64VEC2 = 371,
F64VEC3 = 372,
F64VEC4 = 373,
F64MAT2 = 374,
F64MAT3 = 375,
F64MAT4 = 376,
NOPERSPECTIVE = 377,
FLAT = 378,
SMOOTH = 379,
LAYOUT = 380,
EXPLICITINTERPAMD = 381,
PERVERTEXNV = 382,
PERPRIMITIVENV = 383,
PERVIEWNV = 384,
PERTASKNV = 385,
MAT2X2 = 386,
MAT2X3 = 387,
MAT2X4 = 388,
MAT3X2 = 389,
MAT3X3 = 390,
MAT3X4 = 391,
MAT4X2 = 392,
MAT4X3 = 393,
MAT4X4 = 394,
DMAT2X2 = 395,
DMAT2X3 = 396,
DMAT2X4 = 397,
DMAT3X2 = 398,
DMAT3X3 = 399,
DMAT3X4 = 400,
DMAT4X2 = 401,
DMAT4X3 = 402,
DMAT4X4 = 403,
F16MAT2X2 = 404,
F16MAT2X3 = 405,
F16MAT2X4 = 406,
F16MAT3X2 = 407,
F16MAT3X3 = 408,
F16MAT3X4 = 409,
F16MAT4X2 = 410,
F16MAT4X3 = 411,
F16MAT4X4 = 412,
F32MAT2X2 = 413,
F32MAT2X3 = 414,
F32MAT2X4 = 415,
F32MAT3X2 = 416,
F32MAT3X3 = 417,
F32MAT3X4 = 418,
F32MAT4X2 = 419,
F32MAT4X3 = 420,
F32MAT4X4 = 421,
F64MAT2X2 = 422,
F64MAT2X3 = 423,
F64MAT2X4 = 424,
F64MAT3X2 = 425,
F64MAT3X3 = 426,
F64MAT3X4 = 427,
F64MAT4X2 = 428,
F64MAT4X3 = 429,
F64MAT4X4 = 430,
ATOMIC_UINT = 431,
ACCSTRUCTNV = 432,
SAMPLER1D = 433,
SAMPLER2D = 434,
SAMPLER3D = 435,
SAMPLERCUBE = 436,
SAMPLER1DSHADOW = 437,
SAMPLER2DSHADOW = 438,
SAMPLERCUBESHADOW = 439,
SAMPLER1DARRAY = 440,
SAMPLER2DARRAY = 441,
SAMPLER1DARRAYSHADOW = 442,
SAMPLER2DARRAYSHADOW = 443,
ISAMPLER1D = 444,
ISAMPLER2D = 445,
ISAMPLER3D = 446,
ISAMPLERCUBE = 447,
ISAMPLER1DARRAY = 448,
ISAMPLER2DARRAY = 449,
USAMPLER1D = 450,
USAMPLER2D = 451,
USAMPLER3D = 452,
USAMPLERCUBE = 453,
USAMPLER1DARRAY = 454,
USAMPLER2DARRAY = 455,
SAMPLER2DRECT = 456,
SAMPLER2DRECTSHADOW = 457,
ISAMPLER2DRECT = 458,
USAMPLER2DRECT = 459,
SAMPLERBUFFER = 460,
ISAMPLERBUFFER = 461,
USAMPLERBUFFER = 462,
SAMPLERCUBEARRAY = 463,
SAMPLERCUBEARRAYSHADOW = 464,
ISAMPLERCUBEARRAY = 465,
USAMPLERCUBEARRAY = 466,
SAMPLER2DMS = 467,
ISAMPLER2DMS = 468,
USAMPLER2DMS = 469,
SAMPLER2DMSARRAY = 470,
ISAMPLER2DMSARRAY = 471,
USAMPLER2DMSARRAY = 472,
SAMPLEREXTERNALOES = 473,
F16SAMPLER1D = 474,
F16SAMPLER2D = 475,
F16SAMPLER3D = 476,
F16SAMPLER2DRECT = 477,
F16SAMPLERCUBE = 478,
F16SAMPLER1DARRAY = 479,
F16SAMPLER2DARRAY = 480,
F16SAMPLERCUBEARRAY = 481,
F16SAMPLERBUFFER = 482,
F16SAMPLER2DMS = 483,
F16SAMPLER2DMSARRAY = 484,
F16SAMPLER1DSHADOW = 485,
F16SAMPLER2DSHADOW = 486,
F16SAMPLER1DARRAYSHADOW = 487,
F16SAMPLER2DARRAYSHADOW = 488,
F16SAMPLER2DRECTSHADOW = 489,
F16SAMPLERCUBESHADOW = 490,
F16SAMPLERCUBEARRAYSHADOW = 491,
SAMPLER = 492,
SAMPLERSHADOW = 493,
TEXTURE1D = 494,
TEXTURE2D = 495,
TEXTURE3D = 496,
TEXTURECUBE = 497,
TEXTURE1DARRAY = 498,
TEXTURE2DARRAY = 499,
ITEXTURE1D = 500,
ITEXTURE2D = 501,
ITEXTURE3D = 502,
ITEXTURECUBE = 503,
ITEXTURE1DARRAY = 504,
ITEXTURE2DARRAY = 505,
UTEXTURE1D = 506,
UTEXTURE2D = 507,
UTEXTURE3D = 508,
UTEXTURECUBE = 509,
UTEXTURE1DARRAY = 510,
UTEXTURE2DARRAY = 511,
TEXTURE2DRECT = 512,
ITEXTURE2DRECT = 513,
UTEXTURE2DRECT = 514,
TEXTUREBUFFER = 515,
ITEXTUREBUFFER = 516,
UTEXTUREBUFFER = 517,
TEXTURECUBEARRAY = 518,
ITEXTURECUBEARRAY = 519,
UTEXTURECUBEARRAY = 520,
TEXTURE2DMS = 521,
ITEXTURE2DMS = 522,
UTEXTURE2DMS = 523,
TEXTURE2DMSARRAY = 524,
ITEXTURE2DMSARRAY = 525,
UTEXTURE2DMSARRAY = 526,
F16TEXTURE1D = 527,
F16TEXTURE2D = 528,
F16TEXTURE3D = 529,
F16TEXTURE2DRECT = 530,
F16TEXTURECUBE = 531,
F16TEXTURE1DARRAY = 532,
F16TEXTURE2DARRAY = 533,
F16TEXTURECUBEARRAY = 534,
F16TEXTUREBUFFER = 535,
F16TEXTURE2DMS = 536,
F16TEXTURE2DMSARRAY = 537,
SUBPASSINPUT = 538,
SUBPASSINPUTMS = 539,
ISUBPASSINPUT = 540,
ISUBPASSINPUTMS = 541,
USUBPASSINPUT = 542,
USUBPASSINPUTMS = 543,
F16SUBPASSINPUT = 544,
F16SUBPASSINPUTMS = 545,
IMAGE1D = 546,
IIMAGE1D = 547,
UIMAGE1D = 548,
IMAGE2D = 549,
IIMAGE2D = 550,
UIMAGE2D = 551,
IMAGE3D = 552,
IIMAGE3D = 553,
UIMAGE3D = 554,
IMAGE2DRECT = 555,
IIMAGE2DRECT = 556,
UIMAGE2DRECT = 557,
IMAGECUBE = 558,
IIMAGECUBE = 559,
UIMAGECUBE = 560,
IMAGEBUFFER = 561,
IIMAGEBUFFER = 562,
UIMAGEBUFFER = 563,
IMAGE1DARRAY = 564,
IIMAGE1DARRAY = 565,
UIMAGE1DARRAY = 566,
IMAGE2DARRAY = 567,
IIMAGE2DARRAY = 568,
UIMAGE2DARRAY = 569,
IMAGECUBEARRAY = 570,
IIMAGECUBEARRAY = 571,
UIMAGECUBEARRAY = 572,
IMAGE2DMS = 573,
IIMAGE2DMS = 574,
UIMAGE2DMS = 575,
IMAGE2DMSARRAY = 576,
IIMAGE2DMSARRAY = 577,
UIMAGE2DMSARRAY = 578,
F16IMAGE1D = 579,
F16IMAGE2D = 580,
F16IMAGE3D = 581,
F16IMAGE2DRECT = 582,
F16IMAGECUBE = 583,
F16IMAGE1DARRAY = 584,
F16IMAGE2DARRAY = 585,
F16IMAGECUBEARRAY = 586,
F16IMAGEBUFFER = 587,
F16IMAGE2DMS = 588,
F16IMAGE2DMSARRAY = 589,
STRUCT = 590,
VOID = 591,
WHILE = 592,
IDENTIFIER = 593,
TYPE_NAME = 594,
FLOATCONSTANT = 595,
DOUBLECONSTANT = 596,
INT16CONSTANT = 597,
UINT16CONSTANT = 598,
INT32CONSTANT = 599,
UINT32CONSTANT = 600,
INTCONSTANT = 601,
UINTCONSTANT = 602,
INT64CONSTANT = 603,
UINT64CONSTANT = 604,
BOOLCONSTANT = 605,
FLOAT16CONSTANT = 606,
LEFT_OP = 607,
RIGHT_OP = 608,
INC_OP = 609,
DEC_OP = 610,
LE_OP = 611,
GE_OP = 612,
EQ_OP = 613,
NE_OP = 614,
AND_OP = 615,
OR_OP = 616,
XOR_OP = 617,
MUL_ASSIGN = 618,
DIV_ASSIGN = 619,
ADD_ASSIGN = 620,
MOD_ASSIGN = 621,
LEFT_ASSIGN = 622,
RIGHT_ASSIGN = 623,
AND_ASSIGN = 624,
XOR_ASSIGN = 625,
OR_ASSIGN = 626,
SUB_ASSIGN = 627,
LEFT_PAREN = 628,
RIGHT_PAREN = 629,
LEFT_BRACKET = 630,
RIGHT_BRACKET = 631,
LEFT_BRACE = 632,
RIGHT_BRACE = 633,
DOT = 634,
COMMA = 635,
COLON = 636,
EQUAL = 637,
SEMICOLON = 638,
BANG = 639,
DASH = 640,
TILDE = 641,
PLUS = 642,
STAR = 643,
SLASH = 644,
PERCENT = 645,
LEFT_ANGLE = 646,
RIGHT_ANGLE = 647,
VERTICAL_BAR = 648,
CARET = 649,
AMPERSAND = 650,
QUESTION = 651,
INVARIANT = 652,
PRECISE = 653,
HIGH_PRECISION = 654,
MEDIUM_PRECISION = 655,
LOW_PRECISION = 656,
PRECISION = 657,
PACKED = 658,
RESOURCE = 659,
SUPERP = 660
};
#endif
@ -489,7 +491,7 @@ union YYSTYPE
};
} interm;
#line 493 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */
#line 495 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */
};
typedef union YYSTYPE YYSTYPE;

9
glslang/MachineIndependent/intermOut.cpp
View file

@ -1049,10 +1049,11 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
case EOpSubpassLoadMS: out.debug << "subpassLoadMS"; break;
#ifdef NV_EXTENSIONS
case EOpTraceNV: out.debug << "traceNVX"; break;
case EOpReportIntersectionNV: out.debug << "reportIntersectionNVX"; break;
case EOpIgnoreIntersectionNV: out.debug << "ignoreIntersectionNVX"; break;
case EOpTerminateRayNV: out.debug << "terminateRayNVX"; break;
case EOpTraceNV: out.debug << "traceNV"; break;
case EOpReportIntersectionNV: out.debug << "reportIntersectionNV"; break;
case EOpIgnoreIntersectionNV: out.debug << "ignoreIntersectionNV"; break;
case EOpTerminateRayNV: out.debug << "terminateRayNV"; break;
case EOpExecuteCallableNV: out.debug << "executeCallableNV"; break;
case EOpWritePackedPrimitiveIndices4x8NV: out.debug << "writePackedPrimitiveIndices4x8NV"; break;
#endif

2
glslang/MachineIndependent/linkValidate.cpp
View file

@ -712,7 +712,7 @@ void TIntermediate::finalCheck(TInfoSink& infoSink, bool keepUncalled)
case EShLangMissNV:
case EShLangCallableNV:
if (numShaderRecordNVBlocks > 1)
error(infoSink, "Only one shaderRecordNVX buffer block is allowed per stage");
error(infoSink, "Only one shaderRecordNV buffer block is allowed per stage");
break;
case EShLangMeshNV:
// NV_mesh_shader doesn't allow use of both single-view and per-view builtins.