Created concepts for samplers, added quotient_and_pdf variants to satisfy the concepts

include/nbl/builtin/hlsl/algorithm.hlsl

@@ -163,21 +163,22 @@ struct lower_to_upper_comparator_transform_t
 
 
 template<class Accessor, class Comparator>
-uint32_t lower_bound(NBL_REF_ARG(Accessor) accessor, const uint32_t begin, const uint32_t end, const typename Accessor::value_type value, const Comparator comp)
+uint32_t lower_bound(NBL_REF_ARG(Accessor) accessor, const uint32_t begin, const uint32_t end, const typename Accessor::value_type value, NBL_REF_ARG(Comparator) comp)
 {
     impl::bound_t<Accessor,Comparator> implementation = impl::bound_t<Accessor,Comparator>::setup(begin,end,value,comp);
-    return implementation(accessor);
+    const uint32_t retval = implementation(accessor);
+    comp = implementation.comp;
+    return retval;
 }
 
 template<class Accessor, class Comparator>
-uint32_t upper_bound(NBL_REF_ARG(Accessor) accessor, const uint32_t begin, const uint32_t end, const typename Accessor::value_type value, const Comparator comp)
+uint32_t upper_bound(NBL_REF_ARG(Accessor) accessor, const uint32_t begin, const uint32_t end, const typename Accessor::value_type value, NBL_REF_ARG(Comparator) comp)
 {
-    //using TransformedComparator = impl::lower_to_upper_comparator_transform_t<Accessor,Comparator>;
-    //TransformedComparator transformedComparator;
-
     impl::lower_to_upper_comparator_transform_t<Accessor,Comparator> transformedComparator;
     transformedComparator.comp = comp;
-    return lower_bound<Accessor,impl::lower_to_upper_comparator_transform_t<Accessor,Comparator> >(accessor,begin,end,value,transformedComparator);
+    const uint32_t retval = lower_bound<Accessor,impl::lower_to_upper_comparator_transform_t<Accessor,Comparator> >(accessor,begin,end,value,transformedComparator);
+    comp = transformedComparator.comp;
+    return retval;
 }
 
 

include/nbl/builtin/hlsl/bxdf/base/lambertian.hlsl

@@ -37,16 +37,18 @@ struct SLambertianBase
     template<typename C=bool_constant<!IsBSDF> >
     enable_if_t<C::value && !IsBSDF, sample_type> generate(NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction, const vector2_type u) NBL_CONST_MEMBER_FUNC
     {
+        typename sampling::ProjectedHemisphere<scalar_type>::cache_type cache;
         ray_dir_info_type L;
-        L.setDirection(sampling::ProjectedHemisphere<scalar_type>::generate(u));
+        L.setDirection(sampling::ProjectedHemisphere<scalar_type>::generate(u, cache));
         return sample_type::createFromTangentSpace(L, interaction.getFromTangentSpace());
     }
     template<typename C=bool_constant<IsBSDF> >
     enable_if_t<C::value && IsBSDF, sample_type> generate(NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction, const vector3_type u) NBL_CONST_MEMBER_FUNC
     {
+        typename sampling::ProjectedSphere<scalar_type>::cache_type cache;
         vector3_type _u = u;
         ray_dir_info_type L;
-        L.setDirection(sampling::ProjectedSphere<scalar_type>::generate(_u));
+        L.setDirection(sampling::ProjectedSphere<scalar_type>::generate(_u, cache));
         return sample_type::createFromTangentSpace(L, interaction.getFromTangentSpace());
     }
     template<typename C=bool_constant<!IsBSDF> >
