Tutorial spacing fix.

src/6.pbr/1.1.lighting/pbr.frag

@@ -22,78 +22,78 @@ const float PI = 3.14159265359;
 // ----------------------------------------------------------------------------
 float DistributionGGX(vec3 N, vec3 H, float roughness)
 {
-	float a = roughness*roughness;
+    float a = roughness*roughness;
-	float a2 = a*a;
+    float a2 = a*a;
-	float NdotH = max(dot(N, H), 0.0);
+    float NdotH = max(dot(N, H), 0.0);
-	float NdotH2 = NdotH*NdotH;
+    float NdotH2 = NdotH*NdotH;
-	
+
-	float nom    = a2;
+    float nom   = a2;
-	float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
-	denom = PI * denom * denom;
+    denom = PI * denom * denom;
-	
+
-	return nom / denom;
+    return nom / denom;
 }
 // ----------------------------------------------------------------------------
 float GeometrySchlickGGX(float NdotV, float roughness)
 {
-	float r = (roughness + 1.0);
+    float r = (roughness + 1.0);
-	float k = (r*r) / 8.0;
+    float k = (r*r) / 8.0;
 
-	float nom    = NdotV;
+    float nom   = NdotV;
-	float denom = NdotV * (1.0 - k) + k;
+    float denom = NdotV * (1.0 - k) + k;
-	
+
-	return nom / denom;
+    return nom / denom;
 }
 // ----------------------------------------------------------------------------
 float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
 {
     float NdotV = max(dot(N, V), 0.0);
     float NdotL = max(dot(N, L), 0.0);
-	float ggx2 = GeometrySchlickGGX(NdotV, roughness);
+    float ggx2 = GeometrySchlickGGX(NdotV, roughness);
-	float ggx1 = GeometrySchlickGGX(NdotL, roughness);
+    float ggx1 = GeometrySchlickGGX(NdotL, roughness);
-	
+
-	return ggx1 * ggx2;
+    return ggx1 * ggx2;
 }
 // ----------------------------------------------------------------------------
 vec3 fresnelSchlick(float cosTheta, vec3 F0)
 {
-	return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
+    return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
 }
 // ----------------------------------------------------------------------------
 vec3 fresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness)
 {
-	return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
+    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
 }
 // ----------------------------------------------------------------------------
 void main()
 {		
     vec3 N = normalize(Normal);
-	vec3 V = normalize(camPos - WorldPos);
+    vec3 V = normalize(camPos - WorldPos);
-	vec3 R = reflect(-V, N); 
+    vec3 R = reflect(-V, N); 
 
     // calculate reflectance at normal incidence; if dia-electric (like plastic) use F0 
     // of 0.04 and if it's a metal, use their albedo color as F0 (metallic workflow)    
-	vec3 F0 = vec3(0.04); 
+    vec3 F0 = vec3(0.04); 
-	F0 = mix(F0, albedo, metallic);
+    F0 = mix(F0, albedo, metallic);
-	vec3 F   = fresnelSchlickRoughness(max(dot(N, V), 0.0), F0, roughness); // use modified Fresnel-Schlick approximation to take roughness into account
+    vec3 F   = fresnelSchlickRoughness(max(dot(N, V), 0.0), F0, roughness); // use modified Fresnel-Schlick approximation to take roughness into account
-	
+
     // kS is equal to Fresnel
-     vec3 kS = F;
+    vec3 kS = F;
-	// for energy conservation, the diffuse and specular light can't
+    // for energy conservation, the diffuse and specular light can't
     // be above 1.0 (unless the surface emits light); to preserve this
     // relationship the diffuse component (kD) should equal 1.0 - kS.
-	vec3 kD = vec3(1.0) - kS;
+    vec3 kD = vec3(1.0) - kS;
-	// multiply kD by the inverse metalness such that only non-metals 
+    // multiply kD by the inverse metalness such that only non-metals 
     // have diffuse lighting, or a linear blend if partly metal (pure metals
     // have no diffuse light).
-	kD *= 1.0 - metallic;	
+    kD *= 1.0 - metallic;	
-    
+
     // first do ambient lighting (note that the next IBL tutorial will replace 
     // this ambient lighting with environment lighting).
     vec3 ambient = vec3(0.01) * albedo * ao;
-    
+
     // reflectance equation
-   vec3 Lo = vec3(0.0);
+    vec3 Lo = vec3(0.0);
     for(int i = 0; i < 4; ++i) 
     {
         // calculate per-light radiance
@@ -102,15 +102,15 @@ void main()
         float distance = length(lightPositions[i] - WorldPos);
         float attenuation = 1.0 / distance * distance;
         vec3 radiance = lightColors[i] * attenuation;
-        
+
         // Cook-Torrance BRDF
         float NDF = DistributionGGX(N, H, roughness);   
         float G   = GeometrySmith(N, V, L, roughness);      
-               
+           
         vec3 nominator    = NDF * G * F;
         float denominator = 4 * max(dot(V, N), 0.0) * max(dot(L, N), 0.0) + 0.001; // 0.001 to prevent divide by zero.
         vec3 brdf = nominator / denominator;
-            
+
         // scale light by NdotL
         float NdotL = max(dot(N, L), 0.0);        
 
@@ -118,11 +118,11 @@ void main()
         Lo += (kD * albedo / PI + kS * brdf) * radiance * NdotL; 
     }   
     vec3 color = ambient + Lo;
-	
+
-	// HDR tonemapping
+    // HDR tonemapping
-	color = color / (color + vec3(1.0));
+    color = color / (color + vec3(1.0));
-	// gamma correct
+    // gamma correct
-	color = pow(color, vec3(1.0/2.2)); 
+    color = pow(color, vec3(1.0/2.2)); 
-    
+
-	FragColor = vec4(color, 1.0);
+    FragColor = vec4(color, 1.0);
 }

