Merge pull request #556 from KhronosGroup/refactor/BRDF

Refactor/brdf

source/GltfState/gltf_state.js

@@ -149,10 +149,8 @@ GltfState.DebugOutput = {
  EMISSIVE: "Emissive",
  },
 
- /** output metallic roughness */
+ /** metallic roughness */
  mr: {
- /** output the combined metallic roughness */
- METALLIC_ROUGHNESS: "Metallic Roughness",
  /** output the base color value */
  BASECOLOR: "Base Color",
  /** output the metallic value from pbr metallic roughness */
@@ -161,69 +159,57 @@ GltfState.DebugOutput = {
  ROUGHNESS: "Roughness",
  },
 
- /** output clearcoat lighting */
+ /** KHR_materials_clearcoat */
  clearcoat: {
- /** output the combined clear coat */
- CLEARCOAT: "ClearCoat",
- /** output the clear coat factor */
- CLEARCOAT_FACTOR: "ClearCoat Factor",
+ /** output the clear coat strength */
+ CLEARCOAT_FACTOR: "ClearCoat Strength",
  /** output the clear coat roughness */
  CLEARCOAT_ROUGHNESS: "ClearCoat Roughness",
  /** output the clear coat normal */
  CLEARCOAT_NORMAL: "ClearCoat Normal",
  },
 
- /** output sheen lighting */
+ /** KHR_materials_sheen */
  sheen: {
- /** output the combined sheen */
- SHEEN: "Sheen",
  /** output the sheen color*/
  SHEEN_COLOR: "Sheen Color",
  /** output the sheen roughness*/
  SHEEN_ROUGHNESS: "Sheen Roughness",
  },
 
- /** output specular lighting */
+ /** KHR_materials_specular */
  specular: {
- /** output the combined specular */
- SPECULAR: "Specular",
- /** output the specular factor*/
- SPECULAR_FACTOR: "Specular Factor",
+ /** output the specular strength*/
+ SPECULAR_FACTOR: "Specular Strength",
  /** output the specular color*/
  SPECULAR_COLOR: "Specular Color",
  },
 
- /** output tranmission lighting */
+ /** KHR_materials_transmission */
  transmission: {
- /** output the combined transmission/volume */
- TRANSMISSION_VOLUME: "Transmission/Volume",
- /** output the transmission factor*/
- TRANSMISSION_FACTOR: "Transmission Factor",
+ /** output the transmission strength*/
+ TRANSMISSION_FACTOR: "Transmission Strength",
  /** output the volume thickness*/
  VOLUME_THICKNESS: "Volume Thickness",
  },
 
- /** output diffuse tranmission lighting */
+ /** KHR_materials_diffuse_tranmission */
  diffuseTransmission: {
- /** output the combined diffuse tranmission */
- DIFFUSE_TRANSMISSION: "Diffuse Transmission",
- /** output the diffuse tranmission factor */
- DIFFUSE_TRANSMISSION_FACTOR: "Diffuse Transmission Factor",
+ /** output the diffuse tranmission strength */
+ DIFFUSE_TRANSMISSION_FACTOR: "Diffuse Transmission Strength",
  /** output the diffuse tranmission color factor */
- DIFFUSE_TRANSMISSION_COLOR_FACTOR: "Diffuse Transmission Color Factor",
+ DIFFUSE_TRANSMISSION_COLOR_FACTOR: "Diffuse Transmission Color",
  },
 
- /** output iridescence */
+ /** KHR_materials_iridescence */
  iridescence: {
- /** output the combined iridescence */
- IRIDESCENCE: "Iridescence",
- /** output the iridescence factor*/
- IRIDESCENCE_FACTOR: "Iridescence Factor",
+ /** output the iridescence strength*/
+ IRIDESCENCE_FACTOR: "Iridescence Strength",
  /** output the iridescence thickness*/
  IRIDESCENCE_THICKNESS: "Iridescence Thickness",
  },
 
- /** output anisotropy */
+ /** KHR_materials_anisotropy */
  anisotropy: {
  /** output the anisotropic strength*/
  ANISOTROPIC_STRENGTH: "Anisotropic Strength",

source/Renderer/shaders/brdf.glsl

@@ -8,7 +8,7 @@
 
 // The following equation models the Fresnel reflectance term of the spec equation (aka F())
 // Implementation of fresnel from [4], Equation 15
-vec3 F_Schlick(vec3 f0, vec3 f90, float VdotH)
+vec3 F_Schlick(vec3 f0, vec3 f90, float VdotH) 
 {
  return f0 + (f90 - f0) * pow(clamp(1.0 - VdotH, 0.0, 1.0), 5.0);
 }
@@ -149,54 +149,22 @@ float D_Charlie(float sheenRoughness, float NdotH)
 
 
 //https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#acknowledgments AppendixB
-vec3 BRDF_lambertian(vec3 f0, vec3 f90, vec3 diffuseColor, float specularWeight, float VdotH)
+vec3 BRDF_lambertian(vec3 diffuseColor)
 {
  // see https://seblagarde.wordpress.com/2012/01/08/pi-or-not-to-pi-in-game-lighting-equation/
- return (1.0 - specularWeight * F_Schlick(f0, f90, VdotH)) * (diffuseColor / M_PI);
+ return (diffuseColor / M_PI);
 }
 
-
-#ifdef MATERIAL_IRIDESCENCE
-//https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#acknowledgments AppendixB
-vec3 BRDF_lambertianIridescence(vec3 f0, vec3 f90, vec3 iridescenceFresnel, float iridescenceFactor, vec3 diffuseColor, float specularWeight, float VdotH)
-{
- // Use the maximum component of the iridescence Fresnel color
- // Maximum is used instead of the RGB value to not get inverse colors for the diffuse BRDF
- vec3 iridescenceFresnelMax = vec3(max(max(iridescenceFresnel.r, iridescenceFresnel.g), iridescenceFresnel.b));
-
- vec3 schlickFresnel = F_Schlick(f0, f90, VdotH);
-
- // Blend default specular Fresnel with iridescence Fresnel
- vec3 F = mix(schlickFresnel, iridescenceFresnelMax, iridescenceFactor);
-
- // see https://seblagarde.wordpress.com/2012/01/08/pi-or-not-to-pi-in-game-lighting-equation/
- return (1.0 - specularWeight * F) * (diffuseColor / M_PI);
-}
-#endif
-
-
 // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#acknowledgments AppendixB
-vec3 BRDF_specularGGX(vec3 f0, vec3 f90, float alphaRoughness, float specularWeight, float VdotH, float NdotL, float NdotV, float NdotH)
+vec3 BRDF_specularGGX(float alphaRoughness, float NdotL, float NdotV, float NdotH)
 {
- vec3 F = F_Schlick(f0, f90, VdotH);
  float Vis = V_GGX(NdotL, NdotV, alphaRoughness);
  float D = D_GGX(NdotH, alphaRoughness);
 
- return specularWeight * F * Vis * D;
+ return vec3(Vis * D);
 }
 
 
-#ifdef MATERIAL_IRIDESCENCE
-vec3 BRDF_specularGGXIridescence(vec3 f0, vec3 f90, vec3 iridescenceFresnel, float alphaRoughness, float iridescenceFactor, float specularWeight, float VdotH, float NdotL, float NdotV, float NdotH)
-{
- vec3 F = mix(F_Schlick(f0, f90, VdotH), iridescenceFresnel, iridescenceFactor);
- float Vis = V_GGX(NdotL, NdotV, alphaRoughness);
- float D = D_GGX(NdotH, alphaRoughness);
-
- return specularWeight * F * Vis * D;
-}
-#endif
-
 #ifdef MATERIAL_ANISOTROPY
 // GGX Distribution Anisotropic (Same as Babylon.js)
 // https://blog.selfshadow.com/publications/s2012-shading-course/burley/s2012_pbs_disney_brdf_notes_v3.pdf Addenda
@@ -218,7 +186,7 @@ float V_GGX_anisotropic(float NdotL, float NdotV, float BdotV, float TdotV, floa
  return clamp(v, 0.0, 1.0);
 }
 
-vec3 BRDF_specularGGXAnisotropy(vec3 f0, vec3 f90, float alphaRoughness, float anisotropy, vec3 n, vec3 v, vec3 l, vec3 h, vec3 t, vec3 b)
+vec3 BRDF_specularGGXAnisotropy(float alphaRoughness, float anisotropy, vec3 n, vec3 v, vec3 l, vec3 h, vec3 t, vec3 b)
 {
  // Roughness along the anisotropy bitangent is the material roughness, while the tangent roughness increases with anisotropy.
  float at = mix(alphaRoughness, 1.0, anisotropy * anisotropy);
@@ -227,13 +195,11 @@ vec3 BRDF_specularGGXAnisotropy(vec3 f0, vec3 f90, float alphaRoughness, float a
  float NdotL = clamp(dot(n, l), 0.0, 1.0);
  float NdotH = clamp(dot(n, h), 0.001, 1.0);
  float NdotV = dot(n, v);
- float VdotH = clamp(dot(v, h), 0.0, 1.0);
 
  float V = V_GGX_anisotropic(NdotL, NdotV, dot(b, v), dot(t, v), dot(t, l), dot(b, l), at, ab);
  float D = D_GGX_anisotropic(NdotH, dot(t, h), dot(b, h), anisotropy, at, ab);
 
- vec3 F = F_Schlick(f0, f90, VdotH);
- return F * V * D;
+ return vec3(V * D);
 }
 #endif
 

source/Renderer/shaders/functions.glsl

@@ -84,3 +84,10 @@ float applyIorToRoughness(float roughness, float ior)
  // an IOR of 1.5 results in the default amount of microfacet refraction.
  return roughness * clamp(ior * 2.0 - 2.0, 0.0, 1.0);
 }
+
+vec3 rgb_mix(vec3 base, vec3 layer, vec3 rgb_alpha)
+{
+ float rgb_alpha_max = max(rgb_alpha.r, max(rgb_alpha.g, rgb_alpha.b));
+ return (1.0 - rgb_alpha_max) * base + rgb_alpha * layer;
+}
+

source/Renderer/shaders/ibl.glsl

@@ -17,51 +17,36 @@ vec4 getSheenSample(vec3 reflection, float lod)
  return textureLod(u_CharlieEnvSampler, u_EnvRotation * reflection, lod) * u_EnvIntensity;
 }
 
-
-vec3 getIBLRadianceGGX(vec3 n, vec3 v, float roughness, vec3 F0, float specularWeight)
+vec3 getIBLGGXFresnel(vec3 n, vec3 v, float roughness, vec3 F0, float specularWeight)
 {
+ // see https://bruop.github.io/ibl/#single_scattering_results at Single Scattering Results
+ // Roughness dependent fresnel, from Fdez-Aguera
  float NdotV = clampedDot(n, v);
- float lod = roughness * float(u_MipCount - 1);
- vec3 reflection = normalize(reflect(-v, n));
-
  vec2 brdfSamplePoint = clamp(vec2(NdotV, roughness), vec2(0.0, 0.0), vec2(1.0, 1.0));
  vec2 f_ab = texture(u_GGXLUT, brdfSamplePoint).rg;
- vec4 specularSample = getSpecularSample(reflection, lod);
-
- vec3 specularLight = specularSample.rgb;
-
- // see https://bruop.github.io/ibl/#single_scattering_results at Single Scattering Results
- // Roughness dependent fresnel, from Fdez-Aguera
  vec3 Fr = max(vec3(1.0 - roughness), F0) - F0;
  vec3 k_S = F0 + Fr * pow(1.0 - NdotV, 5.0);
- vec3 FssEss = k_S * f_ab.x + f_ab.y;
+ vec3 FssEss = specularWeight * (k_S * f_ab.x + f_ab.y);
 
- return specularWeight * specularLight * FssEss;
-}
+ // Multiple scattering, from Fdez-Aguera
+ float Ems = (1.0 - (f_ab.x + f_ab.y));
+ vec3 F_avg = specularWeight * (F0 + (1.0 - F0) / 21.0);
+ vec3 FmsEms = Ems * FssEss * F_avg / (1.0 - F_avg * Ems);
 
+ return FssEss + FmsEms;
+}
 
