BSDF + BRDF initial code

Author: knightcrawler25

src/shaders/common/brdf.glsl

@@ -36,8 +36,12 @@ float DisneyPdf(in Ray ray, inout State state, in vec3 bsdfDir)
     vec3 L = bsdfDir;
     vec3 H = normalize(L + V);
 
+    //if (dot(N, L) < 0.0)
+    //    return 1.0;
+
     float NDotH = dot(N, H);
 
+    float specularAlpha = mix(0.1, 0.001, state.mat.roughness);
     float clearcoatAlpha = mix(0.1, 0.001, state.mat.clearcoatGloss);
 
     float diffuseRatio = 0.5 * (1.0 - state.mat.metallic);
@@ -47,15 +51,19 @@ float DisneyPdf(in Ray ray, inout State state, in vec3 bsdfDir)
     float ax = max(0.001, (state.mat.roughness * state.mat.roughness) / aspect);
     float ay = max(0.001, (state.mat.roughness * state.mat.roughness) * aspect);
 
-    // calculate diffuse and specular pdfs and mix ratio
-    float pdfGTR2 = GTR2_aniso(NDotH, dot(H, state.tangent), dot(H, state.bitangent), ax, ay) * NDotH;
+    // PDFs for brdf
+    float pdfGTR2_aniso = GTR2_aniso(NDotH, dot(H, state.tangent), dot(H, state.bitangent), ax, ay) * NDotH;
     float pdfGTR1 = GTR1(NDotH, clearcoatAlpha) * NDotH;
     float ratio = 1.0 / (1.0 + state.mat.clearcoat);
-    float pdfSpec = mix(pdfGTR1, pdfGTR2, ratio) / (4.0 * abs(dot(L, H)));
+    float pdfSpec = mix(pdfGTR1, pdfGTR2_aniso, ratio) / (4.0 * abs(dot(L, H)));
     float pdfDiff = abs(dot(L, N)) * (1.0 / PI);
+    float brdfPdf = diffuseRatio * pdfDiff + specularRatio * pdfSpec;
+
+    // PDFs for bsdf
+    float pdfGTR2 = GTR2(NDotH, specularAlpha) * NDotH;
+    float bsdfPdf = pdfGTR2 / (4.0 * abs(dot(L, H)));
 
-    // weigh pdfs according to ratios
-    return diffuseRatio * pdfDiff + specularRatio * pdfSpec;
+    return brdfPdf;//mix(brdfPdf, bsdfPdf, state.mat.transmission);
 }
 
 //-----------------------------------------------------------------------
@@ -67,32 +75,47 @@ vec3 DisneySample(in Ray ray, inout State state)
 
     vec3 dir;
 
-    float probability = rand();
-    float diffuseRatio = 0.5 * (1.0 - state.mat.metallic);
-
     float r1 = rand();
     float r2 = rand();
+    //float bsdfProb = rand();
 
-    if (probability < diffuseRatio) // sample diffuse
-    {
-        dir = CosineSampleHemisphere(r1, r2);
-        dir = state.tangent * dir.x + state.bitangent * dir.y + N * dir.z;
-    }
-    else
+    // BSDF
+    /*if (bsdfProb < state.mat.transmission)
     {
-        float a = max(0.001, state.mat.roughness);
-
-        float phi = r1 * 2.0 * PI;
+        float n1 = 1.0;
+        float n2 = state.mat.ior;
 
-        float cosTheta = sqrt((1.0 - r2) / (1.0 + (a*a - 1.0) *r2));
-        float sinTheta = clamp(sqrt(1.0 - (cosTheta * cosTheta)), 0.0, 1.0);
-        float sinPhi = sin(phi);
-        float cosPhi = cos(phi);
+        float theta = abs(dot(-V, N));
+        float eta = dot(state.normal, state.ffnormal) > 0.0 ? (n1 / n2) : (n2 / n1);
+        float cos2t = 1.0 - eta * eta * (1.0 - theta * theta);
 
-        vec3 H = vec3(sinTheta*cosPhi, sinTheta*sinPhi, cosTheta);
+        vec3 H = ImportanceSampleGGX(state.mat.roughness, r1, r2);
         H = state.tangent * H.x + state.bitangent * H.y + N * H.z;
 
-        dir = 2.0*dot(V, H)*H - V;
+        float F = Fresnel(theta, n1, n2);
+
+        if (cos2t < 0.0 || rand() < F)
+            dir = normalize(reflect(-V, H));
+        else
+            dir = normalize(refract(-V, H, eta));
+    }
+    else*/
+    {
+        float probability = rand();
+        float diffuseRatio = 0.5 * (1.0 - state.mat.metallic);
+
+        if (probability < diffuseRatio) 
+        {
+            vec3 H = CosineSampleHemisphere(r1, r2);
+            H = state.tangent * H.x + state.bitangent * H.y + N * H.z;
+            dir = H;
+        }
+        else
+        {
+            vec3 H = ImportanceSampleGGX(state.mat.roughness, r1, r2);
+            H = state.tangent * H.x + state.bitangent * H.y + N * H.z;
+            dir = reflect(-V, H);
+        }
     }
     return dir;
 }

