Add Transmission material param, onb, experimental microfacet transmission

Author: knightcrawler25

src/Main.cpp

@@ -348,6 +348,8 @@ void MainLoop(void* arg)
             objectPropChanged |= ImGui::SliderFloat("SheenTint", &scene->materials[scene->meshInstances[selectedInstance].materialID].sheenTint, 0.001f, 1.0f);
             objectPropChanged |= ImGui::SliderFloat("Clearcoat", &scene->materials[scene->meshInstances[selectedInstance].materialID].clearcoat, 0.001f, 1.0f);
             objectPropChanged |= ImGui::SliderFloat("ClearcoatGloss", &scene->materials[scene->meshInstances[selectedInstance].materialID].clearcoatGloss, 0.001f, 1.0f);
+            objectPropChanged |= ImGui::SliderFloat("Transmission", &scene->materials[scene->meshInstances[selectedInstance].materialID].transmission, 0.001f, 1.0f);
+            objectPropChanged |= ImGui::SliderFloat("Ior", &scene->materials[scene->meshInstances[selectedInstance].materialID].ior, 1.0f, 2.0f);
 
             // Transforms Properties
             ImGui::Separator();

src/core/Material.h

@@ -55,10 +55,15 @@ namespace GLSLPT
             clearcoat      = 0.0f;
             clearcoatGloss = 0.0f;
 
+            transmission  = 0.0f;
+            ior           = 1.45f;
+            unused1       = 0.0f;
+            unused2       = 0.0f;
+
             albedoTexID             = -1.0f;
             metallicRoughnessTexID  = -1.0f;
             normalmapTexID          = -1.0f;
-            ior                     = 1.45f;
+            unused3                 =  0.0f;
         };
 
         Vec3 albedo;
@@ -77,9 +82,14 @@ namespace GLSLPT
         float clearcoat;
         float clearcoatGloss;
 
+        float transmission;
+        float ior;
+        float unused1;
+        float unused2;
+
         float albedoTexID;
         float metallicRoughnessTexID;
         float normalmapTexID;
-        float ior;
+        float unused3;
     };
 }

src/loaders/Loader.cpp

@@ -110,6 +110,7 @@ namespace GLSLPT
                     sscanf(line, " sheenTint %f", &material.sheenTint);
                     sscanf(line, " clearcoat %f", &material.clearcoat);
                     sscanf(line, " clearcoatGloss %f", &material.clearcoatGloss);
+                    sscanf(line, " transmission %f", &material.transmission);
                     sscanf(line, " ior %f", &material.ior);
                     //sscanf(line, " transmittance %f", &material.transmittance);
 

src/shaders/common/brdf.glsl

@@ -43,19 +43,13 @@ float DisneyPdf(in Ray ray, inout State state, in vec3 bsdfDir)
     float diffuseRatio = 0.5 * (1.0 - state.mat.metallic);
     float specularRatio = 1.0 - diffuseRatio;
 
-    float cosTheta = abs(dot(H, N));
-
-    vec3 UpVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-    vec3 X = normalize(cross(UpVector, N));
-    vec3 Y = cross(N, X);
-
     float aspect = sqrt(1.0 - state.mat.anisotropic * 0.9);
     float ax = max(0.001, (state.mat.roughness * state.mat.roughness) / aspect);
     float ay = max(0.001, (state.mat.roughness * state.mat.roughness) * aspect);
-    float pdfGTR2 = GTR2_aniso(NDotH, dot(H, X), dot(H, Y), ax, ay) * cosTheta;
-    float pdfGTR1 = GTR1(cosTheta, clearcoatAlpha) * cosTheta;
 
     // calculate diffuse and specular pdfs and mix ratio
