Add proper quality settings to soft shadows

9 files changed, 288 insertions, 124 deletions

diff --git a/servers/rendering/rasterizer.h b/servers/rendering/rasterizer.h
index cf0afe6097..5200136c11 100644
--- a/servers/rendering/rasterizer.h
+++ b/servers/rendering/rasterizer.h
@@ -106,7 +106,8 @@ public:
 	virtual void camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) = 0;
 	virtual void camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) = 0;
 
-	virtual void shadow_filter_set(RS::ShadowFilter p_filter) = 0;
+	virtual void shadows_quality_set(RS::ShadowQuality p_quality) = 0;
+	virtual void directional_shadow_quality_set(RS::ShadowQuality p_quality) = 0;
 
 	struct InstanceBase;
 
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp b/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
index ec05c9e964..9d2a03ac76 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
@@ -77,6 +77,13 @@ static _FORCE_INLINE_ void store_camera(const CameraMatrix &p_mtx, float *p_arra
 	}
 }
 
+static _FORCE_INLINE_ void store_soft_shadow_kernel(const float *p_kernel, float *p_array) {
+
+	for (int i = 0; i < 128; i++) {
+		p_array[i] = p_kernel[i];
+	}
+}
+
 /* SCENE SHADER */
 void RasterizerSceneHighEndRD::ShaderData::set_code(const String &p_code) {
 	//compile
@@ -962,10 +969,18 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, const Camer
 
 	scene_state.ubo.z_far = p_zfar;
 	scene_state.ubo.z_near = p_znear;
-	scene_state.ubo.shadow_filter_mode = shadow_filter_get();
 
 	scene_state.ubo.pancake_shadows = p_pancake_shadows;
-	scene_state.ubo.shadow_blocker_count = 16;
+
+	store_soft_shadow_kernel(directional_penumbra_shadow_kernel_get(), scene_state.ubo.directional_penumbra_shadow_kernel);
+	store_soft_shadow_kernel(directional_soft_shadow_kernel_get(), scene_state.ubo.directional_soft_shadow_kernel);
+	store_soft_shadow_kernel(penumbra_shadow_kernel_get(), scene_state.ubo.penumbra_shadow_kernel);
+	store_soft_shadow_kernel(soft_shadow_kernel_get(), scene_state.ubo.soft_shadow_kernel);
+
+	scene_state.ubo.directional_penumbra_shadow_samples = directional_penumbra_shadow_samples_get();
+	scene_state.ubo.directional_soft_shadow_samples = directional_soft_shadow_samples_get();
+	scene_state.ubo.penumbra_shadow_samples = penumbra_shadow_samples_get();
+	scene_state.ubo.soft_shadow_samples = soft_shadow_samples_get();
 
 	scene_state.ubo.screen_pixel_size[0] = p_screen_pixel_size.x;
 	scene_state.ubo.screen_pixel_size[1] = p_screen_pixel_size.y;
@@ -1585,6 +1600,8 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
 					light_data.fade_from = -light_data.shadow_split_offsets[3] * MIN(fade_start, 0.999); //using 1.0 would break smoothstep
 					light_data.fade_to = -light_data.shadow_split_offsets[3];
 
+					light_data.soft_shadow_scale = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BLUR);
+
 					float softshadow_angle = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
 					if (softshadow_angle > 0.0) {
 						// I know tan(0) is 0, but let's not risk it with numerical precision.
@@ -1593,6 +1610,7 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
 						light_data.softshadow_angle = Math::tan(Math::deg2rad(softshadow_angle));
 					} else {
 						light_data.softshadow_angle = 0;
+						light_data.soft_shadow_scale *= directional_shadow_quality_radius_get(); // Only use quality radius for PCF
 					}
 				}
 
@@ -1703,6 +1721,8 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
 					light_data.atlas_rect[2] = rect.size.width;
 					light_data.atlas_rect[3] = rect.size.height;
 
