Differential D2138 Diff 7200 source/blender/editors/space_view3d/view3d_view.c

Changeset View

Standalone View

source/blender/editors/space_view3d/view3d_view.c

Show All 40 Lines

#include "BKE_anim.h"		#include "BKE_anim.h"
#include "BKE_action.h"		#include "BKE_action.h"
#include "BKE_camera.h"		#include "BKE_camera.h"
#include "BKE_context.h"		#include "BKE_context.h"
#include "BKE_depsgraph.h"		#include "BKE_depsgraph.h"
#include "BKE_object.h"		#include "BKE_object.h"
#include "BKE_global.h"		#include "BKE_global.h"
		#include "BKE_localview.h"
#include "BKE_main.h"		#include "BKE_main.h"
#include "BKE_report.h"		#include "BKE_report.h"
#include "BKE_scene.h"		#include "BKE_scene.h"
#include "BKE_screen.h"		#include "BKE_screen.h"

#include "BIF_gl.h"		#include "BIF_gl.h"
#include "BIF_glutil.h"		#include "BIF_glutil.h"

▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines	else {
glLoadMatrixf(rv3d->winmat);		glLoadMatrixf(rv3d->winmat);
glMatrixMode(GL_MODELVIEW);		glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(rv3d->viewmat);		glLoadMatrixf(rv3d->viewmat);
}		}
}		}

float ED_view3d_cursor3d_get(Scene scene, View3D *v3d)		float ED_view3d_cursor3d_get(Scene scene, View3D *v3d)
{		{
if (v3d && v3d->localvd) return v3d->cursor;		if (v3d && v3d->localviewd) return v3d->cursor;
else return scene->cursor;		else return scene->cursor;
}		}

