Cleanup of PBR Area light code

packages/dev/core/src/Shaders/ShadersInclude/lightFragment.fx

@@ -7,85 +7,87 @@
         #define CUSTOM_LIGHT{X}_COLOR // Use to modify light color. Currently only supports diffuse.
 
         #ifdef PBR
+            // Compute Pre Lighting infos
+            #ifdef SPOTLIGHT{X}
+                preInfo = computePointAndSpotPreLightingInfo(light{X}.vLightData, viewDirectionW, normalW, vPositionW);
+            #elif defined(POINTLIGHT{X})
+                preInfo = computePointAndSpotPreLightingInfo(light{X}.vLightData, viewDirectionW, normalW, vPositionW);
+            #elif defined(HEMILIGHT{X})
+                preInfo = computeHemisphericPreLightingInfo(light{X}.vLightData, viewDirectionW, normalW);
+            #elif defined(DIRLIGHT{X})
+                preInfo = computeDirectionalPreLightingInfo(light{X}.vLightData, viewDirectionW, normalW);
+            #elif defined(AREALIGHT{X})
+                preInfo = computeAreaPreLightingInfo(areaLightsLTC1{X}, areaLightsLTC2{X}, viewDirectionW, normalW, vPositionW, light{X}.vLightData, light{X}.vLightWidth.rgb, light{X}.vLightHeight.rgb, light{X}.vLightSpecular.rgb, roughness);
+            #endif
 
-            #if defined(AREALIGHT{X})
-                info.diffuse = computeAreaLightingDiffuse(areaLightsLTC1{X}, areaLightsLTC2{X}, viewDirectionW, normalW, vPositionW, light{X}.vLightData, light{X}.vLightWidth.rgb, light{X}.vLightHeight.rgb, diffuse{X}.rgb, light{X}.vLightSpecular.rgb, roughness);
-                #ifdef SPECULARTERM
-                    info.specular = computeAreaLightingSpecular(areaLightsLTC1{X}, areaLightsLTC2{X}, viewDirectionW, normalW, vPositionW, light{X}.vLightData, light{X}.vLightWidth.rgb, light{X}.vLightHeight.rgb, diffuse{X}.rgb, light{X}.vLightSpecular.rgb, roughness);
-                #endif
-            #else
-                // Compute Pre Lighting infos
-                #ifdef SPOTLIGHT{X}
-                    preInfo = computePointAndSpotPreLightingInfo(light{X}.vLightData, viewDirectionW, normalW, vPositionW);
-                #elif defined(POINTLIGHT{X})
-                    preInfo = computePointAndSpotPreLightingInfo(light{X}.vLightData, viewDirectionW, normalW, vPositionW);
-                #elif defined(HEMILIGHT{X})
-                    preInfo = computeHemisphericPreLightingInfo(light{X}.vLightData, viewDirectionW, normalW);
-                #elif defined(DIRLIGHT{X})
-                    preInfo = computeDirectionalPreLightingInfo(light{X}.vLightData, viewDirectionW, normalW);
-                #endif
-
-                preInfo.NdotV = NdotV;
+            preInfo.NdotV = NdotV;
 