@@ -63,9 +65,9 @@ struct SLambertianBase
     scalar_type pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(isotropic_interaction_type) interaction) NBL_CONST_MEMBER_FUNC
     {
         NBL_IF_CONSTEXPR (IsBSDF)
-            return sampling::ProjectedSphere<scalar_type>::pdf(_sample.getNdotL(_clamp));
+            return sampling::ProjectedSphere<scalar_type>::backwardPdf(vector<scalar_type, 3>(0, 0, _sample.getNdotL(_clamp)));
         else
-            return sampling::ProjectedHemisphere<scalar_type>::pdf(_sample.getNdotL(_clamp));
+            return sampling::ProjectedHemisphere<scalar_type>::backwardPdf(vector<scalar_type, 3>(0, 0, _sample.getNdotL(_clamp)));
     }
     scalar_type pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction) NBL_CONST_MEMBER_FUNC
     {
@@ -74,12 +76,12 @@ struct SLambertianBase
 
     quotient_pdf_type quotient_and_pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(isotropic_interaction_type) interaction) NBL_CONST_MEMBER_FUNC
     {
-        sampling::quotient_and_pdf<monochrome_type, scalar_type> qp;
+        scalar_type p;
         NBL_IF_CONSTEXPR (IsBSDF)
-            qp = sampling::ProjectedSphere<scalar_type>::template quotient_and_pdf(_sample.getNdotL(_clamp));
+            p = sampling::ProjectedSphere<scalar_type>::backwardPdf(vector<scalar_type, 3>(0, 0, _sample.getNdotL(_clamp)));
         else
-            qp = sampling::ProjectedHemisphere<scalar_type>::template quotient_and_pdf(_sample.getNdotL(_clamp));
-        return quotient_pdf_type::create(qp.quotient[0], qp.pdf);
+            p = sampling::ProjectedHemisphere<scalar_type>::backwardPdf(vector<scalar_type, 3>(0, 0, _sample.getNdotL(_clamp)));
+        return quotient_pdf_type::create(scalar_type(1.0), p);
     }
     quotient_pdf_type quotient_and_pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction) NBL_CONST_MEMBER_FUNC
     {

include/nbl/builtin/hlsl/bxdf/base/oren_nayar.hlsl

@@ -72,16 +72,18 @@ struct SOrenNayarBase
     template<typename C=bool_constant<!IsBSDF> >
     enable_if_t<C::value && !IsBSDF, sample_type> generate(NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction, const vector2_type u) NBL_CONST_MEMBER_FUNC
     {
+        typename sampling::ProjectedHemisphere<scalar_type>::cache_type cache;
         ray_dir_info_type L;
-        L.setDirection(sampling::ProjectedHemisphere<scalar_type>::generate(u));
+        L.setDirection(sampling::ProjectedHemisphere<scalar_type>::generate(u, cache));
         return sample_type::createFromTangentSpace(L, interaction.getFromTangentSpace());
     }
     template<typename C=bool_constant<IsBSDF> >
     enable_if_t<C::value && IsBSDF, sample_type> generate(NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction, const vector3_type u) NBL_CONST_MEMBER_FUNC
     {
+        typename sampling::ProjectedSphere<scalar_type>::cache_type cache;
         vector3_type _u = u;
         ray_dir_info_type L;
-        L.setDirection(sampling::ProjectedSphere<scalar_type>::generate(_u));
+        L.setDirection(sampling::ProjectedSphere<scalar_type>::generate(_u, cache));
         return sample_type::createFromTangentSpace(L, interaction.getFromTangentSpace());
     }
     template<typename C=bool_constant<!IsBSDF> >
@@ -98,9 +100,9 @@ struct SOrenNayarBase
     scalar_type pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(isotropic_interaction_type) interaction) NBL_CONST_MEMBER_FUNC
     {
         if (IsBSDF)
-            return sampling::ProjectedSphere<scalar_type>::pdf(_sample.getNdotL(_clamp));
+            return sampling::ProjectedSphere<scalar_type>::backwardPdf(vector<scalar_type, 3>(0, 0, _sample.getNdotL(_clamp)));
         else
-            return sampling::ProjectedHemisphere<scalar_type>::pdf(_sample.getNdotL(_clamp));
+            return sampling::ProjectedHemisphere<scalar_type>::backwardPdf(vector<scalar_type, 3>(0, 0, _sample.getNdotL(_clamp)));
     }
     scalar_type pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction) NBL_CONST_MEMBER_FUNC
     {

include/nbl/builtin/hlsl/ieee754.hlsl

@@ -291,6 +291,41 @@ NBL_CONSTEXPR_FUNC bool isZero(T val)
 	return !(ieee754::impl::bitCastToUintType(val) & exponentAndMantissaMask);
 }
 
