Hlsl path tracer example

include/nbl/builtin/glsl/utils/morton.glsl

@@ -22,6 +22,18 @@ uint nbl_glsl_morton_decode2d8bComponent(in uint x)
     return x;
 }
 
+uint nbl_glsl_morton_decode2d32bComponent(in uint x) 
+{
+    x &= 0x55555555u;
+    x = (x ^ (x >>  1u)) & 0x33333333u;
+    x = (x ^ (x >>  2u)) & 0x0f0f0f0fu;
+    x = (x ^ (x >>  4u)) & 0x00ff00ffu;
+    x = (x ^ (x >>  8u)) & 0x0000ffffu;
+    x = (x ^ (x >>  16u));
+    return x;
+}
+
+
 uvec2 nbl_glsl_morton_decode2d4b(in uint x)
 {
     return uvec2(nbl_glsl_morton_decode2d4bComponent(x), nbl_glsl_morton_decode2d4bComponent(x >> 1u));
@@ -32,4 +44,9 @@ uvec2 nbl_glsl_morton_decode2d8b(in uint x)
     return uvec2(nbl_glsl_morton_decode2d8bComponent(x), nbl_glsl_morton_decode2d8bComponent(x >> 1u));
 }
 
+uvec2 nbl_glsl_morton_decode2d32b(in uint x)
+{
+    return uvec2(nbl_glsl_morton_decode2d32bComponent(x), nbl_glsl_morton_decode2d32bComponent(x >> 1u));
+}
+
 #endif

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

@@ -103,7 +103,8 @@ template<typename T NBL_STRUCT_CONSTRAINABLE>
 struct nMax_helper;
 template<typename T NBL_STRUCT_CONSTRAINABLE>
 struct nClamp_helper;
-
+template<typename T NBL_STRUCT_CONSTRAINABLE>
+struct fma_helper;
 
 #ifdef __HLSL_VERSION // HLSL only specializations
 
@@ -134,6 +135,7 @@ template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(find_lsb_helper, findIL
 #undef FIND_MSB_LSB_RETURN_TYPE
 
 template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(bitReverse_helper, bitReverse, (T), (T), T)
+template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(dot_helper, dot, (T), (T)(T), typename vector_traits<T>::scalar_type)
 template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(transpose_helper, transpose, (T), (T), T)
 template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(length_helper, length, (T), (T), typename vector_traits<T>::scalar_type)
 template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(normalize_helper, normalize, (T), (T), T)
@@ -162,6 +164,7 @@ template<typename T, typename U> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(refract_hel
 template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(nMax_helper, nMax, (T), (T)(T), T)
 template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(nMin_helper, nMin, (T), (T)(T), T)
 template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(nClamp_helper, nClamp, (T), (T)(T), T)
+template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(fma_helper, fma, (T), (T)(T)(T), T)
 
 #define BITCOUNT_HELPER_RETRUN_TYPE conditional_t<is_vector_v<T>, vector<int32_t, vector_traits<T>::Dimension>, int32_t>
 template<typename T> AUTO_SPECIALIZE_TRIVIAL_CASE_HELPER(bitCount_helper, bitCount, (T), (T), BITCOUNT_HELPER_RETRUN_TYPE)
@@ -599,6 +602,16 @@ struct nClamp_helper<T>
 	}
 };
 
+template<typename FloatingPoint>
+requires concepts::FloatingPointScalar<FloatingPoint>
+struct fma_helper<FloatingPoint>
+{
+	static FloatingPoint __call(NBL_CONST_REF_ARG(FloatingPoint) x, NBL_CONST_REF_ARG(FloatingPoint) y, NBL_CONST_REF_ARG(FloatingPoint) z)
+	{
+		return std::fma(x, y, z);
+	}
+};
+
 #endif // C++ only specializations
 
 // C++ and HLSL specializations
@@ -613,25 +626,6 @@ struct bitReverseAs_helper<T NBL_PARTIAL_REQ_BOT(concepts::UnsignedIntegralScala
 	}
 };
 
