attempt to simplify the phong shaders and lights.

src/renderers/shaders/ShaderChunk/common.glsl

@@ -1,9 +1,10 @@
 #define PI 3.14159
 #define PI2 6.28318
+#define RECIPROCAL_PI 0.31830988618
 #define RECIPROCAL_PI2 0.15915494
 #define LOG2 1.442695
 #define EPSILON 1e-6
-
+#define PHYSICALLY_BASED_RENDERING
 #define saturate(a) clamp( a, 0.0, 1.0 )
 #define whiteCompliment(a) ( 1.0 - saturate( a ) )
 
@@ -52,77 +53,187 @@ float calcLightAttenuation( float lightDistance, float cutoffDistance, float dec
 
 }
 
-vec3 F_Schlick( in vec3 specularColor, in float dotLH ) {
+vec3 inputToLinear( in vec3 a ) {
+
+	#ifdef GAMMA_INPUT
+
+		return pow( a, vec3( float( GAMMA_FACTOR ) ) );
+
+	#else
+
+		return a;
+
+	#endif
+
+}
+
+vec3 linearToOutput( in vec3 a ) {
+
+	#ifdef GAMMA_OUTPUT
+
+		return pow( a, vec3( 1.0 / float( GAMMA_FACTOR ) ) );
+
+	#else
+
+		return a;
+
+	#endif
+
+}
+
+
+struct IncidentLight {
+  vec3 color;
+  vec3 direction;
+};
+
+
+vec3 BRDF_Lambert( const in IncidentLight incidentLight, const in vec3 normal, const in vec3 diffuseColor ) {
+
+	return incidentLight.color * diffuseColor * ( saturate( dot( normal, incidentLight.direction ) ) );
+
+	// the above should be scaled by '' * RECIPROCAL_PI'
+}
+
+vec3 F_Schlick( const in vec3 F0, const in float dotLH ) {
 
 	// Original approximation by Christophe Schlick '94
 	//;float fresnel = pow( 1.0 - dotLH, 5.0 );
 
 	// Optimized variant (presented by Epic at SIGGRAPH '13)
 	float fresnel = exp2( ( -5.55437 * dotLH - 6.98316 ) * dotLH );
 
-	return ( 1.0 - specularColor ) * fresnel + specularColor;
+	return F0 + ( 1.0 - F0 ) * fresnel;
 
 }
 
 float G_BlinnPhong_Implicit( /* in float dotNL, in float dotNV */ ) {
 
-	// geometry term is (n⋅l)(n⋅v) / 4(n⋅l)(n⋅v)
+	// geometry term is (n dot l)(n dot v) / 4(n dot l)(n dot v)
 
 	return 0.25;
 
 }
 
-float D_BlinnPhong( in float shininess, in float dotNH ) {
+float D_BlinnPhong( const in float shininess, const in float dotNH ) {
 
 	// factor of 1/PI in distribution term omitted
 
 	return ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );
 
 }
 
-vec3 BRDF_BlinnPhong( in vec3 specularColor, in float shininess, in vec3 normal, in vec3 lightDir, in vec3 viewDir ) {
+vec3 BRDF_BlinnPhong( const in IncidentLight incidentLight, const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float shininess ) {
 
-	vec3 halfDir = normalize( lightDir + viewDir );
-
-	//float dotNL = saturate( dot( normal, lightDir ) );
-	//float dotNV = saturate( dot( normal, viewDir ) );
+	vec3 halfDir = normalize( incidentLight.direction + viewDir );
 	float dotNH = saturate( dot( normal, halfDir ) );
-	float dotLH = saturate( dot( lightDir, halfDir ) );
+	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );
 
 	vec3 F = F_Schlick( specularColor, dotLH );
-
 	float G = G_BlinnPhong_Implicit( /* dotNL, dotNV */ );
-
 	float D = D_BlinnPhong( shininess, dotNH );
 
-	return F * G * D;
+	return incidentLight.color * F * ( G * D );
 
 }
 
-vec3 inputToLinear( in vec3 a ) {
+#if MAX_DIR_LIGHTS > 0
 
-	#ifdef GAMMA_INPUT
+	struct DirectionalLight {
+	  vec3 direction;
+	  vec3 color;
+	};
 
-		return pow( a, vec3( float( GAMMA_FACTOR ) ) );
+	uniform DirectionalLight singleTestDirLight;
 
-	#else
+	uniform DirectionalLight directionalLights[ MAX_DIR_LIGHTS ];
 
-		return a;
+	void getDirLightDirect( const in DirectionalLight directionalLight, out IncidentLight incidentLight ) { 
+
+		incidentLight.color = directionalLight.color;
+		incidentLight.direction = directionalLight.direction; 
 
-	#endif
+	}
 
-}
+#endif
+
+#if MAX_POINT_LIGHTS > 0
+
+	struct PointLight {
+	  vec3 position;
+	  vec3 color;
+	  float distance;
+	  float decay;
+	};
+
+	uniform PointLight pointLights[ MAX_POINT_LIGHTS ];
+
+	void getPointLightDirect( const in PointLight pointLight, const in vec3 position, out IncidentLight incidentLight ) { 
+
+		vec3 lightPosition = pointLight.position; 
+
+		vec3 lVector = lightPosition - position; 
+		incidentLight.direction = normalize( lVector ); 
+
+		incidentLight.color = pointLight.color; 
+		incidentLight.color *= calcLightAttenuation( length( lVector ), pointLight.distance, pointLight.decay ); 
+
+	}
 
-vec3 linearToOutput( in vec3 a ) {
+#endif
+
+#if MAX_SPOT_LIGHTS > 0
+
+	struct SpotLight {
+	  vec3 position;
+	  vec3 direction;
+	  vec3 color;
+	  float distance;
+	  float decay;
+	  float angleCos;
+	  float exponent;
+	};
+
+	uniform SpotLight spotLights[ MAX_SPOT_LIGHTS ];
+
+	void getSpotLightDirect( const in SpotLight spotLight, const in vec3 position, out IncidentLight incidentLight ) {
+
+		vec3 lightPosition = spotLight.position;
+
+		vec3 lVector = lightPosition - position;
+		incidentLight.direction = normalize( lVector );
+
+		float spotEffect = dot( spotLight.direction, incidentLight.direction );
+		spotEffect = saturate( pow( saturate( spotEffect ), spotLight.exponent ) );
+
+		incidentLight.color = spotLight.color;
+		incidentLight.color *= ( spotEffect * calcLightAttenuation( length( lVector ), spotLight.distance, spotLight.decay ) );
 
-	#ifdef GAMMA_OUTPUT
+	}
 
-		return pow( a, vec3( 1.0 / float( GAMMA_FACTOR ) ) );
+#endif
 
-	#else
 
-		return a;
+#if MAX_HEMI_LIGHTS > 0
 
-	#endif
+	struct HemisphereLight {
+	  vec3 direction;
+	  vec3 skyColor;
+	  vec3 groundColor;
+	};
 
-}
+	uniform HemisphereLight hemisphereLights[ MAX_HEMI_LIGHTS ];
+
+	void getHemisphereLightIndirect( const in HemisphereLight hemiLight, const in vec3 normal, out IncidentLight incidentLight ) { 
+
+		float dotNL = dot( normal, hemiLight.direction );
+
+		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;
+
+		incidentLight.color = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );
+
+		incidentLight.direction = normal;
+
+	}
+
+#endif

