1 files changed, 55 insertions, 267 deletions

diff --git a/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp b/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
index f4afa8fb12..09d2c032a8 100644
--- a/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
@@ -1611,8 +1611,8 @@ void RendererSceneRenderRD::_pre_process_gi(RID p_render_buffers, const Transfor
 				lights[idx].has_shadow = storage->light_has_shadow(li->light);
 				lights[idx].attenuation = storage->light_get_param(li->light, RS::LIGHT_PARAM_ATTENUATION);
 				lights[idx].radius = storage->light_get_param(li->light, RS::LIGHT_PARAM_RANGE);
-				lights[idx].spot_angle = Math::deg2rad(storage->light_get_param(li->light, RS::LIGHT_PARAM_SPOT_ANGLE));
-				lights[idx].spot_attenuation = storage->light_get_param(li->light, RS::LIGHT_PARAM_SPOT_ATTENUATION);
+				lights[idx].cos_spot_angle = Math::cos(Math::deg2rad(storage->light_get_param(li->light, RS::LIGHT_PARAM_SPOT_ANGLE)));
+				lights[idx].inv_spot_attenuation = 1.0f / storage->light_get_param(li->light, RS::LIGHT_PARAM_SPOT_ATTENUATION);
 
 				idx++;
 			}
@@ -3151,7 +3151,7 @@ float RendererSceneRenderRD::environment_get_fog_aerial_perspective(RID p_env) c
 	return env->fog_aerial_perspective;
 }
 
-void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, RenderingServer::EnvVolumetricFogShadowFilter p_shadow_filter) {
+void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, bool p_temporal_reprojection, float p_temporal_reprojection_amount) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 
@@ -3165,8 +3165,9 @@ void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_ena
 	env->volumetric_fog_light_energy = p_light_energy;
 	env->volumetric_fog_length = p_length;
 	env->volumetric_fog_detail_spread = p_detail_spread;
-	env->volumetric_fog_shadow_filter = p_shadow_filter;
 	env->volumetric_fog_gi_inject = p_gi_inject;