-#ifdef MATERIAL_IRIDESCENCE
-vec3 getIBLRadianceGGXIridescence(vec3 n, vec3 v, float roughness, vec3 F0, vec3 iridescenceFresnel, float iridescenceFactor, float specularWeight)
+vec3 getIBLRadianceGGX(vec3 n, vec3 v, float roughness)
 {
  float NdotV = clampedDot(n, v);
  float lod = roughness * float(u_MipCount - 1);
  vec3 reflection = normalize(reflect(-v, n));
-
- vec2 brdfSamplePoint = clamp(vec2(NdotV, roughness), vec2(0.0, 0.0), vec2(1.0, 1.0));
- vec2 f_ab = texture(u_GGXLUT, brdfSamplePoint).rg;
  vec4 specularSample = getSpecularSample(reflection, lod);
 
  vec3 specularLight = specularSample.rgb;
 
- // see https://bruop.github.io/ibl/#single_scattering_results at Single Scattering Results
- // Roughness dependent fresnel, from Fdez-Aguera
- vec3 Fr = max(vec3(1.0 - roughness), F0) - F0;
- vec3 k_S = mix(F0 + Fr * pow(1.0 - NdotV, 5.0), iridescenceFresnel, iridescenceFactor);
- vec3 FssEss = k_S * f_ab.x + f_ab.y;
-
- return specularWeight * specularLight * FssEss;
+ return specularLight;
 }
