Differential D2927 Diff 9587 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 205 Lines • ▼ Show 20 Lines	static void draw_view_icon(RegionView3D rv3d, rcti rect)

UI_icon_draw(5.0 + rect->xmin, 5.0 + rect->ymin, icon);		UI_icon_draw(5.0 + rect->xmin, 5.0 + rect->ymin, icon);

glDisable(GL_BLEND);		glDisable(GL_BLEND);
}		}

/* ********************* backdraw for selection ************* */		/* ********************* backdraw for selection ************* */

static void backdrawview3d(const struct EvaluationContext eval_ctx, Scene scene, SceneLayer sl, wmWindow win, ARegion ar, View3D v3d)		static void backdrawview3d(const struct EvaluationContext eval_ctx, Scene scene, ViewLayer sl, wmWindow win, ARegion ar, View3D v3d)
{		{
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
struct Base *base = sl->basact;		struct Base *base = sl->basact;
int multisample_enabled;		int multisample_enabled;

BLI_assert(ar->regiontype == RGN_TYPE_WINDOW);		BLI_assert(ar->regiontype == RGN_TYPE_WINDOW);

if (base && (base->object->mode & (OB_MODE_VERTEX_PAINT \| OB_MODE_WEIGHT_PAINT) \|\|		if (base && (base->object->mode & (OB_MODE_VERTEX_PAINT \| OB_MODE_WEIGHT_PAINT) \|\|
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
static void view3d_opengl_read_Z_pixels(ARegion ar, int x, int y, int w, int h, int format, int type, void data)		static void view3d_opengl_read_Z_pixels(ARegion ar, int x, int y, int w, int h, int format, int type, void data)
{		{
glReadPixels(ar->winrct.xmin + x, ar->winrct.ymin + y, w, h, format, type, data);		glReadPixels(ar->winrct.xmin + x, ar->winrct.ymin + y, w, h, format, type, data);
}		}

void ED_view3d_backbuf_validate(const struct EvaluationContext eval_ctx, ViewContext vc)		void ED_view3d_backbuf_validate(const struct EvaluationContext eval_ctx, ViewContext vc)
{		{
if (vc->v3d->flag & V3D_INVALID_BACKBUF) {		if (vc->v3d->flag & V3D_INVALID_BACKBUF) {
backdrawview3d(eval_ctx, vc->scene, vc->scene_layer, vc->win, vc->ar, vc->v3d);		backdrawview3d(eval_ctx, vc->scene, vc->view_layer, vc->win, vc->ar, vc->v3d);
}		}
}		}

/**		/**
* allow for small values [0.5 - 2.5],		* allow for small values [0.5 - 2.5],
* and large values, FLT_MAX by clamping by the area size		* and large values, FLT_MAX by clamping by the area size
*/		*/
int ED_view3d_backbuf_sample_size_clamp(ARegion *ar, const float dist)		int ED_view3d_backbuf_sample_size_clamp(ARegion *ar, const float dist)
▲ Show 20 Lines • Show All 452 Lines • ▼ Show 20 Lines	void ED_view3d_after_add(ListBase lb, Base base, const short dflag)
BLI_assert((base->flag_legacy & OB_FROMDUPLI) == 0);		BLI_assert((base->flag_legacy & OB_FROMDUPLI) == 0);
BLI_addtail(lb, v3da);		BLI_addtail(lb, v3da);
v3da->base = base;		v3da->base = base;
v3da->dflag = dflag;		v3da->dflag = dflag;
}		}

/* disables write in zbuffer and draws it over */		/* disables write in zbuffer and draws it over */
static void view3d_draw_transp(		static void view3d_draw_transp(
const EvaluationContext eval_ctx, Scene scene, SceneLayer sl, ARegion ar, View3D *v3d)		const EvaluationContext eval_ctx, Scene scene, ViewLayer sl, ARegion ar, View3D *v3d)
{		{
View3DAfter *v3da;		View3DAfter *v3da;

glDepthMask(GL_FALSE);		glDepthMask(GL_FALSE);
v3d->transp = true;		v3d->transp = true;

while ((v3da = BLI_pophead(&v3d->afterdraw_transp))) {		while ((v3da = BLI_pophead(&v3d->afterdraw_transp))) {
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);		draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);
MEM_freeN(v3da);		MEM_freeN(v3da);
}		}
v3d->transp = false;		v3d->transp = false;

glDepthMask(GL_TRUE);		glDepthMask(GL_TRUE);

}		}

/* clears zbuffer and draws it over */		/* clears zbuffer and draws it over */
static void view3d_draw_xray(		static void view3d_draw_xray(
const EvaluationContext eval_ctx, Scene scene, SceneLayer sl, ARegion ar, View3D v3d, bool clear)		const EvaluationContext eval_ctx, Scene scene, ViewLayer sl, ARegion ar, View3D v3d, bool clear)
{		{
if (*clear && v3d->zbuf) {		if (*clear && v3d->zbuf) {
glClear(GL_DEPTH_BUFFER_BIT);		glClear(GL_DEPTH_BUFFER_BIT);
*clear = false;		*clear = false;
}		}

v3d->xray = true;		v3d->xray = true;
View3DAfter *v3da;		View3DAfter *v3da;
while ((v3da = BLI_pophead(&v3d->afterdraw_xray))) {		while ((v3da = BLI_pophead(&v3d->afterdraw_xray))) {
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);		draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);
MEM_freeN(v3da);		MEM_freeN(v3da);
}		}
v3d->xray = false;		v3d->xray = false;
}		}


