add sidechannel bool if D is infinity

Author: keptsecret

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

@@ -121,27 +121,6 @@ struct getOrientedFresnel<F, true NBL_PARTIAL_REQ_BOT(fresnel::TwoSidedFresnel<F
         return fresnel.getReorientedFresnel(NdotV);
     }
 };
-
-template<class N, class LS, class Interaction, class MicrofacetCache>
-struct overwrite_DG
-{
-    using scalar_type = typename N::scalar_type;
-    using quant_type = typename N::quant_type;
-    using quant_query_type = typename N::quant_query_type;
-    using g2g1_query_type = typename N::g2g1_query_type;
-    NBL_CONSTEXPR_STATIC_INLINE bool HasOverwrite = ndf::NDF_CanOverwriteDG<N>;
-
-    template<typename C=bool_constant<!HasOverwrite> >
-    static enable_if_t<C::value && !HasOverwrite, void> __call(NBL_REF_ARG(scalar_type) DG, N ndf, NBL_CONST_REF_ARG(g2g1_query_type) query, NBL_CONST_REF_ARG(quant_query_type) quant_query, NBL_CONST_REF_ARG(LS) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache)
-    {
-    }
-    template<typename C=bool_constant<HasOverwrite> >
-    static enable_if_t<C::value && HasOverwrite, void> __call(NBL_REF_ARG(scalar_type) DG, N ndf, NBL_CONST_REF_ARG(g2g1_query_type) query, NBL_CONST_REF_ARG(quant_query_type) quant_query, NBL_CONST_REF_ARG(LS) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache)
-    {
-        quant_type dg = ndf.template Dcorrelated<LS, Interaction, MicrofacetCache>(query, quant_query, _sample, interaction, cache);
-        DG = dg.projectedLightMeasure;
-    }
-};
 }
 
 // N (NDF), F (fresnel)
@@ -159,6 +138,23 @@ struct SCookTorrance
     NBL_CONSTEXPR_STATIC_INLINE bool IsBSDF = ndf_type::SupportedPaths != ndf::MTT_REFLECT;
     NBL_HLSL_BXDF_ANISOTROPIC_COND_DECLS(IsAnisotropic);
 
+    template<class Interaction=conditional_t<IsAnisotropic,anisotropic_interaction_type,isotropic_interaction_type>, 
+            class MicrofacetCache=conditional_t<IsAnisotropic,anisocache_type,isocache_type>
+            NBL_FUNC_REQUIRES(!ndf::NDF_CanOverwriteDG<ndf_type> && RequiredInteraction<Interaction> && RequiredMicrofacetCache<MicrofacetCache>)
+    static void overwriteDG(NBL_REF_ARG(scalar_type) DG, ndf_type ndf, NBL_CONST_REF_ARG(typename ndf_type::g2g1_query_type) query, NBL_CONST_REF_ARG(typename ndf_type::quant_query_type) quant_query,
+                    NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache, NBL_REF_ARG(bool) isInfinity)
+    {
+    }
+    template<class Interaction=conditional_t<IsAnisotropic,anisotropic_interaction_type,isotropic_interaction_type>, 
+            class MicrofacetCache=conditional_t<IsAnisotropic,anisocache_type,isocache_type>
+            NBL_FUNC_REQUIRES(ndf::NDF_CanOverwriteDG<ndf_type> && RequiredInteraction<Interaction> && RequiredMicrofacetCache<MicrofacetCache>)
+    static void overwriteDG(NBL_REF_ARG(scalar_type) DG, ndf_type ndf, NBL_CONST_REF_ARG(typename ndf_type::g2g1_query_type) query, NBL_CONST_REF_ARG(typename ndf_type::quant_query_type) quant_query,
+                    NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache, NBL_REF_ARG(bool) isInfinity)
+    {
+        quant_type dg = ndf.template Dcorrelated<sample_type, Interaction, MicrofacetCache>(query, quant_query, _sample, interaction, cache, isInfinity);
+        DG = dg.projectedLightMeasure;
+    }
+
     template<class Interaction=conditional_t<IsAnisotropic,anisotropic_interaction_type,isotropic_interaction_type>, 
             class MicrofacetCache=conditional_t<IsAnisotropic,anisocache_type,isocache_type>
             NBL_FUNC_REQUIRES(RequiredInteraction<Interaction> && RequiredMicrofacetCache<MicrofacetCache>)
