116 blender::Object *b_dicing_camera_object = get_dicing_camera_object(b_v3d, b_rv3d);
117 bool dicing_camera_updated =
false;
121 deg_iter_data.
graph = &b_depsgraph;
141 shader_map.set_recalc(b_id);
145 shader_map.set_recalc(b_id);
146 geometry_map.set_recalc(b_id);
151 const bool can_have_geometry = object_can_have_geometry(*b_ob);
152 const bool is_light = !can_have_geometry && object_is_light(*b_ob);
156 object_map.set_recalc(b_ob);
159 if (can_have_geometry ||
is_light) {
166 if (can_have_geometry) {
167 if (updated_transform || updated_shading) {
168 object_map.set_recalc(b_ob);
171 const bool use_adaptive_subdiv = object_subdivision_type(
172 *b_ob, preview, use_adaptive_subdivision) !=
177 if (updated_geometry || (updated_transform && use_adaptive_subdiv)) {
180 object_get_data(*b_ob, use_adaptive_subdiv);
181 geometry_map.set_recalc(key);
184 const map<void *, set<blender::ID *>>::const_iterator instance_geometries =
185 instance_geometries_by_object.find(b_ob);
186 if (instance_geometries != instance_geometries_by_object.end()) {
187 for (
blender::ID *geometry : instance_geometries->second) {
188 geometry_map.set_recalc(geometry);
193 if (updated_geometry) {
195 particle_system_map.set_recalc(b_ob);
201 if (updated_transform || updated_shading) {
202 object_map.set_recalc(b_ob);
203 geometry_map.set_recalc(b_ob);
206 if (updated_geometry) {
207 geometry_map.set_recalc(b_ob);
211 else if (object_is_camera(*b_ob)) {
212 shader_map.set_recalc(b_ob);
215 if (b_dicing_camera_object == b_ob) {
216 dicing_camera_updated =
true;
221 geometry_map.set_recalc(b_id);
225 const blender::World *b_world = blender::id_cast<blender::World *>(b_id);
226 if (world_map == b_world) {
229 shader_map.set_recalc(b_id);
233 shader_map.set_recalc(b_id);
237 geometry_map.set_recalc(b_id);
241 if (b_dicing_camera_object && b_dicing_camera_object->
data == b_id) {
242 dicing_camera_updated =
true;
248 if (use_adaptive_subdivision) {
252 bool dicing_prop_changed =
false;
254 const float updated_dicing_rate = preview ? RNA_float_get(&cscene,
"preview_dicing_rate") :
255 RNA_float_get(&cscene,
"dicing_rate");
257 if (dicing_rate != updated_dicing_rate) {
258 dicing_rate = updated_dicing_rate;
259 dicing_prop_changed =
true;
262 const int updated_max_subdivisions = RNA_int_get(&cscene,
"max_subdivisions");
264 if (max_subdivisions != updated_max_subdivisions) {
265 max_subdivisions = updated_max_subdivisions;
266 dicing_prop_changed =
true;
269 if ((dicing_camera_updated && !region_view3d_navigating_or_transforming(b_rv3d)) ||
274 for (
const pair<const GeometryKey, Geometry *> &iter : geometry_map.key_to_scene_data()) {
277 Mesh *mesh =
static_cast<Mesh *
>(geom);
279 geometry_map.set_recalc(iter.first.id);
289 if (viewport_parameters.shader_modified(new_viewport_parameters)) {
294 has_updates_ |= viewport_parameters.modified(new_viewport_parameters);
362 use_adaptive_subdivision = !b_bake_target;
366 integrator->set_min_bounce(get_int(cscene,
"min_light_bounces"));
367 integrator->set_max_bounce(get_int(cscene,
"max_bounces"));
369 integrator->set_max_diffuse_bounce(get_int(cscene,
"diffuse_bounces"));
370 integrator->set_max_glossy_bounce(get_int(cscene,
"glossy_bounces"));
371 integrator->set_max_transmission_bounce(get_int(cscene,
"transmission_bounces"));
372 integrator->set_max_volume_bounce(get_int(cscene,
"volume_bounces"));
373 integrator->set_transparent_min_bounce(get_int(cscene,
"min_transparent_bounces"));
374 integrator->set_transparent_max_bounce(get_int(cscene,
"transparent_max_bounces"));
376 integrator->set_volume_ray_marching(get_boolean(cscene,
"volume_biased"));
377 integrator->set_volume_max_steps(get_int(cscene,
"volume_max_steps"));
378 const float volume_step_rate = (preview) ? get_float(cscene,
"volume_preview_step_rate") :
379 get_float(cscene,
"volume_step_rate");
380 integrator->set_volume_step_rate(volume_step_rate);
382 integrator->set_caustics_reflective(get_boolean(cscene,
"caustics_reflective"));
383 integrator->set_caustics_refractive(get_boolean(cscene,
"caustics_refractive"));
384 integrator->set_filter_glossy(get_float(cscene,
"blur_glossy"));
386 integrator->set_use_pixel_jitter(get_boolean(cscene,
"use_pixel_jitter"));
388 bool use_custom_pixel_jitter_sample =
false;
390 &scene_rna_ptr,
"[\"override_pixel_jitter_sample\"]");
391 if (override_pixel_jitter_sample_prop) {
392 const int array_length = RNA_property_array_length(&scene_rna_ptr,
393 override_pixel_jitter_sample_prop);
394 if (array_length == 2) {
396 RNA_property_float_get_array(
397 &scene_rna_ptr, override_pixel_jitter_sample_prop, &pixel_jitter_sample_arr[0]);
398 integrator->set_custom_pixel_jitter_sample(pixel_jitter_sample_arr);
399 use_custom_pixel_jitter_sample =
true;
401 else if (array_length != 0) {
402 printf(
"%s: scene.custom_pixel_jitter_sample length is not 0 or 2.\n", __func__);
405 integrator->set_use_custom_pixel_jitter_sample(use_custom_pixel_jitter_sample);
407 int seed = get_int(cscene,
"seed");
408 if (get_boolean(cscene,
"use_animated_seed")) {
409 seed =
hash_uint2(b_scene->r.cfra, get_int(cscene,
"seed"));
410 if (b_scene->r.subframe != 0.0f) {
414 seed +=
hash_uint2((
int)(b_scene->r.subframe * (
float)
INT_MAX), get_int(cscene,
"seed"));
418 integrator->set_seed(seed);
420 integrator->set_sample_clamp_direct(get_float(cscene,
"sample_clamp_direct"));
421 integrator->set_sample_clamp_indirect(get_float(cscene,
"sample_clamp_indirect"));
423 integrator->set_motion_blur(view_layer.use_motion_blur);
426 const bool use_light_tree = get_boolean(cscene,
"use_light_tree");
427 integrator->set_use_light_tree(use_light_tree);
428 integrator->set_light_sampling_threshold(get_float(cscene,
"light_sampling_threshold"));
430 if (integrator->use_light_tree_is_modified()) {
437 switch (sampling_pattern) {
455 if (!use_developer_ui) {
461 const bool is_vertex_baking = b_bake_target &&
463 scene->bake_manager->set_use_seed(is_vertex_baking);
464 if (is_vertex_baking) {
470 integrator->set_sampling_pattern(sampling_pattern);
473 bool use_adaptive_sampling =
false;
475 samples = get_int(cscene,
"preview_samples");
476 use_adaptive_sampling = RNA_boolean_get(&cscene,
"use_preview_adaptive_sampling");
477 integrator->set_use_adaptive_sampling(use_adaptive_sampling);
478 integrator->set_adaptive_threshold(get_float(cscene,
"preview_adaptive_threshold"));
479 integrator->set_adaptive_min_samples(get_int(cscene,
"preview_adaptive_min_samples"));
482 samples = get_int(cscene,
"samples");
483 use_adaptive_sampling = RNA_boolean_get(&cscene,
"use_adaptive_sampling");
484 integrator->set_use_adaptive_sampling(use_adaptive_sampling);
485 integrator->set_adaptive_threshold(get_float(cscene,
"adaptive_threshold"));
486 integrator->set_adaptive_min_samples(get_int(cscene,
"adaptive_min_samples"));
489 if (get_boolean(cscene,
"use_fast_gi")) {
491 integrator->set_ao_bounces(get_int(cscene,
"ao_bounces"));
494 integrator->set_ao_bounces(get_int(cscene,
"ao_bounces_render"));
498 integrator->set_ao_bounces(0);
501#ifdef WITH_CYCLES_DEBUG
504 integrator->set_direct_light_sampling_type(direct_light_sampling_type);
507 integrator->set_use_guiding(get_boolean(cscene,
"use_guiding"));
508 integrator->set_use_surface_guiding(get_boolean(cscene,
"use_surface_guiding"));
509 integrator->set_use_volume_guiding(get_boolean(cscene,
"use_volume_guiding"));
510 integrator->set_guiding_training_samples(get_int(cscene,
"guiding_training_samples"));
512 if (use_developer_ui) {
513 integrator->set_deterministic_guiding(get_boolean(cscene,
"use_deterministic_guiding"));
514 integrator->set_surface_guiding_probability(get_float(cscene,
"surface_guiding_probability"));
515 integrator->set_volume_guiding_probability(get_float(cscene,
"volume_guiding_probability"));
516 integrator->set_use_guiding_direct_light(get_boolean(cscene,
"use_guiding_direct_light"));
517 integrator->set_use_guiding_mis_weights(get_boolean(cscene,
"use_guiding_mis_weights"));
520 integrator->set_guiding_distribution_type(guiding_distribution_type);
523 "guiding_directional_sampling_type",
526 integrator->set_guiding_directional_sampling_type(guiding_directional_sampling_type);
527 integrator->set_guiding_roughness_threshold(get_float(cscene,
"guiding_roughness_threshold"));
531 *b_scene, &b_view_layer, background, denoise_device_info);
535 if (is_vertex_baking) {
536 denoise_params.
use =
false;
539 integrator->set_use_denoise(denoise_params.
use);
544 if (denoise_params.
use) {
545 integrator->set_denoiser_type(denoise_params.
type);
546 integrator->set_denoise_use_gpu(denoise_params.
use_gpu);
547 integrator->set_denoise_start_sample(denoise_params.
start_sample);
548 integrator->set_denoiser_passes(denoise_params.
passes);
549 integrator->set_denoiser_prefilter(denoise_params.
prefilter);
550 integrator->set_denoiser_quality(denoise_params.
quality);
551 integrator->set_denoiser_upscale_factor(denoise_params.
upscale_factor);
554 float scrambling_distance = get_float(cscene,
"scrambling_distance");
555 const bool auto_scrambling_distance = get_boolean(cscene,
"auto_scrambling_distance");
556 if (auto_scrambling_distance) {
565 if (use_adaptive_sampling) {
571 scrambling_distance *= 4.0f /
sqrtf(samples);
579 const bool preview_scrambling_distance = get_boolean(cscene,
"preview_scrambling_distance");
580 if ((preview && !preview_scrambling_distance) ||
584 scrambling_distance = 1.0f;
587 if (scrambling_distance != 1.0f) {
588 LOG_INFO <<
"Using scrambling distance: " << scrambling_distance;
590 integrator->set_scrambling_distance(scrambling_distance);
1148 enum DenoiserInput {
1149 DENOISER_INPUT_RGB = 1,
1150 DENOISER_INPUT_RGB_ALBEDO = 2,
1151 DENOISER_INPUT_RGB_ALBEDO_NORMAL = 3,
1156 enum DenoiserUpscaleQuality {
1157 DENOISER_UPSCALE_NONE = 0,
1158 DENOISER_UPSCALE_QUALITY = 1,
1159 DENOISER_UPSCALE_BALANCED = 2,
1160 DENOISER_UPSCALE_PERFORMANCE = 3,
1161 DENOISER_UPSCALE_ULTRA_PERFORMANCE = 4,
1163 DENOISER_UPSCALE_NUM,
1170 int input_passes = -1;
1174 denoising.
use = get_boolean(cscene,
"use_denoising");
1176 denoising.
use_gpu = get_boolean(cscene,
"denoising_use_gpu");
1182 input_passes = (DenoiserInput)get_enum(
1183 cscene,
"denoising_input_passes", DENOISER_INPUT_NUM, DENOISER_INPUT_RGB_ALBEDO_NORMAL);
1187 b_scene.id, blender::RNA_ViewLayer, b_view_layer);
1189 if (!get_boolean(clayer,
"use_denoising")) {
1190 denoising.
use =
false;
1196 denoising.
use = get_boolean(cscene,
"use_preview_denoising");
1199 denoising.
use_gpu = get_boolean(cscene,
"preview_denoising_use_gpu");
1204 denoising.
start_sample = get_int(cscene,
"preview_denoising_start_sample");
1206 input_passes = (DenoiserInput)get_enum(
1207 cscene,
"preview_denoising_input_passes", DENOISER_INPUT_NUM, DENOISER_INPUT_RGB_ALBEDO);
1213 denoising.
use =
false;
1220 denoising.
use =
false;
1225 switch ((DenoiserUpscaleQuality)get_enum(cscene,
1226 "preview_denoising_upscale_quality",
1227 DENOISER_UPSCALE_NUM,
1228 DENOISER_UPSCALE_BALANCED))
1230 case DENOISER_UPSCALE_NONE:
1234 case DENOISER_UPSCALE_QUALITY:
1239 case DENOISER_UPSCALE_BALANCED:
1243 case DENOISER_UPSCALE_PERFORMANCE:
1247 case DENOISER_UPSCALE_ULTRA_PERFORMANCE:
1260 switch (input_passes) {
1261 case DENOISER_INPUT_RGB:
1265 case DENOISER_INPUT_RGB_ALBEDO:
1269 case DENOISER_INPUT_RGB_ALBEDO_NORMAL:
1274 LOG_ERROR <<
"Unhandled input passes enum " << input_passes;