Addition of SDFGI for open world global illumination

Move GI to a deferred pass
2025-11-06 12:20:30 +00:00 · 2020-06-25 10:33:28 -03:00
parent b92477d77e
commit 201d606b3d
53 changed files with 8966 additions and 1033 deletions
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
+++ b/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
@@ -31,22 +31,22 @@
 #ifndef RASTERIZER_SCENE_RD_H
 #define RASTERIZER_SCENE_RD_H

+#include "core/local_vector.h"
 #include "core/rid_owner.h"
 #include "servers/rendering/rasterizer.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"
 #include "servers/rendering/rasterizer_rd/shaders/giprobe_debug.glsl.gen.h"
+#include "servers/rendering/rasterizer_rd/shaders/sdfgi_debug.glsl.gen.h"
+#include "servers/rendering/rasterizer_rd/shaders/sdfgi_debug_probes.glsl.gen.h"
+#include "servers/rendering/rasterizer_rd/shaders/sdfgi_direct_light.glsl.gen.h"
+#include "servers/rendering/rasterizer_rd/shaders/sdfgi_integrate.glsl.gen.h"
+#include "servers/rendering/rasterizer_rd/shaders/sdfgi_preprocess.glsl.gen.h"
 #include "servers/rendering/rasterizer_rd/shaders/sky.glsl.gen.h"
 #include "servers/rendering/rendering_device.h"

 class RasterizerSceneRD : public RasterizerScene {
-public:
-	enum GIProbeQuality {
-		GIPROBE_QUALITY_ULTRA_LOW,
-		GIPROBE_QUALITY_MEDIUM,
-		GIPROBE_QUALITY_HIGH,
-	};
-
 protected:
 	double time;

@@ -81,23 +81,27 @@ protected:
 	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;
+	virtual void _render_sdfgi(RID p_render_buffers, const Vector3i &p_from, const Vector3i &p_size, const AABB &p_bounds, InstanceBase **p_cull_result, int p_cull_count, const RID &p_albedo_texture, const RID &p_emission_texture, const RID &p_emission_aniso_texture, const RID &p_geom_facing_texture) = 0;

 	virtual void _debug_giprobe(RID p_gi_probe, RenderingDevice::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform, bool p_lighting, bool p_emission, float p_alpha);
+	void _debug_sdfgi_probes(RID p_render_buffers, RD::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform);

 	RenderBufferData *render_buffers_get_data(RID p_render_buffers);

 	virtual void _base_uniforms_changed() = 0;
 	virtual void _render_buffers_uniform_set_changed(RID p_render_buffers) = 0;
-	virtual RID _render_buffers_get_roughness_texture(RID p_render_buffers) = 0;
 	virtual RID _render_buffers_get_normal_texture(RID p_render_buffers) = 0;
+	virtual RID _render_buffers_get_ambient_texture(RID p_render_buffers) = 0;
+	virtual RID _render_buffers_get_reflection_texture(RID p_render_buffers) = 0;

 	void _process_ssao(RID p_render_buffers, RID p_environment, RID p_normal_buffer, const CameraMatrix &p_projection);
-	void _process_ssr(RID p_render_buffers, RID p_dest_framebuffer, RID p_normal_buffer, RID p_roughness_buffer, RID p_specular_buffer, RID p_metallic, const Color &p_metallic_mask, RID p_environment, const CameraMatrix &p_projection, bool p_use_additive);
+	void _process_ssr(RID p_render_buffers, RID p_dest_framebuffer, RID p_normal_buffer, RID p_specular_buffer, RID p_metallic, const Color &p_metallic_mask, RID p_environment, const CameraMatrix &p_projection, bool p_use_additive);
 	void _process_sss(RID p_render_buffers, const CameraMatrix &p_camera);

 	void _setup_sky(RID p_environment, const Vector3 &p_position, const Size2i p_screen_size);
 	void _update_sky(RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform);
 	void _draw_sky(bool p_can_continue_color, bool p_can_continue_depth, RID p_fb, RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform);
+	void _process_gi(RID p_render_buffers, RID p_normal_roughness_buffer, RID p_ambient_buffer, RID p_reflection_buffer, RID p_gi_probe_buffer, RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count);

 private:
 	RS::ViewportDebugDraw debug_draw = RS::VIEWPORT_DEBUG_DRAW_DISABLED;
@@ -267,6 +271,8 @@ private:
 		SkyMaterialData *prev_material;
 		Vector3 prev_position;
 		float prev_time;
+
+		RID sdfgi_integrate_sky_uniform_set;
 	};

 	Sky *dirty_sky_list = nullptr;
