Pass EvaluationContext instead of bContext

2.8x branch added bContext arg in many places,
pass eval-context instead since its not simple to reason about what
what nested functions do when they can access and change almost anything.

Also use const to prevent unexpected modifications.

This fixes crash loading files with shadows,
since off-screen buffers use a NULL context for rendering.

6 files changed, 114 insertions, 87 deletions

diff --git a/source/blender/editors/mesh/editface.c b/source/blender/editors/mesh/editface.c
index 8aa3b63f795..94fe433e5d7 100644
--- a/source/blender/editors/mesh/editface.c
+++ b/source/blender/editors/mesh/editface.c
@@ -396,7 +396,7 @@ bool paintface_mouse_select(struct bContext *C, Object *ob, const int mval[2], b
 	return true;
 }
 
-int do_paintface_box_select(const bContext *C, ViewContext *vc, rcti *rect, bool select, bool extend)
+int do_paintface_box_select(const struct EvaluationContext *eval_ctx, ViewContext *vc, rcti *rect, bool select, bool extend)
 {
 	Object *ob = vc->obact;
 	Mesh *me;
@@ -427,7 +427,7 @@ int do_paintface_box_select(const bContext *C, ViewContext *vc, rcti *rect, bool
 		}
 	}
 
-	ED_view3d_backbuf_validate(C, vc);
+	ED_view3d_backbuf_validate(eval_ctx, vc);
 
 	ibuf = IMB_allocImBuf(size[0], size[1], 32, IB_rect);
 	rt = ibuf->rect;
