builtin: update inline spirv hlsl

Signed-off-by: Ali Cheraghi <alichraghi@proton.me>

Author: alichraghi

include/nbl/builtin/hlsl/glsl_compat/core.hlsl

@@ -135,21 +135,21 @@ SquareMatrix inverse(NBL_CONST_REF_ARG(SquareMatrix) mat)
  */
  // TODO: Extemely annoying that HLSL doesn't have references, so we can't transparently alias the variables as `&` :(
 //void gl_Position() {spirv::}
-uint32_t gl_VertexIndex() {return spirv::VertexIndex;}
-uint32_t gl_InstanceIndex() {return spirv::InstanceIndex;}
+uint32_t gl_VertexIndex() {return spirv::builtin::VertexIndex;}
+uint32_t gl_InstanceIndex() {return spirv::builtin::InstanceIndex;}
 
 /**
  * For Compute Shaders
  */
 
 // TODO: Extemely annoying that HLSL doesn't have references, so we can't transparently alias the variables as `const&` :(
-uint32_t3 gl_NumWorkGroups() {return spirv::NumWorkGroups;}
+uint32_t3 gl_NumWorkGroups() {return spirv::builtin::NumWorkgroups;}
 // TODO: DXC BUG prevents us from defining this!
 uint32_t3 gl_WorkGroupSize();
-uint32_t3 gl_WorkGroupID() {return spirv::WorkgroupId;}
-uint32_t3 gl_LocalInvocationID() {return spirv::LocalInvocationId;}
-uint32_t3 gl_GlobalInvocationID() {return spirv::GlobalInvocationId;}
-uint32_t gl_LocalInvocationIndex() {return spirv::LocalInvocationIndex;}
+uint32_t3 gl_WorkGroupID() {return spirv::builtin::WorkgroupId;}
+uint32_t3 gl_LocalInvocationID() {return spirv::builtin::LocalInvocationId;}
+uint32_t3 gl_GlobalInvocationID() {return spirv::builtin::GlobalInvocationId;}
+uint32_t gl_LocalInvocationIndex() {return spirv::builtin::LocalInvocationIndex;}
 
 void barrier() {
     spirv::controlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsAcquireReleaseMask | spv::MemorySemanticsWorkgroupMemoryMask);
@@ -182,21 +182,23 @@ struct bitfieldExtract<T, isSigned, false>
     }
 };
 
+// TODO: redundant T
 template<typename T>
 struct bitfieldExtract<T, true, true>
 {
     static T __call( T val, uint32_t offsetBits, uint32_t numBits )
     {
-        return spirv::bitFieldSExtract<T>( val, offsetBits, numBits );
+        return spirv::bitFieldExtract( val, offsetBits, numBits );
     }
 };
 
+// TODO: redundant T
 template<typename T>
 struct bitfieldExtract<T, false, true>
 {
     static T __call( T val, uint32_t offsetBits, uint32_t numBits )
     {
-        return spirv::bitFieldUExtract<T>( val, offsetBits, numBits );
+        return spirv::bitFieldExtract( val, offsetBits, numBits );
     } 
 };
 

include/nbl/builtin/hlsl/glsl_compat/subgroup_arithmetic.hlsl

@@ -4,7 +4,7 @@
 #ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_ARITHMETIC_INCLUDED_
 #define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_ARITHMETIC_INCLUDED_
 
