Merge pull request #50998 from BastiaanOlij/single_bokeh_dof_raster

Rewrote raster DOF shader to using BOKEH

5 files changed, 294 insertions, 147 deletions

diff --git a/servers/rendering/renderer_rd/shaders/blur_raster.glsl b/servers/rendering/renderer_rd/shaders/blur_raster.glsl
index b1d1c2365e..0789a4b396 100644
--- a/servers/rendering/renderer_rd/shaders/blur_raster.glsl
+++ b/servers/rendering/renderer_rd/shaders/blur_raster.glsl
@@ -37,32 +37,6 @@ layout(set = 1, binding = 0) uniform sampler2D source_auto_exposure;
 
 layout(location = 0) out vec4 frag_color;
 
-//DOF
-#ifdef MODE_DOF_BLUR
-
-layout(set = 1, binding = 0) uniform sampler2D dof_source_depth;
-
-#ifdef DOF_QUALITY_LOW
-const int dof_kernel_size = 5;
-const int dof_kernel_from = 2;
-const float dof_kernel[5] = float[](0.153388, 0.221461, 0.250301, 0.221461, 0.153388);
-#endif
-
-#ifdef DOF_QUALITY_MEDIUM
-const int dof_kernel_size = 11;
-const int dof_kernel_from = 5;
-const float dof_kernel[11] = float[](0.055037, 0.072806, 0.090506, 0.105726, 0.116061, 0.119726, 0.116061, 0.105726, 0.090506, 0.072806, 0.055037);
-
-#endif
-
-#ifdef DOF_QUALITY_HIGH
-const int dof_kernel_size = 21;
-const int dof_kernel_from = 10;
-const float dof_kernel[21] = float[](0.028174, 0.032676, 0.037311, 0.041944, 0.046421, 0.050582, 0.054261, 0.057307, 0.059587, 0.060998, 0.061476, 0.060998, 0.059587, 0.057307, 0.054261, 0.050582, 0.046421, 0.041944, 0.037311, 0.032676, 0.028174);
-#endif
-
-#endif
-
 void main() {
 #ifdef MODE_MIPMAP
 
@@ -155,74 +129,8 @@ void main() {
 
 #endif
 
-#ifdef MODE_DOF_BLUR
-
-	vec4 color_accum = vec4(0.0);
-
-	float depth = texture(dof_source_depth, uv_interp, 0.0).r;
-	depth = depth * 2.0 - 1.0;
-
-	if (bool(blur.flags & FLAG_USE_ORTHOGONAL_PROJECTION)) {
-		depth = ((depth + (blur.camera_z_far + blur.camera_z_near) / (blur.camera_z_far - blur.camera_z_near)) * (blur.camera_z_far - blur.camera_z_near)) / 2.0;
-	} else {
-		depth = 2.0 * blur.camera_z_near * blur.camera_z_far / (blur.camera_z_far + blur.camera_z_near - depth * (blur.camera_z_far - blur.camera_z_near));
-	}
-
-	// mix near and far blur amount
-	float amount = 1.0;
-	if (bool(blur.flags & FLAG_DOF_FAR)) {
-		amount *= 1.0 - smoothstep(blur.dof_far_begin, blur.dof_far_end, depth);
-	}
-	if (bool(blur.flags & FLAG_DOF_NEAR)) {
-		amount *= smoothstep(blur.dof_near_end, blur.dof_near_begin, depth);
-	}
-	amount = 1.0 - amount;
-
-	if (amount > 0.0) {
-		float k_accum = 0.0;
-
-		for (int i = 0; i < dof_kernel_size; i++) {
-			int int_ofs = i - dof_kernel_from;
-			vec2 tap_uv = uv_interp + blur.dof_dir * float(int_ofs) * amount * blur.dof_radius;
-
-			float tap_k = dof_kernel[i];
-
-			float tap_depth = texture(dof_source_depth, tap_uv, 0.0).r;
-			tap_depth = tap_depth * 2.0 - 1.0;
-
-			if (bool(blur.flags & FLAG_USE_ORTHOGONAL_PROJECTION)) {
-				tap_depth = ((tap_depth + (blur.camera_z_far + blur.camera_z_near) / (blur.camera_z_far - blur.camera_z_near)) * (blur.camera_z_far - blur.camera_z_near)) / 2.0;
-			} else {
-				tap_depth = 2.0 * blur.camera_z_near * blur.camera_z_far / (blur.camera_z_far + blur.camera_z_near - tap_depth * (blur.camera_z_far - blur.camera_z_near));
-			}
-
-			// mix near and far blur amount
-			float tap_amount = 1.0;
-			if (bool(blur.flags & FLAG_DOF_FAR)) {
-				tap_amount *= mix(1.0 - smoothstep(blur.dof_far_begin, blur.dof_far_end, tap_depth), 0.0, int_ofs == 0);
-			}
-			if (bool(blur.flags & FLAG_DOF_NEAR)) {
-				tap_amount *= mix(smoothstep(blur.dof_near_end, blur.dof_near_begin, tap_depth), 0.0, int_ofs == 0);
-			}
-			tap_amount = 1.0 - tap_amount;
-
-			tap_amount *= tap_amount * tap_amount; //prevent undesired glow effect
-
-			vec4 tap_color = texture(source_color, tap_uv, 0.0) * tap_k;
-
-			k_accum += tap_k * tap_amount;
-			color_accum += tap_color * tap_amount;
-		}
-
-		if (k_accum > 0.0) {
-			color_accum /= k_accum;
-		}
-
-		frag_color = color_accum; ///k_accum;
-	} else {
-		// we are in focus, don't waste time
-		frag_color = texture(source_color, uv_interp, 0.0);
-	}
-
+#ifdef MODE_COPY
+	vec4 color = textureLod(source_color, uv_interp, 0.0);
+	frag_color = color;
 #endif
 }
diff --git a/servers/rendering/renderer_rd/shaders/blur_raster_inc.glsl b/servers/rendering/renderer_rd/shaders/blur_raster_inc.glsl
index 6ea968e595..52bf2886b5 100644
--- a/servers/rendering/renderer_rd/shaders/blur_raster_inc.glsl
+++ b/servers/rendering/renderer_rd/shaders/blur_raster_inc.glsl
@@ -1,8 +1,6 @@
 #define FLAG_HORIZONTAL (1 << 0)
 #define FLAG_USE_ORTHOGONAL_PROJECTION (1 << 1)
 #define FLAG_GLOW_FIRST_PASS (1 << 2)
-#define FLAG_DOF_FAR (1 << 3)
-#define FLAG_DOF_NEAR (1 << 4)
 
 layout(push_constant, binding = 1, std430) uniform Blur {
 	vec2 pixel_size;
@@ -19,18 +17,5 @@ layout(push_constant, binding = 1, std430) uniform Blur {
 	float glow_white;
 	float glow_luminance_cap;
 	float glow_auto_exposure_grey;
-
-	// DOF.
-	float dof_far_begin;
-	float dof_far_end;
-	float dof_near_begin;
-	float dof_near_end;
-
-	float dof_radius;
-	float dof_pad[3];
-
-	vec2 dof_dir;
-	float camera_z_far;
-	float camera_z_near;
 }
 blur;
diff --git a/servers/rendering/renderer_rd/shaders/bokeh_dof.glsl b/servers/rendering/renderer_rd/shaders/bokeh_dof.glsl
index b70e0b6bd5..0438671dd2 100644
--- a/servers/rendering/renderer_rd/shaders/bokeh_dof.glsl
+++ b/servers/rendering/renderer_rd/shaders/bokeh_dof.glsl
@@ -25,34 +25,7 @@ layout(set = 1, binding = 0) uniform sampler2D source_bokeh;
 
 // based on https://www.shadertoy.com/view/Xd3GDl
 
-layout(push_constant, binding = 1, std430) uniform Params {
-	ivec2 size;
-	float z_far;
-	float z_near;
-
-	bool orthogonal;
-	float blur_size;
-	float blur_scale;
-	int blur_steps;
-
-	bool blur_near_active;
-	float blur_near_begin;
-	float blur_near_end;
-	bool blur_far_active;
-
-	float blur_far_begin;
-	float blur_far_end;
-	bool second_pass;
-	bool half_size;
-
-	bool use_jitter;
-	float jitter_seed;
-	uint pad[2];
-}
-params;
-
-//used to work around downsampling filter
-#define DEPTH_GAP 0.0
+#include "bokeh_dof_inc.glsl"
 
 #ifdef MODE_GEN_BLUR_SIZE
 
@@ -80,15 +53,6 @@ float get_blur_size(float depth) {
 
 #endif
 
-const float GOLDEN_ANGLE = 2.39996323;
-
-//note: uniform pdf rand [0;1[
-float hash12n(vec2 p) {
-	p = fract(p * vec2(5.3987, 5.4421));
-	p += dot(p.yx, p.xy + vec2(21.5351, 14.3137));
-	return fract(p.x * p.y * 95.4307);
-}
-
 #if defined(MODE_BOKEH_BOX) || defined(MODE_BOKEH_HEXAGONAL)
 
 vec4 weighted_filter_dir(vec2 dir, vec2 uv, vec2 pixel_size) {
diff --git a/servers/rendering/renderer_rd/shaders/bokeh_dof_inc.glsl b/servers/rendering/renderer_rd/shaders/bokeh_dof_inc.glsl
new file mode 100644
index 0000000000..fadea1631c
--- /dev/null
+++ b/servers/rendering/renderer_rd/shaders/bokeh_dof_inc.glsl
@@ -0,0 +1,37 @@
+layout(push_constant, binding = 1, std430) uniform Params {
+	ivec2 size;
+	float z_far;
+	float z_near;
+
+	bool orthogonal;
+	float blur_size;
+	float blur_scale;
+	int blur_steps;
+
+	bool blur_near_active;
+	float blur_near_begin;
+	float blur_near_end;
+	bool blur_far_active;
+
+	float blur_far_begin;
+	float blur_far_end;
+	bool second_pass;
+	bool half_size;
+
+	bool use_jitter;
+	float jitter_seed;
+	uint pad[2];
+}
+params;
+
+//used to work around downsampling filter
+#define DEPTH_GAP 0.0
+
+const float GOLDEN_ANGLE = 2.39996323;
+
+//note: uniform pdf rand [0;1[
+float hash12n(vec2 p) {
+	p = fract(p * vec2(5.3987, 5.4421));
+	p += dot(p.yx, p.xy + vec2(21.5351, 14.3137));
+	return fract(p.x * p.y * 95.4307);
+}
diff --git a/servers/rendering/renderer_rd/shaders/bokeh_dof_raster.glsl b/servers/rendering/renderer_rd/shaders/bokeh_dof_raster.glsl
new file mode 100644
index 0000000000..43a2a29616
--- /dev/null
+++ b/servers/rendering/renderer_rd/shaders/bokeh_dof_raster.glsl
@@ -0,0 +1,253 @@
+/* clang-format off */
+#[vertex]
+
+#version 450
+
+#VERSION_DEFINES
+
+#include "bokeh_dof_inc.glsl"
+
+layout(location = 0) out vec2 uv_interp;
+/* clang-format on */
+
+void main() {
+	vec2 base_arr[4] = vec2[](vec2(0.0, 0.0), vec2(0.0, 1.0), vec2(1.0, 1.0), vec2(1.0, 0.0));
+	uv_interp = base_arr[gl_VertexIndex];
+
+	gl_Position = vec4(uv_interp * 2.0 - 1.0, 0.0, 1.0);
+}
+
+/* clang-format off */
+#[fragment]
+
+#version 450
+
+#VERSION_DEFINES
+
+#include "bokeh_dof_inc.glsl"
+
+layout(location = 0) in vec2 uv_interp;
+/* clang-format on */
+
+#ifdef MODE_GEN_BLUR_SIZE
+layout(location = 0) out float weight;
+
+layout(set = 0, binding = 0) uniform sampler2D source_depth;
+#else
+layout(location = 0) out vec4 frag_color;
+#ifdef OUTPUT_WEIGHT
+layout(location = 1) out float weight;
+#endif
+
+layout(set = 0, binding = 0) uniform sampler2D source_color;
+layout(set = 1, binding = 0) uniform sampler2D source_weight;
+#ifdef MODE_COMPOSITE_BOKEH
+layout(set = 2, binding = 0) uniform sampler2D original_weight;
+#endif
+#endif
+
+//DOF
+// Bokeh single pass implementation based on http://tuxedolabs.blogspot.com/2018/05/bokeh-depth-of-field-in-single-pass.html
+
+#ifdef MODE_GEN_BLUR_SIZE
+
+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 -(1.0 - smoothstep(params.blur_near_end, params.blur_near_begin, depth)) * params.blur_size - DEPTH_GAP; //near blur is negative
+	}
+
+	if (params.blur_far_active && depth > params.blur_far_begin) {
+		return smoothstep(params.blur_far_begin, params.blur_far_end, depth) * params.blur_size + DEPTH_GAP;
+	}
+
+	return 0.0;
+}
+
+#endif
+
+#if defined(MODE_BOKEH_BOX) || defined(MODE_BOKEH_HEXAGONAL)
+
+vec4 weighted_filter_dir(vec2 dir, vec2 uv, vec2 pixel_size) {
+	dir *= pixel_size;
+	vec4 color = texture(source_color, uv);
+	color.a = texture(source_weight, uv).r;
+
+	vec4 accum = color;
+	float total = 1.0;
+
+	float blur_scale = params.blur_size / float(params.blur_steps);
+
+	if (params.use_jitter) {
+		uv += dir * (hash12n(uv + params.jitter_seed) - 0.5);
+	}
+
+	for (int i = -params.blur_steps; i <= params.blur_steps; i++) {
+		if (i == 0) {
+			continue;
+		}
+		float radius = float(i) * blur_scale;
+		vec2 suv = uv + dir * radius;
+		radius = abs(radius);
+
+		vec4 sample_color = texture(source_color, suv);
+		sample_color.a = texture(source_weight, suv).r;
+		float limit;
+
+		if (sample_color.a < color.a) {
+			limit = abs(sample_color.a);
+		} else {
+			limit = abs(color.a);
+		}
+
+		limit -= DEPTH_GAP;
+
+		float m = smoothstep(radius - 0.5, radius + 0.5, limit);
+
+		accum += mix(color, sample_color, m);
+
+		total += 1.0;
+	}
+
+	return accum / total;
+}
+
+#endif
+
+void main() {
+	vec2 pixel_size = 1.0 / vec2(params.size);
+	vec2 uv = uv_interp;
+
+#ifdef MODE_GEN_BLUR_SIZE
+	uv += pixel_size * 0.5;
+	float center_depth = get_depth_at_pos(uv);
+	weight = get_blur_size(center_depth);
+#endif
+
+#ifdef MODE_BOKEH_BOX
+	//pixel_size*=0.5; //resolution is doubled
+	if (params.second_pass || !params.half_size) {
+		uv += pixel_size * 0.5; //half pixel to read centers
+	} else {
+		uv += pixel_size * 0.25; //half pixel to read centers from full res
+	}
+
+	float alpha = texture(source_color, uv).a; // retain this
+	vec2 dir = (params.second_pass ? vec2(0.0, 1.0) : vec2(1.0, 0.0));
+
+	vec4 color = weighted_filter_dir(dir, uv, pixel_size);
+
+	frag_color = color;
+	frag_color.a = alpha; // attempt to retain this in case we have a transparent background, ignored if half_size
+#ifdef OUTPUT_WEIGHT
+	weight = color.a;
+#endif
+
+#endif
+
+#ifdef MODE_BOKEH_HEXAGONAL
+
+	//pixel_size*=0.5; //resolution is doubled
+	if (params.second_pass || !params.half_size) {
+		uv += pixel_size * 0.5; //half pixel to read centers
+	} else {
+		uv += pixel_size * 0.25; //half pixel to read centers from full res
+	}
+
+	float alpha = texture(source_color, uv).a; // retain this
+
+	vec2 dir = (params.second_pass ? normalize(vec2(1.0, 0.577350269189626)) : vec2(0.0, 1.0));
+
+	vec4 color = weighted_filter_dir(dir, uv, pixel_size);
+
+	if (params.second_pass) {
+		dir = normalize(vec2(-1.0, 0.577350269189626));
+
+		vec4 color2 = weighted_filter_dir(dir, uv, pixel_size);
+
+		color.rgb = min(color.rgb, color2.rgb);
+		color.a = (color.a + color2.a) * 0.5;
+	}
+
+	frag_color = color;
+	frag_color.a = alpha; // attempt to retain this in case we have a transparent background, ignored if half_size
+#ifdef OUTPUT_WEIGHT
+	weight = color.a;
+#endif
+
+#endif
+
+#ifdef MODE_BOKEH_CIRCULAR
+	if (params.half_size) {
+		pixel_size *= 0.5; //resolution is doubled
+	}
+
+	uv += pixel_size * 0.5; //half pixel to read centers
+
+	vec4 color = texture(source_color, uv);
+	float alpha = color.a; // retain this
+	color.a = texture(source_weight, uv).r;
+
+	vec4 color_accum = color;
+	float accum = 1.0;
+
+	float radius = params.blur_scale;
+	for (float ang = 0.0; radius < params.blur_size; ang += GOLDEN_ANGLE) {
+		vec2 uv_adj = uv + vec2(cos(ang), sin(ang)) * pixel_size * radius;
+
+		vec4 sample_color = texture(source_color, uv_adj);
+		sample_color.a = texture(source_weight, uv_adj).r;
+
+		float limit;
+
+		if (sample_color.a < color.a) {
+			limit = abs(sample_color.a);
+		} else {
+			limit = abs(color.a);
+		}
+
+		limit -= DEPTH_GAP;
+
+		float m = smoothstep(radius - 0.5, radius + 0.5, limit);
+		color_accum += mix(color_accum / accum, sample_color, m);
+		accum += 1.0;
+
+		radius += params.blur_scale / radius;
+	}
+
+	color_accum = color_accum / accum;
+
+	frag_color.rgb = color_accum.rgb;
+	frag_color.a = alpha; // attempt to retain this in case we have a transparent background, ignored if half_size
+#ifdef OUTPUT_WEIGHT
+	weight = color_accum.a;
+#endif
+
+#endif
+
+#ifdef MODE_COMPOSITE_BOKEH
+	frag_color.rgb = texture(source_color, uv).rgb;
+
+	float center_weigth = texture(source_weight, uv).r;
+	float sample_weight = texture(original_weight, uv).r;
+
+	float mix_amount;
+	if (sample_weight < center_weigth) {
+		mix_amount = min(1.0, max(0.0, max(abs(center_weigth), abs(sample_weight)) - DEPTH_GAP));
+	} else {
+		mix_amount = min(1.0, max(0.0, abs(center_weigth) - DEPTH_GAP));
+	}
+
+	// let alpha blending take care of mixing
+	frag_color.a = mix_amount;
+#endif
+}