diff --git a/source/blender/editors/mesh/editmesh_knife.c b/source/blender/editors/mesh/editmesh_knife.c
index 37d86ee313f..5aa10620936 100644
--- a/source/blender/editors/mesh/editmesh_knife.c
+++ b/source/blender/editors/mesh/editmesh_knife.c
@@ -161,6 +161,7 @@ typedef struct KnifePosData {
 typedef struct KnifeTool_OpData {
 	ARegion *ar;        /* region that knifetool was activated in */
 	void *draw_handle;  /* for drawing preview loop */
+	EvaluationContext eval_ctx;
 	ViewContext vc;     /* note: _don't_ use 'mval', instead use the one we define below */
 	float mval[2];      /* mouse value with snapping applied */
 	//bContext *C;
@@ -1814,7 +1815,7 @@ static void knife_input_ray_segment(KnifeTool_OpData *kcd, const float mval[2],
 	mul_m4_v3(kcd->ob->imat, r_origin_ofs);
 }
 
-static BMFace *knife_find_closest_face(const bContext *C, KnifeTool_OpData *kcd, float co[3], float cageco[3], bool *is_space)
+static BMFace *knife_find_closest_face(KnifeTool_OpData *kcd, float co[3], float cageco[3], bool *is_space)
 {
 	BMFace *f;
 	float dist = KMAXDIST;
@@ -1839,7 +1840,7 @@ static BMFace *knife_find_closest_face(const bContext *C, KnifeTool_OpData *kcd,
 	if (!f) {
 		if (kcd->is_interactive) {
 			/* try to use backbuffer selection method if ray casting failed */
-			f = EDBM_face_find_nearest(C, &kcd->vc, &dist);
+			f = EDBM_face_find_nearest(&kcd->eval_ctx, &kcd->vc, &dist);
 
 			/* cheat for now; just put in the origin instead
 			 * of a true coordinate on the face.
@@ -1853,7 +1854,7 @@ static BMFace *knife_find_closest_face(const bContext *C, KnifeTool_OpData *kcd,
 
 /* find the 2d screen space density of vertices within a radius.  used to scale snapping
  * distance for picking edges/verts.*/
-static int knife_sample_screen_density(const bContext *C, KnifeTool_OpData *kcd, const float radius)
+static int knife_sample_screen_density(KnifeTool_OpData *kcd, const float radius)
 {
 	BMFace *f;
 	bool is_space;
@@ -1861,7 +1862,7 @@ static int knife_sample_screen_density(const bContext *C, KnifeTool_OpData *kcd,
 
 	BLI_assert(kcd->is_interactive == true);
 
-	f = knife_find_closest_face(C, kcd, co, cageco, &is_space);
+	f = knife_find_closest_face(kcd, co, cageco, &is_space);
 
 	if (f && !is_space) {
 		const float radius_sq = radius * radius;
@@ -1904,15 +1905,15 @@ static int knife_sample_screen_density(const bContext *C, KnifeTool_OpData *kcd,
 
 /* returns snapping distance for edges/verts, scaled by the density of the
  * surrounding mesh (in screen space)*/
-static float knife_snap_size(const bContext *C, KnifeTool_OpData *kcd, float maxsize)
+static float knife_snap_size(KnifeTool_OpData *kcd, float maxsize)
 {
-	float density = (float)knife_sample_screen_density(C, kcd, maxsize * 2.0f);
+	float density = (float)knife_sample_screen_density(kcd, maxsize * 2.0f);
 
 	return min_ff(maxsize / (density * 0.5f), maxsize);
 }
 
 /* p is closest point on edge to the mouse cursor */
-static KnifeEdge *knife_find_closest_edge(const bContext *C, KnifeTool_OpData *kcd, float p[3], float cagep[3],
+static KnifeEdge *knife_find_closest_edge(KnifeTool_OpData *kcd, float p[3], float cagep[3],
                                           BMFace **fptr, bool *is_space)
 {
 	BMFace *f;
@@ -1920,7 +1921,7 @@ static KnifeEdge *knife_find_closest_edge(const bContext *C, KnifeTool_OpData *k
 	float maxdist;
 
 	if (kcd->is_interactive) {
-		maxdist = knife_snap_size(C, kcd, kcd->ethresh);
+		maxdist = knife_snap_size(kcd, kcd->ethresh);
 
 		if (kcd->ignore_vert_snapping) {
 			maxdist *= 0.5f;
@@ -1930,7 +1931,7 @@ static KnifeEdge *knife_find_closest_edge(const bContext *C, KnifeTool_OpData *k
 		maxdist = KNIFE_FLT_EPS;
 	}
 
-	f = knife_find_closest_face(C, kcd, co, cageco, NULL);
+	f = knife_find_closest_face(kcd, co, cageco, NULL);
 	*is_space = !f;
 
 	kcd->curr.bmface = f;
@@ -2044,7 +2045,7 @@ static KnifeEdge *knife_find_closest_edge(const bContext *C, KnifeTool_OpData *k
 }
 
 /* find a vertex near the mouse cursor, if it exists */
-static KnifeVert *knife_find_closest_vert(const bContext *C, KnifeTool_OpData *kcd, float p[3], float cagep[3], BMFace **fptr,
+static KnifeVert *knife_find_closest_vert(KnifeTool_OpData *kcd, float p[3], float cagep[3], BMFace **fptr,
                                           bool *is_space)
 {
 	BMFace *f;
@@ -2052,7 +2053,7 @@ static KnifeVert *knife_find_closest_vert(const bContext *C, KnifeTool_OpData *k
 	float maxdist;
 
 	if (kcd->is_interactive) {
-		maxdist = knife_snap_size(C, kcd, kcd->vthresh);
+		maxdist = knife_snap_size(kcd, kcd->vthresh);
 		if (kcd->ignore_vert_snapping) {
 			maxdist *= 0.5f;
 		}
@@ -2061,7 +2062,7 @@ static KnifeVert *knife_find_closest_vert(const bContext *C, KnifeTool_OpData *k
 		maxdist = KNIFE_FLT_EPS;
 	}
 
-	f = knife_find_closest_face(C, kcd, co, cageco, is_space);
+	f = knife_find_closest_face(kcd, co, cageco, is_space);
 
 	kcd->curr.bmface = f;
 
@@ -2183,7 +2184,7 @@ static bool knife_snap_angle(KnifeTool_OpData *kcd)
 }
 
 /* update active knife edge/vert pointers */
-static int knife_update_active(const bContext *C, KnifeTool_OpData *kcd)
+static int knife_update_active(KnifeTool_OpData *kcd)
 {
 	knife_pos_data_clear(&kcd->curr);
 	copy_v2_v2(kcd->curr.mval, kcd->mval);
@@ -2198,13 +2199,13 @@ static int knife_update_active(const bContext *C, KnifeTool_OpData *kcd)
 		kcd->is_angle_snapping = false;
 	}
 
-	kcd->curr.vert = knife_find_closest_vert(C, kcd, kcd->curr.co, kcd->curr.cage, &kcd->curr.bmface, &kcd->curr.is_space);
+	kcd->curr.vert = knife_find_closest_vert(kcd, kcd->curr.co, kcd->curr.cage, &kcd->curr.bmface, &kcd->curr.is_space);
 
 	if (!kcd->curr.vert &&
 	    /* no edge snapping while dragging (edges are too sticky when cuts are immediate) */
 	    !kcd->is_drag_hold)
 	{
-		kcd->curr.edge = knife_find_closest_edge(C, kcd, kcd->curr.co, kcd->curr.cage,
+		kcd->curr.edge = knife_find_closest_edge(kcd, kcd->curr.co, kcd->curr.cage,
 		                                         &kcd->curr.bmface, &kcd->curr.is_space);
 	}
 
@@ -2571,30 +2572,27 @@ static void knifetool_exit(bContext *C, wmOperator *op)
 	op->customdata = NULL;
 }
 
-static void knifetool_update_mval(const bContext *C, KnifeTool_OpData *kcd, const float mval[2])
+static void knifetool_update_mval(KnifeTool_OpData *kcd, const float mval[2])
 {
 	knife_recalc_projmat(kcd);
 	copy_v2_v2(kcd->mval, mval);
 
-	if (knife_update_active(C, kcd)) {
+	if (knife_update_active(kcd)) {
 		ED_region_tag_redraw(kcd->ar);
 	}
 }
 
-static void knifetool_update_mval_i(const bContext *C, KnifeTool_OpData *kcd, const int mval_i[2])
+static void knifetool_update_mval_i(KnifeTool_OpData *kcd, const int mval_i[2])
 {
 	float mval[2] = {UNPACK2(mval_i)};
-	knifetool_update_mval(C, kcd, mval);
+	knifetool_update_mval(kcd, mval);
 }
 
-static void knifetool_init_bmbvh(const bContext *C, KnifeTool_OpData *kcd)
+static void knifetool_init_bmbvh(KnifeTool_OpData *kcd)
 {
-	EvaluationContext eval_ctx;
 	BM_mesh_elem_index_ensure(kcd->em->bm, BM_VERT);
 
-	CTX_data_eval_ctx(C, &eval_ctx);
-
-	kcd->cagecos = (const float (*)[3])BKE_editmesh_vertexCos_get(&eval_ctx, kcd->em, kcd->scene, NULL);
+	kcd->cagecos = (const float (*)[3])BKE_editmesh_vertexCos_get(&kcd->eval_ctx, kcd->em, kcd->scene, NULL);
 
 	kcd->bmbvh = BKE_bmbvh_new_from_editmesh(
 	        kcd->em,
@@ -2628,6 +2626,7 @@ static void knifetool_init(bContext *C, KnifeTool_OpData *kcd,
 	kcd->ob = obedit;
 	kcd->ar = CTX_wm_region(C);
 
+	CTX_data_eval_ctx(C, &kcd->eval_ctx);
 	em_setup_viewcontext(C, &kcd->vc);
 
 	kcd->em = BKE_editmesh_from_object(kcd->ob);
@@ -2637,7 +2636,7 @@ static void knifetool_init(bContext *C, KnifeTool_OpData *kcd,
 	kcd->cut_through = cut_through;
 	kcd->only_select = only_select;
 
-	knifetool_init_bmbvh(C, kcd);
+	knifetool_init_bmbvh(kcd);
 
 	kcd->arena = BLI_memarena_new(MEM_SIZE_OPTIMAL(1 << 15), "knife");
 #ifdef USE_NET_ISLAND_CONNECT
@@ -2709,7 +2708,7 @@ static int knifetool_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 	WM_cursor_modal_set(CTX_wm_window(C), BC_KNIFECURSOR);
 	WM_event_add_modal_handler(C, op);
 
-	knifetool_update_mval_i(C, kcd, event->mval);
+	knifetool_update_mval_i(kcd, event->mval);
 
 	knife_update_header(C, op, kcd);
 
@@ -2782,6 +2781,7 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 		return OPERATOR_FINISHED;
 	}
 
+	CTX_data_eval_ctx(C, &kcd->eval_ctx);
 	em_setup_viewcontext(C, &kcd->vc);
 	kcd->ar = kcd->vc.ar;
 
@@ -2815,7 +2815,7 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 				kcd->snap_midpoints = true;
 
 				knife_recalc_projmat(kcd);
-				knife_update_active(C, kcd);
+				knife_update_active(kcd);
 				knife_update_header(C, op, kcd);
 				ED_region_tag_redraw(kcd->ar);
 				do_refresh = true;
@@ -2824,7 +2824,7 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 				kcd->snap_midpoints = false;
 
 				knife_recalc_projmat(kcd);
-				knife_update_active(C, kcd);
+				knife_update_active(kcd);
 				knife_update_header(C, op, kcd);
 				ED_region_tag_redraw(kcd->ar);
 				do_refresh = true;
@@ -2879,7 +2879,7 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 					kcd->is_drag_hold = false;
 
 					/* needed because the last face 'hit' is ignored when dragging */
-					knifetool_update_mval(C, kcd, kcd->curr.mval);
+					knifetool_update_mval(kcd, kcd->curr.mval);
 				}
 
 				ED_region_tag_redraw(kcd->ar);
@@ -2890,14 +2890,14 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 					/* shouldn't be possible with default key-layout, just incase... */
 					if (kcd->is_drag_hold) {
 						kcd->is_drag_hold = false;
-						knifetool_update_mval(C, kcd, kcd->curr.mval);
+						knifetool_update_mval(kcd, kcd->curr.mval);
 					}
 
 					kcd->prev = kcd->curr;
 					kcd->curr = kcd->init;
 
 					knife_project_v2(kcd, kcd->curr.cage, kcd->curr.mval);
-					knifetool_update_mval(C, kcd, kcd->curr.mval);
+					knifetool_update_mval(kcd, kcd->curr.mval);
 
 					knife_add_cut(kcd);
 
@@ -2931,7 +2931,7 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 				return OPERATOR_PASS_THROUGH;
 			case MOUSEMOVE: /* mouse moved somewhere to select another loop */
 				if (kcd->mode != MODE_PANNING) {
-					knifetool_update_mval_i(C, kcd, event->mval);
+					knifetool_update_mval_i(kcd, event->mval);
 
 					if (kcd->is_drag_hold) {
 						if (kcd->totlinehit >= 2) {
@@ -2954,7 +2954,7 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 	if (do_refresh) {
 		/* we don't really need to update mval,
 		 * but this happens to be the best way to refresh at the moment */
-		knifetool_update_mval_i(C, kcd, event->mval);
+		knifetool_update_mval_i(kcd, event->mval);
 	}
 
 	/* keep going until the user confirms */
@@ -3042,7 +3042,7 @@ void EDBM_mesh_knife(bContext *C, LinkNode *polys, bool use_tag, bool cut_throug
 			int i;
 
 			for (i = 0; i < mval_tot; i++) {
-				knifetool_update_mval(C, kcd, mval_fl[i]);
+				knifetool_update_mval(kcd, mval_fl[i]);
 				if (i == 0) {
 					knife_start_cut(kcd);
 					kcd->mode = MODE_DRAGGING;
@@ -3073,7 +3073,7 @@ void EDBM_mesh_knife(bContext *C, LinkNode *polys, bool use_tag, bool cut_throug
 
 			/* freed on knifetool_finish_ex, but we need again to check if points are visible */
 			if (kcd->cut_through == false) {
-				knifetool_init_bmbvh(C, kcd);
+				knifetool_init_bmbvh(kcd);
 			}
 
 			ED_view3d_ob_project_mat_get(kcd->ar->regiondata, kcd->ob, projmat);
diff --git a/source/blender/editors/mesh/editmesh_loopcut.c b/source/blender/editors/mesh/editmesh_loopcut.c
index 8db3a2c8d04..a4a6ad82dfb 100644
--- a/source/blender/editors/mesh/editmesh_loopcut.c
+++ b/source/blender/editors/mesh/editmesh_loopcut.c
@@ -63,6 +63,8 @@
 #include "WM_api.h"
 #include "WM_types.h"
 
+#include "DEG_depsgraph.h"
+
 #include "mesh_intern.h"  /* own include */
 
 #define SUBD_SMOOTH_MAX 4.0f
@@ -556,20 +558,23 @@ static void loopcut_update_edge(RingSelOpData *lcd, BMEdge *e, const int preview
 	}
 }
 
-static void loopcut_mouse_move(const bContext *C, RingSelOpData *lcd, const int previewlines)
+static void loopcut_mouse_move(const struct EvaluationContext *eval_ctx, RingSelOpData *lcd, const int previewlines)
 {
 	float dist = ED_view3d_select_dist_px();
-	BMEdge *e = EDBM_edge_find_nearest(C, &lcd->vc, &dist);
+	BMEdge *e = EDBM_edge_find_nearest(eval_ctx, &lcd->vc, &dist);
 	loopcut_update_edge(lcd, e, previewlines);
 }
 
 /* called by both init() and exec() */
 static int loopcut_init(bContext *C, wmOperator *op, const wmEvent *event)
 {
+	EvaluationContext eval_ctx;
 	const bool is_interactive = (event != NULL);
 	Object *obedit = CTX_data_edit_object(C);
 	RingSelOpData *lcd;
 
+	CTX_data_eval_ctx(C, &eval_ctx);
+
 	if (modifiers_isDeformedByLattice(obedit) || modifiers_isDeformedByArmature(obedit))
 		BKE_report(op->reports, RPT_WARNING, "Loop cut does not work well on deformed edit mesh display");
 
@@ -597,7 +602,7 @@ static int loopcut_init(bContext *C, wmOperator *op, const wmEvent *event)
 
 	if (is_interactive) {
 		copy_v2_v2_int(lcd->vc.mval, event->mval);
-		loopcut_mouse_move(C, lcd, is_interactive ? 1 : 0);
+		loopcut_mouse_move(&eval_ctx, lcd, is_interactive ? 1 : 0);
 	}
 	else {
 		const int e_index = RNA_int_get(op->ptr, "edge_index");
@@ -670,12 +675,14 @@ static int loopcut_finish(RingSelOpData *lcd, bContext *C, wmOperator *op)
 
 static int loopcut_modal(bContext *C, wmOperator *op, const wmEvent *event)
 {
+	EvaluationContext eval_ctx;
 	RingSelOpData *lcd = op->customdata;
 	float cuts = lcd->cuts;
 	float smoothness = lcd->smoothness;
 	bool show_cuts = false;
 	const bool has_numinput = hasNumInput(&lcd->num);
 
+	CTX_data_eval_ctx(C, &eval_ctx);
 	em_setup_viewcontext(C, &lcd->vc);
 	lcd->ar = lcd->vc.ar;
 
@@ -761,7 +768,7 @@ static int loopcut_modal(bContext *C, wmOperator *op, const wmEvent *event)
 				if (!has_numinput) {
 					lcd->vc.mval[0] = event->mval[0];
 					lcd->vc.mval[1] = event->mval[1];
-					loopcut_mouse_move(C, lcd, (int)lcd->cuts);
+					loopcut_mouse_move(&eval_ctx, lcd, (int)lcd->cuts);
 
 					ED_region_tag_redraw(lcd->ar);
 					handled = true;
diff --git a/source/blender/editors/mesh/editmesh_path.c b/source/blender/editors/mesh/editmesh_path.c
index 0a36b735f39..29bca00f1a9 100644
--- a/source/blender/editors/mesh/editmesh_path.c
+++ b/source/blender/editors/mesh/editmesh_path.c
@@ -59,6 +59,8 @@
 #include "bmesh.h"
 #include "bmesh_tools.h"
 
+#include "DEG_depsgraph.h"
+
 #include "mesh_intern.h"  /* own include */
 
 struct PathSelectParams {
@@ -570,19 +572,19 @@ static bool edbm_shortest_path_pick_ex(
 
 static int edbm_shortest_path_pick_exec(bContext *C, wmOperator *op);
 
-static BMElem *edbm_elem_find_nearest(const bContext *C, ViewContext *vc, const char htype)
+static BMElem *edbm_elem_find_nearest(const struct EvaluationContext *eval_ctx, ViewContext *vc, const char htype)
 {
 	BMEditMesh *em = vc->em;
 	float dist = ED_view3d_select_dist_px();
 
 	if ((em->selectmode & SCE_SELECT_VERTEX) && (htype == BM_VERT)) {
-		return (BMElem *)EDBM_vert_find_nearest(C, vc, &dist);
+		return (BMElem *)EDBM_vert_find_nearest(eval_ctx, vc, &dist);
 	}
 	else if ((em->selectmode & SCE_SELECT_EDGE) && (htype == BM_EDGE)) {
-		return (BMElem *)EDBM_edge_find_nearest(C, vc, &dist);
+		return (BMElem *)EDBM_edge_find_nearest(eval_ctx, vc, &dist);
 	}
 	else if ((em->selectmode & SCE_SELECT_FACE) && (htype == BM_FACE)) {
-		return (BMElem *)EDBM_face_find_nearest(C, vc, &dist);
+		return (BMElem *)EDBM_face_find_nearest(eval_ctx, vc, &dist);
 	}
 
 	return NULL;
@@ -605,10 +607,12 @@ static int edbm_shortest_path_pick_invoke(bContext *C, wmOperator *op, const wmE
 		return edbm_shortest_path_pick_exec(C, op);
 	}
 
+	EvaluationContext eval_ctx;
 	ViewContext vc;
 	BMEditMesh *em;
 	bool track_active = true;
 
+	CTX_data_eval_ctx(C, &eval_ctx);
 	em_setup_viewcontext(C, &vc);
 	copy_v2_v2_int(vc.mval, event->mval);
 	em = vc.em;
@@ -617,14 +621,14 @@ static int edbm_shortest_path_pick_invoke(bContext *C, wmOperator *op, const wmE
 
 	BMElem *ele_src, *ele_dst;
 	if (!(ele_src = edbm_elem_active_elem_or_face_get(em->bm)) ||
-	    !(ele_dst = edbm_elem_find_nearest(C, &vc, ele_src->head.htype)))
+	    !(ele_dst = edbm_elem_find_nearest(&eval_ctx, &vc, ele_src->head.htype)))
 	{
 		/* special case, toggle edge tags even when we don't have a path */
 		if (((em->selectmode & SCE_SELECT_EDGE) &&
 		     (vc.scene->toolsettings->edge_mode != EDGE_MODE_SELECT)) &&
 		    /* check if we only have a destination edge */
 		    ((ele_src == NULL) &&
-		     (ele_dst = edbm_elem_find_nearest(C, &vc, BM_EDGE))))
+		     (ele_dst = edbm_elem_find_nearest(&eval_ctx, &vc, BM_EDGE))))
 		{
 			ele_src = ele_dst;
 			track_active = false;
diff --git a/source/blender/editors/mesh/editmesh_select.c b/source/blender/editors/mesh/editmesh_select.c
index 97ae8ae166d..7fe4e58d2e0 100644
--- a/source/blender/editors/mesh/editmesh_select.c
+++ b/source/blender/editors/mesh/editmesh_select.c
@@ -68,6 +68,8 @@
 
 #include "bmesh_tools.h"
 
+#include "DEG_depsgraph.h"
+
 #include "mesh_intern.h"  /* own include */
 
 /* use bmesh operator flags for a few operators */
@@ -194,7 +196,9 @@ static BLI_bitmap *edbm_backbuf_alloc(const int size)
 
 /* reads rect, and builds selection array for quick lookup */
 /* returns if all is OK */
-bool EDBM_backbuf_border_init(const bContext *C, ViewContext *vc, short xmin, short ymin, short xmax, short ymax)
+bool EDBM_backbuf_border_init(
+        const struct EvaluationContext *eval_ctx, ViewContext *vc, short xmin,
+        short ymin, short xmax, short ymax)
 {
 	struct ImBuf *buf;
 	unsigned int *dr;
@@ -204,7 +208,7 @@ bool EDBM_backbuf_border_init(const bContext *C, ViewContext *vc, short xmin, sh
 		return false;
 	}
 	
-	buf = ED_view3d_backbuf_read(C, vc, xmin, ymin, xmax, ymax);
+	buf = ED_view3d_backbuf_read(eval_ctx, vc, xmin, ymin, xmax, ymax);
 	if ((buf == NULL) || (bm_vertoffs == 0)) {
 		return false;
 	}
@@ -267,7 +271,7 @@ static void edbm_mask_lasso_px_cb(int x, int x_end, int y, void *user_data)
  * - grab again and compare
  * returns 'OK' 
  */
-bool EDBM_backbuf_border_mask_init(const bContext *C, ViewContext *vc, const int mcords[][2], short tot, short xmin, short ymin, short xmax, short ymax)
+bool EDBM_backbuf_border_mask_init(const struct EvaluationContext *eval_ctx, ViewContext *vc, const int mcords[][2], short tot, short xmin, short ymin, short xmax, short ymax)
 {
 	unsigned int *dr, *dr_mask, *dr_mask_arr;
 	struct ImBuf *buf;
@@ -284,7 +288,7 @@ bool EDBM_backbuf_border_mask_init(const bContext *C, ViewContext *vc, const int
 		return false;
 	}
 
-	buf = ED_view3d_backbuf_read(C, vc, xmin, ymin, xmax, ymax);
+	buf = ED_view3d_backbuf_read(eval_ctx, vc, xmin, ymin, xmax, ymax);
 	if ((buf == NULL) || (bm_vertoffs == 0)) {
 		return false;
 	}
@@ -317,7 +321,9 @@ bool EDBM_backbuf_border_mask_init(const bContext *C, ViewContext *vc, const int
 }
 
 /* circle shaped sample area */
-bool EDBM_backbuf_circle_init(const bContext *C, ViewContext *vc, short xs, short ys, short rads)
+bool EDBM_backbuf_circle_init(
+        const struct EvaluationContext *eval_ctx, ViewContext *vc,
+        short xs, short ys, short rads)
 {
 	struct ImBuf *buf;
 	unsigned int *dr;
@@ -336,7 +342,7 @@ bool EDBM_backbuf_circle_init(const bContext *C, ViewContext *vc, short xs, shor
 
 	xmin = xs - rads; xmax = xs + rads;
 	ymin = ys - rads; ymax = ys + rads;
-	buf = ED_view3d_backbuf_read(C, vc, xmin, ymin, xmax, ymax);
+	buf = ED_view3d_backbuf_read(eval_ctx, vc, xmin, ymin, xmax, ymax);
 	if ((buf == NULL) || (bm_vertoffs == 0)) {
 		return false;
 	}
@@ -435,7 +441,7 @@ static void findnearestvert__doClosest(void *userData, BMVert *eve, const float
  * \param use_cycle Cycle over elements within #FIND_NEAR_CYCLE_THRESHOLD_MIN in order of index.
  */
 BMVert *EDBM_vert_find_nearest_ex(
-        const bContext *C, ViewContext *vc, float *r_dist,
+        const struct EvaluationContext *eval_ctx, ViewContext *vc, float *r_dist,
         const bool use_select_bias, bool use_cycle)
 {
 	BMesh *bm = vc->em->bm;
@@ -447,10 +453,10 @@ BMVert *EDBM_vert_find_nearest_ex(
 		BMVert *eve;
 		
 		/* No afterqueue (yet), so we check it now, otherwise the bm_xxxofs indices are bad. */
-		ED_view3d_backbuf_validate(C, vc);
+		ED_view3d_backbuf_validate(eval_ctx, vc);
 
 		index = ED_view3d_backbuf_sample_rect(
-		        C, vc, vc->mval, dist_px, bm_wireoffs, 0xFFFFFF, &dist_test);
+		        eval_ctx, vc, vc->mval, dist_px, bm_wireoffs, 0xFFFFFF, &dist_test);
 		eve = index ? BM_vert_at_index_find_or_table(bm, index - 1) : NULL;
 		
 		if (eve) {
@@ -485,7 +491,7 @@ BMVert *EDBM_vert_find_nearest_ex(
 		data.cycle_index_prev = prev_select_index;
 
 		ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
-		mesh_foreachScreenVert(C, vc, findnearestvert__doClosest, &data, clip_flag);
+		mesh_foreachScreenVert(eval_ctx, vc, findnearestvert__doClosest, &data, clip_flag);
 
 		hit = (data.use_cycle && data.hit_cycle.vert) ? &data.hit_cycle : &data.hit;
 		*r_dist = hit->dist;
@@ -497,9 +503,9 @@ BMVert *EDBM_vert_find_nearest_ex(
 	}
 }
 
-BMVert *EDBM_vert_find_nearest(const bContext *C, ViewContext *vc, float *r_dist)
+BMVert *EDBM_vert_find_nearest(const struct EvaluationContext *eval_ctx, ViewContext *vc, float *r_dist)
 {
-	return EDBM_vert_find_nearest_ex(C, vc, r_dist, false, false);
+	return EDBM_vert_find_nearest_ex(eval_ctx, vc, r_dist, false, false);
 }
 
 /* find the distance to the edge we already have */
@@ -621,7 +627,7 @@ static void find_nearest_edge__doClosest(
 }
 
 BMEdge *EDBM_edge_find_nearest_ex(
-        const bContext *C, ViewContext *vc, float *r_dist,
+        const struct EvaluationContext *eval_ctx, ViewContext *vc, float *r_dist,
         float *r_dist_center,
         const bool use_select_bias, const bool use_cycle,
         BMEdge **r_eed_zbuf)
@@ -635,9 +641,9 @@ BMEdge *EDBM_edge_find_nearest_ex(
 		BMEdge *eed;
 
 		/* No afterqueue (yet), so we check it now, otherwise the bm_xxxofs indices are bad. */
-		ED_view3d_backbuf_validate(C, vc);
+		ED_view3d_backbuf_validate(eval_ctx, vc);
 
-		index = ED_view3d_backbuf_sample_rect(C, vc, vc->mval, dist_px, bm_solidoffs, bm_wireoffs, &dist_test);
+		index = ED_view3d_backbuf_sample_rect(eval_ctx, vc, vc->mval, dist_px, bm_solidoffs, bm_wireoffs, &dist_test);
 		eed = index ? BM_edge_at_index_find_or_table(bm, index - 1) : NULL;
 
 		if (r_eed_zbuf) {
@@ -655,7 +661,7 @@ BMEdge *EDBM_edge_find_nearest_ex(
 
 			ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
 
-			mesh_foreachScreenEdge(C, vc, find_nearest_edge_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
+			mesh_foreachScreenEdge(eval_ctx, vc, find_nearest_edge_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
 
 			*r_dist_center = data.dist;
 		}
@@ -695,7 +701,7 @@ BMEdge *EDBM_edge_find_nearest_ex(
 		data.cycle_index_prev = prev_select_index;
 
 		ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
-		mesh_foreachScreenEdge(C, vc, find_nearest_edge__doClosest, &data, clip_flag);
+		mesh_foreachScreenEdge(eval_ctx, vc, find_nearest_edge__doClosest, &data, clip_flag);
 
 		hit = (data.use_cycle && data.hit_cycle.edge) ? &data.hit_cycle : &data.hit;
 		*r_dist = hit->dist;
@@ -711,9 +717,9 @@ BMEdge *EDBM_edge_find_nearest_ex(
 }
 
 BMEdge *EDBM_edge_find_nearest(
-        const bContext *C, ViewContext *vc, float *r_dist)
+        const struct EvaluationContext *eval_ctx, ViewContext *vc, float *r_dist)
 {
-	return EDBM_edge_find_nearest_ex(C, vc, r_dist, NULL, false, false, NULL);
+	return EDBM_edge_find_nearest_ex(eval_ctx, vc, r_dist, NULL, false, false, NULL);
 }
 
 /* find the distance to the face we already have */
@@ -787,7 +793,7 @@ static void findnearestface__doClosest(void *userData, BMFace *efa, const float
 
 
 BMFace *EDBM_face_find_nearest_ex(
-        const bContext *C, ViewContext *vc, float *r_dist,
+        const struct EvaluationContext *eval_ctx, ViewContext *vc, float *r_dist,
         float *r_dist_center,
         const bool use_select_bias, const bool use_cycle,
         BMFace **r_efa_zbuf)
@@ -799,9 +805,9 @@ BMFace *EDBM_face_find_nearest_ex(
 		unsigned int index;
 		BMFace *efa;
 
-		ED_view3d_backbuf_validate(C, vc);
+		ED_view3d_backbuf_validate(eval_ctx, vc);
 
-		index = ED_view3d_backbuf_sample(C, vc, vc->mval[0], vc->mval[1]);
+		index = ED_view3d_backbuf_sample(eval_ctx, vc, vc->mval[0], vc->mval[1]);
 		efa = index ? BM_face_at_index_find_or_table(bm, index - 1) : NULL;
 		
 		if (r_efa_zbuf) {
@@ -819,7 +825,7 @@ BMFace *EDBM_face_find_nearest_ex(
 
 			ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
 
-			mesh_foreachScreenFace(C, vc, find_nearest_face_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
+			mesh_foreachScreenFace(eval_ctx, vc, find_nearest_face_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
 
 			*r_dist_center = data.dist;
 		}
@@ -857,7 +863,7 @@ BMFace *EDBM_face_find_nearest_ex(
 		data.cycle_index_prev = prev_select_index;
 
 		ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
-		mesh_foreachScreenFace(C, vc, findnearestface__doClosest, &data, clip_flag);
+		mesh_foreachScreenFace(eval_ctx, vc, findnearestface__doClosest, &data, clip_flag);
 
 		hit = (data.use_cycle && data.hit_cycle.face) ? &data.hit_cycle : &data.hit;
 		*r_dist = hit->dist;
@@ -872,9 +878,9 @@ BMFace *EDBM_face_find_nearest_ex(
 	}
 }
 
-BMFace *EDBM_face_find_nearest(const bContext *C, ViewContext *vc, float *r_dist)
+BMFace *EDBM_face_find_nearest(const struct EvaluationContext *eval_ctx, ViewContext *vc, float *r_dist)
 {
-	return EDBM_face_find_nearest_ex(C, vc, r_dist, NULL, false, false, NULL);
+	return EDBM_face_find_nearest_ex(eval_ctx, vc, r_dist, NULL, false, false, NULL);
 }
 
 #undef FIND_NEAR_SELECT_BIAS
@@ -886,7 +892,9 @@ BMFace *EDBM_face_find_nearest(const bContext *C, ViewContext *vc, float *r_dist
  * selected vertices and edges get disadvantage
  * return 1 if found one
  */
-static int unified_findnearest(const bContext *C, ViewContext *vc, BMVert **r_eve, BMEdge **r_eed, BMFace **r_efa)
+static int unified_findnearest(
+        const struct EvaluationContext *eval_ctx, ViewContext *vc,
+        BMVert **r_eve, BMEdge **r_eed, BMFace **r_efa)
 {
 	BMEditMesh *em = vc->em;
 	static short mval_prev[2] = {-1, -1};
@@ -905,12 +913,12 @@ static int unified_findnearest(const bContext *C, ViewContext *vc, BMVert **r_ev
 
 
 	/* no afterqueue (yet), so we check it now, otherwise the em_xxxofs indices are bad */
-	ED_view3d_backbuf_validate(C, vc);
+	ED_view3d_backbuf_validate(eval_ctx, vc);
 
 	if ((dist > 0.0f) && em->selectmode & SCE_SELECT_FACE) {
 		float dist_center = 0.0f;
 		float *dist_center_p = (em->selectmode & (SCE_SELECT_EDGE | SCE_SELECT_VERTEX)) ? &dist_center : NULL;
-		efa = EDBM_face_find_nearest_ex(C, vc, &dist, dist_center_p, true, use_cycle, &efa_zbuf);
+		efa = EDBM_face_find_nearest_ex(eval_ctx, vc, &dist, dist_center_p, true, use_cycle, &efa_zbuf);
 		if (efa && dist_center_p) {
 			dist = min_ff(dist_margin, dist_center);
 		}
@@ -919,14 +927,14 @@ static int unified_findnearest(const bContext *C, ViewContext *vc, BMVert **r_ev
 	if ((dist > 0.0f) && (em->selectmode & SCE_SELECT_EDGE)) {
 		float dist_center = 0.0f;
 		float *dist_center_p = (em->selectmode & SCE_SELECT_VERTEX) ? &dist_center : NULL;
-		eed = EDBM_edge_find_nearest_ex(C, vc, &dist, dist_center_p, true, use_cycle, &eed_zbuf);
+		eed = EDBM_edge_find_nearest_ex(eval_ctx, vc, &dist, dist_center_p, true, use_cycle, &eed_zbuf);
 		if (eed && dist_center_p) {
 			dist = min_ff(dist_margin, dist_center);
 		}
 	}
 
 	if ((dist > 0.0f) && em->selectmode & SCE_SELECT_VERTEX) {
-		eve = EDBM_vert_find_nearest_ex(C, vc, &dist, true, use_cycle);
+		eve = EDBM_vert_find_nearest_ex(eval_ctx, vc, &dist, true, use_cycle);
 	}
 
 	/* return only one of 3 pointers, for frontbuffer redraws */
@@ -1559,6 +1567,7 @@ static void mouse_mesh_loop_edge(BMEditMesh *em, BMEdge *eed, bool select, bool
 
 static bool mouse_mesh_loop(bContext *C, const int mval[2], bool extend, bool deselect, bool toggle, bool ring)
 {
+	EvaluationContext eval_ctx;
 	ViewContext vc;
 	BMEditMesh *em;
 	BMEdge *eed;
@@ -1568,15 +1577,16 @@ static bool mouse_mesh_loop(bContext *C, const int mval[2], bool extend, bool de
 	float dist = ED_view3d_select_dist_px() * 0.6666f;
 	float mvalf[2];
 
+	CTX_data_eval_ctx(C, &eval_ctx);
 	em_setup_viewcontext(C, &vc);
 	mvalf[0] = (float)(vc.mval[0] = mval[0]);
 	mvalf[1] = (float)(vc.mval[1] = mval[1]);
 	em = vc.em;
 
 	/* no afterqueue (yet), so we check it now, otherwise the bm_xxxofs indices are bad */
-	ED_view3d_backbuf_validate(C, &vc);
+	ED_view3d_backbuf_validate(&eval_ctx, &vc);
 
-	eed = EDBM_edge_find_nearest_ex(C, &vc, &dist, NULL, true, true, NULL);
+	eed = EDBM_edge_find_nearest_ex(&eval_ctx, &vc, &dist, NULL, true, true, NULL);
 	if (eed == NULL) {
 		return false;
 	}
@@ -1819,17 +1829,19 @@ void MESH_OT_select_interior_faces(wmOperatorType *ot)
 /* gets called via generic mouse select operator */
 bool EDBM_select_pick(bContext *C, const int mval[2], bool extend, bool deselect, bool toggle)
 {
+	EvaluationContext eval_ctx;
 	ViewContext vc;
 	BMVert *eve = NULL;
 	BMEdge *eed = NULL;
 	BMFace *efa = NULL;
 
 	/* setup view context for argument to callbacks */
+	CTX_data_eval_ctx(C, &eval_ctx);
 	em_setup_viewcontext(C, &vc);
 	vc.mval[0] = mval[0];
 	vc.mval[1] = mval[1];
 
-	if (unified_findnearest(C, &vc, &eve, &eed, &efa)) {
+	if (unified_findnearest(&eval_ctx, &vc, &eve, &eed, &efa)) {
 
 		/* Deselect everything */
 		if (extend == false && deselect == false && toggle == false)
@@ -2793,6 +2805,7 @@ static void edbm_select_linked_pick_ex(BMEditMesh *em, BMElem *ele, bool sel, in
 static int edbm_select_linked_pick_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 {
 	Object *obedit = CTX_data_edit_object(C);
+	EvaluationContext eval_ctx;
 	ViewContext vc;
 	BMEditMesh *em;
 	BMesh *bm;
@@ -2810,6 +2823,7 @@ static int edbm_select_linked_pick_invoke(bContext *C, wmOperator *op, const wmE
 	view3d_operator_needs_opengl(C);
 
 	/* setup view context for argument to callbacks */
+	CTX_data_eval_ctx(C, &eval_ctx);
 	em_setup_viewcontext(C, &vc);
 	em = vc.em;
 	bm = em->bm;
@@ -2822,7 +2836,7 @@ static int edbm_select_linked_pick_invoke(bContext *C, wmOperator *op, const wmE
 	vc.mval[1] = event->mval[1];
 
 	/* return warning! */
-	if (unified_findnearest(C, &vc, &eve, &eed, &efa) == 0) {
+	if (unified_findnearest(&eval_ctx, &vc, &eve, &eed, &efa) == 0) {
 		WM_event_add_notifier(C, NC_GEOM | ND_SELECT, obedit);
 
 		return OPERATOR_CANCELLED;
diff --git a/source/blender/editors/mesh/meshtools.c b/source/blender/editors/mesh/meshtools.c
index 7ec8e42e6df..8fddf2551b8 100644
--- a/source/blender/editors/mesh/meshtools.c
+++ b/source/blender/editors/mesh/meshtools.c
@@ -88,6 +88,7 @@ static void join_mesh_single(
         Material **matar, int *matmap, int totcol,
         int *vertofs, int *edgeofs, int *loopofs, int *polyofs)
 {
+	EvaluationContext eval_ctx;
 	int a, b;
 
 	Mesh *me = base_src->object->data;
@@ -95,7 +96,6 @@ static void join_mesh_single(
 	MEdge *medge = *medge_pp;
 	MLoop *mloop = *mloop_pp;
 	MPoly *mpoly = *mpoly_pp;
-	EvaluationContext eval_ctx;
 
 	CTX_data_eval_ctx(C, &eval_ctx);
 
@@ -1106,6 +1106,7 @@ int *mesh_get_x_mirror_faces(Object *ob, BMEditMesh *em, DerivedMesh *dm)
  */
 bool ED_mesh_pick_face(bContext *C, Object *ob, const int mval[2], unsigned int *index, int size)
 {
+	EvaluationContext eval_ctx;
 	ViewContext vc;
 	Mesh *me = ob->data;
 
@@ -1114,6 +1115,7 @@ bool ED_mesh_pick_face(bContext *C, Object *ob, const int mval[2], unsigned int
 	if (!me || me->totpoly == 0)
 		return false;
 
+	CTX_data_eval_ctx(C, &eval_ctx);
 	view3d_set_viewcontext(C, &vc);
 
 	if (size) {
@@ -1121,11 +1123,11 @@ bool ED_mesh_pick_face(bContext *C, Object *ob, const int mval[2], unsigned int
 		 * on an edge in the backbuf, we can still select a face */
 
 		float dummy_dist;
-		*index = ED_view3d_backbuf_sample_rect(C, &vc, mval, size, 1, me->totpoly + 1, &dummy_dist);
+		*index = ED_view3d_backbuf_sample_rect(&eval_ctx, &vc, mval, size, 1, me->totpoly + 1, &dummy_dist);
 	}
 	else {
 		/* sample only on the exact position */
-		*index = ED_view3d_backbuf_sample(C, &vc, mval[0], mval[1]);
+		*index = ED_view3d_backbuf_sample(&eval_ctx, &vc, mval[0], mval[1]);
 	}
 
 	if ((*index) == 0 || (*index) > (unsigned int)me->totpoly)
@@ -1293,11 +1295,11 @@ bool ED_mesh_pick_vert(bContext *C, Object *ob, const int mval[2], unsigned int
 			 * on an face in the backbuf, we can still select a vert */
 
 			float dummy_dist;
-			*index = ED_view3d_backbuf_sample_rect(C, &vc, mval, size, 1, me->totvert + 1, &dummy_dist);
+			*index = ED_view3d_backbuf_sample_rect(&eval_ctx, &vc, mval, size, 1, me->totvert + 1, &dummy_dist);
 		}
 		else {
 			/* sample only on the exact position */
-			*index = ED_view3d_backbuf_sample(C, &vc, mval[0], mval[1]);
+			*index = ED_view3d_backbuf_sample(&eval_ctx, &vc, mval[0], mval[1]);
 		}
 
 		if ((*index) == 0 || (*index) > (unsigned int)me->totvert)