src/renderers/shaders/ShaderChunk/hemilight_fragment.glsl

@@ -1,18 +0,0 @@
-#if MAX_HEMI_LIGHTS > 0
-
-	for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {
-
-		vec3 lightDir = hemisphereLightDirection[ i ];
-
-		float dotProduct = dot( normal, lightDir );
-
-		float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;
-
-		vec3 lightColor = mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );
-
-		totalAmbientLight += lightColor;
-
-	}
-
-#endif
-

src/renderers/shaders/ShaderChunk/lights_lambert_pars_vertex.glsl

@@ -1,37 +1 @@
 uniform vec3 ambientLightColor;
-
-#if MAX_DIR_LIGHTS > 0
-
-	uniform vec3 directionalLightColor[ MAX_DIR_LIGHTS ];
-	uniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];
-
-#endif
-
-#if MAX_HEMI_LIGHTS > 0
-
-	uniform vec3 hemisphereLightSkyColor[ MAX_HEMI_LIGHTS ];
-	uniform vec3 hemisphereLightGroundColor[ MAX_HEMI_LIGHTS ];
-	uniform vec3 hemisphereLightDirection[ MAX_HEMI_LIGHTS ];
-
-#endif
-
-#if MAX_POINT_LIGHTS > 0
-
-	uniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];
-	uniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];
-	uniform float pointLightDistance[ MAX_POINT_LIGHTS ];
-	uniform float pointLightDecay[ MAX_POINT_LIGHTS ];
-
-#endif
-
-#if MAX_SPOT_LIGHTS > 0
-
-	uniform vec3 spotLightColor[ MAX_SPOT_LIGHTS ];
-	uniform vec3 spotLightPosition[ MAX_SPOT_LIGHTS ];
-	uniform vec3 spotLightDirection[ MAX_SPOT_LIGHTS ];
-	uniform float spotLightDistance[ MAX_SPOT_LIGHTS ];
-	uniform float spotLightAngleCos[ MAX_SPOT_LIGHTS ];
-	uniform float spotLightExponent[ MAX_SPOT_LIGHTS ];
-	uniform float spotLightDecay[ MAX_SPOT_LIGHTS ];
-
-#endif