[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [44832] trunk/blender/source/blender/ editors/mesh/knifetool.c: Code cleanup: knife gathers pos-related state into a struct.

Howard Trickey howard.trickey at gmail.com
Mon Mar 12 13:46:00 CET 2012


Revision: 44832
          http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=44832
Author:   howardt
Date:     2012-03-12 12:45:55 +0000 (Mon, 12 Mar 2012)
Log Message:
-----------
Code cleanup: knife gathers pos-related state into a struct. No functional change.

This is in preparation for bug fixing and cleanup related to tracking
of bmface and is_space state variables.  And makes it more likely
to avoid bugs in future where some part of state is copied but not all.

Modified Paths:
--------------
    trunk/blender/source/blender/editors/mesh/knifetool.c

Modified: trunk/blender/source/blender/editors/mesh/knifetool.c
===================================================================
--- trunk/blender/source/blender/editors/mesh/knifetool.c	2012-03-12 12:03:52 UTC (rev 44831)
+++ trunk/blender/source/blender/editors/mesh/knifetool.c	2012-03-12 12:45:55 UTC (rev 44832)
@@ -19,7 +19,7 @@
  * All rights reserved.
  *
  * 
- * Contributor(s): Joseph Eagar, Joshua Leung
+ * Contributor(s): Joseph Eagar, Joshua Leung, Howard Trickey
  *
  * ***** END GPL LICENSE BLOCK *****
  */
@@ -62,7 +62,6 @@
 
 /* this code here is kindof messy. . .I might need to eventually rework it - joeedh */
 
-#define MAXGROUP	30
 #define KMAXDIST	10	/* max mouse distance from edge before not detecting it */
 
 /* knifetool operator */
@@ -99,6 +98,21 @@
 	BMFace *f;
 } BMEdgeHit;
 
+typedef struct KnifePosData {
+	float co[3];
+	float cage[3];
+
+	/* At most one of vert, edge, or bmface should be non-NULL,
+	 * saying whether the point is snapped to a vertex, edge, or in a face.
+	 * If none are set, this point is in space and is_space should be true. */
+	KnifeVert *vert;
+	KnifeEdge *edge;
+	BMFace *bmface;
+	int is_space;
+
+	int mval[2];  /* mouse screen position */
+} KnifePosData;
+
 /* struct for properties used while drawing */
 typedef struct knifetool_opdata {
 	ARegion *ar;		/* region that knifetool was activated in */
@@ -124,21 +138,14 @@
 	float vthresh;
 	float ethresh;
 	
-	float vertco[3], vertcage[3];
-	float prevco[3], prevcage[3];
-	
 	/* used for drag-cutting */
 	BMEdgeHit *linehits;
 	int totlinehit;
 	
-	/* if curedge is NULL, attach to curvert;
-	 * if curvert is NULL, attach to curbmface,
-	 * otherwise create null vert */
-	KnifeEdge *curedge, *prevedge;
-	KnifeVert *curvert, *prevvert;
-	BMFace *curbmface, *prevbmface;
+	/* Data for mouse-position-derived data (cur) and previous click (prev) */
+	KnifePosData cur, prev;
 
-	int totkedge, totkvert, cutnr;
+	int totkedge, totkvert;
 	
 	BLI_mempool *refs;
 	
@@ -156,7 +163,6 @@
 	
 	int snap_midpoints, prevmode, extend;
 	int ignore_edge_snapping, ignore_vert_snapping;
-	int prevmval[2];
 	
 	enum {
 		ANGLE_FREE,
@@ -166,7 +172,6 @@
 		ANGLE_135
 	} angle_snapping;
 
-	int is_space, prev_is_space; /*1 if current cut location, vertco, isn't on the mesh */
 	float (*cagecos)[3];
 } knifetool_opdata;
 
@@ -180,6 +185,16 @@
 	ED_view3d_project_float_v3(kcd->ar, co, sco, kcd->projmat);
 }
 
