99cdc47753c6faded152a5972d3204fd994313e8
[blender.git] / source / blender / render / intern / source / pipeline.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) 2006 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup render
22  */
23
24 #include <math.h>
25 #include <limits.h>
26 #include <string.h>
27 #include <stdlib.h>
28 #include <stddef.h>
29 #include <errno.h>
30
31 #include "DNA_anim_types.h"
32 #include "DNA_collection_types.h"
33 #include "DNA_image_types.h"
34 #include "DNA_node_types.h"
35 #include "DNA_object_types.h"
36 #include "DNA_particle_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_sequence_types.h"
39 #include "DNA_userdef_types.h"
40
41 #include "MEM_guardedalloc.h"
42
43 #include "BLI_math.h"
44 #include "BLI_rect.h"
45 #include "BLI_listbase.h"
46 #include "BLI_string.h"
47 #include "BLI_path_util.h"
48 #include "BLI_timecode.h"
49 #include "BLI_fileops.h"
50 #include "BLI_threads.h"
51 #include "BLI_callbacks.h"
52
53 #include "BLT_translation.h"
54
55 #include "BKE_animsys.h" /* <------ should this be here?, needed for sequencer update */
56 #include "BKE_camera.h"
57 #include "BKE_colortools.h"
58 #include "BKE_context.h" /* XXX needed by wm_window.h */
59 #include "BKE_global.h"
60 #include "BKE_image.h"
61 #include "BKE_layer.h"
62 #include "BKE_library.h"
63 #include "BKE_library_remap.h"
64 #include "BKE_mask.h"
65 #include "BKE_modifier.h"
66 #include "BKE_node.h"
67 #include "BKE_object.h"
68 #include "BKE_pointcache.h"
69 #include "BKE_report.h"
70 #include "BKE_scene.h"
71 #include "BKE_sequencer.h"
72 #include "BKE_sound.h"
73 #include "BKE_writeavi.h" /* <------ should be replaced once with generic movie module */
74
75 #include "DEG_depsgraph.h"
76 #include "DEG_depsgraph_build.h"
77 #include "DEG_depsgraph_debug.h"
78 #include "DEG_depsgraph_query.h"
79
80 #include "PIL_time.h"
81 #include "IMB_colormanagement.h"
82 #include "IMB_imbuf.h"
83 #include "IMB_imbuf_types.h"
84 #include "IMB_metadata.h"
85
86 #include "RE_engine.h"
87 #include "RE_pipeline.h"
88 #include "RE_render_ext.h"
89
90 #include "../../../windowmanager/WM_api.h"    /* XXX */
91 #include "../../../windowmanager/wm_window.h" /* XXX */
92 #include "GPU_context.h"
93
94 #ifdef WITH_FREESTYLE
95 #  include "FRS_freestyle.h"
96 #endif
97
98 #include "DEG_depsgraph.h"
99
100 /* internal */
101 #include "initrender.h"
102 #include "renderpipeline.h"
103 #include "render_result.h"
104 #include "render_types.h"
105
106 /* render flow
107  *
108  * 1) Initialize state
109  * - state data, tables
110  * - movie/image file init
111  * - everything that doesn't change during animation
112  *
113  * 2) Initialize data
114  * - camera, world, matrices
115  * - make render verts, faces, halos, strands
116  * - everything can change per frame/field
117  *
118  * 3) Render Processor
119  * - multiple layers
120  * - tiles, rect, baking
121  * - layers/tiles optionally to disk or directly in Render Result
122  *
123  * 4) Composite Render Result
124  * - also read external files etc
125  *
126  * 5) Image Files
127  * - save file or append in movie
128  */
129
130 /* ********* globals ******** */
131
132 /* here we store all renders */
133 static struct {
134   ListBase renderlist;
135 } RenderGlobal = {{NULL, NULL}};
136
137 /* ********* alloc and free ******** */
138
139 static int do_write_image_or_movie(Render *re,
140                                    Main *bmain,
141                                    Scene *scene,
142                                    bMovieHandle *mh,
143                                    const int totvideos,
144                                    const char *name_override);
145
146 /* default callbacks, set in each new render */
147 static void result_nothing(void *UNUSED(arg), RenderResult *UNUSED(rr))
148 {
149 }
150 static void result_rcti_nothing(void *UNUSED(arg),
151                                 RenderResult *UNUSED(rr),
152                                 volatile struct rcti *UNUSED(rect))
153 {
154 }
155 static void current_scene_nothing(void *UNUSED(arg), Scene *UNUSED(scene))
156 {
157 }
158 static void stats_nothing(void *UNUSED(arg), RenderStats *UNUSED(rs))
159 {
160 }
161 static void float_nothing(void *UNUSED(arg), float UNUSED(val))
162 {
163 }
164 static int default_break(void *UNUSED(arg))
165 {
166   return G.is_break == true;
167 }
168
169 static void stats_background(void *UNUSED(arg), RenderStats *rs)
170 {
171   uintptr_t mem_in_use, mmap_in_use, peak_memory;
172   float megs_used_memory, mmap_used_memory, megs_peak_memory;
173   char info_time_str[32];
174
175   mem_in_use = MEM_get_memory_in_use();
176   mmap_in_use = MEM_get_mapped_memory_in_use();
177   peak_memory = MEM_get_peak_memory();
178
179   megs_used_memory = (mem_in_use - mmap_in_use) / (1024.0 * 1024.0);
180   mmap_used_memory = (mmap_in_use) / (1024.0 * 1024.0);
181   megs_peak_memory = (peak_memory) / (1024.0 * 1024.0);
182
183   fprintf(stdout,
184           TIP_("Fra:%d Mem:%.2fM (%.2fM, Peak %.2fM) "),
185           rs->cfra,
186           megs_used_memory,
187           mmap_used_memory,
188           megs_peak_memory);
189
190   if (rs->curfield) {
191     fprintf(stdout, TIP_("Field %d "), rs->curfield);
192   }
193   if (rs->curblur) {
194     fprintf(stdout, TIP_("Blur %d "), rs->curblur);
195   }
196
197   BLI_timecode_string_from_time_simple(
198       info_time_str, sizeof(info_time_str), PIL_check_seconds_timer() - rs->starttime);
199   fprintf(stdout, TIP_("| Time:%s | "), info_time_str);
200
201   if (rs->infostr) {
202     fprintf(stdout, "%s", rs->infostr);
203   }
204   else {
205     if (rs->tothalo) {
206       fprintf(stdout,
207               TIP_("Sce: %s Ve:%d Fa:%d Ha:%d La:%d"),
208               rs->scene_name,
209               rs->totvert,
210               rs->totface,
211               rs->tothalo,
212               rs->totlamp);
213     }
214     else {
215       fprintf(stdout,
216               TIP_("Sce: %s Ve:%d Fa:%d La:%d"),
217               rs->scene_name,
218               rs->totvert,
219               rs->totface,
220               rs->totlamp);
221     }
222   }
223
224   /* Flush stdout to be sure python callbacks are printing stuff after blender. */
225   fflush(stdout);
226
227   /* NOTE: using G_MAIN seems valid here???
228    * Not sure it's actually even used anyway, we could as well pass NULL? */
229   BLI_callback_exec(G_MAIN, NULL, BLI_CB_EVT_RENDER_STATS);
230
231   fputc('\n', stdout);
232   fflush(stdout);
233 }
234
235 static void render_print_save_message(ReportList *reports, const char *name, int ok, int err)
236 {
237   if (ok) {
238     /* no need to report, just some helpful console info */
239     printf("Saved: '%s'\n", name);
240   }
241   else {
242     /* report on error since users will want to know what failed */
243     BKE_reportf(reports, RPT_ERROR, "Render error (%s) cannot save: '%s'", strerror(err), name);
244   }
245 }
246
247 static int render_imbuf_write_stamp_test(ReportList *reports,
248                                          Scene *scene,
249                                          struct RenderResult *rr,
250                                          ImBuf *ibuf,
251                                          const char *name,
252                                          const ImageFormatData *imf,
253                                          bool stamp)
254 {
255   int ok;
256
257   if (stamp) {
258     /* writes the name of the individual cameras */
259     ok = BKE_imbuf_write_stamp(scene, rr, ibuf, name, imf);
260   }
261   else {
262     ok = BKE_imbuf_write(ibuf, name, imf);
263   }
264
265   render_print_save_message(reports, name, ok, errno);
266
267   return ok;
268 }
269
270 void RE_FreeRenderResult(RenderResult *res)
271 {
272   render_result_free(res);
273 }
274
275 float *RE_RenderLayerGetPass(volatile RenderLayer *rl, const char *name, const char *viewname)
276 {
277   RenderPass *rpass = RE_pass_find_by_name(rl, name, viewname);
278   return rpass ? rpass->rect : NULL;
279 }
280
281 RenderLayer *RE_GetRenderLayer(RenderResult *rr, const char *name)
282 {
283   if (rr == NULL) {
284     return NULL;
285   }
286   else {
287     return BLI_findstring(&rr->layers, name, offsetof(RenderLayer, name));
288   }
289 }
290
291 bool RE_HasSingleLayer(Render *re)
292 {
293   return (re->r.scemode & R_SINGLE_LAYER);
294 }
295
296 RenderResult *RE_MultilayerConvert(
297     void *exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
298 {
299   return render_result_new_from_exr(exrhandle, colorspace, predivide, rectx, recty);
300 }
301
302 RenderLayer *render_get_active_layer(Render *re, RenderResult *rr)
303 {
304   ViewLayer *view_layer = BLI_findlink(&re->view_layers, re->active_view_layer);
305
306   if (view_layer) {
307     RenderLayer *rl = BLI_findstring(&rr->layers, view_layer->name, offsetof(RenderLayer, name));
308
309     if (rl) {
310       return rl;
311     }
312   }
313
314   return rr->layers.first;
315 }
316
317 static bool render_scene_has_layers_to_render(Scene *scene, ViewLayer *single_layer)
318 {
319   if (single_layer) {
320     return true;
321   }
322
323   ViewLayer *view_layer;
324   for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
325     if (view_layer->flag & VIEW_LAYER_RENDER) {
326       return true;
327     }
328   }
329   return false;
330 }
331
332 /* *************************************************** */
333
334 Render *RE_GetRender(const char *name)
335 {
336   Render *re;
337
338   /* search for existing renders */
339   for (re = RenderGlobal.renderlist.first; re; re = re->next) {
340     if (STREQLEN(re->name, name, RE_MAXNAME)) {
341       break;
342     }
343   }
344
345   return re;
346 }
347
348 /* if you want to know exactly what has been done */
349 RenderResult *RE_AcquireResultRead(Render *re)
350 {
351   if (re) {
352     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_READ);
353     return re->result;
354   }
355
356   return NULL;
357 }
358
359 RenderResult *RE_AcquireResultWrite(Render *re)
360 {
361   if (re) {
362     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
363     return re->result;
364   }
365
366   return NULL;
367 }
368
369 void RE_ClearResult(Render *re)
370 {
371   if (re) {
372     render_result_free(re->result);
373     re->result = NULL;
374   }
375 }
376
377 void RE_SwapResult(Render *re, RenderResult **rr)
378 {
379   /* for keeping render buffers */
380   if (re) {
381     SWAP(RenderResult *, re->result, *rr);
382   }
383 }
384
385 void RE_ReleaseResult(Render *re)
386 {
387   if (re) {
388     BLI_rw_mutex_unlock(&re->resultmutex);
389   }
390 }
391
392 /* displist.c util.... */
393 Scene *RE_GetScene(Render *re)
394 {
395   if (re) {
396     return re->scene;
397   }
398   return NULL;
399 }
400
401 void RE_SetScene(Render *re, Scene *sce)
402 {
403   if (re) {
404     re->scene = sce;
405   }
406 }
407
408 /**
409  * Same as #RE_AcquireResultImage but creating the necessary views to store the result
410  * fill provided result struct with a copy of thew views of what is done so far the
411  * #RenderResult.views #ListBase needs to be freed after with #RE_ReleaseResultImageViews
412  */
413 void RE_AcquireResultImageViews(Render *re, RenderResult *rr)
414 {
415   memset(rr, 0, sizeof(RenderResult));
416
417   if (re) {
418     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_READ);
419
420     if (re->result) {
421       RenderLayer *rl;
422       RenderView *rv, *rview;
423
424       rr->rectx = re->result->rectx;
425       rr->recty = re->result->recty;
426
427       /* creates a temporary duplication of views */
428       render_result_views_shallowcopy(rr, re->result);
429
430       rv = rr->views.first;
431       rr->have_combined = (rv->rectf != NULL);
432
433       /* active layer */
434       rl = render_get_active_layer(re, re->result);
435
436       if (rl) {
437         if (rv->rectf == NULL) {
438           for (rview = (RenderView *)rr->views.first; rview; rview = rview->next) {
439             rview->rectf = RE_RenderLayerGetPass(rl, RE_PASSNAME_COMBINED, rview->name);
440           }
441         }
442
443         if (rv->rectz == NULL) {
444           for (rview = (RenderView *)rr->views.first; rview; rview = rview->next) {
445             rview->rectz = RE_RenderLayerGetPass(rl, RE_PASSNAME_Z, rview->name);
446           }
447         }
448       }
449
450       rr->layers = re->result->layers;
451       rr->xof = re->disprect.xmin;
452       rr->yof = re->disprect.ymin;
453       rr->stamp_data = re->result->stamp_data;
454     }
455   }
456 }
457
458 /* clear temporary renderresult struct */
459 void RE_ReleaseResultImageViews(Render *re, RenderResult *rr)
460 {
461   if (re) {
462     if (rr) {
463       render_result_views_shallowdelete(rr);
464     }
465     BLI_rw_mutex_unlock(&re->resultmutex);
466   }
467 }
468
469 /* fill provided result struct with what's currently active or done */
470 /* this RenderResult struct is the only exception to the rule of a RenderResult */
471 /* always having at least one RenderView */
472 void RE_AcquireResultImage(Render *re, RenderResult *rr, const int view_id)
473 {
474   memset(rr, 0, sizeof(RenderResult));
475
476   if (re) {
477     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_READ);
478
479     if (re->result) {
480       RenderLayer *rl;
481       RenderView *rv;
482
483       rr->rectx = re->result->rectx;
484       rr->recty = re->result->recty;
485
486       /* actview view */
487       rv = RE_RenderViewGetById(re->result, view_id);
488       rr->have_combined = (rv->rectf != NULL);
489
490       rr->rectf = rv->rectf;
491       rr->rectz = rv->rectz;
492       rr->rect32 = rv->rect32;
493
494       /* active layer */
495       rl = render_get_active_layer(re, re->result);
496
497       if (rl) {
498         if (rv->rectf == NULL) {
499           rr->rectf = RE_RenderLayerGetPass(rl, RE_PASSNAME_COMBINED, rv->name);
500         }
501
502         if (rv->rectz == NULL) {
503           rr->rectz = RE_RenderLayerGetPass(rl, RE_PASSNAME_Z, rv->name);
504         }
505       }
506
507       rr->layers = re->result->layers;
508       rr->views = re->result->views;
509
510       rr->xof = re->disprect.xmin;
511       rr->yof = re->disprect.ymin;
512
513       rr->stamp_data = re->result->stamp_data;
514     }
515   }
516 }
517
518 void RE_ReleaseResultImage(Render *re)
519 {
520   if (re) {
521     BLI_rw_mutex_unlock(&re->resultmutex);
522   }
523 }
524
525 /* caller is responsible for allocating rect in correct size! */
526 void RE_ResultGet32(Render *re, unsigned int *rect)
527 {
528   RenderResult rres;
529   const int view_id = BKE_scene_multiview_view_id_get(&re->r, re->viewname);
530
531   RE_AcquireResultImageViews(re, &rres);
532   render_result_rect_get_pixels(&rres,
533                                 rect,
534                                 re->rectx,
535                                 re->recty,
536                                 &re->scene->view_settings,
537                                 &re->scene->display_settings,
538                                 view_id);
539   RE_ReleaseResultImageViews(re, &rres);
540 }
541
542 /* caller is responsible for allocating rect in correct size! */
543 /* Only for acquired results, for lock */
544 void RE_AcquiredResultGet32(Render *re,
545                             RenderResult *result,
546                             unsigned int *rect,
547                             const int view_id)
548 {
549   render_result_rect_get_pixels(result,
550                                 rect,
551                                 re->rectx,
552                                 re->recty,
553                                 &re->scene->view_settings,
554                                 &re->scene->display_settings,
555                                 view_id);
556 }
557
558 RenderStats *RE_GetStats(Render *re)
559 {
560   return &re->i;
561 }
562
563 Render *RE_NewRender(const char *name)
564 {
565   Render *re;
566
567   /* only one render per name exists */
568   re = RE_GetRender(name);
569   if (re == NULL) {
570
571     /* new render data struct */
572     re = MEM_callocN(sizeof(Render), "new render");
573     BLI_addtail(&RenderGlobal.renderlist, re);
574     BLI_strncpy(re->name, name, RE_MAXNAME);
575     BLI_rw_mutex_init(&re->resultmutex);
576     BLI_rw_mutex_init(&re->partsmutex);
577   }
578
579   RE_InitRenderCB(re);
580
581   return re;
582 }
583
584 /* MAX_ID_NAME + sizeof(Library->name) + space + null-terminator. */
585 #define MAX_SCENE_RENDER_NAME (MAX_ID_NAME + 1024 + 2)
586
587 static void scene_render_name_get(const Scene *scene, const size_t max_size, char *render_name)
588 {
589   if (ID_IS_LINKED(scene)) {
590     BLI_snprintf(render_name, max_size, "%s %s", scene->id.lib->id.name, scene->id.name);
591   }
592   else {
593     BLI_snprintf(render_name, max_size, "%s", scene->id.name);
594   }
595 }
596
597 Render *RE_GetSceneRender(const Scene *scene)
598 {
599   char render_name[MAX_SCENE_RENDER_NAME];
600   scene_render_name_get(scene, sizeof(render_name), render_name);
601   return RE_GetRender(render_name);
602 }
603
604 Render *RE_NewSceneRender(const Scene *scene)
605 {
606   char render_name[MAX_SCENE_RENDER_NAME];
607   scene_render_name_get(scene, sizeof(render_name), render_name);
608   return RE_NewRender(render_name);
609 }
610
611 /* called for new renders and when finishing rendering so
612  * we always have valid callbacks on a render */
613 void RE_InitRenderCB(Render *re)
614 {
615   /* set default empty callbacks */
616   re->display_init = result_nothing;
617   re->display_clear = result_nothing;
618   re->display_update = result_rcti_nothing;
619   re->current_scene_update = current_scene_nothing;
620   re->progress = float_nothing;
621   re->test_break = default_break;
622   if (G.background) {
623     re->stats_draw = stats_background;
624   }
625   else {
626     re->stats_draw = stats_nothing;
627   }
628   /* clear callback handles */
629   re->dih = re->dch = re->duh = re->sdh = re->prh = re->tbh = NULL;
630 }
631
632 /* only call this while you know it will remove the link too */
633 void RE_FreeRender(Render *re)
634 {
635   if (re->engine) {
636     RE_engine_free(re->engine);
637   }
638
639   BLI_rw_mutex_end(&re->resultmutex);
640   BLI_rw_mutex_end(&re->partsmutex);
641
642   BLI_freelistN(&re->view_layers);
643   BLI_freelistN(&re->r.views);
644
645   curvemapping_free_data(&re->r.mblur_shutter_curve);
646
647   /* main dbase can already be invalid now, some database-free code checks it */
648   re->main = NULL;
649   re->scene = NULL;
650
651   render_result_free(re->result);
652   render_result_free(re->pushedresult);
653
654   BLI_remlink(&RenderGlobal.renderlist, re);
655   MEM_freeN(re);
656 }
657
658 /* exit blender */
659 void RE_FreeAllRender(void)
660 {
661   while (RenderGlobal.renderlist.first) {
662     RE_FreeRender(RenderGlobal.renderlist.first);
663   }
664
665 #ifdef WITH_FREESTYLE
666   /* finalize Freestyle */
667   FRS_exit();
668 #endif
669 }
670
671 void RE_FreeAllPersistentData(void)
672 {
673   Render *re;
674   for (re = RenderGlobal.renderlist.first; re != NULL; re = re->next) {
675     if ((re->r.mode & R_PERSISTENT_DATA) != 0 && re->engine != NULL) {
676       RE_engine_free(re->engine);
677       re->engine = NULL;
678     }
679   }
680 }
681
682 /* on file load, free all re */
683 void RE_FreeAllRenderResults(void)
684 {
685   Render *re;
686
687   for (re = RenderGlobal.renderlist.first; re; re = re->next) {
688     render_result_free(re->result);
689     render_result_free(re->pushedresult);
690
691     re->result = NULL;
692     re->pushedresult = NULL;
693   }
694 }
695
696 void RE_FreePersistentData(void)
697 {
698   Render *re;
699
700   /* render engines can be kept around for quick re-render, this clears all */
701   for (re = RenderGlobal.renderlist.first; re; re = re->next) {
702     if (re->engine) {
703       /* if engine is currently rendering, just tag it to be freed when render is finished */
704       if (!(re->engine->flag & RE_ENGINE_RENDERING)) {
705         RE_engine_free(re->engine);
706       }
707
708       re->engine = NULL;
709     }
710   }
711 }
712
713 /* ********* initialize state ******** */
714
715 /* clear full sample and tile flags if needed */
716 static int check_mode_full_sample(RenderData *rd)
717 {
718   int scemode = rd->scemode;
719
720   /* not supported by any current renderer */
721   scemode &= ~R_FULL_SAMPLE;
722
723 #ifdef WITH_OPENEXR
724   if (scemode & R_FULL_SAMPLE) {
725     scemode |= R_EXR_TILE_FILE; /* enable automatic */
726   }
727 #else
728   /* can't do this without openexr support */
729   scemode &= ~(R_EXR_TILE_FILE | R_FULL_SAMPLE);
730 #endif
731
732   return scemode;
733 }
734
735 static void re_init_resolution(Render *re, Render *source, int winx, int winy, rcti *disprect)
736 {
737   re->winx = winx;
738   re->winy = winy;
739   if (source && (source->r.mode & R_BORDER)) {
740     /* eeh, doesn't seem original bordered disprect is storing anywhere
741      * after insertion on black happening in do_render(),
742      * so for now simply re-calculate disprect using border from source
743      * renderer (sergey)
744      */
745
746     re->disprect.xmin = source->r.border.xmin * winx;
747     re->disprect.xmax = source->r.border.xmax * winx;
748
749     re->disprect.ymin = source->r.border.ymin * winy;
750     re->disprect.ymax = source->r.border.ymax * winy;
751
752     re->rectx = BLI_rcti_size_x(&re->disprect);
753     re->recty = BLI_rcti_size_y(&re->disprect);
754
755     /* copy border itself, since it could be used by external engines */
756     re->r.border = source->r.border;
757   }
758   else if (disprect) {
759     re->disprect = *disprect;
760     re->rectx = BLI_rcti_size_x(&re->disprect);
761     re->recty = BLI_rcti_size_y(&re->disprect);
762   }
763   else {
764     re->disprect.xmin = re->disprect.ymin = 0;
765     re->disprect.xmax = winx;
766     re->disprect.ymax = winy;
767     re->rectx = winx;
768     re->recty = winy;
769   }
770 }
771
772 void render_copy_renderdata(RenderData *to, RenderData *from)
773 {
774   BLI_freelistN(&to->views);
775   curvemapping_free_data(&to->mblur_shutter_curve);
776
777   *to = *from;
778
779   BLI_duplicatelist(&to->views, &from->views);
780   curvemapping_copy_data(&to->mblur_shutter_curve, &from->mblur_shutter_curve);
781 }
782
783 /* what doesn't change during entire render sequence */
784 /* disprect is optional, if NULL it assumes full window render */
785 void RE_InitState(Render *re,
786                   Render *source,
787                   RenderData *rd,
788                   ListBase *render_layers,
789                   ViewLayer *single_layer,
790                   int winx,
791                   int winy,
792                   rcti *disprect)
793 {
794   bool had_freestyle = (re->r.mode & R_EDGE_FRS) != 0;
795
796   re->ok = true; /* maybe flag */
797
798   re->i.starttime = PIL_check_seconds_timer();
799
800   /* copy render data and render layers for thread safety */
801   render_copy_renderdata(&re->r, rd);
802   BLI_freelistN(&re->view_layers);
803   BLI_duplicatelist(&re->view_layers, render_layers);
804   re->active_view_layer = 0;
805
806   if (source) {
807     /* reuse border flags from source renderer */
808     re->r.mode &= ~(R_BORDER | R_CROP);
809     re->r.mode |= source->r.mode & (R_BORDER | R_CROP);
810
811     /* dimensions shall be shared between all renderers */
812     re->r.xsch = source->r.xsch;
813     re->r.ysch = source->r.ysch;
814     re->r.size = source->r.size;
815   }
816
817   re_init_resolution(re, source, winx, winy, disprect);
818
819   /* disable border if it's a full render anyway */
820   if (re->r.border.xmin == 0.0f && re->r.border.xmax == 1.0f && re->r.border.ymin == 0.0f &&
821       re->r.border.ymax == 1.0f) {
822     re->r.mode &= ~R_BORDER;
823   }
824
825   if (re->rectx < 1 || re->recty < 1 ||
826       (BKE_imtype_is_movie(rd->im_format.imtype) && (re->rectx < 16 || re->recty < 16))) {
827     BKE_report(re->reports, RPT_ERROR, "Image too small");
828     re->ok = 0;
829     return;
830   }
831
832   re->r.scemode = check_mode_full_sample(&re->r);
833
834   if (single_layer) {
835     int index = BLI_findindex(render_layers, single_layer);
836     if (index != -1) {
837       re->active_view_layer = index;
838       re->r.scemode |= R_SINGLE_LAYER;
839     }
840   }
841
842   /* if preview render, we try to keep old result */
843   BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
844
845   if (re->r.scemode & R_BUTS_PREVIEW) {
846     if (had_freestyle || (re->r.mode & R_EDGE_FRS)) {
847       /* freestyle manipulates render layers so always have to free */
848       render_result_free(re->result);
849       re->result = NULL;
850     }
851     else if (re->result) {
852       ViewLayer *active_render_layer = BLI_findlink(&re->view_layers, re->active_view_layer);
853       RenderLayer *rl;
854       bool have_layer = false;
855
856       for (rl = re->result->layers.first; rl; rl = rl->next) {
857         if (STREQ(rl->name, active_render_layer->name)) {
858           have_layer = true;
859         }
860       }
861
862       if (re->result->rectx == re->rectx && re->result->recty == re->recty && have_layer) {
863         /* keep render result, this avoids flickering black tiles
864          * when the preview changes */
865       }
866       else {
867         /* free because resolution changed */
868         render_result_free(re->result);
869         re->result = NULL;
870       }
871     }
872   }
873   else {
874
875     /* make empty render result, so display callbacks can initialize */
876     render_result_free(re->result);
877     re->result = MEM_callocN(sizeof(RenderResult), "new render result");
878     re->result->rectx = re->rectx;
879     re->result->recty = re->recty;
880     render_result_view_new(re->result, "");
881   }
882
883   /* ensure renderdatabase can use part settings correct */
884   RE_parts_clamp(re);
885
886   BLI_rw_mutex_unlock(&re->resultmutex);
887
888   RE_init_threadcount(re);
889
890   RE_point_density_fix_linking();
891 }
892
893 /* This function is only called by view3d rendering, which doesn't support
894  * multiview at the moment. so handle only one view here */
895 static void render_result_rescale(Render *re)
896 {
897   RenderResult *result = re->result;
898   RenderView *rv;
899   int x, y;
900   float scale_x, scale_y;
901   float *src_rectf;
902
903   rv = RE_RenderViewGetById(result, 0);
904   src_rectf = rv->rectf;
905
906   if (src_rectf == NULL) {
907     RenderLayer *rl = render_get_active_layer(re, re->result);
908     if (rl != NULL) {
909       src_rectf = RE_RenderLayerGetPass(rl, RE_PASSNAME_COMBINED, NULL);
910     }
911   }
912
913   if (src_rectf != NULL) {
914     float *dst_rectf = NULL;
915     re->result = render_result_new(re, &re->disprect, 0, RR_USE_MEM, RR_ALL_LAYERS, "");
916
917     if (re->result != NULL) {
918       dst_rectf = RE_RenderViewGetById(re->result, 0)->rectf;
919       if (dst_rectf == NULL) {
920         RenderLayer *rl;
921         rl = render_get_active_layer(re, re->result);
922         if (rl != NULL) {
923           dst_rectf = RE_RenderLayerGetPass(rl, RE_PASSNAME_COMBINED, NULL);
924         }
925       }
926
927       scale_x = (float)result->rectx / re->result->rectx;
928       scale_y = (float)result->recty / re->result->recty;
929       for (x = 0; x < re->result->rectx; ++x) {
930         for (y = 0; y < re->result->recty; ++y) {
931           int src_x = x * scale_x;
932           int src_y = y * scale_y;
933           int dst_index = y * re->result->rectx + x;
934           int src_index = src_y * result->rectx + src_x;
935           copy_v4_v4(dst_rectf + dst_index * 4, src_rectf + src_index * 4);
936         }
937       }
938     }
939     render_result_free(result);
940   }
941 }
942
943 void RE_ChangeResolution(Render *re, int winx, int winy, rcti *disprect)
944 {
945   re_init_resolution(re, NULL, winx, winy, disprect);
946   RE_parts_clamp(re);
947
948   if (re->result) {
949     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
950     render_result_rescale(re);
951     BLI_rw_mutex_unlock(&re->resultmutex);
952   }
953 }
954
955 /* TODO(sergey): This is a bit hackish, used to temporary disable freestyle when
956  * doing viewport render. Needs some better integration of BI viewport rendering
957  * into the pipeline.
958  */
959 void RE_ChangeModeFlag(Render *re, int flag, bool clear)
960 {
961   if (clear) {
962     re->r.mode &= ~flag;
963   }
964   else {
965     re->r.mode |= flag;
966   }
967 }
968
969 /* update some variables that can be animated, and otherwise wouldn't be due to
970  * RenderData getting copied once at the start of animation render */
971 void render_update_anim_renderdata(Render *re, RenderData *rd, ListBase *render_layers)
972 {
973   /* filter */
974   re->r.gauss = rd->gauss;
975
976   /* motion blur */
977   re->r.blurfac = rd->blurfac;
978
979   /* freestyle */
980   re->r.line_thickness_mode = rd->line_thickness_mode;
981   re->r.unit_line_thickness = rd->unit_line_thickness;
982
983   /* render layers */
984   BLI_freelistN(&re->view_layers);
985   BLI_duplicatelist(&re->view_layers, render_layers);
986
987   /* render views */
988   BLI_freelistN(&re->r.views);
989   BLI_duplicatelist(&re->r.views, &rd->views);
990 }
991
992 void RE_SetWindow(Render *re, const rctf *viewplane, float clip_start, float clip_end)
993 {
994   /* re->ok flag? */
995
996   re->viewplane = *viewplane;
997   re->clip_start = clip_start;
998   re->clip_end = clip_end;
999
1000   perspective_m4(re->winmat,
1001                  re->viewplane.xmin,
1002                  re->viewplane.xmax,
1003                  re->viewplane.ymin,
1004                  re->viewplane.ymax,
1005                  re->clip_start,
1006                  re->clip_end);
1007 }
1008
1009 void RE_SetOrtho(Render *re, const rctf *viewplane, float clip_start, float clip_end)
1010 {
1011   /* re->ok flag? */
1012
1013   re->viewplane = *viewplane;
1014   re->clip_start = clip_start;
1015   re->clip_end = clip_end;
1016
1017   orthographic_m4(re->winmat,
1018                   re->viewplane.xmin,
1019                   re->viewplane.xmax,
1020                   re->viewplane.ymin,
1021                   re->viewplane.ymax,
1022                   re->clip_start,
1023                   re->clip_end);
1024 }
1025
1026 void RE_GetViewPlane(Render *re, rctf *r_viewplane, rcti *r_disprect)
1027 {
1028   *r_viewplane = re->viewplane;
1029
1030   /* make disprect zero when no border render, is needed to detect changes in 3d view render */
1031   if (re->r.mode & R_BORDER) {
1032     *r_disprect = re->disprect;
1033   }
1034   else {
1035     BLI_rcti_init(r_disprect, 0, 0, 0, 0);
1036   }
1037 }
1038
1039 /* image and movie output has to move to either imbuf or kernel */
1040 void RE_display_init_cb(Render *re, void *handle, void (*f)(void *handle, RenderResult *rr))
1041 {
1042   re->display_init = f;
1043   re->dih = handle;
1044 }
1045 void RE_display_clear_cb(Render *re, void *handle, void (*f)(void *handle, RenderResult *rr))
1046 {
1047   re->display_clear = f;
1048   re->dch = handle;
1049 }
1050 void RE_display_update_cb(Render *re,
1051                           void *handle,
1052                           void (*f)(void *handle, RenderResult *rr, volatile rcti *rect))
1053 {
1054   re->display_update = f;
1055   re->duh = handle;
1056 }
1057 void RE_current_scene_update_cb(Render *re, void *handle, void (*f)(void *handle, Scene *scene))
1058 {
1059   re->current_scene_update = f;
1060   re->suh = handle;
1061 }
1062 void RE_stats_draw_cb(Render *re, void *handle, void (*f)(void *handle, RenderStats *rs))
1063 {
1064   re->stats_draw = f;
1065   re->sdh = handle;
1066 }
1067 void RE_progress_cb(Render *re, void *handle, void (*f)(void *handle, float))
1068 {
1069   re->progress = f;
1070   re->prh = handle;
1071 }
1072
1073 void RE_draw_lock_cb(Render *re, void *handle, void (*f)(void *handle, int i))
1074 {
1075   re->draw_lock = f;
1076   re->dlh = handle;
1077 }
1078
1079 void RE_test_break_cb(Render *re, void *handle, int (*f)(void *handle))
1080 {
1081   re->test_break = f;
1082   re->tbh = handle;
1083 }
1084
1085 /* ********* GL Context ******** */
1086
1087 void RE_gl_context_create(Render *re)
1088 {
1089   /* Needs to be created in the main ogl thread. */
1090   re->gl_context = WM_opengl_context_create();
1091   /* So we activate the window's one afterwards. */
1092   wm_window_reset_drawable();
1093 }
1094
1095 void RE_gl_context_destroy(Render *re)
1096 {
1097   /* Needs to be called from the thread which used the ogl context for rendering. */
1098   if (re->gl_context) {
1099     if (re->gpu_context) {
1100       WM_opengl_context_activate(re->gl_context);
1101       GPU_context_active_set(re->gpu_context);
1102       GPU_context_discard(re->gpu_context);
1103       re->gpu_context = NULL;
1104     }
1105
1106     WM_opengl_context_dispose(re->gl_context);
1107     re->gl_context = NULL;
1108   }
1109 }
1110
1111 void *RE_gl_context_get(Render *re)
1112 {
1113   return re->gl_context;
1114 }
1115
1116 void *RE_gpu_context_get(Render *re)
1117 {
1118   if (re->gpu_context == NULL) {
1119     re->gpu_context = GPU_context_create(0);
1120   }
1121   return re->gpu_context;
1122 }
1123
1124 /* ********* add object data (later) ******** */
1125
1126 /* object is considered fully prepared on correct time etc */
1127 /* includes lights */
1128 #if 0
1129 void RE_AddObject(Render *UNUSED(re), Object *UNUSED(ob))
1130 {
1131 }
1132 #endif
1133
1134 /* *************************************** */
1135
1136 #ifdef WITH_FREESTYLE
1137 static void init_freestyle(Render *re);
1138 static void add_freestyle(Render *re, int render);
1139 static void free_all_freestyle_renders(void);
1140 #endif
1141
1142 /* ************  This part uses API, for rendering Blender scenes ********** */
1143
1144 static void do_render_3d(Render *re)
1145 {
1146   re->current_scene_update(re->suh, re->scene);
1147   RE_engine_render(re, 0);
1148 }
1149
1150 /* make sure disprect is not affected by the render border */
1151 static void render_result_disprect_to_full_resolution(Render *re)
1152 {
1153   re->disprect.xmin = re->disprect.ymin = 0;
1154   re->disprect.xmax = re->winx;
1155   re->disprect.ymax = re->winy;
1156   re->rectx = re->winx;
1157   re->recty = re->winy;
1158 }
1159
1160 static void render_result_uncrop(Render *re)
1161 {
1162   /* when using border render with crop disabled, insert render result into
1163    * full size with black pixels outside */
1164   if (re->result && (re->r.mode & R_BORDER)) {
1165     if ((re->r.mode & R_CROP) == 0) {
1166       RenderResult *rres;
1167
1168       /* backup */
1169       const rcti orig_disprect = re->disprect;
1170       const int orig_rectx = re->rectx, orig_recty = re->recty;
1171
1172       BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
1173
1174       /* sub-rect for merge call later on */
1175       re->result->tilerect = re->disprect;
1176
1177       /* weak is: it chances disprect from border */
1178       render_result_disprect_to_full_resolution(re);
1179
1180       rres = render_result_new(re, &re->disprect, 0, RR_USE_MEM, RR_ALL_LAYERS, RR_ALL_VIEWS);
1181       rres->stamp_data = BKE_stamp_data_copy(re->result->stamp_data);
1182
1183       render_result_clone_passes(re, rres, NULL);
1184
1185       render_result_merge(rres, re->result);
1186       render_result_free(re->result);
1187       re->result = rres;
1188
1189       /* weak... the display callback wants an active renderlayer pointer... */
1190       re->result->renlay = render_get_active_layer(re, re->result);
1191
1192       BLI_rw_mutex_unlock(&re->resultmutex);
1193
1194       re->display_init(re->dih, re->result);
1195       re->display_update(re->duh, re->result, NULL);
1196
1197       /* restore the disprect from border */
1198       re->disprect = orig_disprect;
1199       re->rectx = orig_rectx;
1200       re->recty = orig_recty;
1201     }
1202     else {
1203       /* set offset (again) for use in compositor, disprect was manipulated. */
1204       re->result->xof = 0;
1205       re->result->yof = 0;
1206     }
1207   }
1208 }
1209
1210 /* main render routine, no compositing */
1211 static void do_render(Render *re)
1212 {
1213   Object *camera = RE_GetCamera(re);
1214   /* also check for camera here */
1215   if (camera == NULL) {
1216     BKE_report(re->reports, RPT_ERROR, "Cannot render, no camera");
1217     G.is_break = true;
1218     return;
1219   }
1220
1221   /* now use renderdata and camera to set viewplane */
1222   RE_SetCamera(re, camera);
1223
1224   do_render_3d(re);
1225
1226   /* when border render, check if we have to insert it in black */
1227   render_result_uncrop(re);
1228 }
1229
1230 /* within context of current Render *re, render another scene.
1231  * it uses current render image size and disprect, but doesn't execute composite
1232  */
1233 static void render_scene(Render *re, Scene *sce, int cfra)
1234 {
1235   Render *resc = RE_NewSceneRender(sce);
1236   int winx = re->winx, winy = re->winy;
1237
1238   sce->r.cfra = cfra;
1239
1240   BKE_scene_camera_switch_update(sce);
1241
1242   /* exception: scene uses own size (unfinished code) */
1243   if (0) {
1244     winx = (sce->r.size * sce->r.xsch) / 100;
1245     winy = (sce->r.size * sce->r.ysch) / 100;
1246   }
1247
1248   /* initial setup */
1249   RE_InitState(resc, re, &sce->r, &sce->view_layers, NULL, winx, winy, &re->disprect);
1250
1251   /* We still want to use 'rendercache' setting from org (main) scene... */
1252   resc->r.scemode = (resc->r.scemode & ~R_EXR_CACHE_FILE) | (re->r.scemode & R_EXR_CACHE_FILE);
1253
1254   /* still unsure entity this... */
1255   resc->main = re->main;
1256   resc->scene = sce;
1257
1258   /* copy callbacks */
1259   resc->display_update = re->display_update;
1260   resc->duh = re->duh;
1261   resc->test_break = re->test_break;
1262   resc->tbh = re->tbh;
1263   resc->stats_draw = re->stats_draw;
1264   resc->sdh = re->sdh;
1265   resc->current_scene_update = re->current_scene_update;
1266   resc->suh = re->suh;
1267
1268   do_render(resc);
1269 }
1270
1271 /* helper call to detect if this scene needs a render,
1272  * or if there's a any render layer to render. */
1273 static int composite_needs_render(Scene *sce, int this_scene)
1274 {
1275   bNodeTree *ntree = sce->nodetree;
1276   bNode *node;
1277
1278   if (ntree == NULL) {
1279     return 1;
1280   }
1281   if (sce->use_nodes == false) {
1282     return 1;
1283   }
1284   if ((sce->r.scemode & R_DOCOMP) == 0) {
1285     return 1;
1286   }
1287
1288   for (node = ntree->nodes.first; node; node = node->next) {
1289     if (node->type == CMP_NODE_R_LAYERS && (node->flag & NODE_MUTED) == 0) {
1290       if (this_scene == 0 || node->id == NULL || node->id == &sce->id) {
1291         return 1;
1292       }
1293     }
1294   }
1295   return 0;
1296 }
1297
1298 bool RE_allow_render_generic_object(Object *ob)
1299 {
1300   /* override not showing object when duplis are used with particles */
1301   if (ob->transflag & OB_DUPLIPARTS) {
1302     /* pass */ /* let particle system(s) handle showing vs. not showing */
1303   }
1304   else if (ob->transflag & OB_DUPLI) {
1305     return false;
1306   }
1307   return true;
1308 }
1309
1310 static void ntree_render_scenes(Render *re)
1311 {
1312   bNode *node;
1313   int cfra = re->scene->r.cfra;
1314   Scene *restore_scene = re->scene;
1315
1316   if (re->scene->nodetree == NULL) {
1317     return;
1318   }
1319
1320   /* now foreach render-result node we do a full render */
1321   /* results are stored in a way compositor will find it */
1322   GSet *scenes_rendered = BLI_gset_ptr_new(__func__);
1323   for (node = re->scene->nodetree->nodes.first; node; node = node->next) {
1324     if (node->type == CMP_NODE_R_LAYERS && (node->flag & NODE_MUTED) == 0) {
1325       if (node->id && node->id != (ID *)re->scene) {
1326         Scene *scene = (Scene *)node->id;
1327         if (!BLI_gset_haskey(scenes_rendered, scene) &&
1328             render_scene_has_layers_to_render(scene, false)) {
1329           render_scene(re, scene, cfra);
1330           BLI_gset_add(scenes_rendered, scene);
1331           nodeUpdate(restore_scene->nodetree, node);
1332         }
1333       }
1334     }
1335   }
1336   BLI_gset_free(scenes_rendered, NULL);
1337 }
1338
1339 /* bad call... need to think over proper method still */
1340 static void render_composit_stats(void *arg, const char *str)
1341 {
1342   Render *re = (Render *)arg;
1343
1344   RenderStats i;
1345   memcpy(&i, &re->i, sizeof(i));
1346   i.infostr = str;
1347   re->stats_draw(re->sdh, &i);
1348 }
1349
1350 #ifdef WITH_FREESTYLE
1351 /* init Freestyle renderer */
1352 static void init_freestyle(Render *re)
1353 {
1354   re->freestyle_bmain = BKE_main_new();
1355
1356   /* We use the same window manager for freestyle bmain as
1357    * real bmain uses. This is needed because freestyle's
1358    * bmain could be used to tag scenes for update, which
1359    * implies call of ED_render_scene_update in some cases
1360    * and that function requires proper window manager
1361    * to present (sergey)
1362    */
1363   re->freestyle_bmain->wm = re->main->wm;
1364
1365   FRS_init_stroke_renderer(re);
1366 }
1367
1368 /* invokes Freestyle stroke rendering */
1369 static void add_freestyle(Render *re, int render)
1370 {
1371   ViewLayer *view_layer, *active_view_layer;
1372   LinkData *link;
1373   Render *r;
1374
1375   active_view_layer = BLI_findlink(&re->view_layers, re->active_view_layer);
1376
1377   FRS_begin_stroke_rendering(re);
1378
1379   for (view_layer = (ViewLayer *)re->view_layers.first; view_layer;
1380        view_layer = view_layer->next) {
1381     link = (LinkData *)MEM_callocN(sizeof(LinkData), "LinkData to Freestyle render");
1382     BLI_addtail(&re->freestyle_renders, link);
1383
1384     if ((re->r.scemode & R_SINGLE_LAYER) && view_layer != active_view_layer) {
1385       continue;
1386     }
1387     if (FRS_is_freestyle_enabled(view_layer)) {
1388       r = FRS_do_stroke_rendering(re, view_layer, render);
1389       link->data = (void *)r;
1390     }
1391   }
1392
1393   FRS_end_stroke_rendering(re);
1394 }
1395
1396 /* releases temporary scenes and renders for Freestyle stroke rendering */
1397 static void free_all_freestyle_renders(void)
1398 {
1399   Render *re1;
1400   LinkData *link;
1401
1402   for (re1 = RenderGlobal.renderlist.first; re1; re1 = re1->next) {
1403     for (link = (LinkData *)re1->freestyle_renders.first; link; link = link->next) {
1404       Render *freestyle_render = (Render *)link->data;
1405
1406       if (freestyle_render) {
1407         Scene *freestyle_scene = freestyle_render->scene;
1408         RE_FreeRender(freestyle_render);
1409
1410         if (freestyle_scene) {
1411           BKE_libblock_unlink(re1->freestyle_bmain, freestyle_scene, false, false);
1412           BKE_id_free(re1->freestyle_bmain, freestyle_scene);
1413         }
1414       }
1415     }
1416     BLI_freelistN(&re1->freestyle_renders);
1417
1418     if (re1->freestyle_bmain) {
1419       /* detach the window manager from freestyle bmain (see comments
1420        * in add_freestyle() for more detail)
1421        */
1422       BLI_listbase_clear(&re1->freestyle_bmain->wm);
1423
1424       BKE_main_free(re1->freestyle_bmain);
1425       re1->freestyle_bmain = NULL;
1426     }
1427   }
1428 }
1429 #endif
1430
1431 /* returns fully composited render-result on given time step (in RenderData) */
1432 static void do_render_composite(Render *re)
1433 {
1434   bNodeTree *ntree = re->pipeline_scene_eval->nodetree;
1435   int update_newframe = 0;
1436
1437   if (composite_needs_render(re->pipeline_scene_eval, 1)) {
1438     /* save memory... free all cached images */
1439     ntreeFreeCache(ntree);
1440
1441     /* render the frames
1442      * it could be optimized to render only the needed view
1443      * but what if a scene has a different number of views
1444      * than the main scene? */
1445     do_render(re);
1446   }
1447   else {
1448     re->i.cfra = re->r.cfra;
1449
1450     /* ensure new result gets added, like for regular renders */
1451     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
1452
1453     render_result_free(re->result);
1454     if ((re->r.mode & R_CROP) == 0) {
1455       render_result_disprect_to_full_resolution(re);
1456     }
1457     re->result = render_result_new(re, &re->disprect, 0, RR_USE_MEM, RR_ALL_LAYERS, RR_ALL_VIEWS);
1458
1459     BLI_rw_mutex_unlock(&re->resultmutex);
1460
1461     /* scene render process already updates animsys */
1462     update_newframe = 1;
1463   }
1464
1465   /* swap render result */
1466   if (re->r.scemode & R_SINGLE_LAYER) {
1467     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
1468     render_result_single_layer_end(re);
1469     BLI_rw_mutex_unlock(&re->resultmutex);
1470   }
1471
1472   if (!re->test_break(re->tbh)) {
1473
1474     if (ntree) {
1475       ntreeCompositTagRender(re->pipeline_scene_eval);
1476     }
1477
1478     if (ntree && re->scene->use_nodes && re->r.scemode & R_DOCOMP) {
1479       /* checks if there are render-result nodes that need scene */
1480       if ((re->r.scemode & R_SINGLE_LAYER) == 0) {
1481         ntree_render_scenes(re);
1482       }
1483
1484       if (!re->test_break(re->tbh)) {
1485         ntree->stats_draw = render_composit_stats;
1486         ntree->test_break = re->test_break;
1487         ntree->progress = re->progress;
1488         ntree->sdh = re;
1489         ntree->tbh = re->tbh;
1490         ntree->prh = re->prh;
1491
1492         if (update_newframe) {
1493           /* If we have consistent depsgraph now would be a time to update them. */
1494         }
1495
1496         RenderView *rv;
1497         for (rv = re->result->views.first; rv; rv = rv->next) {
1498           ntreeCompositExecTree(re->pipeline_scene_eval,
1499                                 ntree,
1500                                 &re->r,
1501                                 true,
1502                                 G.background == 0,
1503                                 &re->scene->view_settings,
1504                                 &re->scene->display_settings,
1505                                 rv->name);
1506         }
1507
1508         ntree->stats_draw = NULL;
1509         ntree->test_break = NULL;
1510         ntree->progress = NULL;
1511         ntree->tbh = ntree->sdh = ntree->prh = NULL;
1512       }
1513     }
1514   }
1515
1516 #ifdef WITH_FREESTYLE
1517   free_all_freestyle_renders();
1518 #endif
1519
1520   /* weak... the display callback wants an active renderlayer pointer... */
1521   if (re->result != NULL) {
1522     re->result->renlay = render_get_active_layer(re, re->result);
1523     re->display_update(re->duh, re->result, NULL);
1524   }
1525 }
1526
1527 static void renderresult_stampinfo(Render *re)
1528 {
1529   RenderResult rres;
1530   RenderView *rv;
1531   int nr;
1532
1533   /* this is the basic trick to get the displayed float or char rect from render result */
1534   nr = 0;
1535   for (rv = re->result->views.first; rv; rv = rv->next, nr++) {
1536     RE_SetActiveRenderView(re, rv->name);
1537     RE_AcquireResultImage(re, &rres, nr);
1538     BKE_image_stamp_buf(re->scene,
1539                         RE_GetCamera(re),
1540                         (re->r.stamp & R_STAMP_STRIPMETA) ? rres.stamp_data : NULL,
1541                         (unsigned char *)rres.rect32,
1542                         rres.rectf,
1543                         rres.rectx,
1544                         rres.recty,
1545                         4);
1546     RE_ReleaseResultImage(re);
1547   }
1548 }
1549
1550 int RE_seq_render_active(Scene *scene, RenderData *rd)
1551 {
1552   Editing *ed;
1553   Sequence *seq;
1554
1555   ed = scene->ed;
1556
1557   if (!(rd->scemode & R_DOSEQ) || !ed || !ed->seqbase.first) {
1558     return 0;
1559   }
1560
1561   for (seq = ed->seqbase.first; seq; seq = seq->next) {
1562     if (seq->type != SEQ_TYPE_SOUND_RAM) {
1563       return 1;
1564     }
1565   }
1566
1567   return 0;
1568 }
1569
1570 static void do_render_seq(Render *re)
1571 {
1572   static int recurs_depth = 0;
1573   struct ImBuf *out;
1574   RenderResult *rr; /* don't assign re->result here as it might change during give_ibuf_seq */
1575   int cfra = re->r.cfra;
1576   SeqRenderData context;
1577   int view_id, tot_views;
1578   struct ImBuf **ibuf_arr;
1579   int re_x, re_y;
1580
1581   re->i.cfra = cfra;
1582
1583   recurs_depth++;
1584
1585   if ((re->r.mode & R_BORDER) && (re->r.mode & R_CROP) == 0) {
1586     /* if border rendering is used and cropping is disabled, final buffer should
1587      * be as large as the whole frame */
1588     re_x = re->winx;
1589     re_y = re->winy;
1590   }
1591   else {
1592     re_x = re->result->rectx;
1593     re_y = re->result->recty;
1594   }
1595
1596   tot_views = BKE_scene_multiview_num_views_get(&re->r);
1597   ibuf_arr = MEM_mallocN(sizeof(ImBuf *) * tot_views, "Sequencer Views ImBufs");
1598
1599   BKE_sequencer_new_render_data(
1600       re->main, re->pipeline_depsgraph, re->scene, re_x, re_y, 100, true, &context);
1601
1602   /* the renderresult gets destroyed during the rendering, so we first collect all ibufs
1603    * and then we populate the final renderesult */
1604
1605   for (view_id = 0; view_id < tot_views; view_id++) {
1606     context.view_id = view_id;
1607     out = BKE_sequencer_give_ibuf(&context, cfra, 0);
1608
1609     if (out) {
1610       ibuf_arr[view_id] = IMB_dupImBuf(out);
1611       IMB_metadata_copy(ibuf_arr[view_id], out);
1612       IMB_freeImBuf(out);
1613       BKE_sequencer_imbuf_from_sequencer_space(re->pipeline_scene_eval, ibuf_arr[view_id]);
1614     }
1615     else {
1616       ibuf_arr[view_id] = NULL;
1617     }
1618   }
1619
1620   rr = re->result;
1621
1622   BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
1623   render_result_views_new(rr, &re->r);
1624   BLI_rw_mutex_unlock(&re->resultmutex);
1625
1626   for (view_id = 0; view_id < tot_views; view_id++) {
1627     RenderView *rv = RE_RenderViewGetById(rr, view_id);
1628     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
1629
1630     if (ibuf_arr[view_id]) {
1631       /* copy ibuf into combined pixel rect */
1632       RE_render_result_rect_from_ibuf(rr, &re->r, ibuf_arr[view_id], view_id);
1633
1634       if (ibuf_arr[view_id]->metadata && (re->r.stamp & R_STAMP_STRIPMETA)) {
1635         /* ensure render stamp info first */
1636         BKE_render_result_stamp_info(NULL, NULL, rr, true);
1637         BKE_stamp_info_from_imbuf(rr, ibuf_arr[view_id]);
1638       }
1639
1640       if (recurs_depth == 0) { /* with nested scenes, only free on toplevel... */
1641         Editing *ed = re->pipeline_scene_eval->ed;
1642         if (ed) {
1643           BKE_sequencer_free_imbuf(re->pipeline_scene_eval, &ed->seqbase, true);
1644         }
1645       }
1646       IMB_freeImBuf(ibuf_arr[view_id]);
1647     }
1648     else {
1649       /* render result is delivered empty in most cases, nevertheless we handle all cases */
1650       render_result_rect_fill_zero(rr, view_id);
1651     }
1652
1653     BLI_rw_mutex_unlock(&re->resultmutex);
1654
1655     /* would mark display buffers as invalid */
1656     RE_SetActiveRenderView(re, rv->name);
1657     re->display_update(re->duh, re->result, NULL);
1658   }
1659
1660   MEM_freeN(ibuf_arr);
1661
1662   recurs_depth--;
1663
1664   /* just in case this flag went missing at some point */
1665   re->r.scemode |= R_DOSEQ;
1666
1667   /* set overall progress of sequence rendering */
1668   if (re->r.efra != re->r.sfra) {
1669     re->progress(re->prh, (float)(cfra - re->r.sfra) / (re->r.efra - re->r.sfra));
1670   }
1671   else {
1672     re->progress(re->prh, 1.0f);
1673   }
1674 }
1675
1676 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
1677
1678 /* main loop: doing sequence + 3d render + compositing */
1679 static void do_render_all_options(Render *re)
1680 {
1681   Object *camera;
1682   bool render_seq = false;
1683   int cfra = re->r.cfra;
1684
1685   re->current_scene_update(re->suh, re->scene);
1686
1687   BKE_scene_camera_switch_update(re->scene);
1688
1689   re->i.starttime = PIL_check_seconds_timer();
1690
1691   /* ensure no images are in memory from previous animated sequences */
1692   BKE_image_all_free_anim_ibufs(re->main, re->r.cfra);
1693   BKE_sequencer_all_free_anim_ibufs(re->scene, re->r.cfra);
1694
1695   /* Update for sequencer and compositing animation.
1696    * TODO: ideally we would create a depsgraph with a copy of the scene
1697    * like the render engine, but sequencer and compositing do not (yet?)
1698    * work with copy-on-write. */
1699   BKE_animsys_evaluate_all_animation(re->main, NULL, re->scene, (float)cfra);
1700
1701   /* Update for masks
1702    * (these do not use animsys but own lighter weight structure to define animation). */
1703   BKE_mask_evaluate_all_masks(re->main, (float)cfra, true);
1704
1705   if (RE_engine_render(re, 1)) {
1706     /* in this case external render overrides all */
1707   }
1708   else if (RE_seq_render_active(re->scene, &re->r)) {
1709     /* note: do_render_seq() frees rect32 when sequencer returns float images */
1710     if (!re->test_break(re->tbh)) {
1711       do_render_seq(re);
1712       render_seq = true;
1713     }
1714
1715     re->stats_draw(re->sdh, &re->i);
1716     re->display_update(re->duh, re->result, NULL);
1717   }
1718   else {
1719     do_render_composite(re);
1720   }
1721
1722   re->i.lastframetime = PIL_check_seconds_timer() - re->i.starttime;
1723
1724   re->stats_draw(re->sdh, &re->i);
1725
1726   /* save render result stamp if needed */
1727   if (re->result != NULL) {
1728     camera = RE_GetCamera(re);
1729     /* sequence rendering should have taken care of that already */
1730     if (!(render_seq && (re->r.stamp & R_STAMP_STRIPMETA))) {
1731       BKE_render_result_stamp_info(re->scene, camera, re->result, false);
1732     }
1733
1734     /* stamp image info here */
1735     if ((re->r.stamp & R_STAMP_ALL) && (re->r.stamp & R_STAMP_DRAW)) {
1736       renderresult_stampinfo(re);
1737       re->display_update(re->duh, re->result, NULL);
1738     }
1739   }
1740 }
1741
1742 static bool check_valid_compositing_camera(Scene *scene, Object *camera_override)
1743 {
1744   if (scene->r.scemode & R_DOCOMP && scene->use_nodes) {
1745     bNode *node = scene->nodetree->nodes.first;
1746
1747     while (node) {
1748       if (node->type == CMP_NODE_R_LAYERS && (node->flag & NODE_MUTED) == 0) {
1749         Scene *sce = node->id ? (Scene *)node->id : scene;
1750         if (sce->camera == NULL) {
1751           sce->camera = BKE_view_layer_camera_find(BKE_view_layer_default_render(sce));
1752         }
1753         if (sce->camera == NULL) {
1754           /* all render layers nodes need camera */
1755           return false;
1756         }
1757       }
1758       node = node->next;
1759     }
1760
1761     return true;
1762   }
1763   else {
1764     return (camera_override != NULL || scene->camera != NULL);
1765   }
1766 }
1767
1768 static bool check_valid_camera_multiview(Scene *scene, Object *camera, ReportList *reports)
1769 {
1770   SceneRenderView *srv;
1771   bool active_view = false;
1772
1773   if (camera == NULL || (scene->r.scemode & R_MULTIVIEW) == 0) {
1774     return true;
1775   }
1776
1777   for (srv = scene->r.views.first; srv; srv = srv->next) {
1778     if (BKE_scene_multiview_is_render_view_active(&scene->r, srv)) {
1779       active_view = true;
1780
1781       if (scene->r.views_format == SCE_VIEWS_FORMAT_MULTIVIEW) {
1782         Object *view_camera;
1783         view_camera = BKE_camera_multiview_render(scene, camera, srv->name);
1784
1785         if (view_camera == camera) {
1786           /* if the suffix is not in the camera, means we are using the fallback camera */
1787           if (!BLI_str_endswith(view_camera->id.name + 2, srv->suffix)) {
1788             BKE_reportf(reports,
1789                         RPT_ERROR,
1790                         "Camera \"%s\" is not a multi-view camera",
1791                         camera->id.name + 2);
1792             return false;
1793           }
1794         }
1795       }
1796     }
1797   }
1798
1799   if (!active_view) {
1800     BKE_reportf(reports, RPT_ERROR, "No active view found in scene \"%s\"", scene->id.name + 2);
1801     return false;
1802   }
1803
1804   return true;
1805 }
1806
1807 static int check_valid_camera(Scene *scene, Object *camera_override, ReportList *reports)
1808 {
1809   const char *err_msg = "No camera found in scene \"%s\"";
1810
1811   if (camera_override == NULL && scene->camera == NULL) {
1812     scene->camera = BKE_view_layer_camera_find(BKE_view_layer_default_render(scene));
1813   }
1814
1815   if (!check_valid_camera_multiview(scene, scene->camera, reports)) {
1816     return false;
1817   }
1818
1819   if (RE_seq_render_active(scene, &scene->r)) {
1820     if (scene->ed) {
1821       Sequence *seq = scene->ed->seqbase.first;
1822
1823       while (seq) {
1824         if ((seq->type == SEQ_TYPE_SCENE) && ((seq->flag & SEQ_SCENE_STRIPS) == 0) &&
1825             (seq->scene != NULL)) {
1826           if (!seq->scene_camera) {
1827             if (!seq->scene->camera &&
1828                 !BKE_view_layer_camera_find(BKE_view_layer_default_render(seq->scene))) {
1829               /* camera could be unneeded due to composite nodes */
1830               Object *override = (seq->scene == scene) ? camera_override : NULL;
1831
1832               if (!check_valid_compositing_camera(seq->scene, override)) {
1833                 BKE_reportf(reports, RPT_ERROR, err_msg, seq->scene->id.name + 2);
1834                 return false;
1835               }
1836             }
1837           }
1838           else if (!check_valid_camera_multiview(seq->scene, seq->scene_camera, reports)) {
1839             return false;
1840           }
1841         }
1842
1843         seq = seq->next;
1844       }
1845     }
1846   }
1847   else if (!check_valid_compositing_camera(scene, camera_override)) {
1848     BKE_reportf(reports, RPT_ERROR, err_msg, scene->id.name + 2);
1849     return false;
1850   }
1851
1852   return true;
1853 }
1854
1855 static bool node_tree_has_composite_output(bNodeTree *ntree)
1856 {
1857   bNode *node;
1858
1859   for (node = ntree->nodes.first; node; node = node->next) {
1860     if (ELEM(node->type, CMP_NODE_COMPOSITE, CMP_NODE_OUTPUT_FILE)) {
1861       return true;
1862     }
1863     else if (ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) {
1864       if (node->id) {
1865         if (node_tree_has_composite_output((bNodeTree *)node->id)) {
1866           return true;
1867         }
1868       }
1869     }
1870   }
1871
1872   return false;
1873 }
1874
1875 static int check_composite_output(Scene *scene)
1876 {
1877   return node_tree_has_composite_output(scene->nodetree);
1878 }
1879
1880 bool RE_is_rendering_allowed(Scene *scene,
1881                              ViewLayer *single_layer,
1882                              Object *camera_override,
1883                              ReportList *reports)
1884 {
1885   int scemode = check_mode_full_sample(&scene->r);
1886
1887   if (scene->r.mode & R_BORDER) {
1888     if (scene->r.border.xmax <= scene->r.border.xmin ||
1889         scene->r.border.ymax <= scene->r.border.ymin) {
1890       BKE_report(reports, RPT_ERROR, "No border area selected");
1891       return 0;
1892     }
1893   }
1894
1895   if (scemode & (R_EXR_TILE_FILE | R_FULL_SAMPLE)) {
1896     char str[FILE_MAX];
1897
1898     render_result_exr_file_path(scene, "", 0, str);
1899
1900     if (!BLI_file_is_writable(str)) {
1901       BKE_report(reports, RPT_ERROR, "Cannot save render buffers, check the temp default path");
1902       return 0;
1903     }
1904   }
1905
1906   if (scemode & R_DOCOMP) {
1907     if (scene->use_nodes) {
1908       if (!scene->nodetree) {
1909         BKE_report(reports, RPT_ERROR, "No node tree in scene");
1910         return 0;
1911       }
1912
1913       if (!check_composite_output(scene)) {
1914         BKE_report(reports, RPT_ERROR, "No render output node in scene");
1915         return 0;
1916       }
1917
1918       if (scemode & R_FULL_SAMPLE) {
1919         if (composite_needs_render(scene, 0) == 0) {
1920           BKE_report(reports, RPT_ERROR, "Full sample AA not supported without 3D rendering");
1921           return 0;
1922         }
1923       }
1924     }
1925   }
1926
1927   /* check valid camera, without camera render is OK (compo, seq) */
1928   if (!check_valid_camera(scene, camera_override, reports)) {
1929     return 0;
1930   }
1931
1932   if (RE_seq_render_active(scene, &scene->r)) {
1933     if (scene->r.mode & R_BORDER) {
1934       BKE_report(reports, RPT_ERROR, "Border rendering is not supported by sequencer");
1935       return false;
1936     }
1937   }
1938
1939   /* layer flag tests */
1940   if (!render_scene_has_layers_to_render(scene, single_layer)) {
1941     BKE_report(reports, RPT_ERROR, "All render layers are disabled");
1942     return 0;
1943   }
1944
1945   return 1;
1946 }
1947
1948 static void validate_render_settings(Render *re)
1949 {
1950   if (RE_engine_is_external(re)) {
1951     /* not supported yet */
1952     re->r.scemode &= ~(R_FULL_SAMPLE);
1953   }
1954 }
1955
1956 static void update_physics_cache(Render *re,
1957                                  Scene *scene,
1958                                  ViewLayer *view_layer,
1959                                  int UNUSED(anim_init))
1960 {
1961   PTCacheBaker baker;
1962
1963   memset(&baker, 0, sizeof(baker));
1964   baker.bmain = re->main;
1965   baker.scene = scene;
1966   baker.view_layer = view_layer;
1967   baker.depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
1968   baker.bake = 0;
1969   baker.render = 1;
1970   baker.anim_init = 1;
1971   baker.quick_step = 1;
1972
1973   BKE_ptcache_bake(&baker);
1974 }
1975
1976 void RE_SetActiveRenderView(Render *re, const char *viewname)
1977 {
1978   BLI_strncpy(re->viewname, viewname, sizeof(re->viewname));
1979 }
1980
1981 const char *RE_GetActiveRenderView(Render *re)
1982 {
1983   return re->viewname;
1984 }
1985
1986 /* evaluating scene options for general Blender render */
1987 static int render_initialize_from_main(Render *re,
1988                                        const RenderData *rd,
1989                                        Main *bmain,
1990                                        Scene *scene,
1991                                        ViewLayer *single_layer,
1992                                        Object *camera_override,
1993                                        int anim,
1994                                        int anim_init)
1995 {
1996   int winx, winy;
1997   rcti disprect;
1998
1999   /* r.xsch and r.ysch has the actual view window size
2000    * r.border is the clipping rect */
2001
2002   /* calculate actual render result and display size */
2003   winx = (rd->size * rd->xsch) / 100;
2004   winy = (rd->size * rd->ysch) / 100;
2005
2006   /* We always render smaller part, inserting it in larger image is compositor bizz,
2007    * it uses disprect for it. */
2008   if (scene->r.mode & R_BORDER) {
2009     disprect.xmin = rd->border.xmin * winx;
2010     disprect.xmax = rd->border.xmax * winx;
2011
2012     disprect.ymin = rd->border.ymin * winy;
2013     disprect.ymax = rd->border.ymax * winy;
2014   }
2015   else {
2016     disprect.xmin = disprect.ymin = 0;
2017     disprect.xmax = winx;
2018     disprect.ymax = winy;
2019   }
2020
2021   re->main = bmain;
2022   re->scene = scene;
2023   re->camera_override = camera_override;
2024   re->viewname[0] = '\0';
2025
2026   /* not too nice, but it survives anim-border render */
2027   if (anim) {
2028     render_update_anim_renderdata(re, &scene->r, &scene->view_layers);
2029     re->disprect = disprect;
2030     return 1;
2031   }
2032
2033   /*
2034    * Disabled completely for now,
2035    * can be later set as render profile option
2036    * and default for background render.
2037    */
2038   if (0) {
2039     /* make sure dynamics are up to date */
2040     ViewLayer *view_layer = BKE_view_layer_context_active_PLACEHOLDER(scene);
2041     update_physics_cache(re, scene, view_layer, anim_init);
2042   }
2043
2044   if (single_layer || scene->r.scemode & R_SINGLE_LAYER) {
2045     BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
2046     render_result_single_layer_begin(re);
2047     BLI_rw_mutex_unlock(&re->resultmutex);
2048   }
2049
2050   RE_InitState(re, NULL, &scene->r, &scene->view_layers, single_layer, winx, winy, &disprect);
2051   if (!re->ok) { /* if an error was printed, abort */
2052     return 0;
2053   }
2054
2055   /* initstate makes new result, have to send changed tags around */
2056   ntreeCompositTagRender(re->scene);
2057
2058   validate_render_settings(re);
2059
2060   re->display_init(re->dih, re->result);
2061   re->display_clear(re->dch, re->result);
2062
2063   return 1;
2064 }
2065
2066 void RE_SetReports(Render *re, ReportList *reports)
2067 {
2068   re->reports = reports;
2069 }
2070
2071 static void render_update_depsgraph(Render *re)
2072 {
2073   Scene *scene = re->scene;
2074   DEG_evaluate_on_framechange(re->main, re->pipeline_depsgraph, CFRA);
2075   BKE_scene_update_sound(re->pipeline_depsgraph, re->main);
2076 }
2077
2078 static void render_init_depsgraph(Render *re)
2079 {
2080   Scene *scene = re->scene;
2081   ViewLayer *view_layer = BKE_view_layer_default_render(re->scene);
2082
2083   re->pipeline_depsgraph = DEG_graph_new(scene, view_layer, DAG_EVAL_RENDER);
2084   DEG_debug_name_set(re->pipeline_depsgraph, "RENDER PIPELINE");
2085
2086   /* Make sure there is a correct evaluated scene pointer. */
2087   DEG_graph_build_for_render_pipeline(re->pipeline_depsgraph, re->main, scene, view_layer);
2088
2089   /* Update immediately so we have proper evaluated scene. */
2090   render_update_depsgraph(re);
2091
2092   re->pipeline_scene_eval = DEG_get_evaluated_scene(re->pipeline_depsgraph);
2093 }
2094
2095 /* general Blender frame render call */
2096 void RE_RenderFrame(Render *re,
2097                     Main *bmain,
2098                     Scene *scene,
2099                     ViewLayer *single_layer,
2100                     Object *camera_override,
2101                     int frame,
2102                     const bool write_still)
2103 {
2104   BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_INIT);
2105
2106   /* Ugly global still...
2107    * is to prevent preview events and signal subsurfs etc to make full resol. */
2108   G.is_rendering = true;
2109
2110   scene->r.cfra = frame;
2111
2112   if (render_initialize_from_main(
2113           re, &scene->r, bmain, scene, single_layer, camera_override, 0, 0)) {
2114     const RenderData rd = scene->r;
2115     MEM_reset_peak_memory();
2116
2117     render_init_depsgraph(re);
2118
2119     BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_PRE);
2120
2121     do_render_all_options(re);
2122
2123     if (write_still && !G.is_break) {
2124       if (BKE_imtype_is_movie(rd.im_format.imtype)) {
2125         /* operator checks this but in case its called from elsewhere */
2126         printf("Error: cant write single images with a movie format!\n");
2127       }
2128       else {
2129         char name[FILE_MAX];
2130         BKE_image_path_from_imformat(name,
2131                                      rd.pic,
2132                                      BKE_main_blendfile_path(bmain),
2133                                      scene->r.cfra,
2134                                      &rd.im_format,
2135                                      (rd.scemode & R_EXTENSION) != 0,
2136                                      false,
2137                                      NULL);
2138
2139         /* reports only used for Movie */
2140         do_write_image_or_movie(re, bmain, scene, NULL, 0, name);
2141       }
2142     }
2143
2144     /* keep after file save */
2145     BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_POST);
2146     if (write_still) {
2147       BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_WRITE);
2148     }
2149   }
2150
2151   BLI_callback_exec(
2152       re->main, (ID *)scene, G.is_break ? BLI_CB_EVT_RENDER_CANCEL : BLI_CB_EVT_RENDER_COMPLETE);
2153
2154   RE_CleanAfterRender(re);
2155
2156   /* UGLY WARNING */
2157   G.is_rendering = false;
2158 }
2159
2160 #ifdef WITH_FREESTYLE
2161 void RE_RenderFreestyleStrokes(Render *re, Main *bmain, Scene *scene, int render)
2162 {
2163   re->result_ok = 0;
2164   if (render_initialize_from_main(re, &scene->r, bmain, scene, NULL, NULL, 0, 0)) {
2165     if (render) {
2166       do_render_3d(re);
2167     }
2168   }
2169   re->result_ok = 1;
2170 }
2171
2172 void RE_RenderFreestyleExternal(Render *re)
2173 {
2174   if (!re->test_break(re->tbh)) {
2175     RenderView *rv;
2176
2177     init_freestyle(re);
2178
2179     for (rv = re->result->views.first; rv; rv = rv->next) {
2180       RE_SetActiveRenderView(re, rv->name);
2181       add_freestyle(re, 1);
2182     }
2183   }
2184 }
2185 #endif
2186
2187 bool RE_WriteRenderViewsImage(
2188     ReportList *reports, RenderResult *rr, Scene *scene, const bool stamp, char *name)
2189 {
2190   bool ok = true;
2191   RenderData *rd = &scene->r;
2192
2193   if (!rr) {
2194     return false;
2195   }
2196
2197   bool is_mono = BLI_listbase_count_at_most(&rr->views, 2) < 2;
2198   bool is_exr_rr = ELEM(rd->im_format.imtype, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER) &&
2199                    RE_HasFloatPixels(rr);
2200
2201   if (rd->im_format.views_format == R_IMF_VIEWS_MULTIVIEW && is_exr_rr) {
2202     ok = RE_WriteRenderResult(reports, rr, name, &rd->im_format, NULL, -1);
2203     render_print_save_message(reports, name, ok, errno);
2204   }
2205
2206   /* mono, legacy code */
2207   else if (is_mono || (rd->im_format.views_format == R_IMF_VIEWS_INDIVIDUAL)) {
2208     RenderView *rv;
2209     int view_id;
2210     char filepath[FILE_MAX];
2211
2212     BLI_strncpy(filepath, name, sizeof(filepath));
2213
2214     for (view_id = 0, rv = rr->views.first; rv; rv = rv->next, view_id++) {
2215       if (!is_mono) {
2216         BKE_scene_multiview_view_filepath_get(&scene->r, filepath, rv->name, name);
2217       }
2218
2219       if (is_exr_rr) {
2220         ok = RE_WriteRenderResult(reports, rr, name, &rd->im_format, rv->name, -1);
2221         render_print_save_message(reports, name, ok, errno);
2222
2223         /* optional preview images for exr */
2224         if (ok && (rd->im_format.flag & R_IMF_FLAG_PREVIEW_JPG)) {
2225           ImageFormatData imf = rd->im_format;
2226           imf.imtype = R_IMF_IMTYPE_JPEG90;
2227
2228           if (BLI_path_extension_check(name, ".exr")) {
2229             name[strlen(name) - 4] = 0;
2230           }
2231           BKE_image_path_ensure_ext_from_imformat(name, &imf);
2232
2233           ImBuf *ibuf = render_result_rect_to_ibuf(rr, rd, view_id);
2234           ibuf->planes = 24;
2235           IMB_colormanagement_imbuf_for_write(
2236               ibuf, true, false, &scene->view_settings, &scene->display_settings, &imf);
2237
2238           ok = render_imbuf_write_stamp_test(reports, scene, rr, ibuf, name, &imf, stamp);
2239
2240           IMB_freeImBuf(ibuf);
2241         }
2242       }
2243       else {
2244         ImBuf *ibuf = render_result_rect_to_ibuf(rr, rd, view_id);
2245
2246         IMB_colormanagement_imbuf_for_write(
2247             ibuf, true, false, &scene->view_settings, &scene->display_settings, &rd->im_format);
2248
2249         ok = render_imbuf_write_stamp_test(reports, scene, rr, ibuf, name, &rd->im_format, stamp);
2250
2251         /* imbuf knows which rects are not part of ibuf */
2252         IMB_freeImBuf(ibuf);
2253       }
2254     }
2255   }
2256   else { /* R_IMF_VIEWS_STEREO_3D */
2257     BLI_assert(scene->r.im_format.views_format == R_IMF_VIEWS_STEREO_3D);
2258
2259     if (rd->im_format.imtype == R_IMF_IMTYPE_MULTILAYER) {
2260       printf("Stereo 3D not supported for MultiLayer image: %s\n", name);
2261     }
2262     else {
2263       ImBuf *ibuf_arr[3] = {NULL};
2264       const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
2265       int i;
2266
2267       for (i = 0; i < 2; i++) {
2268         int view_id = BLI_findstringindex(&rr->views, names[i], offsetof(RenderView, name));
2269         ibuf_arr[i] = render_result_rect_to_ibuf(rr, rd, view_id);
2270         IMB_colormanagement_imbuf_for_write(ibuf_arr[i],
2271                                             true,
2272                                             false,
2273                                             &scene->view_settings,
2274                                             &scene->display_settings,
2275                                             &scene->r.im_format);
2276         IMB_prepare_write_ImBuf(IMB_isfloat(ibuf_arr[i]), ibuf_arr[i]);
2277       }
2278
2279       ibuf_arr[2] = IMB_stereo3d_ImBuf(&scene->r.im_format, ibuf_arr[0], ibuf_arr[1]);
2280
2281       ok = render_imbuf_write_stamp_test(
2282           reports, scene, rr, ibuf_arr[2], name, &rd->im_format, stamp);
2283
2284       /* optional preview images for exr */
2285       if (ok && is_exr_rr && (rd->im_format.flag & R_IMF_FLAG_PREVIEW_JPG)) {
2286         ImageFormatData imf = rd->im_format;
2287         imf.imtype = R_IMF_IMTYPE_JPEG90;
2288
2289         if (BLI_path_extension_check(name, ".exr")) {
2290           name[strlen(name) - 4] = 0;
2291         }
2292
2293         BKE_image_path_ensure_ext_from_imformat(name, &imf);
2294         ibuf_arr[2]->planes = 24;
2295
2296         ok = render_imbuf_write_stamp_test(
2297             reports, scene, rr, ibuf_arr[2], name, &rd->im_format, stamp);
2298       }
2299
2300       /* imbuf knows which rects are not part of ibuf */
2301       for (i = 0; i < 3; i++) {
2302         IMB_freeImBuf(ibuf_arr[i]);
2303       }
2304     }
2305   }
2306
2307   return ok;
2308 }
2309
2310 bool RE_WriteRenderViewsMovie(ReportList *reports,
2311                               RenderResult *rr,
2312                               Scene *scene,
2313                               RenderData *rd,
2314                               bMovieHandle *mh,
2315                               void **movie_ctx_arr,
2316                               const int totvideos,
2317                               bool preview)
2318 {
2319   bool is_mono;
2320   bool ok = true;
2321
2322   if (!rr) {
2323     return false;
2324   }
2325
2326   is_mono = BLI_listbase_count_at_most(&rr->views, 2) < 2;
2327
2328   if (is_mono || (scene->r.im_format.views_format == R_IMF_VIEWS_INDIVIDUAL)) {
2329     int view_id;
2330     for (view_id = 0; view_id < totvideos; view_id++) {
2331       const char *suffix = BKE_scene_multiview_view_id_suffix_get(&scene->r, view_id);
2332       ImBuf *ibuf = render_result_rect_to_ibuf(rr, &scene->r, view_id);
2333
2334       IMB_colormanagement_imbuf_for_write(
2335           ibuf, true, false, &scene->view_settings, &scene->display_settings, &scene->r.im_format);
2336
2337       ok &= mh->append_movie(movie_ctx_arr[view_id],
2338                              rd,
2339                              preview ? scene->r.psfra : scene->r.sfra,
2340                              scene->r.cfra,
2341                              (int *)ibuf->rect,
2342                              ibuf->x,
2343                              ibuf->y,
2344                              suffix,
2345                              reports);
2346
2347       /* imbuf knows which rects are not part of ibuf */
2348       IMB_freeImBuf(ibuf);
2349     }
2350     printf("Append frame %d\n", scene->r.cfra);
2351   }
2352   else { /* R_IMF_VIEWS_STEREO_3D */
2353     const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
2354     ImBuf *ibuf_arr[3] = {NULL};
2355     int i;
2356
2357     BLI_assert((totvideos == 1) && (scene->r.im_format.views_format == R_IMF_VIEWS_STEREO_3D));
2358
2359     for (i = 0; i < 2; i++) {
2360       int view_id = BLI_findstringindex(&rr->views, names[i], offsetof(RenderView, name));
2361       ibuf_arr[i] = render_result_rect_to_ibuf(rr, &scene->r, view_id);
2362
2363       IMB_colormanagement_imbuf_for_write(ibuf_arr[i],
2364                                           true,
2365                                           false,
2366                                           &scene->view_settings,
2367                                           &scene->display_settings,
2368                                           &scene->r.im_format);
2369     }
2370
2371     ibuf_arr[2] = IMB_stereo3d_ImBuf(&scene->r.im_format, ibuf_arr[0], ibuf_arr[1]);
2372
2373     ok = mh->append_movie(movie_ctx_arr[0],
2374                           rd,
2375                           preview ? scene->r.psfra : scene->r.sfra,
2376                           scene->r.cfra,
2377                           (int *)ibuf_arr[2]->rect,
2378                           ibuf_arr[2]->x,
2379                           ibuf_arr[2]->y,
2380                           "",
2381                           reports);
2382
2383     for (i = 0; i < 3; i++) {
2384       /* imbuf knows which rects are not part of ibuf */
2385       IMB_freeImBuf(ibuf_arr[i]);
2386     }
2387   }
2388
2389   return ok;
2390 }
2391
2392 static int do_write_image_or_movie(Render *re,
2393                                    Main *bmain,
2394                                    Scene *scene,
2395                                    bMovieHandle *mh,
2396                                    const int totvideos,
2397                                    const char *name_override)
2398 {
2399   char name[FILE_MAX];
2400   RenderResult rres;
2401   double render_time;
2402   bool ok = true;
2403
2404   RE_AcquireResultImageViews(re, &rres);
2405
2406   /* write movie or image */
2407   if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
2408     RE_WriteRenderViewsMovie(
2409         re->reports, &rres, scene, &re->r, mh, re->movie_ctx_arr, totvideos, false);
2410   }
2411   else {
2412     if (name_override) {
2413       BLI_strncpy(name, name_override, sizeof(name));
2414     }
2415     else {
2416       BKE_image_path_from_imformat(name,
2417                                    scene->r.pic,
2418                                    BKE_main_blendfile_path(bmain),
2419                                    scene->r.cfra,
2420                                    &scene->r.im_format,
2421                                    (scene->r.scemode & R_EXTENSION) != 0,
2422                                    true,
2423                                    NULL);
2424     }
2425
2426     /* write images as individual images or stereo */
2427     ok = RE_WriteRenderViewsImage(re->reports, &rres, scene, true, name);
2428   }
2429
2430   RE_ReleaseResultImageViews(re, &rres);
2431
2432   render_time = re->i.lastframetime;
2433   re->i.lastframetime = PIL_check_seconds_timer() - re->i.starttime;
2434
2435   BLI_timecode_string_from_time_simple(name, sizeof(name), re->i.lastframetime);
2436   printf(" Time: %s", name);
2437
2438   /* Flush stdout to be sure python callbacks are printing stuff after blender. */
2439   fflush(stdout);
2440
2441   /* NOTE: using G_MAIN seems valid here???
2442    * Not sure it's actually even used anyway, we could as well pass NULL? */
2443   BLI_callback_exec(G_MAIN, NULL, BLI_CB_EVT_RENDER_STATS);
2444
2445   BLI_timecode_string_from_time_simple(name, sizeof(name), re->i.lastframetime - render_time);
2446   printf(" (Saving: %s)\n", name);
2447
2448   fputc('\n', stdout);
2449   fflush(stdout); /* needed for renderd !! (not anymore... (ton)) */
2450
2451   return ok;
2452 }
2453
2454 static void get_videos_dimensions(const Render *re,
2455                                   const RenderData *rd,
2456                                   size_t *r_width,
2457                                   size_t *r_height)
2458 {
2459   size_t width, height;
2460   if (re->r.mode & R_BORDER) {
2461     if ((re->r.mode & R_CROP) == 0) {
2462       width = re->winx;
2463       height = re->winy;
2464     }
2465     else {
2466       width = re->rectx;
2467       height = re->recty;
2468     }
2469   }
2470   else {
2471     width = re->rectx;
2472     height = re->recty;
2473   }
2474
2475   BKE_scene_multiview_videos_dimensions_get(rd, width, height, r_width, r_height);
2476 }
2477
2478 static void re_movie_free_all(Render *re, bMovieHandle *mh, int totvideos)
2479 {
2480   int i;
2481
2482   for (i = 0; i < totvideos; i++) {
2483     mh->end_movie(re->movie_ctx_arr[i]);
2484     mh->context_free(re->movie_ctx_arr[i]);
2485   }
2486
2487   MEM_SAFE_FREE(re->movie_ctx_arr);
2488 }
2489
2490 /* saves images to disk */
2491 void RE_RenderAnim(Render *re,
2492                    Main *bmain,
2493                    Scene *scene,
2494                    ViewLayer *single_layer,
2495                    Object *camera_override,
2496                    int sfra,
2497                    int efra,
2498                    int tfra)
2499 {
2500   const RenderData rd = scene->r;
2501   bMovieHandle *mh = NULL;
2502   const int cfrao = rd.cfra;
2503   int nfra, totrendered = 0, totskipped = 0;
2504   const int totvideos = BKE_scene_multiview_num_videos_get(&rd);
2505   const bool is_movie = BKE_imtype_is_movie(rd.im_format.imtype);
2506   const bool is_multiview_name = ((rd.scemode & R_MULTIVIEW) != 0 &&
2507                                   (rd.im_format.views_format == R_IMF_VIEWS_INDIVIDUAL));
2508
2509   BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_INIT);
2510
2511   /* do not fully call for each frame, it initializes & pops output window */
2512   if (!render_initialize_from_main(re, &rd, bmain, scene, single_layer, camera_override, 0, 1)) {
2513     return;
2514   }
2515
2516   render_init_depsgraph(re);
2517
2518   if (is_movie) {
2519     size_t width, height;
2520     int i;
2521     bool is_error = false;
2522
2523     get_videos_dimensions(re, &rd, &width, &height);
2524
2525     mh = BKE_movie_handle_get(rd.im_format.imtype);
2526     if (mh == NULL) {
2527       BKE_report(re->reports, RPT_ERROR, "Movie format unsupported");
2528       return;
2529     }
2530
2531     re->movie_ctx_arr = MEM_mallocN(sizeof(void *) * totvideos, "Movies' Context");
2532
2533     for (i = 0; i < totvideos; i++) {
2534       const char *suffix = BKE_scene_multiview_view_id_suffix_get(&re->r, i);
2535
2536       re->movie_ctx_arr[i] = mh->context_create();
2537
2538       if (!mh->start_movie(re->movie_ctx_arr[i],
2539                            re->pipeline_scene_eval,
2540                            &re->r,
2541                            width,
2542                            height,
2543                            re->reports,
2544                            false,
2545                            suffix)) {
2546         is_error = true;
2547         break;
2548       }
2549     }
2550
2551     if (is_error) {
2552       /* report is handled above */
2553       re_movie_free_all(re, mh, i + 1);
2554       RE_CleanAfterRender(re);
2555       return;
2556     }
2557   }
2558
2559   /* Ugly global still... is to prevent renderwin events and signal subsurfs etc to make full resol
2560    * is also set by caller renderwin.c */
2561   G.is_rendering = true;
2562
2563   re->flag |= R_ANIMATION;
2564
2565   {
2566     for (nfra = sfra, scene->r.cfra = sfra; scene->r.cfra <= efra; scene->r.cfra++) {
2567       char name[FILE_MAX];
2568
2569       /* A feedback loop exists here -- render initialization requires updated
2570        * render layers settings which could be animated, but scene evaluation for
2571        * the frame happens later because it depends on what layers are visible to
2572        * render engine.
2573        *
2574        * The idea here is to only evaluate animation data associated with the scene,
2575        * which will make sure render layer settings are up-to-date, initialize the
2576        * render database itself and then perform full scene update with only needed
2577        * layers.
2578        *                                                              -sergey-
2579        */
2580       {
2581         float ctime = BKE_scene_frame_get(scene);
2582         AnimData *adt = BKE_animdata_from_id(&scene->id);
2583         /* TODO(sergey): Currently depsgraph is only used to check whether it is an active
2584          * edit window or not to deal with unkeyed changes. We don't have depsgraph here yet,
2585          * but we also don't deal with unkeyed changes. But still nice to get proper depsgraph
2586          * within the render pipeline, somehow.
2587          */
2588         BKE_animsys_evaluate_animdata(NULL, scene, &scene->id, adt, ctime, ADT_RECALC_ALL);
2589       }
2590
2591       render_update_depsgraph(re);
2592
2593       /* only border now, todo: camera lens. (ton) */
2594       render_initialize_from_main(re, &rd, bmain, scene, single_layer, camera_override, 1, 0);
2595
2596       if (nfra != scene->r.cfra) {
2597         /* Skip this frame, but could update for physics and particles system. */
2598         continue;
2599       }
2600       else {
2601         nfra += tfra;
2602       }
2603
2604       /* Touch/NoOverwrite options are only valid for image's */
2605       if (is_movie == false) {
2606         if (rd.mode & (R_NO_OVERWRITE | R_TOUCH)) {
2607           BKE_image_path_from_imformat(name,
2608                                        rd.pic,
2609                                        BKE_main_blendfile_path(bmain),
2610                                        scene->r.cfra,
2611                                        &rd.im_format,
2612                                        (rd.scemode & R_EXTENSION) != 0,
2613                                        true,
2614                                        NULL);
2615         }
2616
2617         if (rd.mode & R_NO_OVERWRITE) {
2618           if (!is_multiview_name) {
2619             if (BLI_exists(name)) {
2620               printf("skipping existing frame \"%s\"\n", name);
2621               totskipped++;
2622               continue;
2623             }
2624           }
2625           else {
2626             SceneRenderView *srv;
2627             bool is_skip = false;
2628             char filepath[FILE_MAX];
2629
2630             for (srv = scene->r.views.first; srv; srv = srv->next) {
2631               if (!BKE_scene_multiview_is_render_view_active(&scene->r, srv)) {
2632                 continue;
2633               }
2634
2635               BKE_scene_multiview_filepath_get(srv, name, filepath);
2636
2637               if (BLI_exists(filepath)) {
2638                 is_skip = true;
2639                 printf("skipping existing frame \"%s\" for view \"%s\"\n", filepath, srv->name);
2640               }
2641             }
2642
2643             if (is_skip) {
2644               totskipped++;
2645               continue;
2646             }
2647           }
2648         }
2649
2650         if (rd.mode & R_TOUCH) {
2651           if (!is_multiview_name) {
2652             if (!BLI_exists(name)) {
2653               BLI_make_existing_file(name); /* makes the dir if its not there */
2654               BLI_file_touch(name);
2655             }
2656           }
2657           else {
2658             SceneRenderView *srv;
2659             char filepath[FILE_MAX];
2660
2661             for (srv = scene->r.views.first; srv; srv = srv->next) {
2662               if (!BKE_scene_multiview_is_render_view_active(&scene->r, srv)) {
2663                 continue;
2664               }
2665
2666               BKE_scene_multiview_filepath_get(srv, name, filepath);
2667
2668               if (!BLI_exists(filepath)) {
2669                 BLI_make_existing_file(filepath); /* makes the dir if its not there */
2670                 BLI_file_touch(filepath);
2671               }
2672             }
2673           }
2674         }
2675       }
2676
2677       re->r.cfra = scene->r.cfra; /* weak.... */
2678
2679       /* run callbacs before rendering, before the scene is updated */
2680       BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_PRE);
2681
2682       do_render_all_options(re);
2683       totrendered++;
2684
2685       if (re->test_break(re->tbh) == 0) {
2686         if (!G.is_break) {
2687           if (!do_write_image_or_movie(re, bmain, scene, mh, totvideos, NULL)) {
2688             G.is_break = true;
2689           }
2690         }
2691       }
2692       else {
2693         G.is_break = true;
2694       }
2695
2696       if (G.is_break == true) {
2697         /* remove touched file */
2698         if (is_movie == false) {
2699           if ((rd.mode & R_TOUCH)) {
2700             if (!is_multiview_name) {
2701               if ((BLI_file_size(name) == 0)) {
2702                 /* BLI_exists(name) is implicit */
2703                 BLI_delete(name, false, false);
2704               }
2705             }
2706             else {
2707               SceneRenderView *srv;
2708               char filepath[FILE_MAX];
2709
2710               for (srv = scene->r.views.first; srv; srv = srv->next) {
2711                 if (!BKE_scene_multiview_is_render_view_active(&scene->r, srv)) {
2712                   continue;
2713                 }
2714
2715                 BKE_scene_multiview_filepath_get(srv, name, filepath);
2716
2717                 if ((BLI_file_size(filepath) == 0)) {
2718                   /* BLI_exists(filepath) is implicit */
2719                   BLI_delete(filepath, false, false);
2720                 }
2721               }
2722             }
2723           }
2724         }
2725
2726         break;
2727       }
2728
2729       if (G.is_break == false) {
2730         /* keep after file save */
2731         BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_POST);
2732         BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_WRITE);
2733       }
2734     }
2735   }
2736
2737   /* end movie */
2738   if (is_movie) {
2739     re_movie_free_all(re, mh, totvideos);
2740   }
2741
2742   if (totskipped && totrendered == 0) {
2743     BKE_report(re->reports, RPT_INFO, "No frames rendered, skipped to not overwrite");
2744   }
2745
2746   scene->r.cfra = cfrao;
2747
2748   re->flag &= ~R_ANIMATION;
2749
2750   BLI_callback_exec(
2751       re->main, (ID *)scene, G.is_break ? BLI_CB_EVT_RENDER_CANCEL : BLI_CB_EVT_RENDER_COMPLETE);
2752   BKE_sound_reset_scene_specs(re->pipeline_scene_eval);
2753
2754   RE_CleanAfterRender(re);
2755
2756   /* UGLY WARNING */
2757   G.is_rendering = false;
2758 }
2759
2760 void RE_PreviewRender(Render *re, Main *bmain, Scene *sce)
2761 {
2762   Object *camera;
2763   int winx, winy;
2764
2765   winx = (sce->r.size * sce->r.xsch) / 100;
2766   winy = (sce->r.size * sce->r.ysch) / 100;
2767
2768   RE_InitState(re, NULL, &sce->r, &sce->view_layers, NULL, winx, winy, NULL);
2769
2770   re->main = bmain;
2771   re->scene = sce;
2772
2773   camera = RE_GetCamera(re);
2774   RE_SetCamera(re, camera);
2775
2776   do_render_3d(re);
2777 }
2778
2779 void RE_CleanAfterRender(Render *re)
2780 {
2781   /* Destroy the opengl context in the correct thread. */
2782   RE_gl_context_destroy(re);
2783   if (re->pipeline_depsgraph != NULL) {
2784     DEG_graph_free(re->pipeline_depsgraph);
2785   }
2786   re->pipeline_depsgraph = NULL;
2787   re->pipeline_scene_eval = NULL;
2788 }
2789
2790 /* note; repeated win/disprect calc... solve that nicer, also in compo */
2791
2792 /* only the temp file! */
2793 bool RE_ReadRenderResult(Scene *scene, Scene *scenode)
2794 {
2795   Render *re;
2796   int winx, winy;
2797   bool success;
2798   rcti disprect;
2799
2800   /* calculate actual render result and display size */
2801   winx = (scene->r.size * scene->r.xsch) / 100;
2802   winy = (scene->r.size * scene->r.ysch) / 100;
2803
2804   /* only in movie case we render smaller part */
2805   if (scene->r.mode & R_BORDER) {
2806     disprect.xmin = scene->r.border.xmin * winx;
2807     disprect.xmax = scene->r.border.xmax * winx;
2808
2809     disprect.ymin = scene->r.border.ymin * winy;
2810     disprect.ymax = scene->r.border.ymax * winy;
2811   }
2812   else {
2813     disprect.xmin = disprect.ymin = 0;
2814     disprect.xmax = winx;
2815     disprect.ymax = winy;
2816   }
2817
2818   if (scenode) {
2819     scene = scenode;
2820   }
2821
2822   /* get render: it can be called from UI with draw callbacks */
2823   re = RE_GetSceneRender(scene);
2824   if (re == NULL) {
2825     re = RE_NewSceneRender(scene);
2826   }
2827   RE_InitState(re, NULL, &scene->r, &scene->view_layers, NULL, winx, winy, &disprect);
2828   re->scene = scene;
2829
2830   BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
2831   success = render_result_exr_file_cache_read(re);
2832   BLI_rw_mutex_unlock(&re->resultmutex);
2833
2834   render_result_uncrop(re);
2835
2836   return success;
2837 }
2838
2839 void RE_init_threadcount(Render *re)
2840 {
2841   re->r.threads = BKE_render_num_threads(&re->r);
2842 }
2843
2844 /* loads in image into a result, size must match
2845  * x/y offsets are only used on a partial copy when dimensions don't match */
2846 void RE_layer_load_from_file(
2847     RenderLayer *layer, ReportList *reports, const char *filename, int x, int y)
2848 {
2849   /* OCIO_TODO: assume layer was saved in defaule color space */
2850   ImBuf *ibuf = IMB_loadiffname(filename, IB_rect, NULL);
2851   RenderPass *rpass = NULL;
2852
2853   /* multiview: since the API takes no 'view', we use the first combined pass found */
2854   for (rpass = layer->passes.first; rpass; rpass = rpass->next) {
2855     if (STREQ(rpass->name, RE_PASSNAME_COMBINED)) {
2856       break;
2857     }
2858   }
2859
2860   if (rpass == NULL) {
2861     BKE_reportf(reports,
2862                 RPT_ERROR,
2863                 "%s: no Combined pass found in the render layer '%s'",
2864                 __func__,
2865                 filename);
2866   }
2867
2868   if (ibuf && (ibuf->rect || ibuf->rect_float)) {
2869     if (ibuf->x == layer->rectx && ibuf->y == layer->recty) {
2870       if (ibuf->rect_float == NULL) {
2871         IMB_float_from_rect(ibuf);
2872       }
2873
2874       memcpy(rpass->rect, ibuf->rect_float, sizeof(float) * 4 * layer->rectx * layer->recty);
2875     }
2876     else {
2877       if ((ibuf->x - x >= layer->rectx) && (ibuf->y - y >= layer->recty)) {
2878         ImBuf *ibuf_clip;
2879
2880         if (ibuf->rect_float == NULL) {
2881           IMB_float_from_rect(ibuf);
2882         }
2883
2884         ibuf_clip = IMB_allocImBuf(layer->rectx, layer->recty, 32, IB_rectfloat);
2885         if (ibuf_clip) {
2886           IMB_rectcpy(ibuf_clip, ibuf, 0, 0, x, y, layer->rectx, layer->recty);
2887
2888           memcpy(
2889               rpass->rect, ibuf_clip->rect_float, sizeof(float) * 4 * layer->rectx * layer->recty);
2890           IMB_freeImBuf(ibuf_clip);
2891         }
2892         else {
2893           BKE_reportf(
2894               reports, RPT_ERROR, "%s: failed to allocate clip buffer '%s'", __func__, filename);
2895         }
2896       }
2897       else {
2898         BKE_reportf(reports,
2899                     RPT_ERROR,
2900                     "%s: incorrect dimensions for partial copy '%s'",
2901                     __func__,
2902                     filename);
2903       }
2904     }
2905
2906     IMB_freeImBuf(ibuf);
2907   }
2908   else {
2909     BKE_reportf(reports, RPT_ERROR, "%s: failed to load '%s'", __func__, filename);
2910   }
2911 }
2912
2913 void RE_result_load_from_file(RenderResult *result, ReportList *reports, const char *filename)
2914 {
2915   if (!render_result_exr_file_read_path(result, NULL, filename)) {
2916     BKE_reportf(reports, RPT_ERROR, "%s: failed to load '%s'", __func__, filename);
2917     return;
2918   }
2919 }
2920
2921 /* Used in the interface to decide whether to show layers or passes. */
2922 bool RE_layers_have_name(struct RenderResult *rr)
2923 {
2924   switch (BLI_listbase_count_at_most(&rr->layers, 2)) {
2925     case 0:
2926       return false;
2927     case 1:
2928       return (((RenderLayer *)rr->layers.first)->name[0] != '\0');
2929     default:
2930       return true;
2931   }
2932   return false;
2933 }
2934
2935 bool RE_passes_have_name(struct RenderLayer *rl)
2936 {
2937   for (RenderPass *rp = rl->passes.first; rp; rp = rp->next) {
2938     if (!STREQ(rp->name, "Combined")) {
2939       return true;
2940     }
2941   }
2942
2943   return false;
2944 }
2945
2946 RenderPass *RE_pass_find_by_name(volatile RenderLayer *rl, const char *name, const char *viewname)
2947 {
2948   RenderPass *rp = NULL;
2949
2950   for (rp = rl->passes.last; rp; rp = rp->prev) {
2951     if (STREQ(rp->name, name)) {
2952       if (viewname == NULL || viewname[0] == '\0') {
2953         break;
2954       }
2955       else if (STREQ(rp->view, viewname)) {
2956         break;
2957       }
2958     }
2959   }
2960   return rp;
2961 }
2962
2963 /* Only provided for API compatibility, don't use this in new code! */
2964 RenderPass *RE_pass_find_by_type(volatile RenderLayer *rl, int passtype, const char *viewname)
2965 {
2966 #define CHECK_PASS(NAME) \
2967   if (passtype == SCE_PASS_##NAME) { \
2968     return RE_pass_find_by_name(rl, RE_PASSNAME_##NAME, viewname); \
2969   } \
2970   ((void)0)
2971
2972   CHECK_PASS(COMBINED);
2973   CHECK_PASS(Z);
2974   CHECK_PASS(VECTOR);
2975   CHECK_PASS(NORMAL);
2976   CHECK_PASS(UV);
2977   CHECK_PASS(EMIT);
2978   CHECK_PASS(SHADOW);
2979   CHECK_PASS(AO);
2980   CHECK_PASS(ENVIRONMENT);
2981   CHECK_PASS(INDEXOB);
2982   CHECK_PASS(INDEXMA);
2983   CHECK_PASS(MIST);
2984   CHECK_PASS(RAYHITS);
2985   CHECK_PASS(DIFFUSE_DIRECT);
2986   CHECK_PASS(DIFFUSE_INDIRECT);
2987   CHECK_PASS(DIFFUSE_COLOR);
2988   CHECK_PASS(GLOSSY_DIRECT);
2989   CHECK_PASS(GLOSSY_INDIRECT);
2990   CHECK_PASS(GLOSSY_COLOR);
2991   CHECK_PASS(TRANSM_DIRECT);
2992   CHECK_PASS(TRANSM_INDIRECT);
2993   CHECK_PASS(TRANSM_COLOR);
2994   CHECK_PASS(SUBSURFACE_DIRECT);
2995   CHECK_PASS(SUBSURFACE_INDIRECT);
2996   CHECK_PASS(SUBSURFACE_COLOR);
2997
2998 #undef CHECK_PASS
2999
3000   return NULL;
3001 }
3002
3003 /* create a renderlayer and renderpass for grease pencil layer */
3004 RenderPass *RE_create_gp_pass(RenderResult *rr, const char *layername, const char *viewname)
3005 {
3006   RenderLayer *rl = BLI_findstring(&rr->layers, layername, offsetof(RenderLayer, name));
3007   /* only create render layer if not exist */
3008   if (!rl) {
3009     rl = MEM_callocN(sizeof(RenderLayer), layername);
3010     BLI_addtail(&rr->layers, rl);
3011     BLI_strncpy(rl->name, layername, sizeof(rl->name));
3012     rl->layflag = SCE_LAY_SOLID;
3013     rl->passflag = SCE_PASS_COMBINED;
3014     rl->rectx = rr->rectx;
3015     rl->recty = rr->recty;
3016   }
3017
3018   /* clear previous pass if exist or the new image will be over previous one*/
3019   RenderPass *rp = RE_pass_find_by_name(rl, RE_PASSNAME_COMBINED, viewname);
3020   if (rp) {
3021     if (rp->rect) {
3022       MEM_freeN(rp->rect);
3023     }
3024     BLI_freelinkN(&rl->passes, rp);
3025   }
3026   /* create a totally new pass */
3027   return gp_add_pass(rr, rl, 4, RE_PASSNAME_COMBINED, viewname);
3028 }