Blender V5.3
blender/session.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 <cstdlib>
6
8#include "DNA_screen_types.h"
9#include "DNA_space_types.h"
10#include "RNA_prototypes.hh"
11
12#include "device/device.h"
13
14#include "scene/background.h"
15#include "scene/bake.h"
16#include "scene/camera.h"
17#include "scene/film.h"
18#include "scene/integrator.h"
19#include "scene/light.h"
20#include "scene/mesh.h"
21#include "scene/object.h"
22#include "scene/scene.h"
23#include "scene/shader.h"
24#include "scene/stats.h"
25
26#include "session/buffers.h"
27#include "session/session.h"
28
29#include "util/hash.h"
30#include "util/log.h"
31#include "util/murmurhash.h"
32#include "util/path.h"
33#include "util/progress.h"
34#include "util/time.h"
35
38#include "blender/session.h"
39#include "blender/sync.h"
40#include "blender/util.h"
41
43
45bool BlenderSession::headless = false;
47
51 bool preview_osl)
52 : session(nullptr),
53 scene(nullptr),
54 sync(nullptr),
57 b_data(&b_data),
58 b_render(RE_engine_get_render_data(b_engine.re)),
59 b_depsgraph(nullptr),
60 b_scene(nullptr),
61 b_screen(nullptr),
62 b_v3d(nullptr),
63 b_rv3d(nullptr),
64 width(0),
65 height(0),
66 pixelsize(1.0f),
68 use_developer_ui(b_userpref.experimental.use_cycles_debug &&
69 (b_userpref.flag & blender::USER_DEVELOPER_UI) != 0)
70{
71 /* offline render */
72 background = true;
73 last_redraw_time = 0.0;
75 last_status_time = 0.0;
76}
77
84 const int width,
85 const int height)
86 : session(nullptr),
87 scene(nullptr),
88 sync(nullptr),
91 b_data(&b_data),
92 b_render(nullptr),
93 b_depsgraph(nullptr),
94 b_scene(nullptr),
96 b_v3d(b_v3d),
98 width(width),
101 preview_osl(false),
102 use_developer_ui(b_userpref.experimental.use_cycles_debug &&
103 (b_userpref.flag & blender::USER_DEVELOPER_UI) != 0)
104{
105 /* 3d view render */
106 background = false;
107 last_redraw_time = 0.0;
108 start_resize_time = 0.0;
109 last_status_time = 0.0;
110}
111
116
118{
119 const SessionParams session_params = BlenderSync::get_session_params(
121 const SceneParams scene_params = BlenderSync::get_scene_params(
123
124 /* reset status/progress */
125 last_status = "";
126 last_error = "";
127 last_progress = -1.0;
128 start_resize_time = 0.0;
129
130 /* create session */
131 session = make_unique<Session>(session_params, scene_params);
132 session->progress.set_update_callback([this] { tag_redraw(); });
133 session->progress.set_cancel_callback([this] { test_cancel(); });
134 session->set_pause(view_paused);
135
136 /* create scene */
137 scene = session->scene.get();
138 scene->name = BKE_id_name(b_scene->id);
139
140 /* create sync */
141 sync = make_unique<BlenderSync>(
143 if (b_v3d) {
144 sync->sync_view(b_depsgraph, b_v3d, b_rv3d, width, height);
145 }
146 else {
147 sync->sync_camera(*b_render, width, height, "");
148 }
149
150 /* set buffer parameters */
151 const BufferParams buffer_params = BlenderSync::get_buffer_params(
153 session->reset(session_params, buffer_params);
154
155 /* Viewport and preview (as in, material preview) does not do tiled rendering, so can inform
156 * engine that no tracking of the tiles state is needed.
157 * The offline rendering will make a decision when tile is being written. The penalty of asking
158 * the engine to keep track of tiles state is minimal, so there is nothing to worry about here
159 * about possible single-tiled final render. */
162 }
163}
164
166{
167 /* Update data, scene and depsgraph pointers. These can change after undo. */
168 this->b_data = &b_data;
169 this->b_depsgraph = &b_depsgraph;
170 this->b_scene = DEG_get_evaluated_scene(&b_depsgraph);
171 if (sync) {
172 sync->reset(*this->b_data, *this->b_scene);
173 }
174
175 if (preview_osl) {
176 blender::PointerRNA scene_rna_ptr = RNA_id_pointer_create(&b_scene->id);
177 blender::PointerRNA cscene = RNA_pointer_get(&scene_rna_ptr, "cycles");
178 RNA_boolean_set(&cscene, "shading_system", preview_osl);
179 }
180
181 if (b_v3d) {
182 this->b_render = &b_scene->r;
183 }
184 else {
185 this->b_render = RE_engine_get_render_data(b_engine.re);
186 width = render_resolution_x(*b_render);
187 height = render_resolution_y(*b_render);
188 }
189
190 const bool is_new_session = (session == nullptr);
191 if (is_new_session) {
192 /* Initialize session and remember it was just created so not to
193 * re-create it below.
194 */
196 }
197
198 if (b_v3d) {
199 /* NOTE: We need to create session, but all the code from below
200 * will make viewport render to stuck on initialization.
201 */
202 return;
203 }
204
205 const SessionParams session_params = BlenderSync::get_session_params(
207 const SceneParams scene_params = BlenderSync::get_scene_params(
209
210 if (scene->params.modified(scene_params) || session->params.modified(session_params) ||
211 (this->b_render->mode & blender::R_PERSISTENT_DATA) == 0)
212 {
213 /* if scene or session parameters changed, it's easier to simply re-create
214 * them rather than trying to distinguish which settings need to be updated
215 */
216 if (!is_new_session) {
217 free_session();
219 }
220 return;
221 }
222
223 session->progress.reset();
224
225 /* peak memory usage should show current render peak, not peak for all renders
226 * made by this render session
227 */
228 session->stats.mem_peak = session->stats.mem_used;
229
230 if (is_new_session) {
231 /* Sync object should be re-created for new scene. */
232 sync = make_unique<BlenderSync>(
234 }
235 else {
236 /* Sync recalculations to do just the required updates. */
237 sync->sync_recalc(b_depsgraph, b_screen, b_v3d, b_rv3d);
238 }
239
240 sync->sync_camera(*b_render, width, height, "");
241
242 const BufferParams buffer_params = BlenderSync::get_buffer_params(
243 nullptr, nullptr, scene->camera, width, height);
244 session->reset(session_params, buffer_params);
245
246 /* reset time */
247 start_resize_time = 0.0;
248
249 {
251 draw_state_.last_pass_index = -1;
252 }
253}
254
256{
257 if (session) {
258 session->cancel(true);
259 }
260
261 sync.reset();
262 session.reset();
263
264 display_driver_ = nullptr;
265}
266
267void BlenderSession::full_buffer_written(string_view filename)
268{
269 full_buffer_files_.emplace_back(filename);
270}
271
272static void add_cryptomatte_layer(blender::RenderResult &b_rr, string name, string manifest)
273{
274 const string identifier = string_printf("%08x",
275 util_murmur_hash3(name.c_str(), name.length(), 0));
276 const string prefix = "cryptomatte/" + identifier.substr(0, 7) + "/";
277
278 render_add_metadata(b_rr, prefix + "name", name);
279 render_add_metadata(b_rr, prefix + "hash", "MurmurHash3_32");
280 render_add_metadata(b_rr, prefix + "conversion", "uint32_to_float32");
281 render_add_metadata(b_rr, prefix + "manifest", manifest);
282}
283
284void BlenderSession::stamp_view_layer_metadata(Scene *scene, const string &view_layer_name)
285{
286 blender::RenderResult *b_rr = RE_engine_get_result(&b_engine);
287 const string prefix = "cycles." + view_layer_name + ".";
288
289 /* Configured number of samples for the view layer. */
290 BKE_render_result_stamp_data(
291 b_rr, (prefix + "samples").c_str(), to_string(session->params.samples).c_str());
292
293 /* Store ranged samples information. */
294 /* TODO(sergey): Need to bring this information back. */
295#if 0
296 if (session->tile_manager.range_num_samples != -1) {
297 b_rr.stamp_data_add_field((prefix + "range_start_sample").c_str(),
298 to_string(session->tile_manager.range_start_sample).c_str());
299 b_rr.stamp_data_add_field((prefix + "range_num_samples").c_str(),
300 to_string(session->tile_manager.range_num_samples).c_str());
301 }
302#endif
303
304 /* Write cryptomatte metadata. */
305 if (scene->film->get_cryptomatte_passes() & CRYPT_OBJECT) {
307 view_layer_name + ".CryptoObject",
308 scene->object_manager->get_cryptomatte_objects(scene));
309 }
310 if (scene->film->get_cryptomatte_passes() & CRYPT_MATERIAL) {
312 view_layer_name + ".CryptoMaterial",
313 scene->shader_manager->get_cryptomatte_materials(scene));
314 }
315 if (scene->film->get_cryptomatte_passes() & CRYPT_ASSET) {
317 view_layer_name + ".CryptoAsset",
318 scene->object_manager->get_cryptomatte_assets(scene));
319 }
320
321 /* Store synchronization and bare-render times. */
322 double total_time;
323 double render_time;
324 session->progress.get_time(total_time, render_time);
325 BKE_render_result_stamp_data(
326 b_rr, (prefix + "total_time").c_str(), time_human_readable_from_seconds(total_time).c_str());
327 BKE_render_result_stamp_data(b_rr,
328 (prefix + "render_time").c_str(),
329 time_human_readable_from_seconds(render_time).c_str());
330 BKE_render_result_stamp_data(b_rr,
331 (prefix + "synchronization_time").c_str(),
332 time_human_readable_from_seconds(total_time - render_time).c_str());
333}
334
335void BlenderSession::render(blender::Depsgraph &b_depsgraph_)
336{
337 b_depsgraph = &b_depsgraph_;
338
339 if (session->progress.get_cancel()) {
341 return;
342 }
343
344 /* Create driver to write out render results. */
346 session->set_output_driver(make_unique<BlenderOutputDriver>(b_engine));
347
348 session->full_buffer_written_cb = [&](string_view filename) { full_buffer_written(filename); };
349
350 blender::ViewLayer &b_view_layer = *DEG_get_evaluated_view_layer(b_depsgraph);
351
352 /* get buffer parameters */
353 const SessionParams session_params = BlenderSync::get_session_params(
357
358 /* temporary render result to find needed passes and views */
359 blender::RenderResult *b_rr = RE_engine_begin_result(
360 &b_engine, 0, 0, 1, 1, b_view_layer.name, nullptr);
361 blender::RenderLayer *b_rlay = b_rr->layers.first();
362
363 {
365 b_rlay_name = b_view_layer.name;
366
367 /* Signal that the display pass is to be updated. */
368 draw_state_.last_pass_index = -1;
369 }
370
371 /* Compute render passes and film settings. */
372 sync->sync_render_passes(*b_rlay, b_view_layer);
373
374 const int num_views = b_rr->views.count();
375
376 for (const auto [view_index, b_view] : b_rr->views.enumerate()) {
377 b_rview_name = b_view.name;
378
379 buffer_params.layer = b_view_layer.name;
380 buffer_params.view = b_rview_name;
381
382 /* set the current view */
383 RE_engine_active_view_set(&b_engine, b_rview_name.c_str());
384
385 /* Force update in this case, since the camera transform on each frame changes
386 * in different views. This could be optimized by somehow storing the animated
387 * camera transforms separate from the fixed stereo transform. */
388 if ((scene->need_motion() != Scene::MOTION_NONE) && view_index > 0) {
389 sync->tag_update();
390 }
391
392 /* update scene */
393 sync->sync_camera(*b_render, width, height, b_rview_name.c_str());
394 sync->sync_data(*b_render,
396 b_screen,
397 b_v3d,
398 b_rv3d,
399 width,
400 height,
401 session_params.denoise_device);
402
403 /* At the moment we only free if we are not doing multi-view
404 * (or if we are rendering the last view). See #58142/D4239 for discussion.
405 */
406 const bool can_free_cache = (view_index == num_views - 1);
407 if (can_free_cache) {
408 sync->free_data_after_sync(*b_depsgraph);
409 }
410
412
413 /* Attempt to free all data which is held by Blender side, since at this
414 * point we know that we've got everything to render current view layer.
415 */
416 if (can_free_cache) {
418 }
419
420 /* Make sure all views have different noise patterns. - hardcoded value just to make it
421 * random
422 */
423 if (view_index != 0) {
424 int seed = scene->integrator->get_seed();
425 seed += hash_uint2(seed, hash_uint2(view_index * 0xdeadbeef, 0));
426 scene->integrator->set_seed(seed);
427 }
428
429 /* Update number of samples per layer. */
430 const int samples = sync->get_layer_samples();
431 const bool bound_samples = sync->get_layer_bound_samples();
432
433 SessionParams effective_session_params = session_params;
434 if (samples != 0 && (!bound_samples || (samples < session_params.samples))) {
435 effective_session_params.samples = samples;
436 }
437
438 /* Update session itself. */
439 session->reset(effective_session_params, buffer_params);
440
441 /* render */
444 }
445
446 session->start();
447 session->wait();
448
450 RenderStats stats;
451 session->collect_statistics(&stats);
452 printf("Render statistics:\n%s\n", stats.full_report().c_str());
453 }
454
455 if (session->progress.get_cancel()) {
456 break;
457 }
458 }
459
460 /* add metadata */
462
463 /* free result without merging */
464 RE_engine_end_result(&b_engine, b_rr, true, false, false);
465
466 /* When tiled rendering is used there will be no "write" done for the tile. Forcefully clear
467 * highlighted tiles now, so that the highlight will be removed while processing full frame
468 * from file. */
469 RE_engine_tile_highlight_clear_all(&b_engine);
470
471 double total_time;
472 double render_time;
473 session->progress.get_time(total_time, render_time);
474 LOG_INFO << "Total render time: " << total_time;
475 LOG_INFO << "Render time (without synchronization): " << render_time;
476}
477
479{
480 /* Processing of all layers and views is done. Clear the strings so that we can communicate
481 * progress about reading files and denoising them. */
482 b_rlay_name = "";
483 b_rview_name = "";
484
486 /* Free the sync object so that it can properly dereference nodes from the scene graph before
487 * the graph is freed. */
488 sync.reset();
489
490 session->device_free();
491 }
492
493 for (const string_view filename : full_buffer_files_) {
494 session->process_full_buffer_from_disk(filename);
496 break;
497 }
498 }
499
500 for (const string_view filename : full_buffer_files_) {
501 path_remove(filename);
502 }
503
504 /* Clear output driver. */
505 session->set_output_driver(nullptr);
506 session->full_buffer_written_cb = nullptr;
507
508 /* The display driver is the source of drawing context for both drawing and possible graphics
509 * interoperability objects in the path trace. Once the frame is finished the OpenGL context
510 * might be freed form Blender side. Need to ensure that all GPU resources are freed prior to
511 * that point.
512 * Ideally would only do this when OpenGL context is actually destroyed, but there is no way to
513 * know when this happens (at least in the code at the time when this comment was written).
514 * The penalty of re-creating resources on every frame is unlikely to be noticed. */
515 display_driver_ = nullptr;
516 session->set_display_driver(nullptr);
517
518 /* All the files are handled.
519 * Clear the list so that this session can be re-used by Persistent Data. */
520 full_buffer_files_.clear();
521}
522
523static bool bake_setup_pass(Scene *scene, const string &bake_type, const int bake_filter)
524{
525 Integrator *integrator = scene->integrator;
526 Film *film = scene->film;
527
528 const bool filter_direct = (bake_filter & blender::R_BAKE_PASS_FILTER_DIRECT) != 0;
529 const bool filter_indirect = (bake_filter & blender::R_BAKE_PASS_FILTER_INDIRECT) != 0;
530 const bool filter_color = (bake_filter & blender::R_BAKE_PASS_FILTER_COLOR) != 0;
531
532 PassType type = PASS_NONE;
533 bool use_direct_light = false;
534 bool use_indirect_light = false;
535 bool include_albedo = false;
536
537 /* Data passes. */
538 if (bake_type == "POSITION") {
539 type = PASS_POSITION;
540 }
541 else if (bake_type == "NORMAL") {
542 type = PASS_NORMAL;
543 }
544 else if (bake_type == "UV") {
545 type = PASS_UV;
546 }
547 else if (bake_type == "ROUGHNESS") {
548 type = PASS_ROUGHNESS;
549 }
550 else if (bake_type == "EMIT") {
551 type = PASS_EMISSION;
552 }
553 /* Environment pass. */
554 else if (bake_type == "ENVIRONMENT") {
555 type = PASS_BACKGROUND;
556 }
557 /* AO pass. */
558 else if (bake_type == "AO") {
559 type = PASS_AO;
560 }
561 /* Shadow pass. */
562 else if (bake_type == "SHADOW") {
563 /* Bake as combined pass, together with marking the object as a shadow catcher. */
564 type = PASS_SHADOW_CATCHER;
565 film->set_use_approximate_shadow_catcher(true);
566
567 use_direct_light = true;
568 use_indirect_light = true;
569 include_albedo = true;
570
571 integrator->set_use_diffuse(true);
572 integrator->set_use_glossy(true);
573 integrator->set_use_transmission(true);
574 integrator->set_use_emission(true);
575 }
576 /* Combined pass. */
577 else if (bake_type == "COMBINED") {
578 type = PASS_COMBINED;
579 film->set_use_approximate_shadow_catcher(true);
580
581 use_direct_light = filter_direct;
582 use_indirect_light = filter_indirect;
583 include_albedo = filter_color;
584
585 integrator->set_use_diffuse((bake_filter & blender::R_BAKE_PASS_FILTER_DIFFUSE) != 0);
586 integrator->set_use_glossy((bake_filter & blender::R_BAKE_PASS_FILTER_GLOSSY) != 0);
587 integrator->set_use_transmission((bake_filter & blender::R_BAKE_PASS_FILTER_TRANSM) != 0);
588 integrator->set_use_emission((bake_filter & blender::R_BAKE_PASS_FILTER_EMIT) != 0);
589 }
590 /* Light component passes. */
591 else if ((bake_type == "DIFFUSE") || (bake_type == "GLOSSY") || (bake_type == "TRANSMISSION")) {
592 use_direct_light = filter_direct;
593 use_indirect_light = filter_indirect;
594 include_albedo = filter_color;
595
596 integrator->set_use_diffuse(bake_type == "DIFFUSE");
597 integrator->set_use_glossy(bake_type == "GLOSSY");
598 integrator->set_use_transmission(bake_type == "TRANSMISSION");
599
600 if (bake_type == "DIFFUSE") {
601 if (filter_direct && filter_indirect) {
602 type = PASS_DIFFUSE;
603 }
604 else if (filter_direct) {
605 type = PASS_DIFFUSE_DIRECT;
606 }
607 else if (filter_indirect) {
609 }
610 else {
611 type = PASS_DIFFUSE_COLOR;
612 }
613 }
614 else if (bake_type == "GLOSSY") {
615 if (filter_direct && filter_indirect) {
616 type = PASS_GLOSSY;
617 }
618 else if (filter_direct) {
619 type = PASS_GLOSSY_DIRECT;
620 }
621 else if (filter_indirect) {
623 }
624 else {
625 type = PASS_GLOSSY_COLOR;
626 }
627 }
628 else if (bake_type == "TRANSMISSION") {
629 if (filter_direct && filter_indirect) {
630 type = PASS_TRANSMISSION;
631 }
632 else if (filter_direct) {
634 }
635 else if (filter_indirect) {
637 }
638 else {
640 }
641 }
642 }
643
644 if (type == PASS_NONE) {
645 return false;
646 }
647
648 /* Create pass. */
649 Pass *pass = scene->create_node<Pass>();
650 pass->set_name(ustring("Combined"));
651 pass->set_type(type);
652 pass->set_include_albedo(include_albedo);
653
654 /* Disable direct indirect light for performance when not needed. */
655 integrator->set_use_direct_light(use_direct_light);
656 integrator->set_use_indirect_light(use_indirect_light);
657
658 /* Disable denoiser if the pass does not support it.
659 * For the passes which support denoising follow the user configuration. */
660 const PassInfo pass_info = Pass::get_info(type);
661 if (integrator->get_use_denoise() && !pass_info.support_denoise) {
662 integrator->set_use_denoise(false);
663 }
664
665 return true;
666}
667
668void BlenderSession::bake(blender::Depsgraph &b_depsgraph_,
669 blender::Object &b_object,
670 const string &bake_type,
671 const int bake_filter,
672 const int bake_width,
673 const int bake_height)
674{
675 b_depsgraph = &b_depsgraph_;
676
677 /* Get session parameters. */
678 const SessionParams session_params = BlenderSync::get_session_params(
680
681 /* Initialize bake manager, before we load the baking kernels. */
682 scene->bake_manager->set_baking(scene, true);
683
684 session->set_display_driver(nullptr);
685 session->set_output_driver(make_unique<BlenderOutputDriver>(b_engine));
686 session->full_buffer_written_cb = [&](string_view filename) { full_buffer_written(filename); };
687
688 /* Sync scene. */
689 sync->set_bake_target(b_object);
690 sync->sync_camera(*b_render, width, height, "");
691 sync->sync_data(*b_render,
693 b_screen,
694 b_v3d,
695 b_rv3d,
696 width,
697 height,
698 session_params.denoise_device);
699
700 /* Save the current state of the denoiser, as it might be disabled by the pass configuration
701 * (for passed which do not support denoising). */
702 Integrator *integrator = scene->integrator;
703 const bool was_denoiser_enabled = integrator->get_use_denoise();
704
705 /* Add render pass that we want to bake, and name it Combined so that it is
706 * used as that on the Blender side. */
707 if (!bake_setup_pass(scene, bake_type, bake_filter)) {
708 session->cancel(true);
709 }
710
711 /* Always use transparent background for baking. */
712 scene->background->set_transparent(true);
713
714 if (!session->progress.get_cancel()) {
715 /* Load built-in images from Blender. */
717 }
718
719 /* Object might have been disabled for rendering or excluded in some
720 * other way, in that case Blender will report a warning afterwards. */
721 Object *bake_object = nullptr;
722 if (!session->progress.get_cancel()) {
723 for (Object *ob : scene->objects) {
724 if (ob->get_is_bake_target()) {
725 bake_object = ob;
726 break;
727 }
728 }
729 }
730
731 /* For the shadow pass, temporarily mark the object as a shadow catcher. */
732 const bool was_shadow_catcher = (bake_object) ? bake_object->get_is_shadow_catcher() : false;
733 if (bake_object && bake_type == "SHADOW") {
734 bake_object->set_is_shadow_catcher(true);
735 }
736
737 if (bake_object && !session->progress.get_cancel()) {
738 /* Get buffer parameters. */
739 BufferParams buffer_params;
740 buffer_params.width = bake_width;
741 buffer_params.height = bake_height;
742 buffer_params.window_width = bake_width;
743 buffer_params.window_height = bake_height;
744 /* Unique layer name for multi-image baking. */
745 buffer_params.layer = string_printf("bake_%d\n", bake_id++);
746
747 /* Update session. */
748 session->reset(session_params, buffer_params);
749
750 session->progress.set_update_callback([this] { update_bake_progress(); });
751 }
752
753 /* Perform bake. Check cancel to avoid crash with incomplete scene data. */
754 if (bake_object && !session->progress.get_cancel()) {
755 session->start();
756 session->wait();
757 }
758
759 /* Restore object state. */
760 if (bake_object) {
761 bake_object->set_is_shadow_catcher(was_shadow_catcher);
762 }
763
764 /* Restore the state of denoiser to before it was possibly disabled by the pass, so that the
765 * next baking pass can use the original value. */
766 integrator->set_use_denoise(was_denoiser_enabled);
767}
768
769void BlenderSession::synchronize(blender::Depsgraph &b_depsgraph_)
770{
771 /* only used for viewport render */
772 if (!b_v3d) {
773 return;
774 }
775
776 /* on session/scene parameter changes, we recreate session entirely */
777 const SessionParams session_params = BlenderSync::get_session_params(
779 const SceneParams scene_params = BlenderSync::get_scene_params(
781
782 if (session->params.modified(session_params) || scene->params.modified(scene_params)) {
783 free_session();
785 }
786
788
789 /* increase samples and render time, but never decrease */
790 session->set_samples(session_params.samples);
791 session->set_time_limit(session_params.time_limit);
792
793 /* copy recalc flags, outside of mutex so we can decide to do the real
794 * synchronization at a later time to not block on running updates */
795 sync->sync_recalc(b_depsgraph_, b_screen, b_v3d, b_rv3d);
796
797 /* don't do synchronization if on pause */
798 if (view_paused) {
799 tag_update();
800 return;
801 }
802
803 /* try to acquire mutex. if we don't want to or can't, come back later */
804 if (!session->ready_to_reset() || !session->scene->mutex.try_lock()) {
805 tag_update();
806 return;
807 }
808
809 /* data and camera synchronize */
810 b_depsgraph = &b_depsgraph_;
811
812 sync->sync_data(*b_render,
814 b_screen,
815 b_v3d,
816 b_rv3d,
817 width,
818 height,
819 session_params.denoise_device);
820
821 if (b_rv3d) {
822 sync->sync_view(b_depsgraph, b_v3d, b_rv3d, width, height);
823 }
824 else {
825 sync->sync_camera(*b_render, width, height, "");
826 }
827
828 /* get buffer parameters */
829 const BufferParams buffer_params = BlenderSync::get_buffer_params(
831
832 /* reset if needed */
833 if (scene->need_reset()) {
834 session->reset(session_params, buffer_params);
835
836 /* After session reset, so device is not accessing image data anymore. */
838
839 /* reset time */
840 start_resize_time = 0.0;
841 }
842
843 /* unlock */
844 session->scene->mutex.unlock();
845
846 /* Start rendering thread, if it's not running already. Do this
847 * after all scene data has been synced at least once. */
848 session->start();
849}
850
852{
853 if (!session || !session->scene) {
854 /* Offline render drawing does not force the render engine update, which means it's possible
855 * that the Session is not created yet. */
856 return;
857 }
858
860
861 const int pass_index = space_image.iuser.pass;
862 if (pass_index != draw_state_.last_pass_index) {
863 blender::RenderPass *b_display_pass = RE_engine_pass_by_index_get(
864 &b_engine, b_rlay_name.c_str(), pass_index);
865 if (!b_display_pass) {
866 /* Fall back to displaying the first pass, like image editor drawing does too. */
867 b_display_pass = RE_engine_pass_by_index_get(&b_engine, b_rlay_name.c_str(), 0);
868 }
869 if (!b_display_pass) {
870 return;
871 }
872
873 Scene *scene = session->scene.get();
874
875 /* Only try to lock, so the user interface stays responsive while
876 * the session thread holds the mutex. */
877 const thread_scoped_lock lock(scene->mutex, std::try_to_lock);
878 if (!lock) {
879 return;
880 }
881
882 const Pass *pass = Pass::find(scene->passes, b_display_pass->name);
883 if (!pass) {
884 return;
885 }
886
887 scene->film->set_display_pass(pass->get_type());
888
889 draw_state_.last_pass_index = pass_index;
890 }
891
892 if (display_driver_) {
893 blender::PointerRNA space_image_rna_ptr = RNA_pointer_create_id_subdata(
894 b_screen.id, blender::RNA_SpaceImageEditor, &space_image);
895 float zoom[2];
896 RNA_float_get_array(&space_image_rna_ptr, "zoom", zoom);
897 display_driver_->set_zoom(zoom[0], zoom[1]);
898 }
899
900 session->draw();
901}
902
903void BlenderSession::view_pause(const bool pause)
904{
905 view_paused = pause;
906 session->set_pause(pause);
907}
908
909void BlenderSession::view_draw(const int w, const int h)
910{
911 /* Update navigating state. */
912 const bool dimensions_changed = (width != w || height != h || pixelsize != blender::U.pixelsize);
913 const bool is_navigating = region_view3d_navigating_or_transforming(b_rv3d) ||
914 dimensions_changed;
915 session->set_navigating(is_navigating);
916
917 /* before drawing, we verify camera and viewport size changes, because
918 * we do not get update callbacks for those, we must detect them here */
919 if (session->ready_to_reset()) {
920 bool reset = false;
921
922 /* If dimensions changed, reset. We need to check pixel size here because
923 * it's only valid during drawing, as it can change per window. */
924 if (dimensions_changed) {
925 if (start_resize_time == 0.0) {
926 /* don't react immediately to resizes to avoid flickery resizing
927 * of the viewport, and some window managers changing the window
928 * size temporarily on unminimize */
930 tag_redraw();
931 }
932 else if (time_dt() - start_resize_time < 0.2) {
933 tag_redraw();
934 }
935 else {
936 width = w;
937 height = h;
939 reset = true;
940 }
941 }
942
943 /* try to acquire mutex. if we can't, come back later */
944 if (!session->scene->mutex.try_lock()) {
945 tag_update();
946 }
947 else {
948 /* update camera from 3d view */
949
950 sync->sync_view(b_depsgraph, b_v3d, b_rv3d, width, height);
951
952 if (scene->camera->is_modified()) {
953 reset = true;
954 }
955
956 session->scene->mutex.unlock();
957 }
958
959 /* reset if requested */
960 if (reset) {
961 const SessionParams session_params = BlenderSync::get_session_params(
963 const BufferParams buffer_params = BlenderSync::get_buffer_params(
965 if (view_paused == false) {
966 session->reset(session_params, buffer_params);
967 start_resize_time = 0.0;
968 }
969 }
970 }
971 else {
972 tag_update();
973 }
974
975 /* update status and progress for 3d view draw */
977
978 /* draw */
979 session->draw();
980}
981
982void BlenderSession::get_status(string &status, string &substatus)
983{
984 session->progress.get_status(status, substatus);
985}
986
987void BlenderSession::get_progress(double &progress, double &total_time, double &render_time)
988{
989 session->progress.get_time(total_time, render_time);
990 progress = session->progress.get_progress();
991}
992
994{
995 const double progress = session->progress.get_progress();
996
997 if (progress != last_progress) {
998 RE_engine_update_progress(&b_engine, (float)progress);
999 last_progress = progress;
1000 }
1001}
1002
1004{
1005 string timestatus;
1006 string status;
1007 string substatus;
1008 get_status(status, substatus);
1009 if (background && !substatus.empty()) {
1010 status += " | " + substatus;
1011 }
1012
1013 double progress;
1014 double total_time;
1015 double render_time;
1016 get_progress(progress, total_time, render_time);
1017
1018 const float mem_used = (float)session->stats.mem_used / 1024.0f / 1024.0f;
1019 const float mem_peak = (float)session->stats.mem_peak / 1024.0f / 1024.0f;
1020 if (background) {
1021
1022 if (progress > 0) {
1023 const double remaining_time = session->get_estimated_remaining_time();
1024 if (remaining_time > 0) {
1025 timestatus = "Remaining: " + time_human_readable_from_seconds(remaining_time) + " | ";
1026 }
1027 }
1028
1029 timestatus += string_printf("Mem: %dM | ", (int)ceilf(mem_used));
1030 }
1031
1032 const double current_time = time_dt();
1033 /* When rendering in a window, redraw the status at least once per second to keep things
1034 * up to date. For headless rendering, only report when something significant changes to
1035 * keep the console output readable. */
1036 if (status != last_status || (!headless && (current_time - last_status_time) > 1.0)) {
1037 RE_engine_update_stats(&b_engine, "", (timestatus + status).c_str());
1038 RE_engine_update_memory_stats(&b_engine, mem_used, mem_peak);
1039 last_status = status;
1040 last_status_time = current_time;
1041 }
1042 if (progress != last_progress) {
1043 RE_engine_update_progress(&b_engine, (float)progress);
1044 last_progress = progress;
1045 }
1046
1048}
1049
1051{
1052 if (!session->progress.get_error()) {
1053 return false;
1054 }
1055
1056 const string error = session->progress.get_error_message();
1057 if (error != last_error) {
1058 /* TODO(sergey): Currently C++ RNA API doesn't let us to use mnemonic name for the variable.
1059 * Would be nice to have this figured out.
1060 *
1061 * For until then, 1 << 5 means RPT_ERROR. */
1062 RE_engine_report(&b_engine, 1 << 5, error.c_str());
1063 RE_engine_set_error_message(&b_engine, error.c_str());
1064 last_error = error;
1065 }
1066
1067 return true;
1068}
1069
1071{
1072 /* tell blender that we want to get another update callback */
1074}
1075
1077{
1078 if (background) {
1079 /* update stats and progress, only for background here because
1080 * in 3d view we do it in draw for thread safety reasons */
1082
1083 /* offline render, redraw if timeout passed */
1084 if (time_dt() - last_redraw_time > 1.0) {
1087 }
1088 }
1089 else {
1090 /* tell blender that we want to redraw */
1092 }
1093}
1094
1096{
1097 /* test if we need to cancel rendering */
1098 if (background) {
1099 if (RE_engine_test_break(&b_engine)) {
1100 session->progress.set_cancel("Cancelled");
1101 }
1102 }
1103}
1104
1106{
1107 if (!background) {
1108 /* During interactive render we can not free anything: attempts to save
1109 * memory would cause things to be allocated and evaluated for every
1110 * updated sample.
1111 */
1112 return;
1113 }
1114 RE_engine_free_blender_memory(&b_engine);
1115}
1116
1118{
1119 if (display_driver_) {
1120 /* Driver is already created. */
1121 return;
1122 }
1123
1124 if (headless) {
1125 /* No display needed for headless. */
1126 return;
1127 }
1128
1130 /* TODO(sergey): Investigate whether DisplayDriver can be used for the preview as well. */
1131 return;
1132 }
1133
1134 unique_ptr<BlenderDisplayDriver> display_driver = make_unique<BlenderDisplayDriver>(
1136 display_driver_ = display_driver.get();
1137 session->set_display_driver(std::move(display_driver));
1138}
1139
volatile int lock
static void add_cryptomatte_layer(blender::RenderResult &b_rr, string name, string manifest)
static bool bake_setup_pass(Scene *scene, const string &bake_type, const int bake_filter)
#define U
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
void reset()
void set_zoom(const float zoom_x, const float zoom_y)
void stamp_view_layer_metadata(Scene *scene, const string &view_layer_name)
static bool headless
blender::RenderData * b_render
static bool print_render_stats
blender::UserDef & b_userpref
bool check_and_report_session_error()
void full_buffer_written(string_view filename)
void draw(blender::bScreen &b_screen, blender::SpaceImage &space_image)
blender::RegionView3D * b_rv3d
vector< string > full_buffer_files_
blender::Depsgraph * b_depsgraph
void ensure_display_driver_if_needed()
blender::Scene * b_scene
void synchronize(blender::Depsgraph &b_depsgraph)
blender::Main * b_data
void view_pause(const bool pause)
void render(blender::Depsgraph &b_depsgraph)
void free_blender_memory_if_possible()
void bake(blender::Depsgraph &b_depsgraph_, blender::Object &b_object, const string &bake_type, const int bake_filter, const int bake_width, const int bake_height)
blender::View3D * b_v3d
void reset_session(blender::Main &b_data, blender::Depsgraph &b_depsgraph)
BlenderDisplayDriver * display_driver_
unique_ptr< BlenderSync > sync
blender::RenderEngine & b_engine
struct BlenderSession::@017120010147135111060124053166052341311215141251 draw_state_
void view_draw(const int w, const int h)
unique_ptr< Session > session
blender::bScreen * b_screen
BlenderSession(blender::RenderEngine &b_engine, blender::UserDef &b_userpref, blender::Main &b_data, bool preview_osl)
void get_status(string &status, string &substatus)
void get_progress(double &progress, double &total_time, double &render_time)
static DeviceTypeMask device_override
static SessionParams get_session_params(blender::RenderEngine &b_engine, blender::UserDef &b_preferences, blender::Scene &b_scene, bool background, float pixelsize)
Definition sync.cpp:1035
static BufferParams get_buffer_params(blender::View3D *b_v3d, blender::RegionView3D *b_rv3d, Camera *cam, const int width, const int height)
static SceneParams get_scene_params(blender::UserDef &b_preferences, blender::Main &b_data, blender::Scene &b_scene, const bool background, const bool use_developer_ui)
Definition sync.cpp:968
ustring view
Definition buffers.h:97
ustring layer
Definition buffers.h:96
int window_height
Definition buffers.h:80
int window_width
Definition buffers.h:79
NODE_DECLARE int width
Definition buffers.h:70
Definition film.h:29
Definition pass.h:50
static const Pass * find(const unique_ptr_vector< Pass > &passes, const string &name)
Definition pass.cpp:417
PassInfo get_info() const
Definition pass.cpp:150
string full_report()
Definition stats.cpp:394
bool modified(const SceneParams &params) const
Definition scene.h:109
Definition scene.h:133
Film * film
Definition scene.h:147
string name
Definition scene.h:136
unique_ptr< ObjectManager > object_manager
Definition scene.h:171
MotionType need_motion() const
Definition scene.cpp:429
SceneParams params
Definition scene.h:190
void enable_update_stats()
Definition scene.cpp:534
T * create_node(Args &&...)=delete
unique_ptr< BakeManager > bake_manager
Definition scene.h:173
Background * background
Definition scene.h:148
@ MOTION_NONE
Definition scene.h:207
unique_ptr< ShaderManager > shader_manager
Definition scene.h:169
Camera * camera
Definition scene.h:145
unique_ptr_vector< Object > objects
Definition scene.h:162
Integrator * integrator
Definition scene.h:149
thread_mutex mutex
Definition scene.h:193
bool need_reset(const bool check_camera=true)
Definition scene.cpp:497
unique_ptr_vector< Pass > passes
Definition scene.h:159
DeviceInfo denoise_device
constexpr const char * c_str() const
#define printf
#define CCL_NAMESPACE_END
DeviceTypeMask
@ DEVICE_MASK_ALL
uint hash_uint2(uint kx, uint ky)
@ CRYPT_ASSET
@ CRYPT_OBJECT
@ CRYPT_MATERIAL
PassType
@ PASS_EMISSION
@ PASS_POSITION
@ PASS_BACKGROUND
@ PASS_TRANSMISSION_DIRECT
@ PASS_UV
@ PASS_TRANSMISSION_COLOR
@ PASS_TRANSMISSION_INDIRECT
@ PASS_SHADOW_CATCHER
@ PASS_ROUGHNESS
@ PASS_DIFFUSE_DIRECT
@ PASS_AO
@ PASS_COMBINED
@ PASS_DIFFUSE
@ PASS_DIFFUSE_INDIRECT
@ PASS_GLOSSY
@ PASS_NONE
@ PASS_TRANSMISSION
@ PASS_NORMAL
@ PASS_DIFFUSE_COLOR
@ PASS_GLOSSY_DIRECT
@ PASS_GLOSSY_COLOR
@ PASS_GLOSSY_INDIRECT
#define LOG_INFO
Definition log.h:106
uint32_t util_murmur_hash3(const void *key, const int len, const uint32_t seed)
BMesh Iterators.
UserDef U
Definition blender.cc:58
@ R_BAKE_PASS_FILTER_TRANSM
@ R_BAKE_PASS_FILTER_INDIRECT
@ R_BAKE_PASS_FILTER_DIFFUSE
@ R_BAKE_PASS_FILTER_EMIT
@ R_BAKE_PASS_FILTER_COLOR
@ R_BAKE_PASS_FILTER_GLOSSY
@ R_BAKE_PASS_FILTER_DIRECT
@ RE_ENGINE_DO_DRAW
Definition RE_engine.h:65
@ RE_ENGINE_HIGHLIGHT_TILES
Definition RE_engine.h:68
@ RE_ENGINE_DO_UPDATE
Definition RE_engine.h:66
@ RE_ENGINE_PREVIEW
Definition RE_engine.h:64
bool path_remove(const string &path)
Definition path.cpp:827
#define ceilf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
string to_string(const char *str)
Definition string.cpp:202
CCL_NAMESPACE_BEGIN string string_printf(const char *format,...)
Definition string.cpp:25
bool is_modified() const
bool support_denoise
Definition pass.h:47
struct Render * re
Definition RE_engine.h:148
ListBaseT< RenderView > views
ListBaseT< RenderLayer > layers
struct RenderData r
struct ImageUser iuser
std::unique_lock< std::mutex > thread_scoped_lock
Definition thread.h:28
string time_human_readable_from_seconds(const double seconds)
Definition time.cpp:129
CCL_NAMESPACE_BEGIN double time_dt()
Definition time.cpp:31