@@ -174,14 +170,16 @@ struct SCookTorrance
         using g2g1_query_type = typename ndf_type::g2g1_query_type;
         g2g1_query_type gq = ndf.template createG2G1Query<sample_type, Interaction>(_sample, interaction);
 
-        quant_type D = ndf.template D<sample_type, Interaction, MicrofacetCache>(qq, _sample, interaction, cache);
+        bool isInfinity;
+        quant_type D = ndf.template D<sample_type, Interaction, MicrofacetCache>(qq, _sample, interaction, cache, isInfinity);
         scalar_type DG = D.projectedLightMeasure;
-        if (D.microfacetMeasure < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity))
+        if (!isInfinity)
             DG *= ndf.template correlated<sample_type, Interaction, MicrofacetCache>(gq, _sample, interaction, cache);
-        else
-            return hlsl::promote<spectral_type>(0.0);
 
-        impl::overwrite_DG<ndf_type, sample_type, Interaction, MicrofacetCache>::__call(DG, ndf, gq, qq, _sample, interaction, cache);
+        overwriteDG<Interaction, MicrofacetCache>(DG, ndf, gq, qq, _sample, interaction, cache, isInfinity);
+
+        if (isInfinity)
+            return hlsl::promote<spectral_type>(0.0);
 
         scalar_type clampedVdotH = cache.getVdotH();
         NBL_IF_CONSTEXPR(IsBSDF)
@@ -320,7 +318,7 @@ struct SCookTorrance
     }
 
     template<class Interaction, class MicrofacetCache>
-    scalar_type __pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache)
+    scalar_type __pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache, NBL_REF_ARG(bool) isInfinity)
     {
         using quant_query_type = typename ndf_type::quant_query_type;
         using dg1_query_type = typename ndf_type::dg1_query_type;
@@ -329,7 +327,7 @@ struct SCookTorrance
 
         fresnel_type _f = impl::getOrientedFresnel<fresnel_type, IsBSDF>::__call(fresnel, interaction.getNdotV());
         quant_query_type qq = impl::quant_query_helper<ndf_type, fresnel_type, IsBSDF>::template __call<Interaction, MicrofacetCache>(ndf, _f, interaction, cache);
-        quant_type DG1 = ndf.template DG1<sample_type, Interaction>(dq, qq, _sample, interaction);
+        quant_type DG1 = ndf.template DG1<sample_type, Interaction>(dq, qq, _sample, interaction, isInfinity);
 
         NBL_IF_CONSTEXPR(IsBSDF)
         {
@@ -350,8 +348,9 @@ struct SCookTorrance
         if (!impl::checkValid<fresnel_type, IsBSDF>::template __call<sample_type, Interaction, MicrofacetCache>(_f, _sample, interaction, cache))
             return scalar_type(0.0);
 
-        scalar_type _pdf = __pdf<Interaction, MicrofacetCache>(_sample, interaction, cache);
-        return hlsl::mix(scalar_type(0.0), _pdf, _pdf < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity));
+        bool isInfinity;
+        scalar_type _pdf = __pdf<Interaction, MicrofacetCache>(_sample, interaction, cache, isInfinity);
+        return hlsl::mix(_pdf, scalar_type(0.0), isInfinity);
     }
 
     template<class Interaction=conditional_t<IsAnisotropic,anisotropic_interaction_type,isotropic_interaction_type>, 
@@ -362,14 +361,15 @@ struct SCookTorrance
         if (!_sample.isValid())
             return quotient_pdf_type::create(scalar_type(0.0), scalar_type(0.0));   // set pdf=0 when quo=0 because we don't want to give high weight to sampling strategy that yields 0 contribution
 
-        scalar_type _pdf = __pdf<Interaction, MicrofacetCache>(_sample, interaction, cache);
+        bool isInfinity;
+        scalar_type _pdf = __pdf<Interaction, MicrofacetCache>(_sample, interaction, cache, isInfinity);
         fresnel_type _f = impl::getOrientedFresnel<fresnel_type, IsBSDF>::__call(fresnel, interaction.getNdotV());
 
         const bool valid = impl::checkValid<fresnel_type, IsBSDF>::template __call<sample_type, Interaction, MicrofacetCache>(_f, _sample, interaction, cache);
         assert(valid);  // expect the generated sample to always be valid, different checks for brdf and btdf
 
         scalar_type G2_over_G1 = scalar_type(1.0);
