@gnsx/three 0.185.15 → 0.186.0

package/src/renderers/shaders/ShaderChunk/envmap_physical_pars_fragment.glsl.js

@@ -42,6 +42,31 @@ export default /* glsl */`
 
 	}
 
+	#ifdef USE_RETROREFLECTION
+
+		vec3 getIBLRetroRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {
+
+			#ifdef ENVMAP_TYPE_CUBE_UV
+
+				// The retroreflective lobe returns light toward its source, so the environment is sampled along the view direction
+				vec3 retroVec = normalize( mix( viewDir, normal, pow4( roughness ) ) );
+
+				retroVec = transformDirectionByInverseViewMatrix( retroVec, viewMatrix );
+
+				vec4 envMapColor = textureCubeUV( envMap, envMapRotation * retroVec, roughness );
+
+				return envMapColor.rgb * envMapIntensity;
+
+			#else
+
+				return vec3( 0.0 );
+
+			#endif
+
+		}
+
+	#endif
+
 	#ifdef USE_ANISOTROPY
 
 		vec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {
@@ -63,6 +88,29 @@ export default /* glsl */`
 
 		}
 
+		#ifdef USE_RETROREFLECTION
+
+			vec3 getIBLAnisotropyRetroRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {
+
+				#ifdef ENVMAP_TYPE_CUBE_UV
+
+				  // https://google.github.io/filament/Filament.md.html#lighting/imagebasedlights/anisotropy
+					vec3 bentNormal = cross( bitangent, viewDir );
+					bentNormal = normalize( cross( bentNormal, bitangent ) );
+					bentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );
+
+					return getIBLRetroRadiance( viewDir, bentNormal, roughness );
+
+				#else
+
+					return vec3( 0.0 );
+
+				#endif
+
+			}
+
+		#endif
+
 	#endif
 
 #endif

package/src/renderers/shaders/ShaderChunk/lights_fragment_begin.glsl.js

@@ -41,18 +41,41 @@ vec3 geometryClearcoatNormal = vec3( 0.0 );
 
 	if ( material.iridescence > 0.0 ) {
 
-		material.iridescenceFresnelDielectric = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );
-		material.iridescenceFresnelMetallic = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.diffuseColor );
+		vec3 iridescenceFresnelDielectric = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );
+		vec3 iridescenceFresnelMetallic = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.diffuseColor );
 
-		material.iridescenceFresnel = mix( material.iridescenceFresnelDielectric, material.iridescenceFresnelMetallic, material.metalness );
+		material.iridescenceFresnel = mix( iridescenceFresnelDielectric, iridescenceFresnelMetallic, material.metalness );
 
 		// Iridescence F0 approximation
-		material.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );
+		material.iridescenceF0Dielectric = Schlick_to_F0( iridescenceFresnelDielectric, 1.0, dotNVi );
+		material.iridescenceF0Metallic = Schlick_to_F0( iridescenceFresnelMetallic, 1.0, dotNVi );
 
 	}
 
 #endif
 
+#ifdef STANDARD
+
+	float dotNVms = saturate( dot( geometryNormal, geometryViewDir ) );
+
+	material.dfg = texture2D( dfgLUT, vec2( material.roughness, dotNVms ) ).rg;
+
+	#if ( NUM_SUN_LIGHTS > 0 || NUM_DIR_LIGHTS > 0 || NUM_POINT_LIGHTS > 0 || NUM_SPOT_LIGHTS > 0 )
+
+		// Multi-scattering energy compensation for direct lighting
+		// Based on "Practical Multiple Scattering Compensation for Microfacet Models"
+		// https://blog.selfshadow.com/publications/turquin/ms_comp_final.pdf
+
+		// Energy of the single-scattering lobe in a white furnace ( F0 = F90 = 1 )
+		float EssMs = material.dfg.x + material.dfg.y;
+
+		// Compensate for the energy lost to multiple scattering, tinting the added term by F0 ( equation 16 )
+		material.multiScatteringCompensation = 1.0 + material.specularColorBlended * ( 1.0 / EssMs - 1.0 );
+
+	#endif
+
+#endif
+
 IncidentLight directLight;
 
 #if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )
