Minor Improvements...
authorCampbell Barton <ideasman42@gmail.com>
Sun, 5 Feb 2012 23:09:07 +0000 (23:09 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sun, 5 Feb 2012 23:09:07 +0000 (23:09 +0000)
- more efficient array growing
- use BM_NGON_STACK_SIZE for more static arrays
- dont use BLI_array for bevel code where size is known.

source/blender/blenkernel/intern/mesh.c
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/bmesh/intern/bmesh_newcore.c
source/blender/bmesh/operators/createops.c
source/blender/bmesh/operators/dissolveops.c
source/blender/editors/mesh/bmesh_tools.c

index 39e103734419a654129064356272600f40e09732..7d13cf86687049dbaa986ef6b472b0a857332111 100644 (file)
@@ -1756,10 +1756,13 @@ void mesh_calc_normals(MVert *mverts, int numVerts, MLoop *mloop, MPoly *mpolys,
 
                BLI_array_empty(vertcos);
                BLI_array_empty(vertnos);
-               for (j=0; j<mp->totloop; j++) {
+               BLI_array_growitems(vertcos, mp->totloop);
+               BLI_array_growitems(vertnos, mp->totloop);
+
+               for (j=0; j < mp->totloop; j++) {
                        int vindex = ml[j].v;
-                       BLI_array_append(vertcos, mverts[vindex].co);
-                       BLI_array_append(vertnos, tnorms[vindex]);
+                       vertcos[j] = mverts[vindex].co;
+                       vertnos[j] = tnorms[vindex];
                }
 
                BLI_array_empty(edgevecbuf);
index 483897b94eaef20f64a94fc1684dc4186736bd3d..c419043896a9d9fa9e1645c188512d9b4d1b1b1a 100644 (file)
@@ -552,10 +552,11 @@ static void ss_sync_from_derivedmesh(CCGSubSurf *ss, DerivedMesh *dm,
                CCGFace *f;
 
                BLI_array_empty(fVerts);
+               BLI_array_growitems(fVerts, mp->totloop);
 
                ml = mloop + mp->loopstart;
                for (j=0; j<mp->totloop; j++, ml++) {
-                       BLI_array_append(fVerts, SET_INT_IN_POINTER(ml->v));
+                       fVerts[j] = SET_INT_IN_POINTER(ml->v);
                }
 
                /* this is very bad, means mesh is internally inconsistent.
index 56a24e0fd731f33a9127a584f37dc8c57b45d98a..dfc241b6037d823f5d4dd6cd6aa9c15f45c4c343 100644 (file)
@@ -1691,7 +1691,7 @@ static int bmesh_cutvert(BMesh *bm, BMVert *v, BMVert ***vout, int *len)
                BLI_array_append(stack, e);
 
                /* Considering only edges and faces incident on vertex v, walk
-                  the edges & faces and assign an index to each connected set */
+                * the edges & faces and assign an index to each connected set */
                while ((e = BLI_array_pop(stack))) {
                        BLI_ghash_insert(visithash, e, SET_INT_IN_POINTER(maxindex));
 
@@ -1721,11 +1721,11 @@ static int bmesh_cutvert(BMesh *bm, BMVert *v, BMVert ***vout, int *len)
                }
 
                /* Loops here should alway refer to an edge that has v as an
-                  endpoint. For each appearance of this vert in a face, there
-                  will actually be two iterations: one for the loop heading
-                  towards vertex v, and another for the loop heading out from
-                  vertex v. Only need to swap the vertex on one of those times,
-                  on the outgoing loop. */
+                * endpoint. For each appearance of this vert in a face, there
+                * will actually be two iterations: one for the loop heading
+                * towards vertex v, and another for the loop heading out from
+                * vertex v. Only need to swap the vertex on one of those times,
+                * on the outgoing loop. */
                if (l->v == v) {
                        l->v = verts[i];
                }
index d81122e42fb96eae8e24d53dbf109f7a218aa3e4..c6530b47cea3a5ca6668316abd79ee70119defd6 100644 (file)
@@ -145,15 +145,16 @@ static BMEdge *rotsys_prevedge(BMEdge *e, BMVert *v,
 static void rotsys_reverse(struct BMEdge *UNUSED(e), struct BMVert *v, EdgeData *edata, VertData *vdata)
 {
        BMEdge **edges = NULL;
-       BMEdge *e2;
-       BLI_array_staticdeclare(edges, 256);
+       BMEdge *e_first;
+       BMEdge *e;
+       BLI_array_staticdeclare(edges, BM_NGON_STACK_SIZE);
        int i, totedge;
        
-       e2 = vdata[BM_GetIndex(v)].e;
+       e = e_first = vdata[BM_GetIndex(v)].e;
        do {
-               BLI_array_append(edges, e2);
-               e2 = rotsys_nextedge(e2, v, edata, vdata);
-       } while (e2 != vdata[BM_GetIndex(v)].e);
+               BLI_array_append(edges, e);
+               e = rotsys_nextedge(e, v, edata, vdata);
+       } while (e != e_first);
        
        totedge = BLI_array_count(edges);
        for (i=0; i<totedge/2; i++) {
@@ -229,8 +230,9 @@ static int UNUSED_FUNCTION(rotsys_fill_faces)(BMesh *bm, EdgeData *edata, VertDa
                                continue;
                                
                        do {
-                               if (BLI_smallhash_haskey(hash, (intptr_t)e2) 
-                                || BLI_smallhash_haskey(hash, (intptr_t)v)) {
+                               if (BLI_smallhash_haskey(hash, (intptr_t)e2) ||
+                                   BLI_smallhash_haskey(hash, (intptr_t)v))
+                               {
                                        ok = 0;
                                        break;
                                }
@@ -333,10 +335,10 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata)
        BMIter iter;
        BMEdge *e;
        BMEdge **edges = NULL;
-       BLI_array_staticdeclare(edges, 256);
+       BLI_array_staticdeclare(edges, BM_NGON_STACK_SIZE);
        BMVert *v;
        /*BMVert **verts = NULL; */
-       /*BLI_array_staticdeclare(verts, 256);*/ /*UNUSED*/
+       /*BLI_array_staticdeclare(verts, BM_NGON_STACK_SIZE);*/ /*UNUSED*/
        int i;
        
        #define SIGN(n) ((n)<0.0f)
index f247c89b0af0e3aa09068c22d2d29c4364f5819f..d37435816844a57514fa08b39ae59d97c4edfdb2 100644 (file)
@@ -158,9 +158,7 @@ void dissolve_edgeloop_exec(BMesh *bm, BMOperator *op)
        }
 
        BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
-               if (BMO_TestFlag(bm, v, VERT_MARK) && 
-                       BM_Vert_EdgeCount(v) == 2)
-               {
+               if (BMO_TestFlag(bm, v, VERT_MARK) && BM_Vert_EdgeCount(v) == 2) {
                        BLI_array_append(verts, v);
                }
        }
index a01b05934871718a861934128a4f0cd9a00e45d2..82b2e3322ed04db503e5cdb724356a8e7e327607 100644 (file)
@@ -4486,7 +4486,6 @@ static int mesh_bevel_exec(bContext *C, wmOperator *op)
        const int use_dist= RNA_boolean_get(op->ptr, "use_dist");
        float *w = NULL, ftot;
        int li;
-       BLI_array_declare(w);
        
        BM_add_data_layer(em->bm, &em->bm->edata, CD_PROP_FLT);
        li = CustomData_number_of_layers(&em->bm->edata, CD_PROP_FLT)-1;
@@ -4500,23 +4499,25 @@ static int mesh_bevel_exec(bContext *C, wmOperator *op)
        
        if (em==NULL) return OPERATOR_CANCELLED;
        
+       w = MEM_mallocN(sizeof(float) * recursion, "bevel weights");
+
        /*ugh, stupid math depends somewhat on angles!*/
        /* dfac = 1.0/(float)(recursion+1); */ /* UNUSED */
        df = 1.0;
        for (i=0, ftot=0.0f; i<recursion; i++) {
-               s = pow(df, 1.25);
-               
-               BLI_array_append(w, s);
+               s = powf(df, 1.25f);
+
+               w[i] = s;
                ftot += s;
-               
+
                df *= 2.0;
        }
 
-       mul_vn_fl(w, BLI_array_count(w), 1.0f / (float)ftot);
+       mul_vn_fl(w, recursion, 1.0f / (float)ftot);
 
        fac = factor;
-       for (i=0; i<BLI_array_count(w); i++) {
-               fac = w[BLI_array_count(w)-i-1]*factor;
+       for (i=0; i < recursion; i++) {
+               fac = w[recursion-i-1]*factor;
 
                if (!EDBM_InitOpf(em, &bmop, op, "bevel geom=%hev percent=%f lengthlayer=%i use_lengths=%i use_even=%i use_dist=%i", BM_SELECT, fac, li, 1, use_even, use_dist))
                        return OPERATOR_CANCELLED;
@@ -4528,7 +4529,8 @@ static int mesh_bevel_exec(bContext *C, wmOperator *op)
        
        BM_free_data_layer_n(em->bm, &em->bm->edata, CD_MASK_PROP_FLT, li);
        
-       BLI_array_free(w);
+       MEM_freeN(w);
+
        EDBM_RecalcNormals(em);
 
        DAG_id_tag_update(obedit->data, 0);