Created concepts for samplers, added quotient_and_pdf variants to satisfy the concepts

include/nbl/builtin/hlsl/bxdf/base/cook_torrance_base.hlsl

@@ -202,9 +202,10 @@ struct SCookTorrance
         // fail if samples have invalid paths
         const scalar_type NdotL = hlsl::mix(scalar_type(2.0) * VdotH * localH.z - NdotV,
                                     localH.z * (VdotH * rcpEta.value[0] + LdotH) - NdotV * rcpEta.value[0], transmitted);
+        assert(!hlsl::isnan(NdotL));
         // VNDF sampling guarantees that `VdotH` has same sign as `NdotV`
         // and `transmitted` controls the sign of `LdotH` relative to `VdotH` by construction (reflect -> same sign, or refract -> opposite sign)
-        if (hlsl::isnan(NdotL) || ComputeMicrofacetNormal<scalar_type>::isTransmissionPath(NdotV, NdotL) != transmitted)
+        if (ComputeMicrofacetNormal<scalar_type>::isTransmissionPath(NdotV, NdotL) != transmitted)
         {
             valid = false;
             return sample_type::createInvalid();    // should check if sample direction is invalid
@@ -307,7 +308,16 @@ struct SCookTorrance
         partitionRandVariable.leftProb = reflectance;
         bool transmitted = partitionRandVariable(z, rcpChoiceProb);
 
-        const scalar_type LdotH = hlsl::mix(VdotH, ieee754::copySign(hlsl::sqrt(rcpEta.value2[0]*VdotH*VdotH + scalar_type(1.0) - rcpEta.value2[0]), -VdotH), transmitted);
+        scalar_type LdotH;
+        if (transmitted)
+        {
+            scalar_type det = rcpEta.value2[0]*VdotH*VdotH + scalar_type(1.0) - rcpEta.value2[0];
+            if (det < scalar_type(0.0))
+                return sample_type::createInvalid();
+            LdotH = ieee754::copySign(hlsl::sqrt(det), -VdotH);
+        }
+        else
+            LdotH = VdotH;
         bool valid;
         sample_type s = __generate_common(interaction, localH, NdotV, VdotH, LdotH, transmitted, rcpEta, valid);
         if (valid)

include/nbl/builtin/hlsl/bxdf/base/lambertian.hlsl

@@ -37,16 +37,18 @@ struct SLambertianBase
     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_CONST_MEMBER_FUNC
     {
+        typename sampling::ProjectedHemisphere<scalar_type>::cache_type cache;
         ray_dir_info_type L;
-        L.setDirection(sampling::ProjectedHemisphere<scalar_type>::generate(u));
+        L.setDirection(sampling::ProjectedHemisphere<scalar_type>::generate(u, cache));
         return sample_type::createFromTangentSpace(L, interaction.getFromTangentSpace());
     }
     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_CONST_MEMBER_FUNC
     {
+        typename sampling::ProjectedSphere<scalar_type>::cache_type cache;
         vector3_type _u = u;
         ray_dir_info_type L;
-        L.setDirection(sampling::ProjectedSphere<scalar_type>::generate(_u));
+        L.setDirection(sampling::ProjectedSphere<scalar_type>::generate(_u, cache));
         return sample_type::createFromTangentSpace(L, interaction.getFromTangentSpace());
     }
     template<typename C=bool_constant<!IsBSDF> >
@@ -76,10 +78,10 @@ struct SLambertianBase
     {
         sampling::quotient_and_pdf<monochrome_type, scalar_type> qp;
         NBL_IF_CONSTEXPR (IsBSDF)
-            qp = sampling::ProjectedSphere<scalar_type>::template quotient_and_pdf(_sample.getNdotL(_clamp));
+            qp = sampling::ProjectedSphere<scalar_type>::template quotientAndPdf(_sample.getNdotL(_clamp));
         else
-            qp = sampling::ProjectedHemisphere<scalar_type>::template quotient_and_pdf(_sample.getNdotL(_clamp));
-        return quotient_pdf_type::create(qp.quotient[0], qp.pdf);
+            qp = sampling::ProjectedHemisphere<scalar_type>::template quotientAndPdf(_sample.getNdotL(_clamp));
+        return quotient_pdf_type::create(qp.quotient()[0], qp.pdf());
     }
     quotient_pdf_type quotient_and_pdf(NBL_CONST_REF_ARG(sample_type) _sample, NBL_CONST_REF_ARG(anisotropic_interaction_type) interaction) NBL_CONST_MEMBER_FUNC
     {

include/nbl/builtin/hlsl/bxdf/base/oren_nayar.hlsl

@@ -72,16 +72,18 @@ struct SOrenNayarBase
     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_CONST_MEMBER_FUNC
     {
+        typename sampling::ProjectedHemisphere<scalar_type>::cache_type cache;
         ray_dir_info_type L;
-        L.setDirection(sampling::ProjectedHemisphere<scalar_type>::generate(u));
+        L.setDirection(sampling::ProjectedHemisphere<scalar_type>::generate(u, cache));
         return sample_type::createFromTangentSpace(L, interaction.getFromTangentSpace());
     }
     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_CONST_MEMBER_FUNC
     {
+        typename sampling::ProjectedSphere<scalar_type>::cache_type cache;
         vector3_type _u = u;
         ray_dir_info_type L;
-        L.setDirection(sampling::ProjectedSphere<scalar_type>::generate(_u));
+        L.setDirection(sampling::ProjectedSphere<scalar_type>::generate(_u, cache));
         return sample_type::createFromTangentSpace(L, interaction.getFromTangentSpace());
     }
     template<typename C=bool_constant<!IsBSDF> >

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

@@ -508,10 +508,8 @@ struct iridescent_helper
     using vector_type = T;
 
     // returns phi, the phase shift for each plane of polarization (p,s)
-    static void phase_shift(const vector_type ior1, const vector_type ior2, const vector_type iork2, const vector_type cosTheta, NBL_REF_ARG(vector_type) phiS, NBL_REF_ARG(vector_type) phiP)
+    static void phase_shift(const vector_type ior1, const vector_type ior2, const vector_type iork2, const vector_type cosTheta, const vector_type cosTheta2, const vector_type sinTheta2, NBL_REF_ARG(vector_type) phiS, NBL_REF_ARG(vector_type) phiP)
     {
-        const vector_type cosTheta2 = cosTheta * cosTheta;
-        const vector_type sinTheta2 = hlsl::promote<vector_type>(1.0) - cosTheta2;
         const vector_type ior1_2 = ior1*ior1;
         const vector_type ior2_2 = ior2*ior2;
         const vector_type iork2_2 = iork2*iork2;
@@ -523,6 +521,7 @@ struct iridescent_helper
         const vector_type a = hlsl::sqrt(a2);
         const vector_type b = hlsl::sqrt(b2);
 
+        // TODO: very optimizable, especially atan2 usage
         phiS = hlsl::atan2(scalar_type(2.0) * ior1 * b * cosTheta, a2 + b2 - ior1_2*cosTheta2);
         const vector_type k2_plus_one = hlsl::promote<vector_type>(1.0) + iork2_2;
         phiP = hlsl::atan2(scalar_type(2.0) * ior1 * ior2_2 * cosTheta * (scalar_type(2.0) * iork2 * a - (hlsl::promote<vector_type>(1.0) - iork2_2) * b),
@@ -549,37 +548,50 @@ struct iridescent_helper
     {
         const scalar_type cosTheta_1 = clampedCosTheta;
         vector_type R12p, R23p, R12s, R23s;
-        vector_type cosTheta_2;
+        vector_type cosTheta_2, cosTheta2_2;
         vector<bool,vector_traits<vector_type>::Dimension> notTIR;
         {
             const vector_type scale = scalar_type(1.0)/eta12;
-            const vector_type cosTheta2_2 = hlsl::promote<vector_type>(1.0) - hlsl::promote<vector_type>(scalar_type(1.0)-cosTheta_1*cosTheta_1) * scale * scale;
+            cosTheta2_2 = hlsl::promote<vector_type>(1.0) - hlsl::promote<vector_type>(scalar_type(1.0)-cosTheta_1*cosTheta_1) * scale * scale;
             notTIR = cosTheta2_2 > hlsl::promote<vector_type>(0.0);
-            cosTheta_2 = hlsl::sqrt(hlsl::max(cosTheta2_2, hlsl::promote<vector_type>(0.0)));
+            cosTheta_2 = hlsl::mix(hlsl::promote<vector_type>(0.0), hlsl::sqrt(cosTheta2_2), notTIR);
         }
 
-        if (hlsl::any(notTIR))
+        NBL_UNROLL for (uint32_t i = 0; i < vector_traits<vector_type>::Dimension; i++)
         {
-            Dielectric<vector_type>::__polarized(eta12 * eta12, hlsl::promote<vector_type>(cosTheta_1), R12p, R12s);
-
-            // Reflected part by the base
-            // if kappa==0, base material is dielectric
-            NBL_IF_CONSTEXPR(SupportsTransmission)
-                Dielectric<vector_type>::__polarized(eta23 * eta23, cosTheta_2, R23p, R23s);
+            // Check for total internal reflection
+            if (notTIR[i])
+            {
+                using monochrome_type = vector<scalar_type, 1>;
+                monochrome_type p12, s12, p23, s23;
+                Dielectric<monochrome_type>::__polarized(hlsl::promote<monochrome_type>(eta12[i] * eta12[i]), hlsl::promote<monochrome_type>(cosTheta_1), p12, s12);
+
+                const monochrome_type eta23_2 = hlsl::promote<monochrome_type>(eta23[i] * eta23[i]);
+
+                // Reflected part by the base
+                // if kappa==0, base material is dielectric
+                NBL_IF_CONSTEXPR(SupportsTransmission)
+                    Dielectric<monochrome_type>::__polarized(eta23_2, hlsl::promote<monochrome_type>(cosTheta_2[i]), p23, s23);
+                else
+                {
+                    const monochrome_type etaLen2 = eta23_2 + hlsl::promote<monochrome_type>(etak23[i] * etak23[i]);
+                    Conductor<monochrome_type>::__polarized(hlsl::promote<monochrome_type>(eta23[i]), etaLen2, hlsl::promote<monochrome_type>(cosTheta_2[i]), p23, s23);
+                }
+
+                R12p[i] = p12[0];
+                R12s[i] = s12[0];
+                R23p[i] = p23[0];
+                R23s[i] = s23[0];
+            }
             else
             {
-                vector_type etaLen2 = eta23 * eta23 + etak23 * etak23;
-                Conductor<vector_type>::__polarized(eta23, etaLen2, cosTheta_2, R23p, R23s);
+                R12s[i] = scalar_type(0.0);
+                R12p[i] = scalar_type(0.0);
+                R23s[i] = scalar_type(0.0);
+                R23p[i] = scalar_type(0.0);
             }
         }
 
-        // Check for total internal reflection
-        const vector_type notTIRFactor = vector_type(notTIR); // 0 when TIR, 1 otherwise
-        R12s = R12s * notTIRFactor;
-        R12p = R12p * notTIRFactor;
-        R23s = R23s * notTIRFactor;
-        R23p = R23p * notTIRFactor;
-
         // Compute the transmission coefficients
         vector_type T121p = hlsl::promote<vector_type>(1.0) - R12p;
         vector_type T121s = hlsl::promote<vector_type>(1.0) - R12s;
@@ -591,8 +603,18 @@ struct iridescent_helper
         vector_type I = hlsl::promote<vector_type>(0.0);
 
         // Evaluate the phase shift
-        phase_shift(ior1, ior2, hlsl::promote<vector_type>(0.0), hlsl::promote<vector_type>(cosTheta_1), phi21s, phi21p);
-        phase_shift(ior2, ior3, iork3, cosTheta_2, phi23s, phi23p);
+        {
+            const vector_type ct = hlsl::promote<vector_type>(cosTheta_1);
+            const vector_type ct2 = ct * ct;
+            const vector_type st2 = hlsl::promote<vector_type>(1.0) - ct2;
+            phase_shift(ior1, ior2, hlsl::promote<vector_type>(0.0), ct, ct2, st2, phi21s, phi21p);
+        }
+        {
+            const vector_type ct = hlsl::promote<vector_type>(cosTheta_2);
+            const vector_type ct2 = cosTheta2_2;
+            const vector_type st2 = hlsl::promote<vector_type>(1.0) - ct2;
+            phase_shift(ior2, ior3, iork3, ct, ct2, st2, phi23s, phi23p);
+        }
         phi21p = hlsl::promote<vector_type>(numbers::pi<scalar_type>) - phi21p;
         phi21s = hlsl::promote<vector_type>(numbers::pi<scalar_type>) - phi21s;
 
@@ -613,6 +635,7 @@ struct iridescent_helper
         NBL_UNROLL for (int m=1; m<=2; ++m)
         {
             Cm *= r123p;
+            // TODO: common subexpression, maybe we can hoist it out somehow?
             Sm  = hlsl::promote<vector_type>(2.0) * evalSensitivity(hlsl::promote<vector_type>(scalar_type(m))*D, hlsl::promote<vector_type>(scalar_type(m))*(phi23p+phi21p));
             I  += Cm*Sm;
         }
@@ -641,6 +664,13 @@ struct iridescent_base
     using scalar_type = typename vector_traits<T>::scalar_type;
     using vector_type = T;
 
+    template<bool SupportsTransmission, typename Colorspace>
+    T __call(const vector_type iork3, const vector_type etak23, const scalar_type clampedCosTheta) NBL_CONST_MEMBER_FUNC
+    {
+        return impl::iridescent_helper<T,false>::template __call<Colorspace>(D, ior1, ior2, ior3, iork3,
+                                                            eta12, eta23, etak23, clampedCosTheta);
+    }
+
     vector_type D;
     vector_type ior1;
     vector_type ior2;
@@ -650,6 +680,14 @@ struct iridescent_base
     vector_type eta23;      // thin-film -> base material IOR
     vector_type eta13;
 };
+
+
+// workaround due to DXC bug: github.com/microsoft/DirectXShaderCompiler/issues/5966
+template<typename T, bool SupportsTransmission, typename Colorspace>
+T __iridescent_base__call_const(NBL_CONST_REF_ARG(iridescent_base<T>) _this, const T iork3, const T etak23, const typename vector_traits<T>::scalar_type clampedCosTheta)
+{
+    return _this.template __call<SupportsTransmission, Colorspace>(iork3, etak23, clampedCosTheta);
+}
 }
 
 template<typename T, typename Colorspace>
@@ -691,8 +729,7 @@ struct Iridescent<T, false, Colorspace NBL_PARTIAL_REQ_BOT(concepts::FloatingPoi
 
     T operator()(const scalar_type clampedCosTheta) NBL_CONST_MEMBER_FUNC
     {
-        return impl::iridescent_helper<T,false>::template __call<Colorspace>(base_type::D, base_type::ior1, base_type::ior2, base_type::ior3, base_type::iork3,
-                                                            base_type::eta12, base_type::eta23, getEtak23(), clampedCosTheta);
+        return impl::__iridescent_base__call_const<T, false, Colorspace>(NBL_DEREF_THIS, base_type::iork3, getEtak23(), clampedCosTheta);
     }
 
     vector_type getEtak23() NBL_CONST_MEMBER_FUNC
@@ -739,8 +776,7 @@ struct Iridescent<T, true, Colorspace NBL_PARTIAL_REQ_BOT(concepts::FloatingPoin
 
     T operator()(const scalar_type clampedCosTheta) NBL_CONST_MEMBER_FUNC
     {
-        return impl::iridescent_helper<T,true>::template __call<Colorspace>(base_type::D, base_type::ior1, base_type::ior2, base_type::ior3, getEtak23(),
-                                                            base_type::eta12, base_type::eta23, getEtak23(), clampedCosTheta);
+        return impl::__iridescent_base__call_const<T, true, Colorspace>(NBL_DEREF_THIS, getEtak23(), getEtak23(), clampedCosTheta);
     }
 
     scalar_type getRefractionOrientedEta() NBL_CONST_MEMBER_FUNC { return base_type::eta13[0]; }

include/nbl/builtin/hlsl/concepts/accessors/anisotropically_sampled.hlsl

@@ -18,25 +18,28 @@ namespace accessors
 {
 // declare concept
 #define NBL_CONCEPT_NAME AnisotropicallySampled
-#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)(int32_t)
-#define NBL_CONCEPT_TPLT_PRM_NAMES (U)(Dims)
+#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)(int32_t)(int32_t)
+#define NBL_CONCEPT_TPLT_PRM_NAMES (U)(Dims)(Components)
 // not the greatest syntax but works
 #define NBL_CONCEPT_PARAM_0 (a,U)
 #define NBL_CONCEPT_PARAM_1 (uv,vector<float32_t,Dims>)
 #define NBL_CONCEPT_PARAM_2 (layer,uint16_t)
 #define NBL_CONCEPT_PARAM_3 (dU,vector<float32_t,Dims>)
 #define NBL_CONCEPT_PARAM_4 (dV,vector<float32_t,Dims>)
+#define NBL_CONCEPT_PARAM_5 (outVal,vector<float32_t,Components>)
 // start concept
-NBL_CONCEPT_BEGIN(5)
+NBL_CONCEPT_BEGIN(6)
 // need to be defined AFTER the cocnept begins
 #define a NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_0
 #define uv NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_1
 #define layer NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_2
 #define dU NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_3
 #define dV NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_4
+#define outVal NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_5
 NBL_CONCEPT_END(
-    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((a.template get<Dims>(uv,layer,dU,dV)) , ::nbl::hlsl::is_same_v, float32_t4>))
+    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((a.template get<Dims>(outVal,uv,layer,dU,dV)) , ::nbl::hlsl::is_same_v, void))
 );
+#undef outVal
 #undef dV
 #undef dU
 #undef layer
@@ -47,4 +50,4 @@ NBL_CONCEPT_END(
 }
 }
 }
-#endif
+#endif

include/nbl/builtin/hlsl/concepts/accessors/loadable_image.hlsl

@@ -18,52 +18,58 @@ namespace accessors
 {
 
 // concept `LoadableImage` translates to smth like this:
-//template<typename U, typename T, int32_t Dims>
-//concept LoadableImage = requires(U a, vector<uint16_t, Dims> uv, uint16_t layer) {
-//    ::nbl::hlsl::is_same_v<decltype(declval<U>().template get<T,Dims>(uv,layer)), vector<T,4>>;
+//template<typename U, typename T, int32_t Dims, int32_t Components>
+//concept LoadableImage = requires(U a, vector<uint16_t, Dims> uv, uint16_t layer, vector<T, Components> outVal) {
+//    ::nbl::hlsl::is_same_v<decltype(declval<U>().template get<T,Dims>(outVal,uv,layer)), void>;
 //};
 
 // declare concept
 #define NBL_CONCEPT_NAME LoadableImage
-#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)(typename)(int32_t)
-#define NBL_CONCEPT_TPLT_PRM_NAMES (U)(T)(Dims)
+#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)(typename)(int32_t)(int32_t)
+#define NBL_CONCEPT_TPLT_PRM_NAMES (U)(T)(Dims)(Components)
 // not the greatest syntax but works
 #define NBL_CONCEPT_PARAM_0 (a,U)
 #define NBL_CONCEPT_PARAM_1 (uv,vector<uint16_t,Dims>)
 #define NBL_CONCEPT_PARAM_2 (layer,uint16_t)
+#define NBL_CONCEPT_PARAM_3 (outVal,vector<T,Components>)
 // start concept
-NBL_CONCEPT_BEGIN(3)
+NBL_CONCEPT_BEGIN(4)
 // need to be defined AFTER the concept begins
 #define a NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_0
 #define uv NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_1
 #define layer NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_2
+#define outVal NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_3
 NBL_CONCEPT_END(
-    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((a.template get<T,Dims>(uv,layer)), ::nbl::hlsl::is_same_v, vector<T,4>))
+    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((a.template get<T,Dims>(outVal,uv,layer)), ::nbl::hlsl::is_same_v, void))
 );
+#undef outVal
 #undef layer
 #undef uv
 #undef a
 #include <nbl/builtin/hlsl/concepts/__end.hlsl>
 
 // declare concept
 #define NBL_CONCEPT_NAME MipmappedLoadableImage
-#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)(typename)(int32_t)
-#define NBL_CONCEPT_TPLT_PRM_NAMES (U)(T)(Dims)
+#define NBL_CONCEPT_TPLT_PRM_KINDS (typename)(typename)(int32_t)(int32_t)
+#define NBL_CONCEPT_TPLT_PRM_NAMES (U)(T)(Dims)(Components)
 // not the greatest syntax but works
 #define NBL_CONCEPT_PARAM_0 (a,U)
 #define NBL_CONCEPT_PARAM_1 (uv,vector<uint16_t,Dims>)
 #define NBL_CONCEPT_PARAM_2 (layer,uint16_t)
 #define NBL_CONCEPT_PARAM_3 (level,uint16_t)
+#define NBL_CONCEPT_PARAM_4 (outVal,vector<T,Components>)
 // start concept
-NBL_CONCEPT_BEGIN(4)
+NBL_CONCEPT_BEGIN(5)
 // need to be defined AFTER the cocnept begins
 #define a NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_0
 #define uv NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_1
 #define layer NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_2
 #define level NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_3
+#define outVal NBL_CONCEPT_PARAM_T NBL_CONCEPT_PARAM_4
 NBL_CONCEPT_END(
-    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((a.template get<T,Dims>(uv,layer,level)) , ::nbl::hlsl::is_same_v, vector<T,4>))
+    ((NBL_CONCEPT_REQ_EXPR_RET_TYPE)((a.template get<T,Dims>(outVal,uv,layer,level)) , ::nbl::hlsl::is_same_v, void))
 );
+#undef outVal
 #undef level
 #undef layer
 #undef uv
@@ -73,4 +79,4 @@ NBL_CONCEPT_END(
 }
 }
 }
-#endif
+#endif