Merge pull request #53790 from briansemrau/remove-distant-shadowy-void

doc/classes/DirectionalLight3D.xml

@@ -11,7 +11,7 @@
 	</tutorials>
 	<members>
 		<member name="directional_shadow_blend_splits" type="bool" setter="set_blend_splits" getter="is_blend_splits_enabled" default="false">
-			If [code]true[/code], shadow detail is sacrificed in exchange for smoother transitions between splits.
+			If [code]true[/code], shadow detail is sacrificed in exchange for smoother transitions between splits. This is ignored when [member directional_shadow_mode] is [code]SHADOW_ORTHOGONAL[/code].
 		</member>
 		<member name="directional_shadow_fade_start" type="float" setter="set_param" getter="get_param" default="0.8">
 			Proportion of [member directional_shadow_max_distance] at which point the shadow starts to fade. At [member directional_shadow_max_distance] the shadow will disappear.
@@ -29,7 +29,7 @@
 			The distance from camera to shadow split 1. Relative to [member directional_shadow_max_distance]. Only used when [member directional_shadow_mode] is [code]SHADOW_PARALLEL_2_SPLITS[/code] or [code]SHADOW_PARALLEL_4_SPLITS[/code].
 		</member>
 		<member name="directional_shadow_split_2" type="float" setter="set_param" getter="get_param" default="0.2">
-			The distance from shadow split 1 to split 2. Relative to [member directional_shadow_max_distance]. Only used when [member directional_shadow_mode] is [code]SHADOW_PARALLEL_2_SPLITS[/code] or [code]SHADOW_PARALLEL_4_SPLITS[/code].
+			The distance from shadow split 1 to split 2. Relative to [member directional_shadow_max_distance]. Only used when [member directional_shadow_mode] is [code]SHADOW_PARALLEL_4_SPLITS[/code].
 		</member>
 		<member name="directional_shadow_split_3" type="float" setter="set_param" getter="get_param" default="0.5">
 			The distance from shadow split 2 to split 3. Relative to [member directional_shadow_max_distance]. Only used when [member directional_shadow_mode] is [code]SHADOW_PARALLEL_4_SPLITS[/code].

doc/classes/Light3D.xml

@@ -32,7 +32,7 @@
 			If [code]true[/code], the light only appears in the editor and will not be visible at runtime.
 		</member>
 		<member name="light_angular_distance" type="float" setter="set_param" getter="get_param" default="0.0">
-			The light's angular size in degrees. Only available for [DirectionalLight3D]s. For reference, the Sun from the Earth is approximately [code]0.5[/code].
+			The light's angular size in degrees. Increasing this will make shadows softer at greater distances. Only available for [DirectionalLight3D]s. For reference, the Sun from the Earth is approximately [code]0.5[/code].
 		</member>
 		<member name="light_bake_mode" type="int" setter="set_bake_mode" getter="get_bake_mode" enum="Light3D.BakeMode" default="1">
 			The light's bake mode. See [enum BakeMode].

servers/rendering/renderer_rd/renderer_scene_render_rd.cpp

