@luma.gl/shadertools 9.1.0-alpha.1 → 9.1.0-alpha.12

package/dist/modules/lighting/pbr-material/pbr-fragment-glsl.js

@@ -6,31 +6,49 @@
 // This fragment shader defines a reference implementation for Physically Based Shading of
 // a microfacet surface material defined by a glTF model.
 // TODO - better do the checks outside of shader
-import { glsl } from "../../../lib/glsl-utils/highlight.js";
-export const fs = `\
+export const fs = /* glsl */ `\
 precision highp float;
+
 uniform Projection {
-uniform vec3 u_Camera;
+  // Projection
+  uniform vec3 u_Camera;
 };
+
 uniform pbrMaterial {
-bool unlit;
-bool baseColorMapEnabled;
-vec4 baseColorFactor;
-bool normalMapEnabled;
-float normalScale;
-bool emissiveMapEnabled;
-vec3 emissiveFactor;
-vec2 metallicRoughnessValues;
-bool metallicRoughnessMapEnabled;
-bool occlusionMapEnabled;
-float occlusionStrength;
-bool alphaCutoffEnabled;
-float alphaCutoff;
-bool IBLenabled;
-vec2 scaleIBLAmbient;
-vec4 scaleDiffBaseMR;
-vec4 scaleFGDSpec;
+  // Material is unlit
+  bool unlit;
+
+  // Base color map
+  bool baseColorMapEnabled;
+  vec4 baseColorFactor;
+
+  bool normalMapEnabled;  
+  float normalScale; // #ifdef HAS_NORMALMAP
+
+  bool emissiveMapEnabled;
+  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP
+
+  vec2 metallicRoughnessValues;
+  bool metallicRoughnessMapEnabled;
+
+  bool occlusionMapEnabled;
+  float occlusionStrength; // #ifdef HAS_OCCLUSIONMAP
+  
+  bool alphaCutoffEnabled;
+  float alphaCutoff; // #ifdef ALPHA_CUTOFF
+  
+  // IBL
+  bool IBLenabled;
+  vec2 scaleIBLAmbient; // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  vec4 scaleDiffBaseMR;
+  vec4 scaleFGDSpec;
+  // #endif
 } u_pbrMaterial;
+
+// Samplers
 #ifdef HAS_BASECOLORMAP
 uniform sampler2D u_BaseColorSampler;
 #endif
@@ -51,8 +69,12 @@ uniform samplerCube u_DiffuseEnvSampler;
 uniform samplerCube u_SpecularEnvSampler;
 uniform sampler2D u_brdfLUT;
 #endif
+
+// Inputs from vertex shader
+
 varying vec3 pbr_vPosition;
 varying vec2 pbr_vUV;
+
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
 varying mat3 pbr_vTBN;
@@ -60,233 +82,334 @@ varying mat3 pbr_vTBN;
 varying vec3 pbr_vNormal;
 #endif
 #endif
+
+// Encapsulate the various inputs used by the various functions in the shading equation
+// We store values in this struct to simplify the integration of alternative implementations
+// of the shading terms, outlined in the Readme.MD Appendix.
 struct PBRInfo {
-float NdotL;
-float NdotV;
-float NdotH;
-float LdotH;
-float VdotH;
-float perceptualRoughness;
-float metalness;
-vec3 reflectance0;
-vec3 reflectance90;
-float alphaRoughness;
-vec3 diffuseColor;
-vec3 specularColor;
-vec3 n;
-vec3 v;
+  float NdotL;                  // cos angle between normal and light direction
+  float NdotV;                  // cos angle between normal and view direction
+  float NdotH;                  // cos angle between normal and half vector
+  float LdotH;                  // cos angle between light direction and half vector
+  float VdotH;                  // cos angle between view direction and half vector
+  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)
+  float metalness;              // metallic value at the surface
+  vec3 reflectance0;            // full reflectance color (normal incidence angle)
+  vec3 reflectance90;           // reflectance color at grazing angle
+  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])
+  vec3 diffuseColor;            // color contribution from diffuse lighting
+  vec3 specularColor;           // color contribution from specular lighting
+  vec3 n;                       // normal at surface point
+  vec3 v;                       // vector from surface point to camera
 };
