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