Camera ED_view3d_camera_data_get(View3D v3d, RegionView3D *rv3d)		Camera ED_view3d_camera_data_get(View3D v3d, RegionView3D *rv3d)
{		{
/* establish the camera object, so we can default to view mapping if anything is wrong with it */		/* establish the camera object, so we can default to view mapping if anything is wrong with it */
if ((rv3d->persp == RV3D_CAMOB) && v3d->camera && (v3d->camera->type == OB_CAMERA)) {		if ((rv3d->persp == RV3D_CAMOB) && v3d->camera && (v3d->camera->type == OB_CAMERA)) {
return v3d->camera->data;		return v3d->camera->data;
▲ Show 20 Lines • Show All 937 Lines • ▼ Show 20 Lines	if (!BDR_drawSketchNames(vc)) {
draw_object(scene, ar, v3d, BASACT, DRAW_PICKING \| DRAW_CONSTCOLOR);		draw_object(scene, ar, v3d, BASACT, DRAW_PICKING \| DRAW_CONSTCOLOR);
}		}
}		}
else {		else {
Base *base;		Base *base;

v3d->xray = true; /* otherwise it postpones drawing */		v3d->xray = true; /* otherwise it postpones drawing */
for (base = scene->base.first; base; base = base->next) {		for (base = scene->base.first; base; base = base->next) {
if (base->lay & v3d->lay) {		if ((base->lay & v3d->lay) && BKE_localview_is_object_visible(v3d, base->object)) {

if ((base->object->restrictflag & OB_RESTRICT_SELECT) \|\|		if ((base->object->restrictflag & OB_RESTRICT_SELECT) \|\|
(use_obedit_skip && (scene->obedit->data == base->object->data)))		(use_obedit_skip && (scene->obedit->data == base->object->data)))
{		{
base->selcol = 0;		base->selcol = 0;
}		}
else {		else {
base->selcol = code;		base->selcol = code;

▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines	short view3d_opengl_select(ViewContext vc, unsigned int buffer, unsigned int bufsize, const rcti *input, bool do_nearest)

if (hits < 0) printf("Too many objects in select buffer\n"); /* XXX make error message */		if (hits < 0) printf("Too many objects in select buffer\n"); /* XXX make error message */

return hits;		return hits;
}		}

/* ******************** local view operator ****************** */		/* ******************** local view operator ****************** */

static unsigned int free_localbit(Main *bmain)		static void find_free_localviewinfo(Main bmain, LocalViewInfo r_free_view)
{		{
unsigned int lay;		unsigned int lay = 0;
ScrArea *sa;
bScreen *sc;

lay = 0;

/* sometimes we loose a localview: when an area is closed */		/* sometimes we loose a localview: when an area is closed */
/* check all areas: which localviews are in use? */		/* check all areas: which localviews are in use? */
for (sc = bmain->screen.first; sc; sc = sc->id.next) {		for (bScreen *sc = bmain->screen.first; sc; sc = sc->id.next) {
for (sa = sc->areabase.first; sa; sa = sa->next) {		for (ScrArea *sa = sc->areabase.first; sa; sa = sa->next) {
SpaceLink *sl = sa->spacedata.first;		for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) {
for (; sl; sl = sl->next) {
if (sl->spacetype == SPACE_VIEW3D) {		if (sl->spacetype == SPACE_VIEW3D) {
View3D v3d = (View3D ) sl;		View3D v3d = (View3D ) sl;
lay \|= v3d->lay;		if (v3d->localviewd) {
		lay \|= v3d->localviewd->info.viewbits;
		}
}		}
}		}
}		}
}		}

if ((lay & 0x01000000) == 0) return 0x01000000;		BLI_assert(r_free_view->viewbits == 0);
if ((lay & 0x02000000) == 0) return 0x02000000;		/* search free bit */
if ((lay & 0x04000000) == 0) return 0x04000000;		for (int i = 0; i < sizeof(r_free_view->viewbits) * 8; i++) {
if ((lay & 0x08000000) == 0) return 0x08000000;		if ((lay & (1 << i)) == 0) {
if ((lay & 0x10000000) == 0) return 0x10000000;		r_free_view->viewbits = (1 << i);
if ((lay & 0x20000000) == 0) return 0x20000000;		break;
if ((lay & 0x40000000) == 0) return 0x40000000;		}
if ((lay & 0x80000000) == 0) return 0x80000000;		}

return 0;
}		}

int ED_view3d_scene_layer_set(int lay, const int values, int active)		int ED_view3d_scene_layer_set(int lay, const int values, int active)
{		{
int i, tot = 0;		int i, tot = 0;

/* ensure we always have some layer selected */		/* ensure we always have some layer selected */
for (i = 0; i < 20; i++)		for (i = 0; i < 20; i++)
Show All 24 Lines	for (i = 0; i < 20; i++) {
break;		break;
}		}
}		}
}		}

return lay;		return lay;
}		}

		static void view3d_localview_area_data_init(LocalViewAreaData localviewd, View3D v3d)
		{
		localviewd->near = v3d->near;
		localviewd->far = v3d->far;
		localviewd->drawtype = v3d->drawtype;
		localviewd->camera = v3d->camera;
		#ifndef NDEBUG
		localviewd->v3d_lay = v3d->lay;
		#endif
		}

		static void view3d_localview_region_data_init(LocalViewRegionData localviewd, RegionView3D rv3d)
		{
		localviewd->camzoom = rv3d->camzoom;
		localviewd->persp = rv3d->persp;
		localviewd->view = rv3d->view;
		localviewd->dist = rv3d->dist;
		copy_qt_qt(localviewd->viewquat, rv3d->viewquat);
		copy_v3_v3(localviewd->ofs, rv3d->ofs);
		}

static bool view3d_localview_init(		static bool view3d_localview_init(
wmWindowManager wm, wmWindow win,		wmWindowManager wm, wmWindow win,
Main bmain, Scene scene, ScrArea *sa, const int smooth_viewtx,		Main bmain, Scene scene, ScrArea *sa, const int smooth_viewtx,
ReportList *reports)		ReportList *reports)
{		{
View3D *v3d = sa->spacedata.first;		View3D *v3d = sa->spacedata.first;
Base *base;
float min[3], max[3], box[3], mid[3];		float min[3], max[3], box[3], mid[3];
float size = 0.0f;		float size = 0.0f;
unsigned int locallay;		LocalViewInfo new_view = {0};
bool ok = false;		bool ok = false;

if (v3d->localvd) {		BLI_assert(v3d->localviewd == NULL);
return ok;
}

INIT_MINMAX(min, max);		INIT_MINMAX(min, max);

locallay = free_localbit(bmain);		find_free_localviewinfo(bmain, &new_view);

if (locallay == 0) {		if (new_view.viewbits == 0) {
BKE_report(reports, RPT_ERROR, "No more than 8 local views");		BKE_reportf(reports, RPT_ERROR, "No more than %lu local views", sizeof(new_view.viewbits) * 8);
ok = false;		ok = false;
}		}
else {		else {
if (scene->obedit) {		if (scene->obedit) {
BKE_object_minmax(scene->obedit, min, max, false);		BKE_object_minmax(scene->obedit, min, max, false);

ok = true;		ok = true;

BASACT->lay \|= locallay;		BASACT->object->localview.viewbits \|= new_view.viewbits;
scene->obedit->lay = BASACT->lay;		scene->obedit->localview = BASACT->object->localview;
}		}
else {		else {
for (base = FIRSTBASE; base; base = base->next) {		for (Base *base = FIRSTBASE; base; base = base->next) {
if (TESTBASE(v3d, base)) {		if (TESTBASE(v3d, base)) {
BKE_object_minmax(base->object, min, max, false);		BKE_object_minmax(base->object, min, max, false);
base->lay \|= locallay;		base->object->localview.viewbits \|= new_view.viewbits;
base->object->lay = base->lay;
ok = true;		ok = true;
}		}
}		}
}		}

sub_v3_v3v3(box, max, min);		sub_v3_v3v3(box, max, min);
size = max_fff(box[0], box[1], box[2]);		size = max_fff(box[0], box[1], box[2]);
}		}

if (ok == true) {		if (ok == true) {
ARegion *ar;		v3d->localviewd = MEM_callocN(sizeof(*v3d->localviewd), "localview area data");
		view3d_localview_area_data_init(v3d->localviewd, v3d);
v3d->localvd = MEM_mallocN(sizeof(View3D), "localview");

memcpy(v3d->localvd, v3d, sizeof(View3D));

mid_v3_v3v3(mid, min, max);		mid_v3_v3v3(mid, min, max);

copy_v3_v3(v3d->cursor, mid);		copy_v3_v3(v3d->cursor, mid);

for (ar = sa->regionbase.first; ar; ar = ar->next) {		for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
if (ar->regiontype == RGN_TYPE_WINDOW) {		if (ar->regiontype == RGN_TYPE_WINDOW) {
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
bool ok_dist = true;		bool ok_dist = true;

/* new view values */		/* new view values */
Object *camera_old = NULL;		Object *camera_old = NULL;
float dist_new, ofs_new[3];		float dist_new, ofs_new[3];

rv3d->localvd = MEM_mallocN(sizeof(RegionView3D), "localview region");		rv3d->localviewd = MEM_mallocN(sizeof(*rv3d->localviewd), "localview region data");
memcpy(rv3d->localvd, rv3d, sizeof(RegionView3D));		view3d_localview_region_data_init(rv3d->localviewd, rv3d);

negate_v3_v3(ofs_new, mid);		negate_v3_v3(ofs_new, mid);

if (rv3d->persp == RV3D_CAMOB) {		if (rv3d->persp == RV3D_CAMOB) {
rv3d->persp = RV3D_PERSP;		rv3d->persp = RV3D_PERSP;
camera_old = v3d->camera;		camera_old = v3d->camera;
}		}

Show All 14 Lines	for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
ED_view3d_smooth_view_ex(		ED_view3d_smooth_view_ex(
wm, win, sa, v3d, ar, smooth_viewtx,		wm, win, sa, v3d, ar, smooth_viewtx,
&(const V3D_SmoothParams) {		&(const V3D_SmoothParams) {
.camera_old = camera_old,		.camera_old = camera_old,
.ofs = ofs_new, .quat = rv3d->viewquat,		.ofs = ofs_new, .quat = rv3d->viewquat,
.dist = ok_dist ? &dist_new : NULL, .lens = &v3d->lens});		.dist = ok_dist ? &dist_new : NULL, .lens = &v3d->lens});
}		}
}		}

v3d->lay = locallay;		v3d->localviewd->info = new_view;
}		}
else {		else {
/* clear flags */		/* clear flags */
for (base = FIRSTBASE; base; base = base->next) {		for (Base *base = FIRSTBASE; base; base = base->next) {
if (base->lay & locallay) {		Object *ob = base->object;
base->lay -= locallay;		if (BKE_localview_info_cmp(new_view, ob->localview)) {
if (base->lay == 0) base->lay = v3d->layact;		ob->localview.viewbits &= ~new_view.viewbits;
if (base->object != scene->obedit) base->flag \|= SELECT;		if (ob != scene->obedit) {
base->object->lay = base->lay;		base->flag \|= SELECT;
}		}
}		}
		/* local view used to work with object/base bitfields, check updates didn't break anything */
		BLI_assert(ob->lay > 0 && ob->lay == base->lay);
		}
}		}

return ok;		return ok;
}		}

