replace BLI_array_fixedstack_declare with() new macro BLI_array_alloca() which uses...
authorCampbell Barton <ideasman42@gmail.com>
Tue, 11 Dec 2012 15:10:19 +0000 (15:10 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 11 Dec 2012 15:10:19 +0000 (15:10 +0000)
source/blender/blenkernel/intern/mesh.c
source/blender/blenlib/BLI_array.h
source/blender/bmesh/intern/bmesh_construct.c
source/blender/bmesh/intern/bmesh_core.c
source/blender/bmesh/intern/bmesh_interp.c
source/blender/bmesh/intern/bmesh_polygon.c
source/blender/bmesh/intern/bmesh_queries.c
source/blender/bmesh/operators/bmo_extrude.c
source/blender/bmesh/tools/bmesh_bevel.c
source/blender/editors/mesh/editmesh_knife.c
source/blender/editors/uvedit/uvedit_unwrap_ops.c

index 036f8f5e6732f748a7d61e1c7dad0ea67cc94e24..75504416067512130ce5bb99ffa576f33483e4fd 100644 (file)
@@ -3009,9 +3009,9 @@ float BKE_mesh_calc_poly_area(MPoly *mpoly, MLoop *loopstart,
        else {
                int i;
                MLoop *l_iter = loopstart;
-               float area, polynorm_local[3], (*vertexcos)[3];
+               float area, polynorm_local[3];
+               float (*vertexcos)[3] = BLI_array_alloca(vertexcos, mpoly->totloop);
                const float *no = polynormal ? polynormal : polynorm_local;
-               BLI_array_fixedstack_declare(vertexcos, BM_DEFAULT_NGON_STACK_SIZE, mpoly->totloop, __func__);
 
                /* pack vertex cos into an array for area_poly_v3 */
                for (i = 0; i < mpoly->totloop; i++, l_iter++) {
@@ -3026,8 +3026,6 @@ float BKE_mesh_calc_poly_area(MPoly *mpoly, MLoop *loopstart,
                /* finally calculate the area */
                area = area_poly_v3(mpoly->totloop, vertexcos, no);
 
-               BLI_array_fixedstack_free(vertexcos);
-
                return area;
        }
 }
index a21778307c193c047d74dd90ee56d2c496649ac1..975476a669b3da69eef521985aa7a52fe64fe35e 100644 (file)
        if (_##arr##_is_static) {                                                 \
                MEM_freeN(arr);                                                       \
        } (void)0
+
+
+/* alloca */
+#if defined(__GNUC__) || defined(__clang__)
+#define BLI_array_alloca(arr, realsize) \
+       (typeof(arr))alloca(sizeof(*arr) * (realsize))
+
+#define BLI_array_alloca_and_count(arr, realsize) \
+       (typeof(arr))alloca(sizeof(*arr) * (realsize));  \
+       const int _##arr##_count = (realsize)
+
+#else
+#define BLI_array_alloca(arr, realsize) \
+       alloca(sizeof(*arr) * (realsize))
+
+#define BLI_array_alloca_and_count(arr, realsize) \
+       alloca(sizeof(*arr) * (realsize));  \
+       const int _##arr##_count = (realsize)
+#endif
index 8b7fac1eacd145b777e929eee5675d3897faef18..e12110b31cae3d1e99d90f4737b8491ed21f3402 100644 (file)
@@ -173,15 +173,17 @@ void BM_face_copy_shared(BMesh *bm, BMFace *f)
  */
 BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len, const int create_flag)
 {
-       BMEdge **edges2 = NULL;
-       BLI_array_staticdeclare(edges2, BM_DEFAULT_NGON_STACK_SIZE);
-       BMVert **verts = NULL;
-       BLI_array_staticdeclare(verts, BM_DEFAULT_NGON_STACK_SIZE);
+       BMEdge **edges2 = BLI_array_alloca_and_count(edges2, len);
+       BMVert **verts = BLI_array_alloca_and_count(verts, len + 1);
+       int e2_index = 0;
+       int v_index = 0;
+
        BMFace *f = NULL;
        BMEdge *e;
        BMVert *v, *ev1, *ev2;
        int i, /* j, */ v1found, reverse;
 
+
        /* this code is hideous, yeek.  I'll have to think about ways of
         *  cleaning it up.  basically, it now combines the old BM_face_create_ngon
         *  _and_ the old bmesh_mf functions, so its kindof smashed together
@@ -207,14 +209,14 @@ BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, i
                SWAP(BMVert *, ev1, ev2);
        }
 
-       BLI_array_append(verts, ev1);
+       verts[v_index++] = ev1;
        v = ev2;
        e = edges[0];
        do {
                BMEdge *e2 = e;
 
-               BLI_array_append(verts, v);
-               BLI_array_append(edges2, e);
+               verts[v_index++] = v;
+               edges2[e2_index++] = e;
 
                /* we only flag the verts to check if they are in the face more then once */
                BM_ELEM_API_FLAG_ENABLE(v, _FLAG_MV);
@@ -289,9 +291,6 @@ BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, i
                BM_ELEM_API_FLAG_DISABLE(edges2[i], _FLAG_MF);
        }
 
-       BLI_array_free(verts);
-       BLI_array_free(edges2);
-
        return f;
 
 err:
@@ -303,9 +302,6 @@ err:
                }
        }
 
