New morton class with arithmetic and comparison operators

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

@@ -8,6 +8,7 @@
 #include <type_traits>
 
 #define ARROW ->
+#define NBL_DEREF_THIS (*this)
 #define NBL_CONSTEXPR constexpr // TODO: rename to NBL_CONSTEXPR_VAR
 #define NBL_CONSTEXPR_FUNC constexpr
 #define NBL_CONSTEXPR_STATIC constexpr static
@@ -44,6 +45,7 @@ namespace nbl::hlsl
 #else
 
 #define ARROW .arrow().
+#define NBL_DEREF_THIS this
 #define NBL_CONSTEXPR const static // TODO: rename to NBL_CONSTEXPR_VAR
 #define NBL_CONSTEXPR_FUNC
 #define NBL_CONSTEXPR_STATIC const static

include/nbl/builtin/hlsl/cpp_compat/truncate.hlsl

@@ -9,6 +9,12 @@ namespace nbl
 namespace hlsl
 {
 
+namespace concepts
+{
+  template<typename To, typename From>
+  NBL_BOOL_CONCEPT can_truncate_vector = concepts::Vectorial<To> && concepts::Vectorial<From> && concepts::same_as<typename vector_traits<To>::scalar_type, typename vector_traits<From>::scalar_type > && vector_traits<To>::Dimension <= vector_traits<From>::Dimension;
+}
+
 namespace impl
 {
 
@@ -21,44 +27,20 @@ struct Truncate
     }
 };
 
-template<typename Scalar, int32_t N> NBL_PARTIAL_REQ_TOP(concepts::Scalar<Scalar>)
-struct Truncate<vector<Scalar, 1>, vector<Scalar, N> NBL_PARTIAL_REQ_BOT(concepts::Scalar<Scalar>) >
+template<typename To, typename From> NBL_PARTIAL_REQ_TOP(concepts::can_truncate_vector<To, From>) 
+struct Truncate<To, From NBL_PARTIAL_REQ_BOT(concepts::can_truncate_vector<To, From>) >
 {
-    NBL_CONSTEXPR_FUNC vector<Scalar, 1> operator()(const vector<Scalar, N> v)
+    NBL_CONSTEXPR_FUNC To operator()(const From v)
     {
-        vector<Scalar, 1> truncated = { v[0] };
-        return truncated;
+        array_get<From, typename vector_traits<From>::scalar_type> getter;
+        array_set<To, typename vector_traits<To>::scalar_type> setter;
+        To output;
+        [[unroll]]
+        for (int i = 0; i < vector_traits<To>::Dimension; ++i)
+            setter(output, i, getter(v, i));
+        return output;
     }
-};
-
-template<typename Scalar, int32_t N> NBL_PARTIAL_REQ_TOP(concepts::Scalar<Scalar> && N >= 2)
-struct Truncate<vector<Scalar, 2>, vector<Scalar, N> NBL_PARTIAL_REQ_BOT(concepts::Scalar<Scalar> && N >= 2) >
-{
-    NBL_CONSTEXPR_FUNC vector<Scalar, 2> operator()(const vector<Scalar, N> v)
-    {
-        vector<Scalar, 2> truncated = { v[0], v[1]};
-        return truncated;
-    }
-};
 
-template<typename Scalar, int32_t N> NBL_PARTIAL_REQ_TOP(concepts::Scalar<Scalar>&& N >= 3)
-struct Truncate<vector<Scalar, 3>, vector<Scalar, N> NBL_PARTIAL_REQ_BOT(concepts::Scalar<Scalar>&& N >= 3) >
-{
-    NBL_CONSTEXPR_FUNC vector<Scalar, 3> operator()(const vector<Scalar, N> v)
-    {
-        vector<Scalar, 3> truncated = { v[0], v[1], v[2] };
-        return truncated;
-    }
-};
-
-template<typename Scalar, int32_t N> NBL_PARTIAL_REQ_TOP(concepts::Scalar<Scalar>&& N >= 4)
-struct Truncate<vector<Scalar, 4>, vector<Scalar, N> NBL_PARTIAL_REQ_BOT(concepts::Scalar<Scalar>&& N >= 4) >
-{
-    NBL_CONSTEXPR_FUNC vector<Scalar, 4> operator()(const vector<Scalar, N> v)
-    {
-        vector<Scalar, 4> truncated = { v[0], v[1], v[2], v[3] };
-        return truncated;
-    }
 };
 
 } //namespace impl

include/nbl/builtin/hlsl/emulated/int64_common_member_inc.hlsl