-template<typename Vectorial>
-NBL_PARTIAL_REQ_TOP(concepts::Vectorial<Vectorial>)
-struct dot_helper<Vectorial NBL_PARTIAL_REQ_BOT(concepts::Vectorial<Vectorial>) >
-{
-	using scalar_type = typename vector_traits<Vectorial>::scalar_type;
-
-	static inline scalar_type __call(NBL_CONST_REF_ARG(Vectorial) lhs, NBL_CONST_REF_ARG(Vectorial) rhs)
-	{
-		static const uint32_t ArrayDim = vector_traits<Vectorial>::Dimension;
-		static array_get<Vectorial, scalar_type> getter;
-
-		scalar_type retval = getter(lhs, 0) * getter(rhs, 0);
-		for (uint32_t i = 1; i < ArrayDim; ++i)
-			retval = retval + getter(lhs, i) * getter(rhs, i);
-
-		return retval;
-	}
-};
-
 #ifdef __HLSL_VERSION
 // SPIR-V already defines specializations for builtin vector types
 #define VECTOR_SPECIALIZATION_CONCEPT concepts::Vectorial<T> && !is_vector_v<T>
@@ -888,6 +882,52 @@ struct mix_helper<T, U NBL_PARTIAL_REQ_BOT(concepts::Vectorial<T> && concepts::B
 	}
 };
 
+#ifdef __HLSL_VERSION
+#define DOT_HELPER_REQUIREMENT (concepts::Vectorial<Vectorial> && !is_vector_v<Vectorial>)
+#else
+#define DOT_HELPER_REQUIREMENT concepts::Vectorial<Vectorial>
+#endif
+
+template<typename Vectorial>
+NBL_PARTIAL_REQ_TOP(DOT_HELPER_REQUIREMENT)
+struct dot_helper<Vectorial NBL_PARTIAL_REQ_BOT(DOT_HELPER_REQUIREMENT) >
+{
+	using scalar_type = typename vector_traits<Vectorial>::scalar_type;
+
+	static inline scalar_type __call(NBL_CONST_REF_ARG(Vectorial) lhs, NBL_CONST_REF_ARG(Vectorial) rhs)
+	{
+		static const uint32_t ArrayDim = vector_traits<Vectorial>::Dimension;
+		static array_get<Vectorial, scalar_type> getter;
+
+		scalar_type retval = getter(lhs, 0) * getter(rhs, 0);
+		for (uint32_t i = 1; i < ArrayDim; ++i)
+			retval = retval + getter(lhs, i) * getter(rhs, i);
+
+		return retval;
+	}
+};
+
+#undef DOT_HELPER_REQUIREMENT
+
+template<typename T>
+NBL_PARTIAL_REQ_TOP(VECTOR_SPECIALIZATION_CONCEPT)
+struct fma_helper<T NBL_PARTIAL_REQ_BOT(VECTOR_SPECIALIZATION_CONCEPT) >
+{
+	using return_t = T;
+	static return_t __call(NBL_CONST_REF_ARG(T) x, NBL_CONST_REF_ARG(T) y, NBL_CONST_REF_ARG(T) z)
+	{
+		using traits = hlsl::vector_traits<T>;
+		array_get<T, typename traits::scalar_type> getter;
+		array_set<T, typename traits::scalar_type> setter;
+
+		return_t output;
+		for (uint32_t i = 0; i < traits::Dimension; ++i)
+			setter(output, i, fma_helper<typename traits::scalar_type>::__call(getter(x, i), getter(y, i), getter(z, i)));
+
+		return output;
+	}
+};
+
 }
 }
 }

include/nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl

@@ -295,6 +295,12 @@ inline int32_t2 unpackDouble2x32(T val)
 	return NAMESPACE::unpackDouble2x32(val);
 }
 
+template<typename T>
+inline T fma(NBL_CONST_REF_ARG(T) x, NBL_CONST_REF_ARG(T) y, NBL_CONST_REF_ARG(T) z)
+{
+	return cpp_compat_intrinsics_impl::fma_helper<T>::__call(x, y, z);
+}
+
 #undef NAMESPACE
 
 }

include/nbl/builtin/hlsl/limits.hlsl

@@ -146,7 +146,7 @@ struct num_base : type_identity<T>
 
     // (TODO) think about what this means for HLSL
     // identifies floating-point types that can represent the special value "quiet not-a-number" (NaN)
-    NBL_CONSTEXPR_STATIC_INLINE bool has_quiet_NaN = !is_integer; 
+    NBL_CONSTEXPR_STATIC_INLINE bool has_quiet_NaN = !is_integer;
     // 	identifies floating-point types that can represent the special value "signaling not-a-number" (NaN)
     NBL_CONSTEXPR_STATIC_INLINE bool has_signaling_NaN = !is_integer;
     // 	identifies the denormalization style used by the floating-point type

