- Make most of intutil shared, deprecate the versions that were in the.h

  that moved to .hlsl
- Update the GLSL bitreverse to be in-line with the GLSL spec

Author: Fletterio

include/nbl/builtin/hlsl/cpp_compat/basic.h

@@ -41,6 +41,7 @@ inline To _static_cast(From v)
 #define NBL_CONSTEXPR_STATIC constexpr static
 #define NBL_CONSTEXPR_STATIC_INLINE constexpr static inline
 #define NBL_CONSTEXPR_INLINE_FUNC constexpr inline
+#define NBL_CONSTEXPR_FORCED_INLINE_FUNC NBL_FORCE_INLINE constexpr
 #define NBL_CONST_MEMBER_FUNC const
 
 namespace nbl::hlsl
@@ -70,6 +71,7 @@ namespace nbl::hlsl
 #define NBL_CONSTEXPR_STATIC const static
 #define NBL_CONSTEXPR_STATIC_INLINE const static
 #define NBL_CONSTEXPR_INLINE_FUNC inline
+#define NBL_CONSTEXPR_FORCED_INLINE_FUNC inline
 #define NBL_CONST_MEMBER_FUNC 
 
 namespace nbl

include/nbl/builtin/hlsl/fft/common.hlsl

@@ -4,9 +4,9 @@
 #include <nbl/builtin/hlsl/cpp_compat.hlsl>
 #include <nbl/builtin/hlsl/complex.hlsl>
 #include <nbl/builtin/hlsl/concepts.hlsl>
