Differential D3007 Diff 9853 source/blender/editors/space_view3d/view3d_draw_legacy.c

Changeset View

Standalone View

source/blender/editors/space_view3d/view3d_draw_legacy.c

Show First 20 Lines • Show All 524 Lines • ▼ Show 20 Lines	if (BKE_image_is_stereo(ima)) {

BKE_image_multiview_index(ima, iuser);		BKE_image_multiview_index(ima, iuser);
}		}
else {		else {
iuser->flag &= ~IMA_SHOW_STEREO;		iuser->flag &= ~IMA_SHOW_STEREO;
}		}
}		}

static void view3d_draw_bgpic(Scene scene, ARegion ar, View3D *v3d,		static void view3d_draw_bgpic(Scene scene, const Depsgraph depsgraph,
		ARegion ar, View3D v3d,
const bool do_foreground, const bool do_camera_frame)		const bool do_foreground, const bool do_camera_frame)
{		{
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
int fg_flag = do_foreground ? CAM_BGIMG_FLAG_FOREGROUND : 0;		int fg_flag = do_foreground ? CAM_BGIMG_FLAG_FOREGROUND : 0;
if (v3d->camera == NULL \|\| v3d->camera->type != OB_CAMERA) {		if (v3d->camera == NULL \|\| v3d->camera->type != OB_CAMERA) {
return;		return;
}		}
Camera *cam = v3d->camera->data;		Camera *cam = v3d->camera->data;
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines	if ((bgpic->flag & CAM_BGIMG_FLAG_FOREGROUND) != fg_flag)

if (ibuf->rect == NULL)		if (ibuf->rect == NULL)
IMB_rect_from_float(ibuf);		IMB_rect_from_float(ibuf);

BLI_assert(rv3d->persp == RV3D_CAMOB);		BLI_assert(rv3d->persp == RV3D_CAMOB);
{		{
if (do_camera_frame) {		if (do_camera_frame) {
rctf vb;		rctf vb;
ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &vb, false);		ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &vb, false);
x1 = vb.xmin;		x1 = vb.xmin;
y1 = vb.ymin;		y1 = vb.ymin;
x2 = vb.xmax;		x2 = vb.xmax;
y2 = vb.ymax;		y2 = vb.ymax;
}		}
else {		else {
x1 = ar->winrct.xmin;		x1 = ar->winrct.xmin;
y1 = ar->winrct.ymin;		y1 = ar->winrct.ymin;
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines	if ((bgpic->flag & CAM_BGIMG_FLAG_FOREGROUND) != fg_flag)
if (freeibuf)		if (freeibuf)
IMB_freeImBuf(freeibuf);		IMB_freeImBuf(freeibuf);
if (releaseibuf)		if (releaseibuf)
BKE_image_release_ibuf(ima, releaseibuf, lock);		BKE_image_release_ibuf(ima, releaseibuf, lock);
}		}
}		}
}		}

