Blender V5.3
shade_background.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
10
15
16#include "kernel/light/light.h"
17#include "kernel/light/sample.h"
18
19#include "kernel/geom/object.h"
21
22#include "kernel/types.h"
23
25
27 const int resume_offset)
28{
29 /* Abuse prim field that is not used by shade_background. */
30 INTEGRATOR_STATE_WRITE(state, isect, prim) = resume_offset;
31}
32
34{
35 /* Abuse prim field that is not used by shade_background. */
36 const int resume_offset = INTEGRATOR_STATE_WRITE(state, isect, prim);
37 return (resume_offset == PRIM_NONE) ? 0 : resume_offset;
38}
39
44{
45 const int shader = kernel_data.background.surface_shader;
46 const PathRayVisibility path_visibility = INTEGRATOR_STATE(state, path, visibility);
47 const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
48
49 /* Use visibility flag to skip lights. */
50 if (!is_light_shader_visible_to_path(shader, path_visibility, path_flag)) {
51 result = SHADER_EVAL_EMPTY;
52 return zero_spectrum();
53 }
54
55 /* Use fast constant background color if available. */
57 if (surface_shader_constant_emission(kg, shader, &L)) {
58 result = SHADER_EVAL_OK;
59 return L;
60 }
61
62 /* Evaluate background shader. */
63
64 /* TODO: does aliasing like this break automatic SoA in CUDA?
65 * Should we instead store closures separate from ShaderData? */
66 ShaderDataTinyStorage emission_sd_storage;
67 ccl_private ShaderData *emission_sd = AS_SHADER_DATA(&emission_sd_storage);
68
69 /* Clamp indirect evaluations to the importance map. Camera rays are not affected
70 * by the importance map and don't involve NEE, so don't need this. */
71 float ray_dD = INTEGRATOR_STATE(state, ray, dD);
72 if (!(path_visibility & PATH_RAY_VISIBILITY_CAMERA)) {
73 ray_dD = background_light_clamp_dD(kg, ray_dD);
74 }
75
78 emission_sd,
81 ray_dD,
82 INTEGRATOR_STATE(state, ray, time));
83
84 PROFILING_SHADER(emission_sd->object, emission_sd->shader);
87 kg, state, emission_sd, render_buffer, path_visibility, path_flag | PATH_RAY_EMISSION);
88
89 result = (emission_sd->runtime_flag & SR_CACHE_MISS) ? SHADER_EVAL_CACHE_MISS : SHADER_EVAL_OK;
90 return surface_shader_background(emission_sd);
91}
92
95{
96 /* Accumulate transparency for transparent background. We can skip background
97 * shader evaluation unless a background pass is used. */
98 bool eval_background = true;
99 float transparent = 0.0f;
100
101 const PathRayVisibility path_visibility = INTEGRATOR_STATE(state, path, visibility);
102 const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
103 const bool is_transparent_background_ray = kernel_data.background.transparent &&
105
106 if (is_transparent_background_ray) {
107 transparent = average(INTEGRATOR_STATE(state, path, throughput));
108
109#ifdef __PASSES__
110 eval_background = (kernel_data.film.light_pass_flag & PASSMASK(BACKGROUND));
111#else
112 eval_background = false;
113#endif
114 }
115
116#ifdef __MNEE__
118 if (kernel_data.background.use_mis) {
119 for (int lamp = 0; lamp < kernel_data.integrator.num_lights; lamp++) {
120 /* This path should have been resolved with mnee, it will
121 * generate a firefly for small lights since it is improbable. */
122 const ccl_global KernelLight *klight = &kernel_data_fetch(lights, lamp);
123 if (klight->type == LIGHT_BACKGROUND && klight->use_caustics) {
124 eval_background = false;
125 break;
126 }
127 }
128 }
129 }
130#endif /* __MNEE__ */
131
132 /* Evaluate background shader. */
134
135 if (eval_background) {
138 if (result == SHADER_EVAL_CACHE_MISS) {
140 kernel_data.integrator.num_lights);
142 }
143
144 /* When using the ao bounces approximation, adjust background
145 * shader intensity with ao factor. */
146 if (path_state_ao_bounce(kg, state)) {
147 L *= kernel_data.integrator.ao_bounces_factor;
148 }
149
150 /* Background MIS weights. */
151 const float mis_weight = light_sample_mis_weight_forward_background(
152 kg, state, path_visibility, path_flag);
153
154 guiding_record_background(kg, state, L, mis_weight);
155 L *= mis_weight;
156 }
157
158 /* Write to render buffer. */
159 film_write_background(kg, state, L, transparent, is_transparent_background_ray, render_buffer);
161
162#ifdef __DENOISING_FEATURES__
163 film_write_denoising_features_background(kg, state, path_flag, render_buffer);
164#endif
165
166 return SHADER_EVAL_OK;
167}
168
171{
172 const float3 ray_D = INTEGRATOR_STATE(state, ray, D);
173 const float ray_time = INTEGRATOR_STATE(state, ray, time);
175
176 for (int lamp = lamp_offset; lamp < kernel_data.integrator.num_lights; lamp++) {
177 const ccl_global KernelLight *klight = &kernel_data_fetch(lights, lamp);
178
179 if (klight->type != LIGHT_SUN || !(klight->shader_id & SHADER_USE_MIS)) {
180 continue;
181 }
182
183 LightEval light_eval = sun_light_eval_from_intersection(klight, ray_D);
184 if (light_eval.eval_fac == 0.0f) {
185 continue;
186 }
187
188 /* Use visibility flag to skip lights. */
189#ifdef __PASSES__
190 const PathRayVisibility path_visibility = INTEGRATOR_STATE(state, path, visibility);
191 const uint32_t path_flag = INTEGRATOR_STATE(state, path, flag);
192 if (!is_light_shader_visible_to_path(klight->shader_id, path_visibility, path_flag)) {
193 continue;
194 }
195#endif
196
197#ifdef __LIGHT_LINKING__
198 if (!(path_visibility & PATH_RAY_VISIBILITY_CAMERA) &&
199 !light_link_object_match(kg, light_link_receiver_forward(kg, state), klight->object_id))
200 {
201 continue;
202 }
203#endif
204#ifdef __SHADOW_LINKING__
205 if (kernel_data_fetch(objects, klight->object_id).shadow_set_membership != LIGHT_LINK_MASK_ALL)
206 {
207 continue;
208 }
209#endif
210
211#ifdef __MNEE__
213 /* This path should have been resolved with mnee, it will
214 * generate a firefly for small lights since it is improbable. */
215 if (klight->use_caustics) {
216 continue;
217 }
218 }
219#endif /* __MNEE__ */
220
221 /* Evaluate light shader. */
222 Spectrum shader_eval;
224 kg, state, lamp, zero_float3(), ray_D, FLT_MAX, ray_time, shader_eval);
225
226 if (eval_result == SHADER_EVAL_CACHE_MISS) {
229 }
230
231 const float3 eval = shader_eval * light_eval.eval_fac;
232 if (is_zero(eval)) {
233 continue;
234 }
235
236 /* MIS weighting. */
237 const float mis_weight = light_sample_mis_weight_forward_distant(
238 kg, state, path_visibility, path_flag, klight->object_id, light_eval.pdf);
239
240 /* Write to render buffer. */
241 guiding_record_background(kg, state, eval, mis_weight);
243 kg, state, eval, mis_weight, render_buffer, object_lightgroup(kg, klight->object_id));
244 }
245
246 return SHADER_EVAL_OK;
247}
248
252{
254
255 /* TODO: unify these in a single loop to only have a single shader evaluation call. */
257 if (result == SHADER_EVAL_CACHE_MISS) {
259 return;
260 }
262 if (result == SHADER_EVAL_CACHE_MISS) {
264 return;
265 }
266
267#ifdef __SHADOW_CATCHER__
269 /* Special case for shadow catcher where we want to fill the background pass
270 * behind the shadow catcher but also continue tracing the path. */
272 integrator_intersect_next_kernel_after_shadow_catcher_background<
274 return;
275 }
276#endif
277
279}
280
#define D
ccl_device_inline bool is_light_shader_visible_to_path(const int shader, const PathRayVisibility path_visibility, const uint32_t path_flag)
ccl_device_inline float light_sample_mis_weight_forward_background(KernelGlobals kg, IntegratorState state, const PathRayVisibility path_visibility, const uint32_t path_flag)
ccl_device_inline float light_sample_mis_weight_forward_distant(KernelGlobals kg, IntegratorState state, const PathRayVisibility path_visibility, const uint32_t path_flag, const int object_id, const float light_sample_pdf)
ccl_device_noinline_cpu ShaderEvalResult light_sample_shader_eval_forward(KernelGlobals kg, IntegratorState state, const int light_id, const float3 ray_P, const float3 ray_D, const float t, const float time, ccl_private Spectrum &r_eval)
ccl_device_inline void film_write_data_passes_background(KernelGlobals kg, IntegratorState state, const uint32_t path_flag, ccl_global float *ccl_restrict render_buffer)
#define kernel_data
#define ccl_restrict
#define kernel_data_fetch(name, index)
#define AS_SHADER_DATA(shader_data_tiny_storage)
#define PRIM_NONE
#define zero_spectrum
#define ccl_private
#define ccl_device_inline
#define PASSMASK(pass)
#define LIGHT_LINK_MASK_ALL
#define ccl_global
#define CCL_NAMESPACE_END
#define FLT_MAX
bool is_zero(float3x3 a)
float average(float2 a)
const int state
ccl_gpu_kernel_postfix ccl_global KernelWorkTile const int ccl_global float * render_buffer
ccl_device_inline int object_lightgroup(KernelGlobals kg, const int object)
ccl_device_forceinline void guiding_record_background(ccl_attr_maybe_unused KernelGlobals kg, ccl_attr_maybe_unused IntegratorState state, ccl_attr_maybe_unused const Spectrum L, ccl_attr_maybe_unused const float mis_weight)
CCL_NAMESPACE_BEGIN ccl_device_forceinline float background_light_clamp_dD(KernelGlobals kg, const float dD)
ccl_device_inline bool light_link_object_match(KernelGlobals kg, const int receiver, const int emitter)
ccl_device_inline int light_link_receiver_forward(KernelGlobals kg, IntegratorState state)
uint32_t PathRayVisibility
@ PATH_MNEE_CULL_LIGHT_CONNECTION
@ SR_CACHE_MISS
ShaderData ShaderDataTinyStorage
ShaderEvalResult
@ SHADER_EVAL_EMPTY
@ SHADER_EVAL_CACHE_MISS
@ SHADER_EVAL_OK
@ PATH_RAY_EMISSION
@ PATH_RAY_TRANSPARENT_BACKGROUND
@ PATH_RAY_SHADOW_CATCHER_BACKGROUND
@ PATH_RAY_VISIBILITY_CAMERA
@ SHADER_USE_MIS
@ LIGHT_SUN
@ LIGHT_BACKGROUND
@ DEVICE_KERNEL_INTEGRATOR_SHADE_BACKGROUND
ccl_device_inline void film_write_background(KernelGlobals kg, ConstIntegratorState state, const Spectrum L, const float transparent, const bool is_transparent_background_ray, ccl_global float *ccl_restrict render_buffer)
ccl_device_inline void film_write_surface_emission(KernelGlobals kg, ConstIntegratorState state, const Spectrum L, const float mis_weight, ccl_global float *ccl_restrict render_buffer, const int lightgroup=LIGHTGROUP_NONE)
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
Definition math_float3.h:17
#define L
#define PROFILING_INIT_FOR_SHADER(kg, event)
#define PROFILING_EVENT(event)
#define PROFILING_SHADER(object, shader)
#define PROFILING_INIT(kg, event)
ccl_device_inline bool path_state_ao_bounce(KernelGlobals kg, ConstIntegratorState state)
Definition path_state.h:309
@ PROFILING_SHADE_LIGHT_SETUP
Definition profiling.h:42
@ PROFILING_SHADE_LIGHT_EVAL
Definition profiling.h:43
#define ccl_device
ccl_device_inline ShaderEvalResult integrate_background(KernelGlobals kg, IntegratorState state, ccl_global float *ccl_restrict render_buffer)
ccl_device Spectrum integrator_eval_background_shader(KernelGlobals kg, IntegratorState state, ccl_global float *ccl_restrict render_buffer, ccl_private ShaderEvalResult &result)
ccl_device_inline ShaderEvalResult integrate_sun_lights(KernelGlobals kg, IntegratorState state, ccl_global float *ccl_restrict render_buffer)
CCL_NAMESPACE_BEGIN ccl_device void integrator_shade_background_cache_miss_set_resume_offset(IntegratorState state, const int resume_offset)
ccl_device void integrator_shade_background(KernelGlobals kg, IntegratorState state, ccl_global float *ccl_restrict render_buffer)
ccl_device int integrator_shade_background_cache_miss_get_resume_offset(IntegratorState state)
ccl_device_inline void shader_setup_from_background(KernelGlobals kg, ccl_private ShaderData *ccl_restrict sd, const float3 ray_P, const float3 ray_D, const float ray_dD, const float ray_time)
#define INTEGRATOR_STATE_WRITE(state, nested_struct, member)
Definition state.h:235
#define INTEGRATOR_STATE(state, nested_struct, member)
Definition state.h:234
IntegratorStateCPU * IntegratorState
Definition state.h:227
ccl_device_forceinline void integrator_path_cache_miss(IntegratorState, const DeviceKernel)
Definition state_flow.h:238
ccl_device_forceinline void integrator_path_terminate(KernelGlobals kg, IntegratorState state, ccl_global float *ccl_restrict render_buffer, const DeviceKernel current_kernel)
Definition state_flow.h:227
ccl_device LightEval sun_light_eval_from_intersection(const ccl_global KernelLight *klight, const float3 ray_D)
Definition sun.h:76
ccl_device void surface_shader_eval(KernelGlobals kg, ConstIntegratorGenericState state, ccl_private ShaderData *ccl_restrict sd, ccl_global float *ccl_restrict buffer, const PathRayVisibility path_visibility, const uint32_t path_flag, bool use_caustics_storage=false)
ccl_device Spectrum surface_shader_background(const ccl_private ShaderData *sd)
ccl_device bool surface_shader_constant_emission(KernelGlobals kg, const int shader, ccl_private Spectrum *eval)
float3 Spectrum