Revision: 22218
          
http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=22218
Author:   joeedh
Date:     2009-08-05 08:06:58 +0200 (Wed, 05 Aug 2009)

Log Message:
-----------
bmeshafied the hide/reveal code.  created a set of API functions for 
hiding/revealing elements in bmesh_marking.c.  main function is BM_Hide, which 
can hide or reveal an element (vert/edge/face, NOT loops, obviously), and will 
handle any flushing necassary.  also renamed BM_Is_Selected to BM_Selected, 
though I may get rid of that function altogether.

Modified Paths:
--------------
    branches/bmesh/blender/source/blender/bmesh/bmesh_iterators.h
    branches/bmesh/blender/source/blender/bmesh/bmesh_marking.h
    branches/bmesh/blender/source/blender/bmesh/bmesh_operator_api.h
    branches/bmesh/blender/source/blender/bmesh/editmesh_tools.c
    branches/bmesh/blender/source/blender/bmesh/intern/bmesh_construct.c
    branches/bmesh/blender/source/blender/bmesh/intern/bmesh_marking.c
    branches/bmesh/blender/source/blender/bmesh/intern/bmesh_operators.c
    branches/bmesh/blender/source/blender/editors/mesh/bmesh_select.c
    branches/bmesh/blender/source/blender/editors/mesh/bmesh_tools.c
    branches/bmesh/blender/source/blender/editors/mesh/bmeshutils.c
    branches/bmesh/blender/source/blender/editors/mesh/editmesh_loop.c
    branches/bmesh/blender/source/blender/editors/mesh/editmesh_mods.c

Modified: branches/bmesh/blender/source/blender/bmesh/bmesh_iterators.h
===================================================================
--- branches/bmesh/blender/source/blender/bmesh/bmesh_iterators.h       
2009-08-05 02:40:51 UTC (rev 22217)
+++ branches/bmesh/blender/source/blender/bmesh/bmesh_iterators.h       
2009-08-05 06:06:58 UTC (rev 22218)
@@ -30,6 +30,10 @@
        ele = BMIter_New(iter, bm, type, data); \
        for ( ; ele; ele=BMIter_Step(iter))
 
+#define BM_ITER_SELECT(ele, iter, bm, type, data)\
+for (ele = BMIter_New(iter, bm, type, data); ele; ele=BMIter_Step(iter)) {\
+       if (BM_TestHFlag(ele, BM_HIDDEN) || !BM_TestHFlag(ele, BM_SELECT)) 
continue;
+
 /*these are topological iterators.*/
 #define BM_EDGES_OF_VERT                       4
 #define BM_FACES_OF_VERT                       5

Modified: branches/bmesh/blender/source/blender/bmesh/bmesh_marking.h
===================================================================
--- branches/bmesh/blender/source/blender/bmesh/bmesh_marking.h 2009-08-05 
02:40:51 UTC (rev 22217)
+++ branches/bmesh/blender/source/blender/bmesh/bmesh_marking.h 2009-08-05 
06:06:58 UTC (rev 22218)
@@ -8,18 +8,30 @@
        void *data;
 } BMEditSelection;
 
+/*geometry hiding code*/
+void BM_Hide(BMesh *bm, void *element, int hide);
+void BM_Hide_Vert(BMesh *bm, BMVert *v, int hide);
+void BM_Hide_Edge(BMesh *bm, BMEdge *e, int hide);
+void BM_Hide_Face(BMesh *bm, BMFace *f, int hide);
+
 /*Selection code*/
+void BM_Select(struct BMesh *bm, void *element, int select);
+/*I don't use this function anywhere, been using BM_TestHFlag instead.
+  Need to decide either to keep it and convert everything over, or
+  chuck it.*/
+int BM_Selected(BMesh *bm, void *element);
+
+/*individual element select functions, BM_Select is a shortcut for these
+  that automatically detects which one to use*/
 void BM_Select_Vert(struct BMesh *bm, struct BMVert *v, int select);
 void BM_Select_Edge(struct BMesh *bm, struct BMEdge *e, int select);
 void BM_Select_Face(struct BMesh *bm, struct BMFace *f, int select);