/* clears zbuffer and draws it over */		/* clears zbuffer and draws it over */
static void view3d_draw_xraytransp(		static void view3d_draw_xraytransp(
const EvaluationContext eval_ctx, Scene scene, SceneLayer sl, ARegion ar, View3D *v3d, const bool clear)		const EvaluationContext eval_ctx, Scene scene, ViewLayer sl, ARegion ar, View3D *v3d, const bool clear)
{		{
if (clear && v3d->zbuf)		if (clear && v3d->zbuf)
glClear(GL_DEPTH_BUFFER_BIT);		glClear(GL_DEPTH_BUFFER_BIT);

v3d->xray = true;		v3d->xray = true;
v3d->transp = true;		v3d->transp = true;

glDepthMask(GL_FALSE);		glDepthMask(GL_FALSE);

View3DAfter *v3da;		View3DAfter *v3da;
while ((v3da = BLI_pophead(&v3d->afterdraw_xraytransp))) {		while ((v3da = BLI_pophead(&v3d->afterdraw_xraytransp))) {
draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);		draw_object(eval_ctx, scene, sl, ar, v3d, v3da->base, v3da->dflag);
MEM_freeN(v3da);		MEM_freeN(v3da);
}		}

v3d->transp = false;		v3d->transp = false;
v3d->xray = false;		v3d->xray = false;

glDepthMask(GL_TRUE);		glDepthMask(GL_TRUE);
}		}

