account for non-symmetry in transmission, added PathOrigin

keptsecret · keptsecret · commit 36c1f4b48328 · 2025-10-29T15:06:26.000+07:00
diff --git a/include/nbl/builtin/hlsl/bxdf/base/cook_torrance_base.hlsl b/include/nbl/builtin/hlsl/bxdf/base/cook_torrance_base.hlsl
@@ -48,10 +48,10 @@ struct quant_query_helper<N, F, true>
 {
     using quant_query_type = typename N::quant_query_type;
 
-    template<class C>
-    static quant_query_type __call(NBL_REF_ARG(N) ndf, NBL_CONST_REF_ARG(F) fresnel, NBL_CONST_REF_ARG(C) cache)
+    template<class I, class C>
+    static quant_query_type __call(NBL_REF_ARG(N) ndf, NBL_CONST_REF_ARG(F) fresnel, NBL_CONST_REF_ARG(I) interaction, NBL_CONST_REF_ARG(C) cache)
     {
-        return ndf.template createQuantQuery<C>(cache, fresnel.orientedEta.value[0]);
+        return ndf.template createQuantQuery<I,C>(interaction, cache, fresnel.orientedEta.value[0]);
     }
 };
 
@@ -60,11 +60,11 @@ struct quant_query_helper<N, F, false>
 {
     using quant_query_type = typename N::quant_query_type;
 
-    template<class C>
-    static quant_query_type __call(NBL_REF_ARG(N) ndf, NBL_CONST_REF_ARG(F) fresnel, NBL_CONST_REF_ARG(C) cache)
+    template<class I, class C>
+    static quant_query_type __call(NBL_REF_ARG(N) ndf, NBL_CONST_REF_ARG(F) fresnel, NBL_CONST_REF_ARG(I) interaction, NBL_CONST_REF_ARG(C) cache)
     {
         typename N::scalar_type dummy;
-        return ndf.template createQuantQuery<C>(cache, dummy);
+        return ndf.template createQuantQuery<I,C>(interaction, cache, dummy);
     }
 };
 
@@ -167,7 +167,7 @@ struct SCookTorrance
             return hlsl::promote<spectral_type>(0.0);
 
         using quant_query_type = typename ndf_type::quant_query_type;
-        quant_query_type qq = impl::quant_query_helper<ndf_type, fresnel_type, IsBSDF>::template __call<MicrofacetCache>(ndf, _f, cache);
+        quant_query_type qq = impl::quant_query_helper<ndf_type, fresnel_type, IsBSDF>::template __call<Interaction, MicrofacetCache>(ndf, _f, interaction, cache);
 
         using g2g1_query_type = typename ndf_type::g2g1_query_type;
         g2g1_query_type gq = ndf.template createG2G1Query<sample_type, Interaction>(_sample, interaction);
@@ -379,7 +379,7 @@ struct SCookTorrance
         dg1_query_type dq = ndf.template createDG1Query<Interaction, MicrofacetCache>(interaction, cache);
 
         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<MicrofacetCache>(ndf, _f, cache);
+        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);
 
         NBL_IF_CONSTEXPR(IsBSDF)
diff --git a/include/nbl/builtin/hlsl/bxdf/common.hlsl b/include/nbl/builtin/hlsl/bxdf/common.hlsl
@@ -157,6 +157,12 @@ enum BxDFClampMode : uint16_t
     BCM_ABS
 };
 
+enum PathOrigin : uint16_t
+{
+    PO_SENSOR = 0,
+    PO_LIGHT
+};
+
 template<typename T NBL_FUNC_REQUIRES(concepts::FloatingPointScalar<T>)
 T conditionalAbsOrMax(T x, BxDFClampMode _clamp)
 {
@@ -186,6 +192,7 @@ NBL_CONCEPT_END(
     ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((iso.getN()), ::nbl::hlsl::is_same_v, typename T::vector3_type))
     ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((iso.getNdotV(clampMode)), ::nbl::hlsl::is_same_v, typename T::scalar_type))
     ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((iso.getNdotV2()), ::nbl::hlsl::is_same_v, typename T::scalar_type))
