Merge pull request #40616 from reduz/refactor-light-clustering

Refactor light clustering

7 files changed, 842 insertions, 793 deletions

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 890ada019f..873f74e3be 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
@@ -33,69 +33,6 @@
 #include "servers/rendering/rendering_device.h"
 #include "servers/rendering/rendering_server_raster.h"
 
-static _FORCE_INLINE_ void store_transform(const Transform &p_mtx, float *p_array) {
-	p_array[0] = p_mtx.basis.elements[0][0];
-	p_array[1] = p_mtx.basis.elements[1][0];
-	p_array[2] = p_mtx.basis.elements[2][0];
-	p_array[3] = 0;
-	p_array[4] = p_mtx.basis.elements[0][1];
-	p_array[5] = p_mtx.basis.elements[1][1];
-	p_array[6] = p_mtx.basis.elements[2][1];
-	p_array[7] = 0;
-	p_array[8] = p_mtx.basis.elements[0][2];
-	p_array[9] = p_mtx.basis.elements[1][2];
-	p_array[10] = p_mtx.basis.elements[2][2];
-	p_array[11] = 0;
-	p_array[12] = p_mtx.origin.x;
-	p_array[13] = p_mtx.origin.y;
-	p_array[14] = p_mtx.origin.z;
-	p_array[15] = 1;
-}
-
-static _FORCE_INLINE_ void store_basis_3x4(const Basis &p_mtx, float *p_array) {
-	p_array[0] = p_mtx.elements[0][0];
-	p_array[1] = p_mtx.elements[1][0];
-	p_array[2] = p_mtx.elements[2][0];
-	p_array[3] = 0;
-	p_array[4] = p_mtx.elements[0][1];
-	p_array[5] = p_mtx.elements[1][1];
-	p_array[6] = p_mtx.elements[2][1];
-	p_array[7] = 0;
-	p_array[8] = p_mtx.elements[0][2];
-	p_array[9] = p_mtx.elements[1][2];
-	p_array[10] = p_mtx.elements[2][2];
-	p_array[11] = 0;
-}
-
-static _FORCE_INLINE_ void store_transform_3x3(const Basis &p_mtx, float *p_array) {
-	p_array[0] = p_mtx.elements[0][0];
-	p_array[1] = p_mtx.elements[1][0];
-	p_array[2] = p_mtx.elements[2][0];
-	p_array[3] = 0;
-	p_array[4] = p_mtx.elements[0][1];
-	p_array[5] = p_mtx.elements[1][1];
-	p_array[6] = p_mtx.elements[2][1];
-	p_array[7] = 0;
-	p_array[8] = p_mtx.elements[0][2];
-	p_array[9] = p_mtx.elements[1][2];
-	p_array[10] = p_mtx.elements[2][2];
-	p_array[11] = 0;
-}
-
-static _FORCE_INLINE_ void store_camera(const CameraMatrix &p_mtx, float *p_array) {
-	for (int i = 0; i < 4; i++) {
-		for (int j = 0; j < 4; j++) {
-			p_array[i * 4 + j] = p_mtx.matrix[i][j];
-		}
-	}
-}
-
-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
@@ -845,8 +782,8 @@ void RasterizerSceneHighEndRD::_fill_instances(RenderList::Element **p_elements,
 	for (int i = 0; i < p_element_count; i++) {
 		const RenderList::Element *e = p_elements[i];
 		InstanceData &id = scene_state.instances[i];
-		store_transform(e->instance->transform, id.transform);
-		store_transform(Transform(e->instance->transform.basis.inverse().transposed()), id.normal_transform);
+		RasterizerStorageRD::store_transform(e->instance->transform, id.transform);
+		RasterizerStorageRD::store_transform(Transform(e->instance->transform.basis.inverse().transposed()), id.normal_transform);
 		id.flags = 0;
 		id.mask = e->instance->layer_mask;
 		id.instance_uniforms_ofs = e->instance->instance_allocated_shader_parameters_offset >= 0 ? e->instance->instance_allocated_shader_parameters_offset : 0;
@@ -1171,20 +1108,20 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, RID p_rende
 	CameraMatrix projection = correction * p_cam_projection;
 
 	//store camera into ubo
-	store_camera(projection, scene_state.ubo.projection_matrix);
-	store_camera(projection.inverse(), scene_state.ubo.inv_projection_matrix);
-	store_transform(p_cam_transform, scene_state.ubo.camera_matrix);
-	store_transform(p_cam_transform.affine_inverse(), scene_state.ubo.inv_camera_matrix);
+	RasterizerStorageRD::store_camera(projection, scene_state.ubo.projection_matrix);
+	RasterizerStorageRD::store_camera(projection.inverse(), scene_state.ubo.inv_projection_matrix);
+	RasterizerStorageRD::store_transform(p_cam_transform, scene_state.ubo.camera_matrix);
+	RasterizerStorageRD::store_transform(p_cam_transform.affine_inverse(), scene_state.ubo.inv_camera_matrix);
 
 	scene_state.ubo.z_far = p_zfar;
 	scene_state.ubo.z_near = p_znear;
 
 	scene_state.ubo.pancake_shadows = p_pancake_shadows;
 
-	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);
+	RasterizerStorageRD::store_soft_shadow_kernel(directional_penumbra_shadow_kernel_get(), scene_state.ubo.directional_penumbra_shadow_kernel);
+	RasterizerStorageRD::store_soft_shadow_kernel(directional_soft_shadow_kernel_get(), scene_state.ubo.directional_soft_shadow_kernel);
+	RasterizerStorageRD::store_soft_shadow_kernel(penumbra_shadow_kernel_get(), scene_state.ubo.penumbra_shadow_kernel);
+	RasterizerStorageRD::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();
@@ -1310,7 +1247,7 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, RID p_rende
 
 			Basis sky_transform = environment_get_sky_orientation(p_environment);
 			sky_transform = sky_transform.inverse() * p_cam_transform.basis;
-			store_transform_3x3(sky_transform, scene_state.ubo.radiance_inverse_xform);
+			RasterizerStorageRD::store_transform_3x3(sky_transform, scene_state.ubo.radiance_inverse_xform);
 
 			scene_state.ubo.use_ambient_cubemap = (ambient_src == RS::ENV_AMBIENT_SOURCE_BG && env_bg == RS::ENV_BG_SKY) || ambient_src == RS::ENV_AMBIENT_SOURCE_SKY;
 			scene_state.ubo.use_ambient_light = scene_state.ubo.use_ambient_cubemap || ambient_src == RS::ENV_AMBIENT_SOURCE_COLOR;
@@ -1582,66 +1519,6 @@ void RasterizerSceneHighEndRD::_fill_render_list(InstanceBase **p_cull_result, i
 	}
 }
 