+
 const float M_PI = 3.141592653589793;
 const float c_MinRoughness = 0.04;
+
 vec4 SRGBtoLINEAR(vec4 srgbIn)
 {
 #ifdef MANUAL_SRGB
 #ifdef SRGB_FAST_APPROXIMATION
-vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
-#else
-vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
-vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
-#endif
-return vec4(linOut,srgbIn.w);;
-#else
-return srgbIn;
-#endif
+  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
+#else // SRGB_FAST_APPROXIMATION
+  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
+  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
+#endif //SRGB_FAST_APPROXIMATION
+  return vec4(linOut,srgbIn.w);;
+#else //MANUAL_SRGB
+  return srgbIn;
+#endif //MANUAL_SRGB
 }
+
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
 vec3 getNormal()
 {
+  // Retrieve the tangent space matrix
 #ifndef HAS_TANGENTS
-vec3 pos_dx = dFdx(pbr_vPosition);
-vec3 pos_dy = dFdy(pbr_vPosition);
-vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
-vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
-vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+  vec3 pos_dx = dFdx(pbr_vPosition);
+  vec3 pos_dy = dFdy(pbr_vPosition);
+  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
+  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
+  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+
 #ifdef HAS_NORMALS
-vec3 ng = normalize(pbr_vNormal);
+  vec3 ng = normalize(pbr_vNormal);
 #else
-vec3 ng = cross(pos_dx, pos_dy);
+  vec3 ng = cross(pos_dx, pos_dy);
 #endif
-t = normalize(t - ng * dot(ng, t));
-vec3 b = normalize(cross(ng, t));
-mat3 tbn = mat3(t, b, ng);
-#else
-mat3 tbn = pbr_vTBN;
+
+  t = normalize(t - ng * dot(ng, t));
+  vec3 b = normalize(cross(ng, t));
+  mat3 tbn = mat3(t, b, ng);
+#else // HAS_TANGENTS
+  mat3 tbn = pbr_vTBN;
 #endif
+
 #ifdef HAS_NORMALMAP
-vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;
-n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_pbrMaterial.normalScale, u_pbrMaterial.normalScale, 1.0)));
+  vec3 n = texture2D(u_NormalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(u_pbrMaterial.normalScale, u_pbrMaterial.normalScale, 1.0)));
 #else
-vec3 n = normalize(tbn[2].xyz);
+  // The tbn matrix is linearly interpolated, so we need to re-normalize
+  vec3 n = normalize(tbn[2].xyz);
 #endif
-return n;
+
+  return n;
 }