-#endif
 
 
 #ifdef MATERIAL_TRANSMISSION
@@ -130,68 +115,8 @@ vec3 getIBLVolumeRefraction(vec3 n, vec3 v, float perceptualRoughness, vec3 base
 #endif
 
 
-// specularWeight is introduced with KHR_materials_specular
-vec3 getIBLRadianceLambertian(vec3 n, vec3 v, float roughness, vec3 diffuseColor, vec3 F0, float specularWeight)
-{
- float NdotV = clampedDot(n, v);
- vec2 brdfSamplePoint = clamp(vec2(NdotV, roughness), vec2(0.0, 0.0), vec2(1.0, 1.0));
- vec2 f_ab = texture(u_GGXLUT, brdfSamplePoint).rg;
-
- vec3 irradiance = getDiffuseLight(n);
-
- // see https://bruop.github.io/ibl/#single_scattering_results at Single Scattering Results
- // Roughness dependent fresnel, from Fdez-Aguera
-
- vec3 Fr = max(vec3(1.0 - roughness), F0) - F0;
- vec3 k_S = F0 + Fr * pow(1.0 - NdotV, 5.0);
- vec3 FssEss = specularWeight * k_S * f_ab.x + f_ab.y; // <--- GGX / specular light contribution (scale it down if the specularWeight is low)
-
- // Multiple scattering, from Fdez-Aguera
- float Ems = (1.0 - (f_ab.x + f_ab.y));
- vec3 F_avg = specularWeight * (F0 + (1.0 - F0) / 21.0);
- vec3 FmsEms = Ems * FssEss * F_avg / (1.0 - F_avg * Ems);
- vec3 k_D = diffuseColor * (1.0 - FssEss + FmsEms); // we use +FmsEms as indicated by the formula in the blog post (might be a typo in the implementation)
-
- return (FmsEms + k_D) * irradiance;
-}
-
-
-#ifdef MATERIAL_IRIDESCENCE
-// specularWeight is introduced with KHR_materials_specular
-vec3 getIBLRadianceLambertianIridescence(vec3 n, vec3 v, float roughness, vec3 diffuseColor, vec3 F0, vec3 iridescenceF0, float iridescenceFactor, float specularWeight)
-{
- float NdotV = clampedDot(n, v);
- vec2 brdfSamplePoint = clamp(vec2(NdotV, roughness), vec2(0.0, 0.0), vec2(1.0, 1.0));
- vec2 f_ab = texture(u_GGXLUT, brdfSamplePoint).rg;
-
- vec3 irradiance = getDiffuseLight(n);
-
- // Use the maximum component of the iridescence Fresnel color
- // Maximum is used instead of the RGB value to not get inverse colors for the diffuse BRDF
- vec3 iridescenceF0Max = vec3(max(max(iridescenceF0.r, iridescenceF0.g), iridescenceF0.b));
-
- // Blend between base F0 and iridescence F0
- vec3 mixedF0 = mix(F0, iridescenceF0Max, iridescenceFactor);
-
- // see https://bruop.github.io/ibl/#single_scattering_results at Single Scattering Results
- // Roughness dependent fresnel, from Fdez-Aguera
-
- vec3 Fr = max(vec3(1.0 - roughness), mixedF0) - mixedF0;
- vec3 k_S = mixedF0 + Fr * pow(1.0 - NdotV, 5.0);
- vec3 FssEss = specularWeight * k_S * f_ab.x + f_ab.y; // <--- GGX / specular light contribution (scale it down if the specularWeight is low)
-
- // Multiple scattering, from Fdez-Aguera
- float Ems = (1.0 - (f_ab.x + f_ab.y));
- vec3 F_avg = specularWeight * (mixedF0 + (1.0 - mixedF0) / 21.0);
- vec3 FmsEms = Ems * FssEss * F_avg / (1.0 - F_avg * Ems);
- vec3 k_D = diffuseColor * (1.0 - FssEss + FmsEms); // we use +FmsEms as indicated by the formula in the blog post (might be a typo in the implementation)
-
- return (FmsEms + k_D) * irradiance;
-}
-#endif
-
 #ifdef MATERIAL_ANISOTROPY
-vec3 getIBLRadianceAnisotropy(vec3 n, vec3 v, float roughness, float anisotropy, vec3 anisotropyDirection, vec3 F0, float specularWeight)
+vec3 getIBLRadianceAnisotropy(vec3 n, vec3 v, float roughness, float anisotropy, vec3 anisotropyDirection)
 {
  float NdotV = clampedDot(n, v);
 
@@ -205,19 +130,11 @@ vec3 getIBLRadianceAnisotropy(vec3 n, vec3 v, float roughness, float anisotropy,
  float lod = roughness * float(u_MipCount - 1);
  vec3 reflection = normalize(reflect(-v, bentNormal));
 
- vec2 brdfSamplePoint = clamp(vec2(NdotV, roughness), vec2(0.0, 0.0), vec2(1.0, 1.0));
- vec2 f_ab = texture(u_GGXLUT, brdfSamplePoint).rg;
  vec4 specularSample = getSpecularSample(reflection, lod);
 
  vec3 specularLight = specularSample.rgb;
 
- // see https://bruop.github.io/ibl/#single_scattering_results at Single Scattering Results
- // Roughness dependent fresnel, from Fdez-Aguera
- vec3 Fr = max(vec3(1.0 - roughness), F0) - F0;
- vec3 k_S = F0 + Fr * pow(1.0 - NdotV, 5.0);
- vec3 FssEss = k_S * f_ab.x + f_ab.y;
-
- return specularWeight * specularLight * FssEss;
+ return specularLight;
 }
 #endif