/* using context, starts job */
static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
{
/* new render clears all callbacks */
Main *mainp;
Scene *scene= CTX_data_scene(C);
SceneRenderLayer *srl=NULL;
bScreen *screen= CTX_wm_screen(C);
View3D *v3d= CTX_wm_view3d(C);
Render *re;
wmJob *steve;
RenderJob *rj;
Image *ima;
int jobflag;
const short is_animation= RNA_boolean_get(op->ptr, "animation");
const short is_write_still= RNA_boolean_get(op->ptr, "write_still");
struct Object *camera_override= v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
/* only one render job at a time */
if(WM_jobs_test(CTX_wm_manager(C), scene))
return OPERATOR_CANCELLED;
if(!RE_is_rendering_allowed(scene, camera_override, op->reports)) {
return OPERATOR_CANCELLED;
}
if(!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.imtype)) {
BKE_report(op->reports, RPT_ERROR, "Can't write a single file with an animation format selected.");
return OPERATOR_CANCELLED;
}
/* stop all running jobs, currently previews frustrate Render */
WM_jobs_stop_all(CTX_wm_manager(C));
/* get main */
if(G.rt == 101) {
/* thread-safety experiment, copy main from the undo buffer */
mainp= BKE_undo_get_main(&scene);
}
else
mainp= CTX_data_main(C);
/* cancel animation playback */
if (screen->animtimer)
ED_screen_animation_play(C, 0, 0);
/* handle UI stuff */
WM_cursor_wait(1);
/* flush multires changes (for sculpt) */
multires_force_render_update(CTX_data_active_object(C));
/* cleanup sequencer caches before starting user triggered render.
otherwise, invalidated cache entries can make their way into
the output rendering. We can't put that into RE_BlenderFrame,
since sequence rendering can call that recursively... (peter) */
seq_stripelem_cache_cleanup();
/* get editmode results */
ED_object_exit_editmode(C, 0); /* 0 = does not exit editmode */
// store spare
// get view3d layer, local layer, make this nice api call to render
// store spare
/* ensure at least 1 area shows result */
render_view_open(C, event->x, event->y);
jobflag= WM_JOB_EXCL_RENDER|WM_JOB_PRIORITY|WM_JOB_PROGRESS;
/* single layer re-render */
if(RNA_property_is_set(op->ptr, "layer")) {
SceneRenderLayer *rl;
Scene *scn;
char scene_name[MAX_ID_NAME-2], rl_name[RE_MAXNAME];
RNA_string_get(op->ptr, "layer", rl_name);
RNA_string_get(op->ptr, "scene", scene_name);
scn = (Scene *)BLI_findstring(&mainp->scene, scene_name, offsetof(ID, name) + 2);
rl = (SceneRenderLayer *)BLI_findstring(&scene->r.layers, rl_name, offsetof(SceneRenderLayer, name));
if (scn && rl) {
/* camera switch wont have updated */
scn->r.cfra= scene->r.cfra;
scene_camera_switch_update(scn);
scene = scn;
srl = rl;
}
jobflag |= WM_JOB_SUSPEND;
}
/* job custom data */
rj= MEM_callocN(sizeof(RenderJob), "render job");
rj->main= mainp;
rj->scene= scene;
rj->win= CTX_wm_window(C);
rj->srl = srl;
rj->camera_override = camera_override;
rj->lay = (v3d)? v3d->lay: scene->lay;
rj->anim= is_animation;
rj->write_still= is_write_still && !is_animation;
rj->iuser.scene= scene;
rj->iuser.ok= 1;
rj->reports= op->reports;
/* setup job */
steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Render", jobflag);
WM_jobs_customdata(steve, rj, render_freejob);
WM_jobs_timer(steve, 0.2, NC_SCENE|ND_RENDER_RESULT, 0);
WM_jobs_callbacks(steve, render_startjob, NULL, NULL, render_endjob);
/* get a render result image, and make sure it is empty */
ima= BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
BKE_image_backup_render(rj->scene, ima);
rj->image= ima;
/* setup new render */
re= RE_NewRender(scene->id.name);
RE_test_break_cb(re, rj, render_breakjob);
RE_draw_lock_cb(re, rj, render_drawlock);
RE_display_draw_cb(re, rj, image_rect_update);
RE_stats_draw_cb(re, rj, image_renderinfo_cb);
RE_progress_cb(re, rj, render_progress_update);
rj->re= re;
G.afbreek= 0;
WM_jobs_start(CTX_wm_manager(C), steve);
WM_cursor_wait(0);
WM_event_add_notifier(C, NC_SCENE|ND_RENDER_RESULT, scene);
/* we set G.rendering here already instead of only in the job, this ensure
main loop or other scene updates are disabled in time, since they may
have started before the job thread */
G.rendering = 1;
/* add modal handler for ESC */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
/* using context, starts job */
static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
/* new render clears all callbacks */
Main *mainp;
Scene *scene = CTX_data_scene(C);
SceneRenderLayer *srl = NULL;
View3D *v3d = CTX_wm_view3d(C);
Render *re;
wmJob *wm_job;
RenderJob *rj;
Image *ima;
int jobflag;
const short is_animation = RNA_boolean_get(op->ptr, "animation");
const short is_write_still = RNA_boolean_get(op->ptr, "write_still");
struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
const char *name;
Object *active_object = CTX_data_active_object(C);
/* only one render job at a time */
if (WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER))
return OPERATOR_CANCELLED;
if (!RE_is_rendering_allowed(scene, camera_override, op->reports)) {
return OPERATOR_CANCELLED;
}
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 OPERATOR_CANCELLED;
}
/* stop all running jobs, except screen one. currently previews frustrate Render */
WM_jobs_kill_all_except(CTX_wm_manager(C), CTX_wm_screen(C));
/* get main */
if (G.debug_value == 101) {
/* thread-safety experiment, copy main from the undo buffer */
mainp = BKE_undo_get_main(&scene);
}
else
mainp = CTX_data_main(C);
/* cancel animation playback */
if (ED_screen_animation_playing(CTX_wm_manager(C)))
ED_screen_animation_play(C, 0, 0);
/* handle UI stuff */
WM_cursor_wait(1);
/* flush multires changes (for sculpt) */
multires_force_render_update(active_object);
/* flush changes from dynamic topology sculpt */
sculptsession_bm_to_me_for_render(active_object);
/* cleanup sequencer caches before starting user triggered render.
* otherwise, invalidated cache entries can make their way into
* the output rendering. We can't put that into RE_BlenderFrame,
* since sequence rendering can call that recursively... (peter) */
BKE_sequencer_cache_cleanup();
/* get editmode results */
ED_object_editmode_load(CTX_data_edit_object(C));
// store spare
// get view3d layer, local layer, make this nice api call to render
// store spare
/* ensure at least 1 area shows result */
render_view_open(C, event->x, event->y);
jobflag = WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS;
/* custom scene and single layer re-render */
screen_render_scene_layer_set(op, mainp, &scene, &srl);
if (RNA_struct_property_is_set(op->ptr, "layer"))
jobflag |= WM_JOB_SUSPEND;
/* job custom data */
rj = MEM_callocN(sizeof(RenderJob), "render job");
rj->main = mainp;
rj->scene = scene;
rj->win = CTX_wm_window(C);
rj->srl = srl;
rj->camera_override = camera_override;
rj->lay = scene->lay;
rj->anim = is_animation;
rj->write_still = is_write_still && !is_animation;
rj->iuser.scene = scene;
rj->iuser.ok = 1;
rj->reports = op->reports;
if (v3d) {
rj->lay = v3d->lay;
if (v3d->localvd)
rj->lay |= v3d->localvd->lay;
}
/* setup job */
if (RE_seq_render_active(scene, &scene->r)) name = "Sequence Render";
else name = "Render";
wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, name, jobflag, WM_JOB_TYPE_RENDER);
WM_jobs_customdata_set(wm_job, rj, render_freejob);
WM_jobs_timer(wm_job, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
WM_jobs_callbacks(wm_job, render_startjob, NULL, NULL, render_endjob);
/* get a render result image, and make sure it is empty */
ima = BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
BKE_image_backup_render(rj->scene, ima);
rj->image = ima;
/* setup new render */
re = RE_NewRender(scene->id.name);
RE_test_break_cb(re, rj, render_breakjob);
RE_draw_lock_cb(re, rj, render_drawlock);
RE_display_draw_cb(re, rj, image_rect_update);
RE_stats_draw_cb(re, rj, image_renderinfo_cb);
RE_progress_cb(re, rj, render_progress_update);
rj->re = re;
G.is_break = FALSE;
/* store actual owner of job, so modal operator could check for it,
* the reason of this is that active scene could change when rendering
* several layers from compositor [#31800]
*/
op->customdata = scene;
WM_jobs_start(CTX_wm_manager(C), wm_job);
WM_cursor_wait(0);
WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
/* we set G.is_rendering here already instead of only in the job, this ensure
* main loop or other scene updates are disabled in time, since they may
* have started before the job thread */
G.is_rendering = TRUE;
/* add modal handler for ESC */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
/* using context, starts job */
static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
/* new render clears all callbacks */
Main *mainp;
Scene *scene = CTX_data_scene(C);
SceneRenderLayer *srl = NULL;
Render *re;
wmJob *wm_job;
RenderJob *rj;
Image *ima;
int jobflag;
const bool is_animation = RNA_boolean_get(op->ptr, "animation");
const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
const bool use_viewport = RNA_boolean_get(op->ptr, "use_viewport");
View3D *v3d = use_viewport ? CTX_wm_view3d(C) : NULL;
struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;
const char *name;
ScrArea *sa;
/* only one render job at a time */
if (WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER))
return OPERATOR_CANCELLED;
if (RE_force_single_renderlayer(scene))
WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, NULL);
if (!RE_is_rendering_allowed(scene, camera_override, op->reports)) {
return OPERATOR_CANCELLED;
}
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 OPERATOR_CANCELLED;
}
/* stop all running jobs, except screen one. currently previews frustrate Render */
WM_jobs_kill_all_except(CTX_wm_manager(C), CTX_wm_screen(C));
/* get main */
if (G.debug_value == 101) {
/* thread-safety experiment, copy main from the undo buffer */
mainp = BKE_undo_get_main(&scene);
}
else
mainp = CTX_data_main(C);
/* cancel animation playback */
if (ED_screen_animation_playing(CTX_wm_manager(C)))
ED_screen_animation_play(C, 0, 0);
/* handle UI stuff */
WM_cursor_wait(1);
/* flush sculpt and editmode changes */
ED_editors_flush_edits(C, true);
/* cleanup sequencer caches before starting user triggered render.
* otherwise, invalidated cache entries can make their way into
* the output rendering. We can't put that into RE_BlenderFrame,
* since sequence rendering can call that recursively... (peter) */
BKE_sequencer_cache_cleanup();
// store spare
// get view3d layer, local layer, make this nice api call to render
// store spare
/* ensure at least 1 area shows result */
sa = render_view_open(C, event->x, event->y);
jobflag = WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS;
/* custom scene and single layer re-render */
screen_render_scene_layer_set(op, mainp, &scene, &srl);
if (RNA_struct_property_is_set(op->ptr, "layer"))
jobflag |= WM_JOB_SUSPEND;
/* job custom data */
rj = MEM_callocN(sizeof(RenderJob), "render job");
rj->main = mainp;
rj->scene = scene;
rj->current_scene = rj->scene;
rj->srl = srl;
rj->camera_override = camera_override;
rj->lay_override = 0;
rj->anim = is_animation;
rj->write_still = is_write_still && !is_animation;
rj->iuser.scene = scene;
rj->iuser.ok = 1;
rj->reports = op->reports;
rj->orig_layer = 0;
rj->last_layer = 0;
rj->sa = sa;
BKE_color_managed_display_settings_copy(&rj->display_settings, &scene->display_settings);
BKE_color_managed_view_settings_copy(&rj->view_settings, &scene->view_settings);
if (sa) {
SpaceImage *sima = sa->spacedata.first;
rj->orig_layer = sima->iuser.layer;
}
if (v3d) {
if (scene->lay != v3d->lay) {
rj->lay_override = v3d->lay;
rj->v3d_override = true;
}
else if (camera_override && camera_override != scene->camera)
rj->v3d_override = true;
if (v3d->localvd)
rj->lay_override |= v3d->localvd->lay;
}
/* Lock the user interface depending on render settings. */
if (scene->r.use_lock_interface) {
int renderlay = rj->lay_override ? rj->lay_override : scene->lay;
WM_set_locked_interface(CTX_wm_manager(C), true);
/* Set flag interface need to be unlocked.
*
* This is so because we don't have copy of render settings
* accessible from render job and copy is needed in case
* of non-locked rendering, so we wouldn't try to unlock
* anything if option was initially unset but then was
* enabled during rendering.
*/
rj->interface_locked = true;
/* Clean memory used by viewport? */
clean_viewport_memory(rj->main, scene, renderlay);
}
/* setup job */
if (RE_seq_render_active(scene, &scene->r)) name = "Sequence Render";
else name = "Render";
wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, name, jobflag, WM_JOB_TYPE_RENDER);
WM_jobs_customdata_set(wm_job, rj, render_freejob);
WM_jobs_timer(wm_job, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
WM_jobs_callbacks(wm_job, render_startjob, NULL, NULL, render_endjob);
/* get a render result image, and make sure it is empty */
ima = BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
BKE_image_signal(ima, NULL, IMA_SIGNAL_FREE);
BKE_image_backup_render(rj->scene, ima);
rj->image = ima;
/* setup new render */
re = RE_NewRender(scene->id.name);
RE_test_break_cb(re, rj, render_breakjob);
RE_draw_lock_cb(re, rj, render_drawlock);
RE_display_update_cb(re, rj, image_rect_update);
RE_current_scene_update_cb(re, rj, current_scene_update);
RE_stats_draw_cb(re, rj, image_renderinfo_cb);
RE_progress_cb(re, rj, render_progress_update);
rj->re = re;
G.is_break = false;
/* store actual owner of job, so modal operator could check for it,
* the reason of this is that active scene could change when rendering
* several layers from compositor [#31800]
*/
op->customdata = scene;
WM_jobs_start(CTX_wm_manager(C), wm_job);
WM_cursor_wait(0);
WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
/* we set G.is_rendering here already instead of only in the job, this ensure
* main loop or other scene updates are disabled in time, since they may
* have started before the job thread */
G.is_rendering = true;
/* add modal handler for ESC */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
