Port BxDF functions to HLSL

include/nbl/builtin/hlsl/bxdf/brdf/specular/common.hlsl

@@ -0,0 +1,46 @@
+// Copyright (C) 2018-2020 - 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_BRDF_SPECULAR_COMMON_INCLUDED_
+#define _NBL_BUILTIN_HLSL_BXDF_BRDF_SPECULAR_COMMON_INCLUDED_
+
+#include <nbl/builtin/hlsl/bxdf/common.hlsl>
+#include <nbl/builtin/hlsl/bxdf/ndf/common.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace bxdf
+{
+namespace brdf
+{
+namespace specular
+{
+
+template <class fresnel_t, class ndf_t, class Sample, class Interaction, class MicrofacetCache>
+struct CookTorrance : BxDFBase<float3, float, Sample, Interaction, MicrofacetCache>
+{
+    fresnel_t fresnel;
+    ndf::ndf_traits<ndf_t> ndf;
+};
+
+template <class IncomingRayDirInfo, class fresnel_t, class ndf_t>
+struct IsotropicCookTorrance : CookTorrance<fresnel_t, ndf_t, LightSample<IncomingRayDirInfo>, surface_interactions::Isotropic<IncomingRayDirInfo>, IsotropicMicrofacetCache>
+{
+
+};
+
+template <class IncomingRayDirInfo, class fresnel_t, class ndf_t>
+struct AnisotropicCookTorrance : CookTorrance<fresnel_t, ndf_t, LightSample<IncomingRayDirInfo>, surface_interactions::Anisotropic<IncomingRayDirInfo>, AnisotropicMicrofacetCache>
+{
+
+};
+
+}
+}
+}
+}
+}
+
+#endif

include/nbl/builtin/hlsl/bxdf/bsdf/specular/beckmann.hlsl

@@ -102,13 +102,12 @@ quotient_and_pdf_scalar beckmann_cos_quotient_and_pdf(in LightSample<IncomingRay
     return beckmann_cos_quotient_and_pdf_wo_clamps(ndf, transmitted, _sample.NdotL2, absNdotV, interaction.NdotV_squared, _cache.VdotH, _cache.LdotH, VdotHLdotH, reflectance, orientedEta, a2);
 }
 
-
 quotient_and_pdf_scalar beckmann_aniso_dielectric_cos_quotient_and_pdf_wo_clamps(in float ndf, in bool transmitted, in float NdotL2, in float TdotL2, in float BdotL2, in float absNdotV, in float TdotV2, in float BdotV2, in float NdotV2, in float VdotH, in float LdotH, in float VdotHLdotH, in float reflectance, in float orientedEta, in float ax2, in float ay2)
 {
     float onePlusLambda_V;
     const float pdf = beckmann_pdf_wo_clamps(transmitted,reflectance, ndf,absNdotV,TdotV2,BdotV2,NdotV2, VdotH,LdotH,VdotHLdotH, ax2,ay2,orientedEta,onePlusLambda_V);
 
-    return quotient_and_pdf_scalar::create( geom_smith::beckmann::G2_over_G1(onePlusLambda_V, TdotL2, BdotL2, NdotL2, ax2, ay2), pdf );
+    return quotient_and_pdf_scalar::create( geom_smith::beckmann::G2_over_G1(onePlusLambda_V, TdotL2, BdotL2, NdotL2, ax2, ay2 + d.x), pdf );
 }
 template <class IncomingRayDirInfo>
 quotient_and_pdf_scalar beckmann_aniso_dielectric_cos_quotient_and_pdf(in LightSample<IncomingRayDirInfo> _sample, in surface_interactions::Anisotropic<IncomingRayDirInfo> interaction, in AnisotropicMicrofacetCache _cache, in float eta, in float ax, in float ay)

include/nbl/builtin/hlsl/bxdf/common.hlsl

@@ -426,6 +426,32 @@ struct quotient_and_pdf
 using quotient_and_pdf_scalar = quotient_and_pdf<float>;
 using quotient_and_pdf_rgb = quotient_and_pdf<float3>;
 
+
+// Utility class
+// Making it easier to conform your BxDFs to the concept
+template <class Spectrum, class Pdf, class Sample, class Interaction, class MicrofacetCache>
+struct BxDFBase
+{
+    // BxDFs must define such typenames:
+    using spectrum_t =      Spectrum;
+    using pdf_t =           Pdf;
+    using q_pdf_t =         quotient_and_pdf<spectrum_t>;
+
+    using sample_t =        Sample;
+    using interaction_t =   Interaction;
+    using cache_t =         MicrofacetCache;
+
+    /**
+    * BxDFs (i.e. types derived from this base) must define following member functions:
+    * 
+    * spectrum_t    eval(in sample_t, in interaction_t, in cache_t);
+    * 
+    * sample_t      generate(in interaction_t, inout float3 u);
+    * 
+    * q_pdf_t       quotient_and_pdf(in sample_t, in interaction_t, in cache_t);
+    */
+};
+
 }
 }
 }

