Blender V5.3
render_internal.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstddef>
10#include <cstring>
11
12#include "MEM_guardedalloc.h"
13
14#include "BLI_listbase.hh"
15#include "BLI_math_base.hh"
16#include "BLI_string_utf8.hh"
17#include "BLI_string_utils.hh"
18#include "BLI_time.hh"
19#include "BLI_timecode.hh"
20#include "BLI_utildefines.hh"
21
22#include "BLT_translation.hh"
23
24#include "DNA_object_types.h"
25#include "DNA_scene_types.h"
26#include "DNA_userdef_types.h"
27#include "DNA_view3d_types.h"
28
29#include "BKE_callbacks.hh"
30#include "BKE_colortools.hh"
31#include "BKE_compositor.hh"
32#include "BKE_context.hh"
33#include "BKE_global.hh"
34#include "BKE_image.hh"
35#include "BKE_image_format.hh"
36#include "BKE_image_gpu.hh"
37#include "BKE_layer.hh"
38#include "BKE_lib_id.hh"
39#include "BKE_main.hh"
41#include "BKE_object.hh"
42#include "BKE_report.hh"
43#include "BKE_scene.hh"
44#include "BKE_screen.hh"
45
46#include "DEG_depsgraph.hh"
47
48#include "WM_api.hh"
49#include "WM_types.hh"
50
51#include "ED_render.hh"
52#include "ED_screen.hh"
53#include "ED_util.hh"
54
55#include "RE_engine.h"
56#include "RE_pipeline.h"
57
58#include "IMB_imbuf.hh"
59#include "IMB_imbuf_types.hh"
60#include "IMB_partial_update.hh"
61
62#include "RNA_access.hh"
63#include "RNA_define.hh"
64
65#include "SEQ_relations.hh"
66
67#include "render_intern.hh"
68
69namespace blender {
70
71/* Render Callbacks */
72static bool render_break(void *rjv);
73
99
100/* ****************************** render invoking ***************** */
101
102/* set callbacks, exported to sequence render too.
103 * Only call in foreground (UI) renders. */
104
106 wmOperator *op, Main *mainp, ViewLayer *active_layer, Scene **scene, ViewLayer **single_layer)
107{
108 /* single layer re-render */
109 if (RNA_struct_property_is_set(op->ptr, "scene")) {
110 Scene *scn;
111 char scene_name[MAX_ID_NAME - 2];
112
113 RNA_string_get(op->ptr, "scene", scene_name);
114 scn = static_cast<Scene *>(BLI_findstring(&mainp->scenes, scene_name, offsetof(ID, name) + 2));
115
116 if (scn) {
117 /* camera switch won't have updated */
118 scn->r.cfra = (*scene)->r.cfra;
120
121 *scene = scn;
122 }
123 }
124
125 if (RNA_struct_property_is_set(op->ptr, "layer")) {
126 ViewLayer *rl;
127 char rl_name[RE_MAXNAME];
128
129 RNA_string_get(op->ptr, "layer", rl_name);
130 rl = static_cast<ViewLayer *>(
131 BLI_findstring(&(*scene)->view_layers, rl_name, offsetof(ViewLayer, name)));
132
133 if (rl) {
134 *single_layer = rl;
135 }
136 }
137 else if (((*scene)->r.scemode & R_SINGLE_LAYER) && active_layer) {
138 *single_layer = active_layer;
139 }
140}
141
143{
144 return RNA_struct_property_is_set(render_operator->ptr, "frame_start") ||
145 RNA_struct_property_is_set(render_operator->ptr, "frame_end");
146}
147
148static void get_render_operator_frame_range(wmOperator *render_operator,
149 const Scene *scene,
150 int &frame_start,
151 int &frame_end)
152{
153 if (RNA_struct_property_is_set(render_operator->ptr, "frame_start")) {
154 frame_start = RNA_int_get(render_operator->ptr, "frame_start");
155 }
156 else {
157 frame_start = scene->r.sfra;
158 }
159
160 if (RNA_struct_property_is_set(render_operator->ptr, "frame_end")) {
161 frame_end = RNA_int_get(render_operator->ptr, "frame_end");
162 }
163 else {
164 frame_end = scene->r.efra;
165 }
166}
167
168/* executes blocking render */
170{
171 ViewLayer *single_layer = nullptr;
172 Render *re;
173 Image *ima;
174 View3D *v3d = CTX_wm_view3d(C);
175 Main *mainp = CTX_data_main(C);
176
177 const bool is_animation = RNA_boolean_get(op->ptr, "animation");
178 const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
179 const bool use_sequencer_scene = RNA_boolean_get(op->ptr, "use_sequencer_scene");
180
181 Scene *scene = use_sequencer_scene ? CTX_data_sequencer_scene(C) : CTX_data_scene(C);
182
183 if (scene == nullptr) {
185 RPT_ERROR,
186 use_sequencer_scene ? "No sequencer scene to render" : "No scene to render");
187 return OPERATOR_CANCELLED;
188 }
189
190 ViewLayer *active_layer = use_sequencer_scene ? BKE_view_layer_default_render(scene) :
192 RenderEngineType *re_type = RE_engines_find(scene->r.engine);
193 Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : nullptr;
194
195 /* Cannot do render if there is not this function. */
196 if (re_type->render == nullptr) {
197 return OPERATOR_CANCELLED;
198 }
199
200 if (use_sequencer_scene && !RE_seq_render_active(scene, &scene->r)) {
201 BKE_report(op->reports, RPT_ERROR, "No sequencer scene with video strips to render");
202 return OPERATOR_CANCELLED;
203 }
204
205 if (!is_animation && render_operator_has_custom_frame_range(op)) {
206 BKE_report(op->reports, RPT_ERROR, "Frame start/end specified in a non-animation render");
207 return OPERATOR_CANCELLED;
208 }
209
210 /* custom scene and single layer re-render */
211 screen_render_single_layer_set(op, mainp, active_layer, &scene, &single_layer);
212
213 int frame_start, frame_end;
214 get_render_operator_frame_range(op, scene, frame_start, frame_end);
215 if (is_animation && frame_start > frame_end) {
216 BKE_report(op->reports, RPT_ERROR, "Start frame is larger than end frame");
217 return OPERATOR_CANCELLED;
218 }
219
220 if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
222 op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
223 return OPERATOR_CANCELLED;
224 }
225
226 if (!RE_disable_save_output_allowed(is_animation, *scene, op->reports)) {
227 return OPERATOR_CANCELLED;
228 }
229
230 /* Flush sculpt and editmode changes. */
232
233 re = RE_NewSceneRender(scene);
234
235 G.is_break = false;
236
237 RE_draw_lock_cb(re, nullptr, nullptr);
238 RE_test_break_cb(re, nullptr, render_break);
239
240 ima = BKE_image_ensure_viewer(mainp, IMA_TYPE_R_RESULT, "Render Result");
241 BKE_image_signal(mainp, ima, nullptr, IMA_SIGNAL_FREE);
242 BKE_image_backup_render(scene, ima, true);
243
244 RE_SetReports(re, op->reports);
245
246 ED_render_view3d_auto_pause(mainp, true);
247
248 if (is_animation) {
249 RE_RenderAnim(re,
250 mainp,
251 scene,
252 single_layer,
253 camera_override,
254 frame_start,
255 frame_end,
256 scene->r.frame_step);
257 }
258 else {
260 mainp,
261 scene,
262 single_layer,
263 camera_override,
264 scene->r.cfra,
265 scene->r.subframe,
266 is_write_still);
267 }
268
269 RE_SetReports(re, nullptr);
270
271 ED_render_view3d_auto_pause(mainp, false);
272
273 const bool cancelled = G.is_break;
274
275 if (cancelled) {
277 if (rr && rr->error) {
278 /* NOTE(@ideasman42): Report, otherwise the error is entirely hidden from script authors.
279 * This is only done for the #wmOperatorType::exec function because it's assumed users
280 * rendering interactively will view the render and see the error message there. */
282 }
284 }
285
286 /* No redraw needed, we leave state as we entered it. */
288
290
291 if (cancelled) {
292 return OPERATOR_CANCELLED;
293 }
294 return OPERATOR_FINISHED;
295}
296
297static void render_freejob(void *rjv)
298{
299 RenderJob *rj = static_cast<RenderJob *>(rjv);
300
302 MEM_delete(rj);
303}
304
306 const Scene *scene,
307 const bool v3d_override,
308 const char *error,
310{
311 const char *info_space = " ";
312 const char *info_sep = "| ";
313 struct {
314 char time_last[32];
315 char time_elapsed[32];
316 char frame[16];
317 char statistics[64];
318 } info_buffers;
319
320 const char *ret_array[32];
321 int i = 0;
322
323 const uintptr_t mem_in_use = MEM_get_memory_in_use();
324 const uintptr_t peak_memory = MEM_get_peak_memory();
325
326 const int megs_used_memory = ceilf(mem_in_use / (1024.0 * 1024.0));
327 const int megs_peak_memory = ceilf(peak_memory / (1024.0 * 1024.0));
328
329 /* local view */
330 if (rs->localview) {
331 ret_array[i++] = RPT_("3D Local View ");
332 ret_array[i++] = info_sep;
333 }
334 else if (v3d_override) {
335 ret_array[i++] = RPT_("3D View ");
336 ret_array[i++] = info_sep;
337 }
338
339 /* frame number */
340 SNPRINTF_UTF8(info_buffers.frame, "%d ", scene->r.cfra);
341 ret_array[i++] = RPT_("Frame:");
342 ret_array[i++] = info_buffers.frame;
343
344 /* Previous and elapsed time. */
345 const char *info_time = info_buffers.time_last;
347 info_buffers.time_last, sizeof(info_buffers.time_last), rs->lastframetime);
348
349 ret_array[i++] = info_sep;
350 if (rs->infostr && rs->infostr[0]) {
351 if (rs->lastframetime != 0.0) {
352 ret_array[i++] = "Last:";
353 ret_array[i++] = info_buffers.time_last;
354 ret_array[i++] = info_space;
355 }
356
357 info_time = info_buffers.time_elapsed;
358 BLI_timecode_string_from_time_simple(info_buffers.time_elapsed,
359 sizeof(info_buffers.time_elapsed),
361 }
362
363 ret_array[i++] = RPT_("Time:");
364 ret_array[i++] = info_time;
365 ret_array[i++] = info_space;
366
367 /* Statistics. */
368 {
369 const char *info_statistics = nullptr;
370 if (rs->statstr) {
371 if (rs->statstr[0]) {
372 info_statistics = rs->statstr;
373 }
374 }
375 else {
376 if (rs->mem_peak == 0.0f) {
377 SNPRINTF_UTF8(info_buffers.statistics,
378 RPT_("Mem:%dM, Peak: %dM"),
379 megs_used_memory,
380 megs_peak_memory);
381 }
382 else {
384 info_buffers.statistics, RPT_("Mem:%dM, Peak: %dM"), rs->mem_used, rs->mem_peak);
385 }
386 info_statistics = info_buffers.statistics;
387 }
388
389 if (info_statistics) {
390 ret_array[i++] = info_sep;
391 ret_array[i++] = info_statistics;
392 ret_array[i++] = info_space;
393 }
394 }
395
396 /* Extra info. */
397 {
398 const char *info_extra = nullptr;
399 if (rs->infostr && rs->infostr[0]) {
400 info_extra = rs->infostr;
401 }
402 else if (error && error[0]) {
403 info_extra = error;
404 }
405
406 if (info_extra) {
407 ret_array[i++] = info_sep;
408 ret_array[i++] = info_extra;
409 ret_array[i++] = info_space;
410 }
411 }
412
413 if (G.debug & G_DEBUG) {
414 if (BLI_string_len_array(ret_array, i) >= IMA_MAX_RENDER_TEXT_SIZE) {
415 printf("WARNING! renderwin text beyond limit\n");
416 }
417 }
418
419 BLI_assert(i < int(BOUNDED_ARRAY_TYPE_SIZE<decltype(ret_array)>()));
421}
422
423static void image_renderinfo_cb(void *rjv, RenderStats *rs)
424{
425 RenderJob *rj = static_cast<RenderJob *>(rjv);
426 RenderResult *rr;
427
428 rr = RE_AcquireResultRead(rj->re);
429
430 if (rr) {
431 /* `malloc` is OK here, `stats_draw` is not in tile threads. */
432 if (rr->text == nullptr) {
434 }
435
436 make_renderinfo_string(rs, rj->scene, rj->v3d_override, rr->error, rr->text);
437 }
438
439 RE_ReleaseResult(rj->re);
440
441 if (rs->infostr != nullptr) {
443 }
444
445 /* make jobs timer to send notifier */
446 *(rj->do_update) = true;
447}
448
449static void render_progress_update(void *rjv, float progress)
450{
451 RenderJob *rj = static_cast<RenderJob *>(rjv);
452
453 if (rj->progress && *rj->progress != progress) {
454 *rj->progress = progress;
455
456 /* make jobs timer to send notifier */
457 *(rj->do_update) = true;
458 }
459}
460
461/* Not totally reliable, but works fine in most of cases and
462 * in worst case would just make it so extra color management
463 * for the whole render result is applied (which was already
464 * happening already).
465 */
467{
468 ScrArea *first_area = nullptr, *matched_area = nullptr;
469
470 /* image window, compo node users */
471
472 /* Only ever 1 `wm`. */
473 for (wmWindowManager *wm = rj->main->wm.first(); wm && matched_area == nullptr;
474 wm = static_cast<wmWindowManager *>(wm->id.next))
475 {
476 wmWindow *win;
477 for (win = wm->windows.first(); win && matched_area == nullptr; win = win->next) {
478 const bScreen *screen = WM_window_get_active_screen(win);
479
480 for (ScrArea &area : screen->areabase) {
481 if (area.spacetype == SPACE_IMAGE) {
482 SpaceImage *sima = area.spacedata.first_as<SpaceImage>();
483 /* area->spacedata might be empty when toggling full-screen mode. */
484 if (sima != nullptr && sima->image == rj->image) {
485 if (first_area == nullptr) {
486 first_area = &area;
487 }
488 if (&area == rj->area) {
489 matched_area = &area;
490 break;
491 }
492 }
493 }
494 }
495 }
496 }
497
498 if (matched_area == nullptr) {
499 matched_area = first_area;
500 }
501
502 if (matched_area) {
503 SpaceImage *sima = matched_area->spacedata.first_as<SpaceImage>();
504 RenderResult *main_rr = RE_AcquireResultRead(rj->re);
505
506 /* TODO(sergey): is there faster way to get the layer index? */
507 if (rr->renlay) {
509 &main_rr->layers, static_cast<char *>(rr->renlay->name), offsetof(RenderLayer, name));
510 sima->iuser.layer = layer;
511 rj->last_layer = layer;
512 }
513
514 iuser->pass = sima->iuser.pass;
515 iuser->layer = sima->iuser.layer;
516
517 RE_ReleaseResult(rj->re);
518 }
519}
520
521static void image_rect_update(void *rjv, RenderResult *rr)
522{
523 RenderJob *rj = static_cast<RenderJob *>(rjv);
524 Image *ima = rj->image;
525
526 /* only update if we are displaying the slot being rendered */
527 if (ima->render_slot != ima->last_render_slot) {
528 rj->image_outdated = true;
529 return;
530 }
531 if (rj->image_outdated) {
532 /* Free all render buffer caches when switching slots, with lock to ensure main
533 * thread is not drawing the buffer at the same time. */
534 rj->image_outdated = false;
535 void *lock;
536 ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
538 BKE_image_release_ibuf(ima, ibuf, lock);
539 *(rj->do_update) = true;
540 return;
541 }
542
543 if (rr == nullptr) {
544 return;
545 }
546
547 /* Update layer and pass to be displayed, and tag update to redraw. */
549 *(rj->do_update) = true;
550}
551
552static void current_scene_update(void *rjv, Scene *scene)
553{
554 RenderJob *rj = static_cast<RenderJob *>(rjv);
555 rj->current_scene = scene;
556 rj->iuser.scene = scene;
557}
558
559static void render_startjob(void *rjv, wmJobWorkerStatus *worker_status)
560{
561 RenderJob *rj = static_cast<RenderJob *>(rjv);
562
563 rj->stop = &worker_status->stop;
564 rj->do_update = &worker_status->do_update;
565 rj->progress = &worker_status->progress;
566
567 RE_SetReports(rj->re, rj->reports);
568
569 if (rj->anim) {
570 RE_RenderAnim(rj->re,
571 rj->main,
572 rj->scene,
573 rj->single_layer,
574 rj->camera_override,
575 rj->frame_start,
576 rj->frame_end,
577 rj->scene->r.frame_step);
578 }
579 else {
580 RE_RenderFrame(rj->re,
581 rj->main,
582 rj->scene,
583 rj->single_layer,
584 rj->camera_override,
585 rj->scene->r.cfra,
586 rj->scene->r.subframe,
587 rj->write_still);
588 }
589
590 RE_SetReports(rj->re, nullptr);
591}
592
594{
595 /* image window, compo node users */
596
597 /* Only ever 1 `wm`. */
598 for (wmWindowManager &wm : rj->main->wm) {
599 for (wmWindow &win : wm.windows) {
600 const bScreen *screen = WM_window_get_active_screen(&win);
601
602 for (ScrArea &area : screen->areabase) {
603 if (&area == rj->area) {
604 if (area.spacetype == SPACE_IMAGE) {
605 SpaceImage *sima = area.spacedata.first_as<SpaceImage>();
606
607 /* Automatically show scene we just rendered. */
610
611 if (RE_HasSingleLayer(rj->re)) {
612 /* For single layer renders keep the active layer
613 * visible, or show the compositing result. */
615 if (RE_HasCombinedLayer(rr)) {
616 sima->iuser.layer = 0;
617 }
618 RE_ReleaseResult(rj->re);
619 }
620 else {
621 /* For multiple layer render, set back the layer
622 * that was set at the start of rendering. */
623 sima->iuser.layer = rj->orig_layer;
624 }
625 }
626 return;
627 }
628 }
629 }
630 }
631}
632
633static void render_endjob(void *rjv)
634{
635 RenderJob *rj = static_cast<RenderJob *>(rjv);
636
637 /* Clear display GPU context and callbacks since this may be used again
638 * by e.g. the sequencer (#24508). */
639 RE_display_free(rj->re);
640
641 if (rj->main != G_MAIN) {
642 BKE_main_free(rj->main);
643 }
644
645 /* Update depsgraph for returning to the original frame before animation render job. */
646 if (rj->anim && !(rj->scene->r.scemode & R_NO_FRAME_UPDATE)) {
647 /* Possible this fails when loading new file while rendering. */
648 if (G_MAIN->wm.first_) {
649 /* Check view layer was not deleted during render. Technically another view layer
650 * may get allocated with the same pointer, but worst case it will cause an
651 * unnecessary update. */
652 if (BLI_findindex(&rj->scene->view_layers, rj->view_layer) != -1) {
653 Depsgraph *depsgraph = BKE_scene_get_depsgraph(rj->scene, rj->view_layer);
654 if (depsgraph) {
655 ED_update_for_newframe(G_MAIN, depsgraph);
656 }
657 }
658 }
659 }
660
661 /* potentially set by caller */
663
664 if (rj->single_layer) {
668 }
669
670 if (rj->area) {
672 }
673
674 /* XXX render stability hack */
675 G.is_rendering = false;
678
679 /* Finally unlock the user interface (if it was locked). */
680 if (rj->interface_locked) {
681 /* Interface was locked, so window manager couldn't have been changed
682 * and using one from Global will unlock exactly the same manager as
683 * was locked before running the job.
684 */
685 WM_locked_interface_set(G_MAIN->wm.first(), false);
687 }
688
689 /* Resume viewport render engines now that the final render is complete. */
691}
692
693/* called by render, check job 'stop' value or the global */
694static bool render_breakjob(void *rjv)
695{
696 RenderJob *rj = static_cast<RenderJob *>(rjv);
697
698 if (G.is_break) {
699 return true;
700 }
701 if (rj->stop && *(rj->stop)) {
702 return true;
703 }
704 return false;
705}
706
711static bool render_break(void * /*rjv*/)
712{
713 if (G.is_break) {
714 return true;
715 }
716 return false;
717}
718
719/* runs in thread, no cursor setting here works. careful with notifiers too (`malloc` conflicts) */
720/* maybe need a way to get job send notifier? */
721static void render_drawlock(void *rjv, bool lock)
722{
723 RenderJob *rj = static_cast<RenderJob *>(rjv);
724
725 /* If interface is locked, renderer callback shall do nothing. */
726 if (!rj->interface_locked) {
728 }
729}
730
733{
734 Scene *scene = static_cast<Scene *>(op->customdata);
735
736 /* no running blender, remove handler and pass through */
739 }
740
741 /* running render */
743}
744
746{
748 Scene *scene = static_cast<Scene *>(op->customdata);
749
750 /* kill on cancel, because job is using op->reports */
752}
753
755{
757 return;
758 }
759
760 Object *object = base->object;
761
762 if (object->id.tag & ID_TAG_DOIT) {
763 return;
764 }
765
766 object->id.tag &= ~ID_TAG_DOIT;
767 if (RE_allow_render_generic_object(object)) {
769 }
770}
771
772static void clean_viewport_memory(Main *bmain, Scene *scene)
773{
774 Scene *sce_iter;
775 Base *base;
776
777 /* Tag all the available objects. */
778 BKE_main_id_tag_listbase(&bmain->objects.cast<ID>(), ID_TAG_DOIT, true);
779
780 /* Go over all the visible objects. */
781
782 /* Only ever 1 `wm`. */
783 for (wmWindowManager &wm : bmain->wm) {
784 for (wmWindow &win : wm.windows) {
785 ViewLayer *view_layer = WM_window_get_active_view_layer(&win);
786 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
787
788 for (Base &b : *BKE_view_layer_object_bases_get(view_layer)) {
790 }
791 }
792 }
793
794 for (SETLOOPER_SET_ONLY(*bmain, scene, sce_iter, base)) {
796 }
797}
798
799/* using context, starts job */
801{
802 /* new render clears all callbacks */
803 Main *bmain = CTX_data_main(C);
804 ViewLayer *single_layer = nullptr;
805 Render *re;
806 wmJob *wm_job;
807 RenderJob *rj;
808 Image *ima;
809 ScrArea *area;
810
811 const bool is_animation = RNA_boolean_get(op->ptr, "animation");
812 const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
813 const bool use_viewport = RNA_boolean_get(op->ptr, "use_viewport");
814 const bool use_sequencer_scene = RNA_boolean_get(op->ptr, "use_sequencer_scene");
815
816 View3D *v3d = use_viewport ? CTX_wm_view3d(C) : nullptr;
817 Scene *scene = use_sequencer_scene ? CTX_data_sequencer_scene(C) : CTX_data_scene(C);
818
819 if (scene == nullptr) {
821 RPT_ERROR,
822 use_sequencer_scene ? "No sequencer scene to render" : "No scene to render");
823 return OPERATOR_CANCELLED;
824 }
825
826 ViewLayer *active_layer = use_sequencer_scene ? BKE_view_layer_default_render(scene) :
828 RenderEngineType *re_type = RE_engines_find(scene->r.engine);
829 Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : nullptr;
830
831 /* Cannot do render if there is not this function. */
832 if (re_type->render == nullptr) {
833 return OPERATOR_CANCELLED;
834 }
835
836 if (use_sequencer_scene && !RE_seq_render_active(scene, &scene->r)) {
837 BKE_report(op->reports, RPT_ERROR, "No sequencer scene with video strips to render");
838 return OPERATOR_CANCELLED;
839 }
840
841 if (!is_animation && render_operator_has_custom_frame_range(op)) {
842 BKE_report(op->reports, RPT_ERROR, "Frame start/end specified in a non-animation render");
843 return OPERATOR_CANCELLED;
844 }
845
846 /* custom scene and single layer re-render */
847 screen_render_single_layer_set(op, bmain, active_layer, &scene, &single_layer);
848
849 int frame_start, frame_end;
850 get_render_operator_frame_range(op, scene, frame_start, frame_end);
851 if (is_animation && frame_start > frame_end) {
852 BKE_report(op->reports, RPT_ERROR, "Start frame is larger than end frame");
853 return OPERATOR_CANCELLED;
854 }
855
856 /* only one render job at a time */
858 return OPERATOR_CANCELLED;
859 }
860
861 if (!RE_disable_save_output_allowed(is_animation, *scene, op->reports)) {
862 return OPERATOR_CANCELLED;
863 }
864
865 if (!RE_is_rendering_allowed(*bmain, scene, single_layer, camera_override, op->reports)) {
866 return OPERATOR_CANCELLED;
867 }
868
869 if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
871 op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
872 return OPERATOR_CANCELLED;
873 }
874
875 /* Reports are done inside check function, and it will return false if there are other strips to
876 * render. */
877 if ((scene->r.scemode & R_DOSEQ) && seq::relations_check_scene_recursion(scene, op->reports)) {
878 return OPERATOR_CANCELLED;
879 }
880
881 /* stop all running jobs, except screen one. currently previews frustrate Render */
883
884 /* cancel animation playback */
887 }
888
889 /* handle UI stuff */
890 WM_cursor_wait(true);
891
892 /* Flush sculpt and editmode changes. */
894
895 /* store spare
896 * get view3d layer, local layer, make this nice API call to render
897 * store spare */
898
899 /* ensure at least 1 area shows result */
900 area = render_view_open(C, event->xy[0], event->xy[1], op->reports);
901
902 /* job custom data */
903 rj = MEM_new<RenderJob>("render job");
904 rj->main = bmain;
905 rj->scene = scene;
906 rj->current_scene = rj->scene;
907 rj->view_layer = active_layer;
908 rj->single_layer = single_layer;
909 rj->camera_override = camera_override;
910 rj->anim = is_animation;
911 rj->write_still = is_write_still && !is_animation;
912 rj->iuser.scene = scene;
913 rj->reports = op->reports;
914 rj->orig_layer = 0;
915 rj->last_layer = 0;
916 rj->use_sequencer_scene = use_sequencer_scene;
917 rj->area = area;
918 rj->frame_start = frame_start;
919 rj->frame_end = frame_end;
920
923
924 if (area) {
925 SpaceImage *sima = area->spacedata.first_as<SpaceImage>();
926 rj->orig_layer = sima->iuser.layer;
927 }
928
929 if (v3d) {
930 if (camera_override && camera_override != scene->camera) {
931 rj->v3d_override = true;
932 }
933 }
934
935 /* Lock the user interface depending on render settings. */
936 if (scene->r.use_lock_interface) {
938
939 /* Set flag interface need to be unlocked.
940 *
941 * This is so because we don't have copy of render settings
942 * accessible from render job and copy is needed in case
943 * of non-locked rendering, so we wouldn't try to unlock
944 * anything if option was initially unset but then was
945 * enabled during rendering.
946 */
947 rj->interface_locked = true;
948
949 /* Clean memory used by viewport? */
950 clean_viewport_memory(rj->main, scene);
951 }
952
953 /* setup job */
954 const char *name;
955 if (RE_seq_render_active(scene, &scene->r)) {
956 name = RPT_("Rendering sequence...");
957 }
958 else {
959 name = RPT_("Rendering...");
960 }
961
962 wm_job = WM_jobs_get(CTX_wm_manager(C),
964 scene,
965 name,
969 WM_jobs_timer(wm_job, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
970 WM_jobs_callbacks(wm_job, render_startjob, nullptr, nullptr, render_endjob);
971
972 if (RNA_struct_property_is_set(op->ptr, "layer")) {
973 WM_jobs_delay_start(wm_job, 0.2);
974 }
975
976 /* get a render result image, and make sure it is empty */
977 ima = BKE_image_ensure_viewer(bmain, IMA_TYPE_R_RESULT, "Render Result");
978 BKE_image_signal(rj->main, ima, nullptr, IMA_SIGNAL_FREE);
979 BKE_image_backup_render(rj->scene, ima, true);
980 rj->image = ima;
981
982 /* setup new render */
983 re = RE_NewSceneRender(scene);
984 RE_display_init(re);
993
994 rj->re = re;
995 G.is_break = false;
996
997 /* store actual owner of job, so modal operator could check for it,
998 * the reason of this is that active scene could change when rendering
999 * several layers from compositor #31800. */
1000 op->customdata = scene;
1001
1002 /* Pause viewport render engines for the duration of the final render. */
1003 ED_render_view3d_auto_pause(bmain, true);
1004
1005 WM_jobs_start(CTX_wm_manager(C), wm_job);
1006
1007 WM_cursor_wait(false);
1009
1010 /* we set G.is_rendering here already instead of only in the job, this ensure
1011 * main loop or other scene updates are disabled in time, since they may
1012 * have started before the job thread */
1013 G.is_rendering = true;
1014
1015 /* add modal handler for ESC */
1017
1019}
1020
1021static std::string screen_render_get_description(bContext * /*C*/,
1022 wmOperatorType * /*ot*/,
1023 PointerRNA *ptr)
1024{
1025 const bool use_sequencer_scene = RNA_boolean_get(ptr, "use_sequencer_scene");
1026 if (use_sequencer_scene) {
1027 return TIP_("Render active sequencer scene");
1028 }
1029 return TIP_("Render active scene");
1030}
1031
1033{
1034 PropertyRNA *prop;
1035
1036 /* identifiers */
1037 ot->name = "Render";
1038 ot->idname = "RENDER_OT_render";
1039
1040 /* API callbacks. */
1046
1047 /* This isn't needed, causes failure in background mode. */
1048#if 0
1050#endif
1051
1052 prop = RNA_def_boolean(ot->srna,
1053 "animation",
1054 false,
1055 "Animation",
1056 "Render files from the animation range of this scene");
1059 ot->srna,
1060 "write_still",
1061 false,
1062 "Write Image",
1063 "Save the rendered image to the output path (used only when animation is disabled)");
1064 prop = RNA_def_boolean(ot->srna,
1065 "use_viewport",
1066 false,
1067 "Use 3D Viewport",
1068 "When inside a 3D viewport, use layers and camera of the viewport");
1070 prop = RNA_def_boolean(ot->srna,
1071 "use_sequencer_scene",
1072 false,
1073 "Use Sequencer Scene",
1074 "Render the sequencer scene instead of the active scene");
1076 prop = RNA_def_string(ot->srna,
1077 "layer",
1078 nullptr,
1079 RE_MAXNAME,
1080 "Render Layer",
1081 "Single render layer to re-render (used only when animation is disabled)");
1083 prop = RNA_def_string(ot->srna,
1084 "scene",
1085 nullptr,
1086 MAX_ID_NAME - 2,
1087 "Scene",
1088 "Scene to render, current scene if not specified");
1090 prop = RNA_def_int(
1091 ot->srna,
1092 "frame_start",
1093 0,
1094 INT_MIN,
1095 INT_MAX,
1096 "Start Frame",
1097 "Frame to start rendering animation at. If not specified, the scene start frame will be "
1098 "assumed. This should only be specified if doing an animation render",
1099 INT_MIN,
1100 INT_MAX);
1102 prop = RNA_def_int(
1103 ot->srna,
1104 "frame_end",
1105 0,
1106 INT_MIN,
1107 INT_MAX,
1108 "End Frame",
1109 "Frame to end rendering animation at. If not specified, the scene end frame will be "
1110 "assumed. This should only be specified if doing an animation render",
1111 INT_MIN,
1112 INT_MAX);
1114}
1115
1117{
1119 RenderJobBase *rj;
1120
1121 /* Try to find job tied to active scene first. */
1122 rj = static_cast<RenderJobBase *>(
1124
1125 /* If not found, attempt to find job tied to sequencer scene. */
1126 if (rj == nullptr) {
1127 return static_cast<RenderJobBase *>(
1129 }
1130
1131 return rj;
1132}
1133
1135{
1137 return rj ? rj->scene : nullptr;
1138}
1139
1141{
1143 return rj ? rj->current_scene : nullptr;
1144}
1145
1146/* Motion blur curve preset */
1147
1149{
1150 Scene *scene = CTX_data_scene(C);
1151 CurveMapping *mblur_shutter_curve = &scene->r.mblur_shutter_curve;
1152 CurveMap *cm = mblur_shutter_curve->cm;
1154
1155 mblur_shutter_curve->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
1156 mblur_shutter_curve->preset = preset;
1158 &mblur_shutter_curve->clipr,
1159 mblur_shutter_curve->preset,
1161 BKE_curvemapping_changed(mblur_shutter_curve, false);
1162
1163 return OPERATOR_FINISHED;
1164}
1165
1167{
1168 PropertyRNA *prop;
1169 static const EnumPropertyItem prop_shape_items[] = {
1170 {CURVE_PRESET_SHARP, "SHARP", 0, "Sharp", ""},
1171 {CURVE_PRESET_SMOOTH, "SMOOTH", 0, "Smooth", ""},
1172 {CURVE_PRESET_MAX, "MAX", 0, "Max", ""},
1173 {CURVE_PRESET_LINE, "LINE", 0, "Line", ""},
1174 {CURVE_PRESET_ROUND, "ROUND", 0, "Round", ""},
1175 {CURVE_PRESET_ROOT, "ROOT", 0, "Root", ""},
1176 {0, nullptr, 0, nullptr, nullptr},
1177 };
1178
1179 ot->name = "Shutter Curve Preset";
1180 ot->description = "Set shutter curve";
1181 ot->idname = "RENDER_OT_shutter_curve_preset";
1182
1184
1185 prop = RNA_def_enum(ot->srna, "shape", prop_shape_items, CURVE_PRESET_SMOOTH, "Mode", "");
1187 BLT_I18NCONTEXT_ID_CURVE_LEGACY); /* Abusing id_curve :/ */
1188}
1189
1190} // namespace blender
#define G_MAIN
#define IMA_SIGNAL_FREE
Definition BKE_image.hh:179
General operations, lookup, etc. for blender objects.
#define SETLOOPER_SET_ONLY(_bmain, _sce_basis, _sce_iter, _base)
Definition BKE_scene.hh:55
#define SNPRINTF_UTF8(dst, format,...)
Platform independent time functions.
#define RPT_(msgid)
#define BLT_I18NCONTEXT_ID_CURVE_LEGACY
#define TIP_(msgid)
#define MAX_ID_NAME
Definition DNA_ID.h:367
#define IMA_MAX_RENDER_TEXT_SIZE
Object is a sort of wrapper for general info.
#define V3D_CAMERA_LOCAL(v3d)
Read Blender memory allocation and freeing.
#define RE_MAXNAME
Definition RE_pipeline.h:42
#define C
Definition RandGen.cpp:29
#define NC_NODE
Definition WM_types.hh:407
#define ND_RENDER_RESULT
Definition WM_types.hh:465
#define NC_SCENE
Definition WM_types.hh:391
#define NA_EDITED
Definition WM_types.hh:634
volatile int lock
#define SET_FLAG_FROM_TEST(value, test, flag)
#define offsetof(t, d)
#define INT_MAX
#define layer
bool relations_check_scene_recursion(Scene *scene, ReportList *reports)
BMesh Iterators.
Scene * ED_render_job_get_scene(const bContext *C)
void WM_main_add_notifier(uint type, void *reference)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
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)
void BKE_callback_exec_string(Main *bmain, const char *str, eCbEvent evt)
Definition callbacks.cc:76
int RNA_enum_get(PointerRNA *ptr, const char *name)
bool RE_seq_render_active(Scene *scene, const RenderData *rd)
void BKE_ntree_update(Main &bmain, std::optional< Span< bNodeTree * > > modified_trees=std::nullopt, const NodeTreeUpdateExtraParams &params={})
void RE_SetReports(Render *re, ReportList *reports)
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, const int maxlen, const char *ui_name, const char *ui_description)
bool ED_editors_flush_edits(Main *bmain)
Definition ed_util.cc:335
Scene * CTX_data_sequencer_scene(const bContext *C)
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition wm_jobs.cc:407
void WM_jobs_delay_start(wmJob *wm_job, double delay_time)
Definition wm_jobs.cc:402
void WM_jobs_kill_all_except(wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:633
bool RE_HasCombinedLayer(const RenderResult *result)
void RE_stats_draw_cb(Render *re, void *handle, void(*f)(void *handle, RenderStats *rs))
@ BKE_CB_EVT_RENDER_STATS
void RE_test_break_cb(Render *re, void *handle, bool(*f)(void *handle))
void BKE_ntree_update_tag_id_changed(Main *bmain, ID *id)
static void current_scene_update(void *rjv, Scene *scene)
Depsgraph * BKE_scene_get_depsgraph(const Scene *scene, const ViewLayer *view_layer)
Definition scene.cc:3631
@ REGION_DRAW_LOCK_NONE
@ REGION_DRAW_LOCK_RENDER
void BKE_image_signal(Main *bmain, Image *ima, ImageUser *iuser, int signal)
@ BASE_ENABLED_AND_MAYBE_VISIBLE_IN_VIEWPORT
void BKE_spacedata_draw_locks(ARegionDrawLockFlags lock_flags)
Definition screen.cc:558
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
static void clean_viewport_memory_base(Base *base)
@ WM_JOB_TYPE_RENDER
Definition WM_api.hh:2011
void IMB_ensure_gpu_context()
Definition module.cc:42
static RenderJobBase * render_job_get(const bContext *C)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
static void make_renderinfo_string(const RenderStats *rs, const Scene *scene, const bool v3d_override, const char *error, char ret[IMA_MAX_RENDER_TEXT_SIZE])
int RNA_int_get(PointerRNA *ptr, const char *name)
wmWindow * CTX_wm_window(const bContext *C)
@ CURVE_PRESET_SMOOTH
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
ScrArea * render_view_open(bContext *C, int mx, int my, ReportList *reports)
@ WM_JOB_PRIORITY
Definition WM_api.hh:1990
@ WM_JOB_EXCL_RENDER
Definition WM_api.hh:1995
@ WM_JOB_PROGRESS
Definition WM_api.hh:1997
static void image_rect_update(void *rjv, RenderResult *rr)
ViewLayer * WM_window_get_active_view_layer(const wmWindow *win)
static std::string screen_render_get_description(bContext *, wmOperatorType *, PointerRNA *ptr)
void BKE_color_managed_view_settings_copy(ColorManagedViewSettings *new_settings, const ColorManagedViewSettings *settings)
constexpr std::enable_if_t< blenlib_internal::IsBoundedArray< T >::value, size_t > BOUNDED_ARRAY_TYPE_SIZE() noexcept
bool RE_allow_render_generic_object(Object *ob)
static void screen_render_single_layer_set(wmOperator *op, Main *mainp, ViewLayer *active_layer, Scene **scene, ViewLayer **single_layer)
static bool render_breakjob(void *rjv)
ViewLayer * CTX_data_view_layer(const bContext *C)
wmOperatorStatus ED_screen_animation_play(bContext *C, int sync, int mode)
void DEG_tag_on_visible_update(Main *bmain, bool do_time)
static void get_render_operator_frame_range(wmOperator *render_operator, const Scene *scene, int &frame_start, int &frame_end)
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:498
size_t(*) MEM_get_memory_in_use()
Global G
Definition blender.cc:57
void RE_current_scene_update_cb(Render *re, void *handle, void(*f)(void *handle, Scene *scene))
static wmOperatorStatus screen_render_modal(bContext *C, wmOperator *op, const wmEvent *event)
void WM_locked_interface_set(wmWindowManager *wm, bool lock)
int BLI_findstringindex(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:794
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
static void render_freejob(void *rjv)
void WM_locked_interface_set_with_flags(wmWindowManager *wm, short lock_flags)
void RE_progress_cb(Render *re, void *handle, void(*f)(void *handle, float))
static void render_image_update_pass_and_layer(RenderJob *rj, RenderResult *rr, ImageUser *iuser)
void BKE_color_managed_display_settings_copy(ColorManagedDisplaySettings *new_settings, const ColorManagedDisplaySettings *settings)
void BKE_object_free_derived_caches(Object *ob)
Definition object.cc:1810
void DEG_id_tag_update(ID *id, unsigned int flags)
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 void render_drawlock(void *rjv, bool lock)
wmWindowManager * CTX_wm_manager(const bContext *C)
void BKE_curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, CurveMapSlopeType slope)
static void render_image_restore_scene_and_layer(RenderJob *rj)
static bool render_break(void *rjv)
void RE_display_ensure_gpu_context(Render *re)
void BKE_curvemapping_changed(CurveMapping *cumap, bool rem_doubles)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
static wmOperatorStatus screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
bool RNA_struct_property_is_set(PointerRNA *ptr, const char *identifier)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
bool RE_is_rendering_allowed(const Main &bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, ReportList *reports)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void RENDER_OT_shutter_curve_preset(wmOperatorType *ot)
RenderEngineType * RE_engines_find(const char *idname)
_W64 unsigned int uintptr_t
Definition BKE_text.h:120
void BKE_image_backup_render(Scene *scene, Image *ima, bool free_current_slot)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
void BKE_main_free(Main *bmain)
Definition main.cc:202
bool BKE_imtype_is_movie(char imtype)
RenderResult * RE_AcquireResultRead(Render *re)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
void ED_update_for_newframe(Main *bmain, Depsgraph *depsgraph)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
void WM_jobs_kill_type(wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:642
size_t(*) MEM_get_peak_memory() ATTR_WARN_UNUSED_RESULT
@ IMA_SHOW_SEQUENCER_SCENE
Main * CTX_data_main(const bContext *C)
void size_t BLI_string_len_array(const char *strings[], uint strings_num) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void clean_viewport_memory(Main *bmain, Scene *scene)
void RE_display_update_cb(Render *re, void *handle, void(*f)(void *handle, RenderResult *rr))
static wmOperatorStatus screen_render_exec(bContext *C, wmOperator *op)
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, const eWM_JobFlag flag, const eWM_JobType job_type)
Definition wm_jobs.cc:228
static void screen_render_cancel(bContext *C, wmOperator *op)
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))
Image * BKE_image_ensure_viewer(Main *bmain, int type, const char *name)
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)
static void render_endjob(void *rjv)
bool RE_disable_save_output_allowed(const bool is_animation, Scene &scene, ReportList *reports)
@ ID_RECALC_COMPOSITOR
Definition DNA_ID.h:1161
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
@ ID_TAG_DOIT
Definition DNA_ID.h:1029
void ED_render_view3d_auto_pause(Main *bmain, bool pause)
void BKE_main_id_tag_listbase(ListBaseT< ID > *lb, int tag, bool value)
Definition lib_id.cc:1291
double BLI_time_now_seconds()
Definition time.cc:30
void BKE_color_managed_view_settings_free(ColorManagedViewSettings *settings)
Scene * CTX_data_scene(const bContext *C)
bScreen * CTX_wm_screen(const bContext *C)
static void image_renderinfo_cb(void *rjv, RenderStats *rs)
static void render_startjob(void *rjv, wmJobWorkerStatus *worker_status)
std::string RNA_string_get(PointerRNA *ptr, const char *name)
size_t BLI_string_join_array(char *result, size_t result_maxncpy, const char *strings[], uint strings_num) ATTR_NONNULL()
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
void BKE_image_free_buffers(Image *image)
static bool render_operator_has_custom_frame_range(wmOperator *render_operator)
ViewLayer * BKE_view_layer_default_render(const Scene *scene)
bScreen * WM_window_get_active_screen(const wmWindow *win)
void WM_cursor_wait(bool val)
size_t BLI_timecode_string_from_time_simple(char *str, size_t maxncpy, double time_seconds) ATTR_NONNULL()
Definition timecode.cc:172
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
static wmOperatorStatus render_shutter_curve_preset_exec(bContext *C, wmOperator *op)
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
void RENDER_OT_render(wmOperatorType *ot)
View3D * CTX_wm_view3d(const bContext *C)
bScreen * ED_screen_animation_playing(const wmWindowManager *wm)
bool ED_operator_screenactive(bContext *C)
static void render_progress_update(void *rjv, float progress)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
Scene * ED_render_job_get_current_scene(const bContext *C)
@ CUMA_EXTEND_EXTRAPOLATE
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
void * WM_jobs_customdata_from_type(wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:347
#define ceilf
struct Object * object
eCurveMappingFlags flag
eCurveMappingPreset preset
eImageUser_Flag flag
struct Scene * scene
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
ListBaseT< Object > objects
Definition BKE_main.hh:388
ListBaseT< Scene > scenes
Definition BKE_main.hh:386
struct CurveMapping mblur_shutter_curve
ImageFormatData im_format
void(*) render(struct RenderEngine *engine, struct Depsgraph *depsgraph)
Definition RE_engine.h:90
ColorManagedDisplaySettings display_settings
ColorManagedViewSettings view_settings
char name[RE_MAXNAME]
Definition RE_pipeline.h:94
RenderLayer * renlay
const char * statstr
const char * infostr
ListBaseT< ViewLayer > view_layers
ColorManagedViewSettings view_settings
struct Object * camera
ColorManagedDisplaySettings display_settings
struct RenderData r
ListBaseT< SpaceLink > spacedata
struct ImageUser iuser
ListBaseT< struct ScrArea > areabase
wmEventType type
Definition WM_types.hh:817
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
void(*) cancel(bContext *C, wmOperator *op)
Definition WM_types.hh:1149
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
std::string(*) get_description(bContext *C, wmOperatorType *ot, PointerRNA *ptr)
Definition WM_types.hh:1197
struct ReportList * reports