Hlsl bxdfs 3 #899

devshgraphicsprogramming · 2025-07-03T13:15:29Z

Description

Continuing #811 due to GH UI messing up diffs again

Testing

TODO list:

devshgraphicsprogramming · 2025-07-09T12:45:55Z

Another Question, why don't we add this_t this_t::clamp(clampMode) methods to the interaction and light sample ?

devshgraphicsprogramming · 2025-07-09T12:49:04Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+        return sample_type::create(L, nbl::hlsl::dot<vector3_type>(V, L.direction), T, B, N);
+    }
+
+    sample_type generate_wo_clamps(NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction, NBL_REF_ARG(vector<scalar_type, 3>) u)


don't take vec3 by reference, take by copy as a const

devshgraphicsprogramming · 2025-07-09T12:49:51Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+        return (spectral_type)0;
+    }
+
+    sample_type __generate_wo_clamps(NBL_CONST_REF_ARG(vector3_type) V, NBL_CONST_REF_ARG(vector3_type) T, NBL_CONST_REF_ARG(vector3_type) B, NBL_CONST_REF_ARG(vector3_type) N, scalar_type NdotV, scalar_type absNdotV, NBL_REF_ARG(vector3_type) u, NBL_CONST_REF_ARG(fresnel::OrientedEtas<scalar_type>) orientedEta, NBL_CONST_REF_ARG(fresnel::OrientedEtaRcps<scalar_type>) rcpEta, NBL_REF_ARG(bool) transmitted)


~~take a scalar u~~

if you collapse all 3 generate methods into one, then keep taking a vec3 u

p.S. you could also have a __generate_wo_clamps which takes just isotropic interaction and spits out a single L ray_dir_info and LdotV not a full blown Light Sample,, then that could take a scalar u

devshgraphicsprogramming · 2025-07-09T13:01:08Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+        Refract<scalar_type> r = Refract<scalar_type>::create(rcpEta, V, N, NdotV);
+        bxdf::ReflectRefract<scalar_type> rr = bxdf::ReflectRefract<scalar_type>::create(transmitted, r);
+        L.direction = rr(transmitted);
+        return sample_type::create(L, nbl::hlsl::dot<vector3_type>(V, L.direction), T, B, N);


the ReflecctRefract::operator() could have an overload added

