Merge pull request #1543 from alelenv/nv-raytracing-final

Add support for nv_ray_tracing final

SPIRV/GLSL.ext.NV.h

@@ -66,8 +66,8 @@ const char* const E_SPV_NV_shader_image_footprint = "SPV_NV_shader_image_footpri
 //SPV_NV_mesh_shader
 const char* const E_SPV_NV_mesh_shader = "SPV_NV_mesh_shader";
 
-//SPV_NVX_raytracing
-const char* const E_SPV_NVX_raytracing = "SPV_NVX_raytracing";
+//SPV_NV_raytracing
+const char* const E_SPV_NV_ray_tracing = "SPV_NV_ray_tracing";
 
 //SPV_NV_shading_rate
 const char* const E_SPV_NV_shading_rate = "SPV_NV_shading_rate";

SPIRV/GlslangToSpv.cpp

@@ -276,12 +276,12 @@ spv::ExecutionModel TranslateExecutionModel(EShLanguage stage)
     case EShLangFragment:         return spv::ExecutionModelFragment;
     case EShLangCompute:          return spv::ExecutionModelGLCompute;
 #ifdef NV_EXTENSIONS
-    case EShLangRayGenNV:         return spv::ExecutionModelRayGenerationNVX;
-    case EShLangIntersectNV:      return spv::ExecutionModelIntersectionNVX;
-    case EShLangAnyHitNV:         return spv::ExecutionModelAnyHitNVX;
-    case EShLangClosestHitNV:     return spv::ExecutionModelClosestHitNVX;
-    case EShLangMissNV:           return spv::ExecutionModelMissNVX;
-    case EShLangCallableNV:       return spv::ExecutionModelCallableNVX;
+    case EShLangRayGenNV:         return spv::ExecutionModelRayGenerationNV;
+    case EShLangIntersectNV:      return spv::ExecutionModelIntersectionNV;
+    case EShLangAnyHitNV:         return spv::ExecutionModelAnyHitNV;
+    case EShLangClosestHitNV:     return spv::ExecutionModelClosestHitNV;
+    case EShLangMissNV:           return spv::ExecutionModelMissNV;
+    case EShLangCallableNV:       return spv::ExecutionModelCallableNV;
     case EShLangTaskNV:           return spv::ExecutionModelTaskNV;
     case EShLangMeshNV:           return spv::ExecutionModelMeshNV;
 #endif
@@ -338,6 +338,8 @@ spv::Decoration TranslateBlockDecoration(const glslang::TType& type, bool useSto
         case glslang::EvqPayloadNV:    return spv::DecorationBlock;
         case glslang::EvqPayloadInNV:  return spv::DecorationBlock;
         case glslang::EvqHitAttrNV:    return spv::DecorationBlock;
+        case glslang::EvqCallableDataNV:   return spv::DecorationBlock;
+        case glslang::EvqCallableDataInNV: return spv::DecorationBlock;
 #endif
         default:
             assert(0);
@@ -411,6 +413,8 @@ spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::T
             case glslang::EvqPayloadNV:
             case glslang::EvqPayloadInNV:
             case glslang::EvqHitAttrNV:
+            case glslang::EvqCallableDataNV:
+            case glslang::EvqCallableDataInNV:
                 return spv::DecorationMax;
 #endif
             default:
@@ -875,31 +879,33 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI
 
     // raytracing
     case glslang::EbvLaunchIdNV:
-        return spv::BuiltInLaunchIdNVX;
+        return spv::BuiltInLaunchIdNV;
     case glslang::EbvLaunchSizeNV:
-        return spv::BuiltInLaunchSizeNVX;
+        return spv::BuiltInLaunchSizeNV;
     case glslang::EbvWorldRayOriginNV:
-        return spv::BuiltInWorldRayOriginNVX;
+        return spv::BuiltInWorldRayOriginNV;
     case glslang::EbvWorldRayDirectionNV:
-        return spv::BuiltInWorldRayDirectionNVX;
+        return spv::BuiltInWorldRayDirectionNV;
     case glslang::EbvObjectRayOriginNV:
-        return spv::BuiltInObjectRayOriginNVX;
+        return spv::BuiltInObjectRayOriginNV;
     case glslang::EbvObjectRayDirectionNV:
-        return spv::BuiltInObjectRayDirectionNVX;
+        return spv::BuiltInObjectRayDirectionNV;
     case glslang::EbvRayTminNV:
-        return spv::BuiltInRayTminNVX;
+        return spv::BuiltInRayTminNV;
     case glslang::EbvRayTmaxNV:
-        return spv::BuiltInRayTmaxNVX;
+        return spv::BuiltInRayTmaxNV;
     case glslang::EbvInstanceCustomIndexNV:
-        return spv::BuiltInInstanceCustomIndexNVX;
+        return spv::BuiltInInstanceCustomIndexNV;
     case glslang::EbvHitTNV:
-        return spv::BuiltInHitTNVX;
+        return spv::BuiltInHitTNV;
     case glslang::EbvHitKindNV:
-        return spv::BuiltInHitKindNVX;
+        return spv::BuiltInHitKindNV;
     case glslang::EbvObjectToWorldNV:
-        return spv::BuiltInObjectToWorldNVX;
+        return spv::BuiltInObjectToWorldNV;
     case glslang::EbvWorldToObjectNV:
-        return spv::BuiltInWorldToObjectNVX;
+        return spv::BuiltInWorldToObjectNV;
+    case glslang::EbvIncomingRayFlagsNV:
+        return spv::BuiltInIncomingRayFlagsNV;
     case glslang::EbvBaryCoordNV:
         builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
         builder.addCapability(spv::CapabilityFragmentBarycentricNV);
@@ -1082,7 +1088,7 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
             return spv::StorageClassPushConstant;
 #ifdef NV_EXTENSIONS
         if (type.getQualifier().layoutShaderRecordNV)
-            return spv::StorageClassShaderRecordBufferNVX;
+            return spv::StorageClassShaderRecordBufferNV;
 #endif
         if (type.getBasicType() == glslang::EbtBlock)
             return spv::StorageClassUniform;
@@ -1095,9 +1101,11 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
     case glslang::EvqConstReadOnly: return spv::StorageClassFunction;
     case glslang::EvqTemporary:     return spv::StorageClassFunction;
 #ifdef NV_EXTENSIONS
-    case glslang::EvqPayloadNV:     return spv::StorageClassRayPayloadNVX;
-    case glslang::EvqPayloadInNV:   return spv::StorageClassIncomingRayPayloadNVX;
-    case glslang::EvqHitAttrNV:     return spv::StorageClassHitAttributeNVX;
+    case glslang::EvqPayloadNV:        return spv::StorageClassRayPayloadNV;
+    case glslang::EvqPayloadInNV:      return spv::StorageClassIncomingRayPayloadNV;
+    case glslang::EvqHitAttrNV:        return spv::StorageClassHitAttributeNV;
+    case glslang::EvqCallableDataNV:   return spv::StorageClassCallableDataNV;
+    case glslang::EvqCallableDataInNV: return spv::StorageClassIncomingCallableDataNV;
 #endif
     default:
         assert(0);
@@ -1430,8 +1438,8 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion, const gl
     case EShLangClosestHitNV:
     case EShLangMissNV:
     case EShLangCallableNV:
-        builder.addCapability(spv::CapabilityRaytracingNVX);
-        builder.addExtension("SPV_NVX_raytracing");
+        builder.addCapability(spv::CapabilityRayTracingNV);
+        builder.addExtension("SPV_NV_ray_tracing");
         break;
     case EShLangTaskNV:
     case EShLangMeshNV:
@@ -2267,6 +2275,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     case glslang::EOpIgnoreIntersectionNV:
     case glslang::EOpTerminateRayNV:
     case glslang::EOpTraceNV:
+    case glslang::EOpExecuteCallableNV:
     case glslang::EOpWritePackedPrimitiveIndices4x8NV:
         noReturnValue = true;
         break;
@@ -6871,12 +6880,18 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
     case glslang::EOpReportIntersectionNV:
     {
         typeId = builder.makeBoolType();
-        opCode = spv::OpReportIntersectionNVX;
+        opCode = spv::OpReportIntersectionNV;
     }
     break;
     case glslang::EOpTraceNV:
     {
-        builder.createNoResultOp(spv::OpTraceNVX, operands);
+        builder.createNoResultOp(spv::OpTraceNV, operands);
+        return 0;
+    }
+    break;
+    case glslang::EOpExecuteCallableNV:
+    {
+        builder.createNoResultOp(spv::OpExecuteCallableNV, operands);
         return 0;
     }
     break;
@@ -7060,10 +7075,10 @@ spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv:
 #endif
 #ifdef NV_EXTENSIONS
     case glslang::EOpIgnoreIntersectionNV:
-        builder.createNoResultOp(spv::OpIgnoreIntersectionNVX);
+        builder.createNoResultOp(spv::OpIgnoreIntersectionNV);
         return 0;
     case glslang::EOpTerminateRayNV:
-        builder.createNoResultOp(spv::OpTerminateRayNVX);
+        builder.createNoResultOp(spv::OpTerminateRayNV);
         return 0;
 #endif
     default:

SPIRV/SpvBuilder.cpp

@@ -507,12 +507,12 @@ Id Builder::makeSampledImageType(Id imageType)
 Id Builder::makeAccelerationStructureNVType()
 {
     Instruction *type;
-    if (groupedTypes[OpTypeAccelerationStructureNVX].size() == 0) {
-        type = new Instruction(getUniqueId(), NoType, OpTypeAccelerationStructureNVX);
+    if (groupedTypes[OpTypeAccelerationStructureNV].size() == 0) {
+        type = new Instruction(getUniqueId(), NoType, OpTypeAccelerationStructureNV);
         constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
         module.mapInstruction(type);
     } else {
-        type = groupedTypes[OpTypeAccelerationStructureNVX].back();
+        type = groupedTypes[OpTypeAccelerationStructureNV].back();
     }
 
     return type->getResultId();

SPIRV/doc.cpp

@@ -106,12 +106,12 @@ const char* ExecutionModelString(int model)
     default: return "Bad";
 
 #ifdef NV_EXTENSIONS
-    case ExecutionModelRayGenerationNVX: return "RayGenerationNVX";
-    case ExecutionModelIntersectionNVX:  return "IntersectionNVX";
-    case ExecutionModelAnyHitNVX:        return "AnyHitNVX";
-    case ExecutionModelClosestHitNVX:    return "ClosestHitNVX";
-    case ExecutionModelMissNVX:          return "MissNVX";
-    case ExecutionModelCallableNVX:      return "CallableNVX";
+    case ExecutionModelRayGenerationNV: return "RayGenerationNV";
+    case ExecutionModelIntersectionNV:  return "IntersectionNV";
+    case ExecutionModelAnyHitNV:        return "AnyHitNV";
+    case ExecutionModelClosestHitNV:    return "ClosestHitNV";
+    case ExecutionModelMissNV:          return "MissNV";
+    case ExecutionModelCallableNV:      return "CallableNV";
 #endif
 
     }
@@ -212,10 +212,12 @@ const char* StorageClassString(int StorageClass)
     case 12: return "StorageBuffer";
 
 #ifdef NV_EXTENSIONS
-    case StorageClassRayPayloadNVX:         return "RayPayloadNVX";
-    case StorageClassHitAttributeNVX:       return "HitAttributeNVX";
-    case StorageClassIncomingRayPayloadNVX: return "IncomingRayPayloadNVX";
-    case StorageClassShaderRecordBufferNVX: return "ShaderRecordBufferNVX";
+    case StorageClassRayPayloadNV:            return "RayPayloadNV";
+    case StorageClassHitAttributeNV:          return "HitAttributeNV";
+    case StorageClassIncomingRayPayloadNV:    return "IncomingRayPayloadNV";
+    case StorageClassShaderRecordBufferNV:    return "ShaderRecordBufferNV";
+    case StorageClassCallableDataNV:          return "CallableDataNV";
+    case StorageClassIncomingCallableDataNV:  return "IncomingCallableDataNV";
 #endif
 
     default: return "Bad";
@@ -367,19 +369,20 @@ const char* BuiltInString(int builtIn)
 #endif
 
 #ifdef NV_EXTENSIONS
-    case BuiltInLaunchIdNVX:                return "LaunchIdNVX";
-    case BuiltInLaunchSizeNVX:              return "LaunchSizeNVX";
-    case BuiltInWorldRayOriginNVX:          return "WorldRayOriginNVX";
-    case BuiltInWorldRayDirectionNVX:       return "WorldRayDirectionNVX";
-    case BuiltInObjectRayOriginNVX:         return "ObjectRayOriginNVX";
-    case BuiltInObjectRayDirectionNVX:      return "ObjectRayDirectionNVX";
-    case BuiltInRayTminNVX:                 return "RayTminNVX";
-    case BuiltInRayTmaxNVX:                 return "RayTmaxNVX";
-    case BuiltInInstanceCustomIndexNVX:     return "InstanceCustomIndexNVX";
-    case BuiltInObjectToWorldNVX:           return "ObjectToWorldNVX";
-    case BuiltInWorldToObjectNVX:           return "WorldToObjectNVX";
-    case BuiltInHitTNVX:                    return "HitTNVX";
-    case BuiltInHitKindNVX:                 return "HitKindNVX";
+    case BuiltInLaunchIdNV:                 return "LaunchIdNV";
+    case BuiltInLaunchSizeNV:               return "LaunchSizeNV";
+    case BuiltInWorldRayOriginNV:           return "WorldRayOriginNV";
+    case BuiltInWorldRayDirectionNV:        return "WorldRayDirectionNV";
+    case BuiltInObjectRayOriginNV:          return "ObjectRayOriginNV";
+    case BuiltInObjectRayDirectionNV:       return "ObjectRayDirectionNV";
+    case BuiltInRayTminNV:                  return "RayTminNV";
+    case BuiltInRayTmaxNV:                  return "RayTmaxNV";
+    case BuiltInInstanceCustomIndexNV:      return "InstanceCustomIndexNV";
+    case BuiltInObjectToWorldNV:            return "ObjectToWorldNV";
+    case BuiltInWorldToObjectNV:            return "WorldToObjectNV";
+    case BuiltInHitTNV:                     return "HitTNV";
+    case BuiltInHitKindNV:                  return "HitKindNV";
+    case BuiltInIncomingRayFlagsNV:         return "IncomingRayFlagsNV";
     case BuiltInViewportMaskNV:             return "ViewportMaskNV";
     case BuiltInSecondaryPositionNV:        return "SecondaryPositionNV";
     case BuiltInSecondaryViewportMaskNV:    return "SecondaryViewportMaskNV";
@@ -889,7 +892,7 @@ const char* CapabilityString(int info)
     case CapabilityShaderStereoViewNV:              return "ShaderStereoViewNV";
     case CapabilityPerViewAttributesNV:             return "PerViewAttributesNV";
     case CapabilityGroupNonUniformPartitionedNV:    return "GroupNonUniformPartitionedNV";
-    case CapabilityRaytracingNVX:                   return "RaytracingNVX";
+    case CapabilityRayTracingNV:                    return "RayTracingNV";
     case CapabilityComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
     case CapabilityComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
     case CapabilityFragmentBarycentricNV:           return "FragmentBarycentricNV";
@@ -1308,11 +1311,12 @@ const char* OpcodeString(int op)
 
 #ifdef NV_EXTENSIONS
     case OpGroupNonUniformPartitionNV:       return "OpGroupNonUniformPartitionNV";
-    case OpReportIntersectionNVX:            return "OpReportIntersectionNVX";
-    case OpIgnoreIntersectionNVX:            return "OpIgnoreIntersectionNVX";
-    case OpTerminateRayNVX:                  return "OpTerminateRayNVX";
-    case OpTraceNVX:                         return "OpTraceNVX";
-    case OpTypeAccelerationStructureNVX:     return "OpTypeAccelerationStructureNVX";
+    case OpReportIntersectionNV:             return "OpReportIntersectionNV";
+    case OpIgnoreIntersectionNV:             return "OpIgnoreIntersectionNV";
+    case OpTerminateRayNV:                   return "OpTerminateRayNV";
+    case OpTraceNV:                          return "OpTraceNV";
+    case OpTypeAccelerationStructureNV:      return "OpTypeAccelerationStructureNV";
+    case OpExecuteCallableNV:                return "OpExecuteCallableNV";
     case OpImageSampleFootprintNV:           return "OpImageSampleFootprintNV";
     case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
 #endif
@@ -2662,28 +2666,32 @@ void Parameterize()
 #ifdef NV_EXTENSIONS
     InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X");
 
-    InstructionDesc[OpTypeAccelerationStructureNVX].setResultAndType(true, false);
+    InstructionDesc[OpTypeAccelerationStructureNV].setResultAndType(true, false);
 
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'NV Acceleration Structure'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'Ray Flags'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'Cull Mask'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'SBT Record Offset'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'SBT Record Stride'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'Miss Index'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'Ray Origin'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'TMin'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'Ray Direction'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'TMax'");
-    InstructionDesc[OpTraceNVX].operands.push(OperandId, "'Payload'");
-    InstructionDesc[OpTraceNVX].setResultAndType(false, false);
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'NV Acceleration Structure'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Flags'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Cull Mask'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Offset'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Stride'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Miss Index'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Origin'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMin'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Direction'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMax'");
+    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Payload'");
+    InstructionDesc[OpTraceNV].setResultAndType(false, false);
 
-    InstructionDesc[OpReportIntersectionNVX].operands.push(OperandId, "'Hit Parameter'");
-    InstructionDesc[OpReportIntersectionNVX].operands.push(OperandId, "'Hit Kind'");
+    InstructionDesc[OpReportIntersectionNV].operands.push(OperandId, "'Hit Parameter'");
+    InstructionDesc[OpReportIntersectionNV].operands.push(OperandId, "'Hit Kind'");
 
-    InstructionDesc[OpIgnoreIntersectionNVX].setResultAndType(false, false);
+    InstructionDesc[OpIgnoreIntersectionNV].setResultAndType(false, false);
 
-    InstructionDesc[OpTerminateRayNVX].setResultAndType(false, false);
+    InstructionDesc[OpTerminateRayNV].setResultAndType(false, false);
     
+    InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "SBT Record Index");
+    InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "CallableData ID");
+    InstructionDesc[OpExecuteCallableNV].setResultAndType(false, false);
+
     InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
     InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
     InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");