-void RasterizerSceneHighEndRD::_setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, RID p_environment) {
-	for (int i = 0; i < p_reflection_probe_cull_count; i++) {
-		RID rpi = p_reflection_probe_cull_result[i];
-
-		if (i >= (int)scene_state.max_reflections) {
-			reflection_probe_instance_set_render_index(rpi, 0); //invalid, but something needs to be set
-			continue;
-		}
-
-		reflection_probe_instance_set_render_index(rpi, i);
-
-		RID base_probe = reflection_probe_instance_get_probe(rpi);
-
-		ReflectionData &reflection_ubo = scene_state.reflections[i];
-
-		Vector3 extents = storage->reflection_probe_get_extents(base_probe);
-
-		reflection_ubo.box_extents[0] = extents.x;
-		reflection_ubo.box_extents[1] = extents.y;
-		reflection_ubo.box_extents[2] = extents.z;
-		reflection_ubo.index = reflection_probe_instance_get_atlas_index(rpi);
-
-		Vector3 origin_offset = storage->reflection_probe_get_origin_offset(base_probe);
-
-		reflection_ubo.box_offset[0] = origin_offset.x;
-		reflection_ubo.box_offset[1] = origin_offset.y;
-		reflection_ubo.box_offset[2] = origin_offset.z;
-		reflection_ubo.mask = storage->reflection_probe_get_cull_mask(base_probe);
-
-		float intensity = storage->reflection_probe_get_intensity(base_probe);
-		bool interior = storage->reflection_probe_is_interior(base_probe);
-		bool box_projection = storage->reflection_probe_is_box_projection(base_probe);
-
-		reflection_ubo.params[0] = intensity;
-		reflection_ubo.params[1] = 0;
-		reflection_ubo.params[2] = interior ? 1.0 : 0.0;
-		reflection_ubo.params[3] = box_projection ? 1.0 : 0.0;
-
-		Color ambient_linear = storage->reflection_probe_get_ambient_color(base_probe).to_linear();
-		float interior_ambient_energy = storage->reflection_probe_get_ambient_color_energy(base_probe);
-		uint32_t ambient_mode = storage->reflection_probe_get_ambient_mode(base_probe);
-		reflection_ubo.ambient[0] = ambient_linear.r * interior_ambient_energy;
-		reflection_ubo.ambient[1] = ambient_linear.g * interior_ambient_energy;
-		reflection_ubo.ambient[2] = ambient_linear.b * interior_ambient_energy;
-		reflection_ubo.ambient_mode = ambient_mode;
-
-		Transform transform = reflection_probe_instance_get_transform(rpi);
-		Transform proj = (p_camera_inverse_transform * transform).inverse();
-		store_transform(proj, reflection_ubo.local_matrix);
-
-		cluster_builder.add_reflection_probe(transform, extents);
-
-		reflection_probe_instance_set_render_pass(rpi, render_pass);
-	}
-
-	if (p_reflection_probe_cull_count) {
-		RD::get_singleton()->buffer_update(scene_state.reflection_buffer, 0, MIN(scene_state.max_reflections, (unsigned int)p_reflection_probe_cull_count) * sizeof(ReflectionData), scene_state.reflections, true);
-	}
-}
-
 void RasterizerSceneHighEndRD::_setup_lightmaps(InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, const Transform &p_cam_transform) {
 	uint32_t lightmaps_used = 0;
 	for (int i = 0; i < p_lightmap_cull_count; i++) {
@@ -1652,7 +1529,7 @@ void RasterizerSceneHighEndRD::_setup_lightmaps(InstanceBase **p_lightmap_cull_r
 		InstanceBase *lm = p_lightmap_cull_result[i];
 		Basis to_lm = lm->transform.basis.inverse() * p_cam_transform.basis;
 		to_lm = to_lm.inverse().transposed(); //will transform normals
-		store_transform_3x3(to_lm, scene_state.lightmaps[i].normal_xform);
+		RasterizerStorageRD::store_transform_3x3(to_lm, scene_state.lightmaps[i].normal_xform);
 		lm->lightmap_cull_index = i;
 		lightmaps_used++;
 	}
@@ -1661,480 +1538,7 @@ void RasterizerSceneHighEndRD::_setup_lightmaps(InstanceBase **p_lightmap_cull_r
 	}
 }
 
-void RasterizerSceneHighEndRD::_setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, RID p_shadow_atlas, bool p_using_shadows) {
-	uint32_t light_count = 0;
-	scene_state.ubo.directional_light_count = 0;
-	sky_scene_state.directional_light_count = 0;
-
-	for (int i = 0; i < p_light_cull_count; i++) {
-		RID li = p_light_cull_result[i];
-		RID base = light_instance_get_base_light(li);
-
-		ERR_CONTINUE(base.is_null());
-
-		RS::LightType type = storage->light_get_type(base);
-		switch (type) {
-			case RS::LIGHT_DIRECTIONAL: {
-				if (scene_state.ubo.directional_light_count >= scene_state.max_directional_lights) {
-					continue;
-				}
-
-				DirectionalLightData &light_data = scene_state.directional_lights[scene_state.ubo.directional_light_count];
-
-				Transform light_transform = light_instance_get_base_transform(li);
-
-				Vector3 direction = p_camera_inverse_transform.basis.xform(light_transform.basis.xform(Vector3(0, 0, 1))).normalized();
-
-				light_data.direction[0] = direction.x;
-				light_data.direction[1] = direction.y;
-				light_data.direction[2] = direction.z;
-
-				float sign = storage->light_is_negative(base) ? -1 : 1;
-
-				light_data.energy = sign * storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY) * Math_PI;
-
-				Color linear_col = storage->light_get_color(base).to_linear();
-				light_data.color[0] = linear_col.r;
-				light_data.color[1] = linear_col.g;
-				light_data.color[2] = linear_col.b;
-
-				light_data.specular = storage->light_get_param(base, RS::LIGHT_PARAM_SPECULAR);
-				light_data.mask = storage->light_get_cull_mask(base);
-
-				float size = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
-
-				light_data.size = 1.0 - Math::cos(Math::deg2rad(size)); //angle to cosine offset
-
-				Color shadow_col = storage->light_get_shadow_color(base).to_linear();
-
-				if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_PSSM_SPLITS) {
-					light_data.shadow_color1[0] = 1.0;
-					light_data.shadow_color1[1] = 0.0;
-					light_data.shadow_color1[2] = 0.0;
-					light_data.shadow_color1[3] = 1.0;
-					light_data.shadow_color2[0] = 0.0;
-					light_data.shadow_color2[1] = 1.0;
-					light_data.shadow_color2[2] = 0.0;
-					light_data.shadow_color2[3] = 1.0;
-					light_data.shadow_color3[0] = 0.0;
-					light_data.shadow_color3[1] = 0.0;
-					light_data.shadow_color3[2] = 1.0;
-					light_data.shadow_color3[3] = 1.0;
-					light_data.shadow_color4[0] = 1.0;
-					light_data.shadow_color4[1] = 1.0;
-					light_data.shadow_color4[2] = 0.0;
-					light_data.shadow_color4[3] = 1.0;
-
-				} else {
-					light_data.shadow_color1[0] = shadow_col.r;
-					light_data.shadow_color1[1] = shadow_col.g;
-					light_data.shadow_color1[2] = shadow_col.b;
-					light_data.shadow_color1[3] = 1.0;
-					light_data.shadow_color2[0] = shadow_col.r;
-					light_data.shadow_color2[1] = shadow_col.g;
-					light_data.shadow_color2[2] = shadow_col.b;
-					light_data.shadow_color2[3] = 1.0;
-					light_data.shadow_color3[0] = shadow_col.r;
-					light_data.shadow_color3[1] = shadow_col.g;
-					light_data.shadow_color3[2] = shadow_col.b;
-					light_data.shadow_color3[3] = 1.0;
-					light_data.shadow_color4[0] = shadow_col.r;
-					light_data.shadow_color4[1] = shadow_col.g;
-					light_data.shadow_color4[2] = shadow_col.b;
-					light_data.shadow_color4[3] = 1.0;
-				}
-
-				light_data.shadow_enabled = p_using_shadows && storage->light_has_shadow(base);
-
-				float angular_diameter = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
-				if (angular_diameter > 0.0) {
-					// I know tan(0) is 0, but let's not risk it with numerical precision.
-					// technically this will keep expanding until reaching the sun, but all we care
-					// is expand until we reach the radius of the near plane (there can't be more occluders than that)
-					angular_diameter = Math::tan(Math::deg2rad(angular_diameter));
-				} else {
-					angular_diameter = 0.0;
-				}
-
-				if (light_data.shadow_enabled) {
-					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);
-					for (int j = 0; j < 4; j++) {
-						Rect2 atlas_rect = light_instance_get_directional_shadow_atlas_rect(li, j);
-						CameraMatrix matrix = light_instance_get_shadow_camera(li, j);
-						float split = light_instance_get_directional_shadow_split(li, MIN(limit, j));
-
-						CameraMatrix bias;
-						bias.set_light_bias();
-						CameraMatrix rectm;
-						rectm.set_light_atlas_rect(atlas_rect);
-
-						Transform modelview = (p_camera_inverse_transform * light_instance_get_shadow_transform(li, j)).inverse();
-
-						CameraMatrix shadow_mtx = rectm * bias * matrix * modelview;
-						light_data.shadow_split_offsets[j] = split;
-						float bias_scale = light_instance_get_shadow_bias_scale(li, j);
-						light_data.shadow_bias[j] = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) * bias_scale;
-						light_data.shadow_normal_bias[j] = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * light_instance_get_directional_shadow_texel_size(li, j);
-						light_data.shadow_transmittance_bias[j] = storage->light_get_transmittance_bias(base) * bias_scale;
-						light_data.shadow_transmittance_z_scale[j] = light_instance_get_shadow_range(li, j);
-						light_data.shadow_range_begin[j] = light_instance_get_shadow_range_begin(li, j);
-						store_camera(shadow_mtx, light_data.shadow_matrices[j]);
-
-						Vector2 uv_scale = light_instance_get_shadow_uv_scale(li, j);
-						uv_scale *= atlas_rect.size; //adapt to atlas size
-						switch (j) {
-							case 0: {
-								light_data.uv_scale1[0] = uv_scale.x;
-								light_data.uv_scale1[1] = uv_scale.y;
-							} break;
-							case 1: {
-								light_data.uv_scale2[0] = uv_scale.x;
-								light_data.uv_scale2[1] = uv_scale.y;
-							} break;
-							case 2: {
-								light_data.uv_scale3[0] = uv_scale.x;
-								light_data.uv_scale3[1] = uv_scale.y;
-							} break;
-							case 3: {
-								light_data.uv_scale4[0] = uv_scale.x;
-								light_data.uv_scale4[1] = uv_scale.y;
-							} break;
-						}
-					}
-
-					float fade_start = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_FADE_START);
-					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);
-					light_data.softshadow_angle = angular_diameter;
-
-					if (angular_diameter <= 0.0) {
-						light_data.soft_shadow_scale *= directional_shadow_quality_radius_get(); // Only use quality radius for PCF
-					}
-				}
-
-				//	Copy to SkyDirectionalLightData
-				if (sky_scene_state.directional_light_count < sky_scene_state.max_directional_lights) {
-					SkyDirectionalLightData &sky_light_data = sky_scene_state.directional_lights[sky_scene_state.directional_light_count];
-
-					Vector3 world_direction = light_transform.basis.xform(Vector3(0, 0, 1)).normalized();
-
-					sky_light_data.direction[0] = world_direction.x;
-					sky_light_data.direction[1] = world_direction.y;
-					sky_light_data.direction[2] = -world_direction.z;
-
-					sky_light_data.energy = light_data.energy / Math_PI;
-
-					sky_light_data.color[0] = light_data.color[0];
-					sky_light_data.color[1] = light_data.color[1];
-					sky_light_data.color[2] = light_data.color[2];
-
-					sky_light_data.enabled = true;
-					sky_light_data.size = angular_diameter;
-					sky_scene_state.directional_light_count++;
-				}
-
-				scene_state.ubo.directional_light_count++;
-			} break;
-			case RS::LIGHT_SPOT:
-			case RS::LIGHT_OMNI: {
-				if (light_count >= scene_state.max_lights) {
-					continue;
-				}
-
-				Transform light_transform = light_instance_get_base_transform(li);
-
-				LightData &light_data = scene_state.lights[light_count];
-
-				float sign = storage->light_is_negative(base) ? -1 : 1;
-				Color linear_col = storage->light_get_color(base).to_linear();
-
-				light_data.attenuation_energy[0] = Math::make_half_float(storage->light_get_param(base, RS::LIGHT_PARAM_ATTENUATION));
-				light_data.attenuation_energy[1] = Math::make_half_float(sign * storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY) * Math_PI);
-
-				light_data.color_specular[0] = MIN(uint32_t(linear_col.r * 255), 255);
-				light_data.color_specular[1] = MIN(uint32_t(linear_col.g * 255), 255);
-				light_data.color_specular[2] = MIN(uint32_t(linear_col.b * 255), 255);
-				light_data.color_specular[3] = MIN(uint32_t(storage->light_get_param(base, RS::LIGHT_PARAM_SPECULAR) * 255), 255);
-
-				float radius = MAX(0.001, storage->light_get_param(base, RS::LIGHT_PARAM_RANGE));
-				light_data.inv_radius = 1.0 / radius;
-
-				Vector3 pos = p_camera_inverse_transform.xform(light_transform.origin);
-
-				light_data.position[0] = pos.x;
-				light_data.position[1] = pos.y;
-				light_data.position[2] = pos.z;
-
-				Vector3 direction = p_camera_inverse_transform.basis.xform(light_transform.basis.xform(Vector3(0, 0, -1))).normalized();
-
-				light_data.direction[0] = direction.x;
-				light_data.direction[1] = direction.y;
-				light_data.direction[2] = direction.z;
-
-				float size = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
-
-				light_data.size = size;
-
-				light_data.cone_attenuation_angle[0] = Math::make_half_float(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_attenuation_angle[1] = Math::make_half_float(Math::cos(Math::deg2rad(spot_angle)));
-
-				light_data.mask = storage->light_get_cull_mask(base);
-
-				light_data.atlas_rect[0] = 0;
-				light_data.atlas_rect[1] = 0;
-				light_data.atlas_rect[2] = 0;
-				light_data.atlas_rect[3] = 0;
-
-				RID projector = storage->light_get_projector(base);
-
-				if (projector.is_valid()) {
-					Rect2 rect = storage->decal_atlas_get_texture_rect(projector);
-
-					if (type == RS::LIGHT_SPOT) {
-						light_data.projector_rect[0] = rect.position.x;
-						light_data.projector_rect[1] = rect.position.y + rect.size.height; //flip because shadow is flipped
-						light_data.projector_rect[2] = rect.size.width;
-						light_data.projector_rect[3] = -rect.size.height;
-					} else {
-						light_data.projector_rect[0] = rect.position.x;
-						light_data.projector_rect[1] = rect.position.y;
-						light_data.projector_rect[2] = rect.size.width;
-						light_data.projector_rect[3] = rect.size.height * 0.5; //used by dp, so needs to be half
-					}
-				} else {
-					light_data.projector_rect[0] = 0;
-					light_data.projector_rect[1] = 0;
-					light_data.projector_rect[2] = 0;
-					light_data.projector_rect[3] = 0;
-				}
-
-				if (p_using_shadows && p_shadow_atlas.is_valid() && shadow_atlas_owns_light_instance(p_shadow_atlas, li)) {
-					// fill in the shadow information
-
-					Color shadow_color = storage->light_get_shadow_color(base);
-
-					light_data.shadow_color_enabled[0] = MIN(uint32_t(shadow_color.r * 255), 255);
-					light_data.shadow_color_enabled[1] = MIN(uint32_t(shadow_color.g * 255), 255);
-					light_data.shadow_color_enabled[2] = MIN(uint32_t(shadow_color.b * 255), 255);
-					light_data.shadow_color_enabled[3] = 255;
-
-					if (type == RS::LIGHT_SPOT) {
-						light_data.shadow_bias = (storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) * radius / 10.0);
-						float shadow_texel_size = Math::tan(Math::deg2rad(spot_angle)) * radius * 2.0;
-						shadow_texel_size *= light_instance_get_shadow_texel_size(li, p_shadow_atlas);
-
-						light_data.shadow_normal_bias = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * shadow_texel_size;
-
-					} else { //omni
-						light_data.shadow_bias = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) * radius / 10.0;
-						float shadow_texel_size = light_instance_get_shadow_texel_size(li, p_shadow_atlas);
-						light_data.shadow_normal_bias = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * shadow_texel_size * 2.0; // applied in -1 .. 1 space
-					}
-
-					light_data.transmittance_bias = storage->light_get_transmittance_bias(base);
-
-					Rect2 rect = light_instance_get_shadow_atlas_rect(li, p_shadow_atlas);
-
-					light_data.atlas_rect[0] = rect.position.x;
-					light_data.atlas_rect[1] = rect.position.y;
-					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
-						Transform proj = (p_camera_inverse_transform * light_transform).inverse();
-
-						store_transform(proj, light_data.shadow_matrix);
-
-						if (size > 0.0) {
-							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) {
-						Transform modelview = (p_camera_inverse_transform * light_transform).inverse();
-						CameraMatrix bias;
-						bias.set_light_bias();
-
-						CameraMatrix shadow_mtx = bias * light_instance_get_shadow_camera(li, 0) * modelview;
-						store_camera(shadow_mtx, light_data.shadow_matrix);
-
-						if (size > 0.0) {
-							CameraMatrix cm = light_instance_get_shadow_camera(li, 0);
-							float half_np = cm.get_z_near() * Math::tan(Math::deg2rad(spot_angle));
-							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 {
-					light_data.shadow_color_enabled[3] = 0;
-				}
-
-				light_instance_set_index(li, light_count);
-
-				cluster_builder.add_light(type == RS::LIGHT_SPOT ? LightClusterBuilder::LIGHT_TYPE_SPOT : LightClusterBuilder::LIGHT_TYPE_OMNI, light_transform, radius, spot_angle);
-
-				light_count++;
-			} break;
-		}
-
-		light_instance_set_render_pass(li, render_pass);
-
-		//update UBO for forward rendering, blit to texture for clustered
-	}
-
-	if (light_count) {
-		RD::get_singleton()->buffer_update(scene_state.light_buffer, 0, sizeof(LightData) * light_count, scene_state.lights, true);
-	}
-
-	if (scene_state.ubo.directional_light_count) {
-		RD::get_singleton()->buffer_update(scene_state.directional_light_buffer, 0, sizeof(DirectionalLightData) * scene_state.ubo.directional_light_count, scene_state.directional_lights, true);
-	}
-}
-
-void RasterizerSceneHighEndRD::_setup_decals(const RID *p_decal_instances, int p_decal_count, const Transform &p_camera_inverse_xform) {
-	Transform uv_xform;
-	uv_xform.basis.scale(Vector3(2.0, 1.0, 2.0));
-	uv_xform.origin = Vector3(-1.0, 0.0, -1.0);
-
-	p_decal_count = MIN((uint32_t)p_decal_count, scene_state.max_decals);
-	int idx = 0;
-	for (int i = 0; i < p_decal_count; i++) {
-		RID di = p_decal_instances[i];
-		RID decal = decal_instance_get_base(di);
-
-		Transform xform = decal_instance_get_transform(di);
-
-		float fade = 1.0;
-
-		if (storage->decal_is_distance_fade_enabled(decal)) {
-			real_t distance = -p_camera_inverse_xform.xform(xform.origin).z;
-			float fade_begin = storage->decal_get_distance_fade_begin(decal);
-			float fade_length = storage->decal_get_distance_fade_length(decal);
-
-			if (distance > fade_begin) {
-				if (distance > fade_begin + fade_length) {
-					continue; // do not use this decal, its invisible
-				}
-
-				fade = 1.0 - (distance - fade_begin) / fade_length;
-			}
-		}
-
-		DecalData &dd = scene_state.decals[idx];
-
-		Vector3 decal_extents = storage->decal_get_extents(decal);
-
-		Transform scale_xform;
-		scale_xform.basis.scale(Vector3(decal_extents.x, decal_extents.y, decal_extents.z));
-		Transform to_decal_xform = (p_camera_inverse_xform * decal_instance_get_transform(di) * scale_xform * uv_xform).affine_inverse();
-		store_transform(to_decal_xform, dd.xform);
-
-		Vector3 normal = xform.basis.get_axis(Vector3::AXIS_Y).normalized();
-		normal = p_camera_inverse_xform.basis.xform(normal); //camera is normalized, so fine
-
-		dd.normal[0] = normal.x;
-		dd.normal[1] = normal.y;
-		dd.normal[2] = normal.z;
-		dd.normal_fade = storage->decal_get_normal_fade(decal);
-
-		RID albedo_tex = storage->decal_get_texture(decal, RS::DECAL_TEXTURE_ALBEDO);
-		RID emission_tex = storage->decal_get_texture(decal, RS::DECAL_TEXTURE_EMISSION);
-		if (albedo_tex.is_valid()) {
-			Rect2 rect = storage->decal_atlas_get_texture_rect(albedo_tex);
-			dd.albedo_rect[0] = rect.position.x;
-			dd.albedo_rect[1] = rect.position.y;
-			dd.albedo_rect[2] = rect.size.x;
-			dd.albedo_rect[3] = rect.size.y;
-		} else {
-			if (!emission_tex.is_valid()) {
-				continue; //no albedo, no emission, no decal.
-			}
-			dd.albedo_rect[0] = 0;
-			dd.albedo_rect[1] = 0;
-			dd.albedo_rect[2] = 0;
-			dd.albedo_rect[3] = 0;
-		}
-
-		RID normal_tex = storage->decal_get_texture(decal, RS::DECAL_TEXTURE_NORMAL);
-
-		if (normal_tex.is_valid()) {
-			Rect2 rect = storage->decal_atlas_get_texture_rect(normal_tex);
-			dd.normal_rect[0] = rect.position.x;
-			dd.normal_rect[1] = rect.position.y;
-			dd.normal_rect[2] = rect.size.x;
-			dd.normal_rect[3] = rect.size.y;
-
-			Basis normal_xform = p_camera_inverse_xform.basis * xform.basis.orthonormalized();
-			store_basis_3x4(normal_xform, dd.normal_xform);
-		} else {
-			dd.normal_rect[0] = 0;
-			dd.normal_rect[1] = 0;
-			dd.normal_rect[2] = 0;
-			dd.normal_rect[3] = 0;
-		}
-
-		RID orm_tex = storage->decal_get_texture(decal, RS::DECAL_TEXTURE_ORM);
-		if (orm_tex.is_valid()) {
-			Rect2 rect = storage->decal_atlas_get_texture_rect(orm_tex);
-			dd.orm_rect[0] = rect.position.x;
-			dd.orm_rect[1] = rect.position.y;
-			dd.orm_rect[2] = rect.size.x;
-			dd.orm_rect[3] = rect.size.y;
-		} else {
-			dd.orm_rect[0] = 0;
-			dd.orm_rect[1] = 0;
-			dd.orm_rect[2] = 0;
-			dd.orm_rect[3] = 0;
-		}
-
-		if (emission_tex.is_valid()) {
-			Rect2 rect = storage->decal_atlas_get_texture_rect(emission_tex);
-			dd.emission_rect[0] = rect.position.x;
-			dd.emission_rect[1] = rect.position.y;
-			dd.emission_rect[2] = rect.size.x;
-			dd.emission_rect[3] = rect.size.y;
-		} else {
-			dd.emission_rect[0] = 0;
-			dd.emission_rect[1] = 0;
-			dd.emission_rect[2] = 0;
-			dd.emission_rect[3] = 0;
-		}
-
-		Color modulate = storage->decal_get_modulate(decal);
-		dd.modulate[0] = modulate.r;
-		dd.modulate[1] = modulate.g;
-		dd.modulate[2] = modulate.b;
-		dd.modulate[3] = modulate.a * fade;
-		dd.emission_energy = storage->decal_get_emission_energy(decal) * fade;
-		dd.albedo_mix = storage->decal_get_albedo_mix(decal);
-		dd.mask = storage->decal_get_cull_mask(decal);
-		dd.upper_fade = storage->decal_get_upper_fade(decal);
-		dd.lower_fade = storage->decal_get_lower_fade(decal);
-
-		cluster_builder.add_decal(xform, decal_extents);
-
-		idx++;
-	}
-
-	if (idx > 0) {
-		RD::get_singleton()->buffer_update(scene_state.decal_buffer, 0, sizeof(DecalData) * idx, scene_state.decals, true);
-	}
-}
-
-void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color) {
+void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color) {
 	RenderBufferDataHighEnd *render_buffer = nullptr;
 	if (p_render_buffer.is_valid()) {
 		render_buffer = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffer);
@@ -2147,19 +1551,8 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 
 	RENDER_TIMESTAMP("Setup 3D Scene");
 
-	if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_UNSHADED) {
-		p_light_cull_count = 0;
-		p_reflection_probe_cull_count = 0;
-		p_gi_probe_cull_count = 0;
-	}
-
-	bool using_shadows = true;
-
 	if (p_reflection_probe.is_valid()) {
 		scene_state.ubo.reflection_multiplier = 0.0;
-		if (!storage->reflection_probe_renders_shadows(reflection_probe_instance_get_probe(p_reflection_probe))) {
-			using_shadows = false;
-		}
 	} else {
 		scene_state.ubo.reflection_multiplier = 1.0;
 	}
