Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / render / render_internal.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edrend
22  */
23
24 #include <math.h>
25 #include <string.h>
26 #include <stddef.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "BLI_listbase.h"
31 #include "BLI_timecode.h"
32 #include "BLI_math.h"
33 #include "BLI_threads.h"
34 #include "BLI_utildefines.h"
35
36 #include "PIL_time.h"
37
38 #include "BLT_translation.h"
39
40 #include "DNA_object_types.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_view3d_types.h"
43 #include "DNA_userdef_types.h"
44
45 #include "BKE_blender_undo.h"
46 #include "BKE_blender_version.h"
47 #include "BKE_camera.h"
48 #include "BKE_context.h"
49 #include "BKE_colortools.h"
50 #include "BKE_global.h"
51 #include "BKE_image.h"
52 #include "BKE_layer.h"
53 #include "BKE_library.h"
54 #include "BKE_main.h"
55 #include "BKE_node.h"
56 #include "BKE_object.h"
57 #include "BKE_report.h"
58 #include "BKE_sequencer.h"
59 #include "BKE_screen.h"
60 #include "BKE_scene.h"
61 #include "BKE_undo_system.h"
62
63 #include "DEG_depsgraph.h"
64
65 #include "WM_api.h"
66 #include "WM_types.h"
67
68 #include "ED_object.h"
69 #include "ED_render.h"
70 #include "ED_screen.h"
71 #include "ED_util.h"
72 #include "ED_undo.h"
73 #include "ED_view3d.h"
74
75 #include "BIF_glutil.h"
76
77 #include "RE_pipeline.h"
78 #include "RE_engine.h"
79
80 #include "IMB_colormanagement.h"
81 #include "IMB_imbuf_types.h"
82
83 #include "GPU_shader.h"
84
85 #include "RNA_access.h"
86 #include "RNA_define.h"
87
88 #include "BLO_undofile.h"
89
90 #include "render_intern.h"
91
92 /* Render Callbacks */
93 static int render_break(void *rjv);
94
95 typedef struct RenderJob {
96   Main *main;
97   Scene *scene;
98   ViewLayer *single_layer;
99   Scene *current_scene;
100   /* TODO(sergey): Should not be needed once engine will have own
101    * depsgraph and copy-on-write will be implemented.
102    */
103   Depsgraph *depsgraph;
104   Render *re;
105   struct Object *camera_override;
106   bool v3d_override;
107   bool anim, write_still;
108   Image *image;
109   ImageUser iuser;
110   bool image_outdated;
111   short *stop;
112   short *do_update;
113   float *progress;
114   ReportList *reports;
115   int orig_layer;
116   int last_layer;
117   ScrArea *sa;
118   ColorManagedViewSettings view_settings;
119   ColorManagedDisplaySettings display_settings;
120   bool supports_glsl_draw;
121   bool interface_locked;
122 } RenderJob;
123
124 /* called inside thread! */
125 static void image_buffer_rect_update(RenderJob *rj,
126                                      RenderResult *rr,
127                                      ImBuf *ibuf,
128                                      ImageUser *iuser,
129                                      volatile rcti *renrect,
130                                      const char *viewname)
131 {
132   Scene *scene = rj->scene;
133   const float *rectf = NULL;
134   int ymin, ymax, xmin, xmax;
135   int rymin, rxmin;
136   int linear_stride, linear_offset_x, linear_offset_y;
137   ColorManagedViewSettings *view_settings;
138   ColorManagedDisplaySettings *display_settings;
139
140   /* Exception for exr tiles -- display buffer conversion happens here,
141    * NOT in the color management pipeline.
142    */
143   if (ibuf->userflags & IB_DISPLAY_BUFFER_INVALID && rr->do_exr_tile == false) {
144     /* The whole image buffer it so be color managed again anyway. */
145     return;
146   }
147
148   /* if renrect argument, we only refresh scanlines */
149   if (renrect) {
150     /* if (ymax == recty), rendering of layer is ready,
151      * we should not draw, other things happen... */
152     if (rr->renlay == NULL || renrect->ymax >= rr->recty) {
153       return;
154     }
155
156     /* xmin here is first subrect x coord, xmax defines subrect width */
157     xmin = renrect->xmin + rr->crop;
158     xmax = renrect->xmax - xmin + rr->crop;
159     if (xmax < 2) {
160       return;
161     }
162
163     ymin = renrect->ymin + rr->crop;
164     ymax = renrect->ymax - ymin + rr->crop;
165     if (ymax < 2) {
166       return;
167     }
168     renrect->ymin = renrect->ymax;
169   }
170   else {
171     xmin = ymin = rr->crop;
172     xmax = rr->rectx - 2 * rr->crop;
173     ymax = rr->recty - 2 * rr->crop;
174   }
175
176   /* xmin ymin is in tile coords. transform to ibuf */
177   rxmin = rr->tilerect.xmin + xmin;
178   if (rxmin >= ibuf->x) {
179     return;
180   }
181   rymin = rr->tilerect.ymin + ymin;
182   if (rymin >= ibuf->y) {
183     return;
184   }
185
186   if (rxmin + xmax > ibuf->x) {
187     xmax = ibuf->x - rxmin;
188   }
189   if (rymin + ymax > ibuf->y) {
190     ymax = ibuf->y - rymin;
191   }
192
193   if (xmax < 1 || ymax < 1) {
194     return;
195   }
196
197   /* The thing here is, the logic below (which was default behavior
198    * of how rectf is acquiring since forever) gives float buffer for
199    * composite output only. This buffer can not be used for other
200    * passes obviously.
201    *
202    * We might try finding corresponding for pass buffer in render result
203    * (which is actually missing when rendering with Cycles, who only
204    * writes all the passes when the tile is finished) or use float
205    * buffer from image buffer as reference, which is easier to use and
206    * contains all the data we need anyway.
207    *                                              - sergey -
208    */
209   /* TODO(sergey): Need to check has_combined here? */
210   if (iuser->pass == 0) {
211     RenderView *rv;
212     const int view_id = BKE_scene_multiview_view_id_get(&scene->r, viewname);
213     rv = RE_RenderViewGetById(rr, view_id);
214
215     /* find current float rect for display, first case is after composite... still weak */
216     if (rv->rectf) {
217       rectf = rv->rectf;
218     }
219     else {
220       if (rv->rect32) {
221         /* special case, currently only happens with sequencer rendering,
222          * which updates the whole frame, so we can only mark display buffer
223          * as invalid here (sergey)
224          */
225         ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
226         return;
227       }
228       else {
229         if (rr->renlay == NULL) {
230           return;
231         }
232         rectf = RE_RenderLayerGetPass(rr->renlay, RE_PASSNAME_COMBINED, viewname);
233       }
234     }
235     if (rectf == NULL) {
236       return;
237     }
238
239     rectf += 4 * (rr->rectx * ymin + xmin);
240     linear_stride = rr->rectx;
241     linear_offset_x = rxmin;
242     linear_offset_y = rymin;
243   }
244   else {
245     rectf = ibuf->rect_float;
246     linear_stride = ibuf->x;
247     linear_offset_x = 0;
248     linear_offset_y = 0;
249   }
250
251   if (rr->do_exr_tile) {
252     /* We don't support changing color management settings during rendering
253      * when using Save Buffers option.
254      */
255     view_settings = &rj->view_settings;
256     display_settings = &rj->display_settings;
257   }
258   else {
259     view_settings = &scene->view_settings;
260     display_settings = &scene->display_settings;
261   }
262
263   IMB_partial_display_buffer_update(ibuf,
264                                     rectf,
265                                     NULL,
266                                     linear_stride,
267                                     linear_offset_x,
268                                     linear_offset_y,
269                                     view_settings,
270                                     display_settings,
271                                     rxmin,
272                                     rymin,
273                                     rxmin + xmax,
274                                     rymin + ymax,
275                                     rr->do_exr_tile);
276 }
277
278 /* ****************************** render invoking ***************** */
279
280 /* set callbacks, exported to sequence render too.
281  * Only call in foreground (UI) renders. */
282
283 static void screen_render_single_layer_set(
284     wmOperator *op, Main *mainp, ViewLayer *active_layer, Scene **scene, ViewLayer **single_layer)
285 {
286   /* single layer re-render */
287   if (RNA_struct_property_is_set(op->ptr, "scene")) {
288     Scene *scn;
289     char scene_name[MAX_ID_NAME - 2];
290
291     RNA_string_get(op->ptr, "scene", scene_name);
292     scn = (Scene *)BLI_findstring(&mainp->scenes, scene_name, offsetof(ID, name) + 2);
293
294     if (scn) {
295       /* camera switch wont have updated */
296       scn->r.cfra = (*scene)->r.cfra;
297       BKE_scene_camera_switch_update(scn);
298
299       *scene = scn;
300     }
301   }
302
303   if (RNA_struct_property_is_set(op->ptr, "layer")) {
304     ViewLayer *rl;
305     char rl_name[RE_MAXNAME];
306
307     RNA_string_get(op->ptr, "layer", rl_name);
308     rl = (ViewLayer *)BLI_findstring(&(*scene)->view_layers, rl_name, offsetof(ViewLayer, name));
309
310     if (rl) {
311       *single_layer = rl;
312     }
313   }
314   else if (((*scene)->r.scemode & R_SINGLE_LAYER) && active_layer) {
315     *single_layer = active_layer;
316   }
317 }
318
319 /* executes blocking render */
320 static int screen_render_exec(bContext *C, wmOperator *op)
321 {
322   Scene *scene = CTX_data_scene(C);
323   RenderEngineType *re_type = RE_engines_find(scene->r.engine);
324   ViewLayer *active_layer = CTX_data_view_layer(C);
325   ViewLayer *single_layer = NULL;
326   Render *re;
327   Image *ima;
328   View3D *v3d = CTX_wm_view3d(C);
329   Main *mainp = CTX_data_main(C);
330   const bool is_animation = RNA_boolean_get(op->ptr, "animation");
331   const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
332   struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
333
334   /* Cannot do render if there is not this function. */
335   if (re_type->render == NULL) {
336     return OPERATOR_CANCELLED;
337   }
338
339   /* custom scene and single layer re-render */
340   screen_render_single_layer_set(op, mainp, active_layer, &scene, &single_layer);
341
342   if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
343     BKE_report(
344         op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
345     return OPERATOR_CANCELLED;
346   }
347
348   re = RE_NewSceneRender(scene);
349
350   G.is_break = false;
351   RE_test_break_cb(re, NULL, render_break);
352
353   ima = BKE_image_verify_viewer(mainp, IMA_TYPE_R_RESULT, "Render Result");
354   BKE_image_signal(mainp, ima, NULL, IMA_SIGNAL_FREE);
355   BKE_image_backup_render(scene, ima, true);
356
357   /* cleanup sequencer caches before starting user triggered render.
358    * otherwise, invalidated cache entries can make their way into
359    * the output rendering. We can't put that into RE_BlenderFrame,
360    * since sequence rendering can call that recursively... (peter) */
361   BKE_sequencer_cache_cleanup();
362
363   RE_SetReports(re, op->reports);
364
365   BLI_threaded_malloc_begin();
366   if (is_animation) {
367     RE_BlenderAnim(re,
368                    mainp,
369                    scene,
370                    single_layer,
371                    camera_override,
372                    scene->r.sfra,
373                    scene->r.efra,
374                    scene->r.frame_step);
375   }
376   else {
377     RE_BlenderFrame(
378         re, mainp, scene, single_layer, camera_override, scene->r.cfra, is_write_still);
379   }
380   BLI_threaded_malloc_end();
381
382   RE_SetReports(re, NULL);
383
384   // no redraw needed, we leave state as we entered it
385   ED_update_for_newframe(mainp, CTX_data_depsgraph(C));
386
387   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
388
389   return OPERATOR_FINISHED;
390 }
391
392 static void render_freejob(void *rjv)
393 {
394   RenderJob *rj = rjv;
395
396   BKE_color_managed_view_settings_free(&rj->view_settings);
397   MEM_freeN(rj);
398 }
399
400 /* str is IMA_MAX_RENDER_TEXT in size */
401 static void make_renderinfo_string(const RenderStats *rs,
402                                    const Scene *scene,
403                                    const bool v3d_override,
404                                    const char *error,
405                                    char *str)
406 {
407   char info_time_str[32];  // used to be extern to header_info.c
408   uintptr_t mem_in_use, mmap_in_use, peak_memory;
409   float megs_used_memory, mmap_used_memory, megs_peak_memory;
410   char *spos = str;
411
412   mem_in_use = MEM_get_memory_in_use();
413   mmap_in_use = MEM_get_mapped_memory_in_use();
414   peak_memory = MEM_get_peak_memory();
415
416   megs_used_memory = (mem_in_use - mmap_in_use) / (1024.0 * 1024.0);
417   mmap_used_memory = (mmap_in_use) / (1024.0 * 1024.0);
418   megs_peak_memory = (peak_memory) / (1024.0 * 1024.0);
419
420   /* local view */
421   if (rs->localview) {
422     spos += sprintf(spos, "%s | ", IFACE_("3D Local View"));
423   }
424   else if (v3d_override) {
425     spos += sprintf(spos, "%s | ", IFACE_("3D View"));
426   }
427
428   /* frame number */
429   spos += sprintf(spos, IFACE_("Frame:%d "), (scene->r.cfra));
430
431   /* previous and elapsed time */
432   BLI_timecode_string_from_time_simple(info_time_str, sizeof(info_time_str), rs->lastframetime);
433
434   if (rs->infostr && rs->infostr[0]) {
435     if (rs->lastframetime != 0.0) {
436       spos += sprintf(spos, IFACE_("| Last:%s "), info_time_str);
437     }
438     else {
439       spos += sprintf(spos, "| ");
440     }
441
442     BLI_timecode_string_from_time_simple(
443         info_time_str, sizeof(info_time_str), PIL_check_seconds_timer() - rs->starttime);
444   }
445   else {
446     spos += sprintf(spos, "| ");
447   }
448
449   spos += sprintf(spos, IFACE_("Time:%s "), info_time_str);
450
451   /* statistics */
452   if (rs->statstr) {
453     if (rs->statstr[0]) {
454       spos += sprintf(spos, "| %s ", rs->statstr);
455     }
456   }
457   else {
458     if (rs->totvert || rs->totface || rs->tothalo || rs->totstrand || rs->totlamp) {
459       spos += sprintf(spos, "| ");
460     }
461
462     if (rs->totvert) {
463       spos += sprintf(spos, IFACE_("Ve:%d "), rs->totvert);
464     }
465     if (rs->totface) {
466       spos += sprintf(spos, IFACE_("Fa:%d "), rs->totface);
467     }
468     if (rs->tothalo) {
469       spos += sprintf(spos, IFACE_("Ha:%d "), rs->tothalo);
470     }
471     if (rs->totstrand) {
472       spos += sprintf(spos, IFACE_("St:%d "), rs->totstrand);
473     }
474     if (rs->totlamp) {
475       spos += sprintf(spos, IFACE_("Li:%d "), rs->totlamp);
476     }
477
478     if (rs->mem_peak == 0.0f) {
479       spos += sprintf(spos,
480                       IFACE_("| Mem:%.2fM (%.2fM, Peak %.2fM) "),
481                       megs_used_memory,
482                       mmap_used_memory,
483                       megs_peak_memory);
484     }
485     else {
486       spos += sprintf(spos, IFACE_("| Mem:%.2fM, Peak: %.2fM "), rs->mem_used, rs->mem_peak);
487     }
488
489     if (rs->curfield) {
490       spos += sprintf(spos, IFACE_("Field %d "), rs->curfield);
491     }
492     if (rs->curblur) {
493       spos += sprintf(spos, IFACE_("Blur %d "), rs->curblur);
494     }
495   }
496
497   /* full sample */
498   if (rs->curfsa) {
499     spos += sprintf(spos, IFACE_("| Full Sample %d "), rs->curfsa);
500   }
501
502   /* extra info */
503   if (rs->infostr && rs->infostr[0]) {
504     spos += sprintf(spos, "| %s ", rs->infostr);
505   }
506   else if (error && error[0]) {
507     spos += sprintf(spos, "| %s ", error);
508   }
509
510   /* very weak... but 512 characters is quite safe */
511   if (spos >= str + IMA_MAX_RENDER_TEXT) {
512     if (G.debug & G_DEBUG) {
513       printf("WARNING! renderwin text beyond limit\n");
514     }
515   }
516 }
517
518 static void image_renderinfo_cb(void *rjv, RenderStats *rs)
519 {
520   RenderJob *rj = rjv;
521   RenderResult *rr;
522
523   rr = RE_AcquireResultRead(rj->re);
524
525   if (rr) {
526     /* malloc OK here, stats_draw is not in tile threads */
527     if (rr->text == NULL) {
528       rr->text = MEM_callocN(IMA_MAX_RENDER_TEXT, "rendertext");
529     }
530
531     make_renderinfo_string(rs, rj->scene, rj->v3d_override, rr->error, rr->text);
532   }
533
534   RE_ReleaseResult(rj->re);
535
536   /* make jobs timer to send notifier */
537   *(rj->do_update) = true;
538 }
539
540 static void render_progress_update(void *rjv, float progress)
541 {
542   RenderJob *rj = rjv;
543
544   if (rj->progress && *rj->progress != progress) {
545     *rj->progress = progress;
546
547     /* make jobs timer to send notifier */
548     *(rj->do_update) = true;
549   }
550 }
551
552 /* Not totally reliable, but works fine in most of cases and
553  * in worst case would just make it so extra color management
554  * for the whole render result is applied (which was already
555  * happening already).
556  */
557 static void render_image_update_pass_and_layer(RenderJob *rj, RenderResult *rr, ImageUser *iuser)
558 {
559   wmWindowManager *wm;
560   ScrArea *first_sa = NULL, *matched_sa = NULL;
561
562   /* image window, compo node users */
563   for (wm = rj->main->wm.first; wm && matched_sa == NULL; wm = wm->id.next) { /* only 1 wm */
564     wmWindow *win;
565     for (win = wm->windows.first; win && matched_sa == NULL; win = win->next) {
566       const bScreen *screen = WM_window_get_active_screen(win);
567
568       for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
569         if (sa->spacetype == SPACE_IMAGE) {
570           SpaceImage *sima = sa->spacedata.first;
571           // sa->spacedata might be empty when toggling fullscreen mode.
572           if (sima != NULL && sima->image == rj->image) {
573             if (first_sa == NULL) {
574               first_sa = sa;
575             }
576             if (sa == rj->sa) {
577               matched_sa = sa;
578               break;
579             }
580           }
581         }
582       }
583     }
584   }
585
586   if (matched_sa == NULL) {
587     matched_sa = first_sa;
588   }
589
590   if (matched_sa) {
591     SpaceImage *sima = matched_sa->spacedata.first;
592     RenderResult *main_rr = RE_AcquireResultRead(rj->re);
593
594     /* TODO(sergey): is there faster way to get the layer index? */
595     if (rr->renlay) {
596       int layer = BLI_findstringindex(
597           &main_rr->layers, (char *)rr->renlay->name, offsetof(RenderLayer, name));
598       sima->iuser.layer = layer;
599       rj->last_layer = layer;
600     }
601
602     iuser->pass = sima->iuser.pass;
603     iuser->layer = sima->iuser.layer;
604
605     RE_ReleaseResult(rj->re);
606   }
607 }
608
609 static void image_rect_update(void *rjv, RenderResult *rr, volatile rcti *renrect)
610 {
611   RenderJob *rj = rjv;
612   Image *ima = rj->image;
613   ImBuf *ibuf;
614   void *lock;
615   const char *viewname = RE_GetActiveRenderView(rj->re);
616
617   /* only update if we are displaying the slot being rendered */
618   if (ima->render_slot != ima->last_render_slot) {
619     rj->image_outdated = true;
620     return;
621   }
622   else if (rj->image_outdated) {
623     /* update entire render */
624     rj->image_outdated = false;
625     BKE_image_signal(rj->main, ima, NULL, IMA_SIGNAL_COLORMANAGE);
626     *(rj->do_update) = true;
627     return;
628   }
629
630   if (rr == NULL) {
631     return;
632   }
633
634   /* update part of render */
635   render_image_update_pass_and_layer(rj, rr, &rj->iuser);
636   ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
637   if (ibuf) {
638     /* Don't waste time on CPU side color management if
639      * image will be displayed using GLSL.
640      *
641      * Need to update rect if Save Buffers enabled because in
642      * this case GLSL doesn't have original float buffer to
643      * operate with.
644      */
645     if (rr->do_exr_tile || !rj->supports_glsl_draw || ibuf->channels == 1 ||
646         ED_draw_imbuf_method(ibuf) != IMAGE_DRAW_METHOD_GLSL) {
647       image_buffer_rect_update(rj, rr, ibuf, &rj->iuser, renrect, viewname);
648     }
649
650     /* make jobs timer to send notifier */
651     *(rj->do_update) = true;
652   }
653   BKE_image_release_ibuf(ima, ibuf, lock);
654 }
655
656 static void current_scene_update(void *rjv, Scene *scene)
657 {
658   RenderJob *rj = rjv;
659   rj->current_scene = scene;
660   rj->iuser.scene = scene;
661 }
662
663 static void render_startjob(void *rjv, short *stop, short *do_update, float *progress)
664 {
665   RenderJob *rj = rjv;
666
667   rj->stop = stop;
668   rj->do_update = do_update;
669   rj->progress = progress;
670
671   RE_SetReports(rj->re, rj->reports);
672
673   if (rj->anim) {
674     RE_BlenderAnim(rj->re,
675                    rj->main,
676                    rj->scene,
677                    rj->single_layer,
678                    rj->camera_override,
679                    rj->scene->r.sfra,
680                    rj->scene->r.efra,
681                    rj->scene->r.frame_step);
682   }
683   else {
684     RE_BlenderFrame(rj->re,
685                     rj->main,
686                     rj->scene,
687                     rj->single_layer,
688                     rj->camera_override,
689                     rj->scene->r.cfra,
690                     rj->write_still);
691   }
692
693   RE_SetReports(rj->re, NULL);
694 }
695
696 static void render_image_restore_layer(RenderJob *rj)
697 {
698   wmWindowManager *wm;
699
700   /* image window, compo node users */
701   for (wm = rj->main->wm.first; wm; wm = wm->id.next) { /* only 1 wm */
702     wmWindow *win;
703     for (win = wm->windows.first; win; win = win->next) {
704       const bScreen *screen = WM_window_get_active_screen(win);
705
706       for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
707         if (sa == rj->sa) {
708           if (sa->spacetype == SPACE_IMAGE) {
709             SpaceImage *sima = sa->spacedata.first;
710
711             if (RE_HasSingleLayer(rj->re)) {
712               /* For single layer renders keep the active layer
713                * visible, or show the compositing result. */
714               RenderResult *rr = RE_AcquireResultRead(rj->re);
715               if (RE_HasCombinedLayer(rr)) {
716                 sima->iuser.layer = 0;
717               }
718               RE_ReleaseResult(rj->re);
719             }
720             else {
721               /* For multiple layer render, set back the layer
722                * that was set at the start of rendering. */
723               sima->iuser.layer = rj->orig_layer;
724             }
725           }
726           return;
727         }
728       }
729     }
730   }
731 }
732
733 static void render_endjob(void *rjv)
734 {
735   RenderJob *rj = rjv;
736
737   /* this render may be used again by the sequencer without the active
738    * 'Render' where the callbacks would be re-assigned. assign dummy callbacks
739    * to avoid referencing freed renderjobs bug T24508. */
740   RE_InitRenderCB(rj->re);
741
742   if (rj->main != G_MAIN) {
743     BKE_main_free(rj->main);
744   }
745
746   /* else the frame will not update for the original value */
747   if (rj->anim && !(rj->scene->r.scemode & R_NO_FRAME_UPDATE)) {
748     /* possible this fails of loading new file while rendering */
749     if (G_MAIN->wm.first) {
750       ED_update_for_newframe(G_MAIN, rj->depsgraph);
751     }
752   }
753
754   /* XXX above function sets all tags in nodes */
755   ntreeCompositClearTags(rj->scene->nodetree);
756
757   /* potentially set by caller */
758   rj->scene->r.scemode &= ~R_NO_FRAME_UPDATE;
759
760   if (rj->single_layer) {
761     nodeUpdateID(rj->scene->nodetree, &rj->scene->id);
762     WM_main_add_notifier(NC_NODE | NA_EDITED, rj->scene);
763   }
764
765   if (rj->sa) {
766     render_image_restore_layer(rj);
767   }
768
769   /* XXX render stability hack */
770   G.is_rendering = false;
771   WM_main_add_notifier(NC_SCENE | ND_RENDER_RESULT, NULL);
772
773   /* Partial render result will always update display buffer
774    * for first render layer only. This is nice because you'll
775    * see render progress during rendering, but it ends up in
776    * wrong display buffer shown after rendering.
777    *
778    * The code below will mark display buffer as invalid after
779    * rendering in case multiple layers were rendered, which
780    * ensures display buffer matches render layer after
781    * rendering.
782    *
783    * Perhaps proper way would be to toggle active render
784    * layer in image editor and job, so we always display
785    * layer being currently rendered. But this is not so much
786    * trivial at this moment, especially because of external
787    * engine API, so lets use simple and robust way for now
788    *                                          - sergey -
789    */
790   if (rj->scene->view_layers.first != rj->scene->view_layers.last || rj->image_outdated) {
791     void *lock;
792     Image *ima = rj->image;
793     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
794
795     if (ibuf) {
796       ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
797     }
798
799     BKE_image_release_ibuf(ima, ibuf, lock);
800   }
801
802   /* Finally unlock the user interface (if it was locked). */
803   if (rj->interface_locked) {
804     /* Interface was locked, so window manager couldn't have been changed
805      * and using one from Global will unlock exactly the same manager as
806      * was locked before running the job.
807      */
808     WM_set_locked_interface(G_MAIN->wm.first, false);
809     DEG_on_visible_update(G_MAIN, false);
810   }
811 }
812
813 /* called by render, check job 'stop' value or the global */
814 static int render_breakjob(void *rjv)
815 {
816   RenderJob *rj = rjv;
817
818   if (G.is_break) {
819     return 1;
820   }
821   if (rj->stop && *(rj->stop)) {
822     return 1;
823   }
824   return 0;
825 }
826
827 /* for exec() when there is no render job
828  * note: this wont check for the escape key being pressed, but doing so isnt threadsafe */
829 static int render_break(void *UNUSED(rjv))
830 {
831   if (G.is_break) {
832     return 1;
833   }
834   return 0;
835 }
836
837 /* runs in thread, no cursor setting here works. careful with notifiers too (malloc conflicts) */
838 /* maybe need a way to get job send notifier? */
839 static void render_drawlock(void *rjv, int lock)
840 {
841   RenderJob *rj = rjv;
842
843   /* If interface is locked, renderer callback shall do nothing. */
844   if (!rj->interface_locked) {
845     BKE_spacedata_draw_locks(lock);
846   }
847 }
848
849 /* catch esc */
850 static int screen_render_modal(bContext *C, wmOperator *op, const wmEvent *event)
851 {
852   Scene *scene = (Scene *)op->customdata;
853
854   /* no running blender, remove handler and pass through */
855   if (0 == WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER)) {
856     return OPERATOR_FINISHED | OPERATOR_PASS_THROUGH;
857   }
858
859   /* running render */
860   switch (event->type) {
861     case ESCKEY:
862       return OPERATOR_RUNNING_MODAL;
863   }
864   return OPERATOR_PASS_THROUGH;
865 }
866
867 static void screen_render_cancel(bContext *C, wmOperator *op)
868 {
869   wmWindowManager *wm = CTX_wm_manager(C);
870   Scene *scene = (Scene *)op->customdata;
871
872   /* kill on cancel, because job is using op->reports */
873   WM_jobs_kill_type(wm, scene, WM_JOB_TYPE_RENDER);
874 }
875
876 static void clean_viewport_memory_base(Base *base)
877 {
878   if ((base->flag & BASE_VISIBLE) == 0) {
879     return;
880   }
881
882   Object *object = base->object;
883
884   if (object->id.tag & LIB_TAG_DOIT) {
885     return;
886   }
887
888   object->id.tag &= ~LIB_TAG_DOIT;
889   if (RE_allow_render_generic_object(object)) {
890     BKE_object_free_derived_caches(object);
891   }
892 }
893
894 static void clean_viewport_memory(Main *bmain, Scene *scene)
895 {
896   Scene *sce_iter;
897   Base *base;
898
899   /* Tag all the available objects. */
900   BKE_main_id_tag_listbase(&bmain->objects, LIB_TAG_DOIT, true);
901
902   /* Go over all the visible objects. */
903   for (wmWindowManager *wm = bmain->wm.first; wm; wm = wm->id.next) {
904     for (wmWindow *win = wm->windows.first; win; win = win->next) {
905       ViewLayer *view_layer = WM_window_get_active_view_layer(win);
906
907       for (base = view_layer->object_bases.first; base; base = base->next) {
908         clean_viewport_memory_base(base);
909       }
910     }
911   }
912
913   for (SETLOOPER_SET_ONLY(scene, sce_iter, base)) {
914     clean_viewport_memory_base(base);
915   }
916 }
917
918 /* using context, starts job */
919 static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
920 {
921   /* new render clears all callbacks */
922   Main *bmain = CTX_data_main(C);
923   Scene *scene = CTX_data_scene(C);
924   ViewLayer *active_layer = CTX_data_view_layer(C);
925   ViewLayer *single_layer = NULL;
926   RenderEngineType *re_type = RE_engines_find(scene->r.engine);
927   Render *re;
928   wmJob *wm_job;
929   RenderJob *rj;
930   Image *ima;
931   int jobflag;
932   const bool is_animation = RNA_boolean_get(op->ptr, "animation");
933   const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
934   const bool use_viewport = RNA_boolean_get(op->ptr, "use_viewport");
935   View3D *v3d = use_viewport ? CTX_wm_view3d(C) : NULL;
936   struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
937   const char *name;
938   ScrArea *sa;
939
940   /* Cannot do render if there is not this function. */
941   if (re_type->render == NULL) {
942     return OPERATOR_CANCELLED;
943   }
944
945   /* custom scene and single layer re-render */
946   screen_render_single_layer_set(op, bmain, active_layer, &scene, &single_layer);
947
948   /* only one render job at a time */
949   if (WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER)) {
950     return OPERATOR_CANCELLED;
951   }
952
953   if (!RE_is_rendering_allowed(scene, single_layer, camera_override, op->reports)) {
954     return OPERATOR_CANCELLED;
955   }
956
957   if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
958     BKE_report(
959         op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
960     return OPERATOR_CANCELLED;
961   }
962
963   /* stop all running jobs, except screen one. currently previews frustrate Render */
964   WM_jobs_kill_all_except(CTX_wm_manager(C), CTX_wm_screen(C));
965
966   /* cancel animation playback */
967   if (ED_screen_animation_playing(CTX_wm_manager(C))) {
968     ED_screen_animation_play(C, 0, 0);
969   }
970
971   /* handle UI stuff */
972   WM_cursor_wait(1);
973
974   /* flush sculpt and editmode changes */
975   ED_editors_flush_edits(bmain, true);
976
977   /* cleanup sequencer caches before starting user triggered render.
978    * otherwise, invalidated cache entries can make their way into
979    * the output rendering. We can't put that into RE_BlenderFrame,
980    * since sequence rendering can call that recursively... (peter) */
981   BKE_sequencer_cache_cleanup();
982
983   // store spare
984   // get view3d layer, local layer, make this nice api call to render
985   // store spare
986
987   /* ensure at least 1 area shows result */
988   sa = render_view_open(C, event->x, event->y, op->reports);
989
990   jobflag = WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS;
991
992   if (RNA_struct_property_is_set(op->ptr, "layer")) {
993     jobflag |= WM_JOB_SUSPEND;
994   }
995
996   /* job custom data */
997   rj = MEM_callocN(sizeof(RenderJob), "render job");
998   rj->main = bmain;
999   rj->scene = scene;
1000   rj->current_scene = rj->scene;
1001   rj->single_layer = single_layer;
1002   /* TODO(sergey): Render engine should be using own depsgraph. */
1003   rj->depsgraph = CTX_data_depsgraph(C);
1004   rj->camera_override = camera_override;
1005   rj->anim = is_animation;
1006   rj->write_still = is_write_still && !is_animation;
1007   rj->iuser.scene = scene;
1008   rj->iuser.ok = 1;
1009   rj->reports = op->reports;
1010   rj->orig_layer = 0;
1011   rj->last_layer = 0;
1012   rj->sa = sa;
1013   rj->supports_glsl_draw = IMB_colormanagement_support_glsl_draw(&scene->view_settings);
1014
1015   BKE_color_managed_display_settings_copy(&rj->display_settings, &scene->display_settings);
1016   BKE_color_managed_view_settings_copy(&rj->view_settings, &scene->view_settings);
1017
1018   if (sa) {
1019     SpaceImage *sima = sa->spacedata.first;
1020     rj->orig_layer = sima->iuser.layer;
1021   }
1022
1023   if (v3d) {
1024     if (camera_override && camera_override != scene->camera) {
1025       rj->v3d_override = true;
1026     }
1027   }
1028
1029   /* Lock the user interface depending on render settings. */
1030   if (scene->r.use_lock_interface) {
1031     WM_set_locked_interface(CTX_wm_manager(C), true);
1032
1033     /* Set flag interface need to be unlocked.
1034      *
1035      * This is so because we don't have copy of render settings
1036      * accessible from render job and copy is needed in case
1037      * of non-locked rendering, so we wouldn't try to unlock
1038      * anything if option was initially unset but then was
1039      * enabled during rendering.
1040      */
1041     rj->interface_locked = true;
1042
1043     /* Clean memory used by viewport? */
1044     clean_viewport_memory(rj->main, scene);
1045   }
1046
1047   /* setup job */
1048   if (RE_seq_render_active(scene, &scene->r)) {
1049     name = "Sequence Render";
1050   }
1051   else {
1052     name = "Render";
1053   }
1054
1055   wm_job = WM_jobs_get(
1056       CTX_wm_manager(C), CTX_wm_window(C), scene, name, jobflag, WM_JOB_TYPE_RENDER);
1057   WM_jobs_customdata_set(wm_job, rj, render_freejob);
1058   WM_jobs_timer(wm_job, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
1059   WM_jobs_callbacks(wm_job, render_startjob, NULL, NULL, render_endjob);
1060
1061   /* get a render result image, and make sure it is empty */
1062   ima = BKE_image_verify_viewer(bmain, IMA_TYPE_R_RESULT, "Render Result");
1063   BKE_image_signal(rj->main, ima, NULL, IMA_SIGNAL_FREE);
1064   BKE_image_backup_render(rj->scene, ima, true);
1065   rj->image = ima;
1066
1067   /* setup new render */
1068   re = RE_NewSceneRender(scene);
1069   RE_test_break_cb(re, rj, render_breakjob);
1070   RE_draw_lock_cb(re, rj, render_drawlock);
1071   RE_display_update_cb(re, rj, image_rect_update);
1072   RE_current_scene_update_cb(re, rj, current_scene_update);
1073   RE_stats_draw_cb(re, rj, image_renderinfo_cb);
1074   RE_progress_cb(re, rj, render_progress_update);
1075   RE_gl_context_create(re);
1076
1077   rj->re = re;
1078   G.is_break = false;
1079
1080   /* store actual owner of job, so modal operator could check for it,
1081    * the reason of this is that active scene could change when rendering
1082    * several layers from compositor [#31800]
1083    */
1084   op->customdata = scene;
1085
1086   WM_jobs_start(CTX_wm_manager(C), wm_job);
1087
1088   WM_cursor_wait(0);
1089   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
1090
1091   /* we set G.is_rendering here already instead of only in the job, this ensure
1092    * main loop or other scene updates are disabled in time, since they may
1093    * have started before the job thread */
1094   G.is_rendering = true;
1095
1096   /* add modal handler for ESC */
1097   WM_event_add_modal_handler(C, op);
1098
1099   return OPERATOR_RUNNING_MODAL;
1100 }
1101
1102 /* contextual render, using current scene, view3d? */
1103 void RENDER_OT_render(wmOperatorType *ot)
1104 {
1105   PropertyRNA *prop;
1106
1107   /* identifiers */
1108   ot->name = "Render";
1109   ot->description = "Render active scene";
1110   ot->idname = "RENDER_OT_render";
1111
1112   /* api callbacks */
1113   ot->invoke = screen_render_invoke;
1114   ot->modal = screen_render_modal;
1115   ot->cancel = screen_render_cancel;
1116   ot->exec = screen_render_exec;
1117
1118   /*ot->poll = ED_operator_screenactive;*/ /* this isn't needed, causes failer in background mode */
1119
1120   prop = RNA_def_boolean(ot->srna,
1121                          "animation",
1122                          0,
1123                          "Animation",
1124                          "Render files from the animation range of this scene");
1125   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1126   RNA_def_boolean(
1127       ot->srna,
1128       "write_still",
1129       0,
1130       "Write Image",
1131       "Save rendered the image to the output path (used only when animation is disabled)");
1132   prop = RNA_def_boolean(ot->srna,
1133                          "use_viewport",
1134                          0,
1135                          "Use 3D Viewport",
1136                          "When inside a 3D viewport, use layers and camera of the viewport");
1137   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1138   prop = RNA_def_string(ot->srna,
1139                         "layer",
1140                         NULL,
1141                         RE_MAXNAME,
1142                         "Render Layer",
1143                         "Single render layer to re-render (used only when animation is disabled)");
1144   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1145   prop = RNA_def_string(ot->srna,
1146                         "scene",
1147                         NULL,
1148                         MAX_ID_NAME - 2,
1149                         "Scene",
1150                         "Scene to render, current scene if not specified");
1151   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1152 }
1153
1154 Scene *ED_render_job_get_scene(const bContext *C)
1155 {
1156   wmWindowManager *wm = CTX_wm_manager(C);
1157   RenderJob *rj = (RenderJob *)WM_jobs_customdata_from_type(wm, WM_JOB_TYPE_RENDER);
1158
1159   if (rj) {
1160     return rj->scene;
1161   }
1162
1163   return NULL;
1164 }
1165
1166 Scene *ED_render_job_get_current_scene(const bContext *C)
1167 {
1168   wmWindowManager *wm = CTX_wm_manager(C);
1169   RenderJob *rj = (RenderJob *)WM_jobs_customdata_from_type(wm, WM_JOB_TYPE_RENDER);
1170   if (rj) {
1171     return rj->current_scene;
1172   }
1173   return NULL;
1174 }
1175
1176 /* Motion blur curve preset */
1177
1178 static int render_shutter_curve_preset_exec(bContext *C, wmOperator *op)
1179 {
1180   Scene *scene = CTX_data_scene(C);
1181   CurveMapping *mblur_shutter_curve = &scene->r.mblur_shutter_curve;
1182   CurveMap *cm = mblur_shutter_curve->cm;
1183   int preset = RNA_enum_get(op->ptr, "shape");
1184
1185   cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
1186   mblur_shutter_curve->preset = preset;
1187   curvemap_reset(
1188       cm, &mblur_shutter_curve->clipr, mblur_shutter_curve->preset, CURVEMAP_SLOPE_POS_NEG);
1189   curvemapping_changed(mblur_shutter_curve, false);
1190
1191   return OPERATOR_FINISHED;
1192 }
1193
1194 void RENDER_OT_shutter_curve_preset(wmOperatorType *ot)
1195 {
1196   PropertyRNA *prop;
1197   static const EnumPropertyItem prop_shape_items[] = {
1198       {CURVE_PRESET_SHARP, "SHARP", 0, "Sharp", ""},
1199       {CURVE_PRESET_SMOOTH, "SMOOTH", 0, "Smooth", ""},
1200       {CURVE_PRESET_MAX, "MAX", 0, "Max", ""},
1201       {CURVE_PRESET_LINE, "LINE", 0, "Line", ""},
1202       {CURVE_PRESET_ROUND, "ROUND", 0, "Round", ""},
1203       {CURVE_PRESET_ROOT, "ROOT", 0, "Root", ""},
1204       {0, NULL, 0, NULL, NULL},
1205   };
1206
1207   ot->name = "Shutter Curve Preset";
1208   ot->description = "Set shutter curve";
1209   ot->idname = "RENDER_OT_shutter_curve_preset";
1210
1211   ot->exec = render_shutter_curve_preset_exec;
1212
1213   prop = RNA_def_enum(ot->srna, "shape", prop_shape_items, CURVE_PRESET_SMOOTH, "Mode", "");
1214   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
1215 }