+	env->volumetric_fog_temporal_reprojection = p_temporal_reprojection;
+	env->volumetric_fog_temporal_reprojection_amount = p_temporal_reprojection_amount;
 }
 
 void RendererSceneRenderRD::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) {
@@ -3177,25 +3178,6 @@ void RendererSceneRenderRD::environment_set_volumetric_fog_volume_size(int p_siz
 void RendererSceneRenderRD::environment_set_volumetric_fog_filter_active(bool p_enable) {
 	volumetric_fog_filter_active = p_enable;
 }
-void RendererSceneRenderRD::environment_set_volumetric_fog_directional_shadow_shrink_size(int p_shrink_size) {
-	p_shrink_size = nearest_power_of_2_templated(p_shrink_size);
-	if (volumetric_fog_directional_shadow_shrink == (uint32_t)p_shrink_size) {
-		return;
-	}
-
-	_clear_shadow_shrink_stages(directional_shadow.shrink_stages);
-}
-void RendererSceneRenderRD::environment_set_volumetric_fog_positional_shadow_shrink_size(int p_shrink_size) {
-	p_shrink_size = nearest_power_of_2_templated(p_shrink_size);
-	if (volumetric_fog_positional_shadow_shrink == (uint32_t)p_shrink_size) {
-		return;
-	}
-
-	for (uint32_t i = 0; i < shadow_atlas_owner.get_rid_count(); i++) {
-		ShadowAtlas *sa = shadow_atlas_owner.get_ptr_by_index(i);
-		_clear_shadow_shrink_stages(sa->shrink_stages);
-	}
-}
 
 void RendererSceneRenderRD::environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) {
 	sdfgi_ray_count = p_ray_count;
@@ -3647,7 +3629,6 @@ void RendererSceneRenderRD::shadow_atlas_set_size(RID p_atlas, int p_size, bool
 	if (shadow_atlas->depth.is_valid()) {
 		RD::get_singleton()->free(shadow_atlas->depth);
 		shadow_atlas->depth = RID();
-		_clear_shadow_shrink_stages(shadow_atlas->shrink_stages);
 	}
 	for (int i = 0; i < 4; i++) {
 		//clear subdivisions
@@ -3946,7 +3927,6 @@ void RendererSceneRenderRD::directional_shadow_atlas_set_size(int p_size, bool p
 
 	if (directional_shadow.depth.is_valid()) {
 		RD::get_singleton()->free(directional_shadow.depth);
-		_clear_shadow_shrink_stages(directional_shadow.shrink_stages);
 		directional_shadow.depth = RID();
 		_base_uniforms_changed();
 	}
@@ -4559,8 +4539,8 @@ void RendererSceneRenderRD::gi_probe_update(RID p_probe, bool p_update_light_ins
 				l.color[1] = color.g;
 				l.color[2] = color.b;
 
-				l.spot_angle_radians = Math::deg2rad(storage->light_get_param(light, RS::LIGHT_PARAM_SPOT_ANGLE));
-				l.spot_attenuation = storage->light_get_param(light, RS::LIGHT_PARAM_SPOT_ATTENUATION);
+				l.cos_spot_angle = Math::cos(Math::deg2rad(storage->light_get_param(light, RS::LIGHT_PARAM_SPOT_ANGLE)));
+				l.inv_spot_attenuation = 1.0f / storage->light_get_param(light, RS::LIGHT_PARAM_SPOT_ATTENUATION);
 
 				Transform xform = light_instance_get_base_transform(light_instance);
 
@@ -6226,7 +6206,7 @@ void RendererSceneRenderRD::_setup_reflections(const PagedArray<RID> &p_reflecti
 	}
 
 	if (cluster.reflection_count) {
-		RD::get_singleton()->buffer_update(cluster.reflection_buffer, 0, cluster.reflection_count * sizeof(ReflectionData), cluster.reflections, 0); //no barriers for now
+		RD::get_singleton()->buffer_update(cluster.reflection_buffer, 0, cluster.reflection_count * sizeof(ReflectionData), cluster.reflections, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
 	}
 }
 
@@ -6478,8 +6458,6 @@ void RendererSceneRenderRD::_setup_lights(const PagedArray<RID> &p_lights, const
 		LightInstance *li = (i < cluster.omni_light_count) ? cluster.omni_light_sort[index].instance : cluster.spot_light_sort[index].instance;
 		RID base = li->light;
 
-		cluster.lights_instances[i] = li->self;
-
 		Transform light_transform = li->transform;
 
 		float sign = storage->light_is_negative(base) ? -1 : 1;
@@ -6513,9 +6491,9 @@ void RendererSceneRenderRD::_setup_lights(const PagedArray<RID> &p_lights, const
 
 		light_data.size = size;
 
-		light_data.cone_attenuation = storage->light_get_param(base, RS::LIGHT_PARAM_SPOT_ATTENUATION);
+		light_data.inv_spot_attenuation = 1.0f / storage->light_get_param(base, RS::LIGHT_PARAM_SPOT_ATTENUATION);
 		float spot_angle = storage->light_get_param(base, RS::LIGHT_PARAM_SPOT_ANGLE);
-		light_data.cone_angle = Math::cos(Math::deg2rad(spot_angle));
+		light_data.cos_spot_angle = Math::cos(Math::deg2rad(spot_angle));
 
 		light_data.mask = storage->light_get_cull_mask(base);
 
@@ -6620,15 +6598,15 @@ void RendererSceneRenderRD::_setup_lights(const PagedArray<RID> &p_lights, const
 
 	//update without barriers
 	if (cluster.omni_light_count) {
-		RD::get_singleton()->buffer_update(cluster.omni_light_buffer, 0, sizeof(Cluster::LightData) * cluster.omni_light_count, cluster.omni_lights, 0);
+		RD::get_singleton()->buffer_update(cluster.omni_light_buffer, 0, sizeof(Cluster::LightData) * cluster.omni_light_count, cluster.omni_lights, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
 	}
 
 	if (cluster.spot_light_count) {
-		RD::get_singleton()->buffer_update(cluster.spot_light_buffer, 0, sizeof(Cluster::LightData) * cluster.spot_light_count, cluster.spot_lights, 0);
+		RD::get_singleton()->buffer_update(cluster.spot_light_buffer, 0, sizeof(Cluster::LightData) * cluster.spot_light_count, cluster.spot_lights, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
 	}
 
 	if (r_directional_light_count) {
-		RD::get_singleton()->buffer_update(cluster.directional_light_buffer, 0, sizeof(Cluster::DirectionalLightData) * r_directional_light_count, cluster.directional_lights, 0);
+		RD::get_singleton()->buffer_update(cluster.directional_light_buffer, 0, sizeof(Cluster::DirectionalLightData) * r_directional_light_count, cluster.directional_lights, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
 	}
 }
 
@@ -6789,13 +6767,14 @@ void RendererSceneRenderRD::_setup_decals(const PagedArray<RID> &p_decals, const
 	}
 
 	if (cluster.decal_count > 0) {
-		RD::get_singleton()->buffer_update(cluster.decal_buffer, 0, sizeof(Cluster::DecalData) * cluster.decal_count, cluster.decals);
+		RD::get_singleton()->buffer_update(cluster.decal_buffer, 0, sizeof(Cluster::DecalData) * cluster.decal_count, cluster.decals, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
 	}
 }
 
 void RendererSceneRenderRD::_volumetric_fog_erase(RenderBuffers *rb) {
 	ERR_FAIL_COND(!rb->volumetric_fog);
 
+	RD::get_singleton()->free(rb->volumetric_fog->prev_light_density_map);
 	RD::get_singleton()->free(rb->volumetric_fog->light_density_map);
 	RD::get_singleton()->free(rb->volumetric_fog->fog_map);
 
@@ -6817,49 +6796,6 @@ void RendererSceneRenderRD::_volumetric_fog_erase(RenderBuffers *rb) {
 	rb->volumetric_fog = nullptr;
 }
 
-void RendererSceneRenderRD::_allocate_shadow_shrink_stages(RID p_base, int p_base_size, Vector<ShadowShrinkStage> &shrink_stages, uint32_t p_target_size) {
-	//create fog mipmaps
-	uint32_t fog_texture_size = p_target_size;
-	uint32_t base_texture_size = p_base_size;
-
-	ShadowShrinkStage first;
-	first.size = base_texture_size;
-	first.texture = p_base;
-	shrink_stages.push_back(first); //put depth first in case we dont find smaller ones
-
-	while (fog_texture_size < base_texture_size) {
-		base_texture_size = MAX(base_texture_size / 8, fog_texture_size);
-
-		ShadowShrinkStage s;
-		s.size = base_texture_size;
-
-		RD::TextureFormat tf;
-		tf.format = RD::DATA_FORMAT_R16_UNORM;
-		tf.width = base_texture_size;
-		tf.height = base_texture_size;
-		tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT;
-
-		if (base_texture_size == fog_texture_size) {
-			s.filter_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
-			tf.usage_bits |= RD::TEXTURE_USAGE_SAMPLING_BIT;
-		}
-
-		s.texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
-
-		shrink_stages.push_back(s);
-	}
-}
-
-void RendererSceneRenderRD::_clear_shadow_shrink_stages(Vector<ShadowShrinkStage> &shrink_stages) {
-	for (int i = 1; i < shrink_stages.size(); i++) {
-		RD::get_singleton()->free(shrink_stages[i].texture);
-		if (shrink_stages[i].filter_texture.is_valid()) {
-			RD::get_singleton()->free(shrink_stages[i].filter_texture);
-		}
-	}
-	shrink_stages.clear();
-}
-
 void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_environment, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, RID p_shadow_atlas, int p_directional_light_count, bool p_use_directional_shadows, int p_positional_light_count, int p_gi_probe_count) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
@@ -6897,11 +6833,16 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 		tf.height = target_height;
 		tf.depth = volumetric_fog_depth;
 		tf.texture_type = RD::TEXTURE_TYPE_3D;
-		tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT;
+		tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
 
 		rb->volumetric_fog->light_density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
 
-		tf.usage_bits |= RD::TEXTURE_USAGE_SAMPLING_BIT;
+		tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
+
+		rb->volumetric_fog->prev_light_density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
+		RD::get_singleton()->texture_clear(rb->volumetric_fog->prev_light_density_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
+
+		tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
 
 		rb->volumetric_fog->fog_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
 		_render_buffers_uniform_set_changed(p_render_buffers);
@@ -6918,173 +6859,6 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 		rb->volumetric_fog->sky_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, sky_shader.default_shader_rd, SKY_SET_FOG);
 	}
 
-	//update directional shadow
-
-	RENDER_TIMESTAMP("Downsample Shadows");
-
-	if (p_use_directional_shadows) {
-		RD::get_singleton()->draw_command_begin_label("Downsample Directional Shadows");
-
-		if (directional_shadow.shrink_stages.is_empty()) {
-			if (rb->volumetric_fog->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->uniform_set)) {
-				//invalidate uniform set, we will need a new one
-				RD::get_singleton()->free(rb->volumetric_fog->uniform_set);
-				rb->volumetric_fog->uniform_set = RID();
-			}
-			_allocate_shadow_shrink_stages(directional_shadow.depth, directional_shadow.size, directional_shadow.shrink_stages, volumetric_fog_directional_shadow_shrink);
-		}
-
-		if (directional_shadow.shrink_stages.size() > 1) {
-			RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
-			for (int i = 1; i < directional_shadow.shrink_stages.size(); i++) {
-				int32_t src_size = directional_shadow.shrink_stages[i - 1].size;
-				int32_t dst_size = directional_shadow.shrink_stages[i].size;
-				Rect2i r(0, 0, src_size, src_size);
-				int32_t shrink_limit = 8 / (src_size / dst_size);
-
-				storage->get_effects()->reduce_shadow(directional_shadow.shrink_stages[i - 1].texture, directional_shadow.shrink_stages[i].texture, Size2i(src_size, src_size), r, shrink_limit, compute_list);
-				RD::get_singleton()->compute_list_add_barrier(compute_list);
-				if (env->volumetric_fog_shadow_filter != RS::ENV_VOLUMETRIC_FOG_SHADOW_FILTER_DISABLED && directional_shadow.shrink_stages[i].filter_texture.is_valid()) {
-					Rect2i rf(0, 0, dst_size, dst_size);
-					storage->get_effects()->filter_shadow(directional_shadow.shrink_stages[i].texture, directional_shadow.shrink_stages[i].filter_texture, Size2i(dst_size, dst_size), rf, env->volumetric_fog_shadow_filter, compute_list);
-				}
-			}
-			RD::get_singleton()->compute_list_end();
-		}
-		RD::get_singleton()->draw_command_end_label();
-	}
-
-	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
-
-	if (shadow_atlas) {
-		//shrink shadows that need to be shrunk
-
-		RD::get_singleton()->draw_command_begin_label("Downsample Positional Shadows");
-
-		bool force_shrink_shadows = false;
-
-		if (shadow_atlas->shrink_stages.is_empty()) {
-			if (rb->volumetric_fog->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->uniform_set)) {
-				//invalidate uniform set, we will need a new one
-				RD::get_singleton()->free(rb->volumetric_fog->uniform_set);
-				rb->volumetric_fog->uniform_set = RID();
-			}
-			_allocate_shadow_shrink_stages(shadow_atlas->depth, shadow_atlas->size, shadow_atlas->shrink_stages, volumetric_fog_positional_shadow_shrink);
-			force_shrink_shadows = true;
-		}
-
-		if (rb->volumetric_fog->last_shadow_filter != env->volumetric_fog_shadow_filter) {
-			//if shadow filter changed, invalidate caches
-			rb->volumetric_fog->last_shadow_filter = env->volumetric_fog_shadow_filter;
-			force_shrink_shadows = true;
-		}
-
-		cluster.lights_shadow_rect_cache_count = 0;
-
-		for (uint32_t i = 0; i < cluster.omni_light_count + cluster.spot_light_count; i++) {
-			Cluster::LightData &ld = i < cluster.omni_light_count ? cluster.omni_lights[i] : cluster.spot_lights[i - cluster.omni_light_count];
-
-			if (ld.shadow_enabled != 0) {
-				RID li = cluster.lights_instances[i];
-
-				ERR_CONTINUE(!shadow_atlas->shadow_owners.has(li));
-
-				uint32_t key = shadow_atlas->shadow_owners[li];
-
-				uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
-				uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
-
-				ERR_CONTINUE((int)shadow >= shadow_atlas->quadrants[quadrant].shadows.size());
-
-				ShadowAtlas::Quadrant::Shadow &s = shadow_atlas->quadrants[quadrant].shadows.write[shadow];
-
-				if (!force_shrink_shadows && s.fog_version == s.version) {
-					continue; //do not update, no need
-				}
-
-				s.fog_version = s.version;
-
-				uint32_t quadrant_size = shadow_atlas->size >> 1;
-
-				Rect2i atlas_rect;
-
-				atlas_rect.position.x = (quadrant & 1) * quadrant_size;
-				atlas_rect.position.y = (quadrant >> 1) * quadrant_size;
-
-				uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
-				atlas_rect.position.x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
-				atlas_rect.position.y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
-
-				atlas_rect.size.x = shadow_size;
-				atlas_rect.size.y = shadow_size;
-
-				cluster.lights_shadow_rect_cache[cluster.lights_shadow_rect_cache_count] = atlas_rect;
-
-				cluster.lights_shadow_rect_cache_count++;
-
-				if (cluster.lights_shadow_rect_cache_count == cluster.max_lights * 2) {
-					break; //light limit reached
-				}
-			}
-		}
-
-		if (cluster.lights_shadow_rect_cache_count > 0) {
-			//there are shadows to be shrunk, try to do them in parallel
-			RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
-
-			for (int i = 1; i < shadow_atlas->shrink_stages.size(); i++) {
-				int32_t base_size = shadow_atlas->shrink_stages[0].size;
-				int32_t src_size = shadow_atlas->shrink_stages[i - 1].size;
-				int32_t dst_size = shadow_atlas->shrink_stages[i].size;
-
-				uint32_t rect_divisor = base_size / src_size;
-
-				int32_t shrink_limit = 8 / (src_size / dst_size);
-
-				//shrink in parallel for more performance
-				for (uint32_t j = 0; j < cluster.lights_shadow_rect_cache_count; j++) {
-					Rect2i src_rect = cluster.lights_shadow_rect_cache[j];
-
-					src_rect.position /= rect_divisor;
-					src_rect.size /= rect_divisor;
-
-					storage->get_effects()->reduce_shadow(shadow_atlas->shrink_stages[i - 1].texture, shadow_atlas->shrink_stages[i].texture, Size2i(src_size, src_size), src_rect, shrink_limit, compute_list);
-				}
-
-				RD::get_singleton()->compute_list_add_barrier(compute_list);
-
-				if (env->volumetric_fog_shadow_filter != RS::ENV_VOLUMETRIC_FOG_SHADOW_FILTER_DISABLED && shadow_atlas->shrink_stages[i].filter_texture.is_valid()) {
-					uint32_t filter_divisor = base_size / dst_size;
-
-					//filter in parallel for more performance
-					for (uint32_t j = 0; j < cluster.lights_shadow_rect_cache_count; j++) {
-						Rect2i dst_rect = cluster.lights_shadow_rect_cache[j];
-
-						dst_rect.position /= filter_divisor;
-						dst_rect.size /= filter_divisor;
-
-						storage->get_effects()->filter_shadow(shadow_atlas->shrink_stages[i].texture, shadow_atlas->shrink_stages[i].filter_texture, Size2i(dst_size, dst_size), dst_rect, env->volumetric_fog_shadow_filter, compute_list, true, false);
-					}
-
-					RD::get_singleton()->compute_list_add_barrier(compute_list);
-
-					for (uint32_t j = 0; j < cluster.lights_shadow_rect_cache_count; j++) {
-						Rect2i dst_rect = cluster.lights_shadow_rect_cache[j];
-
-						dst_rect.position /= filter_divisor;
-						dst_rect.size /= filter_divisor;
-
-						storage->get_effects()->filter_shadow(shadow_atlas->shrink_stages[i].texture, shadow_atlas->shrink_stages[i].filter_texture, Size2i(dst_size, dst_size), dst_rect, env->volumetric_fog_shadow_filter, compute_list, false, true);
-					}
-				}
-			}
-
-			RD::get_singleton()->compute_list_end(RD::BARRIER_MASK_COMPUTE);
-		}
-
-		RD::get_singleton()->draw_command_end_label();
-	}
-
 	//update volumetric fog
 
 	if (rb->volumetric_fog->uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->uniform_set)) {
@@ -7096,10 +6870,11 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 			RD::Uniform u;
 			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1;
-			if (shadow_atlas == nullptr || shadow_atlas->shrink_stages.size() == 0) {
+			ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+			if (shadow_atlas == nullptr || shadow_atlas->depth.is_null()) {
 				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK));
 			} else {
-				u.ids.push_back(shadow_atlas->shrink_stages[shadow_atlas->shrink_stages.size() - 1].texture);
+				u.ids.push_back(shadow_atlas->depth);
 			}
 
 			uniforms.push_back(u);
@@ -7109,10 +6884,10 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 			RD::Uniform u;
 			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 2;
-			if (directional_shadow.shrink_stages.size() == 0) {
-				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK));
+			if (directional_shadow.depth.is_valid()) {
+				u.ids.push_back(directional_shadow.depth);
 			} else {
-				u.ids.push_back(directional_shadow.shrink_stages[directional_shadow.shrink_stages.size() - 1].texture);
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK));
 			}
 			uniforms.push_back(u);
 		}
@@ -7211,6 +6986,13 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 			u.ids.push_back(volumetric_fog.params_ubo);
 			uniforms.push_back(u);
 		}
+		{
+			RD::Uniform u;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+			u.binding = 15;
+			u.ids.push_back(rb->volumetric_fog->prev_light_density_map);
+			uniforms.push_back(u);
+		}
 
 		rb->volumetric_fog->uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.shader.version_get_shader(volumetric_fog.shader_version, 0), 0);
 
@@ -7312,6 +7094,13 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 	params.cam_rotation[11] = 0;
 	params.filter_axis = 0;
 	params.max_gi_probes = env->volumetric_fog_gi_inject > 0.001 ? p_gi_probe_count : 0;
+	params.temporal_frame = RSG::rasterizer->get_frame_number() % VolumetricFog::MAX_TEMPORAL_FRAMES;
+
+	Transform to_prev_cam_view = rb->volumetric_fog->prev_cam_transform.affine_inverse() * p_cam_transform;
+	storage->store_transform(to_prev_cam_view, params.to_prev_view);
+
+	params.use_temporal_reprojection = env->volumetric_fog_temporal_reprojection;
+	params.temporal_blend = env->volumetric_fog_temporal_reprojection_amount;
 
 	{
 		uint32_t cluster_size = rb->cluster_builder->get_cluster_size();
@@ -7351,7 +7140,12 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 	RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
 
 	RD::get_singleton()->draw_command_end_label();
-	RD::get_singleton()->compute_list_add_barrier(compute_list);
+
+	RD::get_singleton()->compute_list_end();
+
+	RD::get_singleton()->texture_copy(rb->volumetric_fog->light_density_map, rb->volumetric_fog->prev_light_density_map, Vector3(0, 0, 0), Vector3(0, 0, 0), Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), 0, 0, 0, 0);
+
+	compute_list = RD::get_singleton()->compute_list_begin();
 
 	if (use_filter) {
 		RD::get_singleton()->draw_command_begin_label("Filter Fog");
@@ -7392,6 +7186,8 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 
 	RENDER_TIMESTAMP("<Volumetric Fog");
 	RD::get_singleton()->draw_command_end_label();
+
+	rb->volumetric_fog->prev_cam_transform = p_cam_transform;
 }
 
 uint32_t RendererSceneRenderRD::_get_render_state_directional_light_count() const {
@@ -7513,6 +7309,9 @@ void RendererSceneRenderRD::_pre_opaque_render(bool p_use_ssao, bool p_use_gi, R
 		}
 	}
 
+	//full barrier here, we need raster, transfer and compute and it depends from the previous work
+	RD::get_singleton()->barrier(RD::BARRIER_MASK_ALL, RD::BARRIER_MASK_ALL);
+
 	if (current_cluster_builder) {
 		current_cluster_builder->begin(render_state.cam_transform, render_state.cam_projection, !render_state.reflection_probe.is_valid());
 	}
@@ -7535,9 +7334,6 @@ void RendererSceneRenderRD::_pre_opaque_render(bool p_use_ssao, bool p_use_gi, R
 
 	render_state.directional_light_count = directional_light_count;
 
-	//full barrier here, we need raster, transfer and compute and it depends from the previous work
-	RD::get_singleton()->barrier(RD::BARRIER_MASK_ALL, RD::BARRIER_MASK_ALL);
-
 	if (current_cluster_builder) {
 		current_cluster_builder->bake_cluster();
 	}
@@ -8298,8 +8094,8 @@ void RendererSceneRenderRD::_render_sdfgi_static_lights(RID p_render_buffers, ui
 				lights[idx].has_shadow = storage->light_has_shadow(li->light);
 				lights[idx].attenuation = storage->light_get_param(li->light, RS::LIGHT_PARAM_ATTENUATION);
 				lights[idx].radius = storage->light_get_param(li->light, RS::LIGHT_PARAM_RANGE);
-				lights[idx].spot_angle = Math::deg2rad(storage->light_get_param(li->light, RS::LIGHT_PARAM_SPOT_ANGLE));
-				lights[idx].spot_attenuation = storage->light_get_param(li->light, RS::LIGHT_PARAM_SPOT_ATTENUATION);
+				lights[idx].cos_spot_angle = Math::cos(Math::deg2rad(storage->light_get_param(li->light, RS::LIGHT_PARAM_SPOT_ANGLE)));
+				lights[idx].inv_spot_attenuation = 1.0f / storage->light_get_param(li->light, RS::LIGHT_PARAM_SPOT_ATTENUATION);
 
 				idx++;
 			}
@@ -9050,10 +8846,6 @@ RendererSceneRenderRD::RendererSceneRenderRD(RendererStorageRD *p_storage) {
 		cluster.spot_light_sort = memnew_arr(Cluster::InstanceSort<LightInstance>, cluster.max_lights);
 		//defines += "\n#define MAX_LIGHT_DATA_STRUCTS " + itos(cluster.max_lights) + "\n";
 
-		//used for volumetric fog shrinking
-		cluster.lights_instances = memnew_arr(RID, cluster.max_lights * 2);
-		cluster.lights_shadow_rect_cache = memnew_arr(Rect2i, cluster.max_lights * 2);
-
 		cluster.max_directional_lights = MAX_DIRECTIONAL_LIGHTS;
 		uint32_t directional_light_buffer_size = cluster.max_directional_lights * sizeof(Cluster::DirectionalLightData);
 		cluster.directional_lights = memnew_arr(Cluster::DirectionalLightData, cluster.max_directional_lights);
@@ -9105,8 +8897,6 @@ RendererSceneRenderRD::RendererSceneRenderRD(RendererStorageRD *p_storage) {
 
 	environment_set_volumetric_fog_volume_size(GLOBAL_GET("rendering/volumetric_fog/volume_size"), GLOBAL_GET("rendering/volumetric_fog/volume_depth"));
 	environment_set_volumetric_fog_filter_active(GLOBAL_GET("rendering/volumetric_fog/use_filter"));
-	environment_set_volumetric_fog_directional_shadow_shrink_size(GLOBAL_GET("rendering/volumetric_fog/directional_shadow_shrink"));
-	environment_set_volumetric_fog_positional_shadow_shrink_size(GLOBAL_GET("rendering/volumetric_fog/positional_shadow_shrink"));
 
 	cull_argument.set_page_pool(&cull_argument_pool);
 
@@ -9168,8 +8958,6 @@ RendererSceneRenderRD::~RendererSceneRenderRD() {
 		memdelete_arr(cluster.spot_lights);
 		memdelete_arr(cluster.omni_light_sort);
 		memdelete_arr(cluster.spot_light_sort);
-		memdelete_arr(cluster.lights_shadow_rect_cache);
-		memdelete_arr(cluster.lights_instances);
 		memdelete_arr(cluster.reflections);
 		memdelete_arr(cluster.reflection_sort);
 		memdelete_arr(cluster.decals);