ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / blender / blender_sync.cpp
1 /*
2  * Copyright 2011-2013 Blender Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include "render/background.h"
18 #include "render/camera.h"
19 #include "render/film.h"
20 #include "render/graph.h"
21 #include "render/integrator.h"
22 #include "render/light.h"
23 #include "render/mesh.h"
24 #include "render/nodes.h"
25 #include "render/object.h"
26 #include "render/scene.h"
27 #include "render/shader.h"
28 #include "render/curves.h"
29
30 #include "device/device.h"
31
32 #include "blender/blender_device.h"
33 #include "blender/blender_sync.h"
34 #include "blender/blender_session.h"
35 #include "blender/blender_util.h"
36
37 #include "util/util_debug.h"
38 #include "util/util_foreach.h"
39 #include "util/util_opengl.h"
40 #include "util/util_hash.h"
41
42 CCL_NAMESPACE_BEGIN
43
44 static const char *cryptomatte_prefix = "Crypto";
45
46 /* Constructor */
47
48 BlenderSync::BlenderSync(BL::RenderEngine &b_engine,
49                          BL::BlendData &b_data,
50                          BL::Scene &b_scene,
51                          Scene *scene,
52                          bool preview,
53                          Progress &progress)
54     : b_engine(b_engine),
55       b_data(b_data),
56       b_scene(b_scene),
57       shader_map(&scene->shaders),
58       object_map(&scene->objects),
59       mesh_map(&scene->meshes),
60       light_map(&scene->lights),
61       particle_system_map(&scene->particle_systems),
62       world_map(NULL),
63       world_recalc(false),
64       scene(scene),
65       preview(preview),
66       experimental(false),
67       dicing_rate(1.0f),
68       max_subdivisions(12),
69       progress(progress)
70 {
71   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
72   dicing_rate = preview ? RNA_float_get(&cscene, "preview_dicing_rate") :
73                           RNA_float_get(&cscene, "dicing_rate");
74   max_subdivisions = RNA_int_get(&cscene, "max_subdivisions");
75 }
76
77 BlenderSync::~BlenderSync()
78 {
79 }
80
81 /* Sync */
82
83 void BlenderSync::sync_recalc(BL::Depsgraph &b_depsgraph)
84 {
85   /* Sync recalc flags from blender to cycles. Actual update is done separate,
86    * so we can do it later on if doing it immediate is not suitable. */
87
88   bool has_updated_objects = b_depsgraph.id_type_updated(BL::DriverTarget::id_type_OBJECT);
89
90   if (experimental) {
91     /* Mark all meshes as needing to be exported again if dicing changed. */
92     PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
93     bool dicing_prop_changed = false;
94
95     float updated_dicing_rate = preview ? RNA_float_get(&cscene, "preview_dicing_rate") :
96                                           RNA_float_get(&cscene, "dicing_rate");
97
98     if (dicing_rate != updated_dicing_rate) {
99       dicing_rate = updated_dicing_rate;
100       dicing_prop_changed = true;
101     }
102
103     int updated_max_subdivisions = RNA_int_get(&cscene, "max_subdivisions");
104
105     if (max_subdivisions != updated_max_subdivisions) {
106       max_subdivisions = updated_max_subdivisions;
107       dicing_prop_changed = true;
108     }
109
110     if (dicing_prop_changed) {
111       for (const pair<void *, Mesh *> &iter : mesh_map.key_to_scene_data()) {
112         Mesh *mesh = iter.second;
113         if (mesh->subdivision_type != Mesh::SUBDIVISION_NONE) {
114           mesh_map.set_recalc(iter.first);
115         }
116       }
117     }
118   }
119
120   /* Iterate over all IDs in this depsgraph. */
121   BL::Depsgraph::updates_iterator b_update;
122   for (b_depsgraph.updates.begin(b_update); b_update != b_depsgraph.updates.end(); ++b_update) {
123     BL::ID b_id(b_update->id());
124
125     /* Material */
126     if (b_id.is_a(&RNA_Material)) {
127       BL::Material b_mat(b_id);
128       shader_map.set_recalc(b_mat);
129     }
130     /* Light */
131     else if (b_id.is_a(&RNA_Light)) {
132       BL::Light b_light(b_id);
133       shader_map.set_recalc(b_light);
134     }
135     /* Object */
136     else if (b_id.is_a(&RNA_Object)) {
137       BL::Object b_ob(b_id);
138       const bool updated_geometry = b_update->is_updated_geometry();
139
140       if (b_update->is_updated_transform()) {
141         object_map.set_recalc(b_ob);
142         light_map.set_recalc(b_ob);
143       }
144
145       if (object_is_mesh(b_ob)) {
146         if (updated_geometry ||
147             (object_subdivision_type(b_ob, preview, experimental) != Mesh::SUBDIVISION_NONE)) {
148           BL::ID key = BKE_object_is_modified(b_ob) ? b_ob : b_ob.data();
149           mesh_map.set_recalc(key);
150         }
151       }
152       else if (object_is_light(b_ob)) {
153         if (updated_geometry) {
154           light_map.set_recalc(b_ob);
155         }
156       }
157
158       if (updated_geometry) {
159         BL::Object::particle_systems_iterator b_psys;
160         for (b_ob.particle_systems.begin(b_psys); b_psys != b_ob.particle_systems.end(); ++b_psys)
161           particle_system_map.set_recalc(b_ob);
162       }
163     }
164     /* Mesh */
165     else if (b_id.is_a(&RNA_Mesh)) {
166       BL::Mesh b_mesh(b_id);
167       mesh_map.set_recalc(b_mesh);
168     }
169     /* World */
170     else if (b_id.is_a(&RNA_World)) {
171       BL::World b_world(b_id);
172       if (world_map == b_world.ptr.data) {
173         world_recalc = true;
174       }
175     }
176   }
177
178   /* Updates shader with object dependency if objects changed. */
179   if (has_updated_objects) {
180     if (scene->default_background->has_object_dependency) {
181       world_recalc = true;
182     }
183
184     foreach (Shader *shader, scene->shaders) {
185       if (shader->has_object_dependency) {
186         shader->need_sync_object = true;
187       }
188     }
189   }
190 }
191
192 void BlenderSync::sync_data(BL::RenderSettings &b_render,
193                             BL::Depsgraph &b_depsgraph,
194                             BL::SpaceView3D &b_v3d,
195                             BL::Object &b_override,
196                             int width,
197                             int height,
198                             void **python_thread_state)
199 {
200   BL::ViewLayer b_view_layer = b_depsgraph.view_layer_eval();
201
202   sync_view_layer(b_v3d, b_view_layer);
203   sync_integrator();
204   sync_film();
205   sync_shaders(b_depsgraph);
206   sync_images();
207   sync_curve_settings();
208
209   mesh_synced.clear(); /* use for objects and motion sync */
210
211   if (scene->need_motion() == Scene::MOTION_PASS || scene->need_motion() == Scene::MOTION_NONE ||
212       scene->camera->motion_position == Camera::MOTION_POSITION_CENTER) {
213     sync_objects(b_depsgraph);
214   }
215   sync_motion(b_render, b_depsgraph, b_override, width, height, python_thread_state);
216
217   mesh_synced.clear();
218
219   free_data_after_sync(b_depsgraph);
220 }
221
222 /* Integrator */
223
224 void BlenderSync::sync_integrator()
225 {
226   BL::RenderSettings r = b_scene.render();
227   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
228
229   experimental = (get_enum(cscene, "feature_set") != 0);
230
231   Integrator *integrator = scene->integrator;
232   Integrator previntegrator = *integrator;
233
234   integrator->max_bounce = get_int(cscene, "max_bounces");
235
236   integrator->max_diffuse_bounce = get_int(cscene, "diffuse_bounces");
237   integrator->max_glossy_bounce = get_int(cscene, "glossy_bounces");
238   integrator->max_transmission_bounce = get_int(cscene, "transmission_bounces");
239   integrator->max_volume_bounce = get_int(cscene, "volume_bounces");
240
241   integrator->transparent_max_bounce = get_int(cscene, "transparent_max_bounces");
242
243   integrator->volume_max_steps = get_int(cscene, "volume_max_steps");
244   integrator->volume_step_size = get_float(cscene, "volume_step_size");
245
246   integrator->caustics_reflective = get_boolean(cscene, "caustics_reflective");
247   integrator->caustics_refractive = get_boolean(cscene, "caustics_refractive");
248   integrator->filter_glossy = get_float(cscene, "blur_glossy");
249
250   integrator->seed = get_int(cscene, "seed");
251   if (get_boolean(cscene, "use_animated_seed")) {
252     integrator->seed = hash_int_2d(b_scene.frame_current(), get_int(cscene, "seed"));
253     if (b_scene.frame_subframe() != 0.0f) {
254       /* TODO(sergey): Ideally should be some sort of hash_merge,
255        * but this is good enough for now.
256        */
257       integrator->seed += hash_int_2d((int)(b_scene.frame_subframe() * (float)INT_MAX),
258                                       get_int(cscene, "seed"));
259     }
260   }
261
262   integrator->sampling_pattern = (SamplingPattern)get_enum(
263       cscene, "sampling_pattern", SAMPLING_NUM_PATTERNS, SAMPLING_PATTERN_SOBOL);
264
265   integrator->sample_clamp_direct = get_float(cscene, "sample_clamp_direct");
266   integrator->sample_clamp_indirect = get_float(cscene, "sample_clamp_indirect");
267   if (!preview) {
268     if (integrator->motion_blur != r.use_motion_blur()) {
269       scene->object_manager->tag_update(scene);
270       scene->camera->tag_update();
271     }
272
273     integrator->motion_blur = r.use_motion_blur();
274   }
275
276   integrator->method = (Integrator::Method)get_enum(
277       cscene, "progressive", Integrator::NUM_METHODS, Integrator::PATH);
278
279   integrator->sample_all_lights_direct = get_boolean(cscene, "sample_all_lights_direct");
280   integrator->sample_all_lights_indirect = get_boolean(cscene, "sample_all_lights_indirect");
281   integrator->light_sampling_threshold = get_float(cscene, "light_sampling_threshold");
282
283   int diffuse_samples = get_int(cscene, "diffuse_samples");
284   int glossy_samples = get_int(cscene, "glossy_samples");
285   int transmission_samples = get_int(cscene, "transmission_samples");
286   int ao_samples = get_int(cscene, "ao_samples");
287   int mesh_light_samples = get_int(cscene, "mesh_light_samples");
288   int subsurface_samples = get_int(cscene, "subsurface_samples");
289   int volume_samples = get_int(cscene, "volume_samples");
290
291   if (get_boolean(cscene, "use_square_samples")) {
292     integrator->diffuse_samples = diffuse_samples * diffuse_samples;
293     integrator->glossy_samples = glossy_samples * glossy_samples;
294     integrator->transmission_samples = transmission_samples * transmission_samples;
295     integrator->ao_samples = ao_samples * ao_samples;
296     integrator->mesh_light_samples = mesh_light_samples * mesh_light_samples;
297     integrator->subsurface_samples = subsurface_samples * subsurface_samples;
298     integrator->volume_samples = volume_samples * volume_samples;
299   }
300   else {
301     integrator->diffuse_samples = diffuse_samples;
302     integrator->glossy_samples = glossy_samples;
303     integrator->transmission_samples = transmission_samples;
304     integrator->ao_samples = ao_samples;
305     integrator->mesh_light_samples = mesh_light_samples;
306     integrator->subsurface_samples = subsurface_samples;
307     integrator->volume_samples = volume_samples;
308   }
309
310   if (b_scene.render().use_simplify()) {
311     if (preview) {
312       integrator->ao_bounces = get_int(cscene, "ao_bounces");
313     }
314     else {
315       integrator->ao_bounces = get_int(cscene, "ao_bounces_render");
316     }
317   }
318   else {
319     integrator->ao_bounces = 0;
320   }
321
322   if (integrator->modified(previntegrator))
323     integrator->tag_update(scene);
324 }
325
326 /* Film */
327
328 void BlenderSync::sync_film()
329 {
330   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
331
332   Film *film = scene->film;
333   Film prevfilm = *film;
334
335   film->exposure = get_float(cscene, "film_exposure");
336   film->filter_type = (FilterType)get_enum(
337       cscene, "pixel_filter_type", FILTER_NUM_TYPES, FILTER_BLACKMAN_HARRIS);
338   film->filter_width = (film->filter_type == FILTER_BOX) ? 1.0f :
339                                                            get_float(cscene, "filter_width");
340
341   if (b_scene.world()) {
342     BL::WorldMistSettings b_mist = b_scene.world().mist_settings();
343
344     film->mist_start = b_mist.start();
345     film->mist_depth = b_mist.depth();
346
347     switch (b_mist.falloff()) {
348       case BL::WorldMistSettings::falloff_QUADRATIC:
349         film->mist_falloff = 2.0f;
350         break;
351       case BL::WorldMistSettings::falloff_LINEAR:
352         film->mist_falloff = 1.0f;
353         break;
354       case BL::WorldMistSettings::falloff_INVERSE_QUADRATIC:
355         film->mist_falloff = 0.5f;
356         break;
357     }
358   }
359
360   if (film->modified(prevfilm))
361     film->tag_update(scene);
362 }
363
364 /* Render Layer */
365
366 void BlenderSync::sync_view_layer(BL::SpaceView3D & /*b_v3d*/, BL::ViewLayer &b_view_layer)
367 {
368   /* render layer */
369   view_layer.name = b_view_layer.name();
370   view_layer.use_background_shader = b_view_layer.use_sky();
371   view_layer.use_background_ao = b_view_layer.use_ao();
372   view_layer.use_surfaces = b_view_layer.use_solid();
373   view_layer.use_hair = b_view_layer.use_strand();
374
375   /* Material override. */
376   view_layer.material_override = b_view_layer.material_override();
377
378   /* Sample override. */
379   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
380   int use_layer_samples = get_enum(cscene, "use_layer_samples");
381
382   view_layer.bound_samples = (use_layer_samples == 1);
383   view_layer.samples = 0;
384
385   if (use_layer_samples != 2) {
386     int samples = b_view_layer.samples();
387     if (get_boolean(cscene, "use_square_samples"))
388       view_layer.samples = samples * samples;
389     else
390       view_layer.samples = samples;
391   }
392 }
393
394 /* Images */
395 void BlenderSync::sync_images()
396 {
397   /* Sync is a convention for this API, but currently it frees unused buffers. */
398
399   const bool is_interface_locked = b_engine.render() && b_engine.render().use_lock_interface();
400   if (is_interface_locked == false && BlenderSession::headless == false) {
401     /* If interface is not locked, it's possible image is needed for
402      * the display.
403      */
404     return;
405   }
406   /* Free buffers used by images which are not needed for render. */
407   BL::BlendData::images_iterator b_image;
408   for (b_data.images.begin(b_image); b_image != b_data.images.end(); ++b_image) {
409     /* TODO(sergey): Consider making it an utility function to check
410      * whether image is considered builtin.
411      */
412     const bool is_builtin = b_image->packed_file() ||
413                             b_image->source() == BL::Image::source_GENERATED ||
414                             b_image->source() == BL::Image::source_MOVIE || b_engine.is_preview();
415     if (is_builtin == false) {
416       b_image->buffers_free();
417     }
418     /* TODO(sergey): Free builtin images not used by any shader. */
419   }
420 }
421
422 /* Passes */
423 PassType BlenderSync::get_pass_type(BL::RenderPass &b_pass)
424 {
425   string name = b_pass.name();
426 #define MAP_PASS(passname, passtype) \
427   if (name == passname) \
428     return passtype;
429   /* NOTE: Keep in sync with defined names from DNA_scene_types.h */
430   MAP_PASS("Combined", PASS_COMBINED);
431   MAP_PASS("Depth", PASS_DEPTH);
432   MAP_PASS("Mist", PASS_MIST);
433   MAP_PASS("Normal", PASS_NORMAL);
434   MAP_PASS("IndexOB", PASS_OBJECT_ID);
435   MAP_PASS("UV", PASS_UV);
436   MAP_PASS("Vector", PASS_MOTION);
437   MAP_PASS("IndexMA", PASS_MATERIAL_ID);
438
439   MAP_PASS("DiffDir", PASS_DIFFUSE_DIRECT);
440   MAP_PASS("GlossDir", PASS_GLOSSY_DIRECT);
441   MAP_PASS("TransDir", PASS_TRANSMISSION_DIRECT);
442   MAP_PASS("SubsurfaceDir", PASS_SUBSURFACE_DIRECT);
443   MAP_PASS("VolumeDir", PASS_VOLUME_DIRECT);
444
445   MAP_PASS("DiffInd", PASS_DIFFUSE_INDIRECT);
446   MAP_PASS("GlossInd", PASS_GLOSSY_INDIRECT);
447   MAP_PASS("TransInd", PASS_TRANSMISSION_INDIRECT);
448   MAP_PASS("SubsurfaceInd", PASS_SUBSURFACE_INDIRECT);
449   MAP_PASS("VolumeInd", PASS_VOLUME_INDIRECT);
450
451   MAP_PASS("DiffCol", PASS_DIFFUSE_COLOR);
452   MAP_PASS("GlossCol", PASS_GLOSSY_COLOR);
453   MAP_PASS("TransCol", PASS_TRANSMISSION_COLOR);
454   MAP_PASS("SubsurfaceCol", PASS_SUBSURFACE_COLOR);
455
456   MAP_PASS("Emit", PASS_EMISSION);
457   MAP_PASS("Env", PASS_BACKGROUND);
458   MAP_PASS("AO", PASS_AO);
459   MAP_PASS("Shadow", PASS_SHADOW);
460
461 #ifdef __KERNEL_DEBUG__
462   MAP_PASS("Debug BVH Traversed Nodes", PASS_BVH_TRAVERSED_NODES);
463   MAP_PASS("Debug BVH Traversed Instances", PASS_BVH_TRAVERSED_INSTANCES);
464   MAP_PASS("Debug BVH Intersections", PASS_BVH_INTERSECTIONS);
465   MAP_PASS("Debug Ray Bounces", PASS_RAY_BOUNCES);
466 #endif
467   MAP_PASS("Debug Render Time", PASS_RENDER_TIME);
468   if (string_startswith(name, cryptomatte_prefix)) {
469     return PASS_CRYPTOMATTE;
470   }
471 #undef MAP_PASS
472
473   return PASS_NONE;
474 }
475
476 int BlenderSync::get_denoising_pass(BL::RenderPass &b_pass)
477 {
478   string name = b_pass.name();
479
480   if (name == "Noisy Image")
481     return DENOISING_PASS_PREFILTERED_COLOR;
482
483   if (name.substr(0, 10) != "Denoising ") {
484     return -1;
485   }
486   name = name.substr(10);
487
488 #define MAP_PASS(passname, offset) \
489   if (name == passname) \
490     return offset;
491   MAP_PASS("Normal", DENOISING_PASS_PREFILTERED_NORMAL);
492   MAP_PASS("Albedo", DENOISING_PASS_PREFILTERED_ALBEDO);
493   MAP_PASS("Depth", DENOISING_PASS_PREFILTERED_DEPTH);
494   MAP_PASS("Shadowing", DENOISING_PASS_PREFILTERED_SHADOWING);
495   MAP_PASS("Variance", DENOISING_PASS_PREFILTERED_VARIANCE);
496   MAP_PASS("Intensity", DENOISING_PASS_PREFILTERED_INTENSITY);
497   MAP_PASS("Clean", DENOISING_PASS_CLEAN);
498 #undef MAP_PASS
499
500   return -1;
501 }
502
503 vector<Pass> BlenderSync::sync_render_passes(BL::RenderLayer &b_rlay, BL::ViewLayer &b_view_layer)
504 {
505   vector<Pass> passes;
506   Pass::add(PASS_COMBINED, passes);
507
508   /* loop over passes */
509   BL::RenderLayer::passes_iterator b_pass_iter;
510
511   for (b_rlay.passes.begin(b_pass_iter); b_pass_iter != b_rlay.passes.end(); ++b_pass_iter) {
512     BL::RenderPass b_pass(*b_pass_iter);
513     PassType pass_type = get_pass_type(b_pass);
514
515     if (pass_type == PASS_MOTION && scene->integrator->motion_blur)
516       continue;
517     if (pass_type != PASS_NONE)
518       Pass::add(pass_type, passes);
519   }
520
521   PointerRNA crp = RNA_pointer_get(&b_view_layer.ptr, "cycles");
522   bool full_denoising = get_boolean(crp, "use_denoising");
523   bool write_denoising_passes = get_boolean(crp, "denoising_store_passes");
524
525   scene->film->denoising_flags = 0;
526   if (full_denoising || write_denoising_passes) {
527 #define MAP_OPTION(name, flag) \
528   if (!get_boolean(crp, name)) \
529     scene->film->denoising_flags |= flag;
530     MAP_OPTION("denoising_diffuse_direct", DENOISING_CLEAN_DIFFUSE_DIR);
531     MAP_OPTION("denoising_diffuse_indirect", DENOISING_CLEAN_DIFFUSE_IND);
532     MAP_OPTION("denoising_glossy_direct", DENOISING_CLEAN_GLOSSY_DIR);
533     MAP_OPTION("denoising_glossy_indirect", DENOISING_CLEAN_GLOSSY_IND);
534     MAP_OPTION("denoising_transmission_direct", DENOISING_CLEAN_TRANSMISSION_DIR);
535     MAP_OPTION("denoising_transmission_indirect", DENOISING_CLEAN_TRANSMISSION_IND);
536     MAP_OPTION("denoising_subsurface_direct", DENOISING_CLEAN_SUBSURFACE_DIR);
537     MAP_OPTION("denoising_subsurface_indirect", DENOISING_CLEAN_SUBSURFACE_IND);
538 #undef MAP_OPTION
539     b_engine.add_pass("Noisy Image", 4, "RGBA", b_view_layer.name().c_str());
540   }
541
542   if (write_denoising_passes) {
543     b_engine.add_pass("Denoising Normal", 3, "XYZ", b_view_layer.name().c_str());
544     b_engine.add_pass("Denoising Albedo", 3, "RGB", b_view_layer.name().c_str());
545     b_engine.add_pass("Denoising Depth", 1, "Z", b_view_layer.name().c_str());
546     b_engine.add_pass("Denoising Shadowing", 1, "X", b_view_layer.name().c_str());
547     b_engine.add_pass("Denoising Variance", 3, "RGB", b_view_layer.name().c_str());
548     b_engine.add_pass("Denoising Intensity", 1, "X", b_view_layer.name().c_str());
549
550     if (scene->film->denoising_flags & DENOISING_CLEAN_ALL_PASSES) {
551       b_engine.add_pass("Denoising Clean", 3, "RGB", b_view_layer.name().c_str());
552     }
553   }
554 #ifdef __KERNEL_DEBUG__
555   if (get_boolean(crp, "pass_debug_bvh_traversed_nodes")) {
556     b_engine.add_pass("Debug BVH Traversed Nodes", 1, "X", b_view_layer.name().c_str());
557     Pass::add(PASS_BVH_TRAVERSED_NODES, passes);
558   }
559   if (get_boolean(crp, "pass_debug_bvh_traversed_instances")) {
560     b_engine.add_pass("Debug BVH Traversed Instances", 1, "X", b_view_layer.name().c_str());
561     Pass::add(PASS_BVH_TRAVERSED_INSTANCES, passes);
562   }
563   if (get_boolean(crp, "pass_debug_bvh_intersections")) {
564     b_engine.add_pass("Debug BVH Intersections", 1, "X", b_view_layer.name().c_str());
565     Pass::add(PASS_BVH_INTERSECTIONS, passes);
566   }
567   if (get_boolean(crp, "pass_debug_ray_bounces")) {
568     b_engine.add_pass("Debug Ray Bounces", 1, "X", b_view_layer.name().c_str());
569     Pass::add(PASS_RAY_BOUNCES, passes);
570   }
571 #endif
572   if (get_boolean(crp, "pass_debug_render_time")) {
573     b_engine.add_pass("Debug Render Time", 1, "X", b_view_layer.name().c_str());
574     Pass::add(PASS_RENDER_TIME, passes);
575   }
576   if (get_boolean(crp, "use_pass_volume_direct")) {
577     b_engine.add_pass("VolumeDir", 3, "RGB", b_view_layer.name().c_str());
578     Pass::add(PASS_VOLUME_DIRECT, passes);
579   }
580   if (get_boolean(crp, "use_pass_volume_indirect")) {
581     b_engine.add_pass("VolumeInd", 3, "RGB", b_view_layer.name().c_str());
582     Pass::add(PASS_VOLUME_INDIRECT, passes);
583   }
584
585   /* Cryptomatte stores two ID/weight pairs per RGBA layer.
586    * User facing paramter is the number of pairs. */
587   int crypto_depth = min(16, get_int(crp, "pass_crypto_depth")) / 2;
588   scene->film->cryptomatte_depth = crypto_depth;
589   scene->film->cryptomatte_passes = CRYPT_NONE;
590   if (get_boolean(crp, "use_pass_crypto_object")) {
591     for (int i = 0; i < crypto_depth; ++i) {
592       string passname = cryptomatte_prefix + string_printf("Object%02d", i);
593       b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());
594       Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());
595     }
596     scene->film->cryptomatte_passes = (CryptomatteType)(scene->film->cryptomatte_passes |
597                                                         CRYPT_OBJECT);
598   }
599   if (get_boolean(crp, "use_pass_crypto_material")) {
600     for (int i = 0; i < crypto_depth; ++i) {
601       string passname = cryptomatte_prefix + string_printf("Material%02d", i);
602       b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());
603       Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());
604     }
605     scene->film->cryptomatte_passes = (CryptomatteType)(scene->film->cryptomatte_passes |
606                                                         CRYPT_MATERIAL);
607   }
608   if (get_boolean(crp, "use_pass_crypto_asset")) {
609     for (int i = 0; i < crypto_depth; ++i) {
610       string passname = cryptomatte_prefix + string_printf("Asset%02d", i);
611       b_engine.add_pass(passname.c_str(), 4, "RGBA", b_view_layer.name().c_str());
612       Pass::add(PASS_CRYPTOMATTE, passes, passname.c_str());
613     }
614     scene->film->cryptomatte_passes = (CryptomatteType)(scene->film->cryptomatte_passes |
615                                                         CRYPT_ASSET);
616   }
617   if (get_boolean(crp, "pass_crypto_accurate") && scene->film->cryptomatte_passes != CRYPT_NONE) {
618     scene->film->cryptomatte_passes = (CryptomatteType)(scene->film->cryptomatte_passes |
619                                                         CRYPT_ACCURATE);
620   }
621
622   return passes;
623 }
624
625 void BlenderSync::free_data_after_sync(BL::Depsgraph &b_depsgraph)
626 {
627   /* When viewport display is not needed during render we can force some
628    * caches to be releases from blender side in order to reduce peak memory
629    * footprint during synchronization process.
630    */
631   const bool is_interface_locked = b_engine.render() && b_engine.render().use_lock_interface();
632   const bool can_free_caches = BlenderSession::headless || is_interface_locked;
633   if (!can_free_caches) {
634     return;
635   }
636   /* TODO(sergey): We can actually remove the whole dependency graph,
637    * but that will need some API support first.
638    */
639   BL::Depsgraph::objects_iterator b_ob;
640   for (b_depsgraph.objects.begin(b_ob); b_ob != b_depsgraph.objects.end(); ++b_ob) {
641     b_ob->cache_release();
642   }
643 }
644
645 /* Scene Parameters */
646
647 SceneParams BlenderSync::get_scene_params(BL::Scene &b_scene, bool background)
648 {
649   BL::RenderSettings r = b_scene.render();
650   SceneParams params;
651   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
652   const bool shadingsystem = RNA_boolean_get(&cscene, "shading_system");
653
654   if (shadingsystem == 0)
655     params.shadingsystem = SHADINGSYSTEM_SVM;
656   else if (shadingsystem == 1)
657     params.shadingsystem = SHADINGSYSTEM_OSL;
658
659   if (background || DebugFlags().viewport_static_bvh)
660     params.bvh_type = SceneParams::BVH_STATIC;
661   else
662     params.bvh_type = SceneParams::BVH_DYNAMIC;
663
664   params.use_bvh_spatial_split = RNA_boolean_get(&cscene, "debug_use_spatial_splits");
665   params.use_bvh_unaligned_nodes = RNA_boolean_get(&cscene, "debug_use_hair_bvh");
666   params.num_bvh_time_steps = RNA_int_get(&cscene, "debug_bvh_time_steps");
667
668   if (background && params.shadingsystem != SHADINGSYSTEM_OSL)
669     params.persistent_data = r.use_persistent_data();
670   else
671     params.persistent_data = false;
672
673   int texture_limit;
674   if (background) {
675     texture_limit = RNA_enum_get(&cscene, "texture_limit_render");
676   }
677   else {
678     texture_limit = RNA_enum_get(&cscene, "texture_limit");
679   }
680   if (texture_limit > 0 && b_scene.render().use_simplify()) {
681     params.texture_limit = 1 << (texture_limit + 6);
682   }
683   else {
684     params.texture_limit = 0;
685   }
686
687   /* TODO(sergey): Once OSL supports per-microarchitecture optimization get
688    * rid of this.
689    */
690   if (params.shadingsystem == SHADINGSYSTEM_OSL) {
691     params.bvh_layout = BVH_LAYOUT_BVH4;
692   }
693   else {
694     params.bvh_layout = DebugFlags().cpu.bvh_layout;
695   }
696
697 #ifdef WITH_EMBREE
698   params.bvh_layout = RNA_boolean_get(&cscene, "use_bvh_embree") ? BVH_LAYOUT_EMBREE :
699                                                                    params.bvh_layout;
700 #endif
701   return params;
702 }
703
704 /* Session Parameters */
705
706 bool BlenderSync::get_session_pause(BL::Scene &b_scene, bool background)
707 {
708   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
709   return (background) ? false : get_boolean(cscene, "preview_pause");
710 }
711
712 SessionParams BlenderSync::get_session_params(BL::RenderEngine &b_engine,
713                                               BL::Preferences &b_preferences,
714                                               BL::Scene &b_scene,
715                                               bool background)
716 {
717   SessionParams params;
718   PointerRNA cscene = RNA_pointer_get(&b_scene.ptr, "cycles");
719
720   /* feature set */
721   params.experimental = (get_enum(cscene, "feature_set") != 0);
722
723   /* Background */
724   params.background = background;
725
726   /* Device */
727   params.threads = blender_device_threads(b_scene);
728   params.device = blender_device_info(b_preferences, b_scene, params.background);
729
730   /* samples */
731   int samples = get_int(cscene, "samples");
732   int aa_samples = get_int(cscene, "aa_samples");
733   int preview_samples = get_int(cscene, "preview_samples");
734   int preview_aa_samples = get_int(cscene, "preview_aa_samples");
735
736   if (get_boolean(cscene, "use_square_samples")) {
737     aa_samples = aa_samples * aa_samples;
738     preview_aa_samples = preview_aa_samples * preview_aa_samples;
739
740     samples = samples * samples;
741     preview_samples = preview_samples * preview_samples;
742   }
743
744   if (get_enum(cscene, "progressive") == 0) {
745     if (background) {
746       params.samples = aa_samples;
747     }
748     else {
749       params.samples = preview_aa_samples;
750       if (params.samples == 0)
751         params.samples = INT_MAX;
752     }
753   }
754   else {
755     if (background) {
756       params.samples = samples;
757     }
758     else {
759       params.samples = preview_samples;
760       if (params.samples == 0)
761         params.samples = INT_MAX;
762     }
763   }
764
765   /* Clamp samples. */
766   params.samples = min(params.samples, Integrator::MAX_SAMPLES);
767
768   /* tiles */
769   const bool is_cpu = (params.device.type == DEVICE_CPU);
770   if (!is_cpu && !background) {
771     /* currently GPU could be much slower than CPU when using tiles,
772      * still need to be investigated, but meanwhile make it possible
773      * to work in viewport smoothly
774      */
775     int debug_tile_size = get_int(cscene, "debug_tile_size");
776
777     params.tile_size = make_int2(debug_tile_size, debug_tile_size);
778   }
779   else {
780     int tile_x = b_engine.tile_x();
781     int tile_y = b_engine.tile_y();
782
783     params.tile_size = make_int2(tile_x, tile_y);
784   }
785
786   if ((BlenderSession::headless == false) && background) {
787     params.tile_order = (TileOrder)get_enum(cscene, "tile_order");
788   }
789   else {
790     params.tile_order = TILE_BOTTOM_TO_TOP;
791   }
792
793   /* other parameters */
794   params.start_resolution = get_int(cscene, "preview_start_resolution");
795   params.pixel_size = b_engine.get_preview_pixel_size(b_scene);
796
797   /* other parameters */
798   params.cancel_timeout = (double)get_float(cscene, "debug_cancel_timeout");
799   params.reset_timeout = (double)get_float(cscene, "debug_reset_timeout");
800   params.text_timeout = (double)get_float(cscene, "debug_text_timeout");
801
802   /* progressive refine */
803   BL::RenderSettings b_r = b_scene.render();
804   params.progressive_refine = (b_engine.is_preview() ||
805                                get_boolean(cscene, "use_progressive_refine")) &&
806                               !b_r.use_save_buffers();
807
808   if (params.progressive_refine) {
809     BL::Scene::view_layers_iterator b_view_layer;
810     for (b_scene.view_layers.begin(b_view_layer); b_view_layer != b_scene.view_layers.end();
811          ++b_view_layer) {
812       PointerRNA crl = RNA_pointer_get(&b_view_layer->ptr, "cycles");
813       if (get_boolean(crl, "use_denoising")) {
814         params.progressive_refine = false;
815       }
816     }
817   }
818
819   if (background) {
820     if (params.progressive_refine)
821       params.progressive = true;
822     else
823       params.progressive = false;
824
825     params.start_resolution = INT_MAX;
826     params.pixel_size = 1;
827   }
828   else
829     params.progressive = true;
830
831   /* shading system - scene level needs full refresh */
832   const bool shadingsystem = RNA_boolean_get(&cscene, "shading_system");
833
834   if (shadingsystem == 0)
835     params.shadingsystem = SHADINGSYSTEM_SVM;
836   else if (shadingsystem == 1)
837     params.shadingsystem = SHADINGSYSTEM_OSL;
838
839   /* color managagement */
840   params.display_buffer_linear = b_engine.support_display_space_shader(b_scene);
841
842   if (b_engine.is_preview()) {
843     /* For preview rendering we're using same timeout as
844      * blender's job update.
845      */
846     params.progressive_update_timeout = 0.1;
847   }
848
849   params.use_profiling = params.device.has_profiling && !b_engine.is_preview() && background &&
850                          BlenderSession::print_render_stats;
851
852   return params;
853 }
854
855 CCL_NAMESPACE_END