SPIRV/spirv.hpp

@@ -75,12 +75,12 @@ enum ExecutionModel {
     ExecutionModelKernel = 6,
     ExecutionModelTaskNV = 5267,
     ExecutionModelMeshNV = 5268,
-    ExecutionModelRayGenerationNVX = 5313,
-    ExecutionModelIntersectionNVX = 5314,
-    ExecutionModelAnyHitNVX = 5315,
-    ExecutionModelClosestHitNVX = 5316,
-    ExecutionModelMissNVX = 5317,
-    ExecutionModelCallableNVX = 5318,
+    ExecutionModelRayGenerationNV = 5313,
+    ExecutionModelIntersectionNV = 5314,
+    ExecutionModelAnyHitNV = 5315,
+    ExecutionModelClosestHitNV = 5316,
+    ExecutionModelMissNV = 5317,
+    ExecutionModelCallableNV = 5318,
     ExecutionModelMax = 0x7fffffff,
 };
 
@@ -162,10 +162,12 @@ enum StorageClass {
     StorageClassAtomicCounter = 10,
     StorageClassImage = 11,
     StorageClassStorageBuffer = 12,
-    StorageClassRayPayloadNVX = 5338,
-    StorageClassHitAttributeNVX = 5339,
-    StorageClassIncomingRayPayloadNVX = 5342,
-    StorageClassShaderRecordBufferNVX = 5343,
+    StorageClassCallableDataNV = 5328,
+    StorageClassIncomingCallableDataNV = 5329,
+    StorageClassRayPayloadNV = 5338,
+    StorageClassHitAttributeNV = 5339,
+    StorageClassIncomingRayPayloadNV = 5342,
+    StorageClassShaderRecordBufferNV = 5343,
     StorageClassMax = 0x7fffffff,
 };
 
@@ -512,19 +514,20 @@ enum BuiltIn {
     BuiltInBaryCoordNoPerspNV = 5287,
     BuiltInFragmentSizeNV = 5292,
     BuiltInInvocationsPerPixelNV = 5293,
-    BuiltInLaunchIdNVX = 5319,
-    BuiltInLaunchSizeNVX = 5320,
-    BuiltInWorldRayOriginNVX = 5321,
-    BuiltInWorldRayDirectionNVX = 5322,
-    BuiltInObjectRayOriginNVX = 5323,
-    BuiltInObjectRayDirectionNVX = 5324,
-    BuiltInRayTminNVX = 5325,
-    BuiltInRayTmaxNVX = 5326,
-    BuiltInInstanceCustomIndexNVX = 5327,
-    BuiltInObjectToWorldNVX = 5330,
-    BuiltInWorldToObjectNVX = 5331,
-    BuiltInHitTNVX = 5332,
-    BuiltInHitKindNVX = 5333,
+    BuiltInLaunchIdNV = 5319,
+    BuiltInLaunchSizeNV = 5320,
+    BuiltInWorldRayOriginNV = 5321,
+    BuiltInWorldRayDirectionNV = 5322,
+    BuiltInObjectRayOriginNV = 5323,
+    BuiltInObjectRayDirectionNV = 5324,
+    BuiltInRayTminNV = 5325,
+    BuiltInRayTmaxNV = 5326,
+    BuiltInInstanceCustomIndexNV = 5327,
+    BuiltInObjectToWorldNV = 5330,
+    BuiltInWorldToObjectNV = 5331,
+    BuiltInHitTNV = 5332,
+    BuiltInHitKindNV = 5333,
+    BuiltInIncomingRayFlagsNV = 5351,
     BuiltInMax = 0x7fffffff,
 };
 