@@ -2169,6 +1562,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 	Vector2 vp_he = p_cam_projection.get_viewport_half_extents();
 	scene_state.ubo.viewport_size[0] = vp_he.x;
 	scene_state.ubo.viewport_size[1] = vp_he.y;
+	scene_state.ubo.directional_light_count = p_directional_light_count;
 
 	Size2 screen_pixel_size;
 	Size2i screen_size;
@@ -2259,16 +1653,9 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 		ERR_FAIL(); //bug?
 	}
 
-	cluster_builder.begin(p_cam_transform.affine_inverse(), p_cam_projection); //prepare cluster
-
-	_setup_lights(p_light_cull_result, p_light_cull_count, p_cam_transform.affine_inverse(), p_shadow_atlas, using_shadows);
-	_setup_decals(p_decal_cull_result, p_decal_cull_count, p_cam_transform.affine_inverse());
-	_setup_reflections(p_reflection_probe_cull_result, p_reflection_probe_cull_count, p_cam_transform.affine_inverse(), p_environment);
 	_setup_lightmaps(p_lightmap_cull_result, p_lightmap_cull_count, p_cam_transform);
 	_setup_environment(p_environment, p_render_buffer, p_cam_projection, p_cam_transform, p_reflection_probe, p_reflection_probe.is_valid(), screen_pixel_size, p_shadow_atlas, !p_reflection_probe.is_valid(), p_default_bg_color, p_cam_projection.get_z_near(), p_cam_projection.get_z_far(), false);
 