@@ -0,0 +1,155 @@
+
+storage_t data;
+
+/**
+* @brief Creates an `emulated_int64` from a vector of two `uint32_t`s representing its bitpattern
+*
+* @param [in] _data Vector of `uint32_t` encoding the `uint64_t/int64_t` being emulated. Stored as little endian (first component are the lower 32 bits)
+*/
+NBL_CONSTEXPR_STATIC this_t create(NBL_CONST_REF_ARG(storage_t) _data)
+{
+	this_t retVal;
+	retVal.data = _data;
+	return retVal;
+}
+
+/**
+* @brief Creates an `emulated_int64` from two `uint32_t`s representing its bitpattern
+*
+* @param [in] lo Lowest 32 bits of the `uint64_t/int64_t` being emulated
+* @param [in] hi Highest 32 bits of the `uint64_t/int64_t` being emulated
+*/
+NBL_CONSTEXPR_STATIC this_t create(NBL_CONST_REF_ARG(uint32_t) lo, NBL_CONST_REF_ARG(uint32_t) hi)
+{
+	return create(storage_t(lo, hi));
+}
+
+// ------------------------------------------------------- CONVERSION OPERATORS---------------------------------------------------------------
+// GLM requires these for vector casts
+
+#ifndef __HLSL_VERSION
+
+template<concepts::IntegralScalar I>
+constexpr explicit operator I() const noexcept;
+
+#endif
+
+// ------------------------------------------------------- INTERNAL GETTERS -------------------------------------------------
+
+NBL_CONSTEXPR_FUNC uint32_t __getLSB() NBL_CONST_MEMBER_FUNC
+{
+	return data.x;
+}
+
+NBL_CONSTEXPR_FUNC uint32_t __getMSB() NBL_CONST_MEMBER_FUNC
+{
+	return data.y;
+}
+
+// ------------------------------------------------------- BITWISE OPERATORS -------------------------------------------------
+
+NBL_CONSTEXPR_FUNC this_t operator&(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	this_t retVal = create(data & rhs.data);
+	return retVal;
+}
+
+NBL_CONSTEXPR_FUNC this_t operator|(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	this_t retVal = create(data | rhs.data);
+	return retVal;
+}
+
+NBL_CONSTEXPR_FUNC this_t operator^(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	this_t retVal = create(data ^ rhs.data);
+	return retVal;
+}
+
+NBL_CONSTEXPR_FUNC this_t operator~() NBL_CONST_MEMBER_FUNC
+{
+	this_t retVal = create(~data);
+	return retVal;
+}
+
+// Only valid in CPP
+#ifndef __HLSL_VERSION
+constexpr inline this_t operator>>(uint32_t bits) const;
+
+constexpr inline this_t operator<<(uint32_t bits) const;
+
+constexpr inline this_t& operator&=(const this_t& val)
+{
+  data &= val.data;
+  return *this;
+}
+
+constexpr inline this_t& operator|=(const this_t& val)
+{
+  data |= val.data;
+  return *this;
+}
+
+constexpr inline this_t& operator^=(const this_t& val)
+{
+  data ^= val.data;
+  return *this;
+}
+
+#endif
+
+// ------------------------------------------------------- ARITHMETIC OPERATORS -------------------------------------------------
+
+NBL_CONSTEXPR_FUNC this_t operator+(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	const spirv::AddCarryOutput<uint32_t> lowerAddResult = addCarry(__getLSB(), rhs.__getLSB());
+	return create(lowerAddResult.result, __getMSB() + rhs.__getMSB() + lowerAddResult.carry);
+}
+
+NBL_CONSTEXPR_FUNC this_t operator-(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	const spirv::SubBorrowOutput<uint32_t> lowerSubResult = subBorrow(__getLSB(), rhs.__getLSB());
+	return create(lowerSubResult.result, __getMSB() - rhs.__getMSB() - lowerSubResult.borrow);
+}
+
+// ------------------------------------------------------- COMPARISON OPERATORS -------------------------------------------------
+NBL_CONSTEXPR_FUNC bool operator==(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	equal_to<storage_t> equals;
+	return all(equals(data, rhs.data));
+}
+
+NBL_CONSTEXPR_FUNC bool operator!=(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	not_equal_to<storage_t> notEquals;
+	return any(notEquals(data, rhs.data));
+}
+
+NBL_CONSTEXPR_FUNC bool operator<(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	// Either the topmost bits, when interpreted with correct sign, are less than those of `rhs`, or they're equal and the lower bits are less
+	// (lower bits are always positive in both unsigned and 2's complement so comparison can happen as-is)
+	const bool MSBEqual = __getMSB() == rhs.__getMSB();
+	const bool MSB = Signed ? (bit_cast<int32_t>(__getMSB()) < bit_cast<int32_t>(rhs.__getMSB())) : (__getMSB() < rhs.__getMSB());
+	const bool LSB = __getLSB() < rhs.__getLSB();
+	return MSBEqual ? LSB : MSB;
+}
+
+NBL_CONSTEXPR_FUNC bool operator>(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	// Same reasoning as above
+	const bool MSBEqual = __getMSB() == rhs.__getMSB();
+	const bool MSB = Signed ? (bit_cast<int32_t>(__getMSB()) > bit_cast<int32_t>(rhs.__getMSB())) : (__getMSB() > rhs.__getMSB());
+	const bool LSB = __getLSB() > rhs.__getLSB();
+	return MSBEqual ? LSB : MSB;
+}
+
+NBL_CONSTEXPR_FUNC bool operator<=(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	return !operator>(rhs);
+}
+
+NBL_CONSTEXPR_FUNC bool operator>=(NBL_CONST_REF_ARG(this_t) rhs) NBL_CONST_MEMBER_FUNC
+{
+	return !operator<(rhs);
+}