-       BLI_array_free(verts);
-       BLI_array_free(edges2);
-
        return NULL;
 }
 
index b9feead0d45f711d14ce00a00d1e40f564cb4f61..4442b4eac9c3dfe502f37fa9fd9213b8541ca400 100644 (file)
@@ -211,10 +211,8 @@ static BMLoop *bm_face_boundary_add(BMesh *bm, BMFace *f, BMVert *startv, BMEdge
 
 BMFace *BM_face_copy(BMesh *bm, BMFace *f, const short copyverts, const short copyedges)
 {
-       BMVert **verts = NULL;
-       BMEdge **edges = NULL;
-       BLI_array_fixedstack_declare(verts, BM_DEFAULT_NGON_STACK_SIZE, f->len, __func__);
-       BLI_array_fixedstack_declare(edges, BM_DEFAULT_NGON_STACK_SIZE, f->len, __func__);
+       BMVert **verts = BLI_array_alloca(verts, f->len);
+       BMEdge **edges = BLI_array_alloca(edges, f->len);
        BMLoop *l_iter;
        BMLoop *l_first;
        BMLoop *l_copy;
@@ -267,9 +265,6 @@ BMFace *BM_face_copy(BMesh *bm, BMFace *f, const short copyverts, const short co
                l_copy = l_copy->next;
        } while ((l_iter = l_iter->next) != l_first);
 
-       BLI_array_fixedstack_free(verts);
-       BLI_array_fixedstack_free(edges);
-
        return f_copy;
 }
 
@@ -585,22 +580,19 @@ static void bm_kill_only_loop(BMesh *bm, BMLoop *l)
  */
 void BM_face_edges_kill(BMesh *bm, BMFace *f)
 {
-       BMEdge **edges = NULL;
-       BLI_array_staticdeclare(edges, BM_DEFAULT_NGON_STACK_SIZE);
+       BMEdge **edges = BLI_array_alloca_and_count(edges, f->len);
        BMLoop *l_iter;
        BMLoop *l_first;
-       int i;
+       int i = 0;
        
        l_iter = l_first = BM_FACE_FIRST_LOOP(f);
        do {
-               BLI_array_append(edges, l_iter->e);
+               edges[i++] = l_iter->e;
        } while ((l_iter = l_iter->next) != l_first);
        
        for (i = 0; i < BLI_array_count(edges); i++) {
                BM_edge_kill(bm, edges[i]);
        }
-       
-       BLI_array_free(edges);
 }
 
 /**
@@ -609,22 +601,19 @@ void BM_face_edges_kill(BMesh *bm, BMFace *f)
  */
 void BM_face_verts_kill(BMesh *bm, BMFace *f)
 {
-       BMVert **verts = NULL;
-       BLI_array_staticdeclare(verts, BM_DEFAULT_NGON_STACK_SIZE);
+       BMVert **verts = BLI_array_alloca_and_count(verts, f->len);
        BMLoop *l_iter;
        BMLoop *l_first;
-       int i;
+       int i = 0;
        
        l_iter = l_first = BM_FACE_FIRST_LOOP(f);
        do {
-               BLI_array_append(verts, l_iter->v);
+               verts[i++] = l_iter->v;
        } while ((l_iter = l_iter->next) != l_first);
        
        for (i = 0; i < BLI_array_count(verts); i++) {
                BM_vert_kill(bm, verts[i]);
        }
-       
-       BLI_array_free(verts);
 }
 
 /**
@@ -761,8 +750,7 @@ static int bm_loop_reverse_loop(BMesh *bm, BMFace *f
        const int len = f->len;
        const int do_disps = CustomData_has_layer(&bm->ldata, CD_MDISPS);
        BMLoop *l_iter, *oldprev, *oldnext;
-       BMEdge **edar = NULL;
-       BLI_array_fixedstack_declare(edar, BM_DEFAULT_NGON_STACK_SIZE, len, __func__);
+       BMEdge **edar = BLI_array_alloca(edar, len);
        int i, j, edok;
 
        for (i = 0, l_iter = l_first; i < len; i++, l_iter = l_iter->next) {
@@ -826,8 +814,6 @@ static int bm_loop_reverse_loop(BMesh *bm, BMFace *f
                BM_CHECK_ELEMENT(l_iter->f);
        }
 
-       BLI_array_fixedstack_free(edar);
-
        BM_CHECK_ELEMENT(f);
 
        return 1;
@@ -1614,8 +1600,7 @@ BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_dou
                                radlen = bmesh_radial_length(ke->l);
 
                                if (LIKELY(radlen)) {
-                                       BMLoop **loops = NULL;
-                                       BLI_array_fixedstack_declare(loops, BM_DEFAULT_NGON_STACK_SIZE, radlen, __func__);
+                                       BMLoop **loops = BLI_array_alloca(loops, radlen);
 
                                        killoop = ke->l;
 
@@ -1628,7 +1613,6 @@ BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_dou
                                                bm->totloop--;
                                                BLI_mempool_free(bm->lpool, loops[i]);
                                        }
-                                       BLI_array_fixedstack_free(loops);
                                }
 
                                /* Validate radial cycle of oe */
index caf9f3c70d52d80259fae65e1f5761ba63b51017..df58b90bc03aa8f0dc53836f55b22d67bffa1395 100644 (file)
@@ -172,11 +172,9 @@ void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source)
        BMLoop *l_iter;
        BMLoop *l_first;
 