@@ -388,13 +394,10 @@ private:
 	struct GIProbeInstance {
 		RID probe;
 		RID texture;
-		RID anisotropy[2]; //only if anisotropy is used
-		RID anisotropy_r16[2]; //only if anisotropy is used
 		RID write_buffer;

 		struct Mipmap {
 			RID texture;
-			RID anisotropy[2]; //only if anisotropy is used
 			RID uniform_set;
 			RID second_bounce_uniform_set;
 			RID write_uniform_set;
@@ -423,7 +426,7 @@ private:
 		uint32_t last_probe_version = 0;
 		uint32_t last_probe_data_version = 0;

-		uint64_t last_pass = 0;
+		//uint64_t last_pass = 0;
 		uint32_t render_index = 0;

 		bool has_dynamic_object_data = false;
@@ -435,11 +438,6 @@ private:
 	uint32_t gi_probe_max_lights;
 	RID gi_probe_lights_uniform;

-	bool gi_probe_use_anisotropy = false;
-	GIProbeQuality gi_probe_quality = GIPROBE_QUALITY_MEDIUM;
-
-	Vector<RID> gi_probe_slots;
-
 	enum {
 		GI_PROBE_SHADER_VERSION_COMPUTE_LIGHT,
 		GI_PROBE_SHADER_VERSION_COMPUTE_SECOND_BOUNCE,
@@ -458,6 +456,8 @@ private:

 	mutable RID_Owner<GIProbeInstance> gi_probe_instance_owner;

+	RS::GIProbeQuality gi_probe_quality = RS::GI_PROBE_QUALITY_HIGH;
+
 	enum {
 		GI_PROBE_DEBUG_COLOR,
 		GI_PROBE_DEBUG_LIGHT,
@@ -591,6 +591,7 @@ private:

 		ShadowTransform shadow_transform[4];

+		AABB aabb;
 		RID self;
 		RID light;
 		Transform transform;
@@ -680,6 +681,19 @@ private:
 		float ssr_fade_in = 0.15;
 		float ssr_fade_out = 2.0;
 		float ssr_depth_tolerance = 0.2;
+
+		/// SDFGI
+		bool sdfgi_enabled = false;
+		RS::EnvironmentSDFGICascades sdfgi_cascades;
+		float sdfgi_min_cell_size = 0.2;
+		bool sdfgi_use_occlusion = false;
+		bool sdfgi_use_multibounce = false;
+		bool sdfgi_read_sky_light = false;
+		bool sdfgi_enhance_ssr = false;
+		float sdfgi_energy = 1.0;
+		float sdfgi_normal_bias = 1.1;
+		float sdfgi_probe_bias = 1.1;
+		RS::EnvironmentSDFGIYScale sdfgi_y_scale = RS::ENV_SDFGI_Y_SCALE_DISABLED;
 	};

 	RS::EnvironmentSSAOQuality ssao_quality = RS::ENV_SSAO_QUALITY_MEDIUM;
@@ -719,7 +733,13 @@ private:

 	/* RENDER BUFFERS */

+	struct SDFGI;
+
 	struct RenderBuffers {
+		enum {
+			MAX_GIPROBES = 8
+		};
+
 		RenderBufferData *data = nullptr;
 		int width = 0, height = 0;
 		RS::ViewportMSAA msaa = RS::VIEWPORT_MSAA_DISABLED;
@@ -732,6 +752,9 @@ private:
 		RID texture; //main texture for rendering to, must be filled after done rendering
 		RID depth_texture; //main depth texture

+		RID gi_uniform_set;
+		SDFGI *sdfgi = nullptr;
+
 		//built-in textures used for ping pong image processing and blurring
 		struct Blur {
 			RID texture;
@@ -764,10 +787,389 @@ private:
 			RID depth_scaled;
 			RID blur_radius[2];
 		} ssr;
+
+		RID giprobe_textures[MAX_GIPROBES];
+		RID giprobe_buffer;
 	};

+	RID default_giprobe_buffer;
+
+	/* SDFGI */
+
+	struct SDFGI {
+		enum {
+			MAX_CASCADES = 8,
+			CASCADE_SIZE = 128,
+			PROBE_DIVISOR = 16,
+			ANISOTROPY_SIZE = 6,
+			MAX_DYNAMIC_LIGHTS = 128,
+			MAX_STATIC_LIGHTS = 1024,
+			LIGHTPROBE_OCT_SIZE = 6,
+			SH_SIZE = 16
+		};
+
+		struct Cascade {
+			struct UBO {
+				float offset[3];
+				float to_cell;
+				int32_t probe_offset[3];
+				uint32_t pad;
+			};
+
+			//cascade blocks are full-size for volume (128^3), half size for albedo/emission
+			RID sdf_tex;
+			RID light_tex;
+			RID light_aniso_0_tex;
+			RID light_aniso_1_tex;
+
+			RID light_data;
+			RID light_aniso_0_data;
+			RID light_aniso_1_data;
+
+			struct SolidCell { // this struct is unused, but remains as reference for size
+				uint32_t position;
+				uint32_t albedo;
+				uint32_t static_light;
+				uint32_t static_light_aniso;
+			};
+
+			RID solid_cell_dispatch_buffer; //buffer for indirect compute dispatch
+			RID solid_cell_buffer;
+
+			RID lightprobe_history_tex;
+			RID lightprobe_average_tex;
+
+			float cell_size;
+			Vector3i position;
+
+			static const Vector3i DIRTY_ALL;
+			Vector3i dirty_regions; //(0,0,0 is not dirty, negative is refresh from the end, DIRTY_ALL is refresh all.
+
+			RID sdf_store_uniform_set;
+			RID sdf_direct_light_uniform_set;
+			RID scroll_uniform_set;
+			RID scroll_occlusion_uniform_set;
+			RID integrate_uniform_set;
+			RID lights_buffer;
+		};
+
+		//used for rendering (voxelization)
+		RID render_albedo;
+		RID render_emission;
+		RID render_emission_aniso;
+		RID render_occlusion[8];
+		RID render_geom_facing;
+
+		RID render_sdf[2];
+		RID render_sdf_half[2];
+
+		//used for ping pong processing in cascades
+		RID sdf_initialize_uniform_set;
+		RID sdf_initialize_half_uniform_set;
+		RID jump_flood_uniform_set[2];
+		RID jump_flood_half_uniform_set[2];
+		RID sdf_upscale_uniform_set;
+		int upscale_jfa_uniform_set_index;
+		RID occlusion_uniform_set;
+
+		uint32_t cascade_size = 128;
+
+		LocalVector<Cascade> cascades;
+
+		RID lightprobe_texture;
+		RID lightprobe_data;
+		RID occlusion_texture;
+		RID occlusion_data;
+
+		RID lightprobe_history_scroll; //used for scrolling lightprobes
+		RID lightprobe_average_scroll; //used for scrolling lightprobes
+
+		uint32_t history_size = 0;
+		float solid_cell_ratio = 0;
+		uint32_t solid_cell_count = 0;
+
+		RS::EnvironmentSDFGICascades cascade_mode;
+		float min_cell_size = 0;
+		uint32_t probe_axis_count = 0; //amount of probes per axis, this is an odd number because it encloses endpoints
+
+		RID debug_uniform_set;
+		RID debug_probes_uniform_set;
+		RID cascades_ubo;
+
+		bool uses_occlusion = false;
+		bool uses_multibounce = false;
+		bool reads_sky = false;
+		float energy = 1.0;
+		float normal_bias = 1.1;
+		float probe_bias = 1.1;
+		RS::EnvironmentSDFGIYScale y_scale_mode = RS::ENV_SDFGI_Y_SCALE_DISABLED;
+
+		float y_mult = 1.0;
+
+		uint32_t render_pass = 0;
+	};
+
+	RS::EnvironmentSDFGIRayCount sdfgi_ray_count = RS::ENV_SDFGI_RAY_COUNT_16;
+	RS::EnvironmentSDFGIFramesToConverge sdfgi_frames_to_converge = RS::ENV_SDFGI_CONVERGE_IN_10_FRAMES;
+	float sdfgi_solid_cell_ratio = 0.25;
+	Vector3 sdfgi_debug_probe_pos;
+	Vector3 sdfgi_debug_probe_dir;
+	bool sdfgi_debug_probe_enabled = false;
+	Vector3i sdfgi_debug_probe_index;
+
+	struct SDGIShader {
+		enum SDFGIPreprocessShaderVersion {
+			PRE_PROCESS_SCROLL,
+			PRE_PROCESS_SCROLL_OCCLUSION,
+			PRE_PROCESS_JUMP_FLOOD_INITIALIZE,
+			PRE_PROCESS_JUMP_FLOOD_INITIALIZE_HALF,
+			PRE_PROCESS_JUMP_FLOOD,
+			PRE_PROCESS_JUMP_FLOOD_OPTIMIZED,
+			PRE_PROCESS_JUMP_FLOOD_UPSCALE,
+			PRE_PROCESS_OCCLUSION,
+			PRE_PROCESS_STORE,
+			PRE_PROCESS_MAX
+		};
+
+		struct PreprocessPushConstant {
+			int32_t scroll[3];
+			int32_t grid_size;
+
+			int32_t probe_offset[3];
+			int32_t step_size;
+
+			int32_t half_size;
+			uint32_t occlusion_index;
+			int32_t cascade;
+			uint32_t pad;
+		};
+
+		SdfgiPreprocessShaderRD preprocess;
+		RID preprocess_shader;
+		RID preprocess_pipeline[PRE_PROCESS_MAX];
+
+		struct DebugPushConstant {
+			float grid_size[3];
+			uint32_t max_cascades;
+
+			int32_t screen_size[2];
+			uint32_t use_occlusion;
+			float y_mult;
+
+			float cam_extent[3];
+			uint32_t probe_axis_size;
+
+			float cam_transform[16];
+		};
+
+		SdfgiDebugShaderRD debug;
+		RID debug_shader;
+		RID debug_shader_version;
+		RID debug_pipeline;
+
+		enum ProbeDebugMode {
+			PROBE_DEBUG_PROBES,
+			PROBE_DEBUG_VISIBILITY,
+			PROBE_DEBUG_MAX
+		};
+
+		struct DebugProbesPushConstant {
+			float projection[16];
+
+			uint32_t band_power;
+			uint32_t sections_in_band;
+			uint32_t band_mask;
+			float section_arc;
+
+			float grid_size[3];
+			uint32_t cascade;
+
+			uint32_t pad;
+			float y_mult;
+			int32_t probe_debug_index;
+			int32_t probe_axis_size;
+		};
+
+		SdfgiDebugProbesShaderRD debug_probes;
+		RID debug_probes_shader;
+		RID debug_probes_shader_version;
+
+		RenderPipelineVertexFormatCacheRD debug_probes_pipeline[PROBE_DEBUG_MAX];
+
+		struct Light {
+			float color[3];
+			float energy;
+
+			float direction[3];
+			uint32_t has_shadow;
+
+			float position[3];
+			float attenuation;
+
+			uint32_t type;
+			float spot_angle;
+			float spot_attenuation;
+			float radius;
+
+			float shadow_color[4];
+		};
+
+		struct DirectLightPushConstant {
+			float grid_size[3];
+			uint32_t max_cascades;
+
+			uint32_t cascade;
+			uint32_t light_count;
+			uint32_t process_offset;
+			uint32_t process_increment;
+
+			int32_t probe_axis_size;
+			uint32_t multibounce;
+			float y_mult;
+			uint32_t pad;
+		};
+
+		enum {
+			DIRECT_LIGHT_MODE_STATIC,
+			DIRECT_LIGHT_MODE_DYNAMIC,
+			DIRECT_LIGHT_MODE_MAX
+		};
+		SdfgiDirectLightShaderRD direct_light;
+		RID direct_light_shader;
+		RID direct_light_pipeline[DIRECT_LIGHT_MODE_MAX];
+
+		enum {
+			INTEGRATE_MODE_PROCESS,
+			INTEGRATE_MODE_STORE,
+			INTEGRATE_MODE_SCROLL,
+			INTEGRATE_MODE_SCROLL_STORE,
+			INTEGRATE_MODE_MAX
+		};
+		struct IntegratePushConstant {
+			enum {
+				SKY_MODE_DISABLED,
+				SKY_MODE_COLOR,
+				SKY_MODE_SKY,
+			};
+
+			float grid_size[3];
+			uint32_t max_cascades;
+
+			uint32_t probe_axis_size;
+			uint32_t cascade;
+			uint32_t history_index;
+			uint32_t history_size;
+
+			uint32_t ray_count;
+			float ray_bias;
+			int32_t image_size[2];
+
+			int32_t world_offset[3];
+			uint32_t sky_mode;
+
+			int32_t scroll[3];
+			float sky_energy;
+
+			float sky_color[3];
+			float y_mult;
+		};
+
+		SdfgiIntegrateShaderRD integrate;
+		RID integrate_shader;
+		RID integrate_pipeline[INTEGRATE_MODE_MAX];
+
+		RID integrate_default_sky_uniform_set;
+
+	} sdfgi_shader;
+
+	void _sdfgi_erase(RenderBuffers *rb);
+	int _sdfgi_get_pending_region_data(RID p_render_buffers, int p_region, Vector3i &r_local_offset, Vector3i &r_local_size, AABB &r_bounds) const;
+	void _sdfgi_update_cascades(RID p_render_buffers);
+
+	/* GI */
+
+	struct GI {
+		struct SDFGIData {
+			float grid_size[3];
+			uint32_t max_cascades;
+
+			uint32_t use_occlusion;
+			int32_t probe_axis_size;
+			float probe_to_uvw;
+			float normal_bias;
+
+			float lightprobe_tex_pixel_size[3];
+			float energy;
+
+			float lightprobe_uv_offset[3];
+			float y_mult;
+
+			float occlusion_clamp[3];
+			uint32_t pad3;
+
+			float occlusion_renormalize[3];
+			uint32_t pad4;
+
+			float cascade_probe_size[3];
+			uint32_t pad5;
+
+			struct ProbeCascadeData {
+				float position[3]; //offset of (0,0,0) in world coordinates
+				float to_probe; // 1/bounds * grid_size
+				int32_t probe_world_offset[3];
+				float to_cell; // 1/bounds * grid_size
+			};
+
+			ProbeCascadeData cascades[SDFGI::MAX_CASCADES];
+		};
+
+		struct GIProbeData {
+			float xform[16];
+			float bounds[3];
+			float dynamic_range;
+
+			float bias;
+			float normal_bias;
+			uint32_t blend_ambient;
+			uint32_t texture_slot;
+
+			float anisotropy_strength;
+			float ao;
+			float ao_size;
+			uint32_t pad[1];
+		};
+
+		struct PushConstant {
+			int32_t screen_size[2];
+			float z_near;
+			float z_far;
+
+			float proj_info[4];
+
+			uint32_t max_giprobes;
+			uint32_t high_quality_vct;
+			uint32_t use_sdfgi;
+			uint32_t orthogonal;
+
+			float ao_color[3];
+			uint32_t pad;
+
+			float cam_rotation[12];
+		};
+
+		RID sdfgi_ubo;
+		enum {
+			MODE_MAX = 1
+		};
+
+		GiShaderRD shader;
+		RID shader_version;
+		RID pipelines[MODE_MAX];
+	} gi;
+
 	bool screen_space_roughness_limiter = false;
-	float screen_space_roughness_limiter_curve = 1.0;
+	float screen_space_roughness_limiter_amount = 0.25;
+	float screen_space_roughness_limiter_limit = 0.18;

 	mutable RID_Owner<RenderBuffers> render_buffers_owner;

@@ -777,10 +1179,16 @@ private:

 	void _render_buffers_debug_draw(RID p_render_buffers, RID p_shadow_atlas);
 	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);

 	uint64_t scene_pass = 0;
 	uint64_t shadow_atlas_realloc_tolerance_msec = 500;

+	struct SDFGICosineNeighbour {
+		uint32_t neighbour;
+		float weight;
+	};
+
 public:
 	/* SHADOW ATLAS API */

@@ -818,6 +1226,15 @@ public:
 		return Size2i(directional_shadow.size, directional_shadow.size);
 	}

+	/* SDFGI UPDATE */
+
+	int sdfgi_get_lightprobe_octahedron_size() const { return SDFGI::LIGHTPROBE_OCT_SIZE; }
+	virtual void sdfgi_update(RID p_render_buffers, RID p_environment, const Vector3 &p_world_position);
+	virtual int sdfgi_get_pending_region_count(RID p_render_buffers) const;
+	virtual AABB sdfgi_get_pending_region_bounds(RID p_render_buffers, int p_region) const;
+	virtual uint32_t sdfgi_get_pending_region_cascade(RID p_render_buffers, int p_region) const;
+	virtual void sdfgi_update_probes(RID p_render_buffers, RID p_environment, const RID *p_directional_light_instances, uint32_t p_directional_light_count, const RID *p_positional_light_instances, uint32_t p_positional_light_count);
+	RID sdfgi_get_ubo() const { return gi.sdfgi_ubo; }
 	/* SKY API */

 	RID sky_create();
@@ -871,6 +1288,11 @@ public:
 	float environment_get_ssao_ao_affect(RID p_env) const;
 	float environment_get_ssao_light_affect(RID p_env) const;
 	bool environment_is_ssr_enabled(RID p_env) const;
+	bool environment_is_sdfgi_enabled(RID p_env) const;
+
+	virtual void environment_set_sdfgi(RID p_env, bool p_enable, RS::EnvironmentSDFGICascades p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, bool p_use_multibounce, bool p_read_sky, bool p_enhance_ssr, float p_energy, float p_normal_bias, float p_probe_bias);
+	virtual void environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count);
+	virtual void environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames);

 	void environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality);
 	RS::EnvironmentSSRRoughnessQuality environment_get_ssr_roughness_quality() const;