+static void knife_pos_data_clear(KnifePosData *kpd) {
+	zero_v3(kpd->co);
+	zero_v3(kpd->cage);
+	kpd->vert = NULL;
+	kpd->edge = NULL;
+	kpd->bmface = NULL;
+	kpd->mval[0] = 0;
+	kpd->mval[1] = 0;
+}
+
 static ListBase *knife_empty_list(knifetool_opdata *kcd)
 {
 	ListBase *lst;
@@ -280,33 +295,26 @@
 	return kfe;
 }
 
+/* User has just clicked for first time or first time after a restart (E key).
+ * Copy the current position data into prev. */
 static void knife_start_cut(knifetool_opdata *kcd)
 {
-	kcd->prevedge = kcd->curedge;
-	kcd->prevvert = kcd->curvert;
-	kcd->prevbmface = kcd->curbmface;
-	kcd->cutnr++;
-	kcd->prev_is_space = kcd->is_space;
-	kcd->is_space = 0;
-	kcd->prevmval[0] = kcd->vc.mval[0];
-	kcd->prevmval[1] = kcd->vc.mval[1];
+	kcd->prev = kcd->cur;
+	kcd->cur.is_space = 0; /*TODO: why do we do this? */
 
-	copy_v3_v3(kcd->prevco, kcd->vertco);
-	copy_v3_v3(kcd->prevcage, kcd->vertcage);
-
-	if (kcd->prevvert == NULL && kcd->prevedge == NULL && is_zero_v3(kcd->prevcage)) {
+	if (kcd->prev.vert == NULL && kcd->prev.edge == NULL && is_zero_v3(kcd->prev.cage)) {
 		/* Make prevcage a point on the view ray to mouse closest to a point on model: choose vertex 0 */
 		float origin[3], ray[3], co[3];
 		BMVert *v0;
 
-		knife_input_ray_cast(kcd, kcd->vc.mval, origin, ray);
+		knife_input_ray_cast(kcd, kcd->cur.mval, origin, ray);
 		add_v3_v3v3(co, origin, ray);
 		v0 = BM_vert_at_index(kcd->em->bm, 0);
 		if (v0) {
-			closest_to_line_v3(kcd->prevcage, v0->co, co, origin);
-			copy_v3_v3(kcd->prevco, kcd->prevcage);
-			copy_v3_v3(kcd->vertcage, kcd->prevcage);
-			copy_v3_v3(kcd->vertco, kcd->prevco);
+			closest_to_line_v3(kcd->prev.cage, v0->co, co, origin);
+			copy_v3_v3(kcd->prev.co, kcd->prev.cage); /*TODO: do we need this? */
+			copy_v3_v3(kcd->cur.cage, kcd->prev.cage);
+			copy_v3_v3(kcd->cur.co, kcd->prev.co);
 		}
 	}
 }
@@ -339,9 +347,9 @@
 
 		if (kfe->v1->isface || kfe->v2->isface) {
 			if (kfe->v2->isface)
-				kfe->basef = kcd->curbmface;
+				kfe->basef = kcd->cur.bmface;
 			else 
-				kfe->basef = kcd->prevbmface;
+				kfe->basef = kcd->prev.bmface;
 		}
 		else {
 			for (r1 = kfe->v1->edges.first; r1 && !kfe->basef; r1 = r1->next) {
@@ -408,48 +416,50 @@
 	return newkfe->v2;
 }
 
+/* Make a single KnifeEdge for cut from kcd->prev to kcd->cur.
+ * and move cur data to prev. */
 static void knife_add_single_cut(knifetool_opdata *kcd)
 {
 	KnifeEdge *kfe = new_knife_edge(kcd), *kfe2 = NULL, *kfe3 = NULL;
 
-	if (kcd->prevvert && kcd->prevvert == kcd->curvert)
+	if (kcd->prev.vert && kcd->prev.vert == kcd->cur.vert)
 		return;
-	if (kcd->prevedge && kcd->prevedge == kcd->curedge)
+	if (kcd->prev.edge && kcd->prev.edge == kcd->cur.edge)
 		return;
 
 	kfe->draw = 1;
 
-	if (kcd->prevvert) {
-		kfe->v1 = kcd->prevvert;
+	if (kcd->prev.vert) {
+		kfe->v1 = kcd->prev.vert;
 	}
-	else if (kcd->prevedge) {
-		kfe->v1 = knife_split_edge(kcd, kcd->prevedge, kcd->prevco, &kfe2);
+	else if (kcd->prev.edge) {
+		kfe->v1 = knife_split_edge(kcd, kcd->prev.edge, kcd->prev.co, &kfe2);
 	}
 	else {
-		kfe->v1 = new_knife_vert(kcd, kcd->prevco, kcd->prevco);
-		kfe->v1->draw = kfe->draw = !kcd->prev_is_space;
-		kfe->v1->inspace = kcd->prev_is_space;
-		kfe->draw = !kcd->prev_is_space;
+		kfe->v1 = new_knife_vert(kcd, kcd->prev.co, kcd->prev.co);
+		kfe->v1->draw = kfe->draw = !kcd->prev.is_space;
+		kfe->v1->inspace = kcd->prev.is_space;
+		kfe->draw = !kcd->prev.is_space;
 		kfe->v1->isface = 1;
 	}
 
-	if (kcd->curvert) {
-		kfe->v2 = kcd->curvert;
+	if (kcd->cur.vert) {
+		kfe->v2 = kcd->cur.vert;
 	}
-	else if (kcd->curedge) {
-		kfe->v2 = knife_split_edge(kcd, kcd->curedge, kcd->vertco, &kfe3);
-		kcd->curvert = kfe->v2;
+	else if (kcd->cur.edge) {
+		kfe->v2 = knife_split_edge(kcd, kcd->cur.edge, kcd->cur.co, &kfe3);
+		kcd->cur.vert = kfe->v2;
 	}
 	else {
-		kfe->v2 = new_knife_vert(kcd, kcd->vertco, kcd->vertco);
-		kfe->v2->draw = !kcd->is_space;
+		kfe->v2 = new_knife_vert(kcd, kcd->cur.co, kcd->cur.co);
+		kfe->v2->draw = !kcd->cur.is_space;
 		kfe->v2->isface = 1;
-		kfe->v2->inspace = kcd->is_space;
+		kfe->v2->inspace = kcd->cur.is_space;
 		
-		if (kcd->is_space)
+		if (kcd->cur.is_space)
 			kfe->draw = 0;
 
-		kcd->curvert = kfe->v2;
+		kcd->cur.vert = kfe->v2;
 	}
 
 	knife_find_basef(kcd, kfe);
@@ -460,27 +470,20 @@
 		knife_edge_append_face(kcd, kfe, kfe->basef);
 
 	/* sanity check to make sure we're in the right edge/face lists */
-	if (kcd->curbmface) {
-		if (!find_ref(&kfe->faces, kcd->curbmface)) {
-			knife_edge_append_face(kcd, kfe, kcd->curbmface);
+	if (kcd->cur.bmface) {
+		if (!find_ref(&kfe->faces, kcd->cur.bmface)) {
+			knife_edge_append_face(kcd, kfe, kcd->cur.bmface);
 		}
 
-		if (kcd->prevbmface && kcd->prevbmface != kcd->curbmface) {
-			if (!find_ref(&kfe->faces, kcd->prevbmface)) {
-				knife_edge_append_face(kcd, kfe, kcd->prevbmface);
+		if (kcd->prev.bmface && kcd->prev.bmface != kcd->cur.bmface) {
+			if (!find_ref(&kfe->faces, kcd->prev.bmface)) {
+				knife_edge_append_face(kcd, kfe, kcd->prev.bmface);
 			}
 		}
 	}
 
 	/* set up for next cut */
-	kcd->prevbmface = kcd->curbmface;
-	kcd->prevvert = kcd->curvert;
-	kcd->prevedge = kcd->curedge;
-	copy_v3_v3(kcd->prevco, kcd->vertco);
-	copy_v3_v3(kcd->prevcage, kcd->vertcage);
-	kcd->prev_is_space = kcd->is_space;
-	kcd->prevmval[0] = kcd->vc.mval[0];
-	kcd->prevmval[1] = kcd->vc.mval[1];
+	kcd->prev = kcd->cur;
 }
 
 static int verge_linehit(const void *vlh1, const void *vlh2)
@@ -562,26 +565,26 @@
 	qsort(kcd->linehits, kcd->totlinehit, sizeof(BMEdgeHit), verge_linehit);
 	splitkfe = MEM_callocN(kcd->totlinehit * sizeof(KnifeEdge *), "knife_cut_through");
 
-	if (kcd->prevvert) {
-		if (kcd->prevvert == kcd->curvert)
+	if (kcd->prev.vert) {
+		if (kcd->prev.vert == kcd->cur.vert)
 			return;
-		firstv = kcd->prevvert;
-		knife_get_vert_faces(kcd, firstv, kcd->prevbmface, &firstfaces);
+		firstv = kcd->prev.vert;
+		knife_get_vert_faces(kcd, firstv, kcd->prev.bmface, &firstfaces);
 	}
-	else if (kcd->prevedge) {
-		if (kcd->prevedge == kcd->curedge)
+	else if (kcd->prev.edge) {
+		if (kcd->prev.edge == kcd->cur.edge)
 			return;
-		firstv = knife_split_edge(kcd, kcd->prevedge, kcd->prevco, &kfe3);
-		knife_get_edge_faces(kcd, kcd->prevedge, &firstfaces);
+		firstv = knife_split_edge(kcd, kcd->prev.edge, kcd->prev.co, &kfe3);
+		knife_get_edge_faces(kcd, kcd->prev.edge, &firstfaces);
 	}
 
-	if (kcd->curvert) {
-		lastv = kcd->curvert;
-		knife_get_vert_faces(kcd, lastv, kcd->curbmface, &lastfaces);
+	if (kcd->cur.vert) {
+		lastv = kcd->cur.vert;
+		knife_get_vert_faces(kcd, lastv, kcd->cur.bmface, &lastfaces);
 	}
-	else if (kcd->curedge) {
-		lastv = knife_split_edge(kcd, kcd->curedge, kcd->vertco, &kfe3);
-		knife_get_edge_faces(kcd, kcd->curedge, &lastfaces);
+	else if (kcd->cur.edge) {
+		lastv = knife_split_edge(kcd, kcd->cur.edge, kcd->cur.co, &kfe3);
+		knife_get_edge_faces(kcd, kcd->cur.edge, &lastfaces);
 	}
 
 	if (firstv) {
@@ -650,19 +653,15 @@
 	kcd->totlinehit = 0;
 
 	/* set up for next cut */
-	kcd->prevbmface = kcd->curbmface;
-	kcd->prevvert = kcd->curvert;
-	kcd->prevedge = kcd->curedge;
-	copy_v3_v3(kcd->prevco, kcd->vertco);
-	copy_v3_v3(kcd->prevcage, kcd->vertcage);
-	kcd->prev_is_space = kcd->is_space;
-	kcd->prevmval[0] = kcd->vc.mval[0];
-	kcd->prevmval[1] = kcd->vc.mval[1];
+	kcd->prev = kcd->cur;
 }
 
+/* User has just left-clicked after the first time.
+ * Add all knife cuts implied by line from prev to cur.
+ * If that line crossed edges then kcd->linehits will be non-NULL. */
 static void knife_add_cut(knifetool_opdata *kcd)
 {
-	knifetool_opdata oldkcd = *kcd;
+	KnifePosData savcur = kcd->cur;
 
 	if (kcd->cut_through) {
 		knife_cut_through(kcd);
@@ -687,56 +686,46 @@
 				if (firstlh->v || lastlh->v) {
 					KnifeVert *kfv = firstlh->v ? firstlh->v : lastlh->v;
 					
-					kcd->prevvert = kfv;
-					copy_v3_v3(kcd->prevco, firstlh->hit);
-					copy_v3_v3(kcd->prevcage, firstlh->cagehit);
-					kcd->prevedge = NULL;
-					kcd->prevbmface = f;
+					kcd->prev.vert = kfv;
+					copy_v3_v3(kcd->prev.co, firstlh->hit);

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list