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/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

include/nbl/builtin/hlsl/sampling/projected_spherical_triangle.hlsl

@@ -0,0 +1,97 @@
+// 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_PROJECTED_SPHERICAL_TRIANGLE_INCLUDED_
+#define _NBL_BUILTIN_HLSL_SAMPLING_PROJECTED_SPHERICAL_TRIANGLE_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include <nbl/builtin/hlsl/limits.hlsl>
+#include <nbl/builtin/hlsl/math/functions.hlsl>
+#include <nbl/builtin/hlsl/sampling/bilinear.hlsl>
+#include <nbl/builtin/hlsl/sampling/spherical_triangle.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace sampling
+{
+
+template<typename T>
+struct ProjectedSphericalTriangle
+{
+    using scalar_type = T;
+    using vector2_type = vector<T, 2>;
+    using vector3_type = vector<T, 3>;
+    using vector4_type = vector<T, 4>;
+
+    static ProjectedSphericalTriangle<T> create(NBL_CONST_REF_ARG(shapes::SphericalTriangle<T>) tri)
+    {
+        ProjectedSphericalTriangle<T> retval;
+        retval.tri = tri;
+        return retval;
+    }
+
+    vector4_type computeBilinearPatch(NBL_CONST_REF_ARG(vector3_type) receiverNormal, bool isBSDF)
+    {
+        const scalar_type minimumProjSolidAngle = 0.0;
+
+        matrix<T, 3, 3> m = matrix<T, 3, 3>(tri.vertex0, tri.vertex1, tri.vertex2);
+        const vector3_type bxdfPdfAtVertex = math::conditionalAbsOrMax(isBSDF, nbl::hlsl::mul(m, receiverNormal), (vector3_type)minimumProjSolidAngle);
+
+        return bxdfPdfAtVertex.yyxz;
+    }
+
+    vector3_type generate(NBL_REF_ARG(scalar_type) rcpPdf, scalar_type solidAngle, NBL_CONST_REF_ARG(vector3_type) cos_vertices, NBL_CONST_REF_ARG(vector3_type) sin_vertices, scalar_type cos_a, scalar_type cos_c, scalar_type csc_b, scalar_type csc_c, NBL_CONST_REF_ARG(vector3_type) receiverNormal, bool isBSDF, NBL_CONST_REF_ARG(vector2_type) _u)
+    {
+        vector2_type u;
+        // pre-warp according to proj solid angle approximation
+        vector4_type patch = computeBilinearPatch(receiverNormal, isBSDF);
+        Bilinear<scalar_type> bilinear = Bilinear<scalar_type>::create(patch);
+        u = bilinear.generate(rcpPdf, u);
+
+        // now warp the points onto a spherical triangle
+        const vector3_type L = sphtri.generate(solidAngle, cos_vertices, sin_vertices, cos_a, cos_c, csc_b, csc_c, u);
+        rcpPdf *= solidAngle;
+
+        return L;
+    }
+
+    vector3_type generate(NBL_REF_ARG(scalar_type) rcpPdf, NBL_CONST_REF_ARG(vector3_type) receiverNormal, bool isBSDF, NBL_CONST_REF_ARG(vector2_type) u)
+    {
+        scalar_type cos_a, cos_c, csc_b, csc_c;
+        vector3_type cos_vertices, sin_vertices;
+        const scalar_type solidAngle = tri.solidAngleOfTriangle(cos_vertices, sin_vertices, cos_a, cos_c, csc_b, csc_c);
+        return generate(rcpPdf, solidAngle, cos_vertices, sin_vertices, cos_a, cos_c, csc_b, csc_c, receiverNormal, isBSDF, u);
+    }
+
+    scalar_type pdf(scalar_type solidAngle, NBL_CONST_REF_ARG(vector3_type) cos_vertices, NBL_CONST_REF_ARG(vector3_type) sin_vertices, scalar_type cos_a, scalar_type cos_c, scalar_type csc_b, scalar_type csc_c, NBL_CONST_REF_ARG(vector3_type) receiverNormal, bool receiverWasBSDF, NBL_CONST_REF_ARG(vector3_type) L)
+    {
+        scalar_type pdf;
+        const vector2_type u = sphtri.generateInverse(pdf, solidAngle, cos_vertices, sin_vertices, cos_a, cos_c, csc_b, csc_c, L);
+
+        vector4_type patch = computeBilinearPatch(receiverNormal, receiverWasBSDF);
+        Bilinear<scalar_type> bilinear = Bilinear<scalar_type>::create(patch);
+        return pdf * bilinear.pdf(u);
+    }
+
+    scalar_type pdf(NBL_CONST_REF_ARG(vector3_type) receiverNormal, bool receiverWasBSDF, NBL_CONST_REF_ARG(vector3_type) L)
+    {
+        scalar_type pdf;
+        const vector2_type u = sphtri.generateInverse(pdf, L);
+
+        vector4_type patch = computeBilinearPatch(receiverNormal, receiverWasBSDF);
+        Bilinear<scalar_type> bilinear = Bilinear<scalar_type>::create(patch);
+        return pdf * bilinear.pdf(u);
+    }
+
+    shapes::SphericalTriangle<T> tri;
+    sampling::SphericalTriangle<T> sphtri;
+};
+
+}
+}
+}
+
+#endif