+// Returns the largest representable value less than `val`.
+// For positive values this decrements the bit representation; for negative values it increments.
+// Caller must guarantee val is finite and non-zero.
+template <bool CanBeNeg = true, typename T NBL_FUNC_REQUIRES(hlsl::is_floating_point_v<T>)
+NBL_CONSTEXPR_FUNC T nextDown(T val)
+{
+	using AsUint = typename unsigned_integer_of_size<sizeof(T)>::type;
+	using traits_t = traits<T>;
+
+	const AsUint bits = ieee754::impl::bitCastToUintType(val);
+
+	// positive: decrement; negative: increment
+	AsUint result;
+	if (CanBeNeg)
+	{
+		const bool isNegative = (bits & traits_t::signMask) != AsUint(0);
+		result = isNegative ? (bits + AsUint(1)) : (bits - AsUint(1));
+	}
+	else
+		result = bits - AsUint(1);
+	return impl::castBackToFloatType<T>(result);
+}
+
+// Returns the representable value nearest to `val` in the direction of zero.
+// For positive values this decrements the bit representation; for negative values it decrements (moving toward zero).
+// Caller must guarantee val is finite and non-zero.
+template <typename T NBL_FUNC_REQUIRES(hlsl::is_floating_point_v<T>)
+NBL_CONSTEXPR_FUNC T nextTowardZero(T val)
+{
+	using AsUint = typename unsigned_integer_of_size<sizeof(T)>::type;
+
+	const AsUint bits = ieee754::impl::bitCastToUintType(val);
+	return impl::castBackToFloatType<T>(bits - AsUint(1));
+}
+
 }
 }
 }

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

@@ -136,7 +136,7 @@ struct conditionalAbsOrMax_helper<T NBL_PARTIAL_REQ_BOT(concepts::FloatingPointL
         using UintOfTSize = unsigned_integer_of_size_t<sizeof(T)>;
         const T condAbs = bit_cast<T>(bit_cast<UintOfTSize>(x) & (cond ? (numeric_limits<UintOfTSize>::max >> 1) : numeric_limits<UintOfTSize>::max));
 
-        return max<T>(condAbs, limit);
+        return nbl::hlsl::max<T>(condAbs, limit);
     }
 };
 
@@ -156,7 +156,7 @@ struct conditionalAbsOrMax_helper<T NBL_PARTIAL_REQ_BOT(concepts::FloatingPointL
         const Uint32VectorWithDimensionOfT condAbsAsUint = xAsUintVec & mask;
         T condAbs = bit_cast<T, Uint32VectorWithDimensionOfT>(condAbsAsUint);
 
-        return max<T>(condAbs, limit);
+        return nbl::hlsl::max<T>(condAbs, limit);
     }
 };
 }

include/nbl/builtin/hlsl/path_tracing/gaussian_filter.hlsl

@@ -22,7 +22,7 @@ struct GaussianFilter
     {
         this_t retval;
         retval.truncation = hlsl::exp(-0.5 * gaussianFilterCutoff * gaussianFilterCutoff);
-        retval.boxMuller.stddev = stddev;
+        retval.boxMuller = sampling::BoxMullerTransform<scalar_type>::create(stddev);
         return retval;
     }
 
@@ -31,7 +31,8 @@ struct GaussianFilter
         vector2_type remappedRand = randVec;
         remappedRand.x *= 1.0 - truncation;
         remappedRand.x += truncation;
-        return boxMuller(remappedRand);
+        typename nbl::hlsl::sampling::BoxMullerTransform<scalar_type>::cache_type cache;
+        return boxMuller.generate(remappedRand, cache);
     }
 
     scalar_type truncation;

include/nbl/builtin/hlsl/path_tracing/unidirectional.hlsl