+					light_data.soft_shadow_scale = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BLUR);
+
 					if (type == RS::LIGHT_OMNI) {
 
 						light_data.atlas_rect[3] *= 0.5; //one paraboloid on top of another
@@ -1715,6 +1735,7 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
 							light_data.soft_shadow_size = size;
 						} else {
 							light_data.soft_shadow_size = 0.0;
+							light_data.soft_shadow_scale *= shadows_quality_radius_get(); // Only use quality radius for PCF
 						}
 
 					} else if (type == RS::LIGHT_SPOT) {
@@ -1738,6 +1759,7 @@ void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_lig
 							light_data.soft_shadow_size = (size * 0.5 / radius) / (half_np / cm.get_z_near()) * rect.size.width;
 						} else {
 							light_data.soft_shadow_size = 0.0;
+							light_data.soft_shadow_scale *= shadows_quality_radius_get(); // Only use quality radius for PCF
 						}
 					}
 				} else {
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h b/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h
index b4f5d25afd..67dd00c27c 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h
@@ -265,8 +265,9 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		float shadow_normal_bias;
 		float transmittance_bias;
 		float soft_shadow_size;
+		float soft_shadow_scale;
 		uint32_t mask;
-		uint32_t pad[3];
+		uint32_t pad[2];
 	};
 
 	struct DirectionalLightData {
@@ -278,7 +279,7 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		float specular;
 		uint32_t mask;
 		float softshadow_angle;
-		uint32_t pad[1];
+		float soft_shadow_scale;
 		uint32_t blend_splits;
 		uint32_t shadow_enabled;
 		float fade_from;
@@ -350,10 +351,17 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 			float reflection_multiplier;
 
 			uint32_t pancake_shadows;
-			uint32_t shadow_filter_mode;
+			uint32_t pad;
+
+			float directional_penumbra_shadow_kernel[128]; //32 vec4s
+			float directional_soft_shadow_kernel[128];
+			float penumbra_shadow_kernel[128];
+			float soft_shadow_kernel[128];
 
-			uint32_t shadow_blocker_count;
-			uint32_t shadow_pad[3];
+			uint32_t directional_penumbra_shadow_samples;
+			uint32_t directional_soft_shadow_samples;
+			uint32_t penumbra_shadow_samples;
+			uint32_t soft_shadow_samples;
 
 			float ambient_light_color_energy[4];
 
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
index a0bbf8bd43..b2a843161b 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
@@ -36,6 +36,18 @@
 
 uint64_t RasterizerSceneRD::auto_exposure_counter = 2;
 
+void get_vogel_disk(float *r_kernel, int p_sample_count) {
+	const float golden_angle = 2.4;
+
+	for (int i = 0; i < p_sample_count; i++) {
+		float r = Math::sqrt(float(i) + 0.5) / Math::sqrt(float(p_sample_count));
+		float theta = float(i) * golden_angle;
+
+		r_kernel[i * 4] = Math::cos(theta) * r;
+		r_kernel[i * 4 + 1] = Math::sin(theta) * r;
+	}
+}
+
 void RasterizerSceneRD::_clear_reflection_data(ReflectionData &rd) {
 
 	rd.layers.clear();
@@ -3583,8 +3595,86 @@ void RasterizerSceneRD::sub_surface_scattering_set_scale(float p_scale, float p_
 	sss_depth_scale = p_depth_scale;
 }
 
-void RasterizerSceneRD::shadow_filter_set(RS::ShadowFilter p_filter) {
-	shadow_filter = p_filter;
+void RasterizerSceneRD::shadows_quality_set(RS::ShadowQuality p_quality) {
+
+	ERR_FAIL_INDEX_MSG(p_quality, RS::SHADOW_QUALITY_MAX, "Shadow quality too high, please see RenderingServer's ShadowQuality enum");
+
+	if (shadows_quality != p_quality) {
+		shadows_quality = p_quality;
+
+		switch (shadows_quality) {
+			case RS::SHADOW_QUALITY_HARD: {
+				penumbra_shadow_samples = 4;
+				soft_shadow_samples = 1;
+				shadows_quality_radius = 1.0;
+			} break;
+			case RS::SHADOW_QUALITY_SOFT_LOW: {
+				penumbra_shadow_samples = 8;
+				soft_shadow_samples = 4;
+				shadows_quality_radius = 2.0;
+			} break;
+			case RS::SHADOW_QUALITY_SOFT_MEDIUM: {
+				penumbra_shadow_samples = 12;
+				soft_shadow_samples = 8;
+				shadows_quality_radius = 2.0;
+			} break;
+			case RS::SHADOW_QUALITY_SOFT_HIGH: {
+				penumbra_shadow_samples = 24;
+				soft_shadow_samples = 16;
+				shadows_quality_radius = 3.0;
+			} break;
+			case RS::SHADOW_QUALITY_SOFT_ULTRA: {
+				penumbra_shadow_samples = 32;
+				soft_shadow_samples = 32;
+				shadows_quality_radius = 4.0;
+			} break;
+			case RS::SHADOW_QUALITY_MAX:
+				break;
+		}
+		get_vogel_disk(penumbra_shadow_kernel, penumbra_shadow_samples);
+		get_vogel_disk(soft_shadow_kernel, soft_shadow_samples);
+	}
+}
+
+void RasterizerSceneRD::directional_shadow_quality_set(RS::ShadowQuality p_quality) {
+
+	ERR_FAIL_INDEX_MSG(p_quality, RS::SHADOW_QUALITY_MAX, "Shadow quality too high, please see RenderingServer's ShadowQuality enum");
+
+	if (directional_shadow_quality != p_quality) {
+		directional_shadow_quality = p_quality;
+
+		switch (directional_shadow_quality) {
+			case RS::SHADOW_QUALITY_HARD: {
+				directional_penumbra_shadow_samples = 4;
+				directional_soft_shadow_samples = 1;
+				directional_shadow_quality_radius = 1.0;
+			} break;
+			case RS::SHADOW_QUALITY_SOFT_LOW: {
+				directional_penumbra_shadow_samples = 8;
+				directional_soft_shadow_samples = 4;
+				directional_shadow_quality_radius = 2.0;
+			} break;
+			case RS::SHADOW_QUALITY_SOFT_MEDIUM: {
+				directional_penumbra_shadow_samples = 12;
+				directional_soft_shadow_samples = 8;
+				directional_shadow_quality_radius = 2.0;
+			} break;
+			case RS::SHADOW_QUALITY_SOFT_HIGH: {
+				directional_penumbra_shadow_samples = 24;
+				directional_soft_shadow_samples = 16;
+				directional_shadow_quality_radius = 3.0;
+			} break;
+			case RS::SHADOW_QUALITY_SOFT_ULTRA: {
+				directional_penumbra_shadow_samples = 32;
+				directional_soft_shadow_samples = 32;
+				directional_shadow_quality_radius = 4.0;
+			} break;
+			case RS::SHADOW_QUALITY_MAX:
+				break;
+		}
+		get_vogel_disk(directional_penumbra_shadow_kernel, directional_penumbra_shadow_samples);
+		get_vogel_disk(directional_soft_shadow_kernel, directional_soft_shadow_samples);
+	}
 }
 
 int RasterizerSceneRD::get_roughness_layers() const {
@@ -4155,7 +4245,12 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 	sss_quality = RS::SubSurfaceScatteringQuality(int(GLOBAL_GET("rendering/quality/subsurface_scattering/subsurface_scattering_quality")));
 	sss_scale = GLOBAL_GET("rendering/quality/subsurface_scattering/subsurface_scattering_scale");
 	sss_depth_scale = GLOBAL_GET("rendering/quality/subsurface_scattering/subsurface_scattering_depth_scale");
-	shadow_filter = RS::ShadowFilter(int(GLOBAL_GET("rendering/quality/shadows/filter_mode")));
+	directional_penumbra_shadow_kernel = memnew_arr(float, 128);
+	directional_soft_shadow_kernel = memnew_arr(float, 128);
+	penumbra_shadow_kernel = memnew_arr(float, 128);
+	soft_shadow_kernel = memnew_arr(float, 128);
+	shadows_quality_set(RS::ShadowQuality(int(GLOBAL_GET("rendering/quality/shadows/soft_shadow_quality"))));
+	directional_shadow_quality_set(RS::ShadowQuality(int(GLOBAL_GET("rendering/quality/directional_shadow/soft_shadow_quality"))));
 }
 
 RasterizerSceneRD::~RasterizerSceneRD() {
@@ -4184,4 +4279,8 @@ RasterizerSceneRD::~RasterizerSceneRD() {
 	memdelete_arr(sky_scene_state.last_frame_directional_lights);
 	storage->free(sky_shader.default_shader);
 	storage->free(sky_shader.default_material);
+	memdelete_arr(directional_penumbra_shadow_kernel);
+	memdelete_arr(directional_soft_shadow_kernel);
+	memdelete_arr(penumbra_shadow_kernel);
+	memdelete_arr(soft_shadow_kernel);
 }
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
index 3478c05fb1..fba2e0df3d 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
@@ -527,7 +527,19 @@ private:
 
 	bool _shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int *p_in_quadrants, int p_quadrant_count, int p_current_subdiv, uint64_t p_tick, int &r_quadrant, int &r_shadow);
 
-	RS::ShadowFilter shadow_filter = RS::SHADOW_FILTER_NONE;
+	RS::ShadowQuality shadows_quality = RS::SHADOW_QUALITY_MAX; //So it always updates when first set
+	RS::ShadowQuality directional_shadow_quality = RS::SHADOW_QUALITY_MAX;
+	float shadows_quality_radius = 1.0;
+	float directional_shadow_quality_radius = 1.0;
+
+	float *directional_penumbra_shadow_kernel;
+	float *directional_soft_shadow_kernel;
+	float *penumbra_shadow_kernel;
+	float *soft_shadow_kernel;
+	int directional_penumbra_shadow_samples = 0;
+	int directional_soft_shadow_samples = 0;
+	int penumbra_shadow_samples = 0;
+	int soft_shadow_samples = 0;
 
 	/* DIRECTIONAL SHADOW */
 
@@ -1177,8 +1189,22 @@ public:
 	RS::SubSurfaceScatteringQuality sub_surface_scattering_get_quality() const;
 	virtual void sub_surface_scattering_set_scale(float p_scale, float p_depth_scale);
 
-	virtual void shadow_filter_set(RS::ShadowFilter p_filter);
-	_FORCE_INLINE_ RS::ShadowFilter shadow_filter_get() const { return shadow_filter; }
+	virtual void shadows_quality_set(RS::ShadowQuality p_quality);
+	virtual void directional_shadow_quality_set(RS::ShadowQuality p_quality);
+	_FORCE_INLINE_ RS::ShadowQuality shadows_quality_get() const { return shadows_quality; }
+	_FORCE_INLINE_ RS::ShadowQuality directional_shadow_quality_get() const { return directional_shadow_quality; }
+	_FORCE_INLINE_ float shadows_quality_radius_get() const { return shadows_quality_radius; }
+	_FORCE_INLINE_ float directional_shadow_quality_radius_get() const { return directional_shadow_quality_radius; }
+
+	_FORCE_INLINE_ float *directional_penumbra_shadow_kernel_get() { return directional_penumbra_shadow_kernel; }
+	_FORCE_INLINE_ float *directional_soft_shadow_kernel_get() { return directional_soft_shadow_kernel; }
+	_FORCE_INLINE_ float *penumbra_shadow_kernel_get() { return penumbra_shadow_kernel; }
+	_FORCE_INLINE_ float *soft_shadow_kernel_get() { return soft_shadow_kernel; }
+
+	_FORCE_INLINE_ int directional_penumbra_shadow_samples_get() const { return directional_penumbra_shadow_samples; }
+	_FORCE_INLINE_ int directional_soft_shadow_samples_get() const { return directional_soft_shadow_samples; }
+	_FORCE_INLINE_ int penumbra_shadow_samples_get() const { return penumbra_shadow_samples; }
+	_FORCE_INLINE_ int soft_shadow_samples_get() const { return soft_shadow_samples; }
 
 	int get_roughness_layers() const;
 	bool is_using_radiance_cubemap_array() const;
diff --git a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
index 70ce8d61e4..71dedc4967 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
@@ -686,61 +686,63 @@ 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) {
+// Produces cheap but low-quality white noise, nothing special
+float quick_hash(vec2 pos) {
+	return fract(sin(dot(pos * 19.19, vec2(49.5791, 97.413))) * 49831.189237);
+}
+
+float sample_directional_pcf_shadow(texture2D shadow, vec2 shadow_pixel_size, vec4 coord) {
 
 	vec2 pos = coord.xy;
 	float depth = coord.z;
 
-	switch (scene_data.shadow_filter_mode) {
-		case SHADOW_MODE_NO_FILTER: {
-			return textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos, depth, 1.0));
-		};
-		case SHADOW_MODE_PCF5: {
-			float avg = textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos, depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(shadow_pixel_size.x, 0.0), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(-shadow_pixel_size.x, 0.0), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(0.0, shadow_pixel_size.y), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(0.0, -shadow_pixel_size.y), depth, 1.0));
-			return avg * (1.0 / 5.0);
-		};
-		case SHADOW_MODE_PCF13: {
-
-			float avg = textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos, depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(shadow_pixel_size.x, 0.0), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(-shadow_pixel_size.x, 0.0), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(0.0, shadow_pixel_size.y), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(0.0, -shadow_pixel_size.y), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(shadow_pixel_size.x, shadow_pixel_size.y), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(-shadow_pixel_size.x, shadow_pixel_size.y), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(shadow_pixel_size.x, -shadow_pixel_size.y), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(-shadow_pixel_size.x, -shadow_pixel_size.y), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(shadow_pixel_size.x * 2.0, 0.0), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(-shadow_pixel_size.x * 2.0, 0.0), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(0.0, shadow_pixel_size.y * 2.0), depth, 1.0));
-			avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + vec2(0.0, -shadow_pixel_size.y * 2.0), depth, 1.0));
-			return avg * (1.0 / 13.0);
-		};
+	//if only one sample is taken, take it from the center
+	if (scene_data.directional_soft_shadow_samples == 1) {
+		return textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos, depth, 1.0));
 	}
 