-       void **blocks = NULL;
-       float (*cos)[3] = NULL, *w = NULL;
-       BLI_array_fixedstack_declare(cos,     BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
-       BLI_array_fixedstack_declare(w,       BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
-       BLI_array_fixedstack_declare(blocks,  BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
+       void **blocks   = BLI_array_alloca(blocks, source->len);
+       float (*cos)[3] = BLI_array_alloca(cos,    source->len);
+       float *w        = BLI_array_alloca(w,      source->len);
        int i;
        
        BM_elem_attrs_copy(bm, bm, source, target);
@@ -196,10 +194,6 @@ void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source)
                CustomData_bmesh_interp(&bm->ldata, blocks, w, NULL, source->len, l_iter->head.data);
                i++;
        } while ((l_iter = l_iter->next) != l_first);
-
-       BLI_array_fixedstack_free(cos);
-       BLI_array_fixedstack_free(w);
-       BLI_array_fixedstack_free(blocks);
 }
 
 /**
@@ -609,14 +603,12 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
 {
        BMLoop *l_iter;
        BMLoop *l_first;
-       void **blocks = NULL;
-       void **vblocks = NULL;
-       float (*cos)[3] = NULL, co[3], *w = NULL;
+       void **vblocks  = BLI_array_alloca(vblocks, do_vertex ? source->len : 0);
+       void **blocks   = BLI_array_alloca(blocks,  source->len);
+       float (*cos)[3] = BLI_array_alloca(cos,     source->len);
+       float *w        = BLI_array_alloca(w,       source->len);
+       float co[3];
        float cent[3] = {0.0f, 0.0f, 0.0f};
-       BLI_array_fixedstack_declare(cos,      BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
-       BLI_array_fixedstack_declare(w,        BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
-       BLI_array_fixedstack_declare(blocks,   BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
-       BLI_array_fixedstack_declare(vblocks,  BM_DEFAULT_NGON_STACK_SIZE, do_vertex ? source->len : 0, __func__);
        int i, ax, ay;
 
        BM_elem_attrs_copy(bm, bm, source, target->f);
@@ -667,13 +659,8 @@ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source,
        CustomData_bmesh_interp(&bm->ldata, blocks, w, NULL, source->len, target->head.data);
        if (do_vertex) {
                CustomData_bmesh_interp(&bm->vdata, vblocks, w, NULL, source->len, target->v->head.data);
-               BLI_array_fixedstack_free(vblocks);
        }
 
-       BLI_array_fixedstack_free(cos);
-       BLI_array_fixedstack_free(w);
-       BLI_array_fixedstack_free(blocks);
-
        if (do_multires) {
                if (CustomData_has_layer(&bm->ldata, CD_MDISPS)) {
                        bm_loop_interp_mdisps(bm, target, source);
@@ -686,12 +673,10 @@ void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source)
 {
        BMLoop *l_iter;
        BMLoop *l_first;
-       void **blocks = NULL;
-       float (*cos)[3] = NULL, *w = NULL;
+       void **blocks   = BLI_array_alloca(blocks, source->len);
+       float (*cos)[3] = BLI_array_alloca(cos,    source->len);
+       float *w        = BLI_array_alloca(w,      source->len);
        float cent[3] = {0.0f, 0.0f, 0.0f};
-       BLI_array_fixedstack_declare(cos,      BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
-       BLI_array_fixedstack_declare(w,        BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
-       BLI_array_fixedstack_declare(blocks,   BM_DEFAULT_NGON_STACK_SIZE, source->len, __func__);
        int i;
 
        i = 0;
@@ -718,10 +703,6 @@ void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source)
        /* interpolate */
        interp_weights_poly_v3(w, cos, source->len, v->co);
        CustomData_bmesh_interp(&bm->vdata, blocks, w, NULL, source->len, v->head.data);