-	cluster_builder.bake_cluster(); //bake to cluster
-
 	_update_render_base_uniform_set(); //may have changed due to the above (light buffer enlarged, as an example)
 
 	render_list.clear();
@@ -2745,7 +2132,7 @@ void RasterizerSceneHighEndRD::_render_sdfgi(RID p_render_buffers, const Vector3
 		to_bounds.origin = p_bounds.position;
 		to_bounds.basis.scale(p_bounds.size);
 
-		store_transform(to_bounds.affine_inverse() * cam_xform, scene_state.ubo.sdf_to_bounds);
+		RasterizerStorageRD::store_transform(to_bounds.affine_inverse() * cam_xform, scene_state.ubo.sdf_to_bounds);
 
 		_setup_environment(RID(), RID(), camera_proj, cam_xform, RID(), true, Vector2(1, 1), RID(), false, Color(), 0, 0);
 
@@ -2826,22 +2213,22 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 			RD::Uniform u;
 			u.binding = 5;
 			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
-			u.ids.push_back(scene_state.light_buffer);
+			u.ids.push_back(get_positional_light_buffer());
 			uniforms.push_back(u);
 		}
 
 		{
 			RD::Uniform u;
 			u.binding = 6;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
-			u.ids.push_back(scene_state.reflection_buffer);
+			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.ids.push_back(get_reflection_probe_buffer());
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 7;
 			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
-			u.ids.push_back(scene_state.directional_light_buffer);
+			u.ids.push_back(get_directional_light_buffer());
 			uniforms.push_back(u);
 		}
 		{
@@ -2885,7 +2272,7 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 			RD::Uniform u;
 			u.binding = 15;
 			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
-			u.ids.push_back(scene_state.decal_buffer);
+			u.ids.push_back(get_decal_buffer());
 			uniforms.push_back(u);
 		}
 
@@ -2893,14 +2280,14 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 			RD::Uniform u;
 			u.binding = 16;
 			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			u.ids.push_back(cluster_builder.get_cluster_texture());
+			u.ids.push_back(get_cluster_builder_texture());
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 17;
 			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
-			u.ids.push_back(cluster_builder.get_cluster_indices_buffer());
+			u.ids.push_back(get_cluster_builder_indices_buffer());
 			uniforms.push_back(u);
 		}
 
@@ -3141,37 +2528,8 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 			defines += "\n#define USE_RADIANCE_CUBEMAP_ARRAY \n";
 		}
 		defines += "\n#define SDFGI_OCT_SIZE " + itos(sdfgi_get_lightprobe_octahedron_size()) + "\n";
+		defines += "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(get_max_directional_lights()) + "\n";
 
-		uint32_t uniform_max_size = RD::get_singleton()->limit_get(RD::LIMIT_MAX_UNIFORM_BUFFER_SIZE);
-
-		{ //reflections
-			uint32_t reflection_buffer_size;
-			if (uniform_max_size < 65536) {
-				//Yes, you guessed right, ARM again
-				reflection_buffer_size = uniform_max_size;
-			} else {
-				reflection_buffer_size = 65536;
-			}
-
-			scene_state.max_reflections = reflection_buffer_size / sizeof(ReflectionData);
-			scene_state.reflections = memnew_arr(ReflectionData, scene_state.max_reflections);
-			scene_state.reflection_buffer = RD::get_singleton()->uniform_buffer_create(reflection_buffer_size);
-			defines += "\n#define MAX_REFLECTION_DATA_STRUCTS " + itos(scene_state.max_reflections) + "\n";
-		}
-
-		{ //lights
-			scene_state.max_lights = MIN(1024 * 1024, uniform_max_size) / sizeof(LightData); //1mb of lights
-			uint32_t light_buffer_size = scene_state.max_lights * sizeof(LightData);
-			scene_state.lights = memnew_arr(LightData, scene_state.max_lights);
-			scene_state.light_buffer = RD::get_singleton()->storage_buffer_create(light_buffer_size);
-			//defines += "\n#define MAX_LIGHT_DATA_STRUCTS " + itos(scene_state.max_lights) + "\n";
-
-			scene_state.max_directional_lights = 8;
-			uint32_t directional_light_buffer_size = scene_state.max_directional_lights * sizeof(DirectionalLightData);
-			scene_state.directional_lights = memnew_arr(DirectionalLightData, scene_state.max_directional_lights);
-			scene_state.directional_light_buffer = RD::get_singleton()->uniform_buffer_create(directional_light_buffer_size);
-			defines += "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(scene_state.max_directional_lights) + "\n";
-		}
 		{
 			//lightmaps
 			scene_state.max_lightmaps = storage->lightmap_array_get_size();
@@ -3187,13 +2545,6 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 			scene_state.lightmap_captures = memnew_arr(LightmapCaptureData, scene_state.max_lightmap_captures);
 			scene_state.lightmap_capture_buffer = RD::get_singleton()->storage_buffer_create(sizeof(LightmapCaptureData) * scene_state.max_lightmap_captures);
 		}
-		{ //decals
-			scene_state.max_decals = MIN(1024 * 1024, uniform_max_size) / sizeof(DecalData); //1mb of decals
-			uint32_t decal_buffer_size = scene_state.max_decals * sizeof(DecalData);
-			scene_state.decals = memnew_arr(DecalData, scene_state.max_decals);
-			scene_state.decal_buffer = RD::get_singleton()->storage_buffer_create(decal_buffer_size);
-		}
-
 		{
 			defines += "\n#define MATERIAL_UNIFORM_SET " + itos(MATERIAL_UNIFORM_SET) + "\n";
 		}
@@ -3467,8 +2818,6 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 
 		default_render_buffers_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, RENDER_BUFFERS_UNIFORM_SET);
 	}
-
-	cluster_builder.setup(16, 8, 24);
 }
 
 RasterizerSceneHighEndRD::~RasterizerSceneHighEndRD() {
@@ -3495,19 +2844,11 @@ RasterizerSceneHighEndRD::~RasterizerSceneHighEndRD() {
 	{
 		RD::get_singleton()->free(scene_state.uniform_buffer);
 		RD::get_singleton()->free(scene_state.instance_buffer);
-		RD::get_singleton()->free(scene_state.directional_light_buffer);
-		RD::get_singleton()->free(scene_state.light_buffer);
 		RD::get_singleton()->free(scene_state.lightmap_buffer);
 		RD::get_singleton()->free(scene_state.lightmap_capture_buffer);
-		RD::get_singleton()->free(scene_state.reflection_buffer);
-		RD::get_singleton()->free(scene_state.decal_buffer);
 		memdelete_arr(scene_state.instances);
-		memdelete_arr(scene_state.directional_lights);
-		memdelete_arr(scene_state.lights);
 		memdelete_arr(scene_state.lightmaps);
 		memdelete_arr(scene_state.lightmap_captures);
-		memdelete_arr(scene_state.reflections);
-		memdelete_arr(scene_state.decals);
 	}
 
 	while (sdfgi_framebuffer_size_cache.front()) {
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 cb03da48c1..a49173de98 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h
@@ -31,7 +31,6 @@
 #ifndef RASTERIZER_SCENE_HIGHEND_RD_H
 #define RASTERIZER_SCENE_HIGHEND_RD_H
 
-#include "servers/rendering/rasterizer_rd/light_cluster_builder.h"
 #include "servers/rendering/rasterizer_rd/rasterizer_scene_rd.h"
 #include "servers/rendering/rasterizer_rd/rasterizer_storage_rd.h"
 #include "servers/rendering/rasterizer_rd/render_pipeline_vertex_format_cache_rd.h"
@@ -264,92 +263,10 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 	void _setup_view_dependant_uniform_set(RID p_shadow_atlas, RID p_reflection_atlas, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count);
 	void _update_render_buffers_uniform_set(RID p_render_buffers);
 
-	/* Scene State UBO */
-
-	struct ReflectionData { //should always be 128 bytes
-		float box_extents[3];
-		float index;
-		float box_offset[3];
-		uint32_t mask;
-		float params[4]; // intensity, 0, interior , boxproject
-		float ambient[3]; // ambient color,
-		uint32_t ambient_mode;
-		float local_matrix[16]; // up to here for spot and omni, rest is for directional
-	};
-
-	struct LightData {
-		float position[3];
-		float inv_radius;
-		float direction[3];
-		float size;
-		uint16_t attenuation_energy[2]; //16 bits attenuation, then energy
-		uint8_t color_specular[4]; //rgb color, a specular (8 bit unorm)
-		uint16_t cone_attenuation_angle[2]; // attenuation and angle, (16bit float)
-		uint8_t shadow_color_enabled[4]; //shadow rgb color, a>0.5 enabled (8bit unorm)
-		float atlas_rect[4]; // in omni, used for atlas uv, in spot, used for projector uv
-		float shadow_matrix[16];
-		float shadow_bias;
-		float shadow_normal_bias;
-		float transmittance_bias;
-		float soft_shadow_size;
-		float soft_shadow_scale;
-		uint32_t mask;
-		uint32_t pad[2];
-		float projector_rect[4];
-	};
-
-	struct DirectionalLightData {
-		float direction[3];
-		float energy;
-		float color[3];
-		float size;
-		float specular;
-		uint32_t mask;
-		float softshadow_angle;
-		float soft_shadow_scale;
-		uint32_t blend_splits;
-		uint32_t shadow_enabled;
-		float fade_from;
-		float fade_to;
-		float shadow_bias[4];
-		float shadow_normal_bias[4];
-		float shadow_transmittance_bias[4];
-		float shadow_transmittance_z_scale[4];
-		float shadow_range_begin[4];
-		float shadow_split_offsets[4];
-		float shadow_matrices[4][16];
-		float shadow_color1[4];
-		float shadow_color2[4];
-		float shadow_color3[4];
-		float shadow_color4[4];
-		float uv_scale1[2];
-		float uv_scale2[2];
-		float uv_scale3[2];
-		float uv_scale4[2];
-	};
-
 	struct LightmapData {
 		float normal_xform[12];
 	};
 
-	struct DecalData {
-		float xform[16];
-		float inv_extents[3];
-		float albedo_mix;
-		float albedo_rect[4];
-		float normal_rect[4];
-		float orm_rect[4];
-		float emission_rect[4];
-		float modulate[4];
-		float emission_energy;
-		uint32_t mask;
-		float upper_fade;
-		float lower_fade;
-		float normal_xform[12];
-		float normal[3];
-		float normal_fade;
-	};
-
 	struct LightmapCaptureData {
 		float sh[9 * 4];
 	};
@@ -448,27 +365,10 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 
 		RID uniform_buffer;
 
-		ReflectionData *reflections;
-		uint32_t max_reflections;
-		RID reflection_buffer;
-		uint32_t max_reflection_probes_per_instance;
-
 		LightmapData *lightmaps;
 		uint32_t max_lightmaps;
 		RID lightmap_buffer;
 
-		DecalData *decals;
-		uint32_t max_decals;
-		RID decal_buffer;
-
-		LightData *lights;
-		uint32_t max_lights;
-		RID light_buffer;
-
-		DirectionalLightData *directional_lights;
-		uint32_t max_directional_lights;
-		RID directional_light_buffer;
-
 		LightmapCaptureData *lightmap_captures;
 		uint32_t max_lightmap_captures;
 		RID lightmap_capture_buffer;
@@ -635,8 +535,6 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 	RID default_vec4_xform_buffer;
 	RID default_vec4_xform_uniform_set;
 
-	LightClusterBuilder cluster_builder;
-
 	enum PassMode {
 		PASS_MODE_COLOR,
 		PASS_MODE_COLOR_SPECULAR,
@@ -651,9 +549,6 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 	};
 
 	void _setup_environment(RID p_environment, RID p_render_buffers, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, RID p_reflection_probe, bool p_no_fog, const Size2 &p_screen_pixel_size, RID p_shadow_atlas, bool p_flip_y, const Color &p_default_bg_color, float p_znear, float p_zfar, bool p_opaque_render_buffers = false, bool p_pancake_shadows = false);
-	void _setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, RID p_shadow_atlas, bool p_using_shadows);
-	void _setup_decals(const RID *p_decal_instances, int p_decal_count, const Transform &p_camera_inverse_xform);
-	void _setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, RID p_environment);
 	void _setup_lightmaps(InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, const Transform &p_cam_transform);
 
 	void _fill_instances(RenderList::Element **p_elements, int p_element_count, bool p_for_depth, bool p_has_sdfgi = false, bool p_has_opaque_gi = false);
@@ -666,7 +561,7 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 	Map<Size2i, RID> sdfgi_framebuffer_size_cache;
 
 protected:
-	virtual void _render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color);
+	virtual void _render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color);
 	virtual void _render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake);
 	virtual void _render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region);
 	virtual void _render_uv2(InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region);
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
index 3854f4c2a4..bdf9b71c56 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
@@ -5619,6 +5619,539 @@ RasterizerSceneRD::RenderBufferData *RasterizerSceneRD::render_buffers_get_data(
 	return rb->data;
 }
 
