split BRDFs from Rendering Equations per @WestLangley's recommendations.

src/renderers/shaders/ShaderChunk/bsdfs.glsl

@@ -29,22 +29,22 @@ ReflectedLight BRDF_Add( const in ReflectedLight base, const in ReflectedLight o
 	);
 }
 
-void BRDF_Lambert( const in IncidentLight incidentLight, const in GeometricContext geometryContext, const in vec3 diffuseColor, inout ReflectedLight reflectedLight ) {
-
-	float lambertianReflectance = saturate( dot( geometryContext.normal, incidentLight.direction ) );
+vec3 BRDF_Diffuse_Lambert( const in IncidentLight incidentLight, const in GeometricContext geometryContext, const in vec3 diffuseColor ) {
 
 	#if defined( ENERGY_PRESERVING_MONOCHROME ) || defined( ENERGY_PRESERVING_RGB )
 
-		lambertianReflectance *= RECIPROCAL_PI;
+		return diffuseColor * RECIPROCAL_PI;
 
-	#endif
+	#else
 
-	reflectedLight.diffuse += incidentLight.color * diffuseColor * lambertianReflectance;
+		return diffuseColor;
+
+	#endif
 
 }
 
 // this roughness is a different property than specular roughness used in GGX.
-void BRDF_OrenNayar( const in IncidentLight incidentLight, const in GeometricContext geometryContext, const in vec3 diffuse, const in float roughness, inout ReflectedLight reflectedLight ) {
+vec3 BRDF_Diffuse_OrenNayar( const in IncidentLight incidentLight, const in GeometricContext geometryContext, const in vec3 diffuse, const in float roughness ) {
 
 	vec3 halfDir = normalize( incidentLight.direction + geometryContext.viewDir );
 	float dotVH = saturate( dot( geometryContext.viewDir, halfDir ) );
@@ -56,7 +56,7 @@ void BRDF_OrenNayar( const in IncidentLight incidentLight, const in GeometricCon
 	float Cosri = 2.0 * dotVH - 1.0 - dotNV * dotNL;
 	float termB = 0.45 * m2 / (m2 + 0.09) * Cosri * ( Cosri >= 0.0 ? min( 1.0, dotNL / dotNV ) : dotNL );
 
-	reflectedLight.diffuse = incidentLight.color * diffuse * ( RECIPROCAL_PI * ( dotNL * termA + termB ) );
+	return diffuse * ( RECIPROCAL_PI * ( dotNL * termA + termB ) );
 
 }
 
@@ -107,7 +107,7 @@ float D_GGX( in float roughtness2, in float dotNH ) {
 
 }
 
-void BRDF_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness2, inout ReflectedLight reflectedLight ) {
+vec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness2 ) {
 	
 	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );
 	float dotNH = saturate( dot( geometry.normal, halfDir ) );
@@ -119,14 +119,14 @@ void BRDF_GGX( const in IncidentLight incidentLight, const in GeometricContext g
 	float G = G_SmithSchlick( roughness2, dotNL, dotNV );
 	float D = D_GGX( roughness2, dotNH );
 
-	reflectedLight.specular += incidentLight.color * F * ( dotNL * G * D );
+	return F * ( G * D );
 
 }
 
 #define DIELECTRIC_SPECULAR_F0 0.20
 
 // this blends the existing reflected light with a clear coat.
-void BRDF_GGX_ClearCoat( const in IncidentLight incidentLight, const in GeometricContext geometry, const in float clearCoatWeight, const in float clearCoatRoughness, inout ReflectedLight reflectedLight ) {
+vec3 BRDF_Specular_ClearCoat( const in IncidentLight incidentLight, const in GeometricContext geometry, const in float clearCoatWeight, const in float clearCoatRoughness ) {
 
 	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );
 	float dotNH = saturate( dot( geometry.normal, halfDir ) );
@@ -139,16 +139,12 @@ void BRDF_GGX_ClearCoat( const in IncidentLight incidentLight, const in Geometri
 	float D = D_GGX( clearCoatRoughness, dotNH );
 
 	
-	ReflectedLight clearCoatReflectedLight;
-	clearCoatReflectedLight.specular = incidentLight.color * F * ( G * D );
-	clearCoatReflectedLight.diffuse = vec3( 0.0 );
-
-	reflectedLight = BRDF_Mix( reflectedLight, clearCoatReflectedLight, clearCoatWeight ); 
+	return F * ( G * D );
 
 }
 
 // ref: https://www.unrealengine.com/blog/physically-based-shading-on-mobile - environmentBRDF for GGX on mobile
-void BRDF_GGX_Environment( const in IncidentLight incidentLight, const in GeometricContext geometry, vec3 specularColor, float roughness, inout ReflectedLight reflectedLight ) {
+vec3 BRDF_Specular_GGX_Environment( const in IncidentLight incidentLight, const in GeometricContext geometry, vec3 specularColor, float roughness ) {
 
 	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );
 
@@ -158,7 +154,7 @@ void BRDF_GGX_Environment( const in IncidentLight incidentLight, const in Geomet
 	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;
 	vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;
 
-	reflectedLight.specular += incidentLight.color * specularColor * AB.x + AB.y;
+	return specularColor * AB.x + AB.y;
 
 }
 
@@ -177,7 +173,7 @@ float D_BlinnPhong( const in float shininess, const in float dotNH ) {
 
 }
 
-void BRDF_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess, inout ReflectedLight reflectedLight ) {
+vec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {
 
 	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );
 	float dotNH = saturate( dot( geometry.normal, halfDir ) );
@@ -187,6 +183,6 @@ void BRDF_BlinnPhong( const in IncidentLight incidentLight, const in GeometricCo
 	float G = G_BlinnPhong_Implicit( /* dotNL, dotNV */ );
 	float D = D_BlinnPhong( shininess, dotNH );
 
-	reflectedLight.specular += incidentLight.color * F * ( G * D );
+	return F * ( G * D );
 
 }

src/renderers/shaders/ShaderChunk/lights_lambert_vertex.glsl

@@ -12,11 +12,13 @@ ReflectedLight backReflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ) );
 
 		IncidentLight directLight = getPointDirectLight( pointLights[ i ], geometry );
 
-		BRDF_Lambert( directLight, geometry, diffuse, frontReflectedLight );
+		float dotNL = dot( geometry.normal, directLight.direction );
+		frontReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, diffuse );
 
 		#ifdef DOUBLE_SIDED
 
-			BRDF_Lambert( directLight, backGeometry, diffuse, backReflectedLight );
+			float dotNLBack = dot( -geometry.normal, directLight.direction );
+			backReflectedLight.diffuse += dotNLBack * directLight.color * BRDF_Diffuse_Lambert( directLight, backGeometry, diffuse );
 
 		#endif
 
@@ -30,14 +32,15 @@ ReflectedLight backReflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ) );
 
 		IncidentLight directLight = getSpotDirectLight( spotLights[ i ], geometry );
 
