don't bitcast when doing OpAccessChain

start implementing struct-member-traits

extend `nbl::hlsl::mpl`

add a `nbl::hlsl::size_of`

Author: devsh

include/nbl/builtin/hlsl/bda/__ref.hlsl

@@ -5,6 +5,7 @@
 #define _NBL_BUILTIN_HLSL_BDA_REF_INCLUDED_
 
 #include "nbl/builtin/hlsl/functional.hlsl"
+#include "nbl/builtin/hlsl/mpl.hlsl"
 
 namespace nbl
 {
@@ -26,6 +27,69 @@ struct __spv_ptr_t<T,true>
     [[vk::ext_decorate(spv::DecorationRestrictPointer)]] spirv::bda_pointer_t<T> value;
 };
 
+
+// silly utility traits
+template<typename T>
+struct member_count
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t value = 0;
+};
+template<typename T>
+NBL_CONSTEXPR uint32_t member_count_v = member_count<T>::value;
+
+template<typename T, int32_t MemberIx>
+struct member_type;
+template<typename T, int32_t MemberIx>
+using member_type_t = typename member_type<T,MemberIx>::type;
+
+// default alignment is the alignment of the type
+template<typename T, int32_t MemberIx>
+struct member_alignment
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t value = alignment_of_v<member_type_t<T,MemberIx> >;
+};
+template<typename T, int32_t MemberIx>
+NBL_CONSTEXPR uint32_t member_alignment_v = member_alignment<T,MemberIx>::value;
+
+namespace impl
+{
+template<typename T, uint32_t N>
+struct default_alignment
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t value = mpl::max_v<uint32_t,member_alignment_v<T,N-1>,member_alignment_v<T,N-2> >;
+};
+template<typename T>
+struct default_alignment<T,1>
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t value = member_alignment_v<T,0>;
+};
+// le invalid value
+template<typename T>
+struct default_alignment<T,0>
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t value = 0;
+};
+template<typename T, typename MemberCount=member_count<T> >
+NBL_CONSTEXPR uint32_t default_alignment_v = default_alignment<T,MemberCount::value>::value;
+}
+
+// the default specialization of the offset assumes scalar layout
+template<typename T, int32_t MemberIx>
+struct member_offset
+{
+    // TODO: assert that the custom alignment is no less than the type's natural alignment?
+    // first byte past previous member, rounded up to out alignment
+    NBL_CONSTEXPR_STATIC_INLINE uint64_t value = mpl::align_up_v<member_offset<T,MemberIx-1>::value+size_of_v<member_type_t<T,MemberIx-1> >,member_alignment_v<T,MemberIx> >;
+};
+template<typename T>
+struct member_offset<T,0>
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint64_t value = 0;
+};
+template<typename T, int32_t MemberIx>
+NBL_CONSTEXPR uint64_t member_offset_v = member_offset<T,MemberIx>::value;
+
+
 template<typename T, uint32_t alignment, bool _restrict>
 struct __base_ref
 {
@@ -112,9 +176,9 @@ struct nbl::hlsl::bda::__ref<MyStruct,alignment,_restrict> : nbl::hlsl::bda::__b
     void __init(const nbl::hlsl::spirv::bda_pointer_t<MyStruct> _ptr)
     {
         base_t::__init(_ptr);
-        a.__init(spirv::accessChain<float32_t>(base_t::__get_spv_ptr(),0));
-        b.__init(spirv::accessChain<int32_t>(base_t::__get_spv_ptr(),1));
-        c.__init(spirv::accessChain<int16_t2>(base_t::__get_spv_ptr(),2));
+		a.__init(spirv::accessChain<float32_t>(base_t::ptr.value,0));
+		b.__init(spirv::accessChain<int32_t>(base_t::ptr.value,1));
+		c.__init(spirv::accessChain<int16_t2>(base_t::ptr.value,2));
     }
 };
 */

include/nbl/builtin/hlsl/mpl.hlsl

@@ -40,35 +40,57 @@ struct countl_zero : impl::countl_zero<uint64_t(N), (sizeof(T) * 8)>
 {
     static_assert(is_integral<T>::value, "countl_zero type parameter must be an integral type");
 };
+template<class T, T N>
+NBL_CONSTEXPR T countl_zero_v = countl_zero<T,N>::value;
 
 template<uint64_t X>
 struct log2
 {
     NBL_CONSTEXPR_STATIC_INLINE uint16_t value = X ? (1ull<<6)-countl_zero<uint64_t, X>::value-1 : -1ull;
 };
