Revision: 56024
          
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=56024
Author:   campbellbarton
Date:     2013-04-13 20:58:49 +0000 (Sat, 13 Apr 2013)
Log Message:
-----------
code cleanup: edit-derived-mesh, define 'BMesh *bm' as local variable, avoid 
'bmdm->em->bm' within functions.

Modified Paths:
--------------
    trunk/blender/source/blender/blenkernel/intern/editderivedmesh.c

Modified: trunk/blender/source/blender/blenkernel/intern/editderivedmesh.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/editderivedmesh.c    
2013-04-13 20:40:34 UTC (rev 56023)
+++ trunk/blender/source/blender/blenkernel/intern/editderivedmesh.c    
2013-04-13 20:58:49 UTC (rev 56024)
@@ -388,17 +388,18 @@
                                    void *userData)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
+       BMesh *bm = bmdm->em->bm;
        BMVert *eve;
        BMIter iter;
        int i;
 
        if (bmdm->vertexCos) {
-               BM_ITER_MESH_INDEX (eve, &iter, bmdm->em->bm, BM_VERTS_OF_MESH, 
i) {
+               BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
                        func(userData, i, bmdm->vertexCos[i], 
bmdm->vertexNos[i], NULL);
                }
        }
        else {
-               BM_ITER_MESH_INDEX (eve, &iter, bmdm->em->bm, BM_VERTS_OF_MESH, 
i) {
+               BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
                        func(userData, i, eve->co, eve->no, NULL);
                }
        }
@@ -408,22 +409,23 @@
                                    void *userData)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
+       BMesh *bm = bmdm->em->bm;
        BMEdge *eed;
        BMIter iter;
        int i;
 
        if (bmdm->vertexCos) {
 
-               BM_mesh_elem_index_ensure(bmdm->em->bm, BM_VERT);
+               BM_mesh_elem_index_ensure(bm, BM_VERT);
 
-               BM_ITER_MESH_INDEX (eed, &iter, bmdm->em->bm, BM_EDGES_OF_MESH, 
i) {
+               BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
                        func(userData, i,
                             bmdm->vertexCos[BM_elem_index_get(eed->v1)],
                             bmdm->vertexCos[BM_elem_index_get(eed->v2)]);
                }
        }
        else {
-               BM_ITER_MESH_INDEX (eed, &iter, bmdm->em->bm, BM_EDGES_OF_MESH, 
i) {
+               BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
                        func(userData, i, eed->v1->co, eed->v2->co);
                }
        }
@@ -434,16 +436,17 @@
                                  void *userData)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
+       BMesh *bm = bmdm->em->bm;
        BMEdge *eed;
        BMIter iter;
        int i;
 
        if (bmdm->vertexCos) {
 
-               BM_mesh_elem_index_ensure(bmdm->em->bm, BM_VERT);
+               BM_mesh_elem_index_ensure(bm, BM_VERT);
 
                glBegin(GL_LINES);
-               BM_ITER_MESH_INDEX (eed, &iter, bmdm->em->bm, BM_EDGES_OF_MESH, 
i) {
+               BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
                        if (!setDrawOptions || (setDrawOptions(userData, i) != 
DM_DRAW_OPTION_SKIP)) {
                                
glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v1)]);
                                
glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v2)]);
@@ -453,7 +456,7 @@
        }
        else {
                glBegin(GL_LINES);
-               BM_ITER_MESH_INDEX (eed, &iter, bmdm->em->bm, BM_EDGES_OF_MESH, 
i) {
+               BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
                        if (!setDrawOptions || (setDrawOptions(userData, i) != 
DM_DRAW_OPTION_SKIP)) {
                                glVertex3fv(eed->v1->co);
                                glVertex3fv(eed->v2->co);
@@ -475,16 +478,17 @@
                                        void *userData)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
+       BMesh *bm = bmdm->em->bm;
        BMEdge *eed;
        BMIter iter;
        int i;
 
        if (bmdm->vertexCos) {
 
-               BM_mesh_elem_index_ensure(bmdm->em->bm, BM_VERT);
+               BM_mesh_elem_index_ensure(bm, BM_VERT);
 
                glBegin(GL_LINES);
-               BM_ITER_MESH_INDEX (eed, &iter, bmdm->em->bm, BM_EDGES_OF_MESH, 
i) {
+               BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
                        if (!setDrawOptions || (setDrawOptions(userData, i) != 
DM_DRAW_OPTION_SKIP)) {
                                setDrawInterpOptions(userData, i, 0.0);
                                
glVertex3fv(bmdm->vertexCos[BM_elem_index_get(eed->v1)]);
@@ -496,7 +500,7 @@
        }
        else {
                glBegin(GL_LINES);
-               BM_ITER_MESH_INDEX (eed, &iter, bmdm->em->bm, BM_EDGES_OF_MESH, 
i) {
+               BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) {
                        if (!setDrawOptions || (setDrawOptions(userData, i) != 
DM_DRAW_OPTION_SKIP)) {
                                setDrawInterpOptions(userData, i, 0.0);
                                glVertex3fv(eed->v1->co);
@@ -511,12 +515,12 @@
 static void emDM_drawUVEdges(DerivedMesh *dm)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
-       BMEditMesh *em = bmdm->em;
+       BMesh *bm = bmdm->em->bm;
        BMFace *efa;
        BMIter iter;
 
        glBegin(GL_LINES);
-       BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
+       BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
                BMIter liter;
                BMLoop *l;
                MLoopUV *lastluv = NULL, *firstluv = NULL;
@@ -525,7 +529,7 @@
                        continue;
 
                BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
-                       MLoopUV *luv = CustomData_bmesh_get(&em->bm->ldata, 
l->head.data, CD_MLOOPUV);
+                       MLoopUV *luv = CustomData_bmesh_get(&bm->ldata, 
l->head.data, CD_MLOOPUV);
 
                        if (luv) {
                                if (lastluv)
@@ -578,6 +582,7 @@
                                          void *userData)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
+       BMesh *bm = bmdm->em->bm;
        float (*polyNos)[3] = NULL;
        BMFace *efa;
        BMIter iter;
@@ -586,13 +591,13 @@
 
        /* ensure for face center calculation */
        if (bmdm->vertexCos) {
-               BM_mesh_elem_index_ensure(bmdm->em->bm, BM_VERT);
+               BM_mesh_elem_index_ensure(bm, BM_VERT);
                polyNos = bmdm->polyNos;
 
                BLI_assert(polyNos != NULL);
        }
 
-       BM_ITER_MESH_INDEX (efa, &iter, bmdm->em->bm, BM_FACES_OF_MESH, i) {
+       BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) {
                emDM__calcFaceCent(efa, cent, bmdm->vertexCos);
                func(userData, i, cent, polyNos ? polyNos[i] : efa->no);
        }
@@ -644,7 +649,7 @@
                float (*polyNos)[3]   = bmdm->polyNos;
                // int *triPolyMap = bmdm->triPolyMap;
 
-               BM_mesh_elem_index_ensure(bmdm->em->bm, BM_VERT | BM_FACE);
+               BM_mesh_elem_index_ensure(bm, BM_VERT | BM_FACE);
 
                for (i = 0; i < tottri; i++) {
                        BMLoop **ltri = looptris[i];
@@ -729,7 +734,7 @@
                }
        }
        else {
-               BM_mesh_elem_index_ensure(bmdm->em->bm, BM_FACE);
+               BM_mesh_elem_index_ensure(bm, BM_FACE);
 
                for (i = 0; i < tottri; i++) {
                        BMLoop **ltri = looptris[i];
@@ -1302,28 +1307,29 @@
        }
 }
 
-static void emDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
+static void emDM_getMinMax(DerivedMesh *dm, float r_min[3], float r_max[3])
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
+       BMesh *bm = bmdm->em->bm;
        BMVert *eve;
        BMIter iter;
        int i;
 
-       if (bmdm->em->bm->totvert) {
+       if (bm->totvert) {
                if (bmdm->vertexCos) {
-                       BM_ITER_MESH_INDEX (eve, &iter, bmdm->em->bm, 
BM_VERTS_OF_MESH, i) {
-                               minmax_v3v3_v3(min_r, max_r, 
bmdm->vertexCos[i]);
+                       BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, 
i) {
+                               minmax_v3v3_v3(r_min, r_max, 
bmdm->vertexCos[i]);
                        }
                }
                else {
-                       BM_ITER_MESH (eve, &iter, bmdm->em->bm, 
BM_VERTS_OF_MESH) {
-                               minmax_v3v3_v3(min_r, max_r, eve->co);
+                       BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
+                               minmax_v3v3_v3(r_min, r_max, eve->co);
                        }
                }
        }
        else {
-               zero_v3(min_r);
-               zero_v3(max_r);
+               zero_v3(r_min);
+               zero_v3(r_max);
        }
 }
 static int emDM_getNumVerts(DerivedMesh *dm)
@@ -1361,70 +1367,71 @@
        return bmdm->em->bm->totface;
 }
 
-static int bmvert_to_mvert(BMesh *bm, BMVert *ev, MVert *vert_r)
+static int bmvert_to_mvert(BMesh *bm, BMVert *ev, MVert *r_vert)
 {
        float *f;
 
-       copy_v3_v3(vert_r->co, ev->co);
+       copy_v3_v3(r_vert->co, ev->co);
 
-       normal_float_to_short_v3(vert_r->no, ev->no);
+       normal_float_to_short_v3(r_vert->no, ev->no);
 
-       vert_r->flag = BM_vert_flag_to_mflag(ev);
+       r_vert->flag = BM_vert_flag_to_mflag(ev);
 
        if ((f = CustomData_bmesh_get(&bm->vdata, ev->head.data, CD_BWEIGHT))) {
-               vert_r->bweight = (unsigned char)((*f) * 255.0f);
+               r_vert->bweight = (unsigned char)((*f) * 255.0f);
        }
 
        return 1;
 }
 
-static void emDM_getVert(DerivedMesh *dm, int index, MVert *vert_r)
+static void emDM_getVert(DerivedMesh *dm, int index, MVert *r_vert)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
+       BMesh *bm = bmdm->em->bm;
        BMVert *ev;
 
-       if (UNLIKELY(index < 0 || index >= bmdm->em->bm->totvert)) {
+       if (UNLIKELY(index < 0 || index >= bm->totvert)) {
                BLI_assert(!"error in emDM_getVert");
                return;
        }
 
        ev = bmdm->em->vert_index[index];  /* should be EDBM_vert_at_index() */
-       // ev = BM_vert_at_index(bmdm->em->bm, index); /* warning, does list 
loop, _not_ ideal */
+       // ev = BM_vert_at_index(bm, index); /* warning, does list loop, _not_ 
ideal */
 
-       bmvert_to_mvert(bmdm->em->bm, ev, vert_r);
+       bmvert_to_mvert(bm, ev, r_vert);
        if (bmdm->vertexCos)
-               copy_v3_v3(vert_r->co, bmdm->vertexCos[index]);
+               copy_v3_v3(r_vert->co, bmdm->vertexCos[index]);
 }
 
-static void emDM_getEdge(DerivedMesh *dm, int index, MEdge *edge_r)
+static void emDM_getEdge(DerivedMesh *dm, int index, MEdge *r_edge)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
        BMesh *bm = bmdm->em->bm;
        BMEdge *e;
        float *f;
 
-       if (UNLIKELY(index < 0 || index >= bmdm->em->bm->totedge)) {
+       if (UNLIKELY(index < 0 || index >= bm->totedge)) {
                BLI_assert(!"error in emDM_getEdge");
                return;
        }
 
        e = bmdm->em->edge_index[index];  /* should be EDBM_edge_at_index() */
-       // e = BM_edge_at_index(bmdm->em->bm, index); /* warning, does list 
loop, _not_ ideal */
+       // e = BM_edge_at_index(bm, index); /* warning, does list loop, _not_ 
ideal */
 
-       edge_r->flag = BM_edge_flag_to_mflag(e);
+       r_edge->flag = BM_edge_flag_to_mflag(e);
 
-       edge_r->v1 = BM_elem_index_get(e->v1);
-       edge_r->v2 = BM_elem_index_get(e->v2);
+       r_edge->v1 = BM_elem_index_get(e->v1);
+       r_edge->v2 = BM_elem_index_get(e->v2);
 
        if ((f = CustomData_bmesh_get(&bm->edata, e->head.data, CD_BWEIGHT))) {
-               edge_r->bweight = (unsigned char)((*f) * 255.0f);
+               r_edge->bweight = (unsigned char)((*f) * 255.0f);
        }
        if ((f = CustomData_bmesh_get(&bm->edata, e->head.data, CD_CREASE))) {
-               edge_r->crease = (unsigned char)((*f) * 255.0f);
+               r_edge->crease = (unsigned char)((*f) * 255.0f);
        }
 }
 
-static void emDM_getTessFace(DerivedMesh *dm, int index, MFace *face_r)
+static void emDM_getTessFace(DerivedMesh *dm, int index, MFace *r_face)
 {
        EditDerivedBMesh *bmdm = (EditDerivedBMesh *)dm;
        BMFace *ef;
@@ -1439,18 +1446,18 @@
 
        ef = ltri[0]->f;
 
-       face_r->mat_nr = (unsigned char) ef->mat_nr;
-       face_r->flag = BM_face_flag_to_mflag(ef);
+       r_face->mat_nr = (unsigned char) ef->mat_nr;
+       r_face->flag = BM_face_flag_to_mflag(ef);
 
-       face_r->v1 = BM_elem_index_get(ltri[0]->v);
-       face_r->v2 = BM_elem_index_get(ltri[1]->v);
-       face_r->v3 = BM_elem_index_get(ltri[2]->v);
-       face_r->v4 = 0;
+       r_face->v1 = BM_elem_index_get(ltri[0]->v);
+       r_face->v2 = BM_elem_index_get(ltri[1]->v);
+       r_face->v3 = BM_elem_index_get(ltri[2]->v);
+       r_face->v4 = 0;
 
-       test_index_face(face_r, NULL, 0, 3);
+       test_index_face(r_face, NULL, 0, 3);
 }
 
-static void emDM_copyVertArray(DerivedMesh *dm, MVert *vert_r)
+static void emDM_copyVertArray(DerivedMesh *dm, MVert *r_vert)
 {

@@ Diff output truncated at 10240 characters. @@
_______________________________________________
Bf-blender-cvs mailing list
[email protected]
http://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to