-        if (_pdf < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity))
+        if (!isInfinity)
         {
             using g2g1_query_type = typename N::g2g1_query_type;
             g2g1_query_type gq = ndf.template createG2G1Query<sample_type, Interaction>(_sample, interaction);

include/nbl/builtin/hlsl/bxdf/ndf.hlsl

@@ -34,26 +34,29 @@ using cache_t = SAnisotropicMicrofacetCache<SIsotropicMicrofacetCache<float> >;
 #define NBL_CONCEPT_PARAM_4 (cache, dummy_impl::cache_t)
 #define NBL_CONCEPT_PARAM_5 (dg1_query, typename T::dg1_query_type)
 #define NBL_CONCEPT_PARAM_6 (g2_query, typename T::g2g1_query_type)
-NBL_CONCEPT_BEGIN(7)
+#define NBL_CONCEPT_PARAM_7 (is_inf, bool)
+NBL_CONCEPT_BEGIN(8)
 #define ndf NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_0
 #define quant_query NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_1
 #define _sample NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_2
 #define interaction NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_3
 #define cache NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_4
 #define dg1_query NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_5
 #define g2_query NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_6
+#define is_inf NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_7
 NBL_CONCEPT_END(
     ((NBL_CONCEPT_REQ_TYPE)(T::scalar_type))
     ((NBL_CONCEPT_REQ_TYPE)(T::quant_type))
     ((NBL_CONCEPT_REQ_TYPE)(T::dg1_query_type))
     ((NBL_CONCEPT_REQ_TYPE)(T::g2g1_query_type))
     ((NBL_CONCEPT_REQ_TYPE)(T::quant_query_type))
     // ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((T::GuaranteedVNDF), ::nbl::hlsl::is_same_v, bool))
-    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((ndf.template D<dummy_impl::sample_t, dummy_impl::interaction_t, dummy_impl::cache_t>(quant_query, _sample, interaction, cache)), ::nbl::hlsl::is_same_v, typename T::quant_type))
-    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((ndf.template DG1<dummy_impl::sample_t, dummy_impl::interaction_t>(dg1_query, quant_query, _sample, interaction)), ::nbl::hlsl::is_same_v, typename T::quant_type))
+    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((ndf.template D<dummy_impl::sample_t, dummy_impl::interaction_t, dummy_impl::cache_t>(quant_query, _sample, interaction, cache, is_inf)), ::nbl::hlsl::is_same_v, typename T::quant_type))
+    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((ndf.template DG1<dummy_impl::sample_t, dummy_impl::interaction_t>(dg1_query, quant_query, _sample, interaction, is_inf)), ::nbl::hlsl::is_same_v, typename T::quant_type))
     ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((ndf.template correlated<dummy_impl::sample_t, dummy_impl::interaction_t, dummy_impl::cache_t>(g2_query, _sample, interaction, cache)), ::nbl::hlsl::is_same_v, typename T::scalar_type))
     ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((ndf.template G2_over_G1<dummy_impl::sample_t, dummy_impl::interaction_t, dummy_impl::cache_t>(g2_query, _sample, interaction, cache)), ::nbl::hlsl::is_same_v, typename T::scalar_type))
 );
+#undef is_inf
 #undef g2_query
 #undef dg1_query
 #undef cache

include/nbl/builtin/hlsl/bxdf/ndf/beckmann.hlsl