+void RasterizerSceneRD::_setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, RID p_environment) {
+	for (int i = 0; i < p_reflection_probe_cull_count; i++) {
+		RID rpi = p_reflection_probe_cull_result[i];
+
+		if (i >= (int)cluster.max_reflections) {
+			reflection_probe_instance_set_render_index(rpi, 0); //invalid, but something needs to be set
+			continue;
+		}
+
+		reflection_probe_instance_set_render_index(rpi, i);
+
+		RID base_probe = reflection_probe_instance_get_probe(rpi);
+
+		Cluster::ReflectionData &reflection_ubo = cluster.reflections[i];
+
+		Vector3 extents = storage->reflection_probe_get_extents(base_probe);
+
+		reflection_ubo.box_extents[0] = extents.x;
+		reflection_ubo.box_extents[1] = extents.y;
+		reflection_ubo.box_extents[2] = extents.z;
+		reflection_ubo.index = reflection_probe_instance_get_atlas_index(rpi);
+
+		Vector3 origin_offset = storage->reflection_probe_get_origin_offset(base_probe);
+
+		reflection_ubo.box_offset[0] = origin_offset.x;
+		reflection_ubo.box_offset[1] = origin_offset.y;
+		reflection_ubo.box_offset[2] = origin_offset.z;
+		reflection_ubo.mask = storage->reflection_probe_get_cull_mask(base_probe);
+
+		float intensity = storage->reflection_probe_get_intensity(base_probe);
+		bool interior = storage->reflection_probe_is_interior(base_probe);
+		bool box_projection = storage->reflection_probe_is_box_projection(base_probe);
+
+		reflection_ubo.params[0] = intensity;
+		reflection_ubo.params[1] = 0;
+		reflection_ubo.params[2] = interior ? 1.0 : 0.0;
+		reflection_ubo.params[3] = box_projection ? 1.0 : 0.0;
+
+		Color ambient_linear = storage->reflection_probe_get_ambient_color(base_probe).to_linear();
+		float interior_ambient_energy = storage->reflection_probe_get_ambient_color_energy(base_probe);
+		uint32_t ambient_mode = storage->reflection_probe_get_ambient_mode(base_probe);
+		reflection_ubo.ambient[0] = ambient_linear.r * interior_ambient_energy;
+		reflection_ubo.ambient[1] = ambient_linear.g * interior_ambient_energy;
+		reflection_ubo.ambient[2] = ambient_linear.b * interior_ambient_energy;
+		reflection_ubo.ambient_mode = ambient_mode;
+
+		Transform transform = reflection_probe_instance_get_transform(rpi);
+		Transform proj = (p_camera_inverse_transform * transform).inverse();
+		RasterizerStorageRD::store_transform(proj, reflection_ubo.local_matrix);
+
+		cluster.builder.add_reflection_probe(transform, extents);
+
+		reflection_probe_instance_set_render_pass(rpi, RSG::rasterizer->get_frame_number());
+	}
+
+	if (p_reflection_probe_cull_count) {
+		RD::get_singleton()->buffer_update(cluster.reflection_buffer, 0, MIN(cluster.max_reflections, (unsigned int)p_reflection_probe_cull_count) * sizeof(ReflectionData), cluster.reflections, true);
+	}
+}
+
+void RasterizerSceneRD::_setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, RID p_shadow_atlas, bool p_using_shadows, uint32_t &r_directional_light_count) {
+	uint32_t light_count = 0;
+	r_directional_light_count = 0;
+	sky_scene_state.directional_light_count = 0;
+
+	for (int i = 0; i < p_light_cull_count; i++) {
+		RID li = p_light_cull_result[i];
+		RID base = light_instance_get_base_light(li);
+
+		ERR_CONTINUE(base.is_null());
+
+		RS::LightType type = storage->light_get_type(base);
+		switch (type) {
+			case RS::LIGHT_DIRECTIONAL: {
+				if (r_directional_light_count >= cluster.max_directional_lights) {
+					continue;
+				}
+
+				Cluster::DirectionalLightData &light_data = cluster.directional_lights[r_directional_light_count];
+
+				Transform light_transform = light_instance_get_base_transform(li);
+
+				Vector3 direction = p_camera_inverse_transform.basis.xform(light_transform.basis.xform(Vector3(0, 0, 1))).normalized();
+
+				light_data.direction[0] = direction.x;
+				light_data.direction[1] = direction.y;
+				light_data.direction[2] = direction.z;
+
+				float sign = storage->light_is_negative(base) ? -1 : 1;
+
+				light_data.energy = sign * storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY) * Math_PI;
+
+				Color linear_col = storage->light_get_color(base).to_linear();
+				light_data.color[0] = linear_col.r;
+				light_data.color[1] = linear_col.g;
+				light_data.color[2] = linear_col.b;
+
+				light_data.specular = storage->light_get_param(base, RS::LIGHT_PARAM_SPECULAR);
+				light_data.mask = storage->light_get_cull_mask(base);
+
+				float size = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
+
+				light_data.size = 1.0 - Math::cos(Math::deg2rad(size)); //angle to cosine offset
+
+				Color shadow_col = storage->light_get_shadow_color(base).to_linear();
+
+				if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_PSSM_SPLITS) {
+					light_data.shadow_color1[0] = 1.0;
+					light_data.shadow_color1[1] = 0.0;
+					light_data.shadow_color1[2] = 0.0;
+					light_data.shadow_color1[3] = 1.0;
+					light_data.shadow_color2[0] = 0.0;
+					light_data.shadow_color2[1] = 1.0;
+					light_data.shadow_color2[2] = 0.0;
+					light_data.shadow_color2[3] = 1.0;
+					light_data.shadow_color3[0] = 0.0;
+					light_data.shadow_color3[1] = 0.0;
+					light_data.shadow_color3[2] = 1.0;
+					light_data.shadow_color3[3] = 1.0;
+					light_data.shadow_color4[0] = 1.0;
+					light_data.shadow_color4[1] = 1.0;
+					light_data.shadow_color4[2] = 0.0;
+					light_data.shadow_color4[3] = 1.0;
+
+				} else {
+					light_data.shadow_color1[0] = shadow_col.r;
+					light_data.shadow_color1[1] = shadow_col.g;
+					light_data.shadow_color1[2] = shadow_col.b;
+					light_data.shadow_color1[3] = 1.0;
+					light_data.shadow_color2[0] = shadow_col.r;
+					light_data.shadow_color2[1] = shadow_col.g;
+					light_data.shadow_color2[2] = shadow_col.b;
+					light_data.shadow_color2[3] = 1.0;
+					light_data.shadow_color3[0] = shadow_col.r;
+					light_data.shadow_color3[1] = shadow_col.g;
+					light_data.shadow_color3[2] = shadow_col.b;
+					light_data.shadow_color3[3] = 1.0;
+					light_data.shadow_color4[0] = shadow_col.r;
+					light_data.shadow_color4[1] = shadow_col.g;
+					light_data.shadow_color4[2] = shadow_col.b;
+					light_data.shadow_color4[3] = 1.0;
+				}
+
+				light_data.shadow_enabled = p_using_shadows && storage->light_has_shadow(base);
+
+				float angular_diameter = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
+				if (angular_diameter > 0.0) {
+					// I know tan(0) is 0, but let's not risk it with numerical precision.
+					// technically this will keep expanding until reaching the sun, but all we care
+					// is expand until we reach the radius of the near plane (there can't be more occluders than that)
+					angular_diameter = Math::tan(Math::deg2rad(angular_diameter));
+				} else {
+					angular_diameter = 0.0;
+				}
+
+				if (light_data.shadow_enabled) {
+					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);
+					for (int j = 0; j < 4; j++) {
+						Rect2 atlas_rect = light_instance_get_directional_shadow_atlas_rect(li, j);
+						CameraMatrix matrix = light_instance_get_shadow_camera(li, j);
+						float split = light_instance_get_directional_shadow_split(li, MIN(limit, j));
+
+						CameraMatrix bias;
+						bias.set_light_bias();
+						CameraMatrix rectm;
+						rectm.set_light_atlas_rect(atlas_rect);
+
+						Transform modelview = (p_camera_inverse_transform * light_instance_get_shadow_transform(li, j)).inverse();
+
+						CameraMatrix shadow_mtx = rectm * bias * matrix * modelview;
+						light_data.shadow_split_offsets[j] = split;
+						float bias_scale = light_instance_get_shadow_bias_scale(li, j);
+						light_data.shadow_bias[j] = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) * bias_scale;
+						light_data.shadow_normal_bias[j] = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * light_instance_get_directional_shadow_texel_size(li, j);
+						light_data.shadow_transmittance_bias[j] = storage->light_get_transmittance_bias(base) * bias_scale;
+						light_data.shadow_transmittance_z_scale[j] = light_instance_get_shadow_range(li, j);
+						light_data.shadow_range_begin[j] = light_instance_get_shadow_range_begin(li, j);
+						RasterizerStorageRD::store_camera(shadow_mtx, light_data.shadow_matrices[j]);
+
+						Vector2 uv_scale = light_instance_get_shadow_uv_scale(li, j);
+						uv_scale *= atlas_rect.size; //adapt to atlas size
+						switch (j) {
+							case 0: {
+								light_data.uv_scale1[0] = uv_scale.x;
+								light_data.uv_scale1[1] = uv_scale.y;
+							} break;
+							case 1: {
+								light_data.uv_scale2[0] = uv_scale.x;
+								light_data.uv_scale2[1] = uv_scale.y;
+							} break;
+							case 2: {
+								light_data.uv_scale3[0] = uv_scale.x;
+								light_data.uv_scale3[1] = uv_scale.y;
+							} break;
+							case 3: {
+								light_data.uv_scale4[0] = uv_scale.x;
+								light_data.uv_scale4[1] = uv_scale.y;
+							} break;
+						}
+					}
+
+					float fade_start = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_FADE_START);
+					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);
+					light_data.softshadow_angle = angular_diameter;
+
+					if (angular_diameter <= 0.0) {
+						light_data.soft_shadow_scale *= directional_shadow_quality_radius_get(); // Only use quality radius for PCF
+					}
+				}
+
+				//	Copy to SkyDirectionalLightData
+				if (r_directional_light_count < sky_scene_state.max_directional_lights) {
+					SkyDirectionalLightData &sky_light_data = sky_scene_state.directional_lights[r_directional_light_count];
+
+					Vector3 world_direction = light_transform.basis.xform(Vector3(0, 0, 1)).normalized();
+
+					sky_light_data.direction[0] = world_direction.x;
+					sky_light_data.direction[1] = world_direction.y;
+					sky_light_data.direction[2] = -world_direction.z;
+
+					sky_light_data.energy = light_data.energy / Math_PI;
+
+					sky_light_data.color[0] = light_data.color[0];
+					sky_light_data.color[1] = light_data.color[1];
+					sky_light_data.color[2] = light_data.color[2];
+
+					sky_light_data.enabled = true;
+					sky_light_data.size = angular_diameter;
+					sky_scene_state.directional_light_count++;
+				}
+
+				r_directional_light_count++;
+			} break;
+			case RS::LIGHT_SPOT:
+			case RS::LIGHT_OMNI: {
+				if (light_count >= cluster.max_lights) {
+					continue;
+				}
+
+				Transform light_transform = light_instance_get_base_transform(li);
+
+				Cluster::LightData &light_data = cluster.lights[light_count];
+
+				float sign = storage->light_is_negative(base) ? -1 : 1;
+				Color linear_col = storage->light_get_color(base).to_linear();
+
+				light_data.attenuation_energy[0] = Math::make_half_float(storage->light_get_param(base, RS::LIGHT_PARAM_ATTENUATION));
+				light_data.attenuation_energy[1] = Math::make_half_float(sign * storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY) * Math_PI);
+
+				light_data.color_specular[0] = MIN(uint32_t(linear_col.r * 255), 255);
+				light_data.color_specular[1] = MIN(uint32_t(linear_col.g * 255), 255);
+				light_data.color_specular[2] = MIN(uint32_t(linear_col.b * 255), 255);
+				light_data.color_specular[3] = MIN(uint32_t(storage->light_get_param(base, RS::LIGHT_PARAM_SPECULAR) * 255), 255);
+
+				float radius = MAX(0.001, storage->light_get_param(base, RS::LIGHT_PARAM_RANGE));
+				light_data.inv_radius = 1.0 / radius;
+
+				Vector3 pos = p_camera_inverse_transform.xform(light_transform.origin);
+
+				light_data.position[0] = pos.x;
+				light_data.position[1] = pos.y;
+				light_data.position[2] = pos.z;
+
+				Vector3 direction = p_camera_inverse_transform.basis.xform(light_transform.basis.xform(Vector3(0, 0, -1))).normalized();
+
+				light_data.direction[0] = direction.x;
+				light_data.direction[1] = direction.y;
+				light_data.direction[2] = direction.z;
+
+				float size = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
+
+				light_data.size = size;
+
+				light_data.cone_attenuation_angle[0] = Math::make_half_float(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_attenuation_angle[1] = Math::make_half_float(Math::cos(Math::deg2rad(spot_angle)));
+
+				light_data.mask = storage->light_get_cull_mask(base);
+
+				light_data.atlas_rect[0] = 0;
+				light_data.atlas_rect[1] = 0;
+				light_data.atlas_rect[2] = 0;
+				light_data.atlas_rect[3] = 0;
+
+				RID projector = storage->light_get_projector(base);
+
+				if (projector.is_valid()) {
+					Rect2 rect = storage->decal_atlas_get_texture_rect(projector);
+
+					if (type == RS::LIGHT_SPOT) {
+						light_data.projector_rect[0] = rect.position.x;
+						light_data.projector_rect[1] = rect.position.y + rect.size.height; //flip because shadow is flipped
+						light_data.projector_rect[2] = rect.size.width;
+						light_data.projector_rect[3] = -rect.size.height;
+					} else {
+						light_data.projector_rect[0] = rect.position.x;
+						light_data.projector_rect[1] = rect.position.y;
+						light_data.projector_rect[2] = rect.size.width;
+						light_data.projector_rect[3] = rect.size.height * 0.5; //used by dp, so needs to be half
+					}
+				} else {
+					light_data.projector_rect[0] = 0;
+					light_data.projector_rect[1] = 0;
+					light_data.projector_rect[2] = 0;
+					light_data.projector_rect[3] = 0;
+				}
+
+				if (p_using_shadows && p_shadow_atlas.is_valid() && shadow_atlas_owns_light_instance(p_shadow_atlas, li)) {
+					// fill in the shadow information
+
+					Color shadow_color = storage->light_get_shadow_color(base);
+
+					light_data.shadow_color_enabled[0] = MIN(uint32_t(shadow_color.r * 255), 255);
+					light_data.shadow_color_enabled[1] = MIN(uint32_t(shadow_color.g * 255), 255);
+					light_data.shadow_color_enabled[2] = MIN(uint32_t(shadow_color.b * 255), 255);
+					light_data.shadow_color_enabled[3] = 255;
+
+					if (type == RS::LIGHT_SPOT) {
+						light_data.shadow_bias = (storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) * radius / 10.0);
+						float shadow_texel_size = Math::tan(Math::deg2rad(spot_angle)) * radius * 2.0;
+						shadow_texel_size *= light_instance_get_shadow_texel_size(li, p_shadow_atlas);
+
+						light_data.shadow_normal_bias = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * shadow_texel_size;
+
+					} else { //omni
+						light_data.shadow_bias = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) * radius / 10.0;
+						float shadow_texel_size = light_instance_get_shadow_texel_size(li, p_shadow_atlas);
+						light_data.shadow_normal_bias = storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * shadow_texel_size * 2.0; // applied in -1 .. 1 space
+					}
+
+					light_data.transmittance_bias = storage->light_get_transmittance_bias(base);
+
+					Rect2 rect = light_instance_get_shadow_atlas_rect(li, p_shadow_atlas);
+
+					light_data.atlas_rect[0] = rect.position.x;
+					light_data.atlas_rect[1] = rect.position.y;
+					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
+						Transform proj = (p_camera_inverse_transform * light_transform).inverse();
+
+						RasterizerStorageRD::store_transform(proj, light_data.shadow_matrix);
+
+						if (size > 0.0) {
+							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) {
+						Transform modelview = (p_camera_inverse_transform * light_transform).inverse();
+						CameraMatrix bias;
+						bias.set_light_bias();
+
+						CameraMatrix shadow_mtx = bias * light_instance_get_shadow_camera(li, 0) * modelview;
+						RasterizerStorageRD::store_camera(shadow_mtx, light_data.shadow_matrix);
+
+						if (size > 0.0) {
+							CameraMatrix cm = light_instance_get_shadow_camera(li, 0);
+							float half_np = cm.get_z_near() * Math::tan(Math::deg2rad(spot_angle));
+							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 {
+					light_data.shadow_color_enabled[3] = 0;
+				}
+
+				light_instance_set_index(li, light_count);
+
+				cluster.builder.add_light(type == RS::LIGHT_SPOT ? LightClusterBuilder::LIGHT_TYPE_SPOT : LightClusterBuilder::LIGHT_TYPE_OMNI, light_transform, radius, spot_angle);
+
+				light_count++;
+			} break;
+		}
+
+		light_instance_set_render_pass(li, RSG::rasterizer->get_frame_number());
+
+		//update UBO for forward rendering, blit to texture for clustered
+	}
+
+	if (light_count) {
+		RD::get_singleton()->buffer_update(cluster.light_buffer, 0, sizeof(Cluster::LightData) * light_count, cluster.lights, true);
+	}
+
+	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, true);
+	}
+}
+
+void RasterizerSceneRD::_setup_decals(const RID *p_decal_instances, int p_decal_count, const Transform &p_camera_inverse_xform) {
+	Transform uv_xform;
+	uv_xform.basis.scale(Vector3(2.0, 1.0, 2.0));
+	uv_xform.origin = Vector3(-1.0, 0.0, -1.0);
+
+	p_decal_count = MIN((uint32_t)p_decal_count, cluster.max_decals);
+	int idx = 0;
+	for (int i = 0; i < p_decal_count; i++) {
+		RID di = p_decal_instances[i];
+		RID decal = decal_instance_get_base(di);
+
+		Transform xform = decal_instance_get_transform(di);
+
+		float fade = 1.0;
+
+		if (storage->decal_is_distance_fade_enabled(decal)) {
+			real_t distance = -p_camera_inverse_xform.xform(xform.origin).z;
+			float fade_begin = storage->decal_get_distance_fade_begin(decal);
+			float fade_length = storage->decal_get_distance_fade_length(decal);
+
+			if (distance > fade_begin) {
+				if (distance > fade_begin + fade_length) {
+					continue; // do not use this decal, its invisible
+				}
+
+				fade = 1.0 - (distance - fade_begin) / fade_length;
+			}
+		}
+
+		Cluster::DecalData &dd = cluster.decals[idx];
+
+		Vector3 decal_extents = storage->decal_get_extents(decal);
+
+		Transform scale_xform;
+		scale_xform.basis.scale(Vector3(decal_extents.x, decal_extents.y, decal_extents.z));
+		Transform to_decal_xform = (p_camera_inverse_xform * decal_instance_get_transform(di) * scale_xform * uv_xform).affine_inverse();
+		RasterizerStorageRD::store_transform(to_decal_xform, dd.xform);
+
+		Vector3 normal = xform.basis.get_axis(Vector3::AXIS_Y).normalized();
+		normal = p_camera_inverse_xform.basis.xform(normal); //camera is normalized, so fine
+
+		dd.normal[0] = normal.x;
+		dd.normal[1] = normal.y;
+		dd.normal[2] = normal.z;
+		dd.normal_fade = storage->decal_get_normal_fade(decal);
+
+		RID albedo_tex = storage->decal_get_texture(decal, RS::DECAL_TEXTURE_ALBEDO);
+		RID emission_tex = storage->decal_get_texture(decal, RS::DECAL_TEXTURE_EMISSION);
+		if (albedo_tex.is_valid()) {
+			Rect2 rect = storage->decal_atlas_get_texture_rect(albedo_tex);
+			dd.albedo_rect[0] = rect.position.x;
+			dd.albedo_rect[1] = rect.position.y;
+			dd.albedo_rect[2] = rect.size.x;
+			dd.albedo_rect[3] = rect.size.y;
+		} else {
+			if (!emission_tex.is_valid()) {
+				continue; //no albedo, no emission, no decal.
+			}
+			dd.albedo_rect[0] = 0;
+			dd.albedo_rect[1] = 0;
+			dd.albedo_rect[2] = 0;
+			dd.albedo_rect[3] = 0;
+		}
+
+		RID normal_tex = storage->decal_get_texture(decal, RS::DECAL_TEXTURE_NORMAL);
+
+		if (normal_tex.is_valid()) {
+			Rect2 rect = storage->decal_atlas_get_texture_rect(normal_tex);
+			dd.normal_rect[0] = rect.position.x;
+			dd.normal_rect[1] = rect.position.y;
+			dd.normal_rect[2] = rect.size.x;
+			dd.normal_rect[3] = rect.size.y;
+
+			Basis normal_xform = p_camera_inverse_xform.basis * xform.basis.orthonormalized();
+			RasterizerStorageRD::store_basis_3x4(normal_xform, dd.normal_xform);
+		} else {
+			dd.normal_rect[0] = 0;
+			dd.normal_rect[1] = 0;
+			dd.normal_rect[2] = 0;
+			dd.normal_rect[3] = 0;
+		}
+
+		RID orm_tex = storage->decal_get_texture(decal, RS::DECAL_TEXTURE_ORM);
+		if (orm_tex.is_valid()) {
+			Rect2 rect = storage->decal_atlas_get_texture_rect(orm_tex);
+			dd.orm_rect[0] = rect.position.x;
+			dd.orm_rect[1] = rect.position.y;
+			dd.orm_rect[2] = rect.size.x;
+			dd.orm_rect[3] = rect.size.y;
+		} else {
+			dd.orm_rect[0] = 0;
+			dd.orm_rect[1] = 0;
+			dd.orm_rect[2] = 0;
+			dd.orm_rect[3] = 0;
+		}
+
+		if (emission_tex.is_valid()) {
+			Rect2 rect = storage->decal_atlas_get_texture_rect(emission_tex);
+			dd.emission_rect[0] = rect.position.x;
+			dd.emission_rect[1] = rect.position.y;
+			dd.emission_rect[2] = rect.size.x;
+			dd.emission_rect[3] = rect.size.y;
+		} else {
+			dd.emission_rect[0] = 0;
+			dd.emission_rect[1] = 0;
+			dd.emission_rect[2] = 0;
+			dd.emission_rect[3] = 0;
+		}
+
+		Color modulate = storage->decal_get_modulate(decal);
+		dd.modulate[0] = modulate.r;
+		dd.modulate[1] = modulate.g;
+		dd.modulate[2] = modulate.b;
+		dd.modulate[3] = modulate.a * fade;
+		dd.emission_energy = storage->decal_get_emission_energy(decal) * fade;
+		dd.albedo_mix = storage->decal_get_albedo_mix(decal);
+		dd.mask = storage->decal_get_cull_mask(decal);
+		dd.upper_fade = storage->decal_get_upper_fade(decal);
+		dd.lower_fade = storage->decal_get_lower_fade(decal);
+
+		cluster.builder.add_decal(xform, decal_extents);
+
+		idx++;
+	}
+
+	if (idx > 0) {
+		RD::get_singleton()->buffer_update(cluster.decal_buffer, 0, sizeof(Cluster::DecalData) * idx, cluster.decals, true);
+	}
+}
+
 void RasterizerSceneRD::render_scene(RID p_render_buffers, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass) {
 	Color clear_color;
 	if (p_render_buffers.is_valid()) {
@@ -5637,7 +6170,31 @@ void RasterizerSceneRD::render_scene(RID p_render_buffers, const Transform &p_ca
 		}
 	}
 
-	_render_scene(p_render_buffers, p_cam_transform, p_cam_projection, p_cam_ortogonal, p_cull_result, p_cull_count, p_light_cull_result, p_light_cull_count, p_reflection_probe_cull_result, p_reflection_probe_cull_count, p_gi_probe_cull_result, p_gi_probe_cull_count, p_decal_cull_result, p_decal_cull_count, p_lightmap_cull_result, p_lightmap_cull_count, p_environment, p_camera_effects, p_shadow_atlas, p_reflection_atlas, p_reflection_probe, p_reflection_probe_pass, clear_color);
+	if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_UNSHADED) {
+		p_light_cull_count = 0;
+		p_reflection_probe_cull_count = 0;
+		p_gi_probe_cull_count = 0;
+	}
+
+	cluster.builder.begin(p_cam_transform.affine_inverse(), p_cam_projection); //prepare cluster
+
+	bool using_shadows = true;
+
+	if (p_reflection_probe.is_valid()) {
+		if (!storage->reflection_probe_renders_shadows(reflection_probe_instance_get_probe(p_reflection_probe))) {
+			using_shadows = false;
+		}
+	} else {
+		//do not render reflections when rendering a reflection probe
+		_setup_reflections(p_reflection_probe_cull_result, p_reflection_probe_cull_count, p_cam_transform.affine_inverse(), p_environment);
+	}
+
+	uint32_t directional_light_count = 0;
+	_setup_lights(p_light_cull_result, p_light_cull_count, p_cam_transform.affine_inverse(), p_shadow_atlas, using_shadows, directional_light_count);
+	_setup_decals(p_decal_cull_result, p_decal_cull_count, p_cam_transform.affine_inverse());
+	cluster.builder.bake_cluster(); //bake to cluster
+
+	_render_scene(p_render_buffers, p_cam_transform, p_cam_projection, p_cam_ortogonal, p_cull_result, p_cull_count, directional_light_count, p_gi_probe_cull_result, p_gi_probe_cull_count, p_lightmap_cull_result, p_lightmap_cull_count, p_environment, p_camera_effects, p_shadow_atlas, p_reflection_atlas, p_reflection_probe, p_reflection_probe_pass, clear_color);
 
 	if (p_render_buffers.is_valid()) {
 		RENDER_TIMESTAMP("Tonemap");
@@ -6496,6 +7053,30 @@ void RasterizerSceneRD::sdfgi_set_debug_probe_select(const Vector3 &p_position,
 
 RasterizerSceneRD *RasterizerSceneRD::singleton = nullptr;
 
+RID RasterizerSceneRD::get_cluster_builder_texture() {
+	return cluster.builder.get_cluster_texture();
+}
+
+RID RasterizerSceneRD::get_cluster_builder_indices_buffer() {
+	return cluster.builder.get_cluster_indices_buffer();
+}
+
+RID RasterizerSceneRD::get_reflection_probe_buffer() {
+	return cluster.reflection_buffer;
+}
+RID RasterizerSceneRD::get_positional_light_buffer() {
+	return cluster.light_buffer;
+}
+RID RasterizerSceneRD::get_directional_light_buffer() {
+	return cluster.directional_light_buffer;
+}
+RID RasterizerSceneRD::get_decal_buffer() {
+	return cluster.decal_buffer;
+}
+int RasterizerSceneRD::get_max_directional_lights() const {
+	return cluster.max_directional_lights;
+}
+
 RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 	storage = p_storage;
 	singleton = this;
@@ -6802,6 +7383,45 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 		}
 	}
 
