simplification of BSDFs.

src/renderers/shaders/ShaderChunk/bsdfs.glsl

@@ -11,7 +11,7 @@ float calcLightAttenuation( float lightDistance, float cutoffDistance, float dec
 }
 
 
-vec3 BRDF_Diffuse_Lambert( const in IncidentLight incidentLight, const in GeometricContext geometryContext, const in vec3 diffuseColor ) {
+vec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {
 
 	// factor of 1/PI in BRDF omitted as incoming light intensity is scaled up by PI because it is considered a punctual light source
 
@@ -93,7 +93,7 @@ vec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in Geometric
 
 
 // ref: https://www.unrealengine.com/blog/physically-based-shading-on-mobile - environmentBRDF for GGX on mobile
-vec3 BRDF_Specular_GGX_Environment( const in IncidentLight incidentLight, const in GeometricContext geometry, vec3 specularColor, float roughness ) {
+vec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, vec3 specularColor, float roughness ) {
 
 	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
 

src/renderers/shaders/ShaderChunk/lights_lambert_vertex.glsl

@@ -10,12 +10,12 @@ GeometricContext backGeometry = GeometricContext( geometry.position, -geometry.n
 		IncidentLight directLight = getPointDirectLight( pointLights[ i ], geometry );
 
 		float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
-		vLightFront += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, diffuse );
+		vLightFront += dotNL * directLight.color * BRDF_Diffuse_Lambert( diffuse );
 
 		#ifdef DOUBLE_SIDED
 
 			float backDotNL = saturate( dot( -geometry.normal, directLight.direction ) );
-			vLightBack += backDotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, backGeometry, diffuse );
+			vLightBack += backDotNL * directLight.color * BRDF_Diffuse_Lambert( diffuse );
 
 		#endif
 
@@ -30,12 +30,12 @@ GeometricContext backGeometry = GeometricContext( geometry.position, -geometry.n
 		IncidentLight directLight = getSpotDirectLight( spotLights[ i ], geometry );
 
 		float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
-		vLightFront += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, diffuse );
+		vLightFront += dotNL * directLight.color * BRDF_Diffuse_Lambert( diffuse );
 
 		#ifdef DOUBLE_SIDED
 
 			float backDotNL = saturate( dot( -geometry.normal, directLight.direction ) );
-			vLightBack += backDotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, backGeometry, diffuse );
+			vLightBack += backDotNL * directLight.color * BRDF_Diffuse_Lambert( diffuse );
 
 		#endif
 	}
@@ -49,12 +49,12 @@ GeometricContext backGeometry = GeometricContext( geometry.position, -geometry.n
 		IncidentLight directLight = getDirectionalDirectLight( directionalLights[ i ], geometry );
 
 		float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
-		vLightFront += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, diffuse );
+		vLightFront += dotNL * directLight.color * BRDF_Diffuse_Lambert( diffuse );
 
 		#ifdef DOUBLE_SIDED
 
 			float backDotNL = saturate( dot( -geometry.normal, directLight.direction ) );
-			vLightBack += backDotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, backGeometry, diffuse );
+			vLightBack += backDotNL * directLight.color * BRDF_Diffuse_Lambert( diffuse );
 
 		#endif
 
