Viewport: MSAA support during ViewportRendering
[blender.git] / source / blender / editors / render / render_opengl.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edrend
22  */
23
24 #include <math.h>
25 #include <string.h>
26 #include <stddef.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "DNA_camera_types.h"
31 #include "BLI_math.h"
32 #include "BLI_math_color_blend.h"
33 #include "BLI_blenlib.h"
34 #include "BLI_utildefines.h"
35 #include "BLI_threads.h"
36 #include "BLI_task.h"
37
38 #include "DNA_scene_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_gpencil_types.h"
41
42 #include "BKE_camera.h"
43 #include "BKE_context.h"
44 #include "BKE_customdata.h"
45 #include "BKE_global.h"
46 #include "BKE_image.h"
47 #include "BKE_main.h"
48 #include "BKE_report.h"
49 #include "BKE_scene.h"
50 #include "BKE_sequencer.h"
51 #include "BKE_writeavi.h"
52
53 #include "DEG_depsgraph.h"
54
55 #include "DRW_engine.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 #include "ED_screen.h"
61 #include "ED_view3d.h"
62 #include "ED_gpencil.h"
63
64 #include "RE_pipeline.h"
65 #include "IMB_imbuf_types.h"
66 #include "IMB_imbuf.h"
67 #include "IMB_colormanagement.h"
68
69 #include "RNA_access.h"
70 #include "RNA_define.h"
71
72 #include "GPU_framebuffer.h"
73 #include "GPU_glew.h"
74 #include "GPU_matrix.h"
75
76 #include "render_intern.h"
77
78 /* Define this to get timing information. */
79 // #undef DEBUG_TIME
80
81 #ifdef DEBUG_TIME
82 #  include "PIL_time.h"
83 #endif
84
85 // TODO(sergey): Find better approximation of the scheduled frames.
86 // For really highres renders it might fail still.
87 #define MAX_SCHEDULED_FRAMES 8
88
89 typedef struct OGLRender {
90   Main *bmain;
91   Render *re;
92   Scene *scene;
93   WorkSpace *workspace;
94   ViewLayer *view_layer;
95   Depsgraph *depsgraph;
96
97   View3D *v3d;
98   RegionView3D *rv3d;
99   ARegion *ar;
100
101   ScrArea *prevsa;
102   ARegion *prevar;
103
104   int views_len; /* multi-view views */
105
106   bool is_sequencer;
107   SpaceSeq *sseq;
108   struct {
109     ImBuf **ibufs_arr;
110   } seq_data;
111
112   Image *ima;
113   ImageUser iuser;
114
115   GPUOffScreen *ofs;
116   int ofs_samples;
117   int sizex, sizey;
118   int write_still;
119
120   ReportList *reports;
121   bMovieHandle *mh;
122   int cfrao, nfra;
123
124   int totvideos;
125
126   /* quick lookup */
127   int view_id;
128
129   /* wm vars for timer and progress cursor */
130   wmWindowManager *wm;
131   wmWindow *win;
132
133   wmTimer *timer; /* use to check if running modal or not (invoke'd or exec'd)*/
134   void **movie_ctx_arr;
135
136   TaskScheduler *task_scheduler;
137   TaskPool *task_pool;
138   bool pool_ok;
139   bool is_animation;
140   SpinLock reports_lock;
141   unsigned int num_scheduled_frames;
142   ThreadMutex task_mutex;
143   ThreadCondition task_condition;
144
145 #ifdef DEBUG_TIME
146   double time_start;
147 #endif
148 } OGLRender;
149
150 static bool screen_opengl_is_multiview(OGLRender *oglrender)
151 {
152   View3D *v3d = oglrender->v3d;
153   RegionView3D *rv3d = oglrender->rv3d;
154   RenderData *rd = &oglrender->scene->r;
155
156   if ((rd == NULL) || ((v3d != NULL) && (rv3d == NULL))) {
157     return false;
158   }
159
160   return (rd->scemode & R_MULTIVIEW) &&
161          ((v3d == NULL) || (rv3d->persp == RV3D_CAMOB && v3d->camera));
162 }
163
164 static void screen_opengl_views_setup(OGLRender *oglrender)
165 {
166   RenderResult *rr;
167   RenderView *rv;
168   SceneRenderView *srv;
169   bool is_multiview;
170   Object *camera;
171   View3D *v3d = oglrender->v3d;
172
173   RenderData *rd = &oglrender->scene->r;
174
175   rr = RE_AcquireResultWrite(oglrender->re);
176
177   is_multiview = screen_opengl_is_multiview(oglrender);
178
179   if (!is_multiview) {
180     /* we only have one view when multiview is off */
181     rv = rr->views.first;
182
183     if (rv == NULL) {
184       rv = MEM_callocN(sizeof(RenderView), "new opengl render view");
185       BLI_addtail(&rr->views, rv);
186     }
187
188     while (rv->next) {
189       RenderView *rv_del = rv->next;
190       BLI_remlink(&rr->views, rv_del);
191
192       if (rv_del->rectf) {
193         MEM_freeN(rv_del->rectf);
194       }
195
196       if (rv_del->rectz) {
197         MEM_freeN(rv_del->rectz);
198       }
199
200       if (rv_del->rect32) {
201         MEM_freeN(rv_del->rect32);
202       }
203
204       MEM_freeN(rv_del);
205     }
206   }
207   else {
208     if (v3d) {
209       RE_SetOverrideCamera(oglrender->re, V3D_CAMERA_SCENE(oglrender->scene, v3d));
210     }
211
212     /* remove all the views that are not needed */
213     rv = rr->views.last;
214     while (rv) {
215       srv = BLI_findstring(&rd->views, rv->name, offsetof(SceneRenderView, name));
216       if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
217         rv = rv->prev;
218       }
219       else {
220         RenderView *rv_del = rv;
221         rv = rv_del->prev;
222
223         BLI_remlink(&rr->views, rv_del);
224
225         if (rv_del->rectf) {
226           MEM_freeN(rv_del->rectf);
227         }
228
229         if (rv_del->rectz) {
230           MEM_freeN(rv_del->rectz);
231         }
232
233         if (rv_del->rect32) {
234           MEM_freeN(rv_del->rect32);
235         }
236
237         MEM_freeN(rv_del);
238       }
239     }
240
241     /* create all the views that are needed */
242     for (srv = rd->views.first; srv; srv = srv->next) {
243       if (BKE_scene_multiview_is_render_view_active(rd, srv) == false) {
244         continue;
245       }
246
247       rv = BLI_findstring(&rr->views, srv->name, offsetof(SceneRenderView, name));
248
249       if (rv == NULL) {
250         rv = MEM_callocN(sizeof(RenderView), "new opengl render view");
251         BLI_strncpy(rv->name, srv->name, sizeof(rv->name));
252         BLI_addtail(&rr->views, rv);
253       }
254     }
255   }
256
257   if (!(is_multiview && BKE_scene_multiview_is_stereo3d(rd))) {
258     oglrender->iuser.flag &= ~IMA_SHOW_STEREO;
259   }
260
261   /* will only work for non multiview correctly */
262   if (v3d) {
263     camera = BKE_camera_multiview_render(oglrender->scene, v3d->camera, "new opengl render view");
264     BKE_render_result_stamp_info(oglrender->scene, camera, rr, false);
265   }
266   else {
267     BKE_render_result_stamp_info(oglrender->scene, oglrender->scene->camera, rr, false);
268   }
269
270   RE_ReleaseResult(oglrender->re);
271 }
272
273 static void screen_opengl_render_doit(const bContext *C, OGLRender *oglrender, RenderResult *rr)
274 {
275   Depsgraph *depsgraph = CTX_data_depsgraph(C);
276   Scene *scene = oglrender->scene;
277   ARegion *ar = oglrender->ar;
278   View3D *v3d = oglrender->v3d;
279   RegionView3D *rv3d = oglrender->rv3d;
280   Object *camera = NULL;
281   int sizex = oglrender->sizex;
282   int sizey = oglrender->sizey;
283   const short view_context = (v3d != NULL);
284   bool draw_sky = (scene->r.alphamode == R_ADDSKY);
285   float *rectf = NULL;
286   const char *viewname = RE_GetActiveRenderView(oglrender->re);
287   ImBuf *ibuf_result = NULL;
288
289   if (oglrender->is_sequencer) {
290     SpaceSeq *sseq = oglrender->sseq;
291     struct bGPdata *gpd = (sseq && (sseq->flag & SEQ_SHOW_GPENCIL)) ? sseq->gpd : NULL;
292
293     /* use pre-calculated ImBuf (avoids deadlock), see: */
294     ImBuf *ibuf = oglrender->seq_data.ibufs_arr[oglrender->view_id];
295
296     if (ibuf) {
297       ImBuf *out = IMB_dupImBuf(ibuf);
298       IMB_freeImBuf(ibuf);
299       /* OpenGL render is considered to be preview and should be
300        * as fast as possible. So currently we're making sure sequencer
301        * result is always byte to simplify color management pipeline.
302        *
303        * TODO(sergey): In the case of output to float container (EXR)
304        * it actually makes sense to keep float buffer instead.
305        */
306       if (out->rect_float != NULL) {
307         IMB_rect_from_float(out);
308         imb_freerectfloatImBuf(out);
309       }
310       BLI_assert((oglrender->sizex == ibuf->x) && (oglrender->sizey == ibuf->y));
311       RE_render_result_rect_from_ibuf(rr, &scene->r, out, oglrender->view_id);
312       IMB_freeImBuf(out);
313     }
314     else if (gpd) {
315       /* If there are no strips, Grease Pencil still needs a buffer to draw on */
316       ImBuf *out = IMB_allocImBuf(oglrender->sizex, oglrender->sizey, 32, IB_rect);
317       RE_render_result_rect_from_ibuf(rr, &scene->r, out, oglrender->view_id);
318       IMB_freeImBuf(out);
319     }
320
321     if (gpd) {
322       int i;
323       unsigned char *gp_rect;
324       unsigned char *render_rect =
325           (unsigned char *)RE_RenderViewGetById(rr, oglrender->view_id)->rect32;
326
327       DRW_opengl_context_enable();
328       GPU_offscreen_bind(oglrender->ofs, true);
329
330       GPU_clear_color(0.0f, 0.0f, 0.0f, 0.0f);
331       GPU_clear(GPU_COLOR_BIT | GPU_DEPTH_BIT);
332
333       wmOrtho2(0, sizex, 0, sizey);
334       GPU_matrix_translate_2f(sizex / 2, sizey / 2);
335
336       G.f |= G_FLAG_RENDER_VIEWPORT;
337       ED_annotation_draw_ex(scene, gpd, sizex, sizey, scene->r.cfra, SPACE_SEQ);
338       G.f &= ~G_FLAG_RENDER_VIEWPORT;
339
340       gp_rect = MEM_mallocN(sizex * sizey * sizeof(unsigned char) * 4, "offscreen rect");
341       GPU_offscreen_read_pixels(oglrender->ofs, GL_UNSIGNED_BYTE, gp_rect);
342
343       for (i = 0; i < sizex * sizey * 4; i += 4) {
344         blend_color_mix_byte(&render_rect[i], &render_rect[i], &gp_rect[i]);
345       }
346       GPU_offscreen_unbind(oglrender->ofs, true);
347       DRW_opengl_context_disable();
348
349       MEM_freeN(gp_rect);
350     }
351   }
352   else {
353     /* shouldnt suddenly give errors mid-render but possible */
354     char err_out[256] = "unknown";
355     ImBuf *ibuf_view;
356     const int alpha_mode = (draw_sky) ? R_ADDSKY : R_ALPHAPREMUL;
357
358     if (view_context) {
359       ibuf_view = ED_view3d_draw_offscreen_imbuf(depsgraph,
360                                                  scene,
361                                                  v3d->shading.type,
362                                                  v3d,
363                                                  ar,
364                                                  sizex,
365                                                  sizey,
366                                                  IB_rectfloat,
367                                                  alpha_mode,
368                                                  oglrender->ofs_samples,
369                                                  viewname,
370                                                  oglrender->ofs,
371                                                  err_out);
372
373       /* for stamp only */
374       if (rv3d->persp == RV3D_CAMOB && v3d->camera) {
375         camera = BKE_camera_multiview_render(oglrender->scene, v3d->camera, viewname);
376       }
377     }
378     else {
379       ibuf_view = ED_view3d_draw_offscreen_imbuf_simple(depsgraph,
380                                                         scene,
381                                                         NULL,
382                                                         OB_SOLID,
383                                                         scene->camera,
384                                                         oglrender->sizex,
385                                                         oglrender->sizey,
386                                                         IB_rectfloat,
387                                                         V3D_OFSDRAW_SHOW_ANNOTATION,
388                                                         alpha_mode,
389                                                         oglrender->ofs_samples,
390                                                         viewname,
391                                                         oglrender->ofs,
392                                                         err_out);
393       camera = scene->camera;
394     }
395
396     if (ibuf_view) {
397       ibuf_result = ibuf_view;
398       rectf = (float *)ibuf_view->rect_float;
399     }
400     else {
401       fprintf(stderr, "%s: failed to get buffer, %s\n", __func__, err_out);
402     }
403   }
404
405   if (ibuf_result != NULL) {
406     if ((scene->r.stamp & R_STAMP_ALL) && (scene->r.stamp & R_STAMP_DRAW)) {
407       BKE_image_stamp_buf(scene, camera, NULL, NULL, rectf, rr->rectx, rr->recty, 4);
408     }
409     RE_render_result_rect_from_ibuf(rr, &scene->r, ibuf_result, oglrender->view_id);
410     IMB_freeImBuf(ibuf_result);
411   }
412 }
413
414 static void screen_opengl_render_write(OGLRender *oglrender)
415 {
416   Scene *scene = oglrender->scene;
417   RenderResult *rr;
418   bool ok;
419   char name[FILE_MAX];
420
421   rr = RE_AcquireResultRead(oglrender->re);
422
423   BKE_image_path_from_imformat(name,
424                                scene->r.pic,
425                                BKE_main_blendfile_path(oglrender->bmain),
426                                scene->r.cfra,
427                                &scene->r.im_format,
428                                (scene->r.scemode & R_EXTENSION) != 0,
429                                false,
430                                NULL);
431
432   /* write images as individual images or stereo */
433   BKE_render_result_stamp_info(scene, scene->camera, rr, false);
434   ok = RE_WriteRenderViewsImage(oglrender->reports, rr, scene, false, name);
435
436   RE_ReleaseResultImage(oglrender->re);
437
438   if (ok) {
439     printf("OpenGL Render written to '%s'\n", name);
440   }
441   else {
442     printf("OpenGL Render failed to write '%s'\n", name);
443   }
444 }
445
446 static void UNUSED_FUNCTION(addAlphaOverFloat)(float dest[4], const float source[4])
447 {
448   /* d = s + (1-alpha_s)d*/
449   float mul;
450
451   mul = 1.0f - source[3];
452
453   dest[0] = (mul * dest[0]) + source[0];
454   dest[1] = (mul * dest[1]) + source[1];
455   dest[2] = (mul * dest[2]) + source[2];
456   dest[3] = (mul * dest[3]) + source[3];
457 }
458
459 static void screen_opengl_render_apply(const bContext *C, OGLRender *oglrender)
460 {
461   RenderResult *rr;
462   RenderView *rv;
463   int view_id;
464   ImBuf *ibuf;
465   void *lock;
466
467   if (oglrender->is_sequencer) {
468     Scene *scene = oglrender->scene;
469
470     SeqRenderData context;
471     SpaceSeq *sseq = oglrender->sseq;
472     int chanshown = sseq ? sseq->chanshown : 0;
473
474     BKE_sequencer_new_render_data(oglrender->bmain,
475                                   oglrender->depsgraph,
476                                   scene,
477                                   oglrender->sizex,
478                                   oglrender->sizey,
479                                   100.0f,
480                                   false,
481                                   &context);
482
483     for (view_id = 0; view_id < oglrender->views_len; view_id++) {
484       context.view_id = view_id;
485       context.gpu_offscreen = oglrender->ofs;
486       oglrender->seq_data.ibufs_arr[view_id] = BKE_sequencer_give_ibuf(&context, CFRA, chanshown);
487     }
488   }
489
490   rr = RE_AcquireResultRead(oglrender->re);
491   for (rv = rr->views.first, view_id = 0; rv; rv = rv->next, view_id++) {
492     BLI_assert(view_id < oglrender->views_len);
493     RE_SetActiveRenderView(oglrender->re, rv->name);
494     oglrender->view_id = view_id;
495     /* render composite */
496     screen_opengl_render_doit(C, oglrender, rr);
497   }
498
499   RE_ReleaseResult(oglrender->re);
500
501   ibuf = BKE_image_acquire_ibuf(oglrender->ima, &oglrender->iuser, &lock);
502   if (ibuf) {
503     ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID;
504   }
505   BKE_image_release_ibuf(oglrender->ima, ibuf, lock);
506
507   if (oglrender->write_still) {
508     screen_opengl_render_write(oglrender);
509   }
510 }
511
512 static bool screen_opengl_render_init(bContext *C, wmOperator *op)
513 {
514   /* new render clears all callbacks */
515   wmWindowManager *wm = CTX_wm_manager(C);
516   wmWindow *win = CTX_wm_window(C);
517   WorkSpace *workspace = CTX_wm_workspace(C);
518
519   Scene *scene = CTX_data_scene(C);
520   ScrArea *prevsa = CTX_wm_area(C);
521   ARegion *prevar = CTX_wm_region(C);
522   GPUOffScreen *ofs;
523   OGLRender *oglrender;
524   int sizex, sizey;
525   bool is_view_context = RNA_boolean_get(op->ptr, "view_context");
526   const bool is_animation = RNA_boolean_get(op->ptr, "animation");
527   const bool is_sequencer = RNA_boolean_get(op->ptr, "sequencer");
528   const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
529   const int samples = U.ogl_multisamples;
530   char err_out[256] = "unknown";
531
532   if (G.background) {
533     BKE_report(
534         op->reports, RPT_ERROR, "Cannot use OpenGL render in background mode (no opengl context)");
535     return false;
536   }
537
538   /* only one render job at a time */
539   if (WM_jobs_test(wm, scene, WM_JOB_TYPE_RENDER)) {
540     return false;
541   }
542
543   if (is_sequencer) {
544     is_view_context = false;
545   }
546   else {
547     /* ensure we have a 3d view */
548     if (!ED_view3d_context_activate(C)) {
549       RNA_boolean_set(op->ptr, "view_context", false);
550       is_view_context = false;
551     }
552
553     if (!is_view_context && scene->camera == NULL) {
554       BKE_report(op->reports, RPT_ERROR, "Scene has no camera");
555       return false;
556     }
557   }
558
559   if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
560     BKE_report(
561         op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
562     return false;
563   }
564
565   /* stop all running jobs, except screen one. currently previews frustrate Render */
566   WM_jobs_kill_all_except(wm, CTX_wm_screen(C));
567
568   /* create offscreen buffer */
569   sizex = (scene->r.size * scene->r.xsch) / 100;
570   sizey = (scene->r.size * scene->r.ysch) / 100;
571
572   /* corrects render size with actual size, not every card supports non-power-of-two dimensions */
573   DRW_opengl_context_enable(); /* Offscreen creation needs to be done in DRW context. */
574   ofs = GPU_offscreen_create(sizex, sizey, samples, true, true, err_out);
575   DRW_opengl_context_disable();
576
577   if (!ofs) {
578     BKE_reportf(op->reports, RPT_ERROR, "Failed to create OpenGL off-screen buffer, %s", err_out);
579     return false;
580   }
581
582   /* allocate opengl render */
583   oglrender = MEM_callocN(sizeof(OGLRender), "OGLRender");
584   op->customdata = oglrender;
585
586   oglrender->ofs = ofs;
587   oglrender->sizex = sizex;
588   oglrender->sizey = sizey;
589   oglrender->bmain = CTX_data_main(C);
590   oglrender->scene = scene;
591   oglrender->workspace = workspace;
592   oglrender->view_layer = CTX_data_view_layer(C);
593   oglrender->depsgraph = CTX_data_depsgraph(C);
594   oglrender->cfrao = scene->r.cfra;
595   oglrender->ofs_samples = samples;
596
597   oglrender->write_still = is_write_still && !is_animation;
598   oglrender->is_animation = is_animation;
599
600   oglrender->views_len = BKE_scene_multiview_num_views_get(&scene->r);
601
602   oglrender->is_sequencer = is_sequencer;
603   if (is_sequencer) {
604     oglrender->sseq = CTX_wm_space_seq(C);
605     ImBuf **ibufs_arr = MEM_callocN(sizeof(*ibufs_arr) * oglrender->views_len, __func__);
606     oglrender->seq_data.ibufs_arr = ibufs_arr;
607   }
608
609   oglrender->prevsa = prevsa;
610   oglrender->prevar = prevar;
611
612   if (is_view_context) {
613     /* so quad view renders camera */
614     ED_view3d_context_user_region(C, &oglrender->v3d, &oglrender->ar);
615
616     oglrender->rv3d = oglrender->ar->regiondata;
617
618     /* MUST be cleared on exit */
619     memset(&oglrender->scene->customdata_mask_modal,
620            0,
621            sizeof(oglrender->scene->customdata_mask_modal));
622     ED_view3d_datamask(
623         C, oglrender->scene, oglrender->v3d, &oglrender->scene->customdata_mask_modal);
624
625     /* apply immediately in case we're rendering from a script,
626      * running notifiers again will overwrite */
627     CustomData_MeshMasks_update(&oglrender->scene->customdata_mask,
628                                 &oglrender->scene->customdata_mask_modal);
629   }
630
631   /* create render */
632   oglrender->re = RE_NewSceneRender(scene);
633
634   /* create image and image user */
635   oglrender->ima = BKE_image_verify_viewer(oglrender->bmain, IMA_TYPE_R_RESULT, "Render Result");
636   BKE_image_signal(oglrender->bmain, oglrender->ima, NULL, IMA_SIGNAL_FREE);
637   BKE_image_backup_render(oglrender->scene, oglrender->ima, true);
638
639   oglrender->iuser.scene = scene;
640   oglrender->iuser.ok = 1;
641
642   /* create render result */
643   RE_InitState(oglrender->re, NULL, &scene->r, &scene->view_layers, NULL, sizex, sizey, NULL);
644
645   /* create render views */
646   screen_opengl_views_setup(oglrender);
647
648   /* wm vars */
649   oglrender->wm = wm;
650   oglrender->win = win;
651
652   oglrender->totvideos = 0;
653   oglrender->mh = NULL;
654   oglrender->movie_ctx_arr = NULL;
655
656   if (is_animation) {
657     TaskScheduler *task_scheduler = BLI_task_scheduler_get();
658     if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
659       task_scheduler = BLI_task_scheduler_create(1);
660       oglrender->task_scheduler = task_scheduler;
661       oglrender->task_pool = BLI_task_pool_create_background(task_scheduler, oglrender);
662     }
663     else {
664       oglrender->task_scheduler = NULL;
665       oglrender->task_pool = BLI_task_pool_create(task_scheduler, oglrender);
666     }
667     oglrender->pool_ok = true;
668     BLI_spin_init(&oglrender->reports_lock);
669   }
670   else {
671     oglrender->task_scheduler = NULL;
672     oglrender->task_pool = NULL;
673   }
674   oglrender->num_scheduled_frames = 0;
675   BLI_mutex_init(&oglrender->task_mutex);
676   BLI_condition_init(&oglrender->task_condition);
677
678 #ifdef DEBUG_TIME
679   oglrender->time_start = PIL_check_seconds_timer();
680 #endif
681
682   return true;
683 }
684
685 static void screen_opengl_render_end(bContext *C, OGLRender *oglrender)
686 {
687   Main *bmain = CTX_data_main(C);
688   Scene *scene = oglrender->scene;
689   int i;
690
691   if (oglrender->is_animation) {
692     /* Trickery part for movie output:
693      *
694      * We MUST write frames in an exact order, so we only let background
695      * thread to work on that, and main thread is simply waits for that
696      * thread to do all the dirty work.
697      *
698      * After this loop is done work_and_wait() will have nothing to do,
699      * so we don't run into wrong order of frames written to the stream.
700      */
701     if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
702       BLI_mutex_lock(&oglrender->task_mutex);
703       while (oglrender->num_scheduled_frames > 0) {
704         BLI_condition_wait(&oglrender->task_condition, &oglrender->task_mutex);
705       }
706       BLI_mutex_unlock(&oglrender->task_mutex);
707     }
708     BLI_task_pool_work_and_wait(oglrender->task_pool);
709     BLI_task_pool_free(oglrender->task_pool);
710     /* Depending on various things we might or might not use global scheduler. */
711     if (oglrender->task_scheduler != NULL) {
712       BLI_task_scheduler_free(oglrender->task_scheduler);
713     }
714     BLI_spin_end(&oglrender->reports_lock);
715   }
716   BLI_mutex_end(&oglrender->task_mutex);
717   BLI_condition_end(&oglrender->task_condition);
718
719 #ifdef DEBUG_TIME
720   printf("Total render time: %f\n", PIL_check_seconds_timer() - oglrender->time_start);
721 #endif
722
723   if (oglrender->mh) {
724     if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
725       for (i = 0; i < oglrender->totvideos; i++) {
726         oglrender->mh->end_movie(oglrender->movie_ctx_arr[i]);
727         oglrender->mh->context_free(oglrender->movie_ctx_arr[i]);
728       }
729     }
730
731     if (oglrender->movie_ctx_arr) {
732       MEM_freeN(oglrender->movie_ctx_arr);
733     }
734   }
735
736   if (oglrender->timer) { /* exec will not have a timer */
737     Depsgraph *depsgraph = oglrender->depsgraph;
738     scene->r.cfra = oglrender->cfrao;
739     BKE_scene_graph_update_for_newframe(depsgraph, bmain);
740
741     WM_event_remove_timer(oglrender->wm, oglrender->win, oglrender->timer);
742   }
743
744   WM_cursor_modal_restore(oglrender->win);
745
746   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene);
747
748   DRW_opengl_context_enable();
749   GPU_offscreen_free(oglrender->ofs);
750   DRW_opengl_context_disable();
751
752   if (oglrender->is_sequencer) {
753     MEM_freeN(oglrender->seq_data.ibufs_arr);
754   }
755
756   memset(&oglrender->scene->customdata_mask_modal,
757          0,
758          sizeof(oglrender->scene->customdata_mask_modal));
759
760   CTX_wm_area_set(C, oglrender->prevsa);
761   CTX_wm_region_set(C, oglrender->prevar);
762
763   MEM_freeN(oglrender);
764 }
765
766 static void screen_opengl_render_cancel(bContext *C, wmOperator *op)
767 {
768   screen_opengl_render_end(C, op->customdata);
769 }
770
771 /* share between invoke and exec */
772 static bool screen_opengl_render_anim_initialize(bContext *C, wmOperator *op)
773 {
774   /* initialize animation */
775   OGLRender *oglrender;
776   Scene *scene;
777
778   oglrender = op->customdata;
779   scene = oglrender->scene;
780   oglrender->totvideos = BKE_scene_multiview_num_videos_get(&scene->r);
781
782   oglrender->reports = op->reports;
783
784   if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
785     size_t width, height;
786     int i;
787
788     BKE_scene_multiview_videos_dimensions_get(
789         &scene->r, oglrender->sizex, oglrender->sizey, &width, &height);
790     oglrender->mh = BKE_movie_handle_get(scene->r.im_format.imtype);
791
792     if (oglrender->mh == NULL) {
793       BKE_report(oglrender->reports, RPT_ERROR, "Movie format unsupported");
794       screen_opengl_render_end(C, oglrender);
795       return false;
796     }
797
798     oglrender->movie_ctx_arr = MEM_mallocN(sizeof(void *) * oglrender->totvideos, "Movies");
799
800     for (i = 0; i < oglrender->totvideos; i++) {
801       const char *suffix = BKE_scene_multiview_view_id_suffix_get(&scene->r, i);
802
803       oglrender->movie_ctx_arr[i] = oglrender->mh->context_create();
804       if (!oglrender->mh->start_movie(oglrender->movie_ctx_arr[i],
805                                       scene,
806                                       &scene->r,
807                                       oglrender->sizex,
808                                       oglrender->sizey,
809                                       oglrender->reports,
810                                       PRVRANGEON != 0,
811                                       suffix)) {
812         screen_opengl_render_end(C, oglrender);
813         return false;
814       }
815     }
816   }
817
818   oglrender->cfrao = scene->r.cfra;
819   oglrender->nfra = PSFRA;
820   scene->r.cfra = PSFRA;
821
822   return true;
823 }
824
825 typedef struct WriteTaskData {
826   RenderResult *rr;
827   Scene tmp_scene;
828 } WriteTaskData;
829
830 static void write_result_func(TaskPool *__restrict pool, void *task_data_v, int UNUSED(thread_id))
831 {
832   OGLRender *oglrender = (OGLRender *)BLI_task_pool_userdata(pool);
833   WriteTaskData *task_data = (WriteTaskData *)task_data_v;
834   Scene *scene = &task_data->tmp_scene;
835   RenderResult *rr = task_data->rr;
836   const bool is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);
837   const int cfra = scene->r.cfra;
838   bool ok;
839   /* Don't attempt to write if we've got an error. */
840   if (!oglrender->pool_ok) {
841     RE_FreeRenderResult(rr);
842     BLI_mutex_lock(&oglrender->task_mutex);
843     oglrender->num_scheduled_frames--;
844     BLI_condition_notify_all(&oglrender->task_condition);
845     BLI_mutex_unlock(&oglrender->task_mutex);
846     return;
847   }
848   /* Construct local thread0safe copy of reports structure which we can
849    * safely pass to the underlying functions.
850    */
851   ReportList reports;
852   BKE_reports_init(&reports, oglrender->reports->flag & ~RPT_PRINT);
853   /* Do actual save logic here, depending on the file format.
854    *
855    * NOTE: We have to construct temporary scene with proper scene->r.cfra.
856    * This is because underlying calls do not use r.cfra but use scene
857    * for that.
858    */
859   if (is_movie) {
860     ok = RE_WriteRenderViewsMovie(&reports,
861                                   rr,
862                                   scene,
863                                   &scene->r,
864                                   oglrender->mh,
865                                   oglrender->movie_ctx_arr,
866                                   oglrender->totvideos,
867                                   PRVRANGEON != 0);
868   }
869   else {
870     /* TODO(sergey): We can in theory save some CPU ticks here because we
871      * calculate file name again here.
872      */
873     char name[FILE_MAX];
874     BKE_image_path_from_imformat(name,
875                                  scene->r.pic,
876                                  BKE_main_blendfile_path(oglrender->bmain),
877                                  cfra,
878                                  &scene->r.im_format,
879                                  (scene->r.scemode & R_EXTENSION) != 0,
880                                  true,
881                                  NULL);
882
883     BKE_render_result_stamp_info(scene, scene->camera, rr, false);
884     ok = RE_WriteRenderViewsImage(NULL, rr, scene, true, name);
885     if (!ok) {
886       BKE_reportf(&reports, RPT_ERROR, "Write error: cannot save %s", name);
887     }
888   }
889   if (reports.list.first != NULL) {
890     BLI_spin_lock(&oglrender->reports_lock);
891     for (Report *report = reports.list.first; report != NULL; report = report->next) {
892       BKE_report(oglrender->reports, report->type, report->message);
893     }
894     BLI_spin_unlock(&oglrender->reports_lock);
895   }
896   if (!ok) {
897     oglrender->pool_ok = false;
898   }
899   RE_FreeRenderResult(rr);
900   BLI_mutex_lock(&oglrender->task_mutex);
901   oglrender->num_scheduled_frames--;
902   BLI_condition_notify_all(&oglrender->task_condition);
903   BLI_mutex_unlock(&oglrender->task_mutex);
904 }
905
906 static bool schedule_write_result(OGLRender *oglrender, RenderResult *rr)
907 {
908   if (!oglrender->pool_ok) {
909     RE_FreeRenderResult(rr);
910     return false;
911   }
912   Scene *scene = oglrender->scene;
913   WriteTaskData *task_data = MEM_mallocN(sizeof(WriteTaskData), "write task data");
914   task_data->rr = rr;
915   task_data->tmp_scene = *scene;
916   BLI_mutex_lock(&oglrender->task_mutex);
917   oglrender->num_scheduled_frames++;
918   if (oglrender->num_scheduled_frames > MAX_SCHEDULED_FRAMES) {
919     BLI_condition_wait(&oglrender->task_condition, &oglrender->task_mutex);
920   }
921   BLI_mutex_unlock(&oglrender->task_mutex);
922   BLI_task_pool_push(oglrender->task_pool, write_result_func, task_data, true, TASK_PRIORITY_LOW);
923   return true;
924 }
925
926 static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op)
927 {
928   Main *bmain = CTX_data_main(C);
929   OGLRender *oglrender = op->customdata;
930   Scene *scene = oglrender->scene;
931   Depsgraph *depsgraph = oglrender->depsgraph;
932   char name[FILE_MAX];
933   bool ok = false;
934   const bool view_context = (oglrender->v3d != NULL);
935   bool is_movie;
936   RenderResult *rr;
937
938   /* go to next frame */
939   if (CFRA < oglrender->nfra) {
940     CFRA++;
941   }
942   while (CFRA < oglrender->nfra) {
943     BKE_scene_graph_update_for_newframe(depsgraph, bmain);
944     CFRA++;
945   }
946
947   is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);
948
949   if (!is_movie) {
950     BKE_image_path_from_imformat(name,
951                                  scene->r.pic,
952                                  BKE_main_blendfile_path(oglrender->bmain),
953                                  scene->r.cfra,
954                                  &scene->r.im_format,
955                                  (scene->r.scemode & R_EXTENSION) != 0,
956                                  true,
957                                  NULL);
958
959     if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(name)) {
960       BLI_spin_lock(&oglrender->reports_lock);
961       BKE_reportf(op->reports, RPT_INFO, "Skipping existing frame \"%s\"", name);
962       BLI_spin_unlock(&oglrender->reports_lock);
963       ok = true;
964       goto finally;
965     }
966   }
967
968   WM_cursor_time(oglrender->win, scene->r.cfra);
969
970   BKE_scene_graph_update_for_newframe(depsgraph, bmain);
971
972   if (view_context) {
973     if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera &&
974         oglrender->v3d->scenelock) {
975       /* since BKE_scene_graph_update_for_newframe() is used rather
976        * then ED_update_for_newframe() the camera needs to be set */
977       if (BKE_scene_camera_switch_update(scene)) {
978         oglrender->v3d->camera = scene->camera;
979       }
980     }
981   }
982   else {
983     BKE_scene_camera_switch_update(scene);
984   }
985
986   /* render into offscreen buffer */
987   screen_opengl_render_apply(C, oglrender);
988
989   /* save to disk */
990   rr = RE_AcquireResultRead(oglrender->re);
991   RenderResult *new_rr = RE_DuplicateRenderResult(rr);
992   RE_ReleaseResult(oglrender->re);
993
994   ok = schedule_write_result(oglrender, new_rr);
995
996 finally: /* Step the frame and bail early if needed */
997
998   /* go to next frame */
999   oglrender->nfra += scene->r.frame_step;
1000
1001   /* stop at the end or on error */
1002   if (CFRA >= PEFRA || !ok) {
1003     screen_opengl_render_end(C, op->customdata);
1004     return 0;
1005   }
1006
1007   return 1;
1008 }
1009
1010 static int screen_opengl_render_modal(bContext *C, wmOperator *op, const wmEvent *event)
1011 {
1012   OGLRender *oglrender = op->customdata;
1013   const bool anim = RNA_boolean_get(op->ptr, "animation");
1014   bool ret;
1015
1016   switch (event->type) {
1017     case ESCKEY:
1018       /* cancel */
1019       oglrender->pool_ok = false; /* Flag pool for cancel. */
1020       screen_opengl_render_end(C, op->customdata);
1021       return OPERATOR_FINISHED;
1022     case TIMER:
1023       /* render frame? */
1024       if (oglrender->timer == event->customdata) {
1025         break;
1026       }
1027       ATTR_FALLTHROUGH;
1028     default:
1029       /* nothing to do */
1030       return OPERATOR_RUNNING_MODAL;
1031   }
1032
1033   /* run first because screen_opengl_render_anim_step can free oglrender */
1034   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene);
1035
1036   if (anim == 0) {
1037     screen_opengl_render_apply(C, op->customdata);
1038     screen_opengl_render_end(C, op->customdata);
1039     return OPERATOR_FINISHED;
1040   }
1041   else {
1042     ret = screen_opengl_render_anim_step(C, op);
1043   }
1044
1045   /* stop at the end or on error */
1046   if (ret == false) {
1047     return OPERATOR_FINISHED;
1048   }
1049
1050   return OPERATOR_RUNNING_MODAL;
1051 }
1052
1053 static int screen_opengl_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1054 {
1055   OGLRender *oglrender;
1056   const bool anim = RNA_boolean_get(op->ptr, "animation");
1057
1058   if (!screen_opengl_render_init(C, op)) {
1059     return OPERATOR_CANCELLED;
1060   }
1061
1062   if (anim) {
1063     if (!screen_opengl_render_anim_initialize(C, op)) {
1064       return OPERATOR_CANCELLED;
1065     }
1066   }
1067
1068   oglrender = op->customdata;
1069   render_view_open(C, event->x, event->y, op->reports);
1070
1071   /* view may be changed above (R_OUTPUT_WINDOW) */
1072   oglrender->win = CTX_wm_window(C);
1073
1074   WM_event_add_modal_handler(C, op);
1075   oglrender->timer = WM_event_add_timer(oglrender->wm, oglrender->win, TIMER, 0.01f);
1076
1077   return OPERATOR_RUNNING_MODAL;
1078 }
1079
1080 /* executes blocking render */
1081 static int screen_opengl_render_exec(bContext *C, wmOperator *op)
1082 {
1083   const bool is_animation = RNA_boolean_get(op->ptr, "animation");
1084
1085   if (!screen_opengl_render_init(C, op)) {
1086     return OPERATOR_CANCELLED;
1087   }
1088
1089   if (!is_animation) { /* same as invoke */
1090     /* render image */
1091     screen_opengl_render_apply(C, op->customdata);
1092     screen_opengl_render_end(C, op->customdata);
1093
1094     return OPERATOR_FINISHED;
1095   }
1096   else {
1097     bool ret = true;
1098
1099     if (!screen_opengl_render_anim_initialize(C, op)) {
1100       return OPERATOR_CANCELLED;
1101     }
1102
1103     while (ret) {
1104       ret = screen_opengl_render_anim_step(C, op);
1105     }
1106   }
1107
1108   /* no redraw needed, we leave state as we entered it */
1109   //  ED_update_for_newframe(C);
1110   WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, CTX_data_scene(C));
1111
1112   return OPERATOR_FINISHED;
1113 }
1114
1115 void RENDER_OT_opengl(wmOperatorType *ot)
1116 {
1117   PropertyRNA *prop;
1118
1119   /* identifiers */
1120   ot->name = "Viewport Render";
1121   ot->description = "Take a snapshot of the active viewport";
1122   ot->idname = "RENDER_OT_opengl";
1123
1124   /* api callbacks */
1125   ot->invoke = screen_opengl_render_invoke;
1126   ot->exec = screen_opengl_render_exec; /* blocking */
1127   ot->modal = screen_opengl_render_modal;
1128   ot->cancel = screen_opengl_render_cancel;
1129
1130   ot->poll = ED_operator_screenactive;
1131
1132   prop = RNA_def_boolean(ot->srna,
1133                          "animation",
1134                          0,
1135                          "Animation",
1136                          "Render files from the animation range of this scene");
1137   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1138   prop = RNA_def_boolean(
1139       ot->srna, "sequencer", 0, "Sequencer", "Render using the sequencer's OpenGL display");
1140   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1141   prop = RNA_def_boolean(
1142       ot->srna,
1143       "write_still",
1144       0,
1145       "Write Image",
1146       "Save rendered the image to the output path (used only when animation is disabled)");
1147   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1148   prop = RNA_def_boolean(ot->srna,
1149                          "view_context",
1150                          1,
1151                          "View Context",
1152                          "Use the current 3D view for rendering, else use scene settings");
1153   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1154 }
1155
1156 /* function for getting an opengl buffer from a View3D, used by sequencer */
1157 // extern void *sequencer_view3d_cb;