Support light size and soft shadows

2 files changed, 369 insertions, 36 deletions

diff --git a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
index 62ab188ddc..70ce8d61e4 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
@@ -441,7 +441,7 @@ vec3 F0(float metallic, float specular, vec3 albedo) {
 	return mix(vec3(dielectric), albedo, vec3(metallic));
 }
 
-void light_compute(vec3 N, vec3 L, vec3 V, vec3 light_color, float attenuation, vec3 shadow_attenuation, vec3 diffuse_color, float roughness, float metallic, float specular, float specular_blob_intensity,
+void light_compute(vec3 N, vec3 L, vec3 V, float A, vec3 light_color, float attenuation, vec3 shadow_attenuation, vec3 diffuse_color, float roughness, float metallic, float specular, float specular_blob_intensity,
 #ifdef LIGHT_BACKLIGHT_USED
 		vec3 backlight,
 #endif
@@ -481,7 +481,7 @@ LIGHT_SHADER_CODE
 	/* clang-format on */
 
 #else
-	float NdotL = dot(N, L);
+	float NdotL = min(A + dot(N, L), 1.0);
 	float cNdotL = max(NdotL, 0.0); // clamped NdotL
 	float NdotV = dot(N, V);
 	float cNdotV = max(NdotV, 0.0);
@@ -491,11 +491,11 @@ LIGHT_SHADER_CODE
 #endif
 
 #if defined(SPECULAR_BLINN) || defined(SPECULAR_SCHLICK_GGX) || defined(LIGHT_CLEARCOAT_USED)
-	float cNdotH = max(dot(N, H), 0.0);
+	float cNdotH = clamp(A + dot(N, H), 0.0, 1.0);
 #endif
 
 #if defined(DIFFUSE_BURLEY) || defined(SPECULAR_SCHLICK_GGX) || defined(LIGHT_CLEARCOAT_USED)
-	float cLdotH = max(dot(L, H), 0.0);
+	float cLdotH = clamp(A + dot(L, H), 0.0, 1.0);
 #endif
 
 	if (metallic < 1.0) {
@@ -613,7 +613,7 @@ LIGHT_SHADER_CODE
 #elif defined(SPECULAR_PHONG)
 
 		vec3 R = normalize(-reflect(L, N));
-		float cRdotV = max(0.0, dot(R, V));
+		float cRdotV = clamp(A + dot(R, V), 0.0, 1.0);
 		float shininess = exp2(15.0 * (1.0 - roughness) + 1.0) * 0.25;
 		float phong = pow(cRdotV, shininess);
 		phong *= (shininess + 8.0) * (1.0 / (8.0 * M_PI));
@@ -686,6 +686,24 @@ LIGHT_SHADER_CODE
 
 #ifndef USE_NO_SHADOWS
 
+const vec2 shadow_poisson_disk[16] = vec2[](
+		vec2(-0.94201624, -0.39906216),
+		vec2(0.94558609, -0.76890725),
+		vec2(-0.094184101, -0.92938870),
+		vec2(0.34495938, 0.29387760),
+		vec2(-0.91588581, 0.45771432),
+		vec2(-0.81544232, -0.87912464),
+		vec2(-0.38277543, 0.27676845),
+		vec2(0.97484398, 0.75648379),
+		vec2(0.44323325, -0.97511554),
+		vec2(0.53742981, -0.47373420),
+		vec2(-0.26496911, -0.41893023),
+		vec2(0.79197514, 0.19090188),
+		vec2(-0.24188840, 0.99706507),
+		vec2(-0.81409955, 0.91437590),
+		vec2(0.19984126, 0.78641367),
+		vec2(0.14383161, -0.14100790));
+
 float sample_shadow(texture2D shadow, vec2 shadow_pixel_size, vec4 coord) {
 
 	vec2 pos = coord.xy;
@@ -725,6 +743,51 @@ float sample_shadow(texture2D shadow, vec2 shadow_pixel_size, vec4 coord) {
 	return 0;
 }
 
+float sample_directional_soft_shadow(texture2D shadow, vec3 pssm_coord, vec2 tex_scale) {
+
+	//find blocker
+	float blocker_count = 0.0;
+	float blocker_average = 0.0;
+
+	mat2 poisson_rotate;
+
+	{
+		float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
+		float sr = sin(r);
+		float cr = cos(r);
+		poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
+	}
+
+	for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
+		vec2 suv = pssm_coord.xy + (poisson_rotate * shadow_poisson_disk[i]) * tex_scale;
+		float d = textureLod(sampler2D(shadow, material_samplers[SAMPLER_LINEAR_CLAMP]), suv, 0.0).r;
+		if (d < pssm_coord.z) {
+			blocker_average += d;
+			blocker_count += 1.0;
+		}
+	}
+
+	if (blocker_count > 0.0) {
+
+		//blockers found, do soft shadow
+		blocker_average /= blocker_count;
+		float penumbra = (pssm_coord.z - blocker_average) / blocker_average;
+		tex_scale *= penumbra;
+
+		float s = 0.0;
+		for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
+			vec2 suv = pssm_coord.xy + (poisson_rotate * shadow_poisson_disk[i]) * tex_scale;
+			s += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(suv, pssm_coord.z, 1.0));
+		}
+
+		return s / float(scene_data.shadow_blocker_count);
+
+	} else {
+		//no blockers found, so no shadow
+		return 1.0;
+	}
+}
+
 #endif //USE_NO_SHADOWS
 
 void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 albedo, float roughness, float metallic, float specular, float p_blob_intensity,
@@ -760,6 +823,13 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 	vec3 shadow_attenuation = vec3(1.0);
 	vec4 color_specular = unpackUnorm4x8(lights.data[idx].color_specular);
 	color_specular.rgb *= attenuation_energy.y;
+	float size_A = 0.0;
+
+	if (lights.data[idx].size > 0.0) {
+
+		float t = lights.data[idx].size / max(0.001, light_length);
+		size_A = max(0.0, 1.0 - 1 / sqrt(1 + t * t));
+	}
 
 #ifdef LIGHT_TRANSMITTANCE_USED
 	float transmittance_z = transmittance_depth; //no transmittance by default
@@ -773,7 +843,7 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 		vec4 v = vec4(vertex, 1.0);
 
 		vec4 splane = (lights.data[idx].shadow_matrix * v);
-		float shadow_len = length(splane.xyz);
+		float shadow_len = length(splane.xyz); //need to remember shadow len from here
 
 		{
 			vec3 nofs = normal_interp * lights.data[idx].shadow_normal_bias / lights.data[idx].inv_radius;
@@ -782,26 +852,126 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 			splane = (lights.data[idx].shadow_matrix * v);
 		}
 
-		splane.xyz = normalize(splane.xyz);
-		vec4 clamp_rect = lights.data[idx].atlas_rect;
+		float shadow;
+
+		if (lights.data[idx].soft_shadow_size > 0.0) {
+			//soft shadow
+
+			//find blocker
+
+			float blocker_count = 0.0;
+			float blocker_average = 0.0;
+
+			mat2 poisson_rotate;
+
+			{
+				float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
+				float sr = sin(r);
+				float cr = cos(r);
+				poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
+			}
+
+			vec3 normal = normalize(splane.xyz);
+			vec3 v0 = abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+			vec3 tangent = normalize(cross(v0, normal));
+			vec3 bitangent = normalize(cross(tangent, normal));
+			float z_norm = shadow_len * lights.data[idx].inv_radius;
+
+			tangent *= lights.data[idx].soft_shadow_size;
+			bitangent *= lights.data[idx].soft_shadow_size;
 
-		if (splane.z >= 0.0) {
+			for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
+				vec2 poisson = (poisson_rotate * shadow_poisson_disk[i]);
+				vec3 pos = splane.xyz + tangent * poisson.x + bitangent * poisson.y;
 
-			splane.z += 1.0;
+				pos = normalize(pos);
+				vec4 uv_rect = lights.data[idx].atlas_rect;
 
-			clamp_rect.y += clamp_rect.w;
+				if (pos.z >= 0.0) {
 
+					pos.z += 1.0;
+					uv_rect.y += uv_rect.w;
+				} else {
+
+					pos.z = 1.0 - pos.z;
+				}
+
+				pos.xy /= pos.z;
+
+				pos.xy = pos.xy * 0.5 + 0.5;
+				pos.xy = uv_rect.xy + pos.xy * uv_rect.zw;
+
+				float d = textureLod(sampler2D(shadow_atlas, material_samplers[SAMPLER_LINEAR_CLAMP]), pos.xy, 0.0).r;
+				if (d < z_norm) {
+					blocker_average += d;
+					blocker_count += 1.0;
+				}
+			}
+
+			if (blocker_count > 0.0) {
+
+				//blockers found, do soft shadow
+				blocker_average /= blocker_count;
+				float penumbra = (z_norm - blocker_average) / blocker_average;
+				tangent *= penumbra;
+				bitangent *= penumbra;
+
+				z_norm -= lights.data[idx].inv_radius * lights.data[idx].shadow_bias;
+
+				shadow = 0.0;
+				for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
+
+					vec2 poisson = (poisson_rotate * shadow_poisson_disk[i]);
+					vec3 pos = splane.xyz + tangent * poisson.x + bitangent * poisson.y;
+
+					pos = normalize(pos);
+					vec4 uv_rect = lights.data[idx].atlas_rect;
+
+					if (pos.z >= 0.0) {
+
+						pos.z += 1.0;
+						uv_rect.y += uv_rect.w;
+					} else {
+
+						pos.z = 1.0 - pos.z;
+					}
+
+					pos.xy /= pos.z;
+
+					pos.xy = pos.xy * 0.5 + 0.5;
+					pos.xy = uv_rect.xy + pos.xy * uv_rect.zw;
+					shadow += textureProj(sampler2DShadow(shadow_atlas, shadow_sampler), vec4(pos.xy, z_norm, 1.0));
+				}
+
+				shadow /= float(scene_data.shadow_blocker_count);
+
+			} else {
+				//no blockers found, so no shadow
+				shadow = 1.0;
+			}
 		} else {
-			splane.z = 1.0 - splane.z;
-		}
 