@@ -781,7 +784,7 @@ enum Capability {
     CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
     CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
     CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
-    CapabilityRaytracingNVX = 5340,
+    CapabilityRayTracingNV = 5340,
     CapabilityVulkanMemoryModelKHR = 5345,
     CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
     CapabilityComputeDerivativeGroupLinearNV = 5350,
@@ -1151,11 +1154,12 @@ enum Op {
     OpImageSampleFootprintNV = 5283,
     OpGroupNonUniformPartitionNV = 5296,
     OpWritePackedPrimitiveIndices4x8NV = 5299,
-    OpReportIntersectionNVX = 5334,
-    OpIgnoreIntersectionNVX = 5335,
-    OpTerminateRayNVX = 5336,
-    OpTraceNVX = 5337,
-    OpTypeAccelerationStructureNVX = 5341,
+    OpReportIntersectionNV = 5334,
+    OpIgnoreIntersectionNV = 5335,
+    OpTerminateRayNV = 5336,
+    OpTraceNV = 5337,
+    OpTypeAccelerationStructureNV = 5341,
+    OpExecuteCallableNV = 5344,
     OpSubgroupShuffleINTEL = 5571,
     OpSubgroupShuffleDownINTEL = 5572,
     OpSubgroupShuffleUpINTEL = 5573,

Test/baseResults/spv.AnyHitShader.rahit.out

@@ -3,99 +3,99 @@ spv.AnyHitShader.rahit
 // Generated by (magic number): 80007
 // Id's are bound by 81
 
-                              Capability RaytracingNVX
-                              Extension  "SPV_NVX_raytracing"
+                              Capability RayTracingNV
+                              Extension  "SPV_NV_ray_tracing"
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint AnyHitNVX 4  "main" 11 14 20 23 26 33 36 39 42 47 50 53 58 64 67
+                              EntryPoint AnyHitNV 4  "main" 11 14 20 23 26 33 36 39 42 47 50 53 58 64 67
                               Source GLSL 460
-                              SourceExtension  "GL_NVX_raytracing"
+                              SourceExtension  "GL_NV_ray_tracing"
                               Name 4  "main"
                               Name 9  "v0"
-                              Name 11  "gl_LaunchIDNVX"
+                              Name 11  "gl_LaunchIDNV"
                               Name 13  "v1"
-                              Name 14  "gl_LaunchSizeNVX"
+                              Name 14  "gl_LaunchSizeNV"
                               Name 18  "v2"
                               Name 20  "gl_PrimitiveID"
                               Name 22  "v3"
                               Name 23  "gl_InstanceID"
                               Name 25  "v4"
-                              Name 26  "gl_InstanceCustomIndexNVX"
+                              Name 26  "gl_InstanceCustomIndexNV"
                               Name 31  "v5"
-                              Name 33  "gl_WorldRayOriginNVX"
+                              Name 33  "gl_WorldRayOriginNV"
                               Name 35  "v6"
-                              Name 36  "gl_WorldRayDirectionNVX"
+                              Name 36  "gl_WorldRayDirectionNV"
                               Name 38  "v7"
-                              Name 39  "gl_ObjectRayOriginNVX"
+                              Name 39  "gl_ObjectRayOriginNV"
                               Name 41  "v8"
-                              Name 42  "gl_ObjectRayDirectionNVX"
+                              Name 42  "gl_ObjectRayDirectionNV"
                               Name 45  "v9"
-                              Name 47  "gl_RayTminNVX"
+                              Name 47  "gl_RayTminNV"
                               Name 49  "v10"
-                              Name 50  "gl_RayTmaxNVX"
+                              Name 50  "gl_RayTmaxNV"
                               Name 52  "v11"
-                              Name 53  "gl_HitTNVX"
+                              Name 53  "gl_HitTNV"
                               Name 56  "v12"
-                              Name 58  "gl_HitKindNVX"
+                              Name 58  "gl_HitKindNV"
                               Name 62  "v13"
-                              Name 64  "gl_ObjectToWorldNVX"
+                              Name 64  "gl_ObjectToWorldNV"
                               Name 66  "v14"
-                              Name 67  "gl_WorldToObjectNVX"
+                              Name 67  "gl_WorldToObjectNV"
                               Name 71  "incomingPayload"
-                              Decorate 11(gl_LaunchIDNVX) BuiltIn LaunchIdNVX
-                              Decorate 14(gl_LaunchSizeNVX) BuiltIn LaunchSizeNVX
+                              Decorate 11(gl_LaunchIDNV) BuiltIn LaunchIdNV
+                              Decorate 14(gl_LaunchSizeNV) BuiltIn LaunchSizeNV
                               Decorate 20(gl_PrimitiveID) BuiltIn PrimitiveId
                               Decorate 23(gl_InstanceID) BuiltIn InstanceId
-                              Decorate 26(gl_InstanceCustomIndexNVX) BuiltIn InstanceCustomIndexNVX
-                              Decorate 33(gl_WorldRayOriginNVX) BuiltIn WorldRayOriginNVX
-                              Decorate 36(gl_WorldRayDirectionNVX) BuiltIn WorldRayDirectionNVX
-                              Decorate 39(gl_ObjectRayOriginNVX) BuiltIn ObjectRayOriginNVX
-                              Decorate 42(gl_ObjectRayDirectionNVX) BuiltIn ObjectRayDirectionNVX
-                              Decorate 47(gl_RayTminNVX) BuiltIn RayTminNVX
-                              Decorate 50(gl_RayTmaxNVX) BuiltIn RayTmaxNVX
-                              Decorate 53(gl_HitTNVX) BuiltIn HitTNVX
-                              Decorate 58(gl_HitKindNVX) BuiltIn HitKindNVX
-                              Decorate 64(gl_ObjectToWorldNVX) BuiltIn ObjectToWorldNVX
-                              Decorate 67(gl_WorldToObjectNVX) BuiltIn WorldToObjectNVX
+                              Decorate 26(gl_InstanceCustomIndexNV) BuiltIn InstanceCustomIndexNV
+                              Decorate 33(gl_WorldRayOriginNV) BuiltIn WorldRayOriginNV
+                              Decorate 36(gl_WorldRayDirectionNV) BuiltIn WorldRayDirectionNV
+                              Decorate 39(gl_ObjectRayOriginNV) BuiltIn ObjectRayOriginNV
+                              Decorate 42(gl_ObjectRayDirectionNV) BuiltIn ObjectRayDirectionNV
+                              Decorate 47(gl_RayTminNV) BuiltIn RayTminNV
+                              Decorate 50(gl_RayTmaxNV) BuiltIn RayTmaxNV
+                              Decorate 53(gl_HitTNV) BuiltIn HitTNV
+                              Decorate 58(gl_HitKindNV) BuiltIn HitKindNV
+                              Decorate 64(gl_ObjectToWorldNV) BuiltIn ObjectToWorldNV
+                              Decorate 67(gl_WorldToObjectNV) BuiltIn WorldToObjectNV
                               Decorate 71(incomingPayload) Location 1
                2:             TypeVoid
                3:             TypeFunction 2
                6:             TypeInt 32 0
-               7:             TypeVector 6(int) 2
-               8:             TypePointer Function 7(ivec2)
-              10:             TypePointer Input 7(ivec2)
-11(gl_LaunchIDNVX):     10(ptr) Variable Input
-14(gl_LaunchSizeNVX):     10(ptr) Variable Input
+               7:             TypeVector 6(int) 3
+               8:             TypePointer Function 7(ivec3)
+              10:             TypePointer Input 7(ivec3)
+11(gl_LaunchIDNV):     10(ptr) Variable Input
+14(gl_LaunchSizeNV):     10(ptr) Variable Input
               16:             TypeInt 32 1
               17:             TypePointer Function 16(int)
               19:             TypePointer Input 16(int)
 20(gl_PrimitiveID):     19(ptr) Variable Input
 23(gl_InstanceID):     19(ptr) Variable Input
-26(gl_InstanceCustomIndexNVX):     19(ptr) Variable Input
+26(gl_InstanceCustomIndexNV):     19(ptr) Variable Input
               28:             TypeFloat 32
               29:             TypeVector 28(float) 3
               30:             TypePointer Function 29(fvec3)
               32:             TypePointer Input 29(fvec3)
-33(gl_WorldRayOriginNVX):     32(ptr) Variable Input
-36(gl_WorldRayDirectionNVX):     32(ptr) Variable Input
-39(gl_ObjectRayOriginNVX):     32(ptr) Variable Input
-42(gl_ObjectRayDirectionNVX):     32(ptr) Variable Input
+33(gl_WorldRayOriginNV):     32(ptr) Variable Input
+36(gl_WorldRayDirectionNV):     32(ptr) Variable Input
+39(gl_ObjectRayOriginNV):     32(ptr) Variable Input
+42(gl_ObjectRayDirectionNV):     32(ptr) Variable Input
               44:             TypePointer Function 28(float)
               46:             TypePointer Input 28(float)
-47(gl_RayTminNVX):     46(ptr) Variable Input
-50(gl_RayTmaxNVX):     46(ptr) Variable Input
-  53(gl_HitTNVX):     46(ptr) Variable Input
+47(gl_RayTminNV):     46(ptr) Variable Input
+50(gl_RayTmaxNV):     46(ptr) Variable Input
+   53(gl_HitTNV):     46(ptr) Variable Input
               55:             TypePointer Function 6(int)
               57:             TypePointer Input 6(int)
-58(gl_HitKindNVX):     57(ptr) Variable Input
+58(gl_HitKindNV):     57(ptr) Variable Input
               60:             TypeMatrix 29(fvec3) 4
               61:             TypePointer Function 60
               63:             TypePointer Input 60
-64(gl_ObjectToWorldNVX):     63(ptr) Variable Input
-67(gl_WorldToObjectNVX):     63(ptr) Variable Input
+64(gl_ObjectToWorldNV):     63(ptr) Variable Input
+67(gl_WorldToObjectNV):     63(ptr) Variable Input
               69:             TypeVector 28(float) 4
-              70:             TypePointer IncomingRayPayloadNVX 69(fvec4)
-71(incomingPayload):     70(ptr) Variable IncomingRayPayloadNVX
+              70:             TypePointer IncomingRayPayloadNV 69(fvec4)
+71(incomingPayload):     70(ptr) Variable IncomingRayPayloadNV
               72:   28(float) Constant 1056964608
               73:   69(fvec4) ConstantComposite 72 72 72 72
               75:     16(int) Constant 1
@@ -117,35 +117,35 @@ spv.AnyHitShader.rahit
          56(v12):     55(ptr) Variable Function
          62(v13):     61(ptr) Variable Function
          66(v14):     61(ptr) Variable Function
-              12:    7(ivec2) Load 11(gl_LaunchIDNVX)
+              12:    7(ivec3) Load 11(gl_LaunchIDNV)
                               Store 9(v0) 12
-              15:    7(ivec2) Load 14(gl_LaunchSizeNVX)
+              15:    7(ivec3) Load 14(gl_LaunchSizeNV)
                               Store 13(v1) 15
               21:     16(int) Load 20(gl_PrimitiveID)
                               Store 18(v2) 21
               24:     16(int) Load 23(gl_InstanceID)
                               Store 22(v3) 24
-              27:     16(int) Load 26(gl_InstanceCustomIndexNVX)
+              27:     16(int) Load 26(gl_InstanceCustomIndexNV)
                               Store 25(v4) 27
-              34:   29(fvec3) Load 33(gl_WorldRayOriginNVX)
+              34:   29(fvec3) Load 33(gl_WorldRayOriginNV)
                               Store 31(v5) 34
-              37:   29(fvec3) Load 36(gl_WorldRayDirectionNVX)
+              37:   29(fvec3) Load 36(gl_WorldRayDirectionNV)
                               Store 35(v6) 37
-              40:   29(fvec3) Load 39(gl_ObjectRayOriginNVX)
+              40:   29(fvec3) Load 39(gl_ObjectRayOriginNV)
                               Store 38(v7) 40
-              43:   29(fvec3) Load 42(gl_ObjectRayDirectionNVX)
+              43:   29(fvec3) Load 42(gl_ObjectRayDirectionNV)
                               Store 41(v8) 43
-              48:   28(float) Load 47(gl_RayTminNVX)
+              48:   28(float) Load 47(gl_RayTminNV)
                               Store 45(v9) 48
-              51:   28(float) Load 50(gl_RayTmaxNVX)
+              51:   28(float) Load 50(gl_RayTmaxNV)
                               Store 49(v10) 51
-              54:   28(float) Load 53(gl_HitTNVX)
+              54:   28(float) Load 53(gl_HitTNV)
                               Store 52(v11) 54
-              59:      6(int) Load 58(gl_HitKindNVX)
+              59:      6(int) Load 58(gl_HitKindNV)
                               Store 56(v12) 59
-              65:          60 Load 64(gl_ObjectToWorldNVX)
+              65:          60 Load 64(gl_ObjectToWorldNV)
                               Store 62(v13) 65
-              68:          60 Load 67(gl_WorldToObjectNVX)
+              68:          60 Load 67(gl_WorldToObjectNV)
                               Store 66(v14) 68
                               Store 71(incomingPayload) 73
               74:     16(int) Load 18(v2)
@@ -153,10 +153,10 @@ spv.AnyHitShader.rahit
                               SelectionMerge 79 None
                               BranchConditional 77 78 80
               78:               Label
-                                IgnoreIntersectionNVX
+                                IgnoreIntersectionNV
                                 Branch 79
               80:               Label
-                                TerminateRayNVX
+                                TerminateRayNV
                                 Branch 79
               79:             Label
                               Return

Test/baseResults/spv.AnyHitShader_Errors.rahit.out

@@ -1,7 +1,7 @@
 spv.AnyHitShader_Errors.rahit
-ERROR: 0:8: 'assign' :  l-value required "payload" (cannot modify hitAttributeNVX in this stage)
-ERROR: 0:9: 'reportIntersectionNVX' : no matching overloaded function found 
-ERROR: 0:10: 'traceNVX' : no matching overloaded function found 
+ERROR: 0:8: 'assign' :  l-value required "payload" (cannot modify hitAttributeNV in this stage)
+ERROR: 0:9: 'reportIntersectionNV' : no matching overloaded function found 
+ERROR: 0:10: 'traceNV' : no matching overloaded function found 
 ERROR: 3 compilation errors.  No code generated.
 
 

Test/baseResults/spv.ClosestHitShader.rchit.out

@@ -3,62 +3,62 @@ spv.ClosestHitShader.rchit
 // Generated by (magic number): 80007
 // Id's are bound by 88
 
-                              Capability RaytracingNVX
-                              Extension  "SPV_NVX_raytracing"
+                              Capability RayTracingNV
+                              Extension  "SPV_NV_ray_tracing"
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint ClosestHitNVX 4  "main" 11 14 20 23 26 33 36 39 42 47 50 53 58 64 67
+                              EntryPoint ClosestHitNV 4  "main" 11 14 20 23 26 33 36 39 42 47 50 53 58 64 67
                               Source GLSL 460
-                              SourceExtension  "GL_NVX_raytracing"
+                              SourceExtension  "GL_NV_ray_tracing"
                               Name 4  "main"
                               Name 9  "v0"
-                              Name 11  "gl_LaunchIDNVX"
+                              Name 11  "gl_LaunchIDNV"
                               Name 13  "v1"
-                              Name 14  "gl_LaunchSizeNVX"
+                              Name 14  "gl_LaunchSizeNV"
                               Name 18  "v2"
                               Name 20  "gl_PrimitiveID"
                               Name 22  "v3"
                               Name 23  "gl_InstanceID"
                               Name 25  "v4"
-                              Name 26  "gl_InstanceCustomIndexNVX"
+                              Name 26  "gl_InstanceCustomIndexNV"
                               Name 31  "v5"
-                              Name 33  "gl_WorldRayOriginNVX"
+                              Name 33  "gl_WorldRayOriginNV"
                               Name 35  "v6"
-                              Name 36  "gl_WorldRayDirectionNVX"
+                              Name 36  "gl_WorldRayDirectionNV"
                               Name 38  "v7"
-                              Name 39  "gl_ObjectRayOriginNVX"
+                              Name 39  "gl_ObjectRayOriginNV"
                               Name 41  "v8"
-                              Name 42  "gl_ObjectRayDirectionNVX"
+                              Name 42  "gl_ObjectRayDirectionNV"
                               Name 45  "v9"
-                              Name 47  "gl_RayTminNVX"
+                              Name 47  "gl_RayTminNV"
                               Name 49  "v10"
-                              Name 50  "gl_RayTmaxNVX"
+                              Name 50  "gl_RayTmaxNV"
                               Name 52  "v11"
-                              Name 53  "gl_HitTNVX"
+                              Name 53  "gl_HitTNV"
                               Name 56  "v12"
-                              Name 58  "gl_HitKindNVX"
+                              Name 58  "gl_HitKindNV"
                               Name 62  "v13"
-                              Name 64  "gl_ObjectToWorldNVX"
+                              Name 64  "gl_ObjectToWorldNV"
                               Name 66  "v14"
-                              Name 67  "gl_WorldToObjectNVX"
+                              Name 67  "gl_WorldToObjectNV"
                               Name 71  "accNV"
                               Name 85  "localPayload"
                               Name 87  "incomingPayload"
-                              Decorate 11(gl_LaunchIDNVX) BuiltIn LaunchIdNVX
-                              Decorate 14(gl_LaunchSizeNVX) BuiltIn LaunchSizeNVX
+                              Decorate 11(gl_LaunchIDNV) BuiltIn LaunchIdNV
+                              Decorate 14(gl_LaunchSizeNV) BuiltIn LaunchSizeNV
                               Decorate 20(gl_PrimitiveID) BuiltIn PrimitiveId
                               Decorate 23(gl_InstanceID) BuiltIn InstanceId
-                              Decorate 26(gl_InstanceCustomIndexNVX) BuiltIn InstanceCustomIndexNVX
-                              Decorate 33(gl_WorldRayOriginNVX) BuiltIn WorldRayOriginNVX
-                              Decorate 36(gl_WorldRayDirectionNVX) BuiltIn WorldRayDirectionNVX
-                              Decorate 39(gl_ObjectRayOriginNVX) BuiltIn ObjectRayOriginNVX
-                              Decorate 42(gl_ObjectRayDirectionNVX) BuiltIn ObjectRayDirectionNVX
-                              Decorate 47(gl_RayTminNVX) BuiltIn RayTminNVX
-                              Decorate 50(gl_RayTmaxNVX) BuiltIn RayTmaxNVX
-                              Decorate 53(gl_HitTNVX) BuiltIn HitTNVX
-                              Decorate 58(gl_HitKindNVX) BuiltIn HitKindNVX
-                              Decorate 64(gl_ObjectToWorldNVX) BuiltIn ObjectToWorldNVX
-                              Decorate 67(gl_WorldToObjectNVX) BuiltIn WorldToObjectNVX
+                              Decorate 26(gl_InstanceCustomIndexNV) BuiltIn InstanceCustomIndexNV
+                              Decorate 33(gl_WorldRayOriginNV) BuiltIn WorldRayOriginNV
+                              Decorate 36(gl_WorldRayDirectionNV) BuiltIn WorldRayDirectionNV
+                              Decorate 39(gl_ObjectRayOriginNV) BuiltIn ObjectRayOriginNV
+                              Decorate 42(gl_ObjectRayDirectionNV) BuiltIn ObjectRayDirectionNV
+                              Decorate 47(gl_RayTminNV) BuiltIn RayTminNV
+                              Decorate 50(gl_RayTmaxNV) BuiltIn RayTmaxNV
+                              Decorate 53(gl_HitTNV) BuiltIn HitTNV
+                              Decorate 58(gl_HitKindNV) BuiltIn HitKindNV
+                              Decorate 64(gl_ObjectToWorldNV) BuiltIn ObjectToWorldNV
+                              Decorate 67(gl_WorldToObjectNV) BuiltIn WorldToObjectNV
                               Decorate 71(accNV) DescriptorSet 0
                               Decorate 71(accNV) Binding 0
                               Decorate 85(localPayload) Location 0
@@ -66,39 +66,39 @@ spv.ClosestHitShader.rchit
                2:             TypeVoid
                3:             TypeFunction 2
                6:             TypeInt 32 0
-               7:             TypeVector 6(int) 2
-               8:             TypePointer Function 7(ivec2)
-              10:             TypePointer Input 7(ivec2)
-11(gl_LaunchIDNVX):     10(ptr) Variable Input
-14(gl_LaunchSizeNVX):     10(ptr) Variable Input
+               7:             TypeVector 6(int) 3
+               8:             TypePointer Function 7(ivec3)
+              10:             TypePointer Input 7(ivec3)
+11(gl_LaunchIDNV):     10(ptr) Variable Input
+14(gl_LaunchSizeNV):     10(ptr) Variable Input
               16:             TypeInt 32 1
               17:             TypePointer Function 16(int)
               19:             TypePointer Input 16(int)
 20(gl_PrimitiveID):     19(ptr) Variable Input
 23(gl_InstanceID):     19(ptr) Variable Input
-26(gl_InstanceCustomIndexNVX):     19(ptr) Variable Input
+26(gl_InstanceCustomIndexNV):     19(ptr) Variable Input
               28:             TypeFloat 32
               29:             TypeVector 28(float) 3
               30:             TypePointer Function 29(fvec3)
               32:             TypePointer Input 29(fvec3)
-33(gl_WorldRayOriginNVX):     32(ptr) Variable Input
-36(gl_WorldRayDirectionNVX):     32(ptr) Variable Input
-39(gl_ObjectRayOriginNVX):     32(ptr) Variable Input
-42(gl_ObjectRayDirectionNVX):     32(ptr) Variable Input
+33(gl_WorldRayOriginNV):     32(ptr) Variable Input
+36(gl_WorldRayDirectionNV):     32(ptr) Variable Input
+39(gl_ObjectRayOriginNV):     32(ptr) Variable Input
+42(gl_ObjectRayDirectionNV):     32(ptr) Variable Input
               44:             TypePointer Function 28(float)
               46:             TypePointer Input 28(float)
-47(gl_RayTminNVX):     46(ptr) Variable Input
-50(gl_RayTmaxNVX):     46(ptr) Variable Input
-  53(gl_HitTNVX):     46(ptr) Variable Input
+47(gl_RayTminNV):     46(ptr) Variable Input
+50(gl_RayTmaxNV):     46(ptr) Variable Input
+   53(gl_HitTNV):     46(ptr) Variable Input
               55:             TypePointer Function 6(int)
               57:             TypePointer Input 6(int)
-58(gl_HitKindNVX):     57(ptr) Variable Input
+58(gl_HitKindNV):     57(ptr) Variable Input
               60:             TypeMatrix 29(fvec3) 4
               61:             TypePointer Function 60
               63:             TypePointer Input 60
-64(gl_ObjectToWorldNVX):     63(ptr) Variable Input
-67(gl_WorldToObjectNVX):     63(ptr) Variable Input
-              69:             TypeAccelerationStructureNVX
+64(gl_ObjectToWorldNV):     63(ptr) Variable Input
+67(gl_WorldToObjectNV):     63(ptr) Variable Input
+              69:             TypeAccelerationStructureNV
               70:             TypePointer UniformConstant 69
        71(accNV):     70(ptr) Variable UniformConstant
               73:      6(int) Constant 0
@@ -112,10 +112,10 @@ spv.ClosestHitShader.rchit
               81:   28(float) Constant 1061158912
               82:     16(int) Constant 1
               83:             TypeVector 28(float) 4
-              84:             TypePointer RayPayloadNVX 83(fvec4)
-85(localPayload):     84(ptr) Variable RayPayloadNVX
-              86:             TypePointer IncomingRayPayloadNVX 83(fvec4)
-87(incomingPayload):     86(ptr) Variable IncomingRayPayloadNVX
+              84:             TypePointer RayPayloadNV 83(fvec4)
+85(localPayload):     84(ptr) Variable RayPayloadNV
+              86:             TypePointer IncomingRayPayloadNV 83(fvec4)
+87(incomingPayload):     86(ptr) Variable IncomingRayPayloadNV
          4(main):           2 Function None 3
                5:             Label
            9(v0):      8(ptr) Variable Function
@@ -133,37 +133,37 @@ spv.ClosestHitShader.rchit
          56(v12):     55(ptr) Variable Function
          62(v13):     61(ptr) Variable Function
          66(v14):     61(ptr) Variable Function
-              12:    7(ivec2) Load 11(gl_LaunchIDNVX)
+              12:    7(ivec3) Load 11(gl_LaunchIDNV)
                               Store 9(v0) 12
-              15:    7(ivec2) Load 14(gl_LaunchSizeNVX)
+              15:    7(ivec3) Load 14(gl_LaunchSizeNV)
                               Store 13(v1) 15
               21:     16(int) Load 20(gl_PrimitiveID)
                               Store 18(v2) 21
               24:     16(int) Load 23(gl_InstanceID)
                               Store 22(v3) 24
-              27:     16(int) Load 26(gl_InstanceCustomIndexNVX)
+              27:     16(int) Load 26(gl_InstanceCustomIndexNV)
                               Store 25(v4) 27
-              34:   29(fvec3) Load 33(gl_WorldRayOriginNVX)
+              34:   29(fvec3) Load 33(gl_WorldRayOriginNV)
                               Store 31(v5) 34
-              37:   29(fvec3) Load 36(gl_WorldRayDirectionNVX)
+              37:   29(fvec3) Load 36(gl_WorldRayDirectionNV)
                               Store 35(v6) 37
-              40:   29(fvec3) Load 39(gl_ObjectRayOriginNVX)
+              40:   29(fvec3) Load 39(gl_ObjectRayOriginNV)
                               Store 38(v7) 40
-              43:   29(fvec3) Load 42(gl_ObjectRayDirectionNVX)
+              43:   29(fvec3) Load 42(gl_ObjectRayDirectionNV)
                               Store 41(v8) 43
-              48:   28(float) Load 47(gl_RayTminNVX)
+              48:   28(float) Load 47(gl_RayTminNV)
                               Store 45(v9) 48
-              51:   28(float) Load 50(gl_RayTmaxNVX)
+              51:   28(float) Load 50(gl_RayTmaxNV)
                               Store 49(v10) 51
-              54:   28(float) Load 53(gl_HitTNVX)
+              54:   28(float) Load 53(gl_HitTNV)
                               Store 52(v11) 54
-              59:      6(int) Load 58(gl_HitKindNVX)
+              59:      6(int) Load 58(gl_HitKindNV)
                               Store 56(v12) 59
-              65:          60 Load 64(gl_ObjectToWorldNVX)
+              65:          60 Load 64(gl_ObjectToWorldNV)
                               Store 62(v13) 65
-              68:          60 Load 67(gl_WorldToObjectNVX)
+              68:          60 Load 67(gl_WorldToObjectNV)
                               Store 66(v14) 68
               72:          69 Load 71(accNV)
-                              TraceNVX 72 73 74 75 76 73 78 77 80 81 82
+                              TraceNV 72 73 74 75 76 73 78 77 80 81 82
                               Return
                               FunctionEnd

Test/baseResults/spv.ClosestHitShader_Errors.rchit.out

@@ -1,8 +1,8 @@
 spv.ClosestHitShader_Errors.rchit
-ERROR: 0:8: 'assign' :  l-value required "payload" (cannot modify hitAttributeNVX in this stage)
-ERROR: 0:9: 'reportIntersectionNVX' : no matching overloaded function found 
-ERROR: 0:10: 'terminateRayNVX' : no matching overloaded function found 
-ERROR: 0:11: 'ignoreIntersectionNVX' : no matching overloaded function found 
+ERROR: 0:8: 'assign' :  l-value required "payload" (cannot modify hitAttributeNV in this stage)
+ERROR: 0:9: 'reportIntersectionNV' : no matching overloaded function found 
+ERROR: 0:10: 'terminateRayNV' : no matching overloaded function found 
+ERROR: 0:11: 'ignoreIntersectionNV' : no matching overloaded function found 
 ERROR: 4 compilation errors.  No code generated.
 
 

Test/baseResults/spv.IntersectShader.rint.out

@@ -3,88 +3,88 @@ spv.IntersectShader.rint
 // Generated by (magic number): 80007
 // Id's are bound by 71
 
-                              Capability RaytracingNVX
-                              Extension  "SPV_NVX_raytracing"
+                              Capability RayTracingNV
+                              Extension  "SPV_NV_ray_tracing"
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint IntersectionNVX 4  "main" 11 14 20 23 26 33 36 39 42 47 50 56 59
+                              EntryPoint IntersectionNV 4  "main" 11 14 20 23 26 33 36 39 42 47 50 56 59
                               Source GLSL 460
-                              SourceExtension  "GL_NVX_raytracing"
+                              SourceExtension  "GL_NV_ray_tracing"
                               Name 4  "main"
                               Name 9  "v0"
-                              Name 11  "gl_LaunchIDNVX"
+                              Name 11  "gl_LaunchIDNV"
                               Name 13  "v1"
-                              Name 14  "gl_LaunchSizeNVX"
+                              Name 14  "gl_LaunchSizeNV"
                               Name 18  "v2"
                               Name 20  "gl_PrimitiveID"
                               Name 22  "v3"
                               Name 23  "gl_InstanceID"
                               Name 25  "v4"
-                              Name 26  "gl_InstanceCustomIndexNVX"
+                              Name 26  "gl_InstanceCustomIndexNV"
                               Name 31  "v5"
-                              Name 33  "gl_WorldRayOriginNVX"
+                              Name 33  "gl_WorldRayOriginNV"
                               Name 35  "v6"
-                              Name 36  "gl_WorldRayDirectionNVX"
+                              Name 36  "gl_WorldRayDirectionNV"
                               Name 38  "v7"
-                              Name 39  "gl_ObjectRayOriginNVX"
+                              Name 39  "gl_ObjectRayOriginNV"
                               Name 41  "v8"
-                              Name 42  "gl_ObjectRayDirectionNVX"
+                              Name 42  "gl_ObjectRayDirectionNV"
                               Name 45  "v9"
-                              Name 47  "gl_RayTminNVX"
+                              Name 47  "gl_RayTminNV"
                               Name 49  "v10"
-                              Name 50  "gl_RayTmaxNVX"
+                              Name 50  "gl_RayTmaxNV"
                               Name 54  "v11"
-                              Name 56  "gl_ObjectToWorldNVX"
+                              Name 56  "gl_ObjectToWorldNV"
                               Name 58  "v12"
-                              Name 59  "gl_WorldToObjectNVX"
+                              Name 59  "gl_WorldToObjectNV"
                               Name 63  "iAttr"
-                              Decorate 11(gl_LaunchIDNVX) BuiltIn LaunchIdNVX
-                              Decorate 14(gl_LaunchSizeNVX) BuiltIn LaunchSizeNVX
+                              Decorate 11(gl_LaunchIDNV) BuiltIn LaunchIdNV
+                              Decorate 14(gl_LaunchSizeNV) BuiltIn LaunchSizeNV
                               Decorate 20(gl_PrimitiveID) BuiltIn PrimitiveId
                               Decorate 23(gl_InstanceID) BuiltIn InstanceId
-                              Decorate 26(gl_InstanceCustomIndexNVX) BuiltIn InstanceCustomIndexNVX
-                              Decorate 33(gl_WorldRayOriginNVX) BuiltIn WorldRayOriginNVX
-                              Decorate 36(gl_WorldRayDirectionNVX) BuiltIn WorldRayDirectionNVX
-                              Decorate 39(gl_ObjectRayOriginNVX) BuiltIn ObjectRayOriginNVX
-                              Decorate 42(gl_ObjectRayDirectionNVX) BuiltIn ObjectRayDirectionNVX
-                              Decorate 47(gl_RayTminNVX) BuiltIn RayTminNVX
-                              Decorate 50(gl_RayTmaxNVX) BuiltIn RayTmaxNVX
-                              Decorate 56(gl_ObjectToWorldNVX) BuiltIn ObjectToWorldNVX
-                              Decorate 59(gl_WorldToObjectNVX) BuiltIn WorldToObjectNVX
+                              Decorate 26(gl_InstanceCustomIndexNV) BuiltIn InstanceCustomIndexNV
+                              Decorate 33(gl_WorldRayOriginNV) BuiltIn WorldRayOriginNV
+                              Decorate 36(gl_WorldRayDirectionNV) BuiltIn WorldRayDirectionNV
+                              Decorate 39(gl_ObjectRayOriginNV) BuiltIn ObjectRayOriginNV
+                              Decorate 42(gl_ObjectRayDirectionNV) BuiltIn ObjectRayDirectionNV
+                              Decorate 47(gl_RayTminNV) BuiltIn RayTminNV
+                              Decorate 50(gl_RayTmaxNV) BuiltIn RayTmaxNV
+                              Decorate 56(gl_ObjectToWorldNV) BuiltIn ObjectToWorldNV
+                              Decorate 59(gl_WorldToObjectNV) BuiltIn WorldToObjectNV
                2:             TypeVoid
                3:             TypeFunction 2
                6:             TypeInt 32 0
-               7:             TypeVector 6(int) 2
-               8:             TypePointer Function 7(ivec2)
-              10:             TypePointer Input 7(ivec2)
-11(gl_LaunchIDNVX):     10(ptr) Variable Input
-14(gl_LaunchSizeNVX):     10(ptr) Variable Input
+               7:             TypeVector 6(int) 3
+               8:             TypePointer Function 7(ivec3)
+              10:             TypePointer Input 7(ivec3)
+11(gl_LaunchIDNV):     10(ptr) Variable Input
+14(gl_LaunchSizeNV):     10(ptr) Variable Input
               16:             TypeInt 32 1
               17:             TypePointer Function 16(int)
               19:             TypePointer Input 16(int)
 20(gl_PrimitiveID):     19(ptr) Variable Input
 23(gl_InstanceID):     19(ptr) Variable Input
-26(gl_InstanceCustomIndexNVX):     19(ptr) Variable Input
+26(gl_InstanceCustomIndexNV):     19(ptr) Variable Input
               28:             TypeFloat 32
               29:             TypeVector 28(float) 3
               30:             TypePointer Function 29(fvec3)
               32:             TypePointer Input 29(fvec3)
-33(gl_WorldRayOriginNVX):     32(ptr) Variable Input
-36(gl_WorldRayDirectionNVX):     32(ptr) Variable Input
-39(gl_ObjectRayOriginNVX):     32(ptr) Variable Input
-42(gl_ObjectRayDirectionNVX):     32(ptr) Variable Input
+33(gl_WorldRayOriginNV):     32(ptr) Variable Input
+36(gl_WorldRayDirectionNV):     32(ptr) Variable Input
+39(gl_ObjectRayOriginNV):     32(ptr) Variable Input
+42(gl_ObjectRayDirectionNV):     32(ptr) Variable Input
               44:             TypePointer Function 28(float)
               46:             TypePointer Input 28(float)
-47(gl_RayTminNVX):     46(ptr) Variable Input
-50(gl_RayTmaxNVX):     46(ptr) Variable Input
+47(gl_RayTminNV):     46(ptr) Variable Input
+50(gl_RayTmaxNV):     46(ptr) Variable Input
               52:             TypeMatrix 29(fvec3) 4
               53:             TypePointer Function 52
               55:             TypePointer Input 52
-56(gl_ObjectToWorldNVX):     55(ptr) Variable Input
-59(gl_WorldToObjectNVX):     55(ptr) Variable Input
+56(gl_ObjectToWorldNV):     55(ptr) Variable Input
+59(gl_WorldToObjectNV):     55(ptr) Variable Input
               61:             TypeVector 28(float) 4
-              62:             TypePointer HitAttributeNVX 61(fvec4)
-       63(iAttr):     62(ptr) Variable HitAttributeNVX
+              62:             TypePointer HitAttributeNV 61(fvec4)
+       63(iAttr):     62(ptr) Variable HitAttributeNV
               64:   28(float) Constant 1056964608
               65:   28(float) Constant 0
               66:   28(float) Constant 1065353216
@@ -106,33 +106,33 @@ spv.IntersectShader.rint
          49(v10):     44(ptr) Variable Function
          54(v11):     53(ptr) Variable Function
          58(v12):     53(ptr) Variable Function
-              12:    7(ivec2) Load 11(gl_LaunchIDNVX)
+              12:    7(ivec3) Load 11(gl_LaunchIDNV)
                               Store 9(v0) 12
-              15:    7(ivec2) Load 14(gl_LaunchSizeNVX)
+              15:    7(ivec3) Load 14(gl_LaunchSizeNV)
                               Store 13(v1) 15
               21:     16(int) Load 20(gl_PrimitiveID)
                               Store 18(v2) 21
               24:     16(int) Load 23(gl_InstanceID)
                               Store 22(v3) 24
-              27:     16(int) Load 26(gl_InstanceCustomIndexNVX)
+              27:     16(int) Load 26(gl_InstanceCustomIndexNV)
                               Store 25(v4) 27
-              34:   29(fvec3) Load 33(gl_WorldRayOriginNVX)
+              34:   29(fvec3) Load 33(gl_WorldRayOriginNV)
                               Store 31(v5) 34
-              37:   29(fvec3) Load 36(gl_WorldRayDirectionNVX)
+              37:   29(fvec3) Load 36(gl_WorldRayDirectionNV)
                               Store 35(v6) 37
-              40:   29(fvec3) Load 39(gl_ObjectRayOriginNVX)
+              40:   29(fvec3) Load 39(gl_ObjectRayOriginNV)
                               Store 38(v7) 40
-              43:   29(fvec3) Load 42(gl_ObjectRayDirectionNVX)
+              43:   29(fvec3) Load 42(gl_ObjectRayDirectionNV)
                               Store 41(v8) 43
-              48:   28(float) Load 47(gl_RayTminNVX)
+              48:   28(float) Load 47(gl_RayTminNV)
                               Store 45(v9) 48
-              51:   28(float) Load 50(gl_RayTmaxNVX)
+              51:   28(float) Load 50(gl_RayTmaxNV)
                               Store 49(v10) 51
-              57:          52 Load 56(gl_ObjectToWorldNVX)
+              57:          52 Load 56(gl_ObjectToWorldNV)
                               Store 54(v11) 57
-              60:          52 Load 59(gl_WorldToObjectNVX)
+              60:          52 Load 59(gl_WorldToObjectNV)
                               Store 58(v12) 60
                               Store 63(iAttr) 67
-              70:    69(bool) ReportIntersectionNVX 64 68
+              70:    69(bool) ReportIntersectionNV 64 68
                               Return
                               FunctionEnd

Test/baseResults/spv.IntersectShader_Errors.rint.out

@@ -1,9 +1,9 @@
 spv.IntersectShader_Errors.rint
-ERROR: 0:3: 'rayPayloadInNVX' : not supported in this stage: intersection
-ERROR: 0:4: 'rayPayloadNVX' : not supported in this stage: intersection
-ERROR: 0:8: 'gl_HitTNVX' : undeclared identifier 
-ERROR: 0:9: 'gl_HitKindNVX' : undeclared identifier 
-ERROR: 0:10: 'traceNVX' : no matching overloaded function found 
+ERROR: 0:3: 'rayPayloadInNV' : not supported in this stage: intersection
+ERROR: 0:4: 'rayPayloadNV' : not supported in this stage: intersection
+ERROR: 0:8: 'gl_HitTNV' : undeclared identifier 
+ERROR: 0:9: 'gl_HitKindNV' : undeclared identifier 
+ERROR: 0:10: 'traceNV' : no matching overloaded function found 
 ERROR: 5 compilation errors.  No code generated.
 
 

Test/baseResults/spv.MissShader.rmiss.out

@@ -3,41 +3,41 @@ spv.MissShader.rmiss
 // Generated by (magic number): 80007
 // Id's are bound by 60
 
-                              Capability RaytracingNVX
-                              Extension  "SPV_NVX_raytracing"
+                              Capability RayTracingNV
+                              Extension  "SPV_NV_ray_tracing"
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint MissNVX 4  "main" 11 14 21 24 27 30 35 38
+                              EntryPoint MissNV 4  "main" 11 14 21 24 27 30 35 38
                               Source GLSL 460
-                              SourceExtension  "GL_NVX_raytracing"
+                              SourceExtension  "GL_NV_ray_tracing"
                               Name 4  "main"
                               Name 9  "v0"
-                              Name 11  "gl_LaunchIDNVX"
+                              Name 11  "gl_LaunchIDNV"
                               Name 13  "v1"
-                              Name 14  "gl_LaunchSizeNVX"
+                              Name 14  "gl_LaunchSizeNV"
                               Name 19  "v2"
-                              Name 21  "gl_WorldRayOriginNVX"
+                              Name 21  "gl_WorldRayOriginNV"
                               Name 23  "v3"
-                              Name 24  "gl_WorldRayDirectionNVX"
+                              Name 24  "gl_WorldRayDirectionNV"
                               Name 26  "v4"
-                              Name 27  "gl_ObjectRayOriginNVX"
+                              Name 27  "gl_ObjectRayOriginNV"
                               Name 29  "v5"
-                              Name 30  "gl_ObjectRayDirectionNVX"
+                              Name 30  "gl_ObjectRayDirectionNV"
                               Name 33  "v6"
-                              Name 35  "gl_RayTminNVX"
+                              Name 35  "gl_RayTminNV"
                               Name 37  "v7"
-                              Name 38  "gl_RayTmaxNVX"
+                              Name 38  "gl_RayTmaxNV"
                               Name 42  "accNV"
                               Name 57  "localPayload"
                               Name 59  "incomingPayload"
-                              Decorate 11(gl_LaunchIDNVX) BuiltIn LaunchIdNVX
-                              Decorate 14(gl_LaunchSizeNVX) BuiltIn LaunchSizeNVX
-                              Decorate 21(gl_WorldRayOriginNVX) BuiltIn WorldRayOriginNVX
-                              Decorate 24(gl_WorldRayDirectionNVX) BuiltIn WorldRayDirectionNVX
-                              Decorate 27(gl_ObjectRayOriginNVX) BuiltIn ObjectRayOriginNVX
-                              Decorate 30(gl_ObjectRayDirectionNVX) BuiltIn ObjectRayDirectionNVX
-                              Decorate 35(gl_RayTminNVX) BuiltIn RayTminNVX
-                              Decorate 38(gl_RayTmaxNVX) BuiltIn RayTmaxNVX
+                              Decorate 11(gl_LaunchIDNV) BuiltIn LaunchIdNV
+                              Decorate 14(gl_LaunchSizeNV) BuiltIn LaunchSizeNV
+                              Decorate 21(gl_WorldRayOriginNV) BuiltIn WorldRayOriginNV
+                              Decorate 24(gl_WorldRayDirectionNV) BuiltIn WorldRayDirectionNV
+                              Decorate 27(gl_ObjectRayOriginNV) BuiltIn ObjectRayOriginNV
+                              Decorate 30(gl_ObjectRayDirectionNV) BuiltIn ObjectRayDirectionNV
+                              Decorate 35(gl_RayTminNV) BuiltIn RayTminNV
+                              Decorate 38(gl_RayTmaxNV) BuiltIn RayTmaxNV
                               Decorate 42(accNV) DescriptorSet 0
                               Decorate 42(accNV) Binding 0
                               Decorate 57(localPayload) Location 0
@@ -45,24 +45,24 @@ spv.MissShader.rmiss
                2:             TypeVoid
                3:             TypeFunction 2
                6:             TypeInt 32 0
-               7:             TypeVector 6(int) 2
-               8:             TypePointer Function 7(ivec2)
-              10:             TypePointer Input 7(ivec2)
-11(gl_LaunchIDNVX):     10(ptr) Variable Input
-14(gl_LaunchSizeNVX):     10(ptr) Variable Input
+               7:             TypeVector 6(int) 3
+               8:             TypePointer Function 7(ivec3)
+              10:             TypePointer Input 7(ivec3)
+11(gl_LaunchIDNV):     10(ptr) Variable Input
+14(gl_LaunchSizeNV):     10(ptr) Variable Input
               16:             TypeFloat 32
               17:             TypeVector 16(float) 3
               18:             TypePointer Function 17(fvec3)
               20:             TypePointer Input 17(fvec3)
-21(gl_WorldRayOriginNVX):     20(ptr) Variable Input
-24(gl_WorldRayDirectionNVX):     20(ptr) Variable Input
-27(gl_ObjectRayOriginNVX):     20(ptr) Variable Input
-30(gl_ObjectRayDirectionNVX):     20(ptr) Variable Input
+21(gl_WorldRayOriginNV):     20(ptr) Variable Input
+24(gl_WorldRayDirectionNV):     20(ptr) Variable Input
+27(gl_ObjectRayOriginNV):     20(ptr) Variable Input
+30(gl_ObjectRayDirectionNV):     20(ptr) Variable Input
               32:             TypePointer Function 16(float)
               34:             TypePointer Input 16(float)
-35(gl_RayTminNVX):     34(ptr) Variable Input
-38(gl_RayTmaxNVX):     34(ptr) Variable Input
-              40:             TypeAccelerationStructureNVX
+35(gl_RayTminNV):     34(ptr) Variable Input
+38(gl_RayTmaxNV):     34(ptr) Variable Input
+              40:             TypeAccelerationStructureNV
               41:             TypePointer UniformConstant 40
        42(accNV):     41(ptr) Variable UniformConstant
               44:      6(int) Constant 0
@@ -77,10 +77,10 @@ spv.MissShader.rmiss
               53:             TypeInt 32 1
               54:     53(int) Constant 1
               55:             TypeVector 16(float) 4
-              56:             TypePointer RayPayloadNVX 55(fvec4)
-57(localPayload):     56(ptr) Variable RayPayloadNVX
-              58:             TypePointer IncomingRayPayloadNVX 55(fvec4)
-59(incomingPayload):     58(ptr) Variable IncomingRayPayloadNVX
+              56:             TypePointer RayPayloadNV 55(fvec4)
+57(localPayload):     56(ptr) Variable RayPayloadNV
+              58:             TypePointer IncomingRayPayloadNV 55(fvec4)
+59(incomingPayload):     58(ptr) Variable IncomingRayPayloadNV
          4(main):           2 Function None 3
                5:             Label
            9(v0):      8(ptr) Variable Function
@@ -91,23 +91,23 @@ spv.MissShader.rmiss
           29(v5):     18(ptr) Variable Function
           33(v6):     32(ptr) Variable Function
           37(v7):     32(ptr) Variable Function
-              12:    7(ivec2) Load 11(gl_LaunchIDNVX)
+              12:    7(ivec3) Load 11(gl_LaunchIDNV)
                               Store 9(v0) 12
-              15:    7(ivec2) Load 14(gl_LaunchSizeNVX)
+              15:    7(ivec3) Load 14(gl_LaunchSizeNV)
                               Store 13(v1) 15
-              22:   17(fvec3) Load 21(gl_WorldRayOriginNVX)
+              22:   17(fvec3) Load 21(gl_WorldRayOriginNV)
                               Store 19(v2) 22
-              25:   17(fvec3) Load 24(gl_WorldRayDirectionNVX)
+              25:   17(fvec3) Load 24(gl_WorldRayDirectionNV)
                               Store 23(v3) 25
-              28:   17(fvec3) Load 27(gl_ObjectRayOriginNVX)
+              28:   17(fvec3) Load 27(gl_ObjectRayOriginNV)
                               Store 26(v4) 28
-              31:   17(fvec3) Load 30(gl_ObjectRayDirectionNVX)
+              31:   17(fvec3) Load 30(gl_ObjectRayDirectionNV)
                               Store 29(v5) 31
-              36:   16(float) Load 35(gl_RayTminNVX)
+              36:   16(float) Load 35(gl_RayTminNV)
                               Store 33(v6) 36
-              39:   16(float) Load 38(gl_RayTmaxNVX)
+              39:   16(float) Load 38(gl_RayTmaxNV)
                               Store 37(v7) 39
               43:          40 Load 42(accNV)
-                              TraceNVX 43 44 45 46 47 44 49 48 51 52 54
+                              TraceNV 43 44 45 46 47 44 49 48 51 52 54
                               Return
                               FunctionEnd

Test/baseResults/spv.MissShader_Errors.rmiss.out

@@ -1,20 +1,20 @@
 spv.MissShader_Errors.rmiss
-ERROR: 0:3: 'hitAttributeNVX' : not supported in this stage: miss
+ERROR: 0:3: 'hitAttributeNV' : not supported in this stage: miss
 ERROR: 0:6: 'gl_PrimitiveID' : undeclared identifier 
 ERROR: 0:6: '=' :  cannot convert from ' temp float' to ' temp highp int'
 ERROR: 0:7: 'gl_InstanceID' : undeclared identifier (Did you mean gl_InstanceIndex?)
 ERROR: 0:7: '=' :  cannot convert from ' temp float' to ' temp highp int'
-ERROR: 0:8: 'gl_InstanceCustomIndexNVX' : undeclared identifier 
+ERROR: 0:8: 'gl_InstanceCustomIndexNV' : undeclared identifier 
 ERROR: 0:8: '=' :  cannot convert from ' temp float' to ' temp highp int'
-ERROR: 0:9: 'gl_ObjectToWorldNVX' : undeclared identifier 
+ERROR: 0:9: 'gl_ObjectToWorldNV' : undeclared identifier 
 ERROR: 0:9: '=' :  cannot convert from ' temp float' to ' temp highp 4X3 matrix of float'
-ERROR: 0:10: 'gl_WorldToObjectNVX' : undeclared identifier 
+ERROR: 0:10: 'gl_WorldToObjectNV' : undeclared identifier 
 ERROR: 0:10: '=' :  cannot convert from ' temp float' to ' temp highp 4X3 matrix of float'
-ERROR: 0:11: 'gl_HitTNVX' : undeclared identifier 
-ERROR: 0:12: 'gl_HitKindNVX' : undeclared identifier 
-ERROR: 0:13: 'reportIntersectionNVX' : no matching overloaded function found 
-ERROR: 0:14: 'ignoreIntersectionNVX' : no matching overloaded function found 
-ERROR: 0:15: 'terminateRayNVX' : no matching overloaded function found 
+ERROR: 0:11: 'gl_HitTNV' : undeclared identifier 
+ERROR: 0:12: 'gl_HitKindNV' : undeclared identifier 
+ERROR: 0:13: 'reportIntersectionNV' : no matching overloaded function found 
+ERROR: 0:14: 'ignoreIntersectionNV' : no matching overloaded function found 
+ERROR: 0:15: 'terminateRayNV' : no matching overloaded function found 
 ERROR: 16 compilation errors.  No code generated.
 
 

Test/baseResults/spv.RayCallable.rcall.out

@@ -0,0 +1,73 @@
+spv.RayCallable.rcall
+// Module Version 10000
+// Generated by (magic number): 80007
+// Id's are bound by 38
+
+                              Capability RayTracingNV
+                              Extension  "SPV_NV_ray_tracing"
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint CallableNV 4  "main" 11 14 19
+                              Source GLSL 460
+                              SourceExtension  "GL_NV_ray_tracing"
+                              Name 4  "main"
+                              Name 9  "id"
+                              Name 11  "gl_LaunchIDNV"
+                              Name 13  "size"
+                              Name 14  "gl_LaunchSizeNV"
+                              Name 17  "curFlags"
+                              Name 19  "gl_IncomingRayFlagsNV"
+                              Name 24  "dataBlock"
+                              MemberName 24(dataBlock) 0  "data1"
+                              Name 26  ""
+                              Name 37  "data0"
+                              Decorate 11(gl_LaunchIDNV) BuiltIn LaunchIdNV
+                              Decorate 14(gl_LaunchSizeNV) BuiltIn LaunchSizeNV
+                              Decorate 19(gl_IncomingRayFlagsNV) BuiltIn IncomingRayFlagsNV
+                              Decorate 24(dataBlock) Block
+                              Decorate 26 Location 1
+                              Decorate 37(data0) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeInt 32 0
+               7:             TypeVector 6(int) 3
+               8:             TypePointer Function 7(ivec3)
+              10:             TypePointer Input 7(ivec3)
+11(gl_LaunchIDNV):     10(ptr) Variable Input
+14(gl_LaunchSizeNV):     10(ptr) Variable Input
+              16:             TypePointer Function 6(int)
+              18:             TypePointer Input 6(int)
+19(gl_IncomingRayFlagsNV):     18(ptr) Variable Input
+              22:      6(int) Constant 1
+   24(dataBlock):             TypeStruct 6(int)
+              25:             TypePointer IncomingCallableDataNV 24(dataBlock)
+              26:     25(ptr) Variable IncomingCallableDataNV
+              27:             TypeInt 32 1
+              28:     27(int) Constant 0
+              29:      6(int) Constant 256
+              30:             TypePointer IncomingCallableDataNV 6(int)
+              32:      6(int) Constant 2
+              33:     27(int) Constant 1
+              34:             TypeFloat 32
+              35:             TypeVector 34(float) 4
+              36:             TypePointer CallableDataNV 35(fvec4)
+       37(data0):     36(ptr) Variable CallableDataNV
+         4(main):           2 Function None 3
+               5:             Label
+           9(id):      8(ptr) Variable Function
+        13(size):      8(ptr) Variable Function
+    17(curFlags):     16(ptr) Variable Function
+              12:    7(ivec3) Load 11(gl_LaunchIDNV)
+                              Store 9(id) 12
+              15:    7(ivec3) Load 14(gl_LaunchSizeNV)
+                              Store 13(size) 15
+              20:      6(int) Load 19(gl_IncomingRayFlagsNV)
+                              Store 17(curFlags) 20
+              21:      6(int) Load 17(curFlags)
+              23:      6(int) BitwiseAnd 21 22
+                              Store 17(curFlags) 23
+              31:     30(ptr) AccessChain 26 28
+                              Store 31 29
+                              ExecuteCallableNV 32 33
+                              Return
+                              FunctionEnd

Test/baseResults/spv.RayCallable_Errors.rcall.out

@@ -0,0 +1,33 @@
+spv.RayCallable_Errors.rcall
+ERROR: 0:3: 'hitAttributeNV' : not supported in this stage: callable
+ERROR: 0:4: 'rayPayloadNV' : not supported in this stage: callable
+ERROR: 0:5: 'rayPayloadInNV' : not supported in this stage: callable
+ERROR: 0:9: 'gl_PrimitiveID' : undeclared identifier 
+ERROR: 0:9: '=' :  cannot convert from ' temp float' to ' temp highp int'
+ERROR: 0:10: 'gl_InstanceID' : undeclared identifier (Did you mean gl_InstanceIndex?)
+ERROR: 0:10: '=' :  cannot convert from ' temp float' to ' temp highp int'
+ERROR: 0:11: 'gl_InstanceCustomIndexNV' : undeclared identifier 
+ERROR: 0:11: '=' :  cannot convert from ' temp float' to ' temp highp int'
+ERROR: 0:12: 'gl_WorldRayOriginNV' : undeclared identifier 
+ERROR: 0:12: '=' :  cannot convert from ' temp float' to ' temp highp 3-component vector of float'
+ERROR: 0:13: 'gl_WorldRayDirectionNV' : undeclared identifier 
+ERROR: 0:13: '=' :  cannot convert from ' temp float' to ' temp highp 3-component vector of float'
+ERROR: 0:14: 'gl_ObjectRayOriginNV' : undeclared identifier 
+ERROR: 0:14: '=' :  cannot convert from ' temp float' to ' temp highp 3-component vector of float'
+ERROR: 0:15: 'gl_ObjectRayDirectionNV' : undeclared identifier 
+ERROR: 0:15: '=' :  cannot convert from ' temp float' to ' temp highp 3-component vector of float'
+ERROR: 0:16: 'gl_RayTminNV' : undeclared identifier 
+ERROR: 0:17: 'gl_RayTmaxNV' : undeclared identifier 
+ERROR: 0:18: 'gl_ObjectToWorldNV' : undeclared identifier 
+ERROR: 0:18: '=' :  cannot convert from ' temp float' to ' temp highp 4X3 matrix of float'
+ERROR: 0:19: 'gl_WorldToObjectNV' : undeclared identifier 
+ERROR: 0:19: '=' :  cannot convert from ' temp float' to ' temp highp 4X3 matrix of float'
+ERROR: 0:20: 'gl_HitTNV' : undeclared identifier 
+ERROR: 0:21: 'gl_HitKindNV' : undeclared identifier 
+ERROR: 0:22: 'reportIntersectionNV' : no matching overloaded function found 
+ERROR: 0:23: 'ignoreIntersectionNV' : no matching overloaded function found 
+ERROR: 0:24: 'terminateRayNV' : no matching overloaded function found 
+ERROR: 28 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link

Test/baseResults/spv.RayConstants.rgen.out

@@ -3,13 +3,13 @@ spv.RayConstants.rgen
 // Generated by (magic number): 80007
 // Id's are bound by 27
 
-                              Capability RaytracingNVX
-                              Extension  "SPV_NVX_raytracing"
+                              Capability RayTracingNV
+                              Extension  "SPV_NV_ray_tracing"
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint RayGenerationNVX 4  "main"
+                              EntryPoint RayGenerationNV 4  "main"
                               Source GLSL 460
-                              SourceExtension  "GL_NVX_raytracing"
+                              SourceExtension  "GL_NV_ray_tracing"
                               Name 4  "main"
                               Name 8  "accNV"
                               Name 26  "payload"
@@ -18,7 +18,7 @@ spv.RayConstants.rgen
                               Decorate 26(payload) Location 0
                2:             TypeVoid
                3:             TypeFunction 2
-               6:             TypeAccelerationStructureNVX
+               6:             TypeAccelerationStructureNV
                7:             TypePointer UniformConstant 6
         8(accNV):      7(ptr) Variable UniformConstant
               10:             TypeInt 32 0
@@ -36,11 +36,11 @@ spv.RayConstants.rgen
               22:             TypeInt 32 1
               23:     22(int) Constant 1
               24:             TypeVector 14(float) 4
-              25:             TypePointer RayPayloadNVX 24(fvec4)
-     26(payload):     25(ptr) Variable RayPayloadNVX
+              25:             TypePointer RayPayloadNV 24(fvec4)
+     26(payload):     25(ptr) Variable RayPayloadNV
          4(main):           2 Function None 3
                5:             Label
                9:           6 Load 8(accNV)
-                              TraceNVX 9 11 12 13 13 12 17 18 20 21 23
+                              TraceNV 9 11 12 13 13 12 17 18 20 21 23
                               Return
                               FunctionEnd

Test/baseResults/spv.RayGenShader.rgen.out

@@ -3,19 +3,19 @@ spv.RayGenShader.rgen
 // Generated by (magic number): 80007
 // Id's are bound by 60
 
-                              Capability RaytracingNVX
-                              Extension  "SPV_NVX_raytracing"
+                              Capability RayTracingNV
+                              Extension  "SPV_NV_ray_tracing"
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint RayGenerationNVX 4  "main" 11 21
+                              EntryPoint RayGenerationNV 4  "main" 11 21
                               Source GLSL 460
-                              SourceExtension  "GL_NVX_raytracing"
+                              SourceExtension  "GL_NV_ray_tracing"
                               Name 4  "main"
                               Name 8  "lx"
-                              Name 11  "gl_LaunchIDNVX"
+                              Name 11  "gl_LaunchIDNV"
                               Name 16  "ly"
                               Name 20  "sx"
-                              Name 21  "gl_LaunchSizeNVX"
+                              Name 21  "gl_LaunchSizeNV"
                               Name 24  "sy"
                               Name 29  "accNV"
                               Name 48  "block"
@@ -23,8 +23,8 @@ spv.RayGenShader.rgen
                               MemberName 48(block) 1  "pad"
                               Name 50  ""
                               Name 56  "payload"
-                              Decorate 11(gl_LaunchIDNVX) BuiltIn LaunchIdNVX
-                              Decorate 21(gl_LaunchSizeNVX) BuiltIn LaunchSizeNVX
+                              Decorate 11(gl_LaunchIDNV) BuiltIn LaunchIdNV
+                              Decorate 21(gl_LaunchSizeNV) BuiltIn LaunchSizeNV
                               Decorate 29(accNV) DescriptorSet 0
                               Decorate 29(accNV) Binding 0
                               Decorate 46 ArrayStride 4
@@ -36,14 +36,14 @@ spv.RayGenShader.rgen
                3:             TypeFunction 2
                6:             TypeInt 32 0
                7:             TypePointer Function 6(int)
-               9:             TypeVector 6(int) 2
-              10:             TypePointer Input 9(ivec2)
-11(gl_LaunchIDNVX):     10(ptr) Variable Input
+               9:             TypeVector 6(int) 3
+              10:             TypePointer Input 9(ivec3)
+11(gl_LaunchIDNV):     10(ptr) Variable Input
               12:      6(int) Constant 0
               13:             TypePointer Input 6(int)
               17:      6(int) Constant 1
-21(gl_LaunchSizeNVX):     10(ptr) Variable Input
-              27:             TypeAccelerationStructureNVX
+21(gl_LaunchSizeNV):     10(ptr) Variable Input
+              27:             TypeAccelerationStructureNV
               28:             TypePointer UniformConstant 27
        29(accNV):     28(ptr) Variable UniformConstant
               35:             TypeFloat 32
@@ -60,30 +60,30 @@ spv.RayGenShader.rgen
               46:             TypeArray 35(float) 45
               47:             TypeVector 35(float) 4
        48(block):             TypeStruct 46 47(fvec4)
-              49:             TypePointer ShaderRecordBufferNVX 48(block)
-              50:     49(ptr) Variable ShaderRecordBufferNVX
+              49:             TypePointer ShaderRecordBufferNV 48(block)
+              50:     49(ptr) Variable ShaderRecordBufferNV
               51:     43(int) Constant 0
               52:     43(int) Constant 3
-              53:             TypePointer ShaderRecordBufferNVX 35(float)
-              55:             TypePointer RayPayloadNVX 47(fvec4)
-     56(payload):     55(ptr) Variable RayPayloadNVX
-              58:             TypePointer ShaderRecordBufferNVX 47(fvec4)
+              53:             TypePointer ShaderRecordBufferNV 35(float)
+              55:             TypePointer RayPayloadNV 47(fvec4)
+     56(payload):     55(ptr) Variable RayPayloadNV
+              58:             TypePointer ShaderRecordBufferNV 47(fvec4)
          4(main):           2 Function None 3
                5:             Label
            8(lx):      7(ptr) Variable Function
           16(ly):      7(ptr) Variable Function
           20(sx):      7(ptr) Variable Function
           24(sy):      7(ptr) Variable Function
-              14:     13(ptr) AccessChain 11(gl_LaunchIDNVX) 12
+              14:     13(ptr) AccessChain 11(gl_LaunchIDNV) 12
               15:      6(int) Load 14
                               Store 8(lx) 15
-              18:     13(ptr) AccessChain 11(gl_LaunchIDNVX) 17
+              18:     13(ptr) AccessChain 11(gl_LaunchIDNV) 17
               19:      6(int) Load 18
                               Store 16(ly) 19
-              22:     13(ptr) AccessChain 21(gl_LaunchSizeNVX) 12
+              22:     13(ptr) AccessChain 21(gl_LaunchSizeNV) 12
               23:      6(int) Load 22
                               Store 20(sx) 23
-              25:     13(ptr) AccessChain 21(gl_LaunchSizeNVX) 17
+              25:     13(ptr) AccessChain 21(gl_LaunchSizeNV) 17
               26:      6(int) Load 25
                               Store 24(sy) 26
               30:          27 Load 29(accNV)
@@ -91,7 +91,7 @@ spv.RayGenShader.rgen
               32:      6(int) Load 16(ly)
               33:      6(int) Load 20(sx)
               34:      6(int) Load 24(sy)
-                              TraceNVX 30 31 32 33 34 12 38 39 41 42 44
+                              TraceNV 30 31 32 33 34 12 38 39 41 42 44
               54:     53(ptr) AccessChain 50 51 52
                               Store 54 40
               57:   47(fvec4) Load 56(payload)

Test/baseResults/spv.RayGenShader_Errors.rgen.out

@@ -1,39 +1,39 @@
 spv.RayGenShader_Errors.rgen
-ERROR: 0:3: 'hitAttributeNVX' : not supported in this stage: ray-generation
-ERROR: 0:4: 'rayPayloadInNVX' : not supported in this stage: ray-generation
-ERROR: 0:5: 'shaderRecordNVX' : can only be used with a buffer 
-ERROR: 0:9: 'binding' : cannot be used with shaderRecordNVX 
-ERROR: 0:12: 'set' : cannot be used with shaderRecordNVX 
-ERROR: 0:23: 'accelerationStructureNVX' : accelerationStructureNVX can only be used in uniform variables or function parameters: a
-ERROR: 0:23: '=' :  cannot convert from ' const int' to ' temp accelerationStructureNVX'
+ERROR: 0:3: 'hitAttributeNV' : not supported in this stage: ray-generation
+ERROR: 0:4: 'rayPayloadInNV' : not supported in this stage: ray-generation
+ERROR: 0:5: 'shaderRecordNV' : can only be used with a buffer 
+ERROR: 0:9: 'binding' : cannot be used with shaderRecordNV 
+ERROR: 0:12: 'set' : cannot be used with shaderRecordNV 
+ERROR: 0:23: 'accelerationStructureNV' : accelerationStructureNV can only be used in uniform variables or function parameters: a
+ERROR: 0:23: '=' :  cannot convert from ' const int' to ' temp accelerationStructureNV'
 ERROR: 0:24: 'gl_PrimitiveID' : undeclared identifier 
 ERROR: 0:24: '=' :  cannot convert from ' temp float' to ' temp highp int'
 ERROR: 0:25: 'gl_InstanceID' : undeclared identifier (Did you mean gl_InstanceIndex?)
 ERROR: 0:25: '=' :  cannot convert from ' temp float' to ' temp highp int'
-ERROR: 0:26: 'gl_InstanceCustomIndexNVX' : undeclared identifier 
+ERROR: 0:26: 'gl_InstanceCustomIndexNV' : undeclared identifier 
 ERROR: 0:26: '=' :  cannot convert from ' temp float' to ' temp highp int'
-ERROR: 0:27: 'gl_WorldRayOriginNVX' : undeclared identifier 
+ERROR: 0:27: 'gl_WorldRayOriginNV' : undeclared identifier 
 ERROR: 0:27: '=' :  cannot convert from ' temp float' to ' temp highp 3-component vector of float'
-ERROR: 0:28: 'gl_WorldRayDirectionNVX' : undeclared identifier 
+ERROR: 0:28: 'gl_WorldRayDirectionNV' : undeclared identifier 
 ERROR: 0:28: '=' :  cannot convert from ' temp float' to ' temp highp 3-component vector of float'
-ERROR: 0:29: 'gl_ObjectRayOriginNVX' : undeclared identifier 
+ERROR: 0:29: 'gl_ObjectRayOriginNV' : undeclared identifier 
 ERROR: 0:29: '=' :  cannot convert from ' temp float' to ' temp highp 3-component vector of float'
-ERROR: 0:30: 'gl_ObjectRayDirectionNVX' : undeclared identifier 
+ERROR: 0:30: 'gl_ObjectRayDirectionNV' : undeclared identifier 
 ERROR: 0:30: '=' :  cannot convert from ' temp float' to ' temp highp 3-component vector of float'
-ERROR: 0:31: 'gl_RayTminNVX' : undeclared identifier 
-ERROR: 0:32: 'gl_RayTmaxNVX' : undeclared identifier 
-ERROR: 0:33: 'gl_ObjectToWorldNVX' : undeclared identifier 
+ERROR: 0:31: 'gl_RayTminNV' : undeclared identifier 
+ERROR: 0:32: 'gl_RayTmaxNV' : undeclared identifier 
+ERROR: 0:33: 'gl_ObjectToWorldNV' : undeclared identifier 
 ERROR: 0:33: '=' :  cannot convert from ' temp float' to ' temp highp 4X3 matrix of float'
-ERROR: 0:34: 'gl_WorldToObjectNVX' : undeclared identifier 
+ERROR: 0:34: 'gl_WorldToObjectNV' : undeclared identifier 
 ERROR: 0:34: '=' :  cannot convert from ' temp float' to ' temp highp 4X3 matrix of float'
-ERROR: 0:35: 'gl_HitTNVX' : undeclared identifier 
-ERROR: 0:36: 'gl_HitKindNVX' : undeclared identifier 
-ERROR: 0:37: 'reportIntersectionNVX' : no matching overloaded function found 
-ERROR: 0:38: 'ignoreIntersectionNVX' : no matching overloaded function found 
-ERROR: 0:39: 'terminateRayNVX' : no matching overloaded function found 
+ERROR: 0:35: 'gl_HitTNV' : undeclared identifier 
+ERROR: 0:36: 'gl_HitKindNV' : undeclared identifier 
+ERROR: 0:37: 'reportIntersectionNV' : no matching overloaded function found 
+ERROR: 0:38: 'ignoreIntersectionNV' : no matching overloaded function found 
+ERROR: 0:39: 'terminateRayNV' : no matching overloaded function found 
 ERROR: 32 compilation errors.  No code generated.
 
 
-ERROR: Linking ray-generation stage: Only one shaderRecordNVX buffer block is allowed per stage
+ERROR: Linking ray-generation stage: Only one shaderRecordNV buffer block is allowed per stage
 
 SPIR-V is not generated for failed compile or link

Test/spv.AnyHitShader.rahit

@@ -1,26 +1,26 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-layout(location = 1) rayPayloadInNVX vec4 incomingPayload;
+#extension GL_NV_ray_tracing : enable
+layout(location = 1) rayPayloadInNV vec4 incomingPayload;
 void main()
 {
-	uvec2 v0 = gl_LaunchIDNVX;
-	uvec2 v1 = gl_LaunchSizeNVX;
+	uvec3 v0 = gl_LaunchIDNV;
+	uvec3 v1 = gl_LaunchSizeNV;
 	int v2 = gl_PrimitiveID;
 	int v3 = gl_InstanceID;
-	int v4 = gl_InstanceCustomIndexNVX;
-	vec3 v5 = gl_WorldRayOriginNVX;
-	vec3 v6 = gl_WorldRayDirectionNVX;
-	vec3 v7 = gl_ObjectRayOriginNVX;
-	vec3 v8 = gl_ObjectRayDirectionNVX;
-	float v9 = gl_RayTminNVX;
-	float v10 = gl_RayTmaxNVX;
-	float v11 = gl_HitTNVX;
-	uint v12 = gl_HitKindNVX;
-	mat4x3 v13 = gl_ObjectToWorldNVX;
-	mat4x3 v14 = gl_WorldToObjectNVX;
+	int v4 = gl_InstanceCustomIndexNV;
+	vec3 v5 = gl_WorldRayOriginNV;
+	vec3 v6 = gl_WorldRayDirectionNV;
+	vec3 v7 = gl_ObjectRayOriginNV;
+	vec3 v8 = gl_ObjectRayDirectionNV;
+	float v9 = gl_RayTminNV;
+	float v10 = gl_RayTmaxNV;
+	float v11 = gl_HitTNV;
+	uint v12 = gl_HitKindNV;
+	mat4x3 v13 = gl_ObjectToWorldNV;
+	mat4x3 v14 = gl_WorldToObjectNV;
 	incomingPayload = vec4(0.5f);
 	if (v2 == 1)
-	    ignoreIntersectionNVX();
+	    ignoreIntersectionNV();
 	else
-	    terminateRayNVX();
+	    terminateRayNV();
 }

Test/spv.AnyHitShader_Errors.rahit

@@ -1,11 +1,11 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-hitAttributeNVX vec4 payload;                               
-layout(binding = 0, set = 0) uniform accelerationStructureNVX accNV;
+#extension GL_NV_ray_tracing : enable
+hitAttributeNV vec4 payload;                               
+layout(binding = 0, set = 0) uniform accelerationStructureNV accNV;
 
 void main()
 {
-    payload.x = 1.0f;                                       // ERROR, cannot write to hitattributeNVX in stage
-    reportIntersectionNVX(1.0, 1U);                         // ERROR, unsupported builtin in stage
-    traceNVX(accNV, 0, 0, 1, 1, 0, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, 0); // ERROR, unsupported builtin in stage
+    payload.x = 1.0f;                                       // ERROR, cannot write to hitattributeNV in stage
+    reportIntersectionNV(1.0, 1U);                          // ERROR, unsupported builtin in stage
+    traceNV(accNV, 0, 0, 1, 1, 0, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, 0); // ERROR, unsupported builtin in stage
 }

Test/spv.ClosestHitShader.rchit

@@ -1,24 +1,24 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-layout(binding = 0, set = 0) uniform accelerationStructureNVX accNV;
-layout(location = 0) rayPayloadNVX vec4 localPayload;
-layout(location = 1) rayPayloadInNVX vec4 incomingPayload;
+#extension GL_NV_ray_tracing : enable
+layout(binding = 0, set = 0) uniform accelerationStructureNV accNV;
+layout(location = 0) rayPayloadNV vec4 localPayload;
+layout(location = 1) rayPayloadInNV vec4 incomingPayload;
 void main()
 {
-	uvec2 v0 = gl_LaunchIDNVX;
-	uvec2 v1 = gl_LaunchSizeNVX;
+	uvec3 v0 = gl_LaunchIDNV;
+	uvec3 v1 = gl_LaunchSizeNV;
 	int v2 = gl_PrimitiveID;
 	int v3 = gl_InstanceID;
-	int v4 = gl_InstanceCustomIndexNVX;
-	vec3 v5 = gl_WorldRayOriginNVX;
-	vec3 v6 = gl_WorldRayDirectionNVX;
-	vec3 v7 = gl_ObjectRayOriginNVX;
-	vec3 v8 = gl_ObjectRayDirectionNVX;
-	float v9 = gl_RayTminNVX;
-	float v10 = gl_RayTmaxNVX;
-	float v11 = gl_HitTNVX;
-	uint v12 = gl_HitKindNVX;
-	mat4x3 v13 = gl_ObjectToWorldNVX;
-	mat4x3 v14 = gl_WorldToObjectNVX;
-	traceNVX(accNV, 0u, 1u, 2u, 3u, 0u, vec3(0.5f), 0.5f, vec3(1.0f), 0.75f, 1);
+	int v4 = gl_InstanceCustomIndexNV;
+	vec3 v5 = gl_WorldRayOriginNV;
+	vec3 v6 = gl_WorldRayDirectionNV;
+	vec3 v7 = gl_ObjectRayOriginNV;
+	vec3 v8 = gl_ObjectRayDirectionNV;
+	float v9 = gl_RayTminNV;
+	float v10 = gl_RayTmaxNV;
+	float v11 = gl_HitTNV;
+	uint v12 = gl_HitKindNV;
+	mat4x3 v13 = gl_ObjectToWorldNV;
+	mat4x3 v14 = gl_WorldToObjectNV;
+	traceNV(accNV, 0u, 1u, 2u, 3u, 0u, vec3(0.5f), 0.5f, vec3(1.0f), 0.75f, 1);
 }

Test/spv.ClosestHitShader_Errors.rchit

@@ -1,12 +1,12 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-hitAttributeNVX vec4 payload;                               
-layout(binding = 0, set = 0) uniform accelerationStructureNVX accNV;
+#extension GL_NV_ray_tracing : enable
+hitAttributeNV vec4 payload;
+layout(binding = 0, set = 0) uniform accelerationStructureNV accNV;
 
 void main()
 {
-    payload.x = 1.0f;                                       // ERROR, cannot write to hitattributeNVX in stage
-    reportIntersectionNVX(1.0, 1U);                         // ERROR, unsupported builtin in stage 
-    terminateRayNVX();
-    ignoreIntersectionNVX();
+    payload.x = 1.0f;                                       // ERROR, cannot write to hitattributeNV in stage
+    reportIntersectionNV(1.0, 1U);                          // ERROR, unsupported builtin in stage 
+    terminateRayNV();
+    ignoreIntersectionNV();
 }

Test/spv.IntersectShader.rint

@@ -1,21 +1,21 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-hitAttributeNVX vec4 iAttr;
+#extension GL_NV_ray_tracing : enable
+hitAttributeNV vec4 iAttr;
 void main()
 {
-	uvec2 v0 = gl_LaunchIDNVX;
-	uvec2 v1 = gl_LaunchSizeNVX;
+	uvec3 v0 = gl_LaunchIDNV;
+	uvec3 v1 = gl_LaunchSizeNV;
 	int v2 = gl_PrimitiveID;
 	int v3 = gl_InstanceID;
-	int v4 = gl_InstanceCustomIndexNVX;
-	vec3 v5 = gl_WorldRayOriginNVX;
-	vec3 v6 = gl_WorldRayDirectionNVX;
-	vec3 v7 = gl_ObjectRayOriginNVX;
-	vec3 v8 = gl_ObjectRayDirectionNVX;
-	float v9 = gl_RayTminNVX;
-	float v10 = gl_RayTmaxNVX;
-	mat4x3 v11 = gl_ObjectToWorldNVX;
-	mat4x3 v12 = gl_WorldToObjectNVX;
+	int v4 = gl_InstanceCustomIndexNV;
+	vec3 v5 = gl_WorldRayOriginNV;
+	vec3 v6 = gl_WorldRayDirectionNV;
+	vec3 v7 = gl_ObjectRayOriginNV;
+	vec3 v8 = gl_ObjectRayDirectionNV;
+	float v9 = gl_RayTminNV;
+	float v10 = gl_RayTmaxNV;
+	mat4x3 v11 = gl_ObjectToWorldNV;
+	mat4x3 v12 = gl_WorldToObjectNV;
 	iAttr = vec4(0.5f,0.5f,0.0f,1.0f);
-	reportIntersectionNVX(0.5, 1U);
+	reportIntersectionNV(0.5, 1U);
 }

Test/spv.IntersectShader_Errors.rint

@@ -1,11 +1,11 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-rayPayloadInNVX vec4 payloadIn;                             // ERROR, rayPayloadIn unsupported in this stage
-rayPayloadNVX vec4 payload;                                 // ERROR, rayPayload unsuppoted in this stage
-uniform accelerationStructureNVX accNV;
+#extension GL_NV_ray_tracing : enable
+rayPayloadInNV vec4 payloadIn;                             // ERROR, rayPayloadIn unsupported in this stage
+rayPayloadNV vec4 payload;                                 // ERROR, rayPayload unsuppoted in this stage
+uniform accelerationStructureNV accNV;
 void main()
 {
-    float e12 = gl_HitTNVX;                                 // ERROR, unsupported builtin in stage
-    float e13 = gl_HitKindNVX;                              // ERROR, unsupported builtin in stage
-    traceNVX(accNV, 0, 0, 1, 1, 0, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, 0); // ERROR, unsupported
+    float e12 = gl_HitTNV;                                 // ERROR, unsupported builtin in stage
+    float e13 = gl_HitKindNV;                              // ERROR, unsupported builtin in stage
+    traceNV(accNV, 0, 0, 1, 1, 0, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, 0); // ERROR, unsupported
 }

Test/spv.MissShader.rmiss

@@ -1,17 +1,17 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-layout(binding = 0, set = 0) uniform accelerationStructureNVX accNV;
-layout(location = 0) rayPayloadNVX vec4 localPayload;
-layout(location = 1) rayPayloadInNVX vec4 incomingPayload;
+#extension GL_NV_ray_tracing : enable
+layout(binding = 0, set = 0) uniform accelerationStructureNV accNV;
+layout(location = 0) rayPayloadNV vec4 localPayload;
+layout(location = 1) rayPayloadInNV vec4 incomingPayload;
 void main()
 {
-	uvec2 v0 = gl_LaunchIDNVX;
-	uvec2 v1 = gl_LaunchSizeNVX;
-	vec3 v2 = gl_WorldRayOriginNVX;
-	vec3 v3 = gl_WorldRayDirectionNVX;
-	vec3 v4 = gl_ObjectRayOriginNVX;
-	vec3 v5 = gl_ObjectRayDirectionNVX;
-	float v6 = gl_RayTminNVX;
-	float v7 = gl_RayTmaxNVX;
-	traceNVX(accNV, 0u, 1u, 2u, 3u, 0u, vec3(0.5f), 0.5f, vec3(1.0f), 0.75f, 1);
+	uvec3 v0 = gl_LaunchIDNV;
+	uvec3 v1 = gl_LaunchSizeNV;
+	vec3 v2 = gl_WorldRayOriginNV;
+	vec3 v3 = gl_WorldRayDirectionNV;
+	vec3 v4 = gl_ObjectRayOriginNV;
+	vec3 v5 = gl_ObjectRayDirectionNV;
+	float v6 = gl_RayTminNV;
+	float v7 = gl_RayTmaxNV;
+	traceNV(accNV, 0u, 1u, 2u, 3u, 0u, vec3(0.5f), 0.5f, vec3(1.0f), 0.75f, 1);
 }

Test/spv.MissShader_Errors.rmiss

@@ -1,16 +1,16 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-hitAttributeNVX vec4 payload;                               // ERROR, hitattributeNVX unsupported in this stage 
+#extension GL_NV_ray_tracing : enable
+hitAttributeNV vec4 payload;                               // ERROR, hitattributeNV unsupported in this stage 
 void main()
 {
-    int e0 = gl_PrimitiveID;                                // ERROR, unsupported builtin in stage
-    int e1 = gl_InstanceID;                                 // ERROR, unsupported builtin in stage
-    int e3 = gl_InstanceCustomIndexNVX;                     // ERROR, unsupported builtin in stage
-    mat4x3 e10 = gl_ObjectToWorldNVX;                       // ERROR, unsupported builtin in stage
-    mat4x3 e11 = gl_WorldToObjectNVX;                       // ERROR, unsupported builtin in stage
-    float e12 = gl_HitTNVX;                                 // ERROR, unsupported builtin in stage
-    float e13 = gl_HitKindNVX;                              // ERROR, unsupported builtin in stage
-    reportIntersectionNVX(1.0, 1U);                         // ERROR, unsupported builtin in stage
-    ignoreIntersectionNVX();                                // ERROR, unsupported builtin in stage
-    terminateRayNVX();                                      // ERROR, unsupported builtin in stage
+    int e0 = gl_PrimitiveID;                               // ERROR, unsupported builtin in stage
+    int e1 = gl_InstanceID;                                // ERROR, unsupported builtin in stage
+    int e3 = gl_InstanceCustomIndexNV;                     // ERROR, unsupported builtin in stage
+    mat4x3 e10 = gl_ObjectToWorldNV;                       // ERROR, unsupported builtin in stage
+    mat4x3 e11 = gl_WorldToObjectNV;                       // ERROR, unsupported builtin in stage
+    float e12 = gl_HitTNV;                                 // ERROR, unsupported builtin in stage
+    float e13 = gl_HitKindNV;                              // ERROR, unsupported builtin in stage
+    reportIntersectionNV(1.0, 1U);                         // ERROR, unsupported builtin in stage
+    ignoreIntersectionNV();                                // ERROR, unsupported builtin in stage
+    terminateRayNV();                                      // ERROR, unsupported builtin in stage
 }

Test/spv.RayCallable.rcall

@@ -0,0 +1,15 @@
+#version 460
+#extension GL_NV_ray_tracing : enable
+layout(location = 0) callableDataNV vec4 data0;
+layout(location = 1) callableDataInNV dataBlock {
+	uint data1;
+};
+void main()
+{
+	uvec3 id = gl_LaunchIDNV;
+	uvec3 size = gl_LaunchSizeNV;
+    uint curFlags = gl_IncomingRayFlagsNV;
+	curFlags = curFlags & gl_RayFlagsOpaqueNV;
+	data1 = 256U;
+	executeCallableNV(2,1);
+}

Test/spv.RayCallable_Errors.rcall

@@ -0,0 +1,25 @@
+#version 460
+#extension GL_NV_ray_tracing : enable
+hitAttributeNV vec4 hitattr;                                // ERROR, hitattributeNV unsupported in this stage 
+rayPayloadNV vec4 payload;                                  // ERROR, rayPayloadNV unsupported in this stage
+rayPayloadInNV vec4 payloadIn;                              // ERROR, rayPayloadInNV unsupported in this stage
+
+void main()
+{
+    int e0 = gl_PrimitiveID;                                // ERROR, unsupported builtin in stage
+    int e1 = gl_InstanceID;                                 // ERROR, unsupported builtin in stage
+    int e3 = gl_InstanceCustomIndexNV;                      // ERROR, unsupported builtin in stage
+    vec3 e4 = gl_WorldRayOriginNV;                          // ERROR, unsupported builtin in stage
+    vec3 e5 = gl_WorldRayDirectionNV;                       // ERROR, unsupported builtin in stage
+    vec3 e6 = gl_ObjectRayOriginNV;                         // ERROR, unsupported builtin in stage
+    vec3 e7 = gl_ObjectRayDirectionNV;                      // ERROR, unsupported builtin in stage
+    float e8 = gl_RayTminNV;                                // ERROR, unsupported builtin in stage
+    float e9 = gl_RayTmaxNV;                                // ERROR, unsupported builtin in stage
+    mat4x3 e10 = gl_ObjectToWorldNV;                        // ERROR, unsupported builtin in stage
+    mat4x3 e11 = gl_WorldToObjectNV;                        // ERROR, unsupported builtin in stage
+    float e12 = gl_HitTNV;                                  // ERROR, unsupported builtin in stage
+    float e13 = gl_HitKindNV;                               // ERROR, unsupported builtin in stage
+    reportIntersectionNV(1.0, 1U);                          // ERROR, unsupported builtin in stage
+    ignoreIntersectionNV();                                 // ERROR, unsupported builtin in stage
+    terminateRayNV();                                       // ERROR, unsupported builtin in stage
+}

Test/spv.RayConstants.rgen

@@ -1,15 +1,15 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-layout(binding = 0, set = 0) uniform accelerationStructureNVX accNV;
-layout(location = 0) rayPayloadNVX vec4 payload;
+#extension GL_NV_ray_tracing : enable
+layout(binding = 0, set = 0) uniform accelerationStructureNV accNV;
+layout(location = 0) rayPayloadNV vec4 payload;
 void main()
 {
-    const uint rayFlags = gl_RayFlagsNoneNVX | gl_RayFlagsOpaqueNVX |
-                          gl_RayFlagsNoOpaqueNVX | gl_RayFlagsTerminateOnFirstHitNVX |
-                          gl_RayFlagsSkipClosestHitShaderNVX | gl_RayFlagsCullBackFacingTrianglesNVX |
-                          gl_RayFlagsCullFrontFacingTrianglesNVX | gl_RayFlagsCullOpaqueNVX | 
-                          gl_RayFlagsCullNoOpaqueNVX;
+    const uint rayFlags = gl_RayFlagsNoneNV | gl_RayFlagsOpaqueNV |
+                          gl_RayFlagsNoOpaqueNV | gl_RayFlagsTerminateOnFirstHitNV |
+                          gl_RayFlagsSkipClosestHitShaderNV | gl_RayFlagsCullBackFacingTrianglesNV |
+                          gl_RayFlagsCullFrontFacingTrianglesNV | gl_RayFlagsCullOpaqueNV | 
+                          gl_RayFlagsCullNoOpaqueNV;
 
     const int payloadId = 1;
-    traceNVX(accNV, rayFlags, 0, 1, 1, 0, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, payloadId);
+    traceNV(accNV, rayFlags, 0, 1, 1, 0, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, payloadId);
 }

Test/spv.RayGenShader.rgen

@@ -1,19 +1,19 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-layout(binding = 0, set = 0) uniform accelerationStructureNVX accNV;
-layout(location = 0) rayPayloadNVX vec4 payload;
-layout(shaderRecordNVX) buffer block
+#extension GL_NV_ray_tracing : enable
+layout(binding = 0, set = 0) uniform accelerationStructureNV accNV;
+layout(location = 0) rayPayloadNV vec4 payload;
+layout(shaderRecordNV) buffer block
 {
 	float arr[4];
 	vec4 pad;
 };
 void main()
 {
-    uint lx = gl_LaunchIDNVX.x;
-    uint ly = gl_LaunchIDNVX.y;
-    uint sx = gl_LaunchSizeNVX.x;
-    uint sy = gl_LaunchSizeNVX.y;
-    traceNVX(accNV, lx, ly, sx, sy, 0u, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, 1);
+    uint lx = gl_LaunchIDNV.x;
+    uint ly = gl_LaunchIDNV.y;
+    uint sx = gl_LaunchSizeNV.x;
+    uint sy = gl_LaunchSizeNV.y;
+    traceNV(accNV, lx, ly, sx, sy, 0u, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, 1);
     arr[3] = 1.0f;
     pad = payload;
 }

Test/spv.RayGenShader_Errors.rgen

@@ -1,40 +1,40 @@
 #version 460
-#extension GL_NVX_raytracing : enable
-hitAttributeNVX vec4 payload;                               // ERROR, hitattributeNVX unsupported in this stage 
-rayPayloadInNVX vec4 payloadIn;                             // ERROR, rayPayloadIn unsupported in this stage
-layout(shaderRecordNVX) uniform ublock                      // ERROR, shaderRecordNVX unsupported on uniform blocks
+#extension GL_NV_ray_tracing : enable
+hitAttributeNV vec4 payload;                                // ERROR, hitattributeNV unsupported in this stage 
+rayPayloadInNV vec4 payloadIn;                              // ERROR, rayPayloadIn unsupported in this stage
+layout(shaderRecordNV) uniform ublock                       // ERROR, shaderRecordNV unsupported on uniform blocks
 {
     float a;
 };
-layout(binding = 0, shaderRecordNVX) buffer bblock {        // ERROR, binding unsupported on shaderRecordNVX blocks
+layout(binding = 0, shaderRecordNV) buffer bblock {         // ERROR, binding unsupported on shaderRecordNV blocks
     float b;
 };
-layout(set = 0, shaderRecordNVX) buffer bblock2 {           // ERROR, set unsupported on shaderRecordNVX blocks
+layout(set = 0, shaderRecordNV) buffer bblock2 {            // ERROR, set unsupported on shaderRecordNV blocks
     float c;
 };
-layout(shaderRecordNVX) buffer bblock3 {
+layout(shaderRecordNV) buffer bblock3 {
     float d;
 };
-layout(shaderRecordNVX) buffer bblock4 {                    // ERROR, cannot have more than one shaderRecordNVX block
+layout(shaderRecordNV) buffer bblock4 {                     // ERROR, cannot have more than one shaderRecordNVX block
     float e;
 };
 void main()
 {
-    accelerationStructureNVX a = 0;
+    accelerationStructureNV a = 0;
     int e0 = gl_PrimitiveID;                                // ERROR, unsupported builtin in stage
     int e1 = gl_InstanceID;                                 // ERROR, unsupported builtin in stage
-    int e3 = gl_InstanceCustomIndexNVX;                     // ERROR, unsupported builtin in stage
-    vec3 e4 = gl_WorldRayOriginNVX;                         // ERROR, unsupported builtin in stage
-    vec3 e5 = gl_WorldRayDirectionNVX;                      // ERROR, unsupported builtin in stage
-    vec3 e6 = gl_ObjectRayOriginNVX;                        // ERROR, unsupported builtin in stage
-    vec3 e7 = gl_ObjectRayDirectionNVX;                     // ERROR, unsupported builtin in stage
-    float e8 = gl_RayTminNVX;                               // ERROR, unsupported builtin in stage
-    float e9 = gl_RayTmaxNVX;                               // ERROR, unsupported builtin in stage
-    mat4x3 e10 = gl_ObjectToWorldNVX;                       // ERROR, unsupported builtin in stage
-    mat4x3 e11 = gl_WorldToObjectNVX;                       // ERROR, unsupported builtin in stage
-    float e12 = gl_HitTNVX;                                 // ERROR, unsupported builtin in stage
-    float e13 = gl_HitKindNVX;                              // ERROR, unsupported builtin in stage
-    reportIntersectionNVX(1.0, 1U);                         // ERROR, unsupported builtin in stage
-    ignoreIntersectionNVX();                                // ERROR, unsupported builtin in stage
-    terminateRayNVX();                                      // ERROR, unsupported builtin in stage
+    int e3 = gl_InstanceCustomIndexNV;                      // ERROR, unsupported builtin in stage
+    vec3 e4 = gl_WorldRayOriginNV;                          // ERROR, unsupported builtin in stage
+    vec3 e5 = gl_WorldRayDirectionNV;                       // ERROR, unsupported builtin in stage
+    vec3 e6 = gl_ObjectRayOriginNV;                         // ERROR, unsupported builtin in stage
+    vec3 e7 = gl_ObjectRayDirectionNV;                      // ERROR, unsupported builtin in stage
+    float e8 = gl_RayTminNV;                                // ERROR, unsupported builtin in stage
+    float e9 = gl_RayTmaxNV;                                // ERROR, unsupported builtin in stage
+    mat4x3 e10 = gl_ObjectToWorldNV;                        // ERROR, unsupported builtin in stage
+    mat4x3 e11 = gl_WorldToObjectNV;                        // ERROR, unsupported builtin in stage
+    float e12 = gl_HitTNV;                                  // ERROR, unsupported builtin in stage
+    float e13 = gl_HitKindNV;                               // ERROR, unsupported builtin in stage
+    reportIntersectionNV(1.0, 1U);                          // ERROR, unsupported builtin in stage
+    ignoreIntersectionNV();                                 // ERROR, unsupported builtin in stage
+    terminateRayNV();                                       // ERROR, unsupported builtin in stage
 }

glslang/Include/BaseTypes.h

@@ -96,6 +96,8 @@ enum TStorageQualifier {
     EvqPayloadNV,
     EvqPayloadInNV,
     EvqHitAttrNV,
+    EvqCallableDataNV,
+    EvqCallableDataInNV,
 #endif
 
     // parameters
@@ -253,6 +255,7 @@ enum TBuiltInVariable {
     EbvHitKindNV,
     EbvObjectToWorldNV,
     EbvWorldToObjectNV,
+    EbvIncomingRayFlagsNV,
     EbvBaryCoordNV,
     EbvBaryCoordNoPerspNV,
     EbvTaskCountNV,
@@ -310,9 +313,11 @@ __inline const char* GetStorageQualifierString(TStorageQualifier q)
     case EvqFragColor:      return "fragColor";      break;
     case EvqFragDepth:      return "gl_FragDepth";   break;
 #ifdef NV_EXTENSIONS
-    case EvqPayloadNV:      return "rayPayloadNVX";   break;
-    case EvqPayloadInNV:    return "rayPayloadInNVX"; break;
-    case EvqHitAttrNV:      return "hitAttributeNVX"; break;
+    case EvqPayloadNV:        return "rayPayloadNV";     break;
+    case EvqPayloadInNV:      return "rayPayloadInNV";   break;
+    case EvqHitAttrNV:        return "hitAttributeNV";   break;
+    case EvqCallableDataNV:   return "callableDataNV";   break;
+    case EvqCallableDataInNV: return "callableDataInNV"; break;
 #endif
     default:                return "unknown qualifier";
     }
@@ -408,19 +413,21 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v)
     case EbvFragFullyCoveredNV:         return "FragFullyCoveredNV";
     case EbvFragmentSizeNV:             return "FragmentSizeNV";
     case EbvInvocationsPerPixelNV:      return "InvocationsPerPixelNV";
-    case EbvLaunchIdNV:                 return "LaunchIdNVX";
-    case EbvLaunchSizeNV:               return "LaunchSizeNVX";
-    case EbvInstanceCustomIndexNV:      return "InstanceCustomIndexNVX";
-    case EbvWorldRayOriginNV:           return "WorldRayOriginNVX";
-    case EbvWorldRayDirectionNV:        return "WorldRayDirectionNVX";
-    case EbvObjectRayOriginNV:          return "ObjectRayOriginNVX";
-    case EbvObjectRayDirectionNV:       return "ObjectRayDirectionNVX";
-    case EbvRayTminNV:                  return "ObjectRayTminNVX";
-    case EbvRayTmaxNV:                  return "ObjectRayTmaxNVX";
-    case EbvHitTNV:                     return "HitTNVX";
-    case EbvHitKindNV:                  return "HitKindNVX";
-    case EbvObjectToWorldNV:            return "ObjectToWorldNVX";
-    case EbvWorldToObjectNV:            return "WorldToObjectNVX";
+    case EbvLaunchIdNV:                 return "LaunchIdNV";
+    case EbvLaunchSizeNV:               return "LaunchSizeNV";
+    case EbvInstanceCustomIndexNV:      return "InstanceCustomIndexNV";
+    case EbvWorldRayOriginNV:           return "WorldRayOriginNV";
+    case EbvWorldRayDirectionNV:        return "WorldRayDirectionNV";
+    case EbvObjectRayOriginNV:          return "ObjectRayOriginNV";
+    case EbvObjectRayDirectionNV:       return "ObjectRayDirectionNV";
+    case EbvRayTminNV:                  return "ObjectRayTminNV";
+    case EbvRayTmaxNV:                  return "ObjectRayTmaxNV";
+    case EbvHitTNV:                     return "HitTNV";
+    case EbvHitKindNV:                  return "HitKindNV";
+    case EbvIncomingRayFlagsNV:         return "IncomingRayFlagsNV";
+    case EbvObjectToWorldNV:            return "ObjectToWorldNV";
+    case EbvWorldToObjectNV:            return "WorldToObjectNV";
+
     case EbvBaryCoordNV:                return "BaryCoordNV";
     case EbvBaryCoordNoPerspNV:         return "BaryCoordNoPerspNV";
     case EbvTaskCountNV:                return "TaskCountNV";

glslang/Include/Types.h

@@ -1684,7 +1684,7 @@ public:
         case EbtStruct:            return "structure";
         case EbtBlock:             return "block";
 #ifdef NV_EXTENSIONS
-        case EbtAccStructNV:       return "accelerationStructureNVX";
+        case EbtAccStructNV:       return "accelerationStructureNV";
 #endif
         default:                   return "unknown type";
         }
@@ -1782,7 +1782,7 @@ public:
                     appendInt(qualifier.layoutSecondaryViewportRelativeOffset);
                 }
                 if (qualifier.layoutShaderRecordNV)
-                    appendStr(" shaderRecordNVX");
+                    appendStr(" shaderRecordNV");
 #endif
 
                 appendStr(")");

glslang/Include/intermediate.h

@@ -898,6 +898,7 @@ enum TOperator {
     EOpReportIntersectionNV,
     EOpIgnoreIntersectionNV,
     EOpTerminateRayNV,
+    EOpExecuteCallableNV,
     EOpWritePackedPrimitiveIndices4x8NV,
 #endif
     //

glslang/MachineIndependent/Initialize.cpp

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

glslang/MachineIndependent/ParseContextBase.cpp

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

glslang/MachineIndependent/ParseHelper.cpp

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

glslang/MachineIndependent/Scan.cpp

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

glslang/MachineIndependent/ShaderLang.cpp

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

glslang/MachineIndependent/Versions.cpp

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

glslang/MachineIndependent/Versions.h

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

glslang/MachineIndependent/glslang.y

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

glslang/MachineIndependent/glslang_tab.cpp.h

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

glslang/MachineIndependent/intermOut.cpp

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

glslang/MachineIndependent/linkValidate.cpp

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

gtests/Spv.FromFile.cpp

@@ -517,6 +517,8 @@ INSTANTIATE_TEST_CASE_P(
     "spv.ClosestHitShader_Errors.rchit",
     "spv.MissShader.rmiss",
     "spv.MissShader_Errors.rmiss",
+    "spv.RayCallable.rcall",
+    "spv.RayCallable_Errors.rcall",
     "spv.fragmentShaderBarycentric.frag",
     "spv.fragmentShaderBarycentric2.frag",
     "spv.computeShaderDerivatives.comp",

known_good.json

@@ -5,14 +5,14 @@
       "site" : "github",
       "subrepo" : "KhronosGroup/SPIRV-Tools",
       "subdir" : "External/spirv-tools",
-      "commit" : "9bfe0eb25e3dfdf4f3fd86ab6c0cda009c9bd661"
+      "commit" : "fb996dce752507132c40c255898154cce6c072c5"
     },
     {
       "name" : "spirv-tools/external/spirv-headers",
       "site" : "github",
       "subrepo" : "KhronosGroup/SPIRV-Headers",
       "subdir" : "External/spirv-tools/external/spirv-headers",
-      "commit" : "d5b2e1255f706ce1f88812217e9a554f299848af"
+      "commit" : "a2c529b5dda18838ab4b52f816acfebd774eaab3"
     }
   ]
 }