+    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((iso.getPathOrigin()), ::nbl::hlsl::is_same_v, PathOrigin))
     ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((T::create(normV,normN)), ::nbl::hlsl::is_same_v, T))
     ((NBL_CONCEPT_REQ_TYPE_ALIAS_CONCEPT)(ray_dir_info::Basic, typename T::ray_dir_info_type))
 );
@@ -222,6 +229,8 @@ struct SIsotropic
     }
     scalar_type getNdotV2() NBL_CONST_MEMBER_FUNC { return NdotV2; }
 
+    PathOrigin getPathOrigin() NBL_CONST_MEMBER_FUNC { return PathOrigin::PO_SENSOR; }
+
     RayDirInfo V;
     vector3_type N;
     scalar_type NdotV;
@@ -309,6 +318,7 @@ struct SAnisotropic
     vector3_type getN() NBL_CONST_MEMBER_FUNC { return isotropic.getN(); }
     scalar_type getNdotV(BxDFClampMode _clamp = BxDFClampMode::BCM_NONE) NBL_CONST_MEMBER_FUNC { return isotropic.getNdotV(_clamp); }
     scalar_type getNdotV2() NBL_CONST_MEMBER_FUNC { return isotropic.getNdotV2(); }
+    PathOrigin getPathOrigin() NBL_CONST_MEMBER_FUNC { return isotropic.getPathOrigin(); }
 
     vector3_type getT() NBL_CONST_MEMBER_FUNC { return T; }
     vector3_type getB() NBL_CONST_MEMBER_FUNC { return B; }
diff --git a/include/nbl/builtin/hlsl/bxdf/ndf/beckmann.hlsl b/include/nbl/builtin/hlsl/bxdf/ndf/beckmann.hlsl
@@ -263,15 +263,18 @@ struct Beckmann
         return hlsl::mix<scalar_type>(scalar_type(0.0), nom / denom, c < scalar_type(1.6));
     }
 
-    template<class MicrofacetCache NBL_FUNC_REQUIRES(RequiredMicrofacetCache<MicrofacetCache>)
-    quant_query_type createQuantQuery(NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)
+    template<class Interaction, class MicrofacetCache NBL_FUNC_REQUIRES(RequiredInteraction<Interaction> && RequiredMicrofacetCache<MicrofacetCache>)
+    quant_query_type createQuantQuery(NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)
     {
         quant_query_type quant_query;   // only has members for refraction
         NBL_IF_CONSTEXPR(SupportsTransmission)
         {
             quant_query.VdotHLdotH = cache.getVdotHLdotH();
-            const scalar_type VdotH_etaLdotH = cache.getVdotH() + orientedEta * cache.getLdotH();
-            quant_query.neg_rcp2_VdotH_etaLdotH = scalar_type(-1.0) / (VdotH_etaLdotH * VdotH_etaLdotH);
+            const scalar_type VdotH = cache.getVdotH();
+            const scalar_type VdotH_etaLdotH = hlsl::mix(VdotH + orientedEta * cache.getLdotH(),
+                                                        VdotH / orientedEta + cache.getLdotH(),
+                                                        interaction.getPathOrigin() == PathOrigin::PO_SENSOR);
+            quant_query.neg_rcp2_refractionDenom = scalar_type(-1.0) / (VdotH_etaLdotH * VdotH_etaLdotH);
         }
         return quant_query;
     }
diff --git a/include/nbl/builtin/hlsl/bxdf/ndf/ggx.hlsl b/include/nbl/builtin/hlsl/bxdf/ndf/ggx.hlsl
@@ -206,15 +206,18 @@ struct GGX
         return scalar_type(1.0) / (NdotX + devsh_part);
     }
 