static void restore_localviewdata(wmWindowManager wm, wmWindow win, Main bmain, Scene scene, ScrArea *sa, const int smooth_viewtx)		static void view3d_localviewdata_restore(
		wmWindowManager wm, wmWindow win,
		Main bmain, Scene scene, ScrArea *sa,
		const int smooth_viewtx)
{		{
const bool free = true;
ARegion *ar;
View3D *v3d = sa->spacedata.first;		View3D *v3d = sa->spacedata.first;
Object camera_old, camera_new;

if (v3d->localvd == NULL) return;

camera_old = v3d->camera;		Object *camera_old = v3d->camera;
camera_new = v3d->localvd->camera;		Object *camera_new = v3d->localviewd->camera;

v3d->near = v3d->localvd->near;		/* reset View3D data */
v3d->far = v3d->localvd->far;		v3d->near = v3d->localviewd->near;
v3d->lay = v3d->localvd->lay;		v3d->far = v3d->localviewd->far;
v3d->layact = v3d->localvd->layact;		v3d->drawtype = v3d->localviewd->drawtype;
v3d->drawtype = v3d->localvd->drawtype;		v3d->camera = v3d->localviewd->camera;
v3d->camera = v3d->localvd->camera;

if (free) {		MEM_SAFE_FREE(v3d->localviewd);
MEM_freeN(v3d->localvd);
v3d->localvd = NULL;
}

for (ar = sa->regionbase.first; ar; ar = ar->next) {		for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
if (ar->regiontype == RGN_TYPE_WINDOW) {		if (ar->regiontype == RGN_TYPE_WINDOW) {
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;

if (rv3d->localvd) {		if (rv3d->localviewd) {
Object camera_old_rv3d, camera_new_rv3d;		Object *camera_old_rv3d = (rv3d->persp == RV3D_CAMOB) ? camera_old : NULL;
		Object *camera_new_rv3d = (rv3d->localviewd->persp == RV3D_CAMOB) ? camera_new : NULL;
camera_old_rv3d = (rv3d->persp == RV3D_CAMOB) ? camera_old : NULL;
camera_new_rv3d = (rv3d->localvd->persp == RV3D_CAMOB) ? camera_new : NULL;		/* reset RegionView3D data */
		rv3d->view = rv3d->localviewd->view;
rv3d->view = rv3d->localvd->view;		rv3d->persp = rv3d->localviewd->persp;
rv3d->persp = rv3d->localvd->persp;		rv3d->camzoom = rv3d->localviewd->camzoom;
rv3d->camzoom = rv3d->localvd->camzoom;

ED_view3d_smooth_view_ex(		ED_view3d_smooth_view_ex(
wm, win, sa,		wm, win, sa,
v3d, ar, smooth_viewtx,		v3d, ar, smooth_viewtx,
&(const V3D_SmoothParams) {		&(const V3D_SmoothParams) {
.camera_old = camera_old_rv3d, .camera = camera_new_rv3d,		.camera_old = camera_old_rv3d, .camera = camera_new_rv3d,
.ofs = rv3d->localvd->ofs, .quat = rv3d->localvd->viewquat,		.ofs = rv3d->localviewd->ofs, .quat = rv3d->localviewd->viewquat,
.dist = &rv3d->localvd->dist});		.dist = &rv3d->localviewd->dist});

if (free) {		MEM_SAFE_FREE(rv3d->localviewd);
MEM_freeN(rv3d->localvd);
rv3d->localvd = NULL;
}
}		}

ED_view3d_shade_update(bmain, scene, v3d, sa);		ED_view3d_shade_update(bmain, scene, v3d, sa);
}		}
}		}
}		}