+
 void BM_Selectmode_Set(struct BMesh *bm, int selectmode);
 
 /*counts number of elements with flag set*/
-int BM_CountFlag(struct BMesh *bm, int type, int flag);
+int BM_CountFlag(struct BMesh *bm, int type, int flag, int respectflag);
 
-void BM_Select(struct BMesh *bm, void *element, int select);
-int BM_Is_Selected(BMesh *bm, void *element);
-
 /*edit selection stuff*/
 void BM_editselection_center(BMesh *bm, float *center, BMEditSelection *ese);
 void BM_editselection_normal(float *normal, BMEditSelection *ese);

Modified: branches/bmesh/blender/source/blender/bmesh/bmesh_operator_api.h
===================================================================
--- branches/bmesh/blender/source/blender/bmesh/bmesh_operator_api.h    
2009-08-05 02:40:51 UTC (rev 22217)
+++ branches/bmesh/blender/source/blender/bmesh/bmesh_operator_api.h    
2009-08-05 06:06:58 UTC (rev 22218)
@@ -234,7 +234,8 @@
 void BMO_UnHeaderFlag_Buffer(struct BMesh *bm, struct BMOperator *op, char 
*slotname, int flag);
 
 /*puts every element of type type (which is a bitmask) with header flag 
-  flag, into a slot.*/
+  flag, into a slot.  note: ignores hidden elements (e.g. elements with
+  header flag BM_HIDDEN set).*/
 void BMO_HeaderFlag_To_Slot(struct BMesh *bm, struct BMOperator *op, char 
*slotname, int flag, int type);
 
 /*counts number of elements inside a slot array.*/

Modified: branches/bmesh/blender/source/blender/bmesh/editmesh_tools.c
===================================================================
--- branches/bmesh/blender/source/blender/bmesh/editmesh_tools.c        
2009-08-05 02:40:51 UTC (rev 22217)
+++ branches/bmesh/blender/source/blender/bmesh/editmesh_tools.c        
2009-08-05 06:06:58 UTC (rev 22218)
@@ -2435,13 +2435,13 @@
 
        BMO_Init_Op(&subdop, BMOP_ESUBDIVIDE);
        for (tot=0, bed=BMIter_New(&iter, bm, BM_EDGES, NULL); bed; 
bed=BMIter_Step(&iter)) {
-               if (BM_Is_Selected(bm, bed)) tot++;
+               if (BM_Selected(bm, bed)) tot++;
        }
        
        list = MEM_callocN(sizeof(void*)*tot, "vert ptr list");
 
        for (tot=0, bed=BMIter_New(&iter, bm, BM_EDGES, NULL); bed; 
bed=BMIter_Step(&iter)) {
-               if (BM_Is_Selected(bm, bed)) list[tot++] = bed;
+               if (BM_Selected(bm, bed)) list[tot++] = bed;
        }
        
        BMO_Set_PntBuf(&subdop, BMOP_ESUBDIVIDE_EDGES, list, tot);

Modified: branches/bmesh/blender/source/blender/bmesh/intern/bmesh_construct.c
===================================================================
--- branches/bmesh/blender/source/blender/bmesh/intern/bmesh_construct.c        
2009-08-05 02:40:51 UTC (rev 22217)
+++ branches/bmesh/blender/source/blender/bmesh/intern/bmesh_construct.c        
2009-08-05 06:06:58 UTC (rev 22218)
@@ -392,7 +392,7 @@
                return;
 
        /*First we copy select*/
-       if(BM_Is_Selected(source_mesh, source)) BM_Select(target_mesh, target, 
1);
+       if(BM_Selected(source_mesh, source)) BM_Select(target_mesh, target, 1);
        
        /*Now we copy flags*/
        theader->flag = sheader->flag;