@@ -106,15 +106,15 @@ struct Unidirectional
             // So we need to weigh the Delta lobes as if the MIS weight is always 1, but other areas regularly.
             // Meaning that eval's pdf should equal quotient's pdf , this way even the diffuse contributions coming from within a specular lobe get a MIS weight near 0 for NEE.
             // This stops a discrepancy in MIS weights and NEE mistakenly trying to add non-delta lobe contributions with a MIS weight > 0 and creating energy from thin air.
-            if (neeContrib.pdf > scalar_type(0.0))
+            if (neeContrib.pdf() > scalar_type(0.0))
             {
                 // TODO: we'll need an `eval_and_mis_weight` and `quotient_and_mis_weight`
                 const scalar_type bsdf_pdf = materialSystem.pdf(matID, nee_sample, interaction);
-                neeContrib.quotient *= materialSystem.eval(matID, nee_sample, interaction) * rcpChoiceProb;
-                if (neeContrib.pdf < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity))
+                neeContrib._quotient *= materialSystem.eval(matID, nee_sample, interaction) * rcpChoiceProb;
+                if (neeContrib.pdf() < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity))
                 {
-                    const scalar_type otherGenOverLightAndChoice = bsdf_pdf * rcpChoiceProb / neeContrib.pdf;
-                    neeContrib.quotient /= 1.f + otherGenOverLightAndChoice * otherGenOverLightAndChoice;   // balance heuristic
+                    const scalar_type otherGenOverLightAndChoice = bsdf_pdf * rcpChoiceProb / neeContrib.pdf();
+                    neeContrib._quotient /= 1.f + otherGenOverLightAndChoice * otherGenOverLightAndChoice;   // balance heuristic
                 }
 
                 const vector3_type origin = intersectP;
@@ -124,8 +124,8 @@ struct Unidirectional
                 nee_ray.template setInteraction<anisotropic_interaction_type>(interaction);
                 nee_ray.setT(t);
                 tolerance_method_type::template adjust<ray_type>(nee_ray, intersectData.getGeometricNormal(), depth);
-                if (getLuma(neeContrib.quotient) > lumaContributionThreshold)
-                    ray.addPayloadContribution(neeContrib.quotient * intersector_type::traceShadowRay(scene, nee_ray, ret.getLightObjectID()));
+                if (getLuma(neeContrib.quotient()) > lumaContributionThreshold)
+                    ray.addPayloadContribution(neeContrib.quotient() * intersector_type::traceShadowRay(scene, nee_ray, ret.getLightObjectID()));
             }
         }
 
@@ -142,8 +142,8 @@ struct Unidirectional
 
             // the value of the bsdf divided by the probability of the sample being generated
             quotient_pdf_type bsdf_quotient_pdf = materialSystem.quotient_and_pdf(matID, bsdf_sample, interaction, _cache);
-            throughput *= bsdf_quotient_pdf.quotient;
-            bxdfPdf = bsdf_quotient_pdf.pdf;
+            throughput *= bsdf_quotient_pdf.quotient();
+            bxdfPdf = bsdf_quotient_pdf.pdf();
             bxdfSample = bsdf_sample.getL().getDirection();
         }
 

include/nbl/builtin/hlsl/sampling/alias_table.hlsl