-		BRDF_Lambert( directLight, geometry, diffuse, frontReflectedLight );
+		float dotNL = dot( geometry.normal, directLight.direction );
+		frontReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, diffuse );
 
 		#ifdef DOUBLE_SIDED
 
-			BRDF_Lambert( directLight, backGeometry, diffuse, backReflectedLight );
+			float dotNLBack = dot( -geometry.normal, directLight.direction );
+			backReflectedLight.diffuse += dotNLBack * directLight.color * BRDF_Diffuse_Lambert( directLight, backGeometry, diffuse );
 
 		#endif
-
 	}
 
 #endif
@@ -48,11 +51,13 @@ ReflectedLight backReflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ) );
 
 		IncidentLight directLight = getDirectionalDirectLight( directionalLights[ i ], geometry );
 
-		BRDF_Lambert( directLight, geometry, diffuse, frontReflectedLight );
+		float dotNL = dot( geometry.normal, directLight.direction );
+		frontReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, diffuse );
 
 		#ifdef DOUBLE_SIDED
 
-			BRDF_Lambert( directLight, backGeometry, diffuse, backReflectedLight );
+			float dotNLBack = dot( -geometry.normal, directLight.direction );
+			backReflectedLight.diffuse += dotNLBack * directLight.color * BRDF_Diffuse_Lambert( directLight, backGeometry, diffuse );
 
 		#endif
 