+	//cluster setup
+	uint32_t uniform_max_size = RD::get_singleton()->limit_get(RD::LIMIT_MAX_UNIFORM_BUFFER_SIZE);
+
+	{ //reflections
+		uint32_t reflection_buffer_size;
+		if (uniform_max_size < 65536) {
+			//Yes, you guessed right, ARM again
+			reflection_buffer_size = uniform_max_size;
+		} else {
+			reflection_buffer_size = 65536;
+		}
+
+		cluster.max_reflections = reflection_buffer_size / sizeof(Cluster::ReflectionData);
+		cluster.reflections = memnew_arr(Cluster::ReflectionData, cluster.max_reflections);
+		cluster.reflection_buffer = RD::get_singleton()->storage_buffer_create(reflection_buffer_size);
+	}
+
+	{ //lights
+		cluster.max_lights = MIN(1024 * 1024, uniform_max_size) / sizeof(Cluster::LightData); //1mb of lights
+		uint32_t light_buffer_size = cluster.max_lights * sizeof(Cluster::LightData);
+		cluster.lights = memnew_arr(Cluster::LightData, cluster.max_lights);
+		cluster.light_buffer = RD::get_singleton()->storage_buffer_create(light_buffer_size);
+		//defines += "\n#define MAX_LIGHT_DATA_STRUCTS " + itos(cluster.max_lights) + "\n";
+
+		cluster.max_directional_lights = 8;
+		uint32_t directional_light_buffer_size = cluster.max_directional_lights * sizeof(Cluster::DirectionalLightData);
+		cluster.directional_lights = memnew_arr(Cluster::DirectionalLightData, cluster.max_directional_lights);
+		cluster.directional_light_buffer = RD::get_singleton()->uniform_buffer_create(directional_light_buffer_size);
+	}
+
+	{ //decals
+		cluster.max_decals = MIN(1024 * 1024, uniform_max_size) / sizeof(Cluster::DecalData); //1mb of decals
+		uint32_t decal_buffer_size = cluster.max_decals * sizeof(Cluster::DecalData);
+		cluster.decals = memnew_arr(Cluster::DecalData, cluster.max_decals);
+		cluster.decal_buffer = RD::get_singleton()->storage_buffer_create(decal_buffer_size);
+	}
+
+	cluster.builder.setup(16, 8, 24);
+
 	default_giprobe_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(GI::GIProbeData) * RenderBuffers::MAX_GIPROBES);
 
 	camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokehShape(int(GLOBAL_GET("rendering/quality/depth_of_field/depth_of_field_bokeh_shape"))));