+
+// Calculation of the lighting contribution from an optional Image Based Light source.
+// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
+// See our README.md on Environment Maps [3] for additional discussion.
 #ifdef USE_IBL
 vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
 {
-float mipCount = 9.0;
-float lod = (pbrInfo.perceptualRoughness * mipCount);
-vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,
-vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
-vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
+  float mipCount = 9.0; // resolution of 512x512
+  float lod = (pbrInfo.perceptualRoughness * mipCount);
+  // retrieve a scale and bias to F0. See [1], Figure 3
+  vec3 brdf = SRGBtoLINEAR(texture2D(u_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(textureCube(u_DiffuseEnvSampler, n)).rgb;
+
 #ifdef USE_TEX_LOD
-vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(textureCubeLod(u_SpecularEnvSampler, reflection, lod)).rgb;
 #else
-vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
+  vec3 specularLight = SRGBtoLINEAR(textureCube(u_SpecularEnvSampler, reflection)).rgb;
 #endif
-vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
-vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
-diffuse *= u_pbrMaterial.scaleIBLAmbient.x;
-specular *= u_pbrMaterial.scaleIBLAmbient.y;
-return diffuse + specular;
+
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
+
+  // For presentation, this allows us to disable IBL terms
+  diffuse *= u_pbrMaterial.scaleIBLAmbient.x;
+  specular *= u_pbrMaterial.scaleIBLAmbient.y;
+
+  return diffuse + specular;
 }
 #endif
+
+// Basic Lambertian diffuse
+// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
+// See also [1], Equation 1
 vec3 diffuse(PBRInfo pbrInfo)
 {
-return pbrInfo.diffuseColor / M_PI;
+  return pbrInfo.diffuseColor / M_PI;
 }
+
+// The following equation models the Fresnel reflectance term of the spec equation (aka F())
+// Implementation of fresnel from [4], Equation 15
 vec3 specularReflection(PBRInfo pbrInfo)
 {
-return pbrInfo.reflectance0 +
-(pbrInfo.reflectance90 - pbrInfo.reflectance0) *
-pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
 }
+
+// This calculates the specular geometric attenuation (aka G()),
+// where rougher material will reflect less light back to the viewer.
+// This implementation is based on [1] Equation 4, and we adopt their modifications to
+// alphaRoughness as input as originally proposed in [2].
 float geometricOcclusion(PBRInfo pbrInfo)
 {
-float NdotL = pbrInfo.NdotL;
-float NdotV = pbrInfo.NdotV;
-float r = pbrInfo.alphaRoughness;
-float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
-float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
-return attenuationL * attenuationV;
+  float NdotL = pbrInfo.NdotL;
+  float NdotV = pbrInfo.NdotV;
+  float r = pbrInfo.alphaRoughness;
+
+  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  float attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
+  return attenuationL * attenuationV;
 }
+
+// The following equation(s) model the distribution of microfacet normals across
+// the area being drawn (aka D())
+// Implementation from "Average Irregularity Representation of a Roughened Surface
+// for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
+// Follows the distribution function recommended in the SIGGRAPH 2013 course notes
+// from EPIC Games [1], Equation 3.
 float microfacetDistribution(PBRInfo pbrInfo)
 {
-float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
-float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
-return roughnessSq / (M_PI * f * f);
+  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  return roughnessSq / (M_PI * f * f);
 }
+
 void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
-pbrInfo.NdotL = 1.0;
-pbrInfo.NdotH = 0.0;
-pbrInfo.LdotH = 0.0;
-pbrInfo.VdotH = 1.0;
+  pbrInfo.NdotL = 1.0;
+  pbrInfo.NdotH = 0.0;
+  pbrInfo.LdotH = 0.0;
+  pbrInfo.VdotH = 1.0;
 }
+
 void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
-vec3 n = pbrInfo.n;
-vec3 v = pbrInfo.v;
-vec3 l = normalize(lightDirection);
-vec3 h = normalize(l+v);
-pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
-pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
-pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
-pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
+  vec3 n = pbrInfo.n;
+  vec3 v = pbrInfo.v;
+  vec3 l = normalize(lightDirection);             // Vector from surface point to light
+  vec3 h = normalize(l+v);                        // Half vector between both l and v
+
+  pbrInfo.NdotL = clamp(dot(n, l), 0.001, 1.0);
+  pbrInfo.NdotH = clamp(dot(n, h), 0.0, 1.0);
+  pbrInfo.LdotH = clamp(dot(l, h), 0.0, 1.0);
+  pbrInfo.VdotH = clamp(dot(v, h), 0.0, 1.0);
 }
+
 void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
-vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
-PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
+
 vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
-vec3 F = specularReflection(pbrInfo);
-float G = geometricOcclusion(pbrInfo);
-float D = microfacetDistribution(pbrInfo);
-vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
-vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
-return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
+  // Calculate the shading terms for the microfacet specular shading model
+  vec3 F = specularReflection(pbrInfo);
+  float G = geometricOcclusion(pbrInfo);
+  float D = microfacetDistribution(pbrInfo);
+
+  // Calculation of analytical lighting contribution
+  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  vec3 specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
+  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
 }