-    template<class MicrofacetCache NBL_FUNC_REQUIRES(RequiredMicrofacetCache<MicrofacetCache>)
-    quant_query_type createQuantQuery(NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)
+    template<class Interaction, class MicrofacetCache NBL_FUNC_REQUIRES(RequiredInteraction<Interaction> && RequiredMicrofacetCache<MicrofacetCache>)
+    quant_query_type createQuantQuery(NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)
     {
         quant_query_type quant_query;   // only has members for refraction
-        NBL_IF_CONSTEXPR (SupportsTransmission)
+        NBL_IF_CONSTEXPR(SupportsTransmission)
         {
             quant_query.VdotHLdotH = cache.getVdotHLdotH();
-            const scalar_type VdotH_etaLdotH = cache.getVdotH() + orientedEta * cache.getLdotH();
-            quant_query.neg_rcp2_VdotH_etaLdotH = scalar_type(-1.0) / (VdotH_etaLdotH * VdotH_etaLdotH);
+            const scalar_type VdotH = cache.getVdotH();
+            const scalar_type VdotH_etaLdotH = hlsl::mix(VdotH + orientedEta * cache.getLdotH(),
+                                                        VdotH / orientedEta + cache.getLdotH(),
+                                                        interaction.getPathOrigin() == PathOrigin::PO_SENSOR);
+            quant_query.neg_rcp2_refractionDenom = scalar_type(-1.0) / (VdotH_etaLdotH * VdotH_etaLdotH);
         }
         return quant_query;
     }
@@ -278,7 +281,7 @@ struct GGX
             const bool transmitted = reflect_refract==MTT_REFRACT || (reflect_refract!=MTT_REFLECT && VdotHLdotH < scalar_type(0.0));
             dmq.projectedLightMeasure = hlsl::mix(scalar_type(0.5),scalar_type(2.0),transmitted) * dg1_over_2NdotV;
             if (transmitted)
-                dmq.projectedLightMeasure *= VdotHLdotH * quant_query.getNeg_rcp2_VdotH_etaLdotH();
+                dmq.projectedLightMeasure *= VdotHLdotH * quant_query.getNeg_rcp2_refractionDenom();
         }
         else
             dmq.projectedLightMeasure = scalar_type(0.5) * dg1_over_2NdotV;
@@ -319,10 +322,14 @@ struct GGX
     quant_type Dcorrelated(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)
     {
         scalar_type dg = __ndf_base.template D<MicrofacetCache>(cache);
-        if (dg < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity))
-            dg *= correlated_wo_numerator<LS, Interaction, MicrofacetCache>(query, _sample, interaction, cache);
-        else
-            dg = scalar_type(0.0);
+        if (dg >= bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity))
+        {
+            quant_type dmq;
+            dmq.microfacetMeasure = scalar_type(0.0);
+            dmq.projectedLightMeasure = scalar_type(0.0);
+            return dmq;
+        }
+        dg *= correlated_wo_numerator<LS, Interaction, MicrofacetCache>(query, _sample, interaction, cache);
 
         quant_type dmq;
         dmq.microfacetMeasure = dg;
@@ -333,7 +340,7 @@ struct GGX
             const bool transmitted = reflect_refract==MTT_REFRACT || (reflect_refract!=MTT_REFLECT && VdotHLdotH < scalar_type(0.0));
             scalar_type NdotL_over_denominator = _sample.getNdotL(BxDFClampMode::BCM_ABS);
             if (transmitted)
-                    NdotL_over_denominator *= scalar_type(4.0) * VdotHLdotH * quant_query.getNeg_rcp2_VdotH_etaLdotH();
+                    NdotL_over_denominator *= scalar_type(4.0) * VdotHLdotH * quant_query.getNeg_rcp2_refractionDenom();
             dmq.projectedLightMeasure = dg * NdotL_over_denominator;
         }
         else
diff --git a/include/nbl/builtin/hlsl/bxdf/ndf/microfacet_to_light_transform.hlsl b/include/nbl/builtin/hlsl/bxdf/ndf/microfacet_to_light_transform.hlsl
@@ -48,10 +48,10 @@ struct DualMeasureQuantQuery
    // note in pbrt it's `abs(VdotH)*abs(LdotH)`
    // we leverage the fact that under transmission the sign must always be negative and rest of the code already accounts for that
    scalar_type getVdotHLdotH() NBL_CONST_MEMBER_FUNC { return VdotHLdotH; }
