void wm_autosave_timer(const bContext *C, wmWindowManager *wm, wmTimer *wt)
{
wmWindow *win;
wmEventHandler *handler;
char filename[FILE_MAX];
int fileflags;
WM_event_remove_timer(wm, NULL, wm->autosavetimer);
/* if a modal operator is running, don't autosave, but try again in 10 seconds */
for(win=wm->windows.first; win; win=win->next) {
for(handler=win->modalhandlers.first; handler; handler=handler->next) {
if(handler->op) {
wm->autosavetimer= WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, 10.0);
return;
}
}
}
wm_autosave_location(filename);
/* force save as regular blend file */
fileflags = G.fileflags & ~(G_FILE_COMPRESS|G_FILE_LOCK|G_FILE_SIGN);
/* no error reporting to console */
BLO_write_file(CTX_data_main(C), filename, fileflags, NULL);
/* do timer after file write, just in case file write takes a long time */
wm->autosavetimer= WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, U.savetime*60.0);
}
static void screen_opengl_render_end(bContext *C, OGLRender *oglrender)
{
Main *bmain = CTX_data_main(C);
Scene *scene = oglrender->scene;
if (oglrender->mh) {
if (BKE_imtype_is_movie(scene->r.im_format.imtype))
oglrender->mh->end_movie();
}
if (oglrender->timer) { /* exec will not have a timer */
scene->r.cfra = oglrender->cfrao;
BKE_scene_update_for_newframe(bmain, scene, screen_opengl_layers(oglrender));
WM_event_remove_timer(oglrender->wm, oglrender->win, oglrender->timer);
}
WM_cursor_modal_restore(oglrender->win);
WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene);
U.obcenter_dia = oglrender->obcenter_dia_back;
GPU_offscreen_free(oglrender->ofs);
oglrender->scene->customdata_mask_modal = 0;
CTX_wm_area_set(C, oglrender->prevsa);
CTX_wm_region_set(C, oglrender->prevar);
MEM_freeN(oglrender);
}
static int flyEnd(bContext *C, FlyInfo *fly)
{
wmWindow *win;
RegionView3D *rv3d;
if (fly->state == FLY_RUNNING)
return OPERATOR_RUNNING_MODAL;
#ifdef NDOF_FLY_DEBUG
puts("\n-- fly end --");
#endif
win = CTX_wm_window(C);
rv3d = fly->rv3d;
WM_event_remove_timer(CTX_wm_manager(C), win, fly->timer);
ED_region_draw_cb_exit(fly->ar->type, fly->draw_handle_pixel);
ED_view3d_cameracontrol_release(fly->v3d_camera_control, fly->state == FLY_CANCEL);
rv3d->rflag &= ~RV3D_NAVIGATING;
if (fly->ndof)
MEM_freeN(fly->ndof);
if (fly->state == FLY_CONFIRM) {
MEM_freeN(fly);
return OPERATOR_FINISHED;
}
MEM_freeN(fly);
return OPERATOR_CANCELLED;
}
void wm_autosave_timer_ended(wmWindowManager *wm)
{
if (wm->autosavetimer) {
WM_event_remove_timer(wm, NULL, wm->autosavetimer);
wm->autosavetimer = NULL;
}
}
static int walkEnd(bContext *C, WalkInfo *walk)
{
wmWindow *win;
RegionView3D *rv3d;
if (walk->state == WALK_RUNNING)
return OPERATOR_RUNNING_MODAL;
#ifdef NDOF_WALK_DEBUG
puts("\n-- walk end --");
#endif
win = CTX_wm_window(C);
rv3d = walk->rv3d;
WM_event_remove_timer(CTX_wm_manager(C), win, walk->timer);
ED_region_draw_cb_exit(walk->ar->type, walk->draw_handle_pixel);
ED_transform_snap_object_context_destroy(walk->snap_context);
ED_view3d_cameracontrol_release(walk->v3d_camera_control, walk->state == WALK_CANCEL);
rv3d->rflag &= ~RV3D_NAVIGATING;
if (walk->ndof)
MEM_freeN(walk->ndof);
/* restore the cursor */
WM_cursor_modal_restore(win);
#ifdef USE_TABLET_SUPPORT
if (walk->is_cursor_absolute == false)
#endif
{
/* center the mouse */
WM_cursor_warp(
win,
walk->ar->winrct.xmin + walk->center_mval[0],
walk->ar->winrct.ymin + walk->center_mval[1]);
}
if (walk->state == WALK_CONFIRM) {
MEM_freeN(walk);
return OPERATOR_FINISHED;
}
MEM_freeN(walk);
return OPERATOR_CANCELLED;
}
static void view_zoom_exit(bContext *C, wmOperator *op, bool cancel)
{
SpaceClip *sc = CTX_wm_space_clip(C);
ViewZoomData *vpd = op->customdata;
if (cancel) {
sc->zoom = vpd->zoom;
ED_region_tag_redraw(CTX_wm_region(C));
}
if (vpd->timer) {
WM_event_remove_timer(CTX_wm_manager(C), vpd->timer->win, vpd->timer);
}
WM_cursor_modal_restore(CTX_wm_window(C));
MEM_freeN(op->customdata);
}
/* including window itself, C can be NULL.
* ED_screen_exit should have been called */
void wm_window_free(bContext *C, wmWindowManager *wm, wmWindow *win)
{
wmTimer *wt, *wtnext;
/* update context */
if (C) {
WM_event_remove_handlers(C, &win->handlers);
WM_event_remove_handlers(C, &win->modalhandlers);
if (CTX_wm_window(C) == win)
CTX_wm_window_set(C, NULL);
}
/* always set drawable and active to NULL,
* prevents non-drawable state of main windows (bugs #22967 and #25071, possibly #22477 too) */
wm->windrawable = NULL;
wm->winactive = NULL;
/* end running jobs, a job end also removes its timer */
for (wt = wm->timers.first; wt; wt = wtnext) {
wtnext = wt->next;
if (wt->win == win && wt->event_type == TIMERJOBS)
wm_jobs_timer_ended(wm, wt);
}
/* timer removing, need to call this api function */
for (wt = wm->timers.first; wt; wt = wtnext) {
wtnext = wt->next;
if (wt->win == win)
WM_event_remove_timer(wm, win, wt);
}
if (win->eventstate) MEM_freeN(win->eventstate);
wm_event_free_all(win);
wm_subwindows_free(win);
wm_draw_data_free(win);
wm_ghostwindow_destroy(win);
MEM_freeN(win->stereo3d_format);
MEM_freeN(win);
}
static void ui_popup_block_remove(bContext *C, uiPopupBlockHandle *handle)
{
wmWindow *win = CTX_wm_window(C);
bScreen *sc = CTX_wm_screen(C);
ui_region_temp_remove(C, sc, handle->region);
/* reset to region cursor (only if there's not another menu open) */
if (BLI_listbase_is_empty(&sc->regionbase)) {
ED_region_cursor_set(win, CTX_wm_area(C), CTX_wm_region(C));
/* in case cursor needs to be changed again */
WM_event_add_mousemove(C);
}
if (handle->scrolltimer) {
WM_event_remove_timer(CTX_wm_manager(C), win, handle->scrolltimer);
}
}
void wm_autosave_timer(const bContext *C, wmWindowManager *wm, wmTimer *UNUSED(wt))
{
wmWindow *win;
wmEventHandler *handler;
char filepath[FILE_MAX];
Scene *scene = CTX_data_scene(C);
WM_event_remove_timer(wm, NULL, wm->autosavetimer);
/* if a modal operator is running, don't autosave, but try again in 10 seconds */
for (win = wm->windows.first; win; win = win->next) {
for (handler = win->modalhandlers.first; handler; handler = handler->next) {
if (handler->op) {
wm->autosavetimer = WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, 10.0);
return;
}
}
}
if (scene) {
Object *ob = OBACT;
if (ob && ob->mode & OB_MODE_SCULPT)
multires_force_update(ob);
}
wm_autosave_location(filepath);
if (U.uiflag & USER_GLOBALUNDO) {
/* fast save of last undobuffer, now with UI */
BKE_undo_save_file(filepath);
}
else {
/* save as regular blend file */
int fileflags = G.fileflags & ~(G_FILE_COMPRESS | G_FILE_AUTOPLAY | G_FILE_LOCK | G_FILE_SIGN | G_FILE_HISTORY);
/* no error reporting to console */
BLO_write_file(CTX_data_main(C), filepath, fileflags, NULL, NULL);
}
/* do timer after file write, just in case file write takes a long time */
wm->autosavetimer = WM_event_add_timer(wm, NULL, TIMERAUTOSAVE, U.savetime * 60.0);
}
static void screen_opengl_render_end(bContext *C, OGLRender *oglrender)
{
Main *bmain = CTX_data_main(C);
Scene *scene = oglrender->scene;
size_t i;
if (oglrender->mh) {
if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
for (i = 0; i < oglrender->totvideos; i++) {
oglrender->mh->end_movie(oglrender->movie_ctx_arr[i]);
oglrender->mh->context_free(oglrender->movie_ctx_arr[i]);
}
}
if (oglrender->movie_ctx_arr) {
MEM_freeN(oglrender->movie_ctx_arr);
}
}
if (oglrender->timer) { /* exec will not have a timer */
scene->r.cfra = oglrender->cfrao;
BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, screen_opengl_layers(oglrender));
WM_event_remove_timer(oglrender->wm, oglrender->win, oglrender->timer);
}
WM_cursor_modal_restore(oglrender->win);
WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene);
if (oglrender->fx)
GPU_fx_compositor_destroy(oglrender->fx);
GPU_offscreen_free(oglrender->ofs);
oglrender->scene->customdata_mask_modal = 0;
CTX_wm_area_set(C, oglrender->prevsa);
CTX_wm_region_set(C, oglrender->prevar);
MEM_freeN(oglrender);
}
/* stop job, end thread, free data completely */
static void wm_jobs_kill_job(wmWindowManager *wm, wmJob *wm_job)
{
if (wm_job->running) {
/* signal job to end */
wm_job->stop = TRUE;
wm_job_main_thread_yield(wm_job, true);
BLI_end_threads(&wm_job->threads);
if (wm_job->endjob)
wm_job->endjob(wm_job->run_customdata);
}
if (wm_job->wt)
WM_event_remove_timer(wm, wm_job->win, wm_job->wt);
if (wm_job->customdata)
wm_job->free(wm_job->customdata);
if (wm_job->run_customdata)
wm_job->run_free(wm_job->run_customdata);
/* remove wm_job */
wm_job_free(wm, wm_job);
}
/* stop job, free data completely */
static void wm_jobs_kill_job(wmWindowManager *wm, wmJob *steve)
{
if(steve->running) {
/* signal job to end */
steve->stop= 1;
BLI_end_threads(&steve->threads);
if(steve->endjob)
steve->endjob(steve->run_customdata);
}
if(steve->wt)
WM_event_remove_timer(wm, steve->win, steve->wt);
if(steve->customdata)
steve->free(steve->customdata);
if(steve->run_customdata)
steve->run_free(steve->run_customdata);
/* remove steve */
BLI_remlink(&wm->jobs, steve);
MEM_freeN(steve);
}
/* stop job, end thread, free data completely */
static void wm_jobs_kill_job(wmWindowManager *wm, wmJob *wm_job)
{
if (wm_job->running) {
/* signal job to end */
wm_job->stop = true;
WM_job_main_thread_lock_release(wm_job);
BLI_threadpool_end(&wm_job->threads);
WM_job_main_thread_lock_acquire(wm_job);
if (wm_job->endjob)
wm_job->endjob(wm_job->run_customdata);
}
if (wm_job->wt)
WM_event_remove_timer(wm, wm_job->win, wm_job->wt);
if (wm_job->customdata)
wm_job->free(wm_job->customdata);
if (wm_job->run_customdata)
wm_job->run_free(wm_job->run_customdata);
/* remove wm_job */
wm_job_free(wm, wm_job);
}
static int update_reports_display_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
{
wmWindowManager *wm = CTX_wm_manager(C);
ReportList *reports = CTX_wm_reports(C);
Report *report;
ReportTimerInfo *rti;
float progress = 0.0, color_progress = 0.0;
float neutral_col[3] = {0.35, 0.35, 0.35};
float neutral_gray = 0.6;
float timeout = 0.0, color_timeout = 0.0;
int send_note = 0;
/* escape if not our timer */
if ((reports->reporttimer == NULL) ||
(reports->reporttimer != event->customdata) ||
((report = BKE_reports_last_displayable(reports)) == NULL) /* may have been deleted */
)
{
return OPERATOR_PASS_THROUGH;
}
rti = (ReportTimerInfo *)reports->reporttimer->customdata;
timeout = (report->type & RPT_ERROR_ALL) ? ERROR_TIMEOUT : INFO_TIMEOUT;
color_timeout = (report->type & RPT_ERROR_ALL) ? ERROR_COLOR_TIMEOUT : INFO_COLOR_TIMEOUT;
/* clear the report display after timeout */
if ((float)reports->reporttimer->duration > timeout) {
WM_event_remove_timer(wm, NULL, reports->reporttimer);
reports->reporttimer = NULL;
WM_event_add_notifier(C, NC_SPACE | ND_SPACE_INFO, NULL);
return (OPERATOR_FINISHED | OPERATOR_PASS_THROUGH);
}
if (rti->widthfac == 0.0f) {
/* initialize colors based on report type */
if (report->type & RPT_ERROR_ALL) {
rti->col[0] = 1.0;
rti->col[1] = 0.2;
rti->col[2] = 0.0;
}
else if (report->type & RPT_WARNING_ALL) {
rti->col[0] = 1.0;
rti->col[1] = 1.0;
rti->col[2] = 0.0;
}
else if (report->type & RPT_INFO_ALL) {
rti->col[0] = 0.3;
rti->col[1] = 0.45;
rti->col[2] = 0.7;
}
rti->grayscale = 0.75;
rti->widthfac = 1.0;
}
progress = (float)reports->reporttimer->duration / timeout;
color_progress = (float)reports->reporttimer->duration / color_timeout;
/* save us from too many draws */
if (color_progress <= 1.0f) {
send_note = 1;
/* fade colors out sharply according to progress through fade-out duration */
interp_v3_v3v3(rti->col, rti->col, neutral_col, color_progress);
rti->grayscale = interpf(neutral_gray, rti->grayscale, color_progress);
}
/* collapse report at end of timeout */
if (progress * timeout > timeout - COLLAPSE_TIMEOUT) {
rti->widthfac = (progress * timeout - (timeout - COLLAPSE_TIMEOUT)) / COLLAPSE_TIMEOUT;
rti->widthfac = 1.0f - rti->widthfac;
send_note = 1;
}
if (send_note) {
WM_event_add_notifier(C, NC_SPACE | ND_SPACE_INFO, NULL);
}
return (OPERATOR_FINISHED | OPERATOR_PASS_THROUGH);
}
bool WM_init_game(bContext *C)
{
wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win;
ScrArea *sa;
ARegion *ar = NULL;
Scene *scene = CTX_data_scene(C);
if (!scene) {
/* XXX, this should not be needed. */
Main *bmain = CTX_data_main(C);
scene = bmain->scene.first;
}
win = wm->windows.first;
/* first to get a valid window */
if (win)
CTX_wm_window_set(C, win);
sa = BKE_screen_find_big_area(CTX_wm_screen(C), SPACE_VIEW3D, 0);
ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
/* if we have a valid 3D view */
if (sa && ar) {
ARegion *arhide;
CTX_wm_area_set(C, sa);
CTX_wm_region_set(C, ar);
/* disable quad view */
if (ar->alignment == RGN_ALIGN_QSPLIT)
WM_operator_name_call(C, "SCREEN_OT_region_quadview", WM_OP_EXEC_DEFAULT, NULL);
/* toolbox, properties panel and header are hidden */
for (arhide = sa->regionbase.first; arhide; arhide = arhide->next) {
if (arhide->regiontype != RGN_TYPE_WINDOW) {
if (!(arhide->flag & RGN_FLAG_HIDDEN)) {
ED_region_toggle_hidden(C, arhide);
}
}
}
/* full screen the area */
if (!sa->full) {
ED_screen_state_toggle(C, win, sa, SCREENMAXIMIZED);
}
/* Fullscreen */
if ((scene->gm.playerflag & GAME_PLAYER_FULLSCREEN)) {
WM_operator_name_call(C, "WM_OT_window_fullscreen_toggle", WM_OP_EXEC_DEFAULT, NULL);
wm_get_screensize(&ar->winrct.xmax, &ar->winrct.ymax);
ar->winx = ar->winrct.xmax + 1;
ar->winy = ar->winrct.ymax + 1;
}
else {
GHOST_RectangleHandle rect = GHOST_GetClientBounds(win->ghostwin);
ar->winrct.ymax = GHOST_GetHeightRectangle(rect);
ar->winrct.xmax = GHOST_GetWidthRectangle(rect);
ar->winx = ar->winrct.xmax + 1;
ar->winy = ar->winrct.ymax + 1;
GHOST_DisposeRectangle(rect);
}
WM_operator_name_call(C, "VIEW3D_OT_game_start", WM_OP_EXEC_DEFAULT, NULL);
BKE_sound_exit();
return true;
}
else {
ReportTimerInfo *rti;
BKE_report(&wm->reports, RPT_ERROR, "No valid 3D View found, game auto start is not possible");
/* After adding the report to the global list, reset the report timer. */
WM_event_remove_timer(wm, NULL, wm->reports.reporttimer);
/* Records time since last report was added */
wm->reports.reporttimer = WM_event_add_timer(wm, CTX_wm_window(C), TIMER, 0.02);
rti = MEM_callocN(sizeof(ReportTimerInfo), "ReportTimerInfo");
wm->reports.reporttimer->customdata = rti;
return false;
}
}
/* the arguments are the desired situation */
void smooth_view(bContext *C, View3D *v3d, ARegion *ar, Object *oldcamera, Object *camera,
float *ofs, float *quat, float *dist, float *lens)
{
wmWindowManager *wm= CTX_wm_manager(C);
wmWindow *win= CTX_wm_window(C);
ScrArea *sa= CTX_wm_area(C);
RegionView3D *rv3d= ar->regiondata;
struct SmoothViewStore sms= {0};
short ok= FALSE;
/* initialize sms */
copy_v3_v3(sms.new_ofs, rv3d->ofs);
copy_qt_qt(sms.new_quat, rv3d->viewquat);
sms.new_dist= rv3d->dist;
sms.new_lens= v3d->lens;
sms.to_camera= 0;
/* note on camera locking, this is a little confusing but works ok.
* we may be changing the view 'as if' there is no active camera, but infact
* there is an active camera which is locked to the view.
*
* In the case where smooth view is moving _to_ a camera we dont want that
* camera to be moved or changed, so only when the camera is not being set should
* we allow camera option locking to initialize the view settings from the camera.
*/
if(camera == NULL && oldcamera == NULL) {
ED_view3d_camera_lock_init(v3d, rv3d);
}
/* store the options we want to end with */
if(ofs) copy_v3_v3(sms.new_ofs, ofs);
if(quat) copy_qt_qt(sms.new_quat, quat);
if(dist) sms.new_dist= *dist;
if(lens) sms.new_lens= *lens;
if (camera) {
ED_view3d_from_object(camera, sms.new_ofs, sms.new_quat, &sms.new_dist, &sms.new_lens);
sms.to_camera= 1; /* restore view3d values in end */
}
if (C && U.smooth_viewtx) {
int changed = 0; /* zero means no difference */
if (oldcamera != camera)
changed = 1;
else if (sms.new_dist != rv3d->dist)
changed = 1;
else if (sms.new_lens != v3d->lens)
changed = 1;
else if (!equals_v3v3(sms.new_ofs, rv3d->ofs))
changed = 1;
else if (!equals_v4v4(sms.new_quat, rv3d->viewquat))
changed = 1;
/* The new view is different from the old one
* so animate the view */
if (changed) {
/* original values */
if (oldcamera) {
sms.orig_dist= rv3d->dist; // below function does weird stuff with it...
ED_view3d_from_object(oldcamera, sms.orig_ofs, sms.orig_quat, &sms.orig_dist, &sms.orig_lens);
}
else {
copy_v3_v3(sms.orig_ofs, rv3d->ofs);
copy_qt_qt(sms.orig_quat, rv3d->viewquat);
sms.orig_dist= rv3d->dist;
sms.orig_lens= v3d->lens;
}
/* grid draw as floor */
if((rv3d->viewlock & RV3D_LOCKED)==0) {
/* use existing if exists, means multiple calls to smooth view wont loose the original 'view' setting */
sms.orig_view= rv3d->sms ? rv3d->sms->orig_view : rv3d->view;
rv3d->view= RV3D_VIEW_USER;
}
sms.time_allowed= (double)U.smooth_viewtx / 1000.0;
/* if this is view rotation only
* we can decrease the time allowed by
* the angle between quats
* this means small rotations wont lag */
if (quat && !ofs && !dist) {
float vec1[3]={0,0,1}, vec2[3]= {0,0,1};
float q1[4], q2[4];
invert_qt_qt(q1, sms.new_quat);
invert_qt_qt(q2, sms.orig_quat);
mul_qt_v3(q1, vec1);
mul_qt_v3(q2, vec2);
/* scale the time allowed by the rotation */
sms.time_allowed *= (double)angle_v3v3(vec1, vec2) / M_PI; /* 180deg == 1.0 */
}
/* ensure it shows correct */
if(sms.to_camera) rv3d->persp= RV3D_PERSP;
rv3d->rflag |= RV3D_NAVIGATING;
/* keep track of running timer! */
if(rv3d->sms==NULL)
rv3d->sms= MEM_mallocN(sizeof(struct SmoothViewStore), "smoothview v3d");
*rv3d->sms= sms;
if(rv3d->smooth_timer)
WM_event_remove_timer(wm, win, rv3d->smooth_timer);
/* TIMER1 is hardcoded in keymap */
rv3d->smooth_timer= WM_event_add_timer(wm, win, TIMER1, 1.0/100.0); /* max 30 frs/sec */
ok= TRUE;
}
}
/* if we get here nothing happens */
if(ok == FALSE) {
if(sms.to_camera==0) {
copy_v3_v3(rv3d->ofs, sms.new_ofs);
copy_qt_qt(rv3d->viewquat, sms.new_quat);
rv3d->dist = sms.new_dist;
v3d->lens = sms.new_lens;
}
if(rv3d->viewlock & RV3D_BOXVIEW)
view3d_boxview_copy(sa, ar);
ED_region_tag_redraw(ar);
}
}
/* hardcoded to event TIMERJOBS */
void wm_jobs_timer(const bContext *C, wmWindowManager *wm, wmTimer *wt)
{
wmJob *steve= wm->jobs.first, *stevenext;
float total_progress= 0.f;
float jobs_progress=0;
for(; steve; steve= stevenext) {
stevenext= steve->next;
if(steve->wt==wt) {
/* running threads */
if(steve->threads.first) {
/* always call note and update when ready */
if(steve->do_update || steve->ready) {
if(steve->update)
steve->update(steve->run_customdata);
if(steve->note)
WM_event_add_notifier(C, steve->note, NULL);
if (steve->flag & WM_JOB_PROGRESS)
WM_event_add_notifier(C, NC_WM|ND_JOB, NULL);
steve->do_update= 0;
}
if(steve->ready) {
if(steve->endjob)
steve->endjob(steve->run_customdata);
/* free own data */
steve->run_free(steve->run_customdata);
steve->run_customdata= NULL;
steve->run_free= NULL;
// if(steve->stop) printf("job ready but stopped %s\n", steve->name);
// else printf("job finished %s\n", steve->name);
steve->running= 0;
BLI_end_threads(&steve->threads);
if(steve->endnote)
WM_event_add_notifier(C, steve->endnote, NULL);
WM_event_add_notifier(C, NC_WM|ND_JOB, NULL);
/* new job added for steve? */
if(steve->customdata) {
// printf("job restarted with new data %s\n", steve->name);
WM_jobs_start(wm, steve);
}
else {
WM_event_remove_timer(wm, steve->win, steve->wt);
steve->wt= NULL;
/* remove steve */
BLI_remlink(&wm->jobs, steve);
MEM_freeN(steve);
}
} else if (steve->flag & WM_JOB_PROGRESS) {
/* accumulate global progress for running jobs */
jobs_progress++;
total_progress += steve->progress;
}
}
else if(steve->suspended) {
WM_jobs_start(wm, steve);
}
}
}
/* on file load 'winactive' can be NULL, possibly it should not happen but for now do a NULL check - campbell */
if(wm->winactive) {
/* if there are running jobs, set the global progress indicator */
if (jobs_progress > 0) {
float progress = total_progress / (float)jobs_progress;
WM_progress_set(wm->winactive, progress);
} else {
WM_progress_clear(wm->winactive);
}
}
}
void WM_event_remove_timer_notifier(wmWindowManager *wm, wmWindow *win, wmTimer *timer)
{
timer->customdata = NULL;
WM_event_remove_timer(wm, win, timer);
}
/* only meant for timer usage */
static int file_smoothscroll_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
{
ScrArea *sa = CTX_wm_area(C);
SpaceFile *sfile = CTX_wm_space_file(C);
ARegion *ar, *oldar = CTX_wm_region(C);
int offset;
int numfiles, numfiles_layout;
int edit_idx = 0;
int i;
/* escape if not our timer */
if (sfile->smoothscroll_timer == NULL || sfile->smoothscroll_timer != event->customdata)
return OPERATOR_PASS_THROUGH;
numfiles = filelist_numfiles(sfile->files);
/* check if we are editing a name */
for (i = 0; i < numfiles; ++i) {
if (filelist_is_selected(sfile->files, i, CHECK_ALL) ) {
edit_idx = i;
break;
}
}
/* if we are not editing, we are done */
if (0 == edit_idx) {
WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), sfile->smoothscroll_timer);
sfile->smoothscroll_timer = NULL;
return OPERATOR_PASS_THROUGH;
}
/* we need the correct area for scrolling */
ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
if (!ar || ar->regiontype != RGN_TYPE_WINDOW) {
WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), sfile->smoothscroll_timer);
sfile->smoothscroll_timer = NULL;
return OPERATOR_PASS_THROUGH;
}
offset = ED_fileselect_layout_offset(sfile->layout, (int)ar->v2d.cur.xmin, (int)-ar->v2d.cur.ymax);
if (offset < 0) offset = 0;
/* scroll offset is the first file in the row/column we are editing in */
if (sfile->scroll_offset == 0) {
if (sfile->layout->flag & FILE_LAYOUT_HOR) {
sfile->scroll_offset = (edit_idx / sfile->layout->rows) * sfile->layout->rows;
if (sfile->scroll_offset <= offset) sfile->scroll_offset -= sfile->layout->rows;
}
else {
sfile->scroll_offset = (edit_idx / sfile->layout->columns) * sfile->layout->columns;
if (sfile->scroll_offset <= offset) sfile->scroll_offset -= sfile->layout->columns;
}
}
numfiles_layout = ED_fileselect_layout_numfiles(sfile->layout, ar);
/* check if we have reached our final scroll position */
if ( (sfile->scroll_offset >= offset) && (sfile->scroll_offset < offset + numfiles_layout) ) {
WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), sfile->smoothscroll_timer);
sfile->smoothscroll_timer = NULL;
return OPERATOR_FINISHED;
}
/* temporarily set context to the main window region,
* so the scroll operators work */
CTX_wm_region_set(C, ar);
/* scroll one step in the desired direction */
if (sfile->scroll_offset < offset) {
if (sfile->layout->flag & FILE_LAYOUT_HOR) {
WM_operator_name_call(C, "VIEW2D_OT_scroll_left", 0, NULL);
}
else {
WM_operator_name_call(C, "VIEW2D_OT_scroll_up", 0, NULL);
}
}
else {
if (sfile->layout->flag & FILE_LAYOUT_HOR) {
WM_operator_name_call(C, "VIEW2D_OT_scroll_right", 0, NULL);
}
else {
WM_operator_name_call(C, "VIEW2D_OT_scroll_down", 0, NULL);
}
}
ED_region_tag_redraw(ar);
/* and restore context */
CTX_wm_region_set(C, oldar);
return OPERATOR_FINISHED;
}
/* only meant for timer usage */
static int view3d_smoothview_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
{
View3D *v3d = CTX_wm_view3d(C);
RegionView3D *rv3d = CTX_wm_region_view3d(C);
struct SmoothView3DStore *sms = rv3d->sms;
float step, step_inv;
/* escape if not our timer */
if (rv3d->smooth_timer == NULL || rv3d->smooth_timer != event->customdata)
return OPERATOR_PASS_THROUGH;
if (sms->time_allowed != 0.0)
step = (float)((rv3d->smooth_timer->duration) / sms->time_allowed);
else
step = 1.0f;
/* end timer */
if (step >= 1.0f) {
/* if we went to camera, store the original */
if (sms->to_camera) {
rv3d->persp = RV3D_CAMOB;
view3d_smooth_view_state_restore(&sms->org, v3d, rv3d);
}
else {
view3d_smooth_view_state_restore(&sms->dst, v3d, rv3d);
ED_view3d_camera_lock_sync(v3d, rv3d);
ED_view3d_camera_lock_autokey(v3d, rv3d, C, true, true);
}
if ((rv3d->viewlock & RV3D_LOCKED) == 0) {
rv3d->view = sms->org_view;
}
MEM_freeN(rv3d->sms);
rv3d->sms = NULL;
WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), rv3d->smooth_timer);
rv3d->smooth_timer = NULL;
rv3d->rflag &= ~RV3D_NAVIGATING;
}
else {
/* ease in/out */
step = (3.0f * step * step - 2.0f * step * step * step);
step_inv = 1.0f - step;
interp_v3_v3v3(rv3d->ofs, sms->src.ofs, sms->dst.ofs, step);
interp_qt_qtqt(rv3d->viewquat, sms->src.quat, sms->dst.quat, step);
rv3d->dist = sms->dst.dist * step + sms->src.dist * step_inv;
v3d->lens = sms->dst.lens * step + sms->src.lens * step_inv;
ED_view3d_camera_lock_sync(v3d, rv3d);
if (ED_screen_animation_playing(CTX_wm_manager(C))) {
ED_view3d_camera_lock_autokey(v3d, rv3d, C, true, true);
}
}
if (rv3d->viewlock & RV3D_BOXVIEW)
view3d_boxview_copy(CTX_wm_area(C), CTX_wm_region(C));
/* note: this doesn't work right because the v3d->lens is now used in ortho mode r51636,
* when switching camera in quad-view the other ortho views would zoom & reset.
*
* For now only redraw all regions when smoothview finishes.
*/
if (step >= 1.0f) {
WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, v3d);
}
else {
ED_region_tag_redraw(CTX_wm_region(C));
}
return OPERATOR_FINISHED;
}
/* only meant for timer usage */
static int view3d_smoothview_invoke(bContext *C, wmOperator *UNUSED(op), wmEvent *event)
{
View3D *v3d = CTX_wm_view3d(C);
RegionView3D *rv3d= CTX_wm_region_view3d(C);
struct SmoothViewStore *sms= rv3d->sms;
float step, step_inv;
/* escape if not our timer */
if(rv3d->smooth_timer==NULL || rv3d->smooth_timer!=event->customdata)
return OPERATOR_PASS_THROUGH;
if(sms->time_allowed != 0.0)
step = (float)((rv3d->smooth_timer->duration)/sms->time_allowed);
else
step = 1.0f;
/* end timer */
if(step >= 1.0f) {
/* if we went to camera, store the original */
if(sms->to_camera) {
rv3d->persp= RV3D_CAMOB;
copy_v3_v3(rv3d->ofs, sms->orig_ofs);
copy_qt_qt(rv3d->viewquat, sms->orig_quat);
rv3d->dist = sms->orig_dist;
v3d->lens = sms->orig_lens;
}
else {
copy_v3_v3(rv3d->ofs, sms->new_ofs);
copy_qt_qt(rv3d->viewquat, sms->new_quat);
rv3d->dist = sms->new_dist;
v3d->lens = sms->new_lens;
ED_view3d_camera_lock_sync(v3d, rv3d);
}
if((rv3d->viewlock & RV3D_LOCKED)==0) {
rv3d->view= sms->orig_view;
}
MEM_freeN(rv3d->sms);
rv3d->sms= NULL;
WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), rv3d->smooth_timer);
rv3d->smooth_timer= NULL;
rv3d->rflag &= ~RV3D_NAVIGATING;
}
else {
int i;
/* ease in/out */
if (step < 0.5f) step = (float)pow(step*2.0f, 2.0)/2.0f;
else step = (float)1.0f-(powf(2.0f*(1.0f-step),2.0f)/2.0f);
step_inv = 1.0f-step;
for (i=0; i<3; i++)
rv3d->ofs[i] = sms->new_ofs[i] * step + sms->orig_ofs[i]*step_inv;
interp_qt_qtqt(rv3d->viewquat, sms->orig_quat, sms->new_quat, step);
rv3d->dist = sms->new_dist * step + sms->orig_dist*step_inv;
v3d->lens = sms->new_lens * step + sms->orig_lens*step_inv;
ED_view3d_camera_lock_sync(v3d, rv3d);
}
if(rv3d->viewlock & RV3D_BOXVIEW)
view3d_boxview_copy(CTX_wm_area(C), CTX_wm_region(C));
WM_event_add_notifier(C, NC_SPACE|ND_SPACE_VIEW3D, v3d);
return OPERATOR_FINISHED;
}
/* hardcoded to event TIMERJOBS */
void wm_jobs_timer(const bContext *C, wmWindowManager *wm, wmTimer *wt)
{
wmJob *wm_job, *wm_jobnext;
float total_progress = 0.f;
float jobs_progress = 0;
for (wm_job = wm->jobs.first; wm_job; wm_job = wm_jobnext) {
wm_jobnext = wm_job->next;
if (wm_job->wt == wt) {
/* running threads */
if (wm_job->threads.first) {
/* let threads get temporary lock over main thread if needed */
wm_job_main_thread_yield(wm_job);
/* always call note and update when ready */
if (wm_job->do_update || wm_job->ready) {
if (wm_job->update)
wm_job->update(wm_job->run_customdata);
if (wm_job->note)
WM_event_add_notifier(C, wm_job->note, NULL);
if (wm_job->flag & WM_JOB_PROGRESS)
WM_event_add_notifier(C, NC_WM | ND_JOB, NULL);
wm_job->do_update = false;
}
if (wm_job->ready) {
if (wm_job->endjob)
wm_job->endjob(wm_job->run_customdata);
/* free own data */
wm_job->run_free(wm_job->run_customdata);
wm_job->run_customdata = NULL;
wm_job->run_free = NULL;
// if (wm_job->stop) printf("job ready but stopped %s\n", wm_job->name);
// else printf("job finished %s\n", wm_job->name);
if (G.debug & G_DEBUG_JOBS) {
printf("Job '%s' finished in %f seconds\n", wm_job->name,
PIL_check_seconds_timer() - wm_job->start_time);
}
wm_job->running = false;
WM_job_main_thread_lock_release(wm_job);
BLI_threadpool_end(&wm_job->threads);
WM_job_main_thread_lock_acquire(wm_job);
if (wm_job->endnote)
WM_event_add_notifier(C, wm_job->endnote, NULL);
WM_event_add_notifier(C, NC_WM | ND_JOB, NULL);
/* new job added for wm_job? */
if (wm_job->customdata) {
// printf("job restarted with new data %s\n", wm_job->name);
WM_jobs_start(wm, wm_job);
}
else {
WM_event_remove_timer(wm, wm_job->win, wm_job->wt);
wm_job->wt = NULL;
/* remove wm_job */
wm_job_free(wm, wm_job);
}
}
else if (wm_job->flag & WM_JOB_PROGRESS) {
/* accumulate global progress for running jobs */
jobs_progress++;
total_progress += wm_job->progress;
}
}
else if (wm_job->suspended) {
WM_jobs_start(wm, wm_job);
}
}
else if (wm_job->threads.first && !wm_job->ready) {
if (wm_job->flag & WM_JOB_PROGRESS) {
/* accumulate global progress for running jobs */
jobs_progress++;
total_progress += wm_job->progress;
}
}
}
/* if there are running jobs, set the global progress indicator */
if (jobs_progress > 0) {
wmWindow *win;
float progress = total_progress / (float)jobs_progress;
for (win = wm->windows.first; win; win = win->next)
WM_progress_set(win, progress);
}
else {
wmWindow *win;
for (win = wm->windows.first; win; win = win->next)
WM_progress_clear(win);
}
}
static void panel_activate_state(const bContext *C, Panel *pa, uiHandlePanelState state)
{
uiHandlePanelData *data= pa->activedata;
wmWindow *win= CTX_wm_window(C);
ARegion *ar= CTX_wm_region(C);
if(data && data->state == state)
return;
if(state == PANEL_STATE_EXIT || state == PANEL_STATE_ANIMATION) {
if(data && data->state != PANEL_STATE_ANIMATION) {
/* XXX:
* - the panel tabbing function call below (test_add_new_tabs()) has been commented out
* "It is too easy to do by accident when reordering panels, is very hard to control and use, and has no real benefit." - BillRey
* Aligorith, 2009Sep
*/
//test_add_new_tabs(ar); // also copies locations of tabs in dragged panel
check_panel_overlap(ar, NULL); // clears
}
pa->flag &= ~PNL_SELECT;
}
else
pa->flag |= PNL_SELECT;
if(data && data->animtimer) {
WM_event_remove_timer(CTX_wm_manager(C), win, data->animtimer);
data->animtimer= NULL;
}
if(state == PANEL_STATE_EXIT) {
MEM_freeN(data);
pa->activedata= NULL;
WM_event_remove_ui_handler(&win->modalhandlers, ui_handler_panel, ui_handler_remove_panel, pa);
}
else {
if(!data) {
data= MEM_callocN(sizeof(uiHandlePanelData), "uiHandlePanelData");
pa->activedata= data;
WM_event_add_ui_handler(C, &win->modalhandlers, ui_handler_panel, ui_handler_remove_panel, pa);
}
if(ELEM(state, PANEL_STATE_ANIMATION, PANEL_STATE_DRAG))
data->animtimer= WM_event_add_timer(CTX_wm_manager(C), win, TIMER, ANIMATION_INTERVAL);
data->state= state;
data->startx= win->eventstate->x;
data->starty= win->eventstate->y;
data->startofsx= pa->ofsx;
data->startofsy= pa->ofsy;
data->startsizex= pa->sizex;
data->startsizey= pa->sizey;
data->starttime= PIL_check_seconds_timer();
}
ED_region_tag_redraw(ar);
/* XXX exception handling, 3d window preview panel */
/* if(block->drawextra==BIF_view3d_previewdraw)
BIF_view3d_previewrender_clear(curarea);*/
/* XXX exception handling, 3d window preview panel */
/* if(block->drawextra==BIF_view3d_previewdraw)
BIF_view3d_previewrender_signal(curarea, PR_DISPRECT);
else if(strcmp(block->name, "image_panel_preview")==0)
image_preview_event(2); */
}
static void wm_reports_free(wmWindowManager *wm)
{
BKE_reports_clear(&wm->reports);
WM_event_remove_timer(wm, NULL, wm->reports.reporttimer);
}
static int flyEnd(bContext *C, FlyInfo *fly)
{
RegionView3D *rv3d = fly->rv3d;
View3D *v3d = fly->v3d;
float upvec[3];
if (fly->state == FLY_RUNNING)
return OPERATOR_RUNNING_MODAL;
#ifdef NDOF_FLY_DEBUG
puts("\n-- fly end --");
#endif
WM_event_remove_timer(CTX_wm_manager(C), CTX_wm_window(C), fly->timer);
ED_region_draw_cb_exit(fly->ar->type, fly->draw_handle_pixel);
rv3d->dist = fly->dist_backup;
if (fly->state == FLY_CANCEL) {
/* Revert to original view? */
if (fly->persp_backup == RV3D_CAMOB) { /* a camera view */
Object *ob_back;
ob_back = (fly->root_parent) ? fly->root_parent : fly->v3d->camera;
/* store the original camera loc and rot */
BKE_object_tfm_restore(ob_back, fly->obtfm);
DAG_id_tag_update(&ob_back->id, OB_RECALC_OB);
}
else {
/* Non Camera we need to reset the view back to the original location bacause the user canceled*/
copy_qt_qt(rv3d->viewquat, fly->rot_backup);
rv3d->persp = fly->persp_backup;
}
/* always, is set to zero otherwise */
copy_v3_v3(rv3d->ofs, fly->ofs_backup);
}
else if (fly->persp_backup == RV3D_CAMOB) { /* camera */
DAG_id_tag_update(fly->root_parent ? &fly->root_parent->id : &v3d->camera->id, OB_RECALC_OB);
/* always, is set to zero otherwise */
copy_v3_v3(rv3d->ofs, fly->ofs_backup);
}
else { /* not camera */
/* Apply the fly mode view */
/* restore the dist */
float mat[3][3];
upvec[0] = upvec[1] = 0;
upvec[2] = fly->dist_backup; /* x and y are 0 */
copy_m3_m4(mat, rv3d->viewinv);
mul_m3_v3(mat, upvec);
add_v3_v3(rv3d->ofs, upvec);
/* Done with correcting for the dist */
}
if (fly->is_ortho_cam) {
((Camera *)fly->v3d->camera->data)->type = CAM_ORTHO;
}
rv3d->rflag &= ~RV3D_NAVIGATING;
//XXX2.5 BIF_view3d_previewrender_signal(fly->sa, PR_DBASE|PR_DISPRECT); /* not working at the moment not sure why */
if (fly->obtfm)
MEM_freeN(fly->obtfm);
if (fly->ndof)
MEM_freeN(fly->ndof);
if (fly->state == FLY_CONFIRM) {
MEM_freeN(fly);
return OPERATOR_FINISHED;
}
MEM_freeN(fly);
return OPERATOR_CANCELLED;
}
static void rna_event_timer_remove(struct wmWindowManager *wm, wmTimer *timer)
{
WM_event_remove_timer(wm, timer->win, timer);
}
/* the arguments are the desired situation */
void ED_view3d_smooth_view_ex(
/* avoid passing in the context */
wmWindowManager *wm, wmWindow *win, ScrArea *sa,
View3D *v3d, ARegion *ar, Object *oldcamera, Object *camera,
const float *ofs, const float *quat, const float *dist, const float *lens,
const int smooth_viewtx)
{
RegionView3D *rv3d = ar->regiondata;
struct SmoothView3DStore sms = {{0}};
bool ok = false;
/* initialize sms */
view3d_smooth_view_state_backup(&sms.dst, v3d, rv3d);
view3d_smooth_view_state_backup(&sms.src, v3d, rv3d);
/* if smoothview runs multiple times... */
if (rv3d->sms == NULL) {
view3d_smooth_view_state_backup(&sms.org, v3d, rv3d);
sms.org_view = rv3d->view;
}
else {
sms.org = rv3d->sms->org;
sms.org_view = rv3d->sms->org_view;
}
/* sms.to_camera = false; */ /* initizlized to zero anyway */
/* note on camera locking, this is a little confusing but works ok.
* we may be changing the view 'as if' there is no active camera, but in fact
* there is an active camera which is locked to the view.
*
* In the case where smooth view is moving _to_ a camera we don't want that
* camera to be moved or changed, so only when the camera is not being set should
* we allow camera option locking to initialize the view settings from the camera.
*/
if (camera == NULL && oldcamera == NULL) {
ED_view3d_camera_lock_init(v3d, rv3d);
}
/* store the options we want to end with */
if (ofs) copy_v3_v3(sms.dst.ofs, ofs);
if (quat) copy_qt_qt(sms.dst.quat, quat);
if (dist) sms.dst.dist = *dist;
if (lens) sms.dst.lens = *lens;
if (camera) {
sms.dst.dist = ED_view3d_offset_distance(camera->obmat, ofs, VIEW3D_DIST_FALLBACK);
ED_view3d_from_object(camera, sms.dst.ofs, sms.dst.quat, &sms.dst.dist, &sms.dst.lens);
sms.to_camera = true; /* restore view3d values in end */
}
/* skip smooth viewing for render engine draw */
if (smooth_viewtx && v3d->drawtype != OB_RENDER) {
bool changed = false; /* zero means no difference */
if (oldcamera != camera)
changed = true;
else if (sms.dst.dist != rv3d->dist)
changed = true;
else if (sms.dst.lens != v3d->lens)
changed = true;
else if (!equals_v3v3(sms.dst.ofs, rv3d->ofs))
changed = true;
else if (!equals_v4v4(sms.dst.quat, rv3d->viewquat))
changed = true;
/* The new view is different from the old one
* so animate the view */
if (changed) {
/* original values */
if (oldcamera) {
sms.src.dist = ED_view3d_offset_distance(oldcamera->obmat, rv3d->ofs, 0.0f);
/* this */
ED_view3d_from_object(oldcamera, sms.src.ofs, sms.src.quat, &sms.src.dist, &sms.src.lens);
}
/* grid draw as floor */
if ((rv3d->viewlock & RV3D_LOCKED) == 0) {
/* use existing if exists, means multiple calls to smooth view wont loose the original 'view' setting */
rv3d->view = RV3D_VIEW_USER;
}
sms.time_allowed = (double)smooth_viewtx / 1000.0;
/* if this is view rotation only
* we can decrease the time allowed by
* the angle between quats
* this means small rotations wont lag */
if (quat && !ofs && !dist) {
float vec1[3] = {0, 0, 1}, vec2[3] = {0, 0, 1};
float q1[4], q2[4];
invert_qt_qt(q1, sms.dst.quat);
invert_qt_qt(q2, sms.src.quat);
mul_qt_v3(q1, vec1);
mul_qt_v3(q2, vec2);
/* scale the time allowed by the rotation */
sms.time_allowed *= (double)angle_v3v3(vec1, vec2) / M_PI; /* 180deg == 1.0 */
}
/* ensure it shows correct */
if (sms.to_camera) {
/* use ortho if we move from an ortho view to an ortho camera */
rv3d->persp = (((rv3d->is_persp == false) &&
(camera->type == OB_CAMERA) &&
(((Camera *)camera->data)->type == CAM_ORTHO)) ?
RV3D_ORTHO : RV3D_PERSP);
}
rv3d->rflag |= RV3D_NAVIGATING;
/* not essential but in some cases the caller will tag the area for redraw,
* and in that case we can get a flicker of the 'org' user view but we want to see 'src' */
view3d_smooth_view_state_restore(&sms.src, v3d, rv3d);
/* keep track of running timer! */
if (rv3d->sms == NULL) {
rv3d->sms = MEM_mallocN(sizeof(struct SmoothView3DStore), "smoothview v3d");
}
*rv3d->sms = sms;
if (rv3d->smooth_timer) {
WM_event_remove_timer(wm, win, rv3d->smooth_timer);
}
/* TIMER1 is hardcoded in keymap */
rv3d->smooth_timer = WM_event_add_timer(wm, win, TIMER1, 1.0 / 100.0); /* max 30 frs/sec */
ok = true;
}
}
/* if we get here nothing happens */
if (ok == false) {
if (sms.to_camera == false) {
copy_v3_v3(rv3d->ofs, sms.dst.ofs);
copy_qt_qt(rv3d->viewquat, sms.dst.quat);
rv3d->dist = sms.dst.dist;
v3d->lens = sms.dst.lens;
ED_view3d_camera_lock_sync(v3d, rv3d);
}
if (rv3d->viewlock & RV3D_BOXVIEW) {
view3d_boxview_copy(sa, ar);
}
ED_region_tag_redraw(ar);
}
}
static void screen_opengl_render_end(bContext *C, OGLRender *oglrender)
{
Main *bmain = CTX_data_main(C);
Scene *scene = oglrender->scene;
int i;
if (oglrender->is_animation) {
BLI_task_pool_work_and_wait(oglrender->task_pool);
BLI_task_pool_free(oglrender->task_pool);
/* Depending on various things we might or might not use global scheduler. */
if (oglrender->task_scheduler != NULL) {
BLI_task_scheduler_free(oglrender->task_scheduler);
}
BLI_spin_end(&oglrender->reports_lock);
}
BLI_mutex_end(&oglrender->task_mutex);
BLI_condition_end(&oglrender->task_condition);
#ifdef DEBUG_TIME
printf("Total render time: %f\n", PIL_check_seconds_timer() - oglrender->time_start);
#endif
if (oglrender->mh) {
if (BKE_imtype_is_movie(scene->r.im_format.imtype)) {
for (i = 0; i < oglrender->totvideos; i++) {
oglrender->mh->end_movie(oglrender->movie_ctx_arr[i]);
oglrender->mh->context_free(oglrender->movie_ctx_arr[i]);
}
}
if (oglrender->movie_ctx_arr) {
MEM_freeN(oglrender->movie_ctx_arr);
}
}
if (oglrender->timer) { /* exec will not have a timer */
scene->r.cfra = oglrender->cfrao;
BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, screen_opengl_layers(oglrender));
WM_event_remove_timer(oglrender->wm, oglrender->win, oglrender->timer);
}
WM_cursor_modal_restore(oglrender->win);
WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene);
if (oglrender->fx)
GPU_fx_compositor_destroy(oglrender->fx);
GPU_offscreen_free(oglrender->ofs);
if (oglrender->is_sequencer) {
MEM_freeN(oglrender->seq_data.ibufs_arr);
}
oglrender->scene->customdata_mask_modal = 0;
CTX_wm_area_set(C, oglrender->prevsa);
CTX_wm_region_set(C, oglrender->prevar);
MEM_freeN(oglrender);
}