static bool view3d_localview_exit(		static bool view3d_localview_exit(
wmWindowManager wm, wmWindow win,		wmWindowManager wm, wmWindow win,
Main bmain, Scene scene, ScrArea *sa, const int smooth_viewtx)		Main bmain, Scene scene, ScrArea *sa,
		const int smooth_viewtx)
{		{
View3D *v3d = sa->spacedata.first;		View3D *v3d = sa->spacedata.first;
struct Base *base;		LocalViewInfo localview = v3d->localviewd->info; /* store for use after v3d local view data is reset */
unsigned int locallay;

if (v3d->localvd) {

locallay = v3d->lay & 0xFF000000;

restore_localviewdata(wm, win, bmain, scene, sa, smooth_viewtx);		BLI_assert(sa->spacetype == SPACE_VIEW3D && v3d->localviewd);
		BLI_assert(v3d->localviewd->v3d_lay == v3d->lay);

/* for when in other window the layers have changed */		view3d_localviewdata_restore(wm, win, bmain, scene, sa, smooth_viewtx);
if (v3d->scenelock) v3d->lay = scene->lay;

for (base = FIRSTBASE; base; base = base->next) {		for (Base *base = FIRSTBASE; base; base = base->next) {
if (base->lay & locallay) {		if (BKE_localview_info_cmp(localview, base->object->localview)) {
base->lay -= locallay;		base->object->localview.viewbits &= ~localview.viewbits;
if (base->lay == 0) base->lay = v3d->layact;
if (base->object != scene->obedit) {		if (base->object != scene->obedit) {
base->flag \|= SELECT;		base->flag \|= SELECT;
base->object->flag \|= SELECT;		base->object->flag \|= SELECT;
}		}
base->object->lay = base->lay;
}		}
		/* local view used to work with object/base bitfields, check updates didn't break anything */
		BLI_assert(base->lay > 0 && base->lay == base->object->lay);
}		}

		BKE_screen_view3d_sync(v3d, scene);
DAG_on_visible_update(bmain, false);		DAG_on_visible_update(bmain, false);

return true;		return true;
}		}
else {
return false;
}
}