Modified: branches/bmesh/blender/source/blender/bmesh/intern/bmesh_marking.c
===================================================================
--- branches/bmesh/blender/source/blender/bmesh/intern/bmesh_marking.c  
2009-08-05 02:40:51 UTC (rev 22217)
+++ branches/bmesh/blender/source/blender/bmesh/intern/bmesh_marking.c  
2009-08-05 06:06:58 UTC (rev 22218)
@@ -282,7 +282,7 @@
 }
 
 
-int BM_CountFlag(struct BMesh *bm, int type, int flag)
+int BM_CountFlag(struct BMesh *bm, int type, int flag, int respecthide)
 {
        BMHeader *head;
        BMIter iter;
@@ -290,16 +290,19 @@
 
        if (type & BM_VERT) {
                for (head = BMIter_New(&iter, bm, BM_VERTS_OF_MESH, NULL); 
head; head=BMIter_Step(&iter)) {
+                       if (respecthide && BM_TestHFlag(head, BM_HIDDEN)) 
continue;
                        if (head->flag & flag) tot++;
                }
        }
        if (type & BM_EDGE) {
                for (head = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL); 
head; head=BMIter_Step(&iter)) {
+                       if (respecthide && BM_TestHFlag(head, BM_HIDDEN)) 
continue;
                        if (head->flag & flag) tot++;
                }
        }
        if (type & BM_FACE) {
                for (head = BMIter_New(&iter, bm, BM_FACES_OF_MESH, NULL); 
head; head=BMIter_Step(&iter)) {
+                       if (respecthide && BM_TestHFlag(head, BM_HIDDEN)) 
continue;
                        if (head->flag & flag) tot++;
                }
        }
@@ -317,7 +320,7 @@
        else if(head->type == BM_FACE) BM_Select_Face(bm, (BMFace*)element, 
select);
 }
 
-int BM_Is_Selected(BMesh *bm, void *element)
+int BM_Selected(BMesh *bm, void *element)
 {
        BMHeader *head = element;
        return BM_TestHFlag(head, BM_SELECT);
@@ -500,3 +503,103 @@
                ese = nextese;
        }
 }
+
+/***************** Mesh Hiding stuff *************/
+
+#define SETHIDE(ele) hide ? BM_SetHFlag(ele, BM_HIDDEN) : BM_ClearHFlag(ele, 
BM_HIDDEN);
+
+static void vert_flush_hide(BMesh *bm, BMVert *v) {
+       BMIter iter;
+       BMEdge *e;
+
+       BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) {
+               if (!BM_TestHFlag(e, BM_HIDDEN))
+                       return;
+       }
+
+       BM_SetHFlag(v, BM_HIDDEN);
+}
+
+static void edge_flush_hide(BMesh *bm, BMEdge *e) {
+       BMIter iter;
+       BMFace *f;
+
+       BM_ITER(f, &iter, bm, BM_FACES_OF_EDGE, e) {
+               if (!BM_TestHFlag(f, BM_HIDDEN))
+                       return;
+       }
+
+       BM_SetHFlag(e, BM_HIDDEN);
+}
+
+void BM_Hide_Vert(BMesh *bm, BMVert *v, int hide)
+{
+       /*vert hiding: vert + surrounding edges and faces*/
+       BMIter iter, fiter;
+       BMEdge *e;
+       BMFace *f;
+
+       SETHIDE(v);
+
+       BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) {
+               SETHIDE(e);
+
+               BM_ITER(f, &fiter, bm, BM_FACES_OF_EDGE, e) {
+                       SETHIDE(f);
+               }
+       }
+}
+
+void BM_Hide_Edge(BMesh *bm, BMEdge *e, int hide)
+{
+       BMIter iter;
+       BMFace *f;
+       BMVert *v;
+
+       /*edge hiding: faces around the edge*/
+       BM_ITER(f, &iter, bm, BM_FACES_OF_EDGE, e) {
+               SETHIDE(f);
+       }
+       
+       SETHIDE(e);
+
+       /*hide vertices if necassary*/
+       vert_flush_hide(bm, e->v1);
+       vert_flush_hide(bm, e->v2);
+}
+
+void BM_Hide_Face(BMesh *bm, BMFace *f, int hide)
+{
+       BMIter iter;
+       BMLoop *l;
+
+       /**/
+       SETHIDE(f);
+
+       BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) {
+               edge_flush_hide(bm, l->e);
+       }
+
+       BM_ITER(l, &iter, bm, BM_LOOPS_OF_FACE, f) {
+               vert_flush_hide(bm, l->v);
+       }
+}
+
+void BM_Hide(BMesh *bm, void *element, int hide)
+{
+       BMHeader *h = element;
+
+       switch (h->type) {
+               case BM_VERT:
+                       BM_Hide_Vert(bm, element, hide);
+                       break;
+               case BM_EDGE:
+                       BM_Hide_Edge(bm, element, hide);
+                       break;
+               case BM_FACE:
+                       BM_Hide_Face(bm, element, hide);
+                       break;
+       }
+}
+
+

