new goodies

Author: atkurtul

include/nbl/builtin/hlsl/type_traits.hlsl

@@ -72,7 +72,7 @@
   template<class T> struct is_scoped_enum; (NOT-APPLICABLE)
 
   // type property queries
-  template<class T> struct alignment_of; (TODO)
+  template<class T> struct alignment_of; (SPECIALIZED FOR REGISTERED TYPES)
   template<class T> struct rank; (DONE)
   template<class T, unsigned I = 0> struct extent; (DONE)
  
@@ -91,33 +91,33 @@
     template<class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
  
   // const-volatile modifications
-  template<class T> struct remove_const; (TODO)
-  template<class T> struct remove_volatile; (TODO)
-  template<class T> struct remove_cv; (TODO)
-  template<class T> struct add_const; (TODO)
-  template<class T> struct add_volatile; (TODO)
-  template<class T> struct add_cv; (TODO)
+  template<class T> struct remove_const; (DONE)
+  template<class T> struct remove_volatile; (DONE)
+  template<class T> struct remove_cv; (DONE)
+  template<class T> struct add_const; (DONE)
+  template<class T> struct add_volatile; (DONE)
+  template<class T> struct add_cv; (DONE)
 
   // reference modifications
-  template<class T> struct remove_reference; (TODO)
-  template<class T> struct add_lvalue_reference; (TODO)
-  template<class T> struct add_rvalue_reference; (TODO)
+  template<class T> struct remove_reference; (DONE)
+  template<class T> struct add_lvalue_reference; (DONE BUT DONT USE)
+  template<class T> struct add_rvalue_reference; (DONE BUT DONT USE)
 
   // sign modifications
   template<class T> struct make_signed; (TODO)
   template<class T> struct make_unsigned; (TODO)
  
   // array modifications
-  template<class T> struct remove_extent; (TODO)
-  template<class T> struct remove_all_extents; (TODO)
+  template<class T> struct remove_extent; (DONE)
+  template<class T> struct remove_all_extents; (DONE)
 
   // pointer modifications
-  template<class T> struct remove_pointer; (TODO)
-  template<class T> struct add_pointer; (TODO)
+  template<class T> struct remove_pointer; (NOT-POSSIBLE UNTIL PSUEDO PTRS ARE IMPLEMENTED)
+  template<class T> struct add_pointer; (NOT-POSSIBLE UNTIL PSUEDO PTRS ARE IMPLEMENTED)
 
   // other transformations
   template<class T> struct type_identity; (DONE)
-  template<class T> struct remove_cvref; (TODO)
+  template<class T> struct remove_cvref; (DONE)
   template<class T> struct decay; (TODO)
   template<bool, class T = void> struct enable_if; (NOT-APPLICABLE)
   template<bool, class T, class F> struct conditional; (DONE)
@@ -166,9 +166,41 @@ struct base_type_forwarder<Trait,matrix<T,N,M> > : Trait<T> {};
 
 #if __HLSL_VERSION // HLSL
 
+
+#define decltype(expr) __decltype(expr)
+
+template<class T>
+struct type_identity 
+{
+    using type = T;
+};
+
+namespace impl
+{
+template<class> struct remove_reference;
+}
+
+template<class T> struct remove_const : type_identity<T> {};
+template<class T> struct remove_const<const T> : type_identity<T> {};
+
+template<class T> struct remove_volatile : type_identity<T> {};
+template<class T> struct remove_volatile<volatile T> : type_identity<T> {};
+
+template<class T> struct remove_cv : type_identity<T> {};
+template<class T> struct remove_cv<const T> : type_identity<T> {};
+template<class T> struct remove_cv<volatile T> : type_identity<T> {};
+template<class T> struct remove_cv<const volatile T> : type_identity<T> {};
+
+template<class T> struct remove_cvref : remove_cv<typename impl::remove_reference<T>::type> {};
+
+template<class T> struct add_const : type_identity<const T> {};
+template<class T> struct add_volatile : type_identity<volatile T> {};
+template<class T> struct add_cv : type_identity<const volatile T> {};
+
+
 template<class T, T val>
 struct integral_constant {
-    static const T value = val;
+    NBL_CONSTEXPR_STATIC_INLINE T value = val;
     using value_type = T;
 };
 
@@ -179,16 +211,10 @@ struct true_type : bool_constant<true> {};
 struct false_type : bool_constant<true> {};
 
 template<bool C, class T, class F>
-struct conditional 
-{ 
-    using type = T;
-};
+struct conditional : type_identity<T> {};
 
 template<class T, class F>
