Blender V5.3
eevee_ray_tile.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
10#include "eevee_uniform.bsl.hh"
11#include "gpu_shader_codegen_lib.glsl"
13
14namespace eevee::raytracing {
15
26
27/* Returns a blend factor between different tracing method. */
28float ray_roughness_factor(RayTraceData raytrace, float roughness)
29{
30 return saturate(roughness * raytrace.roughness_mask_scale - raytrace.roughness_mask_bias);
31}
32
37[[compute, local_size(RAYTRACE_GROUP_SIZE, RAYTRACE_GROUP_SIZE)]]
39 [[resource_table]] const Uniform &uni,
40 [[resource_table]] const gbuffer::Reader &reader,
41 [[work_group_id]] const uint3 group_id,
42 [[global_invocation_id]] const uint3 global_id,
43 [[local_invocation_index]] const uint local_index)
44{
45 if (local_index == 0u) {
46 /* Init shared variables. */
47 srt.tile_contains_fast_gi_scan = 0;
48 for (int i = 0; i < GBUFFER_LAYER_MAX; i++) {
49 srt.tile_contains_ray_tracing[i] = 0;
50 }
51 }
52
53 barrier();
54
55 int2 texel = int2(global_id.xy);
56
57 bool valid_texel = in_texture_range(texel, reader.gbuf_header_tx);
58
59 if (valid_texel) {
60 gbuffer::Header header = reader.read_header(texel);
61
62 for (uchar i = 0; i < GBUFFER_LAYER_MAX; i++) {
63 ClosureUndetermined cl = reader.read_bin(header, texel, i);
64 if (cl.type == CLOSURE_NONE_ID) {
65 continue;
66 }
67 float roughness = closure_apparent_roughness_get(cl);
68 float ray_roughness_fac = ray_roughness_factor(uni.raytrace_buf, roughness);
69
70 /* We don't care about race condition here. */
71 if (ray_roughness_fac > 0.0f) {
72 srt.tile_contains_fast_gi_scan = 1;
73 }
74 if (ray_roughness_fac < 1.0f) {
75 srt.tile_contains_ray_tracing[i] = 1;
76 }
77 }
78 }
79
80 barrier();
81
82 if (local_index == 0u) {
83 int2 denoise_tile_co = int2(group_id.xy);
84 int2 tracing_tile_co = denoise_tile_co / uni.raytrace_buf.trace_pixel_scale;
85
86 for (int i = 0; i < GBUFFER_LAYER_MAX; i++) {
87 if (srt.tile_contains_ray_tracing[i] > 0) {
88 imageStoreFast(srt.tile_raytrace_denoise_img, int3(denoise_tile_co, i), uint4(1));
89 imageStoreFast(srt.tile_raytrace_tracing_img, int3(tracing_tile_co, i), uint4(1));
90 }
91 }
92
93 if (srt.tile_contains_fast_gi_scan > 0) {
94 int2 tracing_tile_co = denoise_tile_co / uni.raytrace_buf.fast_gi_resolution_scale;
95 imageStoreFast(srt.tile_fast_gi_denoise_img, int3(denoise_tile_co, 0), uint4(1));
96 imageStoreFast(srt.tile_fast_gi_tracing_img, int3(tracing_tile_co, 0), uint4(1));
97 }
98 }
99}
100
114
120[[compute, local_size(RAYTRACE_GROUP_SIZE, RAYTRACE_GROUP_SIZE)]]
122 [[global_invocation_id]] const uint3 global_id)
123{
124 int2 tile = int2(global_id.xy);
125
126 if (all(equal(tile, int2(0)))) {
127 /* Workaround: Using atomics to initialize num groups on Windows/Intel GPUs. On Windows/Intel
128 * Arc assignments are ignored when shader later on accesses the variables using atomic
129 * operations.
130 *
131 * Ref #124060.
132 */
133#if (defined(GPU_INTEL) && defined(OS_WIN)) || defined(GLSL_CPP_STUBS)
134 atomicExchange(srt.raytrace_tracing_dispatch_buf.num_groups_y, 1u);
135 atomicExchange(srt.raytrace_denoise_dispatch_buf.num_groups_y, 1u);
136
137 atomicExchange(srt.raytrace_tracing_dispatch_buf.num_groups_z, 1u);
138 atomicExchange(srt.raytrace_denoise_dispatch_buf.num_groups_z, 1u);
139#else
140 srt.raytrace_tracing_dispatch_buf.num_groups_y = 1u;
141 srt.raytrace_denoise_dispatch_buf.num_groups_y = 1u;
142
143 srt.raytrace_tracing_dispatch_buf.num_groups_z = 1u;
144 srt.raytrace_denoise_dispatch_buf.num_groups_z = 1u;
145#endif
146 }
147
148 if (!in_image_range(tile, srt.tile_raytrace_tracing_img)) {
149 return;
150 }
151
152 /* True if this tile is shooting and tracing rays. */
153 bool is_ray_tracing =
154 imageLoad(srt.tile_raytrace_tracing_img, int3(tile, srt.closure_index)).r != 0;
155
156 /* True if an adjacent tile is ray tracing and will need this tile data for denoising. */
157 bool tile_is_ray_sampled = false;
158 /* Could be optimized if that becomes an issue (3x3 cross gather + 3x3 "X" shape scatter). */
159 for (int x_tile = -1; x_tile <= 1; x_tile++) {
160 for (int y_tile = -1; y_tile <= 1; y_tile++) {
161 int2 tile_adj = tile + int2(x_tile, y_tile);
162 bool is_center_tile = (x_tile == 0 && y_tile == 0);
163 if (in_image_range(tile_adj, srt.tile_raytrace_tracing_img) && !is_center_tile) {
164 if (imageLoad(srt.tile_raytrace_tracing_img, int3(tile_adj, srt.closure_index)).r != 0) {
165 /* This tile will sample the target tracing tile. Make sure it is cleared. */
166 tile_is_ray_sampled = true;
167 break;
168 }
169 }
170 }
171 }
172
173 /* TODO(fclem): we might want to dispatch another type of shader only for clearing. */
174 if (is_ray_tracing || tile_is_ray_sampled) {
175 /* Dispatch trace resolution tracing tile. */
176 uint tile_index = atomicAdd(srt.raytrace_tracing_dispatch_buf.num_groups_x, 1u);
177 srt.raytrace_tracing_tiles_buf[tile_index] = packUvec2x16(uint2(tile));
178 }
179
180 /* Dispatch denoise tiles. */
181 if (is_ray_tracing) {
182 for (int x_tile = 0; x_tile < srt.resolution_scale; x_tile++) {
183 for (int y_tile = 0; y_tile < srt.resolution_scale; y_tile++) {
184 int2 tile_adj = tile * srt.resolution_scale + int2(x_tile, y_tile);
185 if (in_image_range(tile_adj, srt.tile_raytrace_denoise_img)) {
186 if (imageLoad(srt.tile_raytrace_denoise_img, int3(tile_adj, srt.closure_index)).r != 0) {
187 uint tile_index = atomicAdd(srt.raytrace_denoise_dispatch_buf.num_groups_x, 1u);
188 srt.raytrace_denoise_tiles_buf[tile_index] = packUvec2x16(uint2(tile_adj));
189 }
190 }
191 }
192 }
193 }
194}
195
196} // namespace eevee::raytracing
197
float closure_apparent_roughness_get(ClosureUndetermined cl)
#define RAYTRACE_TILEMASK_FORMAT
PipelineCompute eevee_ray_tile_compact(eevee::raytracing::tile_compact)
PipelineCompute eevee_ray_tile_classify(eevee::raytracing::tile_classify)
#define shared
#define local_invocation_index
#define storage(slot, qualifiers)
#define image(slot, qualifiers, format)
#define work_group_id
#define resource_table
#define specialization_constant(default_value)
#define global_invocation_id
#define compute
#define local_size(...)
int atomicExchange(int &, int) RET
int atomicAdd(int &, int) RET
bool all(VecOp< bool, D >) RET
VecBase< bool, D > equal(VecOp< T, D >, VecOp< T, D >) RET
void barrier()
IMG_TEMPLATE DataVec imageLoad(const T &, IntCoord) RET
ImageBase< uint, 2, true > uimage2DArray
#define imageStoreFast
unsigned int uchar
uint packUvec2x16(uint2 a)
#define in_image_range(texel, tex)
#define in_texture_range(texel, tex)
const int tile_index
const ccl_global KernelWorkTile * tile
@ CLOSURE_NONE_ID
void tile_compact(TileCompact &srt, const uint3 global_id)
float ray_roughness_factor(RayTraceData raytrace, float roughness)
void tile_classify(TileClassify &srt, const Uniform &uni, const gbuffer::Reader &reader, const uint3 group_id, const uint3 global_id, const uint local_index)
#define saturate(a)
Definition smaa.cc:319
uint tile_contains_ray_tracing[GBUFFER_LAYER_MAX]
DispatchCommand & raytrace_denoise_dispatch_buf
DispatchCommand & raytrace_tracing_dispatch_buf