void view3d_draw_bgpic_test(Scene scene, ARegion ar, View3D *v3d,		void view3d_draw_bgpic_test(Scene scene, const Depsgraph depsgraph,
		ARegion ar, View3D v3d,
const bool do_foreground, const bool do_camera_frame)		const bool do_foreground, const bool do_camera_frame)
{		{
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;

if ((rv3d->persp == RV3D_CAMOB) && v3d->camera && (v3d->camera->type == OB_CAMERA)) {		if ((rv3d->persp == RV3D_CAMOB) && v3d->camera && (v3d->camera->type == OB_CAMERA)) {
Camera *cam = v3d->camera->data;		Camera *cam = v3d->camera->data;
if ((cam->flag & CAM_SHOW_BG_IMAGE) == 0) {		if ((cam->flag & CAM_SHOW_BG_IMAGE) == 0) {
return;		return;
}		}
}		}
else {		else {
return;		return;
}		}

/* disabled - mango request, since footage /w only render is quite useful		/* disabled - mango request, since footage /w only render is quite useful
* and this option is easy to disable all background images at once */		* and this option is easy to disable all background images at once */
#if 0		#if 0
if (v3d->flag2 & V3D_RENDER_OVERRIDE)		if (v3d->flag2 & V3D_RENDER_OVERRIDE)
return;		return;
#endif		#endif

if ((rv3d->view == RV3D_VIEW_USER) \|\| (rv3d->persp != RV3D_ORTHO)) {		if ((rv3d->view == RV3D_VIEW_USER) \|\| (rv3d->persp != RV3D_ORTHO)) {
if (rv3d->persp == RV3D_CAMOB) {		if (rv3d->persp == RV3D_CAMOB) {
view3d_draw_bgpic(scene, ar, v3d, do_foreground, do_camera_frame);		view3d_draw_bgpic(scene, depsgraph, ar, v3d, do_foreground, do_camera_frame);
}		}
}		}
else {		else {
view3d_draw_bgpic(scene, ar, v3d, do_foreground, do_camera_frame);		view3d_draw_bgpic(scene, depsgraph, ar, v3d, do_foreground, do_camera_frame);
}		}
}		}

/* **************** View3d afterdraw ************* */		/* **************** View3d afterdraw ************* */

