Added length function for emulated vectors

Author: Przemog1

examples_tests

@@ -631,6 +631,19 @@ struct bitReverseAs_helper<T NBL_PARTIAL_REQ_BOT(concepts::UnsignedIntegralScala
 	}
 };
 
+#define VECTORIAL_SPECIALIZATION_CONCEPT concepts::Vectorial<T> && !is_vector_v<T>
+template<typename T>
+NBL_PARTIAL_REQ_TOP(VECTORIAL_SPECIALIZATION_CONCEPT)
+struct length_helper<T NBL_PARTIAL_REQ_BOT(VECTORIAL_SPECIALIZATION_CONCEPT) >
+{
+	using scalar_t = typename vector_traits<T>::scalar_type;
+	static inline scalar_t __call(NBL_CONST_REF_ARG(T) vec)
+	{
+		return scalar_t::sqrt(dot_helper<T>::__call(vec, vec));
+	}
+};
+#undef VECTORIAL_SPECIALIZATION_CONCEPT
+
 #ifdef __HLSL_VERSION
 // SPIR-V already defines specializations for builtin vector types
 #define VECTOR_SPECIALIZATION_CONCEPT concepts::Vectorial<T> && !is_vector_v<T>

include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl

@@ -395,6 +395,46 @@ namespace hlsl
             return bit_cast<this_t>(data ^ ieee754::traits<float64_t>::signMask);
         }
 
+        static this_t sqrt(this_t number)
+        {
+            // so it doesn't return NaN for -0.0
+            bool isZero = !(number.data & 0x7FFFFFFFFFFFFFFFull);
+            if (isZero)
+                return number;
+
+            bool isNegative = (number.data >> 63) > 0;
+            if (isNegative)
+                return bit_cast<this_t>(ieee754::traits<this_t>::quietNaN);
+
+            if(!FastMath)
+            {
+                bool isInf = cpp_compat_intrinsics_impl::isinf_uint_impl(number.data);
+                if (isInf)
+                    return number;
+            }
+
+            // find square root initial guess using the fast inverse square root algorithm
+            nbl::hlsl::emulated_float64_t<true, true> invSquareRoot = number;
+            {
+                int64_t i = 0x5fe6eb50c7b537a9ull - (number.data >> 1);
+                invSquareRoot.data = i;
+
+                nbl::hlsl::emulated_float64_t<true, true> threeHalfs = emulated_float64_t<true, true>::create(1.5);
+                nbl::hlsl::emulated_float64_t<true, true> x2 = number * emulated_float64_t<true, true>::create(0.5);
+                invSquareRoot = invSquareRoot * (threeHalfs - (x2 * invSquareRoot * invSquareRoot));
+            }
+
+            // find sqrt approximation using the Newton-Raphson method
+            nbl::hlsl::emulated_float64_t<true, true> squareRoot = nbl::hlsl::emulated_float64_t<true, true>::create(1.0) / invSquareRoot;
+            const int Iterations = 5;
+            for (int i = 0; i < Iterations; ++i)
+            {
+                squareRoot = nbl::hlsl::emulated_float64_t<true, true>::create(0.5) * (squareRoot + number / squareRoot);
+            }
+
+            return squareRoot;
+        }
+
         NBL_CONSTEXPR_STATIC bool isFastMathSupported = FastMath;
     };