@@ -129,6 +152,32 @@ IncidentLight directLight;
 
 #endif
 
+#if ( NUM_SUN_LIGHTS > 0 ) && defined( RE_Direct )
+
+	SunLight sunLight;
+	#if defined( USE_SHADOWMAP ) && NUM_SUN_LIGHT_SHADOWS > 0
+	SunLightShadow sunLightShadow;
+	#endif
+
+	#pragma unroll_loop_start
+	for ( int i = 0; i < NUM_SUN_LIGHTS; i ++ ) {
+
+		sunLight = sunLights[ i ];
+
+		getSunLightInfo( sunLight, directLight );
+
+		#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SUN_LIGHT_SHADOWS )
+		sunLightShadow = sunLightShadows[ i ];
+		directLight.color *= ( directLight.visible && receiveShadow ) ? getSunShadow( sunShadowMap[ i ], sunLightShadow, UNROLLED_LOOP_INDEX ) : 1.0;
+		#endif
+
+		RE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );
+
+	}
+	#pragma unroll_loop_end
+
+#endif
+
 #if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )
 
 	DirectionalLight directionalLight;

package/src/renderers/shaders/ShaderChunk/lights_fragment_maps.glsl.js

@@ -26,14 +26,32 @@ export default /* glsl */`
 
 	#ifdef USE_ANISOTROPY
 
-		radiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );
+		vec3 iblRadiance = getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );
 
 	#else
 
-		radiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );
+		vec3 iblRadiance = getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );
 
 	#endif
 
+	#ifdef USE_RETROREFLECTION
+
+		#ifdef USE_ANISOTROPY
+
+			vec3 retroIBLRadiance = getIBLAnisotropyRetroRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );
+
+		#else
+
+			vec3 retroIBLRadiance = getIBLRetroRadiance( geometryViewDir, geometryNormal, material.roughness );
+
+		#endif
+
+		iblRadiance = mix( iblRadiance, retroIBLRadiance, saturate( material.retroreflectivity ) );
+
+	#endif
+
+	radiance += iblRadiance;
+
 	#ifdef USE_CLEARCOAT
 
 		clearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );

package/src/renderers/shaders/ShaderChunk/lights_pars_begin.glsl.js

@@ -76,6 +76,26 @@ float getSpotAttenuation( const in float coneCosine, const in float penumbraCosi
 
 }
 
+#if NUM_SUN_LIGHTS > 0
+
+	struct SunLight {
+		vec3 direction;
+		vec3 color;
+	};
+
+	uniform SunLight sunLights[ NUM_SUN_LIGHTS ];
+
+	void getSunLightInfo( const in SunLight sunLight, out IncidentLight light ) {
+
+		light.color = sunLight.color;
+		light.direction = sunLight.direction;
+		light.visible = true;
+
+	}
+
+#endif
+
+
 #if NUM_DIR_LIGHTS > 0
 
 	struct DirectionalLight {

package/src/renderers/shaders/ShaderChunk/lights_physical_fragment.glsl.js

@@ -85,6 +85,12 @@ material.roughness = min( material.roughness, 1.0 );
 
 #endif
 
+#ifdef USE_RETROREFLECTION
+
+	material.retroreflectivity = retroreflectivity;
+
+#endif
+
 #ifdef USE_IRIDESCENCE
 
 	material.iridescence = iridescence;

package/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js

@@ -13,6 +13,12 @@ struct PhysicalMaterial {
 	float metalness;
 	float specularF90;
 	float dispersion;
+	vec2 dfg;
+	vec3 multiScatteringCompensation;
+
+	#ifdef USE_RETROREFLECTION
+		float retroreflectivity;
+	#endif
 
 	#ifdef USE_CLEARCOAT
 		float clearcoat;
@@ -26,9 +32,8 @@ struct PhysicalMaterial {
 		float iridescenceIOR;
 		float iridescenceThickness;
 		vec3 iridescenceFresnel;
-		vec3 iridescenceF0;
-		vec3 iridescenceFresnelDielectric;
-		vec3 iridescenceFresnelMetallic;
+		vec3 iridescenceF0Dielectric;
+		vec3 iridescenceF0Metallic;
 	#endif
 
 	#ifdef USE_SHEEN
@@ -387,14 +392,11 @@ vec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3
 // Approximates multiscattering in order to preserve energy.
 // http://www.jcgt.org/published/0008/01/03/
 #ifdef USE_IRIDESCENCE
-void computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
+void computeMultiscatteringIridescence( const in vec2 fab, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, inout vec3 singleScatter, inout vec3 multiScatter ) {
 #else
-void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {
+void computeMultiscattering( const in vec2 fab, const in vec3 specularColor, const in float specularF90, inout vec3 singleScatter, inout vec3 multiScatter ) {
 #endif
 
-	float dotNV = saturate( dot( normal, viewDir ) );
-	vec2 fab = texture2D( dfgLUT, vec2( roughness, dotNV ) ).rg;
-
 	#ifdef USE_IRIDESCENCE
 
 		vec3 Fr = mix( specularColor, iridescenceF0, iridescence );
@@ -418,48 +420,6 @@ void computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const
 
 }
 
-// GGX BRDF with multi-scattering energy compensation for direct lighting
-// Based on "Practical Multiple Scattering Compensation for Microfacet Models"
-// https://blog.selfshadow.com/publications/turquin/ms_comp_final.pdf
-vec3 BRDF_GGX_Multiscatter( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {
-
-	// Single-scattering BRDF (standard GGX)
-	vec3 singleScatter = BRDF_GGX( lightDir, viewDir, normal, material );
-
-	// Multi-scattering compensation
-	float dotNL = saturate( dot( normal, lightDir ) );
-	float dotNV = saturate( dot( normal, viewDir ) );
-
-	// Precomputed DFG values for view and light directions
-	vec2 dfgV = texture2D( dfgLUT, vec2( material.roughness, dotNV ) ).rg;
-	vec2 dfgL = texture2D( dfgLUT, vec2( material.roughness, dotNL ) ).rg;
-
-	// Single-scattering energy for view and light
-	vec3 FssEss_V = material.specularColorBlended * dfgV.x + material.specularF90 * dfgV.y;
-	vec3 FssEss_L = material.specularColorBlended * dfgL.x + material.specularF90 * dfgL.y;
-
-	float Ess_V = dfgV.x + dfgV.y;
-	float Ess_L = dfgL.x + dfgL.y;
-
-	// Energy lost to multiple scattering
-	float Ems_V = 1.0 - Ess_V;
-	float Ems_L = 1.0 - Ess_L;
-
-	// Average Fresnel reflectance
-	vec3 Favg = material.specularColorBlended + ( 1.0 - material.specularColorBlended ) * 0.047619; // 1/21
-
-	// Multiple scattering contribution
-	vec3 Fms = FssEss_V * FssEss_L * Favg / ( 1.0 - Ems_V * Ems_L * Favg + EPSILON );
-
-	// Energy compensation factor
-	float compensationFactor = Ems_V * Ems_L;
-
-	vec3 multiScatter = Fms * compensationFactor;
-
-	return singleScatter + multiScatter;
-
-}
-
 #if NUM_RECT_AREA_LIGHTS > 0
 
 	void RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
@@ -553,19 +513,63 @@ void RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geome
  
  	#endif
 
-	reflectedLight.directSpecular += irradiance * BRDF_GGX_Multiscatter( directLight.direction, geometryViewDir, geometryNormal, material );
+	vec3 specularBRDF = BRDF_GGX( directLight.direction, geometryViewDir, geometryNormal, material );
+
+	#ifdef USE_RETROREFLECTION
 
-	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseContribution );
+		// Minimal Retroreflective Microfacet Model:
+		// https://jcgt.org/published/0015/01/04/
+		vec3 retroViewDir = reflect( - geometryViewDir, geometryNormal );
+		vec3 retroSpecularBRDF = BRDF_GGX( directLight.direction, retroViewDir, geometryNormal, material );
+
+		specularBRDF = mix( specularBRDF, retroSpecularBRDF, saturate( material.retroreflectivity ) );
+
+	#endif
+
+	reflectedLight.directSpecular += irradiance * specularBRDF * material.multiScatteringCompensation;
+
+	// Light reflected by the specular interface is not available to the diffuse layer ( glTF fresnel_mix )
+	vec3 halfDir = normalize( directLight.direction + geometryViewDir );
+	float dotVH = saturate( dot( geometryViewDir, halfDir ) );
+	vec3 F = F_Schlick( material.specularColor, material.specularF90, dotVH );
+
+	#ifdef USE_RETROREFLECTION
+
+		vec3 retroHalfDir = normalize( directLight.direction + retroViewDir );
+		float dotRetroVH = saturate( dot( retroViewDir, retroHalfDir ) );
+		vec3 retroF = F_Schlick( material.specularColor, material.specularF90, dotRetroVH );
+
+		F = mix( F, retroF, saturate( material.retroreflectivity ) );
+
+	#endif
+
+	reflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseContribution ) * ( 1.0 - F );
 }
 
 void RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {
 
-	vec3 diffuse = irradiance * BRDF_Lambert( material.diffuseContribution );
+	// Energy reflected by the specular lobe is not available to the diffuse layer
+	vec3 singleScattering = vec3( 0.0 );
+	vec3 multiScattering = vec3( 0.0 );
+
+	#ifdef USE_IRIDESCENCE
+
+		computeMultiscatteringIridescence( material.dfg, material.specularColor, material.specularF90, material.iridescence, material.iridescenceF0Dielectric, singleScattering, multiScattering );
+
+	#else
+
+		computeMultiscattering( material.dfg, material.specularColor, material.specularF90, singleScattering, multiScattering );
+
+	#endif
+
+	vec3 diffuse = irradiance * BRDF_Lambert( material.diffuseContribution ) * ( 1.0 - singleScattering - multiScattering );
 
 	#ifdef USE_SHEEN
 
 		float sheenAlbedo = IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );
 
+		sheenSpecularIndirect += irradiance * material.sheenColor * sheenAlbedo * RECIPROCAL_PI;
+
 		float sheenEnergyComp = 1.0 - max3( material.sheenColor ) * sheenAlbedo;
 
 		diffuse *= sheenEnergyComp;
@@ -601,13 +605,13 @@ void RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradia
 
 	#ifdef USE_IRIDESCENCE
 
-		computeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnelDielectric, material.roughness, singleScatteringDielectric, multiScatteringDielectric );
-		computeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.diffuseColor, material.specularF90, material.iridescence, material.iridescenceFresnelMetallic, material.roughness, singleScatteringMetallic, multiScatteringMetallic );
+		computeMultiscatteringIridescence( material.dfg, material.specularColor, material.specularF90, material.iridescence, material.iridescenceF0Dielectric, singleScatteringDielectric, multiScatteringDielectric );
+		computeMultiscatteringIridescence( material.dfg, material.diffuseColor, material.specularF90, material.iridescence, material.iridescenceF0Metallic, singleScatteringMetallic, multiScatteringMetallic );
 
 	#else
 
-		computeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScatteringDielectric, multiScatteringDielectric );
-		computeMultiscattering( geometryNormal, geometryViewDir, material.diffuseColor, material.specularF90, material.roughness, singleScatteringMetallic, multiScatteringMetallic );
+		computeMultiscattering( material.dfg, material.specularColor, material.specularF90, singleScatteringDielectric, multiScatteringDielectric );
+		computeMultiscattering( material.dfg, material.diffuseColor, material.specularF90, singleScatteringMetallic, multiScatteringMetallic );
 
 	#endif
 

package/src/renderers/shaders/ShaderChunk/shadowmap_pars_fragment.glsl.js

@@ -13,6 +13,39 @@ export default /* glsl */`
 
 #ifdef USE_SHADOWMAP
 
