Blender V5.3
source/blender/render/intern/pipeline.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2006 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <fmt/format.h>
10
11#include <cerrno>
12#include <cstddef>
13#include <cstdlib>
14#include <cstring>
15#include <forward_list>
16#include <memory>
17
18#include "DNA_anim_types.h"
19#include "DNA_defs.h"
20#include "DNA_image_types.h"
21#include "DNA_node_types.h"
22#include "DNA_object_types.h"
23#include "DNA_scene_types.h"
24#include "DNA_sequence_types.h"
25#include "DNA_space_types.h"
27
28#include "MEM_guardedalloc.h"
29
30#include "BLI_fileops.hh"
31#include "BLI_listbase.hh"
32#include "BLI_map.hh"
33#include "BLI_mutex.hh"
34#include "BLI_rect.hh"
35#include "BLI_string_utf8.hh"
36#include "BLI_threads.hh"
37#include "BLI_time.hh"
38#include "BLI_timecode.hh"
39#include "BLI_vector.hh"
40#include "BLI_vector_set.hh"
41
42#include "BLT_translation.hh"
43
44#include "BKE_anim_data.hh"
45#include "BKE_animsys.hh" /* <------ should this be here?, needed for sequencer update */
46#include "BKE_callbacks.hh"
47#include "BKE_camera.h"
48#include "BKE_colortools.hh"
49#include "BKE_compositor.hh"
50#include "BKE_global.hh"
51#include "BKE_image.hh"
52#include "BKE_image_format.hh"
53#include "BKE_image_save.hh"
54#include "BKE_layer.hh"
55#include "BKE_main.hh"
57#include "BKE_node_runtime.hh"
58#include "BKE_pointcache.h"
59#include "BKE_report.hh"
60#include "BKE_scene.hh"
61#include "BKE_sound.hh"
62
63#include "NOD_composite.hh"
64
66#include "COM_render_context.hh"
67
68#include "DEG_depsgraph.hh"
72
74#include "IMB_imbuf.hh"
75#include "IMB_imbuf_types.hh"
76#include "IMB_metadata.hh"
77#include "IMB_partial_update.hh"
78
79#include "MOV_write.hh"
80
81#include "RE_compositor.hh"
82#include "RE_engine.h"
83#include "RE_pipeline.h"
84
85#include "SEQ_relations.hh"
86#include "SEQ_render.hh"
87
88#include "GPU_capabilities.hh"
89#include "GPU_context.hh"
90#include "WM_api.hh"
91
92#ifdef WITH_FREESTYLE
93# include "FRS_freestyle.h"
94#endif
95
96/* internal */
97#include "pipeline.hh"
98#include "render_result.h"
99#include "render_types.h"
100
101#include "CLG_log.h"
102
103namespace blender {
104
105static CLG_LogRef LOG = {"render"};
106
107namespace path_templates = bke::path_templates;
108
109/* render flow
110 *
111 * 1) Initialize state
112 * - state data, tables
113 * - movie/image file init
114 * - everything that doesn't change during animation
115 *
116 * 2) Initialize data
117 * - camera, world, matrices
118 * - make render verts, faces, halos, strands
119 * - everything can change per frame/field
120 *
121 * 3) Render Processor
122 * - multiple layers
123 * - tiles, rect, baking
124 * - layers/tiles optionally to disk or directly in Render Result
125 *
126 * 4) Composite Render Result
127 * - also read external files etc
128 *
129 * 5) Image Files
130 * - save file or append in movie
131 */
132
133/* -------------------------------------------------------------------- */
136
137/* here we store all renders */
138static struct {
139 std::forward_list<Render *> render_list;
149
151
152/* -------------------------------------------------------------------- */
155
156static void render_callback_exec_string(Render *re, Main *bmain, eCbEvent evt, const char *str)
157{
158 if (re->r.scemode & R_BUTS_PREVIEW) {
159 return;
160 }
161 BKE_callback_exec_string(bmain, str, evt);
162}
163
164static void render_callback_exec_id(Render *re, Main *bmain, ID *id, eCbEvent evt)
165{
166 if (re->r.scemode & R_BUTS_PREVIEW) {
167 return;
168 }
169 BKE_callback_exec_id(bmain, id, evt);
170}
171
173
174/* -------------------------------------------------------------------- */
177
178static bool do_write_image_or_movie(Render *re,
179 Main *bmain,
180 Scene *scene,
181 const int totvideos,
182 const char *filepath_override,
183 const bool write_anim_or_still);
184
185/* default callbacks, set in each new render */
186static void result_rcti_nothing(void * /*arg*/, RenderResult * /*rr*/) {}
187static void current_scene_nothing(void * /*arg*/, Scene * /*scene*/) {}
188static void float_nothing(void * /*arg*/, float /*val*/) {}
189static bool default_break(void * /*arg*/)
190{
191 return G.is_break == true;
192}
193
194static void stats_update(void *arg, RenderStats *rs)
195{
196 if (rs->infostr == nullptr) {
197 return;
198 }
199
200 Render *re = static_cast<Render *>(arg);
201
202 /* Compositor calls this from multiple threads, mutex lock to ensure we don't
203 * get garbled output. */
204 static Mutex mutex;
205 std::scoped_lock lock(mutex);
206
207 /* Only print render process to stdout when blender is running headless, because the same
208 * progress string will be displayed on the UI. */
209 const bool show_info = G.background && CLOG_CHECK(&LOG, CLG_LEVEL_INFO);
210 if (show_info) {
211 CLOG_INFO(&LOG, "Fra: %d | %s", rs->cfra, rs->infostr);
212 /* Flush stdout to be sure python callbacks are printing stuff after blender. */
213 fflush(stdout);
214 }
215
216 /* NOTE: using G_MAIN seems valid here???
217 * Not sure it's actually even used anyway, we could as well pass nullptr? */
219
220 if (show_info) {
221 fflush(stdout);
222 }
223}
224
226{
227 /* There is no need to lock as the user-counted render results are protected by mutex at the
228 * higher call stack level. */
229 ++rr->user_counter;
230}
231
236
237ImBuf *RE_RenderLayerGetPassImBuf(RenderLayer *rl, const char *name, const char *viewname)
238{
239 RenderPass *rpass = RE_pass_find_by_name(rl, name, viewname);
240 return rpass ? rpass->ibuf : nullptr;
241}
242
243float *RE_RenderLayerGetPass(RenderLayer *rl, const char *name, const char *viewname)
244{
245 ImBuf *ibuf = RE_RenderLayerGetPassImBuf(rl, name, viewname);
246 return ibuf ? ibuf->float_data_for_write() : nullptr;
247}
248
250{
251 if (rr == nullptr) {
252 return nullptr;
253 }
254
255 return static_cast<RenderLayer *>(
256 BLI_findstring(&rr->layers, name, offsetof(RenderLayer, name)));
257}
258
260{
261 return (re->r.scemode & R_SINGLE_LAYER);
262}
263
265 ExrReadHandle *exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
266{
267 return render_result_new_from_exr(exrhandle, colorspace, predivide, rectx, recty);
268}
269
271{
272 if (re->single_view_layer[0]) {
274
275 if (rl) {
276 return rl;
277 }
278 }
279
280 return rr->layers.first();
281}
282
283static bool render_scene_has_layers_to_render(Scene *scene, ViewLayer *single_layer)
284{
285 if (single_layer) {
286 return true;
287 }
288
289 for (ViewLayer &view_layer : scene->view_layers) {
290 if (view_layer.flag & VIEW_LAYER_RENDER) {
291 return true;
292 }
293 }
294 return false;
295}
296
298
299/* -------------------------------------------------------------------- */
302
303Render *RE_GetRender(const void *owner)
304{
305 /* search for existing renders */
306 for (Render *re : RenderGlobal.render_list) {
307 if (re->owner == owner) {
308 return re;
309 }
310 }
311
312 return nullptr;
313}
314
316{
317 if (re) {
319 return re->result;
320 }
321
322 return nullptr;
323}
324
326{
327 if (re) {
330 return re->result;
331 }
332
333 return nullptr;
334}
335
337{
338 if (re) {
340 re->result = nullptr;
342 }
343}
344
346{
347 /* for keeping render buffers */
348 if (re) {
349 std::swap(re->result, *rr);
350 }
351}
352
354{
355 if (re) {
357 }
358}
359
361{
362 if (re) {
363 return re->scene;
364 }
365 return nullptr;
366}
367
368void RE_SetScene(Render *re, Scene *sce)
369{
370 if (re) {
371 re->scene = sce;
372 }
373}
374
376{
377 *rr = RenderResult();
378
379 if (re) {
381
382 if (re->result) {
383 rr->rectx = re->result->rectx;
384 rr->recty = re->result->recty;
385
386 copy_v2_v2_db(rr->ppm, re->result->ppm);
387
388 /* creates a temporary duplication of views */
390
391 RenderView *rv = rr->views.first();
392 rr->have_combined = (rv->ibuf != nullptr);
393
394 /* single layer */
396
397 /* The render result uses shallow initialization, and the caller is not expected to
398 * explicitly free it. So simply assign the buffers as a shallow copy here as well. */
399
400 if (rl) {
401 if (rv->ibuf == nullptr) {
402 for (RenderView &rview : rr->views) {
404 }
405 }
406 }
407
408 rr->layers = re->result->layers;
409 rr->stamp_data = re->result->stamp_data;
410 }
411 }
412}
413
415{
416 if (re) {
417 if (rr) {
419 }
421 }
422}
423
424void RE_AcquireResultImage(Render *re, RenderResult *rr, const int view_id)
425{
426 *rr = RenderResult();
427
428 if (re) {
430
431 if (re->result) {
432 RenderLayer *rl;
433 RenderView *rv;
434
435 rr->rectx = re->result->rectx;
436 rr->recty = re->result->recty;
437
438 copy_v2_v2_db(rr->ppm, re->result->ppm);
439
440 /* `scene.rd.actview` view. */
441 rv = RE_RenderViewGetById(re->result, view_id);
442 rr->have_combined = (rv->ibuf != nullptr);
443
444 /* The render result uses shallow initialization, and the caller is not expected to
445 * explicitly free it. So simply assign the buffers as a shallow copy here as well.
446 *
447 * The thread safety is ensured via the `re->resultmutex`. */
448 rr->ibuf = rv->ibuf;
449
450 /* active layer */
451 rl = render_get_single_layer(re, re->result);
452
453 if (rl) {
454 if (rv->ibuf == nullptr) {
456 }
457 }
458
459 rr->layers = re->result->layers;
460 rr->views = re->result->views;
461 rr->stamp_data = re->result->stamp_data;
462 }
463 }
464}
465
467{
468 if (re) {
470 }
471}
472
474{
475 RenderResult rres;
476 const int view_id = BKE_scene_multiview_view_id_get(&re->r, re->viewname);
477
480 dst,
481 re->rectx,
482 re->recty,
483 &re->scene->view_settings,
485 view_id);
487}
488
490{
491 RenderView *view = rr->views.first();
492 return (view && (view->next || view->name[0]));
493}
494
496{
497 return &re->i;
498}
499
500Render *RE_NewRender(const void *owner)
501{
502 Render *re;
503
504 /* only one render per name exists */
505 re = RE_GetRender(owner);
506 if (re == nullptr) {
507
508 /* new render data struct */
509 re = MEM_new<Render>("new render");
510 RenderGlobal.render_list.push_front(re);
511 re->owner = owner;
512 }
513
514 RE_display_init(re);
515
516 return re;
517}
518
520{
521 ViewRender *view_render = MEM_new<ViewRender>("new view render");
522 view_render->engine = RE_engine_create(engine_type);
523 return view_render;
524}
525
527{
528 return RE_GetRender(DEG_get_original_id(&scene->id));
529}
530
532{
533 return RE_NewRender(DEG_get_original_id(&scene->id));
534}
535
537{
538 const void *owner = DEG_get_original_id(&scene->id);
539
540 return RenderGlobal.interactive_compositor_renders.lookup_or_add_cb(owner, [&]() {
541 Render *render = MEM_new<Render>("New Interactive Compositor Render");
542 render->owner = owner;
543 return render;
544 });
545}
546
548{
549 RenderGlobal.render_list.remove(re);
550
551 MEM_delete(re);
552}
553
555{
556 MEM_delete(view_render);
557}
558
560{
561 while (!RenderGlobal.render_list.empty()) {
562 RE_FreeRender(static_cast<Render *>(RenderGlobal.render_list.front()));
563 }
564
566
567#ifdef WITH_FREESTYLE
568 /* finalize Freestyle */
569 FRS_exit();
570#endif
571}
572
574{
575 for (Render *render : RenderGlobal.interactive_compositor_renders.values()) {
577 }
578 RenderGlobal.interactive_compositor_renders.clear();
579}
580
582{
583 for (Render *re : RenderGlobal.render_list) {
586
587 re->result = nullptr;
588 re->pushedresult = nullptr;
590 }
591}
592
594{
595 for (Render *re : RenderGlobal.render_list) {
596 if (re->engine != nullptr) {
599 re->engine = nullptr;
600 }
601 }
602}
603
605{
606 /* Free persistent compositor that may be using these textures. */
607 if (re->compositor) {
609 }
610
611 /* Free textures. */
614 if (result != nullptr) {
616 }
619 }
620}
621
623{
624 for (Render *re : RenderGlobal.render_list) {
626 }
627}
628
630{
632
633 wmWindowManager *wm = G_MAIN->wm.first();
634
635 for (Render *re : RenderGlobal.render_list) {
636 bool do_free = true;
637
638 /* Don't free scenes being rendered or composited. Note there is no
639 * race condition here because we are on the main thread and new jobs can only
640 * be started from the main thread. */
644 {
645 do_free = false;
646 }
647
648 for (const wmWindow &win : wm->windows) {
649 if (!do_free) {
650 /* No need to do further checks. */
651 break;
652 }
653
654 const Scene *scene = WM_window_get_active_scene(&win);
655 if (scene != re->owner) {
656 continue;
657 }
658
659 /* Detect if scene is using GPU compositing, and if either a node editor is
660 * showing the nodes, or an image editor is showing the render result or viewer. */
663 {
664 continue;
665 }
666
667 const bScreen *screen = WM_window_get_active_screen(&win);
668 for (const ScrArea &area : screen->areabase) {
669 const SpaceLink &space = *area.spacedata.first();
670
671 if (space.spacetype == SPACE_NODE) {
672 const SpaceNode &snode = reinterpret_cast<const SpaceNode &>(space);
673 if (snode.nodetree && snode.nodetree->type == NTREE_COMPOSIT &&
675 {
676 do_free = false;
677 }
678 }
679 else if (space.spacetype == SPACE_IMAGE) {
680 const SpaceImage &sima = reinterpret_cast<const SpaceImage &>(space);
681 if (sima.image && sima.image->source == IMA_SRC_VIEWER) {
682 do_free = false;
683 }
684 }
685 }
686 }
687
688 if (do_free) {
690 if (re->display && !re->display_shared) {
691 re->display->free_gpu_context();
692 }
693
694 /* We also free the resources from the interactive compositor render of the scene if one
695 * exists. */
696 Render *interactive_compositor_render =
697 RenderGlobal.interactive_compositor_renders.lookup_default(re->owner, nullptr);
698 if (interactive_compositor_render) {
699 re_gpu_texture_caches_free(interactive_compositor_render);
700 if (interactive_compositor_render->display &&
701 !interactive_compositor_render->display_shared)
702 {
703 interactive_compositor_render->display->free_gpu_context();
704 }
705 }
706 }
707 }
708}
709
711{
712 /* If engine is currently rendering, just wait for it to be freed when it finishes rendering.
713 */
714 if (re->engine && !(re->engine->flag & RE_ENGINE_RENDERING)) {
716 re->engine = nullptr;
717 }
718}
719
720void RE_FreePersistentData(const Scene *scene)
721{
722 /* Render engines can be kept around for quick re-render, this clears all or one scene. */
723 if (scene) {
724 Render *re = RE_GetSceneRender(scene);
725 if (re) {
727 }
728 }
729 else {
730 for (Render *re : RenderGlobal.render_list) {
732 }
733 }
734}
735
737
738/* -------------------------------------------------------------------- */
741
743 Render *re, Render *source, int winx, int winy, const rcti *disprect)
744{
745 re->winx = winx;
746 re->winy = winy;
747 if (source && (source->r.mode & R_BORDER)) {
748 /* NOTE(@sergey): doesn't seem original bordered `disprect` is storing anywhere
749 * after insertion on black happening in #do_render_engine(),
750 * so for now simply re-calculate `disprect` using border from source renderer. */
751
752 re->disprect.xmin = source->r.border.xmin * winx;
753 re->disprect.xmax = source->r.border.xmax * winx;
754
755 re->disprect.ymin = source->r.border.ymin * winy;
756 re->disprect.ymax = source->r.border.ymax * winy;
757
758 re->rectx = BLI_rcti_size_x(&re->disprect);
759 re->recty = BLI_rcti_size_y(&re->disprect);
760
761 /* copy border itself, since it could be used by external engines */
762 re->r.border = source->r.border;
763 }
764 else if (disprect) {
765 re->disprect = *disprect;
766 re->rectx = BLI_rcti_size_x(&re->disprect);
767 re->recty = BLI_rcti_size_y(&re->disprect);
768 }
769 else {
770 re->disprect.xmin = re->disprect.ymin = 0;
771 re->disprect.xmax = winx;
772 re->disprect.ymax = winy;
773 re->rectx = winx;
774 re->recty = winy;
775 }
776}
777
779{
780 /* Mostly shallow copy referencing pointers in scene renderdata. */
782
783 *to = dna::shallow_copy(*from);
784
786}
787
789 Render *source,
790 const RenderData *rd,
791 ListBaseT<ViewLayer> * /*render_layers*/,
792 ViewLayer *single_layer,
793 int winx,
794 int winy,
795 const rcti *disprect)
796{
797 bool had_freestyle = (re->r.mode & R_EDGE_FRS) != 0;
798
799 re->ok = true; /* maybe flag */
800
802
803 /* copy render data and render layers for thread safety */
804 render_copy_renderdata(&re->r, rd);
805 re->single_view_layer[0] = '\0';
806
807 if (source) {
808 /* reuse border flags from source renderer */
809 re->r.mode &= ~(R_BORDER | R_CROP);
810 re->r.mode |= source->r.mode & (R_BORDER | R_CROP);
811
812 /* dimensions shall be shared between all renderers */
813 re->r.xsch = source->r.xsch;
814 re->r.ysch = source->r.ysch;
815 re->r.size = source->r.size;
816 }
817
818 re_init_resolution(re, source, winx, winy, disprect);
819
820 /* disable border if it's a full render anyway */
821 if (re->r.border.xmin == 0.0f && re->r.border.xmax == 1.0f && re->r.border.ymin == 0.0f &&
822 re->r.border.ymax == 1.0f)
823 {
824 re->r.mode &= ~R_BORDER;
825 }
826
827 if (re->rectx < 1 || re->recty < 1 ||
828 (BKE_imtype_is_movie(rd->im_format.imtype) && (re->rectx < 16 || re->recty < 16)))
829 {
830 BKE_report(re->reports, RPT_ERROR, "Image too small");
831 re->ok = false;
832 return;
833 }
834
835 if (single_layer) {
836 STRNCPY_UTF8(re->single_view_layer, single_layer->name);
837 re->r.scemode |= R_SINGLE_LAYER;
838 }
839 else {
841 }
842
843 /* if preview render, we try to keep old result */
845
846 if (re->r.scemode & R_BUTS_PREVIEW) {
847 if (had_freestyle || (re->r.mode & R_EDGE_FRS)) {
848 /* freestyle manipulates render layers so always have to free */
850 re->result = nullptr;
851 }
852 else if (re->result) {
853 bool have_layer = false;
854
855 if (re->single_view_layer[0] == '\0' && re->result->layers.first()) {
856 have_layer = true;
857 }
858 else {
859 for (RenderLayer &rl : re->result->layers) {
860 if (STREQ(rl.name, re->single_view_layer)) {
861 have_layer = true;
862 }
863 }
864 }
865
866 if (re->result->rectx == re->rectx && re->result->recty == re->recty && have_layer) {
867 /* keep render result, this avoids flickering black tiles
868 * when the preview changes */
869 }
870 else {
871 /* free because resolution changed */
873 re->result = nullptr;
874 }
875 }
876 }
877 else {
878
879 /* make empty render result, so display callbacks can initialize */
881 re->result = MEM_new<RenderResult>("new render result");
882 re->result->rectx = re->rectx;
883 re->result->recty = re->recty;
884 BKE_scene_ppm_get(&re->r, re->result->ppm);
886 }
887
889
891}
892
893void RE_display_update_cb(Render *re, void *handle, void (*f)(void *handle, RenderResult *rr))
894{
895 re->display->display_update_cb = f;
896 re->display->duh = handle;
897}
898void RE_current_scene_update_cb(Render *re, void *handle, void (*f)(void *handle, Scene *scene))
899{
900 re->display->current_scene_update_cb = f;
901 re->display->suh = handle;
902}
903void RE_stats_draw_cb(Render *re, void *handle, void (*f)(void *handle, RenderStats *rs))
904{
905 re->display->stats_draw_cb = f;
906 re->display->sdh = handle;
907}
908void RE_progress_cb(Render *re, void *handle, void (*f)(void *handle, float))
909{
910 re->display->progress_cb = f;
911 re->display->prh = handle;
912}
913
914void RE_draw_lock_cb(Render *re, void *handle, void (*f)(void *handle, bool lock))
915{
916 re->display->draw_lock_cb = f;
917 re->display->dlh = handle;
918}
919
920void RE_test_break_cb(Render *re, void *handle, bool (*f)(void *handle))
921{
922 re->display->test_break_cb = f;
923 re->display->tbh = handle;
924}
925
927 void *handle,
928 bool (*f)(void *handle, ViewLayer *vl, Depsgraph *depsgraph))
929{
930 re->prepare_viewlayer_cb = f;
931 re->prepare_vl_handle = handle;
932}
933
935
936/* -------------------------------------------------------------------- */
939
941{
942 re->display_shared = false;
943 re->display = std::make_shared<RenderDisplay>();
944
945 re->display->display_update_cb = result_rcti_nothing;
946 re->display->current_scene_update_cb = current_scene_nothing;
947 re->display->progress_cb = float_nothing;
948 re->display->test_break_cb = default_break;
949 re->display->stats_draw_cb = stats_update;
950 re->display->sdh = re;
951}
952
954{
955 re->display->ensure_system_gpu_context();
956}
957
958void RE_display_share(Render *re, const Render *parent_re)
959{
960 /* Use for compositor and sequencer, which can render scenes recursively.
961 * It more efficient, and we can only create this context on the main thread. */
962 if (ELEM(parent_re, nullptr, re)) {
963 return;
964 }
965
966 re->display_shared = true;
967 re->display = parent_re->display;
968}
969
971{
972 /* Re-initializing with a new RenderDisplay will free the GPU contexts and all callbacks. */
973 RE_display_init(re);
974}
975
977{
978 RenderDisplay *display = re->display.get();
979 return display->system_gpu_context;
980}
981
983{
984 RenderDisplay *display = re->display.get();
985 return display->ensure_blender_gpu_context();
986}
987
989
990/* -------------------------------------------------------------------- */
997
998/* ************ This part uses API, for rendering Blender scenes ********** */
999
1000/* make sure disprect is not affected by the render border */
1002{
1003 re->disprect.xmin = re->disprect.ymin = 0;
1004 re->disprect.xmax = re->winx;
1005 re->disprect.ymax = re->winy;
1006 re->rectx = re->winx;
1007 re->recty = re->winy;
1008}
1009
1011{
1012 /* when using border render with crop disabled, insert render result into
1013 * full size with black pixels outside */
1014 if (re->result && (re->r.mode & R_BORDER)) {
1015 if ((re->r.mode & R_CROP) == 0) {
1016 RenderResult *rres;
1017
1018 /* backup */
1019 const rcti orig_disprect = re->disprect;
1020 const int orig_rectx = re->rectx, orig_recty = re->recty;
1021
1023
1024 /* sub-rect for merge call later on */
1025 re->result->tilerect = re->disprect;
1026
1027 /* weak is: it chances disprect from border */
1029
1032
1033 render_result_clone_passes(re, rres, nullptr);
1035
1036 render_result_merge(rres, re->result);
1038 re->result = rres;
1039
1040 /* Weak, the display callback wants an active render-layer pointer. */
1042
1044
1045 re->display->display_update(re->result);
1046
1047 /* restore the disprect from border */
1048 re->disprect = orig_disprect;
1049 re->rectx = orig_rectx;
1050 re->recty = orig_recty;
1051 }
1052 }
1053}
1054
1055/* Render scene into render result, with a render engine. */
1056static void do_render_engine(Render *re)
1057{
1058 Object *camera = RE_GetCamera(re);
1059 /* also check for camera here */
1060 if (camera == nullptr) {
1061 BKE_report(re->reports, RPT_ERROR, "Cannot render, no camera");
1062 G.is_break = true;
1063 return;
1064 }
1065
1066 /* now use renderdata and camera to set viewplane */
1067 RE_SetCamera(re, camera);
1068
1069 re->display->current_scene_update(re->scene);
1070 RE_engine_render(re, false);
1071
1072 /* when border render, check if we have to insert it in black */
1074}
1075
1076/* Render scene into render result, within a compositor node tree.
1077 * Uses the same image dimensions, does not recursively perform compositing. */
1078static void do_render_compositor_scene(Render *re, Scene *sce, int cfra)
1079{
1080 Render *resc = RE_NewSceneRender(sce);
1081 int winx = re->winx, winy = re->winy;
1082
1083 sce->r.cfra = cfra;
1084
1086
1087 /* exception: scene uses its own size (unfinished code) */
1088 if (false) {
1089 BKE_render_resolution(&sce->r, false, &winx, &winy);
1090 }
1091
1092 /* initial setup */
1093 RE_InitState(resc, re, &sce->r, &sce->view_layers, nullptr, winx, winy, &re->disprect);
1094
1095 /* We still want to use "Render Cache" setting from the original (main) scene. */
1096 resc->r.scemode = (resc->r.scemode & ~R_EXR_CACHE_FILE) | (re->r.scemode & R_EXR_CACHE_FILE);
1097
1098 /* still unsure entity this... */
1099 resc->main = re->main;
1100 resc->scene = sce;
1101
1102 RE_display_share(resc, re);
1103
1104 do_render_engine(resc);
1105
1106 RE_display_free(resc);
1107}
1108
1109/* Get the set of all scenes that needs to be rendered by the given compositor node group in the
1110 * given pipeline scene. If the node group is that of the first enabled compositor effect,
1111 * is_first_enabled_effect will be true. */
1113 Scene &pipeline_scene,
1114 const bNodeTree &node_group,
1115 const bool is_first_enabled_effect,
1116 VectorSet<const bNodeTree *> &node_trees_already_searched)
1117{
1118 VectorSet<Scene *> needed_scenes_to_render;
1119 node_group.ensure_topology_cache();
1120
1121 /* Group Input nodes. */
1122 if (is_first_enabled_effect) {
1123 for (const bNode *node : node_group.group_input_nodes()) {
1124 if (!node->is_muted()) {
1125 needed_scenes_to_render.add(&pipeline_scene);
1126 }
1127 }
1128 }
1129
1130 /* Render Layers nodes. */
1131 for (const bNode *node : node_group.nodes_by_type("CompositorNodeRLayers"_ustr)) {
1132 if (!node->is_muted() && node->id) {
1133 needed_scenes_to_render.add(id_cast<Scene *>(node->id));
1134 }
1135 }
1136
1137 /* Cryptomatte nodes. */
1138 for (const bNode *node : node_group.nodes_by_type("CompositorNodeCryptomatteV2"_ustr)) {
1139 if (!node->is_muted() && node->custom1 == CMP_NODE_CRYPTOMATTE_SOURCE_RENDER && node->id) {
1140 needed_scenes_to_render.add(id_cast<Scene *>(node->id));
1141 }
1142 }
1143
1144 /* Group nodes. */
1145 for (const bNode *node : node_group.group_nodes()) {
1146 if (node->is_muted() || !node->id) {
1147 continue;
1148 }
1149
1150 const bNodeTree &child_node_group = *id_cast<const bNodeTree *>(node->id);
1151 if (node_trees_already_searched.contains(&child_node_group)) {
1152 continue;
1153 }
1154 node_trees_already_searched.add_new(&child_node_group);
1155
1157 pipeline_scene, child_node_group, false, node_trees_already_searched));
1158 }
1159
1160 return needed_scenes_to_render;
1161}
1162
1163/* Get the set of all scenes that needs to be rendered by the compositor of the given pipeline
1164 * scene. */
1166{
1168 return VectorSet<Scene *>();
1169 }
1170
1171 bool is_first_enabled_effect = true;
1172 VectorSet<Scene *> needed_scenes_to_render;
1173 VectorSet<const bNodeTree *> node_trees_already_searched;
1174 for (SceneCompositorEffect &effect : pipeline_scene.compositor_effects) {
1176 continue;
1177 }
1178
1180 pipeline_scene, *effect.node_group, is_first_enabled_effect, node_trees_already_searched));
1181
1182 is_first_enabled_effect = false;
1183 }
1184
1185 return needed_scenes_to_render;
1186}
1187
1188/* Render all scenes needed by the compositor. */
1189static void do_render_compositor_scenes(Render *re, VectorSet<Scene *> &needed_scenes_to_render)
1190{
1191 bool a_scene_was_rendered = false;
1192 for (Scene *scene : needed_scenes_to_render) {
1193 /* The provided needed_scenes_to_render might contain evaluated scenes, so get the original
1194 * scene instead, because we will be doing raw pointer comparison below and the render function
1195 * expects original scenes. */
1196 Scene *original_scene = DEG_get_original(scene);
1197
1198 /* The pipeline scene was already rendered. */
1199 if (original_scene == re->scene) {
1200 continue;
1201 }
1202
1203 if (!render_scene_has_layers_to_render(scene, nullptr)) {
1204 continue;
1205 }
1206
1207 do_render_compositor_scene(re, original_scene, re->scene->r.cfra);
1208 a_scene_was_rendered = true;
1209 }
1210
1211 /* If a scene was rendered, switch back to the current scene. */
1212 if (a_scene_was_rendered) {
1213 re->display->current_scene_update(re->scene);
1214 }
1215}
1216
1217/* Checks if the given scene has a compositor output. */
1218static bool scene_has_compositor_output(const Scene &scene)
1219{
1220 /* The last enabled effect determines if the compositor has an output, depending on if it has
1221 * an active Group Output or not. */
1222 for (const SceneCompositorEffect &effect : scene.compositor_effects.items_reversed()) {
1223 if (!is_effect_enabled(effect, bke::compositor::ExecutionMode::Render)) {
1224 continue;
1225 }
1226
1227 effect.node_group->ensure_topology_cache();
1228 for (const bNode *node : effect.node_group->nodes_by_type("NodeGroupOutput"_ustr)) {
1229 if (node->flag & NODE_DO_OUTPUT && !node->is_muted()) {
1230 return true;
1231 }
1232 }
1233
1234 return false;
1235 }
1236
1237 return false;
1238}
1239
1240/* Checks if the given node tree has any active file output nodes that are directly linked. */
1241static bool node_tree_has_linked_file_output(const bNodeTree *node_tree)
1242{
1243 if (node_tree == nullptr) {
1244 return false;
1245 }
1246
1247 node_tree->ensure_topology_cache();
1248 for (const bNode *node : node_tree->nodes_by_type("CompositorNodeOutputFile"_ustr)) {
1249 if (!node->is_muted()) {
1250 for (const bNodeSocket &input : node->inputs) {
1251 if (input.is_directly_linked()) {
1252 return true;
1253 }
1254 }
1255 }
1256 }
1257
1258 for (const bNode *node : node_tree->group_nodes()) {
1259 if (node->is_muted() || !node->id) {
1260 continue;
1261 }
1262
1263 if (node_tree_has_linked_file_output(reinterpret_cast<const bNodeTree *>(node->id))) {
1264 return true;
1265 }
1266 }
1267
1268 return false;
1269}
1270
1271/* Checks if the given scene has any active compositor file outputs. */
1273{
1274 for (const SceneCompositorEffect &effect : scene.compositor_effects) {
1275 if (!is_effect_enabled(effect, bke::compositor::ExecutionMode::Render)) {
1276 continue;
1277 }
1278
1280 return true;
1281 }
1282 }
1283
1284 return false;
1285}
1286
1287/* Checks if the given scene has any compositor output, be it the actual compositor output or file
1288 * outputs. */
1290{
1291 if (scene_has_compositor_output(scene)) {
1292 return true;
1293 }
1294
1296}
1297
1298/* Render compositor nodes, along with any scenes required for them.
1299 * The result will be output into a compositing render layer in the render result. */
1301{
1302 bool update_newframe = false;
1303
1305 *re->pipeline_scene_eval);
1306
1307 /* Render the pipeline scene because the compositor is disabled and thus we do a simple render,
1308 * or the compositor is enabled and requires the scene to be rendered. */
1311 needed_scenes_to_render.contains(re->pipeline_scene_eval))
1312 {
1313 /* render the frames
1314 * it could be optimized to render only the needed view
1315 * but what if a scene has a different number of views
1316 * than the main scene? */
1317 do_render_engine(re);
1318 }
1319 else {
1320 re->i.cfra = re->r.cfra;
1321
1322 /* ensure new result gets added, like for regular renders */
1324
1326 if ((re->r.mode & R_CROP) == 0) {
1328 }
1330
1332
1333 /* Scene render process already updates animsys. */
1334 update_newframe = true;
1335
1336 /* The compositor does not have a group output, skip writing the render result. See
1337 * R_SKIP_WRITE for more information. */
1339 re->flag |= R_SKIP_WRITE;
1340 }
1341 }
1342
1343 /* swap render result */
1344 if (re->r.scemode & R_SINGLE_LAYER) {
1348 }
1349
1350 if (!re->display->test_break()) {
1353 {
1354 /* checks if there are render-result nodes that need scene */
1355 if ((re->r.scemode & R_SINGLE_LAYER) == 0) {
1356 do_render_compositor_scenes(re, needed_scenes_to_render);
1357 }
1358
1359 if (!re->display->test_break()) {
1360 if (update_newframe) {
1361 /* If we have consistent depsgraph now would be a time to update them. */
1362 }
1363
1364 compositor::SideEffectOutputTypes needed_side_effects_outputs =
1366
1367 CLOG_STR_INFO(&LOG, "Executing compositor");
1368
1369 re->i.infostr = IFACE_("Compositing");
1370 re->display->stats_draw(&re->i);
1371 re->i.infostr = nullptr;
1372
1373 compositor::RenderContext compositor_render_context;
1374 compositor_render_context.is_animation_render = re->flag & R_ANIMATION;
1375 for (RenderView &rv : re->result->views) {
1377 *re->main,
1379 re->r,
1380 rv.name,
1381 &compositor_render_context,
1382 needed_side_effects_outputs,
1383 false));
1384 }
1385 compositor_render_context.save_file_outputs(re->pipeline_scene_eval);
1386 }
1387 }
1388 }
1389
1390 /* Weak: the display callback wants an active render-layer pointer. */
1391 if (re->result != nullptr) {
1393 re->display->display_update(re->result);
1394 }
1395}
1396
1398{
1399 RenderResult *render_result = re->result;
1400
1402
1403 for (RenderLayer &render_layer : render_result->layers) {
1404 for (RenderPass &render_pass : render_layer.passes.items_reversed()) {
1405 if (render_pass.ibuf) {
1406 BKE_imbuf_stamp_info(render_result, render_pass.ibuf);
1407 }
1408 }
1409 }
1410
1412}
1413
1415{
1416 RenderResult rres;
1417 int nr = 0;
1418
1419 /* this is the basic trick to get the displayed float or char rect from render result */
1420 for (RenderView &rv : re->result->views) {
1422 RE_AcquireResultImage(re, &rres, nr);
1423
1424 if (rres.ibuf != nullptr) {
1425 Object *ob_camera_eval = DEG_get_evaluated(re->pipeline_depsgraph, RE_GetCamera(re));
1427 ob_camera_eval,
1428 (re->scene->r.stamp & R_STAMP_STRIPMETA) ? rres.stamp_data : nullptr,
1429 rres.ibuf);
1431 }
1432
1434 nr++;
1435 }
1436}
1437
1439{
1440 Editing *ed = scene->ed;
1441
1442 if (!(rd->scemode & R_DOSEQ) || !ed || !ed->seqbase.first_) {
1443 return false;
1444 }
1445
1446 for (Strip &strip : ed->seqbase) {
1447 if (strip.type != STRIP_TYPE_SOUND && !seq::render_is_muted(&ed->channels, &strip)) {
1448 return true;
1449 }
1450 }
1451
1452 return false;
1453}
1454
1455static bool seq_result_needs_float(const ImageFormatData &im_format)
1456{
1458}
1459
1460/* Render sequencer strips into render result. */
1462{
1463 static int recurs_depth = 0;
1464 RenderResult *rr; /* don't assign re->result here as it might change during give_ibuf_seq */
1465 int cfra = re->r.cfra;
1466 seq::RenderData context;
1467 int view_id, tot_views;
1468 int re_x, re_y;
1469
1470 CLOG_STR_INFO(&LOG, "Executing sequencer");
1471
1472 re->i.cfra = cfra;
1473
1474 recurs_depth++;
1475
1476 if ((re->r.mode & R_BORDER) && (re->r.mode & R_CROP) == 0) {
1477 /* if border rendering is used and cropping is disabled, final buffer should
1478 * be as large as the whole frame */
1479 re_x = re->winx;
1480 re_y = re->winy;
1481 }
1482 else {
1483 re_x = re->result->rectx;
1484 re_y = re->result->recty;
1485 }
1486
1487 tot_views = BKE_scene_multiview_num_views_get(&re->r);
1488 Vector<ImBuf *> ibuf_arr(tot_views);
1489
1490 render_new_render_data(re->main,
1492 re->scene,
1493 re_x,
1494 re_y,
1496 re,
1497 &context);
1498
1499 /* The render-result gets destroyed during the rendering, so we first collect all ibufs
1500 * and then we populate the final render-result. */
1501
1502 for (view_id = 0; view_id < tot_views; view_id++) {
1503 context.view_id = view_id;
1504 ImBuf *out = render_give_ibuf(&context, cfra, 0);
1505 if (out != nullptr) {
1506 bool make_float = seq_result_needs_float(re->r.im_format);
1509 }
1510 ibuf_arr[view_id] = out;
1511 }
1512
1513 rr = re->result;
1514
1516 render_result_views_new(rr, &re->r);
1518
1519 for (view_id = 0; view_id < tot_views; view_id++) {
1520 RenderView *rv = RE_RenderViewGetById(rr, view_id);
1522
1523 if (ibuf_arr[view_id]) {
1524 /* copy ibuf into combined pixel rect */
1525 RE_render_result_rect_from_ibuf(rr, ibuf_arr[view_id], view_id);
1526
1527 if (ibuf_arr[view_id]->metadata() && (re->scene->r.stamp & R_STAMP_STRIPMETA)) {
1528 /* ensure render stamp info first */
1529 BKE_render_result_stamp_info(nullptr, nullptr, rr, true);
1530 BKE_stamp_info_from_imbuf(rr, ibuf_arr[view_id]);
1531 }
1532
1533 if (recurs_depth == 0) { /* With nested scenes, only free on top-level. */
1535 if (ed) {
1536 seq::relations_free_imbuf(re->pipeline_scene_eval, &ed->seqbase, true);
1538 }
1539 }
1540 IMB_freeImBuf(ibuf_arr[view_id]);
1541 }
1542 else {
1543 /* render result is delivered empty in most cases, nevertheless we handle all cases */
1544 render_result_rect_fill_zero(rr, view_id);
1545 }
1546
1548
1549 /* would mark display buffers as invalid */
1551 re->display->display_update(re->result);
1552 }
1553
1554 recurs_depth--;
1555
1556 /* just in case this flag went missing at some point */
1557 re->r.scemode |= R_DOSEQ;
1558
1559 /* set overall progress of sequence rendering */
1560 if (re->r.efra != re->r.sfra) {
1561 re->display->progress(float(cfra - re->r.sfra) / (re->r.efra - re->r.sfra));
1562 }
1563 else {
1564 re->display->progress(1.0f);
1565 }
1566}
1567
1568/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
1569
1570/* Render full pipeline, using render engine, sequencer and compositing nodes. */
1572{
1573 bool render_seq = false;
1574
1575 re->display->current_scene_update_cb(re->display->suh, re->scene);
1576
1578
1580
1581 /* ensure no rendered results are cached from previous animated sequences */
1583
1584 if (RE_engine_render(re, true)) {
1585 /* in this case external render overrides all */
1586 }
1587 else if (RE_seq_render_active(re->scene, &re->r)) {
1588 /* NOTE: do_render_sequencer() frees rect32 when sequencer returns float images. */
1589 if (!re->display->test_break()) {
1591 render_seq = true;
1592 }
1593
1594 re->display->stats_draw(&re->i);
1595 re->display->display_update(re->result);
1596 }
1597 else {
1599 }
1600
1602
1603 re->display->stats_draw(&re->i);
1604
1605 /* save render result stamp if needed */
1606 if (re->result != nullptr) {
1607 /* sequence rendering should have taken care of that already */
1608 if (!(render_seq && (re->scene->r.stamp & R_STAMP_STRIPMETA))) {
1609 Object *ob_camera_eval = DEG_get_evaluated(re->pipeline_depsgraph, RE_GetCamera(re));
1610 BKE_render_result_stamp_info(re->scene, ob_camera_eval, re->result, false);
1611 }
1612
1614
1615 /* stamp image info here */
1616 if ((re->scene->r.stamp & R_STAMP_ALL) && (re->scene->r.stamp & R_STAMP_DRAW)) {
1618 re->display->display_update(re->result);
1619 }
1620 }
1621}
1622
1623static bool check_valid_compositing_camera(const Main &bmain,
1624 Scene *scene,
1625 Object *camera_override,
1626 ReportList *reports)
1627{
1629 for (SceneCompositorEffect &effect : scene->compositor_effects) {
1631 continue;
1632 }
1633
1634 for (bNode *node : effect.node_group->all_nodes()) {
1635 if (node->type_legacy == CMP_NODE_R_LAYERS && !node->is_muted()) {
1636 Scene *sce = node->id ? id_cast<Scene *>(node->id) : scene;
1637 if (sce->camera == nullptr) {
1639 bmain, sce, BKE_view_layer_default_render(sce));
1640 }
1641 if (sce->camera == nullptr) {
1642 /* all render layers nodes need camera */
1643 BKE_reportf(reports,
1644 RPT_ERROR,
1645 "No camera found in scene \"%s\" (used in compositing of scene \"%s\")",
1646 sce->id.name + 2,
1647 scene->id.name + 2);
1648 return false;
1649 }
1650 }
1651 }
1652 }
1653
1654 return true;
1655 }
1656
1657 const bool ok = (camera_override != nullptr || scene->camera != nullptr);
1658 if (!ok) {
1659 BKE_reportf(reports, RPT_ERROR, "No camera found in scene \"%s\"", scene->id.name + 2);
1660 }
1661
1662 return ok;
1663}
1664
1665static bool check_valid_camera_multiview(const Main &bmain,
1666 Scene *scene,
1667 Object *camera,
1668 ReportList *reports)
1669{
1670 bool active_view = false;
1671
1672 if (camera == nullptr || (scene->r.scemode & R_MULTIVIEW) == 0) {
1673 return true;
1674 }
1675
1676 for (SceneRenderView &srv : scene->r.views) {
1677 if (BKE_scene_multiview_is_render_view_active(&scene->r, &srv)) {
1678 active_view = true;
1679
1681 Object *view_camera;
1682 view_camera = BKE_camera_multiview_render(bmain, scene, camera, srv.name);
1683
1684 if (view_camera == camera) {
1685 /* if the suffix is not in the camera, means we are using the fallback camera */
1686 if (!BLI_str_endswith(view_camera->id.name + 2, srv.suffix)) {
1687 BKE_reportf(reports,
1688 RPT_ERROR,
1689 "Camera \"%s\" is not a multi-view camera",
1690 camera->id.name + 2);
1691 return false;
1692 }
1693 }
1694 }
1695 }
1696 }
1697
1698 if (!active_view) {
1699 BKE_reportf(reports, RPT_ERROR, "No active view found in scene \"%s\"", scene->id.name + 2);
1700 return false;
1701 }
1702
1703 return true;
1704}
1705
1706static int check_valid_camera(const Main &bmain,
1707 Scene *scene,
1708 Object *camera_override,
1709 ReportList *reports)
1710{
1711 if (camera_override == nullptr && scene->camera == nullptr) {
1713 }
1714
1715 if (!check_valid_camera_multiview(bmain, scene, scene->camera, reports)) {
1716 return false;
1717 }
1718
1719 if (RE_seq_render_active(scene, &scene->r)) {
1720 if (scene->ed) {
1721 for (Strip &strip : scene->ed->seqbase) {
1722 if ((strip.type == STRIP_TYPE_SCENE) && ((strip.flag & SEQ_SCENE_STRIPS) == 0) &&
1723 (strip.scene != nullptr))
1724 {
1725 if (!strip.scene_camera) {
1726 if (!strip.scene->camera &&
1728 bmain, strip.scene, BKE_view_layer_default_render(strip.scene)))
1729 {
1730 /* camera could be unneeded due to composite nodes */
1731 Object *override = (strip.scene == scene) ? camera_override : nullptr;
1732
1733 if (!check_valid_compositing_camera(bmain, strip.scene, override, reports)) {
1734 return false;
1735 }
1736 }
1737 }
1738 else if (!check_valid_camera_multiview(bmain, strip.scene, strip.scene_camera, reports))
1739 {
1740 return false;
1741 }
1742 }
1743 }
1744 }
1745 }
1746 else if (!check_valid_compositing_camera(bmain, scene, camera_override, reports)) {
1747 return false;
1748 }
1749
1750 return true;
1751}
1752
1753/* Identify if the compositor can run on the GPU. Currently, this only checks if the compositor is
1754 * set to GPU and the render size exceeds what can be allocated as a texture in it. */
1756{
1757 /* CPU compositor can always run. */
1759 return true;
1760 }
1761
1762 int width, height;
1763 BKE_render_resolution(&scene->r, false, &width, &height);
1764 if (width > 8192 || height > 8192) {
1765 BKE_report(reports, RPT_ERROR, "Render size too large for GPU, use CPU compositor instead");
1766 return false;
1767 }
1768
1769 return true;
1770}
1771
1772bool RE_disable_save_output_allowed(const bool is_animation, Scene &scene, ReportList *reports)
1773{
1774 const bool save_output = (scene.r.mode & R_SAVE_OUTPUT) != 0;
1775 const bool do_compositing = (scene.r.scemode & R_DOCOMP) != 0;
1776 const bool do_sequencer = RE_seq_render_active(&scene, &scene.r);
1777
1778 if (is_animation && do_sequencer && !save_output) {
1779 BKE_report(reports, RPT_ERROR, "Render output disabled in Output properties");
1780 return false;
1781 }
1782
1783 if (is_animation && !save_output && !do_compositing) {
1784 BKE_report(reports, RPT_ERROR, "Render output and compositing disabled in Output properties");
1785 return false;
1786 }
1787
1788 if (is_animation && !save_output && do_compositing) {
1790 BKE_report(reports,
1791 RPT_ERROR,
1792 "Render output disabled in Output properties and no active compositing File "
1793 "Output nodes");
1794 return false;
1795 }
1796 }
1797
1798 return true;
1799}
1800
1802 Scene *scene,
1803 ViewLayer *single_layer,
1804 Object *camera_override,
1805 ReportList *reports)
1806{
1807 if (scene->r.mode & R_BORDER) {
1808 if (scene->r.border.xmax <= scene->r.border.xmin ||
1809 scene->r.border.ymax <= scene->r.border.ymin)
1810 {
1811 BKE_report(reports, RPT_ERROR, "No border area selected");
1812 return false;
1813 }
1814 }
1815
1816 if (RE_seq_render_active(scene, &scene->r)) {
1817 /* Sequencer */
1818 if (scene->r.mode & R_BORDER) {
1819 BKE_report(reports, RPT_ERROR, "Border rendering is not supported by sequencer");
1820 return false;
1821 }
1822 }
1824 /* Compositor */
1825 if (!scene_has_any_compositor_output(*scene)) {
1826 BKE_report(reports, RPT_ERROR, "No Group Output or File Output nodes in scene");
1827 return false;
1828 }
1829
1830 if (!is_compositing_possible_on_gpu(scene, reports)) {
1831 return false;
1832 }
1833 }
1834 else {
1835 /* Regular Render */
1836 if (!render_scene_has_layers_to_render(scene, single_layer)) {
1837 BKE_report(reports, RPT_ERROR, "All render layers are disabled");
1838 return false;
1839 }
1840 }
1841
1842 /* check valid camera, without camera render is OK (compo, seq) */
1843 if (!check_valid_camera(bmain, scene, camera_override, reports)) {
1844 return false;
1845 }
1846
1847 return true;
1848}
1849
1851 Scene *scene,
1852 ViewLayer *view_layer,
1853 const bool /*anim_init*/)
1854{
1855 PTCacheBaker baker;
1856
1857 memset(&baker, 0, sizeof(baker));
1858 baker.bmain = re->main;
1859 baker.scene = scene;
1860 baker.view_layer = view_layer;
1861 baker.depsgraph = BKE_scene_ensure_depsgraph(re->main, scene, view_layer);
1862 baker.bake = false;
1863 baker.render = true;
1864 baker.anim_init = true;
1865 baker.quick_step = 1;
1866
1867 BKE_ptcache_bake(&baker);
1868}
1869
1870void RE_SetActiveRenderView(Render *re, const char *viewname)
1871{
1872 STRNCPY(re->viewname, viewname);
1873}
1874
1876{
1877 return re->viewname;
1878}
1879
1882 const RenderData *rd,
1883 Main *bmain,
1884 Scene *scene,
1885 ViewLayer *single_layer,
1886 Object *camera_override,
1887 const bool anim,
1888 const bool anim_init)
1889{
1890 int winx, winy;
1891 rcti disprect;
1892
1893 /* Reset the runtime flags before rendering, but only if this init is not an inter-animation
1894 * init, since some flags needs to be kept across the entire animation. */
1895 if (!anim) {
1896 re->flag = 0;
1897 }
1898
1899 /* r.xsch and r.ysch has the actual view window size
1900 * r.border is the clipping rect */
1901
1902 /* calculate actual render result and display size */
1903 BKE_render_resolution(rd, false, &winx, &winy);
1904
1905 /* We always render smaller part, inserting it in larger image is compositor business,
1906 * it uses 'disprect' for it. */
1907 if (scene->r.mode & R_BORDER) {
1908 disprect.xmin = rd->border.xmin * winx;
1909 disprect.xmax = rd->border.xmax * winx;
1910
1911 disprect.ymin = rd->border.ymin * winy;
1912 disprect.ymax = rd->border.ymax * winy;
1913 }
1914 else {
1915 disprect.xmin = disprect.ymin = 0;
1916 disprect.xmax = winx;
1917 disprect.ymax = winy;
1918 }
1919
1920 re->main = bmain;
1921 re->scene = scene;
1922 re->camera_override = camera_override;
1923 re->viewname[0] = '\0';
1924
1925 /* not too nice, but it survives anim-border render */
1926 if (anim) {
1927 re->disprect = disprect;
1928 return true;
1929 }
1930
1931 /*
1932 * Disabled completely for now,
1933 * can be later set as render profile option
1934 * and default for background render.
1935 */
1936 if (false) {
1937 /* make sure dynamics are up to date */
1939 update_physics_cache(re, scene, view_layer, anim_init);
1940 }
1941
1942 if (single_layer || scene->r.scemode & R_SINGLE_LAYER) {
1946 }
1947
1948 RE_InitState(re, nullptr, &scene->r, &scene->view_layers, single_layer, winx, winy, &disprect);
1949 if (!re->ok) { /* if an error was printed, abort */
1950 return false;
1951 }
1952
1953 return true;
1954}
1955
1957{
1958 re->reports = reports;
1959}
1960
1968
1970{
1971 Scene *scene = re->scene;
1973
1974 re->pipeline_depsgraph = DEG_graph_new(re->main, scene, view_layer, DAG_EVAL_RENDER);
1975 DEG_debug_name_set(re->pipeline_depsgraph, "RENDER PIPELINE");
1976
1977 /* Make sure there is a correct evaluated scene pointer. */
1979
1980 /* Update immediately so we have proper evaluated scene. */
1982
1984}
1985
1986/* Free data only needed during rendering operation. */
1988{
1989 if (re->engine && !RE_engine_use_persistent_data(re->engine)) {
1991 re->engine = nullptr;
1992 }
1993
1994 /* Destroy compositor that was using pipeline depsgraph. */
1995 RE_compositor_free(*re);
1996
1997 /* Destroy pipeline depsgraph. */
1998 if (re->pipeline_depsgraph != nullptr) {
2000 re->pipeline_depsgraph = nullptr;
2001 re->pipeline_scene_eval = nullptr;
2002 }
2003
2004 /* Destroy the opengl context in the correct thread. */
2005 RE_display_free(re);
2006}
2007
2009 Main *bmain,
2010 Scene *scene,
2011 ViewLayer *single_layer,
2012 Object *camera_override,
2013 const int frame,
2014 const float subframe,
2015 const bool write_still)
2016{
2017 CLOG_INFO(&LOG, "Rendering frame %d", frame);
2018
2020
2021 /* Ugly global still...
2022 * is to prevent preview events and signal subdivision-surface etc to make full resolution. */
2023 G.is_rendering = true;
2024
2025 scene->r.cfra = frame;
2026 scene->r.subframe = subframe;
2027
2029 re, &scene->r, bmain, scene, single_layer, camera_override, false, false))
2030 {
2031 RenderData rd = dna::shallow_copy(scene->r);
2033
2035
2036 /* Reduce GPU memory usage so renderer has more space. */
2038
2040
2042
2043 const bool should_write = write_still && !(re->flag & R_SKIP_WRITE);
2044 bool is_written = false;
2045 if (should_write && !G.is_break) {
2047 /* operator checks this but in case its called from elsewhere */
2048 printf("Error: cannot write single images with a movie format!\n");
2049 }
2050 else {
2051 char filepath_override[FILE_MAX];
2052 const char *relbase = BKE_main_blendfile_path(bmain);
2053 path_templates::VariableMap template_variables;
2055 BKE_add_template_variables_general(template_variables, &scene->id, project);
2056 });
2057 BKE_add_template_variables_for_render_path(template_variables, *scene);
2058
2060 filepath_override,
2061 rd.pic,
2062 relbase,
2063 &template_variables,
2064 scene->r.cfra,
2065 &rd.im_format,
2066 (rd.scemode & R_EXTENSION) != 0,
2067 false,
2068 nullptr);
2069
2070 if (errors.is_empty()) {
2071 is_written = do_write_image_or_movie(
2072 re, bmain, scene, 0, filepath_override, write_still);
2073 }
2074 else {
2076 }
2077 }
2078 }
2079
2080 /* Keep after file save. */
2082 if (is_written) {
2084 }
2085 }
2086
2088 re->main,
2089 &scene->id,
2091
2093
2094 /* UGLY WARNING */
2095 G.is_rendering = false;
2096}
2097
2098#ifdef WITH_FREESTYLE
2099
2100/* Not freestyle specific, currently only used by free-style. */
2101static void change_renderdata_engine(Render *re, const char *new_engine)
2102{
2103 if (!STREQ(re->r.engine, new_engine)) {
2104 if (re->engine) {
2105 RE_engine_free(re->engine);
2106 re->engine = nullptr;
2107 }
2108 STRNCPY(re->r.engine, new_engine);
2109 }
2110}
2111
2112static bool use_eevee_for_freestyle_render(Render *re)
2113{
2114 RenderEngineType *type = RE_engines_find(re->r.engine);
2115 return !(type->flag & RE_USE_CUSTOM_FREESTYLE);
2116}
2117
2118void RE_RenderFreestyleStrokes(Render *re, Main *bmain, Scene *scene, const bool render)
2119{
2120 if (render_init_from_main(re, &scene->r, bmain, scene, nullptr, nullptr, false, false)) {
2121 if (render) {
2122 char scene_engine[32];
2123 STRNCPY(scene_engine, re->r.engine);
2124 if (use_eevee_for_freestyle_render(re)) {
2125 change_renderdata_engine(re, RE_engine_id_BLENDER_EEVEE);
2126 }
2127
2128 RE_engine_render(re, false);
2129
2130 change_renderdata_engine(re, scene_engine);
2131 }
2132 }
2133}
2134
2135void RE_RenderFreestyleExternal(Render *re)
2136{
2137 if (re->display->test_break()) {
2138 return;
2139 }
2140
2142
2143 for (RenderView &rv : re->result->views) {
2144 RE_SetActiveRenderView(re, rv.name);
2145
2147
2148 for (ViewLayer &view_layer : re->scene->view_layers) {
2149 if ((re->r.scemode & R_SINGLE_LAYER) && !STREQ(view_layer.name, re->single_view_layer)) {
2150 continue;
2151 }
2152
2153 if (FRS_is_freestyle_enabled(&view_layer)) {
2154 FRS_do_stroke_rendering(re, &view_layer);
2155 }
2156 }
2157
2159 }
2160}
2161#endif
2162
2164
2165/* -------------------------------------------------------------------- */
2168
2170 RenderResult *rr,
2172 Scene *scene,
2173 const RenderData *rd,
2174 MovieWriter **movie_writers,
2175 const int totvideos,
2176 bool preview)
2177{
2178 bool ok = true;
2179
2180 if (!rr) {
2181 return false;
2182 }
2183
2184 ImageFormatData image_format;
2185 BKE_image_format_init_for_write(&image_format, scene, nullptr, true);
2186
2187 const bool is_mono = !RE_ResultIsMultiView(rr);
2188 const float dither = scene->r.dither_intensity;
2189
2190 if (is_mono || (image_format.views_format == R_IMF_VIEWS_INDIVIDUAL)) {
2191 int view_id;
2192 for (view_id = 0; view_id < totvideos; view_id++) {
2193 const char *suffix = BKE_scene_multiview_view_id_suffix_get(&scene->r, view_id);
2194 ImBuf *ibuf = RE_render_result_rect_to_ibuf(rr, &rd->im_format, dither, view_id);
2195
2196 IMB_colormanagement_imbuf_for_write(ibuf, true, false, &image_format);
2197
2198 BLI_assert(movie_writers[view_id] != nullptr);
2199 if (!MOV_write_append(movie_writers[view_id],
2200 scene,
2201 project,
2202 rd,
2203 &image_format,
2204 preview ? scene->r.psfra : scene->r.sfra,
2205 scene->r.cfra,
2206 ibuf,
2207 suffix,
2208 reports))
2209 {
2210 ok = false;
2211 }
2212
2213 /* imbuf knows which rects are not part of ibuf */
2214 IMB_freeImBuf(ibuf);
2215 }
2216 CLOG_INFO_NOCHECK(&LOG, "Video append frame %d", scene->r.cfra);
2217 }
2218 else { /* R_IMF_VIEWS_STEREO_3D */
2219 const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
2220 ImBuf *ibuf_arr[3] = {nullptr};
2221 int i;
2222
2223 BLI_assert((totvideos == 1) && (image_format.views_format == R_IMF_VIEWS_STEREO_3D));
2224
2225 for (i = 0; i < 2; i++) {
2226 int view_id = BLI_findstringindex(&rr->views, names[i], offsetof(RenderView, name));
2227 ibuf_arr[i] = RE_render_result_rect_to_ibuf(rr, &rd->im_format, dither, view_id);
2228
2229 IMB_colormanagement_imbuf_for_write(ibuf_arr[i], true, false, &image_format);
2230 }
2231
2232 ibuf_arr[2] = IMB_stereo3d_ImBuf(&image_format, ibuf_arr[0], ibuf_arr[1]);
2233
2234 if (ibuf_arr[2]) {
2235 BLI_assert(movie_writers[0] != nullptr);
2236 if (!MOV_write_append(movie_writers[0],
2237 scene,
2238 project,
2239 rd,
2240 &image_format,
2241 preview ? scene->r.psfra : scene->r.sfra,
2242 scene->r.cfra,
2243 ibuf_arr[2],
2244 "",
2245 reports))
2246 {
2247 ok = false;
2248 }
2249 }
2250 else {
2251 BKE_report(reports, RPT_ERROR, "Failed to create stereo image buffer");
2252 ok = false;
2253 }
2254
2255 for (i = 0; i < 3; i++) {
2256 /* imbuf knows which rects are not part of ibuf */
2257 if (ibuf_arr[i]) {
2258 IMB_freeImBuf(ibuf_arr[i]);
2259 }
2260 }
2261 }
2262
2263 BKE_image_format_free(&image_format);
2264
2265 return ok;
2266}
2267
2269 Main *bmain,
2270 Scene *scene,
2271 const int totvideos,
2272 const char *filepath_override,
2273 const bool write_anim_or_still)
2274{
2275 char filepath[FILE_MAX];
2276 RenderResult rres;
2277 double render_time;
2278 bool ok = true;
2279 RenderEngineType *re_type = RE_engines_find(re->r.engine);
2280
2281 /* Only disable file writing if postprocessing is also disabled. */
2282 const bool do_write_file = (!(re_type->flag & RE_USE_NO_IMAGE_SAVE) ||
2283 (re_type->flag & RE_USE_POSTPROCESS)) &&
2284 write_anim_or_still;
2285
2286 if (do_write_file) {
2287 RE_AcquireResultImageViews(re, &rres);
2288
2289 /* write movie or image */
2290 if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
2293 &rres,
2294 project,
2295 scene,
2296 &re->r,
2297 re->movie_writers.data(),
2298 totvideos,
2299 false);
2300 });
2301 }
2302 else {
2303 if (filepath_override) {
2304 STRNCPY(filepath, filepath_override);
2305 }
2306 else {
2307 const char *relbase = BKE_main_blendfile_path(bmain);
2308 path_templates::VariableMap template_variables;
2310 BKE_add_template_variables_general(template_variables, &scene->id, project);
2311 });
2312 BKE_add_template_variables_for_render_path(template_variables, *scene);
2313
2315 filepath,
2316 scene->r.pic,
2317 relbase,
2318 &template_variables,
2319 scene->r.cfra,
2320 &scene->r.im_format,
2321 (scene->r.scemode & R_EXTENSION) != 0,
2322 true,
2323 nullptr);
2324 if (!errors.is_empty()) {
2326 ok = false;
2327 }
2328 }
2329
2330 /* write images as individual images or stereo */
2331 if (ok) {
2332 ok = BKE_image_render_write(re->reports, &rres, scene, true, filepath);
2333 }
2334 }
2335
2336 RE_ReleaseResultImageViews(re, &rres);
2337 }
2338
2339 render_time = re->i.lastframetime;
2341
2342 BLI_timecode_string_from_time_simple(filepath, sizeof(filepath), re->i.lastframetime);
2343 std::string message = fmt::format("Time: {}", filepath);
2344
2345 if (do_write_file && ok) {
2347 filepath, sizeof(filepath), re->i.lastframetime - render_time);
2348 message = fmt::format("{} (Saving: {})", message, filepath);
2349 }
2350
2351 const bool show_info = CLOG_CHECK(&LOG, CLG_LEVEL_INFO);
2352 if (show_info) {
2353 CLOG_STR_INFO(&LOG, message.c_str());
2354 /* Flush stdout to be sure python callbacks are printing stuff after blender. */
2355 fflush(stdout);
2356 }
2357
2358 /* NOTE: using G_MAIN seems valid here???
2359 * Not sure it's actually even used anyway, we could as well pass nullptr? */
2361
2362 if (show_info) {
2363 fflush(stdout);
2364 }
2365
2366 return ok;
2367}
2368
2369static void get_videos_dimensions(const Render *re,
2370 const RenderData *rd,
2371 const ImageFormatData *imf,
2372 size_t *r_width,
2373 size_t *r_height)
2374{
2375 size_t width, height;
2376 if (re->r.mode & R_BORDER) {
2377 if ((re->r.mode & R_CROP) == 0) {
2378 width = re->winx;
2379 height = re->winy;
2380 }
2381 else {
2382 width = re->rectx;
2383 height = re->recty;
2384 }
2385 }
2386 else {
2387 width = re->rectx;
2388 height = re->recty;
2389 }
2390
2391 BKE_scene_multiview_videos_dimensions_get(rd, imf, width, height, r_width, r_height);
2392}
2393
2395{
2396 for (MovieWriter *writer : re->movie_writers) {
2397 MOV_write_end(writer);
2398 }
2400}
2401
2402static void touch_file(const char *filepath)
2403{
2404 if (BLI_exists(filepath)) {
2405 return;
2406 }
2407
2408 if (!BLI_file_ensure_parent_dir_exists(filepath)) {
2409 CLOG_ERROR(&LOG, "Couldn't create directory for file %s: %s", filepath, std::strerror(errno));
2410 return;
2411 }
2412 if (!BLI_file_touch(filepath)) {
2413 CLOG_ERROR(&LOG, "Couldn't touch file %s: %s", filepath, std::strerror(errno));
2414 return;
2415 }
2416}
2417
2419 Main *bmain,
2420 Scene *scene,
2421 ViewLayer *single_layer,
2422 Object *camera_override,
2423 int sfra,
2424 int efra,
2425 int tfra)
2426{
2427 if (sfra == efra) {
2428 CLOG_INFO(&LOG, "Rendering single frame");
2429 }
2430 else {
2431 CLOG_INFO(&LOG, "Rendering animation (frames %d..%d)", sfra, efra);
2432 }
2433
2434 /* Call hooks before taking a copy of scene->r, so user can alter the render settings prior to
2435 * copying (e.g. alter the output path). */
2437
2438 RenderData rd = dna::shallow_copy(scene->r);
2439 const int cfra_old = rd.cfra;
2440 const float subframe_old = rd.subframe;
2441 int nfra, totrendered = 0, totskipped = 0;
2442
2443 /* do not fully call for each frame, it initializes & pops output window */
2444 if (!render_init_from_main(re, &rd, bmain, scene, single_layer, camera_override, false, true)) {
2445 return;
2446 }
2447
2448 RenderEngineType *re_type = RE_engines_find(re->r.engine);
2449
2450 /* Image format for writing. */
2451 ImageFormatData image_format;
2452 BKE_image_format_init_for_write(&image_format, scene, nullptr, true);
2453
2454 const int totvideos = BKE_scene_multiview_num_videos_get(&rd, &image_format);
2455 const bool is_movie = BKE_imtype_is_movie(image_format.imtype);
2456 const bool is_multiview_name = ((rd.scemode & R_MULTIVIEW) != 0 &&
2457 (image_format.views_format == R_IMF_VIEWS_INDIVIDUAL));
2458 const bool write_anim = (scene->r.mode & R_SAVE_OUTPUT);
2459
2460 /* Disable file writing if postprocessing is also disabled or if it's explicitly disabled by the
2461 * user. */
2462 const bool do_write_file = (!(re_type->flag & RE_USE_NO_IMAGE_SAVE) ||
2463 (re_type->flag & RE_USE_POSTPROCESS)) &&
2464 write_anim;
2465
2467
2468 if (is_movie && do_write_file) {
2469 size_t width, height;
2470 get_videos_dimensions(re, &rd, &image_format, &width, &height);
2471
2472 bool is_error = false;
2473 re->movie_writers.reserve(totvideos);
2474 for (int i = 0; i < totvideos; i++) {
2475 const char *suffix = is_multiview_name ? BKE_scene_multiview_view_id_suffix_get(&re->r, i) :
2476 "";
2477 MovieWriter *writer = BKE_blender_project_read_callback(
2478 bmain, [&](const bke::BlenderProject *project) {
2480 project,
2481 &re->r,
2482 &image_format,
2483 width,
2484 height,
2485 re->reports,
2486 false,
2487 suffix);
2488 });
2489 if (writer == nullptr) {
2490 is_error = true;
2491 break;
2492 }
2493 re->movie_writers.append(writer);
2494 }
2495
2496 if (is_error) {
2498 BKE_image_format_free(&image_format);
2500 return;
2501 }
2502 }
2503
2504 /* Ugly global still... is to prevent renderwin events and signal subdivision-surface etc
2505 * to make full resolution is also set by caller renderwin.c */
2506 G.is_rendering = true;
2507
2508 re->flag |= R_ANIMATION;
2510
2511 scene->r.subframe = 0.0f;
2512 for (nfra = sfra, scene->r.cfra = sfra; scene->r.cfra <= efra; scene->r.cfra++) {
2513 CLOG_INFO(&LOG, "Rendering frame %d", nfra);
2514
2515 char filepath[FILE_MAX];
2516
2517 /* Reduce GPU memory usage so renderer has more space. */
2519
2520 /* A feedback loop exists here -- render initialization requires updated
2521 * render layers settings which could be animated, but scene evaluation for
2522 * the frame happens later because it depends on what layers are visible to
2523 * render engine.
2524 *
2525 * The idea here is to only evaluate animation data associated with the scene,
2526 * which will make sure render layer settings are up-to-date, initialize the
2527 * render database itself and then perform full scene update with only needed
2528 * layers.
2529 * -sergey-
2530 */
2531 {
2532 float ctime = BKE_scene_ctime_get(scene);
2533 AnimData *adt = BKE_animdata_from_id(&scene->id);
2535 re->pipeline_depsgraph, ctime);
2536 BKE_animsys_evaluate_animdata(&scene->id, adt, &anim_eval_context, ADT_RECALC_ALL, false);
2537 }
2538
2540
2541 /* Only border now, TODO(ton): camera lens. */
2542 render_init_from_main(re, &rd, bmain, scene, single_layer, camera_override, true, false);
2543
2544 if (nfra != scene->r.cfra) {
2545 /* Skip this frame, but could update for physics and particles system. */
2546 continue;
2547 }
2548
2549 nfra += tfra;
2550
2551 /* Touch/NoOverwrite options are only valid for image's */
2552 if (is_movie == false && do_write_file) {
2553 path_templates::VariableMap template_variables;
2555 BKE_add_template_variables_general(template_variables, &scene->id, project);
2556 });
2557 BKE_add_template_variables_for_render_path(template_variables, *scene);
2558
2560 filepath,
2561 rd.pic,
2563 &template_variables,
2564 scene->r.cfra,
2565 &image_format,
2566 (rd.scemode & R_EXTENSION) != 0,
2567 true,
2568 nullptr);
2569
2570 /* The filepath cannot be parsed, so we can't save the renders anywhere.
2571 * So we just cancel. */
2572 if (!errors.is_empty()) {
2574 /* We have to set the `is_break` flag here so that final cleanup code
2575 * recognizes that the render has failed. */
2576 G.is_break = true;
2577 break;
2578 }
2579
2580 if (rd.mode & R_NO_OVERWRITE) {
2581 if (!is_multiview_name) {
2582 if (BLI_exists(filepath)) {
2583 CLOG_INFO(&LOG, "Skipping existing frame \"%s\"", filepath);
2584 totskipped++;
2585 continue;
2586 }
2587 }
2588 else {
2589 bool is_skip = false;
2590 char filepath_view[FILE_MAX];
2591
2592 for (SceneRenderView &srv : scene->r.views) {
2593 if (!BKE_scene_multiview_is_render_view_active(&scene->r, &srv)) {
2594 continue;
2595 }
2596
2597 BKE_scene_multiview_filepath_get(&srv, filepath, filepath_view);
2598 if (BLI_exists(filepath_view)) {
2599 is_skip = true;
2600 CLOG_INFO(
2601 &LOG, "Skipping existing frame \"%s\" for view \"%s\"", filepath_view, srv.name);
2602 }
2603 }
2604
2605 if (is_skip) {
2606 totskipped++;
2607 continue;
2608 }
2609 }
2610 }
2611
2612 if (rd.mode & R_TOUCH) {
2613 if (!is_multiview_name) {
2614 touch_file(filepath);
2615 }
2616 else {
2617 char filepath_view[FILE_MAX];
2618
2619 for (SceneRenderView &srv : scene->r.views) {
2620 if (!BKE_scene_multiview_is_render_view_active(&scene->r, &srv)) {
2621 continue;
2622 }
2623
2624 BKE_scene_multiview_filepath_get(&srv, filepath, filepath_view);
2625
2626 touch_file(filepath);
2627 }
2628 }
2629 }
2630 }
2631
2632 re->r.cfra = scene->r.cfra; /* weak.... */
2633 re->r.subframe = scene->r.subframe;
2634
2635 /* run callbacks before rendering, before the scene is updated */
2637
2639 totrendered++;
2640
2641 const bool should_write = !(re->flag & R_SKIP_WRITE);
2642 bool is_written = false;
2643 if (re->display->test_break() == 0) {
2644 if (!G.is_break && should_write) {
2645 is_written = do_write_image_or_movie(re, bmain, scene, totvideos, nullptr, write_anim);
2646 if (!is_written) {
2647 G.is_break = true;
2648 }
2649 }
2650 }
2651 else {
2652 G.is_break = true;
2653 }
2654
2655 /* A written frame is complete, even if cancelled during file save. */
2656 if (is_written || !G.is_break) {
2657 /* keep after file save */
2659 if (is_written) {
2661 }
2662 }
2663
2664 if (G.is_break == true) {
2665 /* remove touched file */
2666 if (is_movie == false && do_write_file) {
2667 if (rd.mode & R_TOUCH) {
2668 if (!is_multiview_name) {
2669 if (BLI_file_size(filepath) == 0) {
2670 /* BLI_exists(filepath) is implicit */
2671 BLI_delete(filepath, false, false);
2672 }
2673 }
2674 else {
2675 char filepath_view[FILE_MAX];
2676
2677 for (SceneRenderView &srv : scene->r.views) {
2678 if (!BKE_scene_multiview_is_render_view_active(&scene->r, &srv)) {
2679 continue;
2680 }
2681
2682 BKE_scene_multiview_filepath_get(&srv, filepath, filepath_view);
2683
2684 if (BLI_file_size(filepath_view) == 0) {
2685 /* BLI_exists(filepath_view) is implicit */
2686 BLI_delete(filepath_view, false, false);
2687 }
2688 }
2689 }
2690 }
2691 }
2692 break;
2693 }
2694 }
2695
2696 /* end movie */
2697 if (is_movie && do_write_file) {
2699 }
2700
2701 BKE_image_format_free(&image_format);
2702
2703 if (totskipped && totrendered == 0) {
2704 BKE_report(re->reports, RPT_INFO, "No frames rendered, skipped to not overwrite");
2705 }
2706
2707 scene->r.cfra = cfra_old;
2708 scene->r.subframe = subframe_old;
2709
2711 re->main,
2712 &scene->id,
2715
2717
2718 /* UGLY WARNING */
2719 G.is_rendering = false;
2720}
2721
2722void RE_PreviewRender(Render *re, Main *bmain, Scene *sce)
2723{
2724 /* Ensure within GPU render boundary. */
2725 const bool use_gpu = GPU_backend_get_type() != GPU_BACKEND_NONE;
2726 if (use_gpu) {
2728 }
2729
2730 Object *camera;
2731 int winx, winy;
2732
2733 BKE_render_resolution(&sce->r, false, &winx, &winy);
2734
2735 RE_InitState(re, nullptr, &sce->r, &sce->view_layers, nullptr, winx, winy, nullptr);
2736
2737 re->main = bmain;
2738 re->scene = sce;
2739
2740 camera = RE_GetCamera(re);
2741 RE_SetCamera(re, camera);
2742
2743 RE_engine_render(re, false);
2744
2745 /* No persistent data for preview render. */
2746 if (re->engine) {
2748 re->engine = nullptr;
2749 }
2750
2751 /* Close GPU render boundary. */
2752 if (use_gpu) {
2754 }
2755}
2756
2757/* NOTE: repeated win/disprect calc... solve that nicer, also in compo. */
2758
2759bool RE_ReadRenderResult(Scene *scene, Scene *scenode)
2760{
2761 Render *re;
2762 int winx, winy;
2763 bool success;
2764 rcti disprect;
2765
2766 /* calculate actual render result and display size */
2767 BKE_render_resolution(&scene->r, false, &winx, &winy);
2768
2769 /* only in movie case we render smaller part */
2770 if (scene->r.mode & R_BORDER) {
2771 disprect.xmin = scene->r.border.xmin * winx;
2772 disprect.xmax = scene->r.border.xmax * winx;
2773
2774 disprect.ymin = scene->r.border.ymin * winy;
2775 disprect.ymax = scene->r.border.ymax * winy;
2776 }
2777 else {
2778 disprect.xmin = disprect.ymin = 0;
2779 disprect.xmax = winx;
2780 disprect.ymax = winy;
2781 }
2782
2783 if (scenode) {
2784 scene = scenode;
2785 }
2786
2787 /* get render: it can be called from UI with draw callbacks */
2788 re = RE_GetSceneRender(scene);
2789 if (re == nullptr) {
2790 re = RE_NewSceneRender(scene);
2791 }
2792 RE_InitState(re, nullptr, &scene->r, &scene->view_layers, nullptr, winx, winy, &disprect);
2793 re->scene = scene;
2794
2798
2800
2801 return success;
2802}
2803
2805 RenderLayer *layer, ReportList *reports, const char *filepath, int x, int y)
2806{
2807 /* First try loading multi-layer EXR. */
2808 if (render_result_exr_file_read_path(nullptr, layer, reports, filepath)) {
2809 return;
2810 }
2811
2812 /* OCIO_TODO: assume layer was saved in default color space */
2814 RenderPass *rpass = nullptr;
2815
2816 /* multi-view: since the API takes no 'view', we use the first combined pass found */
2817 for (rpass = layer->passes.first(); rpass; rpass = rpass->next) {
2818 if (STREQ(rpass->name, RE_PASSNAME_COMBINED)) {
2819 break;
2820 }
2821 }
2822
2823 if (rpass == nullptr) {
2824 BKE_reportf(reports,
2825 RPT_ERROR,
2826 "%s: no Combined pass found in the render layer '%s'",
2827 __func__,
2828 filepath);
2829 }
2830
2831 if (ibuf && (ibuf->byte_data() || ibuf->float_data())) {
2832 if (ibuf->x == layer->rectx && ibuf->y == layer->recty) {
2833 if (ibuf->float_data() == nullptr) {
2834 IMB_float_from_byte(ibuf);
2835 }
2836
2837 rpass->ibuf->float_buffer = ibuf->float_buffer;
2839 }
2840 else {
2841 if ((ibuf->x - x >= layer->rectx) && (ibuf->y - y >= layer->recty)) {
2842 if (ibuf->float_data() == nullptr) {
2843 IMB_float_from_byte(ibuf);
2844 }
2845 IMB_copy_rect(rpass->ibuf, ibuf, int2(x, y), int2(0, 0), int2(layer->rectx, layer->recty));
2847 }
2848 else {
2849 BKE_reportf(reports,
2850 RPT_ERROR,
2851 "%s: incorrect dimensions for partial copy '%s'",
2852 __func__,
2853 filepath);
2854 }
2855 }
2856
2857 IMB_freeImBuf(ibuf);
2858 }
2859 else {
2860 BKE_reportf(reports, RPT_ERROR, "%s: failed to load '%s'", __func__, filepath);
2861 }
2862}
2863
2864void RE_result_load_from_file(RenderResult *result, ReportList *reports, const char *filepath)
2865{
2866 if (!render_result_exr_file_read_path(result, nullptr, reports, filepath)) {
2867 BKE_reportf(reports, RPT_ERROR, "%s: failed to load '%s'", __func__, filepath);
2868 return;
2869 }
2870}
2871
2873{
2874 switch (BLI_listbase_count_at_most(&result->layers, 2)) {
2875 case 0:
2876 return false;
2877 case 1:
2878 return ((result->layers.first())->name[0] != '\0');
2879 default:
2880 return true;
2881 }
2882}
2883
2885{
2886 for (RenderPass &rp : rl->passes) {
2887 if (!STREQ(rp.name, "Combined")) {
2888 return true;
2889 }
2890 }
2891
2892 return false;
2893}
2894
2895RenderPass *RE_pass_find_by_name(RenderLayer *rl, const char *name, const char *viewname)
2896{
2897 for (RenderPass &rp : rl->passes.items_reversed()) {
2898 if (STREQ(rp.name, name)) {
2899 if (viewname == nullptr || viewname[0] == '\0') {
2900 return &rp;
2901 }
2902 if (STREQ(rp.view, viewname)) {
2903 return &rp;
2904 }
2905 }
2906 }
2907 return nullptr;
2908}
2909
2910RenderPass *RE_create_gp_pass(RenderResult *rr, const char *layername, const char *viewname)
2911{
2912 RenderLayer *rl = RE_GetRenderLayer(rr, layername);
2913 /* only create render layer if not exist */
2914 if (!rl) {
2915 rl = MEM_new<RenderLayer>(layername);
2916 BLI_addtail(&rr->layers, rl);
2917 STRNCPY(rl->name, layername);
2918 rl->layflag = SCE_LAY_SOLID;
2920 rl->rectx = rr->rectx;
2921 rl->recty = rr->recty;
2922 }
2923
2924 /* Clear previous pass if exist or the new image will be over previous one. */
2926 if (rp) {
2927 IMB_freeImBuf(rp->ibuf);
2928 BLI_freelinkN(&rl->passes, rp);
2929 }
2930 /* create a totally new pass */
2931 return render_layer_add_pass(rr, rl, 4, RE_PASSNAME_COMBINED, viewname, "RGBA", true);
2932}
2933
2935
2936/* -------------------------------------------------------------------- */
2939
2941{
2942 /* override not showing object when duplis are used with particles */
2943 if (ob->transflag & OB_DUPLIPARTS) {
2944 /* pass */ /* let particle system(s) handle showing vs. not showing */
2945 }
2946 else if (ob->transflag & OB_DUPLI) {
2947 return false;
2948 }
2949 return true;
2950}
2951
2953{
2954 re->r.threads = BKE_render_num_threads(&re->r);
2955}
2956
2958
2959} // namespace blender
Camera data-block and utility functions.
#define G_MAIN
#define CMP_NODE_R_LAYERS
File and directory operations.
#define FILE_MAX
#define STRNCPY_UTF8(dst, src)
#define THREAD_LOCK_READ
#define THREAD_LOCK_WRITE
Platform independent time functions.
#define IFACE_(msgid)
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define CLOG_CHECK(clg_ref, verbose_level,...)
Definition CLG_log.h:147
#define CLOG_INFO_NOCHECK(clg_ref, format,...)
Definition CLG_log.h:204
@ CLG_LEVEL_INFO
Definition CLG_log.h:60
#define CLOG_STR_INFO(clg_ref, str)
Definition CLG_log.h:198
#define CLOG_INFO(clg_ref,...)
Definition CLG_log.h:190
Object is a sort of wrapper for general info.
#define RE_PASSNAME_COMBINED
#define R_STAMP_ALL
#define STEREO_LEFT_NAME
#define STEREO_RIGHT_NAME
Read Blender memory allocation and freeing.
volatile int lock
#define ELEM(...)
#define STREQ(a, b)
Definition scene.h:133
bool add(const Key &key)
void add_multiple(Span< Key > keys)
bool contains(const Key &key) const
void add_new(const Key &key)
bool is_empty() const
void append(const T &value)
void reserve(const int64_t min_capacity)
#define offsetof(t, d)
#define str(s)
#define layer
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
bool is_enabled(const Scene &scene, ExecutionMode mode)
bool is_effect_enabled(const SceneCompositorEffect &effect, ExecutionMode mode)
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
Definition DNA_defs.h:147
void relations_free_imbuf(Scene *scene, ListBaseT< Strip > *seqbase, bool for_render)
bool render_is_muted(const ListBaseT< SeqTimelineChannel > *channels, const Strip *strip)
Definition render.cc:2241
void ensure_ibuf_is_linear_space(ImBuf *ibuf, bool make_float)
Definition render.cc:176
void cache_cleanup(Scene *scene, CacheCleanup mode)
BMesh Iterators.
bool BKE_scene_multiview_is_render_view_active(const RenderData *rd, const SceneRenderView *srv)
Definition scene.cc:3241
void * RE_blender_gpu_context_ensure(Render *re)
void RE_SetActiveRenderView(Render *re, const char *viewname)
int FRS_is_freestyle_enabled(struct ViewLayer *view_layer)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ SEQ_RENDER_SIZE_SCENE
static bool scene_has_compositor_output(const Scene &scene)
Render * RE_GetRender(const void *owner)
bool render_result_exr_file_read_path(RenderResult *rr, RenderLayer *rl_single, ReportList *reports, const char *filepath)
void render_result_single_layer_begin(Render *re)
void RE_RenderFrame(Render *re, Main *bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, const int frame, const float subframe, const bool write_still)
static void result_rcti_nothing(void *, RenderResult *)
void BKE_callback_exec_string(Main *bmain, const char *str, eCbEvent evt)
Definition callbacks.cc:76
ImBuf * IMB_makeSingleUser(ImBuf *ibuf)
RenderPass * RE_create_gp_pass(RenderResult *rr, const char *layername, const char *viewname)
static VectorSet< Scene * > get_scenes_that_needs_render_by_node_group(Scene &pipeline_scene, const bNodeTree &node_group, const bool is_first_enabled_effect, VectorSet< const bNodeTree * > &node_trees_already_searched)
char * STRNCPY(char(&dst)[N], const char *src)
RenderView * RE_RenderViewGetById(RenderResult *rr, const int view_id)
bool RE_seq_render_active(Scene *scene, const RenderData *rd)
void RE_SetReports(Render *re, ReportList *reports)
ID * DEG_get_original_id(ID *id)
void render_result_views_new(RenderResult *rr, const RenderData *rd)
bool BKE_image_render_write(ReportList *reports, RenderResult *rr, const Scene *scene, bool stamp, const char *filepath_basis, const ImageFormatData *format=nullptr, bool save_as_render=true)
void RE_ResultGet32(Render *re, uint8_t *dst)
void RE_compositor_free(Render &render)
void RE_stats_draw_cb(Render *re, void *handle, void(*f)(void *handle, RenderStats *rs))
@ BKE_CB_EVT_RENDER_PRE
@ BKE_CB_EVT_RENDER_POST
@ BKE_CB_EVT_RENDER_COMPLETE
@ BKE_CB_EVT_RENDER_CANCEL
@ BKE_CB_EVT_RENDER_INIT
@ BKE_CB_EVT_RENDER_STATS
@ BKE_CB_EVT_RENDER_WRITE
void RE_test_break_cb(Render *re, void *handle, bool(*f)(void *handle))
static void renderresult_set_passes_metadata(Render *re)
int BKE_scene_multiview_view_id_get(const RenderData *rd, const char *viewname)
Definition scene.cc:3335
void BKE_add_template_variables_general(bke::path_templates::VariableMap &variables, const ID *path_owner_id, const bke::BlenderProject *project)
bool RE_layers_have_name(RenderResult *result)
static bool check_valid_camera_multiview(const Main &bmain, Scene *scene, Object *camera, ReportList *reports)
static VectorSet< Scene * > get_scenes_that_needs_render_by_compositor(Scene &pipeline_scene)
void DEG_graph_free(Depsgraph *graph)
Definition depsgraph.cc:307
void RE_render_result_rect_from_ibuf(RenderResult *rr, const ImBuf *ibuf, const int view_id)
int bool bool BLI_str_endswith(const char *__restrict str, const char *__restrict end) ATTR_NONNULL(1
bool render_result_exr_file_cache_read(Render *re)
void BKE_scene_multiview_filepath_get(const SceneRenderView *srv, const char *filepath, char *r_filepath)
Definition scene.cc:3361
void render_result_views_shallowdelete(RenderResult *rr)
bool RE_engine_use_persistent_data(RenderEngine *engine)
void BKE_render_result_stamp_info(Scene *scene, Object *camera, RenderResult *rr, bool allocate_only)
bool BLI_exists(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition storage.cc:404
@ WM_JOB_TYPE_RENDER
Definition WM_api.hh:2011
@ WM_JOB_TYPE_COMPOSITE
Definition WM_api.hh:2010
@ WM_JOB_TYPE_OBJECT_BAKE
Definition WM_api.hh:2018
RenderLayer * RE_GetRenderLayer(RenderResult *rr, const char *name)
GPUBackendType GPU_backend_get_type()
void RE_SwapResult(Render *re, RenderResult **rr)
StampData * BKE_stamp_data_copy(const StampData *stamp_data)
static void re_movie_free_all(Render *re)
void DEG_graph_id_tag_update(Main *bmain, Depsgraph *depsgraph, ID *id, unsigned int flags)
Render * RE_NewInteractiveCompositorRender(const Scene *scene)
void BKE_curvemapping_copy_data(CurveMapping *target, const CurveMapping *cumap)
@ RE_USE_CUSTOM_FREESTYLE
Definition RE_engine.h:53
@ RE_USE_POSTPROCESS
Definition RE_engine.h:47
@ RE_USE_NO_IMAGE_SAVE
Definition RE_engine.h:54
Depsgraph * DEG_graph_new(Main *bmain, Scene *scene, ViewLayer *view_layer, eEvaluationMode mode)
Definition depsgraph.cc:279
static void float_nothing(void *, float)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
void BKE_report_path_template_errors(ReportList *reports, eReportType report_type, StringRef path, Span< bke::path_templates::Error > errors)
void BKE_sound_reset_scene_specs(Scene *scene)
void RE_SetScene(Render *re, Scene *sce)
static void do_render_compositor(Render *re)
void BKE_image_stamp_buf(Scene *scene, Object *camera, const StampData *stamp_data_template, ImBuf *ibuf)
void BKE_image_all_free_anim_ibufs(Main *bmain, int except_frame)
ImBuf * RE_RenderLayerGetPassImBuf(RenderLayer *rl, const char *name, const char *viewname)
static void do_render_full_pipeline(Render *re)
void BKE_callback_exec_id(Main *bmain, ID *id, eCbEvent evt)
Definition callbacks.cc:45
void render_result_rect_get_pixels(RenderResult *rr, uint8_t *rect, int rectx, int recty, const ColorManagedViewSettings *view_settings, const ColorManagedDisplaySettings *display_settings, const int view_id)
void RE_FreePersistentData(const Scene *scene)
void GPU_render_begin()
Vector< bke::path_templates::Error > BKE_image_path_from_imformat(char *filepath, const char *base, const char *relbase, const bke::path_templates::VariableMap *template_variables, int frame, const ImageFormatData *im_format, bool use_ext, bool use_frames, const char *suffix)
auto BKE_blender_project_read_callback(const Main *bmain, Fn lambda)
void RE_prepare_viewlayer_cb(Render *re, void *handle, bool(*f)(void *handle, ViewLayer *vl, Depsgraph *depsgraph))
void FRS_end_stroke_rendering(struct Render *re)
void(*) MEM_reset_peak_memory()
int BKE_scene_multiview_num_views_get(const RenderData *rd)
Definition scene.cc:3193
static bool render_init_from_main(Render *re, const RenderData *rd, Main *bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, const bool anim, const bool anim_init)
void BLI_rw_mutex_lock(ThreadRWMutex *mutex, int mode)
Definition threads.cc:470
void render_result_rect_fill_zero(RenderResult *rr, const int view_id)
Render * RE_NewRender(const void *owner)
static bool is_compositing_possible_on_gpu(Scene *scene, ReportList *reports)
bool RE_allow_render_generic_object(Object *ob)
ImBuf * RE_render_result_rect_to_ibuf(RenderResult *rr, const ImageFormatData *imf, const float dither, const int view_id)
ImBuf * IMB_stereo3d_ImBuf(const ImageFormatData *im_format, ImBuf *ibuf_left, ImBuf *ibuf_right)
static void render_pipeline_free(Render *re)
void FRS_init_stroke_renderer(struct Render *re)
void BKE_render_resolution(const RenderData *r, const bool use_crop, int *r_width, int *r_height)
Definition scene.cc:3168
RenderPass * render_layer_add_pass(RenderResult *rr, RenderLayer *rl, int channels, const char *name, const char *viewname, const char *chan_id, const bool allocate)
AnimationEvalContext BKE_animsys_eval_context_construct(Depsgraph *depsgraph, float eval_time) ATTR_WARN_UNUSED_RESULT
Definition anim_sys.cc:602
MovieWriter * MOV_write_begin(const Scene *scene, const bke::BlenderProject *project, const RenderData *rd, const ImageFormatData *imf, int rectx, int recty, ReportList *reports, bool preview, const char *suffix)
static bool seq_result_needs_float(const ImageFormatData &im_format)
const char * RE_engine_id_BLENDER_EEVEE
Definition scene.cc:1717
void DEG_graph_build_for_render_pipeline(Depsgraph *graph)
Object * BKE_view_layer_camera_find(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
void MOV_write_end(MovieWriter *writer)
void BKE_add_template_variables_for_render_path(bke::path_templates::VariableMap &variables, const Scene &scene)
void RE_engine_free(RenderEngine *engine)
Global G
Definition blender.cc:57
static void render_callback_exec_string(Render *re, Main *bmain, eCbEvent evt, const char *str)
const char * BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL()
Definition main.cc:1058
void RE_FreeRenderResult(RenderResult *rr)
void BKE_scene_ppm_get(const RenderData *rd, double r_ppm[2])
Definition scene.cc:3487
void RE_current_scene_update_cb(Render *re, void *handle, void(*f)(void *handle, Scene *scene))
static void touch_file(const char *filepath)
const char * RE_GetActiveRenderView(Render *re)
void FRS_do_stroke_rendering(struct Render *re, struct ViewLayer *view_layer)
AnimData * BKE_animdata_from_id(const ID *id)
Definition anim_data.cc:93
static void current_scene_nothing(void *, Scene *)
static int check_valid_camera(const Main &bmain, Scene *scene, Object *camera_override, ReportList *reports)
void IMB_float_from_byte(ImBuf *ibuf)
static struct blender::@317271233062021340017161275322141305157341246107 RenderGlobal
ImBuf * IMB_load_image_from_filepath(const char *filepath, ImBufFlags flags, ColorManagedColorspaceSettings *colorspace_settings=nullptr)
Definition readimage.cc:201
static void stats_update(void *arg, RenderStats *rs)
static void render_result_uncrop(Render *re)
@ SNODE_COMPOSITOR_SCENE
int BKE_render_num_threads(const RenderData *r)
Definition scene.cc:3141
int BLI_findstringindex(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:794
Render * RE_GetSceneRender(const Scene *scene)
void RE_progress_cb(Render *re, void *handle, void(*f)(void *handle, float))
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition BLI_rect.hh:207
static void get_videos_dimensions(const Render *re, const RenderData *rd, const ImageFormatData *imf, size_t *r_width, size_t *r_height)
void IMB_freeImBuf(ImBuf *ibuf)
VecBase< int32_t, 2 > int2
Scene * WM_window_get_active_scene(const wmWindow *win)
bool MOV_write_append(MovieWriter *writer, const Scene *scene, const bke::BlenderProject *project, const RenderData *rd, const ImageFormatData *imf, int start_frame, int frame, const ImBuf *image, const char *suffix, ReportList *reports)
static void render_init_depsgraph(Render *re)
struct Object * BKE_camera_multiview_render(const Main &bmain, const struct Scene *scene, struct Object *camera, const char *viewname)
void render_result_passes_allocated_ensure(RenderResult *rr)
void FRS_exit(void)
RenderResult * render_result_new_from_exr(ExrReadHandle *exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
void GPU_render_end()
RenderResult * RE_AcquireResultWrite(Render *re)
static bool scene_has_any_compositor_output(const Scene &scene)
void BLI_rw_mutex_unlock(ThreadRWMutex *mutex)
Definition threads.cc:480
static void render_update_depsgraph(Render *re)
@ SCE_COMPOSITOR_DEVICE_GPU
float BKE_scene_frame_get(const Scene *scene)
Definition scene.cc:2595
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
bool WM_jobs_has_running(const wmWindowManager *window_manager, const void *owner, const eWM_JobType type, const eWM_JobFlag exclude_flags)
Definition wm_jobs.cc:809
static bool do_write_image_or_movie(Render *re, Main *bmain, Scene *scene, const int totvideos, const char *filepath_override, const bool write_anim_or_still)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
static bool render_scene_has_layers_to_render(Scene *scene, ViewLayer *single_layer)
bool RE_WriteRenderViewsMovie(ReportList *reports, RenderResult *rr, const bke::BlenderProject *project, Scene *scene, const RenderData *rd, MovieWriter **movie_writers, const int totvideos, bool preview)
static void re_free_persistent_data(Render *re)
int BLI_delete(const char *path, bool dir, bool recursive) ATTR_NONNULL()
static void re_gpu_texture_caches_free(Render *re)
unsigned char uint8_t
Definition BKE_text.h:79
MINLINE void copy_v2_v2_db(double r[2], const double a[2])
bool RE_ResultIsMultiView(RenderResult *rr)
void RE_display_ensure_gpu_context(Render *re)
const char * BKE_scene_multiview_view_id_suffix_get(const RenderData *rd, int view_id)
Definition scene.cc:3407
void render_result_free_gpu_texture_caches(RenderResult *rr)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
float * RE_RenderLayerGetPass(RenderLayer *rl, const char *name, const char *viewname)
void render_result_free(RenderResult *rr)
RenderResult * RE_MultilayerConvert(ExrReadHandle *exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
void BKE_ptcache_bake(struct PTCacheBaker *baker)
void DEG_debug_name_set(Depsgraph *depsgraph, const char *name)
int BLI_thread_is_main()
Definition threads.cc:184
void IMB_partial_update_mark_full(ImBuf *ibuf)
bool RE_is_rendering_allowed(const Main &bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, ReportList *reports)
static void do_render_engine(Render *re)
bool BLI_file_touch(const char *filepath) ATTR_NONNULL(1)
Definition fileops_c.cc:318
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition BLI_rect.hh:203
int BLI_listbase_count_at_most(const ListBase *listbase, int count_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:518
RenderEngineType * RE_engines_find(const char *idname)
void BKE_image_format_free(ImageFormatData *imf)
void BKE_scene_multiview_videos_dimensions_get(const RenderData *rd, const ImageFormatData *imf, size_t width, size_t height, size_t *r_width, size_t *r_height)
Definition scene.cc:3448
void BKE_image_format_init_for_write(ImageFormatData *imf, const Scene *scene_src, const ImageFormatData *imf_src, const bool allow_video=false)
static void re_init_resolution(Render *re, Render *source, int winx, int winy, const rcti *disprect)
void BKE_imbuf_stamp_info(const RenderResult *rr, ImBuf *ibuf)
void RE_result_load_from_file(RenderResult *result, ReportList *reports, const char *filepath)
ImBuf * IMB_colormanagement_imbuf_for_write(ImBuf *ibuf, bool save_as_render, bool allocate_result, const ImageFormatData *image_format)
size_t BLI_file_size(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition storage.cc:228
bool BKE_imtype_is_movie(char imtype)
void RE_display_share(Render *re, const Render *parent_re)
RenderResult * RE_AcquireResultRead(Render *re)
void BKE_animsys_evaluate_animdata(ID *id, AnimData *adt, const AnimationEvalContext *anim_eval_context, eAnimData_Recalc recalc, bool flush_to_original)
Definition anim_sys.cc:3716
RenderPass * RE_pass_find_by_name(RenderLayer *rl, const char *name, const char *viewname)
bool RE_engine_render(Render *re, bool do_all)
int BKE_scene_multiview_num_videos_get(const RenderData *rd, const ImageFormatData *imf)
Definition scene.cc:3469
void RE_InitState(Render *re, Render *source, const RenderData *rd, ListBaseT< ViewLayer > *, ViewLayer *single_layer, int winx, int winy, const rcti *disprect)
void render_result_clone_passes(Render *re, RenderResult *rr, const char *viewname)
void FRS_begin_stroke_rendering(struct Render *re)
bool RE_passes_have_name(RenderLayer *rl)
static void do_render_compositor_scene(Render *re, Scene *sce, int cfra)
RenderEngine * RE_engine_create(RenderEngineType *type)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
void RE_compositor_execute(const render::CompositorInputData input_data)
T * DEG_get_original(T *id)
void BKE_curvemapping_free_data(CurveMapping *cumap)
static void renderresult_stampinfo(Render *re)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
void RE_layer_load_from_file(RenderLayer *layer, ReportList *reports, const char *filepath, int x, int y)
float BKE_scene_ctime_get(const Scene *scene)
Definition scene.cc:2581
void RE_display_update_cb(Render *re, void *handle, void(*f)(void *handle, RenderResult *rr))
bool BKE_scene_camera_switch_update(Scene *scene)
Definition scene.cc:2480
void RE_draw_lock_cb(Render *re, void *handle, void(*f)(void *handle, bool lock))
std::mutex Mutex
Definition BLI_mutex.hh:51
Render * RE_NewSceneRender(const Scene *scene)
void RE_RenderAnim(Render *re, Main *bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, int sfra, int efra, int tfra)
bool RE_disable_save_output_allowed(const bool is_animation, Scene &scene, ReportList *reports)
@ ID_RECALC_AUDIO_MUTE
Definition DNA_ID.h:1129
ViewRender * RE_NewViewRender(RenderEngineType *engine_type)
static bool check_valid_compositing_camera(const Main &bmain, Scene *scene, Object *camera_override, ReportList *reports)
@ R_IMF_VIEWS_INDIVIDUAL
@ R_IMF_VIEWS_STEREO_3D
void DEG_evaluate_on_framechange(Depsgraph *graph, float frame, DepsgraphEvaluateSyncWriteback sync_writeback=DEG_EVALUATE_SYNC_WRITEBACK_NO)
static CLG_LogRef LOG
Definition logging.cpp:12
static bool scene_has_compositor_file_output(const Scene &scene)
double BLI_time_now_seconds()
Definition time.cc:30
RenderStats * RE_GetStats(Render *re)
@ RE_ENGINE_RENDERING
Definition RE_engine.h:67
static bool node_tree_has_linked_file_output(const bNodeTree *node_tree)
@ SCE_VIEWS_FORMAT_MULTIVIEW
Depsgraph * BKE_scene_ensure_depsgraph(Main *bmain, Scene *scene, ViewLayer *view_layer)
Definition scene.cc:3644
void RE_PreviewRender(Render *re, Main *bmain, Scene *sce)
void BKE_scene_update_sound(Depsgraph *depsgraph, Main *bmain)
Definition scene.cc:2750
ViewLayer * BKE_view_layer_context_active_PLACEHOLDER(const Scene *scene)
void RE_AcquireResultImageViews(Render *re, RenderResult *rr)
static void update_physics_cache(Render *re, Scene *scene, ViewLayer *view_layer, const bool)
void RE_SetCamera(Render *re, const Object *cam_ob)
Definition initrender.cc:42
@ CMP_NODE_CRYPTOMATTE_SOURCE_RENDER
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
ViewLayer * BKE_view_layer_default_render(const Scene *scene)
void render_result_single_layer_end(Render *re)
void RE_ReferenceRenderResult(RenderResult *rr)
bool RE_ReadRenderResult(Scene *scene, Scene *scenode)
void RE_ReleaseResultImageViews(Render *re, RenderResult *rr)
bScreen * WM_window_get_active_screen(const wmWindow *win)
static void do_render_sequencer(Render *re)
size_t BLI_timecode_string_from_time_simple(char *str, size_t maxncpy, double time_seconds) ATTR_NONNULL()
Definition timecode.cc:172
static void render_callback_exec_id(Render *re, Main *bmain, ID *id, eCbEvent evt)
void render_result_merge(RenderResult *rr, RenderResult *rrpart)
RenderResult * render_result_new(Render *re, const rcti *partrct, const char *layername, const char *viewname)
bool BLI_file_ensure_parent_dir_exists(const char *filepath) ATTR_NONNULL(1)
Definition fileops_c.cc:454
void render_result_view_new(RenderResult *rr, const char *viewname)
GHOST_IContext * RE_system_gpu_context_get(Render *re)
void RE_FreeViewRender(ViewRender *view_render)
void RE_AcquireResultImage(Render *re, RenderResult *rr, const int view_id)
static bool default_break(void *)
void render_copy_renderdata(RenderData *to, const RenderData *from)
void render_result_views_shallowcopy(RenderResult *dst, RenderResult *src)
static void do_render_compositor_scenes(Render *re, VectorSet< Scene * > &needed_scenes_to_render)
RenderLayer * render_get_single_layer(Render *re, RenderResult *rr)
void BKE_stamp_info_from_imbuf(RenderResult *rr, ImBuf *ibuf)
void IMB_copy_rect(float *dst, const int2 &dst_size, const float *src, const int2 &src_size, int channels, const int2 &src_rect_pos, const int2 &dst_rect_pos, const int2 &rect_size)
Definition rectop.cc:414
static void render_result_disprect_to_full_resolution(Render *re)
Object * RE_GetCamera(Render *re)
Definition initrender.cc:31
#define RR_ALL_VIEWS
#define RR_ALL_LAYERS
#define R_SKIP_WRITE
#define R_ANIMATION
std::shared_ptr< RenderDisplay > display
ThreadRWMutex resultmutex
RenderResult * result
struct RenderEngine * engine
ListBaseT< Strip > seqbase
char name[258]
Definition DNA_ID.h:433
ImBufFloatBuffer float_buffer
const uint8_t * byte_data() const
const float * float_data() const
float * float_data_for_write()
Definition allocimbuf.cc:79
eImageFormat_ViewsFormat views_format
eObject_TransFlag transflag
struct Depsgraph * depsgraph
struct ViewLayer * view_layer
ListBaseT< SceneRenderView > views
struct CurveMapping mblur_shutter_curve
ImageFormatData im_format
eCompositorDevice compositor_device
eSceneViews_Format views_format
void * ensure_blender_gpu_context()
GHOST_IContext * system_gpu_context
ListBaseT< RenderPass > passes
Definition RE_pipeline.h:99
char name[RE_MAXNAME]
Definition RE_pipeline.h:94
struct RenderPass * next
Definition RE_pipeline.h:58
struct ImBuf * ibuf
Definition RE_pipeline.h:72
struct StampData * stamp_data
ListBaseT< RenderView > views
ListBaseT< RenderLayer > layers
struct ImBuf * ibuf
RenderLayer * renlay
const char * infostr
struct ImBuf * ibuf
Definition RE_pipeline.h:54
struct RenderView * next
Definition RE_pipeline.h:46
struct Object * camera_override
const void * owner
bool result_has_gpu_texture_caches
void * prepare_vl_handle
Vector< MovieWriter * > movie_writers
RenderResult * pushedresult
struct ReportList * reports
RenderStats i
struct Main * main
render::Compositor * compositor
Scene * pipeline_scene_eval
struct Depsgraph * pipeline_depsgraph
bool(*) prepare_viewlayer_cb(void *handle, struct ViewLayer *vl, struct Depsgraph *depsgraph)
char viewname[MAX_NAME]
char single_view_layer[MAX_NAME]
ListBaseT< ViewLayer > view_layers
struct Editing * ed
ColorManagedViewSettings view_settings
struct Object * camera
ColorManagedDisplaySettings display_settings
ListBaseT< SceneCompositorEffect > compositor_effects
struct RenderData r
ListBaseT< SpaceLink > spacedata
struct bNodeTree * nodetree
eViewLayer_Flag flag
Map< const void *, Render * > interactive_compositor_renders
std::forward_list< Render * > render_list
eNodeTree_Type type
ListBaseT< struct ScrArea > areabase