Merge pull request #909 from Devsh-Graphics-Programming/ef64_length

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,59 @@ namespace hlsl
             return bit_cast<this_t>(data ^ ieee754::traits<float64_t>::signMask);
         }
 
+        /**
+        * @brief Computes sqare root estimation.
+        * 
+        * Can be less precise when FastMath is disabled.
+        * sqrt(inf) = inf
+        * sqrt(-0) = -0
+        * sqrt(NaN) = NaN
+        */
+        static this_t sqrt(this_t number)
+        {
+            bool isZero = !(number.data & 0x7FFFFFFFFFFFFFFFull);
+            if (isZero)
+                return number;
+
+            static const uint64_t MaxFloat64AsUint64 = 0x7FEFFFFFFFFFFFFFull;
+            if (number.data > MaxFloat64AsUint64)
+            {
+                bool isInf = cpp_compat_intrinsics_impl::isinf_uint_impl(number.data);
+                if (isInf)
+                    return number;
+
+                // when (number.data > MaxFloat64AsUint64) and is not infinity, we can be sure that number is either NaN or negative
+                return bit_cast<this_t>(ieee754::traits<this_t>::quietNaN);
+            }
+
+            const float f32InverseSquareRoot = nbl::hlsl::rsqrt(_static_cast<float>(number));
+
+            // find sqrt approximation using the Newton-Raphson method
+            this_t inverseSquareRoot = _static_cast<this_t>(f32InverseSquareRoot);
+            const int Iterations = 5;
+            static const this_t Half = this_t::create(0.5f);
+            static const this_t ThreeHalfs = this_t::create(1.5f);
+            const this_t x2 = number * Half;
+            [[unroll]]
+            for (int i = 0; i < Iterations; ++i)
+            {
+                inverseSquareRoot = inverseSquareRoot * (ThreeHalfs - (x2 * inverseSquareRoot * inverseSquareRoot));
+            }
+
+            if (FastMath)
+            {
+                return this_t::create(1.0f) / inverseSquareRoot;
+            }
+            else
+            {
+                // 2 Newton-Raphson iterations to increase precision
+                this_t squareRoot = this_t::create(1.0f) / inverseSquareRoot;
+                squareRoot = Half * (squareRoot + number / squareRoot);
+                squareRoot = Half * (squareRoot + number / squareRoot);
+                return squareRoot;
+            }
+        }
+
         NBL_CONSTEXPR_STATIC bool isFastMathSupported = FastMath;
     };