@@ -66,13 +71,15 @@ ReflectedLight backReflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ) );
 
 		IncidentLight indirectLight = getHemisphereIndirectLight( hemisphereLights[ i ], geometry );
 
-		BRDF_Lambert( indirectLight, geometry, diffuse, frontReflectedLight );
+		float dotNL = dot( geometry.normal, directLight.direction );
+		frontReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, diffuse );
 
 		#ifdef DOUBLE_SIDED
 	
 			indirectLight = getHemisphereIndirectLight( hemisphereLights[ i ], backGeometry );
 
-			BRDF_Lambert( indirectLight, backGeometry, diffuse, backReflectedLight );
+			float dotNLBack = dot( -geometry.normal, directLight.direction );
+			backReflectedLight.diffuse += dotNLBack * directLight.color * BRDF_Diffuse_Lambert( directLight, backGeometry, diffuse );
 
 		#endif
 

src/renderers/shaders/ShaderChunk/lights_pars.glsl

@@ -124,12 +124,7 @@ uniform vec3 ambientLightColor;
 
 #ifdef USE_ENVMAP
 
-	struct SpecularLightProbe {
-		samplerCube	map;
-		float intensity;
-	};
-
-	IncidentLight getSpecularLightProbeIndirectLight( const in SpecularLightProbe specularLightProbe, const in GeometricContext geometry, const in float lodLevel ) { 
+	IncidentLight getSpecularLightProbeIndirectLight( /*const in SpecularLightProbe specularLightProbe,*/ const in GeometricContext geometry, const in float lodLevel ) { 
 	
 		#ifdef ENVMAP_MODE_REFLECTION
 
@@ -159,11 +154,11 @@ uniform vec3 ambientLightColor;
 
 				float bias = pow( lodLevel, 0.5 ) * 7.0; // from bhouston - there are other models for this calculation (roughness; not roughnesFactor)
 
-				vec4 envMapColor = textureCubeLodEXT( specularLightProbe.map, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ), bias );
+				vec4 envMapColor = textureCubeLodEXT( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ), bias );
 
 			#else
 
-				vec4 envMapColor = textureCube( specularLightProbe.map, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
+				vec4 envMapColor = textureCube( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );
 
 			#endif
 
@@ -172,19 +167,19 @@ uniform vec3 ambientLightColor;
 			vec2 sampleUV;
 			sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );
 			sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;
-			vec4 envMapColor = texture2D( specularLightProbe.map, sampleUV );
+			vec4 envMapColor = texture2D( envMap, sampleUV );
 
 		#elif defined( ENVMAP_TYPE_SPHERE )
 
 			vec3 reflectView = flipNormal * normalize((viewMatrix * vec4( reflectVec, 0.0 )).xyz + vec3(0.0,0.0,1.0));
-			vec4 envMapColor = texture2D( specularLightProbe.map, reflectView.xy * 0.5 + 0.5 );
+			vec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );
 
 		#endif
 
 		envMapColor.rgb = inputToLinear( envMapColor.rgb );
 
 		IncidentLight indirectLight;
-		indirectLight.color = envMapColor.rgb * specularLightProbe.intensity;
+		indirectLight.color = envMapColor.rgb * reflectivity;
 		indirectLight.direction = geometry.normal;
 
 		return indirectLight;

src/renderers/shaders/ShaderChunk/lights_phong_pars_fragment.glsl

@@ -19,25 +19,27 @@ struct BlinnPhongMaterial {
 	vec3	specularColor;
 };
 
-void BRDF_BlinnPhongMaterial_DirectLight( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight directReflectedLight ) {
+void BlinnPhongMaterial_RE_DirectLight( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight directReflectedLight ) {
 
-	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ) );
+	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
 
-	BRDF_Lambert( directLight, geometry, material.diffuseColor, directReflectedLight );
-	//BRDF_OrenNayar( directLight, geometry, material.diffuseColor, 0.5, directReflectedLight );
+	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 );
 
