WIP CameraEffects implementation (bokeh not working for now)

8 files changed, 372 insertions, 44 deletions

diff --git a/servers/visual/rasterizer_rd/rasterizer_effects_rd.cpp b/servers/visual/rasterizer_rd/rasterizer_effects_rd.cpp
index 72329d8a13..f1ab55e7bf 100644
--- a/servers/visual/rasterizer_rd/rasterizer_effects_rd.cpp
+++ b/servers/visual/rasterizer_rd/rasterizer_effects_rd.cpp
@@ -406,6 +406,70 @@ void RasterizerEffectsRD::luminance_reduction(RID p_source_texture, const Size2i
 	RD::get_singleton()->compute_list_end();
 }
 
+void RasterizerEffectsRD::bokeh_dof(RID p_base_texture, RID p_depth_texture, const Size2i &p_base_texture_size, RID p_bokeh_texture, bool p_dof_far, float p_dof_far_begin, float p_dof_far_size, bool p_dof_near, float p_dof_near_begin, float p_dof_near_size, float p_bokeh_size, VS::DOFBlurQuality p_quality, float p_cam_znear, float p_cam_zfar, bool p_cam_orthogonal) {
+
+	bokeh.push_constant.blur_far_active = p_dof_far;
+	bokeh.push_constant.blur_far_begin = p_dof_far_begin;
+	bokeh.push_constant.blur_far_end = p_dof_far_begin + p_dof_far_size;
+
+	bokeh.push_constant.blur_near_active = p_dof_near;
+	bokeh.push_constant.blur_near_begin = p_dof_near_begin;
+	bokeh.push_constant.blur_near_end = MAX(0, p_dof_near_begin - p_dof_near_size);
+
+	bokeh.push_constant.size[0] = p_base_texture_size.x;
+	bokeh.push_constant.size[1] = p_base_texture_size.y;
+
+	bokeh.push_constant.z_near = p_cam_znear;
+	bokeh.push_constant.z_far = p_cam_zfar;
+	bokeh.push_constant.orthogonal = p_cam_orthogonal;
+	bokeh.push_constant.blur_size = p_bokeh_size;
+	bokeh.push_constant.blur_scale = 0.5;
+
+	RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
+
+	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, bokeh.pipelines[BOKEH_GEN_BLUR_SIZE]);
+
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, _get_uniform_set_from_image(p_base_texture), 0);
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, _get_compute_uniform_set_from_texture(p_depth_texture), 1);
+
+	RD::get_singleton()->compute_list_set_push_constant(compute_list, &bokeh.push_constant, sizeof(BokehPushConstant));
+
+	int32_t x_groups = (p_base_texture_size.x - 1) / 8 + 1;
+	int32_t y_groups = (p_base_texture_size.y - 1) / 8 + 1;
+
+	RD::get_singleton()->compute_list_dispatch(compute_list, x_groups, y_groups, 1);
+	RD::get_singleton()->compute_list_add_barrier(compute_list);
+
+	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, bokeh.pipelines[BOKEH_GEN_BOKEH]);
+
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, _get_uniform_set_from_image(p_bokeh_texture), 0);
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, _get_compute_uniform_set_from_texture(p_depth_texture), 1);
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, _get_compute_uniform_set_from_texture(p_base_texture), 2);
+
+	RD::get_singleton()->compute_list_set_push_constant(compute_list, &bokeh.push_constant, sizeof(BokehPushConstant));
+
+	x_groups = ((p_base_texture_size.x >> 1) - 1) / 8 + 1;
+	y_groups = ((p_base_texture_size.y >> 1) - 1) / 8 + 1;
+
+	RD::get_singleton()->compute_list_dispatch(compute_list, x_groups, y_groups, 1);
+	RD::get_singleton()->compute_list_add_barrier(compute_list);
+
+	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, bokeh.pipelines[BOKEH_COMPOSITE]);
+
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, _get_uniform_set_from_image(p_base_texture), 0);
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, _get_compute_uniform_set_from_texture(p_bokeh_texture), 1);
+
+	RD::get_singleton()->compute_list_set_push_constant(compute_list, &bokeh.push_constant, sizeof(BokehPushConstant));
+
+	x_groups = (p_base_texture_size.x - 1) / 8 + 1;
+	y_groups = (p_base_texture_size.y - 1) / 8 + 1;
+
+	RD::get_singleton()->compute_list_dispatch(compute_list, x_groups, y_groups, 1);
+	RD::get_singleton()->compute_list_add_barrier(compute_list);
+
+	RD::get_singleton()->compute_list_end();
+}
+
 RasterizerEffectsRD::RasterizerEffectsRD() {
 
 	{
@@ -511,6 +575,22 @@ RasterizerEffectsRD::RasterizerEffectsRD() {
 		}
 	}
 
+	{
+		// Initialize bokeh
+		Vector<String> bokeh_modes;
+		bokeh_modes.push_back("\n#define MODE_GEN_BLUR_SIZE\n");
+		bokeh_modes.push_back("\n#define MODE_GEN_BOKEH\n");
+		bokeh_modes.push_back("\n#define MODE_COMPOSITE_BOKEH\n");
+
+		bokeh.shader.initialize(bokeh_modes);
+
+		bokeh.shader_version = bokeh.shader.version_create();
+
+		for (int i = 0; i < BOKEH_MAX; i++) {
+			bokeh.pipelines[i] = RD::get_singleton()->compute_pipeline_create(bokeh.shader.version_get_shader(bokeh.shader_version, i));
+		}
+	}
+
 	RD::SamplerState sampler;
 	sampler.mag_filter = RD::SAMPLER_FILTER_LINEAR;
 	sampler.min_filter = RD::SAMPLER_FILTER_LINEAR;
diff --git a/servers/visual/rasterizer_rd/rasterizer_effects_rd.h b/servers/visual/rasterizer_rd/rasterizer_effects_rd.h
index 1fee77e41c..f050e298a9 100644
--- a/servers/visual/rasterizer_rd/rasterizer_effects_rd.h
+++ b/servers/visual/rasterizer_rd/rasterizer_effects_rd.h
@@ -34,11 +34,13 @@
 #include "core/math/camera_matrix.h"
 #include "render_pipeline_vertex_format_cache_rd.h"
 #include "servers/visual/rasterizer_rd/shaders/blur.glsl.gen.h"
+#include "servers/visual/rasterizer_rd/shaders/bokeh_dof.glsl.gen.h"
 #include "servers/visual/rasterizer_rd/shaders/copy.glsl.gen.h"
 #include "servers/visual/rasterizer_rd/shaders/cubemap_roughness.glsl.gen.h"
 #include "servers/visual/rasterizer_rd/shaders/luminance_reduce.glsl.gen.h"
 #include "servers/visual/rasterizer_rd/shaders/sky.glsl.gen.h"
 #include "servers/visual/rasterizer_rd/shaders/tonemap.glsl.gen.h"
+
 #include "servers/visual_server.h"
 
 class RasterizerEffectsRD {
@@ -221,6 +223,40 @@ class RasterizerEffectsRD {
 		RenderPipelineVertexFormatCacheRD pipelines[COPY_MODE_MAX];
 	} copy;
 
+	struct BokehPushConstant {
+		uint32_t size[2];
+		float z_far;
+		float z_near;
+
+		uint32_t orthogonal;
+		float blur_size;
+		float blur_scale;
+		uint32_t pad;
+
+		uint32_t blur_near_active;
+		float blur_near_begin;
+		float blur_near_end;
+		uint32_t blur_far_active;
+		float blur_far_begin;
+		float blur_far_end;
+		uint32_t pad2[2];
+	};
+
+	enum BokehMode {
+		BOKEH_GEN_BLUR_SIZE,
+		BOKEH_GEN_BOKEH,
+		BOKEH_COMPOSITE,
+		BOKEH_MAX
+	};
+
+	struct Bokeh {
+
+		BokehPushConstant push_constant;
+		BokehDofShaderRD shader;
+		RID shader_version;
+		RID pipelines[BOKEH_MAX];
+	} bokeh;
+
 	RID default_sampler;
 	RID default_mipmap_sampler;
 	RID index_buffer;
@@ -248,6 +284,7 @@ public:
 	void make_mipmap(RID p_source_rd_texture, RID p_framebuffer_half, const Vector2 &p_pixel_size);
 	void copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2 &p_rect, float p_z_near, float p_z_far, float p_bias, bool p_dp_flip);
 	void luminance_reduction(RID p_source_texture, const Size2i p_source_size, const Vector<RID> p_reduce, RID p_prev_luminance, float p_min_luminance, float p_max_luminance, float p_adjust, bool p_set = false);
+	void bokeh_dof(RID p_base_texture, RID p_depth_texture, const Size2i &p_base_texture_size, RID p_bokeh_texture, bool p_dof_far, float p_dof_far_begin, float p_dof_far_size, bool p_dof_near, float p_dof_near_begin, float p_dof_near_size, float p_bokeh_size, VS::DOFBlurQuality p_quality, float p_cam_znear, float p_cam_zfar, bool p_cam_orthogonal);
 
 	struct TonemapSettings {
 
diff --git a/servers/visual/rasterizer_rd/rasterizer_scene_forward_rd.cpp b/servers/visual/rasterizer_rd/rasterizer_scene_forward_rd.cpp
index 248a3efede..3959986f3a 100644
--- a/servers/visual/rasterizer_rd/rasterizer_scene_forward_rd.cpp
+++ b/servers/visual/rasterizer_rd/rasterizer_scene_forward_rd.cpp
@@ -535,30 +535,16 @@ void RasterizerSceneForwardRD::RenderBufferDataForward::clear() {
 		RD::get_singleton()->free(color_fb);
 		color_fb = RID();
 	}
-
-	if (depth.is_valid()) {
-		RD::get_singleton()->free(depth);
-		depth = RID();
-	}
 }
 
-void RasterizerSceneForwardRD::RenderBufferDataForward::configure(RID p_color_buffer, int p_width, int p_height, VS::ViewportMSAA p_msaa) {
+void RasterizerSceneForwardRD::RenderBufferDataForward::configure(RID p_color_buffer, RID p_depth_buffer, int p_width, int p_height, VS::ViewportMSAA p_msaa) {
 	clear();
 
 	width = p_width;
 	height = p_height;
 
 	color = p_color_buffer;
-
-	{
-		RD::TextureFormat tf;
-		tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D24_UNORM_S8_UINT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D24_UNORM_S8_UINT : RD::DATA_FORMAT_D32_SFLOAT_S8_UINT;
-		tf.width = p_width;
-		tf.height = p_height;
-		tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
-
-		depth = RD::get_singleton()->texture_create(tf, RD::TextureView());
-	}
+	depth = p_depth_buffer;
 
 	{
 		Vector<RID> fb;
@@ -1625,7 +1611,7 @@ void RasterizerSceneForwardRD::_setup_lights(RID *p_light_cull_result, int p_lig
 	}
 }
 
-void RasterizerSceneForwardRD::_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_environment, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color) {
+void RasterizerSceneForwardRD::_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_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) {
 
 	RenderBufferDataForward *render_buffer = NULL;
 	if (p_render_buffer.is_valid()) {
@@ -1855,15 +1841,6 @@ void RasterizerSceneForwardRD::_render_scene(RID p_render_buffer, const Transfor
 		}
 	}
 #endif
-	if (p_reflection_probe.is_valid()) {
-		//was rendering a probe, so do no more
-		return;
-	}
-
-	RENDER_TIMESTAMP("Tonemap");
-
-	render_buffers_post_process_and_tonemap(p_render_buffer, p_environment);
-	render_buffers_debug_draw(p_render_buffer, p_shadow_atlas);
 
 #if 0
 	_post_process(env, p_cam_projection);
diff --git a/servers/visual/rasterizer_rd/rasterizer_scene_forward_rd.h b/servers/visual/rasterizer_rd/rasterizer_scene_forward_rd.h
index 8517e4201c..dd86c8ae27 100644
--- a/servers/visual/rasterizer_rd/rasterizer_scene_forward_rd.h
+++ b/servers/visual/rasterizer_rd/rasterizer_scene_forward_rd.h
@@ -195,7 +195,7 @@ class RasterizerSceneForwardRD : public RasterizerSceneRD {
 		int width, height;
 
 		void clear();
-		virtual void configure(RID p_color_buffer, int p_width, int p_height, VS::ViewportMSAA p_msaa);
+		virtual void configure(RID p_color_buffer, RID p_depth_buffer, int p_width, int p_height, VS::ViewportMSAA p_msaa);
 
 		~RenderBufferDataForward();
 	};
@@ -538,7 +538,7 @@ class RasterizerSceneForwardRD : public RasterizerSceneRD {
 	void _draw_sky(RD::DrawListID p_draw_list, RenderingDevice::FramebufferFormatID p_fb_format, RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform, float p_alpha);
 
 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_environment, 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, 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_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);
 	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);
 
diff --git a/servers/visual/rasterizer_rd/rasterizer_scene_rd.cpp b/servers/visual/rasterizer_rd/rasterizer_scene_rd.cpp
index a97c68a619..e5b199261f 100644
--- a/servers/visual/rasterizer_rd/rasterizer_scene_rd.cpp
+++ b/servers/visual/rasterizer_rd/rasterizer_scene_rd.cpp
@@ -1117,6 +1117,36 @@ int RasterizerSceneRD::get_directional_light_shadow_size(RID p_light_intance) {
 
 //////////////////////////////////////////////////
 
+RID RasterizerSceneRD::camera_effects_create() {
+
+	return camera_effects_owner.make_rid(CameraEffects());
+}
+
+void RasterizerSceneRD::camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount, VS::DOFBlurQuality p_quality) {
+	CameraEffects *camfx = camera_effects_owner.getornull(p_camera_effects);
+	ERR_FAIL_COND(!camfx);
+
+	camfx->dof_blur_far_enabled = p_far_enable;
+	camfx->dof_blur_far_distance = p_far_distance;
+	camfx->dof_blur_far_transition = p_far_transition;
+
+	camfx->dof_blur_near_enabled = p_near_enable;
+	camfx->dof_blur_near_distance = p_near_distance;
+	camfx->dof_blur_near_transition = p_near_transition;
+
+	camfx->dof_blur_quality = p_quality;
+	camfx->dof_blur_amount = p_amount;
+}
+
+void RasterizerSceneRD::camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) {
+
+	CameraEffects *camfx = camera_effects_owner.getornull(p_camera_effects);
+	ERR_FAIL_COND(!camfx);
+
+	camfx->override_exposure_enabled = p_enable;
+	camfx->override_exposure = p_exposure;
+}
+
 RID RasterizerSceneRD::light_instance_create(RID p_light) {
 
 	RID li = light_instance_owner.make_rid(LightInstance());
@@ -2172,7 +2202,7 @@ void RasterizerSceneRD::_allocate_blur_textures(RenderBuffers *rb) {
 	tf.width = rb->width;
 	tf.height = rb->height;
 	tf.type = RD::TEXTURE_TYPE_2D;
-	tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
+	tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
 	tf.mipmaps = mipmaps_required;
 
 	rb->blur[0].texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
@@ -2254,6 +2284,12 @@ void RasterizerSceneRD::_free_render_buffer_data(RenderBuffers *rb) {
 
 	if (rb->texture.is_valid()) {
 		RD::get_singleton()->free(rb->texture);
+		rb->texture = RID();
+	}
+
+	if (rb->depth_texture.is_valid()) {
+		RD::get_singleton()->free(rb->depth_texture);
+		rb->depth_texture = RID();
 	}
 
 	for (int i = 0; i < 2; i++) {
@@ -2279,16 +2315,27 @@ void RasterizerSceneRD::_free_render_buffer_data(RenderBuffers *rb) {
 	}
 }
 
-void RasterizerSceneRD::render_buffers_post_process_and_tonemap(RID p_render_buffers, RID p_environment) {
+void RasterizerSceneRD::_render_buffers_post_process_and_tonemap(RID p_render_buffers, RID p_environment, RID p_camera_effects, const CameraMatrix &p_projection) {
 
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
 	Environent *env = environment_owner.getornull(p_environment);
 	//glow (if enabled)
+	CameraEffects *camfx = camera_effects_owner.getornull(p_camera_effects);
 
 	bool can_use_effects = rb->width >= 8 && rb->height >= 8;
 
+	if (can_use_effects && camfx && (camfx->dof_blur_near_enabled || camfx->dof_blur_far_enabled) && camfx->dof_blur_amount > 0.0) {
+
+		if (rb->blur[0].texture.is_null()) {
+			_allocate_blur_textures(rb);
+		}
+
+		float bokeh_size = camfx->dof_blur_amount * 20.0;
+		storage->get_effects()->bokeh_dof(rb->texture, rb->depth_texture, Size2i(rb->width, rb->height), rb->blur[1].mipmaps[0].texture, camfx->dof_blur_far_enabled, camfx->dof_blur_far_distance, camfx->dof_blur_far_transition, camfx->dof_blur_near_enabled, camfx->dof_blur_near_distance, camfx->dof_blur_near_transition, bokeh_size, camfx->dof_blur_quality, p_projection.get_z_near(), p_projection.get_z_far(), p_projection.is_orthogonal());
+	}
+
 	if (can_use_effects && env && env->auto_exposure) {
 
 		if (rb->luminance.current.is_null()) {
@@ -2388,7 +2435,7 @@ void RasterizerSceneRD::render_buffers_post_process_and_tonemap(RID p_render_buf
 	storage->render_target_disable_clear_request(rb->render_target);
 }
 
-void RasterizerSceneRD::render_buffers_debug_draw(RID p_render_buffers, RID p_shadow_atlas) {
+void RasterizerSceneRD::_render_buffers_debug_draw(RID p_render_buffers, RID p_shadow_atlas) {
 	RasterizerEffectsRD *effects = storage->get_effects();
 
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
@@ -2443,12 +2490,22 @@ void RasterizerSceneRD::render_buffers_configure(RID p_render_buffers, RID p_ren
 		tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
 		tf.width = rb->width;
 		tf.height = rb->height;
-		tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
+		tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
 
 		rb->texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
 	}
 
-	rb->data->configure(rb->texture, p_width, p_height, p_msaa);
+	{
+		RD::TextureFormat tf;
+		tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D24_UNORM_S8_UINT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D24_UNORM_S8_UINT : RD::DATA_FORMAT_D32_SFLOAT_S8_UINT;
+		tf.width = p_width;
+		tf.height = p_height;
+		tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+
+		rb->depth_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
+	}
+
+	rb->data->configure(rb->texture, rb->depth_texture, p_width, p_height, p_msaa);
 }
 
 int RasterizerSceneRD::get_roughness_layers() const {
@@ -2465,7 +2522,7 @@ RasterizerSceneRD::RenderBufferData *RasterizerSceneRD::render_buffers_get_data(
 	return rb->data;
 }
 
-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_environment, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass) {
+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_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()) {
@@ -2476,7 +2533,14 @@ void RasterizerSceneRD::render_scene(RID p_render_buffers, const Transform &p_ca
 		clear_color = storage->get_default_clear_color();
 	}
 
-	_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_environment, p_shadow_atlas, p_reflection_atlas, p_reflection_probe, p_reflection_probe_pass, clear_color);
+	_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_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");
+
+		_render_buffers_post_process_and_tonemap(p_render_buffers, p_environment, p_camera_effects, p_cam_projection);
+		_render_buffers_debug_draw(p_render_buffers, p_shadow_atlas);
+	}
 }
 
 void RasterizerSceneRD::render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count) {
@@ -2670,6 +2734,9 @@ bool RasterizerSceneRD::free(RID p_rid) {
 	} else if (environment_owner.owns(p_rid)) {
 		//not much to delete, just free it
 		environment_owner.free(p_rid);
+	} else if (camera_effects_owner.owns(p_rid)) {
+		//not much to delete, just free it
+		camera_effects_owner.free(p_rid);
 	} else if (reflection_atlas_owner.owns(p_rid)) {
 		reflection_atlas_set_size(p_rid, 0, 0);
 		reflection_atlas_owner.free(p_rid);
diff --git a/servers/visual/rasterizer_rd/rasterizer_scene_rd.h b/servers/visual/rasterizer_rd/rasterizer_scene_rd.h
index ae4bcde4b4..cfd11e9a38 100644
--- a/servers/visual/rasterizer_rd/rasterizer_scene_rd.h
+++ b/servers/visual/rasterizer_rd/rasterizer_scene_rd.h
@@ -49,12 +49,12 @@ public:
 protected:
 	struct RenderBufferData {
 
-		virtual void configure(RID p_color_buffer, int p_width, int p_height, VS::ViewportMSAA p_msaa) = 0;
+		virtual void configure(RID p_color_buffer, RID p_depth_buffer, int p_width, int p_height, VS::ViewportMSAA p_msaa) = 0;
 		virtual ~RenderBufferData() {}
 	};
 	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_environment, 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_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_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) = 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;
 
@@ -487,6 +487,28 @@ private:
 
 	mutable RID_Owner<Environent> environment_owner;
 
+	/* CAMERA EFFECTS */
+
+	struct CameraEffects {
+
+		bool dof_blur_far_enabled = false;
+		float dof_blur_far_distance = 10;
+		float dof_blur_far_transition = 5;
+
+		bool dof_blur_near_enabled = false;
+		float dof_blur_near_distance = 2;
+		float dof_blur_near_transition = 1;
+
+		float dof_blur_amount = 0.1;
+
+		VS::DOFBlurQuality dof_blur_quality = VS::DOF_BLUR_QUALITY_MEDIUM;
+
+		bool override_exposure_enabled = false;
+		float override_exposure = 1;
+	};
+
+	mutable RID_Owner<CameraEffects> camera_effects_owner;
+
 	/* RENDER BUFFERS */
 
 	struct RenderBuffers {
@@ -499,6 +521,7 @@ private:
 		uint64_t auto_exposure_version = 1;
 
 		RID texture; //main texture for rendering to, must be filled after done rendering
+		RID depth_texture; //main depth texture
 
 		//built-in textures used for ping pong image processing and blurring
 		struct Blur {
@@ -529,6 +552,9 @@ private:
 	void _allocate_blur_textures(RenderBuffers *rb);
 	void _allocate_luminance_textures(RenderBuffers *rb);
 
+	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);
+
 	uint64_t scene_pass = 0;
 	uint64_t shadow_atlas_realloc_tolerance_msec = 500;
 
@@ -607,8 +633,6 @@ public:
 
 	bool is_environment(RID p_env) const;
 
-	void environment_set_dof_blur_near(RID p_env, bool p_enable, float p_distance, float p_transition, float p_far_amount, VS::EnvironmentDOFBlurQuality p_quality) {}
-	void environment_set_dof_blur_far(RID p_env, bool p_enable, float p_distance, float p_transition, float p_far_amount, VS::EnvironmentDOFBlurQuality p_quality) {}
 	void environment_set_glow(RID p_env, bool p_enable, int p_level_flags, float p_intensity, float p_strength, float p_mix, float p_bloom_threshold, VS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_threshold, float p_hdr_bleed_scale, float p_hdr_luminance_cap, bool p_bicubic_upscale);
 
 	void environment_set_fog(RID p_env, bool p_enable, float p_begin, float p_end, RID p_gradient_texture) {}
@@ -623,6 +647,11 @@ public:
 	void environment_set_fog_depth(RID p_env, bool p_enable, float p_depth_begin, float p_depth_end, float p_depth_curve, bool p_transmit, float p_transmit_curve) {}
 	void environment_set_fog_height(RID p_env, bool p_enable, float p_min_height, float p_max_height, float p_height_curve) {}
 
+	virtual RID camera_effects_create();
+
+	virtual void camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount, VS::DOFBlurQuality p_quality);
+	virtual void camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure);
+
 	RID light_instance_create(RID p_light);
 	void light_instance_set_transform(RID p_light_instance, const Transform &p_transform);
 	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_bias_scale = 1.0);
@@ -846,10 +875,8 @@ public:
 	void render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_width, int p_height, VS::ViewportMSAA p_msaa);
 
 	RID render_buffers_get_back_buffer_texture(RID p_render_buffers);
-	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);
 
-	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_environment, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass);
+	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_environment, RID p_shadow_atlas, RID p_camera_effects, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass);
 
 	void render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count);
 
diff --git a/servers/visual/rasterizer_rd/shaders/SCsub b/servers/visual/rasterizer_rd/shaders/SCsub
index 7d5e88b0ab..194d7d6c0e 100644
--- a/servers/visual/rasterizer_rd/shaders/SCsub
+++ b/servers/visual/rasterizer_rd/shaders/SCsub
@@ -15,5 +15,4 @@ if 'RD_GLSL' in env['BUILDERS']:
     env.RD_GLSL('giprobe_debug.glsl');
     env.RD_GLSL('giprobe_sdf.glsl');
     env.RD_GLSL('luminance_reduce.glsl');
-
-
+    env.RD_GLSL('bokeh_dof.glsl');
diff --git a/servers/visual/rasterizer_rd/shaders/bokeh_dof.glsl b/servers/visual/rasterizer_rd/shaders/bokeh_dof.glsl
new file mode 100644
index 0000000000..7042b72d2a
--- /dev/null
+++ b/servers/visual/rasterizer_rd/shaders/bokeh_dof.glsl
@@ -0,0 +1,141 @@
+/* clang-format off */
+[compute]
+/* clang-format on */
+#version 450
+
+VERSION_DEFINES
+
+#define BLOCK_SIZE 8
+
+layout(local_size_x = BLOCK_SIZE, local_size_y = BLOCK_SIZE, local_size_z = 1) in;
+
+
+#ifdef MODE_GEN_BLUR_SIZE
+layout(rgba16f, set = 0, binding = 0) uniform restrict image2D color_image;
+layout(set = 1, binding = 0) uniform sampler2D source_depth;
+#endif
+
+#ifdef MODE_GEN_BOKEH
+layout(set = 2, binding = 0) uniform sampler2D color_texture;
+layout(set = 1, binding = 0) uniform sampler2D source_depth;
+layout(rgba16f, set = 0, binding = 0) uniform restrict writeonly image2D bokeh_image;
+#endif
+
+#ifdef MODE_COMPOSITE_BOKEH
+layout(rgba16f, set = 0, binding = 0) uniform restrict image2D color_image;
+layout(set = 1, binding = 0) uniform sampler2D source_bokeh;
+#endif
+
+
+
+
+layout(push_constant, binding = 1, std430) uniform Params {
+	ivec2 size;
+	float z_far;
+	float z_near;
+
+	bool orthogonal;
+	float blur_size;
+	float blur_scale;
+	uint pad;
+
+	bool blur_near_active;
+	float blur_near_begin;
+	float blur_near_end;
+	bool blur_far_active;
+	float blur_far_begin;
+	float blur_far_end;
+	uint pad2[2];
+
+} params;
+
+#ifndef MODE_COMPOSITE_BOKEH
+
+float get_depth_at_pos(vec2 uv) {
+	float depth = textureLod(source_depth,uv,0.0).x;
+	if (params.orthogonal) {
+		depth = ((depth + (params.z_far + params.z_near) / (params.z_far - params.z_near)) * (params.z_far - params.z_near)) / 2.0;
+	} else {
+		depth = 2.0 * params.z_near * params.z_far / (params.z_far + params.z_near - depth * (params.z_far - params.z_near));
+	}
+	return depth;
+}
+
+float get_blur_size(float depth) {
+
+	if (params.blur_near_active && depth < params.blur_near_begin) {
+		return smoothstep(params.blur_near_end,params.blur_near_begin,depth) * params.blur_size;
+	}
+
+	if (params.blur_far_active && depth > params.blur_far_begin) {
+		return smoothstep(params.blur_far_begin,params.blur_far_end,depth) * params.blur_size;
+	}
+
+	return 0.0;
+}
+
+#endif
+
+const float GOLDEN_ANGLE = 2.39996323;
+
+void main() {
+
+	ivec2 pos = ivec2(gl_GlobalInvocationID.xy);
+
+	if (any(greaterThan(pos,params.size))) { //too large, do nothing
+		return;
+	}
+
+	vec2 uv = vec2(pos) / vec2(params.size);
+
+#ifdef MODE_GEN_BLUR_SIZE
+	//precompute size in alpha channel
+	float depth = get_depth_at_pos(uv);
+	float size = get_blur_size(depth);
+
+	vec4 color = imageLoad(color_image,pos);
+	color.a = size;
+	imageStore(color_image,pos,color);
+#endif
+
+#ifdef MODE_GEN_BOKEH
+
+	float depth = get_depth_at_pos(uv);
+	float size = get_blur_size(depth);
+	vec4 color = texture(color_texture,uv);
+	float accum = 1.0;
+	float radius = params.blur_scale;
+	vec2 pixel_size = 1.0/vec2(params.size);
+
+	for (float ang = 0.0; radius < params.blur_size; ang += GOLDEN_ANGLE) {
+
+		vec2 suv = uv + vec2(cos(ang), sin(ang)) * pixel_size * radius;
+		vec4 sample_color = texture(color_texture, suv);
+		float sample_depth = get_depth_at_pos(suv);
+		if (sample_depth > depth) {
+			sample_color.a = clamp(sample_color.a, 0.0, size*2.0);
+		}
+
+		float m = smoothstep(radius-0.5, radius+0.5, sample_color.a);
+		color += mix(color/accum, sample_color, m);
+		accum += 1.0;
+		radius += params.blur_size/radius;
+	}
+
+	color /= accum;
+
+	imageStore(bokeh_image,pos,color);
+#endif
+
+#ifdef MODE_COMPOSITE_BOKEH
+
+	vec4 color = imageLoad(color_image,pos);
+	vec4 bokeh = texture(source_bokeh,uv);
+	if (max(color.a,bokeh.a) > 0.5) { //there is some blur in this pixel, so use bokeh
+		color = bokeh;
+	}
+	color.a=0; //reset alpha
+	imageStore(color_image,pos,color);
+#endif
+
+}