src/shaders/common/glass.glsl

@@ -27,6 +27,7 @@
  * SOFTWARE.
  */
 
+/*
 //-----------------------------------------------------------------------
 float GlassPdf(Ray ray, inout State state, in vec3 bsdfDir)
 //-----------------------------------------------------------------------
@@ -76,10 +77,6 @@ vec3 GlassSample(in Ray ray, inout State state)
     float r1 = rand();
     float r2 = rand();
 
-    vec3 UpVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-    vec3 TangentX = normalize(cross(UpVector, N));
-    vec3 TangentY = cross(N, TangentX);
-
     float a = max(0.001, state.mat.roughness);
 
     float phi = r1 * 2.0 * PI;
@@ -90,7 +87,7 @@ vec3 GlassSample(in Ray ray, inout State state)
     float cosPhi = cos(phi);
 
     vec3 H = vec3(sinTheta * cosPhi, sinTheta * sinPhi, cosTheta);
-    H = TangentX * H.x + TangentY * H.y + N * H.z;
+    //H = TangentX * H.x + TangentY * H.y + N * H.z;
 
     float n1 = 1.0;
     float n2 = 1.45;
@@ -151,4 +148,5 @@ vec3 GlassEval(in Ray ray, inout State state, in vec3 bsdfDir)
     }
     else
         return state.mat.albedo * F * D * G;
-}
+}
+*/

src/shaders/common/pathtrace.glsl

@@ -31,8 +31,8 @@
 void Onb(in vec3 N, inout vec3 T, inout vec3 B)
 //-----------------------------------------------------------------------
 {
-    vec3 U = abs(N.z) < 0.999 ? vec3(0, 0, 1) : vec3(1, 0, 0);
-    T = normalize(cross(U, N));
+    vec3 UpVector = abs(N.z) < 0.999 ? vec3(0, 0, 1) : vec3(1, 0, 0);
+    T = normalize(cross(UpVector, N));
     B = cross(N, T);
 }
 
@@ -115,6 +115,7 @@ void GetMaterialsAndTextures(inout State state, in Ray r)
         vec3 nrm = texture(textureMapsArrayTex, vec3(texUV, int(mat.texIDs.z))).xyz;
         nrm = normalize(nrm * 2.0 - 1.0);
 
+        // Orthonormal Basis
         vec3 T, B;
         Onb(state.ffnormal, T, B);
 

src/shaders/common/sampling.glsl

@@ -27,6 +27,22 @@
  * SOFTWARE.
  */
 
+//----------------------------------------------------------------------
+vec3 ImportanceSampleGGX(float rgh, float r1, float r2)
+//----------------------------------------------------------------------
+{
+    float a = max(0.001, rgh);
+
+    float phi = r1 * 2.0 * PI;
+
+    float cosTheta = sqrt((1.0 - r2) / (1.0 + (a * a - 1.0) * r2));
+    float sinTheta = clamp(sqrt(1.0 - (cosTheta * cosTheta)), 0.0, 1.0);
+    float sinPhi = sin(phi);
+    float cosPhi = cos(phi);
+
+    return vec3(sinTheta * cosPhi, sinTheta * sinPhi, cosTheta);
+}
+
 //-----------------------------------------------------------------------
 float SchlickFresnel(float u)
 //-----------------------------------------------------------------------