-	BRDF_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess, directReflectedLight );
+	directReflectedLight.specular += dotNL * directLight.color * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess );
 	
 }
 
-#define BRDF_Material_DirectLight    BRDF_BlinnPhongMaterial_DirectLight
+#define Material_RE_DirectLight    BlinnPhongMaterial_RE_DirectLight
 
-void BRDF_BlinnPhongMaterial_IndirectLight( const in IncidentLight indirectLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight indirectReflectedLight ) {
+void BlinnPhongMaterial_RE_IndirectLight( const in IncidentLight indirectLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight indirectReflectedLight ) {
 
-	BRDF_Lambert( indirectLight, geometry, material.diffuseColor, indirectReflectedLight );
+	float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );
+
+	indirectReflectedLight.diffuse += dotNL * indirectLight.color * BRDF_Diffuse_Lambert( indirectLight, geometry, material.diffuseColor );
 
 }
 
-#define BRDF_Material_DiffuseIndirectLight    BRDF_BlinnPhongMaterial_IndirectLight
+#define Material_RE_DiffuseIndirectLight    BlinnPhongMaterial_RE_IndirectLight
 
 #define Material_LightProbeLOD( material )   (0)

src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl

@@ -6,42 +6,36 @@ struct PhysicalMaterial {
 	float	clearCoatRoughness;
 };
 
-void BRDF_PhysicalMaterial_DirectLight( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight directReflectedLight ) {
+void PhysicalMaterial_RE_DirectLight( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight directReflectedLight ) {
 
-	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ) );
+	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );
 
-	BRDF_Lambert( directLight, geometry, material.diffuseColor, reflectedLight );
-
-	BRDF_GGX( directLight, geometry, material.specularColor, material.roughness, reflectedLight );
-
-#ifdef CLEARCOAT
-
-	BRDF_GGX_ClearCoat_Over( directLight, geometry, material.clearCoatWeight, material.clearCoatRoughness, reflectedLight );
-
-#endif
-
-	directReflectedLight.diffuse += reflectedLight.diffuse;
-	directReflectedLight.specular += reflectedLight.specular;
+	directReflectedLight.diffuse += dotNL * directLight.color * BRDF_Diffuse_Lambert( directLight, geometry, material.diffuseColor );
+	directReflectedLight.specular += dotNL * directLight.color * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );
 	
 }
-#define BRDF_Material_DirectLight    BRDF_PhysicalMaterial_DirectLight
+#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 BRDF_PhysicalMaterial_DiffuseIndirectLight( const in IncidentLight indirectLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight indirectReflectedLight ) {
+	float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );
 
-	BRDF_Lambert( indirectLight, geometry, material.diffuseColor, indirectReflectedLight );
+	indirectReflectedLight.diffuse += dotNL * indirectLight.color * BRDF_Diffuse_Lambert( indirectLight, geometry, material.diffuseColor );
 
 }
 
-#define BRDF_Material_DiffuseIndirectLight    BRDF_PhysicalMaterial_DiffuseIndirectLight
+#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 BRDF_PhysicalMaterial_SpecularIndirectLight( const in IncidentLight indirectLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight indirectReflectedLight ) {
+	float dotNL = saturate( dot( geometry.normal, indirectLight.direction ) );
 
-    BRDF_GGX_Environment( lightProbeIncidentLight, geometry, material.specularColor, material.roughness, indirectReflectedLight );
+    indirectReflectedLight.specular += dotNL * indirectLight.color * BRDF_Specular_GGX_Environment( indirectLight, geometry, material.specularColor, material.specularRoughness );
 
 }
 
-#define Material_LightProbeLOD( material )   (material.roughness)
+#define Material_LightProbeLOD( material )   (material.specularRoughness)
 
-#define BRDF_Material_SpecularIndirectLight    BRDF_PhysicalMaterial_SpecularIndirectLight
+#define Material_RE_IndirectSpecularLight    PhysicalMaterial_RE_SpecularIndirectLight

src/renderers/shaders/ShaderChunk/lights_template.glsl

@@ -4,43 +4,43 @@
 
 GeometricContext geometry = GeometricContext( -vViewPosition, normalize( normal ), normalize(vViewPosition ) );
 