+template<uint64_t X>
+NBL_CONSTEXPR uint64_t log2_v = log2<X>::value;
 
 template<typename T, T X, int32_t S>
 struct rotl
 {
-    static const uint32_t N = 32u;
-    static const int32_t r = S % N;
-    static const T value = (S >= 0) ? ((X << r) | (X >> (N - r))) : (X >> (-r)) | (X << (N - (-r)));
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t N = 32u;
+    NBL_CONSTEXPR_STATIC_INLINE int32_t r = S % N;
+    NBL_CONSTEXPR_STATIC_INLINE T value = (S >= 0) ? ((X << r) | (X >> (N - r))) : (X >> (-r)) | (X << (N - (-r)));
 };
+template<typename T, T X, int32_t S>
+NBL_CONSTEXPR T rotl_v = rotl<T,X,S>::value;
 
 template<typename T, T X, int32_t S>
 struct rotr
 {
-    static const uint32_t N = 32u;
-    static const int32_t r = S % N;
-    static const T value = (S >= 0) ? ((X >> r) | (X << (N - r))) : (X << (-r)) | (X >> (N - (-r)));
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t N = 32u;
+    NBL_CONSTEXPR_STATIC_INLINE int32_t r = S % N;
+    NBL_CONSTEXPR_STATIC_INLINE T value = (S >= 0) ? ((X >> r) | (X << (N - r))) : (X << (-r)) | (X >> (N - (-r)));
+};
+template<typename T, T X, int32_t S>
+NBL_CONSTEXPR T rotr_v = rotr<T,X,S>::value;
+
+template<uint64_t X, uint64_t M>
+struct align_up
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint64_t value = (X+M-1)/M;
 };
+template<uint64_t X, uint64_t M>
+NBL_CONSTEXPR uint64_t align_up_v = align_up<X,M>::value;
 
 template<uint64_t N>
 struct is_pot : bool_constant< (N > 0 && !(N & (N - 1))) > {};
-
 template<uint64_t N>
-NBL_CONSTEXPR_STATIC_INLINE bool is_pot_v = is_pot<N>::value;
+NBL_CONSTEXPR bool is_pot_v = is_pot<N>::value;
 
+template<typename T, T X, T Y>
+struct max
+{
+    NBL_CONSTEXPR_STATIC_INLINE T value = X<Y ? Y:X;
+};
+template<typename T, T X, T Y>
+NBL_CONSTEXPR T max_v = max<T,X,Y>::value;
 }
 }
 }

include/nbl/builtin/hlsl/type_traits.hlsl

@@ -390,6 +390,13 @@ struct enable_if {};
 template<class T>
 struct enable_if<true, T> : type_identity<T> {};
 
+// DXC sometimes doesn't report sizeof properly
+template<class T>
+struct size_of
+{
+    NBL_CONSTEXPR_STATIC_INLINE uint64_t value = sizeof(T);
+};
+
 template<class T>
 struct alignment_of;
 
@@ -581,6 +588,13 @@ struct extent : std::extent<T, I> {};
 template<bool B, class T = void>
 using enable_if = std::enable_if<B, T>;
 
+// DXC sometimes doesn't report sizeof properly
+template<class T>
+struct size_of
+{
+    constexpr static inline uint64_t value = sizeof(T);
+};
+
 template<class T>
 using alignment_of = std::alignment_of<T>;
 
@@ -623,6 +637,8 @@ NBL_CONSTEXPR bool is_signed_v = is_signed<T>::value;
 template<class T>
 NBL_CONSTEXPR bool is_scalar_v = is_scalar<T>::value;
 template<class T>
+NBL_CONSTEXPR uint64_t size_of_v = size_of<T>::value;
+template<class T>
 NBL_CONSTEXPR uint32_t alignment_of_v = alignment_of<T>::value;
 template<class T, uint32_t N = 0>
 NBL_CONSTEXPR uint64_t extent_v = extent<T, N>::value;
@@ -788,7 +804,7 @@ struct extent<matrix<T, N, M>, 1> : integral_constant<uint64_t, M> {};
 // deal with typetraits, for now we rely on Clang/DXC internal __decltype(), if it breaks we revert to commit e4ab38ca227b15b2c79641c39161f1f922b779a3
 #ifdef __HLSL_VERSION
 
-#define alignof(expr) ::nbl::hlsl::alignment_of<__decltype(expr)>::value
+#define alignof(expr) ::nbl::hlsl::alignment_of_v<__decltype(expr)>
 
 // shoudl really return a std::type_info like struct or something, but no `constexpr` and unsure whether its possible to have a `const static SomeStruct` makes it hard to do...
 #define typeid(expr) (::nbl::hlsl::impl::typeid_t<__decltype(expr)>::value)