include/nbl/builtin/hlsl/math/functions.hlsl

@@ -122,11 +122,7 @@ void frisvad(NBL_CONST_REF_ARG(T) normal, NBL_REF_ARG(T) tangent, NBL_REF_ARG(T)
 
 bool partitionRandVariable(float leftProb, NBL_REF_ARG(float) xi, NBL_REF_ARG(float) rcpChoiceProb)
 {
-#ifdef __HLSL_VERSION
-    NBL_CONSTEXPR float NEXT_ULP_AFTER_UNITY = asfloat(0x3f800001u);
-#else
-    NBL_CONSTEXPR float32_t NEXT_ULP_AFTER_UNITY = bit_cast<float32_t>(0x3f800001u);
-#endif
+    const float32_t NEXT_ULP_AFTER_UNITY = bit_cast<float32_t>(0x3f800001u);
     const bool pickRight = xi >= leftProb * NEXT_ULP_AFTER_UNITY;
 
     // This is all 100% correct taking into account the above NEXT_ULP_AFTER_UNITY

include/nbl/builtin/hlsl/math/morton.hlsl

@@ -0,0 +1,68 @@
+// Copyright (C) 2018-2023 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
+#ifndef _NBL_BUILTIN_HLSL_MATH_MORTON_INCLUDED_
+#define _NBL_BUILTIN_HLSL_MATH_MORTON_INCLUDED_
+
+#include "nbl/builtin/hlsl/cpp_compat.hlsl"
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace math
+{
+
+namespace impl
+{
+
+template<typename T, uint32_t bitDepth>
+struct MortonComponent;
+
+template<typename T>
+struct MortonComponent<T, 8u>
+{
+    static T decode2d(T x)
+    {
+        x &= 0x55555555u;
+        x = (x ^ (x >>  1u)) & 0x33333333u;
+        x = (x ^ (x >>  2u)) & 0x0f0f0f0fu;
+        x = (x ^ (x >>  4u)) & 0x00ff00ffu;
+        return x;
+    }
+};
+
+template<typename T>
+struct MortonComponent<T, 32u>
+{
+    static T decode2d(T x)
+    {
+        x &= 0x55555555u;
+        x = (x ^ (x >>  1u)) & 0x33333333u;
+        x = (x ^ (x >>  2u)) & 0x0f0f0f0fu;
+        x = (x ^ (x >>  4u)) & 0x00ff00ffu;
+        x = (x ^ (x >>  8u)) & 0x0000ffffu;
+        x = (x ^ (x >>  16u));
+        return x;
+    }
+};
+
+}
+
+template<typename T, uint32_t bitDepth=sizeof(T)*8u>
+struct Morton
+{
+    using vector2_type = vector<T, 2>;
+    using component_type = impl::MortonComponent<T, bitDepth>;
+
+    static vector2_type decode2d(T x)
+    {
+        return vector2_type(component_type::decode2d(x), component_type::decode2d(x >> 1u));
+    }
+};
+
+}
+}
+}
+
+#endif

include/nbl/builtin/hlsl/sampling/bilinear.hlsl

