- add BM_NGON_STACK_SIZE define to use wherever ngon stack arrays are used.
authorCampbell Barton <ideasman42@gmail.com>
Tue, 29 Nov 2011 04:11:17 +0000 (04:11 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 29 Nov 2011 04:11:17 +0000 (04:11 +0000)
- renamed BM_Compute_Face_Center() to BM_Compute_Face_CenterBounds() and added BM_Compute_Face_CenterMean() since there was code inline to find the mean center in transform.

13 files changed:
source/blender/blenkernel/intern/mesh.c
source/blender/bmesh/bmesh.h
source/blender/bmesh/intern/bmesh_construct.c
source/blender/bmesh/intern/bmesh_interp.c
source/blender/bmesh/intern/bmesh_marking.c
source/blender/bmesh/intern/bmesh_newcore.c
source/blender/bmesh/intern/bmesh_polygon.c
source/blender/bmesh/operators/extrudeops.c
source/blender/bmesh/operators/subdivideop.c
source/blender/bmesh/operators/utils.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/transform/transform_conversions.c
source/blender/modifiers/intern/MOD_solidify.c

index f1dd519a3268645e6ca51209ffd264c2997cc55f..86b4fa6ac42f86f51db4ab191145f863be26481b 100644 (file)
@@ -2596,7 +2596,7 @@ float mesh_calc_poly_area(MPoly *mpoly, MLoop *loopstart,
                int i;
                float area, polynorm_local[3], (*vertexcos)[3] = NULL;
                float *no= polynormal ? polynormal : polynorm_local;
-               BLI_array_staticdeclare(vertexcos, 10);
+               BLI_array_staticdeclare(vertexcos, BM_NGON_STACK_SIZE);
 
                BLI_array_growitems(vertexcos, mpoly->totloop);
 
index 6ce8e3790420d452e6cef10fd1847cd093881432..e5873c161ae24ef8cfe97595cdeb60d20f39fed5 100644 (file)
@@ -284,7 +284,9 @@ float BM_GetCDf(struct CustomData *cd, void *element, int type);
 void BM_SetCDf(struct CustomData *cd, void *element, int type, float val);
 
 /*computes the centroid of a face, using the center of the bounding box*/
-int BM_Compute_Face_Center ( BMesh *bm, BMFace *f, float center[3] );
+void BM_Compute_Face_CenterBounds(BMesh *bm, BMFace *f, float center[3]);
+/*computes the centroid of a face, using the mean average*/
+void BM_Compute_Face_CenterMean(BMesh *bm, BMFace *f, float center[3]);
 
 void BM_SelectMode_Flush ( BMesh *bm );
 
@@ -347,6 +349,11 @@ void bmesh_end_edit(struct BMesh *bm, int flag);
 
 #define bm_firstfaceloop(p) ((BMLoopList*)(p->loops.first))->first
 
+/* size to use for static arrays when dealing with NGons,
+ * alloc after this limit is reached.
+ * this value is rather arbitrary */
+#define BM_NGON_STACK_SIZE 32
+
 /*include the rest of the API*/
 #include "bmesh_filters.h"
 #include "bmesh_iterators.h"
index b046972987acae85f58b4aa0e1280ac9d3403d90..1b228c84c91f8f18aa1ed9a4d85c5c1a08326aee 100644 (file)
@@ -257,13 +257,12 @@ void BM_Face_CopyShared(BMesh *bm, BMFace *f)
  * BM_Make_Face should be considered over this function as it
  * avoids some unnecessary work.
 */
-#define VERT_BUF_SIZE 100
 BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, int nodouble)
 {
        BMEdge **edges2 = NULL;
-       BLI_array_staticdeclare(edges2, VERT_BUF_SIZE);
+       BLI_array_staticdeclare(edges2, BM_NGON_STACK_SIZE);
        BMVert **verts = NULL, *v;
-       BLI_array_staticdeclare(verts, VERT_BUF_SIZE);
+       BLI_array_staticdeclare(verts, BM_NGON_STACK_SIZE);
        BMFace *f = NULL;
        BMEdge *e;
        BMVert *ev1, *ev2;
index 54d6d8dc4738fe56ade27cf22ae7a9742a6c3a6f..65aaa2203a4ff2c4178d8fdbdcc70b2d71be90cf 100644 (file)
@@ -188,9 +188,9 @@ void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source)
        BMLoop *l1, *l2;
        void **blocks=NULL;
        float (*cos)[3]=NULL, *w=NULL;
-       BLI_array_staticdeclare(cos, 64);
-       BLI_array_staticdeclare(w, 64);
-       BLI_array_staticdeclare(blocks, 64);
+       BLI_array_staticdeclare(cos,     BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(w,       BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(blocks,  BM_NGON_STACK_SIZE);
        
        BM_Copy_Attributes(bm, bm, source, target);
        
@@ -698,10 +698,10 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
        void **blocks=NULL;
        void **vblocks=NULL;
        float (*cos)[3]=NULL, co[3], *w=NULL, cent[3] = {0.0f, 0.0f, 0.0f};
-       BLI_array_staticdeclare(cos, 64);
-       BLI_array_staticdeclare(w, 64);
-       BLI_array_staticdeclare(blocks, 64);
-       BLI_array_staticdeclare(vblocks, 64);
+       BLI_array_staticdeclare(cos,      BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(w,        BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(blocks,   BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(vblocks,  BM_NGON_STACK_SIZE);
        int i, xn, yn, zn, ax, ay;
        
        BM_Copy_Attributes(bm, bm, source, target->f);
@@ -775,9 +775,9 @@ void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source)
        BMLoop *l;
        void **blocks=NULL;
        float (*cos)[3]=NULL, *w=NULL, cent[3] = {0.0f, 0.0f, 0.0f};
-       BLI_array_staticdeclare(cos, 64);
-       BLI_array_staticdeclare(w, 64);
-       BLI_array_staticdeclare(blocks, 64);
+       BLI_array_staticdeclare(cos,     BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(w,       BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(blocks,  BM_NGON_STACK_SIZE);
        int i;
        
        l = bm_firstfaceloop(source);
index 142d2f6604b10d691eaa38871c714a7f15c7c07f..81e7bcb1b9df67acf6355d3cfe9c46a104c45d36 100644 (file)
@@ -450,7 +450,7 @@ void BM_editselection_center(BMesh *bm, float *center, BMEditSelection *ese)
        }
        else if (ese->htype == BM_FACE) {
                BMFace *efa= ese->data;
-               BM_Compute_Face_Center(bm, efa, center);
+               BM_Compute_Face_CenterBounds(bm, efa, center);
        }
 }
 
index bd7664673e9954484c4de35e0d867eef92816755..bec970903d4a6b08d8db8b8e312cba1bed40dde7 100644 (file)
@@ -202,8 +202,8 @@ BMFace *BM_Copy_Face(BMesh *bm, BMFace *f, int copyedges, int copyverts)
 {
        BMEdge **edges = NULL;
        BMVert **verts = NULL;
-       BLI_array_staticdeclare(edges, 256);
-       BLI_array_staticdeclare(verts, 256);
+       BLI_array_staticdeclare(edges, BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(verts, BM_NGON_STACK_SIZE);
        BMLoop *l, *l2;
        BMFace *f2;
        int i;
@@ -457,7 +457,7 @@ static void bmesh_kill_loop(BMesh *bm, BMLoop *l)
 void BM_Kill_Face_Edges(BMesh *bm, BMFace *f)
 {
        BMEdge **edges = NULL;
-       BLI_array_staticdeclare(edges, 256);
+       BLI_array_staticdeclare(edges, BM_NGON_STACK_SIZE);
        BMLoop *l;
        int i;
        
@@ -477,7 +477,7 @@ void BM_Kill_Face_Edges(BMesh *bm, BMFace *f)
 void BM_Kill_Face_Verts(BMesh *bm, BMFace *f)
 {
        BMVert**verts = NULL;
-       BLI_array_staticdeclare(verts, 256);
+       BLI_array_staticdeclare(verts, BM_NGON_STACK_SIZE);
        BMLoop *l;
        int i;
        
@@ -623,7 +623,7 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f, BMLoopList *lst)
        BMLoop *l = lst->first, *curloop, *oldprev, *oldnext;
        BMEdge **edar = NULL;
        MDisps *md;
-       BLI_array_staticdeclare(edar, 64);
+       BLI_array_staticdeclare(edar, BM_NGON_STACK_SIZE);
        int i, j, edok, len = 0, do_disps = CustomData_has_layer(&bm->ldata, CD_MDISPS);
 
        len = bmesh_loop_length(l);
@@ -818,9 +818,9 @@ BMFace *BM_Join_Faces(BMesh *bm, BMFace **faces, int totface)
        BMEdge **edges = NULL;
        BMEdge **deledges = NULL;
        BMVert **delverts = NULL;
-       BLI_array_staticdeclare(edges, 64);
-       BLI_array_staticdeclare(deledges, 64);
-       BLI_array_staticdeclare(delverts, 64);
+       BLI_array_staticdeclare(edges,    BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(deledges, BM_NGON_STACK_SIZE);
+       BLI_array_staticdeclare(delverts, BM_NGON_STACK_SIZE);
        BMVert *v1=NULL, *v2=NULL;
        ListBase holes = {NULL, NULL};
        const char *err = NULL;
@@ -1147,7 +1147,8 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2,
  *
 */
 
-BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re){
+BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
+{
        BMLoop *nextl;
        BMEdge *ne;
        BMVert *nv, *ov;
@@ -1340,7 +1341,7 @@ int bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv)
        BMLoop *killoop, *l;
        int len,radlen=0, halt = 0, i, valence1, valence2,edok;
        BMLoop **loops = NULL;
-       BLI_array_staticdeclare(loops, 256);
+       BLI_array_staticdeclare(loops, BM_NGON_STACK_SIZE);
 
        if(bmesh_vert_in_edge(ke,kv) == 0) return 0;
        len = bmesh_disk_count(kv);
index b4c7d386a61d2b422a11d2d761486026cd808bd9..15ded2dc909784c627ee5cc88383ac34ce622b03 100644 (file)
@@ -225,11 +225,11 @@ float BM_face_area(BMFace *f)
 {
        BMLoop *l;
        BMIter iter;
-       float (*verts)[3], stackv[100][3];
+       float (*verts)[3], stackv[BM_NGON_STACK_SIZE][3];
        float area, center[3];
        int i;
 
-       if (f->len <= 100) 
+       if (f->len <= BM_NGON_STACK_SIZE)
                verts = stackv;
        else verts = MEM_callocN(sizeof(float)*f->len*3, "bm_face_area tmp");
 
@@ -241,7 +241,7 @@ float BM_face_area(BMFace *f)
 
        compute_poly_center(center, &area, verts, f->len);
 
-       if (f->len > 100)
+       if (f->len > BM_NGON_STACK_SIZE)
                MEM_freeN(verts);
 
        return area;
@@ -250,7 +250,7 @@ float BM_face_area(BMFace *f)
 computes center of face in 3d.  uses center of bounding box.
 */
 
-int BM_Compute_Face_Center(BMesh *bm, BMFace *f, float center[3])
+void BM_Compute_Face_CenterBounds(BMesh *bm, BMFace *f, float r_cent[3])
 {
        BMIter iter;
        BMLoop *l;
@@ -263,9 +263,23 @@ int BM_Compute_Face_Center(BMesh *bm, BMFace *f, float center[3])
                DO_MINMAX(l->v->co, min, max);
        }
 
-       mid_v3_v3v3(center, min, max);
-       
-       return 0;
+       mid_v3_v3v3(r_cent, min, max);
+}
+
+void BM_Compute_Face_CenterMean(BMesh *bm, BMFace *f, float r_cent[3])
+{
+       BMIter iter;
+       BMLoop *l;
+       int i;
+
+       zero_v3(r_cent);
+
+       l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f);
+       for (i=0; l; l=BMIter_Step(&iter), i++) {
+               add_v3_v3(r_cent, l->v->co);
+       }
+
+       mul_v3_fl(r_cent, 1.0f / (float)f->len);
 }
 
 /*
@@ -404,8 +418,8 @@ void poly_rotate_plane(float normal[3], float (*verts)[3], int nverts)
 
 void BM_Face_UpdateNormal(BMesh *bm, BMFace *f)
 {
-       float projverts[200][3];
-       float (*proj)[3] = f->len < 200 ? projverts : MEM_mallocN(sizeof(float)*f->len*3, "projvertsn");
+       float projverts[BM_NGON_STACK_SIZE][3];
+       float (*proj)[3] = f->len < BM_NGON_STACK_SIZE ? projverts : MEM_mallocN(sizeof(float)*f->len*3, "projvertsn");
 
        if (f->len < 3) return;
 
@@ -854,15 +868,15 @@ void BM_LegalSplits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len)
        BMLoop *l;
        float v1[3], v2[3], v3[3]/*, v4[3]*/, no[3], mid[3], *p1, *p2, *p3, *p4;
        float out[3] = {-234324.0f, -234324.0f, 0.0f};
-       float projectverts[100][3];
-       float edgevertsstack[200][3];
+       float projectverts[BM_NGON_STACK_SIZE][3];
+       float edgevertsstack[BM_NGON_STACK_SIZE * 2][3];
        float (*projverts)[3] = projectverts;
        float (*edgeverts)[3] = edgevertsstack;
        float fac1 = 1.0000001f, fac2 = 0.9f; //9999f; //0.999f;
        int i, j, a=0, clen;
 
-       if (f->len > 100) projverts = MEM_mallocN(sizeof(float)*3*f->len, "projvertsb");
-       if (len > 100) edgeverts = MEM_mallocN(sizeof(float)*3*2*len, "edgevertsb");
+       if (f->len > BM_NGON_STACK_SIZE) projverts = MEM_mallocN(sizeof(float)*3*f->len, "projvertsb");
+       if (len > (BM_NGON_STACK_SIZE * 2)) edgeverts = MEM_mallocN(sizeof(float)*3*2*len, "edgevertsb");
        
        i = 0;
        l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, f);
index 1750f7a36c46e75259c920a52d2a62f71f12b7da..e70ed3af26320d3f2e1c978ae4fdf2e9f5a7aace 100644 (file)
@@ -500,10 +500,10 @@ static void solidify_add_thickness(BMesh *bm, float dist)
 
        /* array for passing verts to angle_poly_v3 */
        float **verts = NULL;
-       BLI_array_staticdeclare(verts, 16);
+       BLI_array_staticdeclare(verts, BM_NGON_STACK_SIZE);
        /* array for receiving angles from angle_poly_v3 */
        float *angles = NULL;
-       BLI_array_staticdeclare(angles, 16);
+       BLI_array_staticdeclare(angles, BM_NGON_STACK_SIZE);
 
        BM_ElemIndex_Ensure(bm, BM_VERT);
 
index 535862b9dd68b726637e3d1dacf5de6b2d8471bf..ba550d644b79ba25b5fec596e56cf538ed8ac0ec 100644 (file)
@@ -136,7 +136,8 @@ for (i=0; i<lvl; i++, df /= 4.0f) {
 #endif
 /*connects face with smallest len, which I think should always be correct for
   edge subdivision*/
-static BMEdge *connect_smallest_face(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf) {
+static BMEdge *connect_smallest_face(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **nf)
+{
        BMIter iter, iter2;
        BMVert *v;
        BMLoop *nl;
@@ -164,7 +165,7 @@ static BMEdge *connect_smallest_face(BMesh *bm, BMVert *v1, BMVert *v2, BMFace *
 }
 /* calculates offset for co, based on fractal, sphere or smooth settings  */
 static void alter_co(BMesh *bm, BMVert *v, BMEdge *UNUSED(origed), const subdparams *params, float perc,
-                    BMVert *vsta, BMVert *vend)
+                     BMVert *vsta, BMVert *vend)
 {
        float tvec[3], prev_co[3], fac;
        float *co=NULL;
index 9cc3571adf31969d85576d6812b275898c01c176..101744363a39200d3984c0d73fe44046670dd119 100644 (file)
@@ -280,7 +280,7 @@ void bmesh_righthandfaces_exec(BMesh *bm, BMOperator *op)
 
                if (!startf) startf = f;
 
-               BM_Compute_Face_Center(bm, f, cent);
+               BM_Compute_Face_CenterBounds(bm, f, cent);
 
                cent[0] = cent[0]*cent[0] + cent[1]*cent[1] + cent[2]*cent[2];
                if (cent[0] > maxx) {
@@ -291,7 +291,7 @@ void bmesh_righthandfaces_exec(BMesh *bm, BMOperator *op)
 
        if (!startf) return;
 
-       BM_Compute_Face_Center(bm, startf, cent);
+       BM_Compute_Face_CenterBounds(bm, startf, cent);
 
        /*make sure the starting face has the correct winding*/
        if (dot_v3v3(cent, startf->no) < 0.0f) {
index e0b8a3241ea9bf07671eb2f702dde7ea9809d77f..6eb148eded1e255cd232000efa07941729762b3f 100644 (file)
@@ -2734,7 +2734,7 @@ static void draw_em_measure_stats(View3D *v3d, RegionView3D *rv3d,
                        BMIter liter;
                        BMLoop *loop;
 
-                       BM_Compute_Face_Center(em->bm, efa, vmid);
+                       BM_Compute_Face_CenterBounds(em->bm, efa, vmid);
 
                        for(loop = BMIter_New(&liter, em->bm, BM_LOOPS_OF_FACE, efa);
                            loop; loop = BMIter_Step(&liter)) {
index 528a0e1c8fd0ee756b969cc777ace64276fe083f..e4db5562ddf33b764e8342f98378190e33781ccb 100644 (file)
@@ -1911,26 +1911,21 @@ static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], f
 }
 
 /* loop-in-a-loop I know, but we need it! (ton) */
- static void get_face_center(float *centout, BMesh *bm, BMVert *eve)
+ static void get_face_center(float cent_r[3], BMesh *bm, BMVert *eve)
 
 {
        BMFace *efa;
-       BMLoop *l;
        BMIter iter;
-       float cent[3] = {0.0, 0.0, 0.0};
 
        efa = BMIter_New(&iter, bm, BM_FACES_OF_VERT, eve);
        if (efa) {
-               l = BMIter_New(&iter, bm, BM_LOOPS_OF_FACE, efa);
-               for ( ; l; l=BMIter_Step(&iter)) {
-                       VECADD(cent, cent, l->v->co);
-               }
-
-               mul_v3_fl(cent, 1.0f / (float)efa->len);
+               BM_Compute_Face_CenterMean(bm, efa, cent_r);
+       }
+       else {
+               zero_v3(cent_r);
        }
 
-       if (cent[0] == 0.0f && cent[1] == 0.0f && cent[2] == 0.0f) cent[2] = 1.0f;
-       copy_v3_v3(centout, cent);
+       if (is_zero_v3(cent_r)) cent_r[2] = 1.0f;
 }
 
 #define VertsToTransData(t, td, em, eve, bweight) \
index d01117aa4bdbbc96588597ffb6734ae959028c0f..a11fd360c164f70294d83082ee2ed8d8f3c16e66 100644 (file)
@@ -434,7 +434,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
                float *vert_angles= MEM_callocN(sizeof(float) * numVerts * 2, "mod_solid_pair"); /* 2 in 1 */
                float *vert_accum= vert_angles + numVerts;
                float *face_angles = NULL;
-               BLI_array_staticdeclare(face_angles, 16);
+               BLI_array_staticdeclare(face_angles, 16); /* BM_NGON_STACK_SIZE */
                int j, vidx;
 
                face_nors = CustomData_get_layer(&dm->polyData, CD_NORMAL);