-
-       BLI_array_fixedstack_free(cos);
-       BLI_array_fixedstack_free(w);
-       BLI_array_fixedstack_free(blocks);
 }
 
 static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
index 3018db1af169747287247732088fdf1544bfd9a2..953e7f4d20ca13381d27fa6a30bba4f65abe21c8 100644 (file)
@@ -157,13 +157,11 @@ float BM_face_calc_area(BMFace *f)
 {
        BMLoop *l;
        BMIter iter;
-       float (*verts)[3];
+       float (*verts)[3] = BLI_array_alloca(verts, f->len);
        float normal[3];
        float area;
        int i;
 
-       BLI_array_fixedstack_declare(verts, BM_DEFAULT_NGON_STACK_SIZE, f->len, __func__);
-
        BM_ITER_ELEM_INDEX (l, &iter, f, BM_LOOPS_OF_FACE, i) {
                copy_v3_v3(verts[i], l->v->co);
        }
@@ -179,8 +177,6 @@ float BM_face_calc_area(BMFace *f)
                area = area_poly_v3(f->len, verts, normal);
        }
 
-       BLI_array_fixedstack_free(verts);
-
        return area;
 }
 
@@ -855,8 +851,8 @@ void BM_face_triangulate(BMesh *bm, BMFace *f, float (*projectverts)[3], const s
        BMLoop *newl;
        BMLoop *l_iter;
        BMLoop *l_first;
-       float *abscoss = NULL;
-       BLI_array_fixedstack_declare(abscoss, 16, f->len, "BM_face_triangulate: temp absolute cosines of face corners");
+       /* BM_face_triangulate: temp absolute cosines of face corners */
+       float *abscoss = BLI_array_alloca(abscoss, f->len);
 
        /* copy vertex coordinates to vertspace area */
        i = 0;
@@ -940,11 +936,10 @@ void BM_face_triangulate(BMesh *bm, BMFace *f, float (*projectverts)[3], const s
        }
 #endif
 
-       BLI_array_fixedstack_free(abscoss);
-
        /* NULL-terminate */
-       if (newfaces)
+       if (newfaces) {
                newfaces[nf_i] = NULL;
+       }
 }
 
 /**
@@ -961,13 +956,10 @@ void BM_face_legal_splits(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] = {-FLT_MAX, -FLT_MAX, 0.0f};
-       float (*projverts)[3];
-       float (*edgeverts)[3];
+       float (*projverts)[3] = BLI_array_alloca(projverts, f->len);
+       float (*edgeverts)[3] = BLI_array_alloca(edgeverts, len * 2);
        float fac1 = 1.0000001f, fac2 = 0.9f; //9999f; //0.999f;
        int i, j, a = 0, clen;
-
-       BLI_array_fixedstack_declare(projverts, BM_DEFAULT_NGON_STACK_SIZE, f->len,      "projvertsb");
-       BLI_array_fixedstack_declare(edgeverts, BM_DEFAULT_NGON_STACK_SIZE * 2, len * 2, "edgevertsb");
        
        i = 0;
        l = BM_iter_new(&iter, bm, BM_LOOPS_OF_FACE, f);
@@ -1085,7 +1077,4 @@ void BM_face_legal_splits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len)
                        }
                }
        }
-
-       BLI_array_fixedstack_free(projverts);
-       BLI_array_fixedstack_free(edgeverts);
 }
index 195c60c5a9cac109bd1d362805246db33d07f969..633c715f257a058382d577f48d1889fcc8833f9c 100644 (file)
@@ -1415,8 +1415,7 @@ int BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len)
 /* same as 'BM_face_exists_multi' but built vert array from edges */
 int BM_face_exists_multi_edge(BMEdge **earr, int len)
 {
-       BMVert **varr;
-       BLI_array_fixedstack_declare(varr, BM_DEFAULT_NGON_STACK_SIZE, len, __func__);
+       BMVert **varr = BLI_array_alloca(varr, len);
 
        int ok;
        int i, i_next;
@@ -1432,14 +1431,11 @@ int BM_face_exists_multi_edge(BMEdge **earr, int len)
 
        if (ok == FALSE) {
                BMESH_ASSERT(0);
-               BLI_array_fixedstack_free(varr);
                return FALSE;
        }
 
        ok = BM_face_exists_multi(varr, earr, len);
 
-       BLI_array_fixedstack_free(varr);
-
        return ok;
 }
 
