Merge pull request #6368 from WestLangley/dev-lambert

Clean up Lambert shader

src/renderers/shaders/ShaderChunk/lights_lambert_vertex.glsl

@@ -6,60 +6,31 @@ vLightFront = vec3( 0.0 );
 
 #endif
 
-transformedNormal = normalize( transformedNormal );
-
-#if MAX_DIR_LIGHTS > 0
-
-for( int i = 0; i < MAX_DIR_LIGHTS; i ++ ) {
-
-	vec3 dirVector = transformDirection( directionalLightDirection[ i ], viewMatrix );
-
-	float dotProduct = dot( transformedNormal, dirVector );
-	vec3 directionalLightWeighting = vec3( max( dotProduct, 0.0 ) );
-
-	#ifdef DOUBLE_SIDED
-
-		vec3 directionalLightWeightingBack = vec3( max( -dotProduct, 0.0 ) );
-
-	#endif
-
-	vLightFront += directionalLightColor[ i ] * directionalLightWeighting;
-
-	#ifdef DOUBLE_SIDED
-
-		vLightBack += directionalLightColor[ i ] * directionalLightWeightingBack;
-
-	#endif
-
-}
-
-#endif
+vec3 normal = normalize( transformedNormal );
 
 #if MAX_POINT_LIGHTS > 0
 
-	for( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {
+	for ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {
+
+		vec3 lightColor = pointLightColor[ i ];
 
 		vec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );
 		vec3 lVector = lPosition.xyz - mvPosition.xyz;
+		vec3 lightDir = normalize( lVector );
 
-		float attenuation = calcLightAttenuation( length( lVector ), pointLightDistance[ i ], pointLightDecay[ i ] );
-
-		lVector = normalize( lVector );
-		float dotProduct = dot( transformedNormal, lVector );
+		// attenuation
 
-		vec3 pointLightWeighting = vec3( max( dotProduct, 0.0 ) );
+		float attenuation = calcLightAttenuation( length( lVector ), pointLightDistance[ i ], pointLightDecay[ i ] );
 
-		#ifdef DOUBLE_SIDED
+		// diffuse
 
-			vec3 pointLightWeightingBack = vec3( max( -dotProduct, 0.0 ) );
+		float dotProduct = dot( normal, lightDir );
 
-		#endif
-
-		vLightFront += pointLightColor[ i ] * pointLightWeighting * attenuation;
+		vLightFront += lightColor * attenuation * saturate( dotProduct );
 
 		#ifdef DOUBLE_SIDED
 
-			vLightBack += pointLightColor[ i ] * pointLightWeightingBack * attenuation;
+			vLightBack += lightColor * attenuation * saturate( - dotProduct );
 
 		#endif
 
@@ -69,39 +40,64 @@ for( int i = 0; i < MAX_DIR_LIGHTS; i ++ ) {
 
 #if MAX_SPOT_LIGHTS > 0
 
-	for( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {
+	for ( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {
+
+		vec3 lightColor = spotLightColor[ i ];
 
-		vec4 lPosition = viewMatrix * vec4( spotLightPosition[ i ], 1.0 );
+		vec3 lightPosition = spotLightPosition[ i ];
+		vec4 lPosition = viewMatrix * vec4( lightPosition, 1.0 );
 		vec3 lVector = lPosition.xyz - mvPosition.xyz;
+		vec3 lightDir = normalize( lVector );
 
-		float spotEffect = dot( spotLightDirection[ i ], normalize( spotLightPosition[ i ] - worldPosition.xyz ) );
+		float spotEffect = dot( spotLightDirection[ i ], normalize( lightPosition - worldPosition.xyz ) );
 
 		if ( spotEffect > spotLightAngleCos[ i ] ) {
 
-			spotEffect = max( pow( max( spotEffect, 0.0 ), spotLightExponent[ i ] ), 0.0 );
+			spotEffect = saturate( pow( saturate( spotEffect ), spotLightExponent[ i ] ) );
+
+			// attenuation
 
 			float attenuation = calcLightAttenuation( length( lVector ), spotLightDistance[ i ], spotLightDecay[ i ] );
 
-			lVector = normalize( lVector );
+			attenuation *= spotEffect;
+
+			// diffuse
+
+			float dotProduct = dot( normal, lightDir );
 
-			float dotProduct = dot( transformedNormal, lVector );
-			vec3 spotLightWeighting = vec3( max( dotProduct, 0.0 ) );
+			vLightFront += lightColor * attenuation * saturate( dotProduct );
 
 			#ifdef DOUBLE_SIDED
 
-				vec3 spotLightWeightingBack = vec3( max( -dotProduct, 0.0 ) );
+				vLightBack += lightColor * attenuation * saturate( - dotProduct );
 
 			#endif
 
-			vLightFront += spotLightColor[ i ] * spotLightWeighting * attenuation * spotEffect;
+		}
 
-			#ifdef DOUBLE_SIDED
+	}
 
-				vLightBack += spotLightColor[ i ] * spotLightWeightingBack * attenuation * spotEffect;
+#endif
 
-			#endif
+#if MAX_DIR_LIGHTS > 0
 
-		}
+	for ( int i = 0; i < MAX_DIR_LIGHTS; i ++ ) {
+
+		vec3 lightColor = directionalLightColor[ i ];
+
+		vec3 lightDir = transformDirection( directionalLightDirection[ i ], viewMatrix );
+
+		// diffuse
+
+		float dotProduct = dot( normal, lightDir );
+
+		vLightFront += lightColor * saturate( dotProduct );
+
+		#ifdef DOUBLE_SIDED
+
+			vLightBack += lightColor * saturate( - dotProduct );
+
+		#endif
 
 	}
 
@@ -109,19 +105,22 @@ for( int i = 0; i < MAX_DIR_LIGHTS; i ++ ) {
 
 #if MAX_HEMI_LIGHTS > 0
 
-	for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {
+	for ( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {
 
-		vec3 lVector = transformDirection( hemisphereLightDirection[ i ], viewMatrix );
+		vec3 lightDir = transformDirection( hemisphereLightDirection[ i ], viewMatrix );
 
-		float dotProduct = dot( transformedNormal, lVector );
+		// diffuse
+
+		float dotProduct = dot( normal, lightDir );
 
 		float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;
-		float hemiDiffuseWeightBack = -0.5 * dotProduct + 0.5;
 
 		vLightFront += mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );
 
 		#ifdef DOUBLE_SIDED
 
+			float hemiDiffuseWeightBack = - 0.5 * dotProduct + 0.5;
+
 			vLightBack += mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeightBack );
 
 		#endif