Merge branch 'master' into texture_nodes_refactortexture_nodes_refactor

Conflicts:
	source/blender/nodes/texture/nodes/node_texture_math.c

1 files changed, 272 insertions, 132 deletions

diff --git a/source/blender/editors/mesh/editmesh_knife.c b/source/blender/editors/mesh/editmesh_knife.c
index f5a7e82a8a8..e9b4e32c39e 100644
--- a/source/blender/editors/mesh/editmesh_knife.c
+++ b/source/blender/editors/mesh/editmesh_knife.c
@@ -97,7 +97,7 @@ typedef struct KnifeVert {
 
 	float co[3], cageco[3], sco[2]; /* sco is screen coordinates for cageco */
 	bool is_face, in_space;
-	bool draw;
+	bool is_cut;  /* along a cut created by user input (will draw too) */
 } KnifeVert;
 
 typedef struct Ref {
@@ -111,7 +111,7 @@ typedef struct KnifeEdge {
 	ListBase faces;
 
 	BMEdge *e /* , *e_old */; /* non-NULL if this is an original edge */
-	bool draw;
+	bool is_cut;  /* along a cut created by user input (will draw too) */
 } KnifeEdge;
 
 typedef struct KnifeLineHit {
@@ -174,8 +174,10 @@ typedef struct KnifeTool_OpData {
 	KnifeLineHit *linehits;
 	int totlinehit;
 
-	/* Data for mouse-position-derived data (cur) and previous click (prev) */
-	KnifePosData curr, prev;
+	/* Data for mouse-position-derived data */
+	KnifePosData curr;  /* current point under the cursor */
+	KnifePosData prev;  /* last added cut (a line draws from the cursor to this) */
+	KnifePosData init;  /* the first point in the cut-list, used for closing the loop */
 
 	int totkedge, totkvert;
 
@@ -206,6 +208,7 @@ typedef struct KnifeTool_OpData {
 		MODE_CONNECT,
 		MODE_PANNING
 	} mode;
+	bool is_drag_hold;
 
 	int prevmode;
 	bool snap_midpoints;
@@ -526,7 +529,7 @@ static KnifeVert *knife_split_edge(
 
 	newkfe->v1 = kfe->v1;
 	newkfe->v2 = new_knife_vert(kcd, co, cageco);
-	newkfe->v2->draw = 1;
+	newkfe->v2->is_cut = true;
 	if (kfe->e) {
 		knife_add_edge_faces_to_vert(kcd, newkfe->v2, kfe->e);
 	}
@@ -551,7 +554,7 @@ static KnifeVert *knife_split_edge(
 
 	knife_add_to_vert_edges(kcd, newkfe);
 
-	newkfe->draw = kfe->draw;
+	newkfe->is_cut = kfe->is_cut;
 	newkfe->e = kfe->e;
 
 	*r_kfe = newkfe;
@@ -559,6 +562,16 @@ static KnifeVert *knife_split_edge(
 	return newkfe->v2;
 }
 
+static void linehit_to_knifepos(KnifePosData *kpos, KnifeLineHit *lh)
+{
+	kpos->bmface = lh->f;
+	kpos->vert = lh->v;
+	kpos->edge = lh->kfe;
+	copy_v3_v3(kpos->cage, lh->cagehit);
+	copy_v3_v3(kpos->co, lh->hit);
+	copy_v2_v2(kpos->mval, lh->schit);
+}
+
 /* primary key: lambda along cut
  * secondary key: lambda along depth
  * tertiary key: pointer comparisons of verts if both snapped to verts
@@ -590,6 +603,7 @@ static void prepare_linehits_for_cut(KnifeTool_OpData *kcd)
 {
 	KnifeLineHit *linehits, *lhi, *lhj;
 	int i, j, n;
+	bool is_double = false;
 
 	n = kcd->totlinehit;
 	linehits = kcd->linehits;
@@ -613,7 +627,11 @@ static void prepare_linehits_for_cut(KnifeTool_OpData *kcd)
 				{
 					break;
 				}
-				lhj->l = -1.0f;
+
+				if (lhi->kfe == lhj->kfe) {
+					lhj->l = -1.0f;
+					is_double = true;
+				}
 			}
 			for (j = i + 1; j < n; j++) {
 				lhj = &linehits[j];
@@ -622,37 +640,42 @@ static void prepare_linehits_for_cut(KnifeTool_OpData *kcd)
 				{
 					break;
 				}
-				if (lhj->kfe || lhi->v == lhj->v) {
+				if ((lhj->kfe && (lhi->kfe == lhj->kfe)) ||
+				    (lhi->v == lhj->v))
+				{
 					lhj->l = -1.0f;
+					is_double = true;
 				}
 			}
 		}
 	}
 
-	/* delete-in-place loop: copying from pos j to pos i+1 */
-	i = 0;
-	j = 1;
-	while (j < n) {
-		lhi = &linehits[i];
-		lhj = &linehits[j];
-		if (lhj->l == -1.0f) {
-			j++; /* skip copying this one */
-		}
-		else {
-			/* copy unless a no-op */
-			if (lhi->l == -1.0f) {
-				/* could happen if linehits[0] is being deleted */
-				memcpy(&linehits[i], &linehits[j], sizeof(KnifeLineHit));
+	if (is_double) {
+		/* delete-in-place loop: copying from pos j to pos i+1 */
+		i = 0;
+		j = 1;
+		while (j < n) {
+			lhi = &linehits[i];
+			lhj = &linehits[j];
+			if (lhj->l == -1.0f) {
+				j++; /* skip copying this one */
 			}
 			else {
-				if (i + 1 != j)
-					memcpy(&linehits[i + 1], &linehits[j], sizeof(KnifeLineHit));
-				i++;
+				/* copy unless a no-op */
+				if (lhi->l == -1.0f) {
+					/* could happen if linehits[0] is being deleted */
+					memcpy(&linehits[i], &linehits[j], sizeof(KnifeLineHit));
+				}
+				else {
+					if (i + 1 != j)
+						memcpy(&linehits[i + 1], &linehits[j], sizeof(KnifeLineHit));
+					i++;
+				}
+				j++;
 			}
-			j++;
 		}
+		kcd->totlinehit = i + 1;
 	}
-	kcd->totlinehit = i + 1;
 }
 
 /* Add hit to list of hits in facehits[f], where facehits is a map, if not already there */
@@ -670,6 +693,7 @@ static void add_hit_to_facehits(KnifeTool_OpData *kcd, GHash *facehits, BMFace *
 static void knife_add_single_cut(KnifeTool_OpData *kcd, KnifeLineHit *lh1, KnifeLineHit *lh2, BMFace *f)
 {
 	KnifeEdge *kfe, *kfe2;
+	BMEdge *e_base;
 
 	if ((lh1->v && lh1->v == lh2->v) ||
 	    (lh1->kfe && lh1->kfe == lh2->kfe))
@@ -677,15 +701,25 @@ static void knife_add_single_cut(KnifeTool_OpData *kcd, KnifeLineHit *lh1, Knife
 		return;
 	}
 
+	/* if the cut is on an edge, just tag that its a cut and return */
+	if ((lh1->v && lh2->v) &&
+	    (lh1->v->v && lh2->v && lh2->v->v) &&
+	    (e_base = BM_edge_exists(lh1->v->v, lh2->v->v)))
+	{
+		kfe = get_bm_knife_edge(kcd, e_base);
+		kfe->is_cut = true;
+		kfe->e = e_base;
+		return;
+	}
 	/* Check if edge actually lies within face (might not, if this face is concave) */
-	if ((lh1->v && !lh1->kfe) && (lh2->v && !lh2->kfe)) {
+	else if ((lh1->v && !lh1->kfe) && (lh2->v && !lh2->kfe)) {
 		if (!knife_verts_edge_in_face(lh1->v, lh2->v, f)) {
 			return;
 		}
 	}
 
 	kfe = new_knife_edge(kcd);
-	kfe->draw = true;
+	kfe->is_cut = true;
 	kfe->basef = f;
 
 	if (lh1->v) {
@@ -698,7 +732,7 @@ static void knife_add_single_cut(KnifeTool_OpData *kcd, KnifeLineHit *lh1, Knife
 	else {
 		BLI_assert(lh1->f);
 		kfe->v1 = new_knife_vert(kcd, lh1->hit, lh1->cagehit);
-		kfe->v1->draw = true;
+		kfe->v1->is_cut = true;
 		kfe->v1->is_face = true;
 		knife_append_list(kcd, &kfe->v1->faces, lh1->f);
 		lh1->v = kfe->v1;  /* record the KnifeVert for this hit */
@@ -714,7 +748,7 @@ static void knife_add_single_cut(KnifeTool_OpData *kcd, KnifeLineHit *lh1, Knife
 	else {
 		BLI_assert(lh2->f);
 		kfe->v2 = new_knife_vert(kcd, lh2->hit, lh2->cagehit);
-		kfe->v2->draw = true;
+		kfe->v2->is_cut = true;
 		kfe->v2->is_face = true;
 		knife_append_list(kcd, &kfe->v2->faces, lh2->f);
 		lh2->v = kfe->v2;  /* record the KnifeVert for this hit */
@@ -735,23 +769,13 @@ static void knife_add_single_cut(KnifeTool_OpData *kcd, KnifeLineHit *lh1, Knife
 static void knife_cut_face(KnifeTool_OpData *kcd, BMFace *f, ListBase *hits)
 {
 	Ref *r;
-	KnifeLineHit *lh, *prevlh;
-	int n;
 
-	(void) kcd;
-
-	n = BLI_countlist(hits);
-	if (n < 2)
+	if (BLI_listbase_count_ex(hits, 2) != 2)
 		return;
 
-	prevlh = NULL;
-	for (r = hits->first; r; r = r->next) {
-		lh = (KnifeLineHit *)r->ref;
-		if (prevlh)
-			knife_add_single_cut(kcd, prevlh, lh, f);
-		prevlh = lh;
+	for (r = hits->first; r->next; r = r->next) {
+		knife_add_single_cut(kcd, r->ref, r->next->ref, f);
 	}
-
 }
 
 /* User has just left-clicked after the first time.
@@ -771,7 +795,9 @@ static void knife_add_cut(KnifeTool_OpData *kcd)
 
 	prepare_linehits_for_cut(kcd);
 	if (kcd->totlinehit == 0) {
-		kcd->prev = kcd->curr;
+		if (kcd->is_drag_hold == false) {
+			kcd->prev = kcd->curr;
+		}
 		return;
 	}
 
@@ -806,10 +832,20 @@ static void knife_add_cut(KnifeTool_OpData *kcd)
 
 	/* set up for next cut */
 	kcd->prev = kcd->curr;
+
+
 	if (kcd->prev.bmface) {
+		KnifeLineHit *lh;
 		/* was "in face" but now we have a KnifeVert it is snapped to */
+		lh = &kcd->linehits[kcd->totlinehit - 1];
+
+		if (kcd->is_drag_hold) {
+			linehit_to_knifepos(&kcd->prev, lh);
+		}
+		else {
+			kcd->prev.vert = lh->v;
+		}
 		kcd->prev.bmface = NULL;
-		kcd->prev.vert = kcd->linehits[kcd->totlinehit - 1].v;
 	}
 
 	BLI_ghash_free(facehits, NULL, NULL);
@@ -1055,7 +1091,7 @@ static void knifetool_draw(const bContext *C, ARegion *UNUSED(ar), void *arg)
 
 		BLI_mempool_iternew(kcd->kedges, &iter);
 		for (kfe = BLI_mempool_iterstep(&iter); kfe; kfe = BLI_mempool_iterstep(&iter)) {
-			if (!kfe->draw)
+			if (!kfe->is_cut)
 				continue;
 
 			glColor3ubv(kcd->colors.line);
@@ -1077,7 +1113,7 @@ static void knifetool_draw(const bContext *C, ARegion *UNUSED(ar), void *arg)
 		glBegin(GL_POINTS);
 		BLI_mempool_iternew(kcd->kverts, &iter);
 		for (kfv = BLI_mempool_iterstep(&iter); kfv; kfv = BLI_mempool_iterstep(&iter)) {
-			if (!kfv->draw)
+			if (!kfv->is_cut)
 				continue;
 
 			glColor3ubv(kcd->colors.point);
@@ -1274,6 +1310,7 @@ static void knife_find_line_hits(KnifeTool_OpData *kcd)
 	SmallHashIter hiter;
 	KnifeLineHit hit;
 	void *val;
+	void **val_p;
 	float plane_cos[12];
 	float s[2], se1[2], se2[2], sint[2];
 	float r1[3], r2[3];
@@ -1281,10 +1318,12 @@ static void knife_find_line_hits(KnifeTool_OpData *kcd)
 	float vert_tol, vert_tol_sq;
 	float line_tol, line_tol_sq;
 	float face_tol, face_tol_sq;
-	float eps_scale;
+	float eps_scale, eps_scale_px;
 	int isect_kind;
 	unsigned int tot;
 	int i;
+	const bool use_hit_prev = true;
+	const bool use_hit_curr = (kcd->is_drag_hold == false);
 
 	bgl_get_mats(&mats);
 
@@ -1360,6 +1399,11 @@ static void knife_find_line_hits(KnifeTool_OpData *kcd)
 		ls = (BMLoop **)kcd->em->looptris[result->indexA];
 		f = ls[0]->f;
 		set_lowest_face_tri(kcd, f, result->indexA);
+
+		/* occlude but never cut unselected faces (when only_select is used) */
+		if (kcd->only_select && !BM_elem_flag_test(f, BM_ELEM_SELECT)) {
+			continue;
+		}
 		/* for faces, store index of lowest hit looptri in hash */
 		if (BLI_smallhash_haskey(&faces, (uintptr_t)f)) {
 			continue;
@@ -1374,11 +1418,9 @@ static void knife_find_line_hits(KnifeTool_OpData *kcd)
 				continue;
 			BLI_smallhash_insert(&kfes, (uintptr_t)kfe, kfe);
 			v = kfe->v1;
-			if (!BLI_smallhash_haskey(&kfvs, (uintptr_t)v))
-				BLI_smallhash_insert(&kfvs, (uintptr_t)v, v);
+			BLI_smallhash_reinsert(&kfvs, (uintptr_t)v, v);
 			v = kfe->v2;
-			if (!BLI_smallhash_haskey(&kfvs, (uintptr_t)v))
-				BLI_smallhash_insert(&kfvs, (uintptr_t)v, v);
+			BLI_smallhash_reinsert(&kfvs, (uintptr_t)v, v);
 		}
 	}
 
@@ -1387,13 +1429,15 @@ static void knife_find_line_hits(KnifeTool_OpData *kcd)
 	{
 		/* Scale the epsilon by the zoom level
 		 * to compensate for projection imprecision, see T41164 */
-		float zoom_xy[2] = {kcd->vc.rv3d->winmat[0][0],
-		                    kcd->vc.rv3d->winmat[1][1]};
+		const float zoom_xy[2] = {
+		        kcd->vc.rv3d->winmat[0][0],
+		        kcd->vc.rv3d->winmat[1][1]};
 		eps_scale = len_v2(zoom_xy);
+		eps_scale_px = eps_scale * (kcd->is_interactive ? KNIFE_FLT_EPS_PX : KNIFE_FLT_EPSBIG);
 	}
 
-	vert_tol = KNIFE_FLT_EPS_PX * eps_scale;
-	line_tol = KNIFE_FLT_EPS_PX * eps_scale;
+	vert_tol = eps_scale_px;
+	line_tol = eps_scale_px;
 	face_tol = max_ff(vert_tol, line_tol);
 
 	vert_tol_sq = vert_tol * vert_tol;
@@ -1403,30 +1447,59 @@ static void knife_find_line_hits(KnifeTool_OpData *kcd)
 	/* Assume these tolerances swamp floating point rounding errors in calculations below */
 
 	/* first look for vertex hits */
-	for (val = BLI_smallhash_iternew(&kfvs, &hiter, (uintptr_t *)&v); val;
-	     val = BLI_smallhash_iternext(&hiter, (uintptr_t *)&v))
+	for (val_p = BLI_smallhash_iternew_p(&kfvs, &hiter, (uintptr_t *)&v); val_p;
+	     val_p = BLI_smallhash_iternext_p(&hiter, (uintptr_t *)&v))
 	{
 		knife_project_v2(kcd, v->cageco, s);
 		d = dist_squared_to_line_segment_v2(s, s1, s2);
-		if (d <= vert_tol_sq) {
-			if (point_is_visible(kcd, v->cageco, s, &mats)) {
-				memset(&hit, 0, sizeof(hit));
-				hit.v = v;
-				copy_v3_v3(hit.hit, v->co);
-				copy_v3_v3(hit.cagehit, v->cageco);
-				copy_v2_v2(hit.schit, s);
-				set_linehit_depth(kcd, &hit);
-				BLI_array_append(linehits, hit);
+		if ((d <= vert_tol_sq) &&
+		    point_is_visible(kcd, v->cageco, s, &mats))
+		{
+			memset(&hit, 0, sizeof(hit));
+			hit.v = v;
+
+			/* If this isn't from an existing BMVert, it may have been added to a BMEdge originally.
+			 * knowing if the hit comes from an edge is important for edge-in-face checks later on
+			 * see: #knife_add_single_cut -> #knife_verts_edge_in_face, T42611 */
+			if (v->v == NULL) {
+				for (ref = v->edges.first; ref; ref = ref->next) {
+					kfe = ref->ref;
+					if (kfe->e) {
+						hit.kfe = kfe;
+						break;
+					}
+				}
 			}
+
+			copy_v3_v3(hit.hit, v->co);
+			copy_v3_v3(hit.cagehit, v->cageco);
+			copy_v2_v2(hit.schit, s);
+			set_linehit_depth(kcd, &hit);
+			BLI_array_append(linehits, hit);
+		}
+		else {
+			/* note that these vertes aren't used */
+			*val_p = NULL;
 		}
 	}
+
 	/* now edge hits; don't add if a vertex at end of edge should have hit */
 	for (val = BLI_smallhash_iternew(&kfes, &hiter, (uintptr_t *)&kfe); val;
 	     val = BLI_smallhash_iternext(&hiter, (uintptr_t *)&kfe))
 	{
+		int kfe_verts_in_cut;
+		/* if we intersect both verts, don't attempt to intersect the edge */
+
+		kfe_verts_in_cut = (BLI_smallhash_lookup(&kfvs, (intptr_t)kfe->v1) != NULL) +
+		                   (BLI_smallhash_lookup(&kfvs, (intptr_t)kfe->v2) != NULL);
+
+		if (kfe_verts_in_cut == 2) {
+			continue;
+		}
+
 		knife_project_v2(kcd, kfe->v1->cageco, se1);
 		knife_project_v2(kcd, kfe->v2->cageco, se2);
-		isect_kind = isect_seg_seg_v2_point(s1, s2, se1, se2, sint);
+		isect_kind = (kfe_verts_in_cut) ? -1 : isect_seg_seg_v2_point(s1, s2, se1, se2, sint);
 		if (isect_kind == -1) {
 			/* isect_seg_seg_v2 doesn't do tolerance test around ends of s1-s2 */
 			closest_to_line_segment_v2(sint, s1, se1, se2);
@@ -1477,7 +1550,7 @@ static void knife_find_line_hits(KnifeTool_OpData *kcd)
 	{
 		float p[3], p_cage[3];
 
-		if (knife_ray_intersect_face(kcd, s1, v1, v3, f, face_tol_sq, p, p_cage)) {
+		if (use_hit_prev && knife_ray_intersect_face(kcd, s1, v1, v3, f, face_tol_sq, p, p_cage)) {
 			if (point_is_visible(kcd, p_cage, s1, &mats)) {
 				memset(&hit, 0, sizeof(hit));
 				hit.f = f;
@@ -1488,7 +1561,8 @@ static void knife_find_line_hits(KnifeTool_OpData *kcd)
 				BLI_array_append(linehits, hit);
 			}
 		}
-		if (knife_ray_intersect_face(kcd, s2, v2, v4, f, face_tol_sq, p, p_cage)) {
+
+		if (use_hit_curr && knife_ray_intersect_face(kcd, s2, v2, v4, f, face_tol_sq, p, p_cage)) {
 			if (point_is_visible(kcd, p_cage, s2, &mats)) {
 				memset(&hit, 0, sizeof(hit));
 				hit.f = f;
@@ -1551,6 +1625,10 @@ static BMFace *knife_find_closest_face(KnifeTool_OpData *kcd, float co[3], float
 
 	f = BKE_bmbvh_ray_cast(kcd->bmbvh, origin, ray, 0.0f, NULL, co, cageco);
 
+	if (f && kcd->only_select && BM_elem_flag_test(f, BM_ELEM_SELECT) == 0) {
+		f = NULL;
+	}
+
 	if (is_space)
 		*is_space = !f;
 
@@ -1913,7 +1991,10 @@ static int knife_update_active(KnifeTool_OpData *kcd)
 
 	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) {
+	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.bmface, &kcd->curr.is_space);
 	}
@@ -2063,7 +2144,7 @@ static ListBase *find_chain(KnifeTool_OpData *kcd, ListBase *fedges)
 			break;
 	}
 	if (ans) {
-		BLI_assert(BLI_countlist(ans) > 0);
+		BLI_assert(!BLI_listbase_is_empty(ans));
 		for (r = ans->first; r; r = r->next) {
 			ref = find_ref(fedges, r->ref);
 			BLI_assert(ref != NULL);
@@ -2171,7 +2252,7 @@ static bool find_hole_chains(KnifeTool_OpData *kcd, ListBase *hole, BMFace *f, L
 	int besti[2], bestj[2];
 	float dist_sq, dist_best_sq;
 
-	nh = BLI_countlist(hole);
+	nh = BLI_listbase_count(hole);
 	nf = f->len;
 	if (nh < 2 || nf < 3)
 		return false;
@@ -2300,13 +2381,22 @@ static bool knife_verts_edge_in_face(KnifeVert *v1, KnifeVert *v2, BMFace *f)
 {
 	bool v1_inside, v2_inside;
 	bool v1_inface, v2_inface;
+	BMLoop *l1, *l2;
 
 	if (!f || !v1 || !v2)
 		return false;
 
+	l1 = v1->v ? BM_face_vert_share_loop(f, v1->v) : NULL;
+	l2 = v2->v ? BM_face_vert_share_loop(f, v2->v) : NULL;
+
+	if ((l1 && l2) && BM_loop_is_adjacent(l1, l2)) {
+		/* boundary-case, always false to avoid edge-in-face checks below */
+		return false;
+	}
+
 	/* find out if v1 and v2, if set, are part of the face */
-	v1_inface = v1->v ? BM_vert_in_face(f, v1->v) : false;
-	v2_inface = v2->v ? BM_vert_in_face(f, v2->v) : false;
+	v1_inface = (l1 != NULL);
+	v2_inface = (l2 != NULL);
 
 	/* BM_face_point_inside_test uses best-axis projection so this isn't most accurate test... */
 	v1_inside = v1_inface ? false : BM_face_point_inside_test(f, v1->co);
@@ -2348,7 +2438,7 @@ static void knife_make_chain_cut(KnifeTool_OpData *kcd, BMFace *f, ListBase *cha
 	KnifeVert *kfv, *kfvprev;
 	BMLoop *l_new, *l_iter;
 	int i;
-	int nco = BLI_countlist(chain) - 1;
+	int nco = BLI_listbase_count(chain) - 1;
 	float (*cos)[3] = BLI_array_alloca(cos, nco);
 	KnifeVert **kverts = BLI_array_alloca(kverts, nco);
 
@@ -2421,7 +2511,7 @@ static void knife_make_face_cuts(KnifeTool_OpData *kcd, BMFace *f, ListBase *kfe
 	Ref *ref, *refnext;
 	int count, oldcount;
 
-	oldcount = BLI_countlist(kfedges);
+	oldcount = BLI_listbase_count(kfedges);
 	while ((chain = find_chain(kcd, kfedges)) != NULL) {
 		ListBase fnew_kfedges;
 		knife_make_chain_cut(kcd, f, chain, &fnew);
@@ -2450,7 +2540,7 @@ static void knife_make_face_cuts(KnifeTool_OpData *kcd, BMFace *f, ListBase *kfe
 
 		/* find_chain should always remove edges if it returns true,
 		 * but guard against infinite loop anyway */
-		count = BLI_countlist(kfedges);
+		count = BLI_listbase_count(kfedges);
 		if (count >= oldcount) {
 			BLI_assert(!"knife find_chain infinite loop");
 			return;
@@ -2518,7 +2608,7 @@ static void knife_make_face_cuts(KnifeTool_OpData *kcd, BMFace *f, ListBase *kfe
 				break;
 			/* find_hole should always remove edges if it returns true,
 			 * but guard against infinite loop anyway */
-			count = BLI_countlist(kfedges);
+			count = BLI_listbase_count(kfedges);
 			if (count >= oldcount) {
 				BLI_assert(!"knife find_hole infinite loop");
 				return;
@@ -2550,6 +2640,14 @@ static void knife_make_cuts(KnifeTool_OpData *kcd)
 	/* put list of cutting edges for a face into fhash, keyed by face */
 	BLI_mempool_iternew(kcd->kedges, &iter);
 	for (kfe = BLI_mempool_iterstep(&iter); kfe; kfe = BLI_mempool_iterstep(&iter)) {
+
+		/* select edges that lie directly on the cut */
+		if (kcd->select_result) {
+			if (kfe->e && kfe->is_cut) {
+				BM_edge_select_set(bm, kfe->e, true);
+			}
+		}
+
 		f = kfe->basef;
 		if (!f || kfe->e)
 			continue;
@@ -2718,10 +2816,11 @@ static void knifetool_init(bContext *C, KnifeTool_OpData *kcd,
 
 	kcd->cagecos = (const float (*)[3])BKE_editmesh_vertexCos_get(kcd->em, scene, NULL);
 
-	kcd->bmbvh = BKE_bmbvh_new_from_editmesh(kcd->em,
-	                                         BMBVH_RETURN_ORIG |
-	                                         (only_select ? BMBVH_RESPECT_SELECT : BMBVH_RESPECT_HIDDEN),
-	                                         kcd->cagecos, false);
+	kcd->bmbvh = BKE_bmbvh_new_from_editmesh(
+	        kcd->em,
+	        BMBVH_RETURN_ORIG |
+	        ((only_select && cut_through) ? BMBVH_RESPECT_SELECT : BMBVH_RESPECT_HIDDEN),
+	        kcd->cagecos, false);
 
 	kcd->arena = BLI_memarena_new(MEM_SIZE_OPTIMAL(1 << 15), "knife");
 	kcd->vthresh = KMAXDIST - 1;
@@ -2809,7 +2908,8 @@ enum {
 	KNF_MODAL_ADD_CUT,
 	KNF_MODAL_ANGLE_SNAP_TOGGLE,
 	KNF_MODAL_CUT_THROUGH_TOGGLE,
-	KNF_MODAL_PANNING
+	KNF_MODAL_PANNING,
+	KNF_MODAL_ADD_CUT_CLOSED,
 };
 
 wmKeyMap *knifetool_modal_keymap(wmKeyConfig *keyconf)
@@ -2840,7 +2940,8 @@ wmKeyMap *knifetool_modal_keymap(wmKeyConfig *keyconf)
 	/* items for modal map */
 	WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, KNF_MODAL_CANCEL);
 	WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_ANY, KM_ANY, 0, KNF_MODAL_PANNING);
-	WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_PRESS, KM_ANY, 0, KNF_MODAL_ADD_CUT);
+	WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_DBL_CLICK, KM_ANY, 0, KNF_MODAL_ADD_CUT_CLOSED);
+	WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_ANY, KM_ANY, 0, KNF_MODAL_ADD_CUT);
 	WM_modalkeymap_add_item(keymap, RIGHTMOUSE, KM_PRESS, KM_ANY, 0, KNF_MODAL_CANCEL);
 	WM_modalkeymap_add_item(keymap, RETKEY, KM_PRESS, KM_ANY, 0, KNF_MODAL_CONFIRM);
 	WM_modalkeymap_add_item(keymap, PADENTER, KM_PRESS, KM_ANY, 0, KNF_MODAL_CONFIRM);
@@ -2951,16 +3052,53 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 			case KNF_MODAL_ADD_CUT:
 				knife_recalc_projmat(kcd);
 
-				if (kcd->mode == MODE_DRAGGING) {
-					knife_add_cut(kcd);
+				/* get the value of the event which triggered this one */
+				if (event->prevval != KM_RELEASE) {
+					if (kcd->mode == MODE_DRAGGING) {
+						knife_add_cut(kcd);
+					}
+					else if (kcd->mode != MODE_PANNING) {
+						knife_start_cut(kcd);
+						kcd->mode = MODE_DRAGGING;
+						kcd->init = kcd->curr;
+					}
+
+					/* freehand drawing is incompatible with cut-through */
+					if (kcd->cut_through == false) {
+						kcd->is_drag_hold = true;
+					}
 				}
-				else if (kcd->mode != MODE_PANNING) {
-					knife_start_cut(kcd);
-					kcd->mode = MODE_DRAGGING;
+				else {
+					kcd->is_drag_hold = false;
+
+					/* needed because the last face 'hit' is ignored when dragging */
+					knifetool_update_mval(kcd, kcd->curr.mval);
 				}
 
 				ED_region_tag_redraw(kcd->ar);
 				break;
+			case KNF_MODAL_ADD_CUT_CLOSED:
+				if (kcd->mode == MODE_DRAGGING) {
+
+					/* 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);
+					}
+
+					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);
+
+					knife_add_cut(kcd);
+
+					/* KNF_MODAL_NEW_CUT */
+					knife_finish_cut(kcd);
+					kcd->mode = MODE_IDLE;
+				}
+				break;
 			case KNF_MODAL_PANNING:
 				if (event->val != KM_RELEASE) {
 					if (kcd->mode != MODE_PANNING) {
@@ -2987,6 +3125,12 @@ static int knifetool_modal(bContext *C, wmOperator *op, const wmEvent *event)
 			case MOUSEMOVE: /* mouse moved somewhere to select another loop */
 				if (kcd->mode != MODE_PANNING) {
 					knifetool_update_mval_i(kcd, event->mval);
+
+					if (kcd->is_drag_hold) {
+						if (kcd->totlinehit >= 2) {
+							knife_add_cut(kcd);
+						}
+					}
 				}
 
 				break;
@@ -3034,16 +3178,14 @@ void MESH_OT_knife_tool(wmOperatorType *ot)
  * tessellation here seems way overkill,
  * but without this its very hard to know of a point is inside the face
  */
-static void edvm_mesh_knife_face_point(BMFace *f, float r_cent[3])
+static void edbm_mesh_knife_face_point(BMFace *f, float r_cent[3])
 {
 	const int tottri = f->len - 2;
 	BMLoop **loops = BLI_array_alloca(loops, f->len);
 	unsigned int  (*index)[3] = BLI_array_alloca(index, tottri);
 	int j;
-
-	const float *best_co[3] = {NULL};
-	float best_area  = -1.0f;
-	bool ok = false;
+	int j_best = 0;  /* use as fallback when unset */
+	float area_best  = -1.0f;
 
 	BM_face_calc_tessellation(f, loops, index);
 
@@ -3056,49 +3198,34 @@ static void edvm_mesh_knife_face_point(BMFace *f, float r_cent[3])
 		float cross[3];
 		cross_v3_v3v3(cross, p2, p3);
 		area = fabsf(dot_v3v3(p1, cross));
-		if (area > best_area) {
-			best_co[0] = p1;
-			best_co[1] = p2;
-			best_co[2] = p3;
-			best_area = area;
-			ok = true;
+		if (area > area_best) {
+			j_best = j;
+			area_best = area;
 		}
 	}
 
-	if (ok) {
-		mid_v3_v3v3v3(r_cent, best_co[0], best_co[1], best_co[2]);
-	}
-	else {
-		mid_v3_v3v3v3(r_cent, loops[0]->v->co, loops[1]->v->co, loops[2]->v->co);
-	}
+	mid_v3_v3v3v3(
+	        r_cent,
+	        loops[index[j_best][0]]->v->co,
+	        loops[index[j_best][1]]->v->co,
+	        loops[index[j_best][2]]->v->co);
 }
 
-static bool edbm_mesh_knife_face_isect(ARegion *ar, LinkNode *polys, BMFace *f, float projmat[4][4])
+static bool edbm_mesh_knife_point_isect(LinkNode *polys, const float cent_ss[2])
 {
-	float cent_ss[2];
-	float cent[3];
+	LinkNode *p = polys;
+	int isect = 0;
 
-	edvm_mesh_knife_face_point(f, cent);
-
-	ED_view3d_project_float_v2_m4(ar, cent, cent_ss, projmat);
-
-	/* check */
-	{
-		LinkNode *p = polys;
-		int isect = 0;
-
-		while (p) {
-			const float (*mval_fl)[2] = p->link;
-			const int mval_tot = MEM_allocN_len(mval_fl) / sizeof(*mval_fl);
-			isect += (int)isect_point_poly_v2(cent_ss, mval_fl, mval_tot - 1, false);
-			p = p->next;
-		}
-
-		if (isect % 2) {
-			return true;
-		}
+	while (p) {
+		const float (*mval_fl)[2] = p->link;
+		const int mval_tot = MEM_allocN_len(mval_fl) / sizeof(*mval_fl);
+		isect += (int)isect_point_poly_v2(cent_ss, mval_fl, mval_tot - 1, false);
+		p = p->next;
 	}
 
+	if (isect % 2) {
+		return true;
+	}
 	return false;
 }
 
@@ -3108,6 +3235,7 @@ static bool edbm_mesh_knife_face_isect(ARegion *ar, LinkNode *polys, BMFace *f,
 void EDBM_mesh_knife(bContext *C, LinkNode *polys, bool use_tag, bool cut_through)
 {
 	KnifeTool_OpData *kcd;
+	bglMats mats;
 
 	view3d_operator_needs_opengl(C);
 
@@ -3126,6 +3254,10 @@ void EDBM_mesh_knife(bContext *C, LinkNode *polys, bool use_tag, bool cut_throug
 		if (use_tag) {
 			BM_mesh_elem_hflag_enable_all(kcd->em->bm, BM_EDGE, BM_ELEM_TAG, false);
 		}
+
+		if (kcd->cut_through == false) {
+			bgl_get_mats(&mats);
+		}
 	}
 
 	/* execute */
@@ -3190,7 +3322,10 @@ void EDBM_mesh_knife(bContext *C, LinkNode *polys, bool use_tag, bool cut_throug
 					BMFace *f;
 					BMIter fiter;
 					BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) {
-						if (edbm_mesh_knife_face_isect(kcd->ar, polys, f, projmat)) {
+						float cent[3], cent_ss[2];
+						edbm_mesh_knife_face_point(f, cent);
+						knife_project_v2(kcd, cent, cent_ss);
+						if (edbm_mesh_knife_point_isect(polys, cent_ss)) {
 							BM_elem_flag_enable(f, BM_ELEM_TAG);
 						}
 					}
@@ -3223,7 +3358,12 @@ void EDBM_mesh_knife(bContext *C, LinkNode *polys, bool use_tag, bool cut_throug
 						} while ((l_iter = l_iter->next) != l_first && (found == false));
 
 						if (found) {
-							if (edbm_mesh_knife_face_isect(kcd->ar, polys, f, projmat)) {
+							float cent[3], cent_ss[2];
+							edbm_mesh_knife_face_point(f, cent);
+							knife_project_v2(kcd, cent, cent_ss);
+							if ((kcd->cut_through || point_is_visible(kcd, cent, cent_ss, &mats)) &&
+							    edbm_mesh_knife_point_isect(polys, cent_ss))
+							{
 								BM_elem_flag_enable(f, BM_ELEM_TAG);
 								keep_search = true;
 							}