typedef struct View3DAfter {		typedef struct View3DAfter {
struct View3DAfter next, prev;		struct View3DAfter next, prev;
struct Base *base;		struct Base *base;
▲ Show 20 Lines • Show All 364 Lines • ▼ Show 20 Lines	void ED_view3d_draw_depth_gpencil(
ED_view3d_draw_setup_view(NULL, eval_ctx, scene, ar, v3d, NULL, NULL, NULL);		ED_view3d_draw_setup_view(NULL, eval_ctx, scene, ar, v3d, NULL, NULL, NULL);

glClear(GL_DEPTH_BUFFER_BIT);		glClear(GL_DEPTH_BUFFER_BIT);

v3d->zbuf = true;		v3d->zbuf = true;
glEnable(GL_DEPTH_TEST);		glEnable(GL_DEPTH_TEST);

if (v3d->flag2 & V3D_SHOW_GPENCIL) {		if (v3d->flag2 & V3D_SHOW_GPENCIL) {
ED_gpencil_draw_view3d(NULL, scene, eval_ctx->view_layer, v3d, ar, true);		ED_gpencil_draw_view3d(NULL, scene, eval_ctx->view_layer, eval_ctx->depsgraph, v3d, ar, true);
}		}

v3d->zbuf = zbuf;		v3d->zbuf = zbuf;
if (!zbuf) glDisable(GL_DEPTH_TEST);		if (!zbuf) glDisable(GL_DEPTH_TEST);
}		}

void ED_view3d_draw_depth_loop(const EvaluationContext eval_ctx, Scene scene, ARegion ar, View3D v3d)		void ED_view3d_draw_depth_loop(const EvaluationContext eval_ctx, Scene scene, ARegion ar, View3D v3d)
{		{
▲ Show 20 Lines • Show All 301 Lines • ▼ Show 20 Lines
static void view3d_draw_objects(		static void view3d_draw_objects(
const bContext *C,		const bContext *C,
const EvaluationContext *eval_ctx,		const EvaluationContext *eval_ctx,
Scene scene, View3D v3d, ARegion *ar,		Scene scene, View3D v3d, ARegion *ar,
const char **grid_unit,		const char **grid_unit,
const bool do_bgpic, const bool draw_offscreen, GPUFX *fx)		const bool do_bgpic, const bool draw_offscreen, GPUFX *fx)
{		{
ViewLayer *view_layer = C ? CTX_data_view_layer(C) : BKE_view_layer_from_scene_get(scene);		ViewLayer *view_layer = C ? CTX_data_view_layer(C) : BKE_view_layer_from_scene_get(scene);
		Depsgraph *depsgraph = CTX_data_depsgraph(C);
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
Base *base;		Base *base;
const bool do_camera_frame = !draw_offscreen;		const bool do_camera_frame = !draw_offscreen;
const bool draw_grids = !draw_offscreen && (v3d->flag2 & V3D_RENDER_OVERRIDE) == 0;		const bool draw_grids = !draw_offscreen && (v3d->flag2 & V3D_RENDER_OVERRIDE) == 0;
const bool draw_floor = (rv3d->view == RV3D_VIEW_USER) \|\| (rv3d->persp != RV3D_ORTHO);		const bool draw_floor = (rv3d->view == RV3D_VIEW_USER) \|\| (rv3d->persp != RV3D_ORTHO);
/* only draw grids after in solid modes, else it hovers over mesh wires */		/* only draw grids after in solid modes, else it hovers over mesh wires */
const bool draw_grids_after = draw_grids && draw_floor && (v3d->drawtype > OB_WIRE) && fx;		const bool draw_grids_after = draw_grids && draw_floor && (v3d->drawtype > OB_WIRE) && fx;
bool do_composite_xray = false;		bool do_composite_xray = false;
Show All 28 Lines	if (draw_grids) {
}		}
else if (!draw_grids_after) {		else if (!draw_grids_after) {
VP_legacy_drawfloor(scene, v3d, grid_unit, true);		VP_legacy_drawfloor(scene, v3d, grid_unit, true);
}		}
}		}

/* important to do before clipping */		/* important to do before clipping */
if (do_bgpic) {		if (do_bgpic) {
view3d_draw_bgpic_test(scene, ar, v3d, false, do_camera_frame);		view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, false, do_camera_frame);
}		}

if (rv3d->rflag & RV3D_CLIPPING) {		if (rv3d->rflag & RV3D_CLIPPING) {
ED_view3d_clipping_set(rv3d);		ED_view3d_clipping_set(rv3d);
}		}

/* draw set first */		/* draw set first */
if (scene->set) {		if (scene->set) {
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines	static void view3d_draw_objects(
}		}

/* must be before xray draw which clears the depth buffer */		/* must be before xray draw which clears the depth buffer */
if (v3d->flag2 & V3D_SHOW_GPENCIL) {		if (v3d->flag2 & V3D_SHOW_GPENCIL) {
wmWindowManager *wm = (C != NULL) ? CTX_wm_manager(C) : NULL;		wmWindowManager *wm = (C != NULL) ? CTX_wm_manager(C) : NULL;

/* must be before xray draw which clears the depth buffer */		/* must be before xray draw which clears the depth buffer */
if (v3d->zbuf) glDisable(GL_DEPTH_TEST);		if (v3d->zbuf) glDisable(GL_DEPTH_TEST);
ED_gpencil_draw_view3d(wm, scene, view_layer, v3d, ar, true);		ED_gpencil_draw_view3d(wm, scene, view_layer, depsgraph, v3d, ar, true);
if (v3d->zbuf) glEnable(GL_DEPTH_TEST);		if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
}		}

/* transp and X-ray afterdraw stuff */		/* transp and X-ray afterdraw stuff */
if (v3d->afterdraw_transp.first) view3d_draw_transp(eval_ctx, scene, view_layer, ar, v3d);		if (v3d->afterdraw_transp.first) view3d_draw_transp(eval_ctx, scene, view_layer, ar, v3d);

/* always do that here to cleanup depth buffers if none needed */		/* always do that here to cleanup depth buffers if none needed */
if (fx) {		if (fx) {
Show All 12 Lines	if (!draw_offscreen) {
ED_region_draw_cb_draw(C, ar, REGION_DRAW_POST_VIEW);		ED_region_draw_cb_draw(C, ar, REGION_DRAW_POST_VIEW);
}		}

if (rv3d->rflag & RV3D_CLIPPING)		if (rv3d->rflag & RV3D_CLIPPING)
ED_view3d_clipping_disable();		ED_view3d_clipping_disable();

/* important to do after clipping */		/* important to do after clipping */
if (do_bgpic) {		if (do_bgpic) {
view3d_draw_bgpic_test(scene, ar, v3d, true, do_camera_frame);		view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, true, do_camera_frame);
}		}

/* cleanup */		/* cleanup */
if (v3d->zbuf) {		if (v3d->zbuf) {
v3d->zbuf = false;		v3d->zbuf = false;
glDisable(GL_DEPTH_TEST);		glDisable(GL_DEPTH_TEST);
}		}

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

static bool view3d_main_region_do_render_draw(const Scene *scene)		static bool view3d_main_region_do_render_draw(const Scene *scene)
{		{
RenderEngineType *type = RE_engines_find(scene->view_render.engine_id);		RenderEngineType *type = RE_engines_find(scene->view_render.engine_id);
return (type && type->view_update && type->render_to_view);		return (type && type->view_update && type->render_to_view);
}		}

bool ED_view3d_calc_render_border(const Scene scene, View3D v3d, ARegion ar, rcti rect)		bool ED_view3d_calc_render_border(const Scene scene, const Depsgraph depsgraph, View3D v3d, ARegion ar, rcti *rect)
{		{
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
bool use_border;		bool use_border;

/* test if there is a 3d view rendering */		/* test if there is a 3d view rendering */
if (v3d->drawtype != OB_RENDER \|\| !view3d_main_region_do_render_draw(scene))		if (v3d->drawtype != OB_RENDER \|\| !view3d_main_region_do_render_draw(scene))
return false;		return false;

/* test if there is a border render */		/* test if there is a border render */
if (rv3d->persp == RV3D_CAMOB)		if (rv3d->persp == RV3D_CAMOB)
use_border = (scene->r.mode & R_BORDER) != 0;		use_border = (scene->r.mode & R_BORDER) != 0;
else		else
use_border = (v3d->flag2 & V3D_RENDER_BORDER) != 0;		use_border = (v3d->flag2 & V3D_RENDER_BORDER) != 0;

if (!use_border)		if (!use_border)
return false;		return false;

/* compute border */		/* compute border */
if (rv3d->persp == RV3D_CAMOB) {		if (rv3d->persp == RV3D_CAMOB) {
rctf viewborder;		rctf viewborder;
ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &viewborder, false);		ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &viewborder, false);

rect->xmin = viewborder.xmin + scene->r.border.xmin * BLI_rctf_size_x(&viewborder);		rect->xmin = viewborder.xmin + scene->r.border.xmin * BLI_rctf_size_x(&viewborder);
rect->ymin = viewborder.ymin + scene->r.border.ymin * BLI_rctf_size_y(&viewborder);		rect->ymin = viewborder.ymin + scene->r.border.ymin * BLI_rctf_size_y(&viewborder);
rect->xmax = viewborder.xmin + scene->r.border.xmax * BLI_rctf_size_x(&viewborder);		rect->xmax = viewborder.xmin + scene->r.border.xmax * BLI_rctf_size_x(&viewborder);
rect->ymax = viewborder.ymin + scene->r.border.ymax * BLI_rctf_size_y(&viewborder);		rect->ymax = viewborder.ymin + scene->r.border.ymax * BLI_rctf_size_y(&viewborder);
}		}
else {		else {
rect->xmin = v3d->render_border.xmin * ar->winx;		rect->xmin = v3d->render_border.xmin * ar->winx;
Show All 12 Lines	/**
* IMPORTANT: this is deprecated, any changes made in this function should		* IMPORTANT: this is deprecated, any changes made in this function should
* be mirrored in view3d_draw_render_draw() in view3d_draw.c		* be mirrored in view3d_draw_render_draw() in view3d_draw.c
*/		*/
static bool view3d_main_region_draw_engine(		static bool view3d_main_region_draw_engine(
const bContext C, const EvaluationContext eval_ctx, Scene *scene,		const bContext C, const EvaluationContext eval_ctx, Scene *scene,
ARegion ar, View3D v3d,		ARegion ar, View3D v3d,
bool clip_border, const rcti *border_rect)		bool clip_border, const rcti *border_rect)
{		{
		const Depsgraph *depsgraph = CTX_data_depsgraph(C);
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
RenderEngineType *type;		RenderEngineType *type;
GLint scissor[4];		GLint scissor[4];


/* create render engine */		/* create render engine */
if (!rv3d->render_engine) {		if (!rv3d->render_engine) {
RenderEngine *engine;		RenderEngine *engine;
type = RE_engines_find(scene->view_render.engine_id);		type = RE_engines_find(scene->view_render.engine_id);

if (!(type->view_update && type->render_to_view))		if (!(type->view_update && type->render_to_view))
return false;		return false;

Show All 28 Lines	static bool view3d_main_region_draw_engine(
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);

bool show_image = false;		bool show_image = false;
{		{
Camera *cam = ED_view3d_camera_data_get(v3d, rv3d);		Camera *cam = ED_view3d_camera_data_get(v3d, rv3d);
if (cam->flag & CAM_SHOW_BG_IMAGE) {		if (cam->flag & CAM_SHOW_BG_IMAGE) {
show_image = true;		show_image = true;
view3d_draw_bgpic_test(scene, ar, v3d, false, true);		view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, false, true);
}		}
else {		else {
imm_draw_box_checker_2d(0, 0, ar->winx, ar->winy);		imm_draw_box_checker_2d(0, 0, ar->winx, ar->winy);
}		}
}		}

if (show_image) {		if (show_image) {
view3d_draw_bgpic_test(scene, ar, v3d, false, true);		view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, false, true);
}		}
else {		else {
imm_draw_box_checker_2d(0, 0, ar->winx, ar->winy);		imm_draw_box_checker_2d(0, 0, ar->winx, ar->winy);
}		}

/* render result draw */		/* render result draw */
type = rv3d->render_engine->type;		type = rv3d->render_engine->type;
type->render_to_view(rv3d->render_engine, C);		type->render_to_view(rv3d->render_engine, C);

if (show_image) {		if (show_image) {
view3d_draw_bgpic_test(scene, ar, v3d, true, true);		view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, true, true);
}		}

if (clip_border) {		if (clip_border) {
/* restore scissor as it was before */		/* restore scissor as it was before */
glScissor(scissor[0], scissor[1], scissor[2], scissor[3]);		glScissor(scissor[0], scissor[1], scissor[2], scissor[3]);
}		}

return true;		return true;
▲ Show 20 Lines • Show All 125 Lines • ▼ Show 20 Lines	if ((v3d->flag2 & V3D_RENDER_OVERRIDE) == 0) {
BDR_drawSketch(C);		BDR_drawSketch(C);
}		}
}		}

static void view3d_main_region_draw_info(const bContext C, Scene scene,		static void view3d_main_region_draw_info(const bContext C, Scene scene,
ARegion ar, View3D v3d,		ARegion ar, View3D v3d,
const char *grid_unit, bool render_border)		const char *grid_unit, bool render_border)
{		{
		const Depsgraph *depsgraph = CTX_data_depsgraph(C);
ViewLayer *view_layer = CTX_data_view_layer(C);		ViewLayer *view_layer = CTX_data_view_layer(C);
wmWindowManager *wm = CTX_wm_manager(C);		wmWindowManager *wm = CTX_wm_manager(C);
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
rcti rect;		rcti rect;

/* local coordinate visible rect inside region, to accomodate overlapping ui */		/* local coordinate visible rect inside region, to accomodate overlapping ui */
ED_region_visible_rect(ar, &rect);		ED_region_visible_rect(ar, &rect);

if (rv3d->persp == RV3D_CAMOB) {		if (rv3d->persp == RV3D_CAMOB) {
VP_drawviewborder(scene, ar, v3d);		VP_drawviewborder(scene, CTX_data_depsgraph(C), ar, v3d);
}		}
else if (v3d->flag2 & V3D_RENDER_BORDER) {		else if (v3d->flag2 & V3D_RENDER_BORDER) {
VP_drawrenderborder(ar, v3d);		VP_drawrenderborder(ar, v3d);
}		}

if (v3d->flag2 & V3D_SHOW_GPENCIL) {		if (v3d->flag2 & V3D_SHOW_GPENCIL) {
/* draw grease-pencil stuff - needed to get paint-buffer shown too (since it's 2D) */		/* draw grease-pencil stuff - needed to get paint-buffer shown too (since it's 2D) */
ED_gpencil_draw_view3d(wm, scene, view_layer, v3d, ar, false);		ED_gpencil_draw_view3d(wm, scene, view_layer, depsgraph, v3d, ar, false);
}		}

if ((v3d->flag2 & V3D_RENDER_OVERRIDE) == 0) {		if ((v3d->flag2 & V3D_RENDER_OVERRIDE) == 0) {
VP_legacy_drawcursor(scene, view_layer, ar, v3d); /* 3D cursor */		VP_legacy_drawcursor(scene, view_layer, ar, v3d); /* 3D cursor */

if (U.uiflag & USER_SHOW_ROTVIEWICON)		if (U.uiflag & USER_SHOW_ROTVIEWICON)
VP_legacy_draw_view_axis(rv3d, &rect);		VP_legacy_draw_view_axis(rv3d, &rect);
else		else
Show All 30 Lines	if (grid_unit) { /* draw below the viewport name */
rect.ymax - (USER_SHOW_VIEWPORTNAME ? 2 * U.widget_unit : U.widget_unit), 0.0f,		rect.ymax - (USER_SHOW_VIEWPORTNAME ? 2 * U.widget_unit : U.widget_unit), 0.0f,
numstr[0] ? numstr : grid_unit, sizeof(numstr));		numstr[0] ? numstr : grid_unit, sizeof(numstr));
}		}
}		}
}		}

