mewin/glslang
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
SPIRV/GLSL.ext.NV.h
View File

@ -81,4 +81,7 @@ const char* const E_SPV_NV_cooperative_matrix = "SPV_NV_cooperative_matrix";
//SPV_NV_shader_sm_builtins //SPV_NV_shader_sm_builtins
const char* const E_SPV_NV_shader_sm_builtins = "SPV_NV_shader_sm_builtins"; const char* const E_SPV_NV_shader_sm_builtins = "SPV_NV_shader_sm_builtins";
//SPV_NV_shader_execution_reorder
const char* const E_SPV_NV_shader_invocation_reorder = "SPV_NV_shader_invocation_reorder";
#endif // #ifndef GLSLextNV_H #endif // #ifndef GLSLextNV_H

348
SPIRV/GlslangToSpv.cpp
View File

@ -278,12 +278,10 @@ protected:
// requiring local translation to and from SPIR-V type on every access. // requiring local translation to and from SPIR-V type on every access.
// Maps <builtin-variable-id -> AST-required-type-id> // Maps <builtin-variable-id -> AST-required-type-id>
std::unordered_map<spv::Id, spv::Id> forceType; std::unordered_map<spv::Id, spv::Id> forceType;
// Used later for generating OpTraceKHR/OpExecuteCallableKHR
std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[2];
// Used by Task shader while generating opearnds for OpEmitMeshTasksEXT // Used by Task shader while generating opearnds for OpEmitMeshTasksEXT
spv::Id taskPayloadID; spv::Id taskPayloadID;
// Used later for generating OpTraceKHR/OpExecuteCallableKHR/OpHitObjectRecordHit*/OpHitObjectGetShaderBindingTableData
std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[4];
}; };
// //
@ -392,6 +390,7 @@ spv::Decoration TranslateBlockDecoration(const glslang::TType& type, bool useSto
case glslang::EvqHitAttr: return spv::DecorationBlock; case glslang::EvqHitAttr: return spv::DecorationBlock;
case glslang::EvqCallableData: return spv::DecorationBlock; case glslang::EvqCallableData: return spv::DecorationBlock;
case glslang::EvqCallableDataIn: return spv::DecorationBlock; case glslang::EvqCallableDataIn: return spv::DecorationBlock;
case glslang::EvqHitObjectAttrNV: return spv::DecorationBlock;
#endif #endif
default: default:
assert(0); assert(0);
@ -469,6 +468,7 @@ spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::T
case glslang::EvqHitAttr: case glslang::EvqHitAttr:
case glslang::EvqCallableData: case glslang::EvqCallableData:
case glslang::EvqCallableDataIn: case glslang::EvqCallableDataIn:
case glslang::EvqHitObjectAttrNV:
return spv::DecorationMax; return spv::DecorationMax;
#endif #endif
default: default:
@ -1299,7 +1299,7 @@ spv::LoopControlMask TGlslangToSpvTraverser::TranslateLoopControl(const glslang:
// Translate glslang type to SPIR-V storage class. // Translate glslang type to SPIR-V storage class.
spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type) spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type)
{ {
if (type.getBasicType() == glslang::EbtRayQuery) if (type.getBasicType() == glslang::EbtRayQuery || type.getBasicType() == glslang::EbtHitObjectNV)
return spv::StorageClassPrivate; return spv::StorageClassPrivate;
#ifndef GLSLANG_WEB #ifndef GLSLANG_WEB
if (type.getQualifier().isSpirvByReference()) { if (type.getQualifier().isSpirvByReference()) {
@ -1356,6 +1356,7 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
case glslang::EvqCallableData: return spv::StorageClassCallableDataKHR; case glslang::EvqCallableData: return spv::StorageClassCallableDataKHR;
case glslang::EvqCallableDataIn: return spv::StorageClassIncomingCallableDataKHR; case glslang::EvqCallableDataIn: return spv::StorageClassIncomingCallableDataKHR;
case glslang::EvqtaskPayloadSharedEXT : return spv::StorageClassTaskPayloadWorkgroupEXT; case glslang::EvqtaskPayloadSharedEXT : return spv::StorageClassTaskPayloadWorkgroupEXT;
case glslang::EvqHitObjectAttrNV: return spv::StorageClassHitObjectAttributeNV;
case glslang::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass); case glslang::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass);
#endif #endif
default: default:
@ -2582,6 +2583,35 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags; spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
const auto hitObjectOpsWithLvalue = [](glslang::TOperator op) {
switch(op) {
case glslang::EOpReorderThreadNV:
case glslang::EOpHitObjectGetCurrentTimeNV:
case glslang::EOpHitObjectGetHitKindNV:
case glslang::EOpHitObjectGetPrimitiveIndexNV:
case glslang::EOpHitObjectGetGeometryIndexNV:
case glslang::EOpHitObjectGetInstanceIdNV:
case glslang::EOpHitObjectGetInstanceCustomIndexNV:
case glslang::EOpHitObjectGetObjectRayDirectionNV:
case glslang::EOpHitObjectGetObjectRayOriginNV:
case glslang::EOpHitObjectGetWorldRayDirectionNV:
case glslang::EOpHitObjectGetWorldRayOriginNV:
case glslang::EOpHitObjectGetWorldToObjectNV:
case glslang::EOpHitObjectGetObjectToWorldNV:
case glslang::EOpHitObjectGetRayTMaxNV:
case glslang::EOpHitObjectGetRayTMinNV:
case glslang::EOpHitObjectIsEmptyNV:
case glslang::EOpHitObjectIsHitNV:
case glslang::EOpHitObjectIsMissNV:
case glslang::EOpHitObjectRecordEmptyNV:
case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
return true;
default:
return false;
}
};
#ifndef GLSLANG_WEB #ifndef GLSLANG_WEB
if (node->getOp() == glslang::EOpAtomicCounterIncrement || if (node->getOp() == glslang::EOpAtomicCounterIncrement ||
node->getOp() == glslang::EOpAtomicCounterDecrement || node->getOp() == glslang::EOpAtomicCounterDecrement ||
@ -2596,7 +2626,8 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
node->getOp() == glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque || node->getOp() == glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque ||
node->getOp() == glslang::EOpRayQueryTerminate || node->getOp() == glslang::EOpRayQueryTerminate ||
node->getOp() == glslang::EOpRayQueryConfirmIntersection || node->getOp() == glslang::EOpRayQueryConfirmIntersection ||
(node->getOp() == glslang::EOpSpirvInst && operandNode->getAsTyped()->getQualifier().isSpirvByReference())) { (node->getOp() == glslang::EOpSpirvInst && operandNode->getAsTyped()->getQualifier().isSpirvByReference()) ||
hitObjectOpsWithLvalue(node->getOp())) {
operand = builder.accessChainGetLValue(); // Special case l-value operands operand = builder.accessChainGetLValue(); // Special case l-value operands
lvalueCoherentFlags = builder.getAccessChain().coherentFlags; lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
lvalueCoherentFlags |= TranslateCoherent(operandNode->getAsTyped()->getType()); lvalueCoherentFlags |= TranslateCoherent(operandNode->getAsTyped()->getType());
@ -2731,6 +2762,12 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
case glslang::EOpRayQueryConfirmIntersection: case glslang::EOpRayQueryConfirmIntersection:
builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operand); builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operand);
return false; return false;
case glslang::EOpReorderThreadNV:
builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operand);
return false;
case glslang::EOpHitObjectRecordEmptyNV:
builder.createNoResultOp(spv::OpHitObjectRecordEmptyNV, operand);
return false;
#endif #endif
default: default:
@ -3222,6 +3259,43 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock); builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
noReturnValue = true; noReturnValue = true;
break; break;
case glslang::EOpHitObjectTraceRayNV:
case glslang::EOpHitObjectTraceRayMotionNV:
case glslang::EOpHitObjectGetAttributesNV:
case glslang::EOpHitObjectExecuteShaderNV:
case glslang::EOpHitObjectRecordEmptyNV:
case glslang::EOpHitObjectRecordMissNV:
case glslang::EOpHitObjectRecordMissMotionNV:
case glslang::EOpHitObjectRecordHitNV:
case glslang::EOpHitObjectRecordHitMotionNV:
case glslang::EOpHitObjectRecordHitWithIndexNV:
case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
case glslang::EOpReorderThreadNV:
noReturnValue = true;
//Fallthrough
case glslang::EOpHitObjectIsEmptyNV:
case glslang::EOpHitObjectIsMissNV:
case glslang::EOpHitObjectIsHitNV:
case glslang::EOpHitObjectGetRayTMinNV:
case glslang::EOpHitObjectGetRayTMaxNV:
case glslang::EOpHitObjectGetObjectRayOriginNV:
case glslang::EOpHitObjectGetObjectRayDirectionNV:
case glslang::EOpHitObjectGetWorldRayOriginNV:
case glslang::EOpHitObjectGetWorldRayDirectionNV:
case glslang::EOpHitObjectGetObjectToWorldNV:
case glslang::EOpHitObjectGetWorldToObjectNV:
case glslang::EOpHitObjectGetInstanceCustomIndexNV:
case glslang::EOpHitObjectGetInstanceIdNV:
case glslang::EOpHitObjectGetGeometryIndexNV:
case glslang::EOpHitObjectGetPrimitiveIndexNV:
case glslang::EOpHitObjectGetHitKindNV:
case glslang::EOpHitObjectGetCurrentTimeNV:
case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
break;
#endif #endif
case glslang::EOpDebugPrintf: case glslang::EOpDebugPrintf:
@ -3279,6 +3353,22 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
lvalue = true; lvalue = true;
break; break;
case glslang::EOpHitObjectRecordHitNV:
case glslang::EOpHitObjectRecordHitMotionNV:
case glslang::EOpHitObjectRecordHitWithIndexNV:
case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
case glslang::EOpHitObjectTraceRayNV:
case glslang::EOpHitObjectTraceRayMotionNV:
case glslang::EOpHitObjectExecuteShaderNV:
case glslang::EOpHitObjectRecordMissNV:
case glslang::EOpHitObjectRecordMissMotionNV:
case glslang::EOpHitObjectGetAttributesNV:
if (arg == 0)
lvalue = true;
break;
case glslang::EOpRayQueryInitialize: case glslang::EOpRayQueryInitialize:
case glslang::EOpRayQueryTerminate: case glslang::EOpRayQueryTerminate:
case glslang::EOpRayQueryConfirmIntersection: case glslang::EOpRayQueryConfirmIntersection:
@ -3379,6 +3469,11 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvByReference()) if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvByReference())
lvalue = true; lvalue = true;
break; break;
case glslang::EOpReorderThreadNV:
//Three variants of reorderThreadNV, two of them use hitObjectNV
if (arg == 0 && glslangOperands.size() != 2)
lvalue = true;
break;
#endif #endif
default: default:
break; break;
@ -3435,7 +3530,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
} else if (arg == 2) { } else if (arg == 2) {
continue; continue;
} }
} }
#endif #endif
// for l-values, pass the address, for r-values, pass the value // for l-values, pass the address, for r-values, pass the value
@ -3477,11 +3572,23 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
operands.push_back(builder.makeIntConstant(cond ? 1 : 0)); operands.push_back(builder.makeIntConstant(cond ? 1 : 0));
} else if ((arg == 10 && glslangOp == glslang::EOpTraceKHR) || } else if ((arg == 10 && glslangOp == glslang::EOpTraceKHR) ||
(arg == 11 && glslangOp == glslang::EOpTraceRayMotionNV) || (arg == 11 && glslangOp == glslang::EOpTraceRayMotionNV) ||
(arg == 1 && glslangOp == glslang::EOpExecuteCallableKHR)) { (arg == 1 && glslangOp == glslang::EOpExecuteCallableKHR) ||
const int opdNum = glslangOp == glslang::EOpTraceKHR ? 10 : (glslangOp == glslang::EOpTraceRayMotionNV ? 11 : 1); (arg == 1 && glslangOp == glslang::EOpHitObjectExecuteShaderNV) ||
(arg == 11 && glslangOp == glslang::EOpHitObjectTraceRayNV) ||
(arg == 12 && glslangOp == glslang::EOpHitObjectTraceRayMotionNV)) {
const int set = glslangOp == glslang::EOpExecuteCallableKHR ? 1 : 0; const int set = glslangOp == glslang::EOpExecuteCallableKHR ? 1 : 0;
const int location = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getUConst();
const int location = glslangOperands[opdNum]->getAsConstantUnion()->getConstArray()[0].getUConst(); auto itNode = locationToSymbol[set].find(location);
visitSymbol(itNode->second);
spv::Id symId = getSymbolId(itNode->second);
operands.push_back(symId);
} else if ((arg == 12 && glslangOp == glslang::EOpHitObjectRecordHitNV) ||
(arg == 13 && glslangOp == glslang::EOpHitObjectRecordHitMotionNV) ||
(arg == 11 && glslangOp == glslang::EOpHitObjectRecordHitWithIndexNV) ||
(arg == 12 && glslangOp == glslang::EOpHitObjectRecordHitWithIndexMotionNV) ||
(arg == 1 && glslangOp == glslang::EOpHitObjectGetAttributesNV)) {
const int location = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getUConst();
const int set = 2;
auto itNode = locationToSymbol[set].find(location); auto itNode = locationToSymbol[set].find(location);
visitSymbol(itNode->second); visitSymbol(itNode->second);
spv::Id symId = getSymbolId(itNode->second); spv::Id symId = getSymbolId(itNode->second);
@ -4307,6 +4414,13 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
case glslang::EbtString: case glslang::EbtString:
// no type used for OpString // no type used for OpString
return 0; return 0;
case glslang::EbtHitObjectNV: {
builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
spvType = builder.makeHitObjectNVType();
}
break;
#ifndef GLSLANG_WEB #ifndef GLSLANG_WEB
case glslang::EbtSpirvType: { case glslang::EbtSpirvType: {
// GL_EXT_spirv_intrinsics // GL_EXT_spirv_intrinsics
@ -4726,6 +4840,9 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
// Decorate the structure // Decorate the structure
builder.addDecoration(spvType, TranslateLayoutDecoration(type, qualifier.layoutMatrix)); builder.addDecoration(spvType, TranslateLayoutDecoration(type, qualifier.layoutMatrix));
builder.addDecoration(spvType, TranslateBlockDecoration(type, glslangIntermediate->usingStorageBuffer())); builder.addDecoration(spvType, TranslateBlockDecoration(type, glslangIntermediate->usingStorageBuffer()));
if (qualifier.hasHitObjectShaderRecordNV())
builder.addDecoration(spvType, spv::DecorationHitObjectShaderRecordBufferNV);
} }
// Turn the expression forming the array size into an id. // Turn the expression forming the array size into an id.
@ -5253,6 +5370,10 @@ void TGlslangToSpvTraverser::collectRayTracingLinkerObjects()
set = 1; set = 1;
break; break;
case glslang::EvqHitObjectAttrNV:
set = 2;
break;
default: default:
set = -1; set = -1;
} }
@ -6897,6 +7018,83 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDe
case glslang::EOpConvUvec2ToAccStruct: case glslang::EOpConvUvec2ToAccStruct:
unaryOp = spv::OpConvertUToAccelerationStructureKHR; unaryOp = spv::OpConvertUToAccelerationStructureKHR;
break; break;
case glslang::EOpHitObjectIsEmptyNV:
unaryOp = spv::OpHitObjectIsEmptyNV;
break;
case glslang::EOpHitObjectIsMissNV:
unaryOp = spv::OpHitObjectIsMissNV;
break;
case glslang::EOpHitObjectIsHitNV:
unaryOp = spv::OpHitObjectIsHitNV;
break;
case glslang::EOpHitObjectGetObjectRayOriginNV:
unaryOp = spv::OpHitObjectGetObjectRayOriginNV;
break;
case glslang::EOpHitObjectGetObjectRayDirectionNV:
unaryOp = spv::OpHitObjectGetObjectRayDirectionNV;
break;
case glslang::EOpHitObjectGetWorldRayOriginNV:
unaryOp = spv::OpHitObjectGetWorldRayOriginNV;
break;
case glslang::EOpHitObjectGetWorldRayDirectionNV:
unaryOp = spv::OpHitObjectGetWorldRayDirectionNV;
break;
case glslang::EOpHitObjectGetObjectToWorldNV:
unaryOp = spv::OpHitObjectGetObjectToWorldNV;
break;
case glslang::EOpHitObjectGetWorldToObjectNV:
unaryOp = spv::OpHitObjectGetWorldToObjectNV;
break;
case glslang::EOpHitObjectGetRayTMinNV:
unaryOp = spv::OpHitObjectGetRayTMinNV;
break;
case glslang::EOpHitObjectGetRayTMaxNV:
unaryOp = spv::OpHitObjectGetRayTMaxNV;
break;
case glslang::EOpHitObjectGetPrimitiveIndexNV:
unaryOp = spv::OpHitObjectGetPrimitiveIndexNV;
break;
case glslang::EOpHitObjectGetInstanceIdNV:
unaryOp = spv::OpHitObjectGetInstanceIdNV;
break;
case glslang::EOpHitObjectGetInstanceCustomIndexNV:
unaryOp = spv::OpHitObjectGetInstanceCustomIndexNV;
break;
case glslang::EOpHitObjectGetGeometryIndexNV:
unaryOp = spv::OpHitObjectGetGeometryIndexNV;
break;
case glslang::EOpHitObjectGetHitKindNV:
unaryOp = spv::OpHitObjectGetHitKindNV;
break;
case glslang::EOpHitObjectGetCurrentTimeNV:
unaryOp = spv::OpHitObjectGetCurrentTimeNV;
break;
case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
unaryOp = spv::OpHitObjectGetShaderBindingTableRecordIndexNV;
break;
case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
unaryOp = spv::OpHitObjectGetShaderRecordBufferHandleNV;
break;
#endif #endif
case glslang::EOpCopyObject: case glslang::EOpCopyObject:
@ -8638,6 +8836,122 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
case glslang::EOpCooperativeMatrixMulAdd: case glslang::EOpCooperativeMatrixMulAdd:
opCode = spv::OpCooperativeMatrixMulAddNV; opCode = spv::OpCooperativeMatrixMulAddNV;
break; break;
case glslang::EOpHitObjectTraceRayNV:
builder.createNoResultOp(spv::OpHitObjectTraceRayNV, operands);
return 0;
case glslang::EOpHitObjectTraceRayMotionNV:
builder.createNoResultOp(spv::OpHitObjectTraceRayMotionNV, operands);
return 0;
case glslang::EOpHitObjectRecordHitNV:
builder.createNoResultOp(spv::OpHitObjectRecordHitNV, operands);
return 0;
case glslang::EOpHitObjectRecordHitMotionNV:
builder.createNoResultOp(spv::OpHitObjectRecordHitMotionNV, operands);
return 0;
case glslang::EOpHitObjectRecordHitWithIndexNV:
builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexNV, operands);
return 0;
case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexMotionNV, operands);
return 0;
case glslang::EOpHitObjectRecordMissNV:
builder.createNoResultOp(spv::OpHitObjectRecordMissNV, operands);
return 0;
case glslang::EOpHitObjectRecordMissMotionNV:
builder.createNoResultOp(spv::OpHitObjectRecordMissMotionNV, operands);
return 0;
case glslang::EOpHitObjectExecuteShaderNV:
builder.createNoResultOp(spv::OpHitObjectExecuteShaderNV, operands);
return 0;
case glslang::EOpHitObjectIsEmptyNV:
typeId = builder.makeBoolType();
opCode = spv::OpHitObjectIsEmptyNV;
break;
case glslang::EOpHitObjectIsMissNV:
typeId = builder.makeBoolType();
opCode = spv::OpHitObjectIsMissNV;
break;
case glslang::EOpHitObjectIsHitNV:
typeId = builder.makeBoolType();
opCode = spv::OpHitObjectIsHitNV;
break;
case glslang::EOpHitObjectGetRayTMinNV:
typeId = builder.makeFloatType(32);
opCode = spv::OpHitObjectGetRayTMinNV;
break;
case glslang::EOpHitObjectGetRayTMaxNV:
typeId = builder.makeFloatType(32);
opCode = spv::OpHitObjectGetRayTMaxNV;
break;
case glslang::EOpHitObjectGetObjectRayOriginNV:
typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
opCode = spv::OpHitObjectGetObjectRayOriginNV;
break;
case glslang::EOpHitObjectGetObjectRayDirectionNV:
typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
opCode = spv::OpHitObjectGetObjectRayDirectionNV;
break;
case glslang::EOpHitObjectGetWorldRayOriginNV:
typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
opCode = spv::OpHitObjectGetWorldRayOriginNV;
break;
case glslang::EOpHitObjectGetWorldRayDirectionNV:
typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
opCode = spv::OpHitObjectGetWorldRayDirectionNV;
break;
case glslang::EOpHitObjectGetWorldToObjectNV:
typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
opCode = spv::OpHitObjectGetWorldToObjectNV;
break;
case glslang::EOpHitObjectGetObjectToWorldNV:
typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
opCode = spv::OpHitObjectGetObjectToWorldNV;
break;
case glslang::EOpHitObjectGetInstanceCustomIndexNV:
typeId = builder.makeIntegerType(32, 1);
opCode = spv::OpHitObjectGetInstanceCustomIndexNV;
break;
case glslang::EOpHitObjectGetInstanceIdNV:
typeId = builder.makeIntegerType(32, 1);
opCode = spv::OpHitObjectGetInstanceIdNV;
break;
case glslang::EOpHitObjectGetGeometryIndexNV:
typeId = builder.makeIntegerType(32, 1);
opCode = spv::OpHitObjectGetGeometryIndexNV;
break;
case glslang::EOpHitObjectGetPrimitiveIndexNV:
typeId = builder.makeIntegerType(32, 1);
opCode = spv::OpHitObjectGetPrimitiveIndexNV;
break;
case glslang::EOpHitObjectGetHitKindNV:
typeId = builder.makeIntegerType(32, 0);
opCode = spv::OpHitObjectGetHitKindNV;
break;
case glslang::EOpHitObjectGetCurrentTimeNV:
typeId = builder.makeFloatType(32);
opCode = spv::OpHitObjectGetCurrentTimeNV;
break;
case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
typeId = builder.makeIntegerType(32, 0);
opCode = spv::OpHitObjectGetShaderBindingTableRecordIndexNV;
return 0;
case glslang::EOpHitObjectGetAttributesNV:
builder.createNoResultOp(spv::OpHitObjectGetAttributesNV, operands);
return 0;
case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
typeId = builder.makeVectorType(builder.makeUintType(32), 2);
opCode = spv::OpHitObjectGetShaderRecordBufferHandleNV;
break;
case glslang::EOpReorderThreadNV: {
if (operands.size() == 2) {
builder.createNoResultOp(spv::OpReorderThreadWithHintNV, operands);
} else {
builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operands);
}
return 0;
}
break;
#endif // GLSLANG_WEB #endif // GLSLANG_WEB
default: default:
return 0; return 0;
@ -8947,13 +9261,17 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol
} }
if (symbol->getQualifier().hasLocation()) { if (symbol->getQualifier().hasLocation()) {
if (!(glslangIntermediate->isRayTracingStage() && glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing) if (!(glslangIntermediate->isRayTracingStage() &&
(glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing) ||
glslangIntermediate->IsRequestedExtension(glslang::E_GL_NV_shader_invocation_reorder))
&& (builder.getStorageClass(id) == spv::StorageClassRayPayloadKHR || && (builder.getStorageClass(id) == spv::StorageClassRayPayloadKHR ||
builder.getStorageClass(id) == spv::StorageClassIncomingRayPayloadKHR || builder.getStorageClass(id) == spv::StorageClassIncomingRayPayloadKHR ||
builder.getStorageClass(id) == spv::StorageClassCallableDataKHR || builder.getStorageClass(id) == spv::StorageClassCallableDataKHR ||
builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR))) { builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR ||
// Location values are used to link TraceRayKHR and ExecuteCallableKHR to corresponding variables builder.getStorageClass(id) == spv::StorageClassHitObjectAttributeNV))) {
// but are not valid in SPIRV since they are supported only for Input/Output Storage classes. // Location values are used to link TraceRayKHR/ExecuteCallableKHR/HitObjectGetAttributesNV
// to corresponding variables but are not valid in SPIRV since they are supported only
// for Input/Output Storage classes.
builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation); builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
} }
} }

