Bxdf fixes cook torrance #930
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -84,10 +84,13 @@ struct check_TIR_helper<F, false> | |
| template<class F> | ||
| struct check_TIR_helper<F, true> | ||
| { | ||
| using vector_type = typename F::vector_type; // expect monochrome | ||
|
|
||
| template<class MicrofacetCache> | ||
| static bool __call(NBL_CONST_REF_ARG(F) fresnel, NBL_CONST_REF_ARG(MicrofacetCache) cache) | ||
| { | ||
| fresnel::OrientedEtas<vector_type> orientedEta = fresnel::OrientedEtas<vector_type>::create(typename F::scalar_type(1.0), hlsl::promote<vector_type>(fresnel.getRefractionOrientedEta())); | ||
| return cache.isValid(orientedEta); | ||
| } | ||
| }; | ||
|
|
||
|
|
@@ -131,33 +134,40 @@ struct SCookTorrance | |
| NBL_CONSTEXPR_STATIC_INLINE bool IsAnisotropic = ndf_type::IsAnisotropic; | ||
| NBL_CONSTEXPR_STATIC_INLINE bool IsBSDF = ndf_type::NDFSurfaceType != ndf::MTT_REFLECT; | ||
|
|
||
| template<class Interaction, class MicrofacetCache> | ||
| static bool __checkValid(NBL_CONST_REF_ARG(fresnel_type) f, NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache) | ||
|
||
| { | ||
| NBL_IF_CONSTEXPR(IsBSDF) | ||
| return impl::check_TIR_helper<fresnel_type, IsBSDF>::template __call<MicrofacetCache>(f, cache); | ||
| else | ||
| return _sample.getNdotL() > numeric_limits<scalar_type>::min && interaction.getNdotV() > numeric_limits<scalar_type>::min; | ||
| } | ||
|
|
||
| template<class Interaction, class MicrofacetCache> | ||
| spectral_type __eval(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache) | ||
| { | ||
| fresnel_type _f = fresnel; | ||
| NBL_IF_CONSTEXPR(IsBSDF) | ||
| _f = impl::getOrientedFresnel<fresnel_type, IsBSDF>::__call(fresnel, interaction.getNdotV()); | ||
| if (!__checkValid<Interaction, MicrofacetCache>(_f, _sample, interaction, cache)) | ||
| return hlsl::promote<spectral_type>(0.0); | ||
|
|
||
| using quant_query_type = typename ndf_type::quant_query_type; | ||
| scalar_type dummy; | ||
| quant_query_type qq = ndf.template createQuantQuery<MicrofacetCache>(cache, dummy); | ||
|
||
|
|
||
| quant_type D = ndf.template D<sample_type, Interaction, MicrofacetCache>(qq, _sample, interaction, cache); | ||
| scalar_type DG = D.projectedLightMeasure; | ||
| if (D.microfacetMeasure < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity)) | ||
| { | ||
| using g2g1_query_type = typename ndf_type::g2g1_query_type; | ||
| g2g1_query_type gq = ndf.template createG2G1Query<sample_type, Interaction>(_sample, interaction); | ||
| DG *= ndf.template correlated<sample_type, Interaction>(gq, _sample, interaction); | ||
|
Comment on lines
175
to
178
There was a problem hiding this comment. we must let NDF provide a We could actually do this in the following way using quant_query_type = typename ndf_type::quant_query_type;
scalar_type dummy;
quant_query_type qq = ndf.template createQuantQuery<MicrofacetCache>(cache, dummy);
quant_type D = ndf.template D<sample_type, Interaction, MicrofacetCache>(qq, _sample, interaction, cache);
scalar_type DG = D.projectedLightMeasure;
if (D.microfacetMeasure < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity))
{
using g2g1_query_type = typename ndf_type::g2g1_query_type;
g2g1_query_type gq = ndf.template createG2G1Query<sample_type, Interaction>(_sample, interaction);
DG *= ndf.template correlated<sample_type, Interaction>(gq, _sample, interaction);
}
// overwrites DG with NDF's `Dcorrelated` method, also `asserts` that the optimal method returns similar to above
impl::overwrite_DG<ndf_type,sample_type,Interaction,Cache>(/*NBL_REF_ARG*/DG,ndf,...);continues #930 (comment) |
||
| } | ||
| scalar_type clampedVdotH = cache.getVdotH(); | ||
| NBL_IF_CONSTEXPR(IsBSDF) | ||
| clampedVdotH = hlsl::abs(clampedVdotH); | ||
| return impl::__implicit_promote<spectral_type, typename fresnel_type::vector_type>::__call(_f(clampedVdotH)) * DG; | ||
| } | ||
| template<typename C=bool_constant<!IsAnisotropic> > | ||
| enable_if_t<C::value && !IsAnisotropic, spectral_type> eval(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(isotropic_interaction_type) interaction, NBL_CONST_REF_ARG(isocache_type) cache) | ||
|
|
@@ -172,79 +182,109 @@ struct SCookTorrance | |
| 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_REF_ARG(anisocache_type) cache) | ||
| { | ||
| if (interaction.getNdotV() > numeric_limits<scalar_type>::min) | ||
|
||
| { | ||
| ray_dir_info_type invalidL; | ||
| invalidL.makeInvalid(); | ||
| return sample_type::createFromTangentSpace(invalidL, interaction.getFromTangentSpace()); | ||
|
||
| } | ||
|
|
||
| const vector3_type localV = interaction.getTangentSpaceV(); | ||
| const vector3_type localH = ndf.generateH(localV, u); | ||
| const scalar_type VdotH = hlsl::dot(localV, localH); | ||
| const vector3_type H = hlsl::mul(interaction.getFromTangentSpace(), localH); | ||
|
|
||
| ray_dir_info_type L; | ||
| if (scalar_type(2.0) * VdotH * localH.z > localV.z) // NdotL>0, compiler's Common Subexpression Elimination pass should re-use 2*VdotH later | ||
| { | ||
| assert(VdotH >= scalar_type(0.0)); | ||
|
||
| ray_dir_info_type V = interaction.getV(); | ||
| struct reflect_wrapper // so we don't recalculate VdotH | ||
| { | ||
| vector3_type operator()() NBL_CONST_MEMBER_FUNC | ||
| { | ||
| return r(VdotH); | ||
| } | ||
| bxdf::Reflect<scalar_type> r; | ||
| scalar_type VdotH; | ||
| }; | ||
| reflect_wrapper rw; | ||
| rw.r = bxdf::Reflect<scalar_type>::create(V.getDirection(), H); | ||
| rw.VdotH = VdotH; | ||
| L = V.template reflect<reflect_wrapper>(rw); | ||
|
|
||
| cache = anisocache_type::createForReflection(localV, localH); | ||
| } | ||
| else // fail if samples have invalid paths | ||
| L.makeInvalid(); // should check if sample direction is invalid | ||
|
|
||
| const vector3_type T = interaction.getT(); | ||
| const vector3_type B = interaction.getB(); | ||
| const vector3_type _N = interaction.getN(); | ||
|
|
||
| return sample_type::create(L, T, B, _N); | ||
| } | ||
| 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_REF_ARG(anisocache_type) cache) | ||
| { | ||
| const vector3_type localV = interaction.getTangentSpaceV(); | ||
| const scalar_type NdotV = localV.z; | ||
|
|
||
| fresnel_type _f = impl::getOrientedFresnel<fresnel_type, IsBSDF>::__call(fresnel, NdotV); | ||
| fresnel::OrientedEtaRcps<monochrome_type> rcpEta = _f.getOrientedEtaRcps(); | ||
|
|
||
| const vector3_type upperHemisphereV = ieee754::flipSignIfRHSNegative<vector3_type>(localV, hlsl::promote<vector3_type>(NdotV)); | ||
| const vector3_type localH = ndf.generateH(upperHemisphereV, u.xy); | ||
| const scalar_type VdotH = hlsl::dot(localV, localH); | ||
| const vector3_type H = hlsl::mul(interaction.getFromTangentSpace(), localH); | ||
|
||
|
|
||
| assert(NdotV * VdotH > scalar_type(0.0)); | ||
| const scalar_type reflectance = _f(hlsl::abs(VdotH))[0]; | ||
|
|
||
| scalar_type rcpChoiceProb; | ||
| scalar_type z = u.z; | ||
| bool transmitted = math::partitionRandVariable(reflectance, z, rcpChoiceProb); | ||
|
|
||
| ray_dir_info_type V = interaction.getV(); | ||
| const vector3_type _N = interaction.getN(); | ||
| Refract<scalar_type> r = Refract<scalar_type>::create(V.getDirection(), H); | ||
| const scalar_type LdotH = hlsl::mix(VdotH, r.getNdotT(rcpEta.value2[0]), transmitted); | ||
| cache = anisocache_type::createPartial(VdotH, LdotH, hlsl::dot(_N, H), transmitted, rcpEta); | ||
|
||
|
|
||
| struct reflect_refract_wrapper // so we don't recalculate LdotH | ||
| { | ||
| vector3_type operator()(const bool doRefract, const scalar_type rcpOrientedEta) NBL_CONST_MEMBER_FUNC | ||
| { | ||
| return rr(NdotTorR, rcpOrientedEta); | ||
| } | ||
| bxdf::ReflectRefract<scalar_type> rr; | ||
|
Comment on lines
+276
to
+278
There was a problem hiding this comment. leave a comment that the call |
||
| scalar_type NdotTorR; | ||
| }; | ||
| bxdf::ReflectRefract<scalar_type> rr; | ||
| rr.refract = r; | ||
| reflect_refract_wrapper rrw; | ||
| rrw.rr = rr; | ||
| rrw.NdotTorR = LdotH; | ||
| ray_dir_info_type L = V.template reflectRefract<reflect_refract_wrapper>(rrw, transmitted, rcpEta.value[0]); | ||
|
|
||
| const vector3_type T = interaction.getT(); | ||
| const vector3_type B = interaction.getB(); | ||
|
|
||
| // fail if samples have invalid paths | ||
| const scalar_type NdotL = scalar_type(2.0) * VdotH * localH.z - localV.z; | ||
|
||
| if ((ComputeMicrofacetNormal<scalar_type>::isTransmissionPath(NdotV, NdotL) != transmitted)) | ||
| L.makeInvalid(); // should check if sample direction is invalid | ||
| else | ||
| { | ||
| fresnel::OrientedEtas<monochrome_type> orientedEta = fresnel::OrientedEtas<monochrome_type>::create(scalar_type(1.0), hlsl::promote<monochrome_type>(fresnel.getRefractionOrientedEta())); | ||
| assert(ComputeMicrofacetNormal::isValidMicrofacet(transmitted,cache.getVdotL(),localH.z,orientedEta)); | ||
| cache.fillTangents(T, B, H); | ||
| } | ||
|
|
||
| return sample_type::create(L, T, B, _N); | ||
|
||
| } | ||
| template<typename C=bool_constant<!IsAnisotropic>, typename T=conditional_t<IsBSDF, vector3_type, vector2_type> > | ||
| enable_if_t<C::value && !IsAnisotropic, sample_type> generate(NBL_CONST_REF_ARG(isotropic_interaction_type) interaction, const T u, NBL_REF_ARG(isocache_type) cache) | ||
|
||
| { | ||
| anisocache_type aniso_cache; | ||
| sample_type s = generate(anisotropic_interaction_type::create(interaction), u, aniso_cache); | ||
|
|
@@ -277,46 +317,57 @@ struct SCookTorrance | |
| template<typename C=bool_constant<!IsAnisotropic> > | ||
| enable_if_t<C::value && !IsAnisotropic, scalar_type> pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(isotropic_interaction_type) interaction, NBL_CONST_REF_ARG(isocache_type) cache) | ||
| { | ||
| fresnel_type _f = fresnel; | ||
| NBL_IF_CONSTEXPR(IsBSDF) | ||
| _f = impl::getOrientedFresnel<fresnel_type, IsBSDF>::__call(fresnel, interaction.getNdotV()); | ||
|
||
| if (!__checkValid<isotropic_interaction_type, isocache_type>(_f, _sample, interaction, cache)) | ||
| return scalar_type(0.0); | ||
|
|
||
| scalar_type _pdf = __pdf<isotropic_interaction_type, isocache_type>(_sample, interaction, cache); | ||
| return hlsl::mix(scalar_type(0.0), _pdf, _pdf < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity)); | ||
| } | ||
| scalar_type pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction, NBL_CONST_REF_ARG(anisocache_type) cache) | ||
| { | ||
| fresnel_type _f = fresnel; | ||
| NBL_IF_CONSTEXPR(IsBSDF) | ||
| _f = impl::getOrientedFresnel<fresnel_type, IsBSDF>::__call(fresnel, interaction.getNdotV()); | ||
| if (!__checkValid<anisotropic_interaction_type, anisocache_type>(_f, _sample, interaction, cache)) | ||
| return scalar_type(0.0); | ||
|
|
||
| scalar_type _pdf = __pdf<anisotropic_interaction_type, anisocache_type>(_sample, interaction, cache); | ||
| return hlsl::mix(scalar_type(0.0), _pdf, _pdf < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity)); | ||
| } | ||
|
|
||
| template<class Interaction, class MicrofacetCache> | ||
| quotient_pdf_type __quotient_and_pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(Interaction) interaction, NBL_CONST_REF_ARG(MicrofacetCache) cache) | ||
| { | ||
| 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); | ||
| fresnel_type _f = impl::getOrientedFresnel<fresnel_type, IsBSDF>::__call(fresnel, interaction.getNdotV()); | ||
devshgraphicsprogramming marked this conversation as resolved.
Show resolved
Hide resolved
|
||
|
|
||
| const bool notTIR = impl::check_TIR_helper<fresnel_type, IsBSDF>::template __call<MicrofacetCache>(_f, cache); | ||
| assert(notTIR); | ||
|
||
|
|
||
| scalar_type G2_over_G1 = scalar_type(1.0); | ||
| if (_pdf < bit_cast<scalar_type>(numeric_limits<scalar_type>::infinity)) | ||
| { | ||
| using g2g1_query_type = typename N::g2g1_query_type; | ||
| g2g1_query_type gq = ndf.template createG2G1Query<sample_type, Interaction>(_sample, interaction); | ||
| G2_over_G1 = ndf.template G2_over_G1<sample_type, Interaction, MicrofacetCache>(gq, _sample, interaction, cache); | ||
| } | ||
|
|
||
| spectral_type quo; | ||
| NBL_IF_CONSTEXPR(IsBSDF) | ||
| quo = hlsl::promote<spectral_type>(G2_over_G1); | ||
| else | ||
| { | ||
| const scalar_type VdotH = cache.getVdotH(); | ||
| assert(VdotH > scalar_type(0.0)); | ||
| quo = _f(VdotH) * G2_over_G1; | ||
| } | ||
|
|
||
| return quotient_pdf_type::create(quo, _pdf); | ||
| } | ||
| template<typename C=bool_constant<!IsAnisotropic> > | ||
|
|
||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
why are you promoting to a vector!?
Cache.isValidMUST take the Eta as a scalar!!!!Uh oh!
There was an error while loading. Please reload this page.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
The
ComputeMicrofacetNormal::isValidthatcache.isValiduses is called withOrientedEtatype. Does that need to take eta (and rcp_eta) as scalar(s) then? Or just move construction ofOrientedEtaintocache.isValidThere was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
OrientedEta<scalar_type> or
scalar_typeyes