-                // Compute Attenuation infos
-                #ifdef SPOTLIGHT{X}
-                    #ifdef LIGHT_FALLOFF_GLTF{X}
-                        preInfo.attenuation = computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared, light{X}.vLightFalloff.y);
-                        preInfo.attenuation *= computeDirectionalLightFalloff_GLTF(light{X}.vLightDirection.xyz, preInfo.L, light{X}.vLightFalloff.z, light{X}.vLightFalloff.w);
-                    #elif defined(LIGHT_FALLOFF_PHYSICAL{X})
-                        preInfo.attenuation = computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);
-                        preInfo.attenuation *= computeDirectionalLightFalloff_Physical(light{X}.vLightDirection.xyz, preInfo.L, light{X}.vLightDirection.w);
-                    #elif defined(LIGHT_FALLOFF_STANDARD{X})
-                        preInfo.attenuation = computeDistanceLightFalloff_Standard(preInfo.lightOffset, light{X}.vLightFalloff.x);
-                        preInfo.attenuation *= computeDirectionalLightFalloff_Standard(light{X}.vLightDirection.xyz, preInfo.L, light{X}.vLightDirection.w, light{X}.vLightData.w);
-                    #else
-                        preInfo.attenuation = computeDistanceLightFalloff(preInfo.lightOffset, preInfo.lightDistanceSquared, light{X}.vLightFalloff.x, light{X}.vLightFalloff.y);
-                        preInfo.attenuation *= computeDirectionalLightFalloff(light{X}.vLightDirection.xyz, preInfo.L, light{X}.vLightDirection.w, light{X}.vLightData.w, light{X}.vLightFalloff.z, light{X}.vLightFalloff.w);
-                    #endif
-                #elif defined(POINTLIGHT{X})
-                    #ifdef LIGHT_FALLOFF_GLTF{X}
-                        preInfo.attenuation = computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared, light{X}.vLightFalloff.y);
-                    #elif defined(LIGHT_FALLOFF_PHYSICAL{X})
-                        preInfo.attenuation = computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);
-                    #elif defined(LIGHT_FALLOFF_STANDARD{X})
-                        preInfo.attenuation = computeDistanceLightFalloff_Standard(preInfo.lightOffset, light{X}.vLightFalloff.x);
-                    #else
-                        preInfo.attenuation = computeDistanceLightFalloff(preInfo.lightOffset, preInfo.lightDistanceSquared, light{X}.vLightFalloff.x, light{X}.vLightFalloff.y);
-                    #endif
+            // Compute Attenuation infos
+            #ifdef SPOTLIGHT{X}
+                #ifdef LIGHT_FALLOFF_GLTF{X}
+                    preInfo.attenuation = computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared, light{X}.vLightFalloff.y);
+                    preInfo.attenuation *= computeDirectionalLightFalloff_GLTF(light{X}.vLightDirection.xyz, preInfo.L, light{X}.vLightFalloff.z, light{X}.vLightFalloff.w);
+                #elif defined(LIGHT_FALLOFF_PHYSICAL{X})
+                    preInfo.attenuation = computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);
+                    preInfo.attenuation *= computeDirectionalLightFalloff_Physical(light{X}.vLightDirection.xyz, preInfo.L, light{X}.vLightDirection.w);
+                #elif defined(LIGHT_FALLOFF_STANDARD{X})
+                    preInfo.attenuation = computeDistanceLightFalloff_Standard(preInfo.lightOffset, light{X}.vLightFalloff.x);
+                    preInfo.attenuation *= computeDirectionalLightFalloff_Standard(light{X}.vLightDirection.xyz, preInfo.L, light{X}.vLightDirection.w, light{X}.vLightData.w);
                 #else
-                    preInfo.attenuation = 1.0;
+                    preInfo.attenuation = computeDistanceLightFalloff(preInfo.lightOffset, preInfo.lightDistanceSquared, light{X}.vLightFalloff.x, light{X}.vLightFalloff.y);
+                    preInfo.attenuation *= computeDirectionalLightFalloff(light{X}.vLightDirection.xyz, preInfo.L, light{X}.vLightDirection.w, light{X}.vLightData.w, light{X}.vLightFalloff.z, light{X}.vLightFalloff.w);
                 #endif
-
-                // Simulates Light radius for diffuse and spec term
-                // clear coat is using a dedicated roughness
-                #ifdef HEMILIGHT{X}
-                    preInfo.roughness = roughness;
+            #elif defined(POINTLIGHT{X})
+                #ifdef LIGHT_FALLOFF_GLTF{X}
+                    preInfo.attenuation = computeDistanceLightFalloff_GLTF(preInfo.lightDistanceSquared, light{X}.vLightFalloff.y);
+                #elif defined(LIGHT_FALLOFF_PHYSICAL{X})
+                    preInfo.attenuation = computeDistanceLightFalloff_Physical(preInfo.lightDistanceSquared);
+                #elif defined(LIGHT_FALLOFF_STANDARD{X})
+                    preInfo.attenuation = computeDistanceLightFalloff_Standard(preInfo.lightOffset, light{X}.vLightFalloff.x);
                 #else