-	return 0;
+	mat2 disk_rotation;
+	{
+		float r = quick_hash(gl_FragCoord.xy) * 2.0 * M_PI;
+		float sr = sin(r);
+		float cr = cos(r);
+		disk_rotation = mat2(vec2(cr, -sr), vec2(sr, cr));
+	}
+
+	float avg = 0.0;
+
+	for (uint i = 0; i < scene_data.directional_soft_shadow_samples; i++) {
+		avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + shadow_pixel_size * (disk_rotation * scene_data.directional_soft_shadow_kernel[i].xy), depth, 1.0));
+	}
+
+	return avg * (1.0 / float(scene_data.directional_soft_shadow_samples));
+}
+
+float sample_pcf_shadow(texture2D shadow, vec2 shadow_pixel_size, vec4 coord) {
+
+	vec2 pos = coord.xy;
+	float depth = coord.z;
+
+	//if only one sample is taken, take it from the center
+	if (scene_data.soft_shadow_samples == 1) {
+		return textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos, depth, 1.0));
+	}
+
+	mat2 disk_rotation;
+	{
+		float r = quick_hash(gl_FragCoord.xy) * 2.0 * M_PI;
+		float sr = sin(r);
+		float cr = cos(r);
+		disk_rotation = mat2(vec2(cr, -sr), vec2(sr, cr));
+	}
+
+	float avg = 0.0;
+
+	for (uint i = 0; i < scene_data.soft_shadow_samples; i++) {
+		avg += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(pos + shadow_pixel_size * (disk_rotation * scene_data.soft_shadow_kernel[i].xy), depth, 1.0));
+	}
+
+	return avg * (1.0 / float(scene_data.soft_shadow_samples));
 }
 
 float sample_directional_soft_shadow(texture2D shadow, vec3 pssm_coord, vec2 tex_scale) {
@@ -749,17 +751,17 @@ float sample_directional_soft_shadow(texture2D shadow, vec3 pssm_coord, vec2 tex
 	float blocker_count = 0.0;
 	float blocker_average = 0.0;
 
-	mat2 poisson_rotate;
-
+	mat2 disk_rotation;
 	{
-		float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
+		float r = quick_hash(gl_FragCoord.xy) * 2.0 * M_PI;
 		float sr = sin(r);
 		float cr = cos(r);
-		poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
+		disk_rotation = 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;
+	for (uint i = 0; i < scene_data.directional_penumbra_shadow_samples; i++) {
+
+		vec2 suv = pssm_coord.xy + (disk_rotation * scene_data.directional_penumbra_shadow_kernel[i].xy) * tex_scale;
 		float d = textureLod(sampler2D(shadow, material_samplers[SAMPLER_LINEAR_CLAMP]), suv, 0.0).r;
 		if (d < pssm_coord.z) {
 			blocker_average += d;
@@ -775,12 +777,12 @@ float sample_directional_soft_shadow(texture2D shadow, vec3 pssm_coord, vec2 tex
 		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;
+		for (uint i = 0; i < scene_data.directional_penumbra_shadow_samples; i++) {
+			vec2 suv = pssm_coord.xy + (disk_rotation * scene_data.directional_penumbra_shadow_kernel[i].xy) * tex_scale;
 			s += textureProj(sampler2DShadow(shadow, shadow_sampler), vec4(suv, pssm_coord.z, 1.0));
 		}
 
-		return s / float(scene_data.shadow_blocker_count);
+		return s / float(scene_data.directional_penumbra_shadow_samples);
 
 	} else {
 		//no blockers found, so no shadow
@@ -862,13 +864,12 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 			float blocker_count = 0.0;
 			float blocker_average = 0.0;
 
-			mat2 poisson_rotate;
-
+			mat2 disk_rotation;
 			{
-				float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
+				float r = quick_hash(gl_FragCoord.xy) * 2.0 * M_PI;
 				float sr = sin(r);
 				float cr = cos(r);
-				poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
+				disk_rotation = mat2(vec2(cr, -sr), vec2(sr, cr));
 			}
 
 			vec3 normal = normalize(splane.xyz);
@@ -877,12 +878,14 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 			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;
+			tangent *= lights.data[idx].soft_shadow_size * lights.data[idx].soft_shadow_scale;
+			bitangent *= lights.data[idx].soft_shadow_size * lights.data[idx].soft_shadow_scale;
 
-			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;
+			for (uint i = 0; i < scene_data.penumbra_shadow_samples; i++) {
+
+				vec2 disk = disk_rotation * scene_data.penumbra_shadow_kernel[i].xy;
+
+				vec3 pos = splane.xyz + tangent * disk.x + bitangent * disk.y;
 
 				pos = normalize(pos);
 				vec4 uv_rect = lights.data[idx].atlas_rect;
@@ -919,10 +922,10 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 				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++) {
+				for (uint i = 0; i < scene_data.penumbra_shadow_samples; i++) {
 
-					vec2 poisson = (poisson_rotate * shadow_poisson_disk[i]);
-					vec3 pos = splane.xyz + tangent * poisson.x + bitangent * poisson.y;
+					vec2 disk = disk_rotation * scene_data.penumbra_shadow_kernel[i].xy;
+					vec3 pos = splane.xyz + tangent * disk.x + bitangent * disk.y;
 
 					pos = normalize(pos);
 					vec4 uv_rect = lights.data[idx].atlas_rect;
@@ -943,7 +946,7 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 					shadow += textureProj(sampler2DShadow(shadow_atlas, shadow_sampler), vec4(pos.xy, z_norm, 1.0));
 				}
 
-				shadow /= float(scene_data.shadow_blocker_count);
+				shadow /= float(scene_data.penumbra_shadow_samples);
 
 			} else {
 				//no blockers found, so no shadow
@@ -970,7 +973,7 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 			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);
+			shadow = sample_pcf_shadow(shadow_atlas, lights.data[idx].soft_shadow_scale * scene_data.shadow_atlas_pixel_size, splane);
 		}
 
 #ifdef LIGHT_TRANSMITTANCE_USED
@@ -1120,18 +1123,18 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 			float blocker_count = 0.0;
 			float blocker_average = 0.0;
 
-			mat2 poisson_rotate;
-
+			mat2 disk_rotation;
 			{
-				float r = dot(vec2(gl_FragCoord.xy), vec2(131.234, 583.123));
+				float r = quick_hash(gl_FragCoord.xy) * 2.0 * M_PI;
 				float sr = sin(r);
 				float cr = cos(r);
-				poisson_rotate = mat2(vec2(cr, -sr), vec2(sr, cr));
+				disk_rotation = 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;
+			float uv_size = lights.data[idx].soft_shadow_size * z_norm * lights.data[idx].soft_shadow_scale;
+			for (uint i = 0; i < scene_data.penumbra_shadow_samples; i++) {
+
+				vec2 suv = splane.xy + (disk_rotation * scene_data.penumbra_shadow_kernel[i].xy) * 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) {
@@ -1148,13 +1151,13 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 				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;
+				for (uint i = 0; i < scene_data.penumbra_shadow_samples; i++) {
+					vec2 suv = splane.xy + (disk_rotation * scene_data.penumbra_shadow_kernel[i].xy) * 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);
+				shadow /= float(scene_data.penumbra_shadow_samples);
 
 			} else {
 				//no blockers found, so no shadow
@@ -1164,7 +1167,7 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 a
 		} else {
 			//hard shadow
 			splane.z = z_norm;
-			shadow = sample_shadow(shadow_atlas, scene_data.shadow_atlas_pixel_size, splane);
+			shadow = sample_pcf_shadow(shadow_atlas, lights.data[idx].soft_shadow_scale * scene_data.shadow_atlas_pixel_size, splane);
 		}
 
 		shadow_attenuation = mix(shadow_color_enabled.rgb, vec3(1.0), shadow);
@@ -1888,9 +1891,9 @@ FRAGMENT_SHADER_CODE
 						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);
+						shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 					} else {
-						shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+						shadow = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale, pssm_coord);
 					}
 
 					shadow_color = directional_lights.data[i].shadow_color1.rgb;
@@ -1922,9 +1925,9 @@ FRAGMENT_SHADER_CODE
 						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);
+						shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 					} else {
-						shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+						shadow = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale, pssm_coord);
 					}
 
 					shadow_color = directional_lights.data[i].shadow_color2.rgb;
