Blender  V3.3
render_internal.cc
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2008 Blender Foundation. All rights reserved. */
3 
8 #include <cmath>
9 #include <cstddef>
10 #include <cstring>
11 
12 #include "MEM_guardedalloc.h"
13 
14 #include "BLI_listbase.h"
15 #include "BLI_math.h"
16 #include "BLI_rect.h"
17 #include "BLI_threads.h"
18 #include "BLI_timecode.h"
19 #include "BLI_utildefines.h"
20 
21 #include "PIL_time.h"
22 
23 #include "BLT_translation.h"
24 
25 #include "DNA_object_types.h"
26 #include "DNA_scene_types.h"
27 #include "DNA_userdef_types.h"
28 #include "DNA_view3d_types.h"
29 
30 #include "BKE_colortools.h"
31 #include "BKE_context.h"
32 #include "BKE_global.h"
33 #include "BKE_image.h"
34 #include "BKE_image_format.h"
35 #include "BKE_lib_id.h"
36 #include "BKE_main.h"
37 #include "BKE_node.h"
38 #include "BKE_node_tree_update.h"
39 #include "BKE_object.h"
40 #include "BKE_report.h"
41 #include "BKE_scene.h"
42 #include "BKE_screen.h"
43 
44 #include "NOD_composite.h"
45 
46 #include "DEG_depsgraph.h"
47 
48 #include "WM_api.h"
49 #include "WM_types.h"
50 
51 #include "ED_render.h"
52 #include "ED_screen.h"
53 #include "ED_util.h"
54 
55 #include "BIF_glutil.h"
56 
57 #include "RE_engine.h"
58 #include "RE_pipeline.h"
59 
60 #include "IMB_colormanagement.h"
61 #include "IMB_imbuf_types.h"
62 
63 #include "RNA_access.h"
64 #include "RNA_define.h"
65 
66 #include "SEQ_relations.h"
67 
68 #include "render_intern.hh"
69 
70 /* Render Callbacks */
71 static int render_break(void *rjv);
72 
73 struct RenderJob {
78  /* TODO(sergey): Should not be needed once engine will have its own
79  * depsgraph and copy-on-write will be implemented.
80  */
89  short *stop;
90  short *do_update;
91  float *progress;
100 };
101 
102 /* called inside thread! */
104  const ImBuf *ibuf,
105  rcti *renrect,
106  rcti *r_ibuf_rect,
107  int *r_offset_x,
108  int *r_offset_y)
109 {
110  int tile_y, tile_height, tile_x, tile_width;
111 
112  /* When `renrect` argument is not nullptr, we only refresh scan-lines. */
113  if (renrect) {
114  /* `if (tile_height == recty)`, rendering of layer is ready,
115  * we should not draw, other things happen... */
116  if (rr->renlay == nullptr || renrect->ymax >= rr->recty) {
117  return false;
118  }
119 
120  /* `tile_x` here is first sub-rectangle x coord, tile_width defines sub-rectangle width. */
121  tile_x = renrect->xmin;
122  tile_width = renrect->xmax - tile_x;
123  if (tile_width < 2) {
124  return false;
125  }
126 
127  tile_y = renrect->ymin;
128  tile_height = renrect->ymax - tile_y;
129  if (tile_height < 2) {
130  return false;
131  }
132  renrect->ymin = renrect->ymax;
133  }
134  else {
135  tile_x = tile_y = 0;
136  tile_width = rr->rectx;
137  tile_height = rr->recty;
138  }
139 
140  /* tile_x tile_y is in tile coords. transform to ibuf */
141  int offset_x = rr->tilerect.xmin;
142  if (offset_x >= ibuf->x) {
143  return false;
144  }
145  int offset_y = rr->tilerect.ymin;
146  if (offset_y >= ibuf->y) {
147  return false;
148  }
149 
150  if (offset_x + tile_width > ibuf->x) {
151  tile_width = ibuf->x - offset_x;
152  }
153  if (offset_y + tile_height > ibuf->y) {
154  tile_height = ibuf->y - offset_y;
155  }
156 
157  if (tile_width < 1 || tile_height < 1) {
158  return false;
159  }
160 
161  r_ibuf_rect->xmax = tile_x + tile_width;
162  r_ibuf_rect->ymax = tile_y + tile_height;
163  r_ibuf_rect->xmin = tile_x;
164  r_ibuf_rect->ymin = tile_y;
165  *r_offset_x = offset_x;
166  *r_offset_y = offset_y;
167  return true;
168 }
169 
171  RenderResult *rr,
172  ImBuf *ibuf,
173  ImageUser *iuser,
174  const rcti *tile_rect,
175  int offset_x,
176  int offset_y,
177  const char *viewname)
178 {
179  Scene *scene = rj->scene;
180  const float *rectf = nullptr;
181  int linear_stride, linear_offset_x, linear_offset_y;
182  ColorManagedViewSettings *view_settings;
183  ColorManagedDisplaySettings *display_settings;
184 
185  if (ibuf->userflags & IB_DISPLAY_BUFFER_INVALID) {
186  /* The whole image buffer is to be color managed again anyway. */
187  return;
188  }
189 
190  /* The thing here is, the logic below (which was default behavior
191  * of how rectf is acquiring since forever) gives float buffer for
192  * composite output only. This buffer can not be used for other
193  * passes obviously.
194  *
195  * We might try finding corresponding for pass buffer in render result
196  * (which is actually missing when rendering with Cycles, who only
197  * writes all the passes when the tile is finished) or use float
198  * buffer from image buffer as reference, which is easier to use and
199  * contains all the data we need anyway.
200  * - sergey -
201  */
202  /* TODO(sergey): Need to check has_combined here? */
203  if (iuser->pass == 0) {
204  RenderView *rv;
205  const int view_id = BKE_scene_multiview_view_id_get(&scene->r, viewname);
206  rv = RE_RenderViewGetById(rr, view_id);
207 
208  /* find current float rect for display, first case is after composite... still weak */
209  if (rv->rectf) {
210  rectf = rv->rectf;
211  }
212  else {
213  if (rv->rect32) {
214  /* special case, currently only happens with sequencer rendering,
215  * which updates the whole frame, so we can only mark display buffer
216  * as invalid here (sergey)
217  */
219  return;
220  }
221  if (rr->renlay == nullptr) {
222  return;
223  }
224  rectf = RE_RenderLayerGetPass(rr->renlay, RE_PASSNAME_COMBINED, viewname);
225  }
226  if (rectf == nullptr) {
227  return;
228  }
229 
230  rectf += 4 * (rr->rectx * tile_rect->ymin + tile_rect->xmin);
231  linear_stride = rr->rectx;
232  linear_offset_x = offset_x;
233  linear_offset_y = offset_y;
234  }
235  else {
236  rectf = ibuf->rect_float;
237  linear_stride = ibuf->x;
238  linear_offset_x = 0;
239  linear_offset_y = 0;
240  }
241 
242  view_settings = &scene->view_settings;
243  display_settings = &scene->display_settings;
244 
246  rectf,
247  nullptr,
248  linear_stride,
249  linear_offset_x,
250  linear_offset_y,
251  view_settings,
252  display_settings,
253  offset_x,
254  offset_y,
255  offset_x + BLI_rcti_size_x(tile_rect),
256  offset_y + BLI_rcti_size_y(tile_rect));
257 }
258 
259 /* ****************************** render invoking ***************** */
260 
261 /* set callbacks, exported to sequence render too.
262  * Only call in foreground (UI) renders. */
263 
265  wmOperator *op, Main *mainp, ViewLayer *active_layer, Scene **scene, ViewLayer **single_layer)
266 {
267  /* single layer re-render */
268  if (RNA_struct_property_is_set(op->ptr, "scene")) {
269  Scene *scn;
270  char scene_name[MAX_ID_NAME - 2];
271 
272  RNA_string_get(op->ptr, "scene", scene_name);
273  scn = (Scene *)BLI_findstring(&mainp->scenes, scene_name, offsetof(ID, name) + 2);
274 
275  if (scn) {
276  /* camera switch won't have updated */
277  scn->r.cfra = (*scene)->r.cfra;
279 
280  *scene = scn;
281  }
282  }
283 
284  if (RNA_struct_property_is_set(op->ptr, "layer")) {
285  ViewLayer *rl;
286  char rl_name[RE_MAXNAME];
287 
288  RNA_string_get(op->ptr, "layer", rl_name);
289  rl = (ViewLayer *)BLI_findstring(&(*scene)->view_layers, rl_name, offsetof(ViewLayer, name));
290 
291  if (rl) {
292  *single_layer = rl;
293  }
294  }
295  else if (((*scene)->r.scemode & R_SINGLE_LAYER) && active_layer) {
296  *single_layer = active_layer;
297  }
298 }
299 
300 /* executes blocking render */
302 {
305  ViewLayer *active_layer = CTX_data_view_layer(C);
306  ViewLayer *single_layer = nullptr;
307  Render *re;
308  Image *ima;
309  View3D *v3d = CTX_wm_view3d(C);
310  Main *mainp = CTX_data_main(C);
311  const bool is_animation = RNA_boolean_get(op->ptr, "animation");
312  const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
313  struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : nullptr;
314 
315  /* Cannot do render if there is not this function. */
316  if (re_type->render == nullptr) {
317  return OPERATOR_CANCELLED;
318  }
319 
320  /* custom scene and single layer re-render */
321  screen_render_single_layer_set(op, mainp, active_layer, &scene, &single_layer);
322 
323  if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
324  BKE_report(
325  op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
326  return OPERATOR_CANCELLED;
327  }
328 
329  re = RE_NewSceneRender(scene);
330 
331  G.is_break = false;
332 
333  RE_draw_lock_cb(re, nullptr, nullptr);
334  RE_test_break_cb(re, nullptr, render_break);
335 
336  ima = BKE_image_ensure_viewer(mainp, IMA_TYPE_R_RESULT, "Render Result");
337  BKE_image_signal(mainp, ima, nullptr, IMA_SIGNAL_FREE);
338  BKE_image_backup_render(scene, ima, true);
339 
340  /* cleanup sequencer caches before starting user triggered render.
341  * otherwise, invalidated cache entries can make their way into
342  * the output rendering. We can't put that into RE_RenderFrame,
343  * since sequence rendering can call that recursively... (peter) */
345 
346  RE_SetReports(re, op->reports);
347 
348  if (is_animation) {
349  RE_RenderAnim(re,
350  mainp,
351  scene,
352  single_layer,
353  camera_override,
354  scene->r.sfra,
355  scene->r.efra,
356  scene->r.frame_step);
357  }
358  else {
359  RE_RenderFrame(re,
360  mainp,
361  scene,
362  single_layer,
363  camera_override,
364  scene->r.cfra,
365  scene->r.subframe,
366  is_write_still);
367  }
368 
369  RE_SetReports(re, nullptr);
370 
371  /* No redraw needed, we leave state as we entered it. */
373 
375 
376  return OPERATOR_FINISHED;
377 }
378 
379 static void render_freejob(void *rjv)
380 {
381  RenderJob *rj = static_cast<RenderJob *>(rjv);
382 
384  MEM_freeN(rj);
385 }
386 
387 /* str is IMA_MAX_RENDER_TEXT in size */
388 static void make_renderinfo_string(const RenderStats *rs,
389  const Scene *scene,
390  const bool v3d_override,
391  const char *error,
392  char *str)
393 {
394  char info_time_str[32]; /* used to be extern to header_info.c */
395  uintptr_t mem_in_use, peak_memory;
396  float megs_used_memory, megs_peak_memory;
397  char *spos = str;
398 
400  peak_memory = MEM_get_peak_memory();
401 
402  megs_used_memory = (mem_in_use) / (1024.0 * 1024.0);
403  megs_peak_memory = (peak_memory) / (1024.0 * 1024.0);
404 
405  /* local view */
406  if (rs->localview) {
407  spos += sprintf(spos, "%s | ", TIP_("3D Local View"));
408  }
409  else if (v3d_override) {
410  spos += sprintf(spos, "%s | ", TIP_("3D View"));
411  }
412 
413  /* frame number */
414  spos += sprintf(spos, TIP_("Frame:%d "), (scene->r.cfra));
415 
416  /* previous and elapsed time */
417  BLI_timecode_string_from_time_simple(info_time_str, sizeof(info_time_str), rs->lastframetime);
418 
419  if (rs->infostr && rs->infostr[0]) {
420  if (rs->lastframetime != 0.0) {
421  spos += sprintf(spos, TIP_("| Last:%s "), info_time_str);
422  }
423  else {
424  spos += sprintf(spos, "| ");
425  }
426 
428  info_time_str, sizeof(info_time_str), PIL_check_seconds_timer() - rs->starttime);
429  }
430  else {
431  spos += sprintf(spos, "| ");
432  }
433 
434  spos += sprintf(spos, TIP_("Time:%s "), info_time_str);
435 
436  /* statistics */
437  if (rs->statstr) {
438  if (rs->statstr[0]) {
439  spos += sprintf(spos, "| %s ", rs->statstr);
440  }
441  }
442  else {
443  if (rs->mem_peak == 0.0f) {
444  spos += sprintf(spos, TIP_("| Mem:%.2fM (Peak %.2fM) "), megs_used_memory, megs_peak_memory);
445  }
446  else {
447  spos += sprintf(spos, TIP_("| Mem:%.2fM, Peak: %.2fM "), rs->mem_used, rs->mem_peak);
448  }
449  }
450 
451  /* extra info */
452  if (rs->infostr && rs->infostr[0]) {
453  spos += sprintf(spos, "| %s ", rs->infostr);
454  }
455  else if (error && error[0]) {
456  spos += sprintf(spos, "| %s ", error);
457  }
458 
459  /* very weak... but 512 characters is quite safe */
460  if (spos >= str + IMA_MAX_RENDER_TEXT) {
461  if (G.debug & G_DEBUG) {
462  printf("WARNING! renderwin text beyond limit\n");
463  }
464  }
465 }
466 
467 static void image_renderinfo_cb(void *rjv, RenderStats *rs)
468 {
469  RenderJob *rj = static_cast<RenderJob *>(rjv);
470  RenderResult *rr;
471 
472  rr = RE_AcquireResultRead(rj->re);
473 
474  if (rr) {
475  /* malloc OK here, stats_draw is not in tile threads */
476  if (rr->text == nullptr) {
477  rr->text = static_cast<char *>(MEM_callocN(IMA_MAX_RENDER_TEXT, "rendertext"));
478  }
479 
480  make_renderinfo_string(rs, rj->scene, rj->v3d_override, rr->error, rr->text);
481  }
482 
483  RE_ReleaseResult(rj->re);
484 
485  /* make jobs timer to send notifier */
486  *(rj->do_update) = true;
487 }
488 
489 static void render_progress_update(void *rjv, float progress)
490 {
491  RenderJob *rj = static_cast<RenderJob *>(rjv);
492 
493  if (rj->progress && *rj->progress != progress) {
494  *rj->progress = progress;
495 
496  /* make jobs timer to send notifier */
497  *(rj->do_update) = true;
498  }
499 }
500 
501 /* Not totally reliable, but works fine in most of cases and
502  * in worst case would just make it so extra color management
503  * for the whole render result is applied (which was already
504  * happening already).
505  */
507 {
508  wmWindowManager *wm;
509  ScrArea *first_area = nullptr, *matched_area = nullptr;
510 
511  /* image window, compo node users */
512  for (wm = static_cast<wmWindowManager *>(rj->main->wm.first); wm && matched_area == nullptr;
513  wm = static_cast<wmWindowManager *>(wm->id.next)) { /* only 1 wm */
514  wmWindow *win;
515  for (win = static_cast<wmWindow *>(wm->windows.first); win && matched_area == nullptr;
516  win = win->next) {
517  const bScreen *screen = WM_window_get_active_screen(win);
518 
519  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
520  if (area->spacetype == SPACE_IMAGE) {
521  SpaceImage *sima = static_cast<SpaceImage *>(area->spacedata.first);
522  /* area->spacedata might be empty when toggling full-screen mode. */
523  if (sima != nullptr && sima->image == rj->image) {
524  if (first_area == nullptr) {
525  first_area = area;
526  }
527  if (area == rj->area) {
528  matched_area = area;
529  break;
530  }
531  }
532  }
533  }
534  }
535  }
536 
537  if (matched_area == nullptr) {
538  matched_area = first_area;
539  }
540 
541  if (matched_area) {
542  SpaceImage *sima = static_cast<SpaceImage *>(matched_area->spacedata.first);
543  RenderResult *main_rr = RE_AcquireResultRead(rj->re);
544 
545  /* TODO(sergey): is there faster way to get the layer index? */
546  if (rr->renlay) {
547  int layer = BLI_findstringindex(
548  &main_rr->layers, (char *)rr->renlay->name, offsetof(RenderLayer, name));
549  sima->iuser.layer = layer;
550  rj->last_layer = layer;
551  }
552 
553  iuser->pass = sima->iuser.pass;
554  iuser->layer = sima->iuser.layer;
555 
556  RE_ReleaseResult(rj->re);
557  }
558 }
559 
560 static void image_rect_update(void *rjv, RenderResult *rr, rcti *renrect)
561 {
562  RenderJob *rj = static_cast<RenderJob *>(rjv);
563  Image *ima = rj->image;
564  ImBuf *ibuf;
565  void *lock;
566  const char *viewname = RE_GetActiveRenderView(rj->re);
567 
568  /* only update if we are displaying the slot being rendered */
569  if (ima->render_slot != ima->last_render_slot) {
570  rj->image_outdated = true;
571  return;
572  }
573  if (rj->image_outdated) {
574  /* Free all render buffer caches when switching slots, with lock to ensure main
575  * thread is not drawing the buffer at the same time. */
576  rj->image_outdated = false;
577  ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
579  BKE_image_release_ibuf(ima, ibuf, lock);
580  *(rj->do_update) = true;
581  return;
582  }
583 
584  if (rr == nullptr) {
585  return;
586  }
587 
588  /* update part of render */
590  rcti tile_rect;
591  int offset_x;
592  int offset_y;
593  ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
594  if (ibuf) {
595  if (!image_buffer_calc_tile_rect(rr, ibuf, renrect, &tile_rect, &offset_x, &offset_y)) {
596  BKE_image_release_ibuf(ima, ibuf, lock);
597  return;
598  }
599 
600  /* Don't waste time on CPU side color management if
601  * image will be displayed using GLSL.
602  *
603  * Need to update rect if Save Buffers enabled because in
604  * this case GLSL doesn't have original float buffer to
605  * operate with.
606  */
607  if (!rj->supports_glsl_draw || ibuf->channels == 1 ||
609  image_buffer_rect_update(rj, rr, ibuf, &rj->iuser, &tile_rect, offset_x, offset_y, viewname);
610  }
611  ImageTile *image_tile = BKE_image_get_tile(ima, 0);
613  image_tile,
614  ibuf,
615  offset_x,
616  offset_y,
617  BLI_rcti_size_x(&tile_rect),
618  BLI_rcti_size_y(&tile_rect));
619 
620  /* make jobs timer to send notifier */
621  *(rj->do_update) = true;
622  }
623  BKE_image_release_ibuf(ima, ibuf, lock);
624 }
625 
626 static void current_scene_update(void *rjv, Scene *scene)
627 {
628  RenderJob *rj = static_cast<RenderJob *>(rjv);
629 
630  if (rj->current_scene != scene) {
631  /* Image must be updated when rendered scene changes. */
633  }
634 
635  rj->current_scene = scene;
636  rj->iuser.scene = scene;
637 }
638 
639 static void render_startjob(void *rjv, short *stop, short *do_update, float *progress)
640 {
641  RenderJob *rj = static_cast<RenderJob *>(rjv);
642 
643  rj->stop = stop;
644  rj->do_update = do_update;
645  rj->progress = progress;
646 
647  RE_SetReports(rj->re, rj->reports);
648 
649  if (rj->anim) {
650  RE_RenderAnim(rj->re,
651  rj->main,
652  rj->scene,
653  rj->single_layer,
654  rj->camera_override,
655  rj->scene->r.sfra,
656  rj->scene->r.efra,
657  rj->scene->r.frame_step);
658  }
659  else {
660  RE_RenderFrame(rj->re,
661  rj->main,
662  rj->scene,
663  rj->single_layer,
664  rj->camera_override,
665  rj->scene->r.cfra,
666  rj->scene->r.subframe,
667  rj->write_still);
668  }
669 
670  RE_SetReports(rj->re, nullptr);
671 }
672 
674 {
675  wmWindowManager *wm;
676 
677  /* image window, compo node users */
678  for (wm = static_cast<wmWindowManager *>(rj->main->wm.first); wm;
679  wm = static_cast<wmWindowManager *>(wm->id.next)) { /* only 1 wm */
680  wmWindow *win;
681  for (win = static_cast<wmWindow *>(wm->windows.first); win; win = win->next) {
682  const bScreen *screen = WM_window_get_active_screen(win);
683 
684  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
685  if (area == rj->area) {
686  if (area->spacetype == SPACE_IMAGE) {
687  SpaceImage *sima = static_cast<SpaceImage *>(area->spacedata.first);
688 
689  if (RE_HasSingleLayer(rj->re)) {
690  /* For single layer renders keep the active layer
691  * visible, or show the compositing result. */
693  if (RE_HasCombinedLayer(rr)) {
694  sima->iuser.layer = 0;
695  }
696  RE_ReleaseResult(rj->re);
697  }
698  else {
699  /* For multiple layer render, set back the layer
700  * that was set at the start of rendering. */
701  sima->iuser.layer = rj->orig_layer;
702  }
703  }
704  return;
705  }
706  }
707  }
708  }
709 }
710 
711 static void render_endjob(void *rjv)
712 {
713  RenderJob *rj = static_cast<RenderJob *>(rjv);
714 
715  /* This render may be used again by the sequencer without the active
716  * 'Render' where the callbacks would be re-assigned. assign dummy callbacks
717  * to avoid referencing freed render-jobs bug T24508. */
718  RE_InitRenderCB(rj->re);
719 
720  if (rj->main != G_MAIN) {
721  BKE_main_free(rj->main);
722  }
723 
724  /* else the frame will not update for the original value */
725  if (rj->anim && !(rj->scene->r.scemode & R_NO_FRAME_UPDATE)) {
726  /* possible this fails of loading new file while rendering */
727  if (G_MAIN->wm.first) {
729  }
730  }
731 
732  /* XXX above function sets all tags in nodes */
734 
735  /* potentially set by caller */
736  rj->scene->r.scemode &= ~R_NO_FRAME_UPDATE;
737 
738  if (rj->single_layer) {
740  BKE_ntree_update_main(rj->main, nullptr);
742  }
743 
744  if (rj->area) {
746  }
747 
748  /* XXX render stability hack */
749  G.is_rendering = false;
751 
752  /* Partial render result will always update display buffer
753  * for first render layer only. This is nice because you'll
754  * see render progress during rendering, but it ends up in
755  * wrong display buffer shown after rendering.
756  *
757  * The code below will mark display buffer as invalid after
758  * rendering in case multiple layers were rendered, which
759  * ensures display buffer matches render layer after
760  * rendering.
761  *
762  * Perhaps proper way would be to toggle active render
763  * layer in image editor and job, so we always display
764  * layer being currently rendered. But this is not so much
765  * trivial at this moment, especially because of external
766  * engine API, so lets use simple and robust way for now
767  * - sergey -
768  */
769  if (rj->scene->view_layers.first != rj->scene->view_layers.last || rj->image_outdated) {
770  void *lock;
771  Image *ima = rj->image;
772  ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
773 
774  if (ibuf) {
776  }
777 
778  BKE_image_release_ibuf(ima, ibuf, lock);
779  }
780 
781  /* Finally unlock the user interface (if it was locked). */
782  if (rj->interface_locked) {
783  /* Interface was locked, so window manager couldn't have been changed
784  * and using one from Global will unlock exactly the same manager as
785  * was locked before running the job.
786  */
787  WM_set_locked_interface(static_cast<wmWindowManager *>(G_MAIN->wm.first), false);
789  }
790 }
791 
792 /* called by render, check job 'stop' value or the global */
793 static int render_breakjob(void *rjv)
794 {
795  RenderJob *rj = static_cast<RenderJob *>(rjv);
796 
797  if (G.is_break) {
798  return 1;
799  }
800  if (rj->stop && *(rj->stop)) {
801  return 1;
802  }
803  return 0;
804 }
805 
810 static int render_break(void *UNUSED(rjv))
811 {
812  if (G.is_break) {
813  return 1;
814  }
815  return 0;
816 }
817 
818 /* runs in thread, no cursor setting here works. careful with notifiers too (malloc conflicts) */
819 /* maybe need a way to get job send notifier? */
820 static void render_drawlock(void *rjv, bool lock)
821 {
822  RenderJob *rj = static_cast<RenderJob *>(rjv);
823 
824  /* If interface is locked, renderer callback shall do nothing. */
825  if (!rj->interface_locked) {
827  }
828 }
829 
831 static int screen_render_modal(bContext *C, wmOperator *op, const wmEvent *event)
832 {
833  Scene *scene = (Scene *)op->customdata;
834 
835  /* no running blender, remove handler and pass through */
838  }
839 
840  /* running render */
841  switch (event->type) {
842  case EVT_ESCKEY:
843  return OPERATOR_RUNNING_MODAL;
844  }
845  return OPERATOR_PASS_THROUGH;
846 }
847 
849 {
851  Scene *scene = (Scene *)op->customdata;
852 
853  /* kill on cancel, because job is using op->reports */
855 }
856 
858 {
859  if ((base->flag & BASE_VISIBLE_DEPSGRAPH) == 0) {
860  return;
861  }
862 
863  Object *object = base->object;
864 
865  if (object->id.tag & LIB_TAG_DOIT) {
866  return;
867  }
868 
869  object->id.tag &= ~LIB_TAG_DOIT;
870  if (RE_allow_render_generic_object(object)) {
872  }
873 }
874 
875 static void clean_viewport_memory(Main *bmain, Scene *scene)
876 {
877  Scene *sce_iter;
878  Base *base;
879 
880  /* Tag all the available objects. */
882 
883  /* Go over all the visible objects. */
884  for (wmWindowManager *wm = static_cast<wmWindowManager *>(bmain->wm.first); wm;
885  wm = static_cast<wmWindowManager *>(wm->id.next)) {
886  LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
887  ViewLayer *view_layer = WM_window_get_active_view_layer(win);
888 
889  for (base = static_cast<Base *>(view_layer->object_bases.first); base; base = base->next) {
891  }
892  }
893  }
894 
895  for (SETLOOPER_SET_ONLY(scene, sce_iter, base)) {
897  }
898 }
899 
900 /* using context, starts job */
901 static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
902 {
903  /* new render clears all callbacks */
904  Main *bmain = CTX_data_main(C);
906  ViewLayer *active_layer = CTX_data_view_layer(C);
907  ViewLayer *single_layer = nullptr;
909  Render *re;
910  wmJob *wm_job;
911  RenderJob *rj;
912  Image *ima;
913  const bool is_animation = RNA_boolean_get(op->ptr, "animation");
914  const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
915  const bool use_viewport = RNA_boolean_get(op->ptr, "use_viewport");
916  View3D *v3d = use_viewport ? CTX_wm_view3d(C) : nullptr;
917  struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : nullptr;
918  const char *name;
919  ScrArea *area;
920 
921  /* Cannot do render if there is not this function. */
922  if (re_type->render == nullptr) {
923  return OPERATOR_CANCELLED;
924  }
925 
926  /* custom scene and single layer re-render */
927  screen_render_single_layer_set(op, bmain, active_layer, &scene, &single_layer);
928 
929  /* only one render job at a time */
931  return OPERATOR_CANCELLED;
932  }
933 
934  if (!RE_is_rendering_allowed(scene, single_layer, camera_override, op->reports)) {
935  return OPERATOR_CANCELLED;
936  }
937 
938  if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
939  BKE_report(
940  op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
941  return OPERATOR_CANCELLED;
942  }
943 
944  /* Reports are done inside check function, and it will return false if there are other strips to
945  * render. */
947  return OPERATOR_CANCELLED;
948  }
949 
950  /* stop all running jobs, except screen one. currently previews frustrate Render */
952 
953  /* cancel animation playback */
956  }
957 
958  /* handle UI stuff */
959  WM_cursor_wait(true);
960 
961  /* flush sculpt and editmode changes */
962  ED_editors_flush_edits_ex(bmain, true, false);
963 
964  /* cleanup sequencer caches before starting user triggered render.
965  * otherwise, invalidated cache entries can make their way into
966  * the output rendering. We can't put that into RE_RenderFrame,
967  * since sequence rendering can call that recursively... (peter) */
969 
970  /* store spare
971  * get view3d layer, local layer, make this nice api call to render
972  * store spare */
973 
974  /* ensure at least 1 area shows result */
975  area = render_view_open(C, event->xy[0], event->xy[1], op->reports);
976 
977  /* job custom data */
978  rj = MEM_cnew<RenderJob>("render job");
979  rj->main = bmain;
980  rj->scene = scene;
981  rj->current_scene = rj->scene;
982  rj->single_layer = single_layer;
983  /* TODO(sergey): Render engine should be using its own depsgraph.
984  *
985  * NOTE: Currently is only used by ED_update_for_newframe() at the end of the render, so no
986  * need to ensure evaluation here. */
988  rj->camera_override = camera_override;
989  rj->anim = is_animation;
990  rj->write_still = is_write_still && !is_animation;
991  rj->iuser.scene = scene;
992  rj->reports = op->reports;
993  rj->orig_layer = 0;
994  rj->last_layer = 0;
995  rj->area = area;
997 
1000 
1001  if (area) {
1002  SpaceImage *sima = static_cast<SpaceImage *>(area->spacedata.first);
1003  rj->orig_layer = sima->iuser.layer;
1004  }
1005 
1006  if (v3d) {
1007  if (camera_override && camera_override != scene->camera) {
1008  rj->v3d_override = true;
1009  }
1010  }
1011 
1012  /* Lock the user interface depending on render settings. */
1013  if (scene->r.use_lock_interface) {
1015 
1016  /* Set flag interface need to be unlocked.
1017  *
1018  * This is so because we don't have copy of render settings
1019  * accessible from render job and copy is needed in case
1020  * of non-locked rendering, so we wouldn't try to unlock
1021  * anything if option was initially unset but then was
1022  * enabled during rendering.
1023  */
1024  rj->interface_locked = true;
1025 
1026  /* Clean memory used by viewport? */
1028  }
1029 
1030  /* setup job */
1031  if (RE_seq_render_active(scene, &scene->r)) {
1032  name = "Sequence Render";
1033  }
1034  else {
1035  name = "Render";
1036  }
1037 
1038  wm_job = WM_jobs_get(CTX_wm_manager(C),
1039  CTX_wm_window(C),
1040  scene,
1041  name,
1045  WM_jobs_timer(wm_job, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
1046  WM_jobs_callbacks(wm_job, render_startjob, nullptr, nullptr, render_endjob);
1047 
1048  if (RNA_struct_property_is_set(op->ptr, "layer")) {
1049  WM_jobs_delay_start(wm_job, 0.2);
1050  }
1051 
1052  /* get a render result image, and make sure it is empty */
1053  ima = BKE_image_ensure_viewer(bmain, IMA_TYPE_R_RESULT, "Render Result");
1054  BKE_image_signal(rj->main, ima, nullptr, IMA_SIGNAL_FREE);
1055  BKE_image_backup_render(rj->scene, ima, true);
1056  rj->image = ima;
1057 
1058  /* setup new render */
1059  re = RE_NewSceneRender(scene);
1067 
1068  rj->re = re;
1069  G.is_break = false;
1070 
1071  /* store actual owner of job, so modal operator could check for it,
1072  * the reason of this is that active scene could change when rendering
1073  * several layers from compositor T31800. */
1074  op->customdata = scene;
1075 
1076  WM_jobs_start(CTX_wm_manager(C), wm_job);
1077 
1078  WM_cursor_wait(false);
1080 
1081  /* we set G.is_rendering here already instead of only in the job, this ensure
1082  * main loop or other scene updates are disabled in time, since they may
1083  * have started before the job thread */
1084  G.is_rendering = true;
1085 
1086  /* add modal handler for ESC */
1088 
1089  return OPERATOR_RUNNING_MODAL;
1090 }
1091 
1093 {
1094  PropertyRNA *prop;
1095 
1096  /* identifiers */
1097  ot->name = "Render";
1098  ot->description = "Render active scene";
1099  ot->idname = "RENDER_OT_render";
1100 
1101  /* api callbacks */
1106 
1107  /* This isn't needed, causes failure in background mode. */
1108 #if 0
1110 #endif
1111 
1112  prop = RNA_def_boolean(ot->srna,
1113  "animation",
1114  false,
1115  "Animation",
1116  "Render files from the animation range of this scene");
1119  ot->srna,
1120  "write_still",
1121  false,
1122  "Write Image",
1123  "Save rendered the image to the output path (used only when animation is disabled)");
1124  prop = RNA_def_boolean(ot->srna,
1125  "use_viewport",
1126  false,
1127  "Use 3D Viewport",
1128  "When inside a 3D viewport, use layers and camera of the viewport");
1130  prop = RNA_def_string(ot->srna,
1131  "layer",
1132  nullptr,
1133  RE_MAXNAME,
1134  "Render Layer",
1135  "Single render layer to re-render (used only when animation is disabled)");
1137  prop = RNA_def_string(ot->srna,
1138  "scene",
1139  nullptr,
1140  MAX_ID_NAME - 2,
1141  "Scene",
1142  "Scene to render, current scene if not specified");
1144 }
1145 
1147 {
1151 
1152  if (rj) {
1153  return rj->scene;
1154  }
1155 
1156  return nullptr;
1157 }
1158 
1160 {
1164  if (rj) {
1165  return rj->current_scene;
1166  }
1167  return nullptr;
1168 }
1169 
1170 /* Motion blur curve preset */
1171 
1173 {
1175  CurveMapping *mblur_shutter_curve = &scene->r.mblur_shutter_curve;
1176  CurveMap *cm = mblur_shutter_curve->cm;
1177  int preset = RNA_enum_get(op->ptr, "shape");
1178 
1179  mblur_shutter_curve->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
1180  mblur_shutter_curve->preset = preset;
1182  cm, &mblur_shutter_curve->clipr, mblur_shutter_curve->preset, CURVEMAP_SLOPE_POS_NEG);
1183  BKE_curvemapping_changed(mblur_shutter_curve, false);
1184 
1185  return OPERATOR_FINISHED;
1186 }
1187 
1189 {
1190  PropertyRNA *prop;
1191  static const EnumPropertyItem prop_shape_items[] = {
1192  {CURVE_PRESET_SHARP, "SHARP", 0, "Sharp", ""},
1193  {CURVE_PRESET_SMOOTH, "SMOOTH", 0, "Smooth", ""},
1194  {CURVE_PRESET_MAX, "MAX", 0, "Max", ""},
1195  {CURVE_PRESET_LINE, "LINE", 0, "Line", ""},
1196  {CURVE_PRESET_ROUND, "ROUND", 0, "Round", ""},
1197  {CURVE_PRESET_ROOT, "ROOT", 0, "Root", ""},
1198  {0, nullptr, 0, nullptr, nullptr},
1199  };
1200 
1201  ot->name = "Shutter Curve Preset";
1202  ot->description = "Set shutter curve";
1203  ot->idname = "RENDER_OT_shutter_curve_preset";
1204 
1206 
1207  prop = RNA_def_enum(ot->srna, "shape", prop_shape_items, CURVE_PRESET_SMOOTH, "Mode", "");
1209  BLT_I18NCONTEXT_ID_CURVE_LEGACY); /* Abusing id_curve :/ */
1210 }
int ED_draw_imbuf_method(struct ImBuf *ibuf)
Definition: glutil.c:600
void BKE_color_managed_display_settings_copy(struct ColorManagedDisplaySettings *new_settings, const struct ColorManagedDisplaySettings *settings)
void BKE_curvemapping_changed(struct CurveMapping *cumap, bool rem_doubles)
Definition: colortools.c:855
void BKE_color_managed_view_settings_free(struct ColorManagedViewSettings *settings)
Definition: colortools.c:1856
void BKE_curvemap_reset(struct CurveMap *cuma, const struct rctf *clipr, int preset, int slope)
void BKE_color_managed_view_settings_copy(struct ColorManagedViewSettings *new_settings, const struct ColorManagedViewSettings *settings)
@ CURVEMAP_SLOPE_POS_NEG
struct Scene * CTX_data_scene(const bContext *C)
Definition: context.c:1090
struct wmWindowManager * CTX_wm_manager(const bContext *C)
Definition: context.c:713
struct ViewLayer * CTX_data_view_layer(const bContext *C)
Definition: context.c:1100
struct View3D * CTX_wm_view3d(const bContext *C)
Definition: context.c:784
struct bScreen * CTX_wm_screen(const bContext *C)
Definition: context.c:733
struct Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
Definition: context.c:1505
struct Main * CTX_data_main(const bContext *C)
Definition: context.c:1074
struct wmWindow * CTX_wm_window(const bContext *C)
Definition: context.c:723
#define G_MAIN
Definition: BKE_global.h:267
@ G_DEBUG
Definition: BKE_global.h:174
void BKE_image_release_ibuf(struct Image *ima, struct ImBuf *ibuf, void *lock)
struct ImBuf * BKE_image_acquire_ibuf(struct Image *ima, struct ImageUser *iuser, void **r_lock)
void BKE_image_backup_render(struct Scene *scene, struct Image *ima, bool free_current_slot)
void BKE_image_partial_update_mark_full_update(struct Image *image)
Mark the whole image to be updated.
struct Image * BKE_image_ensure_viewer(struct Main *bmain, int type, const char *name)
#define IMA_SIGNAL_FREE
Definition: BKE_image.h:130
void BKE_image_signal(struct Main *bmain, struct Image *ima, struct ImageUser *iuser, int signal)
void BKE_image_update_gputexture_delayed(struct Image *ima, struct ImageTile *image_tile, struct ImBuf *ibuf, int x, int y, int w, int h)
Definition: image_gpu.cc:846
bool BKE_imtype_is_movie(char imtype)
void BKE_main_id_tag_listbase(struct ListBase *lb, int tag, bool value)
Definition: lib_id.c:904
void BKE_main_free(struct Main *mainvar)
Definition: main.c:40
void BKE_ntree_update_tag_id_changed(struct Main *bmain, struct ID *id)
void BKE_ntree_update_main(struct Main *bmain, struct NodeTreeUpdateExtraParams *params)
General operations, lookup, etc. for blender objects.
void BKE_object_free_derived_caches(struct Object *ob)
Definition: object.cc:1774
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition: report.c:83
#define SETLOOPER_SET_ONLY(_sce_basis, _sce_iter, _base)
Definition: BKE_scene.h:48
bool BKE_scene_camera_switch_update(struct Scene *scene)
Definition: scene.cc:2295
int BKE_scene_multiview_view_id_get(const struct RenderData *rd, const char *viewname)
void BKE_spacedata_draw_locks(bool set)
Definition: screen.c:516
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
int BLI_findstringindex(const struct ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void * BLI_findstring(const struct ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition: BLI_rect.h:190
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition: BLI_rect.h:186
size_t BLI_timecode_string_from_time_simple(char *str, size_t maxncpy, double time_seconds) ATTR_NONNULL()
Definition: timecode.c:169
#define UNUSED(x)
#define BLT_I18NCONTEXT_ID_CURVE_LEGACY
#define TIP_(msgid)
struct Depsgraph Depsgraph
Definition: DEG_depsgraph.h:35
void DEG_tag_on_visible_update(struct Main *bmain, bool do_time)
#define MAX_ID_NAME
Definition: DNA_ID.h:337
@ LIB_TAG_DOIT
Definition: DNA_ID.h:707
@ CUMA_EXTEND_EXTRAPOLATE
@ CURVE_PRESET_ROOT
@ CURVE_PRESET_SMOOTH
@ CURVE_PRESET_ROUND
@ CURVE_PRESET_LINE
@ CURVE_PRESET_SHARP
@ CURVE_PRESET_MAX
#define IMA_MAX_RENDER_TEXT
@ IMA_TYPE_R_RESULT
@ BASE_VISIBLE_DEPSGRAPH
Object is a sort of wrapper for general info.
#define RE_PASSNAME_COMBINED
#define R_SINGLE_LAYER
#define R_DOSEQ
#define V3D_CAMERA_LOCAL(v3d)
#define R_NO_FRAME_UPDATE
@ SPACE_IMAGE
@ IMAGE_DRAW_METHOD_GLSL
@ OPERATOR_CANCELLED
@ OPERATOR_FINISHED
@ OPERATOR_RUNNING_MODAL
@ OPERATOR_PASS_THROUGH
bool ED_operator_screenactive(struct bContext *C)
Definition: screen_ops.c:119
int ED_screen_animation_play(struct bContext *C, int sync, int mode)
Definition: screen_ops.c:4811
void ED_update_for_newframe(struct Main *bmain, struct Depsgraph *depsgraph)
Definition: screen_edit.c:1694
bScreen * ED_screen_animation_playing(const struct wmWindowManager *wm)
bool ED_editors_flush_edits_ex(struct Main *bmain, bool for_render, bool check_needs_flush)
Definition: ed_util.c:308
bool IMB_colormanagement_support_glsl_draw(const struct ColorManagedViewSettings *view_settings)
void IMB_partial_display_buffer_update(struct ImBuf *ibuf, const float *linear_buffer, const unsigned char *byte_buffer, int stride, int offset_x, int offset_y, const struct ColorManagedViewSettings *view_settings, const struct ColorManagedDisplaySettings *display_settings, int xmin, int ymin, int xmax, int ymax)
Contains defines and structs used throughout the imbuf module.
@ IB_DISPLAY_BUFFER_INVALID
Read Guarded memory(de)allocation.
Platform independent time functions.
#define RE_MAXNAME
Definition: RE_pipeline.h:36
@ PROP_SKIP_SAVE
Definition: RNA_types.h:218
#define C
Definition: RandGen.cpp:25
@ WM_JOB_EXCL_RENDER
Definition: WM_api.h:1338
@ WM_JOB_PROGRESS
Definition: WM_api.h:1339
@ WM_JOB_PRIORITY
Definition: WM_api.h:1337
@ WM_JOB_TYPE_RENDER
Definition: WM_api.h:1349
#define NC_NODE
Definition: WM_types.h:344
#define ND_RENDER_RESULT
Definition: WM_types.h:394
#define NC_SCENE
Definition: WM_types.h:328
#define NA_EDITED
Definition: WM_types.h:523
volatile int lock
short last_render_slot
short render_slot
Scene scene
RenderEngineType * RE_engines_find(const char *idname)
Definition: engine.c:98
#define str(s)
void SEQ_cache_cleanup(Scene *scene)
Definition: image_cache.c:602
void * BKE_image_free_buffers
size_t(* MEM_get_peak_memory)(void)
Definition: mallocn.c:48
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
size_t(* MEM_get_memory_in_use)(void)
Definition: mallocn.c:45
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
static size_t mem_in_use
#define G(x, y, z)
static void error(const char *str)
Definition: meshlaplacian.c:51
static void area(int d1, int d2, int e1, int e2, float weights[2])
void ntreeCompositClearTags(bNodeTree *ntree)
bool RE_HasSingleLayer(Render *re)
Definition: pipeline.c:253
void RE_stats_draw_cb(Render *re, void *handle, void(*f)(void *handle, RenderStats *rs))
Definition: pipeline.c:874
RenderResult * RE_AcquireResultRead(Render *re)
Definition: pipeline.c:314
void RE_progress_cb(Render *re, void *handle, void(*f)(void *handle, float))
Definition: pipeline.c:879
int RE_seq_render_active(Scene *scene, RenderData *rd)
Definition: pipeline.c:1264
void RE_current_scene_update_cb(Render *re, void *handle, void(*f)(void *handle, Scene *scene))
Definition: pipeline.c:869
void RE_InitRenderCB(Render *re)
Definition: pipeline.c:565
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)
Definition: pipeline.c:1813
Render * RE_NewSceneRender(const Scene *scene)
Definition: pipeline.c:558
void RE_ReleaseResult(Render *re)
Definition: pipeline.c:351
float * RE_RenderLayerGetPass(RenderLayer *rl, const char *name, const char *viewname)
Definition: pipeline.c:238
void RE_RenderAnim(Render *re, Main *bmain, Scene *scene, ViewLayer *single_layer, Object *camera_override, int sfra, int efra, int tfra)
Definition: pipeline.c:2142
const char * RE_GetActiveRenderView(Render *re)
Definition: pipeline.c:1671
bool RE_allow_render_generic_object(Object *ob)
Definition: pipeline.c:2678
void RE_gl_context_create(Render *re)
Definition: pipeline.c:903
void RE_display_update_cb(Render *re, void *handle, void(*f)(void *handle, RenderResult *rr, rcti *rect))
Definition: pipeline.c:862
void RE_test_break_cb(Render *re, void *handle, int(*f)(void *handle))
Definition: pipeline.c:891
bool RE_is_rendering_allowed(Scene *scene, ViewLayer *single_layer, Object *camera_override, ReportList *reports)
Definition: pipeline.c:1596
void RE_draw_lock_cb(Render *re, void *handle, void(*f)(void *handle, bool lock))
Definition: pipeline.c:885
void RE_SetReports(Render *re, ReportList *reports)
Definition: pipeline.c:1753
struct ScrArea * render_view_open(struct bContext *C, int mx, int my, struct ReportList *reports)
Definition: render_view.cc:120
static void render_endjob(void *rjv)
static void render_image_restore_layer(RenderJob *rj)
static void current_scene_update(void *rjv, Scene *scene)
static int render_shutter_curve_preset_exec(bContext *C, wmOperator *op)
Scene * ED_render_job_get_scene(const bContext *C)
static int render_break(void *rjv)
static void image_rect_update(void *rjv, RenderResult *rr, rcti *renrect)
static int screen_render_modal(bContext *C, wmOperator *op, const wmEvent *event)
static void image_renderinfo_cb(void *rjv, RenderStats *rs)
void RENDER_OT_render(wmOperatorType *ot)
static void image_buffer_rect_update(RenderJob *rj, RenderResult *rr, ImBuf *ibuf, ImageUser *iuser, const rcti *tile_rect, int offset_x, int offset_y, const char *viewname)
static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
static int render_breakjob(void *rjv)
static void screen_render_single_layer_set(wmOperator *op, Main *mainp, ViewLayer *active_layer, Scene **scene, ViewLayer **single_layer)
static void render_drawlock(void *rjv, bool lock)
static void make_renderinfo_string(const RenderStats *rs, const Scene *scene, const bool v3d_override, const char *error, char *str)
void RENDER_OT_shutter_curve_preset(wmOperatorType *ot)
static int screen_render_exec(bContext *C, wmOperator *op)
static void clean_viewport_memory(Main *bmain, Scene *scene)
static void render_image_update_pass_and_layer(RenderJob *rj, RenderResult *rr, ImageUser *iuser)
static void render_progress_update(void *rjv, float progress)
static void clean_viewport_memory_base(Base *base)
static void screen_render_cancel(bContext *C, wmOperator *op)
static void render_startjob(void *rjv, short *stop, short *do_update, float *progress)
static void render_freejob(void *rjv)
Scene * ED_render_job_get_current_scene(const bContext *C)
static bool image_buffer_calc_tile_rect(const RenderResult *rr, const ImBuf *ibuf, rcti *renrect, rcti *r_ibuf_rect, int *r_offset_x, int *r_offset_y)
RenderView * RE_RenderViewGetById(RenderResult *rr, const int view_id)
bool RE_HasCombinedLayer(const RenderResult *rr)
void RNA_string_get(PointerRNA *ptr, const char *name, char *value)
Definition: rna_access.c:5116
bool RNA_struct_property_is_set(PointerRNA *ptr, const char *identifier)
Definition: rna_access.c:5301
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4863
int RNA_enum_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:5004
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, bool default_value, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3493
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, int maxlen, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3687
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
Definition: rna_define.c:2848
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
Definition: rna_define.c:1490
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3783
_W64 unsigned int uintptr_t
Definition: stdint.h:119
bool SEQ_relations_check_scene_recursion(Scene *scene, ReportList *reports)
struct Base * next
short flag
struct Object * object
CurveMap cm[4]
Definition: DNA_ID.h:368
int tag
Definition: DNA_ID.h:387
void * next
Definition: DNA_ID.h:369
int channels
int userflags
float * rect_float
struct Scene * scene
void * last
Definition: DNA_listBase.h:31
void * first
Definition: DNA_listBase.h:31
Definition: BKE_main.h:121
ListBase scenes
Definition: BKE_main.h:168
ListBase wm
Definition: BKE_main.h:197
ListBase objects
Definition: BKE_main.h:170
ustring name
Definition: graph/node.h:174
ImageUser * iuser
struct CurveMapping mblur_shutter_curve
char engine[32]
struct ImageFormatData im_format
char use_lock_interface
void(* render)(struct RenderEngine *engine, struct Depsgraph *depsgraph)
Definition: RE_engine.h:78
ImageUser iuser
short * do_update
bool image_outdated
ViewLayer * single_layer
Depsgraph * depsgraph
Scene * scene
ColorManagedViewSettings view_settings
ReportList * reports
struct Object * camera_override
Scene * current_scene
short * stop
ScrArea * area
bool supports_glsl_draw
bool interface_locked
Render * re
ColorManagedDisplaySettings display_settings
Image * image
float * progress
char name[RE_MAXNAME]
Definition: RE_pipeline.h:87
ListBase layers
Definition: RE_pipeline.h:122
char * error
Definition: RE_pipeline.h:139
RenderLayer * renlay
Definition: RE_pipeline.h:129
const char * statstr
Definition: RE_pipeline.h:150
float mem_peak
Definition: RE_pipeline.h:152
double starttime
Definition: RE_pipeline.h:149
float mem_used
Definition: RE_pipeline.h:152
double lastframetime
Definition: RE_pipeline.h:149
const char * infostr
Definition: RE_pipeline.h:150
bool localview
Definition: RE_pipeline.h:148
float * rectf
Definition: RE_pipeline.h:54
int * rect32
Definition: RE_pipeline.h:58
struct bNodeTree * nodetree
ColorManagedViewSettings view_settings
struct RenderData r
ListBase view_layers
struct Object * camera
ColorManagedDisplaySettings display_settings
struct ImageUser iuser
struct Image * image
ListBase object_bases
ListBase areabase
int ymin
Definition: DNA_vec_types.h:64
int ymax
Definition: DNA_vec_types.h:64
int xmin
Definition: DNA_vec_types.h:63
int xmax
Definition: DNA_vec_types.h:63
int xy[2]
Definition: WM_types.h:682
short type
Definition: WM_types.h:678
Definition: wm_jobs.c:57
int(* invoke)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:919
const char * name
Definition: WM_types.h:888
int(* modal)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:935
const char * idname
Definition: WM_types.h:890
bool(* poll)(struct bContext *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:943
void(* cancel)(struct bContext *, struct wmOperator *)
Definition: WM_types.h:927
struct StructRNA * srna
Definition: WM_types.h:969
const char * description
Definition: WM_types.h:893
int(* exec)(struct bContext *, struct wmOperator *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:903
struct ReportList * reports
struct PointerRNA * ptr
struct wmWindow * next
double PIL_check_seconds_timer(void)
Definition: time.c:64
void WM_cursor_wait(bool val)
Definition: wm_cursors.c:209
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void WM_main_add_notifier(unsigned int type, void *reference)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void WM_set_locked_interface(wmWindowManager *wm, bool lock)
@ EVT_ESCKEY
wmOperatorType * ot
Definition: wm_files.c:3479
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition: wm_jobs.c:437
void * WM_jobs_customdata_from_type(wmWindowManager *wm, const void *owner, int job_type)
Definition: wm_jobs.c:293
void WM_jobs_kill_type(struct wmWindowManager *wm, const void *owner, int job_type)
Definition: wm_jobs.c:572
void WM_jobs_delay_start(wmJob *wm_job, double delay_time)
Definition: wm_jobs.c:346
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition: wm_jobs.c:351
void WM_jobs_kill_all_except(wmWindowManager *wm, const void *owner)
Definition: wm_jobs.c:563
bool WM_jobs_test(const wmWindowManager *wm, const void *owner, int job_type)
Definition: wm_jobs.c:214
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *))
Definition: wm_jobs.c:323
void WM_jobs_timer(wmJob *wm_job, double timestep, unsigned int note, unsigned int endnote)
Definition: wm_jobs.c:339
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, int flag, int job_type)
Definition: wm_jobs.c:184
bScreen * WM_window_get_active_screen(const wmWindow *win)
Definition: wm_window.c:2300
ViewLayer * WM_window_get_active_view_layer(const wmWindow *win)
Definition: wm_window.c:2217