-#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_arithmetic.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
 
 namespace nbl
 {
@@ -17,93 +17,93 @@ namespace glsl
 // TODO: Furthermore you'll need `bitfieldExtract`-like struct dispatcher to choose between int/float add/mul and sint/uint/float min/max
 template<typename T>
 T subgroupAdd(T value) {
-    return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+    return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
 }
 template<typename T>
 T subgroupInclusiveAdd(T value) {
-    return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+    return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
 }
 template<typename T>
 T subgroupExclusiveAdd(T value) {
-    return spirv::groupAdd(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+    return spirv::groupNonUniformIAdd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
 template<typename T>
 T subgroupMul(T value) {
-    return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+    return spirv::groupNonUniformIMul_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
 }
 template<typename T>
 T subgroupInclusiveMul(T value) {
-    return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+    return spirv::groupNonUniformIMul_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
 }
 template<typename T>
 T subgroupExclusiveMul(T value) {
-    return spirv::groupMul(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+    return spirv::groupNonUniformIMul_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
 template<typename T>
 T subgroupAnd(T value) {
-    return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+    return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
 }
 template<typename T>
 T subgroupInclusiveAnd(T value) {
-    return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+    return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
 }
 template<typename T>
 T subgroupExclusiveAnd(T value) {
-    return spirv::groupBitwiseAnd(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+    return spirv::groupNonUniformBitwiseAnd_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
 template<typename T>
 T subgroupOr(T value) {
-    return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+    return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
 }
 template<typename T>
 T subgroupInclusiveOr(T value) {
-    return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+    return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
 }
 template<typename T>
 T subgroupExclusiveOr(T value) {
-    return spirv::groupBitwiseOr(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+    return spirv::groupNonUniformBitwiseOr_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
 template<typename T>
 T subgroupXor(T value) {
-    return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+    return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
 }
 template<typename T>
 T subgroupInclusiveXor(T value) {
-    return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+    return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
 }
 template<typename T>
 T subgroupExclusiveXor(T value) {
-    return spirv::groupBitwiseXor(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+    return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
 template<typename T>
 T subgroupMin(T value) {
-    return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+    return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
 }
 template<typename T>
 T subgroupInclusiveMin(T value) {
-    return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+    return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
 }
 template<typename T>
 T subgroupExclusiveMin(T value) {
-    return spirv::groupBitwiseMin(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+    return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
 template<typename T>
 T subgroupMax(T value) {
-    return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+    return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
 }
 template<typename T>
 T subgroupInclusiveMax(T value) {
-    return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+    return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
 }
 template<typename T>
 T subgroupExclusiveMax(T value) {
-    return spirv::groupBitwiseMax(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+    return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
 }

include/nbl/builtin/hlsl/glsl_compat/subgroup_ballot.hlsl

@@ -4,7 +4,7 @@
 #ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BALLOT_INCLUDED_
 #define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BALLOT_INCLUDED_
 
-#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_ballot.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
 #include "nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl"
 
 namespace nbl 
@@ -15,62 +15,62 @@ namespace glsl
 {
 
 // TODO: Extemely annoying that HLSL doesn't have referencies, so we can't transparently alias the variables as `const&` :(
-uint32_t4 gl_SubgroupEqMask() {return spirv::BuiltInSubgroupEqMask;}
-uint32_t4 gl_SubgroupGeMask() {return spirv::BuiltInSubgroupGeMask;}
-uint32_t4 gl_SubgroupGtMask() {return spirv::BuiltInSubgroupGtMask;}
-uint32_t4 gl_SubgroupLeMask()  {return spirv::BuiltInSubgroupLeMask;}
-uint32_t4 gl_SubgroupLtMask()  {return spirv::BuiltInSubgroupLtMask;}
+uint32_t4 gl_SubgroupEqMask() {return spirv::builtin::SubgroupEqMask;}
+uint32_t4 gl_SubgroupGeMask() {return spirv::builtin::SubgroupGeMask;}
+uint32_t4 gl_SubgroupGtMask() {return spirv::builtin::SubgroupGtMask;}
+uint32_t4 gl_SubgroupLeMask()  {return spirv::builtin::SubgroupLeMask;}
+uint32_t4 gl_SubgroupLtMask()  {return spirv::builtin::SubgroupLtMask;}
 
 template<typename T>
 T subgroupBroadcastFirst(T value)
 {
-    return spirv::subgroupBroadcastFirst<T>(spv::ScopeSubgroup, value);
+    return spirv::groupNonUniformBroadcastFirst<T>(spv::ScopeSubgroup, value);
 }
 
 template<typename T>
 T subgroupBroadcast(T value, const uint32_t invocationId)
 {
-    return spirv::subgroupBroadcast<T>(spv::ScopeSubgroup, value, invocationId);
+    return spirv::groupNonUniformBroadcast<T>(spv::ScopeSubgroup, value, invocationId);
 }
 
 uint32_t4 subgroupBallot(bool value)
 {
-    return spirv::subgroupBallot(spv::ScopeSubgroup, value);
+    return spirv::groupNonUniformBallot(spv::ScopeSubgroup, value);
 }
 
 bool subgroupInverseBallot(uint32_t4 value)
 {
-    return spirv::subgroupInverseBallot(spv::ScopeSubgroup, value);
+    return spirv::groupNonUniformInverseBallot(spv::ScopeSubgroup, value);
 }
 
 bool subgroupBallotBitExtract(uint32_t4 value, uint32_t index)
 {
-    return spirv::subgroupBallotBitExtract(spv::ScopeSubgroup, value, index);
+    return spirv::groupNonUniformBallotBitExtract(spv::ScopeSubgroup, value, index);
 }
 
 uint32_t subgroupBallotBitCount(uint32_t4 value)
 {
-    return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+    return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
 }
 
 uint32_t subgroupBallotInclusiveBitCount(uint32_t4 value)
 {
-    return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+    return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
 }
 
 uint32_t subgroupBallotExclusiveBitCount(uint32_t4 value)
 {
-    return spirv::subgroupBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+    return spirv::groupNonUniformBallotBitCount(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
 uint32_t subgroupBallotFindLSB(uint32_t4 value)
 {
-    return spirv::subgroupBallotFindLSB(spv::ScopeSubgroup, value);
+    return spirv::groupNonUniformBallotFindLSB(spv::ScopeSubgroup, value);
 }
 
 uint32_t subgroupBallotFindMSB(uint32_t4 value)
 {
-    return spirv::subgroupBallotFindMSB(spv::ScopeSubgroup, value);
+    return spirv::groupNonUniformBallotFindMSB(spv::ScopeSubgroup, value);
 }
 }
 }

include/nbl/builtin/hlsl/glsl_compat/subgroup_basic.hlsl

@@ -5,7 +5,7 @@
 #define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_BASIC_INCLUDED_
 
 #include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
-#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_basic.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
 
 namespace nbl 
 {
@@ -16,16 +16,16 @@ namespace glsl
 #ifdef __HLSL_VERSION
 // TODO: Extemely annoying that HLSL doesn't have referencies, so we can't transparently alias the variables as `const&` :(
 // NOTE: These are not `uint16_t` even though they could be, because IIUtSC they're `uint32_t` in SPIR-V
-uint32_t gl_SubgroupSize() {return spirv::SubgroupSize;}
-uint32_t gl_SubgroupSizeLog2() {return firstbithigh(spirv::SubgroupSize);}
-uint32_t gl_SubgroupInvocationID() {return spirv::SubgroupLocalInvocationId;}
+uint32_t gl_SubgroupSize() {return spirv::builtin::SubgroupSize;}
+uint32_t gl_SubgroupSizeLog2() {return firstbithigh(spirv::builtin::SubgroupSize);}
+uint32_t gl_SubgroupInvocationID() {return spirv::builtin::SubgroupLocalInvocationId;}
 
 // only available in compute
-uint32_t gl_NumSubgroups() {return spirv::NumSubgroups;}
-uint32_t gl_SubgroupID() {return spirv::SubgroupId;}
+uint32_t gl_NumSubgroups() {return spirv::builtin::NumSubgroups;}
+uint32_t gl_SubgroupID() {return spirv::builtin::SubgroupId;}
 
 bool subgroupElect() {
-    return spirv::subgroupElect(spv::ScopeSubgroup);
+    return spirv::groupNonUniformElect(spv::ScopeSubgroup);
 }
 
 void subgroupBarrier() {

include/nbl/builtin/hlsl/glsl_compat/subgroup_shuffle.hlsl

@@ -4,7 +4,7 @@
 #ifndef _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_SHUFFLE_INCLUDED_
 #define _NBL_BUILTIN_HLSL_GLSL_COMPAT_SUBGROUP_SHUFFLE_INCLUDED_
 
-#include "nbl/builtin/hlsl/spirv_intrinsics/subgroup_shuffle.hlsl"
+#include "nbl/builtin/hlsl/spirv_intrinsics/core.hlsl"
 
 namespace nbl 
 {
@@ -15,25 +15,25 @@ namespace glsl
 template<typename T>
 T subgroupShuffle(T value, uint32_t invocationId)
 {
-    return spirv::groupShuffle<T>(spv::ScopeSubgroup, value, invocationId);
+    return spirv::groupNonUniformShuffle<T>(spv::ScopeSubgroup, value, invocationId);
 }
 
 template<typename T>
 T subgroupShuffleXor(T value, uint32_t mask)
 {
-    return spirv::groupShuffleXor<T>(spv::ScopeSubgroup, value, mask);
+    return spirv::groupNonUniformShuffleXor<T>(spv::ScopeSubgroup, value, mask);
 }
 
 template<typename T>
 T subgroupShuffleUp(T value, uint32_t delta)
 {
-    return spirv::groupShuffleUp<T>(spv::ScopeSubgroup, value, delta);
+    return spirv::groupNonUniformShuffleUp<T>(spv::ScopeSubgroup, value, delta);
 }
 
 template<typename T>
 T subgroupShuffleDown(T value, uint32_t delta)
 {
-    return spirv::groupShuffleDown<T>(spv::ScopeSubgroup, value, delta);
+    return spirv::groupNonUniformShuffleDown<T>(spv::ScopeSubgroup, value, delta);
 }