index 065a1b57737cd2c3fc8aa9036e13f1ea46fa1cba..bf3bafc57fb7672657cc6324c6389a6aed5799dd 100644 (file)
@@ -600,39 +600,31 @@ static void solidify_add_thickness(BMesh *bm, const float dist)
        float *vert_accum = vert_angles + bm->totvert;
        int i, index;
 
-       /* array for passing verts to angle_poly_v3 */
-       float **verts = NULL;
-       BLI_array_staticdeclare(verts, BM_DEFAULT_NGON_STACK_SIZE);
-       /* array for receiving angles from angle_poly_v3 */
-       float *face_angles = NULL;
-       BLI_array_staticdeclare(face_angles, BM_DEFAULT_NGON_STACK_SIZE);
-
        BM_mesh_elem_index_ensure(bm, BM_VERT);
 
        BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
-               if (!BMO_elem_flag_test(bm, f, FACE_MARK)) {
-                       continue;
-               }
+               if (BMO_elem_flag_test(bm, f, FACE_MARK)) {
 
-               BLI_array_grow_items(verts, f->len);
-               BM_ITER_ELEM_INDEX (l, &loopIter, f, BM_LOOPS_OF_FACE, i) {
-                       verts[i] = l->v->co;
-               }
+                       /* array for passing verts to angle_poly_v3 */
+                       float  *face_angles = BLI_array_alloca(face_angles, f->len);
+                       /* array for receiving angles from angle_poly_v3 */
+                       float **verts = BLI_array_alloca(verts, f->len);
 
-               BLI_array_grow_items(face_angles, f->len);
-               angle_poly_v3(face_angles, (const float **)verts, f->len);
+                       BM_ITER_ELEM_INDEX (l, &loopIter, f, BM_LOOPS_OF_FACE, i) {
+                               verts[i] = l->v->co;
+                       }
 
-               i = 0;
-               BM_ITER_ELEM (l, &loopIter, f, BM_LOOPS_OF_FACE) {
-                       v = l->v;
-                       index = BM_elem_index_get(v);
-                       vert_accum[index] += face_angles[i];
-                       vert_angles[index] += shell_angle_to_dist(angle_normalized_v3v3(v->no, f->no)) * face_angles[i];
-                       i++;
-               }
+                       angle_poly_v3(face_angles, (const float **)verts, f->len);
 
-               BLI_array_empty(verts);
-               BLI_array_empty(face_angles);
+                       i = 0;
+                       BM_ITER_ELEM (l, &loopIter, f, BM_LOOPS_OF_FACE) {
+                               v = l->v;
+                               index = BM_elem_index_get(v);
+                               vert_accum[index] += face_angles[i];
+                               vert_angles[index] += shell_angle_to_dist(angle_normalized_v3v3(v->no, f->no)) * face_angles[i];
+                               i++;
+                       }
+               }
        }
 
        BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