@@ -0,0 +1,62 @@
+// Copyright (C) 2018-2023 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
+
+#ifndef _NBL_BUILTIN_HLSL_SAMPLING_BILINEAR_INCLUDED_
+#define _NBL_BUILTIN_HLSL_SAMPLING_BILINEAR_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include <nbl/builtin/hlsl/limits.hlsl>
+#include <nbl/builtin/hlsl/sampling/linear.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace sampling
+{
+
+template<typename T>
+struct Bilinear
+{
+    using scalar_type = T;
+    using vector2_type = vector<T, 2>;
+    using vector3_type = vector<T, 3>;
+    using vector4_type = vector<T, 4>;
+
+    static Bilinear<T> create(NBL_CONST_REF_ARG(vector4_type) bilinearCoeffs)
+    {
+        Bilinear<T> retval;
+        retval.bilinearCoeffs = bilinearCoeffs;
+        return retval;
+    }
+
+    vector2_type generate(NBL_REF_ARG(scalar_type) rcpPdf, NBL_CONST_REF_ARG(vector2_type) _u)
+    {
+        vector2_type u = _u;
+        const vector2_type twiceAreasUnderXCurve = vector2_type(bilinearCoeffs[0] + bilinearCoeffs[1], bilinearCoeffs[2] + bilinearCoeffs[3]);
+        Linear<scalar_type> lineary = Linear<scalar_type>::create(twiceAreasUnderXCurve);
+        u.y = lineary.generate(u.y);
+
+        const vector2_type ySliceEndPoints = vector2_type(nbl::hlsl::mix(bilinearCoeffs[0], bilinearCoeffs[2], u.y), nbl::hlsl::mix(bilinearCoeffs[1], bilinearCoeffs[3], u.y));
+        Linear<scalar_type> linearx = Linear<scalar_type>::create(ySliceEndPoints);
+        u.x = linearx.generate(u.x);
+
+        rcpPdf = (twiceAreasUnderXCurve[0] + twiceAreasUnderXCurve[1]) / (4.0 * nbl::hlsl::mix(ySliceEndPoints[0], ySliceEndPoints[1], u.x));
+
+        return u;
+    }
+
+    scalar_type pdf(NBL_CONST_REF_ARG(vector2_type) u)
+    {
+        return 4.0 * nbl::hlsl::mix(nbl::hlsl::mix(bilinearCoeffs[0], bilinearCoeffs[1], u.x), nbl::hlsl::mix(bilinearCoeffs[2], bilinearCoeffs[3], u.x), u.y) / (bilinearCoeffs[0] + bilinearCoeffs[1] + bilinearCoeffs[2] + bilinearCoeffs[3]);
+    }
+
+    vector4_type bilinearCoeffs;
+};
+
+}
+}
+}
+
+#endif

include/nbl/builtin/hlsl/sampling/box_muller_transform.hlsl

@@ -0,0 +1,27 @@
+// Copyright (C) 2018-2023 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
+
+#ifndef _NBL_BUILTIN_HLSL_BOX_MULLER_TRANSFORM_INCLUDED_
+#define _NBL_BUILTIN_HLSL_BOX_MULLER_TRANSFORM_INCLUDED_
+
+#include "nbl/builtin/hlsl/math/functions.hlsl"
+#include "nbl/builtin/hlsl/numbers.hlsl"
+
+namespace nbl
+{
+namespace hlsl
+{
+
+template<typename T>
+vector<T,2> boxMullerTransform(vector<T,2> xi, T stddev)
+{
+    T sinPhi, cosPhi;
+    math::sincos<T>(2.0 * numbers::pi<float> * xi.y - numbers::pi<float>, sinPhi, cosPhi);
+    return vector<T,2>(cosPhi, sinPhi) * nbl::hlsl::sqrt(-2.0 * nbl::hlsl::log(xi.x)) * stddev;
+}
+
+}
+}
+
+#endif

include/nbl/builtin/hlsl/sampling/linear.hlsl

@@ -0,0 +1,45 @@
+// Copyright (C) 2018-2023 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
+
+#ifndef _NBL_BUILTIN_HLSL_SAMPLING_LINEAR_INCLUDED_
+#define _NBL_BUILTIN_HLSL_SAMPLING_LINEAR_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include <nbl/builtin/hlsl/limits.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace sampling
+{
+
+template<typename T>
+struct Linear
+{
+    using scalar_type = T;
+    using vector2_type = vector<T, 2>;
+
+    static Linear<T> create(NBL_CONST_REF_ARG(vector2_type) linearCoeffs)
+    {
+        Linear<T> retval;
+        retval.linearCoeffs = linearCoeffs;
+        return retval;
+    }
+
+    scalar_type generate(scalar_type u)
+    {
+        const scalar_type rcpDiff = 1.0 / (linearCoeffs[0] - linearCoeffs[1]);
+        const vector2_type squaredCoeffs = linearCoeffs * linearCoeffs;
+        return nbl::hlsl::abs(rcpDiff) < numeric_limits<scalar_type>::max ? (linearCoeffs[0] - nbl::hlsl::sqrt(nbl::hlsl::mix(squaredCoeffs[0], squaredCoeffs[1], u))) * rcpDiff : u;
+    }
+
+    vector2_type linearCoeffs;
+};
+
+}
+}
+}
+
+#endif