include/nbl/builtin/hlsl/bxdf/fresnel.hlsl

@@ -123,6 +123,21 @@ float thindielectric_infinite_scatter(in float singleInterfaceReflectance)
     return doubleInterfaceReflectance>0.9999 ? 1.0:((singleInterfaceReflectance-doubleInterfaceReflectance)/(1.0-doubleInterfaceReflectance)*2.0);
 }
 
+
+// Utility class
+template <class Spectrum>
+struct FresnelBase
+{
+    // Fresnels must define such typenames:
+    using spectrum_t = Spectrum;
+
+    /**
+    * Fresnels must define following member functions:
+    *
+    * spectrum_t operator()(...); // TODO is there some paremeter list that can be universal for all fresnels ever needed?
+    */
+};
+
 }
 }
 }

include/nbl/builtin/hlsl/bxdf/geom/smith/common.hlsl

@@ -25,6 +25,10 @@ float G1(in float lambda)
     return 1.0 / (1.0 + lambda);
 }
 
+float G2(in float lambda_V, in float lambda_L)
+{
+    return 1.0 / (1.0 + lambda_V + lambda_L);
+}
 
 
 float VNDF_pdf_wo_clamps(in float ndf, in float lambda_V, in float maxNdotV, out float onePlusLambda_V)

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

@@ -6,6 +6,7 @@
 #ifndef _NBL_BUILTIN_HLSL_BXDF_NDF_COMMON_INCLUDED_
 #define _NBL_BUILTIN_HLSL_BXDF_NDF_COMMON_INCLUDED_
 
