Incorporate diffuse MaterialX BSDFs to BSDL (#2092)

* Implement get_albedo() for BSDL imported BSDFs

We forgot to forward the albedo function to BSDL and also to
implement it for the latest MaterialX components added to BSDL
recently. This led to not very good sampling quality.

Signed-off-by: Alejandro Conty <aconty@imageworks.com>

* Incorporate diffuse MaterialX BSDFs to BSDL

This is just a code movement. The implementation was already there. Just
relocated to the BSDL framework the following items:
- burley_diffuse_bsdf
- oren_nayar_diffuse_bsdf
- translucent_bsdf

There are sampling noise differences that require updating the tests,
but otherwise images look identical.

Signed-off-by: Alejandro Conty <aconty@imageworks.com>

* Update testsuite refs and thresholds

Due to the last two commits (BSDL albedo fix and diffuse MTX code
movement) some references had to be updated due to noise differences.
I'm also following the policy of keeping as few refs as possible and
opening the thresholds so different platforms LSB differences are
accepted.

---------

Signed-off-by: Alejandro Conty <aconty@imageworks.com>

Author: aconty

src/libbsdl/include/BSDL/MTX/bsdf_burley_diffuse_decl.h

@@ -0,0 +1,58 @@
+// Copyright Contributors to the Open Shading Language project.
+// SPDX-License-Identifier: BSD-3-Clause
+// https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
+
+
+#pragma once
+
+#include <BSDL/bsdf_decl.h>
+
+BSDL_ENTER_NAMESPACE
+
+namespace mtx {
+
+template<typename BSDF_ROOT> struct BurleyDiffuseLobe : public Lobe<BSDF_ROOT> {
+    using Base = Lobe<BSDF_ROOT>;
+
+    struct Data {
+        Imath::V3f N;
+        Imath::C3f albedo;
+        float roughness;
+        Stringhash label;
+        using lobe_type = BurleyDiffuseLobe<BSDF_ROOT>;
+    };
+
+    template<typename D> static typename LobeRegistry<D>::Entry entry()
+    {
+        static_assert(
+            std::is_base_of<Data, D>::value);  // Make no other assumptions
+        using R = LobeRegistry<D>;
+        return { name(),
+                 { R::param(&D::N), R::param(&D::albedo),
+                   R::param(&D::roughness), R::param(&D::label, "label"),
+                   R::close() } };
+    }
+
+    template<typename T>
+    BSDL_INLINE_METHOD BurleyDiffuseLobe(T*, const BsdfGlobals& globals,
+                                         const Data& data);
+
+    static constexpr const char* name() { return "burley_diffuse_bsdf"; }
+
+    BSDL_INLINE_METHOD Power albedo_impl() const { return diff_albedo; }
+
+    BSDL_INLINE_METHOD Sample eval_impl(const Imath::V3f& wo,
+                                        const Imath::V3f& wi) const;
+    BSDL_INLINE_METHOD Sample sample_impl(const Imath::V3f& wo,
+                                          const Imath::V3f& rnd) const;
+
+private:
+    static BSDL_INLINE_METHOD float fresnel(float cos_theta, float F90);
+
+    Power diff_albedo;
+    float diff_roughness;
+};
+
+}  // namespace mtx
+
+BSDL_LEAVE_NAMESPACE

src/libbsdl/include/BSDL/MTX/bsdf_burley_diffuse_impl.h

@@ -0,0 +1,74 @@
+// Copyright Contributors to the Open Shading Language project.
+// SPDX-License-Identifier: BSD-3-Clause
+// https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
+
+
+#pragma once
+
+#include <BSDL/MTX/bsdf_burley_diffuse_decl.h>
+
+BSDL_ENTER_NAMESPACE
+
+namespace mtx {
+
+template<typename BSDF_ROOT>
+template<typename T>
+BSDL_INLINE_METHOD
+BurleyDiffuseLobe<BSDF_ROOT>::BurleyDiffuseLobe(T* lobe,
+                                                const BsdfGlobals& globals,
+                                                const Data& data)
+    : Base(lobe, globals.visible_normal(data.N), 1.0f, globals.lambda_0, false)
+    , diff_albedo(globals.wave(data.albedo))
+    , diff_roughness(CLAMP(data.roughness, 0.0f, 1.0f))
+{
+    Base::sample_filter = globals.get_sample_filter(Base::frame.Z, true);
+}
+
+template<typename BSDF_ROOT>
+BSDL_INLINE_METHOD float
+BurleyDiffuseLobe<BSDF_ROOT>::fresnel(float cos_theta, float F90)
+{
+    const float x = CLAMP(1.0f - cos_theta, 0.0f, 1.0f);
+    return LERP(pown<5>(x), 1.0f, F90);
+}
+
+template<typename BSDF_ROOT>
+BSDL_INLINE_METHOD Sample
+BurleyDiffuseLobe<BSDF_ROOT>::eval_impl(const Imath::V3f& wo,
+                                        const Imath::V3f& wi) const
+{
+    if (wo.z <= 0.0f || wi.z <= 0.0f)
+        return {};
+
+    const Imath::V3f H = wi + wo;
+    if (MAX_ABS_XYZ(H) < EPSILON)
+        return {};
+    // From "Physically Based Shading at Disney" by Brent Burley, section 5.3
+    const Imath::V3f Hn = H.normalized();
+    const float cosHI   = CLAMP(wi.dot(Hn), 0.0f, 1.0f);
+    const float cosNO   = CLAMP(wo.z, 0.0f, 1.0f);
+    const float cosNI   = CLAMP(wi.z, 0.0f, 1.0f);
+    // Loses energy with low roughness at grazing angles. Gains it at high roughness
+    const float F90  = 0.5f + 2.0f * diff_roughness * SQR(cosHI);
+    const float refL = fresnel(cosNI, F90);
+    const float refV = fresnel(cosNO, F90);
+    const float pdf  = cosNI * ONEOVERPI;
+
+    return { wi, diff_albedo * (refL * refV), pdf, 1.0f };
+}
+
+template<typename BSDF_ROOT>
+BSDL_INLINE_METHOD Sample
+BurleyDiffuseLobe<BSDF_ROOT>::sample_impl(const Imath::V3f& wo,
+                                          const Imath::V3f& rnd) const
+{
+    if (wo.z <= 0.0f)
+        return {};
+
+    Imath::V3f wi = sample_cos_hemisphere(rnd.x, rnd.y);
+    return eval_impl(wo, wi);
+}
+
+}  // namespace mtx
+
+BSDL_LEAVE_NAMESPACE

src/libbsdl/include/BSDL/MTX/bsdf_dielectric_decl.h

@@ -149,6 +149,11 @@ template<typename BSDF_ROOT> struct DielectricLobe : public Lobe<BSDF_ROOT> {
         return !dorefr ? E_ms * wo_absorption : Power::ZERO();
     }
 
+    BSDL_INLINE_METHOD Power albedo_impl() const
+    {
+        return !dorefr ? refl_tint * (1 - E_ms) : Power::UNIT();
+    }
+
     BSDL_INLINE_METHOD bool single_wavelength() const { return dispersion; }
 
 protected:

src/libbsdl/include/BSDL/MTX/bsdf_oren_nayar_diffuse_decl.h

@@ -0,0 +1,65 @@
+// Copyright Contributors to the Open Shading Language project.
+// SPDX-License-Identifier: BSD-3-Clause
+// https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
+
+
+#pragma once
+
+#include <BSDL/bsdf_decl.h>
+
+BSDL_ENTER_NAMESPACE
+
+namespace mtx {
+
+template<typename BSDF_ROOT>
+struct OrenNayarDiffuseLobe : public Lobe<BSDF_ROOT> {
+    using Base = Lobe<BSDF_ROOT>;
+
+    struct Data {
+        Imath::V3f N;
+        Imath::C3f albedo;
+        float roughness;
+        int energy_compensation;
+        Stringhash label;
+        using lobe_type = OrenNayarDiffuseLobe<BSDF_ROOT>;
+    };
+
+    template<typename D> static typename LobeRegistry<D>::Entry entry()
+    {
+        static_assert(
+            std::is_base_of<Data, D>::value);  // Make no other assumptions
+        using R = LobeRegistry<D>;
+        return { name(),
+                 { R::param(&D::N), R::param(&D::albedo),
+                   R::param(&D::roughness),
+                   R::param(&D::energy_compensation, "energy_compensation"),
+                   R::param(&D::label, "label"), R::close() } };
+    }
+
+    template<typename T>
+    BSDL_INLINE_METHOD OrenNayarDiffuseLobe(T*, const BsdfGlobals& globals,
+                                            const Data& data);
+
+    static constexpr const char* name() { return "oren_nayar_diffuse_bsdf"; }
+
+    BSDL_INLINE_METHOD Power albedo_impl() const { return diff_albedo; }
+
+    BSDL_INLINE_METHOD Sample eval_impl(const Imath::V3f& wo,
+                                        const Imath::V3f& wi) const;
+    BSDL_INLINE_METHOD Sample sample_impl(const Imath::V3f& wo,
+                                          const Imath::V3f& rnd) const;
+
+private:
+    BSDL_INLINE_METHOD float E_FON_analytic(float mu) const;
+
+    static constexpr float constant1_FON = 0.5f - 2.0f / (3.0f * PI);
+    static constexpr float constant2_FON = 2.0f / 3.0f - 28.0f / (15.0f * PI);
+
+    Power diff_albedo;
+    float diff_roughness;
+    bool do_energy_compensation;
+};
+
+}  // namespace mtx
+
+BSDL_LEAVE_NAMESPACE

src/libbsdl/include/BSDL/MTX/bsdf_oren_nayar_diffuse_impl.h

@@ -0,0 +1,113 @@
+// Copyright Contributors to the Open Shading Language project.
+// SPDX-License-Identifier: BSD-3-Clause
+// https://github.com/AcademySoftwareFoundation/OpenShadingLanguage
+
+
+#pragma once
+
+#include <BSDL/MTX/bsdf_oren_nayar_diffuse_decl.h>
+
+BSDL_ENTER_NAMESPACE
+
+namespace mtx {
+
+template<typename BSDF_ROOT>
+template<typename T>
+BSDL_INLINE_METHOD
+OrenNayarDiffuseLobe<BSDF_ROOT>::OrenNayarDiffuseLobe(
+    T* lobe, const BsdfGlobals& globals, const Data& data)
+    : Base(lobe, globals.visible_normal(data.N), 1.0f, globals.lambda_0, false)
+    , diff_albedo(globals.wave(data.albedo))
+    , diff_roughness(CLAMP(data.roughness, 0.0f, 1.0f))
+    , do_energy_compensation(data.energy_compensation != 0)
+{
+    Base::sample_filter = globals.get_sample_filter(Base::frame.Z, true);
+}
+
+template<typename BSDF_ROOT>
+BSDL_INLINE_METHOD float
+OrenNayarDiffuseLobe<BSDF_ROOT>::E_FON_analytic(float mu) const
+{
+    const float sigma = diff_roughness;
+    const float AF    = 1.0f / (1.0f + constant1_FON * sigma);
+    const float BF    = sigma * AF;
+    const float Si    = sqrtf(std::max(0.0f, 1.0f - mu * mu));
+    const float G
+        = Si * (BSDLConfig::Fast::acosf(mu) - Si * mu)
+          + 2.0f * ((Si / std::max(mu, 1e-7f)) * (1.0f - Si * Si * Si) - Si)
+                * (1.0f / 3.0f);
+    return AF + (BF * ONEOVERPI) * G;
+}
+
+template<typename BSDF_ROOT>
+BSDL_INLINE_METHOD Sample
+OrenNayarDiffuseLobe<BSDF_ROOT>::eval_impl(const Imath::V3f& wo,
+                                           const Imath::V3f& wi) const
+{
+    const float cosNI = CLAMP(wi.z, 0.0f, 1.0f);
+    const float cosNO = CLAMP(wo.z, 0.0f, 1.0f);
+    if (cosNI <= 0.0f || cosNO <= 0.0f)
+        return {};
+
+    const float cosIO = CLAMP(wo.dot(wi), -1.0f, 1.0f);
+    const float s     = cosIO - cosNI * cosNO;
+    const float pdf   = cosNI * ONEOVERPI;
+
+    if (!do_energy_compensation) {
+        // Simplified math from: "A tiny improvement of Oren-Nayar reflectance model"
+        // by Yasuhiro Fujii
+        // http://mimosa-pudica.net/improved-oren-nayar.html
+        // NOTE: This is using the math to match the original qualitative ON model
+        // (QON in the paper above) and not the tweak proposed in the text which
+        // is a slightly different BRDF (FON in the paper above). This is done for
+        // backwards compatibility purposes only.
+        const float s2    = SQR(diff_roughness);
+        const float A     = 1.0f - 0.50f * s2 / (s2 + 0.33f);
+        const float B     = 0.45f * s2 / (s2 + 0.09f);
+        const float stinv = s > 0.0f ? s / std::max(cosNI, cosNO) : 0.0f;
+        const float f_ss  = A + B * stinv;
+        return { wi, diff_albedo * f_ss, pdf, 1.0f };
+    } else {
+        // Code below from Jamie Portsmouth's tech report on Energy conversion Oren-Nayar
+        // See slack thread for whitepaper:
+        // https://academysoftwarefdn.slack.com/files/U03SWQFPD08/F06S50CUKV1/oren_nayar.pdf
+        // rho should be the albedo which is a parameter of the closure in the Mx parameters
+        // This only matters for the color-saturation aspect of the BRDF which is rather subtle anyway
+        // and not always desireable for artists. Hardcoding to 1 leaves the coloring entirely up to the
+        // closure weight.
+        const float AF    = 1.0f / (1.0f + constant1_FON * diff_roughness);
+        const float stinv = s > 0.0f ? s / std::max(cosNI, cosNO) : s;
+        const float f_ss  = AF * (1.0f + diff_roughness * stinv);
+        const float EFo   = E_FON_analytic(cosNO);
+        const float EFi   = E_FON_analytic(cosNI);
+        const float avgEF = AF * (1.0f + constant2_FON * diff_roughness);
+
+        const Power rho_ms(
+            [&](int i) {
+                return SQR(diff_albedo[i]) * avgEF
+                       / (1 - diff_albedo[i] * std::max(0.0f, 1.0f - avgEF));
+            },
+            1);
+        const float f_ms = std::max(1e-7f, 1.0f - EFo)
+                           * std::max(1e-7f, 1.0f - EFi)
+                           / std::max(1e-7f, 1.0f - avgEF);
+
+        return { wi, diff_albedo * f_ss + rho_ms * f_ms, pdf, 1.0f };
+    }
+}
+
+template<typename BSDF_ROOT>
+BSDL_INLINE_METHOD Sample
+OrenNayarDiffuseLobe<BSDF_ROOT>::sample_impl(const Imath::V3f& wo,
+                                             const Imath::V3f& rnd) const
+{
+    if (wo.z <= 0.0f)
+        return {};
+
+    const Imath::V3f wi = sample_cos_hemisphere(rnd.x, rnd.y);
+    return eval_impl(wo, wi);
+}
+
+}  // namespace mtx
+
+BSDL_LEAVE_NAMESPACE

src/libbsdl/include/BSDL/MTX/bsdf_schlick_decl.h

@@ -73,6 +73,11 @@ template<typename BSDF_ROOT> struct SchlickLobe : public Lobe<BSDF_ROOT> {
         return !dorefr ? Power(E_ms, 1) : Power::ZERO();
     }
 
+    BSDL_INLINE_METHOD Power albedo_impl() const
+    {
+        return !dorefr ? refl_tint * (1 - E_ms) : Power::UNIT();
+    }
+
 protected:
     BSDL_INLINE_METHOD Power get_tint(float cosNI) const;
 

src/libbsdl/include/BSDL/MTX/bsdf_sheen_decl.h

@@ -41,7 +41,7 @@ template<typename BSDF_ROOT> struct SheenLobe : public Lobe<BSDF_ROOT> {
 
     static constexpr const char* name() { return "sheen_bsdf"; }
 
-    BSDL_INLINE_METHOD Power albedo_impl() const { return Power(1 - Emiss, 1); }
+    BSDL_INLINE_METHOD Power albedo_impl() const { return tint * (1 - Emiss); }
     BSDL_INLINE_METHOD Power filter_o(const Imath::V3f& wo) const
     {
         return Power(Emiss, 1);