-                    preInfo.roughness = adjustRoughnessFromLightProperties(roughness, light{X}.vLightSpecular.a, preInfo.lightDistance);
+                    preInfo.attenuation = computeDistanceLightFalloff(preInfo.lightOffset, preInfo.lightDistanceSquared, light{X}.vLightFalloff.x, light{X}.vLightFalloff.y);
                 #endif
+            #else
+                preInfo.attenuation = 1.0;
+            #endif
 
-                #ifdef IRIDESCENCE
-                    preInfo.iridescenceIntensity = iridescenceIntensity;
-                #endif
+            // Simulates Light radius for diffuse and spec term
+            // clear coat is using a dedicated roughness
+            #if defined(HEMILIGHT{X}) || defined(AREALIGHT{X})
+                preInfo.roughness = roughness;
+            #else
+                preInfo.roughness = adjustRoughnessFromLightProperties(roughness, light{X}.vLightSpecular.a, preInfo.lightDistance);
+            #endif
 
-                // Diffuse contribution
-                #ifdef HEMILIGHT{X}
-                    info.diffuse = computeHemisphericDiffuseLighting(preInfo, diffuse{X}.rgb, light{X}.vLightGround);
-                #elif defined(SS_TRANSLUCENCY)
-                    info.diffuse = computeDiffuseAndTransmittedLighting(preInfo, diffuse{X}.rgb, subSurfaceOut.transmittance);
-                #else
-                    info.diffuse = computeDiffuseLighting(preInfo, diffuse{X}.rgb);
-                #endif
+            #ifdef IRIDESCENCE
+                preInfo.iridescenceIntensity = iridescenceIntensity;
+            #endif
 
-                // Specular contribution
-                #ifdef SPECULARTERM
+            // Diffuse contribution
+            #ifdef HEMILIGHT{X}
+                info.diffuse = computeHemisphericDiffuseLighting(preInfo, diffuse{X}.rgb, light{X}.vLightGround);
+            #elif defined(AREALIGHT{X})
+                info.diffuse = computeAreaDiffuseLighting(preInfo, diffuse{X}.rgb);
+            #elif defined(SS_TRANSLUCENCY)
+                info.diffuse = computeDiffuseAndTransmittedLighting(preInfo, diffuse{X}.rgb, subSurfaceOut.transmittance);
+            #else
+                info.diffuse = computeDiffuseLighting(preInfo, diffuse{X}.rgb);
+            #endif
+
+            // Specular contribution
+            #ifdef SPECULARTERM
+                #if AREALIGHT{X}
+                    info.specular = computeAreaSpecularLighting(preInfo);
+                #else
                     #ifdef ANISOTROPIC
                         info.specular = computeAnisotropicSpecularLighting(preInfo, viewDirectionW, normalW, anisotropicOut.anisotropicTangent, anisotropicOut.anisotropicBitangent, anisotropicOut.anisotropy, clearcoatOut.specularEnvironmentR0, specularEnvironmentR90, AARoughnessFactors.x, diffuse{X}.rgb);
                     #else
                         info.specular = computeSpecularLighting(preInfo, normalW, clearcoatOut.specularEnvironmentR0, specularEnvironmentR90, AARoughnessFactors.x, diffuse{X}.rgb);
                     #endif
                 #endif
+            #endif
 
+            #ifndef AREALIGHT{X}
                 // Sheen contribution
                 #ifdef SHEEN
                     #ifdef SHEEN_LINKWITHALBEDO

packages/dev/core/src/Shaders/ShadersInclude/pbrDirectLightingFunctions.fx