/* clears zbuffer and draws it over,		/* clears zbuffer and draws it over,
* note that in the select version we don't care about transparent flag as with regular drawing */		* note that in the select version we don't care about transparent flag as with regular drawing */
static void view3d_draw_xray_select(		static void view3d_draw_xray_select(
const struct EvaluationContext eval_ctx, Scene scene, SceneLayer sl, ARegion ar, View3D v3d, bool clear)		const struct EvaluationContext eval_ctx, Scene scene, ViewLayer sl, ARegion ar, View3D v3d, bool clear)
{		{
/* Not ideal, but we need to read from the previous depths before clearing		/* Not ideal, but we need to read from the previous depths before clearing
* otherwise we could have a function to load the depths after drawing.		* otherwise we could have a function to load the depths after drawing.
*		*
* Clearing the depth buffer isn't all that common between drawing objects so accept this for now.		* Clearing the depth buffer isn't all that common between drawing objects so accept this for now.
*/		*/
if (U.gpu_select_pick_deph) {		if (U.gpu_select_pick_deph) {
GPU_select_load_id(-1);		GPU_select_load_id(-1);
Show All 39 Lines
static DupliObject dupli_step(DupliObject dob)		static DupliObject dupli_step(DupliObject dob)
{		{
while (dob && dob->no_draw)		while (dob && dob->no_draw)
dob = dob->next;		dob = dob->next;
return dob;		return dob;
}		}

static void draw_dupli_objects_color(		static void draw_dupli_objects_color(
const EvaluationContext eval_ctx, Scene scene, SceneLayer sl, ARegion ar, View3D v3d, Base base,		const EvaluationContext eval_ctx, Scene scene, ViewLayer sl, ARegion ar, View3D v3d, Base base,
const short dflag, const int color)		const short dflag, const int color)
{		{
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
ListBase *lb;		ListBase *lb;
LodLevel *savedlod;		LodLevel *savedlod;
Base tbase = {NULL};		Base tbase = {NULL};
BoundBox bb, bb_tmp; / use a copy because draw_object, calls clear_mesh_caches */		BoundBox bb, bb_tmp; / use a copy because draw_object, calls clear_mesh_caches */
unsigned char color_rgb[3];		unsigned char color_rgb[3];
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines	#endif
if (apply_data) {		if (apply_data) {
duplilist_restore(lb, apply_data);		duplilist_restore(lb, apply_data);
duplilist_free_apply_data(apply_data);		duplilist_free_apply_data(apply_data);
}		}

free_object_duplilist(lb);		free_object_duplilist(lb);
}		}

void draw_dupli_objects(const EvaluationContext eval_ctx, Scene scene, SceneLayer sl, ARegion ar, View3D v3d, Base base)		void draw_dupli_objects(const EvaluationContext eval_ctx, Scene scene, ViewLayer sl, ARegion ar, View3D v3d, Base base)
{		{
/* define the color here so draw_dupli_objects_color can be called		/* define the color here so draw_dupli_objects_color can be called
* from the set loop */		* from the set loop */

int color = (base->flag & BASE_SELECTED) ? TH_SELECT : TH_WIRE;		int color = (base->flag & BASE_SELECTED) ? TH_SELECT : TH_WIRE;
/* debug */		/* debug */
if (base->object->dup_group && base->object->dup_group->id.us < 1)		if (base->object->dup_group && base->object->dup_group->id.us < 1)
color = TH_REDALERT;		color = TH_REDALERT;
▲ Show 20 Lines • Show All 120 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->scene_layer, v3d, ar, true);		ED_gpencil_draw_view3d(NULL, scene, eval_ctx->view_layer, 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)
{		{
Base *base;		Base *base;
SceneLayer *sl = eval_ctx->scene_layer;		ViewLayer *sl = eval_ctx->view_layer;
/* no need for color when drawing depth buffer */		/* no need for color when drawing depth buffer */
const short dflag_depth = DRAW_CONSTCOLOR;		const short dflag_depth = DRAW_CONSTCOLOR;

/* draw set first */		/* draw set first */
if (scene->set) {		if (scene->set) {
Scene *sce_iter;		Scene *sce_iter;
for (SETLOOPER(scene->set, sce_iter, base)) {		for (SETLOOPER(scene->set, sce_iter, base)) {
if ((base->flag & BASE_VISIBLED) != 0) {		if ((base->flag & BASE_VISIBLED) != 0) {
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines	if (v3d->afterdraw_transp.first \|\|
v3d->xray = false;		v3d->xray = false;
v3d->transp = false;		v3d->transp = false;

glDepthMask(mask_orig);		glDepthMask(mask_orig);
}		}
}		}

void ED_view3d_draw_select_loop(		void ED_view3d_draw_select_loop(
const struct EvaluationContext eval_ctx, ViewContext vc, Scene scene, SceneLayer sl,		const struct EvaluationContext eval_ctx, ViewContext vc, Scene scene, ViewLayer sl,
View3D v3d, ARegion ar, bool use_obedit_skip, bool use_nearest)		View3D v3d, ARegion ar, bool use_obedit_skip, bool use_nearest)
{		{
struct bThemeState theme_state;		struct bThemeState theme_state;

short code = 1;		short code = 1;
const short dflag = DRAW_PICKING \| DRAW_CONSTCOLOR;		const short dflag = DRAW_PICKING \| DRAW_CONSTCOLOR;

/* Tools may request depth outside of regular drawing code. */		/* Tools may request depth outside of regular drawing code. */
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines	for (View3DShadow *shadow = shadows.first; shadow; shadow = shadow->next) {
copy_m4_m4(rv3d.winmat, winmat);		copy_m4_m4(rv3d.winmat, winmat);
copy_m4_m4(rv3d.viewmat, viewmat);		copy_m4_m4(rv3d.viewmat, viewmat);
invert_m4_m4(rv3d.viewinv, rv3d.viewmat);		invert_m4_m4(rv3d.viewinv, rv3d.viewmat);
mul_m4_m4m4(rv3d.persmat, rv3d.winmat, rv3d.viewmat);		mul_m4_m4m4(rv3d.persmat, rv3d.winmat, rv3d.viewmat);
invert_m4_m4(rv3d.persinv, rv3d.viewinv);		invert_m4_m4(rv3d.persinv, rv3d.viewinv);

/* no need to call ED_view3d_draw_offscreen_init since shadow buffers were already updated */		/* no need to call ED_view3d_draw_offscreen_init since shadow buffers were already updated */
ED_view3d_draw_offscreen(		ED_view3d_draw_offscreen(
eval_ctx, scene, eval_ctx->scene_layer, v3d, &ar, winsize, winsize, viewmat, winmat,		eval_ctx, scene, eval_ctx->view_layer, v3d, &ar, winsize, winsize, viewmat, winmat,
false, false, true,		false, false, true,
NULL, NULL, NULL, NULL);		NULL, NULL, NULL, NULL);
GPU_lamp_shadow_buffer_unbind(shadow->lamp);		GPU_lamp_shadow_buffer_unbind(shadow->lamp);

v3d->drawtype = drawtype;		v3d->drawtype = drawtype;
v3d->lay = lay;		v3d->lay = lay;
v3d->flag2 = flag2;		v3d->flag2 = flag2;
}		}
▲ Show 20 Lines • Show All 61 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)
{		{
SceneLayer *scene_layer = C ? CTX_data_scene_layer(C) : BKE_scene_layer_from_scene_get(scene);		ViewLayer *view_layer = C ? CTX_data_view_layer(C) : BKE_view_layer_from_scene_get(scene);
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 20 Lines • Show All 42 Lines • ▼ Show 20 Lines	static void view3d_draw_objects(

/* draw set first */		/* draw set first */
if (scene->set) {		if (scene->set) {
const short dflag = DRAW_CONSTCOLOR \| DRAW_SCENESET;		const short dflag = DRAW_CONSTCOLOR \| DRAW_SCENESET;
Scene *sce_iter;		Scene *sce_iter;
for (SETLOOPER(scene->set, sce_iter, base)) {		for (SETLOOPER(scene->set, sce_iter, base)) {
if ((base->flag & BASE_VISIBLED) != 0) {		if ((base->flag & BASE_VISIBLED) != 0) {
UI_ThemeColorBlend(TH_WIRE, TH_BACK, 0.6f);		UI_ThemeColorBlend(TH_WIRE, TH_BACK, 0.6f);
draw_object(eval_ctx, scene, scene_layer, ar, v3d, base, dflag);		draw_object(eval_ctx, scene, view_layer, ar, v3d, base, dflag);

if (base->object->transflag & OB_DUPLI) {		if (base->object->transflag & OB_DUPLI) {
draw_dupli_objects_color(eval_ctx, scene, scene_layer, ar, v3d, base, dflag, TH_UNDEFINED);		draw_dupli_objects_color(eval_ctx, scene, view_layer, ar, v3d, base, dflag, TH_UNDEFINED);
}		}
}		}
}		}

/* Transp and X-ray afterdraw stuff for sets is done later */		/* Transp and X-ray afterdraw stuff for sets is done later */
}		}

if (draw_offscreen) {		if (draw_offscreen) {
for (base = scene_layer->object_bases.first; base; base = base->next) {		for (base = view_layer->object_bases.first; base; base = base->next) {
if ((base->flag & BASE_VISIBLED) != 0) {		if ((base->flag & BASE_VISIBLED) != 0) {
/* dupli drawing */		/* dupli drawing */
if (base->object->transflag & OB_DUPLI) {		if (base->object->transflag & OB_DUPLI) {
draw_dupli_objects(eval_ctx, scene, scene_layer, ar, v3d, base);		draw_dupli_objects(eval_ctx, scene, view_layer, ar, v3d, base);
}		}

draw_object(eval_ctx, scene, scene_layer, ar, v3d, base, 0);		draw_object(eval_ctx, scene, view_layer, ar, v3d, base, 0);
}		}
}		}
}		}
else {		else {
unsigned int lay_used = 0;		unsigned int lay_used = 0;

/* then draw not selected and the duplis, but skip editmode object */		/* then draw not selected and the duplis, but skip editmode object */
for (base = scene_layer->object_bases.first; base; base = base->next) {		for (base = view_layer->object_bases.first; base; base = base->next) {
lay_used \|= base->lay;		lay_used \|= base->lay;

if ((base->flag & BASE_VISIBLED) != 0) {		if ((base->flag & BASE_VISIBLED) != 0) {

/* dupli drawing */		/* dupli drawing */
if (base->object->transflag & OB_DUPLI) {		if (base->object->transflag & OB_DUPLI) {
draw_dupli_objects(eval_ctx, scene, scene_layer, ar, v3d, base);		draw_dupli_objects(eval_ctx, scene, view_layer, ar, v3d, base);
}		}
if ((base->flag & BASE_SELECTED) == 0) {		if ((base->flag & BASE_SELECTED) == 0) {
if (base->object != scene->obedit)		if (base->object != scene->obedit)
draw_object(eval_ctx, scene, scene_layer, ar, v3d, base, 0);		draw_object(eval_ctx, scene, view_layer, ar, v3d, base, 0);
}		}
}		}
}		}

/* mask out localview */		/* mask out localview */
v3d->lay_used = lay_used & ((1 << 20) - 1);		v3d->lay_used = lay_used & ((1 << 20) - 1);

/* draw selected and editmode */		/* draw selected and editmode */
for (base = scene_layer->object_bases.first; base; base = base->next) {		for (base = view_layer->object_bases.first; base; base = base->next) {
if ((base->flag & BASE_VISIBLED) != 0) {		if ((base->flag & BASE_VISIBLED) != 0) {
if (base->object == scene->obedit \|\| (base->flag & BASE_SELECTED)) {		if (base->object == scene->obedit \|\| (base->flag & BASE_SELECTED)) {
draw_object(eval_ctx, scene, scene_layer, ar, v3d, base, 0);		draw_object(eval_ctx, scene, view_layer, ar, v3d, base, 0);
}		}
}		}
}		}
}		}

/* perspective floor goes last to use scene depth and avoid writing to depth buffer */		/* perspective floor goes last to use scene depth and avoid writing to depth buffer */
if (draw_grids_after) {		if (draw_grids_after) {
VP_legacy_drawfloor(scene, v3d, grid_unit, false);		VP_legacy_drawfloor(scene, v3d, grid_unit, false);
}		}

/* 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, scene_layer, v3d, ar, true);		ED_gpencil_draw_view3d(wm, scene, view_layer, 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, scene_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) {
do_composite_xray = v3d->zbuf && (v3d->afterdraw_xray.first \|\| v3d->afterdraw_xraytransp.first);		do_composite_xray = v3d->zbuf && (v3d->afterdraw_xray.first \|\| v3d->afterdraw_xraytransp.first);
GPU_fx_compositor_setup_XRay_pass(fx, do_composite_xray);		GPU_fx_compositor_setup_XRay_pass(fx, do_composite_xray);
}		}

if (v3d->afterdraw_xray.first) view3d_draw_xray(eval_ctx, scene, scene_layer, ar, v3d, &xrayclear);		if (v3d->afterdraw_xray.first) view3d_draw_xray(eval_ctx, scene, view_layer, ar, v3d, &xrayclear);
if (v3d->afterdraw_xraytransp.first) view3d_draw_xraytransp(eval_ctx, scene, scene_layer, ar, v3d, xrayclear);		if (v3d->afterdraw_xraytransp.first) view3d_draw_xraytransp(eval_ctx, scene, view_layer, ar, v3d, xrayclear);

if (fx && do_composite_xray) {		if (fx && do_composite_xray) {
GPU_fx_compositor_XRay_resolve(fx);		GPU_fx_compositor_XRay_resolve(fx);
}		}

if (!draw_offscreen) {		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);
}		}
▲ Show 20 Lines • Show All 286 Lines • ▼ Show 20 Lines	static void update_lods(Scene *scene, float camera_pos[3])

for (SETLOOPER(scene, sce_iter, base)) {		for (SETLOOPER(scene, sce_iter, base)) {
Object *ob = base->object;		Object *ob = base->object;
BKE_object_lod_update(ob, camera_pos);		BKE_object_lod_update(ob, camera_pos);
}		}
}		}
#endif		#endif

static void view3d_main_region_draw_objects(const bContext C, Scene scene, SceneLayer sl, View3D v3d,		static void view3d_main_region_draw_objects(const bContext C, Scene scene, ViewLayer sl, View3D v3d,
ARegion ar, const char *grid_unit)		ARegion ar, const char *grid_unit)
{		{
wmWindow *win = CTX_wm_window(C);		wmWindow *win = CTX_wm_window(C);
EvaluationContext eval_ctx;		EvaluationContext eval_ctx;
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;
unsigned int lay_used = v3d->lay_used;		unsigned int lay_used = v3d->lay_used;

CTX_data_eval_ctx(C, &eval_ctx);		CTX_data_eval_ctx(C, &eval_ctx);
▲ Show 20 Lines • Show All 79 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)
{		{
SceneLayer *scene_layer = CTX_data_scene_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, 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, scene_layer, v3d, ar, false);		ED_gpencil_draw_view3d(wm, scene, view_layer, v3d, ar, false);
}		}

if ((v3d->flag2 & V3D_RENDER_OVERRIDE) == 0) {		if ((v3d->flag2 & V3D_RENDER_OVERRIDE) == 0) {
VP_legacy_drawcursor(scene, scene_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
draw_view_icon(rv3d, &rect);		draw_view_icon(rv3d, &rect);

if (U.uiflag & USER_DRAWVIEWINFO) {		if (U.uiflag & USER_DRAWVIEWINFO) {
Object *ob = OBACT(scene_layer);		Object *ob = OBACT(view_layer);
VP_legacy_draw_selected_name(scene, ob, &rect);		VP_legacy_draw_selected_name(scene, ob, &rect);
}		}
}		}

if (rv3d->render_engine) {		if (rv3d->render_engine) {
view3d_main_region_draw_engine_info(v3d, rv3d, ar, render_border);		view3d_main_region_draw_engine_info(v3d, rv3d, ar, render_border);
return;		return;
}		}
Show All 20 Lines	if ((v3d->flag2 & V3D_RENDER_OVERRIDE) == 0) {
}		}
}		}
}		}

void view3d_main_region_draw_legacy(const bContext C, ARegion ar)		void view3d_main_region_draw_legacy(const bContext C, ARegion ar)
{		{
EvaluationContext eval_ctx;		EvaluationContext eval_ctx;
Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);
SceneLayer *sl = CTX_data_scene_layer(C);		ViewLayer *sl = 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, 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));
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines