1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
/**
* Recombine Pass: Load separate convolution layer and composite with self
* slight defocus convolution and in-focus fields.
*
* The halfres gather methods are fast but lack precision for small CoC areas.
* To fix this we do a bruteforce gather to have a smooth transition between
* in-focus and defocus regions.
*/
#pragma BLENDER_REQUIRE(eevee_depth_of_field_accumulator_lib.glsl)
shared uint shared_max_slight_focus_abs_coc;
/**
* Returns The max CoC in the Slight Focus range inside this compute tile.
*/
float dof_slight_focus_coc_tile_get(vec2 frag_coord)
{
if (all(equal(gl_LocalInvocationID, uvec3(0)))) {
shared_max_slight_focus_abs_coc = floatBitsToUint(0.0);
}
barrier();
float local_abs_max = 0.0;
/* Sample in a cross (X) pattern. This covers all pixels over the whole tile, as long as
* dof_max_slight_focus_radius is less than the group size. */
for (int i = 0; i < 4; i++) {
vec2 sample_uv = (frag_coord + quad_offsets[i] * 2.0 * dof_max_slight_focus_radius) /
vec2(textureSize(color_tx, 0));
float coc = dof_coc_from_depth(dof_buf, sample_uv, textureLod(depth_tx, sample_uv, 0.0).r);
coc = clamp(coc, -dof_buf.coc_abs_max, dof_buf.coc_abs_max);
if (abs(coc) < dof_max_slight_focus_radius) {
local_abs_max = max(local_abs_max, abs(coc));
}
}
/* Use atomic reduce operation. */
atomicMax(shared_max_slight_focus_abs_coc, floatBitsToUint(local_abs_max));
/* "Broadcast" result across all threads. */
barrier();
return uintBitsToFloat(shared_max_slight_focus_abs_coc);
}
vec3 dof_neighborhood_clamp(vec2 frag_coord, vec3 color, float center_coc, float weight)
{
/* Stabilize color by clamping with the stable half res neighborhood. */
vec3 neighbor_min, neighbor_max;
const vec2 corners[4] = vec2[4](vec2(-1, -1), vec2(1, -1), vec2(-1, 1), vec2(1, 1));
for (int i = 0; i < 4; i++) {
/**
* Visit the 4 half-res texels around (and containing) the fullres texel.
* Here a diagram of a fullscreen texel (f) in the bottom left corner of a half res texel.
* We sample the stable half-resolution texture at the 4 location denoted by (h).
* ┌───────┬───────┐
* │ h │ h │
* │ │ │
* │ │ f │
* ├───────┼───────┤
* │ h │ h │
* │ │ │
* │ │ │
* └───────┴───────┘
*/
vec2 uv_sample = ((frag_coord + corners[i]) * 0.5) / vec2(textureSize(stable_color_tx, 0));
/* Reminder: The content of this buffer is YCoCg + CoC. */
vec3 ycocg_sample = textureLod(stable_color_tx, uv_sample, 0.0).rgb;
neighbor_min = (i == 0) ? ycocg_sample : min(neighbor_min, ycocg_sample);
neighbor_max = (i == 0) ? ycocg_sample : max(neighbor_max, ycocg_sample);
}
/* Pad the bounds in the near in focus region to get back a bit of detail. */
float padding = 0.125 * saturate(1.0 - sqr(center_coc) / sqr(8.0));
neighbor_max += abs(neighbor_min) * padding;
neighbor_min -= abs(neighbor_min) * padding;
/* Progressively apply the clamp to avoid harsh transition. Also mask by weight. */
float fac = saturate(sqr(center_coc) * 4.0) * weight;
/* Clamp in YCoCg space to avoid too much color drift. */
color = colorspace_YCoCg_from_scene_linear(color);
color = mix(color, clamp(color, neighbor_min, neighbor_max), fac);
color = colorspace_scene_linear_from_YCoCg(color);
return color;
}
void main()
{
vec2 frag_coord = vec2(gl_GlobalInvocationID.xy) + 0.5;
ivec2 tile_co = ivec2(frag_coord / float(DOF_TILES_SIZE * 2));
CocTile coc_tile = dof_coc_tile_load(in_tiles_fg_img, in_tiles_bg_img, tile_co);
CocTilePrediction prediction = dof_coc_tile_prediction_get(coc_tile);
vec2 uv = frag_coord / vec2(textureSize(color_tx, 0));
vec2 uv_halfres = (frag_coord * 0.5) / vec2(textureSize(color_bg_tx, 0));
float slight_focus_max_coc = 0.0;
if (prediction.do_slight_focus) {
slight_focus_max_coc = dof_slight_focus_coc_tile_get(frag_coord);
prediction.do_slight_focus = slight_focus_max_coc >= 0.5;
if (prediction.do_slight_focus) {
prediction.do_focus = false;
}
}
if (prediction.do_focus) {
float center_coc = (dof_coc_from_depth(dof_buf, uv, textureLod(depth_tx, uv, 0.0).r));
prediction.do_focus = abs(center_coc) <= 0.5;
}
vec4 out_color = vec4(0.0);
float weight = 0.0;
vec4 layer_color;
float layer_weight;
if (!no_hole_fill_pass && prediction.do_hole_fill) {
layer_color = textureLod(color_hole_fill_tx, uv_halfres, 0.0);
layer_weight = textureLod(weight_hole_fill_tx, uv_halfres, 0.0).r;
out_color = layer_color * safe_rcp(layer_weight);
weight = float(layer_weight > 0.0);
}
if (!no_background_pass && prediction.do_background) {
layer_color = textureLod(color_bg_tx, uv_halfres, 0.0);
layer_weight = textureLod(weight_bg_tx, uv_halfres, 0.0).r;
/* Always prefer background to hole_fill pass. */
layer_color *= safe_rcp(layer_weight);
layer_weight = float(layer_weight > 0.0);
/* Composite background. */
out_color = out_color * (1.0 - layer_weight) + layer_color;
weight = weight * (1.0 - layer_weight) + layer_weight;
/* Fill holes with the composited background. */
out_color *= safe_rcp(weight);
weight = float(weight > 0.0);
}
if (!no_slight_focus_pass && prediction.do_slight_focus) {
float center_coc;
dof_slight_focus_gather(depth_tx,
color_tx,
bokeh_lut_tx,
slight_focus_max_coc,
layer_color,
layer_weight,
center_coc);
/* Composite slight defocus. */
out_color = out_color * (1.0 - layer_weight) + layer_color;
weight = weight * (1.0 - layer_weight) + layer_weight;
out_color.rgb = dof_neighborhood_clamp(frag_coord, out_color.rgb, center_coc, layer_weight);
}
if (!no_focus_pass && prediction.do_focus) {
layer_color = safe_color(textureLod(color_tx, uv, 0.0));
layer_weight = 1.0;
/* Composite in focus. */
out_color = out_color * (1.0 - layer_weight) + layer_color;
weight = weight * (1.0 - layer_weight) + layer_weight;
}
if (!no_foreground_pass && prediction.do_foreground) {
layer_color = textureLod(color_fg_tx, uv_halfres, 0.0);
layer_weight = textureLod(weight_fg_tx, uv_halfres, 0.0).r;
/* Composite foreground. */
out_color = out_color * (1.0 - layer_weight) + layer_color;
}
/* Fix float precision issue in alpha compositing. */
if (out_color.a > 0.99) {
out_color.a = 1.0;
}
if (debug_resolve_perf && prediction.do_slight_focus) {
out_color.rgb *= vec3(1.0, 0.1, 0.1);
}
imageStore(out_color_img, ivec2(gl_GlobalInvocationID.xy), out_color);
}
|