@@ -894,6 +1316,7 @@ public:

 	RID light_instance_create(RID p_light);
 	void light_instance_set_transform(RID p_light_instance, const Transform &p_transform);
+	void light_instance_set_aabb(RID p_light_instance, const AABB &p_aabb);
 	void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale = 1.0, float p_range_begin = 0, const Vector2 &p_uv_scale = Vector2());
 	void light_instance_mark_visible(RID p_light_instance);

@@ -1107,6 +1530,8 @@ public:
 	bool gi_probe_needs_update(RID p_probe) const;
 	void gi_probe_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, int p_dynamic_object_count, InstanceBase **p_dynamic_objects);

+	void gi_probe_set_quality(RS::GIProbeQuality p_quality) { gi_probe_quality = p_quality; }
+
 	_FORCE_INLINE_ uint32_t gi_probe_instance_get_slot(RID p_probe) {
 		GIProbeInstance *gi_probe = gi_probe_instance_owner.getornull(p_probe);
 		return gi_probe->slot;
@@ -1124,10 +1549,6 @@ public:
 		GIProbeInstance *gi_probe = gi_probe_instance_owner.getornull(p_probe);
 		return gi_probe->texture;
 	}
-	_FORCE_INLINE_ RID gi_probe_instance_get_aniso_texture(RID p_probe, int p_index) {
-		GIProbeInstance *gi_probe = gi_probe_instance_owner.getornull(p_probe);
-		return gi_probe->anisotropy[p_index];
-	}

 	_FORCE_INLINE_ void gi_probe_instance_set_render_index(RID p_instance, uint32_t p_render_index) {
 		GIProbeInstance *gi_probe = gi_probe_instance_owner.getornull(p_instance);
@@ -1141,7 +1562,7 @@ public:

 		return gi_probe->render_index;
 	}
-
+	/*
 	_FORCE_INLINE_ void gi_probe_instance_set_render_pass(RID p_instance, uint32_t p_render_pass) {
 		GIProbeInstance *g_probe = gi_probe_instance_owner.getornull(p_instance);
 		ERR_FAIL_COND(!g_probe);
@@ -1154,18 +1575,27 @@ public:

 		return g_probe->last_pass;
 	}
-
-	const Vector<RID> &gi_probe_get_slots() const;
-	_FORCE_INLINE_ bool gi_probe_is_anisotropic() const {
-		return gi_probe_use_anisotropy;
-	}
-	GIProbeQuality gi_probe_get_quality() const;
-
+*/
 	RID render_buffers_create();
 	void render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_width, int p_height, RS::ViewportMSAA p_msaa, RS::ViewportScreenSpaceAA p_screen_space_aa);

 	RID render_buffers_get_ao_texture(RID p_render_buffers);
 	RID render_buffers_get_back_buffer_texture(RID p_render_buffers);
+	RID render_buffers_get_gi_probe_buffer(RID p_render_buffers);
+	RID render_buffers_get_default_gi_probe_buffer();
+
+	uint32_t render_buffers_get_sdfgi_cascade_count(RID p_render_buffers) const;
+	bool render_buffers_is_sdfgi_enabled(RID p_render_buffers) const;
+	RID render_buffers_get_sdfgi_irradiance_probes(RID p_render_buffers) const;
+	Vector3 render_buffers_get_sdfgi_cascade_offset(RID p_render_buffers, uint32_t p_cascade) const;
+	Vector3i render_buffers_get_sdfgi_cascade_probe_offset(RID p_render_buffers, uint32_t p_cascade) const;
+	float render_buffers_get_sdfgi_cascade_probe_size(RID p_render_buffers, uint32_t p_cascade) const;
+	float render_buffers_get_sdfgi_normal_bias(RID p_render_buffers) const;
+	uint32_t render_buffers_get_sdfgi_cascade_probe_count(RID p_render_buffers) const;
+	uint32_t render_buffers_get_sdfgi_cascade_size(RID p_render_buffers) const;
+	bool render_buffers_is_sdfgi_using_occlusion(RID p_render_buffers) const;
+	float render_buffers_get_sdfgi_energy(RID p_render_buffers) const;
+	RID render_buffers_get_sdfgi_occlusion_texture(RID p_render_buffers) const;

 	void 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_shadow_atlas, RID p_camera_effects, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass);