-   scalar_type getNeg_rcp2_VdotH_etaLdotH () NBL_CONST_MEMBER_FUNC { return neg_rcp2_VdotH_etaLdotH ; }
+   scalar_type getNeg_rcp2_refractionDenom() NBL_CONST_MEMBER_FUNC { return neg_rcp2_refractionDenom ; }
 
    scalar_type VdotHLdotH;
-   scalar_type neg_rcp2_VdotH_etaLdotH;
+   scalar_type neg_rcp2_refractionDenom;
 };
 
 
@@ -71,14 +71,14 @@ struct createDualMeasureQuantity_helper
 {
    using scalar_type = typename vector_traits<T>::scalar_type;
 
-   static SDualMeasureQuant<T> __call(const T microfacetMeasure, scalar_type clampedNdotV, scalar_type clampedNdotL, scalar_type VdotHLdotH, scalar_type neg_rcp2_VdotH_etaLdotH)
+   static SDualMeasureQuant<T> __call(const T microfacetMeasure, scalar_type clampedNdotV, scalar_type clampedNdotL, scalar_type VdotHLdotH, scalar_type neg_rcp2_refractionDenom)
    {
       assert(clampedNdotV >= scalar_type(0.0) && clampedNdotL >= scalar_type(0.0));
       SDualMeasureQuant<T> retval;
       retval.microfacetMeasure = microfacetMeasure;
       // do constexpr booleans first so optimizer picks up this and short circuits
       const bool transmitted = reflect_refract==MTT_REFRACT || (reflect_refract!=MTT_REFLECT && VdotHLdotH < scalar_type(0.0));
-      retval.projectedLightMeasure = microfacetMeasure * hlsl::mix(scalar_type(0.25),VdotHLdotH*neg_rcp2_VdotH_etaLdotH,transmitted)/clampedNdotV;
+      retval.projectedLightMeasure = microfacetMeasure * hlsl::mix(scalar_type(0.25),VdotHLdotH*neg_rcp2_refractionDenom,transmitted)/clampedNdotV;
       // VdotHLdotH is negative under transmission, so thats denominator is negative
       return retval;
    }
@@ -93,14 +93,14 @@ SDualMeasureQuant<T> createDualMeasureQuantity(const T specialMeasure, typename
    return impl::createDualMeasureQuantity_helper<T,MTT_REFLECT>::__call(specialMeasure,clampedNdotV,clampedNdotL,dummy,dummy);
 }
 template<typename T, MicrofacetTransformTypes reflect_refract>
-SDualMeasureQuant<T> createDualMeasureQuantity(const T specialMeasure, typename vector_traits<T>::scalar_type clampedNdotV, typename vector_traits<T>::scalar_type clampedNdotL, typename vector_traits<T>::scalar_type VdotHLdotH, typename vector_traits<T>::scalar_type neg_rcp2_VdotH_etaLdotH)
+SDualMeasureQuant<T> createDualMeasureQuantity(const T specialMeasure, typename vector_traits<T>::scalar_type clampedNdotV, typename vector_traits<T>::scalar_type clampedNdotL, typename vector_traits<T>::scalar_type VdotHLdotH, typename vector_traits<T>::scalar_type neg_rcp2_refractionDenom)
 {
-   return impl::createDualMeasureQuantity_helper<T,reflect_refract>::__call(specialMeasure,clampedNdotV,clampedNdotL,VdotHLdotH,neg_rcp2_VdotH_etaLdotH);
+   return impl::createDualMeasureQuantity_helper<T,reflect_refract>::__call(specialMeasure,clampedNdotV,clampedNdotL,VdotHLdotH,neg_rcp2_refractionDenom);
 }
 template<typename T, MicrofacetTransformTypes reflect_refract, class Query>
 SDualMeasureQuant<T> createDualMeasureQuantity(const T specialMeasure, typename vector_traits<T>::scalar_type clampedNdotV, typename vector_traits<T>::scalar_type clampedNdotL, NBL_CONST_REF_ARG(Query) query)
 {
-   return impl::createDualMeasureQuantity_helper<T,reflect_refract>::__call(specialMeasure,clampedNdotV,clampedNdotL,query.getVdotHLdotH(),query.getNeg_rcp2_VdotH_etaLdotH());
+   return impl::createDualMeasureQuantity_helper<T,reflect_refract>::__call(specialMeasure,clampedNdotV,clampedNdotL,query.getVdotHLdotH(),query.getNeg_rcp2_refractionDenom());
 }
 
 }