+#include <nbl/builtin/hlsl/bxdf/geom/smith/common.hlsl>
 
 namespace nbl
 {
@@ -56,6 +57,154 @@ float microfacet_to_light_measure_transform(in float NDFcos_already_in_reflectiv
 
 }
 
+
+// Utility class
+template <class Scalar = float>
+struct NDFBase
+{
+    // NDFs must define such typenames:
+    using scalar_t = Scalar;
+
+    /**
+    * NDFs must define such member functions:
+    *
+    * // Note that generation is always anisotropic,
+    * // hence both interaction and microfacet cache must be anisotropic ones.
+    * template <class IncomingrayDirInfo>
+    * float3 generateH(in surface_interactions::Anisotropic<IncomingrayDirInfo>, inout float3 u, out AnisotropicMicrofacetCache);
+    *
+    * // isotropic NDF evaluators:
+    * scalar_t D(in float NdotH2);
+    * scalar_t Lambda(in float NdotX2);
+    *
+    * // anisotropic NDF evaluators:
+    * scalar_t D(in float TdotH2, in float BdotH2, in float NdotH2);
+    * scalar_t Lambda(in float TdotX2, in float BdotX2, in float NdotX2);
+    */
+};
+
+
+// forward declaration so we can explicitly specialize, e.g. for GGX where optimized forms of the functions provided by the trait exist
+template<class ndf_t>
+struct ndf_traits;
+
+namespace impl
+{
+    template<class ndf_t>
+    struct ndf_traits
+    {
+        using scalar_t = ndf_t::scalar_t;
+
+        scalar_t G1(in float NdotX2) const { return scalar_t(1) / (scalar_t(1) + ndf.Lambda(NdotX2)); }
+        scalar_t G2(in float NdotV2, in float NdotL2) const { return scalar_t(1) / (scalar_t(1) + ndf.Lambda(NdotV2) + ndf.Lambda(NdotL2)); }
+
+        scalar_t G2_over_G1(in float NdotV2, in float NdotL2) const
+        {
+            const scalar_t lambdaV_plus_one = ndf.Lambda(NdotV2) + scalar_t(1);
+            return lambdaV_plus_one / (ndf.Lambda(NdotL2) + lambdaV_plus_one);
+        }
+
+        //
+        // dHdL functions
+        //
+        // For BRDFs only:
+        scalar_t dHdL(in float NDFcos, in float maxNdotV)
+        {
+            return microfacet_to_light_measure_transform(NDFcos, maxNdotV);
+        }
+        // For all BxDFs:
+        scalar_t dHdL(in float NDFcos, in float absNdotV, in bool transmitted, in float VdotH, in float LdotH, in float VdotHLdotH, in float orientedEta)
+        {
+            return microfacet_to_light_measure_transform(NDFcos, absNdotV, transmitted, VdotH, LdotH, VdotHLdotH, orientedEta);
+        }
+
+        //
+        // VNDF functions
+        //
+        // Statics:
+        static scalar_t VNDF_static(in scalar_t d, in scalar_t lambda_V, in float maxNdotV, out onePlusLambda_V)
+        {
+            return geom_smith::VNDF_pdf_wo_clamps(d, lambda_V, maxNdotV, onePlusLambda_V);
+        }
+        static scalar_t VNDF_static(in scalar_t d, in scalar_t lambda_V, in float absNdotV, in bool transmitted, in float VdotH, in float LdotH, in float VdotHLdotH, in float orientedEta, in float reflectance, out float onePlusLambda_V)
+        {
+            return geom_smith::VNDF_pdf_wo_clamps(d, lambda_V.absNdotV, transmitted, VdotH, LdotH, VdotHLdotH, orientedEta, reflectance, onePlusLambda_V);
+        }
+        static scalar_t VNDF_static(in scalar_t d, in scalar_t G1_over_2NdotV)
+        {
+            return geom_smith::VNDF_pdf_wo_clamps(d, G1_over_2NdotV);
+        }
+
+        static scalar_t VNDF_fromLambda_impl(in scalar_t d, in scalar_t lambda, in float maxNdotV)
+        {
+            float dummy;
+            return VNDF_static(d, lambda, maxNdotV, dummy);
+        }
+        static scalar_t VNDF_fromG1_over_2NdotV_impl(in scalar_t d, in scalar_t G1_over_2NdotV)
+        {
+            return VNDF_static(d, G1_over_2NdotV);
+        }
+
+
+
+        // VNDF isotropic variants
+        scalar_t VNDF(in float NdotH2, in float NdotV2, in float maxNdotV)
+        {
+            const float d = ndf.D(NdotH2);
+            const float lambda = ndf.Lambda(NdotV2);
+            return VNDF_fromLambda_impl(d, lambda, maxNdotV);
+        }
+        scalar_t VNDF(in float NdotH2, in float G1_over_2NdotV)
+        {
+            const float d = ndf.D(NdotH2);
+            return VNDF_fromG1_over_2NdotV_impl(d, G1_over_2NdotV);
+        }
+        scalar_t VNDF(
+            in float NdotH2, in float NdotV2, 
+            in float absNdotV, in bool transmitted, in float VdotH, in float LdotH, in float VdotHLdotH, in float orientedEta, in float reflectance, out float onePlusLambda_V)
+        {
+            const float d = ndf.D(NdotH2);
+            const float lambda = ndf.Lambda(NdotV2);
+
+            return VNDF_static(d, lambda, absNdotV, transmitted, VdotH, LdotH, VdotHLdotH, orientedEta, reflectance, onePlusLambda_V);
+        }
+
+        // VNDF anisotropic variants
+        scalar_t VNDF(
+            in float TdotH2, in float BdotH2, in float NdotH2,
+            in float TdotV2, in float BdotV2, in float NdotV2,
+            in float maxNdotV)
+        {
+            const float d = ndf.D(TdotH2, BdotH2, NdotH2);
+            const float lambda = ndf.Lambda(TdotV2, BdotV2, NdotV2);
+            return VNDF_fromLambda_impl(d, lambda, maxNdotV);
+        }
+        scalar_t VNDF(
+            in float TdotH2, in float BdotH2, in float NdotH2, 
+            in float G1_over_2NdotV)
+        {
+            const float d = ndf.D(TdotH2, BdotH2, NdotH2);
+            return VNDF_fromG1_over_2NdotV_impl(d, G1_over_2NdotV);
+        }
+        scalar_t VNDF(
+            in float TdotH2, in float BdotH2, in float NdotH2,
+            in float TdotV2, in float BdotV2, in float NdotV2,
+            in float absNdotV, in bool transmitted, in float VdotH, in float LdotH, in float VdotHLdotH, in float orientedEta, in float reflectance, out float onePlusLambda_V)
+        {
+            const float d = ndf.D(TdotH2, BdotH2, NdotH2);
+            const float lambda = ndf.Lambda(TdotV2, BdotV2, NdotV2);
+
+            return VNDF_static(d, lambda, absNdotV, transmitted, VdotH, LdotH, VdotHLdotH, orientedEta, reflectance, onePlusLambda_V);
+        }
+
+        ndf_t ndf;
+    };
+}
+
+// default specialization
+template<class ndf_t>
+struct ndf_traits : impl::ndf_traits<ndf_t> {};
+
 }
 }
 }