+	#if NUM_SUN_LIGHT_SHADOWS > 0
+
+		// must match the cascade count in SunLightShadow
+
+		#define SUN_LIGHT_CASCADES 2
+
+		#if defined( SHADOWMAP_TYPE_PCF )
+
+			uniform sampler2DShadow sunShadowMap[ NUM_SUN_LIGHT_SHADOWS ];
+
+		#else
+
+			uniform sampler2D sunShadowMap[ NUM_SUN_LIGHT_SHADOWS ];
+
+		#endif
+
+		uniform mat4 sunShadowMatrix[ NUM_SUN_LIGHT_SHADOWS * SUN_LIGHT_CASCADES ];
+		uniform vec4 sunShadowCascade[ NUM_SUN_LIGHT_SHADOWS * SUN_LIGHT_CASCADES ];
+		varying vec4 vSunShadowWorldPosition;
+		varying vec3 vSunShadowWorldNormal;
+
+		struct SunLightShadow {
+			float shadowIntensity;
+			float shadowBias;
+			float shadowNormalBias;
+			float shadowRadius;
+			vec2 shadowMapSize;
+		};
+
+		uniform SunLightShadow sunLightShadows[ NUM_SUN_LIGHT_SHADOWS ];
+
+	#endif
+
 	#if NUM_DIR_LIGHT_SHADOWS > 0
 
 		#if defined( SHADOWMAP_TYPE_PCF )