Original file line number	Diff line number	Diff line change
`@@ -263,15 +263,18 @@ struct Beckmann`
`263`	`263`	`return hlsl::mix<scalar_type>(scalar_type(0.0), nom / denom, c < scalar_type(1.6));`
`264`	`264`	`}`
`265`	`265`
`266`		`- template<class MicrofacetCache NBL_FUNC_REQUIRES(RequiredMicrofacetCache<MicrofacetCache>)`
`267`		`- quant_query_type createQuantQuery(NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)`
	`266`	`+ template<class Interaction, class MicrofacetCache NBL_FUNC_REQUIRES(RequiredInteraction<Interaction> && RequiredMicrofacetCache<MicrofacetCache>)`
	`267`	`+ quant_query_type createQuantQuery(NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache, scalar_type orientedEta)`
`268`	`268`	`{`
`269`	`269`	`quant_query_type quant_query; // only has members for refraction`
`270`	`270`	`NBL_IF_CONSTEXPR(SupportsTransmission)`
`271`	`271`	`{`
`272`	`272`	`quant_query.VdotHLdotH = cache.getVdotHLdotH();`
`273`		`- const scalar_type VdotH_etaLdotH = cache.getVdotH() + orientedEta * cache.getLdotH();`
`274`		`- quant_query.neg_rcp2_VdotH_etaLdotH = scalar_type(-1.0) / (VdotH_etaLdotH * VdotH_etaLdotH);`
	`273`	`+ const scalar_type VdotH = cache.getVdotH();`
	`274`	`+ const scalar_type VdotH_etaLdotH = hlsl::mix(VdotH + orientedEta * cache.getLdotH(),`
	`275`	`+ VdotH / orientedEta + cache.getLdotH(),`
	`276`	`+ interaction.getPathOrigin() == PathOrigin::PO_SENSOR);`
	`277`	`+ quant_query.neg_rcp2_refractionDenom = scalar_type(-1.0) / (VdotH_etaLdotH * VdotH_etaLdotH);`
`275`	`278`	`}`
`276`	`279`	`return quant_query;`
`277`	`280`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,10 +48,10 @@ struct DualMeasureQuantQuery`
`48`	`48`	// note in pbrt it's `abs(VdotH)*abs(LdotH)`
`49`	`49`	`// we leverage the fact that under transmission the sign must always be negative and rest of the code already accounts for that`
`50`	`50`	`scalar_type getVdotHLdotH() NBL_CONST_MEMBER_FUNC { return VdotHLdotH; }`
`51`		`- scalar_type getNeg_rcp2_VdotH_etaLdotH () NBL_CONST_MEMBER_FUNC { return neg_rcp2_VdotH_etaLdotH ; }`
	`51`	`+ scalar_type getNeg_rcp2_refractionDenom() NBL_CONST_MEMBER_FUNC { return neg_rcp2_refractionDenom ; }`
`52`	`52`
`53`	`53`	`scalar_type VdotHLdotH;`
`54`		`- scalar_type neg_rcp2_VdotH_etaLdotH;`
	`54`	`+ scalar_type neg_rcp2_refractionDenom;`
`55`	`55`	`};`
`56`	`56`
`57`	`57`
`@@ -71,14 +71,14 @@ struct createDualMeasureQuantity_helper`
`71`	`71`	`{`
`72`	`72`	`using scalar_type = typename vector_traits<T>::scalar_type;`
`73`	`73`
`74`		`- static SDualMeasureQuant<T> __call(const T microfacetMeasure, scalar_type clampedNdotV, scalar_type clampedNdotL, scalar_type VdotHLdotH, scalar_type neg_rcp2_VdotH_etaLdotH)`
	`74`	`+ static SDualMeasureQuant<T> __call(const T microfacetMeasure, scalar_type clampedNdotV, scalar_type clampedNdotL, scalar_type VdotHLdotH, scalar_type neg_rcp2_refractionDenom)`
