9#include <condition_variable>
96#define MAX_SCHEDULED_FRAMES 8
167 if ((rd ==
nullptr) || ((v3d !=
nullptr) && (rv3d ==
nullptr))) {
192 rv = rr->
views.first();
195 rv = MEM_new<RenderView>(
"new opengl render view");
214 rv = rr->
views.last();
243 rv = MEM_new<RenderView>(
"new opengl render view");
257 *oglrender->
bmain, oglrender->
scene, v3d->
camera,
"new opengl render view");
271 int sizex = oglrender->
sizex;
272 int sizey = oglrender->
sizey;
273 ImBuf *ibuf_result =
nullptr;
326 for (i = 0; i < sizex * sizey * 4; i += 4) {
337 Depsgraph *depsgraph = oglrender->
depsgraph;
338 char err_out[256] =
"unknown";
347 if (v3d !=
nullptr) {
390 ibuf_result = ibuf_view;
393 CLOG_ERROR(&
LOG,
"%s: failed to get buffer, %s", __func__, err_out);
397 if (ibuf_result !=
nullptr) {
459 CLOG_ERROR(&
LOG,
"OpenGL Render failed to write '%s'", filepath);
468 mul = 1.0f - source[3];
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];
487 int chanshown = sseq ? sseq->
chanshown : 0;
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;
503 &context, scene->
r.
cfra, chanshown);
508 for (rv = rr->
views.first(), view_id = 0; rv; rv = rv->
next, view_id++) {
525 if (adt ==
nullptr || adt->
action ==
nullptr) {
529 const int frame_start = oglrender->
scene->playback_start();
530 const int frame_end = oglrender->
scene->playback_end();
533 if (fcu->driver !=
nullptr || fcu->fpt !=
nullptr) {
542 fcu->bezt, frame_start, fcu->totvert, &found);
543 for (; key_index < fcu->totvert; key_index++) {
551 if (frame_nr > frame_end) {
566 const int frame_start = oglrender->
scene->playback_start();
567 const int frame_end = oglrender->
scene->playback_end();
582 if (*id_p ==
nullptr) {
598 const ID_Type id_type =
id->id_type();
721 char err_out[256] =
"unknown";
725 op->
reports,
RPT_ERROR,
"Cannot use OpenGL render in background mode (no opengl context)");
736 op->
reports,
RPT_ERROR,
"Cannot write a single file with an animation format selected");
741 is_view_context =
false;
747 is_view_context =
false;
750 if (!is_view_context && scene->
camera ==
nullptr) {
767 gpu::TextureFormat::SFLOAT_16_16_16_16,
784 oglrender = MEM_new<OGLRender>(
"OGLRender");
787 oglrender->
ofs = ofs;
788 oglrender->
sizex = sizex;
789 oglrender->
sizey = sizey;
791 oglrender->
bmain = bmain;
792 oglrender->
scene = scene;
801 oglrender->
write_still = is_write_still && !is_animation;
811 oglrender->
seq_data.ibufs_arr = ibufs_arr;
814 if (is_view_context) {
850 oglrender->
re,
nullptr, &scene->
r, &scene->
view_layers,
nullptr, sizex, sizey,
nullptr);
857 oglrender->
win = win;
860 if (is_render_keyed_only) {
881 if (oglrender->
ended) {
924 oglrender->
ofs =
nullptr;
928 MEM_SAFE_DELETE(oglrender->
seq_data.ibufs_arr);
933 Depsgraph *depsgraph = oglrender->
depsgraph;
937 else if (oglrender->
win) {
942 G.is_rendering =
false;
943 oglrender->
ended =
true;
956 MEM_delete(oglrender);
978 size_t width, height;
982 &scene->
r, &image_format, oglrender->
sizex, oglrender->
sizey, &width, &height);
988 for (i = 0; i < oglrender->
totvideos; i++) {
990 const char *suffix = is_multiview_name ?
995 return MOV_write_begin(scene_eval,
1005 if (writer ==
nullptr) {
1008 MEM_delete(oglrender);
1017 G.is_rendering =
true;
1019 const int playback_start = scene->playback_start();
1020 oglrender->
nfra = playback_start;
1021 scene->
r.
cfra = playback_start;
1040 const int cfra = scene->
r.
cfra;
1085 &template_variables,
1105 if (reports.
list.first() !=
nullptr) {
1108 for (
Report *report = reports.
list.first(); report !=
nullptr; report = report->next) {
1133 write_result(project, pool, task_data);
1145 WriteTaskData *task_data = MEM_new<WriteTaskData>(
"write task data");
1164 Depsgraph *depsgraph = oglrender->
depsgraph;
1167 const bool view_context = (oglrender->
v3d !=
nullptr);
1175 while (scene->
r.
cfra < oglrender->
nfra) {
1192 &template_variables,
1214 if (!oglrender->
wm_job && oglrender->
win) {
1259 if (scene->
r.
cfra >= scene->playback_end() || !ok) {
1279 MEM_delete(oglrender);
1286 MEM_delete(oglrender);
1299 bool canceled =
false;
1300 bool finished =
false;
1303 while (!finished && !canceled) {
1307 if (worker_status->
stop ||
G.is_break) {
1312 finished = !screen_opengl_render_anim_step(project, oglrender);
1321 if (worker_status->
stop ||
G.is_break) {
1368 "Rendering viewport...",
1372 oglrender->
wm_job = wm_job;
1401 MEM_delete(oglrender);
1419 MEM_delete(oglrender);
1434 "Render the viewport for the animation range of this scene, but only render keyframes of "
1435 "selected objects");
1438 return TIP_(
"Render the viewport for the animation range of this scene");
1446 ot->
name =
"Viewport Render";
1447 ot->
description =
"Take a snapshot of the active viewport";
1448 ot->
idname =
"RENDER_OT_opengl";
1463 "Render files from the animation range of this scene");
1467 "render_keyed_only",
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");
1475 ot->
srna,
"sequencer",
false,
"Sequencer",
"Render using the sequencer's OpenGL display");
1482 "Save the rendered image to the output path (used only when animation is disabled)");
1488 "Use the current 3D view for rendering, else use scene settings");
Functions to work with AnimData.
Camera data-block and utility functions.
#define CTX_DATA_BEGIN(C, Type, instance, member)
CustomData interface, see also DNA_customdata_types.h.
#define BLI_BITMAP_NEW(_num, _alloc_string)
#define BLI_BITMAP_ENABLE(_bitmap, _index)
#define BLI_BITMAP_TEST_BOOL(_bitmap, _index)
File and directory operations.
#define STRNCPY_UTF8(dst, src)
#define CLOG_ERROR(clg_ref,...)
#define CLOG_INFO_NOCHECK(clg_ref, format,...)
Object is a sort of wrapper for general info.
#define V3D_CAMERA_SCENE(scene, v3d)
Read Blender memory allocation and freeing.
#define UNUSED_FUNCTION(x)
void append(const T &value)
void reserve(const int64_t min_capacity)
void camera(KernelGlobals &kg, const ShadingData &sd, float3 &outview, float &outdepth, float &outdist)
Span< FCurve * > fcurves_for_assigned_action(AnimData *adt)
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
ImBuf * render_give_ibuf(const RenderData *context, float timeline_frame, int chanshown)
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)
auto isolate_task(const Function &function)
void DRW_gpu_context_enable()
bool BKE_scene_multiview_is_render_view_active(const RenderData *rd, const SceneRenderView *srv)
void RE_SetActiveRenderView(Render *re, const char *viewname)
void CustomData_MeshMasks_update(CustomData_MeshMasks *mask_dst, const CustomData_MeshMasks *mask_src)
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)
static void write_result(const bke::BlenderProject *project, TaskPool *__restrict pool, WriteTaskData *task_data)
void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph)
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)
bool ED_editors_flush_edits(Main *bmain)
void WM_job_main_thread_lock_acquire(wmJob *wm_job)
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 *))
void WM_jobs_kill_all_except(wmWindowManager *wm, const void *owner)
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)
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)
void BKE_render_result_stamp_info(Scene *scene, Object *camera, RenderResult *rr, bool allocate_only)
void BKE_reports_init(ReportList *reports, int flag)
bool BLI_exists(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
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)
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))
ScrArea * render_view_open(bContext *C, int mx, int my, ReportList *reports)
int BKE_scene_multiview_num_views_get(const RenderData *rd)
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)
SpaceSeq * CTX_wm_space_seq(const bContext *C)
void BKE_scene_graph_evaluated_ensure(Depsgraph *depsgraph, Main *bmain)
ImBuf * IMB_dupImBuf(const ImBuf *ibuf1)
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
ScenePlaybackRange BKE_scene_get_playback_range(const Scene *scene)
void BLI_task_pool_work_and_wait(TaskPool *pool)
void * BLI_task_pool_user_data(TaskPool *pool)
void MOV_write_end(MovieWriter *writer)
void BKE_add_template_variables_for_render_path(bke::path_templates::VariableMap &variables, const Scene &scene)
const char * BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL()
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)
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)
void IMB_freeImBuf(ImBuf *ibuf)
struct Object * BKE_camera_multiview_render(const Main &bmain, const struct Scene *scene, struct Object *camera, const char *viewname)
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)
void BKE_report(ReportList *reports, eReportType type, const char *message)
bool WM_jobs_has_running(const wmWindowManager *window_manager, const void *owner, const eWM_JobType type, const eWM_JobFlag exclude_flags)
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)
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)
void BLI_task_pool_free(TaskPool *pool)
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)
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)
int BKE_scene_multiview_num_videos_get(const RenderData *rd, const ImageFormatData *imf)
void RE_InitState(Render *re, Render *source, const RenderData *rd, ListBaseT< ViewLayer > *, ViewLayer *single_layer, int winx, int winy, const rcti *disprect)
void RE_ReleaseResultImage(Render *re)
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)
void GPU_viewport_free(GPUViewport *viewport)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
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)
bool BKE_scene_camera_switch_update(Scene *scene)
Image * BKE_image_ensure_viewer(Main *bmain, int type, const char *name)
Render * RE_NewSceneRender(const Scene *scene)
void ED_annotation_draw_ex(Scene *scene, bGPdata *gpd, int winx, int winy, const int cfra, const char spacetype)
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)
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])
void RE_ReleaseResult(Render *re)
LibraryForeachIDCallbackFlag
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)
void BKE_library_foreach_ID_link(Main *bmain, ID *id, FunctionRef< LibraryIDLinkCallback > callback, void *user_data, LibraryForeachIDFlag flag)
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 *))
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()
const float * float_data() const
LibraryForeachIDCallbackFlag cb_flag
BLI_bitmap * render_frames
eImageFormatDepth color_depth
uint num_scheduled_frames
struct blender::OGLRender::@051054064130315042007016251162371344101331254324 seq_data
Vector< MovieWriter * > movie_writers
std::condition_variable task_condition
eRegionView3D_Persp persp
ListBaseT< SceneRenderView > views
ImageFormatData im_format
ListBaseT< RenderView > views
ListBaseT< ViewLayer > view_layers
struct CustomData_MeshMasks customdata_mask
struct CustomData_MeshMasks customdata_mask_modal
eSpaceSeq_SequencerPreviewOverlay_Flag flag
struct SequencerPreviewOverlay preview_overlay
ListBaseT< bGPDframe > frames
ListBaseT< bGPDlayer > layers
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
void(*) cancel(bContext *C, wmOperator *op)
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
std::string(*) get_description(bContext *C, wmOperatorType *ot, PointerRNA *ptr)
struct ReportList * reports