@@ -0,0 +1,131 @@
+// Copyright (C) 2018-2025 - 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_ALIAS_TABLE_INCLUDED_
+#define _NBL_BUILTIN_HLSL_SAMPLING_ALIAS_TABLE_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include <nbl/builtin/hlsl/bit.hlsl>
+#include <nbl/builtin/hlsl/concepts/accessors/generic_shared_data.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace sampling
+{
+
+// Alias Method (Vose/Walker) discrete sampler.
+//
+// Samples a discrete index in [0, N) with probability proportional to
+// precomputed weights in O(1) time per sample, using a prebuilt alias table.
+//
+// Accessor template parameters must satisfy GenericReadAccessor:
+//   accessor.template get<V, I>(index, outVal)  // void, writes to outVal
+//
+// - ProbabilityAccessor: reads scalar_type threshold in [0, 1] for bin i
+// - AliasIndexAccessor:  reads uint32_t redirect index for bin i
+// - PdfAccessor:         reads scalar_type weight[i] / totalWeight
+//
+// Satisfies TractableSampler (not BackwardTractableSampler: the mapping is discrete).
+// The cache stores the PDF value looked up during generate, avoiding redundant
+// storage of the codomain (sampled index) which is already the return value.
+template<typename T, typename Domain, typename Codomain, typename ProbabilityAccessor, typename AliasIndexAccessor, typename PdfAccessor
+	NBL_PRIMARY_REQUIRES(
+		concepts::accessors::GenericReadAccessor<ProbabilityAccessor, T, Codomain> &&
+		concepts::accessors::GenericReadAccessor<AliasIndexAccessor, Codomain, Codomain> &&
+		concepts::accessors::GenericReadAccessor<PdfAccessor, T, Codomain>)
+struct AliasTable
+{
+	using scalar_type = T;
+
+	using domain_type = Domain;
+	using codomain_type = Codomain;
+	using density_type = scalar_type;
+	using weight_type = density_type;
+
+	struct cache_type
+	{
+		density_type pdf;
+	};
+
+	static AliasTable create(NBL_CONST_REF_ARG(ProbabilityAccessor) _probAccessor, NBL_CONST_REF_ARG(AliasIndexAccessor) _aliasAccessor, NBL_CONST_REF_ARG(PdfAccessor) _pdfAccessor, codomain_type _size)
+	{
+		AliasTable retval;
+		retval.probAccessor = _probAccessor;
+		retval.aliasAccessor = _aliasAccessor;
+		retval.pdfAccessor = _pdfAccessor;
+		// Precompute tableSize as float minus 1 ULP so that u=1.0 maps to bin N-1
+		const scalar_type exact = scalar_type(_size);
+		retval.tableSizeMinusUlp = nbl::hlsl::bit_cast<scalar_type>(nbl::hlsl::bit_cast<uint32_t>(exact) - 1u);
+		return retval;
+	}
+
+	// BasicSampler interface
+	codomain_type generate(const domain_type u)
+	{
+		const scalar_type scaled = u * tableSizeMinusUlp;
+		const codomain_type bin = codomain_type(scaled);
+		const scalar_type remainder = scaled - scalar_type(bin);
+
+		scalar_type prob;
+		probAccessor.template get<scalar_type, codomain_type>(bin, prob);
+
+		// Use if-statement to avoid select: aliasIndex is a dependent read
+		codomain_type result;
+		if (remainder < prob)
+		{
+			result = bin;
+		}
+		else
+		{
+			codomain_type alias;
+			aliasAccessor.template get<codomain_type, codomain_type>(bin, alias);
+			result = alias;
+		}
+
+		return result;
+	}
+
+	// TractableSampler interface
+	codomain_type generate(const domain_type u, NBL_REF_ARG(cache_type) cache)
+	{
+		const codomain_type result = generate(u);
+		pdfAccessor.template get<scalar_type, codomain_type>(result, cache.pdf);
+		return result;
+	}
+
+	density_type forwardPdf(NBL_CONST_REF_ARG(cache_type) cache)
+	{
+		return cache.pdf;
+	}
+
+	weight_type forwardWeight(NBL_CONST_REF_ARG(cache_type) cache)
+	{
+		return cache.pdf;
+	}
+
+	density_type backwardPdf(const codomain_type v)
+	{
+		scalar_type pdf;
+		pdfAccessor.template get<scalar_type, codomain_type>(v, pdf);
+		return pdf;
+	}
+
+	weight_type backwardWeight(const codomain_type v)
+	{
+		return backwardPdf(v);
+	}
+
+	ProbabilityAccessor probAccessor;
+	AliasIndexAccessor aliasAccessor;
+	PdfAccessor pdfAccessor;
+	scalar_type tableSizeMinusUlp;
+};
+
+} // namespace sampling
+} // namespace hlsl
+} // namespace nbl
+
+#endif