Fix numerous sampling bugs.

Author: devshgraphicsprogramming

examples_tests/42.FragmentShaderPathTracer/common.glsl

@@ -1,6 +1,6 @@
 // basic settings
 #define MAX_DEPTH 8
-#define SAMPLES 128
+#define SAMPLES 32
 
 // firefly and variance reduction techniques
 //#define KILL_DIFFUSE_SPECULAR_PATHS
@@ -158,10 +158,6 @@ float BSDFNode_getRoughness(in BSDFNode node)
 {
     return uintBitsToFloat(node.data[1].w);
 }
-vec3 BSDFNode_getReflectance(in BSDFNode node)
-{
-    return uintBitsToFloat(node.data[0].rgb);
-}
 vec3 BSDFNode_getRealEta(in BSDFNode node)
 {
     return uintBitsToFloat(node.data[0].rgb);
@@ -174,6 +170,15 @@ mat2x3 BSDFNode_getEta(in BSDFNode node)
 {
     return mat2x3(BSDFNode_getRealEta(node),BSDFNode_getImaginaryEta(node));
 }
+#include <irr/builtin/glsl/bxdf/fresnel.glsl>
+vec3 BSDFNode_getReflectance(in BSDFNode node, in float VdotH)
+{
+    const vec3 albedoOrRealIoR = uintBitsToFloat(node.data[0].rgb);
+    if (BSDFNode_isNotDiffuse(node))
+        return irr_glsl_fresnel_conductor(albedoOrRealIoR, BSDFNode_getImaginaryEta(node), VdotH);
+    else
+        return albedoOrRealIoR;
+}
 
 float BSDFNode_getMISWeight(in BSDFNode bsdf)
 {
@@ -198,7 +203,7 @@ BSDFNode bsdfs[BSDF_COUNT] = {
     {{uvec4(floatBitsToUint(vec3(1.02,1.02,1.3)),CONDUCTOR_OP),floatBitsToUint(vec4(1.0,1.0,2.0,0.0))}},
     {{uvec4(floatBitsToUint(vec3(1.02,1.3,1.02)),CONDUCTOR_OP),floatBitsToUint(vec4(1.0,2.0,1.0,0.0))}},
     {{uvec4(floatBitsToUint(vec3(1.02,1.3,1.02)),CONDUCTOR_OP),floatBitsToUint(vec4(1.0,2.0,1.0,0.15))}},
-    {{uvec4(floatBitsToUint(vec3(1.4,1.45,1.5)),DIELECTRIC_OP),floatBitsToUint(vec4(0.0,0.0,0.0,0.0))}}
+    {{uvec4(floatBitsToUint(vec3(1.4,1.45,1.5)),DIELECTRIC_OP),floatBitsToUint(vec4(0.0,0.0,0.0,0.05))}}
 };
 
 
@@ -323,91 +328,82 @@ void missProgram()
 }
 
 #include <irr/builtin/glsl/bxdf/brdf/diffuse/oren_nayar.glsl>
+#include <irr/builtin/glsl/bxdf/brdf/specular/beckmann.glsl>
 #include <irr/builtin/glsl/bxdf/brdf/specular/ggx.glsl>
-#include <irr/builtin/glsl/bxdf/bsdf/specular/dielectric.glsl>
-irr_glsl_BxDFSample irr_glsl_bsdf_cos_generate(in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in vec3 u, in BSDFNode bsdf, in vec3 luminosityContributionHint)
+#include <irr/builtin/glsl/bxdf/bsdf/diffuse/lambert.glsl>
+//#include <irr/builtin/glsl/bxdf/bsdf/specular/dielectric.glsl>
+//#include <irr/builtin/glsl/bxdf/bsdf/specular/beckmann.glsl>
+irr_glsl_LightSample irr_glsl_bsdf_cos_generate(in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in vec3 u, in BSDFNode bsdf, in float monochromeEta, out irr_glsl_AnisotropicMicrofacetCache _cache)
 {
     const float a = BSDFNode_getRoughness(bsdf);
     const mat2x3 ior = BSDFNode_getEta(bsdf);
 
-    irr_glsl_BxDFSample smpl;
+    irr_glsl_LightSample smpl;
+    irr_glsl_AnisotropicMicrofacetCache dummy;
     switch (BSDFNode_getType(bsdf))
     {
         case DIFFUSE_OP:
             smpl = irr_glsl_oren_nayar_cos_generate(interaction,u.xy,a*a);
             break;
         case CONDUCTOR_OP:
-            smpl = irr_glsl_ggx_cos_generate(interaction,u.xy,a,a);
+            smpl = irr_glsl_ggx_cos_generate(interaction,u.xy,a,a,_cache);
             break;
         default:
-            {
-                const float _eta = dot(ior[0],luminosityContributionHint);
-                smpl = irr_glsl_smooth_dielectric_cos_generate(interaction,u,_eta);
-            }
+            smpl = irr_glsl_beckmann_cos_generate(interaction,u.xy,a,a,_cache);
+            //smpl = irr_glsl_beckmann_dielectric_cos_generate(interaction,u,a,a,monochromeEta,_cache);
             break;
     }
     return smpl;
 }
 
-vec3 irr_glsl_bsdf_cos_remainder_and_pdf(out float pdf, in irr_glsl_BxDFSample _sample, in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in BSDFNode bsdf, in vec3 luminosityContributionHint)
+vec3 irr_glsl_bsdf_cos_remainder_and_pdf(out float pdf, in irr_glsl_LightSample _sample, in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in BSDFNode bsdf, in float monochromeEta, in irr_glsl_AnisotropicMicrofacetCache _cache)
 {
-    const vec3 reflectance = BSDFNode_getReflectance(bsdf);
-    const float a = max(BSDFNode_getRoughness(bsdf),0.01); // TODO: @Crisspl 0-roughness still doesn't work! Also Beckmann has a weird dark rim instead as fresnel!?
-    const float a2 = a*a;
-
-    const mat2x3 ior = BSDFNode_getEta(bsdf);
-    
-    const float NdotH2 = _sample.NdotH*_sample.NdotH;
-    const float NdotL2 = _sample.NdotL*_sample.NdotL;
-
-    const float VdotL = dot(interaction.isotropic.V.dir,_sample.L);
+    // are V and L on opposite sides of the surface?
     const bool transmitted = irr_glsl_isTransmissionPath(interaction.isotropic.NdotV,_sample.NdotL);
 
+    // is the BSDF or BRDF, if it is then we make the dot products `abs` before `max(,0.0)`
     const bool transmissive = BSDFNode_isBSDF(bsdf);
-    const float clampedNdotL = irr_glsl_conditionalAbsOrMax(transmissive,_sample.NdotL,0.0);
-    const float clampedNdotV = irr_glsl_conditionalAbsOrMax(transmissive,interaction.isotropic.NdotV,0.0);
 
-    float rcpOrientedEta, orientedEta2, rcpOrientedEta2;
-    const bool viewerInsideMedium = irr_glsl_getOrientedEtas(rcpOrientedEta,orientedEta2,rcpOrientedEta2,interaction.isotropic.NdotV,dot(ior[0],luminosityContributionHint));
+    // obtain stuff for transmissive parts of BSDFs
+    float orientedEta, rcpOrientedEta;
+    const bool viewerInsideMedium = irr_glsl_getOrientedEtas(orientedEta,rcpOrientedEta,interaction.isotropic.NdotV,monochromeEta);
 
-    vec3 remainder; // TODO should just return a 0.0 remainder if NdotV<FLT_MIN and BSDF is not transmissive
-    switch (BSDFNode_getType(bsdf))
+    vec3 remainder;
+    if (transmissive || !transmitted)
     {
-        case DIFFUSE_OP:
-            remainder = reflectance*irr_glsl_oren_nayar_cos_remainder_and_pdf_wo_clamps(pdf,a*a,VdotL,clampedNdotL,clampedNdotV);
-            break;
-        case CONDUCTOR_OP:
-            remainder = irr_glsl_ggx_cos_remainder_and_pdf_wo_clamps(pdf,irr_glsl_ggx_trowbridge_reitz(a2,NdotH2),clampedNdotL,NdotL2,clampedNdotV,interaction.isotropic.NdotV_squared,_sample.VdotH,ior,a2);
-            break;
-        default:
-            remainder = vec3(irr_glsl_smooth_dielectric_cos_remainder_and_pdf(pdf, transmitted, rcpOrientedEta2));
-            break;
-    }
-    return remainder;
-}
+        //
+        const mat2x3 ior = BSDFNode_getEta(bsdf);
+        const vec3 reflectance = BSDFNode_getReflectance(bsdf,_cache.isotropic.VdotH);
 
+        //
+        const float VdotL = dot(interaction.isotropic.V.dir,_sample.L);
 
-#define GeneratorSample irr_glsl_BxDFSample
-#define irr_glsl_LightSample irr_glsl_BxDFSample
-irr_glsl_LightSample irr_glsl_createLightSample(in vec3 L, in irr_glsl_AnisotropicViewSurfaceInteraction interaction)
-{
-    irr_glsl_BxDFSample s;
-    s.L = L;
+        // is the BSDF or BRDF, if it is then we make the dot products `abs` before `max(,0.0)`
+        const float clampedNdotL = irr_glsl_conditionalAbsOrMax(transmissive,_sample.NdotL,0.0);
+        const float clampedNdotV = irr_glsl_conditionalAbsOrMax(transmissive,interaction.isotropic.NdotV,0.0);
 
-    s.TdotL = dot(interaction.T,L);
-    s.BdotL = dot(interaction.B,L);
-    s.NdotL = dot(interaction.isotropic.N,L);
-   
-    float VdotL = dot(interaction.isotropic.V.dir,L);
-    float LplusV_rcpLen = inversesqrt(2.0+2.0*VdotL);
+        //
+        const float a = max(BSDFNode_getRoughness(bsdf),0.01); // TODO: @Crisspl 0-roughness still doesn't work! Also Beckmann has a weird dark rim instead as fresnel!?
+        const float a2 = a*a;
 
-    s.TdotH = (interaction.TdotV+s.TdotL)*LplusV_rcpLen;
-    s.BdotH = (interaction.BdotV+s.BdotL)*LplusV_rcpLen;
-    s.NdotH = (interaction.isotropic.NdotV+s.NdotL)*LplusV_rcpLen;
-
-    s.VdotH = LplusV_rcpLen+LplusV_rcpLen*VdotL;
-    
-    return s;
+        switch (BSDFNode_getType(bsdf))
+        {
+            case DIFFUSE_OP:
+                remainder = reflectance*irr_glsl_oren_nayar_cos_remainder_and_pdf_wo_clamps(pdf,a*a,VdotL,clampedNdotL,clampedNdotV);
+                break;
+            case CONDUCTOR_OP:
+                remainder = irr_glsl_ggx_cos_remainder_and_pdf_wo_clamps(pdf,irr_glsl_ggx_trowbridge_reitz(a2,_cache.isotropic.NdotH2),clampedNdotL,_sample.NdotL2,clampedNdotV,interaction.isotropic.NdotV_squared,reflectance,a2);
+                break;
+            default:
+                remainder = irr_glsl_beckmann_cos_remainder_and_pdf_wo_clamps(pdf,irr_glsl_beckmann(a2,_cache.isotropic.NdotH2),_sample.NdotL2,clampedNdotV,interaction.isotropic.NdotV_squared,reflectance,a2);
+                //remainder = vec3(irr_glsl_lambertian_transmitter_cos_remainder_and_pdf(pdf,_sample));
+                //remainder = vec3(irr_glsl_beckmann_dielectric_cos_remainder_and_pdf(pdf, _sample, interaction.isotropic, monochromeEta, a2));
+                break;
+        }
+    }
+    else
+        remainder = vec3(0.0);
+    return remainder;
 }
 
 layout (constant_id = 0) const int MAX_DEPTH_LOG2 = 0;