15
SPIRV/SpvBuilder.cpp
View File

@ -1176,6 +1176,21 @@ Id Builder::makeRayQueryType()
return type->getResultId(); return type->getResultId();
} }
Id Builder::makeHitObjectNVType()
{
Instruction *type;
if (groupedTypes[OpTypeHitObjectNV].size() == 0) {
type = new Instruction(getUniqueId(), NoType, OpTypeHitObjectNV);
groupedTypes[OpTypeHitObjectNV].push_back(type);
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
} else {
type = groupedTypes[OpTypeHitObjectNV].back();
}
return type->getResultId();
}
#endif #endif
Id Builder::getDerefTypeId(Id resultId) const Id Builder::getDerefTypeId(Id resultId) const

2
SPIRV/SpvBuilder.h
View File

@ -240,6 +240,8 @@ public:
Id makeAccelerationStructureType(); Id makeAccelerationStructureType();
// rayQueryEXT type // rayQueryEXT type
Id makeRayQueryType(); Id makeRayQueryType();
// hitObjectNV type
Id makeHitObjectNVType();
// For querying about types. // For querying about types.
Id getTypeId(Id resultId) const { return module.getTypeId(resultId); } Id getTypeId(Id resultId) const { return module.getTypeId(resultId); }

223
SPIRV/doc.cpp
View File