vector_type operator()(const bool doRefract, NBL_REF_ARG(scalar_type) out_IdotTorR) { const float a = hlsl::mix<scalar_type>(1.0f, rcpOrientedEta, doRefract); const float b = NdotI * a + NdotTorR; // assuming `I` is normalized out_IdotTorR = NdotI * b - a; return N * b - I * a; } vector_type operator()(const bool doRefract) { scalar_type dummy; return operator(doRefract,dummy); }

its slightly more efficient than doing the for proguct between L and V

devshgraphicsprogramming · 2025-07-09T13:08:44Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+        Refract<scalar_type> r = Refract<scalar_type>::create(rcpEta, V, N, NdotV);
+        bxdf::ReflectRefract<scalar_type> rr = bxdf::ReflectRefract<scalar_type>::create(transmitted, r);
+        L.direction = rr(transmitted);


the ray_dir_info_type and the ray_dir_info::Basic concept should have a method reflectRefract(NBL_CONST_REF_ARG(ReflectRefract<scalar_type>) rr, const bool tranmitted) which should be used instead of doing L.direction = rr(transmitted)

Why?
Because when we'ss use a RayDirInfo with ray-differentials or covariance tracing metadata we need to handle those extra parameters in the ray-dir-info (its not as simple as just setting a new ray direction) and by using the ray-dir-info's method to do that, the BxDFs don't need to care about how exacly its being done .

devshgraphicsprogramming · 2025-07-09T13:14:55Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+    quotient_pdf_type quotient_and_pdf(NBL_CONST_REF_ARG(params_isotropic_t) params)
+    {
+        const bool transmitted = ComputeMicrofacetNormal<vector3_type>::isTransmissionPath(params.getNdotVUnclamped(), params.getNdotLUnclamped());
+
+        fresnel::OrientedEtaRcps<scalar_type> rcpOrientedEtas = fresnel::OrientedEtaRcps<scalar_type>::create(params.getNdotV(), eta);
+
+        const scalar_type _pdf = bit_cast<scalar_type, uint32_t>(numeric_limits<scalar_type>::infinity);
+        scalar_type quo = hlsl::mix<scalar_type, bool>(1.0, rcpOrientedEtas.value, transmitted);
+        return quotient_pdf_type::create((spectral_type)(quo), _pdf);
+    }
+    quotient_pdf_type quotient_and_pdf(NBL_CONST_REF_ARG(params_anisotropic_t) params)
+    {
+        const bool transmitted = ComputeMicrofacetNormal<vector3_type>::isTransmissionPath(params.getNdotVUnclamped(), params.getNdotLUnclamped());
+
+        fresnel::OrientedEtaRcps<scalar_type> rcpOrientedEtas = fresnel::OrientedEtaRcps<scalar_type>::create(params.getNdotV(), eta);
+
+        const scalar_type _pdf = bit_cast<scalar_type, uint32_t>(numeric_limits<scalar_type>::infinity);
+        scalar_type quo = hlsl::mix(1.0, rcpOrientedEtas.value, transmitted);
+        return quotient_pdf_type::create((spectral_type)(quo), _pdf);
+    }


nope, that is not the correct quotient calculation

you transmit with probablity (1-reflectance)*deltaDistribution(L=V.refract(N)) and reflect with probability reflectance*deltaDistributiron(L=v.reflect(N))

This means your quotient_and_pdf is always (1.f,INF)

Why? There's no absorption, the light reflected and refracted always add up to 1 and you've importance sampled it perfectly.

devshgraphicsprogramming · 2025-07-09T13:16:07Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+    static this_t create(NBL_CONST_REF_ARG(spectral_type) eta2, NBL_CONST_REF_ARG(spectral_type) luminosityContributionHint)
+    {
+        this_t retval;
+        retval.eta2 = eta2;
+        retval.luminosityContributionHint = luminosityContributionHint;
+        return retval;
+    }
+
+    static this_t create(NBL_CONST_REF_ARG(SBxDFCreationParams<scalar_type, spectral_type>) params)
+    {
+        return create(params.eta2, params.luminosityContributionHint);
+    }
+
+    void init(NBL_CONST_REF_ARG(SBxDFCreationParams<scalar_type, spectral_type>) params)
+    {
+        eta2 = params.eta2;
+        luminosityContributionHint = params.luminosityContributionHint;
+    }


same comment as always

you could probide a single create from just eta which sets the luminosityContributionHint to the Rec.709 luma coefficients

devshgraphicsprogramming · 2025-07-09T13:18:14Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+    sample_type __generate_wo_clamps(NBL_CONST_REF_ARG(vector3_type) V, NBL_CONST_REF_ARG(vector3_type) T, NBL_CONST_REF_ARG(vector3_type) B, NBL_CONST_REF_ARG(vector3_type) N, scalar_type NdotV, scalar_type absNdotV, NBL_REF_ARG(vector3_type) u, NBL_CONST_REF_ARG(spectral_type) eta2, NBL_CONST_REF_ARG(spectral_type) luminosityContributionHint, NBL_REF_ARG(spectral_type) remainderMetadata)
+    {
+        // we will only ever intersect from the outside
+        const spectral_type reflectance = fresnel::thinDielectricInfiniteScatter<spectral_type>(fresnel::Dielectric<spectral_type>::__call(eta2,absNdotV));
+
+        // we are only allowed one choice for the entire ray, so make the probability a weighted sum
+        const scalar_type reflectionProb = nbl::hlsl::dot<spectral_type>(reflectance, luminosityContributionHint);
+
+        scalar_type rcpChoiceProb;
+        const bool transmitted = math::partitionRandVariable(reflectionProb, u.z, rcpChoiceProb);
+        remainderMetadata = (transmitted ? ((spectral_type)(1.0) - reflectance) : reflectance) * rcpChoiceProb;
+
+        ray_dir_info_type L;
+        L.direction = (transmitted ? (vector3_type)(0.0) : N * 2.0f * NdotV) - V;
+        return sample_type::create(L, nbl::hlsl::dot<vector3_type>(V, L.direction), T, B, N);
+    }
+
+    sample_type generate_wo_clamps(NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction, NBL_REF_ARG(vector<scalar_type, 3>) u)
+    {
+        scalar_type NdotV = interaction.isotropic.getNdotV();
+        vector3_type dummy;
+        return __generate_wo_clamps(interaction.isotropic.getV().getDirection(), interaction.getT(), interaction.getB(), interaction.isotropic.getN(), NdotV, NdotV, u, eta2, luminosityContributionHint, dummy);
+    }
+
+    sample_type generate(NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction, NBL_REF_ARG(vector<scalar_type, 3>) u)
+    {
+        scalar_type NdotV = interaction.isotropic.getNdotV();


~~again, just collapse the 3 generate together~~

or do 1 __generate_wo_clamps and 1 generate but have them both take an interaction instead of a V,T,B,N,...

devshgraphicsprogramming · 2025-07-09T13:21:49Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+    // its basically a set of weights that determine
+    // assert(1.0==luminosityContributionHint.r+luminosityContributionHint.g+luminosityContributionHint.b);
+    // `remainderMetadata` is a variable which the generator function returns byproducts of sample generation that would otherwise have to be redundantly calculated `quotient_and_pdf`
+    sample_type __generate_wo_clamps(NBL_CONST_REF_ARG(vector3_type) V, NBL_CONST_REF_ARG(vector3_type) T, NBL_CONST_REF_ARG(vector3_type) B, NBL_CONST_REF_ARG(vector3_type) N, scalar_type NdotV, scalar_type absNdotV, NBL_REF_ARG(vector3_type) u, NBL_CONST_REF_ARG(spectral_type) eta2, NBL_CONST_REF_ARG(spectral_type) luminosityContributionHint, NBL_REF_ARG(spectral_type) remainderMetadata)


luminosityContributionHint and eta2 are already member variables, why is the function taking them ?

devshgraphicsprogramming · 2025-07-09T13:25:31Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+        ray_dir_info_type L;
+        L.direction = (transmitted ? (vector3_type)(0.0) : N * 2.0f * NdotV) - V;


do it as L = transmitted ? V.transmit():V.reflect({...construct a fresnel::Reflect from N and NdotV directly...});

for same reasons of ray differentials or covariance tracing

you can also add a transmitReflect method to the concept if you wish and use that instead

devshgraphicsprogramming · 2025-07-09T13:27:23Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+    quotient_pdf_type quotient_and_pdf(NBL_CONST_REF_ARG(params_anisotropic_t) params)
+    {
+        const bool transmitted = ComputeMicrofacetNormal<vector3_type>::isTransmissionPath(params.getNdotVUnclamped(), params.getNdotLUnclamped());
+        const spectral_type reflectance = fresnel::thinDielectricInfiniteScatter<spectral_type>(fresnel::Dielectric<spectral_type>::__call(eta2, params.getNdotV()));
+        const spectral_type sampleValue = hlsl::mix(reflectance, (spectral_type)(1.0) - reflectance, transmitted);
+
+        const scalar_type sampleProb = nbl::hlsl::dot<spectral_type>(sampleValue,luminosityContributionHint);
+
+        const scalar_type _pdf = bit_cast<scalar_type, uint32_t>(numeric_limits<scalar_type>::infinity);
+        return quotient_pdf_type::create((spectral_type)(sampleValue / sampleProb), _pdf);
+    }


btw doesn't anisotropic cast down to isotropic or have a getter to get the isotropic ? So that aniso can call the iso method and return that saving us duplicate code ?

devshgraphicsprogramming · 2025-07-09T13:27:53Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+    {
+        const bool transmitted = ComputeMicrofacetNormal<vector3_type>::isTransmissionPath(params.getNdotVUnclamped(), params.getNdotLUnclamped());
+        const spectral_type reflectance = fresnel::thinDielectricInfiniteScatter<spectral_type>(fresnel::Dielectric<spectral_type>::__call(eta2, params.getNdotV()));
+        const spectral_type sampleValue = hlsl::mix(reflectance, (spectral_type)(1.0) - reflectance, transmitted);


use promote instead of dum C-cast for the 1.0

devshgraphicsprogramming · 2025-07-09T13:29:09Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+        const scalar_type sampleProb = nbl::hlsl::dot<spectral_type>(sampleValue,luminosityContributionHint);
+
+        const scalar_type _pdf = bit_cast<scalar_type, uint32_t>(numeric_limits<scalar_type>::infinity);
+        return quotient_pdf_type::create((spectral_type)(sampleValue / sampleProb), _pdf);


sampleValue is a spectral_type which should already have an operator/(scalar_type) no need to cast

devshgraphicsprogramming · 2025-07-09T13:30:46Z

include/nbl/builtin/hlsl/bxdf/transmission/smooth_dielectric.hlsl

+
+        ray_dir_info_type L;
+        L.direction = (transmitted ? (vector3_type)(0.0) : N * 2.0f * NdotV) - V;
+        return sample_type::create(L, nbl::hlsl::dot<vector3_type>(V, L.direction), T, B, N);


VdotL can be computed much more cheaply as (transmitted ? 0.f:2.f)*NdotV*NdotV-1.f;

devshgraphicsprogramming · 2025-07-09T13:36:31Z

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

+template<typename T NBL_PRIMARY_REQUIRES(is_scalar_v<T>)
+struct SAnisotropicParams
+{
+    using this_t = SAnisotropicParams<T>;
+
+    static this_t create(T NdotH, T one_minus_NdotH2_rcp, T TdotH2, T BdotH2, T nx, T ny)   // blinn-phong
+    {
+        this_t retval;
+        retval.NdotH = NdotH;
+        retval.one_minus_NdotH2_rcp = one_minus_NdotH2_rcp;
+        retval.TdotH2 = TdotH2;
+        retval.BdotH2 = BdotH2;
+        retval.nx = nx;
+        retval.ny = ny;
+        return retval;
+    }
+
+    static this_t create(T ax, T ay, T ax2, T ay2, T TdotH2, T BdotH2, T NdotH2)    // beckmann, ggx aniso
+    {
+        this_t retval;
+        retval.ax = ax;
+        retval.ax2 = ax2;
+        retval.ay = ay;
+        retval.ay2 = ay2;
+        retval.TdotH2 = TdotH2;
+        retval.BdotH2 = BdotH2;
+        retval.NdotH2 = NdotH2;
+        return retval;
+    }
+
+    static this_t create(T a2, T TdotH, T BdotH, T NdotH)   // ggx burley
+    {
+        this_t retval;
+        retval.ax = a2;
+        retval.TdotH = TdotH;
+        retval.BdotH = BdotH;
+        retval.NdotH = NdotH;
+        return retval;
+    }
+
+    T ax;
+    T ay;
+    T ax2;
+    T ay2;
+    T nx;
+    T ny;
+    T NdotH;
+    T TdotH;
+    T BdotH;
+    T NdotH2;
+    T TdotH2;
+    T BdotH2;
+    T one_minus_NdotH2_rcp;
+};


The Microfacet caches already have getters for all the dotH

Do not conflate per-ray and per-material values together.

Each NDF needs to have its own parameter struct with basic members (e.g. roughness) and expands that to more members inside itself via create if needed

Right now you've made a frankenstein that makes GGX keep BlinnPhong nx,ny exponents and Blinn Phong keep ax,ay roughnesses

Same with one_minus_NdotH2 only certain NDFs (seems Ashikhmin-shirley only) need it

the dotH can be rolled into a proto-microfacet cache structs

devshgraphicsprogramming · 2025-07-09T14:38:56Z

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

+    scalar_type operator()(SAnisotropicParams<scalar_type> params)
+    {
+        scalar_type n = (params.TdotH2 * params.ny + params.BdotH2 * params.nx) * params.one_minus_NdotH2_rcp;
+        return (isinf<scalar_type>(params.nx) || isinf<scalar_type>(params.ny)) ?  numeric_limits<scalar_type>::infinity : 


its enough to check that n is "large enough" e.g. >254 because pow with exponent higher than 254 is bound to make a lowest non denormalized number into an inf

devshgraphicsprogramming · 2025-07-09T14:39:40Z

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

+};
+
+
+template<typename T NBL_PRIMARY_REQUIRES(is_scalar_v<T>)


you actually need FloatingPointScalar on all the NDF, surely you don't want them to be creatable with integers and booleans, right ?

devshgraphicsprogramming · 2025-07-09T14:43:21Z

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

+    using scalar_type = T;
+


add some static functions to convert phong exponent to roughness squared and back, according to Walter et al.
https://github.com/Devsh-Graphics-Programming/Nabla/blob/1314fb0d05d85c2df8400733e4ff5602746a06a0/include/nbl/builtin/hlsl/bxdf/ndf/blinn_phong.hlsl

devshgraphicsprogramming · 2025-07-09T14:46:40Z

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

+            sqrt<scalar_type>((params.nx + 2.0) * (params.ny + 2.0)) * numbers::inv_pi<scalar_type> * 0.5 * pow<scalar_type>(params.NdotH, n);
+    }
+};
+
+template<typename T NBL_PRIMARY_REQUIRES(is_scalar_v<T>)
+struct Beckmann
+{
+    using scalar_type = T;
+
+    scalar_type operator()(SIsotropicParams<scalar_type> params)
+    {
+        scalar_type nom = exp<scalar_type>( (params.NdotH2 - 1.0) / (params.n_or_a2 * params.NdotH2) ); // exp(x) == exp2(x/log(2)) ?
+        scalar_type denom = params.n_or_a2 * params.NdotH2 * params.NdotH2;
+        return numbers::inv_pi<scalar_type> * nom / denom;
+    }
+
+    scalar_type operator()(SAnisotropicParams<scalar_type> params)
+    {
+        scalar_type nom = exp<scalar_type>(-(params.TdotH2 / params.ax2 + params.BdotH2 / params.ay2) / params.NdotH2);
+        scalar_type denom = params.ax * params.ay * params.NdotH2 * params.NdotH2;
+        return numbers::inv_pi<scalar_type> * nom / denom;
+    }
+};
+
+
+template<typename T NBL_PRIMARY_REQUIRES(is_scalar_v<T>)
+struct GGX
+{
+    using scalar_type = T;
+
+    // trowbridge-reitz
+    scalar_type operator()(SIsotropicParams<scalar_type> params)
+    {
+        scalar_type denom = params.NdotH2 * (params.n_or_a2 - 1.0) + 1.0;


literals need scalar_type(1.0) otherwise when scalar_type=double you loose precision and with scalar_type=float16_t you accidentally end up with float32_t promotions and truncations for parts of the expression

devshgraphicsprogramming · 2025-07-09T14:54:44Z

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

+    // burley
+    scalar_type operator()(SAnisotropicParams<scalar_type> params, scalar_type anisotropy)


this should have just been done with different creation parameters or a different NDF struct

devshgraphicsprogramming · 2025-07-09T14:55:33Z

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

+    }
+};
+
+template<typename T NBL_PRIMARY_REQUIRES(is_scalar_v<T>)
+struct Beckmann
+{
+    using scalar_type = T;
+
+    scalar_type operator()(SIsotropicParams<scalar_type> params)
+    {
+        scalar_type nom = exp<scalar_type>( (params.NdotH2 - 1.0) / (params.n_or_a2 * params.NdotH2) ); // exp(x) == exp2(x/log(2)) ?
+        scalar_type denom = params.n_or_a2 * params.NdotH2 * params.NdotH2;
+        return numbers::inv_pi<scalar_type> * nom / denom;
+    }
+
+    scalar_type operator()(SAnisotropicParams<scalar_type> params)
+    {
+        scalar_type nom = exp<scalar_type>(-(params.TdotH2 / params.ax2 + params.BdotH2 / params.ay2) / params.NdotH2);
+        scalar_type denom = params.ax * params.ay * params.NdotH2 * params.NdotH2;
+        return numbers::inv_pi<scalar_type> * nom / denom;
+    }
+};
+
+
+template<typename T NBL_PRIMARY_REQUIRES(is_scalar_v<T>)
+struct GGX
+{
+    using scalar_type = T;


because of the differing number of member parameters and implementations of operator() for each NDF you must have a different struct (add a trait ndf::is_anisotropic_v)

example, Isotropic GGX only needs a2 while anisotropic needs ax2,ay2,a2 (created from ax,ay or ax2 and ay2)

devshgraphicsprogramming · 2025-07-09T15:22:48Z

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

+
+    scalar_type operator()(SIsotropicParams<scalar_type> params)
+    {
+        scalar_type nom = exp<scalar_type>( (params.NdotH2 - 1.0) / (params.n_or_a2 * params.NdotH2) ); // exp(x) == exp2(x/log(2)) ?


you can slap the log<scalar_type>(2.f) into the a2*NdotH2 expression here

devshgraphicsprogramming · 2025-07-09T15:25:24Z

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

+template<class T, class U>
+struct is_ggx : bool_constant<
+    is_same<T, GGX<U> >::value
+> {};
+}
+
+template<class T> 
+struct is_ggx : impl::is_ggx<T, typename T::scalar_type> {};
+
+template<typename T>
+NBL_CONSTEXPR bool is_ggx_v = is_ggx<T>::value;


could be a general trait, not hidden in impl::

devshgraphicsprogramming · 2025-07-09T15:32:57Z

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

+// 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_BXDF_NDF_INCLUDED_
+#define _NBL_BUILTIN_HLSL_BXDF_NDF_INCLUDED_
+
+#include "nbl/builtin/hlsl/limits.hlsl"
+#include "nbl/builtin/hlsl/bxdf/common.hlsl"
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace bxdf
+{
+namespace ndf
+{


the NDF "fixes" the Lambda and Beta functions so it makes sense to have an ndf(this_t::query_type) (instead of just operator(this_t::query_type)) and lambda() methods instead of having the lambda buried somewhere else in anothre header

#811 (comment)

actualy ndf should be called D to be consistent with that PBR papers (Cook Torrance)

then vndf is DG1

So to recap:

D (the ndf)

Lambda

Beta

DG1

devshgraphicsprogramming · 2025-07-09T15:41:05Z

include/nbl/builtin/hlsl/bxdf/reflection/ggx.hlsl

+    using this_t = GGXParams<LS, SI, MC, Scalar>;
+
+    static this_t create(NBL_CONST_REF_ARG(LS) _sample, NBL_CONST_REF_ARG(SI) interaction, NBL_CONST_REF_ARG(MC) cache, BxDFClampMode _clamp)
+    {
+        this_t retval;
+        retval._sample = _sample;
+        retval.interaction = interaction;
+        retval.cache = cache;
+        retval._clamp = _clamp;
+        return retval;
+    }


again, pointless constructor, conflation of material properties with query data

devshgraphicsprogramming · 2025-07-09T15:42:06Z

include/nbl/builtin/hlsl/bxdf/reflection/ggx.hlsl

+    // iso
+    Scalar getNdotV() NBL_CONST_MEMBER_FUNC { return hlsl::mix(math::conditionalAbsOrMax<Scalar>(_clamp == BxDFClampMode::BCM_ABS, interaction.getNdotV(), 0.0), interaction.getNdotV(), _clamp == BxDFClampMode::BCM_NONE); }
+    Scalar getNdotVUnclamped() NBL_CONST_MEMBER_FUNC { return interaction.getNdotV(); }
+    Scalar getNdotV2() NBL_CONST_MEMBER_FUNC { return interaction.getNdotV2(); }
+    Scalar getNdotL() NBL_CONST_MEMBER_FUNC { return hlsl::mix(math::conditionalAbsOrMax<Scalar>(_clamp == BxDFClampMode::BCM_ABS, _sample.getNdotL(), 0.0), _sample.getNdotL(), _clamp == BxDFClampMode::BCM_NONE); }
+    Scalar getNdotLUnclamped() NBL_CONST_MEMBER_FUNC { return _sample.getNdotL(); }
+    Scalar getNdotL2() NBL_CONST_MEMBER_FUNC { return _sample.getNdotL2(); }
+    Scalar getVdotL() NBL_CONST_MEMBER_FUNC { return _sample.getVdotL(); }
+    Scalar getNdotH() NBL_CONST_MEMBER_FUNC { return cache.getNdotH(); }
+    Scalar getNdotH2() NBL_CONST_MEMBER_FUNC { return cache.getNdotH2(); }
+    Scalar getVdotH() NBL_CONST_MEMBER_FUNC { return cache.getVdotH(); }
+    Scalar getLdotH() NBL_CONST_MEMBER_FUNC { return cache.getLdotH(); }
+
+    LS _sample;
+    SI interaction;
+    MC cache;
+    BxDFClampMode _clamp;
+};
+template<class LS, class SI, class MC, typename Scalar>
+NBL_PARTIAL_REQ_TOP(surface_interactions::Anisotropic<SI> && AnisotropicMicrofacetCache<MC>)
+struct GGXParams<LS, SI, MC, Scalar NBL_PARTIAL_REQ_BOT(surface_interactions::Anisotropic<SI> && AnisotropicMicrofacetCache<MC>) >
+{
+    using this_t = GGXParams<LS, SI, MC, Scalar>;
+
+    static this_t create(NBL_CONST_REF_ARG(LS) _sample, NBL_CONST_REF_ARG(SI) interaction, NBL_CONST_REF_ARG(MC) cache, BxDFClampMode _clamp)
+    {
+        this_t retval;
+        retval._sample = _sample;
+        retval.interaction = interaction;
+        retval.cache = cache;
+        retval._clamp = _clamp;
+        return retval;
+    }
+
+    // iso
+    Scalar getNdotV() NBL_CONST_MEMBER_FUNC { return hlsl::mix(math::conditionalAbsOrMax<Scalar>(_clamp == BxDFClampMode::BCM_ABS, interaction.getNdotV(), 0.0), interaction.getNdotV(), _clamp == BxDFClampMode::BCM_NONE); }
+    Scalar getNdotVUnclamped() NBL_CONST_MEMBER_FUNC { return interaction.getNdotV(); }
+    Scalar getNdotV2() NBL_CONST_MEMBER_FUNC { return interaction.getNdotV2(); }
+    Scalar getNdotL() NBL_CONST_MEMBER_FUNC { return hlsl::mix(math::conditionalAbsOrMax<Scalar>(_clamp == BxDFClampMode::BCM_ABS, _sample.getNdotL(), 0.0), _sample.getNdotL(), _clamp == BxDFClampMode::BCM_NONE); }
+    Scalar getNdotLUnclamped() NBL_CONST_MEMBER_FUNC { return _sample.getNdotL(); }
+    Scalar getNdotL2() NBL_CONST_MEMBER_FUNC { return _sample.getNdotL2(); }
+    Scalar getVdotL() NBL_CONST_MEMBER_FUNC { return _sample.getVdotL(); }
+    Scalar getNdotH() NBL_CONST_MEMBER_FUNC { return cache.getNdotH(); }
+    Scalar getNdotH2() NBL_CONST_MEMBER_FUNC { return cache.getNdotH2(); }
+    Scalar getVdotH() NBL_CONST_MEMBER_FUNC { return cache.getVdotH(); }
+    Scalar getLdotH() NBL_CONST_MEMBER_FUNC { return cache.getLdotH(); }
+
+    // aniso
+    Scalar getTdotL2() NBL_CONST_MEMBER_FUNC { return _sample.getTdotL() * _sample.getTdotL(); }
+    Scalar getBdotL2() NBL_CONST_MEMBER_FUNC { return _sample.getBdotL() * _sample.getBdotL(); }
+    Scalar getTdotV2() NBL_CONST_MEMBER_FUNC { return interaction.getTdotV() * interaction.getTdotV(); }
+    Scalar getBdotV2() NBL_CONST_MEMBER_FUNC { return interaction.getBdotV() * interaction.getBdotV(); }
+    Scalar getTdotH2() NBL_CONST_MEMBER_FUNC {return cache.getTdotH() * cache.getTdotH(); }
+    Scalar getBdotH2() NBL_CONST_MEMBER_FUNC {return cache.getBdotH() * cache.getBdotH(); }


we definitely need getXdotY(const BxDFClampMode) on our interaction, sample and cache concepts and skip this insanity

devshgraphicsprogramming · 2025-07-09T15:49:06Z

include/nbl/builtin/hlsl/bxdf/reflection/ggx.hlsl

+    vector2_type A;
+    spectral_type ior0, ior1;


you need different BxDF or specializations for anisotropic and isotropic, different amounts of variables to precompute.

devshgraphicsprogramming · 2025-07-09T15:55:59Z

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

+    static this_t create(scalar_type NDFcos, scalar_type maxNdotV)
+    {
+        this_t retval;
+        retval.NDFcos = NDFcos;
+        if (is_ggx_v<NDF>)
+            retval.maxNdotL = maxNdotV;
+        else
+            retval.maxNdotV = maxNdotV;


this makes no sense to me when I'm reading it, why do we have NdotV thats then being assigned to NdotL when we have GGX

I'm pretty sure this is wrong for GGX, you can't just take the dot product of the view vector and geometrical normal and use it as the dot product of view and geometrical

devshgraphicsprogramming · 2025-07-09T15:57:43Z

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

+    scalar_type operator()()
+    {
+        if (is_ggx_v<NDF>)
+            return NDFcos * maxNdotL;
+        else
+            return 0.25 * NDFcos / maxNdotV;
+    }


write a comment that this computes the max(NdotL,0)/(4*max(NdotV,0)*max(NdotL,0)) factor which transforms PDFs in the f in projected microfacet f * NdotH measure to projected light measure f * NdotL

devshgraphicsprogramming · 2025-07-09T15:58:41Z

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

+template<typename NDF>
+struct microfacet_to_light_measure_transform<NDF,REFLECT_BIT>
+{
+    using this_t = microfacet_to_light_measure_transform<NDF,REFLECT_BIT>;
+    using scalar_type = typename NDF::scalar_type;
+
+    static this_t create(scalar_type NDFcos, scalar_type maxNdotV)


btw this doesn't need to be a struct, can be a plain old function (if you need partial specs, can be like the tgmath functions calling an impl::helper)

because right now you're constructing the structs immediately with create and calling operator() on them immediately, also there's literally no input argument you could cache for multiple calls

keptsecret added 30 commits November 25, 2024 17:05

some test bxdfs using concepts and templates

34ee35c

some corrections

f6752c6

anisotropic concept

42fcb2a

concepts for existing stuff

81e56f4

more templated stuff, new type trait dimensions

1e73953

template conditionalabs

6253da8

completed adapting functions?

d13cad4

added bxdf concept

7110c50

fresnel function templates

98a0be1

lambertian, oren nayar brdf

eef66c6

removed dimensions, extended rank/extent to vectors/matrix

eec8486

impl geom_smith and ndf funcs

fcadc22

more bxdfs, fix concepts

9742aa1

restructure existing bxdfs

8433133

ggx brdf

bafe623

some bsdfs

3ad9f44

beckmann bsdf, bug fixes

bc13d1f

typedefs in concepts

f56476e

ndfs as structs()

fe7c882

redid microfacet_to_light_transform as all structs

a12d8d1

fixed missing type

328c7ea

changed geom smith to templated structs

aeafa07

adjusted BxDF concept, new impl BxDF structs

91ca79e

refactored brdfs

3401783

corrected concept macro usage

3115423

finished beckmann+ggx bsdfs, fixed typos

b244c12

changes for cpp compat

e8d5aa3

Merge branch 'master' into hlsl_bxdfs

8158aea

moved math functions to tgmath

d632b3a

Merge branch 'master' into hlsl_bxdfs

3df4851

devshgraphicsprogramming commented Jul 9, 2025

View reviewed changes

		ray_dir_info_type L;
		L.direction = (transmitted ? (vector3_type)(0.0) : N * 2.0f * NdotV) - V;

		// burley
		scalar_type operator()(SAnisotropicParams<scalar_type> params, scalar_type anisotropy)

		};


		template<typename T NBL_PRIMARY_REQUIRES(is_scalar_v<T>)

Hlsl bxdfs 3 #899

Are you sure you want to change the base?

Hlsl bxdfs 3 #899

Conversation

devshgraphicsprogramming commented Jul 3, 2025

Description

Testing

TODO list:

Uh oh!

devshgraphicsprogramming commented Jul 9, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Jul 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Jul 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Jul 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Jul 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Jul 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

devshgraphicsprogramming Jul 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

devshgraphicsprogramming Jul 9, 2025 •

edited

Loading

devshgraphicsprogramming Jul 9, 2025 •

edited

Loading

devshgraphicsprogramming Jul 9, 2025 •

edited

Loading

devshgraphicsprogramming Jul 9, 2025 •

edited

Loading

devshgraphicsprogramming Jul 9, 2025 •

edited

Loading

devshgraphicsprogramming Jul 9, 2025 •

edited

Loading