builtin: update glsl_compat layer to represent new spirv_intrisics

Devsh-Graphics-Programming · Sep 10, 2024 · ca1ae43 · ca1ae43
1 parent 76c1617
commit ca1ae43
Show file tree

Hide file tree

Showing 2 changed files with 145 additions and 14 deletions.
diff --git a/include/nbl/builtin/hlsl/glsl_compat/core.hlsl b/include/nbl/builtin/hlsl/glsl_compat/core.hlsl
@@ -187,7 +187,7 @@ struct bitfieldExtract<T, true, true>
 {
     static T __call( T val, uint32_t offsetBits, uint32_t numBits )
     {
-        return spirv::bitFieldExtract( val, offsetBits, numBits );
+        return spirv::bitFieldSExtract( val, offsetBits, numBits );
     }
 };
 
@@ -196,7 +196,7 @@ struct bitfieldExtract<T, false, true>
 {
     static T __call( T val, uint32_t offsetBits, uint32_t numBits )
     {
-        return spirv::bitFieldExtract( val, offsetBits, numBits );
+        return spirv::bitFieldUExtract( val, offsetBits, numBits );
     } 
 };
 

diff --git a/include/nbl/builtin/hlsl/glsl_compat/subgroup_arithmetic.hlsl b/include/nbl/builtin/hlsl/glsl_compat/subgroup_arithmetic.hlsl
@@ -80,30 +80,161 @@ T subgroupExclusiveXor(T value) {
     return spirv::groupNonUniformBitwiseXor_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
 }
 
+namespace impl
+{
+
+template<typename T, bool isSigned>
+struct subgroupMin {};
+
+template<typename T>
+struct subgroupMin<T, true>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformSMin_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, val);
+    }
+};
+
+template<typename T>
+struct subgroupMin<T, false>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformUMin_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, val);
+    } 
+};
+
+template<typename T, bool isSigned>
+struct subgroupInclusiveMin {};
+
+template<typename T>
+struct subgroupInclusiveMin<T, true>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformSMin_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, val);
+    }
+};
+
+template<typename T>
+struct subgroupInclusiveMin<T, false>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformUMin_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, val);
+    } 
+};
+
+template<typename T, bool isSigned>
+struct subgroupExclusiveMin {};
+
+template<typename T>
+struct subgroupExclusiveMin<T, true>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformSMin_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, val);
+    }
+};
+
+template<typename T>
+struct subgroupExclusiveMin<T, false>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformUMin_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, val);
+    } 
+};
+
+template<typename T, bool isSigned>
+struct subgroupMax {};
+
+template<typename T>
+struct subgroupMax<T, true>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformSMax_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, val);
+    }
+};
+
+template<typename T>
+struct subgroupMax<T, false>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformUMax_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationReduce, val);
+    } 
+};
+
+template<typename T, bool isSigned>
+struct subgroupInclusiveMax {};
+
+template<typename T>
+struct subgroupInclusiveMax<T, true>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformSMax_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, val);
+    }
+};
+
+template<typename T>
+struct subgroupInclusiveMax<T, false>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformUMax_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, val);
+    } 
+};
+
+template<typename T, bool isSigned>
+struct subgroupExclusiveMax {};
+
+template<typename T>
+struct subgroupExclusiveMax<T, true>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformSMax_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, val);
+    }
+};
+
+template<typename T>
+struct subgroupExclusiveMax<T, false>
+{
+    static T __call(T val)
+    {
+        return spirv::groupNonUniformUMax_GroupNonUniformArithmetic<T>(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, val);
+    } 
+};
+
+}
+
 template<typename T>
-T subgroupMin(T value) {
-    return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+T subgroupMin(T val) {
+    return impl::subgroupMin<T, is_signed<T>::value>::__call(val);
 }
 template<typename T>
-T subgroupInclusiveMin(T value) {
-    return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+T subgroupInclusiveMin(T val) {
+    return impl::subgroupInclusiveMin<T, is_signed<T>::value>::__call(val);
 }
 template<typename T>
-T subgroupExclusiveMin(T value) {
-    return spirv::groupNonUniformMin_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+T subgroupExclusiveMin(T val) {
+    return impl::subgroupExclusiveMin<T, is_signed<T>::value>::__call(val);
 }
 
 template<typename T>
-T subgroupMax(T value) {
-    return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationReduce, value);
+T subgroupMax(T val) {
+    return impl::subgroupMax<T, is_signed<T>::value>::__call(val);
 }
 template<typename T>
-T subgroupInclusiveMax(T value) {
-    return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationInclusiveScan, value);
+T subgroupInclusiveMax(T val) {
+    return impl::subgroupInclusiveMax<T, is_signed<T>::value>::__call(val);
 }
 template<typename T>
-T subgroupExclusiveMax(T value) {
-    return spirv::groupNonUniformMax_GroupNonUniformArithmetic(spv::ScopeSubgroup, spv::GroupOperationExclusiveScan, value);
+T subgroupExclusiveMax(T val) {
+    return impl::subgroupExclusiveMax<T, is_signed<T>::value>::__call(val);
 }
 
 }