Modified: branches/bmesh/blender/source/blender/bmesh/intern/bmesh_operators.c
===================================================================
--- branches/bmesh/blender/source/blender/bmesh/intern/bmesh_operators.c        
2009-08-05 02:40:51 UTC (rev 22217)
+++ branches/bmesh/blender/source/blender/bmesh/intern/bmesh_operators.c        
2009-08-05 06:06:58 UTC (rev 22218)
@@ -649,14 +649,14 @@
        BMOpSlot *output = BMO_GetSlot(op, slotname);
        int totelement=0, i=0;
        
-       totelement = BM_CountFlag(bm, type, flag);
+       totelement = BM_CountFlag(bm, type, flag, 1);
 
        if(totelement){
                alloc_slot_buffer(op, slotname, totelement);
 
                if (type & BM_VERT) {
                        for (e = BMIter_New(&elements, bm, BM_VERTS_OF_MESH, 
bm); e; e = BMIter_Step(&elements)) {
-                               if(e->flag & flag) {
+                               if(!BM_TestHFlag(e, BM_HIDDEN) && 
BM_TestHFlag(e, flag)) {
                                        ((BMHeader**)output->data.p)[i] = e;
                                        i++;
                                }
@@ -665,7 +665,7 @@
 
                if (type & BM_EDGE) {
                        for (e = BMIter_New(&elements, bm, BM_EDGES_OF_MESH, 
bm); e; e = BMIter_Step(&elements)) {
-                               if(e->flag & flag){
+                               if(!BM_TestHFlag(e, BM_HIDDEN) && 
BM_TestHFlag(e, flag)) {
                                        ((BMHeader**)output->data.p)[i] = e;
                                        i++;
                                }
@@ -674,7 +674,7 @@
 
                if (type & BM_FACE) {
                        for (e = BMIter_New(&elements, bm, BM_FACES_OF_MESH, 
bm); e; e = BMIter_Step(&elements)) {
-                               if(e->flag & flag){
+                               if(!BM_TestHFlag(e, BM_HIDDEN) && 
BM_TestHFlag(e, flag)) {
                                        ((BMHeader**)output->data.p)[i] = e;
                                        i++;
                                }

Modified: branches/bmesh/blender/source/blender/editors/mesh/bmesh_select.c
===================================================================
--- branches/bmesh/blender/source/blender/editors/mesh/bmesh_select.c   
2009-08-05 02:40:51 UTC (rev 22217)
+++ branches/bmesh/blender/source/blender/editors/mesh/bmesh_select.c   
2009-08-05 06:06:58 UTC (rev 22218)
@@ -1580,7 +1580,7 @@
        int i, tot;
 
        tot = 0;
-       BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
+       BM_ITER_SELECT(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL)
                if (BM_TestHFlag(v, BM_SELECT)) {
                        V_GROW(verts);
                        verts[tot++] = v;

Modified: branches/bmesh/blender/source/blender/editors/mesh/bmesh_tools.c
===================================================================

@@ Diff output truncated at 10240 characters. @@

_______________________________________________
Bf-blender-cvs mailing list
Bf-blender-cvs@blender.org
http://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to