void view3d_main_region_draw_legacy(const bContext C, ARegion ar)		void view3d_main_region_draw_legacy(const bContext C, ARegion ar)
{		{
		const Depsgraph *depsgraph = CTX_data_depsgraph(C);
EvaluationContext eval_ctx;		EvaluationContext eval_ctx;
Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);		ViewLayer *view_layer = CTX_data_view_layer(C);
View3D *v3d = CTX_wm_view3d(C);		View3D *v3d = CTX_wm_view3d(C);
const char *grid_unit = NULL;		const char *grid_unit = NULL;
rcti border_rect;		rcti border_rect;

/* if we only redraw render border area, skip opengl draw and also		/* if we only redraw render border area, skip opengl draw and also
* don't do scissor because it's already set */		* don't do scissor because it's already set */
bool render_border = ED_view3d_calc_render_border(scene, v3d, ar, &border_rect);		bool render_border = ED_view3d_calc_render_border(scene, depsgraph, v3d, ar, &border_rect);
bool clip_border = (render_border && !BLI_rcti_compare(&ar->drawrct, &border_rect));		bool clip_border = (render_border && !BLI_rcti_compare(&ar->drawrct, &border_rect));

gpuPushProjectionMatrix();		gpuPushProjectionMatrix();
gpuLoadIdentityProjectionMatrix();		gpuLoadIdentityProjectionMatrix();
gpuPushMatrix();		gpuPushMatrix();
gpuLoadIdentity();		gpuLoadIdentity();

CTX_data_eval_ctx(C, &eval_ctx);		CTX_data_eval_ctx(C, &eval_ctx);
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines