Rewrite Radiance and Reflection probes to use Octahedral maps.

Co-authored-by: clayjohn <[email protected]>

Author: DarioSamo

doc/classes/ProjectSettings.xml

@@ -3226,7 +3226,7 @@
 		<member name="rendering/reflections/sky_reflections/ggx_samples.mobile" type="int" setter="" getter="" default="16">
 			Lower-end override for [member rendering/reflections/sky_reflections/ggx_samples] on mobile devices, due to performance concerns or driver support.
 		</member>
-		<member name="rendering/reflections/sky_reflections/roughness_layers" type="int" setter="" getter="" default="8">
+		<member name="rendering/reflections/sky_reflections/roughness_layers" type="int" setter="" getter="" default="7">
 			Limits the number of layers to use in radiance maps when using importance sampling. A lower number will be slightly faster and take up less VRAM.
 		</member>
 		<member name="rendering/reflections/sky_reflections/texture_array_reflections" type="bool" setter="" getter="" default="true">

drivers/gles3/storage/light_storage.cpp

@@ -986,6 +986,10 @@ bool LightStorage::reflection_probe_instance_begin_render(RID p_instance, RID p_
 	return true;
 }
 
+bool LightStorage::reflection_probe_instance_end_render(RID p_instance, RID p_reflection_atlas) {
+	return true;
+}
+
 Ref<RenderSceneBuffers> LightStorage::reflection_probe_atlas_get_render_buffers(RID p_reflection_atlas) {
 	ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(p_reflection_atlas);
 	ERR_FAIL_NULL_V(atlas, Ref<RenderSceneBuffersGLES3>());

drivers/gles3/storage/light_storage.h

@@ -687,6 +687,7 @@ class LightStorage : public RendererLightStorage {
 	virtual bool reflection_probe_instance_needs_redraw(RID p_instance) override;
 	virtual bool reflection_probe_instance_has_reflection(RID p_instance) override;
 	virtual bool reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) override;
+	virtual bool reflection_probe_instance_end_render(RID p_instance, RID p_reflection_atlas) override;
 	virtual Ref<RenderSceneBuffers> reflection_probe_atlas_get_render_buffers(RID p_reflection_atlas) override;
 	virtual bool reflection_probe_instance_postprocess_step(RID p_instance) override;
 

servers/rendering/dummy/storage/light_storage.h

@@ -165,6 +165,7 @@ class LightStorage : public RendererLightStorage {
 	virtual bool reflection_probe_instance_needs_redraw(RID p_instance) override { return false; }
 	virtual bool reflection_probe_instance_has_reflection(RID p_instance) override { return false; }
 	virtual bool reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) override { return false; }
+	virtual bool reflection_probe_instance_end_render(RID p_instance, RID p_reflection_atlas) override { return false; }
 	virtual Ref<RenderSceneBuffers> reflection_probe_atlas_get_render_buffers(RID p_reflection_atlas) override { return Ref<RenderSceneBuffers>(); }
 	virtual bool reflection_probe_instance_postprocess_step(RID p_instance) override { return true; }
 

servers/rendering/renderer_rd/effects/copy_effects.cpp

@@ -36,12 +36,13 @@
 #include "servers/rendering/renderer_rd/shaders/effects/copy.glsl.gen.h"
 #include "servers/rendering/renderer_rd/shaders/effects/copy_to_fb.glsl.gen.h"
 #include "servers/rendering/renderer_rd/shaders/effects/cube_to_dp.glsl.gen.h"
-#include "servers/rendering/renderer_rd/shaders/effects/cubemap_downsampler.glsl.gen.h"
-#include "servers/rendering/renderer_rd/shaders/effects/cubemap_downsampler_raster.glsl.gen.h"
-#include "servers/rendering/renderer_rd/shaders/effects/cubemap_filter.glsl.gen.h"
-#include "servers/rendering/renderer_rd/shaders/effects/cubemap_filter_raster.glsl.gen.h"
-#include "servers/rendering/renderer_rd/shaders/effects/cubemap_roughness.glsl.gen.h"
-#include "servers/rendering/renderer_rd/shaders/effects/cubemap_roughness_raster.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/effects/cube_to_octmap.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/effects/octmap_downsampler.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/effects/octmap_downsampler_raster.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/effects/octmap_filter.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/effects/octmap_filter_raster.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/effects/octmap_roughness.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/effects/octmap_roughness_raster.glsl.gen.h"
 #include "servers/rendering/renderer_rd/shaders/effects/specular_merge.glsl.gen.h"
 #include "servers/rendering/renderer_scene_render.h"
 
@@ -50,8 +51,15 @@
 namespace RendererRD {
 
 class CopyEffects {
+public:
+	enum RasterEffects {
+		RASTER_EFFECT_COPY = 1 << 0,
+		RASTER_EFFECT_GAUSSIAN_BLUR = 1 << 1,
+		RASTER_EFFECT_OCTMAP = 1 << 2,
+	};
+
 private:
-	bool prefer_raster_effects;
+	BitField<RasterEffects> raster_effects;
 
 	// Blur raster shader
 
@@ -115,8 +123,8 @@ class CopyEffects {
 		COPY_MODE_SET_COLOR_8BIT,
 		COPY_MODE_MIPMAP,
 		COPY_MODE_LINEARIZE_DEPTH,
-		COPY_MODE_CUBE_TO_PANORAMA,
-		COPY_MODE_CUBE_ARRAY_TO_PANORAMA,
+		COPY_MODE_OCTMAP_TO_PANORAMA,
+		COPY_MODE_OCTMAP_ARRAY_TO_PANORAMA,
 		COPY_MODE_MAX,
 
 	};
@@ -152,7 +160,8 @@ class CopyEffects {
 		// DOF.
 		float camera_z_far;
 		float camera_z_near;
-		uint32_t pad2[2];
+		// Octmap.
+		float octmap_border_size[2];
 		//SET color
 		float set_color[4];
 	};
@@ -224,40 +233,66 @@ class CopyEffects {
 		PipelineCacheRD pipeline;
 	} cube_to_dp;
 
-	// Cubemap effects
+	// Copy to Octmap
 
-	struct CubemapDownsamplerPushConstant {
-		uint32_t face_size;
-		uint32_t face_id;
-		float pad[2];
+	struct CopyToOctmapPushConstant {
+		float border_size;
+		float pad[3];
 	};
 
-	struct CubemapDownsampler {
-		CubemapDownsamplerPushConstant push_constant;
-		CubemapDownsamplerShaderRD compute_shader;
-		CubemapDownsamplerRasterShaderRD raster_shader;
+	struct CopyToOctmap {
+		CopyToOctmapPushConstant push_constant;
+		CubeToOctmapShaderRD shader;
 		RID shader_version;
-		PipelineDeferredRD compute_pipeline;
-		PipelineCacheRD raster_pipeline;
-	} cubemap_downsampler;
+		PipelineCacheRD pipeline;
+	} cube_to_octmap;
+
+	// Octmap effects
+
+	struct OctmapDownsamplerPushConstant {
+		float border_size;
+		uint32_t size;
+		uint32_t pad[2];
+	};
 
-	enum CubemapFilterMode {
+	enum OctmapDownsamplerMode {
+		DOWNSAMPLER_MODE_LOW_QUALITY,
+		DOWNSAMPLER_MODE_HIGH_QUALITY,
+		DOWNSAMPLER_MODE_MAX
+	};
+
+	struct OctmapDownsampler {
+		OctmapDownsamplerPushConstant push_constant;
+		OctmapDownsamplerShaderRD compute_shader;
+		OctmapDownsamplerRasterShaderRD raster_shader;
+		RID shader_version;
+		PipelineDeferredRD compute_pipelines[DOWNSAMPLER_MODE_MAX];
+		PipelineCacheRD raster_pipelines[DOWNSAMPLER_MODE_MAX];
+	} octmap_downsampler;
+
+	enum OctmapFilterMode {
 		FILTER_MODE_HIGH_QUALITY,
 		FILTER_MODE_LOW_QUALITY,
 		FILTER_MODE_HIGH_QUALITY_ARRAY,
 		FILTER_MODE_LOW_QUALITY_ARRAY,
 		FILTER_MODE_MAX,
 	};
 
-	struct CubemapFilterRasterPushConstant {
+	struct OctmapFilterPushConstant {
+		float border_size[2];
+		uint32_t size;
+		uint32_t pad;
+	};
+
+	struct OctmapFilterRasterPushConstant {
+		float border_size[2];
 		uint32_t mip_level;
-		uint32_t face_id;
-		float pad[2];
+		uint32_t pad;
 	};
 
-	struct CubemapFilter {
-		CubemapFilterShaderRD compute_shader;
-		CubemapFilterRasterShaderRD raster_shader;
+	struct OctmapFilter {
+		OctmapFilterShaderRD compute_shader;
+		OctmapFilterRasterShaderRD raster_shader;
 		RID shader_version;
 		PipelineDeferredRD compute_pipelines[FILTER_MODE_MAX];
 		PipelineCacheRD raster_pipelines[FILTER_MODE_MAX];
@@ -269,19 +304,21 @@ class CopyEffects {
 
 	} filter;
 
-	struct CubemapRoughnessPushConstant {
-		uint32_t face_id;
+	struct OctmapRoughnessPushConstant {
 		uint32_t sample_count;
 		float roughness;
+		uint32_t source_size;
+		uint32_t dest_size;
+
+		float border_size[2];
 		uint32_t use_direct_write;
-		float face_size;
-		float pad[3];
+		uint32_t pad;
 	};
 
-	struct CubemapRoughness {
-		CubemapRoughnessPushConstant push_constant;
-		CubemapRoughnessShaderRD compute_shader;
-		CubemapRoughnessRasterShaderRD raster_shader;
+	struct OctmapRoughness {
+		OctmapRoughnessPushConstant push_constant;
+		OctmapRoughnessShaderRD compute_shader;
+		OctmapRoughnessRasterShaderRD raster_shader;
 		RID shader_version;
 		PipelineDeferredRD compute_pipeline;
 		PipelineCacheRD raster_pipeline;
@@ -319,18 +356,18 @@ class CopyEffects {
 public:
 	static CopyEffects *get_singleton();
 
-	CopyEffects(bool p_prefer_raster_effects);
+	CopyEffects(BitField<RasterEffects> p_raster_effects);
 	~CopyEffects();
 
-	bool get_prefer_raster_effects() { return prefer_raster_effects; }
+	BitField<RasterEffects> get_raster_effects() { return raster_effects; }
 
 	void copy_to_rect(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y = false, bool p_force_luminance = false, bool p_all_source = false, bool p_8_bit_dst = false, bool p_alpha_to_one = false, bool p_sanitize_inf_nan = false);
-	void copy_cubemap_to_panorama(RID p_source_cube, RID p_dest_panorama, const Size2i &p_panorama_size, float p_lod, bool p_is_array);
+	void copy_octmap_to_panorama(RID p_source_octmap, RID p_dest_panorama, const Size2i &p_panorama_size, float p_lod, bool p_is_array, const Size2 &p_source_octmap_border_size);
 	void copy_depth_to_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y = false);
 	void copy_depth_to_rect_and_linearize(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y, float p_z_near, float p_z_far);
-	void copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y = false, bool p_force_luminance = false, bool p_alpha_to_zero = false, bool p_srgb = false, RID p_secondary = RID(), bool p_multiview = false, bool alpha_to_one = false, bool p_linear = false, bool p_normal = false, const Rect2 &p_src_rect = Rect2());
+	void copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y = false, bool p_force_luminance = false, bool p_alpha_to_zero = false, bool p_srgb = false, RID p_secondary = RID(), bool p_multiview = false, bool alpha_to_one = false, bool p_linear = false, bool p_normal = false, const Rect2 &p_src_rect = Rect2(), float p_linear_luminance_multiplier = 1.0);
 	void copy_to_atlas_fb(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2 &p_uv_rect, RD::DrawListID p_draw_list, bool p_flip_y = false, bool p_panorama = false);
-	void copy_to_drawlist(RD::DrawListID p_draw_list, RD::FramebufferFormatID p_fb_format, RID p_source_rd_texture, bool p_linear = false);
+	void copy_to_drawlist(RD::DrawListID p_draw_list, RD::FramebufferFormatID p_fb_format, RID p_source_rd_texture, bool p_linear = false, float p_linear_luminance_multiplier = 1.0);
 	void copy_raster(RID p_source_texture, RID p_dest_framebuffer);
 
 	void gaussian_blur(RID p_source_rd_texture, RID p_texture, const Rect2i &p_region, const Size2i &p_size, bool p_8bit_dst = false);
@@ -346,13 +383,13 @@ class CopyEffects {
 	void set_color_raster(RID p_dest_texture, const Color &p_color, const Rect2i &p_region);
 
 	void copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dst_framebuffer, const Rect2 &p_rect, const Vector2 &p_dst_size, float p_z_near, float p_z_far, bool p_dp_flip);
-	void cubemap_downsample(RID p_source_cubemap, RID p_dest_cubemap, const Size2i &p_size);
-	void cubemap_downsample_raster(RID p_source_cubemap, RID p_dest_framebuffer, uint32_t p_face_id, const Size2i &p_size);
-	void cubemap_filter(RID p_source_cubemap, Vector<RID> p_dest_cubemap, bool p_use_array);
-	void cubemap_filter_raster(RID p_source_cubemap, RID p_dest_framebuffer, uint32_t p_face_id, uint32_t p_mip_level);
-
-	void cubemap_roughness(RID p_source_rd_texture, RID p_dest_texture, uint32_t p_face_id, uint32_t p_sample_count, float p_roughness, float p_size);
-	void cubemap_roughness_raster(RID p_source_rd_texture, RID p_dest_framebuffer, uint32_t p_face_id, uint32_t p_sample_count, float p_roughness, float p_size);
+	void copy_cubemap_to_octmap(RID p_source_rd_texture, RID p_dst_framebuffer, float p_border_size);
+	void octmap_downsample(RID p_source_octmap, RID p_dest_octmap, const Size2i &p_size, bool p_use_filter_quality, float p_border_size);
+	void octmap_downsample_raster(RID p_source_octmap, RID p_dest_framebuffer, const Size2i &p_size, bool p_use_filter_quality, float p_border_size);
+	void octmap_filter(RID p_source_octmap, const Vector<RID> &p_dest_octmap, bool p_use_array, float p_border_size);
+	void octmap_filter_raster(RID p_source_octmap, RID p_dest_framebuffer, uint32_t p_mip_level, float p_border_size);
+	void octmap_roughness(RID p_source_rd_texture, RID p_dest_texture, uint32_t p_sample_count, float p_roughness, uint32_t p_source_size, uint32_t p_dest_size, float p_border_size);
+	void octmap_roughness_raster(RID p_source_rd_texture, RID p_dest_framebuffer, uint32_t p_sample_count, float p_roughness, uint32_t p_source_size, uint32_t p_dest_size, float p_border_size);
 
 	void merge_specular(RID p_dest_framebuffer, RID p_specular, RID p_base, RID p_reflection, uint32_t p_view_count);
 };

servers/rendering/renderer_rd/effects/copy_effects.h

@@ -211,7 +211,7 @@ void Fog::fog_instance_free(RID p_rid) {
 ////////////////////////////////////////////////////////////////////////////////
 // Volumetric Fog Shader
 
-void Fog::init_fog_shader(uint32_t p_max_directional_lights, int p_roughness_layers, bool p_is_using_radiance_cubemap_array) {
+void Fog::init_fog_shader(uint32_t p_max_directional_lights, int p_roughness_layers, bool p_is_using_radiance_octmap_array) {
 	MaterialStorage *material_storage = MaterialStorage::get_singleton();
 
 	{
@@ -302,8 +302,8 @@ ALBEDO = vec3(1.0);
 	{
 		String defines = "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(p_max_directional_lights) + "\n";
 		defines += "\n#define MAX_SKY_LOD " + itos(p_roughness_layers - 1) + ".0\n";
-		if (p_is_using_radiance_cubemap_array) {
-			defines += "\n#define USE_RADIANCE_CUBEMAP_ARRAY \n";
+		if (p_is_using_radiance_octmap_array) {
+			defines += "\n#define USE_RADIANCE_OCTMAP_ARRAY \n";
 		}
 		Vector<ShaderRD::VariantDefine> volumetric_fog_modes;
 		int shader_group = 0;
@@ -977,7 +977,7 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P
 			RD::Uniform u;
 			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 19;
-			RID radiance_texture = texture_storage->texture_rd_get_default(p_settings.is_using_radiance_cubemap_array ? RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
+			RID radiance_texture = texture_storage->texture_rd_get_default(p_settings.is_using_radiance_octmap_array ? RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_2D_ARRAY_BLACK : RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_BLACK);
 			RID sky_texture = RendererSceneRenderRD::get_singleton()->environment_get_sky(p_settings.env).is_valid() ? p_settings.sky->sky_get_radiance_texture_rd(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_settings.env)) : RID();
 			u.append_id(sky_texture.is_valid() ? sky_texture : radiance_texture);
 			uniforms.push_back(u);
@@ -1118,6 +1118,13 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P
 	params.use_temporal_reprojection = RendererSceneRenderRD::get_singleton()->environment_get_volumetric_fog_temporal_reprojection(p_settings.env);
 	params.temporal_blend = RendererSceneRenderRD::get_singleton()->environment_get_volumetric_fog_temporal_reprojection_amount(p_settings.env);
 
+	RID sky_rid = RendererSceneRenderRD::get_singleton()->environment_get_sky(p_settings.env);
+	if (sky_rid.is_valid()) {
+		float uv_border_size = p_settings.sky->sky_get_uv_border_size(sky_rid);
+		params.sky_border_size[0] = uv_border_size;
+		params.sky_border_size[1] = 1.0f - uv_border_size * 2.0f;
+	}
+
 	{
 		uint32_t cluster_size = p_settings.cluster_builder->get_cluster_size();
 		params.cluster_shift = get_shift_from_power_of_2(cluster_size);

servers/rendering/renderer_rd/environment/fog.cpp

@@ -182,6 +182,9 @@ class Fog : public RendererFog {
 			uint32_t temporal_frame;
 			float temporal_blend;
 
+			float sky_border_size[2];
+			float pad[2];
+
 			float cam_rotation[12];
 			float to_prev_view[16];
 			float radiance_inverse_xform[12];
@@ -340,13 +343,13 @@ class Fog : public RendererFog {
 		~VolumetricFog();
 	};
 
-	void init_fog_shader(uint32_t p_max_directional_lights, int p_roughness_layers, bool p_is_using_radiance_cubemap_array);
+	void init_fog_shader(uint32_t p_max_directional_lights, int p_roughness_layers, bool p_is_using_radiance_octmap_array);
 	void free_fog_shader();
 
 	struct VolumetricFogSettings {
 		Vector2i rb_size;
 		double time;
-		bool is_using_radiance_cubemap_array;
+		bool is_using_radiance_octmap_array;
 		uint32_t max_cluster_elements;
 		bool volumetric_fog_filter_active;
 		RID shadow_sampler;

servers/rendering/renderer_rd/environment/fog.h

@@ -1306,6 +1306,10 @@ void GI::SDFGI::update_probes(RID p_env, SkyRD::Sky *p_sky) {
 	push_constant.image_size[1] = probe_axis_count;
 	push_constant.store_ambient_texture = RendererSceneRenderRD::get_singleton()->environment_get_volumetric_fog_enabled(p_env);
 
+	const float sky_irradiance_border_size = p_sky != nullptr ? p_sky->uv_border_size : 0.0f;
+	push_constant.sky_irradiance_border_size[0] = sky_irradiance_border_size;
+	push_constant.sky_irradiance_border_size[1] = 1.0 - sky_irradiance_border_size * 2.0f;
+
 	RID sky_uniform_set = gi->sdfgi_shader.integrate_default_sky_uniform_set;
 	push_constant.sky_flags = 0;
 	push_constant.y_mult = y_mult;
@@ -3521,8 +3525,8 @@ void GI::init(SkyRD *p_sky) {
 		//calculate tables
 		String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
 		defines += "\n#define SH_SIZE " + itos(SDFGI::SH_SIZE) + "\n";
-		if (p_sky->sky_use_cubemap_array) {
-			defines += "\n#define USE_CUBEMAP_ARRAY\n";
+		if (p_sky->sky_use_octmap_array) {
+			defines += "\n#define USE_OCTMAP_ARRAY\n";
 		}
 
 		Vector<String> integrate_modes;
@@ -3544,10 +3548,10 @@ void GI::init(SkyRD *p_sky) {
 				RD::Uniform u;
 				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				u.binding = 0;
-				if (p_sky->sky_use_cubemap_array) {
-					u.append_id(texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_WHITE));
+				if (p_sky->sky_use_octmap_array) {
+					u.append_id(texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE));
 				} else {
-					u.append_id(texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_CUBEMAP_WHITE));
+					u.append_id(texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE));
 				}
 				uniforms.push_back(u);
 			}

servers/rendering/renderer_rd/environment/gi.cpp

@@ -419,8 +419,9 @@ class GI : public RendererGI {
 			float sky_color_or_orientation[3];
 			float y_mult;
 
+			float sky_irradiance_border_size[2];
 			uint32_t store_ambient_texture;
-			uint32_t pad[3];
+			uint32_t pad;
 		};
 
 		SdfgiIntegrateShaderRD integrate;