@ -246,6 +246,7 @@ const char* StorageClassString(int StorageClass)
case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT"; case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT"; case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT";
case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV";
default: return "Bad"; default: return "Bad";
} }
} }
@ -320,6 +321,8 @@ const char* DecorationString(int decoration)
case DecorationHlslSemanticGOOGLE: return "DecorationHlslSemanticGOOGLE"; case DecorationHlslSemanticGOOGLE: return "DecorationHlslSemanticGOOGLE";
case DecorationRestrictPointerEXT: return "DecorationRestrictPointerEXT"; case DecorationRestrictPointerEXT: return "DecorationRestrictPointerEXT";
case DecorationAliasedPointerEXT: return "DecorationAliasedPointerEXT"; case DecorationAliasedPointerEXT: return "DecorationAliasedPointerEXT";
case DecorationHitObjectShaderRecordBufferNV: return "DecorationHitObjectShaderRecordBufferNV";
} }
} }
@ -1006,6 +1009,7 @@ const char* CapabilityString(int info)
case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR"; case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR";
case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM"; case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM";
case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
default: return "Bad"; default: return "Bad";
} }
} }
@ -1460,6 +1464,40 @@ const char* OpcodeString(int op)
case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT"; case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT";
case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT"; case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT";
case OpTypeHitObjectNV: return "OpTypeHitObjectNV";
case OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV";
case OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV";
case OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV";
case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV";
case OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV";
case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
case OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV";
case OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV";
case OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV";
case OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV";
case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV";
case OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV";
case OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV";
case OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV";
case OpHitObjectGetHitKindNV: return "OpHitObjectGetFrontFaceNV";
case OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV";
case OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV";
case OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV";
case OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV";
case OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV";
case OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV";
case OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV";
case OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV";
case OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV";
case OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV";
case OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV";
case OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV";
case OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV";
case OpHitObjectIsHitNV: return "OpHitObjectIsHitNV";
case OpHitObjectIsMissNV: return "OpHitObjectIsMissNV";
case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV";
default: default:
return "Bad"; return "Bad";
} }
@ -3037,6 +3075,191 @@ void Parameterize()
InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false); InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false);
InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'"); InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpTypeHitObjectNV].setResultAndType(true, false);
InstructionDesc[OpHitObjectGetShaderRecordBufferHandleNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetShaderRecordBufferHandleNV].setResultAndType(true, true);
InstructionDesc[OpReorderThreadWithHintNV].operands.push(OperandId, "'Hint'");
InstructionDesc[OpReorderThreadWithHintNV].operands.push(OperandId, "'Bits'");
InstructionDesc[OpReorderThreadWithHintNV].setResultAndType(false, false);
InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'Hint'");
InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'Bits'");
InstructionDesc[OpReorderThreadWithHitObjectNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectGetCurrentTimeNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetCurrentTimeNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetHitKindNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetHitKindNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetPrimitiveIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetPrimitiveIndexNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetGeometryIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetGeometryIndexNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetInstanceIdNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetInstanceIdNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetInstanceCustomIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetInstanceCustomIndexNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetObjectRayDirectionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetObjectRayDirectionNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetObjectRayOriginNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetObjectRayOriginNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetWorldRayDirectionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetWorldRayDirectionNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetWorldRayOriginNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetWorldRayOriginNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetWorldToObjectNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetWorldToObjectNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetObjectToWorldNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetObjectToWorldNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetRayTMaxNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetRayTMaxNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetRayTMinNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetRayTMinNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetShaderBindingTableRecordIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetShaderBindingTableRecordIndexNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectIsEmptyNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectIsEmptyNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectIsHitNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectIsHitNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectIsMissNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectIsMissNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetAttributesNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetAttributesNV].operands.push(OperandId, "'HitObjectAttribute'");
InstructionDesc[OpHitObjectGetAttributesNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectExecuteShaderNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectExecuteShaderNV].operands.push(OperandId, "'Payload'");
InstructionDesc[OpHitObjectExecuteShaderNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'InstanceId'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'PrimitiveId'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'GeometryIndex'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitKind'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitObject Attribute'");
InstructionDesc[OpHitObjectRecordHitNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'InstanceId'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'PrimitiveId'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'GeometryIndex'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitKind'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Current Time'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitObject Attribute'");
InstructionDesc[OpHitObjectRecordHitMotionNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'InstanceId'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'PrimitiveId'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'GeometryIndex'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitKind'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'SBT Record Index'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitObject Attribute'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'InstanceId'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'PrimitiveId'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'GeometryIndex'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitKind'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'SBT Record Index'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Current Time'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitObject Attribute'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'SBT Index'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordMissNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'SBT Index'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Current Time'");
InstructionDesc[OpHitObjectRecordMissMotionNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordEmptyNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordEmptyNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'RayFlags'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Cullmask'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Miss Index'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Payload'");
InstructionDesc[OpHitObjectTraceRayNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'RayFlags'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Cullmask'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Miss Index'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Time'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Payload'");
InstructionDesc[OpHitObjectTraceRayMotionNV].setResultAndType(false, false);
} }
}; // end spv namespace }; // end spv namespace

36
SPIRV/spirv.hpp
View File

@ -223,6 +223,7 @@ enum StorageClass {
StorageClassShaderRecordBufferNV = 5343, StorageClassShaderRecordBufferNV = 5343,
StorageClassPhysicalStorageBuffer = 5349, StorageClassPhysicalStorageBuffer = 5349,
StorageClassPhysicalStorageBufferEXT = 5349, StorageClassPhysicalStorageBufferEXT = 5349,
StorageClassHitObjectAttributeNV = 5385,
StorageClassTaskPayloadWorkgroupEXT = 5402, StorageClassTaskPayloadWorkgroupEXT = 5402,
StorageClassCodeSectionINTEL = 5605, StorageClassCodeSectionINTEL = 5605,
StorageClassDeviceOnlyINTEL = 5936, StorageClassDeviceOnlyINTEL = 5936,
@ -518,6 +519,7 @@ enum Decoration {
DecorationRestrictPointerEXT = 5355, DecorationRestrictPointerEXT = 5355,
DecorationAliasedPointer = 5356, DecorationAliasedPointer = 5356,
DecorationAliasedPointerEXT = 5356, DecorationAliasedPointerEXT = 5356,
DecorationHitObjectShaderRecordBufferNV = 5386,
DecorationBindlessSamplerNV = 5398, DecorationBindlessSamplerNV = 5398,
DecorationBindlessImageNV = 5399, DecorationBindlessImageNV = 5399,
DecorationBoundSamplerNV = 5400, DecorationBoundSamplerNV = 5400,
@ -1048,6 +1050,7 @@ enum Capability {
CapabilityFragmentShaderPixelInterlockEXT = 5378, CapabilityFragmentShaderPixelInterlockEXT = 5378,
CapabilityDemoteToHelperInvocation = 5379, CapabilityDemoteToHelperInvocation = 5379,
CapabilityDemoteToHelperInvocationEXT = 5379, CapabilityDemoteToHelperInvocationEXT = 5379,
CapabilityShaderInvocationReorderNV = 5383,
CapabilityBindlessTextureNV = 5390, CapabilityBindlessTextureNV = 5390,
CapabilitySubgroupShuffleINTEL = 5568, CapabilitySubgroupShuffleINTEL = 5568,
CapabilitySubgroupBufferBlockIOINTEL = 5569, CapabilitySubgroupBufferBlockIOINTEL = 5569,
@ -1594,6 +1597,39 @@ enum Op {
OpFragmentMaskFetchAMD = 5011, OpFragmentMaskFetchAMD = 5011,
OpFragmentFetchAMD = 5012, OpFragmentFetchAMD = 5012,
OpReadClockKHR = 5056, OpReadClockKHR = 5056,
OpHitObjectRecordHitMotionNV = 5249,
OpHitObjectRecordHitWithIndexMotionNV = 5250,
OpHitObjectRecordMissMotionNV = 5251,
OpHitObjectGetWorldToObjectNV = 5252,
OpHitObjectGetObjectToWorldNV = 5253,
OpHitObjectGetObjectRayDirectionNV = 5254,
OpHitObjectGetObjectRayOriginNV = 5255,
OpHitObjectTraceRayMotionNV = 5256,
OpHitObjectGetShaderRecordBufferHandleNV = 5257,
OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
OpHitObjectRecordEmptyNV = 5259,
OpHitObjectTraceRayNV = 5260,
OpHitObjectRecordHitNV = 5261,
OpHitObjectRecordHitWithIndexNV = 5262,
OpHitObjectRecordMissNV = 5263,
OpHitObjectExecuteShaderNV = 5264,
OpHitObjectGetCurrentTimeNV = 5265,
OpHitObjectGetAttributesNV = 5266,
OpHitObjectGetHitKindNV = 5267,
OpHitObjectGetPrimitiveIndexNV = 5268,
OpHitObjectGetGeometryIndexNV = 5269,
OpHitObjectGetInstanceIdNV = 5270,
OpHitObjectGetInstanceCustomIndexNV = 5271,
OpHitObjectGetWorldRayDirectionNV = 5272,
OpHitObjectGetWorldRayOriginNV = 5273,
OpHitObjectGetRayTMaxNV = 5274,
OpHitObjectGetRayTMinNV = 5275,
OpHitObjectIsEmptyNV = 5276,
OpHitObjectIsHitNV = 5277,
OpHitObjectIsMissNV = 5278,
OpReorderThreadWithHitObjectNV = 5279,
OpReorderThreadWithHintNV = 5280,
OpTypeHitObjectNV = 5281,
OpImageSampleFootprintNV = 5283, OpImageSampleFootprintNV = 5283,
OpEmitMeshTasksEXT = 5294, OpEmitMeshTasksEXT = 5294,
OpSetMeshOutputsEXT = 5295, OpSetMeshOutputsEXT = 5295,

215
Test/baseResults/spv.nv.hitobject-allops.rchit.out Normal file
View File

@ -0,0 +1,215 @@
spv.nv.hitobject-allops.rchit
// Module Version 10400
// Generated by (magic number): 8000b
// Id's are bound by 116
Capability RayTracingKHR
Capability ShaderInvocationReorderNV
Extension "SPV_KHR_ray_tracing"
Extension "SPV_NV_shader_invocation_reorder"
1: ExtInstImport "GLSL.std.450"
MemoryModel Logical GLSL450
EntryPoint ClosestHitKHR 4 "main" 9 14 22 25 36 42 48 52 53 64
Source GLSL 460
SourceExtension "GL_EXT_ray_tracing"
SourceExtension "GL_NV_ray_tracing_motion_blur"
SourceExtension "GL_NV_shader_invocation_reorder"
Name 4 "main"
Name 9 "attr"
Name 12 "hBlock"
MemberName 12(hBlock) 0 "attrval"
Name 14 ""
Name 22 "hObj"
Name 25 "as"
Name 36 "payload"
Name 40 "pBlock"
MemberName 40(pBlock) 0 "val1"
MemberName 40(pBlock) 1 "val2"
Name 42 ""
Name 48 "hObjHit"
Name 52 "hObjNop"
Name 53 "hObjMiss"
Name 62 "block"
MemberName 62(block) 0 "op"
Name 64 ""
Name 79 "tmin"
Name 81 "tmax"
Name 84 "orig"
Name 86 "dir"
Name 88 "oorig"
Name 90 "odir"
Name 94 "otw"
Name 96 "wto"
Name 99 "cid"
Name 101 "iid"
Name 103 "pid"
Name 105 "gid"
Name 108 "hkind"
Name 112 "handle"
Name 114 "rid"
Decorate 12(hBlock) Block
Decorate 25(as) DescriptorSet 0
Decorate 25(as) Binding 0
Decorate 40(pBlock) Block
MemberDecorate 62(block) 0 Offset 0
Decorate 62(block) Block
Decorate 64 DescriptorSet 0
Decorate 64 Binding 1
2: TypeVoid
3: TypeFunction 2
6: TypeFloat 32
7: TypeVector 6(float) 2
8: TypePointer HitObjectAttributeNV 7(fvec2)
9(attr): 8(ptr) Variable HitObjectAttributeNV
10: 6(float) Constant 1065353216
11: 7(fvec2) ConstantComposite 10 10
12(hBlock): TypeStruct 6(float)
13: TypePointer HitObjectAttributeNV 12(hBlock)
14: 13(ptr) Variable HitObjectAttributeNV
15: TypeInt 32 1
16: 15(int) Constant 0
17: 6(float) Constant 1073741824
18: TypePointer HitObjectAttributeNV 6(float)
20: TypeHitObjectNV
21: TypePointer Private 20
22(hObj): 21(ptr) Variable Private
23: TypeAccelerationStructureKHR
24: TypePointer UniformConstant 23
25(as): 24(ptr) Variable UniformConstant
27: TypeInt 32 0
28: 27(int) Constant 1
29: TypeVector 6(float) 3
30: 6(float) Constant 1056964608
31: 29(fvec3) ConstantComposite 30 30 30
32: 29(fvec3) ConstantComposite 10 10 10
33: 15(int) Constant 1
34: TypeVector 6(float) 4
35: TypePointer RayPayloadKHR 34(fvec4)
36(payload): 35(ptr) Variable RayPayloadKHR
38: 6(float) Constant 1092616192
39: 15(int) Constant 2
40(pBlock): TypeStruct 7(fvec2) 7(fvec2)
41: TypePointer RayPayloadKHR 40(pBlock)
42: 41(ptr) Variable RayPayloadKHR
44: 27(int) Constant 2
45: 29(fvec3) ConstantComposite 17 17 17
47: 6(float) Constant 1082130432
48(hObjHit): 21(ptr) Variable Private
50: 15(int) Constant 3
52(hObjNop): 21(ptr) Variable Private
53(hObjMiss): 21(ptr) Variable Private
54: 6(float) Constant 1069547520
55: 29(fvec3) ConstantComposite 54 54 54
56: 6(float) Constant 1084227584
57: 6(float) Constant 1090519040
58: TypeBool
62(block): TypeStruct 6(float)
63: TypePointer StorageBuffer 62(block)
64: 63(ptr) Variable StorageBuffer
65: TypePointer StorageBuffer 6(float)
76: 6(float) Constant 1077936128
78: TypePointer Function 6(float)
83: TypePointer Function 29(fvec3)
92: TypeMatrix 29(fvec3) 4
93: TypePointer Function 92
98: TypePointer Function 15(int)
107: TypePointer Function 27(int)
110: TypeVector 27(int) 2
111: TypePointer Function 110(ivec2)
4(main): 2 Function None 3
5: Label
79(tmin): 78(ptr) Variable Function
81(tmax): 78(ptr) Variable Function
84(orig): 83(ptr) Variable Function
86(dir): 83(ptr) Variable Function
88(oorig): 83(ptr) Variable Function
90(odir): 83(ptr) Variable Function
94(otw): 93(ptr) Variable Function
96(wto): 93(ptr) Variable Function
99(cid): 98(ptr) Variable Function
101(iid): 98(ptr) Variable Function
103(pid): 98(ptr) Variable Function
105(gid): 98(ptr) Variable Function
108(hkind): 107(ptr) Variable Function
112(handle): 111(ptr) Variable Function
114(rid): 107(ptr) Variable Function
Store 9(attr) 11
19: 18(ptr) AccessChain 14 16
Store 19 17
26: 23 Load 25(as)
HitObjectTraceRayNV 22(hObj) 26 28 28 28 28 28 31 30 32 10 36(payload)
37: 23 Load 25(as)
HitObjectTraceRayMotionNV 22(hObj) 37 28 28 28 28 28 31 30 32 10 38 42
43: 23 Load 25(as)
HitObjectRecordHitNV 22(hObj) 43 33 33 33 44 44 44 32 10 45 17 9(attr)
46: 23 Load 25(as)
HitObjectRecordHitMotionNV 22(hObj) 46 33 33 33 44 44 44 32 10 45 17 47 9(attr)
49: 23 Load 25(as)
HitObjectRecordHitWithIndexNV 48(hObjHit) 49 33 33 33 44 44 32 10 45 17 14
51: 23 Load 25(as)
HitObjectRecordHitWithIndexMotionNV 48(hObjHit) 51 33 33 33 44 44 32 10 45 17 47 14
HitObjectRecordEmptyNV 52(hObjNop)
HitObjectRecordMissNV 53(hObjMiss) 28 31 17 55 56
HitObjectRecordMissMotionNV 53(hObjMiss) 28 31 17 55 56 57
HitObjectExecuteShaderNV 48(hObjHit) 42
59: 58(bool) HitObjectIsHitNV 22(hObj)
SelectionMerge 61 None
BranchConditional 59 60 67
60: Label
66: 65(ptr) AccessChain 64 16
Store 66 10
Branch 61
67: Label
68: 58(bool) HitObjectIsMissNV 22(hObj)
SelectionMerge 70 None
BranchConditional 68 69 72
69: Label
71: 65(ptr) AccessChain 64 16
Store 71 17
Branch 70
72: Label
73: 58(bool) HitObjectIsEmptyNV 22(hObj)
SelectionMerge 75 None
BranchConditional 73 74 75
74: Label
77: 65(ptr) AccessChain 64 16
Store 77 76
Branch 75
75: Label
Branch 70
70: Label
Branch 61
61: Label
80: 6(float) HitObjectGetRayTMinNV 48(hObjHit)
Store 79(tmin) 80
82: 6(float) HitObjectGetRayTMaxNV 48(hObjHit)
Store 81(tmax) 82
85: 29(fvec3) HitObjectGetWorldRayOriginNV 48(hObjHit)
Store 84(orig) 85
87: 29(fvec3) HitObjectGetWorldRayDirectionNV 48(hObjHit)
Store 86(dir) 87
89: 29(fvec3) HitObjectGetObjectRayOriginNV 48(hObjHit)
Store 88(oorig) 89
91: 29(fvec3) HitObjectGetObjectRayDirectionNV 48(hObjHit)
Store 90(odir) 91
95: 92 HitObjectGetObjectToWorldNV 48(hObjHit)
Store 94(otw) 95
97: 92 HitObjectGetWorldToObjectNV 48(hObjHit)
Store 96(wto) 97
100: 15(int) HitObjectGetInstanceCustomIndexNV 53(hObjMiss)
Store 99(cid) 100
102: 15(int) HitObjectGetInstanceIdNV 52(hObjNop)
Store 101(iid) 102
104: 15(int) HitObjectGetPrimitiveIndexNV 22(hObj)
Store 103(pid) 104
106: 15(int) HitObjectGetGeometryIndexNV 22(hObj)
Store 105(gid) 106
109: 27(int) HitObjectGetFrontFaceNV 22(hObj)
Store 108(hkind) 109
HitObjectGetAttributesNV 22(hObj) 9(attr)
113: 110(ivec2) HitObjectGetShaderRecordBufferHandleNV 22(hObj)
Store 112(handle) 113
115: 27(int) HitObjectGetShaderBindingTableRecordIndexNV 22(hObj)
Store 114(rid) 115
Return
FunctionEnd

219
Test/baseResults/spv.nv.hitobject-allops.rgen.out Normal file
View File

@ -0,0 +1,219 @@
spv.nv.hitobject-allops.rgen
// Module Version 10400
// Generated by (magic number): 8000b
// Id's are bound by 117
Capability RayTracingKHR
Capability ShaderInvocationReorderNV
Extension "SPV_KHR_ray_tracing"
Extension "SPV_NV_shader_invocation_reorder"
1: ExtInstImport "GLSL.std.450"
MemoryModel Logical GLSL450
EntryPoint RayGenerationKHR 4 "main" 9 14 22 25 36 42 48 52 53 64
Source GLSL 460
SourceExtension "GL_EXT_ray_tracing"
SourceExtension "GL_NV_ray_tracing_motion_blur"
SourceExtension "GL_NV_shader_invocation_reorder"
Name 4 "main"
Name 9 "attr"
Name 12 "hBlock"
MemberName 12(hBlock) 0 "attrval"
Name 14 ""
Name 22 "hObj"
Name 25 "as"
Name 36 "payload"
Name 40 "pBlock"
MemberName 40(pBlock) 0 "val1"
MemberName 40(pBlock) 1 "val2"
Name 42 ""
Name 48 "hObjHit"
Name 52 "hObjNop"
Name 53 "hObjMiss"
Name 62 "block"
MemberName 62(block) 0 "op"
Name 64 ""
Name 79 "tmin"
Name 81 "tmax"
Name 84 "orig"
Name 86 "dir"
Name 88 "oorig"
Name 90 "odir"
Name 94 "otw"
Name 96 "wto"
Name 99 "cid"
Name 101 "iid"
Name 103 "pid"
Name 105 "gid"
Name 108 "hkind"
Name 112 "handle"
Name 114 "rid"
Decorate 12(hBlock) Block
Decorate 25(as) DescriptorSet 0
Decorate 25(as) Binding 0
Decorate 40(pBlock) Block
MemberDecorate 62(block) 0 Offset 0
Decorate 62(block) Block
Decorate 64 DescriptorSet 0
Decorate 64 Binding 1
2: TypeVoid
3: TypeFunction 2
6: TypeFloat 32
7: TypeVector 6(float) 2
8: TypePointer HitObjectAttributeNV 7(fvec2)
9(attr): 8(ptr) Variable HitObjectAttributeNV
10: 6(float) Constant 1065353216
11: 7(fvec2) ConstantComposite 10 10
12(hBlock): TypeStruct 6(float)
13: TypePointer HitObjectAttributeNV 12(hBlock)
14: 13(ptr) Variable HitObjectAttributeNV
15: TypeInt 32 1
16: 15(int) Constant 0
17: 6(float) Constant 1073741824
18: TypePointer HitObjectAttributeNV 6(float)
20: TypeHitObjectNV
21: TypePointer Private 20
22(hObj): 21(ptr) Variable Private
23: TypeAccelerationStructureKHR
24: TypePointer UniformConstant 23
25(as): 24(ptr) Variable UniformConstant
27: TypeInt 32 0
28: 27(int) Constant 1
29: TypeVector 6(float) 3
30: 6(float) Constant 1056964608
31: 29(fvec3) ConstantComposite 30 30 30
32: 29(fvec3) ConstantComposite 10 10 10
33: 15(int) Constant 1
34: TypeVector 6(float) 4
35: TypePointer RayPayloadKHR 34(fvec4)
36(payload): 35(ptr) Variable RayPayloadKHR
38: 6(float) Constant 1092616192
39: 15(int) Constant 2
40(pBlock): TypeStruct 7(fvec2) 7(fvec2)
41: TypePointer RayPayloadKHR 40(pBlock)
42: 41(ptr) Variable RayPayloadKHR
44: 27(int) Constant 2
45: 29(fvec3) ConstantComposite 17 17 17
47: 6(float) Constant 1082130432
48(hObjHit): 21(ptr) Variable Private
50: 15(int) Constant 3
52(hObjNop): 21(ptr) Variable Private
53(hObjMiss): 21(ptr) Variable Private
54: 6(float) Constant 1069547520
55: 29(fvec3) ConstantComposite 54 54 54
56: 6(float) Constant 1084227584
57: 6(float) Constant 1090519040
58: TypeBool
62(block): TypeStruct 6(float)
63: TypePointer StorageBuffer 62(block)
64: 63(ptr) Variable StorageBuffer
65: TypePointer StorageBuffer 6(float)
76: 6(float) Constant 1077936128
78: TypePointer Function 6(float)
83: TypePointer Function 29(fvec3)
92: TypeMatrix 29(fvec3) 4
93: TypePointer Function 92
98: TypePointer Function 15(int)
107: TypePointer Function 27(int)
110: TypeVector 27(int) 2
111: TypePointer Function 110(ivec2)
116: 27(int) Constant 4
4(main): 2 Function None 3
5: Label
79(tmin): 78(ptr) Variable Function
81(tmax): 78(ptr) Variable Function
84(orig): 83(ptr) Variable Function
86(dir): 83(ptr) Variable Function
88(oorig): 83(ptr) Variable Function
90(odir): 83(ptr) Variable Function
94(otw): 93(ptr) Variable Function
96(wto): 93(ptr) Variable Function
99(cid): 98(ptr) Variable Function
101(iid): 98(ptr) Variable Function
103(pid): 98(ptr) Variable Function
105(gid): 98(ptr) Variable Function
108(hkind): 107(ptr) Variable Function
112(handle): 111(ptr) Variable Function
114(rid): 107(ptr) Variable Function
Store 9(attr) 11
19: 18(ptr) AccessChain 14 16
Store 19 17
26: 23 Load 25(as)
HitObjectTraceRayNV 22(hObj) 26 28 28 28 28 28 31 30 32 10 36(payload)
37: 23 Load 25(as)
HitObjectTraceRayMotionNV 22(hObj) 37 28 28 28 28 28 31 30 32 10 38 42
43: 23 Load 25(as)
HitObjectRecordHitNV 22(hObj) 43 33 33 33 44 44 44 32 10 45 17 9(attr)
46: 23 Load 25(as)
HitObjectRecordHitMotionNV 22(hObj) 46 33 33 33 44 44 44 32 10 45 17 47 9(attr)
49: 23 Load 25(as)
HitObjectRecordHitWithIndexNV 48(hObjHit) 49 33 33 33 44 44 32 10 45 17 14
51: 23 Load 25(as)
HitObjectRecordHitWithIndexMotionNV 48(hObjHit) 51 33 33 33 44 44 32 10 45 17 47 14
HitObjectRecordEmptyNV 52(hObjNop)
HitObjectRecordMissNV 53(hObjMiss) 28 31 17 55 56
HitObjectRecordMissMotionNV 53(hObjMiss) 28 31 17 55 56 57
HitObjectExecuteShaderNV 48(hObjHit) 36(payload)
59: 58(bool) HitObjectIsHitNV 22(hObj)
SelectionMerge 61 None
BranchConditional 59 60 67
60: Label
66: 65(ptr) AccessChain 64 16
Store 66 10
Branch 61
67: Label
68: 58(bool) HitObjectIsMissNV 22(hObj)
SelectionMerge 70 None
BranchConditional 68 69 72
69: Label
71: 65(ptr) AccessChain 64 16
Store 71 17
Branch 70
72: Label
73: 58(bool) HitObjectIsEmptyNV 22(hObj)
SelectionMerge 75 None
BranchConditional 73 74 75
74: Label
77: 65(ptr) AccessChain 64 16
Store 77 76
Branch 75
75: Label
Branch 70
70: Label
Branch 61
61: Label
80: 6(float) HitObjectGetRayTMinNV 48(hObjHit)
Store 79(tmin) 80
82: 6(float) HitObjectGetRayTMaxNV 48(hObjHit)
Store 81(tmax) 82
85: 29(fvec3) HitObjectGetWorldRayOriginNV 48(hObjHit)
Store 84(orig) 85
87: 29(fvec3) HitObjectGetWorldRayDirectionNV 48(hObjHit)
Store 86(dir) 87
89: 29(fvec3) HitObjectGetObjectRayOriginNV 48(hObjHit)
Store 88(oorig) 89
91: 29(fvec3) HitObjectGetObjectRayDirectionNV 48(hObjHit)
Store 90(odir) 91
95: 92 HitObjectGetObjectToWorldNV 48(hObjHit)
Store 94(otw) 95
97: 92 HitObjectGetWorldToObjectNV 48(hObjHit)
Store 96(wto) 97
100: 15(int) HitObjectGetInstanceCustomIndexNV 53(hObjMiss)
Store 99(cid) 100
102: 15(int) HitObjectGetInstanceIdNV 52(hObjNop)
Store 101(iid) 102
104: 15(int) HitObjectGetPrimitiveIndexNV 22(hObj)
Store 103(pid) 104
106: 15(int) HitObjectGetGeometryIndexNV 22(hObj)
Store 105(gid) 106
109: 27(int) HitObjectGetFrontFaceNV 22(hObj)
Store 108(hkind) 109
HitObjectGetAttributesNV 22(hObj) 9(attr)
113: 110(ivec2) HitObjectGetShaderRecordBufferHandleNV 22(hObj)
Store 112(handle) 113
115: 27(int) HitObjectGetShaderBindingTableRecordIndexNV 22(hObj)
Store 114(rid) 115
ReorderThreadWithHintNV 116 116
ReorderThreadWithHitObjectNV 48(hObjHit)
ReorderThreadWithHitObjectNV 48(hObjHit) 116 44
Return
FunctionEnd

215
Test/baseResults/spv.nv.hitobject-allops.rmiss.out Normal file
View File

@ -0,0 +1,215 @@
spv.nv.hitobject-allops.rmiss
// Module Version 10400
// Generated by (magic number): 8000b
// Id's are bound by 116
Capability RayTracingKHR
Capability ShaderInvocationReorderNV
Extension "SPV_KHR_ray_tracing"
Extension "SPV_NV_shader_invocation_reorder"
1: ExtInstImport "GLSL.std.450"
MemoryModel Logical GLSL450
EntryPoint MissKHR 4 "main" 9 14 22 25 36 42 48 52 53 64
Source GLSL 460
SourceExtension "GL_EXT_ray_tracing"
SourceExtension "GL_NV_ray_tracing_motion_blur"
SourceExtension "GL_NV_shader_invocation_reorder"
Name 4 "main"
Name 9 "attr"
Name 12 "hBlock"
MemberName 12(hBlock) 0 "attrval"
Name 14 ""
Name 22 "hObj"
Name 25 "as"
Name 36 "payload"
Name 40 "pBlock"
MemberName 40(pBlock) 0 "val1"
MemberName 40(pBlock) 1 "val2"
Name 42 ""
Name 48 "hObjHit"
Name 52 "hObjNop"
Name 53 "hObjMiss"
Name 62 "block"
MemberName 62(block) 0 "op"
Name 64 ""
Name 79 "tmin"
Name 81 "tmax"
Name 84 "orig"
Name 86 "dir"
Name 88 "oorig"
Name 90 "odir"
Name 94 "otw"
Name 96 "wto"
Name 99 "cid"
Name 101 "iid"
Name 103 "pid"
Name 105 "gid"
Name 108 "hkind"
Name 112 "handle"
Name 114 "rid"
Decorate 12(hBlock) Block
Decorate 25(as) DescriptorSet 0
Decorate 25(as) Binding 0
Decorate 40(pBlock) Block
MemberDecorate 62(block) 0 Offset 0
Decorate 62(block) Block
Decorate 64 DescriptorSet 0
Decorate 64 Binding 1
2: TypeVoid
3: TypeFunction 2
6: TypeFloat 32
7: TypeVector 6(float) 2
8: TypePointer HitObjectAttributeNV 7(fvec2)
9(attr): 8(ptr) Variable HitObjectAttributeNV
10: 6(float) Constant 1065353216
11: 7(fvec2) ConstantComposite 10 10
12(hBlock): TypeStruct 6(float)
13: TypePointer HitObjectAttributeNV 12(hBlock)
14: 13(ptr) Variable HitObjectAttributeNV
15: TypeInt 32 1
16: 15(int) Constant 0
17: 6(float) Constant 1073741824
18: TypePointer HitObjectAttributeNV 6(float)
20: TypeHitObjectNV
21: TypePointer Private 20
22(hObj): 21(ptr) Variable Private
23: TypeAccelerationStructureKHR
24: TypePointer UniformConstant 23
25(as): 24(ptr) Variable UniformConstant
27: TypeInt 32 0
28: 27(int) Constant 1
29: TypeVector 6(float) 3
30: 6(float) Constant 1056964608
31: 29(fvec3) ConstantComposite 30 30 30
32: 29(fvec3) ConstantComposite 10 10 10
33: 15(int) Constant 1
34: TypeVector 6(float) 4
35: TypePointer RayPayloadKHR 34(fvec4)
36(payload): 35(ptr) Variable RayPayloadKHR
38: 6(float) Constant 1092616192
39: 15(int) Constant 2
40(pBlock): TypeStruct 7(fvec2) 7(fvec2)
41: TypePointer RayPayloadKHR 40(pBlock)
42: 41(ptr) Variable RayPayloadKHR
44: 27(int) Constant 2
45: 29(fvec3) ConstantComposite 17 17 17
47: 6(float) Constant 1082130432
48(hObjHit): 21(ptr) Variable Private
50: 15(int) Constant 3
52(hObjNop): 21(ptr) Variable Private
53(hObjMiss): 21(ptr) Variable Private
54: 6(float) Constant 1069547520
55: 29(fvec3) ConstantComposite 54 54 54
56: 6(float) Constant 1084227584
57: 6(float) Constant 1090519040
58: TypeBool
62(block): TypeStruct 6(float)
63: TypePointer StorageBuffer 62(block)
64: 63(ptr) Variable StorageBuffer
65: TypePointer StorageBuffer 6(float)
76: 6(float) Constant 1077936128
78: TypePointer Function 6(float)
83: TypePointer Function 29(fvec3)
92: TypeMatrix 29(fvec3) 4
93: TypePointer Function 92
98: TypePointer Function 15(int)
107: TypePointer Function 27(int)
110: TypeVector 27(int) 2
111: TypePointer Function 110(ivec2)
4(main): 2 Function None 3
5: Label
79(tmin): 78(ptr) Variable Function
81(tmax): 78(ptr) Variable Function
84(orig): 83(ptr) Variable Function
86(dir): 83(ptr) Variable Function
88(oorig): 83(ptr) Variable Function
90(odir): 83(ptr) Variable Function
94(otw): 93(ptr) Variable Function
96(wto): 93(ptr) Variable Function
99(cid): 98(ptr) Variable Function
101(iid): 98(ptr) Variable Function
103(pid): 98(ptr) Variable Function
105(gid): 98(ptr) Variable Function
108(hkind): 107(ptr) Variable Function
112(handle): 111(ptr) Variable Function
114(rid): 107(ptr) Variable Function
Store 9(attr) 11
19: 18(ptr) AccessChain 14 16
Store 19 17
26: 23 Load 25(as)
HitObjectTraceRayNV 22(hObj) 26 28 28 28 28 28 31 30 32 10 36(payload)
37: 23 Load 25(as)
HitObjectTraceRayMotionNV 22(hObj) 37 28 28 28 28 28 31 30 32 10 38 42
43: 23 Load 25(as)
HitObjectRecordHitNV 22(hObj) 43 33 33 33 44 44 44 32 10 45 17 9(attr)
46: 23 Load 25(as)
HitObjectRecordHitMotionNV 22(hObj) 46 33 33 33 44 44 44 32 10 45 17 47 9(attr)
49: 23 Load 25(as)
HitObjectRecordHitWithIndexNV 48(hObjHit) 49 33 33 33 44 44 32 10 45 17 14
51: 23 Load 25(as)
HitObjectRecordHitWithIndexMotionNV 48(hObjHit) 51 33 33 33 44 44 32 10 45 17 47 14
HitObjectRecordEmptyNV 52(hObjNop)
HitObjectRecordMissNV 53(hObjMiss) 28 31 17 55 56
HitObjectRecordMissMotionNV 53(hObjMiss) 28 31 17 55 56 57
HitObjectExecuteShaderNV 48(hObjHit) 42
59: 58(bool) HitObjectIsHitNV 22(hObj)
SelectionMerge 61 None
BranchConditional 59 60 67
60: Label
66: 65(ptr) AccessChain 64 16
Store 66 10
Branch 61
67: Label
68: 58(bool) HitObjectIsMissNV 22(hObj)
SelectionMerge 70 None
BranchConditional 68 69 72
69: Label
71: 65(ptr) AccessChain 64 16
Store 71 17
Branch 70
72: Label
73: 58(bool) HitObjectIsEmptyNV 22(hObj)
SelectionMerge 75 None
BranchConditional 73 74 75
74: Label
77: 65(ptr) AccessChain 64 16
Store 77 76
Branch 75
75: Label
Branch 70
70: Label
Branch 61
61: Label
80: 6(float) HitObjectGetRayTMinNV 48(hObjHit)
Store 79(tmin) 80
82: 6(float) HitObjectGetRayTMaxNV 48(hObjHit)
Store 81(tmax) 82
85: 29(fvec3) HitObjectGetWorldRayOriginNV 48(hObjHit)
Store 84(orig) 85
87: 29(fvec3) HitObjectGetWorldRayDirectionNV 48(hObjHit)
Store 86(dir) 87
89: 29(fvec3) HitObjectGetObjectRayOriginNV 48(hObjHit)
Store 88(oorig) 89
91: 29(fvec3) HitObjectGetObjectRayDirectionNV 48(hObjHit)
Store 90(odir) 91
95: 92 HitObjectGetObjectToWorldNV 48(hObjHit)
Store 94(otw) 95
97: 92 HitObjectGetWorldToObjectNV 48(hObjHit)
Store 96(wto) 97
100: 15(int) HitObjectGetInstanceCustomIndexNV 53(hObjMiss)
Store 99(cid) 100
102: 15(int) HitObjectGetInstanceIdNV 52(hObjNop)
Store 101(iid) 102
104: 15(int) HitObjectGetPrimitiveIndexNV 22(hObj)
Store 103(pid) 104
106: 15(int) HitObjectGetGeometryIndexNV 22(hObj)
Store 105(gid) 106
109: 27(int) HitObjectGetFrontFaceNV 22(hObj)
Store 108(hkind) 109
HitObjectGetAttributesNV 22(hObj) 9(attr)
113: 110(ivec2) HitObjectGetShaderRecordBufferHandleNV 22(hObj)
Store 112(handle) 113
115: 27(int) HitObjectGetShaderBindingTableRecordIndexNV 22(hObj)
Store 114(rid) 115
Return
FunctionEnd

55
Test/spv.nv.hitobject-allops.rchit Normal file
View File

@ -0,0 +1,55 @@
#version 460
#extension GL_EXT_ray_tracing : enable
#extension GL_NV_shader_invocation_reorder : enable
#extension GL_NV_ray_tracing_motion_blur : enable
layout(location = 1) rayPayloadEXT vec4 payload;
layout(location = 2) rayPayloadEXT pBlock { vec2 val1; vec2 val2; };
layout(location = 2) hitObjectAttributeNV vec2 attr;
layout(location = 3) hitObjectAttributeNV hBlock { float attrval;};
layout(binding = 0) uniform accelerationStructureEXT as;
layout(binding = 1) buffer block {
float op;
};
void main()
{
hitObjectNV hObj;
hitObjectNV hObjHit, hObjMiss, hObjNop;
attr = vec2(1.0);
attrval = 2.0;
hitObjectTraceRayNV(hObj, as, 1U, 1U, 1U, 1U, 1U, vec3(0.5), 0.5, vec3(1), 1.0, 1);
hitObjectTraceRayMotionNV(hObj, as, 1U, 1U, 1U, 1U, 1U, vec3(0.5), 0.5, vec3(1), 1.0, 10.0, 2);
hitObjectRecordHitNV(hObj, as, 1, 1, 1, 2U, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 2);
hitObjectRecordHitMotionNV(hObj, as, 1, 1, 1, 2U, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 4.0f, 2);
hitObjectRecordHitWithIndexNV(hObjHit, as, 1, 1, 1, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 3);
hitObjectRecordHitWithIndexMotionNV(hObjHit, as, 1, 1, 1, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 4.0f, 3);
hitObjectRecordEmptyNV(hObjNop);
hitObjectRecordMissNV(hObjMiss, 1U, vec3(0.5), 2.0, vec3(1.5), 5.0);
hitObjectRecordMissMotionNV(hObjMiss, 1U, vec3(0.5), 2.0, vec3(1.5), 5.0, 8.0f);
hitObjectExecuteShaderNV(hObjHit, 2);
if (hitObjectIsHitNV(hObj)) {
op = 1.0f;
} else if (hitObjectIsMissNV(hObj)) {
op = 2.0f;
} else if (hitObjectIsEmptyNV(hObj)) {
op = 3.0f;
}
float tmin = hitObjectGetRayTMinNV(hObjHit);
float tmax = hitObjectGetRayTMaxNV(hObjHit);
vec3 orig = hitObjectGetWorldRayOriginNV(hObjHit);
vec3 dir = hitObjectGetWorldRayDirectionNV(hObjHit);
vec3 oorig = hitObjectGetObjectRayOriginNV(hObjHit);
vec3 odir = hitObjectGetObjectRayDirectionNV(hObjHit);
mat4x3 otw = hitObjectGetObjectToWorldNV(hObjHit);
mat4x3 wto = hitObjectGetWorldToObjectNV(hObjHit);
int cid = hitObjectGetInstanceCustomIndexNV(hObjMiss);
int iid = hitObjectGetInstanceIdNV(hObjNop);
int pid = hitObjectGetPrimitiveIndexNV(hObj);
int gid = hitObjectGetGeometryIndexNV(hObj);
uint hkind = hitObjectGetHitKindNV(hObj);
hitObjectGetAttributesNV(hObj, 2);
uvec2 handle = hitObjectGetShaderRecordBufferHandleNV(hObj);
uint rid = hitObjectGetShaderBindingTableRecordIndexNV(hObj);
}

61
Test/spv.nv.hitobject-allops.rgen Normal file
View File

@ -0,0 +1,61 @@
#version 460
#extension GL_EXT_ray_tracing : enable
#extension GL_NV_shader_invocation_reorder : enable
#extension GL_NV_ray_tracing_motion_blur : enable
layout(location = 1) rayPayloadEXT vec4 payload;
layout(location = 2) rayPayloadEXT pBlock { vec2 val1; vec2 val2; };
layout(location = 2) hitObjectAttributeNV vec2 attr;
layout(location = 3) hitObjectAttributeNV hBlock { float attrval;};
layout(binding = 0) uniform accelerationStructureEXT as;
layout(binding = 1) buffer block {
float op;
};
void main()
{
hitObjectNV hObj;
hitObjectNV hObjHit, hObjMiss, hObjNop;
attr = vec2(1.0);
attrval = 2.0;
hitObjectTraceRayNV(hObj, as, 1U, 1U, 1U, 1U, 1U, vec3(0.5), 0.5, vec3(1), 1.0, 1);
hitObjectTraceRayMotionNV(hObj, as, 1U, 1U, 1U, 1U, 1U, vec3(0.5), 0.5, vec3(1), 1.0, 10.0, 2);
hitObjectRecordHitNV(hObj, as, 1, 1, 1, 2U, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 2);
hitObjectRecordHitMotionNV(hObj, as, 1, 1, 1, 2U, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 4.0f, 2);
hitObjectRecordHitWithIndexNV(hObjHit, as, 1, 1, 1, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 3);
hitObjectRecordHitWithIndexMotionNV(hObjHit, as, 1, 1, 1, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 4.0f, 3);
hitObjectRecordEmptyNV(hObjNop);
hitObjectRecordMissNV(hObjMiss, 1U, vec3(0.5), 2.0, vec3(1.5), 5.0);
hitObjectRecordMissMotionNV(hObjMiss, 1U, vec3(0.5), 2.0, vec3(1.5), 5.0, 8.0f);
hitObjectExecuteShaderNV(hObjHit, 1);
if (hitObjectIsHitNV(hObj)) {
op = 1.0f;
} else if (hitObjectIsMissNV(hObj)) {
op = 2.0f;
} else if (hitObjectIsEmptyNV(hObj)) {
op = 3.0f;
}
float tmin = hitObjectGetRayTMinNV(hObjHit);
float tmax = hitObjectGetRayTMaxNV(hObjHit);
vec3 orig = hitObjectGetWorldRayOriginNV(hObjHit);
vec3 dir = hitObjectGetWorldRayDirectionNV(hObjHit);
vec3 oorig = hitObjectGetObjectRayOriginNV(hObjHit);
vec3 odir = hitObjectGetObjectRayDirectionNV(hObjHit);
mat4x3 otw = hitObjectGetObjectToWorldNV(hObjHit);
mat4x3 wto = hitObjectGetWorldToObjectNV(hObjHit);
int cid = hitObjectGetInstanceCustomIndexNV(hObjMiss);
int iid = hitObjectGetInstanceIdNV(hObjNop);
int pid = hitObjectGetPrimitiveIndexNV(hObj);
int gid = hitObjectGetGeometryIndexNV(hObj);
uint hkind = hitObjectGetHitKindNV(hObj);
hitObjectGetAttributesNV(hObj, 2);
uvec2 handle = hitObjectGetShaderRecordBufferHandleNV(hObj);
uint rid = hitObjectGetShaderBindingTableRecordIndexNV(hObj);
reorderThreadNV(4,4);
reorderThreadNV(hObjHit);
reorderThreadNV(hObjHit, 4, 2);
}

58
Test/spv.nv.hitobject-allops.rmiss Normal file
View File

@ -0,0 +1,58 @@
#version 460
#extension GL_EXT_ray_tracing : enable
#extension GL_NV_shader_invocation_reorder : enable
#extension GL_NV_ray_tracing_motion_blur : enable
layout(location = 1) rayPayloadEXT vec4 payload;
layout(location = 2) rayPayloadEXT pBlock { vec2 val1; vec2 val2; };
layout(location = 2) hitObjectAttributeNV vec2 attr;
layout(location = 3) hitObjectAttributeNV hBlock { float attrval;};
layout(binding = 0) uniform accelerationStructureEXT as;
layout(binding = 1) buffer block {
float op;
};
void main()
{
hitObjectNV hObj;
hitObjectNV hObjHit, hObjMiss, hObjNop;
attr = vec2(1.0);
attrval = 2.0;
hitObjectTraceRayNV(hObj, as, 1U, 1U, 1U, 1U, 1U, vec3(0.5), 0.5, vec3(1), 1.0, 1);
hitObjectTraceRayMotionNV(hObj, as, 1U, 1U, 1U, 1U, 1U, vec3(0.5), 0.5, vec3(1), 1.0, 10.0, 2);
hitObjectRecordHitNV(hObj, as, 1, 1, 1, 2U, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 2);
hitObjectRecordHitMotionNV(hObj, as, 1, 1, 1, 2U, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 4.0f, 2);
hitObjectRecordHitWithIndexNV(hObjHit, as, 1, 1, 1, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 3);
hitObjectRecordHitWithIndexMotionNV(hObjHit, as, 1, 1, 1, 2U, 2U, vec3(1), 1.0f, vec3(2), 2.0f, 4.0f, 3);
hitObjectRecordEmptyNV(hObjNop);
hitObjectRecordMissNV(hObjMiss, 1U, vec3(0.5), 2.0, vec3(1.5), 5.0);
hitObjectRecordMissMotionNV(hObjMiss, 1U, vec3(0.5), 2.0, vec3(1.5), 5.0, 8.0f);
hitObjectExecuteShaderNV(hObjHit, 2);
if (hitObjectIsHitNV(hObj)) {
op = 1.0f;
} else if (hitObjectIsMissNV(hObj)) {
op = 2.0f;
} else if (hitObjectIsEmptyNV(hObj)) {
op = 3.0f;
}
float tmin = hitObjectGetRayTMinNV(hObjHit);
float tmax = hitObjectGetRayTMaxNV(hObjHit);
vec3 orig = hitObjectGetWorldRayOriginNV(hObjHit);
vec3 dir = hitObjectGetWorldRayDirectionNV(hObjHit);
vec3 oorig = hitObjectGetObjectRayOriginNV(hObjHit);
vec3 odir = hitObjectGetObjectRayDirectionNV(hObjHit);
mat4x3 otw = hitObjectGetObjectToWorldNV(hObjHit);
mat4x3 wto = hitObjectGetWorldToObjectNV(hObjHit);
int cid = hitObjectGetInstanceCustomIndexNV(hObjMiss);
int iid = hitObjectGetInstanceIdNV(hObjNop);
int pid = hitObjectGetPrimitiveIndexNV(hObj);
int gid = hitObjectGetGeometryIndexNV(hObj);
uint hkind = hitObjectGetHitKindNV(hObj);
hitObjectGetAttributesNV(hObj, 2);
uvec2 handle = hitObjectGetShaderRecordBufferHandleNV(hObj);
uint rid = hitObjectGetShaderBindingTableRecordIndexNV(hObj);
}

3
glslang/Include/BaseTypes.h
View File

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

14
glslang/Include/Types.h
View File

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

35
glslang/Include/intermediate.h
View File

@ -968,7 +968,42 @@ enum TOperator {
EOpRayQueryGetIntersectionObjectToWorld, EOpRayQueryGetIntersectionObjectToWorld,
EOpRayQueryGetIntersectionWorldToObject, 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 // HLSL operations
// //

160
glslang/MachineIndependent/Initialize.cpp
View File

@ -4550,7 +4550,8 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
"\n"); "\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) { if (profile != EEsProfile && version >= 460) {
commonBuiltins.append("void rayQueryInitializeEXT(rayQueryEXT, accelerationStructureEXT, uint, uint, vec3, float, vec3, float);" commonBuiltins.append("void rayQueryInitializeEXT(rayQueryEXT, accelerationStructureEXT, uint, uint, vec3, float, vec3, float);"
"void rayQueryTerminateEXT(rayQueryEXT);" "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 traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);" "void executeCallableNV(uint, int);"
"void executeCallableEXT(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"); "\n");
stageBuiltins[EShLangIntersect].append( stageBuiltins[EShLangIntersect].append(
"bool reportIntersectionNV(float, uint);" "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 traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);" "void executeCallableNV(uint, int);"
"void executeCallableEXT(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"); "\n");
stageBuiltins[EShLangMiss].append( stageBuiltins[EShLangMiss].append(
"void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);" "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 traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
"void executeCallableNV(uint, int);" "void executeCallableNV(uint, int);"
"void executeCallableEXT(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"); "\n");
stageBuiltins[EShLangCallable].append( stageBuiltins[EShLangCallable].append(
"void executeCallableNV(uint, int);" "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("executeCallableNV", 1, &E_GL_NV_ray_tracing);
symbolTable.setFunctionExtensions("executeCallableEXT", 1, &E_GL_EXT_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_LaunchIDNV", EbvLaunchId, symbolTable);
BuiltInVariable("gl_LaunchIDEXT", 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("traceRayEXT", EOpTraceKHR);
symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallableNV); symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallableNV);
symbolTable.relateToOperator("executeCallableEXT", EOpExecuteCallableKHR); 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; break;
case EShLangIntersect: case EShLangIntersect:

3
glslang/MachineIndependent/ParseContextBase.cpp
View File

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

89
glslang/MachineIndependent/ParseHelper.cpp
View File

@ -2368,6 +2368,79 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
} }
break; 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 EOpRayQueryGetIntersectionType:
case EOpRayQueryGetIntersectionT: case EOpRayQueryGetIntersectionT:
case EOpRayQueryGetIntersectionInstanceCustomIndex: case EOpRayQueryGetIntersectionInstanceCustomIndex:
@ -4581,7 +4654,7 @@ void TParseContext::checkRuntimeSizable(const TSourceLoc& loc, const TIntermType
// check for additional things allowed by GL_EXT_nonuniform_qualifier // check for additional things allowed by GL_EXT_nonuniform_qualifier
if (base.getBasicType() == EbtSampler || base.getBasicType() == EbtAccStruct || base.getBasicType() == EbtRayQuery || 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"); requireExtensions(loc, 1, &E_GL_EXT_nonuniform_qualifier, "variable index");
else else
error(loc, "", "[", "array must be redeclared with a size before being indexed with a variable"); 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; publicType.qualifier.layoutShaderRecord = true;
return; 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; dst.pervertexNV = true;
if (src.pervertexEXT) if (src.pervertexEXT)
dst.pervertexEXT = true; dst.pervertexEXT = true;
if (src.layoutHitObjectShaderRecordNV)
dst.layoutHitObjectShaderRecordNV = true;
#endif #endif
} }
} }
@ -6389,6 +6468,7 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
case EvqHitAttr: case EvqHitAttr:
case EvqCallableData: case EvqCallableData:
case EvqCallableDataIn: case EvqCallableDataIn:
case EvqHitObjectAttrNV:
break; break;
#endif #endif
default: default:
@ -7344,7 +7424,10 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
if (initializer) { if (initializer) {
if (type.getBasicType() == EbtRayQuery) { if (type.getBasicType() == EbtRayQuery) {
error(loc, "ray queries can only be initialized by using the rayQueryInitializeEXT intrinsic:", "=", identifier.c_str()); 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()) { if (type.isCoopMat()) {
@ -8771,6 +8854,10 @@ void TParseContext::blockStageIoCheck(const TSourceLoc& loc, const TQualifier& q
profileRequires(loc, ~EEsProfile, 460, 2, extsrt, "callableDataInNV block"); profileRequires(loc, ~EEsProfile, 460, 2, extsrt, "callableDataInNV block");
requireStage(loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV block"); requireStage(loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV block");
break; 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 #endif
default: default:
error(loc, "only uniform, buffer, in, or out blocks are supported", blockName->c_str(), ""); 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)["icoopmatNV"] = ICOOPMATNV;
(*KeywordMap)["ucoopmatNV"] = UCOOPMATNV; (*KeywordMap)["ucoopmatNV"] = UCOOPMATNV;
(*KeywordMap)["hitObjectNV"] = HITOBJECTNV;
(*KeywordMap)["hitObjectAttributeNV"] = HITOBJECTATTRNV;
ReservedSet = new std::unordered_set<const char*, str_hash, str_eq>; ReservedSet = new std::unordered_set<const char*, str_hash, str_eq>;
ReservedSet->insert("common"); ReservedSet->insert("common");
@ -1789,6 +1792,20 @@ int TScanContext::tokenizeIdentifier()
parseContext.extensionTurnedOn(E_GL_EXT_spirv_intrinsics)) parseContext.extensionTurnedOn(E_GL_EXT_spirv_intrinsics))
return keyword; return keyword;
return identifierOrType(); 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 #endif
default: default:

1
glslang/MachineIndependent/SymbolTable.cpp
View File

@ -78,6 +78,7 @@ void TType::buildMangledName(TString& mangledName) const
case EbtAccStruct: mangledName += "as"; break; case EbtAccStruct: mangledName += "as"; break;
case EbtRayQuery: mangledName += "rq"; break; case EbtRayQuery: mangledName += "rq"; break;
case EbtSpirvType: mangledName += "spv-t"; break; case EbtSpirvType: mangledName += "spv-t"; break;
case EbtHitObjectNV: mangledName += "ho"; break;
#endif #endif
case EbtSampler: case EbtSampler:
switch (sampler.type) { 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_shader_sm_builtins] = EBhDisable;
extensionBehavior[E_GL_NV_integer_cooperative_matrix] = EBhDisable; extensionBehavior[E_GL_NV_integer_cooperative_matrix] = EBhDisable;
// ARM extensionBehavior[E_GL_NV_shader_invocation_reorder] = EBhDisable;
extensionBehavior[E_GL_ARM_shader_core_builtins] = EBhDisable;
// ARM
extensionBehavior[E_GL_ARM_shader_core_builtins] = EBhDisable;
// AEP // AEP
extensionBehavior[E_GL_ANDROID_extension_pack_es31a] = EBhDisable; 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_mesh_shader 1\n"
"#define GL_NV_cooperative_matrix 1\n" "#define GL_NV_cooperative_matrix 1\n"
"#define GL_NV_integer_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 1\n"
"#define GL_EXT_shader_explicit_arithmetic_types_int8 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_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_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_integer_cooperative_matrix = "GL_NV_integer_cooperative_matrix";
const char* const E_GL_NV_shader_invocation_reorder = "GL_NV_shader_invocation_reorder";
// AEP // AEP
const char* const E_GL_ANDROID_extension_pack_es31a = "GL_ANDROID_extension_pack_es31a"; 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> ACCSTRUCTEXT
%token <lex> RAYQUERYEXT %token <lex> RAYQUERYEXT
%token <lex> FCOOPMATNV ICOOPMATNV UCOOPMATNV %token <lex> FCOOPMATNV ICOOPMATNV UCOOPMATNV
%token <lex> HITOBJECTNV HITOBJECTATTRNV
// combined image/sampler // combined image/sampler
%token <lex> SAMPLERCUBEARRAY SAMPLERCUBEARRAYSHADOW %token <lex> SAMPLERCUBEARRAY SAMPLERCUBEARRAYSHADOW
@ -310,7 +311,7 @@ GLSLANG_WEB_EXCLUDE_ON
%token <lex> DOUBLECONSTANT INT16CONSTANT UINT16CONSTANT FLOAT16CONSTANT INT32CONSTANT UINT32CONSTANT %token <lex> DOUBLECONSTANT INT16CONSTANT UINT16CONSTANT FLOAT16CONSTANT INT32CONSTANT UINT32CONSTANT
%token <lex> INT64CONSTANT UINT64CONSTANT %token <lex> INT64CONSTANT UINT64CONSTANT
%token <lex> SUBROUTINE DEMOTE %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> PAYLOADEXT PAYLOADINEXT HITATTREXT CALLDATAEXT CALLDATAINEXT
%token <lex> PATCH SAMPLE NONUNIFORM %token <lex> PATCH SAMPLE NONUNIFORM
%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT %token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT
@ -1534,6 +1535,14 @@ GLSLANG_WEB_EXCLUDE_ON
$$.init($1.loc); $$.init($1.loc);
$$.qualifier.storage = EvqHitAttr; $$.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 { | HITATTREXT {
parseContext.globalCheck($1.loc, "hitAttributeEXT"); parseContext.globalCheck($1.loc, "hitAttributeEXT");
parseContext.requireStage($1.loc, (EShLanguageMask)(EShLangIntersectMask | EShLangClosestHitMask 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"); parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
$$ = $1; $$ = $1;
} }
| HITOBJECTNV {
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtHitObjectNV;
}
GLSLANG_WEB_EXCLUDE_OFF GLSLANG_WEB_EXCLUDE_OFF
| struct_specifier { | struct_specifier {
$$ = $1; $$ = $1;

17
glslang/MachineIndependent/glslang.y
View File

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

4
glslang/MachineIndependent/linkValidate.cpp
View File

@ -1614,6 +1614,8 @@ int TIntermediate::addUsedLocation(const TQualifier& qualifier, const TType& typ
setRT = 0; setRT = 0;
else if (qualifier.isAnyCallable()) else if (qualifier.isAnyCallable())
setRT = 1; setRT = 1;
else if (qualifier.isHitObjectAttrNV())
setRT = 2;
else else
return -1; return -1;
@ -1653,7 +1655,7 @@ int TIntermediate::addUsedLocation(const TQualifier& qualifier, const TType& typ
// slot irrespective of type. // slot irrespective of type.
int collision = -1; // no collision int collision = -1; // no collision
#ifndef GLSLANG_WEB #ifndef GLSLANG_WEB
if (qualifier.isAnyPayload() || qualifier.isAnyCallable()) { if (qualifier.isAnyPayload() || qualifier.isAnyCallable() || qualifier.isHitObjectAttrNV()) {
TRange range(qualifier.layoutLocation, qualifier.layoutLocation); TRange range(qualifier.layoutLocation, qualifier.layoutLocation);
collision = checkLocationRT(setRT, qualifier.layoutLocation); collision = checkLocationRT(setRT, qualifier.layoutLocation);
if (collision < 0) 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::unordered_set<int> usedConstantId; // specialization constant ids used
std::vector<TOffsetRange> usedAtomics; // sets of bindings used by atomic counters 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<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 std::vector<TRange> usedIoRT[4]; // sets of used location, one for rayPayload/rayPayloadIN,
// for callableData/callableDataIn // 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 // set of names of statically read/written I/O that might need extra checking
std::set<TString> ioAccessed; std::set<TString> ioAccessed;

6
gtests/Spv.FromFile.cpp
View File

@ -652,6 +652,12 @@ INSTANTIATE_TEST_SUITE_P(
"spv.atomiAddEXT.task", "spv.atomiAddEXT.task",
"spv.460.subgroupEXT.task", "spv.460.subgroupEXT.task",
"spv.460.subgroupEXT.mesh", "spv.460.subgroupEXT.mesh",
// SPV_NV_shader_execution_reorder
"spv.nv.hitobject-allops.rgen",
"spv.nv.hitobject-allops.rchit",
"spv.nv.hitobject-allops.rmiss",
})), })),
FileNameAsCustomTestSuffix FileNameAsCustomTestSuffix
); );