Pass EvaluationContext argument everywhere

Note that some little parts of code have been dissabled because eval_ctx
was not available there. This should be resolved once DerivedMesh is
replaced.

9 files changed, 121 insertions, 96 deletions

diff --git a/source/blender/editors/mesh/editface.c b/source/blender/editors/mesh/editface.c
index 696f4892530..8aa3b63f795 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(ViewContext *vc, rcti *rect, bool select, bool extend)
+int do_paintface_box_select(const bContext *C, ViewContext *vc, rcti *rect, bool select, bool extend)
 {
 	Object *ob = vc->obact;
 	Mesh *me;
@@ -427,7 +427,7 @@ int do_paintface_box_select(ViewContext *vc, rcti *rect, bool select, bool exten
 		}
 	}
 
-	ED_view3d_backbuf_validate(vc);
+	ED_view3d_backbuf_validate(C, 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 3c974e4b3b9..37d86ee313f 100644
--- a/source/blender/editors/mesh/editmesh_knife.c
+++ b/source/blender/editors/mesh/editmesh_knife.c
@@ -54,6 +54,8 @@
 #include "BKE_editmesh_bvh.h"
 #include "BKE_report.h"
 
+#include "DEG_depsgraph.h"
+
 #include "GPU_immediate.h"
 #include "GPU_matrix.h"
 
@@ -1812,7 +1814,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(KnifeTool_OpData *kcd, float co[3], float cageco[3], bool *is_space)
+static BMFace *knife_find_closest_face(const bContext *C, KnifeTool_OpData *kcd, float co[3], float cageco[3], bool *is_space)
 {
 	BMFace *f;
 	float dist = KMAXDIST;
@@ -1837,7 +1839,7 @@ static BMFace *knife_find_closest_face(KnifeTool_OpData *kcd, float co[3], float
 	if (!f) {
 		if (kcd->is_interactive) {
 			/* try to use backbuffer selection method if ray casting failed */
-			f = EDBM_face_find_nearest(&kcd->vc, &dist);
+			f = EDBM_face_find_nearest(C, &kcd->vc, &dist);
 
 			/* cheat for now; just put in the origin instead
 			 * of a true coordinate on the face.
@@ -1851,7 +1853,7 @@ static BMFace *knife_find_closest_face(KnifeTool_OpData *kcd, float co[3], float
 
 /* 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(KnifeTool_OpData *kcd, const float radius)
+static int knife_sample_screen_density(const bContext *C, KnifeTool_OpData *kcd, const float radius)
 {
 	BMFace *f;
 	bool is_space;
@@ -1859,7 +1861,7 @@ static int knife_sample_screen_density(KnifeTool_OpData *kcd, const float radius
 
 	BLI_assert(kcd->is_interactive == true);
 
-	f = knife_find_closest_face(kcd, co, cageco, &is_space);
+	f = knife_find_closest_face(C, kcd, co, cageco, &is_space);
 
 	if (f && !is_space) {
 		const float radius_sq = radius * radius;
@@ -1902,15 +1904,15 @@ static int knife_sample_screen_density(KnifeTool_OpData *kcd, const float radius
 
 /* returns snapping distance for edges/verts, scaled by the density of the
  * surrounding mesh (in screen space)*/
-static float knife_snap_size(KnifeTool_OpData *kcd, float maxsize)
+static float knife_snap_size(const bContext *C, KnifeTool_OpData *kcd, float maxsize)
 {
-	float density = (float)knife_sample_screen_density(kcd, maxsize * 2.0f);
+	float density = (float)knife_sample_screen_density(C, 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(KnifeTool_OpData *kcd, float p[3], float cagep[3],
+static KnifeEdge *knife_find_closest_edge(const bContext *C, KnifeTool_OpData *kcd, float p[3], float cagep[3],
                                           BMFace **fptr, bool *is_space)
 {
 	BMFace *f;
@@ -1918,7 +1920,7 @@ static KnifeEdge *knife_find_closest_edge(KnifeTool_OpData *kcd, float p[3], flo
 	float maxdist;
 
 	if (kcd->is_interactive) {
-		maxdist = knife_snap_size(kcd, kcd->ethresh);
+		maxdist = knife_snap_size(C, kcd, kcd->ethresh);
 
 		if (kcd->ignore_vert_snapping) {
 			maxdist *= 0.5f;
@@ -1928,7 +1930,7 @@ static KnifeEdge *knife_find_closest_edge(KnifeTool_OpData *kcd, float p[3], flo
 		maxdist = KNIFE_FLT_EPS;
 	}
 
-	f = knife_find_closest_face(kcd, co, cageco, NULL);
+	f = knife_find_closest_face(C, kcd, co, cageco, NULL);
 	*is_space = !f;
 
 	kcd->curr.bmface = f;
@@ -2042,7 +2044,7 @@ static KnifeEdge *knife_find_closest_edge(KnifeTool_OpData *kcd, float p[3], flo
 }
 
 /* find a vertex near the mouse cursor, if it exists */
-static KnifeVert *knife_find_closest_vert(KnifeTool_OpData *kcd, float p[3], float cagep[3], BMFace **fptr,
+static KnifeVert *knife_find_closest_vert(const bContext *C, KnifeTool_OpData *kcd, float p[3], float cagep[3], BMFace **fptr,
                                           bool *is_space)
 {
 	BMFace *f;
@@ -2050,7 +2052,7 @@ static KnifeVert *knife_find_closest_vert(KnifeTool_OpData *kcd, float p[3], flo
 	float maxdist;
 
 	if (kcd->is_interactive) {
-		maxdist = knife_snap_size(kcd, kcd->vthresh);
+		maxdist = knife_snap_size(C, kcd, kcd->vthresh);
 		if (kcd->ignore_vert_snapping) {
 			maxdist *= 0.5f;
 		}
@@ -2059,7 +2061,7 @@ static KnifeVert *knife_find_closest_vert(KnifeTool_OpData *kcd, float p[3], flo
 		maxdist = KNIFE_FLT_EPS;
 	}
 
-	f = knife_find_closest_face(kcd, co, cageco, is_space);
+	f = knife_find_closest_face(C, kcd, co, cageco, is_space);
 
 	kcd->curr.bmface = f;
 
@@ -2181,7 +2183,7 @@ static bool knife_snap_angle(KnifeTool_OpData *kcd)
 }
 
 /* update active knife edge/vert pointers */
-static int knife_update_active(KnifeTool_OpData *kcd)
+static int knife_update_active(const bContext *C, KnifeTool_OpData *kcd)
 {
 	knife_pos_data_clear(&kcd->curr);
 	copy_v2_v2(kcd->curr.mval, kcd->mval);
@@ -2196,13 +2198,13 @@ static int knife_update_active(KnifeTool_OpData *kcd)
 		kcd->is_angle_snapping = false;
 	}
 
-	kcd->curr.vert = knife_find_closest_vert(kcd, kcd->curr.co, kcd->curr.cage, &kcd->curr.bmface, &kcd->curr.is_space);
+	kcd->curr.vert = knife_find_closest_vert(C, 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(kcd, kcd->curr.co, kcd->curr.cage,
+		kcd->curr.edge = knife_find_closest_edge(C, kcd, kcd->curr.co, kcd->curr.cage,
 		                                         &kcd->curr.bmface, &kcd->curr.is_space);
 	}
 
@@ -2569,27 +2571,30 @@ static void knifetool_exit(bContext *C, wmOperator *op)
 	op->customdata = NULL;
 }
 
-static void knifetool_update_mval(KnifeTool_OpData *kcd, const float mval[2])
+static void knifetool_update_mval(const bContext *C, KnifeTool_OpData *kcd, const float mval[2])
 {
 	knife_recalc_projmat(kcd);
 	copy_v2_v2(kcd->mval, mval);
 
-	if (knife_update_active(kcd)) {
+	if (knife_update_active(C, kcd)) {
 		ED_region_tag_redraw(kcd->ar);
 	}
 }
 
-static void knifetool_update_mval_i(KnifeTool_OpData *kcd, const int mval_i[2])
+static void knifetool_update_mval_i(const bContext *C, KnifeTool_OpData *kcd, const int mval_i[2])
 {
 	float mval[2] = {UNPACK2(mval_i)};
-	knifetool_update_mval(kcd, mval);
+	knifetool_update_mval(C, kcd, mval);
 }
 
-static void knifetool_init_bmbvh(KnifeTool_OpData *kcd)
+static void knifetool_init_bmbvh(const bContext *C, KnifeTool_OpData *kcd)
 {
+	EvaluationContext eval_ctx;
 	BM_mesh_elem_index_ensure(kcd->em->bm, BM_VERT);
 
-	kcd->cagecos = (const float (*)[3])BKE_editmesh_vertexCos_get(kcd->em, kcd->scene, NULL);
+	CTX_data_eval_ctx(C, &eval_ctx);
+
+	kcd->cagecos = (const float (*)[3])BKE_editmesh_vertexCos_get(&eval_ctx, kcd->em, kcd->scene, NULL);
 
 	kcd->bmbvh = BKE_bmbvh_new_from_editmesh(
 	        kcd->em,
@@ -2632,7 +2637,7 @@ static void knifetool_init(bContext *C, KnifeTool_OpData *kcd,
 	kcd->cut_through = cut_through;
 	kcd->only_select = only_select;
 
-	knifetool_init_bmbvh(kcd);
+	knifetool_init_bmbvh(C, kcd);
 
 	kcd->arena = BLI_memarena_new(MEM_SIZE_OPTIMAL(1 << 15), "knife");
 #ifdef USE_NET_ISLAND_CONNECT
@@ -2704,7 +2709,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(kcd, event->mval);
+	knifetool_update_mval_i(C, kcd, event->mval);
 
 	knife_update_header(C, op, kcd);
 
@@ -2810,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(kcd);
+				knife_update_active(C, kcd);
 				knife_update_header(C, op, kcd);
 				ED_region_tag_redraw(kcd->ar);
 				do_refresh = true;
@@ -2819,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(kcd);
+				knife_update_active(C, kcd);
 				knife_update_header(C, op, kcd);
 				ED_region_tag_redraw(kcd->ar);
 				do_refresh = true;
@@ -2874,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(kcd, kcd->curr.mval);
+					knifetool_update_mval(C, kcd, kcd->curr.mval);
 				}
 
 				ED_region_tag_redraw(kcd->ar);
@@ -2885,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(kcd, kcd->curr.mval);
+						knifetool_update_mval(C, 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(kcd, kcd->curr.mval);
+					knifetool_update_mval(C, kcd, kcd->curr.mval);
 
 					knife_add_cut(kcd);
 
@@ -2926,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(kcd, event->mval);
+					knifetool_update_mval_i(C, kcd, event->mval);
 
 					if (kcd->is_drag_hold) {
 						if (kcd->totlinehit >= 2) {
@@ -2949,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(kcd, event->mval);
+		knifetool_update_mval_i(C, kcd, event->mval);
 	}
 
 	/* keep going until the user confirms */
@@ -3037,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(kcd, mval_fl[i]);
+				knifetool_update_mval(C, kcd, mval_fl[i]);
 				if (i == 0) {
 					knife_start_cut(kcd);
 					kcd->mode = MODE_DRAGGING;
@@ -3068,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(kcd);
+				knifetool_init_bmbvh(C, kcd);
 			}
 
 			ED_view3d_ob_project_mat_get(kcd->ar->regiondata, kcd->ob, projmat);
diff --git a/source/blender/editors/mesh/editmesh_knife_project.c b/source/blender/editors/mesh/editmesh_knife_project.c
index 0d3cc07589b..c98d22503e1 100644
--- a/source/blender/editors/mesh/editmesh_knife_project.c
+++ b/source/blender/editors/mesh/editmesh_knife_project.c
@@ -42,6 +42,8 @@
 #include "BKE_editmesh.h"
 #include "BKE_report.h"
 
+#include "DEG_depsgraph.h"
+
 #include "RNA_define.h"
 #include "RNA_access.h"
 
@@ -56,13 +58,17 @@
 #include "mesh_intern.h"  /* own include */
 
 
-static LinkNode *knifeproject_poly_from_object(ARegion *ar, Scene *scene, Object *ob, LinkNode *polys)
+static LinkNode *knifeproject_poly_from_object(const bContext *C, Scene *scene, Object *ob, LinkNode *polys)
 {
+	ARegion *ar = CTX_wm_region(C);
+	EvaluationContext eval_ctx;
 	DerivedMesh *dm;
 	bool dm_needsFree;
 
+	CTX_data_eval_ctx(C, &eval_ctx);
+
 	if (ob->type == OB_MESH || ob->derivedFinal) {
-		dm = ob->derivedFinal ? ob->derivedFinal : mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH);
+		dm = ob->derivedFinal ? ob->derivedFinal : mesh_get_derived_final(&eval_ctx, scene, ob, CD_MASK_BAREMESH);
 		dm_needsFree = false;
 	}
 	else if (ELEM(ob->type, OB_FONT, OB_CURVE, OB_SURF)) {
@@ -116,7 +122,6 @@ static LinkNode *knifeproject_poly_from_object(ARegion *ar, Scene *scene, Object
 
 static int knifeproject_exec(bContext *C, wmOperator *op)
 {
-	ARegion *ar = CTX_wm_region(C);
 	Scene *scene = CTX_data_scene(C);
 	Object *obedit = CTX_data_edit_object(C);
 	BMEditMesh *em = BKE_editmesh_from_object(obedit);
@@ -127,7 +132,7 @@ static int knifeproject_exec(bContext *C, wmOperator *op)
 	CTX_DATA_BEGIN (C, Object *, ob, selected_objects)
 	{
 		if (ob != obedit) {
-			polys = knifeproject_poly_from_object(ar, scene, ob, polys);
+			polys = knifeproject_poly_from_object(C, scene, ob, polys);
 		}
 	}
 	CTX_DATA_END;
diff --git a/source/blender/editors/mesh/editmesh_loopcut.c b/source/blender/editors/mesh/editmesh_loopcut.c
index 6a656ace09c..8db3a2c8d04 100644
--- a/source/blender/editors/mesh/editmesh_loopcut.c
+++ b/source/blender/editors/mesh/editmesh_loopcut.c
@@ -556,10 +556,10 @@ static void loopcut_update_edge(RingSelOpData *lcd, BMEdge *e, const int preview
 	}
 }
 
-static void loopcut_mouse_move(RingSelOpData *lcd, const int previewlines)
+static void loopcut_mouse_move(const bContext *C, RingSelOpData *lcd, const int previewlines)
 {
 	float dist = ED_view3d_select_dist_px();
-	BMEdge *e = EDBM_edge_find_nearest(&lcd->vc, &dist);
+	BMEdge *e = EDBM_edge_find_nearest(C, &lcd->vc, &dist);
 	loopcut_update_edge(lcd, e, previewlines);
 }
 
@@ -597,7 +597,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(lcd, is_interactive ? 1 : 0);
+		loopcut_mouse_move(C, lcd, is_interactive ? 1 : 0);
 	}
 	else {
 		const int e_index = RNA_int_get(op->ptr, "edge_index");
@@ -761,7 +761,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(lcd, (int)lcd->cuts);
+					loopcut_mouse_move(C, 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 4431712e720..0a36b735f39 100644
--- a/source/blender/editors/mesh/editmesh_path.c
+++ b/source/blender/editors/mesh/editmesh_path.c
@@ -570,19 +570,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(ViewContext *vc, const char htype)
+static BMElem *edbm_elem_find_nearest(const bContext *C, 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(vc, &dist);
+		return (BMElem *)EDBM_vert_find_nearest(C, vc, &dist);
 	}
 	else if ((em->selectmode & SCE_SELECT_EDGE) && (htype == BM_EDGE)) {
-		return (BMElem *)EDBM_edge_find_nearest(vc, &dist);
+		return (BMElem *)EDBM_edge_find_nearest(C, vc, &dist);
 	}
 	else if ((em->selectmode & SCE_SELECT_FACE) && (htype == BM_FACE)) {
-		return (BMElem *)EDBM_face_find_nearest(vc, &dist);
+		return (BMElem *)EDBM_face_find_nearest(C, vc, &dist);
 	}
 
 	return NULL;
@@ -617,14 +617,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(&vc, ele_src->head.htype)))
+	    !(ele_dst = edbm_elem_find_nearest(C, &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(&vc, BM_EDGE))))
+		     (ele_dst = edbm_elem_find_nearest(C, &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 4220117f5ca..97ae8ae166d 100644
--- a/source/blender/editors/mesh/editmesh_select.c
+++ b/source/blender/editors/mesh/editmesh_select.c
@@ -194,7 +194,7 @@ 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(ViewContext *vc, short xmin, short ymin, short xmax, short ymax)
+bool EDBM_backbuf_border_init(const bContext *C, ViewContext *vc, short xmin, short ymin, short xmax, short ymax)
 {
 	struct ImBuf *buf;
 	unsigned int *dr;
@@ -204,7 +204,7 @@ bool EDBM_backbuf_border_init(ViewContext *vc, short xmin, short ymin, short xma
 		return false;
 	}
 	
-	buf = ED_view3d_backbuf_read(vc, xmin, ymin, xmax, ymax);
+	buf = ED_view3d_backbuf_read(C, vc, xmin, ymin, xmax, ymax);
 	if ((buf == NULL) || (bm_vertoffs == 0)) {
 		return false;
 	}
@@ -267,7 +267,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(ViewContext *vc, const int mcords[][2], short tot, short xmin, short ymin, short xmax, short ymax)
+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)
 {
 	unsigned int *dr, *dr_mask, *dr_mask_arr;
 	struct ImBuf *buf;
@@ -284,7 +284,7 @@ bool EDBM_backbuf_border_mask_init(ViewContext *vc, const int mcords[][2], short
 		return false;
 	}
 
-	buf = ED_view3d_backbuf_read(vc, xmin, ymin, xmax, ymax);
+	buf = ED_view3d_backbuf_read(C, vc, xmin, ymin, xmax, ymax);
 	if ((buf == NULL) || (bm_vertoffs == 0)) {
 		return false;
 	}
@@ -317,7 +317,7 @@ bool EDBM_backbuf_border_mask_init(ViewContext *vc, const int mcords[][2], short
 }
 
 /* circle shaped sample area */
-bool EDBM_backbuf_circle_init(ViewContext *vc, short xs, short ys, short rads)
+bool EDBM_backbuf_circle_init(const bContext *C, ViewContext *vc, short xs, short ys, short rads)
 {
 	struct ImBuf *buf;
 	unsigned int *dr;
@@ -336,7 +336,7 @@ bool EDBM_backbuf_circle_init(ViewContext *vc, short xs, short ys, short rads)
 
 	xmin = xs - rads; xmax = xs + rads;
 	ymin = ys - rads; ymax = ys + rads;
-	buf = ED_view3d_backbuf_read(vc, xmin, ymin, xmax, ymax);
+	buf = ED_view3d_backbuf_read(C, vc, xmin, ymin, xmax, ymax);
 	if ((buf == NULL) || (bm_vertoffs == 0)) {
 		return false;
 	}
@@ -435,7 +435,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(
-        ViewContext *vc, float *r_dist,
+        const bContext *C, ViewContext *vc, float *r_dist,
         const bool use_select_bias, bool use_cycle)
 {
 	BMesh *bm = vc->em->bm;
@@ -447,10 +447,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(vc);
+		ED_view3d_backbuf_validate(C, vc);
 
 		index = ED_view3d_backbuf_sample_rect(
-		        vc, vc->mval, dist_px, bm_wireoffs, 0xFFFFFF, &dist_test);
+		        C, 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 +485,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(vc, findnearestvert__doClosest, &data, clip_flag);
+		mesh_foreachScreenVert(C, 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 +497,9 @@ BMVert *EDBM_vert_find_nearest_ex(
 	}
 }
 
-BMVert *EDBM_vert_find_nearest(ViewContext *vc, float *r_dist)
+BMVert *EDBM_vert_find_nearest(const bContext *C, ViewContext *vc, float *r_dist)
 {
-	return EDBM_vert_find_nearest_ex(vc, r_dist, false, false);
+	return EDBM_vert_find_nearest_ex(C, vc, r_dist, false, false);
 }
 
 /* find the distance to the edge we already have */
@@ -621,7 +621,7 @@ static void find_nearest_edge__doClosest(
 }
 
 BMEdge *EDBM_edge_find_nearest_ex(
-        ViewContext *vc, float *r_dist,
+        const bContext *C, ViewContext *vc, float *r_dist,
         float *r_dist_center,
         const bool use_select_bias, const bool use_cycle,
         BMEdge **r_eed_zbuf)
@@ -635,9 +635,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(vc);
+		ED_view3d_backbuf_validate(C, vc);
 
-		index = ED_view3d_backbuf_sample_rect(vc, vc->mval, dist_px, bm_solidoffs, bm_wireoffs, &dist_test);
+		index = ED_view3d_backbuf_sample_rect(C, 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 +655,7 @@ BMEdge *EDBM_edge_find_nearest_ex(
 
 			ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
 
-			mesh_foreachScreenEdge(vc, find_nearest_edge_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
+			mesh_foreachScreenEdge(C, vc, find_nearest_edge_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
 
 			*r_dist_center = data.dist;
 		}
@@ -695,7 +695,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(vc, find_nearest_edge__doClosest, &data, clip_flag);
+		mesh_foreachScreenEdge(C, 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 +711,9 @@ BMEdge *EDBM_edge_find_nearest_ex(
 }
 
 BMEdge *EDBM_edge_find_nearest(
-        ViewContext *vc, float *r_dist)
+        const bContext *C, ViewContext *vc, float *r_dist)
 {
-	return EDBM_edge_find_nearest_ex(vc, r_dist, NULL, false, false, NULL);
+	return EDBM_edge_find_nearest_ex(C, vc, r_dist, NULL, false, false, NULL);
 }
 
 /* find the distance to the face we already have */
@@ -787,7 +787,7 @@ static void findnearestface__doClosest(void *userData, BMFace *efa, const float
 
 
 BMFace *EDBM_face_find_nearest_ex(
-        ViewContext *vc, float *r_dist,
+        const bContext *C, ViewContext *vc, float *r_dist,
         float *r_dist_center,
         const bool use_select_bias, const bool use_cycle,
         BMFace **r_efa_zbuf)
@@ -799,9 +799,9 @@ BMFace *EDBM_face_find_nearest_ex(
 		unsigned int index;
 		BMFace *efa;
 
-		ED_view3d_backbuf_validate(vc);
+		ED_view3d_backbuf_validate(C, vc);
 
-		index = ED_view3d_backbuf_sample(vc, vc->mval[0], vc->mval[1]);
+		index = ED_view3d_backbuf_sample(C, 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 +819,7 @@ BMFace *EDBM_face_find_nearest_ex(
 
 			ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
 
-			mesh_foreachScreenFace(vc, find_nearest_face_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
+			mesh_foreachScreenFace(C, vc, find_nearest_face_center__doZBuf, &data, V3D_PROJ_TEST_CLIP_DEFAULT);
 
 			*r_dist_center = data.dist;
 		}
@@ -857,7 +857,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(vc, findnearestface__doClosest, &data, clip_flag);
+		mesh_foreachScreenFace(C, 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 +872,9 @@ BMFace *EDBM_face_find_nearest_ex(
 	}
 }
 
-BMFace *EDBM_face_find_nearest(ViewContext *vc, float *r_dist)
+BMFace *EDBM_face_find_nearest(const bContext *C, ViewContext *vc, float *r_dist)
 {
-	return EDBM_face_find_nearest_ex(vc, r_dist, NULL, false, false, NULL);
+	return EDBM_face_find_nearest_ex(C, vc, r_dist, NULL, false, false, NULL);
 }
 
 #undef FIND_NEAR_SELECT_BIAS
@@ -886,7 +886,7 @@ BMFace *EDBM_face_find_nearest(ViewContext *vc, float *r_dist)
  * selected vertices and edges get disadvantage
  * return 1 if found one
  */
-static int unified_findnearest(ViewContext *vc, BMVert **r_eve, BMEdge **r_eed, BMFace **r_efa)
+static int unified_findnearest(const bContext *C, ViewContext *vc, BMVert **r_eve, BMEdge **r_eed, BMFace **r_efa)
 {
 	BMEditMesh *em = vc->em;
 	static short mval_prev[2] = {-1, -1};
@@ -905,12 +905,12 @@ static int unified_findnearest(ViewContext *vc, BMVert **r_eve, BMEdge **r_eed,
 
 
 	/* no afterqueue (yet), so we check it now, otherwise the em_xxxofs indices are bad */
-	ED_view3d_backbuf_validate(vc);
+	ED_view3d_backbuf_validate(C, 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(vc, &dist, dist_center_p, true, use_cycle, &efa_zbuf);
+		efa = EDBM_face_find_nearest_ex(C, vc, &dist, dist_center_p, true, use_cycle, &efa_zbuf);
 		if (efa && dist_center_p) {
 			dist = min_ff(dist_margin, dist_center);
 		}
@@ -919,14 +919,14 @@ static int unified_findnearest(ViewContext *vc, BMVert **r_eve, BMEdge **r_eed,
 	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(vc, &dist, dist_center_p, true, use_cycle, &eed_zbuf);
+		eed = EDBM_edge_find_nearest_ex(C, 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(vc, &dist, true, use_cycle);
+		eve = EDBM_vert_find_nearest_ex(C, vc, &dist, true, use_cycle);
 	}
 
 	/* return only one of 3 pointers, for frontbuffer redraws */
@@ -1574,9 +1574,9 @@ static bool mouse_mesh_loop(bContext *C, const int mval[2], bool extend, bool de
 	em = vc.em;
 
 	/* no afterqueue (yet), so we check it now, otherwise the bm_xxxofs indices are bad */
-	ED_view3d_backbuf_validate(&vc);
+	ED_view3d_backbuf_validate(C, &vc);
 
-	eed = EDBM_edge_find_nearest_ex(&vc, &dist, NULL, true, true, NULL);
+	eed = EDBM_edge_find_nearest_ex(C, &vc, &dist, NULL, true, true, NULL);
 	if (eed == NULL) {
 		return false;
 	}
@@ -1829,7 +1829,7 @@ bool EDBM_select_pick(bContext *C, const int mval[2], bool extend, bool deselect
 	vc.mval[0] = mval[0];
 	vc.mval[1] = mval[1];
 
-	if (unified_findnearest(&vc, &eve, &eed, &efa)) {
+	if (unified_findnearest(C, &vc, &eve, &eed, &efa)) {
 
 		/* Deselect everything */
 		if (extend == false && deselect == false && toggle == false)
@@ -2822,7 +2822,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(&vc, &eve, &eed, &efa) == 0) {
+	if (unified_findnearest(C, &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/editmesh_tools.c b/source/blender/editors/mesh/editmesh_tools.c
index cbed6a37c1f..023b05db62f 100644
--- a/source/blender/editors/mesh/editmesh_tools.c
+++ b/source/blender/editors/mesh/editmesh_tools.c
@@ -317,7 +317,7 @@ void EMBM_project_snap_verts(bContext *C, ARegion *ar, BMEditMesh *em)
 			float mval[2], co_proj[3];
 			if (ED_view3d_project_float_object(ar, eve->co, mval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
 				if (ED_transform_snap_object_project_view3d_mixed(
-				        snap_context,
+				        C, snap_context,
 				        SCE_SELECT_FACE,
 				        &(const struct SnapObjectParams){
 				            .snap_select = SNAP_NOT_ACTIVE,
diff --git a/source/blender/editors/mesh/mesh_navmesh.c b/source/blender/editors/mesh/mesh_navmesh.c
index 66c77593c75..e5705d2d3e7 100644
--- a/source/blender/editors/mesh/mesh_navmesh.c
+++ b/source/blender/editors/mesh/mesh_navmesh.c
@@ -73,18 +73,21 @@ static void createVertsTrisData(bContext *C, LinkNode *obs,
 	LinkNode *oblink, *dmlink;
 	DerivedMesh *dm;
 	Scene *scene = CTX_data_scene(C);
+	EvaluationContext eval_ctx;
 	LinkNode *dms = NULL;
 
 	int nverts, ntris, *tris;
 	float *verts;
 
+	CTX_data_eval_ctx(C, &eval_ctx);
+
 	nverts = 0;
 	ntris = 0;
 
 	/* calculate number of verts and tris */
 	for (oblink = obs; oblink; oblink = oblink->next) {
 		ob = (Object *) oblink->link;
-		dm = mesh_create_derived_no_virtual(scene, ob, NULL, CD_MASK_MESH);
+		dm = mesh_create_derived_no_virtual(&eval_ctx, scene, ob, NULL, CD_MASK_MESH);
 		DM_ensure_tessface(dm);
 		BLI_linklist_prepend(&dms, dm);
 
diff --git a/source/blender/editors/mesh/meshtools.c b/source/blender/editors/mesh/meshtools.c
index e7b1f925d5e..7ec8e42e6df 100644
--- a/source/blender/editors/mesh/meshtools.c
+++ b/source/blender/editors/mesh/meshtools.c
@@ -79,7 +79,7 @@
  * return 0 if no join is made (error) and 1 if the join is done */
 
 static void join_mesh_single(
-        Main *bmain, Scene *scene,
+        bContext *C, Main *bmain, Scene *scene,
         Object *ob_dst, Base *base_src, float imat[4][4],
         MVert **mvert_pp, MEdge **medge_pp, MLoop **mloop_pp, MPoly **mpoly_pp,
         CustomData *vdata, CustomData *edata, CustomData *ldata, CustomData *pdata,
@@ -95,6 +95,9 @@ 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);
 
 	if (me->totvert) {
 		/* merge customdata flag */
@@ -216,7 +219,7 @@ static void join_mesh_single(
 		if (base_src->object != ob_dst) {
 			MultiresModifierData *mmd;
 
-			multiresModifier_prepare_join(scene, base_src->object, ob_dst);
+			multiresModifier_prepare_join(&eval_ctx, scene, base_src->object, ob_dst);
 
 			if ((mmd = get_multires_modifier(scene, base_src->object, true))) {
 				ED_object_iter_other(bmain, base_src->object, true,
@@ -505,7 +508,7 @@ int join_mesh_exec(bContext *C, wmOperator *op)
 	 * active mesh will remain first ones in new result of the merge, in same order for CD layers, etc. See also T50084.
 	 */
 	join_mesh_single(
-	            bmain, scene,
+	            C, bmain, scene,
 	            ob, ob_base, imat,
 	            &mvert, &medge, &mloop, &mpoly,
 	            &vdata, &edata, &ldata, &pdata,
@@ -522,7 +525,7 @@ int join_mesh_exec(bContext *C, wmOperator *op)
 		/* only join if this is a mesh */
 		if (base->object->type == OB_MESH) {
 			join_mesh_single(
-			            bmain, scene,
+			            C, bmain, scene,
 			            ob, base, imat,
 			            &mvert, &medge, &mloop, &mpoly,
 			            &vdata, &edata, &ldata, &pdata,
@@ -624,6 +627,7 @@ int join_mesh_shapes_exec(bContext *C, wmOperator *op)
 {
 	Scene *scene = CTX_data_scene(C);
 	Object *ob = CTX_data_active_object(C);
+	EvaluationContext eval_ctx;
 	Mesh *me = (Mesh *)ob->data;
 	Mesh *selme = NULL;
 	DerivedMesh *dm = NULL;
@@ -631,6 +635,8 @@ int join_mesh_shapes_exec(bContext *C, wmOperator *op)
 	KeyBlock *kb;
 	bool ok = false, nonequal_verts = false;
 	
+	CTX_data_eval_ctx(C, &eval_ctx);
+
 	CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases)
 	{
 		if (base->object == ob) continue;
@@ -672,7 +678,7 @@ int join_mesh_shapes_exec(bContext *C, wmOperator *op)
 			selme = (Mesh *)base->object->data;
 			
 			if (selme->totvert == me->totvert) {
-				dm = mesh_get_derived_deform(scene, base->object, CD_MASK_BAREMESH);
+				dm = mesh_get_derived_deform(&eval_ctx, scene, base->object, CD_MASK_BAREMESH);
 				
 				if (!dm) continue;
 					
@@ -1115,11 +1121,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(&vc, mval, size, 1, me->totpoly + 1, &dummy_dist);
+		*index = ED_view3d_backbuf_sample_rect(C, &vc, mval, size, 1, me->totpoly + 1, &dummy_dist);
 	}
 	else {
 		/* sample only on the exact position */
-		*index = ED_view3d_backbuf_sample(&vc, mval[0], mval[1]);
+		*index = ED_view3d_backbuf_sample(C, &vc, mval[0], mval[1]);
 	}
 
 	if ((*index) == 0 || (*index) > (unsigned int)me->totpoly)
@@ -1158,9 +1164,12 @@ static void ed_mesh_pick_face_vert__mpoly_find(
  */
 bool ED_mesh_pick_face_vert(bContext *C, Object *ob, const int mval[2], unsigned int *index, int size)
 {
+	EvaluationContext eval_ctx;
 	unsigned int poly_index;
 	Mesh *me = ob->data;
 
+	CTX_data_eval_ctx(C, &eval_ctx);
+
 	BLI_assert(me && GS(me->id.name) == ID_ME);
 
 	if (ED_mesh_pick_face(C, ob, mval, &poly_index, size)) {
@@ -1168,7 +1177,7 @@ bool ED_mesh_pick_face_vert(bContext *C, Object *ob, const int mval[2], unsigned
 		struct ARegion *ar = CTX_wm_region(C);
 
 		/* derived mesh to find deformed locations */
-		DerivedMesh *dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
+		DerivedMesh *dm = mesh_get_derived_final(&eval_ctx, scene, ob, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
 
 		int v_idx_best = ORIGINDEX_NONE;
 
@@ -1265,9 +1274,12 @@ static void ed_mesh_pick_vert__mapFunc(void *userData, int index, const float co
 }
 bool ED_mesh_pick_vert(bContext *C, Object *ob, const int mval[2], unsigned int *index, int size, bool use_zbuf)
 {
+	EvaluationContext eval_ctx;
 	ViewContext vc;
 	Mesh *me = ob->data;
 
+	CTX_data_eval_ctx(C, &eval_ctx);
+
 	BLI_assert(me && GS(me->id.name) == ID_ME);
 
 	if (!me || me->totvert == 0)
@@ -1281,11 +1293,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(&vc, mval, size, 1, me->totvert + 1, &dummy_dist);
+			*index = ED_view3d_backbuf_sample_rect(C, &vc, mval, size, 1, me->totvert + 1, &dummy_dist);
 		}
 		else {
 			/* sample only on the exact position */
-			*index = ED_view3d_backbuf_sample(&vc, mval[0], mval[1]);
+			*index = ED_view3d_backbuf_sample(C, &vc, mval[0], mval[1]);
 		}
 
 		if ((*index) == 0 || (*index) > (unsigned int)me->totvert)
@@ -1295,7 +1307,7 @@ bool ED_mesh_pick_vert(bContext *C, Object *ob, const int mval[2], unsigned int
 	}
 	else {
 		/* derived mesh to find deformed locations */
-		DerivedMesh *dm = mesh_get_derived_final(vc.scene, ob, CD_MASK_BAREMESH);
+		DerivedMesh *dm = mesh_get_derived_final(&eval_ctx, vc.scene, ob, CD_MASK_BAREMESH);
 		ARegion *ar = vc.ar;
 		RegionView3D *rv3d = ar->regiondata;