`75`	`75`	`{`
`76`	`76`	`assert(clampedNdotV >= scalar_type(0.0) && clampedNdotL >= scalar_type(0.0));`
`77`	`77`	`SDualMeasureQuant<T> retval;`
`78`	`78`	`retval.microfacetMeasure = microfacetMeasure;`
`79`	`79`	`// do constexpr booleans first so optimizer picks up this and short circuits`
`80`	`80`	`const bool transmitted = reflect_refract==MTT_REFRACT \|\| (reflect_refract!=MTT_REFLECT && VdotHLdotH < scalar_type(0.0));`
`81`		`- retval.projectedLightMeasure = microfacetMeasure * hlsl::mix(scalar_type(0.25),VdotHLdotH*neg_rcp2_VdotH_etaLdotH,transmitted)/clampedNdotV;`
	`81`	`+ retval.projectedLightMeasure = microfacetMeasure * hlsl::mix(scalar_type(0.25),VdotHLdotH*neg_rcp2_refractionDenom,transmitted)/clampedNdotV;`
`82`	`82`	`// VdotHLdotH is negative under transmission, so thats denominator is negative`
`83`	`83`	`return retval;`
`84`	`84`	`}`
`@@ -93,14 +93,14 @@ SDualMeasureQuant<T> createDualMeasureQuantity(const T specialMeasure, typename`
`93`	`93`	`return impl::createDualMeasureQuantity_helper<T,MTT_REFLECT>::__call(specialMeasure,clampedNdotV,clampedNdotL,dummy,dummy);`
`94`	`94`	`}`
`95`	`95`	`template<typename T, MicrofacetTransformTypes reflect_refract>`
`96`		`-SDualMeasureQuant<T> createDualMeasureQuantity(const T specialMeasure, typename vector_traits<T>::scalar_type clampedNdotV, typename vector_traits<T>::scalar_type clampedNdotL, typename vector_traits<T>::scalar_type VdotHLdotH, typename vector_traits<T>::scalar_type neg_rcp2_VdotH_etaLdotH)`
	`96`	`+SDualMeasureQuant<T> createDualMeasureQuantity(const T specialMeasure, typename vector_traits<T>::scalar_type clampedNdotV, typename vector_traits<T>::scalar_type clampedNdotL, typename vector_traits<T>::scalar_type VdotHLdotH, typename vector_traits<T>::scalar_type neg_rcp2_refractionDenom)`
`97`	`97`	`{`
`98`		`- return impl::createDualMeasureQuantity_helper<T,reflect_refract>::__call(specialMeasure,clampedNdotV,clampedNdotL,VdotHLdotH,neg_rcp2_VdotH_etaLdotH);`
	`98`	`+ return impl::createDualMeasureQuantity_helper<T,reflect_refract>::__call(specialMeasure,clampedNdotV,clampedNdotL,VdotHLdotH,neg_rcp2_refractionDenom);`
`99`	`99`	`}`
`100`	`100`	`template<typename T, MicrofacetTransformTypes reflect_refract, class Query>`
`101`	`101`	`SDualMeasureQuant<T> createDualMeasureQuantity(const T specialMeasure, typename vector_traits<T>::scalar_type clampedNdotV, typename vector_traits<T>::scalar_type clampedNdotL, NBL_CONST_REF_ARG(Query) query)`
`102`	`102`	`{`
`103`		`- return impl::createDualMeasureQuantity_helper<T,reflect_refract>::__call(specialMeasure,clampedNdotV,clampedNdotL,query.getVdotHLdotH(),query.getNeg_rcp2_VdotH_etaLdotH());`
	`103`	`+ return impl::createDualMeasureQuantity_helper<T,reflect_refract>::__call(specialMeasure,clampedNdotV,clampedNdotL,query.getVdotHLdotH(),query.getNeg_rcp2_refractionDenom());`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`}`