-		splane.xy /= splane.z;
+			splane.xyz = normalize(splane.xyz);
+			vec4 clamp_rect = lights.data[idx].atlas_rect;
+
+			if (splane.z >= 0.0) {
+
+				splane.z += 1.0;
+
+				clamp_rect.y += clamp_rect.w;
+
+			} else {
+				splane.z = 1.0 - splane.z;
+			}
+
+			splane.xy /= splane.z;
 
-		splane.xy = splane.xy * 0.5 + 0.5;
-		splane.z = (shadow_len - lights.data[idx].shadow_bias) * lights.data[idx].inv_radius;
-		splane.xy = clamp_rect.xy + splane.xy * clamp_rect.zw;
-		splane.w = 1.0; //needed? i think it should be 1 already
-		float shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
+			splane.xy = splane.xy * 0.5 + 0.5;
+			splane.z = (shadow_len - lights.data[idx].shadow_bias) * lights.data[idx].inv_radius;
+			splane.xy = clamp_rect.xy + splane.xy * clamp_rect.zw;
+			splane.w = 1.0; //needed? i think it should be 1 already
+			shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
+		}
 
 #ifdef LIGHT_TRANSMITTANCE_USED
 		{
@@ -836,7 +1006,7 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 	}
 #endif //USE_NO_SHADOWS
 