@@ -1955,9 +1958,9 @@ FRAGMENT_SHADER_CODE
 						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);
+						shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 					} else {
-						shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+						shadow = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale, pssm_coord);
 					}
 
 					shadow_color = directional_lights.data[i].shadow_color3.rgb;
@@ -1989,9 +1992,9 @@ FRAGMENT_SHADER_CODE
 						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);
+						shadow = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 					} else {
-						shadow = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+						shadow = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale, pssm_coord);
 					}
 
 					shadow_color = directional_lights.data[i].shadow_color4.rgb;
@@ -2028,9 +2031,9 @@ FRAGMENT_SHADER_CODE
 							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);
+							shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 						} else {
-							shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+							shadow2 = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale, pssm_coord);
 						}
 
 						pssm_blend = smoothstep(0.0, directional_lights.data[i].shadow_split_offsets.x, depth_z);
@@ -2046,9 +2049,9 @@ FRAGMENT_SHADER_CODE
 							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);
+							shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 						} else {
-							shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+							shadow2 = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale, pssm_coord);
 						}
 
 						pssm_blend = smoothstep(directional_lights.data[i].shadow_split_offsets.x, directional_lights.data[i].shadow_split_offsets.y, depth_z);
@@ -2064,9 +2067,9 @@ FRAGMENT_SHADER_CODE
 							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);