@@ -63,16 +63,15 @@ GeometricContext backGeometry = GeometricContext( geometry.position, -geometry.n
 #endif
 
 	{
-	
-		IncidentLight frontIndirectLight;
-		frontIndirectLight.direction = geometry.normal;
-		frontIndirectLight.color = ambientLightColor;
+		// dotNL is always one, and diffuseColor is vec3(1.0), thus the result is equivalent to summing indirectDiffuse lights
+		//float frontDotNL = saturate( dot( geometry.normal, frontIndirectLight.direction ) );
+		//vLightFront += frontDotNL * frontIndirectLight.color * BRDF_Diffuse_Lambert( diffuse );
+		
+		vLightFront += ambientLightColor;
 
 		#ifdef DOUBLE_SIDED
 		
-			IncidentLight backIndirectLight;
-			backIndirectLight.direction = -geometry.normal;
-			backIndirectLight.color = ambientLightColor;
+			vec3 vLightBack = ambientLightColor;
 
 		#endif
 
@@ -80,12 +79,12 @@ GeometricContext backGeometry = GeometricContext( geometry.position, -geometry.n
 
 			for ( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {
 
-				frontIndirectLight.color += getHemisphereIndirectLight( hemisphereLights[ i ], geometry ).color;
+				vLightFront += getHemisphereIndirectLight( hemisphereLights[ i ], geometry );
 
 
 				#ifdef DOUBLE_SIDED
 			
-					backIndirectLight.color += getHemisphereIndirectLight( hemisphereLights[ i ], backGeometry ).color;
+					vLightBack += getHemisphereIndirectLight( hemisphereLights[ i ], backGeometry );
 
 				#endif
 
@@ -93,18 +92,4 @@ GeometricContext backGeometry = GeometricContext( geometry.position, -geometry.n
 
 		#endif
 
-		//float frontDotNL = saturate( dot( geometry.normal, frontIndirectLight.direction ) );
-		//vLightFront += frontDotNL * frontIndirectLight.color * BRDF_Diffuse_Lambert( frontIndirectLight, geometry, diffuse );
-		// the following is equivalent to the above
-		vLightFront += frontIndirectLight.color;
-
-		#ifdef DOUBLE_SIDED
-
-			//float backDotNL = saturate( dot( -geometry.normal, backIndirectLight.direction ) );
-			//vLightBack += backDotNL * backIndirectLight.color * BRDF_Diffuse_Lambert( backIndirectLight, backGeometry, diffuse );
-			// the following is equivalent to the above
-			vLightBack += backIndirectLight.color;
-
-		#endif
-
 	}

src/renderers/shaders/ShaderChunk/lights_pars.glsl

@@ -86,15 +86,6 @@ uniform vec3 ambientLightColor;
 
 #endif
 
-	IncidentLight getAmbientIndirectLight( const in vec3 ambientLightColor, const in GeometricContext geometry ) { 
-	
-		IncidentLight indirectLight;
-
-		indirectLight.color = ambientLightColor;
-		indirectLight.direction = geometry.normal;
-
-		return indirectLight;
-	}
 
 #if MAX_HEMI_LIGHTS > 0
 
@@ -106,17 +97,13 @@ uniform vec3 ambientLightColor;
 
 	uniform HemisphereLight hemisphereLights[ MAX_HEMI_LIGHTS ];
 
-	IncidentLight getHemisphereIndirectLight( const in HemisphereLight hemiLight, const in GeometricContext geometry ) { 
+	vec3 getHemisphereIndirectLightColor( const in HemisphereLight hemiLight, const in GeometricContext geometry ) { 
 	
-		IncidentLight indirectLight;
-
 		float dotNL = dot( geometry.normal, hemiLight.direction );
 		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
 
-		indirectLight.color = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
-		indirectLight.direction = geometry.normal;
+		return mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
 
-		return indirectLight;
 	}
 
 #endif
@@ -124,7 +111,7 @@ uniform vec3 ambientLightColor;
 
 #if defined( USE_ENVMAP ) && defined( PHYSICAL )
 
-	IncidentLight getSpecularLightProbeIndirectLight( /*const in SpecularLightProbe specularLightProbe,*/ const in GeometricContext geometry, const in float lodLevel ) { 
+	vec3 getSpecularLightProbeIndirectLightColor( /*const in SpecularLightProbe specularLightProbe,*/ const in GeometricContext geometry, const in float lodLevel ) { 
 	
 		#ifdef ENVMAP_MODE_REFLECTION
 
@@ -176,11 +163,7 @@ uniform vec3 ambientLightColor;
 
 		envMapColor.rgb = inputToLinear( envMapColor.rgb );
 
-		IncidentLight indirectLight;
-		indirectLight.color = envMapColor.rgb * reflectivity;
-		indirectLight.direction = geometry.normal;
-
-		return indirectLight;
+		return envMapColor.rgb * reflectivity;
 
 	}
 

src/renderers/shaders/ShaderChunk/lights_phong_pars_fragment.glsl

@@ -23,8 +23,7 @@ void BlinnPhongMaterial_RE_DirectLight( const in IncidentLight directLight, cons
 
 	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
 
-	directReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, material.diffuseColor );
-	//directReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_OrenNayar( directLight, geometry, material.diffuseColor, 0.5 );
+	directReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( material.diffuseColor );
 
 	directReflectedLight.specular += dotNL * directLight.color * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess );
 	
@@ -32,14 +31,14 @@ void BlinnPhongMaterial_RE_DirectLight( const in IncidentLight directLight, cons
 
 #define Material_RE_DirectLight    BlinnPhongMaterial_RE_DirectLight
 
-void BlinnPhongMaterial_RE_IndirectLight( const in IncidentLight indirectLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight indirectReflectedLight ) {
+void BlinnPhongMaterial_RE_IndirectDiffuseLight( const in vec3 indirectDiffuseColor, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight indirectReflectedLight ) {
 
-	float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );
+	//float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );  not required because result is always 1.0
 
-	indirectReflectedLight.diffuse += dotNL * indirectLight.color * BRDF_Diffuse_Lambert( indirectLight, geometry, material.diffuseColor );
+	indirectReflectedLight.diffuse += indirectDiffuseColor * BRDF_Diffuse_Lambert( material.diffuseColor );
 
 }
 
-#define Material_RE_IndirectDiffuseLight    BlinnPhongMaterial_RE_IndirectLight
+#define Material_RE_IndirectDiffuseLight    BlinnPhongMaterial_RE_IndirectDiffuseLight
 
 #define Material_LightProbeLOD( material )   (0)

src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl

@@ -10,29 +10,29 @@ void PhysicalMaterial_RE_DirectLight( const in IncidentLight directLight, const
 
 	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
 
-	directReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, material.diffuseColor );
+	directReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( material.diffuseColor );
 	directReflectedLight.specular += dotNL * directLight.color * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );
 	
 }
 #define Material_RE_DirectLight    PhysicalMaterial_RE_DirectLight
 
 
-void PhysicalMaterial_RE_DiffuseIndirectLight( const in IncidentLight indirectLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight indirectReflectedLight ) {
+void PhysicalMaterial_RE_DiffuseIndirectLight( const in vec3 indirectDiffuseColor, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight indirectReflectedLight ) {
 
-	float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );
+	//float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );  not required because result is always 1.0
 
-	indirectReflectedLight.diffuse += dotNL * indirectLight.color * BRDF_Diffuse_Lambert( indirectLight, geometry, material.diffuseColor );
+	indirectReflectedLight.diffuse += indirectDiffuseColor * BRDF_Diffuse_Lambert( material.diffuseColor );
 
 }
 
 #define Material_RE_IndirectDiffuseLight    PhysicalMaterial_RE_DiffuseIndirectLight
 
 
-void PhysicalMaterial_RE_SpecularIndirectLight( const in IncidentLight indirectLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight indirectReflectedLight ) {
+void PhysicalMaterial_RE_SpecularIndirectLight( const in vec3 indirectSpecularColor, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight indirectReflectedLight ) {
 
-	float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );
+	//float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );  not required because result is always 1.0
 
-    indirectReflectedLight.specular += dotNL * indirectLight.color * BRDF_Specular_GGX_Environment( indirectLight, geometry, material.specularColor, material.specularRoughness );
+    indirectReflectedLight.specular += indirectSpecularColor * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );
 
 }
 

src/renderers/shaders/ShaderChunk/lights_template.glsl

@@ -55,13 +55,11 @@ GeometricContext geometry = GeometricContext( -vViewPosition, normalize( normal
 
 	{
 	
-		IncidentLight indirectLight;
-		indirectLight.direction = geometry.normal;
-		indirectLight.color = ambientLightColor;
+		vec3 indirectDiffuseColor = ambientLightColor;
 
 #ifdef USE_LIGHTMAP
 
-		indirectLight.color += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;
+		indirectDiffuseColor += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;
 
 #endif
 
@@ -69,13 +67,13 @@ GeometricContext geometry = GeometricContext( -vViewPosition, normalize( normal
 
 		for ( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {
 
-			indirectLight.color += getHemisphereIndirectLight( hemisphereLights[ i ], geometry ).color;
+			indirectDiffuseColor += getHemisphereIndirectLightColor( hemisphereLights[ i ], geometry );
 
 		}
 
 #endif
 
-		Material_RE_IndirectDiffuseLight( indirectLight, geometry, material, indirectReflectedLight );
+		Material_RE_IndirectDiffuseLight( indirectDiffuseColor, geometry, material, indirectReflectedLight );
 
 	}
 
@@ -85,9 +83,9 @@ GeometricContext geometry = GeometricContext( -vViewPosition, normalize( normal
 
 	{
 
-		IncidentLight indirectLight = getSpecularLightProbeIndirectLight( /*specularLightProbe,*/ geometry, Material_LightProbeLOD( material ) );
+		vec3 indirectSpecularColor = getSpecularLightProbeIndirectLightColor( /*specularLightProbe,*/ geometry, Material_LightProbeLOD( material ) );
 
-    	Material_RE_IndirectSpecularLight( indirectLight, geometry, material, indirectReflectedLight );
+    	Material_RE_IndirectSpecularLight( indirectSpecularColor, geometry, material, indirectReflectedLight );
 
     }