-#if ( MAX_POINT_LIGHTS > 0 ) && defined( BRDF_Material_DirectLight )
+#if ( MAX_POINT_LIGHTS > 0 ) && defined( Material_RE_DirectLight )
 
 	for ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {
 
 		IncidentLight directLight = getPointDirectLight( pointLights[ i ], geometry );
 
-		BRDF_Material_DirectLight( directLight, geometry, material, directReflectedLight );
+		Material_RE_DirectLight( directLight, geometry, material, directReflectedLight );
 
 	}
 
 #endif
 
-#if ( MAX_SPOT_LIGHTS > 0 ) && defined( BRDF_Material_DirectLight )
+#if ( MAX_SPOT_LIGHTS > 0 ) && defined( Material_RE_DirectLight )
 
 	for ( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {
 
 		IncidentLight directLight = getSpotDirectLight( spotLights[ i ], geometry );
 
-		BRDF_Material_DirectLight( directLight, geometry, material, directReflectedLight );
+		Material_RE_DirectLight( directLight, geometry, material, directReflectedLight );
 
 	}
 
 #endif
 
-#if ( MAX_DIR_LIGHTS > 0 ) && defined( BRDF_Material_DirectLight )
+#if ( MAX_DIR_LIGHTS > 0 ) && defined( Material_RE_DirectLight )
 
 	for ( int i = 0; i < MAX_DIR_LIGHTS; i ++ ) {
 
 		IncidentLight directLight = getDirectionalDirectLight( directionalLights[ i ], geometry );
 
-		BRDF_Material_DirectLight( directLight, geometry, material, directReflectedLight );
+		Material_RE_DirectLight( directLight, geometry, material, directReflectedLight );
 		
 	}
 
 #endif
 
-#if defined( BRDF_Material_DiffuseIndirectLight )
+#if defined( Material_RE_IndirectDiffuseLight )
 
 	{
 	
@@ -64,19 +64,19 @@ GeometricContext geometry = GeometricContext( -vViewPosition, normalize( normal
 
 #endif
 
-		BRDF_Material_DiffuseIndirectLight( indirectLight, geometry, material, indirectReflectedLight );
+		Material_RE_IndirectDiffuseLight( indirectLight, geometry, material, indirectReflectedLight );
 
 	}
 
 #endif
 
-#if defined( ENV_MAP ) && defined( BRDF_Material_SpecularIndirectLight )
+#if defined( USE_ENVMAP ) && defined( Material_RE_IndirectSpecularLight )
 
 	{
 
-		IncidentLight indirectLight = getSpecularLightProbeIndirectLight( specularLightProbe, geometry, Material_LightProbeLOD( material ) );
+		IncidentLight indirectLight = getSpecularLightProbeIndirectLight( /*specularLightProbe,*/ geometry, Material_LightProbeLOD( material ) );
 
-    	BRDF_Material_SpecularIndirectLight( lightProbeIncidentLight, geometry, material, indirectReflectedLight );
+    	Material_RE_IndirectSpecularLight( indirectLight, geometry, material, indirectReflectedLight );
 
     }
 

src/renderers/shaders/ShaderLib.js

@@ -67,6 +67,12 @@ THREE.ShaderLib = {
 			"uniform vec3 diffuse;",
 			"uniform float opacity;",
 
+			"#ifndef FLAT_SHADED",
+
+			"	varying vec3 vNormal;",
+
+			"#endif",
+
 			THREE.ShaderChunk[ "common" ],
 			THREE.ShaderChunk[ "color_pars_fragment" ],
 			THREE.ShaderChunk[ "uv_pars_fragment" ],
@@ -512,6 +518,14 @@ THREE.ShaderLib = {
 
 			"uniform float envMapIntensity;", // temporary
 
+			"varying vec3 vViewPosition;",
+
+			"#ifndef FLAT_SHADED",
+
+			"	varying vec3 vNormal;",
+
+			"#endif",
+
 			THREE.ShaderChunk[ "common" ],
 			THREE.ShaderChunk[ "color_pars_fragment" ],
 			THREE.ShaderChunk[ "uv_pars_fragment" ],