Differential D2451 Diff 8780 source/blender/windowmanager/intern/wm_draw.c

Changeset View

Standalone View

source/blender/windowmanager/intern/wm_draw.c

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines


static void wm_paintcursor_draw(bContext C, ARegion ar)		static void wm_paintcursor_draw(bContext C, ARegion ar)
{		{
wmWindowManager *wm = CTX_wm_manager(C);		wmWindowManager *wm = CTX_wm_manager(C);

if (wm->paintcursors.first) {		if (wm->paintcursors.first) {
wmWindow *win = CTX_wm_window(C);		wmWindow *win = CTX_wm_window(C);
bScreen *screen = win->screen;		bScreen *screen = WM_window_get_active_screen(win);
wmPaintCursor *pc;		wmPaintCursor *pc;

if (ar->swinid && screen->subwinactive == ar->swinid) {		if (ar->swinid && screen->subwinactive == ar->swinid) {
for (pc = wm->paintcursors.first; pc; pc = pc->next) {		for (pc = wm->paintcursors.first; pc; pc = pc->next) {
if (pc->poll == NULL \|\| pc->poll(C)) {		if (pc->poll == NULL \|\| pc->poll(C)) {
ARegion *ar_other = CTX_wm_region(C);		ARegion *ar_other = CTX_wm_region(C);
if (ELEM(win->grabcursor, GHOST_kGrabWrap, GHOST_kGrabHide)) {		if (ELEM(win->grabcursor, GHOST_kGrabWrap, GHOST_kGrabHide)) {
int x = 0, y = 0;		int x = 0, y = 0;
Show All 26 Lines
static bool wm_area_test_invalid_backbuf(ScrArea *sa)		static bool wm_area_test_invalid_backbuf(ScrArea *sa)
{		{
if (sa->spacetype == SPACE_VIEW3D)		if (sa->spacetype == SPACE_VIEW3D)
return (((View3D *)sa->spacedata.first)->flag & V3D_INVALID_BACKBUF) != 0;		return (((View3D *)sa->spacedata.first)->flag & V3D_INVALID_BACKBUF) != 0;
else		else
return true;		return true;
}		}

static void wm_region_test_render_do_draw(bScreen screen, ScrArea sa, ARegion *ar)		static void wm_region_test_render_do_draw(const Scene scene, ScrArea sa, ARegion *ar)
{		{
/* tag region for redraw from render engine preview running inside of it */		/* tag region for redraw from render engine preview running inside of it */
if (sa->spacetype == SPACE_VIEW3D) {		if (sa->spacetype == SPACE_VIEW3D) {
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
RenderEngine *engine = (rv3d) ? rv3d->render_engine : NULL;		RenderEngine *engine = (rv3d) ? rv3d->render_engine : NULL;

if (engine && (engine->flag & RE_ENGINE_DO_DRAW)) {		if (engine && (engine->flag & RE_ENGINE_DO_DRAW)) {
Scene *scene = screen->scene;
View3D *v3d = sa->spacedata.first;		View3D *v3d = sa->spacedata.first;
rcti border_rect;		rcti border_rect;

/* do partial redraw when possible */		/* do partial redraw when possible */
if (ED_view3d_calc_render_border(scene, v3d, ar, &border_rect))		if (ED_view3d_calc_render_border(scene, v3d, ar, &border_rect))
ED_region_tag_redraw_partial(ar, &border_rect);		ED_region_tag_redraw_partial(ar, &border_rect);
else		else
ED_region_tag_redraw(ar);		ED_region_tag_redraw(ar);

engine->flag &= ~RE_ENGINE_DO_DRAW;		engine->flag &= ~RE_ENGINE_DO_DRAW;
}		}
}		}
}		}

/******************** draw all ************************/		/******************** draw all ************************/
/* - reference method, draw all each time */		/* - reference method, draw all each time */

static void wm_method_draw_full(bContext C, wmWindow win)		static void wm_method_draw_full(bContext C, wmWindow win)
{		{
bScreen *screen = win->screen;		bScreen *screen = WM_window_get_active_screen(win);
ScrArea *sa;		ScrArea *sa;
ARegion *ar;		ARegion *ar;

/* draw area regions */		/* draw area regions */
for (sa = screen->areabase.first; sa; sa = sa->next) {		for (sa = screen->areabase.first; sa; sa = sa->next) {
CTX_wm_area_set(C, sa);		CTX_wm_area_set(C, sa);

for (ar = sa->regionbase.first; ar; ar = ar->next) {		for (ar = sa->regionbase.first; ar; ar = ar->next) {
if (ar->swinid) {		if (ar->swinid) {
CTX_wm_region_set(C, ar);		CTX_wm_region_set(C, ar);
ED_region_do_draw(C, ar);		ED_region_do_draw(C, ar);
ar->do_draw = false;		ar->do_draw = false;
wm_paintcursor_draw(C, ar);		wm_paintcursor_draw(C, ar);
CTX_wm_region_set(C, NULL);		CTX_wm_region_set(C, NULL);
}		}
}		}

wm_area_mark_invalid_backbuf(sa);		wm_area_mark_invalid_backbuf(sa);
CTX_wm_area_set(C, NULL);		CTX_wm_area_set(C, NULL);
}		}

ED_screen_draw(win);		ED_screen_draw(win);
win->screen->do_draw = false;		screen->do_draw = false;

/* draw overlapping regions */		/* draw overlapping regions */
for (ar = screen->regionbase.first; ar; ar = ar->next) {		for (ar = screen->regionbase.first; ar; ar = ar->next) {
if (ar->swinid) {		if (ar->swinid) {
CTX_wm_menu_set(C, ar);		CTX_wm_menu_set(C, ar);
ED_region_do_draw(C, ar);		ED_region_do_draw(C, ar);
ar->do_draw = false;		ar->do_draw = false;
CTX_wm_menu_set(C, NULL);		CTX_wm_menu_set(C, NULL);
Show All 39 Lines	if (BLI_rcti_isect(dirty, &ar->winrct, NULL)) {
ar->swap = WIN_NONE_OK;		ar->swap = WIN_NONE_OK;
}		}
}		}
}		}

static void wm_method_draw_overlap_all(bContext C, wmWindow win, int exchange)		static void wm_method_draw_overlap_all(bContext C, wmWindow win, int exchange)
{		{
wmWindowManager *wm = CTX_wm_manager(C);		wmWindowManager *wm = CTX_wm_manager(C);
bScreen *screen = win->screen;		bScreen *screen = WM_window_get_active_screen(win);
ScrArea *sa;		ScrArea *sa;
ARegion *ar;		ARegion *ar;
static rcti rect = {0, 0, 0, 0};		static rcti rect = {0, 0, 0, 0};

/* after backbuffer selection draw, we need to redraw */		/* after backbuffer selection draw, we need to redraw */
for (sa = screen->areabase.first; sa; sa = sa->next)		for (sa = screen->areabase.first; sa; sa = sa->next)
for (ar = sa->regionbase.first; ar; ar = ar->next)		for (ar = sa->regionbase.first; ar; ar = ar->next)
if (ar->swinid && !wm_area_test_invalid_backbuf(sa))		if (ar->swinid && !wm_area_test_invalid_backbuf(sa))
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines	for (sa = screen->areabase.first; sa; sa = sa->next) {

wm_area_mark_invalid_backbuf(sa);		wm_area_mark_invalid_backbuf(sa);
CTX_wm_area_set(C, NULL);		CTX_wm_area_set(C, NULL);
}		}

/* after area regions so we can do area 'overlay' drawing */		/* after area regions so we can do area 'overlay' drawing */
if (screen->do_draw) {		if (screen->do_draw) {
ED_screen_draw(win);		ED_screen_draw(win);
win->screen->do_draw = false;		screen->do_draw = false;

if (exchange)		if (exchange)
screen->swap = WIN_FRONT_OK;		screen->swap = WIN_FRONT_OK;
}		}
else if (exchange) {		else if (exchange) {
if (screen->swap == WIN_FRONT_OK) {		if (screen->swap == WIN_FRONT_OK) {
ED_screen_draw(win);		ED_screen_draw(win);
win->screen->do_draw = false;		screen->do_draw = false;
screen->swap = WIN_BOTH_OK;		screen->swap = WIN_BOTH_OK;
}		}
else if (screen->swap == WIN_BACK_OK)		else if (screen->swap == WIN_BACK_OK)
screen->swap = WIN_FRONT_OK;		screen->swap = WIN_FRONT_OK;
else if (screen->swap == WIN_BOTH_OK)		else if (screen->swap == WIN_BOTH_OK)
screen->swap = WIN_BOTH_OK;		screen->swap = WIN_BOTH_OK;
}		}

▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines
}		}

static void wm_draw_region_blend(wmWindow win, ARegion ar, wmDrawTriple *triple)		static void wm_draw_region_blend(wmWindow win, ARegion ar, wmDrawTriple *triple)
{		{
float fac = ED_region_blend_factor(ar);		float fac = ED_region_blend_factor(ar);

/* region blend always is 1, except when blend timer is running */		/* region blend always is 1, except when blend timer is running */
if (fac < 1.0f) {		if (fac < 1.0f) {
wmSubWindowScissorSet(win, win->screen->mainwin, &ar->winrct, true);		bScreen *screen = WM_window_get_active_screen(win);

		wmSubWindowScissorSet(win, screen->mainwin, &ar->winrct, true);

glEnable(GL_BLEND);		glEnable(GL_BLEND);
wm_triple_draw_textures(win, triple, 1.0f - fac);		wm_triple_draw_textures(win, triple, 1.0f - fac);
glDisable(GL_BLEND);		glDisable(GL_BLEND);
}		}
}		}

static void wm_method_draw_triple(bContext C, wmWindow win)		static void wm_method_draw_triple(bContext C, wmWindow win)
{		{
wmWindowManager *wm = CTX_wm_manager(C);		wmWindowManager *wm = CTX_wm_manager(C);
wmDrawData dd, dd_next, *drawdata = win->drawdata.first;		wmDrawData dd, dd_next, *drawdata = win->drawdata.first;
bScreen *screen = win->screen;		bScreen *screen = WM_window_get_active_screen(win);
ScrArea *sa;		ScrArea *sa;
ARegion *ar;		ARegion *ar;
bool copytex = false;		bool copytex = false;

if (drawdata && drawdata->triple) {		if (drawdata && drawdata->triple) {
#if 0 /* why do we need to clear before overwriting? */		#if 0 /* why do we need to clear before overwriting? */
glClearColor(1, 1, 0, 0);		glClearColor(1, 1, 0, 0);
glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines	for (ar = sa->regionbase.first; ar; ar = ar->next) {
}		}
}		}

CTX_wm_area_set(C, NULL);		CTX_wm_area_set(C, NULL);
}		}

/* after area regions so we can do area 'overlay' drawing */		/* after area regions so we can do area 'overlay' drawing */
ED_screen_draw(win);		ED_screen_draw(win);
win->screen->do_draw = false;		WM_window_get_active_screen(win)->do_draw = false;

/* draw floating regions (menus) */		/* draw floating regions (menus) */
for (ar = screen->regionbase.first; ar; ar = ar->next) {		for (ar = screen->regionbase.first; ar; ar = ar->next) {
if (ar->swinid) {		if (ar->swinid) {
CTX_wm_menu_set(C, ar);		CTX_wm_menu_set(C, ar);
ED_region_do_draw(C, ar);		ED_region_do_draw(C, ar);
ar->do_draw = false;		ar->do_draw = false;
CTX_wm_menu_set(C, NULL);		CTX_wm_menu_set(C, NULL);
Show All 10 Lines	static void wm_method_draw_triple(bContext C, wmWindow win)
}		}
}		}

static void wm_method_draw_triple_multiview(bContext C, wmWindow win, StereoViews sview)		static void wm_method_draw_triple_multiview(bContext C, wmWindow win, StereoViews sview)
{		{
wmWindowManager *wm = CTX_wm_manager(C);		wmWindowManager *wm = CTX_wm_manager(C);
wmDrawData *drawdata;		wmDrawData *drawdata;
wmDrawTriple triple_data, triple_all;		wmDrawTriple triple_data, triple_all;
bScreen *screen = win->screen;		bScreen *screen = WM_window_get_active_screen(win);
ScrArea *sa;		ScrArea *sa;
ARegion *ar;		ARegion *ar;
int copytex = false;		int copytex = false;
int id;		int id;

/* we store the triple_data in sequence to triple_all */		/* we store the triple_data in sequence to triple_all */
for (id = 0; id < 2; id++) {		for (id = 0; id < 2; id++) {
drawdata = BLI_findlink(&win->drawdata, (sview * 2) + id);		drawdata = BLI_findlink(&win->drawdata, (sview * 2) + id);
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines	for (sa = screen->areabase.first; sa; sa = sa->next) {
}		}

CTX_wm_area_set(C, NULL);		CTX_wm_area_set(C, NULL);
}		}

/* after area regions so we can do area 'overlay' drawing */		/* after area regions so we can do area 'overlay' drawing */
ED_screen_draw(win);		ED_screen_draw(win);
if (sview == STEREO_RIGHT_ID)		if (sview == STEREO_RIGHT_ID)
win->screen->do_draw = false;		screen->do_draw = false;

/* draw floating regions (menus) */		/* draw floating regions (menus) */
for (ar = screen->regionbase.first; ar; ar = ar->next) {		for (ar = screen->regionbase.first; ar; ar = ar->next) {
if (ar->swinid) {		if (ar->swinid) {
CTX_wm_menu_set(C, ar);		CTX_wm_menu_set(C, ar);
ED_region_do_draw(C, ar);		ED_region_do_draw(C, ar);
if (sview == STEREO_RIGHT_ID)		if (sview == STEREO_RIGHT_ID)
ar->do_draw = false;		ar->do_draw = false;
Show All 15 Lines	static void wm_method_draw_triple_multiview(bContext C, wmWindow win, StereoViews sview)
wm_triple_copy_textures(win, triple_all);		wm_triple_copy_textures(win, triple_all);
}		}

/**************** main update call ********************/		/**************** main update call ********************/

/* quick test to prevent changing window drawable */		/* quick test to prevent changing window drawable */
static bool wm_draw_update_test_window(wmWindow *win)		static bool wm_draw_update_test_window(wmWindow *win)
{		{
		const Scene *scene = WM_window_get_active_scene(win);
		const bScreen *screen = WM_window_get_active_screen(win);
ScrArea *sa;		ScrArea *sa;
ARegion *ar;		ARegion *ar;
bool do_draw = false;		bool do_draw = false;

for (ar = win->screen->regionbase.first; ar; ar = ar->next) {		for (ar = screen->regionbase.first; ar; ar = ar->next) {
if (ar->do_draw_overlay) {		if (ar->do_draw_overlay) {
wm_tag_redraw_overlay(win, ar);		wm_tag_redraw_overlay(win, ar);
ar->do_draw_overlay = false;		ar->do_draw_overlay = false;
}		}
if (ar->swinid && ar->do_draw)		if (ar->swinid && ar->do_draw)
do_draw = true;		do_draw = true;
}		}

for (sa = win->screen->areabase.first; sa; sa = sa->next) {		for (sa = screen->areabase.first; sa; sa = sa->next) {
for (ar = sa->regionbase.first; ar; ar = ar->next) {		for (ar = sa->regionbase.first; ar; ar = ar->next) {
wm_region_test_render_do_draw(win->screen, sa, ar);		wm_region_test_render_do_draw(scene, sa, ar);

if (ar->swinid && ar->do_draw)		if (ar->swinid && ar->do_draw)
do_draw = true;		do_draw = true;
}		}
}		}

if (do_draw)		if (do_draw)
return true;		return true;

if (win->screen->do_refresh)		if (screen->do_refresh)
return true;		return true;
if (win->screen->do_draw)		if (screen->do_draw)
return true;		return true;
if (win->screen->do_draw_gesture)		if (screen->do_draw_gesture)
return true;		return true;
if (win->screen->do_draw_paintcursor)		if (screen->do_draw_paintcursor)
return true;		return true;
if (win->screen->do_draw_drag)		if (screen->do_draw_drag)
return true;		return true;

return false;		return false;
}		}

static int wm_automatic_draw_method(wmWindow *win)		static int wm_automatic_draw_method(wmWindow *win)
{		{
/* Ideally all cards would work well with triple buffer, since if it works		/* Ideally all cards would work well with triple buffer, since if it works
Show All 24 Lines	if (win->drawmethod != U.wmdrawmethod)
win->drawmethod = U.wmdrawmethod;		win->drawmethod = U.wmdrawmethod;
return (USER_DRAW_TRIPLE == wm_automatic_draw_method(win));		return (USER_DRAW_TRIPLE == wm_automatic_draw_method(win));
}		}

void wm_tag_redraw_overlay(wmWindow win, ARegion ar)		void wm_tag_redraw_overlay(wmWindow win, ARegion ar)
{		{
/* for draw triple gestures, paint cursors don't need region redraw */		/* for draw triple gestures, paint cursors don't need region redraw */
if (ar && win) {		if (ar && win) {
		bScreen *screen = WM_window_get_active_screen(win);

if (wm_automatic_draw_method(win) != USER_DRAW_TRIPLE)		if (wm_automatic_draw_method(win) != USER_DRAW_TRIPLE)
ED_region_tag_redraw(ar);		ED_region_tag_redraw(ar);
win->screen->do_draw_paintcursor = true;		screen->do_draw_paintcursor = true;
}		}
}		}

void WM_paint_cursor_tag_redraw(wmWindow win, ARegion ar)		void WM_paint_cursor_tag_redraw(wmWindow win, ARegion ar)
{		{
win->screen->do_draw_paintcursor = true;		bScreen *screen = WM_window_get_active_screen(win);
		screen->do_draw_paintcursor = true;
wm_tag_redraw_overlay(win, ar);		wm_tag_redraw_overlay(win, ar);
}		}

void wm_draw_update(bContext *C)		void wm_draw_update(bContext *C)
{		{
wmWindowManager *wm = CTX_wm_manager(C);		wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win;		wmWindow *win;

Show All 17 Lines	#ifdef WIN32
}		}
#endif		#endif
if (win->drawmethod != U.wmdrawmethod) {		if (win->drawmethod != U.wmdrawmethod) {
wm_draw_window_clear(win);		wm_draw_window_clear(win);
win->drawmethod = U.wmdrawmethod;		win->drawmethod = U.wmdrawmethod;
}		}

if (wm_draw_update_test_window(win)) {		if (wm_draw_update_test_window(win)) {
		bScreen *screen = WM_window_get_active_screen(win);

CTX_wm_window_set(C, win);		CTX_wm_window_set(C, win);

/* sets context window+screen */		/* sets context window+screen */
wm_window_make_drawable(wm, win);		wm_window_make_drawable(wm, win);

/* notifiers for screen redraw */		/* notifiers for screen redraw */
if (win->screen->do_refresh)		if (screen->do_refresh)
ED_screen_refresh(wm, win);		ED_screen_refresh(wm, win);

int drawmethod = wm_automatic_draw_method(win);		int drawmethod = wm_automatic_draw_method(win);

if (win->drawfail)		if (win->drawfail)
wm_method_draw_overlap_all(C, win, 0);		wm_method_draw_overlap_all(C, win, 0);
else if (drawmethod == USER_DRAW_FULL)		else if (drawmethod == USER_DRAW_FULL)
wm_method_draw_full(C, win);		wm_method_draw_full(C, win);
else if (drawmethod == USER_DRAW_OVERLAP)		else if (drawmethod == USER_DRAW_OVERLAP)
wm_method_draw_overlap_all(C, win, 0);		wm_method_draw_overlap_all(C, win, 0);
else if (drawmethod == USER_DRAW_OVERLAP_FLIP)		else if (drawmethod == USER_DRAW_OVERLAP_FLIP)
wm_method_draw_overlap_all(C, win, 1);		wm_method_draw_overlap_all(C, win, 1);
else { /* USER_DRAW_TRIPLE */		else { /* USER_DRAW_TRIPLE */
if ((WM_stereo3d_enabled(win, false)) == false) {		if ((WM_stereo3d_enabled(win, false)) == false) {
wm_method_draw_triple(C, win);		wm_method_draw_triple(C, win);
}		}
else {		else {
wm_method_draw_triple_multiview(C, win, STEREO_LEFT_ID);		wm_method_draw_triple_multiview(C, win, STEREO_LEFT_ID);
wm_method_draw_triple_multiview(C, win, STEREO_RIGHT_ID);		wm_method_draw_triple_multiview(C, win, STEREO_RIGHT_ID);
wm_method_draw_stereo3d(C, win);		wm_method_draw_stereo3d(C, win);
}		}
}		}

win->screen->do_draw_gesture = false;		screen->do_draw_gesture = false;
win->screen->do_draw_paintcursor = false;		screen->do_draw_paintcursor = false;
win->screen->do_draw_drag = false;		screen->do_draw_drag = false;

wm_window_swap_buffers(win);		wm_window_swap_buffers(win);

CTX_wm_window_set(C, NULL);		CTX_wm_window_set(C, NULL);
}		}
}		}
}		}

void wm_draw_data_free(wmWindow *win)		void wm_draw_data_free(wmWindow *win)
{		{
wmDrawData *dd;		wmDrawData *dd;

for (dd = win->drawdata.first; dd; dd = dd->next) {		for (dd = win->drawdata.first; dd; dd = dd->next) {
wm_draw_triple_free(dd->triple);		wm_draw_triple_free(dd->triple);
}		}
BLI_freelistN(&win->drawdata);		BLI_freelistN(&win->drawdata);
}		}

void wm_draw_window_clear(wmWindow *win)		void wm_draw_window_clear(wmWindow *win)
{		{
bScreen *screen = win->screen;		bScreen *screen = WM_window_get_active_screen(win);
ScrArea *sa;		ScrArea *sa;
ARegion *ar;		ARegion *ar;

wm_draw_data_free(win);		wm_draw_data_free(win);

/* clear screen swap flags */		/* clear screen swap flags */
if (screen) {		if (screen) {
for (sa = screen->areabase.first; sa; sa = sa->next)		for (sa = screen->areabase.first; sa; sa = sa->next)
for (ar = sa->regionbase.first; ar; ar = ar->next)		for (ar = sa->regionbase.first; ar; ar = ar->next)
ar->swap = WIN_NONE_OK;		ar->swap = WIN_NONE_OK;

screen->swap = WIN_NONE_OK;		screen->swap = WIN_NONE_OK;
}		}
}		}

void wm_draw_region_clear(wmWindow win, ARegion ar)		void wm_draw_region_clear(wmWindow win, ARegion ar)
{		{
		bScreen *screen = WM_window_get_active_screen(win);
int drawmethod = wm_automatic_draw_method(win);		int drawmethod = wm_automatic_draw_method(win);

if (ELEM(drawmethod, USER_DRAW_OVERLAP, USER_DRAW_OVERLAP_FLIP))		if (ELEM(drawmethod, USER_DRAW_OVERLAP, USER_DRAW_OVERLAP_FLIP))
wm_flush_regions_down(win->screen, &ar->winrct);		wm_flush_regions_down(screen, &ar->winrct);

win->screen->do_draw = true;		screen->do_draw = true;
}		}

void WM_redraw_windows(bContext *C)		void WM_redraw_windows(bContext *C)
{		{
wmWindow *win_prev = CTX_wm_window(C);		wmWindow *win_prev = CTX_wm_window(C);
ScrArea *area_prev = CTX_wm_area(C);		ScrArea *area_prev = CTX_wm_area(C);
ARegion *ar_prev = CTX_wm_region(C);		ARegion *ar_prev = CTX_wm_region(C);

wm_draw_update(C);		wm_draw_update(C);

CTX_wm_window_set(C, win_prev);		CTX_wm_window_set(C, win_prev);
CTX_wm_area_set(C, area_prev);		CTX_wm_area_set(C, area_prev);
CTX_wm_region_set(C, ar_prev);		CTX_wm_region_set(C, ar_prev);
}		}