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

3 files changed, 24 insertions, 36 deletions

diff --git a/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp b/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
index 329deeb1ae..d128578d0b 100644
--- a/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
+++ b/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;
diff --git a/servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl b/servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl
index 5261868155..987960069b 100644
--- a/servers/rendering/renderer_rd/shaders/scene_forward_clustered.glsl
+++ b/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) {
diff --git a/servers/rendering/renderer_scene_cull.cpp b/servers/rendering/renderer_scene_cull.cpp
index bae98f8884..a7886bb6b1 100644
--- a/servers/rendering/renderer_scene_cull.cpp
+++ b/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);