@@ -6863,4 +7483,15 @@ RasterizerSceneRD::~RasterizerSceneRD() {
 	memdelete_arr(directional_soft_shadow_kernel);
 	memdelete_arr(penumbra_shadow_kernel);
 	memdelete_arr(soft_shadow_kernel);
+
+	{
+		RD::get_singleton()->free(cluster.directional_light_buffer);
+		RD::get_singleton()->free(cluster.light_buffer);
+		RD::get_singleton()->free(cluster.reflection_buffer);
+		RD::get_singleton()->free(cluster.decal_buffer);
+		memdelete_arr(cluster.directional_lights);
+		memdelete_arr(cluster.lights);
+		memdelete_arr(cluster.reflections);
+		memdelete_arr(cluster.decals);
+	}
 }
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
index bbc0f536aa..27eec44ec3 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
@@ -34,6 +34,7 @@
 #include "core/local_vector.h"
 #include "core/rid_owner.h"
 #include "servers/rendering/rasterizer.h"
+#include "servers/rendering/rasterizer_rd/light_cluster_builder.h"
 #include "servers/rendering/rasterizer_rd/rasterizer_storage_rd.h"
 #include "servers/rendering/rasterizer_rd/shaders/gi.glsl.gen.h"
 #include "servers/rendering/rasterizer_rd/shaders/giprobe.glsl.gen.h"
