[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [11413] branches/bmesh/source/blender: -> Selection functions and Mesh Iterators

Geoffrey Bantle hairbat at yahoo.com
Sun Jul 29 10:36:58 CEST 2007


Revision: 11413
          http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=11413
Author:   briggs
Date:     2007-07-29 10:36:58 +0200 (Sun, 29 Jul 2007)

Log Message:
-----------
-> Selection functions and Mesh Iterators

Selections should now be handled through the BME_select_vert/edge/poly functions.
To check selection state use the BME_SELECTED macro. For iterating over the verts/
edges/polys or loops in a mesh use the BME_first and BME_next functions.

Modified Paths:
--------------
    branches/bmesh/source/blender/blenkernel/BKE_bmesh.h
    branches/bmesh/source/blender/blenkernel/intern/BME_mesh.c
    branches/bmesh/source/blender/src/editbmesh_interface.c

Modified: branches/bmesh/source/blender/blenkernel/BKE_bmesh.h
===================================================================
--- branches/bmesh/source/blender/blenkernel/BKE_bmesh.h	2007-07-29 07:32:19 UTC (rev 11412)
+++ branches/bmesh/source/blender/blenkernel/BKE_bmesh.h	2007-07-29 08:36:58 UTC (rev 11413)
@@ -48,6 +48,11 @@
 struct RetopoPaintData;
 struct DerivedMesh;
 
+#define BME_VERT 1
+#define BME_EDGE 2
+#define BME_POLY 3
+#define BME_LOOP 4
+
 typedef struct BME_CycleNode{
 	struct BME_CycleNode *next, *prev;
 	void *data;
@@ -70,31 +75,41 @@
 //60, 52, 52, 12 704
 //60, 52, 84 
 
+/*only defined to make certain things easier*/
+typedef struct BME_Element
+{
+	struct BME_Element *next, *prev;
+	int EID;
+	unsigned short flag,h;
 
+} BME_Element;
+
 typedef struct BME_Vert
 {
 	struct BME_Vert *next, *prev;
 	int	EID;
+	unsigned short flag, h;
 	float co[3];									/*vertex location. Actually pointer to custom data block*/
 	float no[3];									/*vertex normal. Actually pointer to custom data block*/
 	struct BME_Edge *edge;							/*first edge in the disk cycle for this vertex*/
 	void *data;										/*custom vertex data*/
 	int eflag1, eflag2;								/*reserved for use by eulers*/
 	int tflag1, tflag2;								/*reserved for use by tools*/
-	unsigned short flag, h;
+
 } BME_Vert;
 
 typedef struct BME_Edge
 {
 	struct BME_Edge *next, *prev;
 	int EID;
+	unsigned short flag, h;
 	struct BME_Vert *v1, *v2;						/*note that order of vertex pointers means nothing to eulers*/
 	struct BME_CycleNode d1, d2;					/*disk cycle nodes for v1 and v2 respectivley*/
 	struct BME_Loop *loop;							/*first BME_Loop in the radial cycle around this edge*/
 	void *data;										/*custom edge data*/
 	int eflag1, eflag2;								/*reserved for use by eulers*/
 	int tflag1, tflag2;								/*reserved for use by tools*/
-	unsigned char flag, h;
+
 	float crease;
 } BME_Edge;
 
@@ -102,6 +117,7 @@
 {	
 	struct BME_Loop *next, *prev;					/*circularly linked list around face*/
 	int EID;
+	unsigned short flag, h;
 	struct BME_CycleNode radial;					/*circularly linked list used to find faces around an edge*/
 	struct BME_CycleNode *gref;						/*pointer to loop ref. Nasty.*/
 	struct BME_Vert *v;								/*vertex that this loop starts at.*/
@@ -110,20 +126,22 @@
 	void *data;										/*custom per face vertex data*/
 	int eflag1, eflag2;								/*reserved for use by eulers*/
 	int tflag1, tflag2;								/*reserved for use by tools*/
-	unsigned short flag, h;
+
 } BME_Loop;
 
 typedef struct BME_Poly
 {
 	struct BME_Poly *next, *prev;
 	int EID;
+	unsigned short flag, h; 
+	unsigned short mat_nr;
 	struct BME_Loop *loopbase;						/*First editloop around Polygon.*/
 	struct ListBase holes;							/*list of inner loops in the face*/
 	unsigned int len;								/*total length of the face. Eulers should preserve this data*/
 	void *data;										/*custom face data*/
 	int eflag1, eflag2;								/*reserved for use by eulers*/
 	int tflag1, tflag2;								/*reserved for use by tools*/
-	unsigned short flag, h, mat_nr;
+
 } BME_Poly;
 
 //*EDGE UTILITIES*/
@@ -172,6 +190,14 @@
 /*NORMAL FLIP(Is its own inverse)*/
 int BME_loop_reverse(struct BME_Mesh *bm, struct BME_Poly *f);
 
+/* SELECTION  AND ITERATOR FUNCTIONS*/
+void *BME_first(struct BME_Mesh *bm, int type);
+void *BME_next(struct BME_Mesh *bm, int type, void *element);
+void BME_select_vert(struct BME_Mesh *bm, struct BME_Vert *v, int select);
+void BME_select_edge(struct BME_Mesh *bm, struct BME_Edge *e, int select);
+void BME_select_poly(struct BME_Mesh *bm, struct BME_Poly *f, int select);
+#define BME_SELECTED(element) (element->flag & SELECT)
+
 /*TOOLS CODE*/
 struct BME_Loop *BME_inset_edge(struct BME_Mesh *bm, struct BME_Loop *l, struct BME_Poly *f);
 struct BME_Poly *BME_inset_poly(struct BME_Mesh *bm, struct BME_Poly *f);

Modified: branches/bmesh/source/blender/blenkernel/intern/BME_mesh.c
===================================================================
--- branches/bmesh/source/blender/blenkernel/intern/BME_mesh.c	2007-07-29 07:32:19 UTC (rev 11412)
+++ branches/bmesh/source/blender/blenkernel/intern/BME_mesh.c	2007-07-29 08:36:58 UTC (rev 11413)
@@ -61,6 +61,56 @@
 
 
 /*	
+ *	BME FIRST
+ *
+ * Finds the first element of the given type in the bmesh
+*/
+
+void *BME_first(BME_Mesh *bm, int type){
+	if(type == BME_VERT) return bm->verts.first;
+	else if(type == BME_EDGE) return bm->edges.first;
+	else if (type == BME_POLY) return bm->polys.first;
+	else if (type == BME_LOOP){
+		if(bm->loops.first){
+			return ((BME_CycleNode*)bm->loops.first)->data;
+		}
+	}
+	return NULL;
+}
+/*	
+ *	BME NEXT
+ *
+ * Finds the next element of the givent type in the bmesh
+*/
+void *BME_next(BME_Mesh *bm, int type, void *element){
+	if(type == BME_VERT) return ((BME_Vert*)element)->next;
+	else if(type == BME_EDGE) return ((BME_Edge*)element)->next;
+	else if(type == BME_POLY) return ((BME_Poly*)element)->next;
+	else if(type == BME_LOOP) return ((BME_Loop*)element)->gref->next->data;
+	return NULL;
+}
+
+/*	
+ *	BME SELECT VERT/EDGE/POLY
+ *
+ * Selects elements.
+*/
+void BME_select_vert(BME_Mesh *bm, BME_Vert *v, int select){
+	if(select) v->flag |= SELECT;
+	else v->flag &= ~SELECT;
+}
+void BME_select_edge(BME_Mesh *bm, BME_Edge *e, int select){
+	if(select) e->flag |= SELECT;
+	else e->flag &= ~SELECT;
+}
+void BME_select_poly(BME_Mesh *bm, BME_Poly *f, int select){
+	if(select) f->flag |= SELECT;
+	else f->flag &= ~SELECT;
+}
+
+
+
+/*	
  *	BME MAKE MESH
  *
  *  Allocates a new BME_Mesh structure
@@ -174,15 +224,19 @@
 */
 
 int BME_model_begin(BME_Mesh *bm){
-	if(bm->lock) return 0;
-	bm->lock = 1;
-	bm->backup = BME_copy_mesh(bm);
-	return 1;
+	BME_Vert *v;
+	BME_Edge *e;
+	BME_Poly *f;
+	BME_Loop *l;
+
+	for(v=BME_first(bm,BME_VERT); v; v=BME_next(bm,BME_VERT,v)) v->tflag1 = v->tflag2 = 0;
+	for(e=BME_first(bm,BME_EDGE); e; e=BME_next(bm,BME_EDGE,e)) e->tflag1 = e->tflag2 = 0;
+	for(f=BME_first(bm,BME_POLY); f; f=BME_next(bm,BME_POLY,f)) f->tflag1 = f->tflag2 = 0;
+	for(l=BME_first(bm,BME_LOOP); l; l=BME_next(bm,BME_LOOP,l)) l->tflag1 = l->tflag2 = 0;
 }
 
 void BME_model_end(BME_Mesh *bm){
-	BME_Mesh *badmesh;
-	int meshok,backupok, totvert, totedge, totpoly, totloop;
+	int meshok, totvert, totedge, totpoly, totloop;
 
 	totvert = BLI_countlist(&(bm->verts));
 	totedge = BLI_countlist(&(bm->edges));
@@ -194,23 +248,15 @@
 	
 	meshok = BME_validate_mesh(bm, 1);
 	if(!meshok){
-		printf("Warning, Mesh failed validation, restoring from backup");
-		badmesh = bm;
-		bm= badmesh->backup;
-		bm->backup = badmesh;
-		backupok = BME_validate_mesh(bm,1);
-		if(!backupok) printf("Backup corrupted too, Briggs did something stupid!");
+		printf("Warning, Mesh failed validation! Put in bug tracker!");
 	}
-	BME_free_mesh(bm->backup);
-	bm->lock = 0;
 }
 
-
 /*	
  *	BME VALIDATE MESH
  *
  *	There are several levels of validation for meshes. At the 
- *  Euler level, some basic validation is done to local topology.
+ *  Euler level, some basic validation is done to local topology.SSSS
  *  To catch more subtle problems however, BME_validate_mesh() is 
  *  called by BME_model_end() whenever a tool is done executing.
  *  The purpose of this function is to insure that during the course 

Modified: branches/bmesh/source/blender/src/editbmesh_interface.c
===================================================================
--- branches/bmesh/source/blender/src/editbmesh_interface.c	2007-07-29 07:32:19 UTC (rev 11412)
+++ branches/bmesh/source/blender/src/editbmesh_interface.c	2007-07-29 08:36:58 UTC (rev 11413)
@@ -357,14 +357,14 @@
 		BME_Vert *vert = EditBME_FindNearestVert(&dis, 1, 0);
 		if (vert) {
 			if (G.qual & LR_SHIFTKEY) {
-				if (vert->flag & SELECT) vert->flag &= ~SELECT;
-				else vert->flag |= SELECT;
+				if (BME_SELECTED(vert)) BME_select_vert(G.editMesh,vert,0);
+				else BME_select_vert(G.editMesh,vert,1);
 			} else {
 				BME_Vert *eve;
-				for (eve=G.editMesh->verts.first; eve; eve=eve->next) eve->flag &= ~SELECT;
-				vert->flag |= SELECT;
+				for(eve=BME_first(G.editMesh,BME_VERT);eve;eve=BME_next(G.editMesh,BME_VERT,eve)) BME_select_vert(G.editMesh,eve,0);
+				BME_select_vert(G.editMesh,vert,1);
 			}
-			EditBME_FlushSelUpward(G.editMesh);
+			//EditBME_FlushSelUpward(G.editMesh);
 			allqueue(REDRAWVIEW3D, 1);
 		}
 	} else if (G.scene->selectmode == SCE_SELECT_EDGE) {
@@ -379,42 +379,14 @@
 
 		if (edge) {
 			if (G.qual & LR_SHIFTKEY) {
-				if (edge->flag & SELECT) edge->flag &= ~SELECT;
-				else edge->flag |= SELECT;
+				if (BME_SELECTED(edge)) BME_select_edge(G.editMesh,edge,0);
+				else BME_select_edge(G.editMesh,edge,1);
 			} else {
 				BME_Edge *eed;
-				for (eed=G.editMesh->edges.first; eed; eed=eed->next) eed->flag &= ~SELECT;
-				edge->flag |= SELECT;
+				for (eed=BME_first(G.editMesh,BME_EDGE); eed; eed=BME_next(G.editMesh,BME_EDGE,eed)) BME_select_edge(G.editMesh, eed,0);
+				BME_select_edge(G.editMesh,edge,1);
 			}
 
-			/*Hackish code for edge flushing.  Will need proper implementation later.*/
-			for (eve=G.editMesh->verts.first; eve; eve=eve->next) eve->tflag1 = 0;
-			for (eed=G.editMesh->edges.first; eed; eed=eed->next) {
-				if (eed->flag & SELECT) {
-					eed->v1->tflag1 = 1;
-					eed->v2->tflag1 = 1;
-				}
-			}
-
-			for (eve=G.editMesh->verts.first; eve; eve=eve->next) {
-				if (eve->tflag1==0) eve->flag &= ~SELECT;
-				else eve->flag |= SELECT;
-			}
-			
-			for (efa=G.editMesh->polys.first; efa; efa=efa->next) {
-				stop = 0;
-				loop = efa->loopbase;
-				do {
-					if ((loop->e->flag & SELECT)==0) {
-						stop = 1;
-						break;
-					}
-					loop=loop->next;
-				} while (loop != efa->loopbase);
-				if (stop) efa->flag &= ~SELECT;
-				else efa->flag |= SELECT;
-			}
-
 			allqueue(REDRAWVIEW3D, 1);
 		}
 	}





More information about the Bf-blender-cvs mailing list