@@ -1173,6 +1603,9 @@ public:

 	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);

+	void render_sdfgi(RID p_render_buffers, int p_region, InstanceBase **p_cull_result, int p_cull_count);
+	void render_sdfgi_static_lights(RID p_render_buffers, uint32_t p_cascade_count, const uint32_t *p_cascade_indices, const RID **p_positional_light_cull_result, const uint32_t *p_positional_light_cull_count);
+
 	virtual void set_scene_pass(uint64_t p_pass) {
 		scene_pass = p_pass;
 	}
@@ -1180,9 +1613,10 @@ public:
 		return scene_pass;
 	}

-	virtual void screen_space_roughness_limiter_set_active(bool p_enable, float p_curve);
+	virtual void screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit);
 	virtual bool screen_space_roughness_limiter_is_active() const;
-	virtual float screen_space_roughness_limiter_get_curve() const;
+	virtual float screen_space_roughness_limiter_get_amount() const;
+	virtual float screen_space_roughness_limiter_get_limit() const;

 	virtual void sub_surface_scattering_set_quality(RS::SubSurfaceScatteringQuality p_quality);
 	RS::SubSurfaceScatteringQuality sub_surface_scattering_get_quality() const;
@@ -1221,6 +1655,8 @@ public:

 	virtual void set_time(double p_time, double p_step);

+	void sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir);
+
 	RasterizerSceneRD(RasterizerStorageRD *p_storage);
 	~RasterizerSceneRD();
 };