Merge branch 'master' into nahim_complex_fft_workgroup

Author: Fletterio

3rdparty/dxc/dxc

@@ -356,4 +356,18 @@ complex_t<Scalar> polar(const Scalar r, const Scalar theta)
 }
 }
 
-#endif
+// due to lack of alignof and typeid in DXC, need C++03 style tricks
+NBL_REGISTER_OBJ_TYPE(complex_t<float16_t>,::nbl::hlsl::alignment_of_v<float16_t>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float16_t2>,::nbl::hlsl::alignment_of_v<float16_t2>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float16_t3>,::nbl::hlsl::alignment_of_v<float16_t3>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float16_t4>,::nbl::hlsl::alignment_of_v<float16_t4>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float32_t>,::nbl::hlsl::alignment_of_v<float32_t>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float32_t2>,::nbl::hlsl::alignment_of_v<float32_t2>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float32_t3>,::nbl::hlsl::alignment_of_v<float32_t3>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float32_t4>,::nbl::hlsl::alignment_of_v<float32_t4>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float64_t>,::nbl::hlsl::alignment_of_v<float64_t>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float64_t2>,::nbl::hlsl::alignment_of_v<float64_t2>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float64_t3>,::nbl::hlsl::alignment_of_v<float64_t3>)
+NBL_REGISTER_OBJ_TYPE(complex_t<float64_t4>,::nbl::hlsl::alignment_of_v<float64_t4>)
+
+#endif

include/nbl/builtin/hlsl/complex.hlsl

@@ -1,13 +1,16 @@
 #ifndef _NBL_BUILTIN_HLSL_CPP_COMPAT_PROMOTE_INCLUDED_
 #define _NBL_BUILTIN_HLSL_CPP_COMPAT_PROMOTE_INCLUDED_
 
+#include "nbl/builtin/hlsl/type_traits.hlsl"
+
 namespace nbl
 {
 namespace hlsl
 {
 
 namespace impl
 {
+
 // partial specialize this for `T=matrix<scalar_t,,>|vector<scalar_t,>` and `U=matrix<scalar_t,,>|vector<scalar_t,>|scalar_t`
 template<typename T, typename U>
 struct Promote
@@ -20,76 +23,43 @@ struct Promote
 
 #ifdef __HLSL_VERSION
 
-// TODO: write this scalar-type agnostic!
-template<typename U>
-struct Promote<float32_t1,U>
-{
-    float32_t1 operator()(U v)
-    {
-        return float32_t1(v);
-    }
-};
-
-template<typename U>
-struct Promote<float32_t2, U>
-{
-    float32_t2 operator()(U v)
-    {
-        return float32_t2(v, v);
-    }
-};
-
-template<typename U>
-struct Promote<float32_t3, U>
-{
-    float32_t3 operator()(U v)
-    {
-        return float32_t3(v, v, v);
-    }
-};
-
-template<typename U>
-struct Promote<float32_t4, U>
-{
-    float32_t4 operator()(U v)
-    {
-        return float32_t4(v, v, v, v);
-    }
-};
-
-template<typename U>
-struct Promote<float64_t1,U>
+template<typename Scalar, typename U>
+struct Promote<vector <Scalar, 1>, U>
 {
-    float64_t1 operator()(U v)
+    enable_if_t<is_scalar<Scalar>::value && is_scalar<U>::value, vector <Scalar, 1> > operator()(U v)
     {
-        return float64_t1(v);
+        vector <Scalar, 1> promoted = {Scalar(v)};
+        return promoted;
     }
 };
 
-template<typename U>
-struct Promote<float64_t2, U>
+template<typename Scalar, typename U>
+struct Promote<vector <Scalar, 2>, U>
 {
-    float64_t2 operator()(U v)
+    enable_if_t<is_scalar<Scalar>::value && is_scalar<U>::value, vector <Scalar, 2> > operator()(U v)
     {
-        return float64_t2(v, v);
+        vector <Scalar, 2> promoted = {Scalar(v), Scalar(v)};
+        return promoted;
     }
 };
 
-template<typename U>
-struct Promote<float64_t3, U>
+template<typename Scalar, typename U>
+struct Promote<vector <Scalar, 3>, U>
 {
-    float64_t3 operator()(U v)
+    enable_if_t<is_scalar<Scalar>::value && is_scalar<U>::value, vector <Scalar, 3> > operator()(U v)
     {
-        return float64_t3(v, v, v);
+        vector <Scalar, 3> promoted = {Scalar(v), Scalar(v), Scalar(v)};
+        return promoted;
     }
 };
 
-template<typename U>
-struct Promote<float64_t4, U>
+template<typename Scalar, typename U>
+struct Promote<vector <Scalar, 4>, U>
 {
-    float64_t4 operator()(U v)
+    enable_if_t<is_scalar<Scalar>::value && is_scalar<U>::value, vector <Scalar, 4> > operator()(U v)
     {
-        return float64_t4(v, v, v, v);
+        vector <Scalar, 4> promoted = {Scalar(v), Scalar(v), Scalar(v), Scalar(v)};
+        return promoted;
     }
 };
 

include/nbl/builtin/hlsl/cpp_compat/promote.hlsl

@@ -695,13 +695,13 @@ struct unsigned_integer_of_size<8>
 #define typeid(expr) (::nbl::hlsl::impl::typeid_t<__decltype(expr)>::value)
 
 // Found a bug in Boost.Wave, try to avoid multi-line macros https://github.com/boostorg/wave/issues/195
-#define NBL_IMPL_SPECIALIZE_TYPE_ID(T) namespace impl { template<> struct typeid_t<T> : integral_constant<uint32_t,__COUNTER__> {}; }
+#define NBL_IMPL_SPECIALIZE_TYPE_ID(T) namespace impl { template<> struct typeid_t<T > : integral_constant<uint32_t,__COUNTER__> {}; }
 
 #define NBL_REGISTER_OBJ_TYPE(T,A) namespace nbl { namespace hlsl { NBL_IMPL_SPECIALIZE_TYPE_ID(T) \
-    template<> struct alignment_of<T> : integral_constant<uint32_t,A> {}; \
-    template<> struct alignment_of<const T> : integral_constant<uint32_t,A> {}; \
-    template<> struct alignment_of<typename impl::add_lvalue_reference<T>::type> : integral_constant<uint32_t,A> {}; \
-    template<> struct alignment_of<typename impl::add_lvalue_reference<const T>::type> : integral_constant<uint32_t,A> {}; \
+    template<> struct alignment_of<T > : integral_constant<uint32_t,A > {}; \
+    template<> struct alignment_of<const T > : integral_constant<uint32_t,A > {}; \
+    template<> struct alignment_of<typename impl::add_lvalue_reference<T >::type> : integral_constant<uint32_t,A > {}; \
+    template<> struct alignment_of<typename impl::add_lvalue_reference<const T >::type> : integral_constant<uint32_t,A > {}; \
 }}
 
 // TODO: find out how to do it such that we don't get duplicate definition if we use two function identifiers with same signature