src/6.pbr/1.1.lighting/pbr.vs

@@ -13,9 +13,9 @@ uniform mat4 model;
 
 void main()
 {
-	TexCoords = texCoords;
+    TexCoords = texCoords;
-	WorldPos = vec3(model * vec4(pos, 1.0f));
+    WorldPos = vec3(model * vec4(pos, 1.0f));
-	Normal = mat3(model) * normal;
+    Normal = mat3(model) * normal;
-    
+
-	gl_Position =  projection * view * vec4(WorldPos, 1.0);
+    gl_Position =  projection * view * vec4(WorldPos, 1.0);
 }

src/6.pbr/1.2.lighting_textured/pbr.frag

@@ -28,7 +28,7 @@ const float PI = 3.14159265359;
 vec3 getNormal()
 {
     vec3 tangentNormal = texture(normalMap, TexCoords).xyz * 2.0 - 1.0;
-    
+
     vec3 Q1  = dFdx(WorldPos);
     vec3 Q2  = dFdy(WorldPos);
     vec2 st1 = dFdx(TexCoords);
@@ -44,83 +44,83 @@ vec3 getNormal()
 // ----------------------------------------------------------------------------
 float DistributionGGX(vec3 N, vec3 H, float roughness)
 {
-	float a = roughness*roughness;
+    float a = roughness*roughness;
-	float a2 = a*a;
+    float a2 = a*a;
-	float NdotH = max(dot(N, H), 0.0);
+    float NdotH = max(dot(N, H), 0.0);
-	float NdotH2 = NdotH*NdotH;
+    float NdotH2 = NdotH*NdotH;
-	
+
-	float nom    = a2;
+    float nom   = a2;
-	float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
-	denom = PI * denom * denom;
+    denom = PI * denom * denom;
-	
+
-	return nom / denom;
+    return nom / denom;
 }
 // ----------------------------------------------------------------------------
 float GeometrySchlickGGX(float NdotV, float roughness)
 {
-	float r = (roughness + 1.0);
+    float r = (roughness + 1.0);
-	float k = (r*r) / 8.0;
+    float k = (r*r) / 8.0;
 
-	float nom    = NdotV;
+    float nom   = NdotV;
-	float denom = NdotV * (1.0 - k) + k;
+    float denom = NdotV * (1.0 - k) + k;
-	
+
-	return nom / denom;
+    return nom / denom;
 }
 // ----------------------------------------------------------------------------
 float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
 {
     float NdotV = max(dot(N, V), 0.0);
     float NdotL = max(dot(N, L), 0.0);
-	float ggx2 = GeometrySchlickGGX(NdotV, roughness);
+    float ggx2 = GeometrySchlickGGX(NdotV, roughness);
-	float ggx1 = GeometrySchlickGGX(NdotL, roughness);
+    float ggx1 = GeometrySchlickGGX(NdotL, roughness);
-	
+
-	return ggx1 * ggx2;
+    return ggx1 * ggx2;
 }
 // ----------------------------------------------------------------------------
 vec3 fresnelSchlick(float cosTheta, vec3 F0)
 {
-	return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
+    return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
 }
 // ----------------------------------------------------------------------------
 vec3 fresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness)
 {
-	return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
+    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
 }
 // ----------------------------------------------------------------------------
 void main()
 {		
     vec3 albedo     = pow(texture(albedoMap, TexCoords).rgb, vec3(2.2));
-    float metallic    = texture(metallicMap, TexCoords).r;
+    float metallic  = texture(metallicMap, TexCoords).r;
     float roughness = texture(roughnessMap, TexCoords).r;
-    float ao           = texture(aoMap, TexCoords).r;
+    float ao        = texture(aoMap, TexCoords).r;
 
     vec3 N = getNormal();
-	vec3 V = normalize(camPos - WorldPos);
+    vec3 V = normalize(camPos - WorldPos);
-	vec3 R = reflect(-V, N); 
+    vec3 R = reflect(-V, N); 
 
     // calculate reflectance at normal incidence; if dia-electric (like plastic) use F0 
     // of 0.04 and if it's a metal, use their albedo color as F0 (metallic workflow)    
     vec3 F0 = vec3(0.04); 
     F0 = mix(F0, albedo, metallic);
     vec3 F   = fresnelSchlickRoughness(max(dot(N, V), 0.0), F0, roughness); // use modified Fresnel-Schlick approximation to take roughness into account
-	
+
     // kS is equal to Fresnel
-     vec3 kS = F;
+    vec3 kS = F;
-	// for energy conservation, the diffuse and specular light can't
+    // for energy conservation, the diffuse and specular light can't
     // be above 1.0 (unless the surface emits light); to preserve this
     // relationship the diffuse component (kD) should equal 1.0 - kS.
-	vec3 kD = vec3(1.0) - kS;
+    vec3 kD = vec3(1.0) - kS;
-	// multiply kD by the inverse metalness such that only non-metals 
+    // multiply kD by the inverse metalness such that only non-metals 
     // have diffuse lighting, or a linear blend if partly metal (pure metals
     // have no diffuse light).
-	kD *= 1.0 - metallic;	
+    kD *= 1.0 - metallic;	
-    
+
     // first do ambient lighting (note that the next IBL tutorial will replace 
     // this ambient lighting with environment lighting).
     vec3 ambient = vec3(0.01) * albedo * ao;
-    
+
     // reflectance equation
-   vec3 Lo = vec3(0.0);
+    vec3 Lo = vec3(0.0);
     for(int i = 0; i < 4; ++i) 
     {
         // calculate per-light radiance
@@ -129,7 +129,7 @@ void main()
         float distance = length(lightPositions[i] - WorldPos);
         float attenuation = 1.0 / distance * distance;
         vec3 radiance = lightColors[i] * attenuation;
-        
+
         // Cook-Torrance BRDF
         float NDF = DistributionGGX(N, H, roughness);   
         float G   = GeometrySmith(N, V, L, roughness);      
@@ -145,11 +145,11 @@ void main()
         Lo += (kD * albedo / PI + kS * brdf) * radiance * NdotL; 
     }   
     vec3 color = ambient + Lo;
-	
+
-	// HDR tonemapping
+    // HDR tonemapping
-	color = color / (color + vec3(1.0));
+    color = color / (color + vec3(1.0));
-	// gamma correct
+    // gamma correct
-	color = pow(color, vec3(1.0/2.2)); 
+    color = pow(color, vec3(1.0/2.2)); 
-    
+
-	FragColor = vec4(color, 1.0);
+    FragColor = vec4(color, 1.0);
 }

src/6.pbr/1.2.lighting_textured/pbr.vs

@@ -13,9 +13,9 @@ uniform mat4 model;
 
 void main()
 {
-	TexCoords = texCoords;
+    TexCoords = texCoords;
-	WorldPos = vec3(model * vec4(pos, 1.0f));
+    WorldPos = vec3(model * vec4(pos, 1.0f));
-	Normal = mat3(model) * normal;   
+    Normal = mat3(model) * normal;   
 
-	gl_Position =  projection * view * vec4(WorldPos, 1.0);
+    gl_Position =  projection * view * vec4(WorldPos, 1.0);
 }