summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--data/shaders/pbr-frag.glsl169
1 files changed, 115 insertions, 54 deletions
diff --git a/data/shaders/pbr-frag.glsl b/data/shaders/pbr-frag.glsl
index 47ed573..36545d3 100644
--- a/data/shaders/pbr-frag.glsl
+++ b/data/shaders/pbr-frag.glsl
@@ -123,18 +123,19 @@ vec4 applyAlpha(vec4 color) {
}
vec2 texcoord(int i) {
- if(i == 0) {
- return fragTexcoord0;
- } else {
- return fragTexcoord1;
- }
+ return i == 0 ? fragTexcoord0: fragTexcoord1;
}
vec4 sRGBtoLinear(vec4 srgb) {
- return vec4(pow(srgb.r, GAMMA),
- pow(srgb.g, GAMMA),
- pow(srgb.b, GAMMA),
- srgb.a);
+ return vec4(pow(srgb.rgb, vec3(GAMMA)), srgb.a);
+}
+
+vec3 gammaCorrect(vec3 color) {
+ return pow(color, vec3(1.0 / GAMMA));
+}
+
+vec3 toneMap(vec3 color) {
+ return color / (color + vec3(1.0));
}
float materialMetallic() {
@@ -177,16 +178,16 @@ vec4 materialAlbedo() {
return color;
}
-vec4 materialEmissive() {
- vec4 color = vec4(0.0);
+vec3 materialEmissive() {
+ vec3 color = vec3(0.0);
if(material.emissiveTextureEnabled) {
vec4 texColor = texture(emissiveTexture,
texcoord(material.emissiveTexcoord));
- color = sRGBtoLinear(texColor);
+ color = sRGBtoLinear(texColor).rgb;
}
- return color * vec4(material.emissiveFactor, 1.0);
+ return color * material.emissiveFactor;
}
vec3 materialOcclusion() {
@@ -199,16 +200,25 @@ vec3 materialOcclusion() {
}
vec3 materialNormal() {
- vec3 normal;
-
if(material.normalTextureEnabled) {
- normal = texture(normalTexture,
- texcoord(material.normalTexcoord)).rgb * 2.0 - 1.0;
+ // See: http://www.thetenthplanet.de/archives/1180
+ vec2 t = texcoord(material.normalTexcoord);
+ vec3 tangentNormal = texture(normalTexture, t).xyz * 2.0 - 1.0;
+
+ vec3 q1 = dFdx(fragWorldPos);
+ vec3 q2 = dFdy(fragWorldPos);
+ vec2 st1 = dFdx(fragTexcoord0);
+ vec2 st2 = dFdy(fragTexcoord0);
+
+ vec3 N = normalize(fragNormal);
+ vec3 T = normalize(q1 * st2.t - q2 * st1.t);
+ vec3 B = -normalize(cross(N, T));
+ mat3 TBN = mat3(T, B, N);
+
+ return normalize(TBN * tangentNormal);
} else {
- normal = fragNormal;
+ return fragNormal;
}
-
- return normalize(normal);
}
vec3 lightDirection(Light light) {
@@ -237,7 +247,9 @@ vec3 lightRadiance(Light light, vec3 direction) {
// Spot lights only shine light in a specific conical area.
// They have no effect outside of that area.
if(theta > light.cutOff) {
- return lightAttenuate(light);
+ // Feather out the light as it approaches the edge of its cone.
+ float intensity = (theta - light.cutOff) / (1.0 - light.cutOff);
+ return lightAttenuate(light) * intensity;
} else {
return vec3(0.0);
}
@@ -246,6 +258,9 @@ vec3 lightRadiance(Light light, vec3 direction) {
return vec3(0.0); // should never be reached.
}
+// Useful resources I learned a lot from:
+// https://learnopengl.com/PBR/Theory
+// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
void main(void) {
// The unit vector pointing from the fragment position to the viewer
// position.
@@ -261,7 +276,7 @@ void main(void) {
// The ambient occlusion factor affects the degree to which ambient
// lighting has an affect on the fragment. Each element of the
// vector is in the range [0, 1].
- vec3 ao = materialOcclusion();
+ vec3 ambientOcclusion = materialOcclusion();
// The color that the fragment relects at zero incidence. In other
// words, the color reflected when looking directly at the fragment.
// A material that is fully metallic will fully express its albedo
@@ -271,7 +286,8 @@ void main(void) {
// somewhere between both colors, as calculated by a linear
// interpolation.
vec3 baseColor = mix(vec3(0.04), albedo, metallic);
- // Stores the sum of all lighting operations.
+ // We will accumulate the results of all lights (ambient, emissive,
+ // and user-specified direct lights) into this color vector.
vec3 color = vec3(0.0);
// Apply direct lighting.
@@ -285,45 +301,90 @@ void main(void) {
// The unit vector pointing from the fragment position to the
// light position.
- vec3 lightDirection = lightDirection(light);
- vec3 radiance = lightRadiance(light, lightDirection);
- // The half angle vector sits between the view direction and the
- // light direction.
- vec3 halfwayVector = normalize(viewDirection + lightDirection);
- // Apply the normal distribution function.
- float normalDistribution = distributionGGX(normal, halfwayVector, roughness);
- // Apply the geometry function.
- float geo = geometrySmith(normal, viewDirection, lightDirection, roughness);
- // Compute the fresnel factor via Schlick's approximation to get
- // the specular relection coeffecient. Since this is a microfacet
- // lighting model, we need to use the dot product of the halfway
- // vector and the view direction to get the cos(theta) value,
- // according to:
- // https://en.wikipedia.org/wiki/Schlick%27s_approximation
- vec3 fresnelFactor = fresnelSchlick(posDot(halfwayVector, viewDirection), baseColor);
- vec3 refractionRatio = (vec3(1.0) - fresnelFactor) * (1.0 - metallic);
- vec3 specularNumerator = normalDistribution * geo * fresnelFactor;
+ vec3 direction = lightDirection(light);
// The dot product of the surface normal and the light direction
- // gives a value in the range [0, 1]. 0 means the normal and light
+ // gives a value in the range [0, 1] that tells us how directly
+ // light is hitting the fragment. 0 means the normal and light
// direction form a >= 90 degree angle and thus the light should
// have no effect. 1 means the light is directly hitting the
- // surface and the lighting should be applied with full intensity.
- float specularFactor = posDot(normal, lightDirection);
- float specularDenominator = 4.0 * posDot(normal, viewDirection) * specularFactor;
- vec3 specular = specularNumerator / max(specularDenominator, 0.001);
+ // surface and the light should be applied with full intensity.
+ float incidenceFactor = posDot(normal, direction);
+ // The intensity of the light.
+ vec3 radiance = lightRadiance(light, direction);
+
+ // Skip all the expensive math below if the light will have no
+ // effect on the result.
+ if(incidenceFactor == 0.0 || radiance == vec3(0.0)) {
+ continue;
+ }
- color += (refractionRatio * albedo / PI + specular) * radiance * specularFactor;
+ // The halfway vector is named as such because it is halfway
+ // between the view direction and the light direction. It is a
+ // significant vector for microfacet lighting calculations.
+ vec3 halfwayVector = normalize(viewDirection + direction);
+ // Apply the Trowbridge-Reitz GGX normal distribution function.
+ // This function approximates the percentage of microfacets that
+ // are aligned with the halfway vector. Smooth objects have a lot
+ // of aligned microfacets over a small area, thus the viewer sees
+ // a bright spot. Rough objects have few aligned microfacets over
+ // a larger area, thus it appears dull.
+ float normalDistribution = distributionGGX(normal, halfwayVector, roughness);
+ // Apply the geometry distribution function using Smith's method.
+ // This function approximates how much light is reflected based on
+ // the fragment's roughness. Rougher objects reflect less light
+ // because the microfacets of the surface obstruct or overshadow
+ // the reflected light rays.
+ float geoFactor = geometrySmith(normal, viewDirection, direction, roughness);
+ // Compute the fresnel factor via Schlick's approximation to get
+ // the specular reflection coeffecient, i.e. the percentage of
+ // light that is reflected. Since this is a microfacet lighting
+ // model, we need to use the dot product of the halfway vector and
+ // the view direction to get the cos(theta) value, according to:
+ // https://en.wikipedia.org/wiki/Schlick%27s_approximation
+ //
+ // I also found this article useful:
+ // http://psgraphics.blogspot.com/2020/03/fresnel-equations-schlick-approximation.html
+ vec3 reflectionFactor = fresnelSchlick(posDot(halfwayVector, direction), baseColor);
+ // Refracted light is the leftover light that hasn't been
+ // reflected. One additional complicating factor is that metallic
+ // surfaces don't refract light, so we must scale the refraction
+ // factor based on how metallic the fragment is.
+ vec3 refractionFactor = (vec3(1.0) - reflectionFactor) * (1.0 - metallic);
+ // The dot product of the surface normal and the view direction
+ // gives a value in the range [0, 1] that tells us how directly
+ // the viewer is looking at the fragment. The effect of specular
+ // lighting changes based on the angle from the viewer to the
+ // surface.
+ float viewFactor = posDot(normal, viewDirection);
+ // Specular and diffuse lighting are processed together using the
+ // Cook-Torrance bidirectional reflectance distribution function
+ // (BRDF.)
+ //
+ // http://www.codinglabs.net/article_physically_based_rendering_cook_torrance.aspx
+ vec3 cookTorranceNumerator = normalDistribution * reflectionFactor * geoFactor;
+ float cookTorranceDenominator = 4.0 * viewFactor * incidenceFactor;
+ // We need to be careful to avoid a division by zero error, such
+ // as when the specular factor is 0, so we clamp the denominator
+ // to some very small value to safeguard ourselves.
+ vec3 specular = cookTorranceNumerator / max(cookTorranceDenominator, 0.0001);
+ // Apply Lambertian reflectance to get the diffuse lighting
+ // factor. https://en.wikipedia.org/wiki/Lambertian_reflectance
+ vec3 diffuse = refractionFactor * albedo / PI;
+ // The final light value is the combination of diffuse and
+ // specular light scaled by the intensity of the light source and
+ // the angle of incidence (how directly the light hit the
+ // fragment.)
+ color += (diffuse + specular) * radiance * incidenceFactor;
}
- // The emissive texture says which fragments emit light. There's
- // probably something more complicated to do here, but for now we
- // just add it to the accumulator to get a decent result.
- color += materialEmissive().rgb;
+ // The emissive texture says which fragments emit light. We simply
+ // add this light value to the color accumulator.
+ color += materialEmissive();
// Apply simple ambient lighting. The affect of the ambient light
// is dampened by the ambient occlusion factor.
//
// TODO: Use image based lighting.
- color += ambientLightColor.rgb * albedo * ao;
+ color += ambientLightColor.rgb * albedo * ambientOcclusion;
// Apply Reinhard tone mapping to convert our high dynamic range
// color value to low dynamic range. All of the lighting
// calculations stacked on top of each other is likely to create
@@ -331,13 +392,13 @@ void main(void) {
// linear color space, i.e. high dynamic range. If we did nothing,
// the resulting color values would be clamped to that range and the
// final image would be mostly white and washed out.
- color = color / (color + vec3(1.0));
+ color = toneMap(color);
// Apply gamma correction. The power of 2.2 is the rough average
// gamma value of most monitors. So, scaling the color by the
// inverse, the power of 1/2.2, the color that people see on the
// monitor is closer to what we intend to present with our original
// linear color value.
- color = pow(color, vec3(1.0 / GAMMA));
+ color = gammaCorrect(color);
// Add alpha channel back in and apply the appropriate blend mode.
// Yay, we're done!
vec4 finalColor = applyAlpha(vec4(color, rawAlbedo.a));