+
 vec4 pbr_filterColor(vec4 colorUnused)
 {
+  // The albedo may be defined from a base texture or a flat color
 #ifdef HAS_BASECOLORMAP
-vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_pbrMaterial.baseColorFactor;
+  vec4 baseColor = SRGBtoLINEAR(texture2D(u_BaseColorSampler, pbr_vUV)) * u_pbrMaterial.baseColorFactor;
 #else
-vec4 baseColor = u_pbrMaterial.baseColorFactor;
+  vec4 baseColor = u_pbrMaterial.baseColorFactor;
 #endif
+
 #ifdef ALPHA_CUTOFF
-if (baseColor.a < u_pbrMaterial.alphaCutoff) {
-discard;
-}
+  if (baseColor.a < u_pbrMaterial.alphaCutoff) {
+    discard;
+  }
 #endif
-vec3 color = vec3(0, 0, 0);
-if(u_pbrMaterial.unlit){
-color.rgb = baseColor.rgb;
-}
-else{
-float perceptualRoughness = u_pbrMaterial.metallicRoughnessValues.y;
-float metallic = u_pbrMaterial.metallicRoughnessValues.x;
+
+  vec3 color = vec3(0, 0, 0);
+
+  if(u_pbrMaterial.unlit){
+    color.rgb = baseColor.rgb;
+  }
+  else{
+    // Metallic and Roughness material properties are packed together
+    // In glTF, these factors can be specified by fixed scalar values
+    // or from a metallic-roughness map
+    float perceptualRoughness = u_pbrMaterial.metallicRoughnessValues.y;
+    float metallic = u_pbrMaterial.metallicRoughnessValues.x;
 #ifdef HAS_METALROUGHNESSMAP
-vec4 mrSample = texture2D(u_MetallicRoughnessSampler, pbr_vUV);
-perceptualRoughness = mrSample.g * perceptualRoughness;
-metallic = mrSample.b * metallic;
+    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
+    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
+    vec4 mrSample = texture2D(u_MetallicRoughnessSampler, pbr_vUV);
+    perceptualRoughness = mrSample.g * perceptualRoughness;
+    metallic = mrSample.b * metallic;
 #endif
-perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
-metallic = clamp(metallic, 0.0, 1.0);
-float alphaRoughness = perceptualRoughness * perceptualRoughness;
-vec3 f0 = vec3(0.04);
-vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
-diffuseColor *= 1.0 - metallic;
-vec3 specularColor = mix(f0, baseColor.rgb, metallic);
-float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
-float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
-vec3 specularEnvironmentR0 = specularColor.rgb;
-vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
-vec3 n = getNormal();
-vec3 v = normalize(u_Camera - pbr_vPosition);
-float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
-vec3 reflection = -normalize(reflect(v, n));
-PBRInfo pbrInfo = PBRInfo(
-0.0,
-NdotV,
-0.0,
-0.0,
-0.0,
-perceptualRoughness,
-metallic,
-specularEnvironmentR0,
-specularEnvironmentR90,
-alphaRoughness,
-diffuseColor,
-specularColor,
-n,
-v
-);
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    // Roughness is authored as perceptual roughness; as is convention,
+    // convert to material roughness by squaring the perceptual roughness [2].
+    float alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+    vec3 f0 = vec3(0.04);
+    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
+    diffuseColor *= 1.0 - metallic;
+    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+
+    // Compute reflectance.
+    float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+
+    // For typical incident reflectance range (between 4% to 100%) set the grazing
+    // reflectance to 100% for typical fresnel effect.
+    // For very low reflectance range on highly diffuse objects (below 4%),
+    // incrementally reduce grazing reflecance to 0%.
+    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+    vec3 specularEnvironmentR0 = specularColor.rgb;
+    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+
+    vec3 n = getNormal();                          // normal at surface point
+    vec3 v = normalize(u_Camera - pbr_vPosition);  // Vector from surface point to camera
+
+    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+    vec3 reflection = -normalize(reflect(v, n));
+
+    PBRInfo pbrInfo = PBRInfo(
+      0.0, // NdotL
+      NdotV,
+      0.0, // NdotH
+      0.0, // LdotH
+      0.0, // VdotH
+      perceptualRoughness,
+      metallic,
+      specularEnvironmentR0,
+      specularEnvironmentR90,
+      alphaRoughness,
+      diffuseColor,
+      specularColor,
+      n,
+      v
+    );
+
 #ifdef USE_LIGHTS
-PBRInfo_setAmbientLight(pbrInfo);
-color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);
-for(int i = 0; i < lighting_uDirectionalLightCount; i++) {
-if (i < lighting_uDirectionalLightCount) {
-PBRInfo_setDirectionalLight(pbrInfo, lighting_uDirectionalLight[i].direction);
-color += calculateFinalColor(pbrInfo, lighting_uDirectionalLight[i].color);
-}
-}
-for(int i = 0; i < lighting_uPointLightCount; i++) {
-if (i < lighting_uPointLightCount) {
-PBRInfo_setPointLight(pbrInfo, lighting_uPointLight[i]);
-float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
-color += calculateFinalColor(pbrInfo, lighting_uPointLight[i].color / attenuation);
-}
-}
+    // Apply ambient light
+    PBRInfo_setAmbientLight(pbrInfo);
+    color += calculateFinalColor(pbrInfo, lighting_uAmbientLight.color);
+
+    // Apply directional light
+    for(int i = 0; i < lighting_uDirectionalLightCount; i++) {
+      if (i < lighting_uDirectionalLightCount) {
+        PBRInfo_setDirectionalLight(pbrInfo, lighting_uDirectionalLight[i].direction);
+        color += calculateFinalColor(pbrInfo, lighting_uDirectionalLight[i].color);
+      }
+    }
+
+    // Apply point light
+    for(int i = 0; i < lighting_uPointLightCount; i++) {
+      if (i < lighting_uPointLightCount) {
+        PBRInfo_setPointLight(pbrInfo, lighting_uPointLight[i]);
+        float attenuation = getPointLightAttenuation(lighting_uPointLight[i], distance(lighting_uPointLight[i].position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_uPointLight[i].color / attenuation);
+      }
+    }
 #endif
+
+    // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
-if (u_pbrMateral.IBLEnabled) {
-color += getIBLContribution(pbrInfo, n, reflection);
-}
+    if (u_pbrMateral.IBLEnabled) {
+      color += getIBLContribution(pbrInfo, n, reflection);
+    }
 #endif
+
+    // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
-if (u_pbrMaterial.occlusionMapEnabled) {
-float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;
-color = mix(color, color * ao, u_pbrMaterial.occlusionStrength);
-}
+    if (u_pbrMaterial.occlusionMapEnabled) {
+      float ao = texture2D(u_OcclusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, u_pbrMaterial.occlusionStrength);
+    }
 #endif
+
 #ifdef HAS_EMISSIVEMAP
-if (u_pbrMaterial.emmissiveMapEnabled) {
-vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_pbrMaterial.emissiveFactor;
-color += emissive;
-}
+    if (u_pbrMaterial.emmissiveMapEnabled) {
+      vec3 emissive = SRGBtoLINEAR(texture2D(u_EmissiveSampler, pbr_vUV)).rgb * u_pbrMaterial.emissiveFactor;
+      color += emissive;
+    }
 #endif
+
+    // This section uses mix to override final color for reference app visualization
+    // of various parameters in the lighting equation.
 #ifdef PBR_DEBUG
-color = mix(color, baseColor.rgb, u_pbrMaterial.scaleDiffBaseMR.y);
-color = mix(color, vec3(metallic), u_pbrMaterial.scaleDiffBaseMR.z);
-color = mix(color, vec3(perceptualRoughness), u_pbrMaterial.scaleDiffBaseMR.w);
+    // TODO: Figure out how to debug multiple lights
+
+    // color = mix(color, F, u_ScaleFGDSpec.x);
+    // color = mix(color, vec3(G), u_ScaleFGDSpec.y);
+    // color = mix(color, vec3(D), u_ScaleFGDSpec.z);
+    // color = mix(color, specContrib, u_ScaleFGDSpec.w);
+
+    // color = mix(color, diffuseContrib, u_ScaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, u_pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3(metallic), u_pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3(perceptualRoughness), u_pbrMaterial.scaleDiffBaseMR.w);
 #endif
-}
-return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
+
+  }
+
+  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
 }
 `;