@@ -34,173 +34,17 @@ vec3 computeHemisphericDiffuseLighting(preLightingInfo info, vec3 lightColor, ve
     return mix(groundColor, lightColor, info.NdotL);
 }
 
+#ifdef AREALIGHTUSED
+    vec3 computeAreaDiffuseLighting(preLightingInfo info, vec3 lightColor) {
+        return info.areaLightDiffuse * lightColor;
+    }
+#endif
+
 vec3 computeDiffuseLighting(preLightingInfo info, vec3 lightColor) {
     float diffuseTerm = diffuseBRDF_Burley(info.NdotL, info.NdotV, info.VdotH, info.roughness);
     return diffuseTerm * info.attenuation * info.NdotL * lightColor;
 }
 
-#ifdef AREALIGHTUSED
-
-// Area Light
-
-// Real-Time Polygonal-Light Shading with Linearly Transformed Cosines
-// by Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt
-// code: https://github.com/selfshadow/ltc_code/
-
-vec2 LTCUv( const in vec3 N, const in vec3 V, const in float roughness ) {
-
-	const float LUTSIZE = 64.0;
-	const float LUTSCALE = ( LUTSIZE - 1.0 ) / LUTSIZE;
-	const float LUTBIAS = 0.5 / LUTSIZE;
-
-	float dotNV = saturate( dot( N, V ) );
-
-	// texture parameterized by sqrt( GGX alpha ) and sqrt( 1 - cos( theta ) )
-	vec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );
-
-	uv = uv * LUTSCALE + LUTBIAS;
-
-	return uv;
-
-}
-
-float LTCClippedSphereFormFactor( const in vec3 f ) {
-
-	// Real-Time Area Lighting: a Journey from Research to Production (p.102)
-	// An approximation of the form factor of a horizon-clipped rectangle.
-	float l = length( f );
-	return max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );
-}
-
-vec3 LTCEdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {
-
-	float x = dot( v1, v2 );
-
-	float y = abs( x );
-
-	// rational polynomial approximation to theta / sin( theta ) / 2PI
-	float a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;
-	float b = 3.4175940 + ( 4.1616724 + y ) * y;
-	float v = a / b;
-
-	float thetaSintheta = 0.0;
-
-	if( x > 0.0 )
-	{
-		thetaSintheta = v;
-	}
-	else
-	{
-		thetaSintheta = 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;
-	}
-	return cross( v1, v2 ) * thetaSintheta;
-}
-
-vec3 LTCEvaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {
-
-	// bail if point is on back side of plane of light
-	// assumes ccw winding order of light vertices
-	vec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];
-	vec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];
-	vec3 lightNormal = cross( v1, v2 );
-
-	if( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );
-
-	// construct orthonormal basis around N
-	vec3 T1, T2;
-	T1 = normalize( V - N * dot( V, N ) );
-	T2 = - cross( N, T1 ); // negated from paper; possibly due to a different handedness of world coordinate system
-
-	// compute transform
-	mat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );
-
-	// transform rect
-	vec3 coords[ 4 ];
-	coords[ 0 ] = mat * ( rectCoords[ 0 ] - P );
-	coords[ 1 ] = mat * ( rectCoords[ 1 ] - P );
-	coords[ 2 ] = mat * ( rectCoords[ 2 ] - P );
-	coords[ 3 ] = mat * ( rectCoords[ 3 ] - P );
-
-	// project rect onto sphere
-	coords[ 0 ] = normalize( coords[ 0 ] );
-	coords[ 1 ] = normalize( coords[ 1 ] );
-	coords[ 2 ] = normalize( coords[ 2 ] );
-	coords[ 3 ] = normalize( coords[ 3 ] );
-
-	// calculate vector form factor
-	vec3 vectorFormFactor = vec3( 0.0 );
-	vectorFormFactor += LTCEdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );
-	vectorFormFactor += LTCEdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );
-	vectorFormFactor += LTCEdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );
-	vectorFormFactor += LTCEdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );
-
-	// adjust for horizon clipping
-	float result = LTCClippedSphereFormFactor( vectorFormFactor );
-	return vec3( result );
-}
-
-vec3 computeAreaLightingDiffuse(sampler2D areaLightsLTC1, sampler2D areaLightsLTC2, vec3 viewDirectionW, vec3 vNormal, vec3 vPosition, vec4 lightData, vec3 halfWidth, vec3 halfHeight, vec3 diffuseColor, vec3 specularColor, float roughness ) 
-{
-	vec3 normal = vNormal;
-	vec3 viewDir = viewDirectionW;
-	vec3 position = vPosition;
-	vec3 lightPos = lightData.xyz;
-
-	vec3 rectCoords[ 4 ];
-	rectCoords[ 0 ] = lightPos + halfWidth - halfHeight; // counterclockwise; light shines in local neg z direction
-	rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
-	rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
-	rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
-
-	vec2 uv = LTCUv( normal, viewDir, roughness );
-
-	vec4 t1 = texture2D( areaLightsLTC1, uv );
-	vec4 t2 = texture2D( areaLightsLTC2, uv );
-
-	mat3 mInv = mat3(
-		vec3( t1.x, 0, t1.y ),
-		vec3(    0, 1,    0 ),
-		vec3( t1.z, 0, t1.w )
-	);
-
-	return diffuseColor * LTCEvaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );
-}
-
-#ifdef SPECULARTERM
-
-vec3 computeAreaLightingSpecular(sampler2D areaLightsLTC1, sampler2D areaLightsLTC2, vec3 viewDirectionW, vec3 vNormal, vec3 vPosition, vec4 lightData, vec3 halfWidth, vec3 halfHeight, vec3 diffuseColor, vec3 specularColor, float roughness ) 
-{
-	vec3 normal = vNormal;
-	vec3 viewDir = viewDirectionW;
-	vec3 position = vPosition;
-	vec3 lightPos = lightData.xyz;
-
-	vec3 rectCoords[ 4 ];
-	rectCoords[ 0 ] = lightPos + halfWidth - halfHeight; // counterclockwise; light shines in local neg z direction
-	rectCoords[ 1 ] = lightPos - halfWidth - halfHeight;
-	rectCoords[ 2 ] = lightPos - halfWidth + halfHeight;
-	rectCoords[ 3 ] = lightPos + halfWidth + halfHeight;
-
-	vec2 uv = LTCUv( normal, viewDir, roughness );
-
-	vec4 t1 = texture2D( areaLightsLTC1, uv );
-	vec4 t2 = texture2D( areaLightsLTC2, uv );
-
-	mat3 mInv = mat3(
-		vec3( t1.x, 0, t1.y ),
-		vec3(    0, 1,    0 ),
-		vec3( t1.z, 0, t1.w )
-	);
-
-
-	// LTC Fresnel Approximation by Stephen Hill
-	// http://blog.selfshadow.com/publications/s2016-advances/s2016_ltc_fresnel.pdf
-	vec3 fresnel = ( specularColor * t2.x + ( vec3( 1.0 ) - specularColor ) * t2.y );
-	return specularColor * fresnel * LTCEvaluate( normal, viewDir, position, mInv, rectCoords );
-}
-#endif
-#endif
-
 #define inline
 vec3 computeProjectionTextureDiffuseLighting(sampler2D projectionLightSampler, mat4 textureProjectionMatrix, vec3 posW){
     vec4 strq = textureProjectionMatrix * vec4(posW, 1.0);
@@ -248,6 +92,13 @@ vec3 computeProjectionTextureDiffuseLighting(sampler2D projectionLightSampler, m
         vec3 specTerm = fresnel * distribution * smithVisibility;
         return specTerm * info.attenuation * info.NdotL * lightColor;
     }
+
+    #ifdef AREALIGHTUSED
+        vec3 computeAreaSpecularLighting(preLightingInfo info) {
+            return info.areaLightSpecular;
+        }
+    #endif
+
 #endif
 
 #ifdef ANISOTROPIC