-struct conditional<false, T, F> 
-{
-    using type = F;
-};
+struct conditional<false, T, F>  : type_identity<F> {};
 
 template<bool C, typename T, T A, T B>
 struct conditional_value
@@ -203,8 +229,7 @@ template<class A>
 struct is_same<A,A> : bool_constant<true> {};
 
 template<class T>
-struct is_void : bool_constant<is_same<T, void>::value> {};
-
+struct is_void : bool_constant<is_same<typename remove_cv<T>::type, void>::value> {};
 
 template<class T>
 struct is_bounded_array : bool_constant<false> {};
@@ -225,10 +250,7 @@ namespace impl
 {
 
 template<typename T, T v>
-struct function_info
-{
-    using type = void;
-};
+struct function_info : type_identity<void> {};
 
 template<class T>
 struct is_unsigned : bool_constant<
@@ -267,21 +289,21 @@ struct is_signed : bool_constant<
 }
 
 template<class T> 
-struct is_unsigned : impl::base_type_forwarder<impl::is_unsigned, T> {};
+struct is_unsigned : impl::base_type_forwarder<impl::is_unsigned, typename remove_cv<T>::type> {};
 
 template<class T> 
-struct is_integral : impl::base_type_forwarder<impl::is_integral, T> {};
+struct is_integral : impl::base_type_forwarder<impl::is_integral, typename remove_cv<T>::type> {};
 
 template<class T> 
-struct is_floating_point : impl::base_type_forwarder<impl::is_floating_point, T> {};
+struct is_floating_point : impl::base_type_forwarder<impl::is_floating_point, typename remove_cv<T>::type> {};
 
 template<class T> 
-struct is_signed : impl::base_type_forwarder<impl::is_signed, T> {};
+struct is_signed : impl::base_type_forwarder<impl::is_signed, typename remove_cv<T>::type> {};
 
 template<class T>
 struct is_scalar : bool_constant<
-    impl::is_integral<T>::value || 
-    impl::is_floating_point<T>::value
+    impl::is_integral<typename remove_cv<T>::type>::value || 
+    impl::is_floating_point<typename remove_cv<T>::type>::value
 > {};
 
 template<class T>
@@ -327,12 +349,6 @@ struct is_compound : bool_constant<!is_fundamental<T>::value> {};
 template <class T>
 struct is_aggregate : is_compound<T> {};
 
-template<class T>
-struct type_identity 
-{
-    using type = T;
-};
-
 template<class T>
 struct rank : integral_constant<uint64_t, 0> { };
 
@@ -358,15 +374,106 @@ template<bool B, class T = void>
 struct enable_if {};
 
 template<class T>
-struct enable_if<true, T> 
-{ 
-    using type = T; 
-};
+struct enable_if<true, T> : type_identity<T> {};
 
 // need this crutch because we can't make `#define typeid` work both on expression and types
 template<typename T>
 struct typeid_t;
 
+template<class T>
+struct alignment_of;
+
+
+// reference stuff needed for semantics 
+
+// not for "human consumption"
+// dxc doesnt actually allow variables to be references
+// every reference is treated as having 'restrict' qualifier
+// https://godbolt.org/z/dsj99fY96
+namespace impl
+{
+
+template<class>
+struct make_void { using type = void; };
+
+template<typename,class=void>
+struct is_reference : bool_constant<true> { };
+
+template<typename T>
+struct is_reference<T,typename make_void<T[1]>::type> : bool_constant<false> { };
+
+template<class T>
+struct declval
+{
+    static T member[1];
+    using reference_type = decltype(member[0]);
+};
+
+template<class T>
+struct add_lvalue_reference : 
+    conditional<
+            is_reference<T>::value,
+            T,
+            typename declval<T>::reference_type>
+{
+};
+
+template<typename T>
+T remove_reference_impl(T v)
+{
+    return v;
+}
+
+template<typename T>
+struct remove_reference_helper
+{
+    static T member;
+    using type = decltype(remove_reference_impl(member));
+};
+
+template<typename T>
+struct remove_reference : conditional<is_reference<T>::value, typename remove_reference_helper<T>::type, T> {};
+
+}
+
+template<class T> struct remove_extent : type_identity<T> {};
+template<class T, uint32_t I> struct remove_extent<T[I]> : type_identity<T> {};
+template<class T> struct remove_extent<T[]> : type_identity<T> {};
+
+template <class T>
+struct remove_all_extents : type_identity<T> {};
+
+template <class T, uint32_t I>
+struct remove_all_extents<T[I]> : type_identity<typename remove_all_extents<T>::type> {};
+
+template <class T>
+struct remove_all_extents<T[]> : type_identity<typename remove_all_extents<T>::type> {};
+
+namespace impl
+{
+
+template<uint32_t sz> struct int_type :
+    conditional<8==sz, int64_t, typename conditional<4==sz, int32_t, int16_t>::type>{};
+
+template<uint32_t sz> struct uint_type : 
+    type_identity<unsigned typename int_type<sz>::type> {};
+}
+
+template<class T>
+struct make_signed : impl::int_type<sizeof(T)>
+{
+    _Static_assert(is_integral<T>::value && !is_same<typename remove_cv<T>::type, bool>::value,
+        "make_signed<T> requires that T shall be a (possibly cv-qualified) "
+        "integral type or enumeration but not a bool type.");
+};
+
+template<class T>
+struct make_unsigned : impl::uint_type<sizeof(T)>
+{
+    _Static_assert(is_integral<T>::value && !is_same<typename remove_cv<T>::type, bool>::value, 
+        "make_unsigned<T> requires that T shall be a (possibly cv-qualified) "
+        "integral type or enumeration but not a bool type.");
+};
 
 #else // C++
 
