diff options
Diffstat (limited to 'source/blender/editors/render/render_opengl.c')
| -rw-r--r-- | source/blender/editors/render/render_opengl.c | 1879 |
1 files changed, 959 insertions, 920 deletions
diff --git a/source/blender/editors/render/render_opengl.c b/source/blender/editors/render/render_opengl.c index 3fdc34bd9c9..6862881de59 100644 --- a/source/blender/editors/render/render_opengl.c +++ b/source/blender/editors/render/render_opengl.c @@ -21,7 +21,6 @@ * \ingroup edrend */ - #include <math.h> #include <string.h> #include <stddef.h> @@ -88,1039 +87,1079 @@ #define MAX_SCHEDULED_FRAMES 8 typedef struct OGLRender { - Main *bmain; - Render *re; - Scene *scene; - WorkSpace *workspace; - ViewLayer *view_layer; - Depsgraph *depsgraph; - - View3D *v3d; - RegionView3D *rv3d; - ARegion *ar; - - ScrArea *prevsa; - ARegion *prevar; - - int views_len; /* multi-view views */ - - bool is_sequencer; - SpaceSeq *sseq; - struct { - ImBuf **ibufs_arr; - } seq_data; - - - Image *ima; - ImageUser iuser; - - GPUOffScreen *ofs; - int ofs_samples; - bool ofs_full_samples; - int sizex, sizey; - int write_still; - - ReportList *reports; - bMovieHandle *mh; - int cfrao, nfra; - - int totvideos; - - /* quick lookup */ - int view_id; - - /* wm vars for timer and progress cursor */ - wmWindowManager *wm; - wmWindow *win; - - wmTimer *timer; /* use to check if running modal or not (invoke'd or exec'd)*/ - void **movie_ctx_arr; - - TaskScheduler *task_scheduler; - TaskPool *task_pool; - bool pool_ok; - bool is_animation; - SpinLock reports_lock; - unsigned int num_scheduled_frames; - ThreadMutex task_mutex; - ThreadCondition task_condition; + Main *bmain; + Render *re; + Scene *scene; + WorkSpace *workspace; + ViewLayer *view_layer; + Depsgraph *depsgraph; + + View3D *v3d; + RegionView3D *rv3d; + ARegion *ar; + + ScrArea *prevsa; + ARegion *prevar; + + int views_len; /* multi-view views */ + + bool is_sequencer; + SpaceSeq *sseq; + struct { + ImBuf **ibufs_arr; + } seq_data; + + Image *ima; + ImageUser iuser; + + GPUOffScreen *ofs; + int ofs_samples; + bool ofs_full_samples; + int sizex, sizey; + int write_still; + + ReportList *reports; + bMovieHandle *mh; + int cfrao, nfra; + + int totvideos; + + /* quick lookup */ + int view_id; + + /* wm vars for timer and progress cursor */ + wmWindowManager *wm; + wmWindow *win; + + wmTimer *timer; /* use to check if running modal or not (invoke'd or exec'd)*/ + void **movie_ctx_arr; + + TaskScheduler *task_scheduler; + TaskPool *task_pool; + bool pool_ok; + bool is_animation; + SpinLock reports_lock; + unsigned int num_scheduled_frames; + ThreadMutex task_mutex; + ThreadCondition task_condition; #ifdef DEBUG_TIME - double time_start; + double time_start; #endif } OGLRender; static bool screen_opengl_is_multiview(OGLRender *oglrender) { - View3D *v3d = oglrender->v3d; - RegionView3D *rv3d = oglrender->rv3d; - RenderData *rd = &oglrender->scene->r; + View3D *v3d = oglrender->v3d; + RegionView3D *rv3d = oglrender->rv3d; + RenderData *rd = &oglrender->scene->r; - if ((rd == NULL) || ((v3d != NULL) && (rv3d == NULL))) - return false; + if ((rd == NULL) || ((v3d != NULL) && (rv3d == NULL))) + return false; - return (rd->scemode & R_MULTIVIEW) && ((v3d == NULL) || (rv3d->persp == RV3D_CAMOB && v3d->camera)); + return (rd->scemode & R_MULTIVIEW) && + ((v3d == NULL) || (rv3d->persp == RV3D_CAMOB && v3d->camera)); } static void screen_opengl_views_setup(OGLRender *oglrender) { - RenderResult *rr; - RenderView *rv; - SceneRenderView *srv; - bool is_multiview; - Object *camera; - View3D *v3d = oglrender->v3d; - - RenderData *rd = &oglrender->scene->r; - - rr = RE_AcquireResultWrite(oglrender->re); - - is_multiview = screen_opengl_is_multiview(oglrender); - - if (!is_multiview) { - /* we only have one view when multiview is off */ - rv = rr->views.first; - - if (rv == NULL) { - rv = MEM_callocN(sizeof(RenderView), "new opengl render view"); - BLI_addtail(&rr->views, rv); - } - - while (rv->next) { - RenderView *rv_del = rv->next; - BLI_remlink(&rr->views, rv_del); - - if (rv_del->rectf) - MEM_freeN(rv_del->rectf); - - if (rv_del->rectz) - MEM_freeN(rv_del->rectz); - - if (rv_del->rect32) - MEM_freeN(rv_del->rect32); - - MEM_freeN(rv_del); - } - } - else { - if (v3d) { - RE_SetOverrideCamera(oglrender->re, V3D_CAMERA_SCENE(oglrender->scene, v3d)); - } - - /* remove all the views that are not needed */ - rv = rr->views.last; - while (rv) { - srv = BLI_findstring(&rd->views, rv->name, offsetof(SceneRenderView, name)); - if (BKE_scene_multiview_is_render_view_active(rd, srv)) { - rv = rv->prev; - } - else { - RenderView *rv_del = rv; - rv = rv_del->prev; - - BLI_remlink(&rr->views, rv_del); - - if (rv_del->rectf) - MEM_freeN(rv_del->rectf); - - if (rv_del->rectz) - MEM_freeN(rv_del->rectz); - - if (rv_del->rect32) - MEM_freeN(rv_del->rect32); - - MEM_freeN(rv_del); - } - } - - /* create all the views that are needed */ - for (srv = rd->views.first; srv; srv = srv->next) { - if (BKE_scene_multiview_is_render_view_active(rd, srv) == false) - continue; - - rv = BLI_findstring(&rr->views, srv->name, offsetof(SceneRenderView, name)); - - if (rv == NULL) { - rv = MEM_callocN(sizeof(RenderView), "new opengl render view"); - BLI_strncpy(rv->name, srv->name, sizeof(rv->name)); - BLI_addtail(&rr->views, rv); - } - } - } - - if (!(is_multiview && BKE_scene_multiview_is_stereo3d(rd))) - oglrender->iuser.flag &= ~IMA_SHOW_STEREO; - - /* will only work for non multiview correctly */ - if (v3d) { - camera = BKE_camera_multiview_render(oglrender->scene, v3d->camera, "new opengl render view"); - BKE_render_result_stamp_info(oglrender->scene, camera, rr, false); - } - else { - BKE_render_result_stamp_info(oglrender->scene, oglrender->scene->camera, rr, false); - } - - RE_ReleaseResult(oglrender->re); + RenderResult *rr; + RenderView *rv; + SceneRenderView *srv; + bool is_multiview; + Object *camera; + View3D *v3d = oglrender->v3d; + + RenderData *rd = &oglrender->scene->r; + + rr = RE_AcquireResultWrite(oglrender->re); + + is_multiview = screen_opengl_is_multiview(oglrender); + + if (!is_multiview) { + /* we only have one view when multiview is off */ + rv = rr->views.first; + + if (rv == NULL) { + rv = MEM_callocN(sizeof(RenderView), "new opengl render view"); + BLI_addtail(&rr->views, rv); + } + + while (rv->next) { + RenderView *rv_del = rv->next; + BLI_remlink(&rr->views, rv_del); + + if (rv_del->rectf) + MEM_freeN(rv_del->rectf); + + if (rv_del->rectz) + MEM_freeN(rv_del->rectz); + + if (rv_del->rect32) + MEM_freeN(rv_del->rect32); + + MEM_freeN(rv_del); + } + } + else { + if (v3d) { + RE_SetOverrideCamera(oglrender->re, V3D_CAMERA_SCENE(oglrender->scene, v3d)); + } + + /* remove all the views that are not needed */ + rv = rr->views.last; + while (rv) { + srv = BLI_findstring(&rd->views, rv->name, offsetof(SceneRenderView, name)); + if (BKE_scene_multiview_is_render_view_active(rd, srv)) { + rv = rv->prev; + } + else { + RenderView *rv_del = rv; + rv = rv_del->prev; + + BLI_remlink(&rr->views, rv_del); + + if (rv_del->rectf) + MEM_freeN(rv_del->rectf); + + if (rv_del->rectz) + MEM_freeN(rv_del->rectz); + + if (rv_del->rect32) + MEM_freeN(rv_del->rect32); + + MEM_freeN(rv_del); + } + } + + /* create all the views that are needed */ + for (srv = rd->views.first; srv; srv = srv->next) { + if (BKE_scene_multiview_is_render_view_active(rd, srv) == false) + continue; + + rv = BLI_findstring(&rr->views, srv->name, offsetof(SceneRenderView, name)); + + if (rv == NULL) { + rv = MEM_callocN(sizeof(RenderView), "new opengl render view"); + BLI_strncpy(rv->name, srv->name, sizeof(rv->name)); + BLI_addtail(&rr->views, rv); + } + } + } + + if (!(is_multiview && BKE_scene_multiview_is_stereo3d(rd))) + oglrender->iuser.flag &= ~IMA_SHOW_STEREO; + + /* will only work for non multiview correctly */ + if (v3d) { + camera = BKE_camera_multiview_render(oglrender->scene, v3d->camera, "new opengl render view"); + BKE_render_result_stamp_info(oglrender->scene, camera, rr, false); + } + else { + BKE_render_result_stamp_info(oglrender->scene, oglrender->scene->camera, rr, false); + } + + RE_ReleaseResult(oglrender->re); } static void screen_opengl_render_doit(const bContext *C, OGLRender *oglrender, RenderResult *rr) { - Depsgraph *depsgraph = CTX_data_depsgraph(C); - Scene *scene = oglrender->scene; - ARegion *ar = oglrender->ar; - View3D *v3d = oglrender->v3d; - RegionView3D *rv3d = oglrender->rv3d; - Object *camera = NULL; - int sizex = oglrender->sizex; - int sizey = oglrender->sizey; - const short view_context = (v3d != NULL); - bool draw_sky = (scene->r.alphamode == R_ADDSKY); - float *rectf = NULL; - const char *viewname = RE_GetActiveRenderView(oglrender->re); - ImBuf *ibuf_result = NULL; - - if (oglrender->is_sequencer) { - SpaceSeq *sseq = oglrender->sseq; - struct bGPdata *gpd = (sseq && (sseq->flag & SEQ_SHOW_GPENCIL)) ? sseq->gpd : NULL; - - /* use pre-calculated ImBuf (avoids deadlock), see: */ - ImBuf *ibuf = oglrender->seq_data.ibufs_arr[oglrender->view_id]; - - if (ibuf) { - ImBuf *out = IMB_dupImBuf(ibuf); - IMB_freeImBuf(ibuf); - /* OpenGL render is considered to be preview and should be - * as fast as possible. So currently we're making sure sequencer - * result is always byte to simplify color management pipeline. - * - * TODO(sergey): In the case of output to float container (EXR) - * it actually makes sense to keep float buffer instead. - */ - if (out->rect_float != NULL) { - IMB_rect_from_float(out); - imb_freerectfloatImBuf(out); - } - BLI_assert((oglrender->sizex == ibuf->x) && (oglrender->sizey == ibuf->y)); - RE_render_result_rect_from_ibuf(rr, &scene->r, out, oglrender->view_id); - IMB_freeImBuf(out); - } - else if (gpd) { - /* If there are no strips, Grease Pencil still needs a buffer to draw on */ - ImBuf *out = IMB_allocImBuf(oglrender->sizex, oglrender->sizey, 32, IB_rect); - RE_render_result_rect_from_ibuf(rr, &scene->r, out, oglrender->view_id); - IMB_freeImBuf(out); - } - - if (gpd) { - int i; - unsigned char *gp_rect; - unsigned char *render_rect = (unsigned char *)RE_RenderViewGetById(rr, oglrender->view_id)->rect32; - - DRW_opengl_context_enable(); - GPU_offscreen_bind(oglrender->ofs, true); - - GPU_clear_color(0.0f, 0.0f, 0.0f, 0.0f); - GPU_clear(GPU_COLOR_BIT | GPU_DEPTH_BIT); - - wmOrtho2(0, sizex, 0, sizey); - GPU_matrix_translate_2f(sizex / 2, sizey / 2); - - G.f |= G_FLAG_RENDER_VIEWPORT; - ED_annotation_draw_ex( - scene, gpd, sizex, sizey, scene->r.cfra, SPACE_SEQ); - G.f &= ~G_FLAG_RENDER_VIEWPORT; - - gp_rect = MEM_mallocN(sizex * sizey * sizeof(unsigned char) * 4, "offscreen rect"); - GPU_offscreen_read_pixels(oglrender->ofs, GL_UNSIGNED_BYTE, gp_rect); - - for (i = 0; i < sizex * sizey * 4; i += 4) { - blend_color_mix_byte(&render_rect[i], &render_rect[i], &gp_rect[i]); - } - GPU_offscreen_unbind(oglrender->ofs, true); - DRW_opengl_context_disable(); - - MEM_freeN(gp_rect); - } - } - else { - /* shouldnt suddenly give errors mid-render but possible */ - char err_out[256] = "unknown"; - ImBuf *ibuf_view; - const int alpha_mode = (draw_sky) ? R_ADDSKY : R_ALPHAPREMUL; - - unsigned int draw_flags = V3D_OFSDRAW_NONE; - draw_flags |= (oglrender->ofs_full_samples) ? V3D_OFSDRAW_USE_FULL_SAMPLE : 0; - - if (view_context) { - ibuf_view = ED_view3d_draw_offscreen_imbuf( - depsgraph, scene, v3d->shading.type, - v3d, ar, sizex, sizey, - IB_rectfloat, draw_flags, alpha_mode, oglrender->ofs_samples, viewname, - oglrender->ofs, err_out); - - /* for stamp only */ - if (rv3d->persp == RV3D_CAMOB && v3d->camera) { - camera = BKE_camera_multiview_render(oglrender->scene, v3d->camera, viewname); - } - } - else { - draw_flags |= V3D_OFSDRAW_USE_GPENCIL; - ibuf_view = ED_view3d_draw_offscreen_imbuf_simple( - depsgraph, scene, OB_SOLID, - scene->camera, oglrender->sizex, oglrender->sizey, - IB_rectfloat, draw_flags, - alpha_mode, oglrender->ofs_samples, viewname, - oglrender->ofs, err_out); - camera = scene->camera; - } - - if (ibuf_view) { - ibuf_result = ibuf_view; - rectf = (float *)ibuf_view->rect_float; - } - else { - fprintf(stderr, "%s: failed to get buffer, %s\n", __func__, err_out); - } - } - - if (ibuf_result != NULL) { - if ((scene->r.stamp & R_STAMP_ALL) && (scene->r.stamp & R_STAMP_DRAW)) { - BKE_image_stamp_buf(scene, camera, NULL, NULL, rectf, rr->rectx, rr->recty, 4); - } - RE_render_result_rect_from_ibuf(rr, &scene->r, ibuf_result, oglrender->view_id); - IMB_freeImBuf(ibuf_result); - } + Depsgraph *depsgraph = CTX_data_depsgraph(C); + Scene *scene = oglrender->scene; + ARegion *ar = oglrender->ar; + View3D *v3d = oglrender->v3d; + RegionView3D *rv3d = oglrender->rv3d; + Object *camera = NULL; + int sizex = oglrender->sizex; + int sizey = oglrender->sizey; + const short view_context = (v3d != NULL); + bool draw_sky = (scene->r.alphamode == R_ADDSKY); + float *rectf = NULL; + const char *viewname = RE_GetActiveRenderView(oglrender->re); + ImBuf *ibuf_result = NULL; + + if (oglrender->is_sequencer) { + SpaceSeq *sseq = oglrender->sseq; + struct bGPdata *gpd = (sseq && (sseq->flag & SEQ_SHOW_GPENCIL)) ? sseq->gpd : NULL; + + /* use pre-calculated ImBuf (avoids deadlock), see: */ + ImBuf *ibuf = oglrender->seq_data.ibufs_arr[oglrender->view_id]; + + if (ibuf) { + ImBuf *out = IMB_dupImBuf(ibuf); + IMB_freeImBuf(ibuf); + /* OpenGL render is considered to be preview and should be + * as fast as possible. So currently we're making sure sequencer + * result is always byte to simplify color management pipeline. + * + * TODO(sergey): In the case of output to float container (EXR) + * it actually makes sense to keep float buffer instead. + */ + if (out->rect_float != NULL) { + IMB_rect_from_float(out); + imb_freerectfloatImBuf(out); + } + BLI_assert((oglrender->sizex == ibuf->x) && (oglrender->sizey == ibuf->y)); + RE_render_result_rect_from_ibuf(rr, &scene->r, out, oglrender->view_id); + IMB_freeImBuf(out); + } + else if (gpd) { + /* If there are no strips, Grease Pencil still needs a buffer to draw on */ + ImBuf *out = IMB_allocImBuf(oglrender->sizex, oglrender->sizey, 32, IB_rect); + RE_render_result_rect_from_ibuf(rr, &scene->r, out, oglrender->view_id); + IMB_freeImBuf(out); + } + + if (gpd) { + int i; + unsigned char *gp_rect; + unsigned char *render_rect = + (unsigned char *)RE_RenderViewGetById(rr, oglrender->view_id)->rect32; + + DRW_opengl_context_enable(); + GPU_offscreen_bind(oglrender->ofs, true); + + GPU_clear_color(0.0f, 0.0f, 0.0f, 0.0f); + GPU_clear(GPU_COLOR_BIT | GPU_DEPTH_BIT); + + wmOrtho2(0, sizex, 0, sizey); + GPU_matrix_translate_2f(sizex / 2, sizey / 2); + + G.f |= G_FLAG_RENDER_VIEWPORT; + ED_annotation_draw_ex(scene, gpd, sizex, sizey, scene->r.cfra, SPACE_SEQ); + G.f &= ~G_FLAG_RENDER_VIEWPORT; + + gp_rect = MEM_mallocN(sizex * sizey * sizeof(unsigned char) * 4, "offscreen rect"); + GPU_offscreen_read_pixels(oglrender->ofs, GL_UNSIGNED_BYTE, gp_rect); + + for (i = 0; i < sizex * sizey * 4; i += 4) { + blend_color_mix_byte(&render_rect[i], &render_rect[i], &gp_rect[i]); + } + GPU_offscreen_unbind(oglrender->ofs, true); + DRW_opengl_context_disable(); + + MEM_freeN(gp_rect); + } + } + else { + /* shouldnt suddenly give errors mid-render but possible */ + char err_out[256] = "unknown"; + ImBuf *ibuf_view; + const int alpha_mode = (draw_sky) ? R_ADDSKY : R_ALPHAPREMUL; + + unsigned int draw_flags = V3D_OFSDRAW_NONE; + draw_flags |= (oglrender->ofs_full_samples) ? V3D_OFSDRAW_USE_FULL_SAMPLE : 0; + + if (view_context) { + ibuf_view = ED_view3d_draw_offscreen_imbuf(depsgraph, + scene, + v3d->shading.type, + v3d, + ar, + sizex, + sizey, + IB_rectfloat, + draw_flags, + alpha_mode, + oglrender->ofs_samples, + viewname, + oglrender->ofs, + err_out); + + /* for stamp only */ + if (rv3d->persp == RV3D_CAMOB && v3d->camera) { + camera = BKE_camera_multiview_render(oglrender->scene, v3d->camera, viewname); + } + } + else { + draw_flags |= V3D_OFSDRAW_USE_GPENCIL; + ibuf_view = ED_view3d_draw_offscreen_imbuf_simple(depsgraph, + scene, + OB_SOLID, + scene->camera, + oglrender->sizex, + oglrender->sizey, + IB_rectfloat, + draw_flags, + alpha_mode, + oglrender->ofs_samples, + viewname, + oglrender->ofs, + err_out); + camera = scene->camera; + } + + if (ibuf_view) { + ibuf_result = ibuf_view; + rectf = (float *)ibuf_view->rect_float; + } + else { + fprintf(stderr, "%s: failed to get buffer, %s\n", __func__, err_out); + } + } + + if (ibuf_result != NULL) { + if ((scene->r.stamp & R_STAMP_ALL) && (scene->r.stamp & R_STAMP_DRAW)) { + BKE_image_stamp_buf(scene, camera, NULL, NULL, rectf, rr->rectx, rr->recty, 4); + } + RE_render_result_rect_from_ibuf(rr, &scene->r, ibuf_result, oglrender->view_id); + IMB_freeImBuf(ibuf_result); + } } static void screen_opengl_render_write(OGLRender *oglrender) { - Scene *scene = oglrender->scene; - RenderResult *rr; - bool ok; - char name[FILE_MAX]; - - rr = RE_AcquireResultRead(oglrender->re); - - BKE_image_path_from_imformat( - name, scene->r.pic, BKE_main_blendfile_path(oglrender->bmain), scene->r.cfra, - &scene->r.im_format, (scene->r.scemode & R_EXTENSION) != 0, false, NULL); - - /* write images as individual images or stereo */ - BKE_render_result_stamp_info(scene, scene->camera, rr, false); - ok = RE_WriteRenderViewsImage(oglrender->reports, rr, scene, false, name); - - RE_ReleaseResultImage(oglrender->re); - - if (ok) printf("OpenGL Render written to '%s'\n", name); - else printf("OpenGL Render failed to write '%s'\n", name); + Scene *scene = oglrender->scene; + RenderResult *rr; + bool ok; + char name[FILE_MAX]; + + rr = RE_AcquireResultRead(oglrender->re); + + BKE_image_path_from_imformat(name, + scene->r.pic, + BKE_main_blendfile_path(oglrender->bmain), + scene->r.cfra, + &scene->r.im_format, + (scene->r.scemode & R_EXTENSION) != 0, + false, + NULL); + + /* write images as individual images or stereo */ + BKE_render_result_stamp_info(scene, scene->camera, rr, false); + ok = RE_WriteRenderViewsImage(oglrender->reports, rr, scene, false, name); + + RE_ReleaseResultImage(oglrender->re); + + if (ok) + printf("OpenGL Render written to '%s'\n", name); + else + printf("OpenGL Render failed to write '%s'\n", name); } static void UNUSED_FUNCTION(addAlphaOverFloat)(float dest[4], const float source[4]) { - /* d = s + (1-alpha_s)d*/ - float mul; - - mul = 1.0f - source[3]; + /* d = s + (1-alpha_s)d*/ + float mul; - dest[0] = (mul * dest[0]) + source[0]; - dest[1] = (mul * dest[1]) + source[1]; - dest[2] = (mul * dest[2]) + source[2]; - dest[3] = (mul * dest[3]) + source[3]; + mul = 1.0f - source[3]; + dest[0] = (mul * dest[0]) + source[0]; + dest[1] = (mul * dest[1]) + source[1]; + dest[2] = (mul * dest[2]) + source[2]; + dest[3] = (mul * dest[3]) + source[3]; } static void screen_opengl_render_apply(const bContext *C, OGLRender *oglrender) { - RenderResult *rr; - RenderView *rv; - int view_id; - ImBuf *ibuf; - void *lock; - - if (oglrender->is_sequencer) { - Scene *scene = oglrender->scene; - - SeqRenderData context; - SpaceSeq *sseq = oglrender->sseq; - int chanshown = sseq ? sseq->chanshown : 0; - - BKE_sequencer_new_render_data( - oglrender->bmain, oglrender->depsgraph, scene, - oglrender->sizex, oglrender->sizey, 100.0f, false, - &context); - - for (view_id = 0; view_id < oglrender->views_len; view_id++) { - context.view_id = view_id; - context.gpu_offscreen = oglrender->ofs; - context.gpu_full_samples = oglrender->ofs_full_samples; - - oglrender->seq_data.ibufs_arr[view_id] = BKE_sequencer_give_ibuf(&context, CFRA, chanshown); - } - } - - rr = RE_AcquireResultRead(oglrender->re); - for (rv = rr->views.first, view_id = 0; rv; rv = rv->next, view_id++) { - BLI_assert(view_id < oglrender->views_len); - RE_SetActiveRenderView(oglrender->re, rv->name); - oglrender->view_id = view_id; - /* render composite */ - screen_opengl_render_doit(C, oglrender, rr); - } - - RE_ReleaseResult(oglrender->re); - - ibuf = BKE_image_acquire_ibuf(oglrender->ima, &oglrender->iuser, &lock); - if (ibuf) { - ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID; - } - BKE_image_release_ibuf(oglrender->ima, ibuf, lock); - - if (oglrender->write_still) { - screen_opengl_render_write(oglrender); - } + RenderResult *rr; + RenderView *rv; + int view_id; + ImBuf *ibuf; + void *lock; + + if (oglrender->is_sequencer) { + Scene *scene = oglrender->scene; + + SeqRenderData context; + SpaceSeq *sseq = oglrender->sseq; + int chanshown = sseq ? sseq->chanshown : 0; + + BKE_sequencer_new_render_data(oglrender->bmain, + oglrender->depsgraph, + scene, + oglrender->sizex, + oglrender->sizey, + 100.0f, + false, + &context); + + for (view_id = 0; view_id < oglrender->views_len; view_id++) { + context.view_id = view_id; + context.gpu_offscreen = oglrender->ofs; + context.gpu_full_samples = oglrender->ofs_full_samples; + + oglrender->seq_data.ibufs_arr[view_id] = BKE_sequencer_give_ibuf(&context, CFRA, chanshown); + } + } + + rr = RE_AcquireResultRead(oglrender->re); + for (rv = rr->views.first, view_id = 0; rv; rv = rv->next, view_id++) { + BLI_assert(view_id < oglrender->views_len); + RE_SetActiveRenderView(oglrender->re, rv->name); + oglrender->view_id = view_id; + /* render composite */ + screen_opengl_render_doit(C, oglrender, rr); + } + + RE_ReleaseResult(oglrender->re); + + ibuf = BKE_image_acquire_ibuf(oglrender->ima, &oglrender->iuser, &lock); + if (ibuf) { + ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID; + } + BKE_image_release_ibuf(oglrender->ima, ibuf, lock); + + if (oglrender->write_still) { + screen_opengl_render_write(oglrender); + } } static bool screen_opengl_fullsample_enabled(Scene *scene) { - if (scene->r.scemode & R_FULL_SAMPLE) { - return true; - } - else { - /* XXX TODO: - * Technically if the hardware supports MSAA we could keep using Blender 2.7x approach. - * However anti-aliasing without full_sample is not playing well even in 2.7x. - * - * For example, if you enable depth of field, there is aliasing, even if the viewport is fine. - * For 2.8x this is more complicated because so many things rely on shader. - * So until we fix the gpu_framebuffer anti-aliasing suupport we need to force full sample. - */ - return true; - } + if (scene->r.scemode & R_FULL_SAMPLE) { + return true; + } + else { + /* XXX TODO: + * Technically if the hardware supports MSAA we could keep using Blender 2.7x approach. + * However anti-aliasing without full_sample is not playing well even in 2.7x. + * + * For example, if you enable depth of field, there is aliasing, even if the viewport is fine. + * For 2.8x this is more complicated because so many things rely on shader. + * So until we fix the gpu_framebuffer anti-aliasing suupport we need to force full sample. + */ + return true; + } } static bool screen_opengl_render_init(bContext *C, wmOperator *op) { - /* new render clears all callbacks */ - wmWindowManager *wm = CTX_wm_manager(C); - wmWindow *win = CTX_wm_window(C); - WorkSpace *workspace = CTX_wm_workspace(C); - - Scene *scene = CTX_data_scene(C); - ScrArea *prevsa = CTX_wm_area(C); - ARegion *prevar = CTX_wm_region(C); - GPUOffScreen *ofs; - OGLRender *oglrender; - int sizex, sizey; - const int samples = (scene->r.mode & R_OSA) ? scene->r.osa : 0; - const bool full_samples = (samples != 0) && screen_opengl_fullsample_enabled(scene); - bool is_view_context = RNA_boolean_get(op->ptr, "view_context"); - const bool is_animation = RNA_boolean_get(op->ptr, "animation"); - const bool is_sequencer = RNA_boolean_get(op->ptr, "sequencer"); - const bool is_write_still = RNA_boolean_get(op->ptr, "write_still"); - char err_out[256] = "unknown"; - - if (G.background) { - BKE_report(op->reports, RPT_ERROR, "Cannot use OpenGL render in background mode (no opengl context)"); - return false; - } - - /* only one render job at a time */ - if (WM_jobs_test(wm, scene, WM_JOB_TYPE_RENDER)) - return false; - - if (is_sequencer) { - is_view_context = false; - } - else { - /* ensure we have a 3d view */ - if (!ED_view3d_context_activate(C)) { - RNA_boolean_set(op->ptr, "view_context", false); - is_view_context = false; - } - - if (!is_view_context && scene->camera == NULL) { - BKE_report(op->reports, RPT_ERROR, "Scene has no camera"); - return false; - } - } - - if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) { - BKE_report(op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected"); - return false; - } - - /* stop all running jobs, except screen one. currently previews frustrate Render */ - WM_jobs_kill_all_except(wm, CTX_wm_screen(C)); - - /* create offscreen buffer */ - sizex = (scene->r.size * scene->r.xsch) / 100; - sizey = (scene->r.size * scene->r.ysch) / 100; - - /* corrects render size with actual size, not every card supports non-power-of-two dimensions */ - DRW_opengl_context_enable(); /* Offscreen creation needs to be done in DRW context. */ - ofs = GPU_offscreen_create(sizex, sizey, full_samples ? 0 : samples, true, true, err_out); - DRW_opengl_context_disable(); - - if (!ofs) { - BKE_reportf(op->reports, RPT_ERROR, "Failed to create OpenGL off-screen buffer, %s", err_out); - return false; - } - - /* allocate opengl render */ - oglrender = MEM_callocN(sizeof(OGLRender), "OGLRender"); - op->customdata = oglrender; - - oglrender->ofs = ofs; - oglrender->ofs_samples = samples; - oglrender->ofs_full_samples = full_samples; - oglrender->sizex = sizex; - oglrender->sizey = sizey; - oglrender->bmain = CTX_data_main(C); - oglrender->scene = scene; - oglrender->workspace = workspace; - oglrender->view_layer = CTX_data_view_layer(C); - oglrender->depsgraph = CTX_data_depsgraph(C); - oglrender->cfrao = scene->r.cfra; - - oglrender->write_still = is_write_still && !is_animation; - oglrender->is_animation = is_animation; - - oglrender->views_len = BKE_scene_multiview_num_views_get(&scene->r); - - oglrender->is_sequencer = is_sequencer; - if (is_sequencer) { - oglrender->sseq = CTX_wm_space_seq(C); - ImBuf **ibufs_arr = MEM_callocN(sizeof(*ibufs_arr) * oglrender->views_len, __func__); - oglrender->seq_data.ibufs_arr = ibufs_arr; - } - - oglrender->prevsa = prevsa; - oglrender->prevar = prevar; - - if (is_view_context) { - /* so quad view renders camera */ - ED_view3d_context_user_region(C, &oglrender->v3d, &oglrender->ar); - - oglrender->rv3d = oglrender->ar->regiondata; - - /* MUST be cleared on exit */ - memset(&oglrender->scene->customdata_mask_modal, 0, sizeof(oglrender->scene->customdata_mask_modal)); - ED_view3d_datamask(C, oglrender->scene, oglrender->v3d, &oglrender->scene->customdata_mask_modal); - - /* apply immediately in case we're rendering from a script, - * running notifiers again will overwrite */ - CustomData_MeshMasks_update(&oglrender->scene->customdata_mask, &oglrender->scene->customdata_mask_modal); - } - - /* create render */ - oglrender->re = RE_NewSceneRender(scene); - - /* create image and image user */ - oglrender->ima = BKE_image_verify_viewer(oglrender->bmain, IMA_TYPE_R_RESULT, "Render Result"); - BKE_image_signal(oglrender->bmain, oglrender->ima, NULL, IMA_SIGNAL_FREE); - BKE_image_backup_render(oglrender->scene, oglrender->ima, true); - - oglrender->iuser.scene = scene; - oglrender->iuser.ok = 1; - - /* create render result */ - RE_InitState(oglrender->re, NULL, &scene->r, &scene->view_layers, NULL, sizex, sizey, NULL); - - /* create render views */ - screen_opengl_views_setup(oglrender); - - /* wm vars */ - oglrender->wm = wm; - oglrender->win = win; - - oglrender->totvideos = 0; - oglrender->mh = NULL; - oglrender->movie_ctx_arr = NULL; - - if (is_animation) { - TaskScheduler *task_scheduler = BLI_task_scheduler_get(); - if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { - task_scheduler = BLI_task_scheduler_create(1); - oglrender->task_scheduler = task_scheduler; - oglrender->task_pool = BLI_task_pool_create_background(task_scheduler, - oglrender); - } - else { - oglrender->task_scheduler = NULL; - oglrender->task_pool = BLI_task_pool_create(task_scheduler, - oglrender); - } - oglrender->pool_ok = true; - BLI_spin_init(&oglrender->reports_lock); - } - else { - oglrender->task_scheduler = NULL; - oglrender->task_pool = NULL; - } - oglrender->num_scheduled_frames = 0; - BLI_mutex_init(&oglrender->task_mutex); - BLI_condition_init(&oglrender->task_condition); + /* new render clears all callbacks */ + wmWindowManager *wm = CTX_wm_manager(C); + wmWindow *win = CTX_wm_window(C); + WorkSpace *workspace = CTX_wm_workspace(C); + + Scene *scene = CTX_data_scene(C); + ScrArea *prevsa = CTX_wm_area(C); + ARegion *prevar = CTX_wm_region(C); + GPUOffScreen *ofs; + OGLRender *oglrender; + int sizex, sizey; + const int samples = (scene->r.mode & R_OSA) ? scene->r.osa : 0; + const bool full_samples = (samples != 0) && screen_opengl_fullsample_enabled(scene); + bool is_view_context = RNA_boolean_get(op->ptr, "view_context"); + const bool is_animation = RNA_boolean_get(op->ptr, "animation"); + const bool is_sequencer = RNA_boolean_get(op->ptr, "sequencer"); + const bool is_write_still = RNA_boolean_get(op->ptr, "write_still"); + char err_out[256] = "unknown"; + + if (G.background) { + BKE_report( + op->reports, RPT_ERROR, "Cannot use OpenGL render in background mode (no opengl context)"); + return false; + } + + /* only one render job at a time */ + if (WM_jobs_test(wm, scene, WM_JOB_TYPE_RENDER)) + return false; + + if (is_sequencer) { + is_view_context = false; + } + else { + /* ensure we have a 3d view */ + if (!ED_view3d_context_activate(C)) { + RNA_boolean_set(op->ptr, "view_context", false); + is_view_context = false; + } + + if (!is_view_context && scene->camera == NULL) { + BKE_report(op->reports, RPT_ERROR, "Scene has no camera"); + return false; + } + } + + if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) { + BKE_report( + op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected"); + return false; + } + + /* stop all running jobs, except screen one. currently previews frustrate Render */ + WM_jobs_kill_all_except(wm, CTX_wm_screen(C)); + + /* create offscreen buffer */ + sizex = (scene->r.size * scene->r.xsch) / 100; + sizey = (scene->r.size * scene->r.ysch) / 100; + + /* corrects render size with actual size, not every card supports non-power-of-two dimensions */ + DRW_opengl_context_enable(); /* Offscreen creation needs to be done in DRW context. */ + ofs = GPU_offscreen_create(sizex, sizey, full_samples ? 0 : samples, true, true, err_out); + DRW_opengl_context_disable(); + + if (!ofs) { + BKE_reportf(op->reports, RPT_ERROR, "Failed to create OpenGL off-screen buffer, %s", err_out); + return false; + } + + /* allocate opengl render */ + oglrender = MEM_callocN(sizeof(OGLRender), "OGLRender"); + op->customdata = oglrender; + + oglrender->ofs = ofs; + oglrender->ofs_samples = samples; + oglrender->ofs_full_samples = full_samples; + oglrender->sizex = sizex; + oglrender->sizey = sizey; + oglrender->bmain = CTX_data_main(C); + oglrender->scene = scene; + oglrender->workspace = workspace; + oglrender->view_layer = CTX_data_view_layer(C); + oglrender->depsgraph = CTX_data_depsgraph(C); + oglrender->cfrao = scene->r.cfra; + + oglrender->write_still = is_write_still && !is_animation; + oglrender->is_animation = is_animation; + + oglrender->views_len = BKE_scene_multiview_num_views_get(&scene->r); + + oglrender->is_sequencer = is_sequencer; + if (is_sequencer) { + oglrender->sseq = CTX_wm_space_seq(C); + ImBuf **ibufs_arr = MEM_callocN(sizeof(*ibufs_arr) * oglrender->views_len, __func__); + oglrender->seq_data.ibufs_arr = ibufs_arr; + } + + oglrender->prevsa = prevsa; + oglrender->prevar = prevar; + + if (is_view_context) { + /* so quad view renders camera */ + ED_view3d_context_user_region(C, &oglrender->v3d, &oglrender->ar); + + oglrender->rv3d = oglrender->ar->regiondata; + + /* MUST be cleared on exit */ + memset(&oglrender->scene->customdata_mask_modal, + 0, + sizeof(oglrender->scene->customdata_mask_modal)); + ED_view3d_datamask( + C, oglrender->scene, oglrender->v3d, &oglrender->scene->customdata_mask_modal); + + /* apply immediately in case we're rendering from a script, + * running notifiers again will overwrite */ + CustomData_MeshMasks_update(&oglrender->scene->customdata_mask, + &oglrender->scene->customdata_mask_modal); + } + + /* create render */ + oglrender->re = RE_NewSceneRender(scene); + + /* create image and image user */ + oglrender->ima = BKE_image_verify_viewer(oglrender->bmain, IMA_TYPE_R_RESULT, "Render Result"); + BKE_image_signal(oglrender->bmain, oglrender->ima, NULL, IMA_SIGNAL_FREE); + BKE_image_backup_render(oglrender->scene, oglrender->ima, true); + + oglrender->iuser.scene = scene; + oglrender->iuser.ok = 1; + + /* create render result */ + RE_InitState(oglrender->re, NULL, &scene->r, &scene->view_layers, NULL, sizex, sizey, NULL); + + /* create render views */ + screen_opengl_views_setup(oglrender); + + /* wm vars */ + oglrender->wm = wm; + oglrender->win = win; + + oglrender->totvideos = 0; + oglrender->mh = NULL; + oglrender->movie_ctx_arr = NULL; + + if (is_animation) { + TaskScheduler *task_scheduler = BLI_task_scheduler_get(); + if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { + task_scheduler = BLI_task_scheduler_create(1); + oglrender->task_scheduler = task_scheduler; + oglrender->task_pool = BLI_task_pool_create_background(task_scheduler, oglrender); + } + else { + oglrender->task_scheduler = NULL; + oglrender->task_pool = BLI_task_pool_create(task_scheduler, oglrender); + } + oglrender->pool_ok = true; + BLI_spin_init(&oglrender->reports_lock); + } + else { + oglrender->task_scheduler = NULL; + oglrender->task_pool = NULL; + } + oglrender->num_scheduled_frames = 0; + BLI_mutex_init(&oglrender->task_mutex); + BLI_condition_init(&oglrender->task_condition); #ifdef DEBUG_TIME - oglrender->time_start = PIL_check_seconds_timer(); + oglrender->time_start = PIL_check_seconds_timer(); #endif - return true; + return true; } static void screen_opengl_render_end(bContext *C, OGLRender *oglrender) { - Main *bmain = CTX_data_main(C); - Scene *scene = oglrender->scene; - int i; - - if (oglrender->is_animation) { - /* Trickery part for movie output: - * - * We MUST write frames in an exact order, so we only let background - * thread to work on that, and main thread is simply waits for that - * thread to do all the dirty work. - * - * After this loop is done work_and_wait() will have nothing to do, - * so we don't run into wrong order of frames written to the stream. - */ - if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { - BLI_mutex_lock(&oglrender->task_mutex); - while (oglrender->num_scheduled_frames > 0) { - BLI_condition_wait(&oglrender->task_condition, - &oglrender->task_mutex); - } - BLI_mutex_unlock(&oglrender->task_mutex); - } - BLI_task_pool_work_and_wait(oglrender->task_pool); - BLI_task_pool_free(oglrender->task_pool); - /* Depending on various things we might or might not use global scheduler. */ - if (oglrender->task_scheduler != NULL) { - BLI_task_scheduler_free(oglrender->task_scheduler); - } - BLI_spin_end(&oglrender->reports_lock); - } - BLI_mutex_end(&oglrender->task_mutex); - BLI_condition_end(&oglrender->task_condition); + Main *bmain = CTX_data_main(C); + Scene *scene = oglrender->scene; + int i; + + if (oglrender->is_animation) { + /* Trickery part for movie output: + * + * We MUST write frames in an exact order, so we only let background + * thread to work on that, and main thread is simply waits for that + * thread to do all the dirty work. + * + * After this loop is done work_and_wait() will have nothing to do, + * so we don't run into wrong order of frames written to the stream. + */ + if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { + BLI_mutex_lock(&oglrender->task_mutex); + while (oglrender->num_scheduled_frames > 0) { + BLI_condition_wait(&oglrender->task_condition, &oglrender->task_mutex); + } + BLI_mutex_unlock(&oglrender->task_mutex); + } + BLI_task_pool_work_and_wait(oglrender->task_pool); + BLI_task_pool_free(oglrender->task_pool); + /* Depending on various things we might or might not use global scheduler. */ + if (oglrender->task_scheduler != NULL) { + BLI_task_scheduler_free(oglrender->task_scheduler); + } + BLI_spin_end(&oglrender->reports_lock); + } + BLI_mutex_end(&oglrender->task_mutex); + BLI_condition_end(&oglrender->task_condition); #ifdef DEBUG_TIME - printf("Total render time: %f\n", PIL_check_seconds_timer() - oglrender->time_start); + printf("Total render time: %f\n", PIL_check_seconds_timer() - oglrender->time_start); #endif - if (oglrender->mh) { - if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { - for (i = 0; i < oglrender->totvideos; i++) { - oglrender->mh->end_movie(oglrender->movie_ctx_arr[i]); - oglrender->mh->context_free(oglrender->movie_ctx_arr[i]); - } - } + if (oglrender->mh) { + if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { + for (i = 0; i < oglrender->totvideos; i++) { + oglrender->mh->end_movie(oglrender->movie_ctx_arr[i]); + oglrender->mh->context_free(oglrender->movie_ctx_arr[i]); + } + } - if (oglrender->movie_ctx_arr) { - MEM_freeN(oglrender->movie_ctx_arr); - } - } + if (oglrender->movie_ctx_arr) { + MEM_freeN(oglrender->movie_ctx_arr); + } + } - if (oglrender->timer) { /* exec will not have a timer */ - Depsgraph *depsgraph = oglrender->depsgraph; - scene->r.cfra = oglrender->cfrao; - BKE_scene_graph_update_for_newframe(depsgraph, bmain); + if (oglrender->timer) { /* exec will not have a timer */ + Depsgraph *depsgraph = oglrender->depsgraph; + scene->r.cfra = oglrender->cfrao; + BKE_scene_graph_update_for_newframe(depsgraph, bmain); - WM_event_remove_timer(oglrender->wm, oglrender->win, oglrender->timer); - } + WM_event_remove_timer(oglrender->wm, oglrender->win, oglrender->timer); + } - WM_cursor_modal_restore(oglrender->win); + WM_cursor_modal_restore(oglrender->win); - WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene); + WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene); - DRW_opengl_context_enable(); - GPU_offscreen_free(oglrender->ofs); - DRW_opengl_context_disable(); + DRW_opengl_context_enable(); + GPU_offscreen_free(oglrender->ofs); + DRW_opengl_context_disable(); - if (oglrender->is_sequencer) { - MEM_freeN(oglrender->seq_data.ibufs_arr); - } + if (oglrender->is_sequencer) { + MEM_freeN(oglrender->seq_data.ibufs_arr); + } - memset(&oglrender->scene->customdata_mask_modal, 0, sizeof(oglrender->scene->customdata_mask_modal)); + memset(&oglrender->scene->customdata_mask_modal, + 0, + sizeof(oglrender->scene->customdata_mask_modal)); - CTX_wm_area_set(C, oglrender->prevsa); - CTX_wm_region_set(C, oglrender->prevar); + CTX_wm_area_set(C, oglrender->prevsa); + CTX_wm_region_set(C, oglrender->prevar); - MEM_freeN(oglrender); + MEM_freeN(oglrender); } static void screen_opengl_render_cancel(bContext *C, wmOperator *op) { - screen_opengl_render_end(C, op->customdata); + screen_opengl_render_end(C, op->customdata); } /* share between invoke and exec */ static bool screen_opengl_render_anim_initialize(bContext *C, wmOperator *op) { - /* initialize animation */ - OGLRender *oglrender; - Scene *scene; - - oglrender = op->customdata; - scene = oglrender->scene; - oglrender->totvideos = BKE_scene_multiview_num_videos_get(&scene->r); - - oglrender->reports = op->reports; - - if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { - size_t width, height; - int i; - - BKE_scene_multiview_videos_dimensions_get(&scene->r, oglrender->sizex, oglrender->sizey, &width, &height); - oglrender->mh = BKE_movie_handle_get(scene->r.im_format.imtype); - - if (oglrender->mh == NULL) { - BKE_report(oglrender->reports, RPT_ERROR, "Movie format unsupported"); - screen_opengl_render_end(C, oglrender); - return false; - } - - oglrender->movie_ctx_arr = MEM_mallocN(sizeof(void *) * oglrender->totvideos, "Movies"); - - for (i = 0; i < oglrender->totvideos; i++) { - const char *suffix = BKE_scene_multiview_view_id_suffix_get(&scene->r, i); - - oglrender->movie_ctx_arr[i] = oglrender->mh->context_create(); - if (!oglrender->mh->start_movie(oglrender->movie_ctx_arr[i], scene, &scene->r, oglrender->sizex, - oglrender->sizey, oglrender->reports, PRVRANGEON != 0, suffix)) - { - screen_opengl_render_end(C, oglrender); - return false; - } - } - } - - oglrender->cfrao = scene->r.cfra; - oglrender->nfra = PSFRA; - scene->r.cfra = PSFRA; - - return true; + /* initialize animation */ + OGLRender *oglrender; + Scene *scene; + + oglrender = op->customdata; + scene = oglrender->scene; + oglrender->totvideos = BKE_scene_multiview_num_videos_get(&scene->r); + + oglrender->reports = op->reports; + + if (BKE_imtype_is_movie(scene->r.im_format.imtype)) { + size_t width, height; + int i; + + BKE_scene_multiview_videos_dimensions_get( + &scene->r, oglrender->sizex, oglrender->sizey, &width, &height); + oglrender->mh = BKE_movie_handle_get(scene->r.im_format.imtype); + + if (oglrender->mh == NULL) { + BKE_report(oglrender->reports, RPT_ERROR, "Movie format unsupported"); + screen_opengl_render_end(C, oglrender); + return false; + } + + oglrender->movie_ctx_arr = MEM_mallocN(sizeof(void *) * oglrender->totvideos, "Movies"); + + for (i = 0; i < oglrender->totvideos; i++) { + const char *suffix = BKE_scene_multiview_view_id_suffix_get(&scene->r, i); + + oglrender->movie_ctx_arr[i] = oglrender->mh->context_create(); + if (!oglrender->mh->start_movie(oglrender->movie_ctx_arr[i], + scene, + &scene->r, + oglrender->sizex, + oglrender->sizey, + oglrender->reports, + PRVRANGEON != 0, + suffix)) { + screen_opengl_render_end(C, oglrender); + return false; + } + } + } + + oglrender->cfrao = scene->r.cfra; + oglrender->nfra = PSFRA; + scene->r.cfra = PSFRA; + + return true; } typedef struct WriteTaskData { - RenderResult *rr; - Scene tmp_scene; + RenderResult *rr; + Scene tmp_scene; } WriteTaskData; -static void write_result_func(TaskPool * __restrict pool, - void *task_data_v, - int UNUSED(thread_id)) +static void write_result_func(TaskPool *__restrict pool, void *task_data_v, int UNUSED(thread_id)) { - OGLRender *oglrender = (OGLRender *) BLI_task_pool_userdata(pool); - WriteTaskData *task_data = (WriteTaskData *) task_data_v; - Scene *scene = &task_data->tmp_scene; - RenderResult *rr = task_data->rr; - const bool is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype); - const int cfra = scene->r.cfra; - bool ok; - /* Don't attempt to write if we've got an error. */ - if (!oglrender->pool_ok) { - RE_FreeRenderResult(rr); - BLI_mutex_lock(&oglrender->task_mutex); - oglrender->num_scheduled_frames--; - BLI_condition_notify_all(&oglrender->task_condition); - BLI_mutex_unlock(&oglrender->task_mutex); - return; - } - /* Construct local thread0safe copy of reports structure which we can - * safely pass to the underlying functions. - */ - ReportList reports; - BKE_reports_init(&reports, oglrender->reports->flag & ~RPT_PRINT); - /* Do actual save logic here, depending on the file format. - * - * NOTE: We have to construct temporary scene with proper scene->r.cfra. - * This is because underlying calls do not use r.cfra but use scene - * for that. - */ - if (is_movie) { - ok = RE_WriteRenderViewsMovie(&reports, - rr, - scene, - &scene->r, - oglrender->mh, - oglrender->movie_ctx_arr, - oglrender->totvideos, - PRVRANGEON != 0); - } - else { - /* TODO(sergey): We can in theory save some CPU ticks here because we - * calculate file name again here. - */ - char name[FILE_MAX]; - BKE_image_path_from_imformat(name, - scene->r.pic, - BKE_main_blendfile_path(oglrender->bmain), - cfra, - &scene->r.im_format, - (scene->r.scemode & R_EXTENSION) != 0, - true, - NULL); - - BKE_render_result_stamp_info(scene, scene->camera, rr, false); - ok = RE_WriteRenderViewsImage(NULL, rr, scene, true, name); - if (!ok) { - BKE_reportf(&reports, - RPT_ERROR, - "Write error: cannot save %s", - name); - } - } - if (reports.list.first != NULL) { - BLI_spin_lock(&oglrender->reports_lock); - for (Report *report = reports.list.first; - report != NULL; - report = report->next) - { - BKE_report(oglrender->reports, - report->type, - report->message); - } - BLI_spin_unlock(&oglrender->reports_lock); - } - if (!ok) { - oglrender->pool_ok = false; - } - RE_FreeRenderResult(rr); - BLI_mutex_lock(&oglrender->task_mutex); - oglrender->num_scheduled_frames--; - BLI_condition_notify_all(&oglrender->task_condition); - BLI_mutex_unlock(&oglrender->task_mutex); + OGLRender *oglrender = (OGLRender *)BLI_task_pool_userdata(pool); + WriteTaskData *task_data = (WriteTaskData *)task_data_v; + Scene *scene = &task_data->tmp_scene; + RenderResult *rr = task_data->rr; + const bool is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype); + const int cfra = scene->r.cfra; + bool ok; + /* Don't attempt to write if we've got an error. */ + if (!oglrender->pool_ok) { + RE_FreeRenderResult(rr); + BLI_mutex_lock(&oglrender->task_mutex); + oglrender->num_scheduled_frames--; + BLI_condition_notify_all(&oglrender->task_condition); + BLI_mutex_unlock(&oglrender->task_mutex); + return; + } + /* Construct local thread0safe copy of reports structure which we can + * safely pass to the underlying functions. + */ + ReportList reports; + BKE_reports_init(&reports, oglrender->reports->flag & ~RPT_PRINT); + /* Do actual save logic here, depending on the file format. + * + * NOTE: We have to construct temporary scene with proper scene->r.cfra. + * This is because underlying calls do not use r.cfra but use scene + * for that. + */ + if (is_movie) { + ok = RE_WriteRenderViewsMovie(&reports, + rr, + scene, + &scene->r, + oglrender->mh, + oglrender->movie_ctx_arr, + oglrender->totvideos, + PRVRANGEON != 0); + } + else { + /* TODO(sergey): We can in theory save some CPU ticks here because we + * calculate file name again here. + */ + char name[FILE_MAX]; + BKE_image_path_from_imformat(name, + scene->r.pic, + BKE_main_blendfile_path(oglrender->bmain), + cfra, + &scene->r.im_format, + (scene->r.scemode & R_EXTENSION) != 0, + true, + NULL); + + BKE_render_result_stamp_info(scene, scene->camera, rr, false); + ok = RE_WriteRenderViewsImage(NULL, rr, scene, true, name); + if (!ok) { + BKE_reportf(&reports, RPT_ERROR, "Write error: cannot save %s", name); + } + } + if (reports.list.first != NULL) { + BLI_spin_lock(&oglrender->reports_lock); + for (Report *report = reports.list.first; report != NULL; report = report->next) { + BKE_report(oglrender->reports, report->type, report->message); + } + BLI_spin_unlock(&oglrender->reports_lock); + } + if (!ok) { + oglrender->pool_ok = false; + } + RE_FreeRenderResult(rr); + BLI_mutex_lock(&oglrender->task_mutex); + oglrender->num_scheduled_frames--; + BLI_condition_notify_all(&oglrender->task_condition); + BLI_mutex_unlock(&oglrender->task_mutex); } static bool schedule_write_result(OGLRender *oglrender, RenderResult *rr) { - if (!oglrender->pool_ok) { - RE_FreeRenderResult(rr); - return false; - } - Scene *scene = oglrender->scene; - WriteTaskData *task_data = MEM_mallocN(sizeof(WriteTaskData), "write task data"); - task_data->rr = rr; - task_data->tmp_scene = *scene; - BLI_mutex_lock(&oglrender->task_mutex); - oglrender->num_scheduled_frames++; - if (oglrender->num_scheduled_frames > MAX_SCHEDULED_FRAMES) { - BLI_condition_wait(&oglrender->task_condition, - &oglrender->task_mutex); - } - BLI_mutex_unlock(&oglrender->task_mutex); - BLI_task_pool_push(oglrender->task_pool, - write_result_func, - task_data, - true, - TASK_PRIORITY_LOW); - return true; + if (!oglrender->pool_ok) { + RE_FreeRenderResult(rr); + return false; + } + Scene *scene = oglrender->scene; + WriteTaskData *task_data = MEM_mallocN(sizeof(WriteTaskData), "write task data"); + task_data->rr = rr; + task_data->tmp_scene = *scene; + BLI_mutex_lock(&oglrender->task_mutex); + oglrender->num_scheduled_frames++; + if (oglrender->num_scheduled_frames > MAX_SCHEDULED_FRAMES) { + BLI_condition_wait(&oglrender->task_condition, &oglrender->task_mutex); + } + BLI_mutex_unlock(&oglrender->task_mutex); + BLI_task_pool_push(oglrender->task_pool, write_result_func, task_data, true, TASK_PRIORITY_LOW); + return true; } static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op) { - Main *bmain = CTX_data_main(C); - OGLRender *oglrender = op->customdata; - Scene *scene = oglrender->scene; - Depsgraph *depsgraph = oglrender->depsgraph; - char name[FILE_MAX]; - bool ok = false; - const bool view_context = (oglrender->v3d != NULL); - bool is_movie; - RenderResult *rr; - - /* go to next frame */ - if (CFRA < oglrender->nfra) - CFRA++; - while (CFRA < oglrender->nfra) { - BKE_scene_graph_update_for_newframe(depsgraph, bmain); - CFRA++; - } - - is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype); - - if (!is_movie) { - BKE_image_path_from_imformat( - name, scene->r.pic, BKE_main_blendfile_path(oglrender->bmain), scene->r.cfra, - &scene->r.im_format, (scene->r.scemode & R_EXTENSION) != 0, true, NULL); - - if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(name)) { - BLI_spin_lock(&oglrender->reports_lock); - BKE_reportf(op->reports, RPT_INFO, "Skipping existing frame \"%s\"", name); - BLI_spin_unlock(&oglrender->reports_lock); - ok = true; - goto finally; - } - } - - WM_cursor_time(oglrender->win, scene->r.cfra); - - BKE_scene_graph_update_for_newframe(depsgraph, bmain); - - if (view_context) { - if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera && oglrender->v3d->scenelock) { - /* since BKE_scene_graph_update_for_newframe() is used rather - * then ED_update_for_newframe() the camera needs to be set */ - if (BKE_scene_camera_switch_update(scene)) { - oglrender->v3d->camera = scene->camera; - } - } - } - else { - BKE_scene_camera_switch_update(scene); - } - - /* render into offscreen buffer */ - screen_opengl_render_apply(C, oglrender); - - /* save to disk */ - rr = RE_AcquireResultRead(oglrender->re); - RenderResult *new_rr = RE_DuplicateRenderResult(rr); - RE_ReleaseResult(oglrender->re); - - ok = schedule_write_result(oglrender, new_rr); - -finally: /* Step the frame and bail early if needed */ - - /* go to next frame */ - oglrender->nfra += scene->r.frame_step; - - /* stop at the end or on error */ - if (CFRA >= PEFRA || !ok) { - screen_opengl_render_end(C, op->customdata); - return 0; - } - - return 1; + Main *bmain = CTX_data_main(C); + OGLRender *oglrender = op->customdata; + Scene *scene = oglrender->scene; + Depsgraph *depsgraph = oglrender->depsgraph; + char name[FILE_MAX]; + bool ok = false; + const bool view_context = (oglrender->v3d != NULL); + bool is_movie; + RenderResult *rr; + + /* go to next frame */ + if (CFRA < oglrender->nfra) + CFRA++; + while (CFRA < oglrender->nfra) { + BKE_scene_graph_update_for_newframe(depsgraph, bmain); + CFRA++; + } + + is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype); + + if (!is_movie) { + BKE_image_path_from_imformat(name, + scene->r.pic, + BKE_main_blendfile_path(oglrender->bmain), + scene->r.cfra, + &scene->r.im_format, + (scene->r.scemode & R_EXTENSION) != 0, + true, + NULL); + + if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(name)) { + BLI_spin_lock(&oglrender->reports_lock); + BKE_reportf(op->reports, RPT_INFO, "Skipping existing frame \"%s\"", name); + BLI_spin_unlock(&oglrender->reports_lock); + ok = true; + goto finally; + } + } + + WM_cursor_time(oglrender->win, scene->r.cfra); + + BKE_scene_graph_update_for_newframe(depsgraph, bmain); + + if (view_context) { + if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera && + oglrender->v3d->scenelock) { + /* since BKE_scene_graph_update_for_newframe() is used rather + * then ED_update_for_newframe() the camera needs to be set */ + if (BKE_scene_camera_switch_update(scene)) { + oglrender->v3d->camera = scene->camera; + } + } + } + else { + BKE_scene_camera_switch_update(scene); + } + + /* render into offscreen buffer */ + screen_opengl_render_apply(C, oglrender); + + /* save to disk */ + rr = RE_AcquireResultRead(oglrender->re); + RenderResult *new_rr = RE_DuplicateRenderResult(rr); + RE_ReleaseResult(oglrender->re); + + ok = schedule_write_result(oglrender, new_rr); + +finally: /* Step the frame and bail early if needed */ + + /* go to next frame */ + oglrender->nfra += scene->r.frame_step; + + /* stop at the end or on error */ + if (CFRA >= PEFRA || !ok) { + screen_opengl_render_end(C, op->customdata); + return 0; + } + + return 1; } - static int screen_opengl_render_modal(bContext *C, wmOperator *op, const wmEvent *event) { - OGLRender *oglrender = op->customdata; - const bool anim = RNA_boolean_get(op->ptr, "animation"); - bool ret; - - switch (event->type) { - case ESCKEY: - /* cancel */ - oglrender->pool_ok = false; /* Flag pool for cancel. */ - screen_opengl_render_end(C, op->customdata); - return OPERATOR_FINISHED; - case TIMER: - /* render frame? */ - if (oglrender->timer == event->customdata) - break; - ATTR_FALLTHROUGH; - default: - /* nothing to do */ - return OPERATOR_RUNNING_MODAL; - } - - /* run first because screen_opengl_render_anim_step can free oglrender */ - WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene); - - if (anim == 0) { - screen_opengl_render_apply(C, op->customdata); - screen_opengl_render_end(C, op->customdata); - return OPERATOR_FINISHED; - } - else { - ret = screen_opengl_render_anim_step(C, op); - } - - /* stop at the end or on error */ - if (ret == false) { - return OPERATOR_FINISHED; - } - - return OPERATOR_RUNNING_MODAL; + OGLRender *oglrender = op->customdata; + const bool anim = RNA_boolean_get(op->ptr, "animation"); + bool ret; + + switch (event->type) { + case ESCKEY: + /* cancel */ + oglrender->pool_ok = false; /* Flag pool for cancel. */ + screen_opengl_render_end(C, op->customdata); + return OPERATOR_FINISHED; + case TIMER: + /* render frame? */ + if (oglrender->timer == event->customdata) + break; + ATTR_FALLTHROUGH; + default: + /* nothing to do */ + return OPERATOR_RUNNING_MODAL; + } + + /* run first because screen_opengl_render_anim_step can free oglrender */ + WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene); + + if (anim == 0) { + screen_opengl_render_apply(C, op->customdata); + screen_opengl_render_end(C, op->customdata); + return OPERATOR_FINISHED; + } + else { + ret = screen_opengl_render_anim_step(C, op); + } + + /* stop at the end or on error */ + if (ret == false) { + return OPERATOR_FINISHED; + } + + return OPERATOR_RUNNING_MODAL; } static int screen_opengl_render_invoke(bContext *C, wmOperator *op, const wmEvent *event) { - OGLRender *oglrender; - const bool anim = RNA_boolean_get(op->ptr, "animation"); + OGLRender *oglrender; + const bool anim = RNA_boolean_get(op->ptr, "animation"); - if (!screen_opengl_render_init(C, op)) - return OPERATOR_CANCELLED; + if (!screen_opengl_render_init(C, op)) + return OPERATOR_CANCELLED; - if (anim) { - if (!screen_opengl_render_anim_initialize(C, op)) - return OPERATOR_CANCELLED; - } + if (anim) { + if (!screen_opengl_render_anim_initialize(C, op)) + return OPERATOR_CANCELLED; + } - oglrender = op->customdata; - render_view_open(C, event->x, event->y, op->reports); + oglrender = op->customdata; + render_view_open(C, event->x, event->y, op->reports); - /* view may be changed above (R_OUTPUT_WINDOW) */ - oglrender->win = CTX_wm_window(C); + /* view may be changed above (R_OUTPUT_WINDOW) */ + oglrender->win = CTX_wm_window(C); - WM_event_add_modal_handler(C, op); - oglrender->timer = WM_event_add_timer(oglrender->wm, oglrender->win, TIMER, 0.01f); + WM_event_add_modal_handler(C, op); + oglrender->timer = WM_event_add_timer(oglrender->wm, oglrender->win, TIMER, 0.01f); - return OPERATOR_RUNNING_MODAL; + return OPERATOR_RUNNING_MODAL; } /* executes blocking render */ static int screen_opengl_render_exec(bContext *C, wmOperator *op) { - const bool is_animation = RNA_boolean_get(op->ptr, "animation"); + const bool is_animation = RNA_boolean_get(op->ptr, "animation"); - if (!screen_opengl_render_init(C, op)) - return OPERATOR_CANCELLED; + if (!screen_opengl_render_init(C, op)) + return OPERATOR_CANCELLED; - if (!is_animation) { /* same as invoke */ - /* render image */ - screen_opengl_render_apply(C, op->customdata); - screen_opengl_render_end(C, op->customdata); + if (!is_animation) { /* same as invoke */ + /* render image */ + screen_opengl_render_apply(C, op->customdata); + screen_opengl_render_end(C, op->customdata); - return OPERATOR_FINISHED; - } - else { - bool ret = true; + return OPERATOR_FINISHED; + } + else { + bool ret = true; - if (!screen_opengl_render_anim_initialize(C, op)) - return OPERATOR_CANCELLED; + if (!screen_opengl_render_anim_initialize(C, op)) + return OPERATOR_CANCELLED; - while (ret) { - ret = screen_opengl_render_anim_step(C, op); - } - } + while (ret) { + ret = screen_opengl_render_anim_step(C, op); + } + } - /* no redraw needed, we leave state as we entered it */ -// ED_update_for_newframe(C); - WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, CTX_data_scene(C)); + /* no redraw needed, we leave state as we entered it */ + // ED_update_for_newframe(C); + WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, CTX_data_scene(C)); - return OPERATOR_FINISHED; + return OPERATOR_FINISHED; } void RENDER_OT_opengl(wmOperatorType *ot) { - PropertyRNA *prop; - - /* identifiers */ - ot->name = "Viewport Render"; - ot->description = "Take a snapshot of the active viewport"; - ot->idname = "RENDER_OT_opengl"; - - /* api callbacks */ - ot->invoke = screen_opengl_render_invoke; - ot->exec = screen_opengl_render_exec; /* blocking */ - ot->modal = screen_opengl_render_modal; - ot->cancel = screen_opengl_render_cancel; - - ot->poll = ED_operator_screenactive; - - prop = RNA_def_boolean(ot->srna, "animation", 0, "Animation", "Render files from the animation range of this scene"); - RNA_def_property_flag(prop, PROP_SKIP_SAVE); - prop = RNA_def_boolean(ot->srna, "sequencer", 0, "Sequencer", "Render using the sequencer's OpenGL display"); - RNA_def_property_flag(prop, PROP_SKIP_SAVE); - prop = RNA_def_boolean(ot->srna, "write_still", 0, "Write Image", "Save rendered the image to the output path (used only when animation is disabled)"); - RNA_def_property_flag(prop, PROP_SKIP_SAVE); - prop = RNA_def_boolean(ot->srna, "view_context", 1, "View Context", "Use the current 3D view for rendering, else use scene settings"); - RNA_def_property_flag(prop, PROP_SKIP_SAVE); - + PropertyRNA *prop; + + /* identifiers */ + ot->name = "Viewport Render"; + ot->description = "Take a snapshot of the active viewport"; + ot->idname = "RENDER_OT_opengl"; + + /* api callbacks */ + ot->invoke = screen_opengl_render_invoke; + ot->exec = screen_opengl_render_exec; /* blocking */ + ot->modal = screen_opengl_render_modal; + ot->cancel = screen_opengl_render_cancel; + + ot->poll = ED_operator_screenactive; + + prop = RNA_def_boolean(ot->srna, + "animation", + 0, + "Animation", + "Render files from the animation range of this scene"); + RNA_def_property_flag(prop, PROP_SKIP_SAVE); + prop = RNA_def_boolean( + ot->srna, "sequencer", 0, "Sequencer", "Render using the sequencer's OpenGL display"); + RNA_def_property_flag(prop, PROP_SKIP_SAVE); + prop = RNA_def_boolean( + ot->srna, + "write_still", + 0, + "Write Image", + "Save rendered the image to the output path (used only when animation is disabled)"); + RNA_def_property_flag(prop, PROP_SKIP_SAVE); + prop = RNA_def_boolean(ot->srna, + "view_context", + 1, + "View Context", + "Use the current 3D view for rendering, else use scene settings"); + RNA_def_property_flag(prop, PROP_SKIP_SAVE); } /* function for getting an opengl buffer from a View3D, used by sequencer */ |