Blender V5.3
render_opengl.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <condition_variable>
10#include <cstddef>
11#include <cstring>
12
14#include "DNA_defs.h"
15#include "MEM_guardedalloc.h"
16
17#include "BLI_bitmap.hh"
18#include "BLI_fileops.hh"
19#include "BLI_listbase.hh"
21#include "BLI_mutex.hh"
22#include "BLI_string_utf8.hh"
23#include "BLI_task.hh"
24#include "BLI_task_c.hh"
25#include "BLI_utildefines.hh"
26#include "BLI_vector.hh"
27
28#include "DNA_anim_types.h"
29#include "DNA_curve_types.h"
31#include "DNA_object_types.h"
32#include "DNA_scene_types.h"
33
34#include "BKE_anim_data.hh"
35#include "BKE_camera.h"
36#include "BKE_context.hh"
37#include "BKE_customdata.hh"
38#include "BKE_fcurve.hh"
39#include "BKE_global.hh"
40#include "BKE_image.hh"
41#include "BKE_image_format.hh"
42#include "BKE_image_save.hh"
43#include "BKE_lib_query.hh"
44#include "BKE_main.hh"
45#include "BKE_report.hh"
46#include "BKE_scene.hh"
47
48#include "DEG_depsgraph.hh"
50
51#include "DRW_engine.hh"
52
53#include "WM_api.hh"
54#include "WM_types.hh"
55
56#include "ED_gpencil_legacy.hh"
57#include "ED_screen.hh"
58#include "ED_util.hh"
59#include "ED_view3d.hh"
61
62#include "IMB_imbuf.hh"
63#include "IMB_imbuf_types.hh"
64
65#include "MOV_write.hh"
66
67#include "RE_pipeline.h"
68
69#include "BLT_translation.hh"
70
71#include "RNA_access.hh"
72#include "RNA_define.hh"
73
74#include "SEQ_render.hh"
75
76#include "ANIM_animdata.hh"
77
78#include "GPU_context.hh"
79#include "GPU_framebuffer.hh"
80#include "GPU_matrix.hh"
81#include "GPU_state.hh"
82#include "GPU_viewport.hh"
83
84#include "CLG_log.h"
85
86#include "render_intern.hh"
87
88namespace blender {
89
91
92static CLG_LogRef LOG = {"render"};
93
94/* TODO(sergey): Find better approximation of the scheduled frames.
95 * For really high-resolution renders it might fail still. */
96#define MAX_SCHEDULED_FRAMES 8
97
98struct OGLRender : public RenderJobBase {
99 Main *bmain = nullptr;
100 Render *re = nullptr;
103 Depsgraph *depsgraph = nullptr;
104
105 View3D *v3d = nullptr;
106 RegionView3D *rv3d = nullptr;
107 ARegion *region = nullptr;
108
109 int views_len = 0; /* multi-view views */
110
111 bool is_sequencer = false;
112 SpaceSeq *sseq = nullptr;
113 struct {
114 ImBuf **ibufs_arr = nullptr;
116
117 Image *ima = nullptr;
119
120 GPUOffScreen *ofs = nullptr;
121 int sizex = 0;
122 int sizey = 0;
123 int write_still = false;
124
126
128 ReportList *reports = nullptr;
129
130 int cfrao = 0;
131 int nfra = 0;
132
133 int totvideos = 0;
134
135 /* For only rendering frames that have a key in animation data. */
137
138 /* quick lookup */
139 int view_id = 0;
140
141 /* wm vars for timer and progress cursor */
142 wmWindowManager *wm = nullptr;
143 wmWindow *win = nullptr;
144
146
147 TaskPool *task_pool = nullptr;
148 bool pool_ok = true;
149 bool is_animation = false;
150
153 std::mutex task_mutex;
154 std::condition_variable task_condition;
155
156 wmJob *wm_job = nullptr;
157
158 bool ended = false;
159};
160
162{
163 View3D *v3d = oglrender->v3d;
164 RegionView3D *rv3d = oglrender->rv3d;
165 RenderData *rd = &oglrender->scene->r;
166
167 if ((rd == nullptr) || ((v3d != nullptr) && (rv3d == nullptr))) {
168 return false;
169 }
170
171 return (rd->scemode & R_MULTIVIEW) &&
172 ((v3d == nullptr) || (rv3d->persp == RV3D_CAMOB && v3d->camera));
173}
174
176{
177 RenderResult *rr;
178 RenderView *rv;
179 SceneRenderView *srv;
180 bool is_multiview;
181 Object *camera;
182 View3D *v3d = oglrender->v3d;
183
184 RenderData *rd = &oglrender->scene->r;
185
186 rr = RE_AcquireResultWrite(oglrender->re);
187
188 is_multiview = screen_opengl_is_multiview(oglrender);
189
190 if (!is_multiview) {
191 /* we only have one view when multiview is off */
192 rv = rr->views.first();
193
194 if (rv == nullptr) {
195 rv = MEM_new<RenderView>("new opengl render view");
196 BLI_addtail(&rr->views, rv);
197 }
198
199 while (rv->next) {
200 RenderView *rv_del = rv->next;
201 BLI_remlink(&rr->views, rv_del);
202
203 IMB_freeImBuf(rv_del->ibuf);
204
205 MEM_delete(rv_del);
206 }
207 }
208 else {
209 if (v3d) {
210 RE_SetOverrideCamera(oglrender->re, V3D_CAMERA_SCENE(oglrender->scene, v3d));
211 }
212
213 /* remove all the views that are not needed */
214 rv = rr->views.last();
215 while (rv) {
216 srv = static_cast<SceneRenderView *>(
219 rv = rv->prev;
220 }
221 else {
222 RenderView *rv_del = rv;
223 rv = rv_del->prev;
224
225 BLI_remlink(&rr->views, rv_del);
226
227 IMB_freeImBuf(rv_del->ibuf);
228
229 MEM_delete(rv_del);
230 }
231 }
232
233 /* create all the views that are needed */
234 for (SceneRenderView &srv : rd->views) {
235 if (BKE_scene_multiview_is_render_view_active(rd, &srv) == false) {
236 continue;
237 }
238
239 rv = static_cast<RenderView *>(
241
242 if (rv == nullptr) {
243 rv = MEM_new<RenderView>("new opengl render view");
244 STRNCPY_UTF8(rv->name, srv.name);
245 BLI_addtail(&rr->views, rv);
246 }
247 }
248 }
249
250 if (!(is_multiview && BKE_scene_multiview_is_stereo3d(rd))) {
251 oglrender->iuser.flag &= ~IMA_SHOW_STEREO;
252 }
253
254 /* will only work for non multiview correctly */
255 if (v3d) {
257 *oglrender->bmain, oglrender->scene, v3d->camera, "new opengl render view");
258 BKE_render_result_stamp_info(oglrender->scene, camera, rr, false);
259 }
260 else {
261 BKE_render_result_stamp_info(oglrender->scene, oglrender->scene->camera, rr, false);
262 }
263
264 RE_ReleaseResult(oglrender->re);
265}
266
268{
269 Scene *scene = oglrender->scene;
270 Object *camera = nullptr;
271 int sizex = oglrender->sizex;
272 int sizey = oglrender->sizey;
273 ImBuf *ibuf_result = nullptr;
274
275 if (oglrender->is_sequencer) {
276 SpaceSeq *sseq = oglrender->sseq;
277 bGPdata *gpd = (sseq && (sseq->preview_overlay.flag & SEQ_PREVIEW_SHOW_GPENCIL)) ? sseq->gpd :
278 nullptr;
279
280 /* use pre-calculated ImBuf (avoids deadlock), see: */
281 ImBuf *ibuf = oglrender->seq_data.ibufs_arr[oglrender->view_id];
282
283 if (ibuf) {
284 ibuf_result = IMB_dupImBuf(ibuf);
285 IMB_freeImBuf(ibuf);
286 /* OpenGL render is considered to be preview and should be
287 * as fast as possible. So currently we're making sure sequencer
288 * result is always byte to simplify color management pipeline.
289 *
290 * TODO(sergey): In the case of output to float container (EXR)
291 * it actually makes sense to keep float buffer instead.
292 */
293 if (ibuf_result->float_data() != nullptr) {
294 IMB_byte_from_float(ibuf_result);
295 IMB_free_float_pixels(ibuf_result);
296 }
297 BLI_assert((sizex == ibuf->x) && (sizey == ibuf->y));
298 }
299 else if (gpd) {
300 /* If there are no strips, Grease Pencil still needs a buffer to draw on */
301 ibuf_result = IMB_allocImBuf(sizex, sizey, ImBufFlags::ByteData);
302 }
303
304 if (gpd) {
305 int i;
306 uchar *gp_rect;
307 uchar *render_rect = ibuf_result->byte_data_for_write();
308
310 GPU_offscreen_bind(oglrender->ofs, true);
311
312 GPU_clear_color(0.0f, 0.0f, 0.0f, 0.0f);
313 GPU_clear_depth(1.0f);
314
316 wmOrtho2(0, scene->r.xsch, 0, scene->r.ysch);
317 GPU_matrix_translate_2f(scene->r.xsch / 2, scene->r.ysch / 2);
318
320 ED_annotation_draw_ex(scene, gpd, sizex, sizey, scene->r.cfra, SPACE_SEQ);
322
323 gp_rect = MEM_new_array_uninitialized<uchar>(4 * sizex * sizey, "offscreen rect");
324 GPU_offscreen_read_color(oglrender->ofs, GPU_DATA_UBYTE, gp_rect);
325
326 for (i = 0; i < sizex * sizey * 4; i += 4) {
327 blend_color_mix_byte(&render_rect[i], &render_rect[i], &gp_rect[i]);
328 }
329 GPU_offscreen_unbind(oglrender->ofs, true);
331
332 MEM_delete(gp_rect);
333 }
334 }
335 else {
336 /* shouldn't suddenly give errors mid-render but possible */
337 Depsgraph *depsgraph = oglrender->depsgraph;
338 char err_out[256] = "unknown";
339 ImBuf *ibuf_view;
340 bool draw_sky = (scene->r.alphamode == R_ADDSKY);
341 const int alpha_mode = (draw_sky) ? R_ADDSKY : R_ALPHAPREMUL;
342 const char *viewname = RE_GetActiveRenderView(oglrender->re);
343 View3D *v3d = oglrender->v3d;
344
345 BKE_scene_graph_evaluated_ensure(depsgraph, oglrender->bmain);
346
347 if (v3d != nullptr) {
348 ARegion *region = oglrender->region;
349 ibuf_view = ED_view3d_draw_offscreen_imbuf(depsgraph,
350 scene,
351 v3d->shading.type,
352 v3d,
353 region,
354 sizex,
355 sizey,
357 alpha_mode,
358 viewname,
359 true,
360 oglrender->ofs,
361 oglrender->viewport,
362 true,
363 err_out);
364
365 /* for stamp only */
366 if (oglrender->rv3d->persp == RV3D_CAMOB && v3d->camera) {
368 *oglrender->bmain, oglrender->scene, v3d->camera, viewname);
369 }
370 }
371 else {
372 ibuf_view = ED_view3d_draw_offscreen_imbuf_simple(depsgraph,
373 scene,
374 nullptr,
375 OB_SOLID,
376 scene->camera,
377 sizex,
378 sizey,
381 alpha_mode,
382 viewname,
383 oglrender->ofs,
384 oglrender->viewport,
385 err_out);
386 camera = scene->camera;
387 }
388
389 if (ibuf_view) {
390 ibuf_result = ibuf_view;
391 }
392 else {
393 CLOG_ERROR(&LOG, "%s: failed to get buffer, %s", __func__, err_out);
394 }
395 }
396
397 if (ibuf_result != nullptr) {
398 if ((scene->r.stamp & R_STAMP_ALL) && (scene->r.stamp & R_STAMP_DRAW)) {
399 BKE_image_stamp_buf(scene, camera, nullptr, ibuf_result);
400 }
401 RE_render_result_rect_from_ibuf(rr, ibuf_result, oglrender->view_id);
402 IMB_freeImBuf(ibuf_result);
403 }
404
406 /* Metal: Perform render step between samples to allow flushing of freed GPUBackend resources.
407 * Vulkan: Perform render step between samples to avoid allocation of a high amount of command
408 * buffer memory that can eventually result in out-of-memory errors or a TDR when submitted as
409 * one large command buffer. */
411 GPU_flush();
412 }
413 GPU_render_step(true);
415}
416
418{
419 Scene *scene = oglrender->scene;
420 RenderResult *rr;
421 bool ok;
422 char filepath[FILE_MAX];
423
424 rr = RE_AcquireResultRead(oglrender->re);
425
426 path_templates::VariableMap template_variables;
427 BKE_add_template_variables_general(template_variables, &scene->id, project);
428 BKE_add_template_variables_for_render_path(template_variables, *scene);
429
430 const char *relbase = BKE_main_blendfile_path(oglrender->bmain);
432 filepath,
433 scene->r.pic,
434 relbase,
435 &template_variables,
436 scene->r.cfra,
437 &scene->r.im_format,
438 (scene->r.scemode & R_EXTENSION) != 0,
439 false,
440 nullptr);
441
442 if (!errors.is_empty()) {
443 std::unique_lock lock(oglrender->reports_mutex);
444 BKE_report_path_template_errors(oglrender->reports, RPT_ERROR, scene->r.pic, errors);
445 ok = false;
446 }
447 else {
448 /* write images as individual images or stereo */
449 BKE_render_result_stamp_info(scene, scene->camera, rr, false);
450 ok = BKE_image_render_write(oglrender->reports, rr, scene, false, filepath);
451
452 RE_ReleaseResultImage(oglrender->re);
453 }
454
455 if (ok) {
456 CLOG_INFO_NOCHECK(&LOG, "OpenGL Render written to '%s'", filepath);
457 }
458 else {
459 CLOG_ERROR(&LOG, "OpenGL Render failed to write '%s'", filepath);
460 }
461}
462
463static void UNUSED_FUNCTION(addAlphaOverFloat)(float dest[4], const float source[4])
464{
465 /* `d = s + (1-alpha_s)d` */
466 float mul;
467
468 mul = 1.0f - source[3];
469
470 dest[0] = (mul * dest[0]) + source[0];
471 dest[1] = (mul * dest[1]) + source[1];
472 dest[2] = (mul * dest[2]) + source[2];
473 dest[3] = (mul * dest[3]) + source[3];
474}
475
477{
478 RenderResult *rr;
479 RenderView *rv;
480 int view_id;
481
482 if (oglrender->is_sequencer) {
483 Scene *scene = oglrender->scene;
484
485 seq::RenderData context;
486 SpaceSeq *sseq = oglrender->sseq;
487 int chanshown = sseq ? sseq->chanshown : 0;
488
490 oglrender->depsgraph,
491 scene,
492 oglrender->sizex,
493 oglrender->sizey,
495 nullptr,
496 &context);
497
498 for (view_id = 0; view_id < oglrender->views_len; view_id++) {
499 context.view_id = view_id;
500 context.gpu_offscreen = oglrender->ofs;
501 context.gpu_viewport = oglrender->viewport;
502 oglrender->seq_data.ibufs_arr[view_id] = seq::render_give_ibuf(
503 &context, scene->r.cfra, chanshown);
504 }
505 }
506
507 rr = RE_AcquireResultRead(oglrender->re);
508 for (rv = rr->views.first(), view_id = 0; rv; rv = rv->next, view_id++) {
509 BLI_assert(view_id < oglrender->views_len);
510 RE_SetActiveRenderView(oglrender->re, rv->name);
511 oglrender->view_id = view_id;
512 /* render composite */
513 screen_opengl_render_doit(oglrender, rr);
514 }
515
516 RE_ReleaseResult(oglrender->re);
517
518 if (oglrender->write_still) {
520 }
521}
522
523static void gather_frames_to_render_for_adt(const OGLRender *oglrender, const AnimData *adt)
524{
525 if (adt == nullptr || adt->action == nullptr) {
526 return;
527 }
528
529 const int frame_start = oglrender->scene->playback_start();
530 const int frame_end = oglrender->scene->playback_end();
531
532 for (const FCurve *fcu : animrig::fcurves_for_assigned_action(adt)) {
533 if (fcu->driver != nullptr || fcu->fpt != nullptr) {
534 /* Drivers have values for any point in time, so to get "the keyed frames" they are
535 * useless. Same for baked FCurves, they also have keys for every frame, which is not
536 * useful for rendering the keyed subset of the frames. */
537 continue;
538 }
539
540 bool found = false; /* Not interesting, we just want a starting point for the for-loop. */
542 fcu->bezt, frame_start, fcu->totvert, &found);
543 for (; key_index < fcu->totvert; key_index++) {
544 BezTriple *bezt = &fcu->bezt[key_index];
545 /* The frame range to render uses integer frame numbers, and the frame
546 * step is also an integer, so we always render on the frame. */
547 int frame_nr = round_fl_to_int(bezt->vec[1][0]);
548
549 /* (frame_nr < frame_start) cannot happen because of the binary search above. */
550 BLI_assert(frame_nr >= frame_start);
551 if (frame_nr > frame_end) {
552 break;
553 }
554 BLI_BITMAP_ENABLE(oglrender->render_frames, frame_nr - frame_start);
555 }
556 }
557}
558
560 const bGPdata *gp)
561{
562 if (gp == nullptr) {
563 return;
564 }
565
566 const int frame_start = oglrender->scene->playback_start();
567 const int frame_end = oglrender->scene->playback_end();
568
569 for (const bGPDlayer &gp_layer : gp->layers) {
570 for (const bGPDframe &gp_frame : gp_layer.frames) {
571 if (gp_frame.framenum < frame_start || gp_frame.framenum > frame_end) {
572 continue;
573 }
574 BLI_BITMAP_ENABLE(oglrender->render_frames, gp_frame.framenum - frame_start);
575 }
576 }
577}
578
580{
581 ID **id_p = cb_data->id_pointer;
582 if (*id_p == nullptr) {
583 return IDWALK_RET_NOP;
584 }
585 ID *id = *id_p;
586
587 ID *self_id = cb_data->self_id;
588 const LibraryForeachIDCallbackFlag cb_flag = cb_data->cb_flag;
589 if (cb_flag == IDWALK_CB_LOOPBACK || id == self_id) {
590 /* IDs may end up referencing themselves one way or the other, and those
591 * (the self_id ones) have always already been processed. */
593 }
594
595 OGLRender *oglrender = static_cast<OGLRender *>(cb_data->user_data);
596
597 /* Whitelist of datablocks to follow pointers into. */
598 const ID_Type id_type = id->id_type();
599 switch (id_type) {
600 /* Whitelist: */
601 case ID_ME: /* Mesh */
602 case ID_CU_LEGACY: /* Curve */
603 case ID_MB: /* MetaBall */
604 case ID_MA: /* Material */
605 case ID_TE: /* Tex (Texture) */
606 case ID_IM: /* Image */
607 case ID_LT: /* Lattice */
608 case ID_LA: /* Light */
609 case ID_CA: /* Camera */
610 case ID_KE: /* Key (shape key) */
611 case ID_VF: /* VFont (Vector Font) */
612 case ID_TXT: /* Text */
613 case ID_SPK: /* Speaker */
614 case ID_SO: /* Sound */
615 case ID_AR: /* bArmature */
616 case ID_NT: /* bNodeTree */
617 case ID_PA: /* ParticleSettings */
618 case ID_MC: /* MovieClip */
619 case ID_MSK: /* Mask */
620 case ID_LP: /* LightProbe */
621 case ID_CV: /* Curves */
622 case ID_PT: /* PointCloud */
623 case ID_VO: /* Volume */
624 break;
625
626 /* Blacklist: */
627 case ID_SCE: /* Scene */
628 case ID_LI: /* Library */
629 case ID_OB: /* Object */
630 case ID_WO: /* World */
631 case ID_SCR: /* Screen */
632 case ID_GR: /* Group */
633 case ID_AC: /* bAction */
634 case ID_BR: /* Brush */
635 case ID_WM: /* WindowManager */
636 case ID_LS: /* FreestyleLineStyle */
637 case ID_PAL: /* Palette */
638 case ID_PC: /* PaintCurve */
639 case ID_CF: /* CacheFile */
640 case ID_WS: /* WorkSpace */
641 /* Only follow pointers to specific datablocks, to avoid ending up in
642 * unrelated datablocks and exploding the number of blocks we follow. If the
643 * frames of the animation of certain objects should be taken into account,
644 * they should have been selected by the user. */
646
647 /* Special cases: */
648 case ID_GD_LEGACY: /* bGPdata, (Grease Pencil) */
649 /* In addition to regular ID's animdata, GreasePencil uses a specific frame-based animation
650 * system that requires specific handling here. */
651 gather_frames_to_render_for_grease_pencil(oglrender, id_cast<bGPdata *>(id));
652 break;
653 case ID_GP:
654 /* TODO: gather frames. */
655 break;
656 }
657
659 gather_frames_to_render_for_adt(oglrender, adt);
660
661 return IDWALK_RET_NOP;
662}
663
672{
673 const ScenePlaybackRange playback_range = BKE_scene_get_playback_range(oglrender->scene);
674
675 /* Will be freed in screen_opengl_render_end(). */
676 oglrender->render_frames = BLI_BITMAP_NEW(
677 playback_range.end_frame - playback_range.start_frame + 1, "OGLRender::render_frames");
678
679 /* The first frame should always be rendered, otherwise there is nothing to write to file. */
680 BLI_BITMAP_ENABLE(oglrender->render_frames, 0);
681
682 CTX_DATA_BEGIN (C, Object *, ob, selected_objects) {
683 ID *id = &ob->id;
684
685 /* Gather the frames from the object animation data. */
687 gather_frames_to_render_for_adt(oglrender, adt);
688
689 /* Gather the frames from linked data-blocks (materials, shape-keys, etc.). */
691 nullptr, id, gather_frames_to_render_for_id, oglrender, IDWALK_RECURSE);
692 }
694}
695
697{
698 /* new render clears all callbacks */
700 wmWindow *win = CTX_wm_window(C);
701 WorkSpace *workspace = CTX_wm_workspace(C);
702
703 const bool is_sequencer = RNA_boolean_get(op->ptr, "sequencer");
704
705 Scene *scene = !is_sequencer ? CTX_data_scene(C) : CTX_data_sequencer_scene(C);
706 if (!scene) {
707 return false;
708 }
709 ScrArea *prev_area = CTX_wm_area(C);
710 ARegion *prev_region = CTX_wm_region(C);
711 GPUOffScreen *ofs;
712 OGLRender *oglrender;
713 int sizex, sizey;
714 bool is_view_context = RNA_boolean_get(op->ptr, "view_context");
715 const bool is_animation = RNA_boolean_get(op->ptr, "animation");
716 const bool is_render_keyed_only = RNA_boolean_get(op->ptr, "render_keyed_only");
717 const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
718 const eImageFormatDepth color_depth = is_animation ?
721 char err_out[256] = "unknown";
722
723 if (G.background) {
725 op->reports, RPT_ERROR, "Cannot use OpenGL render in background mode (no opengl context)");
726 return false;
727 }
728
729 /* only one render job at a time */
731 return false;
732 }
733
734 if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {
736 op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
737 return false;
738 }
739
740 if (is_sequencer) {
741 is_view_context = false;
742 }
743 else {
744 /* ensure we have a 3d view */
746 RNA_boolean_set(op->ptr, "view_context", false);
747 is_view_context = false;
748 }
749
750 if (!is_view_context && scene->camera == nullptr) {
751 BKE_report(op->reports, RPT_ERROR, "Scene has no camera");
752 return false;
753 }
754 }
755
756 /* stop all running jobs, except screen one. currently previews frustrate Render */
758
759 /* create offscreen buffer */
760 BKE_render_resolution(&scene->r, false, &sizex, &sizey);
761
762 /* corrects render size with actual size, not every card supports non-power-of-two dimensions */
763 DRW_gpu_context_enable(); /* Off-screen creation needs to be done in DRW context. */
764 ofs = GPU_offscreen_create(sizex,
765 sizey,
766 true,
767 gpu::TextureFormat::SFLOAT_16_16_16_16,
769 false,
770 err_out);
772
773 if (!ofs) {
774 BKE_reportf(op->reports, RPT_ERROR, "Failed to create OpenGL off-screen buffer, %s", err_out);
775 CTX_wm_area_set(C, prev_area);
776 CTX_wm_region_set(C, prev_region);
777 return false;
778 }
779
780 Main *bmain = CTX_data_main(C);
782
783 /* allocate opengl render */
784 oglrender = MEM_new<OGLRender>("OGLRender");
785 op->customdata = oglrender;
786
787 oglrender->ofs = ofs;
788 oglrender->sizex = sizex;
789 oglrender->sizey = sizey;
790 oglrender->viewport = GPU_viewport_create();
791 oglrender->bmain = bmain;
792 oglrender->scene = scene;
793 oglrender->current_scene = scene;
794 oglrender->workspace = workspace;
795 oglrender->view_layer = CTX_data_view_layer(C);
796 /* NOTE: The depsgraph is not only used to update scene for a new frames, but also to initialize
797 * output video handles, which does need evaluated scene. */
799 oglrender->cfrao = scene->r.cfra;
800
801 oglrender->write_still = is_write_still && !is_animation;
802 oglrender->is_animation = is_animation;
803 oglrender->color_depth = color_depth;
804
805 oglrender->views_len = BKE_scene_multiview_num_views_get(&scene->r);
806
807 oglrender->is_sequencer = is_sequencer;
808 if (is_sequencer) {
809 oglrender->sseq = CTX_wm_space_seq(C);
810 ImBuf **ibufs_arr = MEM_new_array_zeroed<ImBuf *>(oglrender->views_len, __func__);
811 oglrender->seq_data.ibufs_arr = ibufs_arr;
812 }
813
814 if (is_view_context) {
815 /* Prefer rendering camera in quad view if possible. */
816 if (!ED_view3d_context_user_region(C, &oglrender->v3d, &oglrender->region)) {
817 /* If not get region activated by ED_view3d_context_activate earlier. */
818 oglrender->v3d = CTX_wm_view3d(C);
819 oglrender->region = CTX_wm_region(C);
820 }
821
822 oglrender->rv3d = static_cast<RegionView3D *>(oglrender->region->regiondata);
823
824 /* MUST be cleared on exit */
826 ED_view3d_datamask(*oglrender->bmain,
827 oglrender->scene,
828 oglrender->view_layer,
829 oglrender->v3d,
830 &oglrender->scene->customdata_mask_modal);
831
832 /* apply immediately in case we're rendering from a script,
833 * running notifiers again will overwrite */
835 &oglrender->scene->customdata_mask_modal);
836 }
837
838 /* create render */
839 oglrender->re = RE_NewSceneRender(scene);
840
841 /* create image and image user */
842 oglrender->ima = BKE_image_ensure_viewer(oglrender->bmain, IMA_TYPE_R_RESULT, "Render Result");
843 BKE_image_signal(oglrender->bmain, oglrender->ima, nullptr, IMA_SIGNAL_FREE);
844 BKE_image_backup_render(oglrender->scene, oglrender->ima, true);
845
846 oglrender->iuser.scene = scene;
847
848 /* create render result */
850 oglrender->re, nullptr, &scene->r, &scene->view_layers, nullptr, sizex, sizey, nullptr);
851
852 /* create render views */
853 screen_opengl_views_setup(oglrender);
854
855 /* wm vars */
856 oglrender->wm = wm;
857 oglrender->win = win;
858
859 if (is_animation) {
860 if (is_render_keyed_only) {
861 gather_frames_to_render(C, oglrender);
862 }
863
866 }
867 else {
868 oglrender->task_pool = BLI_task_pool_create(oglrender, TASK_PRIORITY_HIGH);
869 }
870 }
871
872 CTX_wm_area_set(C, prev_area);
873 CTX_wm_region_set(C, prev_region);
874
875 return true;
876}
877
878static void screen_opengl_render_end(OGLRender *oglrender)
879{
880 /* Ensure we don't call this both from the job and operator callbacks. */
881 if (oglrender->ended) {
882 return;
883 }
884
885 if (oglrender->task_pool) {
886 /* Trickery part for movie output:
887 *
888 * We MUST write frames in an exact order, so we only let background
889 * thread to work on that, and main thread is simply waits for that
890 * thread to do all the dirty work.
891 *
892 * After this loop is done work_and_wait() will have nothing to do,
893 * so we don't run into wrong order of frames written to the stream.
894 */
895 if (BKE_imtype_is_movie(oglrender->scene->r.im_format.imtype)) {
896 std::unique_lock lock(oglrender->task_mutex);
897 while (oglrender->num_scheduled_frames > 0) {
898 oglrender->task_condition.wait(lock);
899 }
900 }
901
903 BLI_task_pool_free(oglrender->task_pool);
904 oglrender->task_pool = nullptr;
905 }
906
907 MEM_SAFE_DELETE(oglrender->render_frames);
908
909 if (!oglrender->movie_writers.is_empty()) {
910 if (BKE_imtype_is_movie(oglrender->scene->r.im_format.imtype)) {
911 for (MovieWriter *writer : oglrender->movie_writers) {
912 MOV_write_end(writer);
913 }
914 }
915 oglrender->movie_writers.clear_and_shrink();
916 }
917
918 if (oglrender->ofs || oglrender->viewport) {
920 GPU_offscreen_free(oglrender->ofs);
921 GPU_viewport_free(oglrender->viewport);
923
924 oglrender->ofs = nullptr;
925 oglrender->viewport = nullptr;
926 }
927
928 MEM_SAFE_DELETE(oglrender->seq_data.ibufs_arr);
929
931
932 if (oglrender->wm_job) { /* exec will not have a job */
933 Depsgraph *depsgraph = oglrender->depsgraph;
934 oglrender->scene->r.cfra = oglrender->cfrao;
936 }
937 else if (oglrender->win) {
938 WM_cursor_modal_restore(oglrender->win);
939 }
940
942 G.is_rendering = false;
943 oglrender->ended = true;
944}
945
947{
949 OGLRender *oglrender = static_cast<OGLRender *>(op->customdata);
950
951 if (oglrender->is_animation) {
953 }
954
955 screen_opengl_render_end(oglrender);
956 MEM_delete(oglrender);
957}
958
959/* share between invoke and exec */
961{
962 /* initialize animation */
963 OGLRender *oglrender = static_cast<OGLRender *>(op->customdata);
964 Scene *scene = oglrender->scene;
965
966 if (!(scene->r.mode & R_SAVE_OUTPUT)) {
967 BKE_report(op->reports, RPT_ERROR, "Render output disabled in Output properties");
968 return false;
969 }
970
971 ImageFormatData image_format;
972 BKE_image_format_init_for_write(&image_format, scene, nullptr, true);
973
974 oglrender->totvideos = BKE_scene_multiview_num_videos_get(&scene->r, &image_format);
975 oglrender->reports = op->reports;
976
977 if (BKE_imtype_is_movie(image_format.imtype)) {
978 size_t width, height;
979 int i;
980
982 &scene->r, &image_format, oglrender->sizex, oglrender->sizey, &width, &height);
983 oglrender->movie_writers.reserve(oglrender->totvideos);
984
985 const bool is_multiview_name = ((scene->r.scemode & R_MULTIVIEW) != 0 &&
986 (image_format.views_format == R_IMF_VIEWS_INDIVIDUAL));
987
988 for (i = 0; i < oglrender->totvideos; i++) {
989 Scene *scene_eval = DEG_get_evaluated_scene(oglrender->depsgraph);
990 const char *suffix = is_multiview_name ?
992 "";
993 MovieWriter *writer = BKE_blender_project_read_callback(
994 oglrender->bmain, [&](const bke::BlenderProject *project) {
995 return MOV_write_begin(scene_eval,
996 project,
997 &scene->r,
998 &image_format,
999 width,
1000 height,
1001 oglrender->reports,
1002 PRVRANGEON != 0,
1003 suffix);
1004 });
1005 if (writer == nullptr) {
1006 BKE_image_format_free(&image_format);
1007 screen_opengl_render_end(oglrender);
1008 MEM_delete(oglrender);
1009 return false;
1010 }
1011 oglrender->movie_writers.append(writer);
1012 }
1013 }
1014
1015 BKE_image_format_free(&image_format);
1016
1017 G.is_rendering = true;
1018 oglrender->cfrao = scene->r.cfra;
1019 const int playback_start = scene->playback_start();
1020 oglrender->nfra = playback_start;
1021 scene->r.cfra = playback_start;
1022
1023 return true;
1024}
1025
1031
1033 TaskPool *__restrict pool,
1034 WriteTaskData *task_data)
1035{
1036 OGLRender *oglrender = static_cast<OGLRender *>(BLI_task_pool_user_data(pool));
1037 Scene *scene = &task_data->tmp_scene;
1038 RenderResult *rr = task_data->rr;
1039 const bool is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);
1040 const int cfra = scene->r.cfra;
1041 bool ok;
1042 /* Don't attempt to write if we've got an error. */
1043 if (!oglrender->pool_ok) {
1045 std::scoped_lock lock(oglrender->task_mutex);
1046 oglrender->num_scheduled_frames--;
1047 oglrender->task_condition.notify_all();
1048 return;
1049 }
1050 /* Construct local thread0safe copy of reports structure which we can
1051 * safely pass to the underlying functions.
1052 */
1053 ReportList reports;
1054 BKE_reports_init(&reports, oglrender->reports->flag & ~RPT_PRINT);
1055 /* Do actual save logic here, depending on the file format.
1056 *
1057 * NOTE: We have to construct temporary scene with proper scene->r.cfra.
1058 * This is because underlying calls do not use r.cfra but use scene
1059 * for that.
1060 */
1061 if (is_movie) {
1062 ok = RE_WriteRenderViewsMovie(&reports,
1063 rr,
1064 project,
1065 scene,
1066 &scene->r,
1067 oglrender->movie_writers.data(),
1068 oglrender->totvideos,
1069 PRVRANGEON != 0);
1070 }
1071 else {
1072 /* TODO(sergey): We can in theory save some CPU ticks here because we
1073 * calculate file name again here.
1074 */
1075 char filepath[FILE_MAX];
1076 path_templates::VariableMap template_variables;
1077 BKE_add_template_variables_general(template_variables, &scene->id, project);
1078 BKE_add_template_variables_for_render_path(template_variables, *scene);
1079
1080 const char *relbase = BKE_main_blendfile_path(oglrender->bmain);
1082 filepath,
1083 scene->r.pic,
1084 relbase,
1085 &template_variables,
1086 cfra,
1087 &scene->r.im_format,
1088 (scene->r.scemode & R_EXTENSION) != 0,
1089 true,
1090 nullptr);
1091
1092 if (!errors.is_empty()) {
1093 BKE_report_path_template_errors(&reports, RPT_ERROR, scene->r.pic, errors);
1094 ok = false;
1095 }
1096 else {
1097 BKE_render_result_stamp_info(scene, scene->camera, rr, false);
1098 ok = BKE_image_render_write(nullptr, rr, scene, true, filepath);
1099 }
1100
1101 if (!ok) {
1102 BKE_reportf(&reports, RPT_ERROR, "Write error: cannot save %s", filepath);
1103 }
1104 }
1105 if (reports.list.first() != nullptr) {
1106 /* TODO: Should rather use new #BKE_reports_move_to_reports ? */
1107 std::unique_lock lock(oglrender->reports_mutex);
1108 for (Report *report = reports.list.first(); report != nullptr; report = report->next) {
1109 BKE_report(oglrender->reports, static_cast<eReportType>(report->type), report->message);
1110 }
1111 }
1112 BKE_reports_free(&reports);
1113 if (!ok) {
1114 oglrender->pool_ok = false;
1115 }
1117
1118 {
1119 std::unique_lock lock(oglrender->task_mutex);
1120 oglrender->num_scheduled_frames--;
1121 oglrender->task_condition.notify_all();
1122 }
1123}
1124
1125static void write_result_func(TaskPool *__restrict pool, void *task_data_v)
1126{
1127 /* Isolate task so that multithreaded image operations don't cause this thread to start
1128 * writing another frame. If that happens we may reach the MAX_SCHEDULED_FRAMES limit,
1129 * and cause the render thread and writing threads to deadlock waiting for each other. */
1130 WriteTaskData *task_data = static_cast<WriteTaskData *>(task_data_v);
1133 write_result(project, pool, task_data);
1134 });
1135 });
1136}
1137
1139{
1140 if (!oglrender->pool_ok) {
1142 return false;
1143 }
1144 Scene *scene = oglrender->scene;
1145 WriteTaskData *task_data = MEM_new<WriteTaskData>("write task data");
1146 task_data->bmain = oglrender->bmain;
1147 task_data->rr = rr;
1148 task_data->tmp_scene = dna::shallow_copy(*scene);
1149 {
1150 std::unique_lock lock(oglrender->task_mutex);
1151 oglrender->num_scheduled_frames++;
1152 if (oglrender->num_scheduled_frames > MAX_SCHEDULED_FRAMES) {
1153 oglrender->task_condition.wait(lock);
1154 }
1155 }
1156 BLI_task_pool_push(oglrender->task_pool, write_result_func, task_data, true, nullptr);
1157 return true;
1158}
1159
1161 OGLRender *oglrender)
1162{
1163 Scene *scene = oglrender->scene;
1164 Depsgraph *depsgraph = oglrender->depsgraph;
1165 char filepath[FILE_MAX];
1166 bool ok = false;
1167 const bool view_context = (oglrender->v3d != nullptr);
1168 bool is_movie;
1169 RenderResult *rr;
1170
1171 /* go to next frame */
1172 if (scene->r.cfra < oglrender->nfra) {
1173 scene->r.cfra++;
1174 }
1175 while (scene->r.cfra < oglrender->nfra) {
1177 scene->r.cfra++;
1178 }
1179
1180 is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);
1181
1182 if (!is_movie) {
1183 path_templates::VariableMap template_variables;
1184 BKE_add_template_variables_general(template_variables, &scene->id, project);
1185 BKE_add_template_variables_for_render_path(template_variables, *scene);
1186
1187 const char *relbase = BKE_main_blendfile_path(oglrender->bmain);
1189 filepath,
1190 scene->r.pic,
1191 relbase,
1192 &template_variables,
1193 scene->r.cfra,
1194 &scene->r.im_format,
1195 (scene->r.scemode & R_EXTENSION) != 0,
1196 true,
1197 nullptr);
1198
1199 if (!errors.is_empty()) {
1200 std::unique_lock lock(oglrender->reports_mutex);
1201 BKE_report_path_template_errors(oglrender->reports, RPT_ERROR, scene->r.pic, errors);
1202 ok = false;
1203 }
1204 else if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(filepath)) {
1205 {
1206 std::unique_lock lock(oglrender->reports_mutex);
1207 BKE_reportf(oglrender->reports, RPT_INFO, "Skipping existing frame \"%s\"", filepath);
1208 }
1209 ok = true;
1210 goto finally;
1211 }
1212 }
1213
1214 if (!oglrender->wm_job && oglrender->win) {
1215 /* When doing blocking animation render without a job from a Python script, show time cursor so
1216 * Blender doesn't appear frozen. */
1217 WM_cursor_time(oglrender->win, scene->r.cfra);
1218 }
1219
1221
1222 if (view_context) {
1223 if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera &&
1224 oglrender->v3d->scenelock)
1225 {
1226 /* since BKE_scene_graph_update_for_newframe() is used rather
1227 * then ED_update_for_newframe() the camera needs to be set */
1228 if (BKE_scene_camera_switch_update(scene)) {
1229 oglrender->v3d->camera = scene->camera;
1230 }
1231 }
1232 }
1233 else {
1235 }
1236
1237 if (oglrender->render_frames == nullptr ||
1238 BLI_BITMAP_TEST_BOOL(oglrender->render_frames, scene->r.cfra - scene->playback_start()))
1239 {
1240 /* render into offscreen buffer */
1242 }
1243
1244 /* save to disk */
1245 rr = RE_AcquireResultRead(oglrender->re);
1246 {
1248 RE_ReleaseResult(oglrender->re);
1249
1250 ok = schedule_write_result(oglrender, new_rr);
1251 }
1252
1253finally: /* Step the frame and bail early if needed */
1254
1255 /* go to next frame */
1256 oglrender->nfra += scene->r.frame_step;
1257
1258 /* stop at the end or on error */
1259 if (scene->r.cfra >= scene->playback_end() || !ok) {
1260 return false;
1261 }
1262
1263 return true;
1264}
1265
1267 wmOperator *op,
1268 const wmEvent *event)
1269{
1270 OGLRender *oglrender = static_cast<OGLRender *>(op->customdata);
1271
1272 /* Still render completes immediately, but still modal to show some feedback
1273 * in case render initialization takes a while. */
1274 if (!oglrender->is_animation) {
1277 });
1278 screen_opengl_render_end(oglrender);
1279 MEM_delete(oglrender);
1280 return OPERATOR_FINISHED;
1281 }
1282
1283 /* no running blender, remove handler and pass through */
1285 screen_opengl_render_end(oglrender);
1286 MEM_delete(oglrender);
1288 }
1289
1290 /* catch escape key. */
1292}
1293
1294static void opengl_render_startjob(void *customdata, wmJobWorkerStatus *worker_status)
1295{
1296 OGLRender *oglrender = static_cast<OGLRender *>(customdata);
1297 Scene *scene = oglrender->scene;
1298
1299 bool canceled = false;
1300 bool finished = false;
1301 const ScenePlaybackRange playback_range = BKE_scene_get_playback_range(scene);
1302
1303 while (!finished && !canceled) {
1304 /* Render while blocking main thread, since we use 3D viewport resources. */
1306
1307 if (worker_status->stop || G.is_break) {
1308 canceled = true;
1309 }
1310 else {
1312 finished = !screen_opengl_render_anim_step(project, oglrender);
1313 });
1314 worker_status->progress = float(scene->r.cfra - playback_range.start_frame + 1) /
1315 float(playback_range.end_frame - playback_range.start_frame + 1);
1316 worker_status->do_update = true;
1317 }
1318
1320
1321 if (worker_status->stop || G.is_break) {
1322 canceled = true;
1323 }
1324 }
1325
1326 if (canceled) {
1327 /* Cancel task pool writing images asynchronously. */
1328 oglrender->pool_ok = false;
1329 }
1330}
1331
1332static void opengl_render_freejob(void *customdata)
1333{
1334 /* End the render here, as the modal handler might be called with the window out of focus. */
1335 OGLRender *oglrender = static_cast<OGLRender *>(customdata);
1336 screen_opengl_render_end(oglrender);
1337}
1338
1340 wmOperator *op,
1341 const wmEvent *event)
1342{
1343 const bool anim = RNA_boolean_get(op->ptr, "animation");
1344
1345 if (!screen_opengl_render_init(C, op)) {
1346 return OPERATOR_CANCELLED;
1347 }
1348
1349 if (anim) {
1351 return OPERATOR_CANCELLED;
1352 }
1353 }
1354
1355 OGLRender *oglrender = static_cast<OGLRender *>(op->customdata);
1356 render_view_open(C, event->xy[0], event->xy[1], op->reports);
1357
1358 /* View may be changed above #USER_RENDER_DISPLAY_WINDOW. */
1359 oglrender->win = CTX_wm_window(C);
1360
1361 /* Setup animation job. */
1362 if (anim) {
1363 G.is_break = false;
1364
1365 wmJob *wm_job = WM_jobs_get(CTX_wm_manager(C),
1367 oglrender->scene,
1368 "Rendering viewport...",
1371
1372 oglrender->wm_job = wm_job;
1373
1375 WM_jobs_timer(wm_job, 0.01f, NC_SCENE | ND_RENDER_RESULT, 0);
1376 WM_jobs_callbacks(wm_job, opengl_render_startjob, nullptr, nullptr, nullptr);
1377 WM_jobs_start(CTX_wm_manager(C), wm_job);
1378 }
1379
1381
1383}
1384
1385/* executes blocking render */
1387{
1388 if (!screen_opengl_render_init(C, op)) {
1389 return OPERATOR_CANCELLED;
1390 }
1391
1392 const Main *bmain = CTX_data_main(C);
1393
1394 OGLRender *oglrender = static_cast<OGLRender *>(op->customdata);
1395
1396 if (!oglrender->is_animation) { /* same as invoke */
1399 });
1400 screen_opengl_render_end(oglrender);
1401 MEM_delete(oglrender);
1402
1403 return OPERATOR_FINISHED;
1404 }
1405
1406 bool ret = true;
1407
1409 return OPERATOR_CANCELLED;
1410 }
1411
1413 while (ret) {
1415 }
1416 });
1417
1418 screen_opengl_render_end(oglrender);
1419 MEM_delete(oglrender);
1420
1421 return OPERATOR_FINISHED;
1422}
1423
1425 wmOperatorType * /*ot*/,
1426 PointerRNA *ptr)
1427{
1428 if (!RNA_boolean_get(ptr, "animation")) {
1429 return "";
1430 }
1431
1432 if (RNA_boolean_get(ptr, "render_keyed_only")) {
1433 return TIP_(
1434 "Render the viewport for the animation range of this scene, but only render keyframes of "
1435 "selected objects");
1436 }
1437
1438 return TIP_("Render the viewport for the animation range of this scene");
1439}
1440
1442{
1443 PropertyRNA *prop;
1444
1445 /* identifiers */
1446 ot->name = "Viewport Render";
1447 ot->description = "Take a snapshot of the active viewport";
1448 ot->idname = "RENDER_OT_opengl";
1449
1450 /* API callbacks. */
1453 ot->exec = screen_opengl_render_exec; /* blocking */
1456
1458
1459 prop = RNA_def_boolean(ot->srna,
1460 "animation",
1461 false,
1462 "Animation",
1463 "Render files from the animation range of this scene");
1465
1466 prop = RNA_def_boolean(ot->srna,
1467 "render_keyed_only",
1468 false,
1469 "Render Keyframes Only",
1470 "Render only those frames where selected objects have a key in their "
1471 "animation data. Only used when rendering animation");
1473
1474 prop = RNA_def_boolean(
1475 ot->srna, "sequencer", false, "Sequencer", "Render using the sequencer's OpenGL display");
1477 prop = RNA_def_boolean(
1478 ot->srna,
1479 "write_still",
1480 false,
1481 "Write Image",
1482 "Save the rendered image to the output path (used only when animation is disabled)");
1484 prop = RNA_def_boolean(ot->srna,
1485 "view_context",
1486 true,
1487 "View Context",
1488 "Use the current 3D view for rendering, else use scene settings");
1490}
1491
1492} // namespace blender
Functions to work with AnimData.
Camera data-block and utility functions.
#define CTX_DATA_BEGIN(C, Type, instance, member)
#define CTX_DATA_END
CustomData interface, see also DNA_customdata_types.h.
#define IMA_SIGNAL_FREE
Definition BKE_image.hh:179
#define BLI_BITMAP_NEW(_num, _alloc_string)
Definition BLI_bitmap.hh:39
#define BLI_BITMAP_ENABLE(_bitmap, _index)
Definition BLI_bitmap.hh:80
#define BLI_BITMAP_TEST_BOOL(_bitmap, _index)
Definition BLI_bitmap.hh:73
File and directory operations.
#define FILE_MAX
#define STRNCPY_UTF8(dst, src)
#define TIP_(msgid)
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define CLOG_INFO_NOCHECK(clg_ref, format,...)
Definition CLG_log.h:204
Object is a sort of wrapper for general info.
#define R_STAMP_ALL
#define V3D_CAMERA_SCENE(scene, v3d)
#define PRVRANGEON
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define ND_RENDER_RESULT
Definition WM_types.hh:465
#define NC_SCENE
Definition WM_types.hh:391
volatile int lock
#define UNUSED_FUNCTION(x)
#define ELEM(...)
bool is_empty() const
void append(const T &value)
void reserve(const int64_t min_capacity)
#define offsetof(t, d)
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
Span< FCurve * > fcurves_for_assigned_action(AnimData *adt)
Definition animdata.cc:349
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
Definition DNA_defs.h:147
ImBuf * render_give_ibuf(const RenderData *context, float timeline_frame, int chanshown)
Definition render.cc:2139
void render_new_render_data(Main *bmain, Depsgraph *depsgraph, Scene *scene, int rectx, int recty, eSpaceSeq_Proxy_RenderSize preview_render_size, Render *render, RenderData *r_context)
Definition render.cc:194
auto isolate_task(const Function &function)
Definition BLI_task.hh:224
BMesh Iterators.
void DRW_gpu_context_enable()
bool BKE_scene_multiview_is_render_view_active(const RenderData *rd, const SceneRenderView *srv)
Definition scene.cc:3241
void RE_SetActiveRenderView(Render *re, const char *viewname)
void CustomData_MeshMasks_update(CustomData_MeshMasks *mask_dst, const CustomData_MeshMasks *mask_src)
Definition customdata.cc:89
bool ED_view3d_context_user_region(bContext *C, View3D **r_v3d, ARegion **r_region)
void WM_main_add_notifier(uint type, void *reference)
static void opengl_render_startjob(void *customdata, wmJobWorkerStatus *worker_status)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ SEQ_RENDER_SIZE_SCENE
static void write_result(const bke::BlenderProject *project, TaskPool *__restrict pool, WriteTaskData *task_data)
void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph)
Definition scene.cc:2953
ImBuf * ED_view3d_draw_offscreen_imbuf(Depsgraph *depsgraph, Scene *scene, eDrawType drawtype, View3D *v3d, ARegion *region, int sizex, int sizey, ImBufFlags imbuf_flag, int alpha_mode, const char *viewname, bool restore_rv3d_mats, GPUOffScreen *ofs, GPUViewport *viewport, bool use_camera_view_bounds, char err_out[256])
static wmOperatorStatus screen_opengl_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
ScrArea * CTX_wm_area(const bContext *C)
static wmOperatorStatus screen_opengl_render_exec(bContext *C, wmOperator *op)
void GPU_offscreen_free(GPUOffScreen *offscreen)
void RE_SetOverrideCamera(Render *re, Object *cam_ob)
Definition initrender.cc:37
bool ED_editors_flush_edits(Main *bmain)
Definition ed_util.cc:335
void WM_job_main_thread_lock_acquire(wmJob *wm_job)
Definition wm_jobs.cc:162
Scene * CTX_data_sequencer_scene(const bContext *C)
bool BKE_image_render_write(ReportList *reports, RenderResult *rr, const Scene *scene, bool stamp, const char *filepath_basis, const ImageFormatData *format=nullptr, bool save_as_render=true)
static bool screen_opengl_is_multiview(OGLRender *oglrender)
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition wm_jobs.cc:407
void WM_jobs_kill_all_except(wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:633
unsigned int uint
Definition BKE_text.h:55
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static bool screen_opengl_render_anim_step(const bke::BlenderProject *project, OGLRender *oglrender)
void GPU_clear_color(float red, float green, float blue, float alpha)
WorkSpace * CTX_wm_workspace(const bContext *C)
void BKE_add_template_variables_general(bke::path_templates::VariableMap &variables, const ID *path_owner_id, const bke::BlenderProject *project)
void BKE_reports_free(ReportList *reports)
Definition report.cc:106
MINLINE int round_fl_to_int(float a)
void RE_render_result_rect_from_ibuf(RenderResult *rr, const ImBuf *ibuf, const int view_id)
void BKE_image_signal(Main *bmain, Image *ima, ImageUser *iuser, int signal)
static void gather_frames_to_render_for_adt(const OGLRender *oglrender, const AnimData *adt)
@ TASK_PRIORITY_HIGH
Definition BLI_task_c.hh:61
void BKE_render_result_stamp_info(Scene *scene, Object *camera, RenderResult *rr, bool allocate_only)
void BKE_reports_init(ReportList *reports, int flag)
Definition report.cc:91
bool BLI_exists(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition storage.cc:404
@ WM_JOB_TYPE_RENDER
Definition WM_api.hh:2011
GPUBackendType GPU_backend_get_type()
static bool schedule_write_result(OGLRender *oglrender, RenderResult *rr)
static void screen_opengl_render_write(const bke::BlenderProject *project, OGLRender *oglrender)
void GPU_clear_depth(float depth)
MINLINE void blend_color_mix_byte(unsigned char dst[4], const unsigned char src1[4], const unsigned char src2[4])
void GPU_render_step(bool force_resource_release=false)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
static void UNUSED_FUNCTION addAlphaOverFloat(float dest[4], const float source[4])
void BKE_report_path_template_errors(ReportList *reports, eReportType report_type, StringRef path, Span< bke::path_templates::Error > errors)
@ V3D_OFSDRAW_SHOW_ANNOTATION
void BKE_image_stamp_buf(Scene *scene, Object *camera, const StampData *stamp_data_template, ImBuf *ibuf)
static void gather_frames_to_render(bContext *C, OGLRender *oglrender)
wmWindow * CTX_wm_window(const bContext *C)
static void screen_opengl_views_setup(OGLRender *oglrender)
Vector< bke::path_templates::Error > BKE_image_path_from_imformat(char *filepath, const char *base, const char *relbase, const bke::path_templates::VariableMap *template_variables, int frame, const ImageFormatData *im_format, bool use_ext, bool use_frames, const char *suffix)
auto BKE_blender_project_read_callback(const Main *bmain, Fn lambda)
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
ScrArea * render_view_open(bContext *C, int mx, int my, ReportList *reports)
int BKE_scene_multiview_num_views_get(const RenderData *rd)
Definition scene.cc:3193
@ WM_JOB_PRIORITY
Definition WM_api.hh:1990
@ WM_JOB_EXCL_RENDER
Definition WM_api.hh:1995
@ WM_JOB_PROGRESS
Definition WM_api.hh:1997
ViewLayer * CTX_data_view_layer(const bContext *C)
void BKE_render_resolution(const RenderData *r, const bool use_crop, int *r_width, int *r_height)
Definition scene.cc:3168
SpaceSeq * CTX_wm_space_seq(const bContext *C)
void BKE_scene_graph_evaluated_ensure(Depsgraph *depsgraph, Main *bmain)
Definition scene.cc:2872
ImBuf * IMB_dupImBuf(const ImBuf *ibuf1)
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:498
ScenePlaybackRange BKE_scene_get_playback_range(const Scene *scene)
Definition scene.cc:2607
void BLI_task_pool_work_and_wait(TaskPool *pool)
Definition task_pool.cc:455
void * BLI_task_pool_user_data(TaskPool *pool)
Definition task_pool.cc:460
void MOV_write_end(MovieWriter *writer)
void BKE_add_template_variables_for_render_path(bke::path_templates::VariableMap &variables, const Scene &scene)
Global G
Definition blender.cc:57
const char * BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL()
Definition main.cc:1058
void RE_FreeRenderResult(RenderResult *rr)
void wmOrtho2(float x1, float x2, float y1, float y2)
const char * RE_GetActiveRenderView(Render *re)
static void screen_opengl_render_end(OGLRender *oglrender)
static wmOperatorStatus screen_opengl_render_modal(bContext *C, wmOperator *op, const wmEvent *event)
AnimData * BKE_animdata_from_id(const ID *id)
Definition anim_data.cc:93
static bool screen_opengl_render_init(bContext *C, wmOperator *op)
void DRW_gpu_context_disable()
static void opengl_render_freejob(void *customdata)
TaskPool * BLI_task_pool_create_background_serial(void *userdata, eTaskPriority priority)
Definition task_pool.cc:436
void IMB_freeImBuf(ImBuf *ibuf)
struct Object * BKE_camera_multiview_render(const Main &bmain, const struct Scene *scene, struct Object *camera, const char *viewname)
unsigned char uchar
Definition BKE_text.h:58
void GPU_offscreen_unbind(GPUOffScreen *offscreen, bool restore)
@ GPU_TEXTURE_USAGE_SHADER_READ
@ GPU_TEXTURE_USAGE_HOST_READ
RenderResult * RE_AcquireResultWrite(Render *re)
static void gather_frames_to_render_for_grease_pencil(const OGLRender *oglrender, const bGPdata *gp)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
bool WM_jobs_has_running(const wmWindowManager *window_manager, const void *owner, const eWM_JobType type, const eWM_JobFlag exclude_flags)
Definition wm_jobs.cc:809
static void write_result_func(TaskPool *__restrict pool, void *task_data_v)
bool RE_WriteRenderViewsMovie(ReportList *reports, RenderResult *rr, const bke::BlenderProject *project, Scene *scene, const RenderData *rd, MovieWriter **movie_writers, const int totvideos, bool preview)
wmWindowManager * CTX_wm_manager(const bContext *C)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
static int gather_frames_to_render_for_id(LibraryIDLinkCallbackData *cb_data)
bool ED_view3d_context_activate(bContext *C)
@ SEQ_PREVIEW_SHOW_GPENCIL
const char * BKE_scene_multiview_view_id_suffix_get(const RenderData *rd, int view_id)
Definition scene.cc:3407
static bool screen_opengl_render_anim_init(wmOperator *op)
void WM_cursor_modal_restore(wmWindow *win)
void WM_cursor_time(wmWindow *win, int nr)
static void screen_opengl_render_doit(OGLRender *oglrender, RenderResult *rr)
void GPU_offscreen_bind(GPUOffScreen *offscreen, bool save)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void ED_view3d_datamask(const Main &bmain, const Scene *scene, ViewLayer *view_layer, const View3D *v3d, CustomData_MeshMasks *r_cddata_masks)
void GPU_matrix_translate_2f(float x, float y)
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
bool BKE_scene_multiview_is_stereo3d(const RenderData *rd)
Definition scene.cc:3224
void BLI_task_pool_free(TaskPool *pool)
Definition task_pool.cc:441
void BKE_image_format_free(ImageFormatData *imf)
void BKE_scene_multiview_videos_dimensions_get(const RenderData *rd, const ImageFormatData *imf, size_t width, size_t height, size_t *r_width, size_t *r_height)
Definition scene.cc:3448
void BKE_image_format_init_for_write(ImageFormatData *imf, const Scene *scene_src, const ImageFormatData *imf_src, const bool allow_video=false)
static void screen_opengl_render_apply(const bke::BlenderProject *project, OGLRender *oglrender)
void RENDER_OT_opengl(wmOperatorType *ot)
static void screen_opengl_render_cancel(bContext *C, wmOperator *op)
void BKE_image_backup_render(Scene *scene, Image *ima, bool free_current_slot)
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
bool BKE_imtype_is_movie(char imtype)
RenderResult * RE_AcquireResultRead(Render *re)
TaskPool * BLI_task_pool_create(void *userdata, eTaskPriority priority)
Definition task_pool.cc:404
int BKE_scene_multiview_num_videos_get(const RenderData *rd, const ImageFormatData *imf)
Definition scene.cc:3469
void RE_InitState(Render *re, Render *source, const RenderData *rd, ListBaseT< ViewLayer > *, ViewLayer *single_layer, int winx, int winy, const rcti *disprect)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
void WM_jobs_kill_type(wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:642
void GPU_viewport_free(GPUViewport *viewport)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
void GPU_flush()
Definition gpu_state.cc:284
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
unsigned int BLI_bitmap
Definition BLI_bitmap.hh:15
@ G_FLAG_RENDER_VIEWPORT
Main * CTX_data_main(const bContext *C)
@ IDWALK_RET_STOP_RECURSION
void IMB_byte_from_float(ImBuf *ibuf)
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, const eWM_JobFlag flag, const eWM_JobType job_type)
Definition wm_jobs.cc:228
bool BKE_scene_camera_switch_update(Scene *scene)
Definition scene.cc:2480
std::mutex Mutex
Definition BLI_mutex.hh:51
Image * BKE_image_ensure_viewer(Main *bmain, int type, const char *name)
Render * RE_NewSceneRender(const Scene *scene)
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
@ R_IMF_VIEWS_INDIVIDUAL
static CLG_LogRef LOG
Definition logging.cpp:12
void ED_annotation_draw_ex(Scene *scene, bGPdata *gpd, int winx, int winy, const int cfra, const char spacetype)
void GPU_matrix_reset()
Definition gpu_matrix.cc:87
Scene * CTX_data_scene(const bContext *C)
bScreen * CTX_wm_screen(const bContext *C)
static std::string screen_opengl_render_get_description(bContext *, wmOperatorType *, PointerRNA *ptr)
void CTX_wm_region_set(bContext *C, ARegion *region)
void WM_job_main_thread_lock_release(wmJob *wm_job)
Definition wm_jobs.cc:167
int BKE_fcurve_bezt_binarysearch_index(const BezTriple array[], float frame, int arraylen, bool *r_replace)
GPUOffScreen * GPU_offscreen_create(int width, int height, bool with_depth_buffer, gpu::TextureFormat format, eGPUTextureUsage usage, bool clear, char err_out[256])
LibraryForeachIDCallbackFlag
@ IDWALK_CB_LOOPBACK
ImBuf * ED_view3d_draw_offscreen_imbuf_simple(Depsgraph *depsgraph, Scene *scene, View3DShading *shading_override, eDrawType drawtype, Object *camera, int width, int height, ImBufFlags imbuf_flags, eV3DOffscreenDrawFlag draw_flags, int alpha_mode, const char *viewname, GPUOffScreen *ofs, GPUViewport *viewport, char err_out[256])
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
Scene * DEG_get_evaluated_scene(const Depsgraph *graph)
RenderResult * RE_DuplicateRenderResult(RenderResult *rr)
void BLI_task_pool_push(TaskPool *pool, TaskRunFunction run, void *taskdata, bool free_taskdata, TaskFreeFunction freedata)
Definition task_pool.cc:446
void BKE_library_foreach_ID_link(Main *bmain, ID *id, FunctionRef< LibraryIDLinkCallback > callback, void *user_data, LibraryForeachIDFlag flag)
Definition lib_query.cc:449
ARegion * CTX_wm_region(const bContext *C)
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
void IMB_free_float_pixels(ImBuf *ibuf)
View3D * CTX_wm_view3d(const bContext *C)
bool ED_operator_screenactive(bContext *C)
GPUViewport * GPU_viewport_create()
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void CTX_wm_area_set(bContext *C, ScrArea *area)
void GPU_offscreen_read_color(GPUOffScreen *offscreen, eGPUDataFormat data_format, void *r_data)
#define MAX_SCHEDULED_FRAMES
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
uint8_t * byte_data_for_write()
Definition allocimbuf.cc:60
const float * float_data() const
eImageFormat_ViewsFormat views_format
eImageUser_Flag flag
struct Scene * scene
LibraryForeachIDCallbackFlag cb_flag
BLI_bitmap * render_frames
eImageFormatDepth color_depth
wmWindowManager * wm
GPUViewport * viewport
struct blender::OGLRender::@051054064130315042007016251162371344101331254324 seq_data
Vector< MovieWriter * > movie_writers
RegionView3D * rv3d
std::condition_variable task_condition
GPUOffScreen * ofs
eRegionView3D_Persp persp
ListBaseT< SceneRenderView > views
ImageFormatData im_format
ListBaseT< RenderView > views
struct ImBuf * ibuf
Definition RE_pipeline.h:54
struct RenderView * next
Definition RE_pipeline.h:46
struct RenderView * prev
Definition RE_pipeline.h:46
ListBaseT< Report > list
Definition BKE_report.hh:79
ListBaseT< ViewLayer > view_layers
struct Object * camera
struct CustomData_MeshMasks customdata_mask
struct CustomData_MeshMasks customdata_mask_modal
struct RenderData r
eSpaceSeq_SequencerPreviewOverlay_Flag flag
struct SequencerPreviewOverlay preview_overlay
struct bGPdata * gpd
struct Object * camera
View3DShading shading
ListBaseT< bGPDframe > frames
ListBaseT< bGPDlayer > layers
wmEventType type
Definition WM_types.hh:817
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
void(*) cancel(bContext *C, wmOperator *op)
Definition WM_types.hh:1149
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
std::string(*) get_description(bContext *C, wmOperatorType *ot, PointerRNA *ptr)
Definition WM_types.hh:1197
struct ReportList * reports