Blender V5.3
integrator.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "device/device.h"
6
7#include "scene/background.h"
8#include "scene/bake.h"
9#include "scene/camera.h"
10#include "scene/film.h"
11#include "scene/integrator.h"
12#include "scene/light.h"
13#include "scene/object.h"
14#include "scene/scene.h"
15#include "scene/shader.h"
16#include "scene/stats.h"
18#include "scene/volume.h"
19
20#include "kernel/types.h"
21
22#include "util/hash.h"
23#include "util/log.h"
24#include "util/task.h"
25#include "util/time.h"
26
28
29/* Halton sequence generator using only integer numbers.
30 * See https://doi.org/10.1016/0010-4655(91)90064-R for details. */
31static float halton(int &a, int &b, int base)
32{
33 int x = b - a;
34 if (x == 1) {
35 a = 1;
36 b *= base;
37 }
38 else {
39 int y = b / base;
40 while (x <= y) {
41 y /= base;
42 }
43 a = (1 + base) * y - x;
44 }
45 return static_cast<float>(a) / static_cast<float>(b);
46}
48{
49 return make_float2(halton(a2, b2, 2) - 0.5f, halton(a3, b3, 3) - 0.5f);
50}
51
53{
54 NodeType *type = NodeType::add("integrator", create);
55
56 SOCKET_INT(min_bounce, "Min Bounce", 0);
57 SOCKET_INT(max_bounce, "Max Bounce", 7);
58
59 SOCKET_INT(max_diffuse_bounce, "Max Diffuse Bounce", 7);
60 SOCKET_INT(max_glossy_bounce, "Max Glossy Bounce", 7);
61 SOCKET_INT(max_transmission_bounce, "Max Transmission Bounce", 7);
62 SOCKET_INT(max_volume_bounce, "Max Volume Bounce", 7);
63
64 SOCKET_INT(transparent_min_bounce, "Transparent Min Bounce", 0);
65 SOCKET_INT(transparent_max_bounce, "Transparent Max Bounce", 7);
66
67#ifdef WITH_CYCLES_DEBUG
68 static NodeEnum direct_light_sampling_type_enum;
69 direct_light_sampling_type_enum.insert("multiple_importance_sampling",
71 direct_light_sampling_type_enum.insert("forward_path_tracing", DIRECT_LIGHT_SAMPLING_FORWARD);
72 direct_light_sampling_type_enum.insert("next_event_estimation", DIRECT_LIGHT_SAMPLING_NEE);
73 SOCKET_ENUM(direct_light_sampling_type,
74 "Direct Light Sampling Type",
75 direct_light_sampling_type_enum,
77#endif
78
79 SOCKET_INT(ao_bounces, "AO Bounces", 0);
80 SOCKET_FLOAT(ao_factor, "AO Factor", 0.0f);
81 SOCKET_FLOAT(ao_distance, "AO Distance", FLT_MAX);
82 SOCKET_FLOAT(ao_additive_factor, "AO Additive Factor", 0.0f);
83
84 SOCKET_BOOLEAN(volume_ray_marching, "Biased", false);
85 SOCKET_INT(volume_max_steps, "Volume Max Steps", 1024);
86 SOCKET_FLOAT(volume_step_rate, "Volume Step Rate", 1.0f);
87
88 static NodeEnum guiding_distribution_enum;
89 guiding_distribution_enum.insert("PARALLAX_AWARE_VMM", GUIDING_TYPE_PARALLAX_AWARE_VMM);
90 guiding_distribution_enum.insert("DIRECTIONAL_QUAD_TREE", GUIDING_TYPE_DIRECTIONAL_QUAD_TREE);
91 guiding_distribution_enum.insert("VMM", GUIDING_TYPE_VMM);
92
93 static NodeEnum guiding_directional_sampling_type_enum;
94 guiding_directional_sampling_type_enum.insert("MIS",
96 guiding_directional_sampling_type_enum.insert("RIS", GUIDING_DIRECTIONAL_SAMPLING_TYPE_RIS);
97 guiding_directional_sampling_type_enum.insert("ROUGHNESS",
99
100 SOCKET_BOOLEAN(use_guiding, "Guiding", false);
101 SOCKET_BOOLEAN(deterministic_guiding, "Deterministic Guiding", true);
102 SOCKET_BOOLEAN(use_surface_guiding, "Surface Guiding", true);
103 SOCKET_FLOAT(surface_guiding_probability, "Surface Guiding Probability", 0.5f);
104 SOCKET_BOOLEAN(use_volume_guiding, "Volume Guiding", true);
105 SOCKET_FLOAT(volume_guiding_probability, "Volume Guiding Probability", 0.5f);
106 SOCKET_INT(guiding_training_samples, "Training Samples", 128);
107 SOCKET_BOOLEAN(use_guiding_direct_light, "Guide Direct Light", true);
108 SOCKET_BOOLEAN(use_guiding_mis_weights, "Use MIS Weights", true);
109 SOCKET_ENUM(guiding_distribution_type,
110 "Guiding Distribution Type",
111 guiding_distribution_enum,
113 SOCKET_ENUM(guiding_directional_sampling_type,
114 "Guiding Directional Sampling Type",
115 guiding_directional_sampling_type_enum,
117 SOCKET_FLOAT(guiding_roughness_threshold, "Guiding Roughness Threshold", 0.05f);
118
119 SOCKET_BOOLEAN(caustics_reflective, "Reflective Caustics", true);
120 SOCKET_BOOLEAN(caustics_refractive, "Refractive Caustics", true);
121 SOCKET_FLOAT(filter_glossy, "Filter Glossy", 1.0f);
122
123 SOCKET_BOOLEAN(use_direct_light, "Use Direct Light", true);
124 SOCKET_BOOLEAN(use_indirect_light, "Use Indirect Light", true);
125 SOCKET_BOOLEAN(use_diffuse, "Use Diffuse", true);
126 SOCKET_BOOLEAN(use_glossy, "Use Glossy", true);
127 SOCKET_BOOLEAN(use_transmission, "Use Transmission", true);
128 SOCKET_BOOLEAN(use_emission, "Use Emission", true);
129
130 SOCKET_INT(seed, "Seed", 0);
131
132 SOCKET_FLOAT(sample_clamp_direct, "Sample Clamp Direct", 0.0f);
133 SOCKET_FLOAT(sample_clamp_indirect, "Sample Clamp Indirect", 10.0f);
134 SOCKET_BOOLEAN(motion_blur, "Motion Blur", false);
135
136 SOCKET_INT(aa_samples, "AA Samples", 0);
137 SOCKET_BOOLEAN(use_sample_subset, "Use Sample Subset", false);
138 SOCKET_INT(sample_subset_offset, "Sample Subset Offset", 0);
139 SOCKET_INT(sample_subset_length, "Sample Subset Length", MAX_SAMPLES);
140
141 SOCKET_BOOLEAN(use_adaptive_sampling, "Use Adaptive Sampling", true);
142 SOCKET_FLOAT(adaptive_threshold, "Adaptive Threshold", 0.01f);
143 SOCKET_INT(adaptive_min_samples, "Adaptive Min Samples", 0);
144
145 SOCKET_BOOLEAN(use_light_tree, "Use light tree to optimize many light sampling", true);
146 SOCKET_FLOAT(light_sampling_threshold, "Light Sampling Threshold", 0.0f);
147
148 static NodeEnum sampling_pattern_enum;
149 sampling_pattern_enum.insert("sobol_burley", SAMPLING_PATTERN_SOBOL_BURLEY);
150 sampling_pattern_enum.insert("tabulated_sobol", SAMPLING_PATTERN_TABULATED_SOBOL);
151 sampling_pattern_enum.insert("blue_noise_pure", SAMPLING_PATTERN_BLUE_NOISE_PURE);
152 sampling_pattern_enum.insert("blue_noise_round", SAMPLING_PATTERN_BLUE_NOISE_ROUND);
153 sampling_pattern_enum.insert("blue_noise_first", SAMPLING_PATTERN_BLUE_NOISE_FIRST);
154 SOCKET_ENUM(sampling_pattern,
155 "Sampling Pattern",
156 sampling_pattern_enum,
158 SOCKET_FLOAT(scrambling_distance, "Scrambling Distance", 1.0f);
159
160 SOCKET_BOOLEAN(use_pixel_jitter, "Use Pixel Jitter", false);
161 SOCKET_BOOLEAN(use_custom_pixel_jitter_sample, "Use custom pixel jitter sample value", false);
163 custom_pixel_jitter_sample, "Custom pixel jitter sample overwrite value", array<float>());
164
165 static NodeEnum denoiser_type_enum;
166 denoiser_type_enum.insert("none", DENOISER_NONE);
167 denoiser_type_enum.insert("optix", DENOISER_OPTIX);
168 denoiser_type_enum.insert("openimagedenoise", DENOISER_OPENIMAGEDENOISE);
169 denoiser_type_enum.insert("dlss", DENOISER_DLSS);
170
171 static NodeEnum denoiser_prefilter_enum;
172 denoiser_prefilter_enum.insert("none", DENOISER_PREFILTER_NONE);
173 denoiser_prefilter_enum.insert("fast", DENOISER_PREFILTER_FAST);
174 denoiser_prefilter_enum.insert("accurate", DENOISER_PREFILTER_ACCURATE);
175
176 static NodeEnum denoiser_quality_enum;
177 denoiser_quality_enum.insert("high", DENOISER_QUALITY_HIGH);
178 denoiser_quality_enum.insert("balanced", DENOISER_QUALITY_BALANCED);
179 denoiser_quality_enum.insert("fast", DENOISER_QUALITY_FAST);
180
181 /* Default to accurate denoising with OpenImageDenoise. For interactive viewport
182 * it's best use OptiX and disable the normal pass since it does not always have
183 * the desired effect for that denoiser. */
184 SOCKET_BOOLEAN(use_denoise, "Use Denoiser", false);
185 SOCKET_ENUM(denoiser_type, "Denoiser Type", denoiser_type_enum, DENOISER_OPENIMAGEDENOISE);
186 SOCKET_INT(denoise_start_sample, "Start Sample to Denoise", 0);
187 SOCKET_INT(denoiser_passes, "Denoiser Passes", DENOISER_PASS_ALBEDO | DENOISER_PASS_NORMAL);
188 SOCKET_ENUM(denoiser_prefilter,
189 "Denoiser Prefilter",
190 denoiser_prefilter_enum,
192 SOCKET_BOOLEAN(denoise_use_gpu, "Denoise on GPU", true);
193 SOCKET_ENUM(denoiser_quality, "Denoiser Quality", denoiser_quality_enum, DENOISER_QUALITY_HIGH);
194 SOCKET_FLOAT(denoiser_upscale_factor, "Denoiser Upscale Factor", 1.0f);
195
196 return type;
197}
198
199Integrator::Integrator() : Node(get_node_type()) {}
200
201Integrator::~Integrator() = default;
202
203void Integrator::device_update(Device *device, DeviceScene *dscene, Scene *scene)
204{
205 if (!is_modified()) {
206 return;
207 }
208
209 const scoped_callback_timer timer([scene](double time) {
210 if (scene->update_stats) {
211 scene->update_stats->integrator.times.add_entry({"device_update", time});
212 }
213 });
214
215 if (use_denoise && denoiser_type == DENOISER_DLSS) {
216 use_pixel_jitter = true;
217 }
218
219 KernelIntegrator *kintegrator = &dscene->data.integrator;
220
221 device_free(device, dscene);
222
223 /* integrator parameters */
224
225 /* Plus one so that a bounce of 0 indicates no global illumination, only direct illumination. */
226 kintegrator->min_bounce = min_bounce + 1;
227 kintegrator->max_bounce = max_bounce + 1;
228
229 kintegrator->max_diffuse_bounce = max_diffuse_bounce + 1;
230 kintegrator->max_glossy_bounce = max_glossy_bounce + 1;
231 kintegrator->max_transmission_bounce = max_transmission_bounce + 1;
232 kintegrator->max_volume_bounce = max_volume_bounce + 1;
233
234 kintegrator->transparent_min_bounce = transparent_min_bounce + 1;
235
236 /* Unlike other type of bounces, 0 transparent bounce means there is no transparent bounce in the
237 * scene. */
238 kintegrator->transparent_max_bounce = transparent_max_bounce;
239
240 kintegrator->ao_bounces = (ao_factor != 0.0f) ? ao_bounces : 0;
241 kintegrator->ao_bounces_distance = ao_distance;
242 kintegrator->ao_bounces_factor = ao_factor;
243 kintegrator->ao_additive_factor = ao_additive_factor;
244
245#ifdef WITH_CYCLES_DEBUG
246 kintegrator->direct_light_sampling_type = direct_light_sampling_type;
247#else
248 kintegrator->direct_light_sampling_type = DIRECT_LIGHT_SAMPLING_MIS;
249#endif
250
251 /* Transparent Shadows
252 * We only need to enable transparent shadows, if we actually have
253 * transparent shaders in the scene. Otherwise we can disable it
254 * to improve performance a bit. */
255 kintegrator->transparent_shadows = false;
256 for (Shader *shader : scene->shaders) {
257 if (shader->reference_count() == 0) {
258 continue;
259 }
260 /* keep this in sync with SD_HAS_TRANSPARENT_SHADOW in shader.cpp */
261 if ((shader->has_surface_transparent && shader->get_use_transparent_shadow()) ||
262 shader->has_volume)
263 {
264 kintegrator->transparent_shadows = true;
265 break;
266 }
267 }
268
269 /* TODO(sergey): Treat Gaussian splats as semi-transparent objects. */
270 /* It will allow accumulation of transparency in the intersect_shadows_all(). */
271
272 kintegrator->volume_ray_marching = volume_ray_marching;
273 kintegrator->volume_max_steps = volume_max_steps;
274
275 kintegrator->caustics_reflective = caustics_reflective;
276 kintegrator->caustics_refractive = caustics_refractive;
277 kintegrator->filter_glossy = (filter_glossy == 0.0f) ? FLT_MAX : 1.0f / filter_glossy;
278 kintegrator->differential_widen_scale = min(1.0f, filter_glossy);
279
280 kintegrator->filter_closures = 0;
281 if (!use_direct_light) {
282 kintegrator->filter_closures |= FILTER_CLOSURE_DIRECT_LIGHT;
283 }
284 if (!use_indirect_light) {
285 kintegrator->min_bounce = 1;
286 kintegrator->max_bounce = 1;
287 }
288 if (!use_diffuse) {
289 kintegrator->filter_closures |= FILTER_CLOSURE_DIFFUSE;
290 }
291 if (!use_glossy) {
292 kintegrator->filter_closures |= FILTER_CLOSURE_GLOSSY;
293 }
294 if (!use_transmission) {
295 kintegrator->filter_closures |= FILTER_CLOSURE_TRANSMISSION;
296 }
297 if (!use_emission) {
298 kintegrator->filter_closures |= FILTER_CLOSURE_EMISSION;
299 }
300 if (scene->bake_manager->get_baking()) {
301 /* Baking does not need to trace through transparency, we only want to bake
302 * the object itself. */
303 kintegrator->filter_closures |= FILTER_CLOSURE_TRANSPARENT;
304 }
305
306 const GuidingParams guiding_params = get_guiding_params(device);
307 kintegrator->use_guiding = guiding_params.use;
308 kintegrator->train_guiding = kintegrator->use_guiding;
309 kintegrator->use_surface_guiding = guiding_params.use_surface_guiding;
310 kintegrator->use_volume_guiding = guiding_params.use_volume_guiding;
311 kintegrator->surface_guiding_probability = surface_guiding_probability;
312 kintegrator->volume_guiding_probability = volume_guiding_probability;
313 kintegrator->use_guiding_direct_light = use_guiding_direct_light;
314 kintegrator->use_guiding_mis_weights = use_guiding_mis_weights;
315 kintegrator->guiding_distribution_type = guiding_params.type;
316 kintegrator->guiding_directional_sampling_type = guiding_params.sampling_type;
317 kintegrator->guiding_roughness_threshold = guiding_params.roughness_threshold;
318
319 kintegrator->sample_clamp_direct = (sample_clamp_direct == 0.0f) ? FLT_MAX :
320 sample_clamp_direct * 3.0f;
321 kintegrator->sample_clamp_indirect = (sample_clamp_indirect == 0.0f) ?
322 FLT_MAX :
323 sample_clamp_indirect * 3.0f;
324
325 const int clamped_aa_samples = min(aa_samples, MAX_SAMPLES);
326
327 kintegrator->sampling_pattern = sampling_pattern;
328 kintegrator->scrambling_distance = scrambling_distance;
329 kintegrator->sobol_index_mask = reverse_integer_bits(next_power_of_two(clamped_aa_samples - 1) -
330 1);
331 kintegrator->blue_noise_sequence_length = clamped_aa_samples;
332 if (kintegrator->sampling_pattern == SAMPLING_PATTERN_BLUE_NOISE_ROUND) {
333 if (!is_power_of_two(clamped_aa_samples)) {
334 kintegrator->blue_noise_sequence_length = next_power_of_two(clamped_aa_samples);
335 }
336 kintegrator->sampling_pattern = SAMPLING_PATTERN_BLUE_NOISE_PURE;
337 }
338 if (kintegrator->sampling_pattern == SAMPLING_PATTERN_BLUE_NOISE_FIRST) {
339 kintegrator->blue_noise_sequence_length -= 1;
340 }
341
342 /* Randomize the seed every frame when applying pixel jitter. */
343 if (use_pixel_jitter) {
344 if (use_custom_pixel_jitter_sample) {
345 kintegrator->seed = hash_uint2(seed, pixel_jitter_frame);
346 }
347 else {
348 kintegrator->seed = hash_uint3(seed, pixel_jitter_state.a2, pixel_jitter_state.a3);
349 }
350 }
351 /* The blue-noise sampler needs a randomized seed to scramble properly, providing e.g. 0 won't
352 * work properly. Therefore, hash the seed in those cases. */
353 else if (kintegrator->sampling_pattern == SAMPLING_PATTERN_BLUE_NOISE_FIRST ||
354 kintegrator->sampling_pattern == SAMPLING_PATTERN_BLUE_NOISE_PURE)
355 {
356 kintegrator->seed = hash_uint(seed);
357 }
358 else {
359 kintegrator->seed = seed;
360 }
361
362 /* NOTE: The kintegrator->use_light_tree is assigned to the efficient value in the light manager,
363 * and the synchronization code is expected to tag the light manager for update when the
364 * `use_light_tree` is changed. */
365 if (light_sampling_threshold > 0.0f && !kintegrator->use_light_tree) {
366 kintegrator->light_inv_rr_threshold = scene->film->get_exposure() / light_sampling_threshold;
367 }
368 else {
369 kintegrator->light_inv_rr_threshold = 0.0f;
370 }
371
372 /* Build pre-tabulated Sobol samples if needed. */
373 const int sequence_size = clamp(
375 const int table_size = sequence_size * NUM_TAB_SOBOL_PATTERNS * NUM_TAB_SOBOL_DIMENSIONS;
376 if (kintegrator->sampling_pattern == SAMPLING_PATTERN_TABULATED_SOBOL &&
377 dscene->sample_pattern_lut.size() != table_size)
378 {
379 kintegrator->tabulated_sobol_sequence_size = sequence_size;
380
381 if (dscene->sample_pattern_lut.size() != 0) {
382 dscene->sample_pattern_lut.free();
383 }
384 float4 *directions = (float4 *)dscene->sample_pattern_lut.alloc(table_size);
385 TaskPool pool;
386 for (int j = 0; j < NUM_TAB_SOBOL_PATTERNS; ++j) {
387 float4 *sequence = directions + j * sequence_size;
388 pool.push([sequence, sequence_size, j] {
389 tabulated_sobol_generate_4D(sequence, sequence_size, j);
390 });
391 }
392 pool.wait_work();
393
395 }
396
398 kintegrator->has_shadow_catcher = scene_has_shadow_catcher_;
399
400 if (use_pixel_jitter) {
401 if (use_custom_pixel_jitter_sample) {
402 kintegrator->pixel_jitter = make_float2(custom_pixel_jitter_sample[0],
403 custom_pixel_jitter_sample[1]);
405 }
406 else {
407 kintegrator->pixel_jitter = pixel_jitter_state.next();
408 }
409 }
410 else {
411 kintegrator->pixel_jitter = make_float2(FLT_MAX);
413 }
414
417}
418
419void Integrator::device_free(Device * /*unused*/, DeviceScene *dscene, bool force_free)
420{
421 dscene->sample_pattern_lut.free_if_need_realloc(force_free);
422}
423
428
434
435void Integrator::tag_update(Scene *scene, const uint32_t flag)
436{
437 if (flag == UPDATE_ALL) {
438 tag_modified();
439 }
440
441 if (flag & AO_PASS_MODIFIED) {
442 /* tag only the ao_bounces socket as modified so we avoid updating sample_pattern_lut
443 * unnecessarily */
444 tag_ao_bounces_modified();
445 }
446
447 if (flag & OBJECT_MANAGER) {
449 }
450
451 if (motion_blur_is_modified()) {
452 scene->object_manager->tag_update(scene, ObjectManager::MOTION_BLUR_MODIFIED);
453 scene->camera->tag_modified();
454 }
455
456 if (volume_ray_marching_is_modified()) {
457 scene->volume_manager->tag_update_algorithm();
458 scene->geometry_manager->tag_update(scene, GeometryManager::VOLUME_MODIFIED);
459 }
460}
461
463{
464 uint64_t kernel_features = 0;
465
466 if (ao_additive_factor != 0.0f) {
467 kernel_features |= KERNEL_FEATURE_AO_ADDITIVE;
468 }
469
470 if (get_use_light_tree()) {
471 kernel_features |= KERNEL_FEATURE_LIGHT_TREE;
472 }
473
474 return kernel_features;
475}
476
478{
479 AdaptiveSampling adaptive_sampling;
480
481 adaptive_sampling.use = use_adaptive_sampling;
482
483 /* Disable sample count pass with upscaling. */
484 if (use_denoise && (denoiser_upscale_factor != 1.0f || denoiser_type == DENOISER_DLSS)) {
485 adaptive_sampling.use = false;
486 }
487
488 if (!adaptive_sampling.use) {
489 return adaptive_sampling;
490 }
491
492 const int clamped_aa_samples = min(aa_samples, MAX_SAMPLES);
493
494 if (clamped_aa_samples > 0 && adaptive_threshold == 0.0f) {
495 adaptive_sampling.threshold = max(0.001f, 1.0f / (float)aa_samples);
496 LOG_INFO << "Adaptive sampling: automatic threshold = " << adaptive_sampling.threshold;
497 }
498 else {
499 adaptive_sampling.threshold = adaptive_threshold;
500 }
501
502 if (use_sample_subset && clamped_aa_samples > 0) {
503 const int subset_samples = max(
504 min(sample_subset_offset + sample_subset_length, clamped_aa_samples) -
505 sample_subset_offset,
506 0);
507
508 adaptive_sampling.threshold *= sqrtf((float)subset_samples / (float)clamped_aa_samples);
509 }
510
511 if (adaptive_sampling.threshold > 0 && adaptive_min_samples == 0) {
512 /* Threshold 0.1 -> 32, 0.01 -> 64, 0.001 -> 128.
513 * This is highly scene dependent, we make a guess that seemed to work well
514 * in various test scenes. */
515 const int min_samples = (int)ceilf(16.0f / powf(adaptive_sampling.threshold, 0.3f));
516 adaptive_sampling.min_samples = max(4, min_samples);
517 LOG_INFO << "Adaptive sampling: automatic min samples = " << adaptive_sampling.min_samples;
518 }
519 else {
520 adaptive_sampling.min_samples = max(4, adaptive_min_samples);
521 }
522
523 /* Arbitrary factor that makes the threshold more similar to what is was before,
524 * and gives arguably more intuitive values. */
525 adaptive_sampling.threshold *= 5.0f;
526
527 adaptive_sampling.adaptive_step = 16;
528
529 DCHECK(is_power_of_two(adaptive_sampling.adaptive_step))
530 << "Adaptive step must be a power of two for bitwise operations to work";
531
532 return adaptive_sampling;
533}
534
536{
537 DenoiseParams denoise_params;
538
539 denoise_params.use = use_denoise;
540
541 denoise_params.type = denoiser_type;
542
543 denoise_params.use_gpu = denoise_use_gpu;
544
545 denoise_params.start_sample = denoise_start_sample;
546
547 denoise_params.passes = denoiser_passes;
548
549 denoise_params.prefilter = denoiser_prefilter;
550 denoise_params.quality = denoiser_quality;
551 denoise_params.upscale_factor = denoiser_upscale_factor;
552
554 /* Disable upscaling with shadow catcher, since not all passes required for shadow catcher
555 * compositing can be upscaled currently. */
556 denoise_params.upscale_factor = 1.0f;
557 }
558
559 return denoise_params;
560}
561
563{
564 const bool use = use_guiding && device->info.has_guiding;
565
566 GuidingParams guiding_params;
567 guiding_params.use_surface_guiding = use && use_surface_guiding &&
568 surface_guiding_probability > 0.0f;
569 guiding_params.use_volume_guiding = use && use_volume_guiding &&
570 volume_guiding_probability > 0.0f;
571 guiding_params.use = guiding_params.use_surface_guiding || guiding_params.use_volume_guiding;
572 guiding_params.type = guiding_distribution_type;
573 guiding_params.training_samples = guiding_training_samples;
574 guiding_params.deterministic = deterministic_guiding;
575 guiding_params.sampling_type = guiding_directional_sampling_type;
576 // In Blender/Cycles the user set roughness is squared to behave more linear.
577 guiding_params.roughness_threshold = guiding_roughness_threshold * guiding_roughness_threshold;
578 return guiding_params;
579}
unsigned long long int uint64_t
btScalar max
float upscale_factor
Definition denoise.h:90
DenoiserType type
Definition denoise.h:73
DenoiserQuality quality
Definition denoise.h:89
bool use_gpu
Definition denoise.h:86
DenoiserPassMask passes
Definition denoise.h:79
int start_sample
Definition denoise.h:76
DenoiserPrefilter prefilter
Definition denoise.h:88
NODE_DECLARE bool use
Definition denoise.h:70
device_vector< float > sample_pattern_lut
Definition devicescene.h:86
KernelData data
DeviceInfo info
void tag_update(Scene *scene, const uint32_t flag)
void device_update(Device *device, DeviceScene *dscene, Scene *scene)
HaltonSequence pixel_jitter_state
Definition integrator.h:120
uint64_t get_kernel_features() const
DenoiseParams get_denoise_params() const
~Integrator() override
bool scene_has_shadow_catcher_
Definition integrator.h:143
int pixel_jitter_frame
Definition integrator.h:121
AdaptiveSampling get_adaptive_sampling() const
void device_free(Device *device, DeviceScene *dscene, bool force_free=false)
GuidingParams get_guiding_params(const Device *device) const
bool is_modified() const
static const int MAX_SAMPLES
Definition integrator.h:99
void clear_modified()
bool shadow_catcher_needs_recalc_
Definition integrator.h:142
Definition scene.h:133
Film * film
Definition scene.h:147
unique_ptr< ObjectManager > object_manager
Definition scene.h:171
unique_ptr< SceneUpdateStats > update_stats
Definition scene.h:197
unique_ptr< BakeManager > bake_manager
Definition scene.h:173
unique_ptr_vector< Shader > shaders
Definition scene.h:158
Camera * camera
Definition scene.h:145
bool has_shadow_catcher()
Definition scene.cpp:818
unique_ptr< GeometryManager > geometry_manager
Definition scene.h:170
unique_ptr< VolumeManager > volume_manager
Definition scene.h:175
bool has_volume
bool has_surface_transparent
void push(TaskRunFunction &&task)
Definition task.cpp:21
void wait_work(Summary *stats=nullptr)
Definition task.cpp:27
size_t size() const
T * alloc(const size_t width, const size_t height=0)
void free_if_need_realloc(bool force_free)
@ DENOISER_QUALITY_FAST
Definition denoise.h:58
@ DENOISER_QUALITY_BALANCED
Definition denoise.h:57
@ DENOISER_QUALITY_HIGH
Definition denoise.h:56
@ DENOISER_PREFILTER_FAST
Definition denoise.h:46
@ DENOISER_PREFILTER_NONE
Definition denoise.h:42
@ DENOISER_PREFILTER_ACCURATE
Definition denoise.h:50
@ DENOISER_PASS_NORMAL
Definition denoise.h:30
@ DENOISER_PASS_ALBEDO
Definition denoise.h:28
@ DENOISER_NONE
Definition denoise.h:17
@ DENOISER_OPTIX
Definition denoise.h:12
@ DENOISER_OPENIMAGEDENOISE
Definition denoise.h:13
@ DENOISER_DLSS
Definition denoise.h:14
#define KERNEL_FEATURE_LIGHT_TREE
#define MIN_TAB_SOBOL_SAMPLES
#define NUM_TAB_SOBOL_DIMENSIONS
#define MAX_TAB_SOBOL_SAMPLES
#define NUM_TAB_SOBOL_PATTERNS
#define KERNEL_FEATURE_AO_ADDITIVE
#define powf(x, y)
#define CCL_NAMESPACE_END
uint hash_uint(uint kx)
uint hash_uint3(uint kx, uint ky, uint kz)
uint hash_uint2(uint kx, uint ky)
#define FLT_MAX
constexpr T clamp(T, U, U) RET
static CCL_NAMESPACE_BEGIN float halton(int &a, int &b, int base)
@ FILTER_CLOSURE_EMISSION
@ FILTER_CLOSURE_GLOSSY
@ FILTER_CLOSURE_DIFFUSE
@ FILTER_CLOSURE_TRANSPARENT
@ FILTER_CLOSURE_DIRECT_LIGHT
@ FILTER_CLOSURE_TRANSMISSION
@ DIRECT_LIGHT_SAMPLING_MIS
@ DIRECT_LIGHT_SAMPLING_NEE
@ DIRECT_LIGHT_SAMPLING_FORWARD
@ GUIDING_DIRECTIONAL_SAMPLING_TYPE_PRODUCT_MIS
@ GUIDING_DIRECTIONAL_SAMPLING_TYPE_RIS
@ GUIDING_DIRECTIONAL_SAMPLING_TYPE_ROUGHNESS
@ SAMPLING_PATTERN_BLUE_NOISE_FIRST
@ SAMPLING_PATTERN_TABULATED_SOBOL
@ SAMPLING_PATTERN_BLUE_NOISE_PURE
@ SAMPLING_PATTERN_SOBOL_BURLEY
@ SAMPLING_PATTERN_BLUE_NOISE_ROUND
@ GUIDING_TYPE_VMM
@ GUIDING_TYPE_DIRECTIONAL_QUAD_TREE
@ GUIDING_TYPE_PARALLAX_AWARE_VMM
#define DCHECK(expression)
Definition log.h:135
#define LOG_INFO
Definition log.h:106
ccl_device_inline uint32_t reverse_integer_bits(uint32_t x)
Definition math_base.h:848
ccl_device_inline uint next_power_of_two(const uint x)
Definition math_base.h:832
#define SOCKET_FLOAT(name, ui_name, default_value,...)
Definition node_type.h:219
#define SOCKET_INT(name, ui_name, default_value,...)
Definition node_type.h:213
#define SOCKET_FLOAT_ARRAY(name, ui_name, default_value,...)
Definition node_type.h:267
#define NODE_DEFINE(structname)
Definition node_type.h:157
#define SOCKET_BOOLEAN(name, ui_name, default_value,...)
Definition node_type.h:211
#define SOCKET_ENUM(name, ui_name, values, default_value,...)
Definition node_type.h:235
#define sqrtf
#define make_float2
#define ceilf
#define min(a, b)
Definition sort.cc:38
GuidingDirectionalSamplingType sampling_type
GuidingDistributionType type
void insert(const char *x, const int y)
Definition node_enum.h:21
static NodeType * add(const char *name, CreateFunc create, Type type=NONE, const NodeType *base=nullptr)
int reference_count() const
Definition graph/node.h:184
void clear_modified()
void tag_modified()
bool is_modified() const
Node(const NodeType *type, ustring name=ustring())
CCL_NAMESPACE_BEGIN void tabulated_sobol_generate_4D(float4 points[], const int size, const int rng_seed)
ccl_device_inline bool is_power_of_two(const size_t x)
Definition types_base.h:78