Viewport: MSAA support during ViewportRendering
[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_RenderFrame,
360    * since sequence rendering can call that recursively... (peter) */
361   BKE_sequencer_cache_cleanup(scene);
362
363   RE_SetReports(re, op->reports);
364
365   BLI_threaded_malloc_begin();
366   if (is_animation) {
367     RE_RenderAnim(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_RenderFrame(re, mainp, scene, single_layer, camera_override, scene->r.cfra, is_write_still);
378   }
379   BLI_threaded_malloc_end();
380
381   RE_SetReports(re, NULL);
382
383   // no redraw needed, we leave state as we entered it
384   ED_update_for_newframe(mainp, CTX_data_depsgraph(C));
385
386   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
387
388   return OPERATOR_FINISHED;
389 }
390
391 static void render_freejob(void *rjv)
392 {
393   RenderJob *rj = rjv;
394
395   BKE_color_managed_view_settings_free(&rj->view_settings);
396   MEM_freeN(rj);
397 }
398
399 /* str is IMA_MAX_RENDER_TEXT in size */
400 static void make_renderinfo_string(const RenderStats *rs,
401                                    const Scene *scene,
402                                    const bool v3d_override,
403                                    const char *error,
404                                    char *str)
405 {
406   char info_time_str[32];  // used to be extern to header_info.c
407   uintptr_t mem_in_use, mmap_in_use, peak_memory;
408   float megs_used_memory, mmap_used_memory, megs_peak_memory;
409   char *spos = str;
410
411   mem_in_use = MEM_get_memory_in_use();
412   mmap_in_use = MEM_get_mapped_memory_in_use();
413   peak_memory = MEM_get_peak_memory();
414
415   megs_used_memory = (mem_in_use - mmap_in_use) / (1024.0 * 1024.0);
416   mmap_used_memory = (mmap_in_use) / (1024.0 * 1024.0);
417   megs_peak_memory = (peak_memory) / (1024.0 * 1024.0);
418
419   /* local view */
420   if (rs->localview) {
421     spos += sprintf(spos, "%s | ", IFACE_("3D Local View"));
422   }
423   else if (v3d_override) {
424     spos += sprintf(spos, "%s | ", IFACE_("3D View"));
425   }
426
427   /* frame number */
428   spos += sprintf(spos, IFACE_("Frame:%d "), (scene->r.cfra));
429
430   /* previous and elapsed time */
431   BLI_timecode_string_from_time_simple(info_time_str, sizeof(info_time_str), rs->lastframetime);
432
433   if (rs->infostr && rs->infostr[0]) {
434     if (rs->lastframetime != 0.0) {
435       spos += sprintf(spos, IFACE_("| Last:%s "), info_time_str);
436     }
437     else {
438       spos += sprintf(spos, "| ");
439     }
440
441     BLI_timecode_string_from_time_simple(
442         info_time_str, sizeof(info_time_str), PIL_check_seconds_timer() - rs->starttime);
443   }
444   else {
445     spos += sprintf(spos, "| ");
446   }
447
448   spos += sprintf(spos, IFACE_("Time:%s "), info_time_str);
449
450   /* statistics */
451   if (rs->statstr) {
452     if (rs->statstr[0]) {
453       spos += sprintf(spos, "| %s ", rs->statstr);
454     }
455   }
456   else {
457     if (rs->totvert || rs->totface || rs->tothalo || rs->totstrand || rs->totlamp) {
458       spos += sprintf(spos, "| ");
459     }
460
461     if (rs->totvert) {
462       spos += sprintf(spos, IFACE_("Ve:%d "), rs->totvert);
463     }
464     if (rs->totface) {
465       spos += sprintf(spos, IFACE_("Fa:%d "), rs->totface);
466     }
467     if (rs->tothalo) {
468       spos += sprintf(spos, IFACE_("Ha:%d "), rs->tothalo);
469     }
470     if (rs->totstrand) {
471       spos += sprintf(spos, IFACE_("St:%d "), rs->totstrand);
472     }
473     if (rs->totlamp) {
474       spos += sprintf(spos, IFACE_("Li:%d "), rs->totlamp);
475     }
476
477     if (rs->mem_peak == 0.0f) {
478       spos += sprintf(spos,
479                       IFACE_("| Mem:%.2fM (%.2fM, Peak %.2fM) "),
480                       megs_used_memory,
481                       mmap_used_memory,
482                       megs_peak_memory);
483     }
484     else {
485       spos += sprintf(spos, IFACE_("| Mem:%.2fM, Peak: %.2fM "), rs->mem_used, rs->mem_peak);
486     }
487
488     if (rs->curfield) {
489       spos += sprintf(spos, IFACE_("Field %d "), rs->curfield);
490     }
491     if (rs->curblur) {
492       spos += sprintf(spos, IFACE_("Blur %d "), rs->curblur);
493     }
494   }
495
496   /* full sample */
497   if (rs->curfsa) {
498     spos += sprintf(spos, IFACE_("| Full Sample %d "), rs->curfsa);
499   }
500
501   /* extra info */
502   if (rs->infostr && rs->infostr[0]) {
503     spos += sprintf(spos, "| %s ", rs->infostr);
504   }
505   else if (error && error[0]) {
506     spos += sprintf(spos, "| %s ", error);
507   }
508
509   /* very weak... but 512 characters is quite safe */
510   if (spos >= str + IMA_MAX_RENDER_TEXT) {
511     if (G.debug & G_DEBUG) {
512       printf("WARNING! renderwin text beyond limit\n");
513     }
514   }
515 }
516
517 static void image_renderinfo_cb(void *rjv, RenderStats *rs)
518 {
519   RenderJob *rj = rjv;
520   RenderResult *rr;
521
522   rr = RE_AcquireResultRead(rj->re);
523
524   if (rr) {
525     /* malloc OK here, stats_draw is not in tile threads */
526     if (rr->text == NULL) {
527       rr->text = MEM_callocN(IMA_MAX_RENDER_TEXT, "rendertext");
528     }
529
530     make_renderinfo_string(rs, rj->scene, rj->v3d_override, rr->error, rr->text);
531   }
532
533   RE_ReleaseResult(rj->re);
534
535   /* make jobs timer to send notifier */
536   *(rj->do_update) = true;
537 }
538
539 static void render_progress_update(void *rjv, float progress)
540 {
541   RenderJob *rj = rjv;
542
543   if (rj->progress && *rj->progress != progress) {
544     *rj->progress = progress;
545
546     /* make jobs timer to send notifier */
547     *(rj->do_update) = true;
548   }
549 }
550
551 /* Not totally reliable, but works fine in most of cases and
552  * in worst case would just make it so extra color management
553  * for the whole render result is applied (which was already
554  * happening already).
555  */
556 static void render_image_update_pass_and_layer(RenderJob *rj, RenderResult *rr, ImageUser *iuser)
557 {
558   wmWindowManager *wm;
559   ScrArea *first_sa = NULL, *matched_sa = NULL;
560
561   /* image window, compo node users */
562   for (wm = rj->main->wm.first; wm && matched_sa == NULL; wm = wm->id.next) { /* only 1 wm */
563     wmWindow *win;
564     for (win = wm->windows.first; win && matched_sa == NULL; win = win->next) {
565       const bScreen *screen = WM_window_get_active_screen(win);
566
567       for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
568         if (sa->spacetype == SPACE_IMAGE) {
569           SpaceImage *sima = sa->spacedata.first;
570           // sa->spacedata might be empty when toggling fullscreen mode.
571           if (sima != NULL && sima->image == rj->image) {
572             if (first_sa == NULL) {
573               first_sa = sa;
574             }
575             if (sa == rj->sa) {
576               matched_sa = sa;
577               break;
578             }
579           }
580         }
581       }
582     }
583   }
584
585   if (matched_sa == NULL) {
586     matched_sa = first_sa;
587   }
588
589   if (matched_sa) {
590     SpaceImage *sima = matched_sa->spacedata.first;
591     RenderResult *main_rr = RE_AcquireResultRead(rj->re);
592
593     /* TODO(sergey): is there faster way to get the layer index? */
594     if (rr->renlay) {
595       int layer = BLI_findstringindex(
596           &main_rr->layers, (char *)rr->renlay->name, offsetof(RenderLayer, name));
597       sima->iuser.layer = layer;
598       rj->last_layer = layer;
599     }
600
601     iuser->pass = sima->iuser.pass;
602     iuser->layer = sima->iuser.layer;
603
604     RE_ReleaseResult(rj->re);
605   }
606 }
607
608 static void image_rect_update(void *rjv, RenderResult *rr, volatile rcti *renrect)
609 {
610   RenderJob *rj = rjv;
611   Image *ima = rj->image;
612   ImBuf *ibuf;
613   void *lock;
614   const char *viewname = RE_GetActiveRenderView(rj->re);
615
616   /* only update if we are displaying the slot being rendered */
617   if (ima->render_slot != ima->last_render_slot) {
618     rj->image_outdated = true;
619     return;
620   }
621   else if (rj->image_outdated) {
622     /* update entire render */
623     rj->image_outdated = false;
624     BKE_image_signal(rj->main, ima, NULL, IMA_SIGNAL_COLORMANAGE);
625     *(rj->do_update) = true;
626     return;
627   }
628
629   if (rr == NULL) {
630     return;
631   }
632
633   /* update part of render */
634   render_image_update_pass_and_layer(rj, rr, &rj->iuser);
635   ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
636   if (ibuf) {
637     /* Don't waste time on CPU side color management if
638      * image will be displayed using GLSL.
639      *
640      * Need to update rect if Save Buffers enabled because in
641      * this case GLSL doesn't have original float buffer to
642      * operate with.
643      */
644     if (rr->do_exr_tile || !rj->supports_glsl_draw || ibuf->channels == 1 ||
645         ED_draw_imbuf_method(ibuf) != IMAGE_DRAW_METHOD_GLSL) {
646       image_buffer_rect_update(rj, rr, ibuf, &rj->iuser, renrect, viewname);
647     }
648
649     /* make jobs timer to send notifier */
650     *(rj->do_update) = true;
651   }
652   BKE_image_release_ibuf(ima, ibuf, lock);
653 }
654
655 static void current_scene_update(void *rjv, Scene *scene)
656 {
657   RenderJob *rj = rjv;
658   rj->current_scene = scene;
659   rj->iuser.scene = scene;
660 }
661
662 static void render_startjob(void *rjv, short *stop, short *do_update, float *progress)
663 {
664   RenderJob *rj = rjv;
665
666   rj->stop = stop;
667   rj->do_update = do_update;
668   rj->progress = progress;
669
670   RE_SetReports(rj->re, rj->reports);
671
672   if (rj->anim) {
673     RE_RenderAnim(rj->re,
674                   rj->main,
675                   rj->scene,
676                   rj->single_layer,
677                   rj->camera_override,
678                   rj->scene->r.sfra,
679                   rj->scene->r.efra,
680                   rj->scene->r.frame_step);
681   }
682   else {
683     RE_RenderFrame(rj->re,
684                    rj->main,
685                    rj->scene,
686                    rj->single_layer,
687                    rj->camera_override,
688                    rj->scene->r.cfra,
689                    rj->write_still);
690   }
691
692   RE_SetReports(rj->re, NULL);
693 }
694
695 static void render_image_restore_layer(RenderJob *rj)
696 {
697   wmWindowManager *wm;
698
699   /* image window, compo node users */
700   for (wm = rj->main->wm.first; wm; wm = wm->id.next) { /* only 1 wm */
701     wmWindow *win;
702     for (win = wm->windows.first; win; win = win->next) {
703       const bScreen *screen = WM_window_get_active_screen(win);
704
705       for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
706         if (sa == rj->sa) {
707           if (sa->spacetype == SPACE_IMAGE) {
708             SpaceImage *sima = sa->spacedata.first;
709
710             if (RE_HasSingleLayer(rj->re)) {
711               /* For single layer renders keep the active layer
712                * visible, or show the compositing result. */
713               RenderResult *rr = RE_AcquireResultRead(rj->re);
714               if (RE_HasCombinedLayer(rr)) {
715                 sima->iuser.layer = 0;
716               }
717               RE_ReleaseResult(rj->re);
718             }
719             else {
720               /* For multiple layer render, set back the layer
721                * that was set at the start of rendering. */
722               sima->iuser.layer = rj->orig_layer;
723             }
724           }
725           return;
726         }
727       }
728     }
729   }
730 }
731
732 static void render_endjob(void *rjv)
733 {
734   RenderJob *rj = rjv;
735
736   /* this render may be used again by the sequencer without the active
737    * 'Render' where the callbacks would be re-assigned. assign dummy callbacks
738    * to avoid referencing freed renderjobs bug T24508. */
739   RE_InitRenderCB(rj->re);
740
741   if (rj->main != G_MAIN) {
742     BKE_main_free(rj->main);
743   }
744
745   /* else the frame will not update for the original value */
746   if (rj->anim && !(rj->scene->r.scemode & R_NO_FRAME_UPDATE)) {
747     /* possible this fails of loading new file while rendering */
748     if (G_MAIN->wm.first) {
749       ED_update_for_newframe(G_MAIN, rj->depsgraph);
750     }
751   }
752
753   /* XXX above function sets all tags in nodes */
754   ntreeCompositClearTags(rj->scene->nodetree);
755
756   /* potentially set by caller */
757   rj->scene->r.scemode &= ~R_NO_FRAME_UPDATE;
758
759   if (rj->single_layer) {
760     nodeUpdateID(rj->scene->nodetree, &rj->scene->id);
761     WM_main_add_notifier(NC_NODE | NA_EDITED, rj->scene);
762   }
763
764   if (rj->sa) {
765     render_image_restore_layer(rj);
766   }
767
768   /* XXX render stability hack */
769   G.is_rendering = false;
770   WM_main_add_notifier(NC_SCENE | ND_RENDER_RESULT, NULL);
771
772   /* Partial render result will always update display buffer
773    * for first render layer only. This is nice because you'll
774    * see render progress during rendering, but it ends up in
775    * wrong display buffer shown after rendering.
776    *
777    * The code below will mark display buffer as invalid after
778    * rendering in case multiple layers were rendered, which
779    * ensures display buffer matches render layer after
780    * rendering.
781    *
782    * Perhaps proper way would be to toggle active render
783    * layer in image editor and job, so we always display
784    * layer being currently rendered. But this is not so much
785    * trivial at this moment, especially because of external
786    * engine API, so lets use simple and robust way for now
787    *                                          - sergey -
788    */
789   if (rj->scene->view_layers.first != rj->scene->view_layers.last || rj->image_outdated) {
790     void *lock;
791     Image *ima = rj->image;
792     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);
793
794     if (ibuf) {
795       ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
796     }
797
798     BKE_image_release_ibuf(ima, ibuf, lock);
799   }
800
801   /* Finally unlock the user interface (if it was locked). */
802   if (rj->interface_locked) {
803     /* Interface was locked, so window manager couldn't have been changed
804      * and using one from Global will unlock exactly the same manager as
805      * was locked before running the job.
806      */
807     WM_set_locked_interface(G_MAIN->wm.first, false);
808     DEG_on_visible_update(G_MAIN, false);
809   }
810 }
811
812 /* called by render, check job 'stop' value or the global */
813 static int render_breakjob(void *rjv)
814 {
815   RenderJob *rj = rjv;
816
817   if (G.is_break) {
818     return 1;
819   }
820   if (rj->stop && *(rj->stop)) {
821     return 1;
822   }
823   return 0;
824 }
825
826 /* for exec() when there is no render job
827  * note: this wont check for the escape key being pressed, but doing so isnt threadsafe */
828 static int render_break(void *UNUSED(rjv))
829 {
830   if (G.is_break) {
831     return 1;
832   }
833   return 0;
834 }
835
836 /* runs in thread, no cursor setting here works. careful with notifiers too (malloc conflicts) */
837 /* maybe need a way to get job send notifier? */
838 static void render_drawlock(void *rjv, int lock)
839 {
840   RenderJob *rj = rjv;
841
842   /* If interface is locked, renderer callback shall do nothing. */
843   if (!rj->interface_locked) {
844     BKE_spacedata_draw_locks(lock);
845   }
846 }
847
848 /* catch esc */
849 static int screen_render_modal(bContext *C, wmOperator *op, const wmEvent *event)
850 {
851   Scene *scene = (Scene *)op->customdata;
852
853   /* no running blender, remove handler and pass through */
854   if (0 == WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER)) {
855     return OPERATOR_FINISHED | OPERATOR_PASS_THROUGH;
856   }
857
858   /* running render */
859   switch (event->type) {
860     case ESCKEY:
861       return OPERATOR_RUNNING_MODAL;
862   }
863   return OPERATOR_PASS_THROUGH;
864 }
865
866 static void screen_render_cancel(bContext *C, wmOperator *op)
867 {
868   wmWindowManager *wm = CTX_wm_manager(C);
869   Scene *scene = (Scene *)op->customdata;
870
871   /* kill on cancel, because job is using op->reports */
872   WM_jobs_kill_type(wm, scene, WM_JOB_TYPE_RENDER);
873 }
874
875 static void clean_viewport_memory_base(Base *base)
876 {
877   if ((base->flag & BASE_VISIBLE) == 0) {
878     return;
879   }
880
881   Object *object = base->object;
882
883   if (object->id.tag & LIB_TAG_DOIT) {
884     return;
885   }
886
887   object->id.tag &= ~LIB_TAG_DOIT;
888   if (RE_allow_render_generic_object(object)) {
889     BKE_object_free_derived_caches(object);
890   }
891 }
892
893 static void clean_viewport_memory(Main *bmain, Scene *scene)
894 {
895   Scene *sce_iter;
896   Base *base;
897
898   /* Tag all the available objects. */
899   BKE_main_id_tag_listbase(&bmain->objects, LIB_TAG_DOIT, true);
900
901   /* Go over all the visible objects. */
902   for (wmWindowManager *wm = bmain->wm.first; wm; wm = wm->id.next) {
903     for (wmWindow *win = wm->windows.first; win; win = win->next) {
904       ViewLayer *view_layer = WM_window_get_active_view_layer(win);
905
906       for (base = view_layer->object_bases.first; base; base = base->next) {
907         clean_viewport_memory_base(base);
908       }
909     }
910   }
911
912   for (SETLOOPER_SET_ONLY(scene, sce_iter, base)) {
913     clean_viewport_memory_base(base);
914   }
915 }
916
917 /* using context, starts job */
918 static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
919 {
920   /* new render clears all callbacks */
921   Main *bmain = CTX_data_main(C);
922   Scene *scene = CTX_data_scene(C);
923   ViewLayer *active_layer = CTX_data_view_layer(C);
924   ViewLayer *single_layer = NULL;
925   RenderEngineType *re_type = RE_engines_find(scene->r.engine);
926   Render *re;
927   wmJob *wm_job;
928   RenderJob *rj;
929   Image *ima;
930   int jobflag;
931   const bool is_animation = RNA_boolean_get(op->ptr, "animation");
932   const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
933   const bool use_viewport = RNA_boolean_get(op->ptr, "use_viewport");
934   View3D *v3d = use_viewport ? CTX_wm_view3d(C) : NULL;
935   struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
936   const char *name;
937   ScrArea *sa;
938
939   /* Cannot do render if there is not this function. */
940   if (re_type->render == NULL) {
941     return OPERATOR_CANCELLED;
942   }
943
944   /* custom scene and single layer re-render */
945   screen_render_single_layer_set(op, bmain, active_layer, &scene, &single_layer);
946
947   /* only one render job at a time */
948   if (WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER)) {
949     return OPERATOR_CANCELLED;
950   }
951
952   if (!RE_is_rendering_allowed(scene, single_layer, camera_override, op->reports)) {
953     return OPERATOR_CANCELLED;
954   }
955
956   if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
957     BKE_report(
958         op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
959     return OPERATOR_CANCELLED;
960   }
961
962   /* stop all running jobs, except screen one. currently previews frustrate Render */
963   WM_jobs_kill_all_except(CTX_wm_manager(C), CTX_wm_screen(C));
964
965   /* cancel animation playback */
966   if (ED_screen_animation_playing(CTX_wm_manager(C))) {
967     ED_screen_animation_play(C, 0, 0);
968   }
969
970   /* handle UI stuff */
971   WM_cursor_wait(1);
972
973   /* flush sculpt and editmode changes */
974   ED_editors_flush_edits(bmain, true);
975
976   /* cleanup sequencer caches before starting user triggered render.
977    * otherwise, invalidated cache entries can make their way into
978    * the output rendering. We can't put that into RE_RenderFrame,
979    * since sequence rendering can call that recursively... (peter) */
980   BKE_sequencer_cache_cleanup(scene);
981
982   // store spare
983   // get view3d layer, local layer, make this nice api call to render
984   // store spare
985
986   /* ensure at least 1 area shows result */
987   sa = render_view_open(C, event->x, event->y, op->reports);
988
989   jobflag = WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS;
990
991   if (RNA_struct_property_is_set(op->ptr, "layer")) {
992     jobflag |= WM_JOB_SUSPEND;
993   }
994
995   /* job custom data */
996   rj = MEM_callocN(sizeof(RenderJob), "render job");
997   rj->main = bmain;
998   rj->scene = scene;
999   rj->current_scene = rj->scene;
1000   rj->single_layer = single_layer;
1001   /* TODO(sergey): Render engine should be using own depsgraph. */
1002   rj->depsgraph = CTX_data_depsgraph(C);
1003   rj->camera_override = camera_override;
1004   rj->anim = is_animation;
1005   rj->write_still = is_write_still && !is_animation;
1006   rj->iuser.scene = scene;
1007   rj->iuser.ok = 1;
1008   rj->reports = op->reports;
1009   rj->orig_layer = 0;
1010   rj->last_layer = 0;
1011   rj->sa = sa;
1012   rj->supports_glsl_draw = IMB_colormanagement_support_glsl_draw(&scene->view_settings);
1013
1014   BKE_color_managed_display_settings_copy(&rj->display_settings, &scene->display_settings);
1015   BKE_color_managed_view_settings_copy(&rj->view_settings, &scene->view_settings);
1016
1017   if (sa) {
1018     SpaceImage *sima = sa->spacedata.first;
1019     rj->orig_layer = sima->iuser.layer;
1020   }
1021
1022   if (v3d) {
1023     if (camera_override && camera_override != scene->camera) {
1024       rj->v3d_override = true;
1025     }
1026   }
1027
1028   /* Lock the user interface depending on render settings. */
1029   if (scene->r.use_lock_interface) {
1030     WM_set_locked_interface(CTX_wm_manager(C), true);
1031
1032     /* Set flag interface need to be unlocked.
1033      *
1034      * This is so because we don't have copy of render settings
1035      * accessible from render job and copy is needed in case
1036      * of non-locked rendering, so we wouldn't try to unlock
1037      * anything if option was initially unset but then was
1038      * enabled during rendering.
1039      */
1040     rj->interface_locked = true;
1041
1042     /* Clean memory used by viewport? */
1043     clean_viewport_memory(rj->main, scene);
1044   }
1045
1046   /* setup job */
1047   if (RE_seq_render_active(scene, &scene->r)) {
1048     name = "Sequence Render";
1049   }
1050   else {
1051     name = "Render";
1052   }
1053
1054   wm_job = WM_jobs_get(
1055       CTX_wm_manager(C), CTX_wm_window(C), scene, name, jobflag, WM_JOB_TYPE_RENDER);
1056   WM_jobs_customdata_set(wm_job, rj, render_freejob);
1057   WM_jobs_timer(wm_job, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
1058   WM_jobs_callbacks(wm_job, render_startjob, NULL, NULL, render_endjob);
1059
1060   /* get a render result image, and make sure it is empty */
1061   ima = BKE_image_verify_viewer(bmain, IMA_TYPE_R_RESULT, "Render Result");
1062   BKE_image_signal(rj->main, ima, NULL, IMA_SIGNAL_FREE);
1063   BKE_image_backup_render(rj->scene, ima, true);
1064   rj->image = ima;
1065
1066   /* setup new render */
1067   re = RE_NewSceneRender(scene);
1068   RE_test_break_cb(re, rj, render_breakjob);
1069   RE_draw_lock_cb(re, rj, render_drawlock);
1070   RE_display_update_cb(re, rj, image_rect_update);
1071   RE_current_scene_update_cb(re, rj, current_scene_update);
1072   RE_stats_draw_cb(re, rj, image_renderinfo_cb);
1073   RE_progress_cb(re, rj, render_progress_update);
1074   RE_gl_context_create(re);
1075
1076   rj->re = re;
1077   G.is_break = false;
1078
1079   /* store actual owner of job, so modal operator could check for it,
1080    * the reason of this is that active scene could change when rendering
1081    * several layers from compositor [#31800]
1082    */
1083   op->customdata = scene;
1084
1085   WM_jobs_start(CTX_wm_manager(C), wm_job);
1086
1087   WM_cursor_wait(0);
1088   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
1089
1090   /* we set G.is_rendering here already instead of only in the job, this ensure
1091    * main loop or other scene updates are disabled in time, since they may
1092    * have started before the job thread */
1093   G.is_rendering = true;
1094
1095   /* add modal handler for ESC */
1096   WM_event_add_modal_handler(C, op);
1097
1098   return OPERATOR_RUNNING_MODAL;
1099 }
1100
1101 /* contextual render, using current scene, view3d? */
1102 void RENDER_OT_render(wmOperatorType *ot)
1103 {
1104   PropertyRNA *prop;
1105
1106   /* identifiers */
1107   ot->name = "Render";
1108   ot->description = "Render active scene";
1109   ot->idname = "RENDER_OT_render";
1110
1111   /* api callbacks */
1112   ot->invoke = screen_render_invoke;
1113   ot->modal = screen_render_modal;
1114   ot->cancel = screen_render_cancel;
1115   ot->exec = screen_render_exec;
1116
1117   /* this isn't needed, causes failer in background mode */
1118 #if 0
1119   ot->poll = ED_operator_screenactive;
1120 #endif
1121
1122   prop = RNA_def_boolean(ot->srna,
1123                          "animation",
1124                          0,
1125                          "Animation",
1126                          "Render files from the animation range of this scene");
1127   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1128   RNA_def_boolean(
1129       ot->srna,
1130       "write_still",
1131       0,
1132       "Write Image",
1133       "Save rendered the image to the output path (used only when animation is disabled)");
1134   prop = RNA_def_boolean(ot->srna,
1135                          "use_viewport",
1136                          0,
1137                          "Use 3D Viewport",
1138                          "When inside a 3D viewport, use layers and camera of the viewport");
1139   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1140   prop = RNA_def_string(ot->srna,
1141                         "layer",
1142                         NULL,
1143                         RE_MAXNAME,
1144                         "Render Layer",
1145                         "Single render layer to re-render (used only when animation is disabled)");
1146   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1147   prop = RNA_def_string(ot->srna,
1148                         "scene",
1149                         NULL,
1150                         MAX_ID_NAME - 2,
1151                         "Scene",
1152                         "Scene to render, current scene if not specified");
1153   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1154 }
1155
1156 Scene *ED_render_job_get_scene(const bContext *C)
1157 {
1158   wmWindowManager *wm = CTX_wm_manager(C);
1159   RenderJob *rj = (RenderJob *)WM_jobs_customdata_from_type(wm, WM_JOB_TYPE_RENDER);
1160
1161   if (rj) {
1162     return rj->scene;
1163   }
1164
1165   return NULL;
1166 }
1167
1168 Scene *ED_render_job_get_current_scene(const bContext *C)
1169 {
1170   wmWindowManager *wm = CTX_wm_manager(C);
1171   RenderJob *rj = (RenderJob *)WM_jobs_customdata_from_type(wm, WM_JOB_TYPE_RENDER);
1172   if (rj) {
1173     return rj->current_scene;
1174   }
1175   return NULL;
1176 }
1177
1178 /* Motion blur curve preset */
1179
1180 static int render_shutter_curve_preset_exec(bContext *C, wmOperator *op)
1181 {
1182   Scene *scene = CTX_data_scene(C);
1183   CurveMapping *mblur_shutter_curve = &scene->r.mblur_shutter_curve;
1184   CurveMap *cm = mblur_shutter_curve->cm;
1185   int preset = RNA_enum_get(op->ptr, "shape");
1186
1187   cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
1188   mblur_shutter_curve->preset = preset;
1189   curvemap_reset(
1190       cm, &mblur_shutter_curve->clipr, mblur_shutter_curve->preset, CURVEMAP_SLOPE_POS_NEG);
1191   curvemapping_changed(mblur_shutter_curve, false);
1192
1193   return OPERATOR_FINISHED;
1194 }
1195
1196 void RENDER_OT_shutter_curve_preset(wmOperatorType *ot)
1197 {
1198   PropertyRNA *prop;
1199   static const EnumPropertyItem prop_shape_items[] = {
1200       {CURVE_PRESET_SHARP, "SHARP", 0, "Sharp", ""},
1201       {CURVE_PRESET_SMOOTH, "SMOOTH", 0, "Smooth", ""},
1202       {CURVE_PRESET_MAX, "MAX", 0, "Max", ""},
1203       {CURVE_PRESET_LINE, "LINE", 0, "Line", ""},
1204       {CURVE_PRESET_ROUND, "ROUND", 0, "Round", ""},
1205       {CURVE_PRESET_ROOT, "ROOT", 0, "Root", ""},
1206       {0, NULL, 0, NULL, NULL},
1207   };
1208
1209   ot->name = "Shutter Curve Preset";
1210   ot->description = "Set shutter curve";
1211   ot->idname = "RENDER_OT_shutter_curve_preset";
1212
1213   ot->exec = render_shutter_curve_preset_exec;
1214
1215   prop = RNA_def_enum(ot->srna, "shape", prop_shape_items, CURVE_PRESET_SMOOTH, "Mode", "");
1216   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
1217 }