-
-#ifndef __HLSL_VERSION
-#include <nbl/core/math/intutil.h>
+#include <nbl/builtin/hlsl/math/intutil.hlsl>
+#include "nbl/builtin/hlsl/numbers.hlsl"
+#include "nbl/builtin/hlsl/concepts.hlsl"
 
 namespace nbl
 {
@@ -25,7 +25,7 @@ inline vector<uint64_t, 3> padDimensions(NBL_CONST_REF_ARG(vector<uint32_t, N>)
     uint16_t axisCount = 0;
     for (uint16_t i = 0u; i < M; i++)
     {
-        newDimensions[i] = core::roundUpToPoT(newDimensions[i]);
+        newDimensions[i] = hlsl::roundUpToPoT(newDimensions[i]);
         if (realFFT && !axisCount++)
             newDimensions[i] /= 2;
     }
@@ -43,57 +43,40 @@ inline uint64_t getOutputBufferSize(NBL_CONST_REF_ARG(vector<uint32_t, N>) input
     return numberOfComplexElements * (halfFloats ? sizeof(complex_t<float16_t>) : sizeof(complex_t<float32_t>));
 }
 
-
-}
-}
-}
-
-#else
-
-#include "nbl/builtin/hlsl/numbers.hlsl"
-#include "nbl/builtin/hlsl/concepts.hlsl"
-
-namespace nbl 
-{
-namespace hlsl
-{
-namespace fft 
-{
-
 // Computes the kth element in the group of N roots of unity
 // Notice 0 <= k < N/2, rotating counterclockwise in the forward (DIF) transform and clockwise in the inverse (DIT)
 template<bool inverse, typename Scalar>
 complex_t<Scalar> twiddle(uint32_t k, uint32_t halfN)
 {
     complex_t<Scalar> retVal;
-    const Scalar kthRootAngleRadians = numbers::pi<Scalar> * Scalar(k) / Scalar(halfN);
-    retVal.real( cos(kthRootAngleRadians) );
-    if (! inverse)
-        retVal.imag( sin(-kthRootAngleRadians) );
+    const Scalar kthRootAngleRadians = numbers::pi<Scalar> *Scalar(k) / Scalar(halfN);
+    retVal.real(cos(kthRootAngleRadians));
+    if (!inverse)
+        retVal.imag(sin(-kthRootAngleRadians));
     else
-        retVal.imag( sin(kthRootAngleRadians) );
-    return retVal;                         
+        retVal.imag(sin(kthRootAngleRadians));
+    return retVal;
 }
 
-template<bool inverse, typename Scalar> 
-struct DIX 
-{ 
+template<bool inverse, typename Scalar>
+struct DIX
+{
     static void radix2(NBL_CONST_REF_ARG(complex_t<Scalar>) twiddle, NBL_REF_ARG(complex_t<Scalar>) lo, NBL_REF_ARG(complex_t<Scalar>) hi)
     {
         plus_assign< complex_t<Scalar> > plusAss;
         //Decimation in time - inverse           
         if (inverse) {
             complex_t<Scalar> wHi = twiddle * hi;
             hi = lo - wHi;
-            plusAss(lo, wHi);            
+            plusAss(lo, wHi);
         }
         //Decimation in frequency - forward   
         else {
             complex_t<Scalar> diff = lo - hi;
             plusAss(lo, hi);
-            hi = twiddle * diff; 
+            hi = twiddle * diff;
         }
-    }                                              
+    }
 };
 
 template<typename Scalar>
@@ -113,11 +96,27 @@ void unpack(NBL_REF_ARG(complex_t<Scalar>) lo, NBL_REF_ARG(complex_t<Scalar>) hi
     lo = x;
 }
 
+
+}
+}
+}
+
+#ifdef __HLSL_VERSION
+
+namespace nbl 
+{
+namespace hlsl
+{
+namespace fft 
+{
+
+// ------------------------------------------------- Utils ---------------------------------------------------------
+
 // Bit-reverses T as a binary string of length given by Bits
 template<typename T, uint16_t Bits NBL_FUNC_REQUIRES(is_integral_v<T> && Bits <= sizeof(T) * 8)
 T bitReverse(T value)
 {
-    return glsl::bitfieldReverse<uint32_t>(value) >> (sizeof(T) * 8 - Bits);
+    return spirv::bitReverse<uint32_t>(value) >> (sizeof(T) * 8 - Bits);
 }
 
 }

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

@@ -31,6 +31,12 @@ genIUType bitfieldInsert(genIUType const& Base, genIUType const& Insert, int Off
 	return glm::bitfieldInsert<genIUType>(Base, Insert, Offset, Bits);
 }
 
+template<typename genIUType>
+genIUType bitfieldReverse(genIUType const& Value)
+{
+    return glm::bitfieldReverse<genIUType>(Value);
+}
+
 #else
 /**
 * Generic SPIR-V
@@ -136,61 +142,6 @@ float32_t2 unpackSnorm2x16(uint32_t p)
     return spirv::unpackSnorm2x16(p);
 }
 
-// No better way to get a vector type of same length as Integral but made up of `int32_t` s?
-
-template<typename T>
-vector<int32_t, uint32_t(sizeof(T) / sizeof(scalar_type_t<T>))> findLSB(T value)
-{
-    using return_t = vector<int32_t, uint32_t(sizeof(T) / sizeof(scalar_type_t<T>))>;
-    return bit_cast<return_t, T>(spirv::findILsb<T>(value));
-}
-
-namespace impl
-{
-    template<typename T, bool isSigned, bool isIntegral>
-    struct findMSB {};
-
-    template<typename T, bool isSigned>
-    struct findMSB<T, isSigned, false>
-    {
-        using return_t = vector<int32_t, uint32_t(sizeof(T) / sizeof(scalar_type_t<T>))>;
-
-        static return_t __call(T value)
-        {
-            static_assert(is_integral<T>::value, "T is not an integral type!");
-            return value;
-        }
-    };
-
-    template<typename T>
-    struct findMSB<T, true, true>
-    {
-        using return_t = vector<int32_t, uint32_t(sizeof(T) / sizeof(scalar_type_t<T>))>;
-
-        static return_t __call(T value)
-        {
-            return bit_cast<return_t, T>(spirv::findSMsb<T>(value));
-        }
-    };
-
-    template<typename T>
-    struct findMSB<T, false, true>
-    {
-        using return_t = vector<int32_t, uint32_t(sizeof(T) / sizeof(scalar_type_t<T>))>;
-
-        static return_t __call(T value)
-        {
-            return bit_cast<return_t, T>(spirv::findUMsb<T>(value));
-        }
-    };
-} // namespace impl
-
-template<typename T>
-vector<int32_t, uint32_t(sizeof(T) / sizeof(scalar_type_t<T>))> findMSB(T value)
-{
-    return impl::findMSB<T, is_signed_v<T>, is_integral_v<T> >::__call(value);
-}
-
 /**
  * For Vertex Shaders
  */
@@ -275,10 +226,17 @@ T bitfieldInsert(T base, T insert, uint32_t offset, uint32_t bits)
     return spirv::bitFieldInsert<T>(base, insert, offset, bits);
 }
 
+// Spec requires this to return the bitreversal done with the amount of bits necessary to represent the number https://registry.khronos.org/OpenGL-Refpages/gl4/html/bitfieldReverse.xhtml
 template<typename T>
 T bitfieldReverse(T value)
 {
-    return spirv::bitFieldReverse<T>(value);
+    using unsigned_t = typename make_unsigned<T>::type;
+    // Bit-cast to uint to use the uint version of MSB
+    unsigned_t unsignedCasted = spirv::bitcast<unsigned_t, T>(value);
+    unsigned_t bits = findMSB(unsignedCasted);
+    NBL_CONSTEXPR_STATIC_INLINE unsigned_t width = promote<unsigned_t, scalar_type_t<unsigned_t> >(scalar_type_t<unsigned_t>(sizeof(scalar_type_t<unsigned_t>)));
+    // Do the shift in unsigned to ensure we do not get an arithmetic shift if signed, then cast back to original type
+    return spirv::bitcast<T, unsigned_t>(spirv::bitReverse<unsigned_t>(unsignedCasted) >> (width - bits));
 }
 
 #endif

include/nbl/builtin/hlsl/math/intutil.hlsl

@@ -0,0 +1,88 @@
+#ifndef _NBL_BUILTIN_HLSL_MATH_INTUTIL_INCLUDED_
+#define _NBL_BUILTIN_HLSL_MATH_INTUTIL_INCLUDED_
+
+#include "nbl/builtin/hlsl/cpp_compat.hlsl"
+#include "nbl/builtin/hlsl/type_traits.hlsl"
+
+namespace nbl
+{
+namespace hlsl
+{
+
+template<typename Integer NBL_FUNC_REQUIRES(is_integral_v<Integer>)
+NBL_CONSTEXPR_FORCED_INLINE_FUNC bool isNPoT(Integer value)
+{
+    return value & (value - Integer(1));
+}
+
+template<typename Integer NBL_FUNC_REQUIRES(is_integral_v<Integer>)
+NBL_CONSTEXPR_FORCED_INLINE_FUNC bool isPoT(Integer value)
+{
+    return !isNPoT<Integer>(value);
+}
+
+
+template<typename Integer NBL_FUNC_REQUIRES(is_integral_v<Integer>)
+NBL_CONSTEXPR_FORCED_INLINE_FUNC Integer roundUpToPoT(Integer value)
+{
+    return Integer(0x1u) << Integer(1 + hlsl::findMSB<Integer>(value - Integer(1))); // this wont result in constexpr because findMSB is not one
+}
+
+template<typename Integer NBL_FUNC_REQUIRES(is_integral_v<Integer>)
+NBL_CONSTEXPR_FORCED_INLINE_FUNC Integer roundDownToPoT(Integer value)
+{
+    return Integer(0x1u) << hlsl::findMSB<Integer>(value);
+}
+
+template<typename Integer NBL_FUNC_REQUIRES(is_integral_v<Integer>)
+NBL_CONSTEXPR_FORCED_INLINE_FUNC Integer roundUp(Integer value, Integer multiple)
+{
+    Integer tmp = (value + multiple - 1u) / multiple;
+    return tmp * multiple;
+}
+
+template<typename Integer NBL_FUNC_REQUIRES(is_integral_v<Integer>)
+NBL_CONSTEXPR_FORCED_INLINE_FUNC Integer align(Integer alignment, Integer size, NBL_REF_ARG(Integer) address, NBL_REF_ARG(Integer) space)
+{
+    Integer nextAlignedAddr = roundUp<Integer>(address, alignment);
+
+    Integer spaceDecrement = nextAlignedAddr - address;
+    if (spaceDecrement > space)
+        return 0u;
+
+    Integer newSpace = space - spaceDecrement;
+    if (size > newSpace)
+        return 0u;
+
+    space = newSpace;
+    return address = nextAlignedAddr;
+}
+
+#ifndef __HLSL_VERSION
+
+// Have to wait for the HLSL patch for `is_enum`. Would also have to figure out how to do it without initializer lists for HLSL use. 
+
+//! Get bitmask from variadic arguments passed. 
+/*
+    For example if you were to create bitmask for vertex attributes
+    having positions inteeger set as 0, colors as 1 and normals
+    as 3, just pass them to it and use the value returned.
+*/
+
+template<typename BitmaskType NBL_FUNC_REQUIRES(is_integral_v<BitmaskType> || std::is_enum_v<BitmaskType>)
+NBL_CONSTEXPR_FORCED_INLINE_FUNC uint64_t createBitmask(std::initializer_list<BitmaskType> initializer)
+{
+    uint64_t retval{};
+    for (const auto& it : initializer)
+        retval |= (1ull << it);
+    return retval;
+}
+
+#endif
+
+} // end namespace hlsl
+} // end namespace nbl
+
+
+#endif
+

include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl

@@ -232,7 +232,7 @@ enable_if_t<is_integral_v<Integral>, Integral> bitFieldInsert( Integral base, In
 
 template<typename Integral>
 [[vk::ext_instruction( spv::OpBitReverse )]]
-enable_if_t<is_integral_v<Integral>, Integral> bitFieldReverse( Integral base );
+enable_if_t<is_integral_v<Integral>, Integral> bitReverse( Integral base );
 
 template<typename FloatingPoint>
 [[vk::ext_instruction( spv::OpIsNan )]]