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