+							shadow2 = sample_directional_soft_shadow(directional_shadow_atlas, pssm_coord.xyz, tex_scale * directional_lights.data[i].soft_shadow_scale);
 						} else {
-							shadow2 = sample_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size, pssm_coord);
+							shadow2 = sample_directional_pcf_shadow(directional_shadow_atlas, scene_data.directional_shadow_pixel_size * directional_lights.data[i].soft_shadow_scale, pssm_coord);
 						}
 
 						pssm_blend = smoothstep(directional_lights.data[i].shadow_split_offsets.y, directional_lights.data[i].shadow_split_offsets.z, depth_z);
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 59f326bc9b..db11e4b005 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl
@@ -22,10 +22,6 @@ draw_call;
 #define SAMPLER_NEAREST_WITH_MIPMAPS_ANISOTROPIC_REPEAT 10
 #define SAMPLER_LINEAR_WITH_MIPMAPS_ANISOTROPIC_REPEAT 11
 
-#define SHADOW_MODE_NO_FILTER 0
-#define SHADOW_MODE_PCF5 1
-#define SHADOW_MODE_PCF13 2
-
 layout(set = 0, binding = 1) uniform sampler material_samplers[12];
 
 layout(set = 0, binding = 2) uniform sampler shadow_sampler;
@@ -45,12 +41,18 @@ layout(set = 0, binding = 3, std140) uniform SceneData {
 	float reflection_multiplier; // one normally, zero when rendering reflections
 
 	bool pancake_shadows;
-	uint shadow_filter_mode;
+	uint pad;
+
+	//use vec4s because std140 doesnt play nice with vec2s, z and w are wasted
+	vec4 directional_penumbra_shadow_kernel[32];
+	vec4 directional_soft_shadow_kernel[32];
+	vec4 penumbra_shadow_kernel[32];
+	vec4 soft_shadow_kernel[32];
 
-	uint shadow_blocker_count;
-	uint shadow_pad0;
-	uint shadow_pad1;
-	uint shadow_pad2;
+	uint directional_penumbra_shadow_samples;
+	uint directional_soft_shadow_samples;
+	uint penumbra_shadow_samples;
+	uint soft_shadow_samples;
 
 	vec4 ambient_light_color_energy;
 
@@ -157,8 +159,9 @@ struct LightData { //this structure needs to be as packed as possible
 	float shadow_normal_bias;
 	float transmittance_bias;
 	float soft_shadow_size; // for spot, it's the size in uv coordinates of the light, for omni it's the span angle
+	float soft_shadow_scale; // scales the shadow kernel for blurrier shadows
 	uint mask;
-	uint pad[3];
+	uint pad[2];
 };
 
 layout(set = 0, binding = 5, std430) buffer Lights {
@@ -191,7 +194,7 @@ struct DirectionalLightData {
 	float specular;
 	uint mask;
 	float softshadow_angle;
-	uint pad1;
+	float soft_shadow_scale;
 	bool blend_splits;
 	bool shadow_enabled;
 	float fade_from;
diff --git a/servers/rendering/rendering_server_raster.h b/servers/rendering/rendering_server_raster.h
index 1162946796..a3b66ec99a 100644
--- a/servers/rendering/rendering_server_raster.h
+++ b/servers/rendering/rendering_server_raster.h
@@ -554,7 +554,8 @@ public:
 	BIND8(camera_effects_set_dof_blur, RID, bool, float, float, bool, float, float, float)
 	BIND3(camera_effects_set_custom_exposure, RID, bool, float)
 
-	BIND1(shadow_filter_set, ShadowFilter)
+	BIND1(shadows_quality_set, ShadowQuality);
+	BIND1(directional_shadow_quality_set, ShadowQuality);
 
 	/* SCENARIO API */
 
diff --git a/servers/rendering/rendering_server_wrap_mt.h b/servers/rendering/rendering_server_wrap_mt.h
index a3077980ce..944edf4398 100644
--- a/servers/rendering/rendering_server_wrap_mt.h
+++ b/servers/rendering/rendering_server_wrap_mt.h
@@ -467,7 +467,8 @@ public:
 	FUNC8(camera_effects_set_dof_blur, RID, bool, float, float, bool, float, float, float)
 	FUNC3(camera_effects_set_custom_exposure, RID, bool, float)
 
-	FUNC1(shadow_filter_set, ShadowFilter)
+	FUNC1(shadows_quality_set, ShadowQuality);
+	FUNC1(directional_shadow_quality_set, ShadowQuality);
 
 	FUNCRID(scenario)