examples_tests/42.FragmentShaderPathTracer/litBySphere.frag

@@ -160,7 +160,8 @@ void closestHitProgram(in ImmutableRay_t _immutable, inout irr_glsl_xoroshiro64s
         float maxT;
         // the probability of generating a sample w.r.t. the light generator only possible and used when it was generated with it!
         float lightPdf;
-        GeneratorSample _sample;
+        irr_glsl_LightSample _sample;
+        irr_glsl_AnisotropicMicrofacetCache _cache;
         if (doNEE)
         {
             vec3 lightRemainder;
@@ -172,17 +173,22 @@ void closestHitProgram(in ImmutableRay_t _immutable, inout irr_glsl_xoroshiro64s
             throughput *= lightRemainder;
         }
         const vec3 throughputCIE_Y = transpose(irr_glsl_sRGBtoXYZ)[1]*throughput;
-        const vec3 luminosityContributionHint = throughputCIE_Y/(throughputCIE_Y.r+throughputCIE_Y.g+throughputCIE_Y.b);
-        if (!doNEE)
+        const float monochromeEta = dot(throughputCIE_Y,BSDFNode_getEta(bsdf)[0])/(throughputCIE_Y.r+throughputCIE_Y.g+throughputCIE_Y.b);
+        if (doNEE)
+        {
+            const bool validPath = irr_glsl_calcAnisotropicMicrofacetCache(_cache,interaction,_sample,monochromeEta);
+            throughput = validPath ? throughput:vec3(0.0);
+        }
+        else
         {
             maxT = FLT_MAX;
-            _sample = irr_glsl_bsdf_cos_generate(interaction,epsilon,bsdf,luminosityContributionHint);
+            _sample = irr_glsl_bsdf_cos_generate(interaction,epsilon,bsdf,monochromeEta,_cache);
         }
 
         // do a cool trick and always compute the bsdf parts this way! (no divergence)
         float bsdfPdf;
         // the value of the bsdf divided by the probability of the sample being generated
-        throughput *= irr_glsl_bsdf_cos_remainder_and_pdf(bsdfPdf,_sample,interaction,bsdf,luminosityContributionHint);
+        throughput *= irr_glsl_bsdf_cos_remainder_and_pdf(bsdfPdf,_sample,interaction,bsdf,monochromeEta,_cache);
 
         // OETF smallest perceptible value
         const float bsdfPdfThreshold = getLuma(irr_glsl_eotf_sRGB(vec3(1.0)/255.0));

examples_tests/42.FragmentShaderPathTracer/litByTriangle.frag

@@ -445,7 +445,7 @@ void closestHitProgram(in ImmutableRay_t _immutable, inout irr_glsl_xoroshiro64s
         float maxT;
         // the probability of generating a sample w.r.t. the light generator only possible and used when it was generated with it!
         float lightPdf;
-        GeneratorSample _sample;
+        irr_glsl_LightSample _sample;
         const bool isBSDF = BSDFNode_isBSDF(bsdf);
         if (doNEE)
         {

include/irr/builtin/glsl/bxdf/brdf/diffuse/lambert.glsl

@@ -26,15 +26,15 @@ float irr_glsl_lambertian_cos_eval(in irr_glsl_LightSample _sample)
     return irr_glsl_lambertian_cos_eval_rec_pi_factored_out(_sample.NdotL)*irr_glsl_lambertian();
 }
 
-irr_glsl_LightSample irr_glsl_lambertian_cos_generate_wo_clamps(in vec3 V, in mat3 m, in vec2 u)
+irr_glsl_LightSample irr_glsl_lambertian_cos_generate_wo_clamps(in vec3 tangentSpaceV, in mat3 m, in vec2 u)
 {
     vec3 L = irr_glsl_projected_hemisphere_generate(u);
 
-    return irr_glsl_createLightSampleTangentSpaceL(V,L,m);
+    return irr_glsl_createLightSampleTangentSpace(tangentSpaceV,L,m);
 }
 irr_glsl_LightSample irr_glsl_lambertian_cos_generate(in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in vec2 u)
 {
-    return irr_glsl_lambertian_cos_generate_wo_clamps(interaction.isotropic.V.dir,irr_glsl_getTangentFrame(interaction),u);
+    return irr_glsl_lambertian_cos_generate_wo_clamps(irr_glsl_getTangentSpaceV(interaction),irr_glsl_getTangentFrame(interaction),u);
 }
 
 

include/irr/builtin/glsl/bxdf/brdf/diffuse/oren_nayar.glsl

@@ -31,14 +31,14 @@ float irr_glsl_oren_nayar_cos_eval(in irr_glsl_LightSample _sample, in irr_glsl_
 }
 
 
-irr_glsl_LightSample irr_glsl_oren_nayar_cos_generate_wo_clamps(in vec3 V, in mat3 m, in vec2 u)
+irr_glsl_LightSample irr_glsl_oren_nayar_cos_generate_wo_clamps(in vec3 tangentSpaceV, in mat3 m, in vec2 u)
 {
     // until we find something better
-    return irr_glsl_lambertian_cos_generate_wo_clamps(V, m, u);
+    return irr_glsl_lambertian_cos_generate_wo_clamps(tangentSpaceV, m, u);
 }
 irr_glsl_LightSample irr_glsl_oren_nayar_cos_generate(in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in vec2 u, in float a2)
 {
-    return irr_glsl_oren_nayar_cos_generate_wo_clamps(interaction.isotropic.V.dir,irr_glsl_getTangentFrame(interaction),u);
+    return irr_glsl_oren_nayar_cos_generate_wo_clamps(irr_glsl_getTangentSpaceV(interaction),irr_glsl_getTangentFrame(interaction),u);
 }
 
 

include/irr/builtin/glsl/bxdf/brdf/specular/beckmann.glsl

@@ -84,7 +84,7 @@ irr_glsl_LightSample irr_glsl_beckmann_cos_generate_wo_clamps(in vec3 localV, in
     vec3 localL;
     _cache = irr_glsl_calcAnisotropicMicrofacetCache(localV,H,localL);
 
-    return irr_glsl_createLightSampleTangentSpaceL(localV,localL,m);
+    return irr_glsl_createLightSampleTangentSpace(localV,localL,m);
 }
 
 irr_glsl_LightSample irr_glsl_beckmann_cos_generate(in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in vec2 u, in float ax, in float ay, out irr_glsl_AnisotropicMicrofacetCache _cache)

include/irr/builtin/glsl/bxdf/brdf/specular/blinn_phong.glsl

@@ -39,7 +39,7 @@ irr_glsl_LightSample irr_glsl_blinn_phong_cos_generate(in irr_glsl_AnisotropicVi
     _cache = irr_glsl_calcAnisotropicMicrofacetCache(localV,H,localL);
 
     const mat3 m = irr_glsl_getTangentFrame(interaction);
-    return irr_glsl_createLightSampleTangentSpaceL(localV, localL, m);
+    return irr_glsl_createLightSampleTangentSpace(localV, localL, m);
 }
 
 /*

include/irr/builtin/glsl/bxdf/brdf/specular/ggx.glsl

@@ -123,7 +123,7 @@ irr_glsl_LightSample irr_glsl_ggx_cos_generate_wo_clamps(in vec3 localV, in mat3
     vec3 localL;
     _cache = irr_glsl_calcAnisotropicMicrofacetCache(localV,H,localL);
 
-    return irr_glsl_createLightSampleTangentSpaceL(localV,localL,m);
+    return irr_glsl_createLightSampleTangentSpace(localV,localL,m);
 }
 
 irr_glsl_LightSample irr_glsl_ggx_cos_generate(in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in vec2 u, in float _ax, in float _ay, out irr_glsl_AnisotropicMicrofacetCache _cache)
@@ -157,7 +157,7 @@ float irr_glsl_ggx_pdf_wo_clamps(in float NdotH2, in float TdotH2, in float Bdot
 
 
 
-vec3 irr_glsl_ggx_cos_remainder_and_pdf_wo_clamps(out float pdf, in float ndf, in float maxNdotL, in float NdotL2, in float maxNdotV, in float NdotV2, in float VdotH, in vec3 reflectance, in float a2)
+vec3 irr_glsl_ggx_cos_remainder_and_pdf_wo_clamps(out float pdf, in float ndf, in float maxNdotL, in float NdotL2, in float maxNdotV, in float NdotV2, in vec3 reflectance, in float a2)
 {
     float one_minus_a2 = 1.0 - a2;
     float devsh_v = irr_glsl_smith_ggx_devsh_part(NdotV2, a2, one_minus_a2);
@@ -175,7 +175,7 @@ vec3 irr_glsl_ggx_cos_remainder_and_pdf(out float pdf, in irr_glsl_LightSample _
         const float ndf = irr_glsl_ggx_trowbridge_reitz(a2, _cache.NdotH2);
         const vec3 reflectance = irr_glsl_fresnel_conductor(ior[0], ior[1], _cache.VdotH);
 
-        return irr_glsl_ggx_cos_remainder_and_pdf_wo_clamps(pdf, ndf, max(_sample.NdotL,0.0), _sample.NdotL2, max(interaction.NdotV,0.0), interaction.NdotV_squared, _cache.VdotH, reflectance, a2);
+        return irr_glsl_ggx_cos_remainder_and_pdf_wo_clamps(pdf, ndf, max(_sample.NdotL,0.0), _sample.NdotL2, max(interaction.NdotV,0.0), interaction.NdotV_squared, reflectance, a2);
     }
     else
     {
@@ -185,7 +185,7 @@ vec3 irr_glsl_ggx_cos_remainder_and_pdf(out float pdf, in irr_glsl_LightSample _
 }
 
 
-vec3 irr_glsl_ggx_aniso_cos_remainder_and_pdf_wo_clamps(out float pdf, in float ndf, in float maxNdotL, in float NdotL2, in float TdotL2, in float BdotL2, in float maxNdotV, in float TdotV2, in float BdotV2, in float NdotV2, in float VdotH, in vec3 reflectance, in float ax2,in float ay2)
+vec3 irr_glsl_ggx_aniso_cos_remainder_and_pdf_wo_clamps(out float pdf, in float ndf, in float maxNdotL, in float NdotL2, in float TdotL2, in float BdotL2, in float maxNdotV, in float TdotV2, in float BdotV2, in float NdotV2, in vec3 reflectance, in float ax2,in float ay2)
 {
     const float devsh_v = irr_glsl_smith_ggx_devsh_part(TdotV2, BdotV2, NdotV2, ax2, ay2);
     pdf = irr_glsl_ggx_pdf_wo_clamps(ndf, devsh_v, maxNdotV);
@@ -217,7 +217,7 @@ vec3 irr_glsl_ggx_aniso_cos_remainder_and_pdf(out float pdf, in irr_glsl_LightSa
         const float ndf = irr_glsl_ggx_aniso(TdotH2,BdotH2,_cache.isotropic.NdotH2, ax, ay, ax2, ay2);
 
         const vec3 reflectance = irr_glsl_fresnel_conductor(ior[0], ior[1], _cache.isotropic.VdotH);
-	    return irr_glsl_ggx_aniso_cos_remainder_and_pdf_wo_clamps(pdf, ndf, max(_sample.NdotL, 0.0), _sample.NdotL2, TdotL2, BdotL2, max(interaction.isotropic.NdotV, 0.0), TdotV2, BdotV2, interaction.isotropic.NdotV_squared, _cache.isotropic.VdotH, reflectance, ax2, ay2);
+	    return irr_glsl_ggx_aniso_cos_remainder_and_pdf_wo_clamps(pdf, ndf, max(_sample.NdotL, 0.0), _sample.NdotL2, TdotL2, BdotL2, max(interaction.isotropic.NdotV, 0.0), TdotV2, BdotV2, interaction.isotropic.NdotV_squared, reflectance, ax2, ay2);
     }
     else
     {

include/irr/builtin/glsl/bxdf/bsdf/diffuse/lambert.glsl

@@ -30,11 +30,11 @@ irr_glsl_LightSample irr_glsl_lambertian_transmitter_cos_generate_wo_clamps(in v
 {
     vec3 L = irr_glsl_projected_sphere_generate(u);
 
-    return irr_glsl_createLightSampleTangentSpaceL(tangentSpaceV,L,m);
+    return irr_glsl_createLightSampleTangentSpace(tangentSpaceV,L,m);
 }
 irr_glsl_LightSample irr_glsl_lambertian_transmitter_cos_generate(in irr_glsl_AnisotropicViewSurfaceInteraction interaction, in vec3 u)
 {
-    return irr_glsl_lambertian_transmitter_cos_generate_wo_clamps(interaction.isotropic.V.dir,irr_glsl_getTangentFrame(interaction),u);
+    return irr_glsl_lambertian_transmitter_cos_generate_wo_clamps(irr_glsl_getTangentSpaceV(interaction),irr_glsl_getTangentFrame(interaction),u);
 }
 
 

include/irr/builtin/glsl/bxdf/common.glsl

@@ -55,12 +55,12 @@ struct irr_glsl_LightSample
 };
 
 // require tangentSpaceL already be normalized and in tangent space (tangentSpaceL==vec3(TdotL,BdotL,NdotL))
-irr_glsl_LightSample irr_glsl_createLightSampleTangentSpaceL(in vec3 V, in vec3 tangentSpaceL, in mat3 tangentFrame)
+irr_glsl_LightSample irr_glsl_createLightSampleTangentSpace(in vec3 tangentSpaceV, in vec3 tangentSpaceL, in mat3 tangentFrame)
 {
     irr_glsl_LightSample s;
 
     s.L = tangentFrame*tangentSpaceL; // m must be an orthonormal matrix
-    s.VdotL = dot(V,s.L);
+    s.VdotL = dot(tangentSpaceV,tangentSpaceL);
 
     s.TdotL = tangentSpaceL.x;
     s.BdotL = tangentSpaceL.y;
@@ -69,10 +69,6 @@ irr_glsl_LightSample irr_glsl_createLightSampleTangentSpaceL(in vec3 V, in vec3
 
     return s;
 }
-irr_glsl_LightSample irr_glsl_createLightSampleTangentSpaceL(in vec3 tangentSpaceL, in irr_glsl_AnisotropicViewSurfaceInteraction interaction)
-{
-    return irr_glsl_createLightSampleTangentSpaceL(interaction.isotropic.V.dir,tangentSpaceL,irr_glsl_getTangentFrame(interaction));
-}
 
 //
 irr_glsl_LightSample irr_glsl_createLightSample(in vec3 L, in float VdotL, in irr_glsl_IsotropicViewSurfaceInteraction interaction)