Blender V5.3
eevee_depth_of_field_tiles.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
8
9namespace eevee::dof {
10
15
20
33namespace tile_flatten {
34
50
51static constexpr uint dof_tile_large_coc_uint = floatBitsToUint(dof_tile_large_coc);
52
53[[compute, local_size(DOF_TILES_FLATTEN_GROUP_SIZE, DOF_TILES_FLATTEN_GROUP_SIZE)]]
56 [[work_group_id]] const uint3 group_id,
57 [[global_invocation_id]] const uint3 global_id,
58 [[local_invocation_index]] const uint local_index)
59{
60 if (local_index == 0u) {
61 /* NOTE: Min/Max flipped because of inverted fg_coc sign. */
62 srt.fg_min_coc = floatBitsToUint(0.0f);
63 srt.fg_max_coc = dof_tile_large_coc_uint;
64 srt.fg_max_intersectable_coc = dof_tile_large_coc_uint;
65 srt.bg_min_coc = dof_tile_large_coc_uint;
66 srt.bg_max_coc = floatBitsToUint(0.0f);
67 srt.bg_min_intersectable_coc = dof_tile_large_coc_uint;
68 }
69 barrier();
70
71 int2 sample_texel = min(int2(global_id.xy), textureSize(srt.coc_tx, 0).xy - 1);
72 float2 sample_data = texelFetch(srt.coc_tx, sample_texel, 0).rg;
73
74 float sample_coc = sample_data.x;
75 uint fg_coc = floatBitsToUint(max(-sample_coc, 0.0f));
76 /* NOTE: atomicMin/Max flipped because of inverted fg_coc sign. */
77 atomicMax(srt.fg_min_coc, fg_coc);
78 atomicMin(srt.fg_max_coc, fg_coc);
79 atomicMin(srt.fg_max_intersectable_coc, (sample_coc < 0.0f) ? fg_coc : dof_tile_large_coc_uint);
80
81 uint bg_coc = floatBitsToUint(max(sample_coc, 0.0f));
82 atomicMin(srt.bg_min_coc, bg_coc);
83 atomicMax(srt.bg_max_coc, bg_coc);
84 atomicMin(srt.bg_min_intersectable_coc, (sample_coc > 0.0f) ? bg_coc : dof_tile_large_coc_uint);
85
86 barrier();
87
88 if (local_index == 0u) {
89 if (srt.fg_max_intersectable_coc == dof_tile_large_coc_uint) {
90 srt.fg_max_intersectable_coc = floatBitsToUint(0.0f);
91 }
92
94 /* Foreground sign is flipped since we compare unsigned representation. */
95 tile.fg_min_coc = -uintBitsToFloat(srt.fg_min_coc);
96 tile.fg_max_coc = -uintBitsToFloat(srt.fg_max_coc);
97 tile.fg_max_intersectable_coc = -uintBitsToFloat(srt.fg_max_intersectable_coc);
98 tile.bg_min_coc = uintBitsToFloat(srt.bg_min_coc);
99 tile.bg_max_coc = uintBitsToFloat(srt.bg_max_coc);
100 tile.bg_min_intersectable_coc = uintBitsToFloat(srt.bg_min_intersectable_coc);
101
102 int2 tile_co = int2(group_id.xy);
103 dof_coc_tile_store(tiles.out_tiles_fg_img, tiles.out_tiles_bg_img, tile_co, tile);
104 }
105}
106
107} // namespace tile_flatten
108
116namespace tile_dilate {
117
124
125[[compute, local_size(DOF_TILES_DILATE_GROUP_SIZE, DOF_TILES_DILATE_GROUP_SIZE)]]
127 [[resource_table]] Tiles &in_tiles,
128 [[resource_table]] TilesWrite &out_tiles,
129 [[global_invocation_id]] const uint3 global_id)
130{
131 int2 center_tile_pos = int2(global_id.xy);
132
133 /* Error introduced by the random offset of the gathering kernel's center. */
134 constexpr float bluring_radius_error = 1.0f + 1.0f / (float(DOF_GATHER_RING_COUNT) + 0.5f);
135 constexpr float tile_to_fullres_factor = float(DOF_TILES_SIZE * 2);
136
137 CocTile ring_buckets[DOF_DILATE_RING_COUNT];
138
139 for (int ring = 0; ring < srt.ring_count && ring < DOF_DILATE_RING_COUNT; ring++) {
140 ring_buckets[ring] = dof_coc_tile_init();
141
142 int ring_distance = ring + 1;
143 for (int sample_id = 0; sample_id < 4 * ring_distance; sample_id++) {
144 int2 offset = dof_square_ring_sample_offset(ring_distance, sample_id);
145
146 offset *= srt.ring_width_multiplier;
147
148 for (int i = 0; i < 2; i++) {
149 int2 adj_tile_pos = center_tile_pos + ((i == 0) ? offset : -offset);
150
151 CocTile adj_tile = dof_coc_tile_load(
152 in_tiles.in_tiles_fg_img, in_tiles.in_tiles_bg_img, adj_tile_pos);
153
154 if (srt.dilate_mode_min_max) [[static_branch]] {
155 /* Actually gather the "absolute" biggest coc but keeping the sign. */
156 ring_buckets[ring].fg_min_coc = min(ring_buckets[ring].fg_min_coc, adj_tile.fg_min_coc);
157 ring_buckets[ring].bg_max_coc = max(ring_buckets[ring].bg_max_coc, adj_tile.bg_max_coc);
158 }
159 else { /* DILATE_MODE_MIN_ABS */
160 ring_buckets[ring].fg_max_coc = max(ring_buckets[ring].fg_max_coc, adj_tile.fg_max_coc);
161 ring_buckets[ring].bg_min_coc = min(ring_buckets[ring].bg_min_coc, adj_tile.bg_min_coc);
162
163 /* Should be tight as possible to reduce gather overhead (see slide 61). */
164 float closest_neighbor_distance = length(max(abs(float2(offset)) - 1.0f, 0.0f)) *
165 tile_to_fullres_factor;
166
167 ring_buckets[ring].fg_max_intersectable_coc = max(
168 ring_buckets[ring].fg_max_intersectable_coc,
169 adj_tile.fg_max_intersectable_coc + closest_neighbor_distance);
170 ring_buckets[ring].bg_min_intersectable_coc = min(
171 ring_buckets[ring].bg_min_intersectable_coc,
172 adj_tile.bg_min_intersectable_coc + closest_neighbor_distance);
173 }
174 }
175 }
176 }
177
178 /* Load center tile. */
179 CocTile out_tile = dof_coc_tile_load(
180 in_tiles.in_tiles_fg_img, in_tiles.in_tiles_bg_img, center_tile_pos);
181
182 for (int ring = 0; ring < srt.ring_count && ring < DOF_DILATE_RING_COUNT; ring++) {
183 float ring_distance = float(ring + 1);
184
185 ring_distance = (ring_distance * srt.ring_width_multiplier - 1) * tile_to_fullres_factor;
186
187 if (srt.dilate_mode_min_max) [[static_branch]] {
188 /* NOTE(fclem): Unsure if both sides of the inequalities have the same unit. */
189 if (-ring_buckets[ring].fg_min_coc * bluring_radius_error > ring_distance) {
190 out_tile.fg_min_coc = min(out_tile.fg_min_coc, ring_buckets[ring].fg_min_coc);
191 }
192
193 if (ring_buckets[ring].bg_max_coc * bluring_radius_error > ring_distance) {
194 out_tile.bg_max_coc = max(out_tile.bg_max_coc, ring_buckets[ring].bg_max_coc);
195 }
196 }
197 else { /* DILATE_MODE_MIN_ABS */
198 /* Find minimum absolute CoC radii that will be intersected for the previously
199 * computed maximum CoC values. */
200 if (-out_tile.fg_min_coc * bluring_radius_error > ring_distance) {
201 out_tile.fg_max_coc = max(out_tile.fg_max_coc, ring_buckets[ring].fg_max_coc);
203 ring_buckets[ring].fg_max_intersectable_coc);
204 }
205
206 if (out_tile.bg_max_coc * bluring_radius_error > ring_distance) {
207 out_tile.bg_min_coc = min(out_tile.bg_min_coc, ring_buckets[ring].bg_min_coc);
209 ring_buckets[ring].bg_min_intersectable_coc);
210 }
211 }
212 }
213
214 int2 texel_out = int2(global_id.xy);
215 dof_coc_tile_store(out_tiles.out_tiles_fg_img, out_tiles.out_tiles_bg_img, texel_out, out_tile);
216}
217
218} // namespace tile_dilate
219
220} // namespace eevee::dof
221
223
226 .dilate_mode_min_max = false});
229 .dilate_mode_min_max = true});
btScalar max
void dof_coc_tile_store(image2D tiles_fg_img, image2D tiles_bg_img, int2 texel_out, CocTile tile_data)
int2 dof_square_ring_sample_offset(int ring_distance, int sample_id)
CocTile dof_coc_tile_load(image2D tiles_fg_img, image2D tiles_bg_img, int2 texel)
CocTile dof_coc_tile_init()
PipelineCompute eevee_depth_of_field_tiles_dilate_minabs(eevee::dof::tile_dilate::comp_main, eevee::dof::tile_dilate::Resources{ .dilate_mode_min_max=false})
PipelineCompute eevee_depth_of_field_tiles_flatten(eevee::dof::tile_flatten::comp_main)
PipelineCompute eevee_depth_of_field_tiles_dilate_minmax(eevee::dof::tile_dilate::comp_main, eevee::dof::tile_dilate::Resources{ .dilate_mode_min_max=true})
#define shared
#define local_invocation_index
#define image(slot, qualifiers, format)
#define work_group_id
#define push_constant
#define compilation_constant
#define resource_table
#define sampler(slot)
#define static_branch
#define global_invocation_id
#define compute
#define local_size(...)
int atomicMin(int &, int) RET
int atomicMax(int &, int) RET
#define abs
VecBase< uint, D > floatBitsToUint(VecOp< float, D >) RET
VecBase< float, D > uintBitsToFloat(VecOp< uint, D >) RET
void barrier()
float length(VecOp< float, D >) RET
ImageBase< float, 2 > image2D
TEX_TEMPLATE DataVec texelFetch(T, IntCoord, int) RET
SamplerBase< float, 2 > sampler2D
TEX_TEMPLATE SizeVec textureSize(T, int) RET
ccl_gpu_kernel_postfix ccl_global KernelWorkTile * tiles
const ccl_global KernelWorkTile * tile
void comp_main(Resources &srt, Tiles &in_tiles, TilesWrite &out_tiles, const uint3 global_id)
void comp_main(Resources &srt, TilesWrite &tiles, const uint3 group_id, const uint3 global_id, const uint local_index)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define min(a, b)
Definition sort.cc:38
float x