//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Returns: the current frame index inside the sequence
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int BlenderSession::load_internal_mb_sequence(bool &stop_render, BL::RenderLayer *layer) {
stop_render = false;
int cur_frame = b_scene.frame_current();
float frames_cnt = shuttertime / mb_frame_time_sampling;
int first_frame, last_frame;
if(mb_direction == AFTER) {
first_frame = cur_frame;
last_frame = static_cast<int>(ceilf(static_cast<float>(cur_frame)+frames_cnt));
}
else if(mb_direction == BEFORE) {
first_frame = static_cast<int>(floorf(static_cast<float>(cur_frame)-frames_cnt));
last_frame = cur_frame;
}
else if(mb_direction == SYMMETRIC) {
first_frame = static_cast<int>(floorf(static_cast<float>(cur_frame)-frames_cnt / 2));
last_frame = static_cast<int>(ceilf(static_cast<float>(cur_frame)+frames_cnt / 2));
}
CLAMP(first_frame, b_scene.frame_start(), b_scene.frame_end());
CLAMP(last_frame, b_scene.frame_start(), b_scene.frame_end());
double last_cfra;
for(int cur_mb_frame = first_frame; cur_mb_frame <= last_frame; ++cur_mb_frame) {
//b_scene.frame_set(cur_mb_frame, 0); //Crashes due to BPy_BEGIN_ALLOW_THREADS-BPy_END_ALLOW_THREADS block in rna_Scene_frame_set()
last_cfra = (double)cur_mb_frame;
CLAMP(last_cfra, MINAFRAME, MAXFRAME);
BKE_scene_frame_set((::Scene *)b_scene.ptr.data, last_cfra);
BKE_scene_update_for_newframe_ex(G.main->eval_ctx, G.main, (::Scene *)b_scene.ptr.data, (1 << 20) - 1, true);
BKE_scene_camera_switch_update((::Scene *)b_scene.ptr.data);
sync->sync_data(b_v3d, b_engine.camera_override(), layer);
sync->sync_camera(b_engine.camera_override(), width, height);
session->update_scene_to_server(cur_mb_frame - first_frame, last_frame - first_frame + 1);
if(!interactive && session->progress.get_cancel()) {
stop_render = true;
break;
}
}
//b_scene.frame_set(cur_frame, 0); //Crashes due to BPy_BEGIN_ALLOW_THREADS-BPy_END_ALLOW_THREADS block in rna_Scene_frame_set()
double cfra = (double)cur_frame;
CLAMP(cfra, MINAFRAME, MAXFRAME);
if(last_cfra != cfra) {
BKE_scene_frame_set((::Scene *)b_scene.ptr.data, cfra);
BKE_scene_update_for_newframe_ex(G.main->eval_ctx, G.main, (::Scene *)b_scene.ptr.data, (1 << 20) - 1, true);
BKE_scene_camera_switch_update((::Scene *)b_scene.ptr.data);
}
return cur_frame - first_frame;
} //load_internal_mb_sequence()
static void screen_render_scene_layer_set(wmOperator *op, Main *mainp, Scene **scene, SceneRenderLayer **srl)
{
/* single layer re-render */
if (RNA_struct_property_is_set(op->ptr, "scene")) {
Scene *scn;
char scene_name[MAX_ID_NAME - 2];
RNA_string_get(op->ptr, "scene", scene_name);
scn = (Scene *)BLI_findstring(&mainp->scene, scene_name, offsetof(ID, name) + 2);
if (scn) {
/* camera switch wont have updated */
scn->r.cfra = (*scene)->r.cfra;
BKE_scene_camera_switch_update(scn);
*scene = scn;
}
}
if (RNA_struct_property_is_set(op->ptr, "layer")) {
SceneRenderLayer *rl;
char rl_name[RE_MAXNAME];
RNA_string_get(op->ptr, "layer", rl_name);
rl = (SceneRenderLayer *)BLI_findstring(&(*scene)->r.layers, rl_name, offsetof(SceneRenderLayer, name));
if (rl)
*srl = rl;
}
}
/* note, init has to be called succesfully */
static void ed_marker_move_apply(bContext *C, wmOperator *op)
{
#ifdef DURIAN_CAMERA_SWITCH
bScreen *sc = CTX_wm_screen(C);
Scene *scene = CTX_data_scene(C);
Object *camera = scene->camera;
#endif
MarkerMove *mm = op->customdata;
TimeMarker *marker;
int a, offs;
offs = RNA_int_get(op->ptr, "frames");
for (a = 0, marker = mm->markers->first; marker; marker = marker->next) {
if (marker->flag & SELECT) {
marker->frame = mm->oldframe[a] + offs;
a++;
}
}
WM_event_add_notifier(C, NC_SCENE | ND_MARKERS, NULL);
WM_event_add_notifier(C, NC_ANIMATION | ND_MARKERS, NULL);
#ifdef DURIAN_CAMERA_SWITCH
/* so we get view3d redraws */
BKE_scene_camera_switch_update(scene);
if (camera != scene->camera) {
BKE_screen_view3d_scene_sync(sc);
WM_event_add_notifier(C, NC_SCENE | NA_EDITED, scene);
}
#endif
}
static void rna_Scene_frame_set(Scene *scene, int frame, float subframe)
{
double cfra = (double)frame + (double)subframe;
CLAMP(cfra, MINAFRAME, MAXFRAME);
BKE_scene_frame_set(scene, cfra);
#ifdef WITH_PYTHON
BPy_BEGIN_ALLOW_THREADS;
#endif
/* It's possible that here we're including layers which were never visible before. */
BKE_scene_update_for_newframe_ex(G.main->eval_ctx, G.main, scene, (1 << 20) - 1, true);
#ifdef WITH_PYTHON
BPy_END_ALLOW_THREADS;
#endif
BKE_scene_camera_switch_update(scene);
/* don't do notifier when we're rendering, avoid some viewport crashes
* redrawing while the data is being modified for render */
if (!G.is_rendering) {
/* cant use NC_SCENE|ND_FRAME because this causes wm_event_do_notifiers to call
* BKE_scene_update_for_newframe which will loose any un-keyed changes [#24690] */
/* WM_main_add_notifier(NC_SCENE|ND_FRAME, scene); */
/* instead just redraw the views */
WM_main_add_notifier(NC_WINDOW, NULL);
}
}
static void rna_Scene_frame_set(Scene *scene, int frame, float subframe)
{
double cfra = (double)frame + (double)subframe;
CLAMP(cfra, MINAFRAME, MAXFRAME);
BKE_scene_frame_set(scene, cfra);
BKE_scene_update_for_newframe(G.main, scene, (1 << 20) - 1);
BKE_scene_camera_switch_update(scene);
/* don't do notifier when we're rendering, avoid some viewport crashes
* redrawing while the data is being modified for render */
if (!G.is_rendering) {
/* cant use NC_SCENE|ND_FRAME because this causes wm_event_do_notifiers to call
* BKE_scene_update_for_newframe which will loose any un-keyed changes [#24690] */
/* WM_main_add_notifier(NC_SCENE|ND_FRAME, scene); */
/* instead just redraw the views */
WM_main_add_notifier(NC_WINDOW, NULL);
}
}
void RE_engine_frame_set(RenderEngine *engine, int frame, float subframe)
{
Render *re = engine->re;
Scene *scene = re->scene;
double cfra = (double)frame + (double)subframe;
CLAMP(cfra, MINAFRAME, MAXFRAME);
BKE_scene_frame_set(scene, cfra);
#ifdef WITH_PYTHON
BPy_BEGIN_ALLOW_THREADS;
#endif
/* It's possible that here we're including layers which were never visible before. */
BKE_scene_update_for_newframe_ex(re->eval_ctx, re->main, scene, (1 << 20) - 1, true);
#ifdef WITH_PYTHON
BPy_END_ALLOW_THREADS;
#endif
BKE_scene_camera_switch_update(scene);
}
static int ed_marker_camera_bind_exec(bContext *C, wmOperator *UNUSED(op))
{
bScreen *sc = CTX_wm_screen(C);
Scene *scene = CTX_data_scene(C);
Object *ob = CTX_data_active_object(C);
ListBase *markers = ED_context_get_markers(C);
TimeMarker *marker;
marker = ED_markers_get_first_selected(markers);
if (marker == NULL)
return OPERATOR_CANCELLED;
marker->camera = ob;
/* camera may have changes */
BKE_scene_camera_switch_update(scene);
BKE_screen_view3d_scene_sync(sc);
WM_event_add_notifier(C, NC_SCENE | ND_MARKERS, NULL);
WM_event_add_notifier(C, NC_ANIMATION | ND_MARKERS, NULL);
WM_event_add_notifier(C, NC_SCENE | NA_EDITED, scene); /* so we get view3d redraws */
return OPERATOR_FINISHED;
}
static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
OGLRender *oglrender = op->customdata;
Scene *scene = oglrender->scene;
char name[FILE_MAX];
bool ok = false;
const bool view_context = (oglrender->v3d != NULL);
bool is_movie;
RenderResult *rr;
/* go to next frame */
if (CFRA < oglrender->nfra)
CFRA++;
while (CFRA < oglrender->nfra) {
unsigned int lay = screen_opengl_layers(oglrender);
if (lay & 0xFF000000)
lay &= 0xFF000000;
BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, lay);
CFRA++;
}
is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);
if (!is_movie) {
BKE_image_path_from_imformat(
name, scene->r.pic, oglrender->bmain->name, scene->r.cfra,
&scene->r.im_format, (scene->r.scemode & R_EXTENSION) != 0, true, NULL);
if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(name)) {
BKE_reportf(op->reports, RPT_INFO, "Skipping existing frame \"%s\"", name);
ok = true;
goto finally;
}
}
WM_cursor_time(oglrender->win, scene->r.cfra);
BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, screen_opengl_layers(oglrender));
if (view_context) {
if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera && oglrender->v3d->scenelock) {
/* since BKE_scene_update_for_newframe() is used rather
* then ED_update_for_newframe() the camera needs to be set */
if (BKE_scene_camera_switch_update(scene)) {
oglrender->v3d->camera = scene->camera;
}
}
}
else {
BKE_scene_camera_switch_update(scene);
}
/* render into offscreen buffer */
screen_opengl_render_apply(oglrender);
/* save to disk */
rr = RE_AcquireResultRead(oglrender->re);
if (is_movie) {
ok = RE_WriteRenderViewsMovie(oglrender->reports, rr, scene, &scene->r, oglrender->mh, oglrender->sizex,
oglrender->sizey, oglrender->movie_ctx_arr, oglrender->totvideos, PRVRANGEON != 0);
if (ok) {
printf("Append frame %d", scene->r.cfra);
BKE_reportf(op->reports, RPT_INFO, "Appended frame: %d", scene->r.cfra);
}
}
else {
ok = RE_WriteRenderViewsImage(op->reports, rr, scene, scene->camera, true, name);
if (ok) {
printf("Saved: %s", name);
BKE_reportf(op->reports, RPT_INFO, "Saved file: %s", name);
}
else {
printf("Write error: cannot save %s\n", name);
BKE_reportf(op->reports, RPT_ERROR, "Write error: cannot save %s", name);
}
}
RE_ReleaseResult(oglrender->re);
/* movie stats prints have no line break */
printf("\n");
finally: /* Step the frame and bail early if needed */
/* go to next frame */
oglrender->nfra += scene->r.frame_step;
/* stop at the end or on error */
if (CFRA >= PEFRA || !ok) {
screen_opengl_render_end(C, op->customdata);
return 0;
}
return 1;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// "render" python API function
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void BlenderSession::render() {
// Get buffer parameters
SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, interactive);
if(session_params.export_alembic) {
session->update_scene_to_server(0, 0);
session->server->start_render(width, height, 0, session_params.out_of_core_enabled, session_params.out_of_core_mem_limit, session_params.out_of_core_gpu_headroom);
if(b_engine.test_break() || b_scene.frame_current() >= b_scene.frame_end()) {
session->progress.set_status("Transferring alembic file...");
session->server->stop_render(session_params.fps);
}
return;
}
BufferParams buffer_params = BlenderSync::get_display_buffer_params(scene->camera, width, height);
// Render each layer
BL::RenderSettings render = b_scene.render();
if(motion_blur && mb_type == SUBFRAME && mb_samples > 1)
session->params.samples = session->params.samples / mb_samples;
if(session->params.samples < 1) session->params.samples = 1;
bool stop_render = false;
BL::RenderSettings::layers_iterator b_iter;
for(render.layers.begin(b_iter); b_iter != render.layers.end(); ++b_iter) {
clear_passes_buffers();
BL::RenderLayer cur_layer(*b_iter);
// Render
if(motion_blur && mb_type == SUBFRAME && mb_samples > 1) {
mb_sample_in_work = 0;
float subframe = 0;
int cur_frame = b_scene.frame_current();
for(mb_cur_sample = 1; mb_cur_sample <= mb_samples; ++mb_cur_sample) {
session->start("Final render", true, 0, 0);
session->params.image_stat.cur_samples = 0;
if(mb_cur_sample < mb_samples) {
subframe += shuttertime / (mb_samples - 1);
if(subframe < 1.0f) {
//b_scene.frame_set(cur_frame, subframe); //Crashes due to BPy_BEGIN_ALLOW_THREADS-BPy_END_ALLOW_THREADS block in rna_Scene_frame_set()
double cfra = (double)cur_frame + (double)subframe;
CLAMP(cfra, MINAFRAME, MAXFRAME);
BKE_scene_frame_set((::Scene *)b_scene.ptr.data, cfra);
BKE_scene_update_for_newframe_ex(G.main->eval_ctx, G.main, (::Scene *)b_scene.ptr.data, (1 << 20) - 1, true);
BKE_scene_camera_switch_update((::Scene *)b_scene.ptr.data);
}
sync->sync_data(b_v3d, b_engine.camera_override(), &cur_layer);
sync->sync_camera(b_engine.camera_override(), width, height);
}
if(session->progress.get_cancel()) {
stop_render = true;
break;
}
}
//b_scene.frame_set(cur_frame, 0); //Crashes due to BPy_BEGIN_ALLOW_THREADS-BPy_END_ALLOW_THREADS block in rna_Scene_frame_set()
double cfra = (double)cur_frame;
CLAMP(cfra, MINAFRAME, MAXFRAME);
BKE_scene_frame_set((::Scene *)b_scene.ptr.data, cfra);
BKE_scene_update_for_newframe_ex(G.main->eval_ctx, G.main, (::Scene *)b_scene.ptr.data, (1 << 20) - 1, true);
BKE_scene_camera_switch_update((::Scene *)b_scene.ptr.data);
}
else if(motion_blur && mb_type == INTERNAL) {
int int_frame_idx = load_internal_mb_sequence(stop_render, &cur_layer);
if(!stop_render) {
session->start("Final render", true, int_frame_idx, 0);
session->params.image_stat.cur_samples = 0;
}
}
else {
if(motion_blur) motion_blur = false;
mb_cur_sample = 0;
if(!stop_render) {
session->start("Final render", true, 0, 0);
session->params.image_stat.cur_samples = 0;
}
}
write_render_img();
if(session->progress.get_cancel()) {
stop_render = true;
break;
}
} //for(r.layers.begin(b_iter); b_iter != r.layers.end(); ++b_iter)
clear_passes_buffers();
if(stop_render || !b_engine.is_animation() || b_scene.frame_current() >= b_scene.frame_end())
session->server->stop_render(session_params.fps);
} //render()
static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
OGLRender *oglrender = op->customdata;
Scene *scene = oglrender->scene;
ImBuf *ibuf, *ibuf_save = NULL;
void *lock;
char name[FILE_MAX];
int ok = 0;
const short view_context = (oglrender->v3d != NULL);
Object *camera = NULL;
int is_movie;
/* go to next frame */
if (CFRA < oglrender->nfra)
CFRA++;
while (CFRA < oglrender->nfra) {
unsigned int lay = screen_opengl_layers(oglrender);
if (lay & 0xFF000000)
lay &= 0xFF000000;
BKE_scene_update_for_newframe(bmain, scene, lay);
CFRA++;
}
is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);
if (!is_movie) {
BKE_makepicstring(name, scene->r.pic, oglrender->bmain->name, scene->r.cfra, &scene->r.im_format, scene->r.scemode & R_EXTENSION, TRUE);
if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(name)) {
BKE_reportf(op->reports, RPT_INFO, "Skipping existing frame \"%s\"", name);
ok = true;
goto finally;
}
}
WM_cursor_time(oglrender->win, scene->r.cfra);
BKE_scene_update_for_newframe(bmain, scene, screen_opengl_layers(oglrender));
if (view_context) {
if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera && oglrender->v3d->scenelock) {
/* since BKE_scene_update_for_newframe() is used rather
* then ED_update_for_newframe() the camera needs to be set */
if (BKE_scene_camera_switch_update(scene)) {
oglrender->v3d->camera = scene->camera;
}
camera = oglrender->v3d->camera;
}
}
else {
BKE_scene_camera_switch_update(scene);
camera = scene->camera;
}
/* render into offscreen buffer */
screen_opengl_render_apply(oglrender);
/* save to disk */
ibuf = BKE_image_acquire_ibuf(oglrender->ima, &oglrender->iuser, &lock);
if (ibuf) {
int needs_free = FALSE;
ibuf_save = ibuf;
if (is_movie || !BKE_imtype_requires_linear_float(scene->r.im_format.imtype)) {
ibuf_save = IMB_colormanagement_imbuf_for_write(ibuf, true, true, &scene->view_settings,
&scene->display_settings, &scene->r.im_format);
needs_free = TRUE;
}
/* color -> grayscale */
/* editing directly would alter the render view */
if (scene->r.im_format.planes == R_IMF_PLANES_BW) {
ImBuf *ibuf_bw = IMB_dupImBuf(ibuf_save);
IMB_color_to_bw(ibuf_bw);
if (needs_free)
IMB_freeImBuf(ibuf_save);
ibuf_save = ibuf_bw;
}
else {
/* this is lightweight & doesnt re-alloc the buffers, only do this
* to save the correct bit depth since the image is always RGBA */
ImBuf *ibuf_cpy = IMB_allocImBuf(ibuf_save->x, ibuf_save->y, scene->r.im_format.planes, 0);
ibuf_cpy->rect = ibuf_save->rect;
ibuf_cpy->rect_float = ibuf_save->rect_float;
ibuf_cpy->zbuf_float = ibuf_save->zbuf_float;
if (needs_free) {
ibuf_cpy->mall = ibuf_save->mall;
ibuf_save->mall = 0;
IMB_freeImBuf(ibuf_save);
}
ibuf_save = ibuf_cpy;
}
if (is_movie) {
ok = oglrender->mh->append_movie(&scene->r, PSFRA, CFRA, (int *)ibuf_save->rect,
oglrender->sizex, oglrender->sizey, oglrender->reports);
if (ok) {
printf("Append frame %d", scene->r.cfra);
BKE_reportf(op->reports, RPT_INFO, "Appended frame: %d", scene->r.cfra);
}
}
else {
ok = BKE_imbuf_write_stamp(scene, camera, ibuf_save, name, &scene->r.im_format);
if (ok == 0) {
printf("Write error: cannot save %s\n", name);
BKE_reportf(op->reports, RPT_ERROR, "Write error: cannot save %s", name);
}
else {
printf("Saved: %s", name);
BKE_reportf(op->reports, RPT_INFO, "Saved file: %s", name);
}
}
if (needs_free)
IMB_freeImBuf(ibuf_save);
}
BKE_image_release_ibuf(oglrender->ima, ibuf, lock);
/* movie stats prints have no line break */
printf("\n");
finally: /* Step the frame and bail early if needed */
/* go to next frame */
oglrender->nfra += scene->r.frame_step;
/* stop at the end or on error */
if (CFRA >= PEFRA || !ok) {
screen_opengl_render_end(C, op->customdata);
return 0;
}
return 1;
}