@@ -258,6 +291,55 @@ export default /* glsl */`
 
 	#endif
 
+	#if NUM_SUN_LIGHT_SHADOWS > 0
+
+		float getSunShadow(
+			#if defined( SHADOWMAP_TYPE_PCF )
+				sampler2DShadow shadowMap,
+			#else
+				sampler2D shadowMap,
+			#endif
+			SunLightShadow sunLightShadow,
+			int shadowIndex
+		) {
+
+			vec4 shadowWorldPosition = vec4( vSunShadowWorldPosition.xyz + vSunShadowWorldNormal * sunLightShadow.shadowNormalBias, 1.0 );
+			float viewDepth = vSunShadowWorldPosition.w;
+			int cascadeOffset = shadowIndex * SUN_LIGHT_CASCADES;
+
+			float shadow = 1.0;
+
+			// walk the cascades back to front so each fade band can blend with the shadow behind it
+
+			for ( int i = SUN_LIGHT_CASCADES - 1; i >= 0; i -- ) {
+
+				// ( begin, end, fade start ) view depths of the cascade
+
+				vec4 cascade = sunShadowCascade[ cascadeOffset + i ];
+
+				if ( viewDepth >= cascade.x && viewDepth < cascade.y ) {
+
+					float cascadeShadow = getShadow(
+						shadowMap,
+						sunLightShadow.shadowMapSize,
+						sunLightShadow.shadowIntensity,
+						sunLightShadow.shadowBias,
+						sunLightShadow.shadowRadius,
+						sunShadowMatrix[ cascadeOffset + i ] * shadowWorldPosition
+					);
+
+					shadow = mix( cascadeShadow, shadow, smoothstep( cascade.z, cascade.y, viewDepth ) );
+
+				}
+
+			}
+
+			return shadow;
+
+		}
+
+	#endif
+
 	#if NUM_POINT_LIGHT_SHADOWS > 0
 
 	#if defined( SHADOWMAP_TYPE_PCF )

package/src/renderers/shaders/ShaderChunk/shadowmap_pars_vertex.glsl.js

@@ -9,6 +9,15 @@ export default /* glsl */`
 
 #ifdef USE_SHADOWMAP
 
