Modify ternary operator in complex and add it as a functional struct in functional.hlsl . Small change to FFT Indexing utils

Author: Fletterio

include/nbl/builtin/hlsl/complex.hlsl

@@ -6,6 +6,9 @@
 #define _NBL_BUILTIN_HLSL_COMPLEX_INCLUDED_
 
 #include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include <nbl/builtin/hlsl/functional.hlsl>
+
+using namespace nbl::hlsl;
 
 // -------------------------------------- CPP VERSION ------------------------------------
 #ifndef __HLSL_VERSION
@@ -44,8 +47,6 @@ complex_t<Scalar> rotateRight(NBL_CONST_REF_ARG(complex_t<Scalar>) value)
 // -------------------------------------- HLSL VERSION ---------------------------------------
 #else
 
-#include "nbl/builtin/hlsl/functional.hlsl"
-
 namespace nbl
 {
 namespace hlsl
@@ -164,6 +165,8 @@ struct complex_t
 template<typename Scalar> 
 struct plus< complex_t<Scalar> > 
 {
+    using type_t = complex_t<Scalar>;
+
     complex_t<Scalar> operator()(NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs) 
     {
         return lhs + rhs;                                                             
@@ -175,6 +178,8 @@ struct plus< complex_t<Scalar> >
 template<typename Scalar> 
 struct minus< complex_t<Scalar> > 
 {
+    using type_t = complex_t<Scalar>;
+
     complex_t<Scalar> operator()(NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs) 
     {
         return lhs - rhs;                                                             
@@ -186,6 +191,8 @@ struct minus< complex_t<Scalar> >
 template<typename Scalar> 
 struct multiplies< complex_t<Scalar> > 
 {
+    using type_t = complex_t<Scalar>;
+
     complex_t<Scalar> operator()(NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs) 
     {
         return lhs * rhs;                                                             
@@ -202,6 +209,8 @@ struct multiplies< complex_t<Scalar> >
 template<typename Scalar> 
 struct divides< complex_t<Scalar> > 
 {
+    using type_t = complex_t<Scalar>;
+
     complex_t<Scalar> operator()(NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs) 
     {
         return lhs / rhs;                                                             
@@ -417,17 +426,20 @@ complex_t<Scalar> rotateRight(NBL_CONST_REF_ARG(complex_t<Scalar>) value)
     return retVal;
 }
 
-// Annoyed at having to write a lot of boilerplate to do a select
-// Essentially returns what you'd expect from doing `condition ? a : b`
 template<typename Scalar>
-complex_t<Scalar> ternaryOperator(bool condition, NBL_CONST_REF_ARG(complex_t<Scalar>) a, NBL_CONST_REF_ARG(complex_t<Scalar>) b) 
+struct ternary_operator< complex_t<Scalar> >
 {
-    const vector<Scalar, 2> aVector = vector<Scalar, 2>(a.real(), a.imag());
-    const vector<Scalar, 2> bVector = vector<Scalar, 2>(b.real(), b.imag());
-    const vector<Scalar, 2> resultVector = condition ? aVector : bVector;
-    const complex_t<Scalar> result = { resultVector.x, resultVector.y };
-    return result;
-}
+    using type_t = complex_t<Scalar>;
+
+    complex_t<Scalar> operator()(bool condition, NBL_CONST_REF_ARG(complex_t<Scalar>) lhs, NBL_CONST_REF_ARG(complex_t<Scalar>) rhs)
+    {
+        const vector<Scalar, 2> lhsVector = vector<Scalar, 2>(lhs.real(), lhs.imag());
+        const vector<Scalar, 2> rhsVector = vector<Scalar, 2>(rhs.real(), rhs.imag());
+        const vector<Scalar, 2> resultVector = condition ? lhsVector : rhsVector;
+        const complex_t<Scalar> result = { resultVector.x, resultVector.y };
+        return result;
+    }
+};
 
 
 }

include/nbl/builtin/hlsl/functional.hlsl

@@ -165,7 +165,7 @@ COMPOUND_ASSIGN(divides)
 
 // ----------------- End of compound assignment ops ----------------
 
-// Min and Max don't use ALIAS_STD because they don't exist in STD
+// Min, Max and Ternary Operator don't use ALIAS_STD because they don't exist in STD
 // TODO: implement as mix(rhs<lhs,lhs,rhs) (SPIR-V intrinsic from the extended set & glm on C++)
 template<typename T>
 struct minimum
@@ -195,6 +195,17 @@ struct maximum
     NBL_CONSTEXPR_STATIC_INLINE T identity = numeric_limits<scalar_t>::lowest; // TODO: `all_components<T>`
 };
 
+template<typename T>
+struct ternary_operator
+{
+    using type_t = T;
+
+    T operator()(bool condition, NBL_CONST_REF_ARG(T) lhs, NBL_CONST_REF_ARG(T) rhs)
+    {
+        return condition ? lhs : rhs;
+    }
+};
+
 }
 }
 

include/nbl/builtin/hlsl/workgroup/fft.hlsl

@@ -200,9 +200,8 @@ struct FFTIndexingUtils
         uint32_t mirrorLocalIndex;
     };
 
-    static NablaMirrorLocalInfo getNablaMirrorLocalInfo(uint32_t localElementIndex)
+    static NablaMirrorLocalInfo getNablaMirrorLocalInfo(uint32_t globalElementIndex)
     {
-        const uint32_t globalElementIndex = localElementIndex * WorkgroupSize | workgroup::SubgroupContiguousIndex();
         const uint32_t otherElementIndex = FFTIndexingUtils::getNablaMirrorIndex(globalElementIndex);
         const uint32_t mirrorLocalIndex = otherElementIndex / WorkgroupSize;
         const uint32_t otherThreadID = otherElementIndex & (WorkgroupSize - 1);