static int localview_exec(bContext C, wmOperator op)		static int localview_exec(bContext C, wmOperator op)
{		{
const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);		const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
wmWindowManager *wm = CTX_wm_manager(C);		wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win = CTX_wm_window(C);		wmWindow *win = CTX_wm_window(C);
Main *bmain = CTX_data_main(C);		Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);
ScrArea *sa = CTX_wm_area(C);		ScrArea *sa = CTX_wm_area(C);
View3D *v3d = CTX_wm_view3d(C);		View3D *v3d = CTX_wm_view3d(C);
bool changed;		bool changed;

if (v3d->localvd) {		if (v3d->localviewd) {
changed = view3d_localview_exit(wm, win, bmain, scene, sa, smooth_viewtx);		changed = view3d_localview_exit(wm, win, bmain, scene, sa, smooth_viewtx);
}		}
else {		else {
changed = view3d_localview_init(wm, win, bmain, scene, sa, smooth_viewtx, op->reports);		changed = view3d_localview_init(wm, win, bmain, scene, sa, smooth_viewtx, op->reports);
}		}

if (changed) {		if (changed) {
DAG_id_type_tag(bmain, ID_OB);		DAG_id_type_tag(bmain, ID_OB);
ED_area_tag_redraw(sa);		ED_area_tag_redraw(sa);

/* unselected objects become selected when exiting */		/* unselected objects become selected when exiting */
if (v3d->localvd == NULL) {		if (v3d->localviewd == NULL) {
WM_event_add_notifier(C, NC_SCENE \| ND_OB_SELECT, scene);		WM_event_add_notifier(C, NC_SCENE \| ND_OB_SELECT, scene);
}		}

return OPERATOR_FINISHED;		return OPERATOR_FINISHED;
}		}
else {		else {
return OPERATOR_CANCELLED;		return OPERATOR_CANCELLED;
}		}
▲ Show 20 Lines • Show All 408 Lines • Show Last 20 Lines