+    float pdfGTR2 = 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 pdfDiff = abs(dot(L, N)) * (1.0 / PI);
@@ -79,14 +73,10 @@ vec3 DisneySample(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);
-
     if (probability < diffuseRatio) // sample diffuse
     {
         dir = CosineSampleHemisphere(r1, r2);
-        dir = TangentX * dir.x + TangentY * dir.y + N * dir.z;
+        dir = state.tangent * dir.x + state.bitangent * dir.y + N * dir.z;
     }
     else
     {
@@ -100,7 +90,7 @@ vec3 DisneySample(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 = state.tangent * H.x + state.bitangent * H.y + N * H.z;
 
         dir = 2.0*dot(V, H)*H - V;
     }
@@ -147,7 +137,7 @@ vec3 DisneyEval(in Ray ray, inout State state, in vec3 bsdfDir)
     float ss = 1.25 * (Fss * (1.0 / (NDotL + NDotV) - 0.5) + 0.5);
 
     // specular
-    /*float a = max(0.001f, state.mat.roughness);
+    /*float a = max(0.001, state.mat.roughness);
     float Ds = GTR2(NDotH, a);
     float FH = SchlickFresnel(LDotH);
     vec3 Fs = mix(Cspec0, vec3(1.0), FH);
@@ -156,18 +146,14 @@ vec3 DisneyEval(in Ray ray, inout State state, in vec3 bsdfDir)
     float Gs = SmithG_GGX(NDotL, roughg) * SmithG_GGX(NDotV, roughg);*/
 
     // specular
-    vec3 UpVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
-    vec3 X = normalize(cross(UpVector, N));
-    vec3 Y = cross(N, X);
-
     float aspect = sqrt(1.0 - state.mat.anisotropic * 0.9);
     float ax = max(0.001, (state.mat.roughness * state.mat.roughness) / aspect);
     float ay = max(0.001, (state.mat.roughness * state.mat.roughness) * aspect);
-    float Ds = GTR2_aniso(NDotH, dot(H, X), dot(H, Y), ax, ay);
+    float Ds = GTR2_aniso(NDotH, dot(H, state.tangent), dot(H, state.bitangent), ax, ay);
     float FH = SchlickFresnel(LDotH);
     vec3 Fs = mix(Cspec0, vec3(1.0), FH);
-    float Gs = SmithG_GGX_aniso(NDotL, dot(L, X), dot(L, Y), ax, ay);
-    Gs *= SmithG_GGX_aniso(NDotV, dot(V, X), dot(V, Y), ax, ay);
+    float Gs = SmithG_GGX_aniso(NDotL, dot(L, state.tangent), dot(L, state.bitangent), ax, ay);
+    Gs *= SmithG_GGX_aniso(NDotV, dot(V, state.tangent), dot(V, state.bitangent), ax, ay);
 
     // sheen
     vec3 Fsheen = FH * state.mat.sheen * Csheen;

src/shaders/common/glass.glsl

@@ -28,53 +28,127 @@
  */
 
 //-----------------------------------------------------------------------
-float GlassPdf(Ray ray, inout State state)
+float GlassPdf(Ray ray, inout State state, in vec3 bsdfDir)
 //-----------------------------------------------------------------------
 {
-    return 1.0;
+    vec3 N = state.ffnormal;
+    vec3 V = -ray.direction;
+    vec3 L = bsdfDir;
+
+    if (dot(N,L) <= 0.0)
+    {
+        L = -L;
+    }
+
+    vec3 H = normalize(L + V);
+
+    float NDotH = abs(dot(N, H));
+    float VDotH = abs(dot(V, H));
+
+    float a = max(0.001, state.mat.roughness);
+    float pdfGTR2 = GTR2(NDotH, a) * NDotH;
+
+    float F = Fresnel(abs(dot(L, H)), 1.0, 1.45);
+
+    float n1 = 1.0;
+    float n2 = 1.45;
+    float eta = dot(state.normal, N) > 0.0 ? (n1 / n2) : (n2 / n1);
+
+    // Transmission Vector
+    if (dot(N, L) < 0.0)
+    {
+        float denom = n1 * dot(V, H) + n2 * dot(L, H);
+        return pdfGTR2 * (1.0 - F) * abs(dot(L, H)) / (denom * denom);
+        //return 1.0;
+    }
+    else
+        return pdfGTR2 * F / (4.0 * abs(dot(L, H)));
+
 }
 
 //-----------------------------------------------------------------------
 vec3 GlassSample(in Ray ray, inout State state)
 //-----------------------------------------------------------------------
 {
-    /*float n1 = 1.0;
-    float n2 = state.mat.param.z;
-    float R0 = (n1 - n2) / (n1 + n2);
-    R0 *= R0;
-    float theta = dot(-ray.direction, state.ffnormal);
-    float prob = R0 + (1. - R0) * SchlickFresnel(theta);
-    vec3 dir;
+    vec3 N = state.ffnormal;
+    vec3 V = -ray.direction;
+
+    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;
 
-    //vec3 transmittance = vec3(1.0);
-    //vec3 extinction = -log(vec3(0.1, 0.1, 0.908));
-    //vec3 extinction = -log(vec3(0.905, 0.63, 0.3));
+    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 eta = dot(state.normal, state.ffnormal) > 0.0 ? (n1 / n2) : (n2 / n1);
-    vec3 transDir = normalize(refract(ray.direction, state.ffnormal, eta));
+    vec3 H = vec3(sinTheta * cosPhi, sinTheta * sinPhi, cosTheta);
+    H = TangentX * H.x + TangentY * H.y + N * H.z;
+
+    float n1 = 1.0;
+    float n2 = 1.45;
+
+    float theta = abs(dot(-V, N));
+    float eta = dot(state.normal, N) > 0.0 ? (n1 / n2) : (n2 / n1);
     float cos2t = 1.0 - eta * eta * (1.0 - theta * theta);
 
-    //if(dot(-ray.direction, state.normal) <= 0.0)
-    //    transmittance = exp(-extinction * state.hitDist * 100.0);
+    float F = Fresnel(theta, n1, n2);
 
-    if (cos2t < 0.0 || rand() < prob) // Reflection
-    {
-        dir = normalize(reflect(ray.direction, state.ffnormal));
-    }
-    else  // Transmission
-    {
-        dir = transDir;
-    }
-    //state.mat.albedo.xyz = transmittance;
-    return dir;*/
+    vec3 dir;
+    if (cos2t < 0.0 || rand() < F)
+       dir = normalize(reflect(-V, H));
+    else
+        dir = normalize(refract(-V, H, eta));
 
-    return vec3(1.0);
+    return dir;
 }
 
 //-----------------------------------------------------------------------
-vec3 GlassEval(in Ray ray, inout State state)
+vec3 GlassEval(in Ray ray, inout State state, in vec3 bsdfDir)
 //-----------------------------------------------------------------------
 {
-    return vec3(1.0);
-    //return state.mat.albedo.xyz;
+    vec3 N = state.ffnormal;
+    vec3 V = -ray.direction;
+    vec3 L = bsdfDir;
+
+    float NDotL = dot(N, L);
+    float NDotV = dot(N, V);
+
+    if (NDotL <= 0.0)
+    {
+        L = -L;
+    }
+    NDotL = dot(N, L);
+
+    vec3 H = normalize(L + V);
+
+    //if (NDotL <= 0.0 || NDotV <= 0.0)
+    //    return vec3(0.0);
+   
+    float NDotH = abs(dot(N, H));
+    float LDotH = abs(dot(L, H));
+    float VDotH = abs(dot(V, H));
+
+    float n1 = 1.0;
+    float n2 = 1.45;
+    float a = max(0.001, state.mat.roughness);
+    float D = GTR2(NDotH, a);
+    float F = Fresnel(LDotH, n1, n2);
+    float G = SmithG_GGX(NDotL, a) * SmithG_GGX(NDotV, a);
+
+    if (dot(N, L) < 0.0)
+    {
+        float denom = n1 * dot(V, H) + n2 * dot(L, H);
+        return 4.0 * state.mat.albedo * (LDotH * VDotH) * (1.0 - F) * D * G / (denom * denom);
+        //return vec3(1.0);
+    }
+    else
+        return state.mat.albedo * F * D * G;
 }

src/shaders/common/globals.glsl

@@ -32,25 +32,92 @@
 #define INFINITY  1000000.0
 #define EPS 0.001
 
-// Global variables
-
 mat4 transform;
 
 vec2 seed;
 vec3 tempTexCoords;
-struct Ray { vec3 origin; vec3 direction; };
-struct Material { vec3 albedo; float specular; vec3 emission; float anisotropic; float metallic; float roughness; float subsurface; float specularTint; float sheen; float sheenTint; float clearcoat; float clearcoatGloss; vec4 texIDs; };
-struct Camera { vec3 up; vec3 right; vec3 forward; vec3 position; float fov; float focalDist; float aperture; };
-struct Light { vec3 position; vec3 emission; vec3 u; vec3 v; vec3 radiusAreaType; };
-struct State { vec3 normal; vec3 ffnormal; vec3 fhp; bool isEmitter; int depth; float hitDist; vec2 texCoord; vec3 bary; ivec3 triID; int matID; Material mat; bool specularBounce; };
-struct BsdfSampleRec { vec3 bsdfDir; float pdf; };
-struct LightSampleRec { vec3 surfacePos; vec3 normal; vec3 emission; float pdf; };
+
+struct Ray 
+{ 
+    vec3 origin; 
+    vec3 direction; 
+};
+
+struct Material
+{
+    vec3 albedo; 
+    float specular; 
+    vec3 emission; 
+    float anisotropic; 
+    float metallic; 
+    float roughness; 
+    float subsurface; 
+    float specularTint; 
+    float sheen; 
+    float sheenTint; 
+    float clearcoat; 
+    float clearcoatGloss; 
+    float transmission; 
+    float ior; 
+    vec4 texIDs;
+};
+
+struct Camera 
+{ 
+    vec3 up; 
+    vec3 right;
+    vec3 forward; 
+    vec3 position; 
+    float fov; 
+    float focalDist;
+    float aperture; 
+};
+
+struct Light 
+{ 
+    vec3 position; 
+    vec3 emission; 
+    vec3 u; 
+    vec3 v; 
+    vec3 radiusAreaType; 
+};
+
+struct State 
+{ 
+    vec3 normal; 
+    vec3 ffnormal; 
+    vec3 tangent; 
+    vec3 bitangent;
+    vec3 fhp; 
+    bool isEmitter;
+    int depth; 
+    float hitDist; 
+    vec2 texCoord; 
+    vec3 bary; 
+    ivec3 triID; 
+    int matID;
+    Material mat;
+};
+
+struct BsdfSampleRec 
+{ 
+    vec3 bsdfDir; 
+    float pdf;
+};
+
+struct LightSampleRec 
+{ 
+    vec3 surfacePos; 
+    vec3 normal; 
+    vec3 emission; 
+    float pdf; 
+};
 
 uniform Camera camera;
 
-//-----------------------------------------------------------------------
+//-----------
 float rand()
-//-----------------------------------------------------------------------
+//-----------
 {
     seed -= randomVector.xy;
     return fract(sin(dot(seed, vec2(12.9898, 78.233))) * 43758.5453);