@@ -3026,7 +3026,7 @@ void RendererSceneRenderRD::_setup_lights(const PagedArray<RID> &p_lights, const
 					RS::LightDirectionalShadowMode smode = storage->light_directional_get_shadow_mode(base);
 
 					int limit = smode == RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL ? 0 : (smode == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS ? 1 : 3);
-					light_data.blend_splits = storage->light_directional_get_blend_splits(base);
+					light_data.blend_splits = (smode != RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL) && storage->light_directional_get_blend_splits(base);
 					for (int j = 0; j < 4; j++) {
 						Rect2 atlas_rect = li->shadow_transform[j].atlas_rect;
 						CameraMatrix matrix = li->shadow_transform[j].camera;

servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl

@@ -1270,21 +1270,21 @@ void main() {
 
 			float shadow = 1.0;
 
-			//version with soft shadows, more expensive
 			if (directional_lights.data[i].shadow_enabled) {
-				if (sc_use_directional_soft_shadows && directional_lights.data[i].softshadow_angle > 0) {
-					float depth_z = -vertex.z;
-
-					vec3 shadow_color = vec3(0.0);
-					vec3 light_dir = directional_lights.data[i].direction;
+				float depth_z = -vertex.z;
+				vec3 light_dir = directional_lights.data[i].direction;
+				vec3 base_normal_bias = normalize(normal_interp) * (1.0 - max(0.0, dot(light_dir, -normalize(normal_interp))));
 
-#define BIAS_FUNC(m_var, m_idx)                                                                                                                                       \
-	m_var.xyz += light_dir * directional_lights.data[i].shadow_bias[m_idx];                                                                                           \
-	vec3 normal_bias = normalize(normal_interp) * (1.0 - max(0.0, dot(light_dir, -normalize(normal_interp)))) * directional_lights.data[i].shadow_normal_bias[m_idx]; \
-	normal_bias -= light_dir * dot(light_dir, normal_bias);                                                                                                           \
+#define BIAS_FUNC(m_var, m_idx)                                                                 \
+	m_var.xyz += light_dir * directional_lights.data[i].shadow_bias[m_idx];                     \
+	vec3 normal_bias = base_normal_bias * directional_lights.data[i].shadow_normal_bias[m_idx]; \
+	normal_bias -= light_dir * dot(light_dir, normal_bias);                                     \
 	m_var.xyz += normal_bias;
 
-					uint blend_index = 0;
+				//version with soft shadows, more expensive
+				if (sc_use_directional_soft_shadows && directional_lights.data[i].softshadow_angle > 0) {
+					uint blend_count = 0;
+					const uint blend_max = directional_lights.data[i].blend_splits ? 2 : 1;
 
 					if (depth_z < directional_lights.data[i].shadow_split_offsets.x) {
 						vec4 v = vec4(vertex, 1.0);
@@ -1299,10 +1299,10 @@ void main() {
 						float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
 						vec2 tex_scale = directional_lights.data[i].uv_scale1 * test_radius;
 						shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
-						blend_index++;
+						blend_count++;
 					}
 
-					if (blend_index < 2 && depth_z < directional_lights.data[i].shadow_split_offsets.y) {
+					if (blend_count < blend_max && depth_z < directional_lights.data[i].shadow_split_offsets.y) {
 						vec4 v = vec4(vertex, 1.0);
 
 						BIAS_FUNC(v, 1)
@@ -1316,7 +1316,7 @@ void main() {
 						vec2 tex_scale = directional_lights.data[i].uv_scale2 * test_radius;
 						float s = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 
-						if (blend_index == 0) {
+						if (blend_count == 0) {
 							shadow = s;
 						} else {
 							//blend
@@ -1324,10 +1324,10 @@ void main() {
 							shadow = mix(shadow, s, blend);
 						}
 
-						blend_index++;
+						blend_count++;
 					}
 
-					if (blend_index < 2 && depth_z < directional_lights.data[i].shadow_split_offsets.z) {
+					if (blend_count < blend_max && depth_z < directional_lights.data[i].shadow_split_offsets.z) {
 						vec4 v = vec4(vertex, 1.0);
 
 						BIAS_FUNC(v, 2)
@@ -1341,7 +1341,7 @@ void main() {
 						vec2 tex_scale = directional_lights.data[i].uv_scale3 * test_radius;
 						float s = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 
-						if (blend_index == 0) {
+						if (blend_count == 0) {
 							shadow = s;
 						} else {
 							//blend
@@ -1349,10 +1349,10 @@ void main() {
 							shadow = mix(shadow, s, blend);
 						}
 
-						blend_index++;
+						blend_count++;
 					}
 
-					if (blend_index < 2) {
+					if (blend_count < blend_max) {
 						vec4 v = vec4(vertex, 1.0);
 
 						BIAS_FUNC(v, 3)
@@ -1366,7 +1366,7 @@ void main() {
 						vec2 tex_scale = directional_lights.data[i].uv_scale4 * test_radius;
 						float s = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 
-						if (blend_index == 0) {
+						if (blend_count == 0) {
 							shadow = s;
 						} else {
 							//blend
@@ -1375,21 +1375,9 @@ void main() {
 						}
 					}
 
-#undef BIAS_FUNC
 				} else { //no soft shadows
 
-					float depth_z = -vertex.z;
-
 					vec4 pssm_coord;
-					vec3 light_dir = directional_lights.data[i].direction;
-					vec3 base_normal_bias = normalize(normal_interp) * (1.0 - max(0.0, dot(light_dir, -normalize(normal_interp))));
-
-#define BIAS_FUNC(m_var, m_idx)                                                                 \
-	m_var.xyz += light_dir * directional_lights.data[i].shadow_bias[m_idx];                     \
-	vec3 normal_bias = base_normal_bias * directional_lights.data[i].shadow_normal_bias[m_idx]; \
-	normal_bias -= light_dir * dot(light_dir, normal_bias);                                     \
-	m_var.xyz += normal_bias;
-
 					if (depth_z < directional_lights.data[i].shadow_split_offsets.x) {
 						vec4 v = vec4(vertex, 1.0);
 
@@ -1448,11 +1436,11 @@ void main() {
 						float shadow2 = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale, pssm_coord);
 						shadow = mix(shadow, shadow2, pssm_blend);
 					}
+				}
 
-					shadow = mix(shadow, 1.0, smoothstep(directional_lights.data[i].fade_from, directional_lights.data[i].fade_to, vertex.z)); //done with negative values for performance
+				shadow = mix(shadow, 1.0, smoothstep(directional_lights.data[i].fade_from, directional_lights.data[i].fade_to, vertex.z)); //done with negative values for performance
 
 #undef BIAS_FUNC
-				}
 			} // shadows
 
 			if (i < 4) {

servers/rendering/renderer_scene_cull.cpp

@@ -2076,7 +2076,7 @@ void RendererSceneCull::_light_instance_setup_directional_shadow(int p_shadow_in
 
 			// This trick here is what stabilizes the shadow (make potential jaggies to not move)
 			// at the cost of some wasted resolution. Still, the quality increase is very well worth it.
-			const real_t unit = radius * 2.0 / texture_size;
+			const real_t unit = (radius + soft_shadow_expand) * 2.0 / texture_size;
 			x_max_cam = Math::snapped(x_vec.dot(center) + radius + soft_shadow_expand, unit);
 			x_min_cam = Math::snapped(x_vec.dot(center) - radius - soft_shadow_expand, unit);
 			y_max_cam = Math::snapped(y_vec.dot(center) + radius + soft_shadow_expand, unit);