@@ -643,9 +635,6 @@ static void solidify_add_thickness(BMesh *bm, const float dist)
        }
 
        MEM_freeN(vert_angles);
-
-       BLI_array_free(verts);
-       BLI_array_free(face_angles);
 }
 
 void bmo_solidify_face_region_exec(BMesh *bm, BMOperator *op)
index 9125800d3e838e12c947d9893c101d7967e9c4eb..fe9b0f218126f2815efd94c1aecea7501334e801 100644 (file)
@@ -263,14 +263,12 @@ static BMFace *bev_create_ngon(BMesh *bm, BMVert **vert_arr, const int totv, BMF
        }
        else {
                int i;
-               BMEdge **ee = NULL;
-               BLI_array_fixedstack_declare(ee, BM_DEFAULT_NGON_STACK_SIZE, totv, __func__);
+               BMEdge **ee = BLI_array_alloca(ee, totv);
 
                for (i = 0; i < totv; i++) {
                        ee[i] = BM_edge_create(bm, vert_arr[i], vert_arr[(i + 1) % totv], NULL, BM_CREATE_NO_DOUBLE);
                }
                f = BM_face_create_ngon(bm, vert_arr[0], vert_arr[1], ee, totv, 0);
-               BLI_array_fixedstack_free(ee);
        }
        if (facerep && f) {
                int has_mdisps = CustomData_has_layer(&bm->ldata, CD_MDISPS);
index f18168a25bf6d8a83ba7da1d25293517db3f41bd..b7b71be0df983ab82c8dcad0c386b6ddb4bf2023 100644 (file)
@@ -2591,10 +2591,8 @@ static void knife_make_chain_cut(KnifeTool_OpData *kcd, BMFace *f, ListBase *cha
        BMLoop *lnew, *l_iter;
        int i;
        int nco = BLI_countlist(chain) - 1;
-       float (*cos)[3] = NULL;
-       KnifeVert **kverts;
-       BLI_array_fixedstack_declare(cos, BM_DEFAULT_NGON_STACK_SIZE, nco, __func__);
-       BLI_array_fixedstack_declare(kverts, BM_DEFAULT_NGON_STACK_SIZE, nco, __func__);
+       float (*cos)[3] = BLI_array_alloca(cos, nco);
+       KnifeVert **kverts = BLI_array_alloca(kverts, nco);
 
        kfe = ((Ref *)chain->first)->ref;
        v1 = kfe->v1->v ? kfe->v1->v : kfe->v2->v;
@@ -2643,9 +2641,6 @@ static void knife_make_chain_cut(KnifeTool_OpData *kcd, BMFace *f, ListBase *cha
                        BM_edge_select_set(bm, lnew->e, TRUE);
                }
        }
-
-       BLI_array_fixedstack_free(cos);
-       BLI_array_fixedstack_free(kverts);
 }
 
 static void knife_make_face_cuts(KnifeTool_OpData *kcd, BMFace *f, ListBase *kfedges)
index 6e6de03a83465ec6111cacc9771f076f4cf9493e..b50b8d466f18e2afa8df8a1de9eb8601a8df5e57 100644 (file)
@@ -1413,8 +1413,7 @@ static void uv_map_mirror(BMEditMesh *em, BMFace *efa, MTexPoly *UNUSED(tf))
        BMLoop *l;
        BMIter liter;
        MLoopUV *luv;
-       float **uvs = NULL;
-       BLI_array_fixedstack_declare(uvs, BM_DEFAULT_NGON_STACK_SIZE, efa->len, __func__);
+       float **uvs = BLI_array_alloca(uvs, efa->len);
        float dx;
        int i, mi;
 
@@ -1436,8 +1435,6 @@ static void uv_map_mirror(BMEditMesh *em, BMFace *efa, MTexPoly *UNUSED(tf))
                        if (dx > 0.5f) uvs[i][0] += 1.0f;
                }
        }
-
-       BLI_array_fixedstack_free(uvs);
 }
 
 static int sphere_project_exec(bContext *C, wmOperator *op)