Transform: Support mixed snap in 3d View.

Allows more than one snap mode to be enabled. So different combinations are possible.

Reviewers: campbellbarton

Reviewed By: campbellbarton

Subscribers: Christopher_Anderssarian, duarteframos

Tags: #bf_blender_2.8

Differential Revision: D3400

10 files changed, 145 insertions, 160 deletions

diff --git a/source/blender/editors/curve/editcurve.c b/source/blender/editors/curve/editcurve.c
index 21131b2017d..fc6520a33f2 100644
--- a/source/blender/editors/curve/editcurve.c
+++ b/source/blender/editors/curve/editcurve.c
@@ -5015,9 +5015,9 @@ static int add_vertex_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 			struct SnapObjectContext *snap_context = ED_transform_snap_object_context_create_view3d(
 			        CTX_data_main(C), vc.scene, CTX_data_depsgraph(C), 0, vc.ar, vc.v3d);
 
-			ED_transform_snap_object_project_view3d_mixed(
+			ED_transform_snap_object_project_view3d(
 			        snap_context,
-			        SCE_SELECT_FACE,
+			        SCE_SNAP_MODE_FACE,
 			        &(const struct SnapObjectParams){
 			            .snap_select = (vc.obedit != NULL) ? SNAP_NOT_ACTIVE : SNAP_ALL,
 			            .use_object_edit_cage = false,
diff --git a/source/blender/editors/include/ED_transform_snap_object_context.h b/source/blender/editors/include/ED_transform_snap_object_context.h
index d65679e1872..8ac7dfcf9d8 100644
--- a/source/blender/editors/include/ED_transform_snap_object_context.h
+++ b/source/blender/editors/include/ED_transform_snap_object_context.h
@@ -128,12 +128,6 @@ bool ED_transform_snap_object_project_view3d(
         const float mval[2], float *dist_px,
         /* return args */
         float r_loc[3], float r_no[3]);
-bool ED_transform_snap_object_project_view3d_mixed(
-        SnapObjectContext *sctx,
-        const unsigned short snap_to_flag,
-        const struct SnapObjectParams *params,
-        const float mval_fl[2], float *dist_px,
-        float r_co[3], float r_no[3]);
 
 bool ED_transform_snap_object_project_all_view3d_ex(
         SnapObjectContext *sctx,
diff --git a/source/blender/editors/mesh/editmesh_tools.c b/source/blender/editors/mesh/editmesh_tools.c
index 8c6e7fed49b..8438375a97f 100644
--- a/source/blender/editors/mesh/editmesh_tools.c
+++ b/source/blender/editors/mesh/editmesh_tools.c
@@ -373,9 +373,9 @@ void EMBM_project_snap_verts(bContext *C, ARegion *ar, BMEditMesh *em)
 		if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
 			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(
+				if (ED_transform_snap_object_project_view3d(
 				        snap_context,
-				        SCE_SELECT_FACE,
+				        SCE_SNAP_MODE_FACE,
 				        &(const struct SnapObjectParams){
 				            .snap_select = SNAP_NOT_ACTIVE,
 				            .use_object_edit_cage = false,
diff --git a/source/blender/editors/space_view3d/view3d_manipulator_ruler.c b/source/blender/editors/space_view3d/view3d_manipulator_ruler.c
index f286db75129..909b5ed11ca 100644
--- a/source/blender/editors/space_view3d/view3d_manipulator_ruler.c
+++ b/source/blender/editors/space_view3d/view3d_manipulator_ruler.c
@@ -320,9 +320,9 @@ static bool view3d_ruler_item_mousemove(
 
 			co_other = ruler_item->co[inter->co_index == 0 ? 2 : 0];
 
-			if (ED_transform_snap_object_project_view3d_mixed(
+			if (ED_transform_snap_object_project_view3d(
 			        ruler_info->snap_context,
-			        SCE_SELECT_FACE,
+			        SCE_SNAP_MODE_FACE,
 			        &(const struct SnapObjectParams){
 			            .snap_select = SNAP_ALL,
 			            .use_object_edit_cage = true,
@@ -346,9 +346,9 @@ static bool view3d_ruler_item_mousemove(
 		else if (do_snap) {
 			const float mval_fl[2] = {UNPACK2(mval)};
 
-			if (ED_transform_snap_object_project_view3d_mixed(
+			if (ED_transform_snap_object_project_view3d(
 			        ruler_info->snap_context,
-			        (SCE_SELECT_VERTEX | SCE_SELECT_EDGE | SCE_SELECT_FACE),
+			        (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE),
 			        &(const struct SnapObjectParams){
 			            .snap_select = SNAP_ALL,
 			            .use_object_edit_cage = true,
diff --git a/source/blender/editors/space_view3d/view3d_ruler.c b/source/blender/editors/space_view3d/view3d_ruler.c
index a141814d767..5b616f29c60 100644
--- a/source/blender/editors/space_view3d/view3d_ruler.c
+++ b/source/blender/editors/space_view3d/view3d_ruler.c
@@ -761,9 +761,9 @@ static bool view3d_ruler_item_mousemove(
 
 			co_other = ruler_item->co[ruler_item->co_index == 0 ? 2 : 0];
 
-			if (ED_transform_snap_object_project_view3d_mixed(
+			if (ED_transform_snap_object_project_view3d(
 			        ruler_info->snap_context,
-			        SCE_SELECT_FACE,
+			        SCE_SNAP_MODE_FACE,
 			        &(const struct SnapObjectParams){
 			            .snap_select = SNAP_ALL,
 			            .use_object_edit_cage = true,
@@ -787,9 +787,9 @@ static bool view3d_ruler_item_mousemove(
 		else if (do_snap) {
 			const float mval_fl[2] = {UNPACK2(mval)};
 
-			if (ED_transform_snap_object_project_view3d_mixed(
+			if (ED_transform_snap_object_project_view3d(
 			        ruler_info->snap_context,
-			        (SCE_SELECT_VERTEX | SCE_SELECT_EDGE | SCE_SELECT_FACE),
+			        (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE),
 			        &(const struct SnapObjectParams){
 			            .snap_select = SNAP_ALL,
 			            .use_object_edit_cage = true,
diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c
index 318e21bb7c9..e20ef264a93 100644
--- a/source/blender/editors/transform/transform.c
+++ b/source/blender/editors/transform/transform.c
@@ -3007,7 +3007,7 @@ static void Bend(TransInfo *t, const int UNUSED(mval[2]))
 #else
 	/* hrmf, snapping radius is using 'angle' steps, need to convert to something else
 	 * this isnt essential but nicer to give reasonable snapping values for radius */
-	if (t->tsnap.mode == SCE_SNAP_MODE_INCREMENT) {
+	if (t->tsnap.mode & SCE_SNAP_MODE_INCREMENT) {
 		const float radius_snap = 0.1f;
 		const float snap_hack = (t->snap[1] * data->warp_init_dist) / radius_snap;
 		values.scale *= snap_hack;
diff --git a/source/blender/editors/transform/transform.h b/source/blender/editors/transform/transform.h
index c2751626523..2cf66794709 100644
--- a/source/blender/editors/transform/transform.h
+++ b/source/blender/editors/transform/transform.h
@@ -881,7 +881,6 @@ void projectVertSlideData(TransInfo *t, bool is_final);
 /* TODO. transform_queries.c */
 bool checkUseAxisMatrix(TransInfo *t);
 
-#define TRANSFORM_DIST_MAX_PX 1000.0f
 #define TRANSFORM_SNAP_MAX_PX 100.0f
 #define TRANSFORM_DIST_INVALID -FLT_MAX
 
diff --git a/source/blender/editors/transform/transform_constraints.c b/source/blender/editors/transform/transform_constraints.c
index a95d21b2f02..3c70eaae2d3 100644
--- a/source/blender/editors/transform/transform_constraints.c
+++ b/source/blender/editors/transform/transform_constraints.c
@@ -343,8 +343,7 @@ static void applyAxisConstraintVec(
 		mul_m3_v3(t->con.pmtx, out);
 
 		// With snap, a projection is alright, no need to correct for view alignment
-		if (!(!ELEM(t->tsnap.mode, SCE_SNAP_MODE_INCREMENT, SCE_SNAP_MODE_GRID) && activeSnap(t))) {
-
+		if (!validSnap(t)) {
 			const int dims = getConstraintSpaceDimension(t);
 			if (dims == 2) {
 				if (!is_zero_v3(out)) {
diff --git a/source/blender/editors/transform/transform_snap.c b/source/blender/editors/transform/transform_snap.c
index 948eb47965f..32ca32dcc9c 100644
--- a/source/blender/editors/transform/transform_snap.c
+++ b/source/blender/editors/transform/transform_snap.c
@@ -280,7 +280,6 @@ void applyProject(TransInfo *t)
 			for (i = 0; i < tc->data_len; i++, td++) {
 				float iloc[3], loc[3], no[3];
 				float mval_fl[2];
-				float dist_px = TRANSFORM_DIST_MAX_PX;
 
 				if (td->flag & TD_NOACTION)
 					break;
@@ -301,9 +300,15 @@ void applyProject(TransInfo *t)
 				}
 
 				if (ED_view3d_project_float_global(t->ar, iloc, mval_fl, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
-					if (snapObjectsTransform(
-					        t, mval_fl, &dist_px,
-					        loc, no))
+					if (ED_transform_snap_object_project_view3d(
+					        t->tsnap.object_context,
+					        SCE_SNAP_MODE_FACE,
+					        &(const struct SnapObjectParams){
+					            .snap_select = t->tsnap.modeSelect,
+					            .use_object_edit_cage = (t->flag & T_EDIT) != 0,
+					            .use_occlusion_test = false,
+					        },
+					        mval_fl, 0, loc, no))
 					{
 #if 0
 						if (tc->use_local_mat) {
@@ -346,7 +351,7 @@ void applyGridAbsolute(TransInfo *t)
 	GearsType grid_action;
 	int i;
 
-	if (!(activeSnap(t) && (ELEM(t->tsnap.mode, SCE_SNAP_MODE_INCREMENT, SCE_SNAP_MODE_GRID))))
+	if (!(activeSnap(t) && (t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID))))
 		return;
 
 	grid_action = BIG_GEARS;
@@ -401,16 +406,20 @@ void applyGridAbsolute(TransInfo *t)
 
 void applySnapping(TransInfo *t, float *vec)
 {
-	/* project is not applied this way */
-	if (t->tsnap.project)
+	if (t->tsnap.project && t->tsnap.mode == SCE_SNAP_MODE_FACE) {
+		/* Each Trans Data already makes the snap to face */
 		return;
+	}
 
 	if (t->tsnap.status & SNAP_FORCED) {
 		t->tsnap.targetSnap(t);
 
 		t->tsnap.applySnap(t, vec);
 	}
-	else if (!ELEM(t->tsnap.mode, SCE_SNAP_MODE_INCREMENT, SCE_SNAP_MODE_GRID) && activeSnap(t)) {
+	else if ((t->tsnap.mode &
+	        ~(SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID) != 0) &&
+	        activeSnap(t))
+	{
 		double current = PIL_check_seconds_timer();
 
 		// Time base quirky code to go around findnearest slowness
@@ -512,7 +521,7 @@ static void initSnappingMode(TransInfo *t)
 	}
 	else {
 		/* force project off when not supported */
-		if (ts->snap_mode != SCE_SNAP_MODE_FACE)
+		if ((ts->snap_mode & SCE_SNAP_MODE_FACE) == 0)
 			t->tsnap.project = 0;
 
 		t->tsnap.mode = ts->snap_mode;
@@ -948,18 +957,22 @@ static void CalcSnapGeometry(TransInfo *t, float *UNUSED(vec))
 		mval[0] = t->mval[0];
 		mval[1] = t->mval[1];
 
-		if (t->tsnap.mode == SCE_SNAP_MODE_VOLUME) {
-			found = peelObjectsTransform(
-			        t, mval,
-			        (t->settings->snap_flag & SCE_SNAP_PEEL_OBJECT) != 0,
-			        loc, no, NULL);
-		}
-		else {
+		if (t->tsnap.mode &
+		    (SCE_SNAP_MODE_VERTEX |
+		     SCE_SNAP_MODE_EDGE   |
+		     SCE_SNAP_MODE_FACE))
+		{
 			zero_v3(no);  /* objects won't set this */
 			found = snapObjectsTransform(
 			        t, mval, &dist_px,
 			        loc, no);
 		}
+		if ((found == false) && (t->tsnap.mode & SCE_SNAP_MODE_VOLUME)) {
+			found = peelObjectsTransform(
+			        t, mval,
+			        (t->settings->snap_flag & SCE_SNAP_PEEL_OBJECT) != 0,
+			        loc, no, NULL);
+		}
 
 		if (found == true) {
 			copy_v3_v3(t->tsnap.snapPoint, loc);
@@ -972,35 +985,38 @@ static void CalcSnapGeometry(TransInfo *t, float *UNUSED(vec))
 		}
 	}
 	else if (t->spacetype == SPACE_IMAGE && t->obedit_type == OB_MESH) {
-		/* same as above but for UV's */
-		Image *ima = ED_space_image(t->sa->spacedata.first);
-		float co[2];
+		if (t->tsnap.mode & SCE_SNAP_MODE_VERTEX) {
+			Image *ima = ED_space_image(t->sa->spacedata.first);
+			float co[2];
 
-		UI_view2d_region_to_view(&t->ar->v2d, t->mval[0], t->mval[1], &co[0], &co[1]);
+			UI_view2d_region_to_view(&t->ar->v2d, t->mval[0], t->mval[1], &co[0], &co[1]);
 
-		if (ED_uvedit_nearest_uv(t->scene, TRANS_DATA_CONTAINER_FIRST_EVIL(t)->obedit, ima, co, t->tsnap.snapPoint)) {
-			t->tsnap.snapPoint[0] *= t->aspect[0];
-			t->tsnap.snapPoint[1] *= t->aspect[1];
+			if (ED_uvedit_nearest_uv(t->scene, TRANS_DATA_CONTAINER_FIRST_EVIL(t)->obedit, ima, co, t->tsnap.snapPoint)) {
+				t->tsnap.snapPoint[0] *= t->aspect[0];
+				t->tsnap.snapPoint[1] *= t->aspect[1];
 
-			t->tsnap.status |=  POINT_INIT;
-		}
-		else {
-			t->tsnap.status &= ~POINT_INIT;
+				t->tsnap.status |= POINT_INIT;
+			}
+			else {
+				t->tsnap.status &= ~POINT_INIT;
+			}
 		}
 	}
 	else if (t->spacetype == SPACE_NODE) {
-		float loc[2];
-		float dist_px = SNAP_MIN_DISTANCE; // Use a user defined value here
-		char node_border;
+		if (t->tsnap.mode & (SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y)) {
+			float loc[2];
+			float dist_px = SNAP_MIN_DISTANCE; // Use a user defined value here
+			char node_border;
 
-		if (snapNodesTransform(t, t->mval, loc, &dist_px, &node_border)) {
-			copy_v2_v2(t->tsnap.snapPoint, loc);
-			t->tsnap.snapNodeBorder = node_border;
+			if (snapNodesTransform(t, t->mval, loc, &dist_px, &node_border)) {
+				copy_v2_v2(t->tsnap.snapPoint, loc);
+				t->tsnap.snapNodeBorder = node_border;
 
-			t->tsnap.status |=  POINT_INIT;
-		}
-		else {
-			t->tsnap.status &= ~POINT_INIT;
+				t->tsnap.status |= POINT_INIT;
+			}
+			else {
+				t->tsnap.status &= ~POINT_INIT;
+			}
 		}
 	}
 }
@@ -1309,15 +1325,14 @@ static bool snapNodeTest(View2D *v2d, bNode *node, eSnapSelect snap_select)
 
 static NodeBorder snapNodeBorder(int snap_node_mode)
 {
-	switch (snap_node_mode) {
-		case SCE_SNAP_MODE_NODE_X:
-			return NODE_LEFT | NODE_RIGHT;
-		case SCE_SNAP_MODE_NODE_Y:
-			return NODE_TOP | NODE_BOTTOM;
-		case SCE_SNAP_MODE_NODE_XY:
-			return NODE_LEFT | NODE_RIGHT | NODE_TOP | NODE_BOTTOM;
+	NodeBorder flag = 0;
+	if (snap_node_mode & SCE_SNAP_MODE_NODE_X) {
+		flag |= NODE_LEFT | NODE_RIGHT;
+	}
+	if (snap_node_mode & SCE_SNAP_MODE_NODE_Y) {
+		flag |= NODE_TOP | NODE_BOTTOM;
 	}
-	return 0;
+	return flag;
 }
 
 static bool snapNode(
@@ -1425,9 +1440,13 @@ void snapGridIncrement(TransInfo *t, float *val)
 {
 	GearsType action;
 
-	/* only do something if using absolute or incremental grid snapping */
-	if (!ELEM(t->tsnap.mode, SCE_SNAP_MODE_INCREMENT, SCE_SNAP_MODE_GRID))
+	/* only do something if using absolute or incremental grid snapping
+	 * and there is no valid snap point */
+	if (!(t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) ||
+	    validSnap(t))
+	{
 		return;
+	}
 
 	action = activeSnap(t) ? BIG_GEARS : NO_GEARS;
 
@@ -1467,7 +1486,7 @@ static void applyGridIncrement(TransInfo *t, float *val, int max_index, const fl
 	const float *asp = use_aspect ? t->aspect : asp_local;
 	int i;
 
-	BLI_assert(ELEM(t->tsnap.mode, SCE_SNAP_MODE_INCREMENT, SCE_SNAP_MODE_GRID));
+	BLI_assert(t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID));
 	BLI_assert(max_index <= 2);
 
 	/* Early bailing out if no need to snap */
diff --git a/source/blender/editors/transform/transform_snap_object.c b/source/blender/editors/transform/transform_snap_object.c
index 5b75e0d54a6..db1a6cc4240 100644
--- a/source/blender/editors/transform/transform_snap_object.c
+++ b/source/blender/editors/transform/transform_snap_object.c
@@ -1125,8 +1125,8 @@ static short snap_mesh_polygon(
 
 		MPoly *mp = &((Mesh *)ob->data)->mpoly[*r_index];
 		const MLoop *ml;
-		if (snapdata->snap_to_flag & SCE_SELECT_EDGE) {
-			elem = SCE_SELECT_EDGE;
+		if (snapdata->snap_to_flag & SCE_SNAP_MODE_EDGE) {
+			elem = SCE_SNAP_MODE_EDGE;
 			treedata->edge = ((Mesh *)ob->data)->medge;
 			ml = &treedata->loop[mp->loopstart];
 			for (int i = mp->totloop; i--; ml++) {
@@ -1137,7 +1137,7 @@ static short snap_mesh_polygon(
 			}
 		}
 		else {
-			elem = SCE_SELECT_VERTEX;
+			elem = SCE_SNAP_MODE_VERTEX;
 			ml = &treedata->loop[mp->loopstart];
 			for (int i = mp->totloop; i--; ml++) {
 				cb_snap_vert(
@@ -1160,8 +1160,8 @@ static short snap_mesh_polygon(
 		BMFace *f = BM_face_at_index(em->bm, *r_index);
 		BMLoop *l_iter, *l_first;
 		l_iter = l_first = BM_FACE_FIRST_LOOP(f);
-		if (snapdata->snap_to_flag & SCE_SELECT_EDGE) {
-			elem = SCE_SELECT_EDGE;
+		if (snapdata->snap_to_flag & SCE_SNAP_MODE_EDGE) {
+			elem = SCE_SNAP_MODE_EDGE;
 			BM_mesh_elem_table_ensure(em->bm, BM_VERT | BM_EDGE);
 			do {
 				cb_snap_edge(
@@ -1172,7 +1172,7 @@ static short snap_mesh_polygon(
 			} while ((l_iter = l_iter->next) != l_first);
 		}
 		else {
-			elem = SCE_SELECT_VERTEX;
+			elem = SCE_SNAP_MODE_VERTEX;
 			BM_mesh_elem_table_ensure(em->bm, BM_VERT);
 			do {
 				cb_snap_vert(
@@ -1218,7 +1218,7 @@ static short snap_mesh_edge_verts_mixed(
         /* return args */
         float r_loc[3], float r_no[3], int *r_index)
 {
-	short elem = SCE_SELECT_EDGE;
+	short elem = SCE_SNAP_MODE_EDGE;
 
 	if (ob->type != OB_MESH) {
 		return elem;
@@ -1282,7 +1282,7 @@ static short snap_mesh_edge_verts_mixed(
 		{
 			nearest.index = vindex[v_id];
 			nearest2d.copy_vert_no(vindex[v_id], nearest.no, nearest2d.userdata);
-			elem = SCE_SELECT_VERTEX;
+			elem = SCE_SNAP_MODE_VERTEX;
 		}
 	}
 
@@ -1319,7 +1319,7 @@ static short snapArmature(
 {
 	short retval = 0;
 
-	if (snapdata->snap_to_flag == SCE_SELECT_FACE) { /* Currently only edge and vert */
+	if (snapdata->snap_to_flag == SCE_SNAP_MODE_FACE) { /* Currently only edge and vert */
 		return retval;
 	}
 
@@ -1361,7 +1361,7 @@ static short snapArmature(
 				if ((eBone->flag & (BONE_HIDDEN_A | BONE_ROOTSEL | BONE_TIPSEL)) == 0) {
 					bool has_vert_snap = false;
 
-					if (snapdata->snap_to_flag & SCE_SELECT_VERTEX) {
+					if (snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX) {
 						has_vert_snap = test_projected_vert_dist(
 						        &neasrest_precalc,
 						        clip_planes_local, snapdata->clip_plane_len,
@@ -1372,17 +1372,17 @@ static short snapArmature(
 						        is_persp, eBone->tail, &dist_px_sq, r_loc);
 
 						if (has_vert_snap) {
-							retval = SCE_SELECT_VERTEX;
+							retval = SCE_SNAP_MODE_VERTEX;
 						}
 					}
-					if (!has_vert_snap && snapdata->snap_to_flag & SCE_SELECT_EDGE) {
+					if (!has_vert_snap && snapdata->snap_to_flag & SCE_SNAP_MODE_EDGE) {
 						if (test_projected_edge_dist(
 						        &neasrest_precalc,
 						        clip_planes_local, snapdata->clip_plane_len,
 						        is_persp, eBone->head, eBone->tail,
 						        &dist_px_sq, r_loc))
 						{
-							retval = SCE_SELECT_EDGE;
+							retval = SCE_SNAP_MODE_EDGE;
 						}
 					}
 				}
@@ -1398,7 +1398,7 @@ static short snapArmature(
 				const float *head_vec = pchan->pose_head;
 				const float *tail_vec = pchan->pose_tail;
 
-				if (snapdata->snap_to_flag & SCE_SELECT_VERTEX) {
+				if (snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX) {
 					has_vert_snap = test_projected_vert_dist(
 					        &neasrest_precalc,
 					        clip_planes_local, snapdata->clip_plane_len,
@@ -1409,17 +1409,17 @@ static short snapArmature(
 					        is_persp, tail_vec, &dist_px_sq, r_loc);
 
 					if (has_vert_snap) {
-						retval = SCE_SELECT_VERTEX;
+						retval = SCE_SNAP_MODE_VERTEX;
 					}
 				}
-				if (!has_vert_snap && snapdata->snap_to_flag & SCE_SELECT_EDGE) {
+				if (!has_vert_snap && snapdata->snap_to_flag & SCE_SNAP_MODE_EDGE) {
 					if (test_projected_edge_dist(
 					        &neasrest_precalc,
 					        clip_planes_local, snapdata->clip_plane_len,
 					        is_persp, head_vec, tail_vec,
 					        &dist_px_sq, r_loc))
 					{
-						retval = SCE_SELECT_EDGE;
+						retval = SCE_SNAP_MODE_EDGE;
 					}
 				}
 			}
@@ -1450,7 +1450,7 @@ static short snapCurve(
 	bool has_snap = false;
 
 	/* only vertex snapping mode (eg control points and handles) supported for now) */
-	if (snapdata->snap_to_flag != SCE_SELECT_VERTEX) {
+	if (snapdata->snap_to_flag != SCE_SNAP_MODE_VERTEX) {
 		return 0;
 	}
 
@@ -1489,7 +1489,7 @@ static short snapCurve(
 
 	for (Nurb *nu = (use_obedit ? cu->editnurb->nurbs.first : cu->nurb.first); nu; nu = nu->next) {
 		for (int u = 0; u < nu->pntsu; u++) {
-			if (snapdata->snap_to_flag & SCE_SELECT_VERTEX) {
+			if (snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX) {
 				if (use_obedit) {
 					if (nu->bezt) {
 						/* don't snap to selected (moving) or hidden */
@@ -1562,7 +1562,7 @@ static short snapCurve(
 			/* Does not support index yet. */
 			*r_index = -1;
 		}
-		return SCE_SELECT_VERTEX;
+		return SCE_SNAP_MODE_VERTEX;
 	}
 
 	return 0;
@@ -1584,7 +1584,7 @@ static short snapEmpty(
 	}
 
 	/* for now only vertex supported */
-	if (snapdata->snap_to_flag & SCE_SELECT_VERTEX) {
+	if (snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX) {
 		struct DistProjectedAABBPrecalc neasrest_precalc;
 		dist_squared_to_projected_aabb_precalc(
 		        &neasrest_precalc, snapdata->pmat, snapdata->win_size, snapdata->mval);
@@ -1605,7 +1605,7 @@ static short snapEmpty(
 		        is_persp, co, &dist_px_sq, r_loc))
 		{
 			*dist_px = sqrtf(dist_px_sq);
-			retval = SCE_SELECT_VERTEX;
+			retval = SCE_SNAP_MODE_VERTEX;
 		}
 	}
 
@@ -1659,7 +1659,7 @@ static short snapCamera(
 	invert_m4_m4(orig_camera_imat, orig_camera_mat);
 	invert_m4_m4(imat, obmat);
 
-	if (snapdata->snap_to_flag & SCE_SELECT_VERTEX) {
+	if (snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX) {
 		struct DistProjectedAABBPrecalc neasrest_precalc;
 		dist_squared_to_projected_aabb_precalc(
 		        &neasrest_precalc, snapdata->pmat, snapdata->win_size, snapdata->mval);
@@ -1704,7 +1704,7 @@ static short snapCamera(
 				        clip_planes_local, snapdata->clip_plane_len,
 				        is_persp, bundle_pos, &dist_px_sq, r_loc))
 				{
-					retval = SCE_SELECT_VERTEX;
+					retval = SCE_SNAP_MODE_VERTEX;
 				}
 			}
 		}
@@ -1730,9 +1730,9 @@ static short snapMesh(
         /* return args */
         float r_loc[3], float r_no[3], int *r_index)
 {
-	BLI_assert(snapdata->snap_to_flag != SCE_SELECT_FACE);
+	BLI_assert(snapdata->snap_to_flag != SCE_SNAP_MODE_FACE);
 
-	if ((snapdata->snap_to_flag & ~SCE_SELECT_FACE) == SCE_SELECT_EDGE) {
+	if ((snapdata->snap_to_flag & ~SCE_SNAP_MODE_FACE) == SCE_SNAP_MODE_EDGE) {
 		if (me->totedge == 0) {
 			return 0;
 		}
@@ -1822,7 +1822,7 @@ static short snapMesh(
 			treedata->edge_allocated = dummy_treedata.edge_allocated;
 		}
 	}
-	if (snapdata->snap_to_flag & SCE_SELECT_VERTEX) {
+	if (snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX) {
 		if (sod->has_loose_vert && bvhtree[1] == NULL) {
 			bvhtree[1] = BKE_bvhtree_from_mesh_get(&dummy_treedata, me, BVHTREE_FROM_LOOSEVERTS, 2);
 			sod->has_loose_vert = bvhtree[1] != NULL;
@@ -1871,7 +1871,7 @@ static short snapMesh(
 		.dist_sq = dist_px_sq,
 	};
 	int last_index = nearest.index;
-	short elem = SCE_SELECT_VERTEX;
+	short elem = SCE_SNAP_MODE_VERTEX;
 
 	float tobmat[4][4], clip_planes_local[MAX_CLIPPLANE_LEN][4];
 	transpose_m4_m4(tobmat, obmat);
@@ -1879,7 +1879,7 @@ static short snapMesh(
 		mul_v4_m4v4(clip_planes_local[i], tobmat, snapdata->clip_plane[i]);
 	}
 
-	if (bvhtree[1] && (snapdata->snap_to_flag & SCE_SELECT_VERTEX)) {
+	if (bvhtree[1] && (snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX)) {
 		/* snap to loose verts */
 		BLI_bvhtree_find_nearest_projected(
 		        bvhtree[1], lpmat, snapdata->win_size, snapdata->mval,
@@ -1889,7 +1889,7 @@ static short snapMesh(
 		last_index = nearest.index;
 	}
 
-	if (snapdata->snap_to_flag & SCE_SELECT_EDGE) {
+	if (snapdata->snap_to_flag & SCE_SNAP_MODE_EDGE) {
 		if (bvhtree[0]) {
 			/* snap to loose edges */
 			BLI_bvhtree_find_nearest_projected(
@@ -1907,11 +1907,11 @@ static short snapMesh(
 		}
 
 		if (last_index != nearest.index) {
-			elem = SCE_SELECT_EDGE;
+			elem = SCE_SNAP_MODE_EDGE;
 		}
 	}
 	else {
-		BLI_assert(snapdata->snap_to_flag & SCE_SELECT_VERTEX);
+		BLI_assert(snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX);
 		if (bvhtree[0]) {
 			/* snap to loose edges */
 			BLI_bvhtree_find_nearest_projected(
@@ -1961,9 +1961,9 @@ static short snapEditMesh(
         /* return args */
         float r_loc[3], float r_no[3], int *r_index)
 {
-	BLI_assert(snapdata->snap_to_flag != SCE_SELECT_FACE);
+	BLI_assert(snapdata->snap_to_flag != SCE_SNAP_MODE_FACE);
 
-	if ((snapdata->snap_to_flag & ~SCE_SELECT_FACE) == SCE_SELECT_EDGE) {
+	if ((snapdata->snap_to_flag & ~SCE_SNAP_MODE_FACE) == SCE_SNAP_MODE_EDGE) {
 		if (em->bm->totedge == 0) {
 			return 0;
 		}
@@ -1986,7 +1986,7 @@ static short snapEditMesh(
 		sod->sd.type = SNAP_EDIT_MESH;
 	}
 
-	if (snapdata->snap_to_flag & SCE_SELECT_VERTEX) {
+	if (snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX) {
 		if (sod->bvh_trees[0] == NULL) {
 			sod->bvh_trees[0] = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(**sod->bvh_trees));
 		}
@@ -2006,7 +2006,7 @@ static short snapEditMesh(
 		}
 	}
 
-	if (snapdata->snap_to_flag & SCE_SELECT_EDGE) {
+	if (snapdata->snap_to_flag & SCE_SNAP_MODE_EDGE) {
 		if (sod->bvh_trees[1] == NULL) {
 			sod->bvh_trees[1] = BLI_memarena_calloc(sctx->cache.mem_arena, sizeof(**sod->bvh_trees));
 		}
@@ -2040,7 +2040,7 @@ static short snapEditMesh(
 		.dist_sq = SQUARE(*dist_px),
 	};
 	int last_index = nearest.index;
-	short elem = SCE_SELECT_VERTEX;
+	short elem = SCE_SNAP_MODE_VERTEX;
 
 	float lpmat[4][4], tobmat[4][4], clip_planes_local[MAX_CLIPPLANE_LEN][4];
 	mul_m4_m4m4(lpmat, snapdata->pmat, obmat);
@@ -2050,7 +2050,7 @@ static short snapEditMesh(
 		mul_v4_m4v4(clip_planes_local[i], tobmat, snapdata->clip_plane[i]);
 	}
 
-	if (treedata_vert && snapdata->snap_to_flag & SCE_SELECT_VERTEX) {
+	if (treedata_vert && snapdata->snap_to_flag & SCE_SNAP_MODE_VERTEX) {
 		BM_mesh_elem_table_ensure(em->bm, BM_VERT);
 		BLI_bvhtree_find_nearest_projected(
 		        treedata_vert->tree, lpmat, snapdata->win_size, snapdata->mval,
@@ -2060,7 +2060,7 @@ static short snapEditMesh(
 		last_index = nearest.index;
 	}
 
-	if (treedata_edge && snapdata->snap_to_flag & SCE_SELECT_EDGE) {
+	if (treedata_edge && snapdata->snap_to_flag & SCE_SNAP_MODE_EDGE) {
 		BM_mesh_elem_table_ensure(em->bm, BM_EDGE | BM_VERT);
 		BLI_bvhtree_find_nearest_projected(
 		        treedata_edge->tree, lpmat, snapdata->win_size, snapdata->mval,
@@ -2068,7 +2068,7 @@ static short snapEditMesh(
 		        &nearest, cb_snap_edge, &nearest2d);
 
 		if (last_index != nearest.index) {
-			elem = SCE_SELECT_EDGE;
+			elem = SCE_SNAP_MODE_EDGE;
 		}
 	}
 
@@ -2448,8 +2448,11 @@ static short transform_snap_context_project_view3d_mixed_impl(
         float r_loc[3], float r_no[3], int *r_index,
         Object **r_ob, float r_obmat[4][4])
 {
-	BLI_assert(snap_to_flag != 0);
-	BLI_assert((snap_to_flag & ~(1 | 2 | 4)) == 0);
+	BLI_assert(
+	        (snap_to_flag & (
+	        SCE_SNAP_MODE_VERTEX |
+	        SCE_SNAP_MODE_EDGE   |
+	        SCE_SNAP_MODE_FACE)) != 0);
 
 	short retval = 0;
 	bool has_hit = false;
@@ -2461,7 +2464,7 @@ static short transform_snap_context_project_view3d_mixed_impl(
 	const ARegion *ar = sctx->v3d_data.ar;
 	const RegionView3D *rv3d = ar->regiondata;
 
-	if (snap_to_flag & SCE_SELECT_FACE || params->use_occlusion_test) {
+	if (snap_to_flag & SCE_SNAP_MODE_FACE || params->use_occlusion_test) {
 		float ray_start[3], ray_normal[3];
 
 		if (!ED_view3d_win_to_ray_ex(
@@ -2480,12 +2483,12 @@ static short transform_snap_context_project_view3d_mixed_impl(
 		        &dummy_ray_depth, loc, no,
 		        &index, &ob, obmat, NULL);
 
-		if (has_hit && (snap_to_flag & SCE_SELECT_FACE)) {
-			retval = SCE_SELECT_FACE;
+		if (has_hit && (snap_to_flag & SCE_SNAP_MODE_FACE)) {
+			retval = SCE_SNAP_MODE_FACE;
 		}
 	}
 
-	if (snap_to_flag & (SCE_SELECT_VERTEX | SCE_SELECT_EDGE)) {
+	if (snap_to_flag & (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE)) {
 		short elem;
 		float dist_px_tmp = *dist_px;
 
@@ -2534,8 +2537,8 @@ static short transform_snap_context_project_view3d_mixed_impl(
 			retval = elem;
 		}
 
-		if ((retval == SCE_SELECT_EDGE) &&
-		    (snapdata.snap_to_flag & SCE_SELECT_VERTEX))
+		if ((retval == SCE_SNAP_MODE_EDGE) &&
+		    (snapdata.snap_to_flag & SCE_SNAP_MODE_VERTEX))
 		{
 			retval = snap_mesh_edge_verts_mixed(
 			        sctx, &snapdata,
@@ -2566,32 +2569,6 @@ static short transform_snap_context_project_view3d_mixed_impl(
 	return 0;
 }
 
-/**
- * Convenience function for performing snapping.
- *
- * Given a 2D region value, snap to vert/edge/face.
- *
- * \param sctx: Snap context.
- * \param mval_fl: Screenspace coordinate.
- * \param dist_px: Maximum distance to snap (in pixels).
- * \param r_co: hit location.
- * \param r_no: hit normal (optional).
- * \return Snap success
- */
-bool ED_transform_snap_object_project_view3d_mixed(
-        SnapObjectContext *sctx,
-        const unsigned short snap_to_flag,
-        const struct SnapObjectParams *params,
-        const float mval_fl[2], float *dist_px,
-        float r_co[3], float r_no[3])
-{
-	return transform_snap_context_project_view3d_mixed_impl(
-	        sctx,
-	        snap_to_flag, params,
-	        mval_fl, dist_px,
-	        r_co, r_no, NULL, NULL, NULL) != 0;
-}
-
 bool ED_transform_snap_object_project_view3d_ex(
         SnapObjectContext *sctx,
         const unsigned short snap_to,
@@ -2600,28 +2577,25 @@ bool ED_transform_snap_object_project_view3d_ex(
         float r_loc[3], float r_no[3], int *r_index,
         Object **r_ob, float r_obmat[4][4])
 {
-	short snap_to_flag;
-	switch (snap_to) {
-		case SCE_SNAP_MODE_FACE:
-			snap_to_flag = SCE_SELECT_FACE;
-			break;
-		case SCE_SNAP_MODE_VERTEX:
-			snap_to_flag = SCE_SELECT_VERTEX;
-			break;
-		case SCE_SNAP_MODE_EDGE:
-			snap_to_flag = SCE_SELECT_EDGE;
-			break;
-		default:
-			return false;
-	}
-
 	return transform_snap_context_project_view3d_mixed_impl(
 	        sctx,
-	        snap_to_flag, params,
+	        snap_to, params,
 	        mval, dist_px,
 	        r_loc, r_no, r_index, r_ob, r_obmat) != 0;
 }
 
+/**
+ * Convenience function for performing snapping.
+ *
+ * Given a 2D region value, snap to vert/edge/face.
+ *
+ * \param sctx: Snap context.
+ * \param mval_fl: Screenspace coordinate.
+ * \param dist_px: Maximum distance to snap (in pixels).
+ * \param r_co: hit location.
+ * \param r_no: hit normal (optional).
+ * \return Snap success
+ */
 bool ED_transform_snap_object_project_view3d(
         SnapObjectContext *sctx,
         const unsigned short snap_to,