@@ -100,10 +100,14 @@ struct BeckmannCommon<T,false NBL_PARTIAL_REQ_BOT(concepts::FloatingPointScalar<
     using scalar_type = T;
 
     template<class MicrofacetCache NBL_FUNC_REQUIRES(ReadableIsotropicMicrofacetCache<MicrofacetCache>)
-    scalar_type D(NBL_CONST_REF_ARG(MicrofacetCache) cache)
+    scalar_type D(NBL_CONST_REF_ARG(MicrofacetCache) cache, NBL_REF_ARG(bool) isInfinity)
     {
         if (a2 < numeric_limits<scalar_type>::min)
+        {
+            isInfinity = true;
             return bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity);
+        }
+        isInfinity = false;
         scalar_type NdotH2 = cache.getNdotH2();
         scalar_type nom = exp2<scalar_type>((NdotH2 - scalar_type(1.0)) / (log<scalar_type>(2.0) * a2 * NdotH2));
         scalar_type denom = a2 * NdotH2 * NdotH2;
@@ -126,10 +130,14 @@ struct BeckmannCommon<T,true NBL_PARTIAL_REQ_BOT(concepts::FloatingPointScalar<T
     using scalar_type = T;
 
     template<class MicrofacetCache NBL_FUNC_REQUIRES(AnisotropicMicrofacetCache<MicrofacetCache>)
-    scalar_type D(NBL_CONST_REF_ARG(MicrofacetCache) cache)
+    scalar_type D(NBL_CONST_REF_ARG(MicrofacetCache) cache, NBL_REF_ARG(bool) isInfinity)
     {
         if (a2 < numeric_limits<scalar_type>::min)
+        {
+            isInfinity = true;
             return bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity);
+        }
+        isInfinity = false;
         scalar_type NdotH2 = cache.getNdotH2();
         scalar_type nom = exp<scalar_type>(-(cache.getTdotH2() / ax2 + cache.getBdotH2() / ay2) / NdotH2);
         scalar_type denom = a2 * NdotH2 * NdotH2;
@@ -282,7 +290,8 @@ struct Beckmann
     enable_if_t<C::value && !IsAnisotropic, dg1_query_type> createDG1Query(NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache)
     {
         dg1_query_type dg1_query;
-        dg1_query.ndf = __ndf_base.template D<MicrofacetCache>(cache);
+        bool dummy;
+        dg1_query.ndf = __ndf_base.template D<MicrofacetCache>(cache, dummy);
         dg1_query.lambda_V = Lambda(__ndf_base.C2(interaction.getNdotV2()));
         return dg1_query;
     }
@@ -298,7 +307,8 @@ struct Beckmann
     enable_if_t<C::value && IsAnisotropic, dg1_query_type> createDG1Query(NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache)
     {
         dg1_query_type dg1_query;
-        dg1_query.ndf = __ndf_base.template D<MicrofacetCache>(cache);
+        bool dummy;
+        dg1_query.ndf = __ndf_base.template D<MicrofacetCache>(cache, dummy);
         dg1_query.lambda_V = Lambda(__ndf_base.C2(interaction.getTdotV2(), interaction.getBdotV2(), interaction.getNdotV2()));
         return dg1_query;
     }
@@ -317,16 +327,18 @@ struct Beckmann
     }
 
     template<class LS, class Interaction, class MicrofacetCache NBL_FUNC_REQUIRES(LightSample<LS> && RequiredInteraction<Interaction> && RequiredMicrofacetCache<MicrofacetCache>)
-    quant_type D(NBL_CONST_REF_ARG(quant_query_type) quant_query, NBL_CONST_REF_ARG(LS) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache)
+    quant_type D(NBL_CONST_REF_ARG(quant_query_type) quant_query, NBL_CONST_REF_ARG(LS) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache, NBL_REF_ARG(bool) isInfinity)
     {
-        scalar_type d = __ndf_base.template D<MicrofacetCache>(cache);
+        scalar_type d = __ndf_base.template D<MicrofacetCache>(cache, isInfinity);
         return createDualMeasureQuantity<T, reflect_refract, quant_query_type>(d, interaction.getNdotV(BxDFClampMode::BCM_ABS), _sample.getNdotL(BxDFClampMode::BCM_ABS), quant_query);
     }
 
     template<class LS, class Interaction NBL_FUNC_REQUIRES(LightSample<LS> && RequiredInteraction<Interaction>)
-    quant_type DG1(NBL_CONST_REF_ARG(dg1_query_type) query, NBL_CONST_REF_ARG(quant_query_type) quant_query, NBL_CONST_REF_ARG(LS) _sample, NBL_CONST_REF_ARG(Interaction) interaction)
+    quant_type DG1(NBL_CONST_REF_ARG(dg1_query_type) query, NBL_CONST_REF_ARG(quant_query_type) quant_query, NBL_CONST_REF_ARG(LS) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_REF_ARG(bool) isInfinity)
     {
+        scalar_type D = query.getNdf();
         scalar_type dg1 = query.getNdf() / (scalar_type(1.0) + query.getLambdaV());
+        isInfinity = D == bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity);
         return createDualMeasureQuantity<T, reflect_refract, quant_query_type>(dg1, interaction.getNdotV(BxDFClampMode::BCM_ABS), _sample.getNdotL(BxDFClampMode::BCM_ABS), quant_query);
     }