+	#if NUM_SUN_LIGHT_SHADOWS > 0
+
+		// cascade selection and shadow coordinates are computed per fragment
+
+		varying vec4 vSunShadowWorldPosition;
+		varying vec3 vSunShadowWorldNormal;
+
+	#endif
+
 	#if NUM_DIR_LIGHT_SHADOWS > 0
 
 		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];

package/src/renderers/shaders/ShaderChunk/shadowmap_vertex.glsl.js

@@ -1,6 +1,6 @@
 export default /* glsl */`
 
-#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )
+#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SUN_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )
 
 	#ifdef HAS_NORMAL
 
@@ -20,6 +20,13 @@ export default /* glsl */`
 
 #if defined( USE_SHADOWMAP )
 
+	#if NUM_SUN_LIGHT_SHADOWS > 0
+
+		vSunShadowWorldPosition = vec4( worldPosition.xyz, - mvPosition.z );
+		vSunShadowWorldNormal = shadowWorldNormal;
+
+	#endif
+
 	#if NUM_DIR_LIGHT_SHADOWS > 0
 
 		#pragma unroll_loop_start

package/src/renderers/shaders/ShaderChunk/shadowmask_pars_fragment.glsl.js

@@ -5,6 +5,21 @@ float getShadowMask() {
 
 	#ifdef USE_SHADOWMAP
 
+	#if NUM_SUN_LIGHT_SHADOWS > 0
+
+	SunLightShadow sunLight;
+
+	#pragma unroll_loop_start
+	for ( int i = 0; i < NUM_SUN_LIGHT_SHADOWS; i ++ ) {
+
+		sunLight = sunLightShadows[ i ];
+		shadow *= receiveShadow ? getSunShadow( sunShadowMap[ i ], sunLight, UNROLLED_LOOP_INDEX ) : 1.0;
+
+	}
+	#pragma unroll_loop_end
+
+	#endif
+
 	#if NUM_DIR_LIGHT_SHADOWS > 0
 
 	DirectionalLightShadow directionalLight;

package/src/renderers/shaders/ShaderLib/meshphysical.glsl.js

@@ -99,6 +99,10 @@ uniform float opacity;
 	uniform float dispersion;
 #endif
 
+#ifdef USE_RETROREFLECTION
+	uniform float retroreflectivity;
+#endif
+
 #ifdef USE_IRIDESCENCE
 	uniform float iridescence;
 	uniform float iridescenceIOR;

package/src/renderers/shaders/ShaderLib.js

@@ -316,6 +316,7 @@ ShaderLib.physical = {
 			clearcoatRoughnessMap: { value: null },
 			clearcoatRoughnessMapTransform: { value: /*@__PURE__*/ new Matrix3() },
 			dispersion: { value: 0 },
+			retroreflectivity: { value: 0 },
 			iridescence: { value: 0 },
 			iridescenceMap: { value: null },
 			iridescenceMapTransform: { value: /*@__PURE__*/ new Matrix3() },

package/src/renderers/shaders/UniformsLib.js

@@ -122,6 +122,22 @@ const UniformsLib = {
 
 		lightProbe: { value: [] },
 
+		sunLights: { value: [], properties: {
+			direction: {},
+			color: {}
+		} },
+
+		sunLightShadows: { value: [], properties: {
+			shadowIntensity: 1,
+			shadowBias: {},
+			shadowNormalBias: {},
+			shadowRadius: {},
+			shadowMapSize: {}
+		} },
+
+		sunShadowMatrix: { value: [] },
+		sunShadowCascade: { value: [] },
+
 		directionalLights: { value: [], properties: {
 			direction: {},
 			color: {}

package/src/renderers/webgl/WebGLAnimation.js

@@ -7,10 +7,10 @@ function WebGLAnimation() {
 
 	function onAnimationFrame( time, frame ) {
 
-		animationLoop( time, frame );
-
 		requestId = context.requestAnimationFrame( onAnimationFrame );
 
+		animationLoop( time, frame );
+
 	}
 
 	return {

package/src/renderers/webgl/WebGLCapabilities.js

@@ -41,8 +41,8 @@ function WebGLCapabilities( gl, extensions, parameters, utils ) {
 
 		const halfFloatSupportedByExt = ( textureType === HalfFloatType ) && ( extensions.has( 'EXT_color_buffer_half_float' ) || extensions.has( 'EXT_color_buffer_float' ) );
 
-		if ( textureType !== UnsignedByteType && utils.convert( textureType ) !== gl.getParameter( gl.IMPLEMENTATION_COLOR_READ_TYPE ) && // Edge and Chrome Mac < 52 (#9513)
-			textureType !== FloatType && ! halfFloatSupportedByExt ) {
+		if ( textureType !== UnsignedByteType && textureType !== FloatType && ! halfFloatSupportedByExt &&
+			utils.convert( textureType ) !== gl.getParameter( gl.IMPLEMENTATION_COLOR_READ_TYPE ) ) { // Edge and Chrome Mac < 52 (#9513)
 
 			return false;