@@ -77,7 +78,11 @@ protected:
 	};
 	virtual RenderBufferData *_create_render_buffer_data() = 0;
 
-	virtual void _render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_color) = 0;
+	void _setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, RID p_shadow_atlas, bool p_using_shadows, uint32_t &r_directional_light_count);
+	void _setup_decals(const RID *p_decal_instances, int p_decal_count, const Transform &p_camera_inverse_xform);
+	void _setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, RID p_environment);
+
+	virtual void _render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_color) = 0;
 	virtual void _render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool use_dp_flip, bool p_use_pancake) = 0;
 	virtual void _render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) = 0;
 	virtual void _render_uv2(InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) = 0;
@@ -1181,6 +1186,112 @@ private:
 	void _render_buffers_post_process_and_tonemap(RID p_render_buffers, RID p_environment, RID p_camera_effects, const CameraMatrix &p_projection);
 	void _sdfgi_debug_draw(RID p_render_buffers, const CameraMatrix &p_projection, const Transform &p_transform);
 
+	/* Cluster */
+
+	struct Cluster {
+		/* Scene State UBO */
+
+		struct ReflectionData { //should always be 128 bytes
+			float box_extents[3];
+			float index;
+			float box_offset[3];
+			uint32_t mask;
+			float params[4]; // intensity, 0, interior , boxproject
+			float ambient[3]; // ambient color,
+			uint32_t ambient_mode;
+			float local_matrix[16]; // up to here for spot and omni, rest is for directional
+		};
+
+		struct LightData {
+			float position[3];
+			float inv_radius;
+			float direction[3];
+			float size;
+			uint16_t attenuation_energy[2]; //16 bits attenuation, then energy
+			uint8_t color_specular[4]; //rgb color, a specular (8 bit unorm)
+			uint16_t cone_attenuation_angle[2]; // attenuation and angle, (16bit float)
+			uint8_t shadow_color_enabled[4]; //shadow rgb color, a>0.5 enabled (8bit unorm)
+			float atlas_rect[4]; // in omni, used for atlas uv, in spot, used for projector uv
+			float shadow_matrix[16];
+			float shadow_bias;
+			float shadow_normal_bias;
+			float transmittance_bias;
+			float soft_shadow_size;
+			float soft_shadow_scale;
+			uint32_t mask;
+			uint32_t pad[2];
+			float projector_rect[4];
+		};
+
+		struct DirectionalLightData {
+			float direction[3];
+			float energy;
+			float color[3];
+			float size;
+			float specular;
+			uint32_t mask;
+			float softshadow_angle;
+			float soft_shadow_scale;
+			uint32_t blend_splits;
+			uint32_t shadow_enabled;
+			float fade_from;
+			float fade_to;
+			float shadow_bias[4];
+			float shadow_normal_bias[4];
+			float shadow_transmittance_bias[4];
+			float shadow_transmittance_z_scale[4];
+			float shadow_range_begin[4];
+			float shadow_split_offsets[4];
+			float shadow_matrices[4][16];
+			float shadow_color1[4];
+			float shadow_color2[4];
+			float shadow_color3[4];
+			float shadow_color4[4];
+			float uv_scale1[2];
+			float uv_scale2[2];
+			float uv_scale3[2];
+			float uv_scale4[2];
+		};
+
+		struct DecalData {
+			float xform[16];
+			float inv_extents[3];
+			float albedo_mix;
+			float albedo_rect[4];
+			float normal_rect[4];
+			float orm_rect[4];
+			float emission_rect[4];
+			float modulate[4];
+			float emission_energy;
+			uint32_t mask;
+			float upper_fade;
+			float lower_fade;
+			float normal_xform[12];
+			float normal[3];
+			float normal_fade;
+		};
+
+		ReflectionData *reflections;
+		uint32_t max_reflections;
+		RID reflection_buffer;
+		uint32_t max_reflection_probes_per_instance;
+
+		DecalData *decals;
+		uint32_t max_decals;
+		RID decal_buffer;
+
+		LightData *lights;
+		uint32_t max_lights;
+		RID light_buffer;
+
+		DirectionalLightData *directional_lights;
+		uint32_t max_directional_lights;
+		RID directional_light_buffer;
+
+		LightClusterBuilder builder;
+
+	} cluster;
+
 	uint64_t scene_pass = 0;
 	uint64_t shadow_atlas_realloc_tolerance_msec = 500;
 
@@ -1655,6 +1766,14 @@ public:
 
 	virtual void set_time(double p_time, double p_step);
 
+	RID get_cluster_builder_texture();
+	RID get_cluster_builder_indices_buffer();
+	RID get_reflection_probe_buffer();
+	RID get_positional_light_buffer();
+	RID get_directional_light_buffer();
+	RID get_decal_buffer();
+	int get_max_directional_lights() const;
+
 	void sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir);
 
 	RasterizerSceneRD(RasterizerStorageRD *p_storage);
diff --git a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h b/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h
index b1146f1386..b7aedf8717 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h
+++ b/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h
@@ -40,6 +40,69 @@
 
 class RasterizerStorageRD : public RasterizerStorage {
 public:
+	static _FORCE_INLINE_ void store_transform(const Transform &p_mtx, float *p_array) {
+		p_array[0] = p_mtx.basis.elements[0][0];
+		p_array[1] = p_mtx.basis.elements[1][0];
+		p_array[2] = p_mtx.basis.elements[2][0];
+		p_array[3] = 0;
+		p_array[4] = p_mtx.basis.elements[0][1];
+		p_array[5] = p_mtx.basis.elements[1][1];
+		p_array[6] = p_mtx.basis.elements[2][1];
+		p_array[7] = 0;
+		p_array[8] = p_mtx.basis.elements[0][2];
+		p_array[9] = p_mtx.basis.elements[1][2];
+		p_array[10] = p_mtx.basis.elements[2][2];
+		p_array[11] = 0;
+		p_array[12] = p_mtx.origin.x;
+		p_array[13] = p_mtx.origin.y;
+		p_array[14] = p_mtx.origin.z;
+		p_array[15] = 1;
+	}
+
+	static _FORCE_INLINE_ void store_basis_3x4(const Basis &p_mtx, float *p_array) {
+		p_array[0] = p_mtx.elements[0][0];
+		p_array[1] = p_mtx.elements[1][0];
+		p_array[2] = p_mtx.elements[2][0];
+		p_array[3] = 0;
+		p_array[4] = p_mtx.elements[0][1];
+		p_array[5] = p_mtx.elements[1][1];
+		p_array[6] = p_mtx.elements[2][1];
+		p_array[7] = 0;
+		p_array[8] = p_mtx.elements[0][2];
+		p_array[9] = p_mtx.elements[1][2];
+		p_array[10] = p_mtx.elements[2][2];
+		p_array[11] = 0;
+	}
+
+	static _FORCE_INLINE_ void store_transform_3x3(const Basis &p_mtx, float *p_array) {
+		p_array[0] = p_mtx.elements[0][0];
+		p_array[1] = p_mtx.elements[1][0];
+		p_array[2] = p_mtx.elements[2][0];
+		p_array[3] = 0;
+		p_array[4] = p_mtx.elements[0][1];
+		p_array[5] = p_mtx.elements[1][1];
+		p_array[6] = p_mtx.elements[2][1];
+		p_array[7] = 0;
+		p_array[8] = p_mtx.elements[0][2];
+		p_array[9] = p_mtx.elements[1][2];
+		p_array[10] = p_mtx.elements[2][2];
+		p_array[11] = 0;
+	}
+
+	static _FORCE_INLINE_ void store_camera(const CameraMatrix &p_mtx, float *p_array) {
+		for (int i = 0; i < 4; i++) {
+			for (int j = 0; j < 4; j++) {
+				p_array[i * 4 + j] = p_mtx.matrix[i][j];
+			}
+		}
+	}
+
+	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];
+		}
+	}
+
 	enum ShaderType {
 		SHADER_TYPE_2D,
 		SHADER_TYPE_3D,
diff --git a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
index d6a56b2543..792a1aa05f 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
@@ -2685,7 +2685,7 @@ FRAGMENT_SHADER_CODE
 	frag_color = vec4(albedo, alpha);
 #else
 	frag_color = vec4(emission + ambient_light + diffuse_light + specular_light, alpha);
-	//frag_color = vec4(1.0);
+	//frag_color = vec4(1.0);;;
 
 #endif //USE_NO_SHADING
 
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 1244599097..c4dc7bd675 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl
+++ b/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl
@@ -205,8 +205,8 @@ struct ReflectionData {
 	// notes: for ambientblend, use distance to edge to blend between already existing global environment
 };
 
-layout(set = 0, binding = 6, std140) uniform ReflectionProbeData {
-	ReflectionData data[MAX_REFLECTION_DATA_STRUCTS];
+layout(set = 0, binding = 6) buffer restrict readonly ReflectionProbeData {
+	ReflectionData data[];
 }
 reflections;