-	light_compute(normal, normalize(light_rel_vec), eye_vec, color_specular.rgb, light_attenuation, shadow_attenuation, albedo, roughness, metallic, specular, color_specular.a * p_blob_intensity,
+	light_compute(normal, normalize(light_rel_vec), eye_vec, size_A, color_specular.rgb, light_attenuation, shadow_attenuation, albedo, roughness, metallic, specular, color_specular.a * p_blob_intensity,
 #ifdef LIGHT_BACKLIGHT_USED
 			backlight,
 #endif
@@ -903,6 +1073,13 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 	vec4 color_specular = unpackUnorm4x8(lights.data[idx].color_specular);
 	color_specular.rgb *= attenuation_energy.y;
 
+	float size_A = 0.0;
+
+	if (lights.data[idx].size > 0.0) {
+
+		float t = lights.data[idx].size / max(0.001, light_length);
+		size_A = max(0.0, 1.0 - 1 / sqrt(1 + t * t));
+	}
 /*
 	if (lights.data[idx].atlas_rect!=vec4(0.0)) {
 		//use projector texture
@@ -920,22 +1097,82 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 
 		v.xyz -= spot_dir * lights.data[idx].shadow_bias;
 
-		float depth_bias_scale = 1.0 / (max(0.0001, dot(spot_dir, -light_rel_vec) * lights.data[idx].inv_radius)); //the closer to the light origin, the more you have to offset to reach 1px in the map
+		float z_norm = dot(spot_dir, -light_rel_vec) * lights.data[idx].inv_radius;
+
+		float depth_bias_scale = 1.0 / (max(0.0001, z_norm)); //the closer to the light origin, the more you have to offset to reach 1px in the map
 		vec3 normal_bias = normalize(normal_interp) * (1.0 - max(0.0, dot(spot_dir, -normalize(normal_interp)))) * lights.data[idx].shadow_normal_bias * depth_bias_scale;
 		normal_bias -= spot_dir * dot(spot_dir, normal_bias); //only XY, no Z
 		v.xyz += normal_bias;
 
+		//adjust with bias
+		z_norm = dot(spot_dir, v.xyz - lights.data[idx].position) * lights.data[idx].inv_radius;
+
+		float shadow;
+
 		vec4 splane = (lights.data[idx].shadow_matrix * v);
 		splane /= splane.w;
-		splane.z = dot(spot_dir, v.xyz - lights.data[idx].position) * lights.data[idx].inv_radius;
-		float shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
+
+		if (lights.data[idx].soft_shadow_size > 0.0) {
+			//soft shadow
+
+			//find blocker
+
+			float blocker_count = 0.0;
+			float blocker_average = 0.0;
+
+			mat2 poisson_rotate;
+
+			{
+				float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
+				float sr = sin(r);
+				float cr = cos(r);
+				poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
+			}
+
+			float uv_size = lights.data[idx].soft_shadow_size * z_norm;
+			for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
+				vec2 suv = splane.xy + (poisson_rotate * shadow_poisson_disk[i]) * uv_size;
+				suv = clamp(suv, lights.data[idx].atlas_rect.xy, lights.data[idx].atlas_rect.zw);
+				float d = textureLod(sampler2D(shadow_atlas, material_samplers[SAMPLER_LINEAR_CLAMP]), suv, 0.0).r;
+				if (d < z_norm) {
+					blocker_average += d;
+					blocker_count += 1.0;
+				}
+			}
+
+			if (blocker_count > 0.0) {
+
+				//blockers found, do soft shadow
+				blocker_average /= blocker_count;
+				float penumbra = (z_norm - blocker_average) / blocker_average;
+				uv_size *= penumbra;
+
+				shadow = 0.0;
+				for (uint i = 0; i < scene_data.shadow_blocker_count; i++) {
+					vec2 suv = splane.xy + (poisson_rotate * shadow_poisson_disk[i]) * uv_size;
+					suv = clamp(suv, lights.data[idx].atlas_rect.xy, lights.data[idx].atlas_rect.zw);
+					shadow += textureProj(sampler2DShadow(shadow_atlas, shadow_sampler), vec4(suv, z_norm, 1.0));
+				}
+
+				shadow /= float(scene_data.shadow_blocker_count);
+
+			} else {
+				//no blockers found, so no shadow
+				shadow = 1.0;
+			}
+
+		} else {
+			//hard shadow
+			splane.z = z_norm;
+			shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
+		}
 
 		shadow_attenuation = mix(shadow_color_enabled.rgb, vec3(1.0), shadow);
 
 #ifdef LIGHT_TRANSMITTANCE_USED
 		{
 
-			splane = (lights.data[idx].shadow_matrix * vec4(vertex - normalize(normal_interp) * lights.data[idx].transmittance_bias, 1.0));
+			vec4 splane = (lights.data[idx].shadow_matrix * vec4(vertex - normalize(normal_interp) * lights.data[idx].transmittance_bias, 1.0));
 			splane /= splane.w;
 
 			float shadow_z = textureLod(sampler2D(shadow_atlas, material_samplers[SAMPLER_LINEAR_CLAMP]), splane.xy, 0.0).r;
@@ -950,7 +1187,7 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 
 #endif //USE_NO_SHADOWS
 
-	light_compute(normal, normalize(light_rel_vec), eye_vec, color_specular.rgb, light_attenuation, shadow_attenuation, albedo, roughness, metallic, specular, color_specular.a * p_blob_intensity,
+	light_compute(normal, normalize(light_rel_vec), eye_vec, size_A, color_specular.rgb, light_attenuation, shadow_attenuation, albedo, roughness, metallic, specular, color_specular.a * p_blob_intensity,
 #ifdef LIGHT_BACKLIGHT_USED
 			backlight,
 #endif
@@ -1636,13 +1873,28 @@ FRAGMENT_SHADER_CODE
 	normal_bias -= light_dir * dot(light_dir, normal_bias);                                                                                                           \
 	m_var.xyz += normal_bias;
 
+				float shadow = 0.0;
+
 				if (depth_z < directional_lights.data[i].shadow_split_offsets.x) {
 					vec4 v = vec4(vertex, 1.0);
 
 					BIAS_FUNC(v, 0)
 
 					pssm_coord = (directional_lights.data[i].shadow_matrix1 * v);
+					pssm_coord /= pssm_coord.w;
+
+					if (directional_lights.data[i].softshadow_angle > 0) {
+						float range_pos = dot(directional_lights.data[i].direction, v.xyz);
+						float range_begin = directional_lights.data[i].shadow_range_begin.x;
+						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);
+					} else {
+						shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+					}
+
 					shadow_color = directional_lights.data[i].shadow_color1.rgb;
+
 #ifdef LIGHT_TRANSMITTANCE_USED
 					{
 						vec4 trans_vertex = vec4(vertex - normalize(normal_interp) * directional_lights.data[i].shadow_transmittance_bias.x, 1.0);
@@ -1663,6 +1915,18 @@ FRAGMENT_SHADER_CODE
 					BIAS_FUNC(v, 1)
 
 					pssm_coord = (directional_lights.data[i].shadow_matrix2 * v);
+					pssm_coord /= pssm_coord.w;
+
+					if (directional_lights.data[i].softshadow_angle > 0) {
+						float range_pos = dot(directional_lights.data[i].direction, v.xyz);
+						float range_begin = directional_lights.data[i].shadow_range_begin.y;
+						float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
+						vec2 tex_scale = directional_lights.data[i].uv_scale2 * test_radius;
+						shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
+					} else {
+						shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+					}
+
 					shadow_color = directional_lights.data[i].shadow_color2.rgb;
 #ifdef LIGHT_TRANSMITTANCE_USED
 					{
@@ -1684,6 +1948,18 @@ FRAGMENT_SHADER_CODE
 					BIAS_FUNC(v, 2)
 
 					pssm_coord = (directional_lights.data[i].shadow_matrix3 * v);
+					pssm_coord /= pssm_coord.w;
+
+					if (directional_lights.data[i].softshadow_angle > 0) {
+						float range_pos = dot(directional_lights.data[i].direction, v.xyz);
+						float range_begin = directional_lights.data[i].shadow_range_begin.z;
+						float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
+						vec2 tex_scale = directional_lights.data[i].uv_scale3 * test_radius;
+						shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
+					} else {
+						shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+					}
+
 					shadow_color = directional_lights.data[i].shadow_color3.rgb;
 #ifdef LIGHT_TRANSMITTANCE_USED
 					{
@@ -1706,7 +1982,20 @@ FRAGMENT_SHADER_CODE
 					BIAS_FUNC(v, 3)
 
 					pssm_coord = (directional_lights.data[i].shadow_matrix4 * v);
+					pssm_coord /= pssm_coord.w;
+
+					if (directional_lights.data[i].softshadow_angle > 0) {
+						float range_pos = dot(directional_lights.data[i].direction, v.xyz);
+						float range_begin = directional_lights.data[i].shadow_range_begin.w;
+						float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
+						vec2 tex_scale = directional_lights.data[i].uv_scale4 * test_radius;
+						shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
+					} else {
+						shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+					}
+
 					shadow_color = directional_lights.data[i].shadow_color4.rgb;
+
 #ifdef LIGHT_TRANSMITTANCE_USED
 					{
 						vec4 trans_vertex = vec4(vertex - normalize(normal_interp) * directional_lights.data[i].shadow_transmittance_bias.w, 1.0);
@@ -1722,40 +2011,72 @@ FRAGMENT_SHADER_CODE
 #endif
 				}
 
-				pssm_coord /= pssm_coord.w;
-
-				float shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
-
 				if (directional_lights.data[i].blend_splits) {
 
 					vec3 shadow_color_blend = vec3(0.0);
 					float pssm_blend;
+					float shadow2;
 
 					if (depth_z < directional_lights.data[i].shadow_split_offsets.x) {
 						vec4 v = vec4(vertex, 1.0);
 						BIAS_FUNC(v, 1)
 						pssm_coord = (directional_lights.data[i].shadow_matrix2 * v);
+						pssm_coord /= pssm_coord.w;
+
+						if (directional_lights.data[i].softshadow_angle > 0) {
+							float range_pos = dot(directional_lights.data[i].direction, v.xyz);
+							float range_begin = directional_lights.data[i].shadow_range_begin.y;
+							float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
+							vec2 tex_scale = directional_lights.data[i].uv_scale2 * test_radius;
+							shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
+						} else {
+							shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+						}
+
 						pssm_blend = smoothstep(0.0, directional_lights.data[i].shadow_split_offsets.x, depth_z);
 						shadow_color_blend = directional_lights.data[i].shadow_color2.rgb;
 					} else if (depth_z < directional_lights.data[i].shadow_split_offsets.y) {
 						vec4 v = vec4(vertex, 1.0);
 						BIAS_FUNC(v, 2)
 						pssm_coord = (directional_lights.data[i].shadow_matrix3 * v);
+						pssm_coord /= pssm_coord.w;
+
+						if (directional_lights.data[i].softshadow_angle > 0) {
+							float range_pos = dot(directional_lights.data[i].direction, v.xyz);
+							float range_begin = directional_lights.data[i].shadow_range_begin.z;
+							float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
+							vec2 tex_scale = directional_lights.data[i].uv_scale3 * test_radius;
+							shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
+						} else {
+							shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+						}
+
 						pssm_blend = smoothstep(directional_lights.data[i].shadow_split_offsets.x, directional_lights.data[i].shadow_split_offsets.y, depth_z);
+
 						shadow_color_blend = directional_lights.data[i].shadow_color3.rgb;
 					} else if (depth_z < directional_lights.data[i].shadow_split_offsets.z) {
 						vec4 v = vec4(vertex, 1.0);
 						BIAS_FUNC(v, 3)
 						pssm_coord = (directional_lights.data[i].shadow_matrix4 * v);
+						pssm_coord /= pssm_coord.w;
+						if (directional_lights.data[i].softshadow_angle > 0) {
+							float range_pos = dot(directional_lights.data[i].direction, v.xyz);
+							float range_begin = directional_lights.data[i].shadow_range_begin.w;
+							float test_radius = (range_pos - range_begin) * directional_lights.data[i].softshadow_angle;
+							vec2 tex_scale = directional_lights.data[i].uv_scale4 * test_radius;
+							shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale);
+						} else {
+							shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+						}
+
 						pssm_blend = smoothstep(directional_lights.data[i].shadow_split_offsets.y, directional_lights.data[i].shadow_split_offsets.z, depth_z);
 						shadow_color_blend = directional_lights.data[i].shadow_color4.rgb;
 					} else {
 						pssm_blend = 0.0; //if no blend, same coord will be used (divide by z will result in same value, and already cached)
 					}
 
-					pssm_coord /= pssm_coord.w;
+					pssm_blend = sqrt(pssm_blend);
 
-					float shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
 					shadow = mix(shadow, shadow2, pssm_blend);
 					shadow_color = mix(shadow_color, shadow_color_blend, pssm_blend);
 				}
@@ -1767,7 +2088,7 @@ FRAGMENT_SHADER_CODE
 #undef BIAS_FUNC
 			}
 
-			light_compute(normal, directional_lights.data[i].direction, normalize(view), directional_lights.data[i].color * directional_lights.data[i].energy, 1.0, shadow_attenuation, albedo, roughness, metallic, specular, directional_lights.data[i].specular * specular_blob_intensity,
+			light_compute(normal, directional_lights.data[i].direction, normalize(view), directional_lights.data[i].size, directional_lights.data[i].color * directional_lights.data[i].energy, 1.0, shadow_attenuation, albedo, roughness, metallic, specular, directional_lights.data[i].specular * specular_blob_intensity,
 #ifdef LIGHT_BACKLIGHT_USED
 					backlight,
 #endif
diff --git a/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl b/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl
index e3f1e650ed..59f326bc9b 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl
@@ -47,6 +47,11 @@ layout(set = 0, binding = 3, std140) uniform SceneData {
 	bool pancake_shadows;
 	uint shadow_filter_mode;
 
+	uint shadow_blocker_count;
+	uint shadow_pad0;
+	uint shadow_pad1;
+	uint shadow_pad2;
+
 	vec4 ambient_light_color_energy;
 
 	float ambient_color_sky_mix;
@@ -141,17 +146,19 @@ struct LightData { //this structure needs to be as packed as possible
 	vec3 position;
 	float inv_radius;
 	vec3 direction;
+	float size;
 	uint attenuation_energy; //attenuation
 	uint color_specular; //rgb color, a specular (8 bit unorm)
 	uint cone_attenuation_angle; // attenuation and angle, (16bit float)
-	uint mask;
 	uint shadow_color_enabled; //shadow rgb color, a>0.5 enabled (8bit unorm)
 	vec4 atlas_rect; // used for spot
 	mat4 shadow_matrix;
 	float shadow_bias;
 	float shadow_normal_bias;
 	float transmittance_bias;
-	uint pad;
+	float soft_shadow_size; // for spot, it's the size in uv coordinates of the light, for omni it's the span angle
+	uint mask;
+	uint pad[3];
 };
 
 layout(set = 0, binding = 5, std430) buffer Lights {
@@ -180,11 +187,11 @@ struct DirectionalLightData {
 	vec3 direction;
 	float energy;
 	vec3 color;
+	float size;
 	float specular;
 	uint mask;
-	uint pad0;
+	float softshadow_angle;
 	uint pad1;
-	uint pad2;
 	bool blend_splits;
 	bool shadow_enabled;
 	float fade_from;
@@ -193,6 +200,7 @@ struct DirectionalLightData {
 	vec4 shadow_normal_bias;
 	vec4 shadow_transmittance_bias;
 	vec4 shadow_transmittance_z_scale;
+	vec4 shadow_range_begin;
 	vec4 shadow_split_offsets;
 	mat4 shadow_matrix1;
 	mat4 shadow_matrix2;
@@ -202,6 +210,10 @@ struct DirectionalLightData {
 	vec4 shadow_color2;
 	vec4 shadow_color3;
 	vec4 shadow_color4;
+	vec2 uv_scale1;
+	vec2 uv_scale2;
+	vec2 uv_scale3;
+	vec2 uv_scale4;
 };
 
 layout(set = 0, binding = 7, std140) uniform DirectionalLights {