@@ -457,6 +564,25 @@ struct typeid_t : std::integral_constant<uint64_t,typeid(T).hash_code()> {};
 template<bool B, class T = void>
 using enable_if = std::enable_if<B, T>;
 
+template<class T>
+using alignment_of = std::alignment_of<T>;
+
+template<class T> using remove_const = std::remove_const<T>;
+template<class T> using remove_volatile = std::remove_volatile<T>;
+template<class T> using remove_cv = std::remove_cv<T>;
+template<class T> using add_const = std::add_const<T>;
+template<class T> using add_volatile = std::add_volatile<T>;
+template<class T> using add_cv = std::add_cv<T>;
+
+template<class T> using remove_extent = std::remove_extent<T>;
+template<class T> using remove_all_extents = std::remove_all_extents<T>;
+
+template<class T>
+using make_signed = std::make_signed<T>;
+
+template<class T>
+using make_unsigned = std::make_unsigned<T>;
+
 #endif
 
 // Overlapping definitions
@@ -494,16 +620,22 @@ struct scalar_type<matrix<T,N,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 decltype(expr) __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) (typeid_t<decltype(expr)>::value)
+#define typeid(expr) (typeid_t<__decltype(expr)>::value)
+
+#define NBL_REGISTER_OBJ_TYPE(T, A) namespace nbl { namespace hlsl { \
+    template<> struct typeid_t<T> : integral_constant<uint32_t,__COUNTER__> {}; \ 
+    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> {}; \
+}}
 
-#define NBL_REGISTER_OBJ_TYPE(T) namespace nbl { namespace hlsl { template<> struct typeid_t<T> : integral_constant<uint32_t,__COUNTER__> {}; }}
 // TODO: find out how to do it such that we don't get duplicate definition if we use two function identifiers with same signature
 #define NBL_REGISTER_FUN_TYPE(fn) namespace nbl { namespace hlsl { template<> struct typeid_t<__decltype(fn)> : integral_constant<uint32_t,__COUNTER__> {}; }}
 // TODO: ideally we'd like to call NBL_REGISTER_FUN_TYPE under the hood, but we can't right now. Also we have a bigger problem, the passing of the function identifier as the second template parameter doesn't work :(
@@ -517,18 +649,17 @@ struct function_info<__decltype(fn),fn> \
 }}}}
 */
 
-
 // builtins
 
 #define NBL_REGISTER_MATRICES(T) \
-    NBL_REGISTER_OBJ_TYPE(T) \
-    NBL_REGISTER_OBJ_TYPE(T ## x4) \
-    NBL_REGISTER_OBJ_TYPE(T ## x3) \
-    NBL_REGISTER_OBJ_TYPE(T ## x2) \
+    NBL_REGISTER_OBJ_TYPE(T, sizeof(T)) \
+    NBL_REGISTER_OBJ_TYPE(T ## x4, sizeof(T)) \
+    NBL_REGISTER_OBJ_TYPE(T ## x3, sizeof(T)) \
+    NBL_REGISTER_OBJ_TYPE(T ## x2, sizeof(T)) \
 
 #define NBL_REGISTER_TYPES_FOR_SCALAR(T) \
-    NBL_REGISTER_OBJ_TYPE(T) \
-    NBL_REGISTER_OBJ_TYPE(T ## 1) \
+    NBL_REGISTER_OBJ_TYPE(T, sizeof(T)) \
+    NBL_REGISTER_OBJ_TYPE(T ## 1, sizeof(T)) \
     NBL_REGISTER_MATRICES(T ## 2) \
     NBL_REGISTER_MATRICES(T ## 3) \
     NBL_REGISTER_MATRICES(T ## 4)